]>
Commit | Line | Data |
---|---|---|
8e3b890d SÖ |
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":119,"vm":444}],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":50,"inherits":119}],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":360}],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":119}],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":119}],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":50,"inherits":119}],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":50,"inherits":119}],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":119}],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":398}],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":49,"cipher-base":51,"inherits":119,"safe-buffer":398}],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":51,"evp_bytestokey":103,"inherits":119,"safe-buffer":398}],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":51,"evp_bytestokey":103,"inherits":119,"safe-buffer":398}],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":398}],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":49}],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":49,"safe-buffer":398}],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":398}],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":398}],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":49,"safe-buffer":398}],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":50,"buffer-xor":49}],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":51,"inherits":119,"safe-buffer":398}],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":103}],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":51,"des.js":74,"inherits":119,"safe-buffer":398}],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":50,"randombytes":381}],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":50,"create-hash":68,"inherits":119,"stream":437}],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":50,"create-hmac":70,"elliptic":86,"parse-asn1":366}],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":50,"elliptic":86,"parse-asn1":366}],48:[function(require,module,exports){ | |
10267 | arguments[4][20][0].apply(exports,arguments) | |
10268 | },{"dup":20}],49:[function(require,module,exports){ | |
10269 | (function (Buffer){ | |
10270 | module.exports = function xor (a, b) { | |
10271 | var length = Math.min(a.length, b.length) | |
10272 | var buffer = new Buffer(length) | |
10273 | ||
10274 | for (var i = 0; i < length; ++i) { | |
10275 | buffer[i] = a[i] ^ b[i] | |
10276 | } | |
10277 | ||
10278 | return buffer | |
10279 | } | |
10280 | ||
10281 | }).call(this,require("buffer").Buffer) | |
10282 | },{"buffer":50}],50:[function(require,module,exports){ | |
10283 | /*! | |
10284 | * The buffer module from node.js, for the browser. | |
10285 | * | |
10286 | * @author Feross Aboukhadijeh <https://feross.org> | |
10287 | * @license MIT | |
10288 | */ | |
10289 | /* eslint-disable no-proto */ | |
10290 | ||
10291 | 'use strict' | |
10292 | ||
10293 | var base64 = require('base64-js') | |
10294 | var ieee754 = require('ieee754') | |
10295 | ||
10296 | exports.Buffer = Buffer | |
10297 | exports.SlowBuffer = SlowBuffer | |
10298 | exports.INSPECT_MAX_BYTES = 50 | |
10299 | ||
10300 | var K_MAX_LENGTH = 0x7fffffff | |
10301 | exports.kMaxLength = K_MAX_LENGTH | |
10302 | ||
10303 | /** | |
10304 | * If `Buffer.TYPED_ARRAY_SUPPORT`: | |
10305 | * === true Use Uint8Array implementation (fastest) | |
10306 | * === false Print warning and recommend using `buffer` v4.x which has an Object | |
10307 | * implementation (most compatible, even IE6) | |
10308 | * | |
10309 | * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, | |
10310 | * Opera 11.6+, iOS 4.2+. | |
10311 | * | |
10312 | * We report that the browser does not support typed arrays if the are not subclassable | |
10313 | * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` | |
10314 | * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support | |
10315 | * for __proto__ and has a buggy typed array implementation. | |
10316 | */ | |
10317 | Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() | |
10318 | ||
10319 | if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && | |
10320 | typeof console.error === 'function') { | |
10321 | console.error( | |
10322 | 'This browser lacks typed array (Uint8Array) support which is required by ' + | |
10323 | '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' | |
10324 | ) | |
10325 | } | |
10326 | ||
10327 | function typedArraySupport () { | |
10328 | // Can typed array instances can be augmented? | |
10329 | try { | |
10330 | var arr = new Uint8Array(1) | |
10331 | arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } } | |
10332 | return arr.foo() === 42 | |
10333 | } catch (e) { | |
10334 | return false | |
10335 | } | |
10336 | } | |
10337 | ||
10338 | Object.defineProperty(Buffer.prototype, 'parent', { | |
10339 | enumerable: true, | |
10340 | get: function () { | |
10341 | if (!Buffer.isBuffer(this)) return undefined | |
10342 | return this.buffer | |
10343 | } | |
10344 | }) | |
10345 | ||
10346 | Object.defineProperty(Buffer.prototype, 'offset', { | |
10347 | enumerable: true, | |
10348 | get: function () { | |
10349 | if (!Buffer.isBuffer(this)) return undefined | |
10350 | return this.byteOffset | |
10351 | } | |
10352 | }) | |
10353 | ||
10354 | function createBuffer (length) { | |
10355 | if (length > K_MAX_LENGTH) { | |
10356 | throw new RangeError('The value "' + length + '" is invalid for option "size"') | |
10357 | } | |
10358 | // Return an augmented `Uint8Array` instance | |
10359 | var buf = new Uint8Array(length) | |
10360 | buf.__proto__ = Buffer.prototype | |
10361 | return buf | |
10362 | } | |
10363 | ||
10364 | /** | |
10365 | * The Buffer constructor returns instances of `Uint8Array` that have their | |
10366 | * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of | |
10367 | * `Uint8Array`, so the returned instances will have all the node `Buffer` methods | |
10368 | * and the `Uint8Array` methods. Square bracket notation works as expected -- it | |
10369 | * returns a single octet. | |
10370 | * | |
10371 | * The `Uint8Array` prototype remains unmodified. | |
10372 | */ | |
10373 | ||
10374 | function Buffer (arg, encodingOrOffset, length) { | |
10375 | // Common case. | |
10376 | if (typeof arg === 'number') { | |
10377 | if (typeof encodingOrOffset === 'string') { | |
10378 | throw new TypeError( | |
10379 | 'The "string" argument must be of type string. Received type number' | |
10380 | ) | |
10381 | } | |
10382 | return allocUnsafe(arg) | |
10383 | } | |
10384 | return from(arg, encodingOrOffset, length) | |
10385 | } | |
10386 | ||
10387 | // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 | |
10388 | if (typeof Symbol !== 'undefined' && Symbol.species != null && | |
10389 | Buffer[Symbol.species] === Buffer) { | |
10390 | Object.defineProperty(Buffer, Symbol.species, { | |
10391 | value: null, | |
10392 | configurable: true, | |
10393 | enumerable: false, | |
10394 | writable: false | |
10395 | }) | |
10396 | } | |
10397 | ||
10398 | Buffer.poolSize = 8192 // not used by this implementation | |
10399 | ||
10400 | function from (value, encodingOrOffset, length) { | |
10401 | if (typeof value === 'string') { | |
10402 | return fromString(value, encodingOrOffset) | |
10403 | } | |
10404 | ||
10405 | if (ArrayBuffer.isView(value)) { | |
10406 | return fromArrayLike(value) | |
10407 | } | |
10408 | ||
10409 | if (value == null) { | |
10410 | throw TypeError( | |
10411 | 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + | |
10412 | 'or Array-like Object. Received type ' + (typeof value) | |
10413 | ) | |
10414 | } | |
10415 | ||
10416 | if (isInstance(value, ArrayBuffer) || | |
10417 | (value && isInstance(value.buffer, ArrayBuffer))) { | |
10418 | return fromArrayBuffer(value, encodingOrOffset, length) | |
10419 | } | |
10420 | ||
10421 | if (typeof value === 'number') { | |
10422 | throw new TypeError( | |
10423 | 'The "value" argument must not be of type number. Received type number' | |
10424 | ) | |
10425 | } | |
10426 | ||
10427 | var valueOf = value.valueOf && value.valueOf() | |
10428 | if (valueOf != null && valueOf !== value) { | |
10429 | return Buffer.from(valueOf, encodingOrOffset, length) | |
10430 | } | |
10431 | ||
10432 | var b = fromObject(value) | |
10433 | if (b) return b | |
10434 | ||
10435 | if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && | |
10436 | typeof value[Symbol.toPrimitive] === 'function') { | |
10437 | return Buffer.from( | |
10438 | value[Symbol.toPrimitive]('string'), encodingOrOffset, length | |
10439 | ) | |
10440 | } | |
10441 | ||
10442 | throw new TypeError( | |
10443 | 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + | |
10444 | 'or Array-like Object. Received type ' + (typeof value) | |
10445 | ) | |
10446 | } | |
10447 | ||
10448 | /** | |
10449 | * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError | |
10450 | * if value is a number. | |
10451 | * Buffer.from(str[, encoding]) | |
10452 | * Buffer.from(array) | |
10453 | * Buffer.from(buffer) | |
10454 | * Buffer.from(arrayBuffer[, byteOffset[, length]]) | |
10455 | **/ | |
10456 | Buffer.from = function (value, encodingOrOffset, length) { | |
10457 | return from(value, encodingOrOffset, length) | |
10458 | } | |
10459 | ||
10460 | // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: | |
10461 | // https://github.com/feross/buffer/pull/148 | |
10462 | Buffer.prototype.__proto__ = Uint8Array.prototype | |
10463 | Buffer.__proto__ = Uint8Array | |
10464 | ||
10465 | function assertSize (size) { | |
10466 | if (typeof size !== 'number') { | |
10467 | throw new TypeError('"size" argument must be of type number') | |
10468 | } else if (size < 0) { | |
10469 | throw new RangeError('The value "' + size + '" is invalid for option "size"') | |
10470 | } | |
10471 | } | |
10472 | ||
10473 | function alloc (size, fill, encoding) { | |
10474 | assertSize(size) | |
10475 | if (size <= 0) { | |
10476 | return createBuffer(size) | |
10477 | } | |
10478 | if (fill !== undefined) { | |
10479 | // Only pay attention to encoding if it's a string. This | |
10480 | // prevents accidentally sending in a number that would | |
10481 | // be interpretted as a start offset. | |
10482 | return typeof encoding === 'string' | |
10483 | ? createBuffer(size).fill(fill, encoding) | |
10484 | : createBuffer(size).fill(fill) | |
10485 | } | |
10486 | return createBuffer(size) | |
10487 | } | |
10488 | ||
10489 | /** | |
10490 | * Creates a new filled Buffer instance. | |
10491 | * alloc(size[, fill[, encoding]]) | |
10492 | **/ | |
10493 | Buffer.alloc = function (size, fill, encoding) { | |
10494 | return alloc(size, fill, encoding) | |
10495 | } | |
10496 | ||
10497 | function allocUnsafe (size) { | |
10498 | assertSize(size) | |
10499 | return createBuffer(size < 0 ? 0 : checked(size) | 0) | |
10500 | } | |
10501 | ||
10502 | /** | |
10503 | * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. | |
10504 | * */ | |
10505 | Buffer.allocUnsafe = function (size) { | |
10506 | return allocUnsafe(size) | |
10507 | } | |
10508 | /** | |
10509 | * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. | |
10510 | */ | |
10511 | Buffer.allocUnsafeSlow = function (size) { | |
10512 | return allocUnsafe(size) | |
10513 | } | |
10514 | ||
10515 | function fromString (string, encoding) { | |
10516 | if (typeof encoding !== 'string' || encoding === '') { | |
10517 | encoding = 'utf8' | |
10518 | } | |
10519 | ||
10520 | if (!Buffer.isEncoding(encoding)) { | |
10521 | throw new TypeError('Unknown encoding: ' + encoding) | |
10522 | } | |
10523 | ||
10524 | var length = byteLength(string, encoding) | 0 | |
10525 | var buf = createBuffer(length) | |
10526 | ||
10527 | var actual = buf.write(string, encoding) | |
10528 | ||
10529 | if (actual !== length) { | |
10530 | // Writing a hex string, for example, that contains invalid characters will | |
10531 | // cause everything after the first invalid character to be ignored. (e.g. | |
10532 | // 'abxxcd' will be treated as 'ab') | |
10533 | buf = buf.slice(0, actual) | |
10534 | } | |
10535 | ||
10536 | return buf | |
10537 | } | |
10538 | ||
10539 | function fromArrayLike (array) { | |
10540 | var length = array.length < 0 ? 0 : checked(array.length) | 0 | |
10541 | var buf = createBuffer(length) | |
10542 | for (var i = 0; i < length; i += 1) { | |
10543 | buf[i] = array[i] & 255 | |
10544 | } | |
10545 | return buf | |
10546 | } | |
10547 | ||
10548 | function fromArrayBuffer (array, byteOffset, length) { | |
10549 | if (byteOffset < 0 || array.byteLength < byteOffset) { | |
10550 | throw new RangeError('"offset" is outside of buffer bounds') | |
10551 | } | |
10552 | ||
10553 | if (array.byteLength < byteOffset + (length || 0)) { | |
10554 | throw new RangeError('"length" is outside of buffer bounds') | |
10555 | } | |
10556 | ||
10557 | var buf | |
10558 | if (byteOffset === undefined && length === undefined) { | |
10559 | buf = new Uint8Array(array) | |
10560 | } else if (length === undefined) { | |
10561 | buf = new Uint8Array(array, byteOffset) | |
10562 | } else { | |
10563 | buf = new Uint8Array(array, byteOffset, length) | |
10564 | } | |
10565 | ||
10566 | // Return an augmented `Uint8Array` instance | |
10567 | buf.__proto__ = Buffer.prototype | |
10568 | return buf | |
10569 | } | |
10570 | ||
10571 | function fromObject (obj) { | |
10572 | if (Buffer.isBuffer(obj)) { | |
10573 | var len = checked(obj.length) | 0 | |
10574 | var buf = createBuffer(len) | |
10575 | ||
10576 | if (buf.length === 0) { | |
10577 | return buf | |
10578 | } | |
10579 | ||
10580 | obj.copy(buf, 0, 0, len) | |
10581 | return buf | |
10582 | } | |
10583 | ||
10584 | if (obj.length !== undefined) { | |
10585 | if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { | |
10586 | return createBuffer(0) | |
10587 | } | |
10588 | return fromArrayLike(obj) | |
10589 | } | |
10590 | ||
10591 | if (obj.type === 'Buffer' && Array.isArray(obj.data)) { | |
10592 | return fromArrayLike(obj.data) | |
10593 | } | |
10594 | } | |
10595 | ||
10596 | function checked (length) { | |
10597 | // Note: cannot use `length < K_MAX_LENGTH` here because that fails when | |
10598 | // length is NaN (which is otherwise coerced to zero.) | |
10599 | if (length >= K_MAX_LENGTH) { | |
10600 | throw new RangeError('Attempt to allocate Buffer larger than maximum ' + | |
10601 | 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') | |
10602 | } | |
10603 | return length | 0 | |
10604 | } | |
10605 | ||
10606 | function SlowBuffer (length) { | |
10607 | if (+length != length) { // eslint-disable-line eqeqeq | |
10608 | length = 0 | |
10609 | } | |
10610 | return Buffer.alloc(+length) | |
10611 | } | |
10612 | ||
10613 | Buffer.isBuffer = function isBuffer (b) { | |
10614 | return b != null && b._isBuffer === true && | |
10615 | b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false | |
10616 | } | |
10617 | ||
10618 | Buffer.compare = function compare (a, b) { | |
10619 | if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) | |
10620 | if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) | |
10621 | if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { | |
10622 | throw new TypeError( | |
10623 | 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' | |
10624 | ) | |
10625 | } | |
10626 | ||
10627 | if (a === b) return 0 | |
10628 | ||
10629 | var x = a.length | |
10630 | var y = b.length | |
10631 | ||
10632 | for (var i = 0, len = Math.min(x, y); i < len; ++i) { | |
10633 | if (a[i] !== b[i]) { | |
10634 | x = a[i] | |
10635 | y = b[i] | |
10636 | break | |
10637 | } | |
10638 | } | |
10639 | ||
10640 | if (x < y) return -1 | |
10641 | if (y < x) return 1 | |
10642 | return 0 | |
10643 | } | |
10644 | ||
10645 | Buffer.isEncoding = function isEncoding (encoding) { | |
10646 | switch (String(encoding).toLowerCase()) { | |
10647 | case 'hex': | |
10648 | case 'utf8': | |
10649 | case 'utf-8': | |
10650 | case 'ascii': | |
10651 | case 'latin1': | |
10652 | case 'binary': | |
10653 | case 'base64': | |
10654 | case 'ucs2': | |
10655 | case 'ucs-2': | |
10656 | case 'utf16le': | |
10657 | case 'utf-16le': | |
10658 | return true | |
10659 | default: | |
10660 | return false | |
10661 | } | |
10662 | } | |
10663 | ||
10664 | Buffer.concat = function concat (list, length) { | |
10665 | if (!Array.isArray(list)) { | |
10666 | throw new TypeError('"list" argument must be an Array of Buffers') | |
10667 | } | |
10668 | ||
10669 | if (list.length === 0) { | |
10670 | return Buffer.alloc(0) | |
10671 | } | |
10672 | ||
10673 | var i | |
10674 | if (length === undefined) { | |
10675 | length = 0 | |
10676 | for (i = 0; i < list.length; ++i) { | |
10677 | length += list[i].length | |
10678 | } | |
10679 | } | |
10680 | ||
10681 | var buffer = Buffer.allocUnsafe(length) | |
10682 | var pos = 0 | |
10683 | for (i = 0; i < list.length; ++i) { | |
10684 | var buf = list[i] | |
10685 | if (isInstance(buf, Uint8Array)) { | |
10686 | buf = Buffer.from(buf) | |
10687 | } | |
10688 | if (!Buffer.isBuffer(buf)) { | |
10689 | throw new TypeError('"list" argument must be an Array of Buffers') | |
10690 | } | |
10691 | buf.copy(buffer, pos) | |
10692 | pos += buf.length | |
10693 | } | |
10694 | return buffer | |
10695 | } | |
10696 | ||
10697 | function byteLength (string, encoding) { | |
10698 | if (Buffer.isBuffer(string)) { | |
10699 | return string.length | |
10700 | } | |
10701 | if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { | |
10702 | return string.byteLength | |
10703 | } | |
10704 | if (typeof string !== 'string') { | |
10705 | throw new TypeError( | |
10706 | 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + | |
10707 | 'Received type ' + typeof string | |
10708 | ) | |
10709 | } | |
10710 | ||
10711 | var len = string.length | |
10712 | var mustMatch = (arguments.length > 2 && arguments[2] === true) | |
10713 | if (!mustMatch && len === 0) return 0 | |
10714 | ||
10715 | // Use a for loop to avoid recursion | |
10716 | var loweredCase = false | |
10717 | for (;;) { | |
10718 | switch (encoding) { | |
10719 | case 'ascii': | |
10720 | case 'latin1': | |
10721 | case 'binary': | |
10722 | return len | |
10723 | case 'utf8': | |
10724 | case 'utf-8': | |
10725 | return utf8ToBytes(string).length | |
10726 | case 'ucs2': | |
10727 | case 'ucs-2': | |
10728 | case 'utf16le': | |
10729 | case 'utf-16le': | |
10730 | return len * 2 | |
10731 | case 'hex': | |
10732 | return len >>> 1 | |
10733 | case 'base64': | |
10734 | return base64ToBytes(string).length | |
10735 | default: | |
10736 | if (loweredCase) { | |
10737 | return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 | |
10738 | } | |
10739 | encoding = ('' + encoding).toLowerCase() | |
10740 | loweredCase = true | |
10741 | } | |
10742 | } | |
10743 | } | |
10744 | Buffer.byteLength = byteLength | |
10745 | ||
10746 | function slowToString (encoding, start, end) { | |
10747 | var loweredCase = false | |
10748 | ||
10749 | // No need to verify that "this.length <= MAX_UINT32" since it's a read-only | |
10750 | // property of a typed array. | |
10751 | ||
10752 | // This behaves neither like String nor Uint8Array in that we set start/end | |
10753 | // to their upper/lower bounds if the value passed is out of range. | |
10754 | // undefined is handled specially as per ECMA-262 6th Edition, | |
10755 | // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. | |
10756 | if (start === undefined || start < 0) { | |
10757 | start = 0 | |
10758 | } | |
10759 | // Return early if start > this.length. Done here to prevent potential uint32 | |
10760 | // coercion fail below. | |
10761 | if (start > this.length) { | |
10762 | return '' | |
10763 | } | |
10764 | ||
10765 | if (end === undefined || end > this.length) { | |
10766 | end = this.length | |
10767 | } | |
10768 | ||
10769 | if (end <= 0) { | |
10770 | return '' | |
10771 | } | |
10772 | ||
10773 | // Force coersion to uint32. This will also coerce falsey/NaN values to 0. | |
10774 | end >>>= 0 | |
10775 | start >>>= 0 | |
10776 | ||
10777 | if (end <= start) { | |
10778 | return '' | |
10779 | } | |
10780 | ||
10781 | if (!encoding) encoding = 'utf8' | |
10782 | ||
10783 | while (true) { | |
10784 | switch (encoding) { | |
10785 | case 'hex': | |
10786 | return hexSlice(this, start, end) | |
10787 | ||
10788 | case 'utf8': | |
10789 | case 'utf-8': | |
10790 | return utf8Slice(this, start, end) | |
10791 | ||
10792 | case 'ascii': | |
10793 | return asciiSlice(this, start, end) | |
10794 | ||
10795 | case 'latin1': | |
10796 | case 'binary': | |
10797 | return latin1Slice(this, start, end) | |
10798 | ||
10799 | case 'base64': | |
10800 | return base64Slice(this, start, end) | |
10801 | ||
10802 | case 'ucs2': | |
10803 | case 'ucs-2': | |
10804 | case 'utf16le': | |
10805 | case 'utf-16le': | |
10806 | return utf16leSlice(this, start, end) | |
10807 | ||
10808 | default: | |
10809 | if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | |
10810 | encoding = (encoding + '').toLowerCase() | |
10811 | loweredCase = true | |
10812 | } | |
10813 | } | |
10814 | } | |
10815 | ||
10816 | // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) | |
10817 | // to detect a Buffer instance. It's not possible to use `instanceof Buffer` | |
10818 | // reliably in a browserify context because there could be multiple different | |
10819 | // copies of the 'buffer' package in use. This method works even for Buffer | |
10820 | // instances that were created from another copy of the `buffer` package. | |
10821 | // See: https://github.com/feross/buffer/issues/154 | |
10822 | Buffer.prototype._isBuffer = true | |
10823 | ||
10824 | function swap (b, n, m) { | |
10825 | var i = b[n] | |
10826 | b[n] = b[m] | |
10827 | b[m] = i | |
10828 | } | |
10829 | ||
10830 | Buffer.prototype.swap16 = function swap16 () { | |
10831 | var len = this.length | |
10832 | if (len % 2 !== 0) { | |
10833 | throw new RangeError('Buffer size must be a multiple of 16-bits') | |
10834 | } | |
10835 | for (var i = 0; i < len; i += 2) { | |
10836 | swap(this, i, i + 1) | |
10837 | } | |
10838 | return this | |
10839 | } | |
10840 | ||
10841 | Buffer.prototype.swap32 = function swap32 () { | |
10842 | var len = this.length | |
10843 | if (len % 4 !== 0) { | |
10844 | throw new RangeError('Buffer size must be a multiple of 32-bits') | |
10845 | } | |
10846 | for (var i = 0; i < len; i += 4) { | |
10847 | swap(this, i, i + 3) | |
10848 | swap(this, i + 1, i + 2) | |
10849 | } | |
10850 | return this | |
10851 | } | |
10852 | ||
10853 | Buffer.prototype.swap64 = function swap64 () { | |
10854 | var len = this.length | |
10855 | if (len % 8 !== 0) { | |
10856 | throw new RangeError('Buffer size must be a multiple of 64-bits') | |
10857 | } | |
10858 | for (var i = 0; i < len; i += 8) { | |
10859 | swap(this, i, i + 7) | |
10860 | swap(this, i + 1, i + 6) | |
10861 | swap(this, i + 2, i + 5) | |
10862 | swap(this, i + 3, i + 4) | |
10863 | } | |
10864 | return this | |
10865 | } | |
10866 | ||
10867 | Buffer.prototype.toString = function toString () { | |
10868 | var length = this.length | |
10869 | if (length === 0) return '' | |
10870 | if (arguments.length === 0) return utf8Slice(this, 0, length) | |
10871 | return slowToString.apply(this, arguments) | |
10872 | } | |
10873 | ||
10874 | Buffer.prototype.toLocaleString = Buffer.prototype.toString | |
10875 | ||
10876 | Buffer.prototype.equals = function equals (b) { | |
10877 | if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') | |
10878 | if (this === b) return true | |
10879 | return Buffer.compare(this, b) === 0 | |
10880 | } | |
10881 | ||
10882 | Buffer.prototype.inspect = function inspect () { | |
10883 | var str = '' | |
10884 | var max = exports.INSPECT_MAX_BYTES | |
10885 | str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() | |
10886 | if (this.length > max) str += ' ... ' | |
10887 | return '<Buffer ' + str + '>' | |
10888 | } | |
10889 | ||
10890 | Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { | |
10891 | if (isInstance(target, Uint8Array)) { | |
10892 | target = Buffer.from(target, target.offset, target.byteLength) | |
10893 | } | |
10894 | if (!Buffer.isBuffer(target)) { | |
10895 | throw new TypeError( | |
10896 | 'The "target" argument must be one of type Buffer or Uint8Array. ' + | |
10897 | 'Received type ' + (typeof target) | |
10898 | ) | |
10899 | } | |
10900 | ||
10901 | if (start === undefined) { | |
10902 | start = 0 | |
10903 | } | |
10904 | if (end === undefined) { | |
10905 | end = target ? target.length : 0 | |
10906 | } | |
10907 | if (thisStart === undefined) { | |
10908 | thisStart = 0 | |
10909 | } | |
10910 | if (thisEnd === undefined) { | |
10911 | thisEnd = this.length | |
10912 | } | |
10913 | ||
10914 | if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { | |
10915 | throw new RangeError('out of range index') | |
10916 | } | |
10917 | ||
10918 | if (thisStart >= thisEnd && start >= end) { | |
10919 | return 0 | |
10920 | } | |
10921 | if (thisStart >= thisEnd) { | |
10922 | return -1 | |
10923 | } | |
10924 | if (start >= end) { | |
10925 | return 1 | |
10926 | } | |
10927 | ||
10928 | start >>>= 0 | |
10929 | end >>>= 0 | |
10930 | thisStart >>>= 0 | |
10931 | thisEnd >>>= 0 | |
10932 | ||
10933 | if (this === target) return 0 | |
10934 | ||
10935 | var x = thisEnd - thisStart | |
10936 | var y = end - start | |
10937 | var len = Math.min(x, y) | |
10938 | ||
10939 | var thisCopy = this.slice(thisStart, thisEnd) | |
10940 | var targetCopy = target.slice(start, end) | |
10941 | ||
10942 | for (var i = 0; i < len; ++i) { | |
10943 | if (thisCopy[i] !== targetCopy[i]) { | |
10944 | x = thisCopy[i] | |
10945 | y = targetCopy[i] | |
10946 | break | |
10947 | } | |
10948 | } | |
10949 | ||
10950 | if (x < y) return -1 | |
10951 | if (y < x) return 1 | |
10952 | return 0 | |
10953 | } | |
10954 | ||
10955 | // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, | |
10956 | // OR the last index of `val` in `buffer` at offset <= `byteOffset`. | |
10957 | // | |
10958 | // Arguments: | |
10959 | // - buffer - a Buffer to search | |
10960 | // - val - a string, Buffer, or number | |
10961 | // - byteOffset - an index into `buffer`; will be clamped to an int32 | |
10962 | // - encoding - an optional encoding, relevant is val is a string | |
10963 | // - dir - true for indexOf, false for lastIndexOf | |
10964 | function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { | |
10965 | // Empty buffer means no match | |
10966 | if (buffer.length === 0) return -1 | |
10967 | ||
10968 | // Normalize byteOffset | |
10969 | if (typeof byteOffset === 'string') { | |
10970 | encoding = byteOffset | |
10971 | byteOffset = 0 | |
10972 | } else if (byteOffset > 0x7fffffff) { | |
10973 | byteOffset = 0x7fffffff | |
10974 | } else if (byteOffset < -0x80000000) { | |
10975 | byteOffset = -0x80000000 | |
10976 | } | |
10977 | byteOffset = +byteOffset // Coerce to Number. | |
10978 | if (numberIsNaN(byteOffset)) { | |
10979 | // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer | |
10980 | byteOffset = dir ? 0 : (buffer.length - 1) | |
10981 | } | |
10982 | ||
10983 | // Normalize byteOffset: negative offsets start from the end of the buffer | |
10984 | if (byteOffset < 0) byteOffset = buffer.length + byteOffset | |
10985 | if (byteOffset >= buffer.length) { | |
10986 | if (dir) return -1 | |
10987 | else byteOffset = buffer.length - 1 | |
10988 | } else if (byteOffset < 0) { | |
10989 | if (dir) byteOffset = 0 | |
10990 | else return -1 | |
10991 | } | |
10992 | ||
10993 | // Normalize val | |
10994 | if (typeof val === 'string') { | |
10995 | val = Buffer.from(val, encoding) | |
10996 | } | |
10997 | ||
10998 | // Finally, search either indexOf (if dir is true) or lastIndexOf | |
10999 | if (Buffer.isBuffer(val)) { | |
11000 | // Special case: looking for empty string/buffer always fails | |
11001 | if (val.length === 0) { | |
11002 | return -1 | |
11003 | } | |
11004 | return arrayIndexOf(buffer, val, byteOffset, encoding, dir) | |
11005 | } else if (typeof val === 'number') { | |
11006 | val = val & 0xFF // Search for a byte value [0-255] | |
11007 | if (typeof Uint8Array.prototype.indexOf === 'function') { | |
11008 | if (dir) { | |
11009 | return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) | |
11010 | } else { | |
11011 | return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) | |
11012 | } | |
11013 | } | |
11014 | return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) | |
11015 | } | |
11016 | ||
11017 | throw new TypeError('val must be string, number or Buffer') | |
11018 | } | |
11019 | ||
11020 | function arrayIndexOf (arr, val, byteOffset, encoding, dir) { | |
11021 | var indexSize = 1 | |
11022 | var arrLength = arr.length | |
11023 | var valLength = val.length | |
11024 | ||
11025 | if (encoding !== undefined) { | |
11026 | encoding = String(encoding).toLowerCase() | |
11027 | if (encoding === 'ucs2' || encoding === 'ucs-2' || | |
11028 | encoding === 'utf16le' || encoding === 'utf-16le') { | |
11029 | if (arr.length < 2 || val.length < 2) { | |
11030 | return -1 | |
11031 | } | |
11032 | indexSize = 2 | |
11033 | arrLength /= 2 | |
11034 | valLength /= 2 | |
11035 | byteOffset /= 2 | |
11036 | } | |
11037 | } | |
11038 | ||
11039 | function read (buf, i) { | |
11040 | if (indexSize === 1) { | |
11041 | return buf[i] | |
11042 | } else { | |
11043 | return buf.readUInt16BE(i * indexSize) | |
11044 | } | |
11045 | } | |
11046 | ||
11047 | var i | |
11048 | if (dir) { | |
11049 | var foundIndex = -1 | |
11050 | for (i = byteOffset; i < arrLength; i++) { | |
11051 | if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { | |
11052 | if (foundIndex === -1) foundIndex = i | |
11053 | if (i - foundIndex + 1 === valLength) return foundIndex * indexSize | |
11054 | } else { | |
11055 | if (foundIndex !== -1) i -= i - foundIndex | |
11056 | foundIndex = -1 | |
11057 | } | |
11058 | } | |
11059 | } else { | |
11060 | if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength | |
11061 | for (i = byteOffset; i >= 0; i--) { | |
11062 | var found = true | |
11063 | for (var j = 0; j < valLength; j++) { | |
11064 | if (read(arr, i + j) !== read(val, j)) { | |
11065 | found = false | |
11066 | break | |
11067 | } | |
11068 | } | |
11069 | if (found) return i | |
11070 | } | |
11071 | } | |
11072 | ||
11073 | return -1 | |
11074 | } | |
11075 | ||
11076 | Buffer.prototype.includes = function includes (val, byteOffset, encoding) { | |
11077 | return this.indexOf(val, byteOffset, encoding) !== -1 | |
11078 | } | |
11079 | ||
11080 | Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { | |
11081 | return bidirectionalIndexOf(this, val, byteOffset, encoding, true) | |
11082 | } | |
11083 | ||
11084 | Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { | |
11085 | return bidirectionalIndexOf(this, val, byteOffset, encoding, false) | |
11086 | } | |
11087 | ||
11088 | function hexWrite (buf, string, offset, length) { | |
11089 | offset = Number(offset) || 0 | |
11090 | var remaining = buf.length - offset | |
11091 | if (!length) { | |
11092 | length = remaining | |
11093 | } else { | |
11094 | length = Number(length) | |
11095 | if (length > remaining) { | |
11096 | length = remaining | |
11097 | } | |
11098 | } | |
11099 | ||
11100 | var strLen = string.length | |
11101 | ||
11102 | if (length > strLen / 2) { | |
11103 | length = strLen / 2 | |
11104 | } | |
11105 | for (var i = 0; i < length; ++i) { | |
11106 | var parsed = parseInt(string.substr(i * 2, 2), 16) | |
11107 | if (numberIsNaN(parsed)) return i | |
11108 | buf[offset + i] = parsed | |
11109 | } | |
11110 | return i | |
11111 | } | |
11112 | ||
11113 | function utf8Write (buf, string, offset, length) { | |
11114 | return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) | |
11115 | } | |
11116 | ||
11117 | function asciiWrite (buf, string, offset, length) { | |
11118 | return blitBuffer(asciiToBytes(string), buf, offset, length) | |
11119 | } | |
11120 | ||
11121 | function latin1Write (buf, string, offset, length) { | |
11122 | return asciiWrite(buf, string, offset, length) | |
11123 | } | |
11124 | ||
11125 | function base64Write (buf, string, offset, length) { | |
11126 | return blitBuffer(base64ToBytes(string), buf, offset, length) | |
11127 | } | |
11128 | ||
11129 | function ucs2Write (buf, string, offset, length) { | |
11130 | return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) | |
11131 | } | |
11132 | ||
11133 | Buffer.prototype.write = function write (string, offset, length, encoding) { | |
11134 | // Buffer#write(string) | |
11135 | if (offset === undefined) { | |
11136 | encoding = 'utf8' | |
11137 | length = this.length | |
11138 | offset = 0 | |
11139 | // Buffer#write(string, encoding) | |
11140 | } else if (length === undefined && typeof offset === 'string') { | |
11141 | encoding = offset | |
11142 | length = this.length | |
11143 | offset = 0 | |
11144 | // Buffer#write(string, offset[, length][, encoding]) | |
11145 | } else if (isFinite(offset)) { | |
11146 | offset = offset >>> 0 | |
11147 | if (isFinite(length)) { | |
11148 | length = length >>> 0 | |
11149 | if (encoding === undefined) encoding = 'utf8' | |
11150 | } else { | |
11151 | encoding = length | |
11152 | length = undefined | |
11153 | } | |
11154 | } else { | |
11155 | throw new Error( | |
11156 | 'Buffer.write(string, encoding, offset[, length]) is no longer supported' | |
11157 | ) | |
11158 | } | |
11159 | ||
11160 | var remaining = this.length - offset | |
11161 | if (length === undefined || length > remaining) length = remaining | |
11162 | ||
11163 | if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { | |
11164 | throw new RangeError('Attempt to write outside buffer bounds') | |
11165 | } | |
11166 | ||
11167 | if (!encoding) encoding = 'utf8' | |
11168 | ||
11169 | var loweredCase = false | |
11170 | for (;;) { | |
11171 | switch (encoding) { | |
11172 | case 'hex': | |
11173 | return hexWrite(this, string, offset, length) | |
11174 | ||
11175 | case 'utf8': | |
11176 | case 'utf-8': | |
11177 | return utf8Write(this, string, offset, length) | |
11178 | ||
11179 | case 'ascii': | |
11180 | return asciiWrite(this, string, offset, length) | |
11181 | ||
11182 | case 'latin1': | |
11183 | case 'binary': | |
11184 | return latin1Write(this, string, offset, length) | |
11185 | ||
11186 | case 'base64': | |
11187 | // Warning: maxLength not taken into account in base64Write | |
11188 | return base64Write(this, string, offset, length) | |
11189 | ||
11190 | case 'ucs2': | |
11191 | case 'ucs-2': | |
11192 | case 'utf16le': | |
11193 | case 'utf-16le': | |
11194 | return ucs2Write(this, string, offset, length) | |
11195 | ||
11196 | default: | |
11197 | if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) | |
11198 | encoding = ('' + encoding).toLowerCase() | |
11199 | loweredCase = true | |
11200 | } | |
11201 | } | |
11202 | } | |
11203 | ||
11204 | Buffer.prototype.toJSON = function toJSON () { | |
11205 | return { | |
11206 | type: 'Buffer', | |
11207 | data: Array.prototype.slice.call(this._arr || this, 0) | |
11208 | } | |
11209 | } | |
11210 | ||
11211 | function base64Slice (buf, start, end) { | |
11212 | if (start === 0 && end === buf.length) { | |
11213 | return base64.fromByteArray(buf) | |
11214 | } else { | |
11215 | return base64.fromByteArray(buf.slice(start, end)) | |
11216 | } | |
11217 | } | |
11218 | ||
11219 | function utf8Slice (buf, start, end) { | |
11220 | end = Math.min(buf.length, end) | |
11221 | var res = [] | |
11222 | ||
11223 | var i = start | |
11224 | while (i < end) { | |
11225 | var firstByte = buf[i] | |
11226 | var codePoint = null | |
11227 | var bytesPerSequence = (firstByte > 0xEF) ? 4 | |
11228 | : (firstByte > 0xDF) ? 3 | |
11229 | : (firstByte > 0xBF) ? 2 | |
11230 | : 1 | |
11231 | ||
11232 | if (i + bytesPerSequence <= end) { | |
11233 | var secondByte, thirdByte, fourthByte, tempCodePoint | |
11234 | ||
11235 | switch (bytesPerSequence) { | |
11236 | case 1: | |
11237 | if (firstByte < 0x80) { | |
11238 | codePoint = firstByte | |
11239 | } | |
11240 | break | |
11241 | case 2: | |
11242 | secondByte = buf[i + 1] | |
11243 | if ((secondByte & 0xC0) === 0x80) { | |
11244 | tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) | |
11245 | if (tempCodePoint > 0x7F) { | |
11246 | codePoint = tempCodePoint | |
11247 | } | |
11248 | } | |
11249 | break | |
11250 | case 3: | |
11251 | secondByte = buf[i + 1] | |
11252 | thirdByte = buf[i + 2] | |
11253 | if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { | |
11254 | tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) | |
11255 | if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { | |
11256 | codePoint = tempCodePoint | |
11257 | } | |
11258 | } | |
11259 | break | |
11260 | case 4: | |
11261 | secondByte = buf[i + 1] | |
11262 | thirdByte = buf[i + 2] | |
11263 | fourthByte = buf[i + 3] | |
11264 | if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { | |
11265 | tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) | |
11266 | if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { | |
11267 | codePoint = tempCodePoint | |
11268 | } | |
11269 | } | |
11270 | } | |
11271 | } | |
11272 | ||
11273 | if (codePoint === null) { | |
11274 | // we did not generate a valid codePoint so insert a | |
11275 | // replacement char (U+FFFD) and advance only 1 byte | |
11276 | codePoint = 0xFFFD | |
11277 | bytesPerSequence = 1 | |
11278 | } else if (codePoint > 0xFFFF) { | |
11279 | // encode to utf16 (surrogate pair dance) | |
11280 | codePoint -= 0x10000 | |
11281 | res.push(codePoint >>> 10 & 0x3FF | 0xD800) | |
11282 | codePoint = 0xDC00 | codePoint & 0x3FF | |
11283 | } | |
11284 | ||
11285 | res.push(codePoint) | |
11286 | i += bytesPerSequence | |
11287 | } | |
11288 | ||
11289 | return decodeCodePointsArray(res) | |
11290 | } | |
11291 | ||
11292 | // Based on http://stackoverflow.com/a/22747272/680742, the browser with | |
11293 | // the lowest limit is Chrome, with 0x10000 args. | |
11294 | // We go 1 magnitude less, for safety | |
11295 | var MAX_ARGUMENTS_LENGTH = 0x1000 | |
11296 | ||
11297 | function decodeCodePointsArray (codePoints) { | |
11298 | var len = codePoints.length | |
11299 | if (len <= MAX_ARGUMENTS_LENGTH) { | |
11300 | return String.fromCharCode.apply(String, codePoints) // avoid extra slice() | |
11301 | } | |
11302 | ||
11303 | // Decode in chunks to avoid "call stack size exceeded". | |
11304 | var res = '' | |
11305 | var i = 0 | |
11306 | while (i < len) { | |
11307 | res += String.fromCharCode.apply( | |
11308 | String, | |
11309 | codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) | |
11310 | ) | |
11311 | } | |
11312 | return res | |
11313 | } | |
11314 | ||
11315 | function asciiSlice (buf, start, end) { | |
11316 | var ret = '' | |
11317 | end = Math.min(buf.length, end) | |
11318 | ||
11319 | for (var i = start; i < end; ++i) { | |
11320 | ret += String.fromCharCode(buf[i] & 0x7F) | |
11321 | } | |
11322 | return ret | |
11323 | } | |
11324 | ||
11325 | function latin1Slice (buf, start, end) { | |
11326 | var ret = '' | |
11327 | end = Math.min(buf.length, end) | |
11328 | ||
11329 | for (var i = start; i < end; ++i) { | |
11330 | ret += String.fromCharCode(buf[i]) | |
11331 | } | |
11332 | return ret | |
11333 | } | |
11334 | ||
11335 | function hexSlice (buf, start, end) { | |
11336 | var len = buf.length | |
11337 | ||
11338 | if (!start || start < 0) start = 0 | |
11339 | if (!end || end < 0 || end > len) end = len | |
11340 | ||
11341 | var out = '' | |
11342 | for (var i = start; i < end; ++i) { | |
11343 | out += toHex(buf[i]) | |
11344 | } | |
11345 | return out | |
11346 | } | |
11347 | ||
11348 | function utf16leSlice (buf, start, end) { | |
11349 | var bytes = buf.slice(start, end) | |
11350 | var res = '' | |
11351 | for (var i = 0; i < bytes.length; i += 2) { | |
11352 | res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) | |
11353 | } | |
11354 | return res | |
11355 | } | |
11356 | ||
11357 | Buffer.prototype.slice = function slice (start, end) { | |
11358 | var len = this.length | |
11359 | start = ~~start | |
11360 | end = end === undefined ? len : ~~end | |
11361 | ||
11362 | if (start < 0) { | |
11363 | start += len | |
11364 | if (start < 0) start = 0 | |
11365 | } else if (start > len) { | |
11366 | start = len | |
11367 | } | |
11368 | ||
11369 | if (end < 0) { | |
11370 | end += len | |
11371 | if (end < 0) end = 0 | |
11372 | } else if (end > len) { | |
11373 | end = len | |
11374 | } | |
11375 | ||
11376 | if (end < start) end = start | |
11377 | ||
11378 | var newBuf = this.subarray(start, end) | |
11379 | // Return an augmented `Uint8Array` instance | |
11380 | newBuf.__proto__ = Buffer.prototype | |
11381 | return newBuf | |
11382 | } | |
11383 | ||
11384 | /* | |
11385 | * Need to make sure that buffer isn't trying to write out of bounds. | |
11386 | */ | |
11387 | function checkOffset (offset, ext, length) { | |
11388 | if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') | |
11389 | if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') | |
11390 | } | |
11391 | ||
11392 | Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { | |
11393 | offset = offset >>> 0 | |
11394 | byteLength = byteLength >>> 0 | |
11395 | if (!noAssert) checkOffset(offset, byteLength, this.length) | |
11396 | ||
11397 | var val = this[offset] | |
11398 | var mul = 1 | |
11399 | var i = 0 | |
11400 | while (++i < byteLength && (mul *= 0x100)) { | |
11401 | val += this[offset + i] * mul | |
11402 | } | |
11403 | ||
11404 | return val | |
11405 | } | |
11406 | ||
11407 | Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { | |
11408 | offset = offset >>> 0 | |
11409 | byteLength = byteLength >>> 0 | |
11410 | if (!noAssert) { | |
11411 | checkOffset(offset, byteLength, this.length) | |
11412 | } | |
11413 | ||
11414 | var val = this[offset + --byteLength] | |
11415 | var mul = 1 | |
11416 | while (byteLength > 0 && (mul *= 0x100)) { | |
11417 | val += this[offset + --byteLength] * mul | |
11418 | } | |
11419 | ||
11420 | return val | |
11421 | } | |
11422 | ||
11423 | Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { | |
11424 | offset = offset >>> 0 | |
11425 | if (!noAssert) checkOffset(offset, 1, this.length) | |
11426 | return this[offset] | |
11427 | } | |
11428 | ||
11429 | Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { | |
11430 | offset = offset >>> 0 | |
11431 | if (!noAssert) checkOffset(offset, 2, this.length) | |
11432 | return this[offset] | (this[offset + 1] << 8) | |
11433 | } | |
11434 | ||
11435 | Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { | |
11436 | offset = offset >>> 0 | |
11437 | if (!noAssert) checkOffset(offset, 2, this.length) | |
11438 | return (this[offset] << 8) | this[offset + 1] | |
11439 | } | |
11440 | ||
11441 | Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { | |
11442 | offset = offset >>> 0 | |
11443 | if (!noAssert) checkOffset(offset, 4, this.length) | |
11444 | ||
11445 | return ((this[offset]) | | |
11446 | (this[offset + 1] << 8) | | |
11447 | (this[offset + 2] << 16)) + | |
11448 | (this[offset + 3] * 0x1000000) | |
11449 | } | |
11450 | ||
11451 | Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { | |
11452 | offset = offset >>> 0 | |
11453 | if (!noAssert) checkOffset(offset, 4, this.length) | |
11454 | ||
11455 | return (this[offset] * 0x1000000) + | |
11456 | ((this[offset + 1] << 16) | | |
11457 | (this[offset + 2] << 8) | | |
11458 | this[offset + 3]) | |
11459 | } | |
11460 | ||
11461 | Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { | |
11462 | offset = offset >>> 0 | |
11463 | byteLength = byteLength >>> 0 | |
11464 | if (!noAssert) checkOffset(offset, byteLength, this.length) | |
11465 | ||
11466 | var val = this[offset] | |
11467 | var mul = 1 | |
11468 | var i = 0 | |
11469 | while (++i < byteLength && (mul *= 0x100)) { | |
11470 | val += this[offset + i] * mul | |
11471 | } | |
11472 | mul *= 0x80 | |
11473 | ||
11474 | if (val >= mul) val -= Math.pow(2, 8 * byteLength) | |
11475 | ||
11476 | return val | |
11477 | } | |
11478 | ||
11479 | Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { | |
11480 | offset = offset >>> 0 | |
11481 | byteLength = byteLength >>> 0 | |
11482 | if (!noAssert) checkOffset(offset, byteLength, this.length) | |
11483 | ||
11484 | var i = byteLength | |
11485 | var mul = 1 | |
11486 | var val = this[offset + --i] | |
11487 | while (i > 0 && (mul *= 0x100)) { | |
11488 | val += this[offset + --i] * mul | |
11489 | } | |
11490 | mul *= 0x80 | |
11491 | ||
11492 | if (val >= mul) val -= Math.pow(2, 8 * byteLength) | |
11493 | ||
11494 | return val | |
11495 | } | |
11496 | ||
11497 | Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { | |
11498 | offset = offset >>> 0 | |
11499 | if (!noAssert) checkOffset(offset, 1, this.length) | |
11500 | if (!(this[offset] & 0x80)) return (this[offset]) | |
11501 | return ((0xff - this[offset] + 1) * -1) | |
11502 | } | |
11503 | ||
11504 | Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { | |
11505 | offset = offset >>> 0 | |
11506 | if (!noAssert) checkOffset(offset, 2, this.length) | |
11507 | var val = this[offset] | (this[offset + 1] << 8) | |
11508 | return (val & 0x8000) ? val | 0xFFFF0000 : val | |
11509 | } | |
11510 | ||
11511 | Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { | |
11512 | offset = offset >>> 0 | |
11513 | if (!noAssert) checkOffset(offset, 2, this.length) | |
11514 | var val = this[offset + 1] | (this[offset] << 8) | |
11515 | return (val & 0x8000) ? val | 0xFFFF0000 : val | |
11516 | } | |
11517 | ||
11518 | Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { | |
11519 | offset = offset >>> 0 | |
11520 | if (!noAssert) checkOffset(offset, 4, this.length) | |
11521 | ||
11522 | return (this[offset]) | | |
11523 | (this[offset + 1] << 8) | | |
11524 | (this[offset + 2] << 16) | | |
11525 | (this[offset + 3] << 24) | |
11526 | } | |
11527 | ||
11528 | Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { | |
11529 | offset = offset >>> 0 | |
11530 | if (!noAssert) checkOffset(offset, 4, this.length) | |
11531 | ||
11532 | return (this[offset] << 24) | | |
11533 | (this[offset + 1] << 16) | | |
11534 | (this[offset + 2] << 8) | | |
11535 | (this[offset + 3]) | |
11536 | } | |
11537 | ||
11538 | Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { | |
11539 | offset = offset >>> 0 | |
11540 | if (!noAssert) checkOffset(offset, 4, this.length) | |
11541 | return ieee754.read(this, offset, true, 23, 4) | |
11542 | } | |
11543 | ||
11544 | Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { | |
11545 | offset = offset >>> 0 | |
11546 | if (!noAssert) checkOffset(offset, 4, this.length) | |
11547 | return ieee754.read(this, offset, false, 23, 4) | |
11548 | } | |
11549 | ||
11550 | Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { | |
11551 | offset = offset >>> 0 | |
11552 | if (!noAssert) checkOffset(offset, 8, this.length) | |
11553 | return ieee754.read(this, offset, true, 52, 8) | |
11554 | } | |
11555 | ||
11556 | Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { | |
11557 | offset = offset >>> 0 | |
11558 | if (!noAssert) checkOffset(offset, 8, this.length) | |
11559 | return ieee754.read(this, offset, false, 52, 8) | |
11560 | } | |
11561 | ||
11562 | function checkInt (buf, value, offset, ext, max, min) { | |
11563 | if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') | |
11564 | if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') | |
11565 | if (offset + ext > buf.length) throw new RangeError('Index out of range') | |
11566 | } | |
11567 | ||
11568 | Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { | |
11569 | value = +value | |
11570 | offset = offset >>> 0 | |
11571 | byteLength = byteLength >>> 0 | |
11572 | if (!noAssert) { | |
11573 | var maxBytes = Math.pow(2, 8 * byteLength) - 1 | |
11574 | checkInt(this, value, offset, byteLength, maxBytes, 0) | |
11575 | } | |
11576 | ||
11577 | var mul = 1 | |
11578 | var i = 0 | |
11579 | this[offset] = value & 0xFF | |
11580 | while (++i < byteLength && (mul *= 0x100)) { | |
11581 | this[offset + i] = (value / mul) & 0xFF | |
11582 | } | |
11583 | ||
11584 | return offset + byteLength | |
11585 | } | |
11586 | ||
11587 | Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { | |
11588 | value = +value | |
11589 | offset = offset >>> 0 | |
11590 | byteLength = byteLength >>> 0 | |
11591 | if (!noAssert) { | |
11592 | var maxBytes = Math.pow(2, 8 * byteLength) - 1 | |
11593 | checkInt(this, value, offset, byteLength, maxBytes, 0) | |
11594 | } | |
11595 | ||
11596 | var i = byteLength - 1 | |
11597 | var mul = 1 | |
11598 | this[offset + i] = value & 0xFF | |
11599 | while (--i >= 0 && (mul *= 0x100)) { | |
11600 | this[offset + i] = (value / mul) & 0xFF | |
11601 | } | |
11602 | ||
11603 | return offset + byteLength | |
11604 | } | |
11605 | ||
11606 | Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { | |
11607 | value = +value | |
11608 | offset = offset >>> 0 | |
11609 | if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) | |
11610 | this[offset] = (value & 0xff) | |
11611 | return offset + 1 | |
11612 | } | |
11613 | ||
11614 | Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { | |
11615 | value = +value | |
11616 | offset = offset >>> 0 | |
11617 | if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) | |
11618 | this[offset] = (value & 0xff) | |
11619 | this[offset + 1] = (value >>> 8) | |
11620 | return offset + 2 | |
11621 | } | |
11622 | ||
11623 | Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { | |
11624 | value = +value | |
11625 | offset = offset >>> 0 | |
11626 | if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) | |
11627 | this[offset] = (value >>> 8) | |
11628 | this[offset + 1] = (value & 0xff) | |
11629 | return offset + 2 | |
11630 | } | |
11631 | ||
11632 | Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { | |
11633 | value = +value | |
11634 | offset = offset >>> 0 | |
11635 | if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) | |
11636 | this[offset + 3] = (value >>> 24) | |
11637 | this[offset + 2] = (value >>> 16) | |
11638 | this[offset + 1] = (value >>> 8) | |
11639 | this[offset] = (value & 0xff) | |
11640 | return offset + 4 | |
11641 | } | |
11642 | ||
11643 | Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { | |
11644 | value = +value | |
11645 | offset = offset >>> 0 | |
11646 | if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) | |
11647 | this[offset] = (value >>> 24) | |
11648 | this[offset + 1] = (value >>> 16) | |
11649 | this[offset + 2] = (value >>> 8) | |
11650 | this[offset + 3] = (value & 0xff) | |
11651 | return offset + 4 | |
11652 | } | |
11653 | ||
11654 | Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { | |
11655 | value = +value | |
11656 | offset = offset >>> 0 | |
11657 | if (!noAssert) { | |
11658 | var limit = Math.pow(2, (8 * byteLength) - 1) | |
11659 | ||
11660 | checkInt(this, value, offset, byteLength, limit - 1, -limit) | |
11661 | } | |
11662 | ||
11663 | var i = 0 | |
11664 | var mul = 1 | |
11665 | var sub = 0 | |
11666 | this[offset] = value & 0xFF | |
11667 | while (++i < byteLength && (mul *= 0x100)) { | |
11668 | if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { | |
11669 | sub = 1 | |
11670 | } | |
11671 | this[offset + i] = ((value / mul) >> 0) - sub & 0xFF | |
11672 | } | |
11673 | ||
11674 | return offset + byteLength | |
11675 | } | |
11676 | ||
11677 | Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { | |
11678 | value = +value | |
11679 | offset = offset >>> 0 | |
11680 | if (!noAssert) { | |
11681 | var limit = Math.pow(2, (8 * byteLength) - 1) | |
11682 | ||
11683 | checkInt(this, value, offset, byteLength, limit - 1, -limit) | |
11684 | } | |
11685 | ||
11686 | var i = byteLength - 1 | |
11687 | var mul = 1 | |
11688 | var sub = 0 | |
11689 | this[offset + i] = value & 0xFF | |
11690 | while (--i >= 0 && (mul *= 0x100)) { | |
11691 | if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { | |
11692 | sub = 1 | |
11693 | } | |
11694 | this[offset + i] = ((value / mul) >> 0) - sub & 0xFF | |
11695 | } | |
11696 | ||
11697 | return offset + byteLength | |
11698 | } | |
11699 | ||
11700 | Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { | |
11701 | value = +value | |
11702 | offset = offset >>> 0 | |
11703 | if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) | |
11704 | if (value < 0) value = 0xff + value + 1 | |
11705 | this[offset] = (value & 0xff) | |
11706 | return offset + 1 | |
11707 | } | |
11708 | ||
11709 | Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { | |
11710 | value = +value | |
11711 | offset = offset >>> 0 | |
11712 | if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) | |
11713 | this[offset] = (value & 0xff) | |
11714 | this[offset + 1] = (value >>> 8) | |
11715 | return offset + 2 | |
11716 | } | |
11717 | ||
11718 | Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { | |
11719 | value = +value | |
11720 | offset = offset >>> 0 | |
11721 | if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) | |
11722 | this[offset] = (value >>> 8) | |
11723 | this[offset + 1] = (value & 0xff) | |
11724 | return offset + 2 | |
11725 | } | |
11726 | ||
11727 | Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { | |
11728 | value = +value | |
11729 | offset = offset >>> 0 | |
11730 | if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) | |
11731 | this[offset] = (value & 0xff) | |
11732 | this[offset + 1] = (value >>> 8) | |
11733 | this[offset + 2] = (value >>> 16) | |
11734 | this[offset + 3] = (value >>> 24) | |
11735 | return offset + 4 | |
11736 | } | |
11737 | ||
11738 | Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { | |
11739 | value = +value | |
11740 | offset = offset >>> 0 | |
11741 | if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) | |
11742 | if (value < 0) value = 0xffffffff + value + 1 | |
11743 | this[offset] = (value >>> 24) | |
11744 | this[offset + 1] = (value >>> 16) | |
11745 | this[offset + 2] = (value >>> 8) | |
11746 | this[offset + 3] = (value & 0xff) | |
11747 | return offset + 4 | |
11748 | } | |
11749 | ||
11750 | function checkIEEE754 (buf, value, offset, ext, max, min) { | |
11751 | if (offset + ext > buf.length) throw new RangeError('Index out of range') | |
11752 | if (offset < 0) throw new RangeError('Index out of range') | |
11753 | } | |
11754 | ||
11755 | function writeFloat (buf, value, offset, littleEndian, noAssert) { | |
11756 | value = +value | |
11757 | offset = offset >>> 0 | |
11758 | if (!noAssert) { | |
11759 | checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) | |
11760 | } | |
11761 | ieee754.write(buf, value, offset, littleEndian, 23, 4) | |
11762 | return offset + 4 | |
11763 | } | |
11764 | ||
11765 | Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { | |
11766 | return writeFloat(this, value, offset, true, noAssert) | |
11767 | } | |
11768 | ||
11769 | Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { | |
11770 | return writeFloat(this, value, offset, false, noAssert) | |
11771 | } | |
11772 | ||
11773 | function writeDouble (buf, value, offset, littleEndian, noAssert) { | |
11774 | value = +value | |
11775 | offset = offset >>> 0 | |
11776 | if (!noAssert) { | |
11777 | checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) | |
11778 | } | |
11779 | ieee754.write(buf, value, offset, littleEndian, 52, 8) | |
11780 | return offset + 8 | |
11781 | } | |
11782 | ||
11783 | Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { | |
11784 | return writeDouble(this, value, offset, true, noAssert) | |
11785 | } | |
11786 | ||
11787 | Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { | |
11788 | return writeDouble(this, value, offset, false, noAssert) | |
11789 | } | |
11790 | ||
11791 | // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) | |
11792 | Buffer.prototype.copy = function copy (target, targetStart, start, end) { | |
11793 | if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer') | |
11794 | if (!start) start = 0 | |
11795 | if (!end && end !== 0) end = this.length | |
11796 | if (targetStart >= target.length) targetStart = target.length | |
11797 | if (!targetStart) targetStart = 0 | |
11798 | if (end > 0 && end < start) end = start | |
11799 | ||
11800 | // Copy 0 bytes; we're done | |
11801 | if (end === start) return 0 | |
11802 | if (target.length === 0 || this.length === 0) return 0 | |
11803 | ||
11804 | // Fatal error conditions | |
11805 | if (targetStart < 0) { | |
11806 | throw new RangeError('targetStart out of bounds') | |
11807 | } | |
11808 | if (start < 0 || start >= this.length) throw new RangeError('Index out of range') | |
11809 | if (end < 0) throw new RangeError('sourceEnd out of bounds') | |
11810 | ||
11811 | // Are we oob? | |
11812 | if (end > this.length) end = this.length | |
11813 | if (target.length - targetStart < end - start) { | |
11814 | end = target.length - targetStart + start | |
11815 | } | |
11816 | ||
11817 | var len = end - start | |
11818 | ||
11819 | if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') { | |
11820 | // Use built-in when available, missing from IE11 | |
11821 | this.copyWithin(targetStart, start, end) | |
11822 | } else if (this === target && start < targetStart && targetStart < end) { | |
11823 | // descending copy from end | |
11824 | for (var i = len - 1; i >= 0; --i) { | |
11825 | target[i + targetStart] = this[i + start] | |
11826 | } | |
11827 | } else { | |
11828 | Uint8Array.prototype.set.call( | |
11829 | target, | |
11830 | this.subarray(start, end), | |
11831 | targetStart | |
11832 | ) | |
11833 | } | |
11834 | ||
11835 | return len | |
11836 | } | |
11837 | ||
11838 | // Usage: | |
11839 | // buffer.fill(number[, offset[, end]]) | |
11840 | // buffer.fill(buffer[, offset[, end]]) | |
11841 | // buffer.fill(string[, offset[, end]][, encoding]) | |
11842 | Buffer.prototype.fill = function fill (val, start, end, encoding) { | |
11843 | // Handle string cases: | |
11844 | if (typeof val === 'string') { | |
11845 | if (typeof start === 'string') { | |
11846 | encoding = start | |
11847 | start = 0 | |
11848 | end = this.length | |
11849 | } else if (typeof end === 'string') { | |
11850 | encoding = end | |
11851 | end = this.length | |
11852 | } | |
11853 | if (encoding !== undefined && typeof encoding !== 'string') { | |
11854 | throw new TypeError('encoding must be a string') | |
11855 | } | |
11856 | if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { | |
11857 | throw new TypeError('Unknown encoding: ' + encoding) | |
11858 | } | |
11859 | if (val.length === 1) { | |
11860 | var code = val.charCodeAt(0) | |
11861 | if ((encoding === 'utf8' && code < 128) || | |
11862 | encoding === 'latin1') { | |
11863 | // Fast path: If `val` fits into a single byte, use that numeric value. | |
11864 | val = code | |
11865 | } | |
11866 | } | |
11867 | } else if (typeof val === 'number') { | |
11868 | val = val & 255 | |
11869 | } | |
11870 | ||
11871 | // Invalid ranges are not set to a default, so can range check early. | |
11872 | if (start < 0 || this.length < start || this.length < end) { | |
11873 | throw new RangeError('Out of range index') | |
11874 | } | |
11875 | ||
11876 | if (end <= start) { | |
11877 | return this | |
11878 | } | |
11879 | ||
11880 | start = start >>> 0 | |
11881 | end = end === undefined ? this.length : end >>> 0 | |
11882 | ||
11883 | if (!val) val = 0 | |
11884 | ||
11885 | var i | |
11886 | if (typeof val === 'number') { | |
11887 | for (i = start; i < end; ++i) { | |
11888 | this[i] = val | |
11889 | } | |
11890 | } else { | |
11891 | var bytes = Buffer.isBuffer(val) | |
11892 | ? val | |
11893 | : Buffer.from(val, encoding) | |
11894 | var len = bytes.length | |
11895 | if (len === 0) { | |
11896 | throw new TypeError('The value "' + val + | |
11897 | '" is invalid for argument "value"') | |
11898 | } | |
11899 | for (i = 0; i < end - start; ++i) { | |
11900 | this[i + start] = bytes[i % len] | |
11901 | } | |
11902 | } | |
11903 | ||
11904 | return this | |
11905 | } | |
11906 | ||
11907 | // HELPER FUNCTIONS | |
11908 | // ================ | |
11909 | ||
11910 | var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g | |
11911 | ||
11912 | function base64clean (str) { | |
11913 | // Node takes equal signs as end of the Base64 encoding | |
11914 | str = str.split('=')[0] | |
11915 | // Node strips out invalid characters like \n and \t from the string, base64-js does not | |
11916 | str = str.trim().replace(INVALID_BASE64_RE, '') | |
11917 | // Node converts strings with length < 2 to '' | |
11918 | if (str.length < 2) return '' | |
11919 | // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not | |
11920 | while (str.length % 4 !== 0) { | |
11921 | str = str + '=' | |
11922 | } | |
11923 | return str | |
11924 | } | |
11925 | ||
11926 | function toHex (n) { | |
11927 | if (n < 16) return '0' + n.toString(16) | |
11928 | return n.toString(16) | |
11929 | } | |
11930 | ||
11931 | function utf8ToBytes (string, units) { | |
11932 | units = units || Infinity | |
11933 | var codePoint | |
11934 | var length = string.length | |
11935 | var leadSurrogate = null | |
11936 | var bytes = [] | |
11937 | ||
11938 | for (var i = 0; i < length; ++i) { | |
11939 | codePoint = string.charCodeAt(i) | |
11940 | ||
11941 | // is surrogate component | |
11942 | if (codePoint > 0xD7FF && codePoint < 0xE000) { | |
11943 | // last char was a lead | |
11944 | if (!leadSurrogate) { | |
11945 | // no lead yet | |
11946 | if (codePoint > 0xDBFF) { | |
11947 | // unexpected trail | |
11948 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
11949 | continue | |
11950 | } else if (i + 1 === length) { | |
11951 | // unpaired lead | |
11952 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
11953 | continue | |
11954 | } | |
11955 | ||
11956 | // valid lead | |
11957 | leadSurrogate = codePoint | |
11958 | ||
11959 | continue | |
11960 | } | |
11961 | ||
11962 | // 2 leads in a row | |
11963 | if (codePoint < 0xDC00) { | |
11964 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
11965 | leadSurrogate = codePoint | |
11966 | continue | |
11967 | } | |
11968 | ||
11969 | // valid surrogate pair | |
11970 | codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 | |
11971 | } else if (leadSurrogate) { | |
11972 | // valid bmp char, but last char was a lead | |
11973 | if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) | |
11974 | } | |
11975 | ||
11976 | leadSurrogate = null | |
11977 | ||
11978 | // encode utf8 | |
11979 | if (codePoint < 0x80) { | |
11980 | if ((units -= 1) < 0) break | |
11981 | bytes.push(codePoint) | |
11982 | } else if (codePoint < 0x800) { | |
11983 | if ((units -= 2) < 0) break | |
11984 | bytes.push( | |
11985 | codePoint >> 0x6 | 0xC0, | |
11986 | codePoint & 0x3F | 0x80 | |
11987 | ) | |
11988 | } else if (codePoint < 0x10000) { | |
11989 | if ((units -= 3) < 0) break | |
11990 | bytes.push( | |
11991 | codePoint >> 0xC | 0xE0, | |
11992 | codePoint >> 0x6 & 0x3F | 0x80, | |
11993 | codePoint & 0x3F | 0x80 | |
11994 | ) | |
11995 | } else if (codePoint < 0x110000) { | |
11996 | if ((units -= 4) < 0) break | |
11997 | bytes.push( | |
11998 | codePoint >> 0x12 | 0xF0, | |
11999 | codePoint >> 0xC & 0x3F | 0x80, | |
12000 | codePoint >> 0x6 & 0x3F | 0x80, | |
12001 | codePoint & 0x3F | 0x80 | |
12002 | ) | |
12003 | } else { | |
12004 | throw new Error('Invalid code point') | |
12005 | } | |
12006 | } | |
12007 | ||
12008 | return bytes | |
12009 | } | |
12010 | ||
12011 | function asciiToBytes (str) { | |
12012 | var byteArray = [] | |
12013 | for (var i = 0; i < str.length; ++i) { | |
12014 | // Node's code seems to be doing this and not & 0x7F.. | |
12015 | byteArray.push(str.charCodeAt(i) & 0xFF) | |
12016 | } | |
12017 | return byteArray | |
12018 | } | |
12019 | ||
12020 | function utf16leToBytes (str, units) { | |
12021 | var c, hi, lo | |
12022 | var byteArray = [] | |
12023 | for (var i = 0; i < str.length; ++i) { | |
12024 | if ((units -= 2) < 0) break | |
12025 | ||
12026 | c = str.charCodeAt(i) | |
12027 | hi = c >> 8 | |
12028 | lo = c % 256 | |
12029 | byteArray.push(lo) | |
12030 | byteArray.push(hi) | |
12031 | } | |
12032 | ||
12033 | return byteArray | |
12034 | } | |
12035 | ||
12036 | function base64ToBytes (str) { | |
12037 | return base64.toByteArray(base64clean(str)) | |
12038 | } | |
12039 | ||
12040 | function blitBuffer (src, dst, offset, length) { | |
12041 | for (var i = 0; i < length; ++i) { | |
12042 | if ((i + offset >= dst.length) || (i >= src.length)) break | |
12043 | dst[i + offset] = src[i] | |
12044 | } | |
12045 | return i | |
12046 | } | |
12047 | ||
12048 | // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass | |
12049 | // the `instanceof` check but they should be treated as of that type. | |
12050 | // See: https://github.com/feross/buffer/issues/166 | |
12051 | function isInstance (obj, type) { | |
12052 | return obj instanceof type || | |
12053 | (obj != null && obj.constructor != null && obj.constructor.name != null && | |
12054 | obj.constructor.name === type.name) | |
12055 | } | |
12056 | function numberIsNaN (obj) { | |
12057 | // For IE11 support | |
12058 | return obj !== obj // eslint-disable-line no-self-compare | |
12059 | } | |
12060 | ||
12061 | },{"base64-js":16,"ieee754":118}],51:[function(require,module,exports){ | |
12062 | var Buffer = require('safe-buffer').Buffer | |
12063 | var Transform = require('stream').Transform | |
12064 | var StringDecoder = require('string_decoder').StringDecoder | |
12065 | var inherits = require('inherits') | |
12066 | ||
12067 | function CipherBase (hashMode) { | |
12068 | Transform.call(this) | |
12069 | this.hashMode = typeof hashMode === 'string' | |
12070 | if (this.hashMode) { | |
12071 | this[hashMode] = this._finalOrDigest | |
12072 | } else { | |
12073 | this.final = this._finalOrDigest | |
12074 | } | |
12075 | if (this._final) { | |
12076 | this.__final = this._final | |
12077 | this._final = null | |
12078 | } | |
12079 | this._decoder = null | |
12080 | this._encoding = null | |
12081 | } | |
12082 | inherits(CipherBase, Transform) | |
12083 | ||
12084 | CipherBase.prototype.update = function (data, inputEnc, outputEnc) { | |
12085 | if (typeof data === 'string') { | |
12086 | data = Buffer.from(data, inputEnc) | |
12087 | } | |
12088 | ||
12089 | var outData = this._update(data) | |
12090 | if (this.hashMode) return this | |
12091 | ||
12092 | if (outputEnc) { | |
12093 | outData = this._toString(outData, outputEnc) | |
12094 | } | |
12095 | ||
12096 | return outData | |
12097 | } | |
12098 | ||
12099 | CipherBase.prototype.setAutoPadding = function () {} | |
12100 | CipherBase.prototype.getAuthTag = function () { | |
12101 | throw new Error('trying to get auth tag in unsupported state') | |
12102 | } | |
12103 | ||
12104 | CipherBase.prototype.setAuthTag = function () { | |
12105 | throw new Error('trying to set auth tag in unsupported state') | |
12106 | } | |
12107 | ||
12108 | CipherBase.prototype.setAAD = function () { | |
12109 | throw new Error('trying to set aad in unsupported state') | |
12110 | } | |
12111 | ||
12112 | CipherBase.prototype._transform = function (data, _, next) { | |
12113 | var err | |
12114 | try { | |
12115 | if (this.hashMode) { | |
12116 | this._update(data) | |
12117 | } else { | |
12118 | this.push(this._update(data)) | |
12119 | } | |
12120 | } catch (e) { | |
12121 | err = e | |
12122 | } finally { | |
12123 | next(err) | |
12124 | } | |
12125 | } | |
12126 | CipherBase.prototype._flush = function (done) { | |
12127 | var err | |
12128 | try { | |
12129 | this.push(this.__final()) | |
12130 | } catch (e) { | |
12131 | err = e | |
12132 | } | |
12133 | ||
12134 | done(err) | |
12135 | } | |
12136 | CipherBase.prototype._finalOrDigest = function (outputEnc) { | |
12137 | var outData = this.__final() || Buffer.alloc(0) | |
12138 | if (outputEnc) { | |
12139 | outData = this._toString(outData, outputEnc, true) | |
12140 | } | |
12141 | return outData | |
12142 | } | |
12143 | ||
12144 | CipherBase.prototype._toString = function (value, enc, fin) { | |
12145 | if (!this._decoder) { | |
12146 | this._decoder = new StringDecoder(enc) | |
12147 | this._encoding = enc | |
12148 | } | |
12149 | ||
12150 | if (this._encoding !== enc) throw new Error('can\'t switch encodings') | |
12151 | ||
12152 | var out = this._decoder.write(value) | |
12153 | if (fin) { | |
12154 | out += this._decoder.end() | |
12155 | } | |
12156 | ||
12157 | return out | |
12158 | } | |
12159 | ||
12160 | module.exports = CipherBase | |
12161 | ||
12162 | },{"inherits":119,"safe-buffer":398,"stream":437,"string_decoder":438}],52:[function(require,module,exports){ | |
12163 | (function (Buffer){ | |
12164 | // Copyright Joyent, Inc. and other Node contributors. | |
12165 | // | |
12166 | // Permission is hereby granted, free of charge, to any person obtaining a | |
12167 | // copy of this software and associated documentation files (the | |
12168 | // "Software"), to deal in the Software without restriction, including | |
12169 | // without limitation the rights to use, copy, modify, merge, publish, | |
12170 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
12171 | // persons to whom the Software is furnished to do so, subject to the | |
12172 | // following conditions: | |
12173 | // | |
12174 | // The above copyright notice and this permission notice shall be included | |
12175 | // in all copies or substantial portions of the Software. | |
12176 | // | |
12177 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
12178 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
12179 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
12180 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
12181 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
12182 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
12183 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
12184 | ||
12185 | // NOTE: These type checking functions intentionally don't use `instanceof` | |
12186 | // because it is fragile and can be easily faked with `Object.create()`. | |
12187 | ||
12188 | function isArray(arg) { | |
12189 | if (Array.isArray) { | |
12190 | return Array.isArray(arg); | |
12191 | } | |
12192 | return objectToString(arg) === '[object Array]'; | |
12193 | } | |
12194 | exports.isArray = isArray; | |
12195 | ||
12196 | function isBoolean(arg) { | |
12197 | return typeof arg === 'boolean'; | |
12198 | } | |
12199 | exports.isBoolean = isBoolean; | |
12200 | ||
12201 | function isNull(arg) { | |
12202 | return arg === null; | |
12203 | } | |
12204 | exports.isNull = isNull; | |
12205 | ||
12206 | function isNullOrUndefined(arg) { | |
12207 | return arg == null; | |
12208 | } | |
12209 | exports.isNullOrUndefined = isNullOrUndefined; | |
12210 | ||
12211 | function isNumber(arg) { | |
12212 | return typeof arg === 'number'; | |
12213 | } | |
12214 | exports.isNumber = isNumber; | |
12215 | ||
12216 | function isString(arg) { | |
12217 | return typeof arg === 'string'; | |
12218 | } | |
12219 | exports.isString = isString; | |
12220 | ||
12221 | function isSymbol(arg) { | |
12222 | return typeof arg === 'symbol'; | |
12223 | } | |
12224 | exports.isSymbol = isSymbol; | |
12225 | ||
12226 | function isUndefined(arg) { | |
12227 | return arg === void 0; | |
12228 | } | |
12229 | exports.isUndefined = isUndefined; | |
12230 | ||
12231 | function isRegExp(re) { | |
12232 | return objectToString(re) === '[object RegExp]'; | |
12233 | } | |
12234 | exports.isRegExp = isRegExp; | |
12235 | ||
12236 | function isObject(arg) { | |
12237 | return typeof arg === 'object' && arg !== null; | |
12238 | } | |
12239 | exports.isObject = isObject; | |
12240 | ||
12241 | function isDate(d) { | |
12242 | return objectToString(d) === '[object Date]'; | |
12243 | } | |
12244 | exports.isDate = isDate; | |
12245 | ||
12246 | function isError(e) { | |
12247 | return (objectToString(e) === '[object Error]' || e instanceof Error); | |
12248 | } | |
12249 | exports.isError = isError; | |
12250 | ||
12251 | function isFunction(arg) { | |
12252 | return typeof arg === 'function'; | |
12253 | } | |
12254 | exports.isFunction = isFunction; | |
12255 | ||
12256 | function isPrimitive(arg) { | |
12257 | return arg === null || | |
12258 | typeof arg === 'boolean' || | |
12259 | typeof arg === 'number' || | |
12260 | typeof arg === 'string' || | |
12261 | typeof arg === 'symbol' || // ES6 symbol | |
12262 | typeof arg === 'undefined'; | |
12263 | } | |
12264 | exports.isPrimitive = isPrimitive; | |
12265 | ||
12266 | exports.isBuffer = Buffer.isBuffer; | |
12267 | ||
12268 | function objectToString(o) { | |
12269 | return Object.prototype.toString.call(o); | |
12270 | } | |
12271 | ||
12272 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | |
12273 | },{"../../is-buffer/index.js":120}],53:[function(require,module,exports){ | |
12274 | 'use strict'; | |
12275 | ||
12276 | var _buffer = require('buffer'); | |
12277 | ||
12278 | var _create_buffer = require('./create_buffer'); | |
12279 | ||
12280 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12281 | ||
12282 | var _define_crc = require('./define_crc'); | |
12283 | ||
12284 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12285 | ||
12286 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12287 | ||
12288 | module.exports = (0, _define_crc2.default)('crc1', function (buf, previous) { | |
12289 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12290 | ||
12291 | var crc = ~~previous; | |
12292 | var accum = 0; | |
12293 | ||
12294 | for (var index = 0; index < buf.length; index++) { | |
12295 | var byte = buf[index]; | |
12296 | accum += byte; | |
12297 | } | |
12298 | ||
12299 | crc += accum % 256; | |
12300 | return crc % 256; | |
12301 | }); | |
12302 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],54:[function(require,module,exports){ | |
12303 | 'use strict'; | |
12304 | ||
12305 | var _buffer = require('buffer'); | |
12306 | ||
12307 | var _create_buffer = require('./create_buffer'); | |
12308 | ||
12309 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12310 | ||
12311 | var _define_crc = require('./define_crc'); | |
12312 | ||
12313 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12314 | ||
12315 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12316 | ||
12317 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-16 --generate=c` | |
12318 | 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]; | |
12319 | ||
12320 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12321 | ||
12322 | module.exports = (0, _define_crc2.default)('crc-16', function (buf, previous) { | |
12323 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12324 | ||
12325 | var crc = ~~previous; | |
12326 | ||
12327 | for (var index = 0; index < buf.length; index++) { | |
12328 | var byte = buf[index]; | |
12329 | crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff; | |
12330 | } | |
12331 | ||
12332 | return crc; | |
12333 | }); | |
12334 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],55:[function(require,module,exports){ | |
12335 | 'use strict'; | |
12336 | ||
12337 | var _buffer = require('buffer'); | |
12338 | ||
12339 | var _create_buffer = require('./create_buffer'); | |
12340 | ||
12341 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12342 | ||
12343 | var _define_crc = require('./define_crc'); | |
12344 | ||
12345 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12346 | ||
12347 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12348 | ||
12349 | // Generated by `./pycrc.py --algorithm=table-driven --model=ccitt --generate=c` | |
12350 | 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]; | |
12351 | ||
12352 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12353 | ||
12354 | module.exports = (0, _define_crc2.default)('ccitt', function (buf, previous) { | |
12355 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12356 | ||
12357 | var crc = typeof previous !== 'undefined' ? ~~previous : 0xffff; | |
12358 | ||
12359 | for (var index = 0; index < buf.length; index++) { | |
12360 | var byte = buf[index]; | |
12361 | crc = (TABLE[(crc >> 8 ^ byte) & 0xff] ^ crc << 8) & 0xffff; | |
12362 | } | |
12363 | ||
12364 | return crc; | |
12365 | }); | |
12366 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],56:[function(require,module,exports){ | |
12367 | 'use strict'; | |
12368 | ||
12369 | var _buffer = require('buffer'); | |
12370 | ||
12371 | var _create_buffer = require('./create_buffer'); | |
12372 | ||
12373 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12374 | ||
12375 | var _define_crc = require('./define_crc'); | |
12376 | ||
12377 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12378 | ||
12379 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12380 | ||
12381 | // Generated by `./pycrc.py --algorithm=table-driven --model=kermit --generate=c` | |
12382 | 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]; | |
12383 | ||
12384 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12385 | ||
12386 | module.exports = (0, _define_crc2.default)('kermit', function (buf, previous) { | |
12387 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12388 | ||
12389 | var crc = typeof previous !== 'undefined' ? ~~previous : 0x0000; | |
12390 | ||
12391 | for (var index = 0; index < buf.length; index++) { | |
12392 | var byte = buf[index]; | |
12393 | crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff; | |
12394 | } | |
12395 | ||
12396 | return crc; | |
12397 | }); | |
12398 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],57:[function(require,module,exports){ | |
12399 | 'use strict'; | |
12400 | ||
12401 | var _buffer = require('buffer'); | |
12402 | ||
12403 | var _create_buffer = require('./create_buffer'); | |
12404 | ||
12405 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12406 | ||
12407 | var _define_crc = require('./define_crc'); | |
12408 | ||
12409 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12410 | ||
12411 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12412 | ||
12413 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-16-modbus --generate=c` | |
12414 | 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]; | |
12415 | ||
12416 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12417 | ||
12418 | module.exports = (0, _define_crc2.default)('crc-16-modbus', function (buf, previous) { | |
12419 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12420 | ||
12421 | var crc = typeof previous !== 'undefined' ? ~~previous : 0xffff; | |
12422 | ||
12423 | for (var index = 0; index < buf.length; index++) { | |
12424 | var byte = buf[index]; | |
12425 | crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff; | |
12426 | } | |
12427 | ||
12428 | return crc; | |
12429 | }); | |
12430 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],58:[function(require,module,exports){ | |
12431 | 'use strict'; | |
12432 | ||
12433 | var _buffer = require('buffer'); | |
12434 | ||
12435 | var _create_buffer = require('./create_buffer'); | |
12436 | ||
12437 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12438 | ||
12439 | var _define_crc = require('./define_crc'); | |
12440 | ||
12441 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12442 | ||
12443 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12444 | ||
12445 | module.exports = (0, _define_crc2.default)('xmodem', function (buf, previous) { | |
12446 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12447 | ||
12448 | var crc = typeof previous !== 'undefined' ? ~~previous : 0x0; | |
12449 | ||
12450 | for (var index = 0; index < buf.length; index++) { | |
12451 | var byte = buf[index]; | |
12452 | var code = crc >>> 8 & 0xFF; | |
12453 | ||
12454 | code ^= byte & 0xFF; | |
12455 | code ^= code >>> 4; | |
12456 | crc = crc << 8 & 0xFFFF; | |
12457 | crc ^= code; | |
12458 | code = code << 5 & 0xFFFF; | |
12459 | crc ^= code; | |
12460 | code = code << 7 & 0xFFFF; | |
12461 | crc ^= code; | |
12462 | } | |
12463 | ||
12464 | return crc; | |
12465 | }); | |
12466 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],59:[function(require,module,exports){ | |
12467 | 'use strict'; | |
12468 | ||
12469 | var _buffer = require('buffer'); | |
12470 | ||
12471 | var _create_buffer = require('./create_buffer'); | |
12472 | ||
12473 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12474 | ||
12475 | var _define_crc = require('./define_crc'); | |
12476 | ||
12477 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12478 | ||
12479 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12480 | ||
12481 | // Generated by `./pycrc.py --algorithm=table-drive --model=crc-24 --generate=c` | |
12482 | 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]; | |
12483 | ||
12484 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12485 | ||
12486 | module.exports = (0, _define_crc2.default)('crc-24', function (buf, previous) { | |
12487 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12488 | ||
12489 | var crc = typeof previous !== 'undefined' ? ~~previous : 0xb704ce; | |
12490 | ||
12491 | for (var index = 0; index < buf.length; index++) { | |
12492 | var byte = buf[index]; | |
12493 | crc = (TABLE[(crc >> 16 ^ byte) & 0xff] ^ crc << 8) & 0xffffff; | |
12494 | } | |
12495 | ||
12496 | return crc; | |
12497 | }); | |
12498 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],60:[function(require,module,exports){ | |
12499 | 'use strict'; | |
12500 | ||
12501 | var _buffer = require('buffer'); | |
12502 | ||
12503 | var _create_buffer = require('./create_buffer'); | |
12504 | ||
12505 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12506 | ||
12507 | var _define_crc = require('./define_crc'); | |
12508 | ||
12509 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12510 | ||
12511 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12512 | ||
12513 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-32 --generate=c` | |
12514 | 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]; | |
12515 | ||
12516 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12517 | ||
12518 | module.exports = (0, _define_crc2.default)('crc-32', function (buf, previous) { | |
12519 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12520 | ||
12521 | var crc = previous === 0 ? 0 : ~~previous ^ -1; | |
12522 | ||
12523 | for (var index = 0; index < buf.length; index++) { | |
12524 | var byte = buf[index]; | |
12525 | crc = TABLE[(crc ^ byte) & 0xff] ^ crc >>> 8; | |
12526 | } | |
12527 | ||
12528 | return crc ^ -1; | |
12529 | }); | |
12530 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],61:[function(require,module,exports){ | |
12531 | 'use strict'; | |
12532 | ||
12533 | var _buffer = require('buffer'); | |
12534 | ||
12535 | var _create_buffer = require('./create_buffer'); | |
12536 | ||
12537 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12538 | ||
12539 | var _define_crc = require('./define_crc'); | |
12540 | ||
12541 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12542 | ||
12543 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12544 | ||
12545 | // Generated by `./pycrc.py --algorithm=table-driven --model=crc-8 --generate=c` | |
12546 | 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]; | |
12547 | ||
12548 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12549 | ||
12550 | module.exports = (0, _define_crc2.default)('crc-8', function (buf, previous) { | |
12551 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12552 | ||
12553 | var crc = ~~previous; | |
12554 | ||
12555 | for (var index = 0; index < buf.length; index++) { | |
12556 | var byte = buf[index]; | |
12557 | crc = TABLE[(crc ^ byte) & 0xff] & 0xff; | |
12558 | } | |
12559 | ||
12560 | return crc; | |
12561 | }); | |
12562 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],62:[function(require,module,exports){ | |
12563 | 'use strict'; | |
12564 | ||
12565 | var _buffer = require('buffer'); | |
12566 | ||
12567 | var _create_buffer = require('./create_buffer'); | |
12568 | ||
12569 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12570 | ||
12571 | var _define_crc = require('./define_crc'); | |
12572 | ||
12573 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12574 | ||
12575 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12576 | ||
12577 | // Generated by `./pycrc.py --algorithm=table-driven --model=dallas-1-wire --generate=c` | |
12578 | 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]; | |
12579 | ||
12580 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12581 | ||
12582 | module.exports = (0, _define_crc2.default)('dallas-1-wire', function (buf, previous) { | |
12583 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12584 | ||
12585 | var crc = ~~previous; | |
12586 | ||
12587 | for (var index = 0; index < buf.length; index++) { | |
12588 | var byte = buf[index]; | |
12589 | crc = TABLE[(crc ^ byte) & 0xff] & 0xff; | |
12590 | } | |
12591 | ||
12592 | return crc; | |
12593 | }); | |
12594 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],63:[function(require,module,exports){ | |
12595 | 'use strict'; | |
12596 | ||
12597 | var _buffer = require('buffer'); | |
12598 | ||
12599 | var _create_buffer = require('./create_buffer'); | |
12600 | ||
12601 | var _create_buffer2 = _interopRequireDefault(_create_buffer); | |
12602 | ||
12603 | var _define_crc = require('./define_crc'); | |
12604 | ||
12605 | var _define_crc2 = _interopRequireDefault(_define_crc); | |
12606 | ||
12607 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
12608 | ||
12609 | // Generated by `./pycrc.py --algorithm=table-driven --model=jam --generate=c` | |
12610 | 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]; | |
12611 | ||
12612 | if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); | |
12613 | ||
12614 | module.exports = (0, _define_crc2.default)('jam', function (buf) { | |
12615 | var previous = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1; | |
12616 | ||
12617 | if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf); | |
12618 | ||
12619 | var crc = previous === 0 ? 0 : ~~previous; | |
12620 | ||
12621 | for (var index = 0; index < buf.length; index++) { | |
12622 | var byte = buf[index]; | |
12623 | crc = TABLE[(crc ^ byte) & 0xff] ^ crc >>> 8; | |
12624 | } | |
12625 | ||
12626 | return crc; | |
12627 | }); | |
12628 | },{"./create_buffer":64,"./define_crc":65,"buffer":50}],64:[function(require,module,exports){ | |
12629 | 'use strict'; | |
12630 | ||
12631 | Object.defineProperty(exports, "__esModule", { | |
12632 | value: true | |
12633 | }); | |
12634 | ||
12635 | var _buffer = require('buffer'); | |
12636 | ||
12637 | var createBuffer = _buffer.Buffer.from && _buffer.Buffer.alloc && _buffer.Buffer.allocUnsafe && _buffer.Buffer.allocUnsafeSlow ? _buffer.Buffer.from | |
12638 | ||
12639 | // support for Node < 5.10 | |
12640 | : function (val) { | |
12641 | return new _buffer.Buffer(val); | |
12642 | }; | |
12643 | ||
12644 | exports.default = createBuffer; | |
12645 | },{"buffer":50}],65:[function(require,module,exports){ | |
12646 | "use strict"; | |
12647 | ||
12648 | Object.defineProperty(exports, "__esModule", { | |
12649 | value: true | |
12650 | }); | |
12651 | ||
12652 | exports.default = function (model, calc) { | |
12653 | var fn = function fn(buf, previous) { | |
12654 | return calc(buf, previous) >>> 0; | |
12655 | }; | |
12656 | fn.signed = calc; | |
12657 | fn.unsigned = fn; | |
12658 | fn.model = model; | |
12659 | ||
12660 | return fn; | |
12661 | }; | |
12662 | },{}],66:[function(require,module,exports){ | |
12663 | 'use strict'; | |
12664 | ||
12665 | module.exports = { | |
12666 | crc1: require('./crc1'), | |
12667 | crc8: require('./crc8'), | |
12668 | crc81wire: require('./crc8_1wire'), | |
12669 | crc16: require('./crc16'), | |
12670 | crc16ccitt: require('./crc16_ccitt'), | |
12671 | crc16modbus: require('./crc16_modbus'), | |
12672 | crc16xmodem: require('./crc16_xmodem'), | |
12673 | crc16kermit: require('./crc16_kermit'), | |
12674 | crc24: require('./crc24'), | |
12675 | crc32: require('./crc32'), | |
12676 | crcjam: require('./crcjam') | |
12677 | }; | |
12678 | },{"./crc1":53,"./crc16":54,"./crc16_ccitt":55,"./crc16_kermit":56,"./crc16_modbus":57,"./crc16_xmodem":58,"./crc24":59,"./crc32":60,"./crc8":61,"./crc8_1wire":62,"./crcjam":63}],67:[function(require,module,exports){ | |
12679 | (function (Buffer){ | |
12680 | var elliptic = require('elliptic') | |
12681 | var BN = require('bn.js') | |
12682 | ||
12683 | module.exports = function createECDH (curve) { | |
12684 | return new ECDH(curve) | |
12685 | } | |
12686 | ||
12687 | var aliases = { | |
12688 | secp256k1: { | |
12689 | name: 'secp256k1', | |
12690 | byteLength: 32 | |
12691 | }, | |
12692 | secp224r1: { | |
12693 | name: 'p224', | |
12694 | byteLength: 28 | |
12695 | }, | |
12696 | prime256v1: { | |
12697 | name: 'p256', | |
12698 | byteLength: 32 | |
12699 | }, | |
12700 | prime192v1: { | |
12701 | name: 'p192', | |
12702 | byteLength: 24 | |
12703 | }, | |
12704 | ed25519: { | |
12705 | name: 'ed25519', | |
12706 | byteLength: 32 | |
12707 | }, | |
12708 | secp384r1: { | |
12709 | name: 'p384', | |
12710 | byteLength: 48 | |
12711 | }, | |
12712 | secp521r1: { | |
12713 | name: 'p521', | |
12714 | byteLength: 66 | |
12715 | } | |
12716 | } | |
12717 | ||
12718 | aliases.p224 = aliases.secp224r1 | |
12719 | aliases.p256 = aliases.secp256r1 = aliases.prime256v1 | |
12720 | aliases.p192 = aliases.secp192r1 = aliases.prime192v1 | |
12721 | aliases.p384 = aliases.secp384r1 | |
12722 | aliases.p521 = aliases.secp521r1 | |
12723 | ||
12724 | function ECDH (curve) { | |
12725 | this.curveType = aliases[curve] | |
12726 | if (!this.curveType) { | |
12727 | this.curveType = { | |
12728 | name: curve | |
12729 | } | |
12730 | } | |
12731 | this.curve = new elliptic.ec(this.curveType.name) // eslint-disable-line new-cap | |
12732 | this.keys = void 0 | |
12733 | } | |
12734 | ||
12735 | ECDH.prototype.generateKeys = function (enc, format) { | |
12736 | this.keys = this.curve.genKeyPair() | |
12737 | return this.getPublicKey(enc, format) | |
12738 | } | |
12739 | ||
12740 | ECDH.prototype.computeSecret = function (other, inenc, enc) { | |
12741 | inenc = inenc || 'utf8' | |
12742 | if (!Buffer.isBuffer(other)) { | |
12743 | other = new Buffer(other, inenc) | |
12744 | } | |
12745 | var otherPub = this.curve.keyFromPublic(other).getPublic() | |
12746 | var out = otherPub.mul(this.keys.getPrivate()).getX() | |
12747 | return formatReturnValue(out, enc, this.curveType.byteLength) | |
12748 | } | |
12749 | ||
12750 | ECDH.prototype.getPublicKey = function (enc, format) { | |
12751 | var key = this.keys.getPublic(format === 'compressed', true) | |
12752 | if (format === 'hybrid') { | |
12753 | if (key[key.length - 1] % 2) { | |
12754 | key[0] = 7 | |
12755 | } else { | |
12756 | key[0] = 6 | |
12757 | } | |
12758 | } | |
12759 | return formatReturnValue(key, enc) | |
12760 | } | |
12761 | ||
12762 | ECDH.prototype.getPrivateKey = function (enc) { | |
12763 | return formatReturnValue(this.keys.getPrivate(), enc) | |
12764 | } | |
12765 | ||
12766 | ECDH.prototype.setPublicKey = function (pub, enc) { | |
12767 | enc = enc || 'utf8' | |
12768 | if (!Buffer.isBuffer(pub)) { | |
12769 | pub = new Buffer(pub, enc) | |
12770 | } | |
12771 | this.keys._importPublic(pub) | |
12772 | return this | |
12773 | } | |
12774 | ||
12775 | ECDH.prototype.setPrivateKey = function (priv, enc) { | |
12776 | enc = enc || 'utf8' | |
12777 | if (!Buffer.isBuffer(priv)) { | |
12778 | priv = new Buffer(priv, enc) | |
12779 | } | |
12780 | ||
12781 | var _priv = new BN(priv) | |
12782 | _priv = _priv.toString(16) | |
12783 | this.keys = this.curve.genKeyPair() | |
12784 | this.keys._importPrivate(_priv) | |
12785 | return this | |
12786 | } | |
12787 | ||
12788 | function formatReturnValue (bn, enc, len) { | |
12789 | if (!Array.isArray(bn)) { | |
12790 | bn = bn.toArray() | |
12791 | } | |
12792 | var buf = new Buffer(bn) | |
12793 | if (len && buf.length < len) { | |
12794 | var zeros = new Buffer(len - buf.length) | |
12795 | zeros.fill(0) | |
12796 | buf = Buffer.concat([zeros, buf]) | |
12797 | } | |
12798 | if (!enc) { | |
12799 | return buf | |
12800 | } else { | |
12801 | return buf.toString(enc) | |
12802 | } | |
12803 | } | |
12804 | ||
12805 | }).call(this,require("buffer").Buffer) | |
12806 | },{"bn.js":18,"buffer":50,"elliptic":86}],68:[function(require,module,exports){ | |
12807 | 'use strict' | |
12808 | var inherits = require('inherits') | |
12809 | var MD5 = require('md5.js') | |
12810 | var RIPEMD160 = require('ripemd160') | |
12811 | var sha = require('sha.js') | |
12812 | var Base = require('cipher-base') | |
12813 | ||
12814 | function Hash (hash) { | |
12815 | Base.call(this, 'digest') | |
12816 | ||
12817 | this._hash = hash | |
12818 | } | |
12819 | ||
12820 | inherits(Hash, Base) | |
12821 | ||
12822 | Hash.prototype._update = function (data) { | |
12823 | this._hash.update(data) | |
12824 | } | |
12825 | ||
12826 | Hash.prototype._final = function () { | |
12827 | return this._hash.digest() | |
12828 | } | |
12829 | ||
12830 | module.exports = function createHash (alg) { | |
12831 | alg = alg.toLowerCase() | |
12832 | if (alg === 'md5') return new MD5() | |
12833 | if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160() | |
12834 | ||
12835 | return new Hash(sha(alg)) | |
12836 | } | |
12837 | ||
12838 | },{"cipher-base":51,"inherits":119,"md5.js":358,"ripemd160":397,"sha.js":400}],69:[function(require,module,exports){ | |
12839 | var MD5 = require('md5.js') | |
12840 | ||
12841 | module.exports = function (buffer) { | |
12842 | return new MD5().update(buffer).digest() | |
12843 | } | |
12844 | ||
12845 | },{"md5.js":358}],70:[function(require,module,exports){ | |
12846 | 'use strict' | |
12847 | var inherits = require('inherits') | |
12848 | var Legacy = require('./legacy') | |
12849 | var Base = require('cipher-base') | |
12850 | var Buffer = require('safe-buffer').Buffer | |
12851 | var md5 = require('create-hash/md5') | |
12852 | var RIPEMD160 = require('ripemd160') | |
12853 | ||
12854 | var sha = require('sha.js') | |
12855 | ||
12856 | var ZEROS = Buffer.alloc(128) | |
12857 | ||
12858 | function Hmac (alg, key) { | |
12859 | Base.call(this, 'digest') | |
12860 | if (typeof key === 'string') { | |
12861 | key = Buffer.from(key) | |
12862 | } | |
12863 | ||
12864 | var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64 | |
12865 | ||
12866 | this._alg = alg | |
12867 | this._key = key | |
12868 | if (key.length > blocksize) { | |
12869 | var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg) | |
12870 | key = hash.update(key).digest() | |
12871 | } else if (key.length < blocksize) { | |
12872 | key = Buffer.concat([key, ZEROS], blocksize) | |
12873 | } | |
12874 | ||
12875 | var ipad = this._ipad = Buffer.allocUnsafe(blocksize) | |
12876 | var opad = this._opad = Buffer.allocUnsafe(blocksize) | |
12877 | ||
12878 | for (var i = 0; i < blocksize; i++) { | |
12879 | ipad[i] = key[i] ^ 0x36 | |
12880 | opad[i] = key[i] ^ 0x5C | |
12881 | } | |
12882 | this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg) | |
12883 | this._hash.update(ipad) | |
12884 | } | |
12885 | ||
12886 | inherits(Hmac, Base) | |
12887 | ||
12888 | Hmac.prototype._update = function (data) { | |
12889 | this._hash.update(data) | |
12890 | } | |
12891 | ||
12892 | Hmac.prototype._final = function () { | |
12893 | var h = this._hash.digest() | |
12894 | var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg) | |
12895 | return hash.update(this._opad).update(h).digest() | |
12896 | } | |
12897 | ||
12898 | module.exports = function createHmac (alg, key) { | |
12899 | alg = alg.toLowerCase() | |
12900 | if (alg === 'rmd160' || alg === 'ripemd160') { | |
12901 | return new Hmac('rmd160', key) | |
12902 | } | |
12903 | if (alg === 'md5') { | |
12904 | return new Legacy(md5, key) | |
12905 | } | |
12906 | return new Hmac(alg, key) | |
12907 | } | |
12908 | ||
12909 | },{"./legacy":71,"cipher-base":51,"create-hash/md5":69,"inherits":119,"ripemd160":397,"safe-buffer":398,"sha.js":400}],71:[function(require,module,exports){ | |
12910 | 'use strict' | |
12911 | var inherits = require('inherits') | |
12912 | var Buffer = require('safe-buffer').Buffer | |
12913 | ||
12914 | var Base = require('cipher-base') | |
12915 | ||
12916 | var ZEROS = Buffer.alloc(128) | |
12917 | var blocksize = 64 | |
12918 | ||
12919 | function Hmac (alg, key) { | |
12920 | Base.call(this, 'digest') | |
12921 | if (typeof key === 'string') { | |
12922 | key = Buffer.from(key) | |
12923 | } | |
12924 | ||
12925 | this._alg = alg | |
12926 | this._key = key | |
12927 | ||
12928 | if (key.length > blocksize) { | |
12929 | key = alg(key) | |
12930 | } else if (key.length < blocksize) { | |
12931 | key = Buffer.concat([key, ZEROS], blocksize) | |
12932 | } | |
12933 | ||
12934 | var ipad = this._ipad = Buffer.allocUnsafe(blocksize) | |
12935 | var opad = this._opad = Buffer.allocUnsafe(blocksize) | |
12936 | ||
12937 | for (var i = 0; i < blocksize; i++) { | |
12938 | ipad[i] = key[i] ^ 0x36 | |
12939 | opad[i] = key[i] ^ 0x5C | |
12940 | } | |
12941 | ||
12942 | this._hash = [ipad] | |
12943 | } | |
12944 | ||
12945 | inherits(Hmac, Base) | |
12946 | ||
12947 | Hmac.prototype._update = function (data) { | |
12948 | this._hash.push(data) | |
12949 | } | |
12950 | ||
12951 | Hmac.prototype._final = function () { | |
12952 | var h = this._alg(Buffer.concat(this._hash)) | |
12953 | return this._alg(Buffer.concat([this._opad, h])) | |
12954 | } | |
12955 | module.exports = Hmac | |
12956 | ||
12957 | },{"cipher-base":51,"inherits":119,"safe-buffer":398}],72:[function(require,module,exports){ | |
12958 | 'use strict' | |
12959 | ||
12960 | exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes') | |
12961 | exports.createHash = exports.Hash = require('create-hash') | |
12962 | exports.createHmac = exports.Hmac = require('create-hmac') | |
12963 | ||
12964 | var algos = require('browserify-sign/algos') | |
12965 | var algoKeys = Object.keys(algos) | |
12966 | var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys) | |
12967 | exports.getHashes = function () { | |
12968 | return hashes | |
12969 | } | |
12970 | ||
12971 | var p = require('pbkdf2') | |
12972 | exports.pbkdf2 = p.pbkdf2 | |
12973 | exports.pbkdf2Sync = p.pbkdf2Sync | |
12974 | ||
12975 | var aes = require('browserify-cipher') | |
12976 | ||
12977 | exports.Cipher = aes.Cipher | |
12978 | exports.createCipher = aes.createCipher | |
12979 | exports.Cipheriv = aes.Cipheriv | |
12980 | exports.createCipheriv = aes.createCipheriv | |
12981 | exports.Decipher = aes.Decipher | |
12982 | exports.createDecipher = aes.createDecipher | |
12983 | exports.Decipheriv = aes.Decipheriv | |
12984 | exports.createDecipheriv = aes.createDecipheriv | |
12985 | exports.getCiphers = aes.getCiphers | |
12986 | exports.listCiphers = aes.listCiphers | |
12987 | ||
12988 | var dh = require('diffie-hellman') | |
12989 | ||
12990 | exports.DiffieHellmanGroup = dh.DiffieHellmanGroup | |
12991 | exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup | |
12992 | exports.getDiffieHellman = dh.getDiffieHellman | |
12993 | exports.createDiffieHellman = dh.createDiffieHellman | |
12994 | exports.DiffieHellman = dh.DiffieHellman | |
12995 | ||
12996 | var sign = require('browserify-sign') | |
12997 | ||
12998 | exports.createSign = sign.createSign | |
12999 | exports.Sign = sign.Sign | |
13000 | exports.createVerify = sign.createVerify | |
13001 | exports.Verify = sign.Verify | |
13002 | ||
13003 | exports.createECDH = require('create-ecdh') | |
13004 | ||
13005 | var publicEncrypt = require('public-encrypt') | |
13006 | ||
13007 | exports.publicEncrypt = publicEncrypt.publicEncrypt | |
13008 | exports.privateEncrypt = publicEncrypt.privateEncrypt | |
13009 | exports.publicDecrypt = publicEncrypt.publicDecrypt | |
13010 | exports.privateDecrypt = publicEncrypt.privateDecrypt | |
13011 | ||
13012 | // the least I can do is make error messages for the rest of the node.js/crypto api. | |
13013 | // ;[ | |
13014 | // 'createCredentials' | |
13015 | // ].forEach(function (name) { | |
13016 | // exports[name] = function () { | |
13017 | // throw new Error([ | |
13018 | // 'sorry, ' + name + ' is not implemented yet', | |
13019 | // 'we accept pull requests', | |
13020 | // 'https://github.com/crypto-browserify/crypto-browserify' | |
13021 | // ].join('\n')) | |
13022 | // } | |
13023 | // }) | |
13024 | ||
13025 | var rf = require('randomfill') | |
13026 | ||
13027 | exports.randomFill = rf.randomFill | |
13028 | exports.randomFillSync = rf.randomFillSync | |
13029 | ||
13030 | exports.createCredentials = function () { | |
13031 | throw new Error([ | |
13032 | 'sorry, createCredentials is not implemented yet', | |
13033 | 'we accept pull requests', | |
13034 | 'https://github.com/crypto-browserify/crypto-browserify' | |
13035 | ].join('\n')) | |
13036 | } | |
13037 | ||
13038 | exports.constants = { | |
13039 | 'DH_CHECK_P_NOT_SAFE_PRIME': 2, | |
13040 | 'DH_CHECK_P_NOT_PRIME': 1, | |
13041 | 'DH_UNABLE_TO_CHECK_GENERATOR': 4, | |
13042 | 'DH_NOT_SUITABLE_GENERATOR': 8, | |
13043 | 'NPN_ENABLED': 1, | |
13044 | 'ALPN_ENABLED': 1, | |
13045 | 'RSA_PKCS1_PADDING': 1, | |
13046 | 'RSA_SSLV23_PADDING': 2, | |
13047 | 'RSA_NO_PADDING': 3, | |
13048 | 'RSA_PKCS1_OAEP_PADDING': 4, | |
13049 | 'RSA_X931_PADDING': 5, | |
13050 | 'RSA_PKCS1_PSS_PADDING': 6, | |
13051 | 'POINT_CONVERSION_COMPRESSED': 2, | |
13052 | 'POINT_CONVERSION_UNCOMPRESSED': 4, | |
13053 | 'POINT_CONVERSION_HYBRID': 6 | |
13054 | } | |
13055 | ||
13056 | },{"browserify-cipher":38,"browserify-sign":45,"browserify-sign/algos":42,"create-ecdh":67,"create-hash":68,"create-hmac":70,"diffie-hellman":80,"pbkdf2":368,"public-encrypt":375,"randombytes":381,"randomfill":382}],73:[function(require,module,exports){ | |
13057 | (function (Buffer){ | |
13058 | var Cursor = function(buffer) | |
13059 | { | |
13060 | if (!(this instanceof Cursor)) | |
13061 | { | |
13062 | return new Cursor(buffer); | |
13063 | } | |
13064 | ||
13065 | if (!(buffer instanceof Buffer)) | |
13066 | { | |
13067 | buffer = new Buffer(buffer); | |
13068 | } | |
13069 | ||
13070 | this._setBuffer(buffer); | |
13071 | this.rewind(); | |
13072 | }; | |
13073 | ||
13074 | Cursor.prototype._setBuffer = function(buffer) | |
13075 | { | |
13076 | this._buffer = buffer; | |
13077 | this.length = buffer.length; | |
13078 | }; | |
13079 | ||
13080 | Cursor.prototype.buffer = function() | |
13081 | { | |
13082 | return this._buffer; | |
13083 | }; | |
13084 | ||
13085 | Cursor.prototype.tap = function(cb) | |
13086 | { | |
13087 | cb(this); | |
13088 | return this; | |
13089 | }; | |
13090 | ||
13091 | Cursor.prototype.clone = function(newIndex) | |
13092 | { | |
13093 | var c = new this.constructor(this.buffer()); | |
13094 | c.seek(arguments.length === 0 ? this.tell() : newIndex); | |
13095 | ||
13096 | return c; | |
13097 | }; | |
13098 | ||
13099 | Cursor.prototype.tell = function() | |
13100 | { | |
13101 | return this._index; | |
13102 | }; | |
13103 | ||
13104 | Cursor.prototype.seek = function(op, index) | |
13105 | { | |
13106 | if (arguments.length == 1) | |
13107 | { | |
13108 | index = op; | |
13109 | op = '='; | |
13110 | } | |
13111 | ||
13112 | if (op == '+') | |
13113 | { | |
13114 | this._index += index; | |
13115 | } | |
13116 | else if (op == '-') | |
13117 | { | |
13118 | this._index -= index; | |
13119 | } | |
13120 | else | |
13121 | { | |
13122 | this._index = index; | |
13123 | } | |
13124 | ||
13125 | return this; | |
13126 | }; | |
13127 | ||
13128 | Cursor.prototype.rewind = function() | |
13129 | { | |
13130 | return this.seek(0); | |
13131 | }; | |
13132 | ||
13133 | Cursor.prototype.eof = function() | |
13134 | { | |
13135 | return this.tell() == this.buffer().length; | |
13136 | }; | |
13137 | ||
13138 | Cursor.prototype.write = function(string, length, encoding) | |
13139 | { | |
13140 | return this.seek('+', this.buffer().write(string, this.tell(), length, encoding)); | |
13141 | }; | |
13142 | ||
13143 | Cursor.prototype.fill = function(value, length) | |
13144 | { | |
13145 | if (arguments.length == 1) | |
13146 | { | |
13147 | length = this.buffer().length - this.tell(); | |
13148 | } | |
5b689bd6 | 13149 | |
8e3b890d SÖ |
13150 | this.buffer().fill(value, this.tell(), this.tell() + length); |
13151 | this.seek('+', length); | |
13152 | ||
13153 | return this; | |
13154 | }; | |
13155 | ||
13156 | Cursor.prototype.slice = function(length) | |
13157 | { | |
13158 | if (arguments.length === 0) | |
13159 | { | |
13160 | length = this.length - this.tell(); | |
13161 | } | |
13162 | ||
13163 | var c = new this.constructor(this.buffer().slice(this.tell(), this.tell() + length)); | |
13164 | this.seek('+', length); | |
13165 | ||
13166 | return c; | |
13167 | }; | |
13168 | ||
13169 | Cursor.prototype.copyFrom = function(source) | |
13170 | { | |
13171 | var buf = source instanceof Buffer ? source: source.buffer(); | |
13172 | buf.copy(this.buffer(), this.tell(), 0, buf.length); | |
13173 | this.seek('+', buf.length); | |
13174 | ||
13175 | return this; | |
13176 | }; | |
13177 | ||
13178 | Cursor.prototype.concat = function(list) | |
13179 | { | |
13180 | for (var i in list) | |
13181 | { | |
13182 | if (list[i] instanceof Cursor) | |
13183 | { | |
13184 | list[i] = list[i].buffer(); | |
13185 | } | |
13186 | } | |
13187 | ||
13188 | list.unshift(this.buffer()); | |
13189 | ||
13190 | var b = Buffer.concat(list); | |
13191 | this._setBuffer(b); | |
13192 | ||
13193 | return this; | |
13194 | }; | |
13195 | ||
13196 | Cursor.prototype.toString = function(encoding, length) | |
13197 | { | |
13198 | if (arguments.length === 0) | |
13199 | { | |
13200 | encoding = 'utf8'; | |
13201 | length = this.buffer().length - this.tell(); | |
13202 | } | |
13203 | else if (arguments.length === 1) | |
13204 | { | |
13205 | length = this.buffer().length - this.tell(); | |
13206 | } | |
13207 | ||
13208 | var val = this.buffer().toString(encoding, this.tell(), this.tell() + length); | |
13209 | this.seek('+', length); | |
13210 | ||
13211 | return val; | |
13212 | }; | |
13213 | ||
13214 | [ | |
13215 | [1, ['readInt8', 'readUInt8']], | |
13216 | [2, ['readInt16BE', 'readInt16LE', 'readUInt16BE', 'readUInt16LE']], | |
13217 | [4, ['readInt32BE', 'readInt32LE', 'readUInt32BE', 'readUInt32LE', 'readFloatBE', 'readFloatLE']], | |
13218 | [8, ['readDoubleBE', 'readDoubleLE']] | |
13219 | ].forEach(function(arr) | |
13220 | { | |
13221 | arr[1].forEach(function(method) | |
13222 | { | |
13223 | Cursor.prototype[method] = function() | |
13224 | { | |
13225 | var val = this.buffer()[method](this.tell()); | |
13226 | this.seek('+', arr[0]); | |
13227 | ||
13228 | return val; | |
13229 | }; | |
13230 | }); | |
13231 | }); | |
13232 | ||
13233 | [ | |
13234 | [1, ['writeInt8', 'writeUInt8']], | |
13235 | [2, ['writeInt16BE', 'writeInt16LE', 'writeUInt16BE', 'writeUInt16LE']], | |
13236 | [4, ['writeInt32BE', 'writeInt32LE', 'writeUInt32BE', 'writeUInt32LE', 'writeFloatBE', 'writeFloatLE']], | |
13237 | [8, ['writeDoubleBE', 'writeDoubleLE']] | |
13238 | ].forEach(function(arr) | |
13239 | { | |
13240 | arr[1].forEach(function(method) | |
13241 | { | |
13242 | Cursor.prototype[method] = function(val) | |
13243 | { | |
13244 | val = this.buffer()[method](val, this.tell()); | |
13245 | this.seek('+', arr[0]); | |
13246 | ||
13247 | return this; | |
13248 | }; | |
13249 | }); | |
13250 | }); | |
13251 | ||
13252 | //basic extend functionality to facilitate | |
13253 | //writing your own cursor while still providing | |
13254 | //access to low level r/w functionality | |
13255 | Cursor.extend = function(C, proto) | |
13256 | { | |
13257 | var parent = this; | |
13258 | ||
13259 | if (arguments.length === 1) | |
13260 | { | |
13261 | proto = C; | |
13262 | C = null; | |
13263 | } | |
13264 | ||
13265 | proto = proto || {}; | |
13266 | ||
13267 | C = C || function ctor(buffer) | |
13268 | { | |
13269 | if (!(this instanceof C)) | |
13270 | { | |
13271 | return new C(buffer); | |
13272 | } | |
13273 | ||
13274 | parent.call(this, buffer); | |
13275 | }; | |
13276 | ||
13277 | require('util').inherits(C, parent); | |
13278 | ||
13279 | C.extend = parent.extend; | |
13280 | C.define = parent.define; | |
13281 | ||
13282 | for (var i in proto) | |
13283 | { | |
13284 | C.define(i, proto[i]); | |
13285 | } | |
13286 | ||
13287 | return C; | |
13288 | }; | |
13289 | ||
13290 | Cursor.define = function(name, fn) | |
13291 | { | |
13292 | var proto = this.prototype[name]; | |
13293 | ||
13294 | this.prototype[name] = proto && function() | |
13295 | { | |
13296 | this.__super = proto; | |
13297 | return fn.apply(this, arguments); | |
13298 | } || fn; | |
13299 | }; | |
13300 | ||
13301 | module.exports = Cursor; | |
13302 | ||
13303 | }).call(this,require("buffer").Buffer) | |
13304 | },{"buffer":50,"util":443}],74:[function(require,module,exports){ | |
13305 | 'use strict'; | |
13306 | ||
13307 | exports.utils = require('./des/utils'); | |
13308 | exports.Cipher = require('./des/cipher'); | |
13309 | exports.DES = require('./des/des'); | |
13310 | exports.CBC = require('./des/cbc'); | |
13311 | exports.EDE = require('./des/ede'); | |
13312 | ||
13313 | },{"./des/cbc":75,"./des/cipher":76,"./des/des":77,"./des/ede":78,"./des/utils":79}],75:[function(require,module,exports){ | |
13314 | 'use strict'; | |
13315 | ||
13316 | var assert = require('minimalistic-assert'); | |
13317 | var inherits = require('inherits'); | |
13318 | ||
13319 | var proto = {}; | |
13320 | ||
13321 | function CBCState(iv) { | |
13322 | assert.equal(iv.length, 8, 'Invalid IV length'); | |
13323 | ||
13324 | this.iv = new Array(8); | |
13325 | for (var i = 0; i < this.iv.length; i++) | |
13326 | this.iv[i] = iv[i]; | |
13327 | } | |
13328 | ||
13329 | function instantiate(Base) { | |
13330 | function CBC(options) { | |
13331 | Base.call(this, options); | |
13332 | this._cbcInit(); | |
13333 | } | |
13334 | inherits(CBC, Base); | |
13335 | ||
13336 | var keys = Object.keys(proto); | |
13337 | for (var i = 0; i < keys.length; i++) { | |
13338 | var key = keys[i]; | |
13339 | CBC.prototype[key] = proto[key]; | |
13340 | } | |
13341 | ||
13342 | CBC.create = function create(options) { | |
13343 | return new CBC(options); | |
13344 | }; | |
13345 | ||
13346 | return CBC; | |
13347 | } | |
13348 | ||
13349 | exports.instantiate = instantiate; | |
13350 | ||
13351 | proto._cbcInit = function _cbcInit() { | |
13352 | var state = new CBCState(this.options.iv); | |
13353 | this._cbcState = state; | |
13354 | }; | |
13355 | ||
13356 | proto._update = function _update(inp, inOff, out, outOff) { | |
13357 | var state = this._cbcState; | |
13358 | var superProto = this.constructor.super_.prototype; | |
13359 | ||
13360 | var iv = state.iv; | |
13361 | if (this.type === 'encrypt') { | |
13362 | for (var i = 0; i < this.blockSize; i++) | |
13363 | iv[i] ^= inp[inOff + i]; | |
13364 | ||
13365 | superProto._update.call(this, iv, 0, out, outOff); | |
13366 | ||
13367 | for (var i = 0; i < this.blockSize; i++) | |
13368 | iv[i] = out[outOff + i]; | |
13369 | } else { | |
13370 | superProto._update.call(this, inp, inOff, out, outOff); | |
13371 | ||
13372 | for (var i = 0; i < this.blockSize; i++) | |
13373 | out[outOff + i] ^= iv[i]; | |
13374 | ||
13375 | for (var i = 0; i < this.blockSize; i++) | |
13376 | iv[i] = inp[inOff + i]; | |
13377 | } | |
13378 | }; | |
13379 | ||
13380 | },{"inherits":119,"minimalistic-assert":360}],76:[function(require,module,exports){ | |
13381 | 'use strict'; | |
13382 | ||
13383 | var assert = require('minimalistic-assert'); | |
13384 | ||
13385 | function Cipher(options) { | |
13386 | this.options = options; | |
13387 | ||
13388 | this.type = this.options.type; | |
13389 | this.blockSize = 8; | |
13390 | this._init(); | |
13391 | ||
13392 | this.buffer = new Array(this.blockSize); | |
13393 | this.bufferOff = 0; | |
13394 | } | |
13395 | module.exports = Cipher; | |
13396 | ||
13397 | Cipher.prototype._init = function _init() { | |
13398 | // Might be overrided | |
13399 | }; | |
13400 | ||
13401 | Cipher.prototype.update = function update(data) { | |
13402 | if (data.length === 0) | |
13403 | return []; | |
13404 | ||
13405 | if (this.type === 'decrypt') | |
13406 | return this._updateDecrypt(data); | |
13407 | else | |
13408 | return this._updateEncrypt(data); | |
13409 | }; | |
13410 | ||
13411 | Cipher.prototype._buffer = function _buffer(data, off) { | |
13412 | // Append data to buffer | |
13413 | var min = Math.min(this.buffer.length - this.bufferOff, data.length - off); | |
13414 | for (var i = 0; i < min; i++) | |
13415 | this.buffer[this.bufferOff + i] = data[off + i]; | |
13416 | this.bufferOff += min; | |
13417 | ||
13418 | // Shift next | |
13419 | return min; | |
13420 | }; | |
13421 | ||
13422 | Cipher.prototype._flushBuffer = function _flushBuffer(out, off) { | |
13423 | this._update(this.buffer, 0, out, off); | |
13424 | this.bufferOff = 0; | |
13425 | return this.blockSize; | |
13426 | }; | |
13427 | ||
13428 | Cipher.prototype._updateEncrypt = function _updateEncrypt(data) { | |
13429 | var inputOff = 0; | |
13430 | var outputOff = 0; | |
13431 | ||
13432 | var count = ((this.bufferOff + data.length) / this.blockSize) | 0; | |
13433 | var out = new Array(count * this.blockSize); | |
13434 | ||
13435 | if (this.bufferOff !== 0) { | |
13436 | inputOff += this._buffer(data, inputOff); | |
13437 | ||
13438 | if (this.bufferOff === this.buffer.length) | |
13439 | outputOff += this._flushBuffer(out, outputOff); | |
13440 | } | |
13441 | ||
13442 | // Write blocks | |
13443 | var max = data.length - ((data.length - inputOff) % this.blockSize); | |
13444 | for (; inputOff < max; inputOff += this.blockSize) { | |
13445 | this._update(data, inputOff, out, outputOff); | |
13446 | outputOff += this.blockSize; | |
13447 | } | |
13448 | ||
13449 | // Queue rest | |
13450 | for (; inputOff < data.length; inputOff++, this.bufferOff++) | |
13451 | this.buffer[this.bufferOff] = data[inputOff]; | |
13452 | ||
13453 | return out; | |
13454 | }; | |
13455 | ||
13456 | Cipher.prototype._updateDecrypt = function _updateDecrypt(data) { | |
13457 | var inputOff = 0; | |
13458 | var outputOff = 0; | |
13459 | ||
13460 | var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1; | |
13461 | var out = new Array(count * this.blockSize); | |
13462 | ||
13463 | // TODO(indutny): optimize it, this is far from optimal | |
13464 | for (; count > 0; count--) { | |
13465 | inputOff += this._buffer(data, inputOff); | |
13466 | outputOff += this._flushBuffer(out, outputOff); | |
13467 | } | |
13468 | ||
13469 | // Buffer rest of the input | |
13470 | inputOff += this._buffer(data, inputOff); | |
13471 | ||
13472 | return out; | |
13473 | }; | |
13474 | ||
13475 | Cipher.prototype.final = function final(buffer) { | |
13476 | var first; | |
13477 | if (buffer) | |
13478 | first = this.update(buffer); | |
13479 | ||
13480 | var last; | |
13481 | if (this.type === 'encrypt') | |
13482 | last = this._finalEncrypt(); | |
13483 | else | |
13484 | last = this._finalDecrypt(); | |
13485 | ||
13486 | if (first) | |
13487 | return first.concat(last); | |
13488 | else | |
13489 | return last; | |
13490 | }; | |
13491 | ||
13492 | Cipher.prototype._pad = function _pad(buffer, off) { | |
13493 | if (off === 0) | |
13494 | return false; | |
13495 | ||
13496 | while (off < buffer.length) | |
13497 | buffer[off++] = 0; | |
13498 | ||
13499 | return true; | |
13500 | }; | |
13501 | ||
13502 | Cipher.prototype._finalEncrypt = function _finalEncrypt() { | |
13503 | if (!this._pad(this.buffer, this.bufferOff)) | |
13504 | return []; | |
13505 | ||
13506 | var out = new Array(this.blockSize); | |
13507 | this._update(this.buffer, 0, out, 0); | |
13508 | return out; | |
13509 | }; | |
13510 | ||
13511 | Cipher.prototype._unpad = function _unpad(buffer) { | |
13512 | return buffer; | |
13513 | }; | |
13514 | ||
13515 | Cipher.prototype._finalDecrypt = function _finalDecrypt() { | |
13516 | assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt'); | |
13517 | var out = new Array(this.blockSize); | |
13518 | this._flushBuffer(out, 0); | |
13519 | ||
13520 | return this._unpad(out); | |
13521 | }; | |
13522 | ||
13523 | },{"minimalistic-assert":360}],77:[function(require,module,exports){ | |
13524 | 'use strict'; | |
13525 | ||
13526 | var assert = require('minimalistic-assert'); | |
13527 | var inherits = require('inherits'); | |
13528 | ||
13529 | var des = require('../des'); | |
13530 | var utils = des.utils; | |
13531 | var Cipher = des.Cipher; | |
13532 | ||
13533 | function DESState() { | |
13534 | this.tmp = new Array(2); | |
13535 | this.keys = null; | |
13536 | } | |
13537 | ||
13538 | function DES(options) { | |
13539 | Cipher.call(this, options); | |
13540 | ||
13541 | var state = new DESState(); | |
13542 | this._desState = state; | |
13543 | ||
13544 | this.deriveKeys(state, options.key); | |
13545 | } | |
13546 | inherits(DES, Cipher); | |
13547 | module.exports = DES; | |
13548 | ||
13549 | DES.create = function create(options) { | |
13550 | return new DES(options); | |
13551 | }; | |
13552 | ||
13553 | var shiftTable = [ | |
13554 | 1, 1, 2, 2, 2, 2, 2, 2, | |
13555 | 1, 2, 2, 2, 2, 2, 2, 1 | |
13556 | ]; | |
13557 | ||
13558 | DES.prototype.deriveKeys = function deriveKeys(state, key) { | |
13559 | state.keys = new Array(16 * 2); | |
13560 | ||
13561 | assert.equal(key.length, this.blockSize, 'Invalid key length'); | |
13562 | ||
13563 | var kL = utils.readUInt32BE(key, 0); | |
13564 | var kR = utils.readUInt32BE(key, 4); | |
13565 | ||
13566 | utils.pc1(kL, kR, state.tmp, 0); | |
13567 | kL = state.tmp[0]; | |
13568 | kR = state.tmp[1]; | |
13569 | for (var i = 0; i < state.keys.length; i += 2) { | |
13570 | var shift = shiftTable[i >>> 1]; | |
13571 | kL = utils.r28shl(kL, shift); | |
13572 | kR = utils.r28shl(kR, shift); | |
13573 | utils.pc2(kL, kR, state.keys, i); | |
13574 | } | |
13575 | }; | |
13576 | ||
13577 | DES.prototype._update = function _update(inp, inOff, out, outOff) { | |
13578 | var state = this._desState; | |
13579 | ||
13580 | var l = utils.readUInt32BE(inp, inOff); | |
13581 | var r = utils.readUInt32BE(inp, inOff + 4); | |
13582 | ||
13583 | // Initial Permutation | |
13584 | utils.ip(l, r, state.tmp, 0); | |
13585 | l = state.tmp[0]; | |
13586 | r = state.tmp[1]; | |
13587 | ||
13588 | if (this.type === 'encrypt') | |
13589 | this._encrypt(state, l, r, state.tmp, 0); | |
13590 | else | |
13591 | this._decrypt(state, l, r, state.tmp, 0); | |
13592 | ||
13593 | l = state.tmp[0]; | |
13594 | r = state.tmp[1]; | |
13595 | ||
13596 | utils.writeUInt32BE(out, l, outOff); | |
13597 | utils.writeUInt32BE(out, r, outOff + 4); | |
13598 | }; | |
13599 | ||
13600 | DES.prototype._pad = function _pad(buffer, off) { | |
13601 | var value = buffer.length - off; | |
13602 | for (var i = off; i < buffer.length; i++) | |
13603 | buffer[i] = value; | |
13604 | ||
13605 | return true; | |
13606 | }; | |
13607 | ||
13608 | DES.prototype._unpad = function _unpad(buffer) { | |
13609 | var pad = buffer[buffer.length - 1]; | |
13610 | for (var i = buffer.length - pad; i < buffer.length; i++) | |
13611 | assert.equal(buffer[i], pad); | |
13612 | ||
13613 | return buffer.slice(0, buffer.length - pad); | |
13614 | }; | |
13615 | ||
13616 | DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) { | |
13617 | var l = lStart; | |
13618 | var r = rStart; | |
13619 | ||
13620 | // Apply f() x16 times | |
13621 | for (var i = 0; i < state.keys.length; i += 2) { | |
13622 | var keyL = state.keys[i]; | |
13623 | var keyR = state.keys[i + 1]; | |
13624 | ||
13625 | // f(r, k) | |
13626 | utils.expand(r, state.tmp, 0); | |
13627 | ||
13628 | keyL ^= state.tmp[0]; | |
13629 | keyR ^= state.tmp[1]; | |
13630 | var s = utils.substitute(keyL, keyR); | |
13631 | var f = utils.permute(s); | |
13632 | ||
13633 | var t = r; | |
13634 | r = (l ^ f) >>> 0; | |
13635 | l = t; | |
13636 | } | |
13637 | ||
13638 | // Reverse Initial Permutation | |
13639 | utils.rip(r, l, out, off); | |
13640 | }; | |
13641 | ||
13642 | DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) { | |
13643 | var l = rStart; | |
13644 | var r = lStart; | |
13645 | ||
13646 | // Apply f() x16 times | |
13647 | for (var i = state.keys.length - 2; i >= 0; i -= 2) { | |
13648 | var keyL = state.keys[i]; | |
13649 | var keyR = state.keys[i + 1]; | |
13650 | ||
13651 | // f(r, k) | |
13652 | utils.expand(l, state.tmp, 0); | |
13653 | ||
13654 | keyL ^= state.tmp[0]; | |
13655 | keyR ^= state.tmp[1]; | |
13656 | var s = utils.substitute(keyL, keyR); | |
13657 | var f = utils.permute(s); | |
13658 | ||
13659 | var t = l; | |
13660 | l = (r ^ f) >>> 0; | |
13661 | r = t; | |
13662 | } | |
13663 | ||
13664 | // Reverse Initial Permutation | |
13665 | utils.rip(l, r, out, off); | |
13666 | }; | |
13667 | ||
13668 | },{"../des":74,"inherits":119,"minimalistic-assert":360}],78:[function(require,module,exports){ | |
13669 | 'use strict'; | |
13670 | ||
13671 | var assert = require('minimalistic-assert'); | |
13672 | var inherits = require('inherits'); | |
13673 | ||
13674 | var des = require('../des'); | |
13675 | var Cipher = des.Cipher; | |
13676 | var DES = des.DES; | |
13677 | ||
13678 | function EDEState(type, key) { | |
13679 | assert.equal(key.length, 24, 'Invalid key length'); | |
13680 | ||
13681 | var k1 = key.slice(0, 8); | |
13682 | var k2 = key.slice(8, 16); | |
13683 | var k3 = key.slice(16, 24); | |
13684 | ||
13685 | if (type === 'encrypt') { | |
13686 | this.ciphers = [ | |
13687 | DES.create({ type: 'encrypt', key: k1 }), | |
13688 | DES.create({ type: 'decrypt', key: k2 }), | |
13689 | DES.create({ type: 'encrypt', key: k3 }) | |
13690 | ]; | |
13691 | } else { | |
13692 | this.ciphers = [ | |
13693 | DES.create({ type: 'decrypt', key: k3 }), | |
13694 | DES.create({ type: 'encrypt', key: k2 }), | |
13695 | DES.create({ type: 'decrypt', key: k1 }) | |
13696 | ]; | |
13697 | } | |
13698 | } | |
13699 | ||
13700 | function EDE(options) { | |
13701 | Cipher.call(this, options); | |
13702 | ||
13703 | var state = new EDEState(this.type, this.options.key); | |
13704 | this._edeState = state; | |
13705 | } | |
13706 | inherits(EDE, Cipher); | |
13707 | ||
13708 | module.exports = EDE; | |
13709 | ||
13710 | EDE.create = function create(options) { | |
13711 | return new EDE(options); | |
13712 | }; | |
13713 | ||
13714 | EDE.prototype._update = function _update(inp, inOff, out, outOff) { | |
13715 | var state = this._edeState; | |
13716 | ||
13717 | state.ciphers[0]._update(inp, inOff, out, outOff); | |
13718 | state.ciphers[1]._update(out, outOff, out, outOff); | |
13719 | state.ciphers[2]._update(out, outOff, out, outOff); | |
13720 | }; | |
13721 | ||
13722 | EDE.prototype._pad = DES.prototype._pad; | |
13723 | EDE.prototype._unpad = DES.prototype._unpad; | |
13724 | ||
13725 | },{"../des":74,"inherits":119,"minimalistic-assert":360}],79:[function(require,module,exports){ | |
13726 | 'use strict'; | |
13727 | ||
13728 | exports.readUInt32BE = function readUInt32BE(bytes, off) { | |
13729 | var res = (bytes[0 + off] << 24) | | |
13730 | (bytes[1 + off] << 16) | | |
13731 | (bytes[2 + off] << 8) | | |
13732 | bytes[3 + off]; | |
13733 | return res >>> 0; | |
13734 | }; | |
13735 | ||
13736 | exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) { | |
13737 | bytes[0 + off] = value >>> 24; | |
13738 | bytes[1 + off] = (value >>> 16) & 0xff; | |
13739 | bytes[2 + off] = (value >>> 8) & 0xff; | |
13740 | bytes[3 + off] = value & 0xff; | |
13741 | }; | |
13742 | ||
13743 | exports.ip = function ip(inL, inR, out, off) { | |
13744 | var outL = 0; | |
13745 | var outR = 0; | |
13746 | ||
13747 | for (var i = 6; i >= 0; i -= 2) { | |
13748 | for (var j = 0; j <= 24; j += 8) { | |
13749 | outL <<= 1; | |
13750 | outL |= (inR >>> (j + i)) & 1; | |
13751 | } | |
13752 | for (var j = 0; j <= 24; j += 8) { | |
13753 | outL <<= 1; | |
13754 | outL |= (inL >>> (j + i)) & 1; | |
13755 | } | |
13756 | } | |
13757 | ||
13758 | for (var i = 6; i >= 0; i -= 2) { | |
13759 | for (var j = 1; j <= 25; j += 8) { | |
13760 | outR <<= 1; | |
13761 | outR |= (inR >>> (j + i)) & 1; | |
13762 | } | |
13763 | for (var j = 1; j <= 25; j += 8) { | |
13764 | outR <<= 1; | |
13765 | outR |= (inL >>> (j + i)) & 1; | |
13766 | } | |
13767 | } | |
13768 | ||
13769 | out[off + 0] = outL >>> 0; | |
13770 | out[off + 1] = outR >>> 0; | |
13771 | }; | |
13772 | ||
13773 | exports.rip = function rip(inL, inR, out, off) { | |
13774 | var outL = 0; | |
13775 | var outR = 0; | |
13776 | ||
13777 | for (var i = 0; i < 4; i++) { | |
13778 | for (var j = 24; j >= 0; j -= 8) { | |
13779 | outL <<= 1; | |
13780 | outL |= (inR >>> (j + i)) & 1; | |
13781 | outL <<= 1; | |
13782 | outL |= (inL >>> (j + i)) & 1; | |
13783 | } | |
13784 | } | |
13785 | for (var i = 4; i < 8; i++) { | |
13786 | for (var j = 24; j >= 0; j -= 8) { | |
13787 | outR <<= 1; | |
13788 | outR |= (inR >>> (j + i)) & 1; | |
13789 | outR <<= 1; | |
13790 | outR |= (inL >>> (j + i)) & 1; | |
13791 | } | |
13792 | } | |
13793 | ||
13794 | out[off + 0] = outL >>> 0; | |
13795 | out[off + 1] = outR >>> 0; | |
13796 | }; | |
13797 | ||
13798 | exports.pc1 = function pc1(inL, inR, out, off) { | |
13799 | var outL = 0; | |
13800 | var outR = 0; | |
13801 | ||
13802 | // 7, 15, 23, 31, 39, 47, 55, 63 | |
13803 | // 6, 14, 22, 30, 39, 47, 55, 63 | |
13804 | // 5, 13, 21, 29, 39, 47, 55, 63 | |
13805 | // 4, 12, 20, 28 | |
13806 | for (var i = 7; i >= 5; i--) { | |
13807 | for (var j = 0; j <= 24; j += 8) { | |
13808 | outL <<= 1; | |
13809 | outL |= (inR >> (j + i)) & 1; | |
13810 | } | |
13811 | for (var j = 0; j <= 24; j += 8) { | |
13812 | outL <<= 1; | |
13813 | outL |= (inL >> (j + i)) & 1; | |
13814 | } | |
13815 | } | |
13816 | for (var j = 0; j <= 24; j += 8) { | |
13817 | outL <<= 1; | |
13818 | outL |= (inR >> (j + i)) & 1; | |
13819 | } | |
13820 | ||
13821 | // 1, 9, 17, 25, 33, 41, 49, 57 | |
13822 | // 2, 10, 18, 26, 34, 42, 50, 58 | |
13823 | // 3, 11, 19, 27, 35, 43, 51, 59 | |
13824 | // 36, 44, 52, 60 | |
13825 | for (var i = 1; i <= 3; i++) { | |
13826 | for (var j = 0; j <= 24; j += 8) { | |
13827 | outR <<= 1; | |
13828 | outR |= (inR >> (j + i)) & 1; | |
13829 | } | |
13830 | for (var j = 0; j <= 24; j += 8) { | |
13831 | outR <<= 1; | |
13832 | outR |= (inL >> (j + i)) & 1; | |
13833 | } | |
13834 | } | |
13835 | for (var j = 0; j <= 24; j += 8) { | |
13836 | outR <<= 1; | |
13837 | outR |= (inL >> (j + i)) & 1; | |
13838 | } | |
13839 | ||
13840 | out[off + 0] = outL >>> 0; | |
13841 | out[off + 1] = outR >>> 0; | |
13842 | }; | |
13843 | ||
13844 | exports.r28shl = function r28shl(num, shift) { | |
13845 | return ((num << shift) & 0xfffffff) | (num >>> (28 - shift)); | |
13846 | }; | |
13847 | ||
13848 | var pc2table = [ | |
13849 | // inL => outL | |
13850 | 14, 11, 17, 4, 27, 23, 25, 0, | |
13851 | 13, 22, 7, 18, 5, 9, 16, 24, | |
13852 | 2, 20, 12, 21, 1, 8, 15, 26, | |
13853 | ||
13854 | // inR => outR | |
13855 | 15, 4, 25, 19, 9, 1, 26, 16, | |
13856 | 5, 11, 23, 8, 12, 7, 17, 0, | |
13857 | 22, 3, 10, 14, 6, 20, 27, 24 | |
13858 | ]; | |
13859 | ||
13860 | exports.pc2 = function pc2(inL, inR, out, off) { | |
13861 | var outL = 0; | |
13862 | var outR = 0; | |
13863 | ||
13864 | var len = pc2table.length >>> 1; | |
13865 | for (var i = 0; i < len; i++) { | |
13866 | outL <<= 1; | |
13867 | outL |= (inL >>> pc2table[i]) & 0x1; | |
13868 | } | |
13869 | for (var i = len; i < pc2table.length; i++) { | |
13870 | outR <<= 1; | |
13871 | outR |= (inR >>> pc2table[i]) & 0x1; | |
13872 | } | |
13873 | ||
13874 | out[off + 0] = outL >>> 0; | |
13875 | out[off + 1] = outR >>> 0; | |
13876 | }; | |
13877 | ||
13878 | exports.expand = function expand(r, out, off) { | |
13879 | var outL = 0; | |
13880 | var outR = 0; | |
13881 | ||
13882 | outL = ((r & 1) << 5) | (r >>> 27); | |
13883 | for (var i = 23; i >= 15; i -= 4) { | |
13884 | outL <<= 6; | |
13885 | outL |= (r >>> i) & 0x3f; | |
13886 | } | |
13887 | for (var i = 11; i >= 3; i -= 4) { | |
13888 | outR |= (r >>> i) & 0x3f; | |
13889 | outR <<= 6; | |
13890 | } | |
13891 | outR |= ((r & 0x1f) << 1) | (r >>> 31); | |
13892 | ||
13893 | out[off + 0] = outL >>> 0; | |
13894 | out[off + 1] = outR >>> 0; | |
13895 | }; | |
13896 | ||
13897 | var sTable = [ | |
13898 | 14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1, | |
13899 | 3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8, | |
13900 | 4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7, | |
13901 | 15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13, | |
13902 | ||
13903 | 15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14, | |
13904 | 9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5, | |
13905 | 0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2, | |
13906 | 5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9, | |
13907 | ||
13908 | 10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10, | |
13909 | 1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1, | |
13910 | 13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7, | |
13911 | 11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12, | |
13912 | ||
13913 | 7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3, | |
13914 | 1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9, | |
13915 | 10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8, | |
13916 | 15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14, | |
13917 | ||
13918 | 2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1, | |
13919 | 8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6, | |
13920 | 4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13, | |
13921 | 15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3, | |
13922 | ||
13923 | 12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5, | |
13924 | 0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8, | |
13925 | 9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10, | |
13926 | 7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13, | |
13927 | ||
13928 | 4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10, | |
13929 | 3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6, | |
13930 | 1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7, | |
13931 | 10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12, | |
13932 | ||
13933 | 13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4, | |
13934 | 10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2, | |
13935 | 7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13, | |
13936 | 0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11 | |
13937 | ]; | |
13938 | ||
13939 | exports.substitute = function substitute(inL, inR) { | |
13940 | var out = 0; | |
13941 | for (var i = 0; i < 4; i++) { | |
13942 | var b = (inL >>> (18 - i * 6)) & 0x3f; | |
13943 | var sb = sTable[i * 0x40 + b]; | |
13944 | ||
13945 | out <<= 4; | |
13946 | out |= sb; | |
13947 | } | |
13948 | for (var i = 0; i < 4; i++) { | |
13949 | var b = (inR >>> (18 - i * 6)) & 0x3f; | |
13950 | var sb = sTable[4 * 0x40 + i * 0x40 + b]; | |
13951 | ||
13952 | out <<= 4; | |
13953 | out |= sb; | |
13954 | } | |
13955 | return out >>> 0; | |
13956 | }; | |
13957 | ||
13958 | var permuteTable = [ | |
13959 | 16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22, | |
13960 | 30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7 | |
13961 | ]; | |
13962 | ||
13963 | exports.permute = function permute(num) { | |
13964 | var out = 0; | |
13965 | for (var i = 0; i < permuteTable.length; i++) { | |
13966 | out <<= 1; | |
13967 | out |= (num >>> permuteTable[i]) & 0x1; | |
13968 | } | |
13969 | return out >>> 0; | |
13970 | }; | |
13971 | ||
13972 | exports.padSplit = function padSplit(num, size, group) { | |
13973 | var str = num.toString(2); | |
13974 | while (str.length < size) | |
13975 | str = '0' + str; | |
13976 | ||
13977 | var out = []; | |
13978 | for (var i = 0; i < size; i += group) | |
13979 | out.push(str.slice(i, i + group)); | |
13980 | return out.join(' '); | |
13981 | }; | |
13982 | ||
13983 | },{}],80:[function(require,module,exports){ | |
13984 | (function (Buffer){ | |
13985 | var generatePrime = require('./lib/generatePrime') | |
13986 | var primes = require('./lib/primes.json') | |
13987 | ||
13988 | var DH = require('./lib/dh') | |
13989 | ||
13990 | function getDiffieHellman (mod) { | |
13991 | var prime = new Buffer(primes[mod].prime, 'hex') | |
13992 | var gen = new Buffer(primes[mod].gen, 'hex') | |
13993 | ||
13994 | return new DH(prime, gen) | |
13995 | } | |
13996 | ||
13997 | var ENCODINGS = { | |
13998 | 'binary': true, 'hex': true, 'base64': true | |
13999 | } | |
14000 | ||
14001 | function createDiffieHellman (prime, enc, generator, genc) { | |
14002 | if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) { | |
14003 | return createDiffieHellman(prime, 'binary', enc, generator) | |
14004 | } | |
14005 | ||
14006 | enc = enc || 'binary' | |
14007 | genc = genc || 'binary' | |
14008 | generator = generator || new Buffer([2]) | |
14009 | ||
14010 | if (!Buffer.isBuffer(generator)) { | |
14011 | generator = new Buffer(generator, genc) | |
14012 | } | |
14013 | ||
14014 | if (typeof prime === 'number') { | |
14015 | return new DH(generatePrime(prime, generator), generator, true) | |
14016 | } | |
14017 | ||
14018 | if (!Buffer.isBuffer(prime)) { | |
14019 | prime = new Buffer(prime, enc) | |
14020 | } | |
14021 | ||
14022 | return new DH(prime, generator, true) | |
14023 | } | |
14024 | ||
14025 | exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman | |
14026 | exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman | |
14027 | ||
14028 | }).call(this,require("buffer").Buffer) | |
14029 | },{"./lib/dh":81,"./lib/generatePrime":82,"./lib/primes.json":83,"buffer":50}],81:[function(require,module,exports){ | |
14030 | (function (Buffer){ | |
14031 | var BN = require('bn.js'); | |
14032 | var MillerRabin = require('miller-rabin'); | |
14033 | var millerRabin = new MillerRabin(); | |
14034 | var TWENTYFOUR = new BN(24); | |
14035 | var ELEVEN = new BN(11); | |
14036 | var TEN = new BN(10); | |
14037 | var THREE = new BN(3); | |
14038 | var SEVEN = new BN(7); | |
14039 | var primes = require('./generatePrime'); | |
14040 | var randomBytes = require('randombytes'); | |
14041 | module.exports = DH; | |
14042 | ||
14043 | function setPublicKey(pub, enc) { | |
14044 | enc = enc || 'utf8'; | |
14045 | if (!Buffer.isBuffer(pub)) { | |
14046 | pub = new Buffer(pub, enc); | |
14047 | } | |
14048 | this._pub = new BN(pub); | |
14049 | return this; | |
14050 | } | |
14051 | ||
14052 | function setPrivateKey(priv, enc) { | |
14053 | enc = enc || 'utf8'; | |
14054 | if (!Buffer.isBuffer(priv)) { | |
14055 | priv = new Buffer(priv, enc); | |
14056 | } | |
14057 | this._priv = new BN(priv); | |
14058 | return this; | |
14059 | } | |
14060 | ||
14061 | var primeCache = {}; | |
14062 | function checkPrime(prime, generator) { | |
14063 | var gen = generator.toString('hex'); | |
14064 | var hex = [gen, prime.toString(16)].join('_'); | |
14065 | if (hex in primeCache) { | |
14066 | return primeCache[hex]; | |
14067 | } | |
14068 | var error = 0; | |
14069 | ||
14070 | if (prime.isEven() || | |
14071 | !primes.simpleSieve || | |
14072 | !primes.fermatTest(prime) || | |
14073 | !millerRabin.test(prime)) { | |
14074 | //not a prime so +1 | |
14075 | error += 1; | |
14076 | ||
14077 | if (gen === '02' || gen === '05') { | |
14078 | // we'd be able to check the generator | |
14079 | // it would fail so +8 | |
14080 | error += 8; | |
14081 | } else { | |
14082 | //we wouldn't be able to test the generator | |
14083 | // so +4 | |
14084 | error += 4; | |
14085 | } | |
14086 | primeCache[hex] = error; | |
14087 | return error; | |
14088 | } | |
14089 | if (!millerRabin.test(prime.shrn(1))) { | |
14090 | //not a safe prime | |
14091 | error += 2; | |
14092 | } | |
14093 | var rem; | |
14094 | switch (gen) { | |
14095 | case '02': | |
14096 | if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) { | |
14097 | // unsuidable generator | |
14098 | error += 8; | |
14099 | } | |
14100 | break; | |
14101 | case '05': | |
14102 | rem = prime.mod(TEN); | |
14103 | if (rem.cmp(THREE) && rem.cmp(SEVEN)) { | |
14104 | // prime mod 10 needs to equal 3 or 7 | |
14105 | error += 8; | |
14106 | } | |
14107 | break; | |
14108 | default: | |
14109 | error += 4; | |
14110 | } | |
14111 | primeCache[hex] = error; | |
14112 | return error; | |
14113 | } | |
14114 | ||
14115 | function DH(prime, generator, malleable) { | |
14116 | this.setGenerator(generator); | |
14117 | this.__prime = new BN(prime); | |
14118 | this._prime = BN.mont(this.__prime); | |
14119 | this._primeLen = prime.length; | |
14120 | this._pub = undefined; | |
14121 | this._priv = undefined; | |
14122 | this._primeCode = undefined; | |
14123 | if (malleable) { | |
14124 | this.setPublicKey = setPublicKey; | |
14125 | this.setPrivateKey = setPrivateKey; | |
14126 | } else { | |
14127 | this._primeCode = 8; | |
14128 | } | |
14129 | } | |
14130 | Object.defineProperty(DH.prototype, 'verifyError', { | |
14131 | enumerable: true, | |
14132 | get: function () { | |
14133 | if (typeof this._primeCode !== 'number') { | |
14134 | this._primeCode = checkPrime(this.__prime, this.__gen); | |
14135 | } | |
14136 | return this._primeCode; | |
14137 | } | |
14138 | }); | |
14139 | DH.prototype.generateKeys = function () { | |
14140 | if (!this._priv) { | |
14141 | this._priv = new BN(randomBytes(this._primeLen)); | |
14142 | } | |
14143 | this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed(); | |
14144 | return this.getPublicKey(); | |
14145 | }; | |
14146 | ||
14147 | DH.prototype.computeSecret = function (other) { | |
14148 | other = new BN(other); | |
14149 | other = other.toRed(this._prime); | |
14150 | var secret = other.redPow(this._priv).fromRed(); | |
14151 | var out = new Buffer(secret.toArray()); | |
14152 | var prime = this.getPrime(); | |
14153 | if (out.length < prime.length) { | |
14154 | var front = new Buffer(prime.length - out.length); | |
14155 | front.fill(0); | |
14156 | out = Buffer.concat([front, out]); | |
14157 | } | |
14158 | return out; | |
14159 | }; | |
14160 | ||
14161 | DH.prototype.getPublicKey = function getPublicKey(enc) { | |
14162 | return formatReturnValue(this._pub, enc); | |
14163 | }; | |
14164 | ||
14165 | DH.prototype.getPrivateKey = function getPrivateKey(enc) { | |
14166 | return formatReturnValue(this._priv, enc); | |
14167 | }; | |
14168 | ||
14169 | DH.prototype.getPrime = function (enc) { | |
14170 | return formatReturnValue(this.__prime, enc); | |
14171 | }; | |
14172 | ||
14173 | DH.prototype.getGenerator = function (enc) { | |
14174 | return formatReturnValue(this._gen, enc); | |
14175 | }; | |
14176 | ||
14177 | DH.prototype.setGenerator = function (gen, enc) { | |
14178 | enc = enc || 'utf8'; | |
14179 | if (!Buffer.isBuffer(gen)) { | |
14180 | gen = new Buffer(gen, enc); | |
14181 | } | |
14182 | this.__gen = gen; | |
14183 | this._gen = new BN(gen); | |
14184 | return this; | |
14185 | }; | |
14186 | ||
14187 | function formatReturnValue(bn, enc) { | |
14188 | var buf = new Buffer(bn.toArray()); | |
14189 | if (!enc) { | |
14190 | return buf; | |
14191 | } else { | |
14192 | return buf.toString(enc); | |
14193 | } | |
14194 | } | |
14195 | ||
14196 | }).call(this,require("buffer").Buffer) | |
14197 | },{"./generatePrime":82,"bn.js":18,"buffer":50,"miller-rabin":359,"randombytes":381}],82:[function(require,module,exports){ | |
14198 | var randomBytes = require('randombytes'); | |
14199 | module.exports = findPrime; | |
14200 | findPrime.simpleSieve = simpleSieve; | |
14201 | findPrime.fermatTest = fermatTest; | |
14202 | var BN = require('bn.js'); | |
14203 | var TWENTYFOUR = new BN(24); | |
14204 | var MillerRabin = require('miller-rabin'); | |
14205 | var millerRabin = new MillerRabin(); | |
14206 | var ONE = new BN(1); | |
14207 | var TWO = new BN(2); | |
14208 | var FIVE = new BN(5); | |
14209 | var SIXTEEN = new BN(16); | |
14210 | var EIGHT = new BN(8); | |
14211 | var TEN = new BN(10); | |
14212 | var THREE = new BN(3); | |
14213 | var SEVEN = new BN(7); | |
14214 | var ELEVEN = new BN(11); | |
14215 | var FOUR = new BN(4); | |
14216 | var TWELVE = new BN(12); | |
14217 | var primes = null; | |
14218 | ||
14219 | function _getPrimes() { | |
14220 | if (primes !== null) | |
14221 | return primes; | |
14222 | ||
14223 | var limit = 0x100000; | |
14224 | var res = []; | |
14225 | res[0] = 2; | |
14226 | for (var i = 1, k = 3; k < limit; k += 2) { | |
14227 | var sqrt = Math.ceil(Math.sqrt(k)); | |
14228 | for (var j = 0; j < i && res[j] <= sqrt; j++) | |
14229 | if (k % res[j] === 0) | |
14230 | break; | |
14231 | ||
14232 | if (i !== j && res[j] <= sqrt) | |
14233 | continue; | |
14234 | ||
14235 | res[i++] = k; | |
14236 | } | |
14237 | primes = res; | |
14238 | return res; | |
14239 | } | |
14240 | ||
14241 | function simpleSieve(p) { | |
14242 | var primes = _getPrimes(); | |
14243 | ||
14244 | for (var i = 0; i < primes.length; i++) | |
14245 | if (p.modn(primes[i]) === 0) { | |
14246 | if (p.cmpn(primes[i]) === 0) { | |
14247 | return true; | |
14248 | } else { | |
14249 | return false; | |
14250 | } | |
14251 | } | |
14252 | ||
14253 | return true; | |
14254 | } | |
14255 | ||
14256 | function fermatTest(p) { | |
14257 | var red = BN.mont(p); | |
14258 | return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0; | |
14259 | } | |
14260 | ||
14261 | function findPrime(bits, gen) { | |
14262 | if (bits < 16) { | |
14263 | // this is what openssl does | |
14264 | if (gen === 2 || gen === 5) { | |
14265 | return new BN([0x8c, 0x7b]); | |
14266 | } else { | |
14267 | return new BN([0x8c, 0x27]); | |
14268 | } | |
14269 | } | |
14270 | gen = new BN(gen); | |
14271 | ||
14272 | var num, n2; | |
14273 | ||
14274 | while (true) { | |
14275 | num = new BN(randomBytes(Math.ceil(bits / 8))); | |
14276 | while (num.bitLength() > bits) { | |
14277 | num.ishrn(1); | |
14278 | } | |
14279 | if (num.isEven()) { | |
14280 | num.iadd(ONE); | |
14281 | } | |
14282 | if (!num.testn(1)) { | |
14283 | num.iadd(TWO); | |
14284 | } | |
14285 | if (!gen.cmp(TWO)) { | |
14286 | while (num.mod(TWENTYFOUR).cmp(ELEVEN)) { | |
14287 | num.iadd(FOUR); | |
14288 | } | |
14289 | } else if (!gen.cmp(FIVE)) { | |
14290 | while (num.mod(TEN).cmp(THREE)) { | |
14291 | num.iadd(FOUR); | |
14292 | } | |
14293 | } | |
14294 | n2 = num.shrn(1); | |
14295 | if (simpleSieve(n2) && simpleSieve(num) && | |
14296 | fermatTest(n2) && fermatTest(num) && | |
14297 | millerRabin.test(n2) && millerRabin.test(num)) { | |
14298 | return num; | |
14299 | } | |
14300 | } | |
14301 | ||
14302 | } | |
14303 | ||
14304 | },{"bn.js":18,"miller-rabin":359,"randombytes":381}],83:[function(require,module,exports){ | |
14305 | module.exports={ | |
14306 | "modp1": { | |
14307 | "gen": "02", | |
14308 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff" | |
14309 | }, | |
14310 | "modp2": { | |
14311 | "gen": "02", | |
14312 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff" | |
14313 | }, | |
14314 | "modp5": { | |
14315 | "gen": "02", | |
14316 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff" | |
14317 | }, | |
14318 | "modp14": { | |
14319 | "gen": "02", | |
14320 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff" | |
14321 | }, | |
14322 | "modp15": { | |
14323 | "gen": "02", | |
14324 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff" | |
14325 | }, | |
14326 | "modp16": { | |
14327 | "gen": "02", | |
14328 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff" | |
14329 | }, | |
14330 | "modp17": { | |
14331 | "gen": "02", | |
14332 | "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff" | |
14333 | }, | |
14334 | "modp18": { | |
14335 | "gen": "02", | |
14336 | "prime": "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" | |
14337 | } | |
14338 | } | |
14339 | },{}],84:[function(require,module,exports){ | |
14340 | (function (Buffer){ | |
14341 | "use strict"; | |
14342 | Object.defineProperty(exports, "__esModule", { value: true }); | |
14343 | const createHmac = require("create-hmac"); | |
14344 | const naclFactory = require("js-nacl"); | |
14345 | const utils_1 = require("./utils"); | |
14346 | const ED25519_CURVE = 'ed25519 seed'; | |
14347 | const HARDENED_OFFSET = 0x80000000; | |
14348 | let naclInstance; | |
14349 | naclFactory.instantiate((nacl) => (naclInstance = nacl)); | |
14350 | exports.getMasterKeyFromSeed = (seed) => { | |
14351 | const hmac = createHmac('sha512', ED25519_CURVE); | |
14352 | const I = hmac.update(Buffer.from(seed, 'hex')).digest(); | |
14353 | const IL = I.slice(0, 32); | |
14354 | const IR = I.slice(32); | |
14355 | return { | |
14356 | key: IL, | |
14357 | chainCode: IR, | |
14358 | }; | |
14359 | }; | |
14360 | const CKDPriv = ({ key, chainCode }, index) => { | |
14361 | const indexBuffer = Buffer.allocUnsafe(4); | |
14362 | indexBuffer.writeUInt32BE(index, 0); | |
14363 | const data = Buffer.concat([Buffer.alloc(1, 0), key, indexBuffer]); | |
14364 | const I = createHmac('sha512', chainCode) | |
14365 | .update(data) | |
14366 | .digest(); | |
14367 | const IL = I.slice(0, 32); | |
14368 | const IR = I.slice(32); | |
14369 | return { | |
14370 | key: IL, | |
14371 | chainCode: IR, | |
14372 | }; | |
14373 | }; | |
14374 | exports.getPublicKey = (privateKey, withZeroByte = true) => { | |
14375 | const { signPk } = naclInstance.crypto_sign_seed_keypair(privateKey); | |
14376 | const zero = Buffer.alloc(1, 0); | |
14377 | return withZeroByte ? | |
14378 | Buffer.concat([zero, Buffer.from(signPk)]) : | |
14379 | Buffer.from(signPk); | |
14380 | }; | |
14381 | exports.isValidPath = (path) => { | |
14382 | if (!utils_1.pathRegex.test(path)) { | |
14383 | return false; | |
14384 | } | |
14385 | return !path | |
14386 | .split('/') | |
14387 | .slice(1) | |
14388 | .map(utils_1.replaceDerive) | |
14389 | .some(isNaN); | |
14390 | }; | |
14391 | exports.derivePath = (path, seed) => { | |
14392 | if (!exports.isValidPath(path)) { | |
14393 | throw new Error('Invalid derivation path'); | |
14394 | } | |
14395 | const { key, chainCode } = exports.getMasterKeyFromSeed(seed); | |
14396 | const segments = path | |
14397 | .split('/') | |
14398 | .slice(1) | |
14399 | .map(utils_1.replaceDerive) | |
14400 | .map(el => parseInt(el, 10)); | |
14401 | return segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + HARDENED_OFFSET), { key, chainCode }); | |
14402 | }; | |
14403 | ||
14404 | }).call(this,require("buffer").Buffer) | |
14405 | },{"./utils":85,"buffer":50,"create-hmac":70,"js-nacl":122}],85:[function(require,module,exports){ | |
14406 | "use strict"; | |
14407 | Object.defineProperty(exports, "__esModule", { value: true }); | |
14408 | exports.pathRegex = new RegExp("^m(\\/[0-9]+')+$"); | |
14409 | exports.replaceDerive = (val) => val.replace("'", ''); | |
14410 | ||
14411 | },{}],86:[function(require,module,exports){ | |
14412 | 'use strict'; | |
14413 | ||
14414 | var elliptic = exports; | |
14415 | ||
14416 | elliptic.version = require('../package.json').version; | |
14417 | elliptic.utils = require('./elliptic/utils'); | |
14418 | elliptic.rand = require('brorand'); | |
14419 | elliptic.curve = require('./elliptic/curve'); | |
14420 | elliptic.curves = require('./elliptic/curves'); | |
14421 | ||
14422 | // Protocols | |
14423 | elliptic.ec = require('./elliptic/ec'); | |
14424 | elliptic.eddsa = require('./elliptic/eddsa'); | |
14425 | ||
14426 | },{"../package.json":101,"./elliptic/curve":89,"./elliptic/curves":92,"./elliptic/ec":93,"./elliptic/eddsa":96,"./elliptic/utils":100,"brorand":19}],87:[function(require,module,exports){ | |
14427 | 'use strict'; | |
14428 | ||
14429 | var BN = require('bn.js'); | |
14430 | var elliptic = require('../../elliptic'); | |
14431 | var utils = elliptic.utils; | |
14432 | var getNAF = utils.getNAF; | |
14433 | var getJSF = utils.getJSF; | |
14434 | var assert = utils.assert; | |
14435 | ||
14436 | function BaseCurve(type, conf) { | |
14437 | this.type = type; | |
14438 | this.p = new BN(conf.p, 16); | |
14439 | ||
14440 | // Use Montgomery, when there is no fast reduction for the prime | |
14441 | this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p); | |
14442 | ||
14443 | // Useful for many curves | |
14444 | this.zero = new BN(0).toRed(this.red); | |
14445 | this.one = new BN(1).toRed(this.red); | |
14446 | this.two = new BN(2).toRed(this.red); | |
14447 | ||
14448 | // Curve configuration, optional | |
14449 | this.n = conf.n && new BN(conf.n, 16); | |
14450 | this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed); | |
14451 | ||
14452 | // Temporary arrays | |
14453 | this._wnafT1 = new Array(4); | |
14454 | this._wnafT2 = new Array(4); | |
14455 | this._wnafT3 = new Array(4); | |
14456 | this._wnafT4 = new Array(4); | |
14457 | ||
14458 | // Generalized Greg Maxwell's trick | |
14459 | var adjustCount = this.n && this.p.div(this.n); | |
14460 | if (!adjustCount || adjustCount.cmpn(100) > 0) { | |
14461 | this.redN = null; | |
14462 | } else { | |
14463 | this._maxwellTrick = true; | |
14464 | this.redN = this.n.toRed(this.red); | |
14465 | } | |
14466 | } | |
14467 | module.exports = BaseCurve; | |
14468 | ||
14469 | BaseCurve.prototype.point = function point() { | |
14470 | throw new Error('Not implemented'); | |
14471 | }; | |
14472 | ||
14473 | BaseCurve.prototype.validate = function validate() { | |
14474 | throw new Error('Not implemented'); | |
14475 | }; | |
14476 | ||
14477 | BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) { | |
14478 | assert(p.precomputed); | |
14479 | var doubles = p._getDoubles(); | |
14480 | ||
14481 | var naf = getNAF(k, 1); | |
14482 | var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1); | |
14483 | I /= 3; | |
14484 | ||
14485 | // Translate into more windowed form | |
14486 | var repr = []; | |
14487 | for (var j = 0; j < naf.length; j += doubles.step) { | |
14488 | var nafW = 0; | |
14489 | for (var k = j + doubles.step - 1; k >= j; k--) | |
14490 | nafW = (nafW << 1) + naf[k]; | |
14491 | repr.push(nafW); | |
14492 | } | |
14493 | ||
14494 | var a = this.jpoint(null, null, null); | |
14495 | var b = this.jpoint(null, null, null); | |
14496 | for (var i = I; i > 0; i--) { | |
14497 | for (var j = 0; j < repr.length; j++) { | |
14498 | var nafW = repr[j]; | |
14499 | if (nafW === i) | |
14500 | b = b.mixedAdd(doubles.points[j]); | |
14501 | else if (nafW === -i) | |
14502 | b = b.mixedAdd(doubles.points[j].neg()); | |
14503 | } | |
14504 | a = a.add(b); | |
14505 | } | |
14506 | return a.toP(); | |
14507 | }; | |
14508 | ||
14509 | BaseCurve.prototype._wnafMul = function _wnafMul(p, k) { | |
14510 | var w = 4; | |
14511 | ||
14512 | // Precompute window | |
14513 | var nafPoints = p._getNAFPoints(w); | |
14514 | w = nafPoints.wnd; | |
14515 | var wnd = nafPoints.points; | |
14516 | ||
14517 | // Get NAF form | |
14518 | var naf = getNAF(k, w); | |
14519 | ||
14520 | // Add `this`*(N+1) for every w-NAF index | |
14521 | var acc = this.jpoint(null, null, null); | |
14522 | for (var i = naf.length - 1; i >= 0; i--) { | |
14523 | // Count zeroes | |
14524 | for (var k = 0; i >= 0 && naf[i] === 0; i--) | |
14525 | k++; | |
14526 | if (i >= 0) | |
14527 | k++; | |
14528 | acc = acc.dblp(k); | |
14529 | ||
14530 | if (i < 0) | |
14531 | break; | |
14532 | var z = naf[i]; | |
14533 | assert(z !== 0); | |
14534 | if (p.type === 'affine') { | |
14535 | // J +- P | |
14536 | if (z > 0) | |
14537 | acc = acc.mixedAdd(wnd[(z - 1) >> 1]); | |
14538 | else | |
14539 | acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg()); | |
14540 | } else { | |
14541 | // J +- J | |
14542 | if (z > 0) | |
14543 | acc = acc.add(wnd[(z - 1) >> 1]); | |
14544 | else | |
14545 | acc = acc.add(wnd[(-z - 1) >> 1].neg()); | |
14546 | } | |
14547 | } | |
14548 | return p.type === 'affine' ? acc.toP() : acc; | |
14549 | }; | |
14550 | ||
14551 | BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, | |
14552 | points, | |
14553 | coeffs, | |
14554 | len, | |
14555 | jacobianResult) { | |
14556 | var wndWidth = this._wnafT1; | |
14557 | var wnd = this._wnafT2; | |
14558 | var naf = this._wnafT3; | |
14559 | ||
14560 | // Fill all arrays | |
14561 | var max = 0; | |
14562 | for (var i = 0; i < len; i++) { | |
14563 | var p = points[i]; | |
14564 | var nafPoints = p._getNAFPoints(defW); | |
14565 | wndWidth[i] = nafPoints.wnd; | |
14566 | wnd[i] = nafPoints.points; | |
14567 | } | |
14568 | ||
14569 | // Comb small window NAFs | |
14570 | for (var i = len - 1; i >= 1; i -= 2) { | |
14571 | var a = i - 1; | |
14572 | var b = i; | |
14573 | if (wndWidth[a] !== 1 || wndWidth[b] !== 1) { | |
14574 | naf[a] = getNAF(coeffs[a], wndWidth[a]); | |
14575 | naf[b] = getNAF(coeffs[b], wndWidth[b]); | |
14576 | max = Math.max(naf[a].length, max); | |
14577 | max = Math.max(naf[b].length, max); | |
14578 | continue; | |
14579 | } | |
14580 | ||
14581 | var comb = [ | |
14582 | points[a], /* 1 */ | |
14583 | null, /* 3 */ | |
14584 | null, /* 5 */ | |
14585 | points[b] /* 7 */ | |
14586 | ]; | |
14587 | ||
14588 | // Try to avoid Projective points, if possible | |
14589 | if (points[a].y.cmp(points[b].y) === 0) { | |
14590 | comb[1] = points[a].add(points[b]); | |
14591 | comb[2] = points[a].toJ().mixedAdd(points[b].neg()); | |
14592 | } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) { | |
14593 | comb[1] = points[a].toJ().mixedAdd(points[b]); | |
14594 | comb[2] = points[a].add(points[b].neg()); | |
14595 | } else { | |
14596 | comb[1] = points[a].toJ().mixedAdd(points[b]); | |
14597 | comb[2] = points[a].toJ().mixedAdd(points[b].neg()); | |
14598 | } | |
14599 | ||
14600 | var index = [ | |
14601 | -3, /* -1 -1 */ | |
14602 | -1, /* -1 0 */ | |
14603 | -5, /* -1 1 */ | |
14604 | -7, /* 0 -1 */ | |
14605 | 0, /* 0 0 */ | |
14606 | 7, /* 0 1 */ | |
14607 | 5, /* 1 -1 */ | |
14608 | 1, /* 1 0 */ | |
14609 | 3 /* 1 1 */ | |
14610 | ]; | |
14611 | ||
14612 | var jsf = getJSF(coeffs[a], coeffs[b]); | |
14613 | max = Math.max(jsf[0].length, max); | |
14614 | naf[a] = new Array(max); | |
14615 | naf[b] = new Array(max); | |
14616 | for (var j = 0; j < max; j++) { | |
14617 | var ja = jsf[0][j] | 0; | |
14618 | var jb = jsf[1][j] | 0; | |
14619 | ||
14620 | naf[a][j] = index[(ja + 1) * 3 + (jb + 1)]; | |
14621 | naf[b][j] = 0; | |
14622 | wnd[a] = comb; | |
14623 | } | |
14624 | } | |
14625 | ||
14626 | var acc = this.jpoint(null, null, null); | |
14627 | var tmp = this._wnafT4; | |
14628 | for (var i = max; i >= 0; i--) { | |
14629 | var k = 0; | |
14630 | ||
14631 | while (i >= 0) { | |
14632 | var zero = true; | |
14633 | for (var j = 0; j < len; j++) { | |
14634 | tmp[j] = naf[j][i] | 0; | |
14635 | if (tmp[j] !== 0) | |
14636 | zero = false; | |
14637 | } | |
14638 | if (!zero) | |
14639 | break; | |
14640 | k++; | |
14641 | i--; | |
14642 | } | |
14643 | if (i >= 0) | |
14644 | k++; | |
14645 | acc = acc.dblp(k); | |
14646 | if (i < 0) | |
14647 | break; | |
14648 | ||
14649 | for (var j = 0; j < len; j++) { | |
14650 | var z = tmp[j]; | |
14651 | var p; | |
14652 | if (z === 0) | |
14653 | continue; | |
14654 | else if (z > 0) | |
14655 | p = wnd[j][(z - 1) >> 1]; | |
14656 | else if (z < 0) | |
14657 | p = wnd[j][(-z - 1) >> 1].neg(); | |
14658 | ||
14659 | if (p.type === 'affine') | |
14660 | acc = acc.mixedAdd(p); | |
14661 | else | |
14662 | acc = acc.add(p); | |
14663 | } | |
14664 | } | |
14665 | // Zeroify references | |
14666 | for (var i = 0; i < len; i++) | |
14667 | wnd[i] = null; | |
14668 | ||
14669 | if (jacobianResult) | |
14670 | return acc; | |
14671 | else | |
14672 | return acc.toP(); | |
14673 | }; | |
14674 | ||
14675 | function BasePoint(curve, type) { | |
14676 | this.curve = curve; | |
14677 | this.type = type; | |
14678 | this.precomputed = null; | |
14679 | } | |
14680 | BaseCurve.BasePoint = BasePoint; | |
14681 | ||
14682 | BasePoint.prototype.eq = function eq(/*other*/) { | |
14683 | throw new Error('Not implemented'); | |
14684 | }; | |
14685 | ||
14686 | BasePoint.prototype.validate = function validate() { | |
14687 | return this.curve.validate(this); | |
14688 | }; | |
14689 | ||
14690 | BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) { | |
14691 | bytes = utils.toArray(bytes, enc); | |
14692 | ||
14693 | var len = this.p.byteLength(); | |
14694 | ||
14695 | // uncompressed, hybrid-odd, hybrid-even | |
14696 | if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) && | |
14697 | bytes.length - 1 === 2 * len) { | |
14698 | if (bytes[0] === 0x06) | |
14699 | assert(bytes[bytes.length - 1] % 2 === 0); | |
14700 | else if (bytes[0] === 0x07) | |
14701 | assert(bytes[bytes.length - 1] % 2 === 1); | |
14702 | ||
14703 | var res = this.point(bytes.slice(1, 1 + len), | |
14704 | bytes.slice(1 + len, 1 + 2 * len)); | |
14705 | ||
14706 | return res; | |
14707 | } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) && | |
14708 | bytes.length - 1 === len) { | |
14709 | return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03); | |
14710 | } | |
14711 | throw new Error('Unknown point format'); | |
14712 | }; | |
14713 | ||
14714 | BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) { | |
14715 | return this.encode(enc, true); | |
14716 | }; | |
14717 | ||
14718 | BasePoint.prototype._encode = function _encode(compact) { | |
14719 | var len = this.curve.p.byteLength(); | |
14720 | var x = this.getX().toArray('be', len); | |
14721 | ||
14722 | if (compact) | |
14723 | return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x); | |
14724 | ||
14725 | return [ 0x04 ].concat(x, this.getY().toArray('be', len)) ; | |
14726 | }; | |
14727 | ||
14728 | BasePoint.prototype.encode = function encode(enc, compact) { | |
14729 | return utils.encode(this._encode(compact), enc); | |
14730 | }; | |
14731 | ||
14732 | BasePoint.prototype.precompute = function precompute(power) { | |
14733 | if (this.precomputed) | |
14734 | return this; | |
14735 | ||
14736 | var precomputed = { | |
14737 | doubles: null, | |
14738 | naf: null, | |
14739 | beta: null | |
14740 | }; | |
14741 | precomputed.naf = this._getNAFPoints(8); | |
14742 | precomputed.doubles = this._getDoubles(4, power); | |
14743 | precomputed.beta = this._getBeta(); | |
14744 | this.precomputed = precomputed; | |
14745 | ||
14746 | return this; | |
14747 | }; | |
14748 | ||
14749 | BasePoint.prototype._hasDoubles = function _hasDoubles(k) { | |
14750 | if (!this.precomputed) | |
14751 | return false; | |
14752 | ||
14753 | var doubles = this.precomputed.doubles; | |
14754 | if (!doubles) | |
14755 | return false; | |
14756 | ||
14757 | return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step); | |
14758 | }; | |
14759 | ||
14760 | BasePoint.prototype._getDoubles = function _getDoubles(step, power) { | |
14761 | if (this.precomputed && this.precomputed.doubles) | |
14762 | return this.precomputed.doubles; | |
14763 | ||
14764 | var doubles = [ this ]; | |
14765 | var acc = this; | |
14766 | for (var i = 0; i < power; i += step) { | |
14767 | for (var j = 0; j < step; j++) | |
14768 | acc = acc.dbl(); | |
14769 | doubles.push(acc); | |
14770 | } | |
14771 | return { | |
14772 | step: step, | |
14773 | points: doubles | |
14774 | }; | |
14775 | }; | |
14776 | ||
14777 | BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) { | |
14778 | if (this.precomputed && this.precomputed.naf) | |
14779 | return this.precomputed.naf; | |
14780 | ||
14781 | var res = [ this ]; | |
14782 | var max = (1 << wnd) - 1; | |
14783 | var dbl = max === 1 ? null : this.dbl(); | |
14784 | for (var i = 1; i < max; i++) | |
14785 | res[i] = res[i - 1].add(dbl); | |
14786 | return { | |
14787 | wnd: wnd, | |
14788 | points: res | |
14789 | }; | |
14790 | }; | |
14791 | ||
14792 | BasePoint.prototype._getBeta = function _getBeta() { | |
14793 | return null; | |
14794 | }; | |
14795 | ||
14796 | BasePoint.prototype.dblp = function dblp(k) { | |
14797 | var r = this; | |
14798 | for (var i = 0; i < k; i++) | |
14799 | r = r.dbl(); | |
14800 | return r; | |
14801 | }; | |
14802 | ||
14803 | },{"../../elliptic":86,"bn.js":18}],88:[function(require,module,exports){ | |
14804 | 'use strict'; | |
14805 | ||
14806 | var curve = require('../curve'); | |
14807 | var elliptic = require('../../elliptic'); | |
14808 | var BN = require('bn.js'); | |
14809 | var inherits = require('inherits'); | |
14810 | var Base = curve.base; | |
14811 | ||
14812 | var assert = elliptic.utils.assert; | |
14813 | ||
14814 | function EdwardsCurve(conf) { | |
14815 | // NOTE: Important as we are creating point in Base.call() | |
14816 | this.twisted = (conf.a | 0) !== 1; | |
14817 | this.mOneA = this.twisted && (conf.a | 0) === -1; | |
14818 | this.extended = this.mOneA; | |
14819 | ||
14820 | Base.call(this, 'edwards', conf); | |
14821 | ||
14822 | this.a = new BN(conf.a, 16).umod(this.red.m); | |
14823 | this.a = this.a.toRed(this.red); | |
14824 | this.c = new BN(conf.c, 16).toRed(this.red); | |
14825 | this.c2 = this.c.redSqr(); | |
14826 | this.d = new BN(conf.d, 16).toRed(this.red); | |
14827 | this.dd = this.d.redAdd(this.d); | |
14828 | ||
14829 | assert(!this.twisted || this.c.fromRed().cmpn(1) === 0); | |
14830 | this.oneC = (conf.c | 0) === 1; | |
14831 | } | |
14832 | inherits(EdwardsCurve, Base); | |
14833 | module.exports = EdwardsCurve; | |
14834 | ||
14835 | EdwardsCurve.prototype._mulA = function _mulA(num) { | |
14836 | if (this.mOneA) | |
14837 | return num.redNeg(); | |
14838 | else | |
14839 | return this.a.redMul(num); | |
14840 | }; | |
14841 | ||
14842 | EdwardsCurve.prototype._mulC = function _mulC(num) { | |
14843 | if (this.oneC) | |
14844 | return num; | |
14845 | else | |
14846 | return this.c.redMul(num); | |
14847 | }; | |
14848 | ||
14849 | // Just for compatibility with Short curve | |
14850 | EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) { | |
14851 | return this.point(x, y, z, t); | |
14852 | }; | |
14853 | ||
14854 | EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) { | |
14855 | x = new BN(x, 16); | |
14856 | if (!x.red) | |
14857 | x = x.toRed(this.red); | |
14858 | ||
14859 | var x2 = x.redSqr(); | |
14860 | var rhs = this.c2.redSub(this.a.redMul(x2)); | |
14861 | var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2)); | |
14862 | ||
14863 | var y2 = rhs.redMul(lhs.redInvm()); | |
14864 | var y = y2.redSqrt(); | |
14865 | if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) | |
14866 | throw new Error('invalid point'); | |
14867 | ||
14868 | var isOdd = y.fromRed().isOdd(); | |
14869 | if (odd && !isOdd || !odd && isOdd) | |
14870 | y = y.redNeg(); | |
14871 | ||
14872 | return this.point(x, y); | |
14873 | }; | |
14874 | ||
14875 | EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) { | |
14876 | y = new BN(y, 16); | |
14877 | if (!y.red) | |
14878 | y = y.toRed(this.red); | |
14879 | ||
14880 | // x^2 = (y^2 - c^2) / (c^2 d y^2 - a) | |
14881 | var y2 = y.redSqr(); | |
14882 | var lhs = y2.redSub(this.c2); | |
14883 | var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a); | |
14884 | var x2 = lhs.redMul(rhs.redInvm()); | |
14885 | ||
14886 | if (x2.cmp(this.zero) === 0) { | |
14887 | if (odd) | |
14888 | throw new Error('invalid point'); | |
14889 | else | |
14890 | return this.point(this.zero, y); | |
14891 | } | |
14892 | ||
14893 | var x = x2.redSqrt(); | |
14894 | if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) | |
14895 | throw new Error('invalid point'); | |
14896 | ||
14897 | if (x.fromRed().isOdd() !== odd) | |
14898 | x = x.redNeg(); | |
14899 | ||
14900 | return this.point(x, y); | |
14901 | }; | |
14902 | ||
14903 | EdwardsCurve.prototype.validate = function validate(point) { | |
14904 | if (point.isInfinity()) | |
14905 | return true; | |
14906 | ||
14907 | // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2) | |
14908 | point.normalize(); | |
14909 | ||
14910 | var x2 = point.x.redSqr(); | |
14911 | var y2 = point.y.redSqr(); | |
14912 | var lhs = x2.redMul(this.a).redAdd(y2); | |
14913 | var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2))); | |
14914 | ||
14915 | return lhs.cmp(rhs) === 0; | |
14916 | }; | |
14917 | ||
14918 | function Point(curve, x, y, z, t) { | |
14919 | Base.BasePoint.call(this, curve, 'projective'); | |
14920 | if (x === null && y === null && z === null) { | |
14921 | this.x = this.curve.zero; | |
14922 | this.y = this.curve.one; | |
14923 | this.z = this.curve.one; | |
14924 | this.t = this.curve.zero; | |
14925 | this.zOne = true; | |
14926 | } else { | |
14927 | this.x = new BN(x, 16); | |
14928 | this.y = new BN(y, 16); | |
14929 | this.z = z ? new BN(z, 16) : this.curve.one; | |
14930 | this.t = t && new BN(t, 16); | |
14931 | if (!this.x.red) | |
14932 | this.x = this.x.toRed(this.curve.red); | |
14933 | if (!this.y.red) | |
14934 | this.y = this.y.toRed(this.curve.red); | |
14935 | if (!this.z.red) | |
14936 | this.z = this.z.toRed(this.curve.red); | |
14937 | if (this.t && !this.t.red) | |
14938 | this.t = this.t.toRed(this.curve.red); | |
14939 | this.zOne = this.z === this.curve.one; | |
14940 | ||
14941 | // Use extended coordinates | |
14942 | if (this.curve.extended && !this.t) { | |
14943 | this.t = this.x.redMul(this.y); | |
14944 | if (!this.zOne) | |
14945 | this.t = this.t.redMul(this.z.redInvm()); | |
14946 | } | |
14947 | } | |
14948 | } | |
14949 | inherits(Point, Base.BasePoint); | |
14950 | ||
14951 | EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) { | |
14952 | return Point.fromJSON(this, obj); | |
14953 | }; | |
14954 | ||
14955 | EdwardsCurve.prototype.point = function point(x, y, z, t) { | |
14956 | return new Point(this, x, y, z, t); | |
14957 | }; | |
14958 | ||
14959 | Point.fromJSON = function fromJSON(curve, obj) { | |
14960 | return new Point(curve, obj[0], obj[1], obj[2]); | |
14961 | }; | |
14962 | ||
14963 | Point.prototype.inspect = function inspect() { | |
14964 | if (this.isInfinity()) | |
14965 | return '<EC Point Infinity>'; | |
14966 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + | |
14967 | ' y: ' + this.y.fromRed().toString(16, 2) + | |
14968 | ' z: ' + this.z.fromRed().toString(16, 2) + '>'; | |
14969 | }; | |
14970 | ||
14971 | Point.prototype.isInfinity = function isInfinity() { | |
14972 | // XXX This code assumes that zero is always zero in red | |
14973 | return this.x.cmpn(0) === 0 && | |
14974 | (this.y.cmp(this.z) === 0 || | |
14975 | (this.zOne && this.y.cmp(this.curve.c) === 0)); | |
14976 | }; | |
14977 | ||
14978 | Point.prototype._extDbl = function _extDbl() { | |
14979 | // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html | |
14980 | // #doubling-dbl-2008-hwcd | |
14981 | // 4M + 4S | |
14982 | ||
14983 | // A = X1^2 | |
14984 | var a = this.x.redSqr(); | |
14985 | // B = Y1^2 | |
14986 | var b = this.y.redSqr(); | |
14987 | // C = 2 * Z1^2 | |
14988 | var c = this.z.redSqr(); | |
14989 | c = c.redIAdd(c); | |
14990 | // D = a * A | |
14991 | var d = this.curve._mulA(a); | |
14992 | // E = (X1 + Y1)^2 - A - B | |
14993 | var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b); | |
14994 | // G = D + B | |
14995 | var g = d.redAdd(b); | |
14996 | // F = G - C | |
14997 | var f = g.redSub(c); | |
14998 | // H = D - B | |
14999 | var h = d.redSub(b); | |
15000 | // X3 = E * F | |
15001 | var nx = e.redMul(f); | |
15002 | // Y3 = G * H | |
15003 | var ny = g.redMul(h); | |
15004 | // T3 = E * H | |
15005 | var nt = e.redMul(h); | |
15006 | // Z3 = F * G | |
15007 | var nz = f.redMul(g); | |
15008 | return this.curve.point(nx, ny, nz, nt); | |
15009 | }; | |
15010 | ||
15011 | Point.prototype._projDbl = function _projDbl() { | |
15012 | // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html | |
15013 | // #doubling-dbl-2008-bbjlp | |
15014 | // #doubling-dbl-2007-bl | |
15015 | // and others | |
15016 | // Generally 3M + 4S or 2M + 4S | |
15017 | ||
15018 | // B = (X1 + Y1)^2 | |
15019 | var b = this.x.redAdd(this.y).redSqr(); | |
15020 | // C = X1^2 | |
15021 | var c = this.x.redSqr(); | |
15022 | // D = Y1^2 | |
15023 | var d = this.y.redSqr(); | |
15024 | ||
15025 | var nx; | |
15026 | var ny; | |
15027 | var nz; | |
15028 | if (this.curve.twisted) { | |
15029 | // E = a * C | |
15030 | var e = this.curve._mulA(c); | |
15031 | // F = E + D | |
15032 | var f = e.redAdd(d); | |
15033 | if (this.zOne) { | |
15034 | // X3 = (B - C - D) * (F - 2) | |
15035 | nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two)); | |
15036 | // Y3 = F * (E - D) | |
15037 | ny = f.redMul(e.redSub(d)); | |
15038 | // Z3 = F^2 - 2 * F | |
15039 | nz = f.redSqr().redSub(f).redSub(f); | |
15040 | } else { | |
15041 | // H = Z1^2 | |
15042 | var h = this.z.redSqr(); | |
15043 | // J = F - 2 * H | |
15044 | var j = f.redSub(h).redISub(h); | |
15045 | // X3 = (B-C-D)*J | |
15046 | nx = b.redSub(c).redISub(d).redMul(j); | |
15047 | // Y3 = F * (E - D) | |
15048 | ny = f.redMul(e.redSub(d)); | |
15049 | // Z3 = F * J | |
15050 | nz = f.redMul(j); | |
15051 | } | |
15052 | } else { | |
15053 | // E = C + D | |
15054 | var e = c.redAdd(d); | |
15055 | // H = (c * Z1)^2 | |
15056 | var h = this.curve._mulC(this.z).redSqr(); | |
15057 | // J = E - 2 * H | |
15058 | var j = e.redSub(h).redSub(h); | |
15059 | // X3 = c * (B - E) * J | |
15060 | nx = this.curve._mulC(b.redISub(e)).redMul(j); | |
15061 | // Y3 = c * E * (C - D) | |
15062 | ny = this.curve._mulC(e).redMul(c.redISub(d)); | |
15063 | // Z3 = E * J | |
15064 | nz = e.redMul(j); | |
15065 | } | |
15066 | return this.curve.point(nx, ny, nz); | |
15067 | }; | |
15068 | ||
15069 | Point.prototype.dbl = function dbl() { | |
15070 | if (this.isInfinity()) | |
15071 | return this; | |
15072 | ||
15073 | // Double in extended coordinates | |
15074 | if (this.curve.extended) | |
15075 | return this._extDbl(); | |
15076 | else | |
15077 | return this._projDbl(); | |
15078 | }; | |
15079 | ||
15080 | Point.prototype._extAdd = function _extAdd(p) { | |
15081 | // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html | |
15082 | // #addition-add-2008-hwcd-3 | |
15083 | // 8M | |
15084 | ||
15085 | // A = (Y1 - X1) * (Y2 - X2) | |
15086 | var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x)); | |
15087 | // B = (Y1 + X1) * (Y2 + X2) | |
15088 | var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x)); | |
15089 | // C = T1 * k * T2 | |
15090 | var c = this.t.redMul(this.curve.dd).redMul(p.t); | |
15091 | // D = Z1 * 2 * Z2 | |
15092 | var d = this.z.redMul(p.z.redAdd(p.z)); | |
15093 | // E = B - A | |
15094 | var e = b.redSub(a); | |
15095 | // F = D - C | |
15096 | var f = d.redSub(c); | |
15097 | // G = D + C | |
15098 | var g = d.redAdd(c); | |
15099 | // H = B + A | |
15100 | var h = b.redAdd(a); | |
15101 | // X3 = E * F | |
15102 | var nx = e.redMul(f); | |
15103 | // Y3 = G * H | |
15104 | var ny = g.redMul(h); | |
15105 | // T3 = E * H | |
15106 | var nt = e.redMul(h); | |
15107 | // Z3 = F * G | |
15108 | var nz = f.redMul(g); | |
15109 | return this.curve.point(nx, ny, nz, nt); | |
15110 | }; | |
15111 | ||
15112 | Point.prototype._projAdd = function _projAdd(p) { | |
15113 | // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html | |
15114 | // #addition-add-2008-bbjlp | |
15115 | // #addition-add-2007-bl | |
15116 | // 10M + 1S | |
15117 | ||
15118 | // A = Z1 * Z2 | |
15119 | var a = this.z.redMul(p.z); | |
15120 | // B = A^2 | |
15121 | var b = a.redSqr(); | |
15122 | // C = X1 * X2 | |
15123 | var c = this.x.redMul(p.x); | |
15124 | // D = Y1 * Y2 | |
15125 | var d = this.y.redMul(p.y); | |
15126 | // E = d * C * D | |
15127 | var e = this.curve.d.redMul(c).redMul(d); | |
15128 | // F = B - E | |
15129 | var f = b.redSub(e); | |
15130 | // G = B + E | |
15131 | var g = b.redAdd(e); | |
15132 | // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D) | |
15133 | var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d); | |
15134 | var nx = a.redMul(f).redMul(tmp); | |
15135 | var ny; | |
15136 | var nz; | |
15137 | if (this.curve.twisted) { | |
15138 | // Y3 = A * G * (D - a * C) | |
15139 | ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c))); | |
15140 | // Z3 = F * G | |
15141 | nz = f.redMul(g); | |
15142 | } else { | |
15143 | // Y3 = A * G * (D - C) | |
15144 | ny = a.redMul(g).redMul(d.redSub(c)); | |
15145 | // Z3 = c * F * G | |
15146 | nz = this.curve._mulC(f).redMul(g); | |
15147 | } | |
15148 | return this.curve.point(nx, ny, nz); | |
15149 | }; | |
15150 | ||
15151 | Point.prototype.add = function add(p) { | |
15152 | if (this.isInfinity()) | |
15153 | return p; | |
15154 | if (p.isInfinity()) | |
15155 | return this; | |
15156 | ||
15157 | if (this.curve.extended) | |
15158 | return this._extAdd(p); | |
15159 | else | |
15160 | return this._projAdd(p); | |
15161 | }; | |
15162 | ||
15163 | Point.prototype.mul = function mul(k) { | |
15164 | if (this._hasDoubles(k)) | |
15165 | return this.curve._fixedNafMul(this, k); | |
15166 | else | |
15167 | return this.curve._wnafMul(this, k); | |
15168 | }; | |
15169 | ||
15170 | Point.prototype.mulAdd = function mulAdd(k1, p, k2) { | |
15171 | return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false); | |
15172 | }; | |
15173 | ||
15174 | Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) { | |
15175 | return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true); | |
15176 | }; | |
15177 | ||
15178 | Point.prototype.normalize = function normalize() { | |
15179 | if (this.zOne) | |
15180 | return this; | |
15181 | ||
15182 | // Normalize coordinates | |
15183 | var zi = this.z.redInvm(); | |
15184 | this.x = this.x.redMul(zi); | |
15185 | this.y = this.y.redMul(zi); | |
15186 | if (this.t) | |
15187 | this.t = this.t.redMul(zi); | |
15188 | this.z = this.curve.one; | |
15189 | this.zOne = true; | |
15190 | return this; | |
15191 | }; | |
15192 | ||
15193 | Point.prototype.neg = function neg() { | |
15194 | return this.curve.point(this.x.redNeg(), | |
15195 | this.y, | |
15196 | this.z, | |
15197 | this.t && this.t.redNeg()); | |
15198 | }; | |
15199 | ||
15200 | Point.prototype.getX = function getX() { | |
15201 | this.normalize(); | |
15202 | return this.x.fromRed(); | |
15203 | }; | |
15204 | ||
15205 | Point.prototype.getY = function getY() { | |
15206 | this.normalize(); | |
15207 | return this.y.fromRed(); | |
15208 | }; | |
15209 | ||
15210 | Point.prototype.eq = function eq(other) { | |
15211 | return this === other || | |
15212 | this.getX().cmp(other.getX()) === 0 && | |
15213 | this.getY().cmp(other.getY()) === 0; | |
15214 | }; | |
15215 | ||
15216 | Point.prototype.eqXToP = function eqXToP(x) { | |
15217 | var rx = x.toRed(this.curve.red).redMul(this.z); | |
15218 | if (this.x.cmp(rx) === 0) | |
15219 | return true; | |
15220 | ||
15221 | var xc = x.clone(); | |
15222 | var t = this.curve.redN.redMul(this.z); | |
15223 | for (;;) { | |
15224 | xc.iadd(this.curve.n); | |
15225 | if (xc.cmp(this.curve.p) >= 0) | |
15226 | return false; | |
15227 | ||
15228 | rx.redIAdd(t); | |
15229 | if (this.x.cmp(rx) === 0) | |
15230 | return true; | |
15231 | } | |
15232 | }; | |
15233 | ||
15234 | // Compatibility with BaseCurve | |
15235 | Point.prototype.toP = Point.prototype.normalize; | |
15236 | Point.prototype.mixedAdd = Point.prototype.add; | |
15237 | ||
15238 | },{"../../elliptic":86,"../curve":89,"bn.js":18,"inherits":119}],89:[function(require,module,exports){ | |
15239 | 'use strict'; | |
15240 | ||
15241 | var curve = exports; | |
15242 | ||
15243 | curve.base = require('./base'); | |
15244 | curve.short = require('./short'); | |
15245 | curve.mont = require('./mont'); | |
15246 | curve.edwards = require('./edwards'); | |
15247 | ||
15248 | },{"./base":87,"./edwards":88,"./mont":90,"./short":91}],90:[function(require,module,exports){ | |
15249 | 'use strict'; | |
15250 | ||
15251 | var curve = require('../curve'); | |
15252 | var BN = require('bn.js'); | |
15253 | var inherits = require('inherits'); | |
15254 | var Base = curve.base; | |
15255 | ||
15256 | var elliptic = require('../../elliptic'); | |
15257 | var utils = elliptic.utils; | |
15258 | ||
15259 | function MontCurve(conf) { | |
15260 | Base.call(this, 'mont', conf); | |
15261 | ||
15262 | this.a = new BN(conf.a, 16).toRed(this.red); | |
15263 | this.b = new BN(conf.b, 16).toRed(this.red); | |
15264 | this.i4 = new BN(4).toRed(this.red).redInvm(); | |
15265 | this.two = new BN(2).toRed(this.red); | |
15266 | this.a24 = this.i4.redMul(this.a.redAdd(this.two)); | |
15267 | } | |
15268 | inherits(MontCurve, Base); | |
15269 | module.exports = MontCurve; | |
15270 | ||
15271 | MontCurve.prototype.validate = function validate(point) { | |
15272 | var x = point.normalize().x; | |
15273 | var x2 = x.redSqr(); | |
15274 | var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x); | |
15275 | var y = rhs.redSqrt(); | |
15276 | ||
15277 | return y.redSqr().cmp(rhs) === 0; | |
15278 | }; | |
15279 | ||
15280 | function Point(curve, x, z) { | |
15281 | Base.BasePoint.call(this, curve, 'projective'); | |
15282 | if (x === null && z === null) { | |
15283 | this.x = this.curve.one; | |
15284 | this.z = this.curve.zero; | |
15285 | } else { | |
15286 | this.x = new BN(x, 16); | |
15287 | this.z = new BN(z, 16); | |
15288 | if (!this.x.red) | |
15289 | this.x = this.x.toRed(this.curve.red); | |
15290 | if (!this.z.red) | |
15291 | this.z = this.z.toRed(this.curve.red); | |
15292 | } | |
15293 | } | |
15294 | inherits(Point, Base.BasePoint); | |
15295 | ||
15296 | MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) { | |
15297 | return this.point(utils.toArray(bytes, enc), 1); | |
15298 | }; | |
15299 | ||
15300 | MontCurve.prototype.point = function point(x, z) { | |
15301 | return new Point(this, x, z); | |
15302 | }; | |
15303 | ||
15304 | MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) { | |
15305 | return Point.fromJSON(this, obj); | |
15306 | }; | |
15307 | ||
15308 | Point.prototype.precompute = function precompute() { | |
15309 | // No-op | |
15310 | }; | |
15311 | ||
15312 | Point.prototype._encode = function _encode() { | |
15313 | return this.getX().toArray('be', this.curve.p.byteLength()); | |
15314 | }; | |
15315 | ||
15316 | Point.fromJSON = function fromJSON(curve, obj) { | |
15317 | return new Point(curve, obj[0], obj[1] || curve.one); | |
15318 | }; | |
15319 | ||
15320 | Point.prototype.inspect = function inspect() { | |
15321 | if (this.isInfinity()) | |
15322 | return '<EC Point Infinity>'; | |
15323 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + | |
15324 | ' z: ' + this.z.fromRed().toString(16, 2) + '>'; | |
15325 | }; | |
15326 | ||
15327 | Point.prototype.isInfinity = function isInfinity() { | |
15328 | // XXX This code assumes that zero is always zero in red | |
15329 | return this.z.cmpn(0) === 0; | |
15330 | }; | |
15331 | ||
15332 | Point.prototype.dbl = function dbl() { | |
15333 | // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3 | |
15334 | // 2M + 2S + 4A | |
15335 | ||
15336 | // A = X1 + Z1 | |
15337 | var a = this.x.redAdd(this.z); | |
15338 | // AA = A^2 | |
15339 | var aa = a.redSqr(); | |
15340 | // B = X1 - Z1 | |
15341 | var b = this.x.redSub(this.z); | |
15342 | // BB = B^2 | |
15343 | var bb = b.redSqr(); | |
15344 | // C = AA - BB | |
15345 | var c = aa.redSub(bb); | |
15346 | // X3 = AA * BB | |
15347 | var nx = aa.redMul(bb); | |
15348 | // Z3 = C * (BB + A24 * C) | |
15349 | var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c))); | |
15350 | return this.curve.point(nx, nz); | |
15351 | }; | |
15352 | ||
15353 | Point.prototype.add = function add() { | |
15354 | throw new Error('Not supported on Montgomery curve'); | |
15355 | }; | |
15356 | ||
15357 | Point.prototype.diffAdd = function diffAdd(p, diff) { | |
15358 | // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3 | |
15359 | // 4M + 2S + 6A | |
15360 | ||
15361 | // A = X2 + Z2 | |
15362 | var a = this.x.redAdd(this.z); | |
15363 | // B = X2 - Z2 | |
15364 | var b = this.x.redSub(this.z); | |
15365 | // C = X3 + Z3 | |
15366 | var c = p.x.redAdd(p.z); | |
15367 | // D = X3 - Z3 | |
15368 | var d = p.x.redSub(p.z); | |
15369 | // DA = D * A | |
15370 | var da = d.redMul(a); | |
15371 | // CB = C * B | |
15372 | var cb = c.redMul(b); | |
15373 | // X5 = Z1 * (DA + CB)^2 | |
15374 | var nx = diff.z.redMul(da.redAdd(cb).redSqr()); | |
15375 | // Z5 = X1 * (DA - CB)^2 | |
15376 | var nz = diff.x.redMul(da.redISub(cb).redSqr()); | |
15377 | return this.curve.point(nx, nz); | |
15378 | }; | |
15379 | ||
15380 | Point.prototype.mul = function mul(k) { | |
15381 | var t = k.clone(); | |
15382 | var a = this; // (N / 2) * Q + Q | |
15383 | var b = this.curve.point(null, null); // (N / 2) * Q | |
15384 | var c = this; // Q | |
15385 | ||
15386 | for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) | |
15387 | bits.push(t.andln(1)); | |
15388 | ||
15389 | for (var i = bits.length - 1; i >= 0; i--) { | |
15390 | if (bits[i] === 0) { | |
15391 | // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q | |
15392 | a = a.diffAdd(b, c); | |
15393 | // N * Q = 2 * ((N / 2) * Q + Q)) | |
15394 | b = b.dbl(); | |
15395 | } else { | |
15396 | // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q) | |
15397 | b = a.diffAdd(b, c); | |
15398 | // N * Q + Q = 2 * ((N / 2) * Q + Q) | |
15399 | a = a.dbl(); | |
15400 | } | |
15401 | } | |
15402 | return b; | |
15403 | }; | |
15404 | ||
15405 | Point.prototype.mulAdd = function mulAdd() { | |
15406 | throw new Error('Not supported on Montgomery curve'); | |
15407 | }; | |
15408 | ||
15409 | Point.prototype.jumlAdd = function jumlAdd() { | |
15410 | throw new Error('Not supported on Montgomery curve'); | |
15411 | }; | |
15412 | ||
15413 | Point.prototype.eq = function eq(other) { | |
15414 | return this.getX().cmp(other.getX()) === 0; | |
15415 | }; | |
15416 | ||
15417 | Point.prototype.normalize = function normalize() { | |
15418 | this.x = this.x.redMul(this.z.redInvm()); | |
15419 | this.z = this.curve.one; | |
15420 | return this; | |
15421 | }; | |
15422 | ||
15423 | Point.prototype.getX = function getX() { | |
15424 | // Normalize coordinates | |
15425 | this.normalize(); | |
15426 | ||
15427 | return this.x.fromRed(); | |
15428 | }; | |
15429 | ||
15430 | },{"../../elliptic":86,"../curve":89,"bn.js":18,"inherits":119}],91:[function(require,module,exports){ | |
15431 | 'use strict'; | |
15432 | ||
15433 | var curve = require('../curve'); | |
15434 | var elliptic = require('../../elliptic'); | |
15435 | var BN = require('bn.js'); | |
15436 | var inherits = require('inherits'); | |
15437 | var Base = curve.base; | |
15438 | ||
15439 | var assert = elliptic.utils.assert; | |
15440 | ||
15441 | function ShortCurve(conf) { | |
15442 | Base.call(this, 'short', conf); | |
15443 | ||
15444 | this.a = new BN(conf.a, 16).toRed(this.red); | |
15445 | this.b = new BN(conf.b, 16).toRed(this.red); | |
15446 | this.tinv = this.two.redInvm(); | |
15447 | ||
15448 | this.zeroA = this.a.fromRed().cmpn(0) === 0; | |
15449 | this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0; | |
15450 | ||
15451 | // If the curve is endomorphic, precalculate beta and lambda | |
15452 | this.endo = this._getEndomorphism(conf); | |
15453 | this._endoWnafT1 = new Array(4); | |
15454 | this._endoWnafT2 = new Array(4); | |
15455 | } | |
15456 | inherits(ShortCurve, Base); | |
15457 | module.exports = ShortCurve; | |
15458 | ||
15459 | ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) { | |
15460 | // No efficient endomorphism | |
15461 | if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) | |
15462 | return; | |
15463 | ||
15464 | // Compute beta and lambda, that lambda * P = (beta * Px; Py) | |
15465 | var beta; | |
15466 | var lambda; | |
15467 | if (conf.beta) { | |
15468 | beta = new BN(conf.beta, 16).toRed(this.red); | |
15469 | } else { | |
15470 | var betas = this._getEndoRoots(this.p); | |
15471 | // Choose the smallest beta | |
15472 | beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1]; | |
15473 | beta = beta.toRed(this.red); | |
15474 | } | |
15475 | if (conf.lambda) { | |
15476 | lambda = new BN(conf.lambda, 16); | |
15477 | } else { | |
15478 | // Choose the lambda that is matching selected beta | |
15479 | var lambdas = this._getEndoRoots(this.n); | |
15480 | if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) { | |
15481 | lambda = lambdas[0]; | |
15482 | } else { | |
15483 | lambda = lambdas[1]; | |
15484 | assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0); | |
15485 | } | |
15486 | } | |
15487 | ||
15488 | // Get basis vectors, used for balanced length-two representation | |
15489 | var basis; | |
15490 | if (conf.basis) { | |
15491 | basis = conf.basis.map(function(vec) { | |
15492 | return { | |
15493 | a: new BN(vec.a, 16), | |
15494 | b: new BN(vec.b, 16) | |
15495 | }; | |
15496 | }); | |
15497 | } else { | |
15498 | basis = this._getEndoBasis(lambda); | |
15499 | } | |
15500 | ||
15501 | return { | |
15502 | beta: beta, | |
15503 | lambda: lambda, | |
15504 | basis: basis | |
15505 | }; | |
15506 | }; | |
15507 | ||
15508 | ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) { | |
15509 | // Find roots of for x^2 + x + 1 in F | |
15510 | // Root = (-1 +- Sqrt(-3)) / 2 | |
15511 | // | |
15512 | var red = num === this.p ? this.red : BN.mont(num); | |
15513 | var tinv = new BN(2).toRed(red).redInvm(); | |
15514 | var ntinv = tinv.redNeg(); | |
15515 | ||
15516 | var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv); | |
15517 | ||
15518 | var l1 = ntinv.redAdd(s).fromRed(); | |
15519 | var l2 = ntinv.redSub(s).fromRed(); | |
15520 | return [ l1, l2 ]; | |
15521 | }; | |
15522 | ||
15523 | ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) { | |
15524 | // aprxSqrt >= sqrt(this.n) | |
15525 | var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2)); | |
15526 | ||
15527 | // 3.74 | |
15528 | // Run EGCD, until r(L + 1) < aprxSqrt | |
15529 | var u = lambda; | |
15530 | var v = this.n.clone(); | |
15531 | var x1 = new BN(1); | |
15532 | var y1 = new BN(0); | |
15533 | var x2 = new BN(0); | |
15534 | var y2 = new BN(1); | |
15535 | ||
15536 | // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n) | |
15537 | var a0; | |
15538 | var b0; | |
15539 | // First vector | |
15540 | var a1; | |
15541 | var b1; | |
15542 | // Second vector | |
15543 | var a2; | |
15544 | var b2; | |
15545 | ||
15546 | var prevR; | |
15547 | var i = 0; | |
15548 | var r; | |
15549 | var x; | |
15550 | while (u.cmpn(0) !== 0) { | |
15551 | var q = v.div(u); | |
15552 | r = v.sub(q.mul(u)); | |
15553 | x = x2.sub(q.mul(x1)); | |
15554 | var y = y2.sub(q.mul(y1)); | |
15555 | ||
15556 | if (!a1 && r.cmp(aprxSqrt) < 0) { | |
15557 | a0 = prevR.neg(); | |
15558 | b0 = x1; | |
15559 | a1 = r.neg(); | |
15560 | b1 = x; | |
15561 | } else if (a1 && ++i === 2) { | |
15562 | break; | |
15563 | } | |
15564 | prevR = r; | |
15565 | ||
15566 | v = u; | |
15567 | u = r; | |
15568 | x2 = x1; | |
15569 | x1 = x; | |
15570 | y2 = y1; | |
15571 | y1 = y; | |
15572 | } | |
15573 | a2 = r.neg(); | |
15574 | b2 = x; | |
15575 | ||
15576 | var len1 = a1.sqr().add(b1.sqr()); | |
15577 | var len2 = a2.sqr().add(b2.sqr()); | |
15578 | if (len2.cmp(len1) >= 0) { | |
15579 | a2 = a0; | |
15580 | b2 = b0; | |
15581 | } | |
15582 | ||
15583 | // Normalize signs | |
15584 | if (a1.negative) { | |
15585 | a1 = a1.neg(); | |
15586 | b1 = b1.neg(); | |
15587 | } | |
15588 | if (a2.negative) { | |
15589 | a2 = a2.neg(); | |
15590 | b2 = b2.neg(); | |
15591 | } | |
15592 | ||
15593 | return [ | |
15594 | { a: a1, b: b1 }, | |
15595 | { a: a2, b: b2 } | |
15596 | ]; | |
15597 | }; | |
15598 | ||
15599 | ShortCurve.prototype._endoSplit = function _endoSplit(k) { | |
15600 | var basis = this.endo.basis; | |
15601 | var v1 = basis[0]; | |
15602 | var v2 = basis[1]; | |
15603 | ||
15604 | var c1 = v2.b.mul(k).divRound(this.n); | |
15605 | var c2 = v1.b.neg().mul(k).divRound(this.n); | |
15606 | ||
15607 | var p1 = c1.mul(v1.a); | |
15608 | var p2 = c2.mul(v2.a); | |
15609 | var q1 = c1.mul(v1.b); | |
15610 | var q2 = c2.mul(v2.b); | |
15611 | ||
15612 | // Calculate answer | |
15613 | var k1 = k.sub(p1).sub(p2); | |
15614 | var k2 = q1.add(q2).neg(); | |
15615 | return { k1: k1, k2: k2 }; | |
15616 | }; | |
15617 | ||
15618 | ShortCurve.prototype.pointFromX = function pointFromX(x, odd) { | |
15619 | x = new BN(x, 16); | |
15620 | if (!x.red) | |
15621 | x = x.toRed(this.red); | |
15622 | ||
15623 | var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b); | |
15624 | var y = y2.redSqrt(); | |
15625 | if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) | |
15626 | throw new Error('invalid point'); | |
15627 | ||
15628 | // XXX Is there any way to tell if the number is odd without converting it | |
15629 | // to non-red form? | |
15630 | var isOdd = y.fromRed().isOdd(); | |
15631 | if (odd && !isOdd || !odd && isOdd) | |
15632 | y = y.redNeg(); | |
15633 | ||
15634 | return this.point(x, y); | |
15635 | }; | |
15636 | ||
15637 | ShortCurve.prototype.validate = function validate(point) { | |
15638 | if (point.inf) | |
15639 | return true; | |
15640 | ||
15641 | var x = point.x; | |
15642 | var y = point.y; | |
15643 | ||
15644 | var ax = this.a.redMul(x); | |
15645 | var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b); | |
15646 | return y.redSqr().redISub(rhs).cmpn(0) === 0; | |
15647 | }; | |
15648 | ||
15649 | ShortCurve.prototype._endoWnafMulAdd = | |
15650 | function _endoWnafMulAdd(points, coeffs, jacobianResult) { | |
15651 | var npoints = this._endoWnafT1; | |
15652 | var ncoeffs = this._endoWnafT2; | |
15653 | for (var i = 0; i < points.length; i++) { | |
15654 | var split = this._endoSplit(coeffs[i]); | |
15655 | var p = points[i]; | |
15656 | var beta = p._getBeta(); | |
15657 | ||
15658 | if (split.k1.negative) { | |
15659 | split.k1.ineg(); | |
15660 | p = p.neg(true); | |
15661 | } | |
15662 | if (split.k2.negative) { | |
15663 | split.k2.ineg(); | |
15664 | beta = beta.neg(true); | |
15665 | } | |
15666 | ||
15667 | npoints[i * 2] = p; | |
15668 | npoints[i * 2 + 1] = beta; | |
15669 | ncoeffs[i * 2] = split.k1; | |
15670 | ncoeffs[i * 2 + 1] = split.k2; | |
15671 | } | |
15672 | var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult); | |
15673 | ||
15674 | // Clean-up references to points and coefficients | |
15675 | for (var j = 0; j < i * 2; j++) { | |
15676 | npoints[j] = null; | |
15677 | ncoeffs[j] = null; | |
15678 | } | |
15679 | return res; | |
15680 | }; | |
15681 | ||
15682 | function Point(curve, x, y, isRed) { | |
15683 | Base.BasePoint.call(this, curve, 'affine'); | |
15684 | if (x === null && y === null) { | |
15685 | this.x = null; | |
15686 | this.y = null; | |
15687 | this.inf = true; | |
15688 | } else { | |
15689 | this.x = new BN(x, 16); | |
15690 | this.y = new BN(y, 16); | |
15691 | // Force redgomery representation when loading from JSON | |
15692 | if (isRed) { | |
15693 | this.x.forceRed(this.curve.red); | |
15694 | this.y.forceRed(this.curve.red); | |
15695 | } | |
15696 | if (!this.x.red) | |
15697 | this.x = this.x.toRed(this.curve.red); | |
15698 | if (!this.y.red) | |
15699 | this.y = this.y.toRed(this.curve.red); | |
15700 | this.inf = false; | |
15701 | } | |
15702 | } | |
15703 | inherits(Point, Base.BasePoint); | |
15704 | ||
15705 | ShortCurve.prototype.point = function point(x, y, isRed) { | |
15706 | return new Point(this, x, y, isRed); | |
15707 | }; | |
15708 | ||
15709 | ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) { | |
15710 | return Point.fromJSON(this, obj, red); | |
15711 | }; | |
15712 | ||
15713 | Point.prototype._getBeta = function _getBeta() { | |
15714 | if (!this.curve.endo) | |
15715 | return; | |
15716 | ||
15717 | var pre = this.precomputed; | |
15718 | if (pre && pre.beta) | |
15719 | return pre.beta; | |
15720 | ||
15721 | var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y); | |
15722 | if (pre) { | |
15723 | var curve = this.curve; | |
15724 | var endoMul = function(p) { | |
15725 | return curve.point(p.x.redMul(curve.endo.beta), p.y); | |
15726 | }; | |
15727 | pre.beta = beta; | |
15728 | beta.precomputed = { | |
15729 | beta: null, | |
15730 | naf: pre.naf && { | |
15731 | wnd: pre.naf.wnd, | |
15732 | points: pre.naf.points.map(endoMul) | |
15733 | }, | |
15734 | doubles: pre.doubles && { | |
15735 | step: pre.doubles.step, | |
15736 | points: pre.doubles.points.map(endoMul) | |
15737 | } | |
15738 | }; | |
15739 | } | |
15740 | return beta; | |
15741 | }; | |
15742 | ||
15743 | Point.prototype.toJSON = function toJSON() { | |
15744 | if (!this.precomputed) | |
15745 | return [ this.x, this.y ]; | |
15746 | ||
15747 | return [ this.x, this.y, this.precomputed && { | |
15748 | doubles: this.precomputed.doubles && { | |
15749 | step: this.precomputed.doubles.step, | |
15750 | points: this.precomputed.doubles.points.slice(1) | |
15751 | }, | |
15752 | naf: this.precomputed.naf && { | |
15753 | wnd: this.precomputed.naf.wnd, | |
15754 | points: this.precomputed.naf.points.slice(1) | |
15755 | } | |
15756 | } ]; | |
15757 | }; | |
15758 | ||
15759 | Point.fromJSON = function fromJSON(curve, obj, red) { | |
15760 | if (typeof obj === 'string') | |
15761 | obj = JSON.parse(obj); | |
15762 | var res = curve.point(obj[0], obj[1], red); | |
15763 | if (!obj[2]) | |
15764 | return res; | |
15765 | ||
15766 | function obj2point(obj) { | |
15767 | return curve.point(obj[0], obj[1], red); | |
15768 | } | |
15769 | ||
15770 | var pre = obj[2]; | |
15771 | res.precomputed = { | |
15772 | beta: null, | |
15773 | doubles: pre.doubles && { | |
15774 | step: pre.doubles.step, | |
15775 | points: [ res ].concat(pre.doubles.points.map(obj2point)) | |
15776 | }, | |
15777 | naf: pre.naf && { | |
15778 | wnd: pre.naf.wnd, | |
15779 | points: [ res ].concat(pre.naf.points.map(obj2point)) | |
15780 | } | |
15781 | }; | |
15782 | return res; | |
15783 | }; | |
15784 | ||
15785 | Point.prototype.inspect = function inspect() { | |
15786 | if (this.isInfinity()) | |
15787 | return '<EC Point Infinity>'; | |
15788 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + | |
15789 | ' y: ' + this.y.fromRed().toString(16, 2) + '>'; | |
15790 | }; | |
15791 | ||
15792 | Point.prototype.isInfinity = function isInfinity() { | |
15793 | return this.inf; | |
15794 | }; | |
15795 | ||
15796 | Point.prototype.add = function add(p) { | |
15797 | // O + P = P | |
15798 | if (this.inf) | |
15799 | return p; | |
15800 | ||
15801 | // P + O = P | |
15802 | if (p.inf) | |
15803 | return this; | |
15804 | ||
15805 | // P + P = 2P | |
15806 | if (this.eq(p)) | |
15807 | return this.dbl(); | |
15808 | ||
15809 | // P + (-P) = O | |
15810 | if (this.neg().eq(p)) | |
15811 | return this.curve.point(null, null); | |
15812 | ||
15813 | // P + Q = O | |
15814 | if (this.x.cmp(p.x) === 0) | |
15815 | return this.curve.point(null, null); | |
15816 | ||
15817 | var c = this.y.redSub(p.y); | |
15818 | if (c.cmpn(0) !== 0) | |
15819 | c = c.redMul(this.x.redSub(p.x).redInvm()); | |
15820 | var nx = c.redSqr().redISub(this.x).redISub(p.x); | |
15821 | var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); | |
15822 | return this.curve.point(nx, ny); | |
15823 | }; | |
15824 | ||
15825 | Point.prototype.dbl = function dbl() { | |
15826 | if (this.inf) | |
15827 | return this; | |
15828 | ||
15829 | // 2P = O | |
15830 | var ys1 = this.y.redAdd(this.y); | |
15831 | if (ys1.cmpn(0) === 0) | |
15832 | return this.curve.point(null, null); | |
15833 | ||
15834 | var a = this.curve.a; | |
15835 | ||
15836 | var x2 = this.x.redSqr(); | |
15837 | var dyinv = ys1.redInvm(); | |
15838 | var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv); | |
15839 | ||
15840 | var nx = c.redSqr().redISub(this.x.redAdd(this.x)); | |
15841 | var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); | |
15842 | return this.curve.point(nx, ny); | |
15843 | }; | |
15844 | ||
15845 | Point.prototype.getX = function getX() { | |
15846 | return this.x.fromRed(); | |
15847 | }; | |
15848 | ||
15849 | Point.prototype.getY = function getY() { | |
15850 | return this.y.fromRed(); | |
15851 | }; | |
15852 | ||
15853 | Point.prototype.mul = function mul(k) { | |
15854 | k = new BN(k, 16); | |
15855 | ||
15856 | if (this._hasDoubles(k)) | |
15857 | return this.curve._fixedNafMul(this, k); | |
15858 | else if (this.curve.endo) | |
15859 | return this.curve._endoWnafMulAdd([ this ], [ k ]); | |
15860 | else | |
15861 | return this.curve._wnafMul(this, k); | |
15862 | }; | |
15863 | ||
15864 | Point.prototype.mulAdd = function mulAdd(k1, p2, k2) { | |
15865 | var points = [ this, p2 ]; | |
15866 | var coeffs = [ k1, k2 ]; | |
15867 | if (this.curve.endo) | |
15868 | return this.curve._endoWnafMulAdd(points, coeffs); | |
15869 | else | |
15870 | return this.curve._wnafMulAdd(1, points, coeffs, 2); | |
15871 | }; | |
15872 | ||
15873 | Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) { | |
15874 | var points = [ this, p2 ]; | |
15875 | var coeffs = [ k1, k2 ]; | |
15876 | if (this.curve.endo) | |
15877 | return this.curve._endoWnafMulAdd(points, coeffs, true); | |
15878 | else | |
15879 | return this.curve._wnafMulAdd(1, points, coeffs, 2, true); | |
15880 | }; | |
15881 | ||
15882 | Point.prototype.eq = function eq(p) { | |
15883 | return this === p || | |
15884 | this.inf === p.inf && | |
15885 | (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0); | |
15886 | }; | |
15887 | ||
15888 | Point.prototype.neg = function neg(_precompute) { | |
15889 | if (this.inf) | |
15890 | return this; | |
15891 | ||
15892 | var res = this.curve.point(this.x, this.y.redNeg()); | |
15893 | if (_precompute && this.precomputed) { | |
15894 | var pre = this.precomputed; | |
15895 | var negate = function(p) { | |
15896 | return p.neg(); | |
15897 | }; | |
15898 | res.precomputed = { | |
15899 | naf: pre.naf && { | |
15900 | wnd: pre.naf.wnd, | |
15901 | points: pre.naf.points.map(negate) | |
15902 | }, | |
15903 | doubles: pre.doubles && { | |
15904 | step: pre.doubles.step, | |
15905 | points: pre.doubles.points.map(negate) | |
15906 | } | |
15907 | }; | |
15908 | } | |
15909 | return res; | |
15910 | }; | |
15911 | ||
15912 | Point.prototype.toJ = function toJ() { | |
15913 | if (this.inf) | |
15914 | return this.curve.jpoint(null, null, null); | |
15915 | ||
15916 | var res = this.curve.jpoint(this.x, this.y, this.curve.one); | |
15917 | return res; | |
15918 | }; | |
15919 | ||
15920 | function JPoint(curve, x, y, z) { | |
15921 | Base.BasePoint.call(this, curve, 'jacobian'); | |
15922 | if (x === null && y === null && z === null) { | |
15923 | this.x = this.curve.one; | |
15924 | this.y = this.curve.one; | |
15925 | this.z = new BN(0); | |
15926 | } else { | |
15927 | this.x = new BN(x, 16); | |
15928 | this.y = new BN(y, 16); | |
15929 | this.z = new BN(z, 16); | |
15930 | } | |
15931 | if (!this.x.red) | |
15932 | this.x = this.x.toRed(this.curve.red); | |
15933 | if (!this.y.red) | |
15934 | this.y = this.y.toRed(this.curve.red); | |
15935 | if (!this.z.red) | |
15936 | this.z = this.z.toRed(this.curve.red); | |
15937 | ||
15938 | this.zOne = this.z === this.curve.one; | |
15939 | } | |
15940 | inherits(JPoint, Base.BasePoint); | |
15941 | ||
15942 | ShortCurve.prototype.jpoint = function jpoint(x, y, z) { | |
15943 | return new JPoint(this, x, y, z); | |
15944 | }; | |
15945 | ||
15946 | JPoint.prototype.toP = function toP() { | |
15947 | if (this.isInfinity()) | |
15948 | return this.curve.point(null, null); | |
15949 | ||
15950 | var zinv = this.z.redInvm(); | |
15951 | var zinv2 = zinv.redSqr(); | |
15952 | var ax = this.x.redMul(zinv2); | |
15953 | var ay = this.y.redMul(zinv2).redMul(zinv); | |
15954 | ||
15955 | return this.curve.point(ax, ay); | |
15956 | }; | |
15957 | ||
15958 | JPoint.prototype.neg = function neg() { | |
15959 | return this.curve.jpoint(this.x, this.y.redNeg(), this.z); | |
15960 | }; | |
15961 | ||
15962 | JPoint.prototype.add = function add(p) { | |
15963 | // O + P = P | |
15964 | if (this.isInfinity()) | |
15965 | return p; | |
15966 | ||
15967 | // P + O = P | |
15968 | if (p.isInfinity()) | |
15969 | return this; | |
15970 | ||
15971 | // 12M + 4S + 7A | |
15972 | var pz2 = p.z.redSqr(); | |
15973 | var z2 = this.z.redSqr(); | |
15974 | var u1 = this.x.redMul(pz2); | |
15975 | var u2 = p.x.redMul(z2); | |
15976 | var s1 = this.y.redMul(pz2.redMul(p.z)); | |
15977 | var s2 = p.y.redMul(z2.redMul(this.z)); | |
15978 | ||
15979 | var h = u1.redSub(u2); | |
15980 | var r = s1.redSub(s2); | |
15981 | if (h.cmpn(0) === 0) { | |
15982 | if (r.cmpn(0) !== 0) | |
15983 | return this.curve.jpoint(null, null, null); | |
15984 | else | |
15985 | return this.dbl(); | |
15986 | } | |
15987 | ||
15988 | var h2 = h.redSqr(); | |
15989 | var h3 = h2.redMul(h); | |
15990 | var v = u1.redMul(h2); | |
15991 | ||
15992 | var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); | |
15993 | var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); | |
15994 | var nz = this.z.redMul(p.z).redMul(h); | |
15995 | ||
15996 | return this.curve.jpoint(nx, ny, nz); | |
15997 | }; | |
15998 | ||
15999 | JPoint.prototype.mixedAdd = function mixedAdd(p) { | |
16000 | // O + P = P | |
16001 | if (this.isInfinity()) | |
16002 | return p.toJ(); | |
16003 | ||
16004 | // P + O = P | |
16005 | if (p.isInfinity()) | |
16006 | return this; | |
16007 | ||
16008 | // 8M + 3S + 7A | |
16009 | var z2 = this.z.redSqr(); | |
16010 | var u1 = this.x; | |
16011 | var u2 = p.x.redMul(z2); | |
16012 | var s1 = this.y; | |
16013 | var s2 = p.y.redMul(z2).redMul(this.z); | |
16014 | ||
16015 | var h = u1.redSub(u2); | |
16016 | var r = s1.redSub(s2); | |
16017 | if (h.cmpn(0) === 0) { | |
16018 | if (r.cmpn(0) !== 0) | |
16019 | return this.curve.jpoint(null, null, null); | |
16020 | else | |
16021 | return this.dbl(); | |
16022 | } | |
16023 | ||
16024 | var h2 = h.redSqr(); | |
16025 | var h3 = h2.redMul(h); | |
16026 | var v = u1.redMul(h2); | |
16027 | ||
16028 | var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); | |
16029 | var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); | |
16030 | var nz = this.z.redMul(h); | |
16031 | ||
16032 | return this.curve.jpoint(nx, ny, nz); | |
16033 | }; | |
16034 | ||
16035 | JPoint.prototype.dblp = function dblp(pow) { | |
16036 | if (pow === 0) | |
16037 | return this; | |
16038 | if (this.isInfinity()) | |
16039 | return this; | |
16040 | if (!pow) | |
16041 | return this.dbl(); | |
16042 | ||
16043 | if (this.curve.zeroA || this.curve.threeA) { | |
16044 | var r = this; | |
16045 | for (var i = 0; i < pow; i++) | |
16046 | r = r.dbl(); | |
16047 | return r; | |
16048 | } | |
16049 | ||
16050 | // 1M + 2S + 1A + N * (4S + 5M + 8A) | |
16051 | // N = 1 => 6M + 6S + 9A | |
16052 | var a = this.curve.a; | |
16053 | var tinv = this.curve.tinv; | |
16054 | ||
16055 | var jx = this.x; | |
16056 | var jy = this.y; | |
16057 | var jz = this.z; | |
16058 | var jz4 = jz.redSqr().redSqr(); | |
16059 | ||
16060 | // Reuse results | |
16061 | var jyd = jy.redAdd(jy); | |
16062 | for (var i = 0; i < pow; i++) { | |
16063 | var jx2 = jx.redSqr(); | |
16064 | var jyd2 = jyd.redSqr(); | |
16065 | var jyd4 = jyd2.redSqr(); | |
16066 | var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); | |
16067 | ||
16068 | var t1 = jx.redMul(jyd2); | |
16069 | var nx = c.redSqr().redISub(t1.redAdd(t1)); | |
16070 | var t2 = t1.redISub(nx); | |
16071 | var dny = c.redMul(t2); | |
16072 | dny = dny.redIAdd(dny).redISub(jyd4); | |
16073 | var nz = jyd.redMul(jz); | |
16074 | if (i + 1 < pow) | |
16075 | jz4 = jz4.redMul(jyd4); | |
16076 | ||
16077 | jx = nx; | |
16078 | jz = nz; | |
16079 | jyd = dny; | |
16080 | } | |
16081 | ||
16082 | return this.curve.jpoint(jx, jyd.redMul(tinv), jz); | |
16083 | }; | |
16084 | ||
16085 | JPoint.prototype.dbl = function dbl() { | |
16086 | if (this.isInfinity()) | |
16087 | return this; | |
16088 | ||
16089 | if (this.curve.zeroA) | |
16090 | return this._zeroDbl(); | |
16091 | else if (this.curve.threeA) | |
16092 | return this._threeDbl(); | |
16093 | else | |
16094 | return this._dbl(); | |
16095 | }; | |
16096 | ||
16097 | JPoint.prototype._zeroDbl = function _zeroDbl() { | |
16098 | var nx; | |
16099 | var ny; | |
16100 | var nz; | |
16101 | // Z = 1 | |
16102 | if (this.zOne) { | |
16103 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html | |
16104 | // #doubling-mdbl-2007-bl | |
16105 | // 1M + 5S + 14A | |
16106 | ||
16107 | // XX = X1^2 | |
16108 | var xx = this.x.redSqr(); | |
16109 | // YY = Y1^2 | |
16110 | var yy = this.y.redSqr(); | |
16111 | // YYYY = YY^2 | |
16112 | var yyyy = yy.redSqr(); | |
16113 | // S = 2 * ((X1 + YY)^2 - XX - YYYY) | |
16114 | var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); | |
16115 | s = s.redIAdd(s); | |
16116 | // M = 3 * XX + a; a = 0 | |
16117 | var m = xx.redAdd(xx).redIAdd(xx); | |
16118 | // T = M ^ 2 - 2*S | |
16119 | var t = m.redSqr().redISub(s).redISub(s); | |
16120 | ||
16121 | // 8 * YYYY | |
16122 | var yyyy8 = yyyy.redIAdd(yyyy); | |
16123 | yyyy8 = yyyy8.redIAdd(yyyy8); | |
16124 | yyyy8 = yyyy8.redIAdd(yyyy8); | |
16125 | ||
16126 | // X3 = T | |
16127 | nx = t; | |
16128 | // Y3 = M * (S - T) - 8 * YYYY | |
16129 | ny = m.redMul(s.redISub(t)).redISub(yyyy8); | |
16130 | // Z3 = 2*Y1 | |
16131 | nz = this.y.redAdd(this.y); | |
16132 | } else { | |
16133 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html | |
16134 | // #doubling-dbl-2009-l | |
16135 | // 2M + 5S + 13A | |
16136 | ||
16137 | // A = X1^2 | |
16138 | var a = this.x.redSqr(); | |
16139 | // B = Y1^2 | |
16140 | var b = this.y.redSqr(); | |
16141 | // C = B^2 | |
16142 | var c = b.redSqr(); | |
16143 | // D = 2 * ((X1 + B)^2 - A - C) | |
16144 | var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c); | |
16145 | d = d.redIAdd(d); | |
16146 | // E = 3 * A | |
16147 | var e = a.redAdd(a).redIAdd(a); | |
16148 | // F = E^2 | |
16149 | var f = e.redSqr(); | |
16150 | ||
16151 | // 8 * C | |
16152 | var c8 = c.redIAdd(c); | |
16153 | c8 = c8.redIAdd(c8); | |
16154 | c8 = c8.redIAdd(c8); | |
16155 | ||
16156 | // X3 = F - 2 * D | |
16157 | nx = f.redISub(d).redISub(d); | |
16158 | // Y3 = E * (D - X3) - 8 * C | |
16159 | ny = e.redMul(d.redISub(nx)).redISub(c8); | |
16160 | // Z3 = 2 * Y1 * Z1 | |
16161 | nz = this.y.redMul(this.z); | |
16162 | nz = nz.redIAdd(nz); | |
16163 | } | |
16164 | ||
16165 | return this.curve.jpoint(nx, ny, nz); | |
16166 | }; | |
16167 | ||
16168 | JPoint.prototype._threeDbl = function _threeDbl() { | |
16169 | var nx; | |
16170 | var ny; | |
16171 | var nz; | |
16172 | // Z = 1 | |
16173 | if (this.zOne) { | |
16174 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html | |
16175 | // #doubling-mdbl-2007-bl | |
16176 | // 1M + 5S + 15A | |
16177 | ||
16178 | // XX = X1^2 | |
16179 | var xx = this.x.redSqr(); | |
16180 | // YY = Y1^2 | |
16181 | var yy = this.y.redSqr(); | |
16182 | // YYYY = YY^2 | |
16183 | var yyyy = yy.redSqr(); | |
16184 | // S = 2 * ((X1 + YY)^2 - XX - YYYY) | |
16185 | var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); | |
16186 | s = s.redIAdd(s); | |
16187 | // M = 3 * XX + a | |
16188 | var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a); | |
16189 | // T = M^2 - 2 * S | |
16190 | var t = m.redSqr().redISub(s).redISub(s); | |
16191 | // X3 = T | |
16192 | nx = t; | |
16193 | // Y3 = M * (S - T) - 8 * YYYY | |
16194 | var yyyy8 = yyyy.redIAdd(yyyy); | |
16195 | yyyy8 = yyyy8.redIAdd(yyyy8); | |
16196 | yyyy8 = yyyy8.redIAdd(yyyy8); | |
16197 | ny = m.redMul(s.redISub(t)).redISub(yyyy8); | |
16198 | // Z3 = 2 * Y1 | |
16199 | nz = this.y.redAdd(this.y); | |
16200 | } else { | |
16201 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b | |
16202 | // 3M + 5S | |
16203 | ||
16204 | // delta = Z1^2 | |
16205 | var delta = this.z.redSqr(); | |
16206 | // gamma = Y1^2 | |
16207 | var gamma = this.y.redSqr(); | |
16208 | // beta = X1 * gamma | |
16209 | var beta = this.x.redMul(gamma); | |
16210 | // alpha = 3 * (X1 - delta) * (X1 + delta) | |
16211 | var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta)); | |
16212 | alpha = alpha.redAdd(alpha).redIAdd(alpha); | |
16213 | // X3 = alpha^2 - 8 * beta | |
16214 | var beta4 = beta.redIAdd(beta); | |
16215 | beta4 = beta4.redIAdd(beta4); | |
16216 | var beta8 = beta4.redAdd(beta4); | |
16217 | nx = alpha.redSqr().redISub(beta8); | |
16218 | // Z3 = (Y1 + Z1)^2 - gamma - delta | |
16219 | nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta); | |
16220 | // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2 | |
16221 | var ggamma8 = gamma.redSqr(); | |
16222 | ggamma8 = ggamma8.redIAdd(ggamma8); | |
16223 | ggamma8 = ggamma8.redIAdd(ggamma8); | |
16224 | ggamma8 = ggamma8.redIAdd(ggamma8); | |
16225 | ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8); | |
16226 | } | |
16227 | ||
16228 | return this.curve.jpoint(nx, ny, nz); | |
16229 | }; | |
16230 | ||
16231 | JPoint.prototype._dbl = function _dbl() { | |
16232 | var a = this.curve.a; | |
16233 | ||
16234 | // 4M + 6S + 10A | |
16235 | var jx = this.x; | |
16236 | var jy = this.y; | |
16237 | var jz = this.z; | |
16238 | var jz4 = jz.redSqr().redSqr(); | |
16239 | ||
16240 | var jx2 = jx.redSqr(); | |
16241 | var jy2 = jy.redSqr(); | |
16242 | ||
16243 | var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); | |
16244 | ||
16245 | var jxd4 = jx.redAdd(jx); | |
16246 | jxd4 = jxd4.redIAdd(jxd4); | |
16247 | var t1 = jxd4.redMul(jy2); | |
16248 | var nx = c.redSqr().redISub(t1.redAdd(t1)); | |
16249 | var t2 = t1.redISub(nx); | |
16250 | ||
16251 | var jyd8 = jy2.redSqr(); | |
16252 | jyd8 = jyd8.redIAdd(jyd8); | |
16253 | jyd8 = jyd8.redIAdd(jyd8); | |
16254 | jyd8 = jyd8.redIAdd(jyd8); | |
16255 | var ny = c.redMul(t2).redISub(jyd8); | |
16256 | var nz = jy.redAdd(jy).redMul(jz); | |
16257 | ||
16258 | return this.curve.jpoint(nx, ny, nz); | |
16259 | }; | |
16260 | ||
16261 | JPoint.prototype.trpl = function trpl() { | |
16262 | if (!this.curve.zeroA) | |
16263 | return this.dbl().add(this); | |
16264 | ||
16265 | // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl | |
16266 | // 5M + 10S + ... | |
16267 | ||
16268 | // XX = X1^2 | |
16269 | var xx = this.x.redSqr(); | |
16270 | // YY = Y1^2 | |
16271 | var yy = this.y.redSqr(); | |
16272 | // ZZ = Z1^2 | |
16273 | var zz = this.z.redSqr(); | |
16274 | // YYYY = YY^2 | |
16275 | var yyyy = yy.redSqr(); | |
16276 | // M = 3 * XX + a * ZZ2; a = 0 | |
16277 | var m = xx.redAdd(xx).redIAdd(xx); | |
16278 | // MM = M^2 | |
16279 | var mm = m.redSqr(); | |
16280 | // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM | |
16281 | var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); | |
16282 | e = e.redIAdd(e); | |
16283 | e = e.redAdd(e).redIAdd(e); | |
16284 | e = e.redISub(mm); | |
16285 | // EE = E^2 | |
16286 | var ee = e.redSqr(); | |
16287 | // T = 16*YYYY | |
16288 | var t = yyyy.redIAdd(yyyy); | |
16289 | t = t.redIAdd(t); | |
16290 | t = t.redIAdd(t); | |
16291 | t = t.redIAdd(t); | |
16292 | // U = (M + E)^2 - MM - EE - T | |
16293 | var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t); | |
16294 | // X3 = 4 * (X1 * EE - 4 * YY * U) | |
16295 | var yyu4 = yy.redMul(u); | |
16296 | yyu4 = yyu4.redIAdd(yyu4); | |
16297 | yyu4 = yyu4.redIAdd(yyu4); | |
16298 | var nx = this.x.redMul(ee).redISub(yyu4); | |
16299 | nx = nx.redIAdd(nx); | |
16300 | nx = nx.redIAdd(nx); | |
16301 | // Y3 = 8 * Y1 * (U * (T - U) - E * EE) | |
16302 | var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee))); | |
16303 | ny = ny.redIAdd(ny); | |
16304 | ny = ny.redIAdd(ny); | |
16305 | ny = ny.redIAdd(ny); | |
16306 | // Z3 = (Z1 + E)^2 - ZZ - EE | |
16307 | var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee); | |
16308 | ||
16309 | return this.curve.jpoint(nx, ny, nz); | |
16310 | }; | |
16311 | ||
16312 | JPoint.prototype.mul = function mul(k, kbase) { | |
16313 | k = new BN(k, kbase); | |
16314 | ||
16315 | return this.curve._wnafMul(this, k); | |
16316 | }; | |
16317 | ||
16318 | JPoint.prototype.eq = function eq(p) { | |
16319 | if (p.type === 'affine') | |
16320 | return this.eq(p.toJ()); | |
16321 | ||
16322 | if (this === p) | |
16323 | return true; | |
16324 | ||
16325 | // x1 * z2^2 == x2 * z1^2 | |
16326 | var z2 = this.z.redSqr(); | |
16327 | var pz2 = p.z.redSqr(); | |
16328 | if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) | |
16329 | return false; | |
16330 | ||
16331 | // y1 * z2^3 == y2 * z1^3 | |
16332 | var z3 = z2.redMul(this.z); | |
16333 | var pz3 = pz2.redMul(p.z); | |
16334 | return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0; | |
16335 | }; | |
16336 | ||
16337 | JPoint.prototype.eqXToP = function eqXToP(x) { | |
16338 | var zs = this.z.redSqr(); | |
16339 | var rx = x.toRed(this.curve.red).redMul(zs); | |
16340 | if (this.x.cmp(rx) === 0) | |
16341 | return true; | |
16342 | ||
16343 | var xc = x.clone(); | |
16344 | var t = this.curve.redN.redMul(zs); | |
16345 | for (;;) { | |
16346 | xc.iadd(this.curve.n); | |
16347 | if (xc.cmp(this.curve.p) >= 0) | |
16348 | return false; | |
16349 | ||
16350 | rx.redIAdd(t); | |
16351 | if (this.x.cmp(rx) === 0) | |
16352 | return true; | |
16353 | } | |
16354 | }; | |
16355 | ||
16356 | JPoint.prototype.inspect = function inspect() { | |
16357 | if (this.isInfinity()) | |
16358 | return '<EC JPoint Infinity>'; | |
16359 | return '<EC JPoint x: ' + this.x.toString(16, 2) + | |
16360 | ' y: ' + this.y.toString(16, 2) + | |
16361 | ' z: ' + this.z.toString(16, 2) + '>'; | |
16362 | }; | |
16363 | ||
16364 | JPoint.prototype.isInfinity = function isInfinity() { | |
16365 | // XXX This code assumes that zero is always zero in red | |
16366 | return this.z.cmpn(0) === 0; | |
16367 | }; | |
16368 | ||
16369 | },{"../../elliptic":86,"../curve":89,"bn.js":18,"inherits":119}],92:[function(require,module,exports){ | |
16370 | 'use strict'; | |
16371 | ||
16372 | var curves = exports; | |
16373 | ||
16374 | var hash = require('hash.js'); | |
16375 | var elliptic = require('../elliptic'); | |
16376 | ||
16377 | var assert = elliptic.utils.assert; | |
16378 | ||
16379 | function PresetCurve(options) { | |
16380 | if (options.type === 'short') | |
16381 | this.curve = new elliptic.curve.short(options); | |
16382 | else if (options.type === 'edwards') | |
16383 | this.curve = new elliptic.curve.edwards(options); | |
16384 | else | |
16385 | this.curve = new elliptic.curve.mont(options); | |
16386 | this.g = this.curve.g; | |
16387 | this.n = this.curve.n; | |
16388 | this.hash = options.hash; | |
16389 | ||
16390 | assert(this.g.validate(), 'Invalid curve'); | |
16391 | assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O'); | |
16392 | } | |
16393 | curves.PresetCurve = PresetCurve; | |
16394 | ||
16395 | function defineCurve(name, options) { | |
16396 | Object.defineProperty(curves, name, { | |
16397 | configurable: true, | |
16398 | enumerable: true, | |
16399 | get: function() { | |
16400 | var curve = new PresetCurve(options); | |
16401 | Object.defineProperty(curves, name, { | |
16402 | configurable: true, | |
16403 | enumerable: true, | |
16404 | value: curve | |
16405 | }); | |
16406 | return curve; | |
16407 | } | |
16408 | }); | |
16409 | } | |
16410 | ||
16411 | defineCurve('p192', { | |
16412 | type: 'short', | |
16413 | prime: 'p192', | |
16414 | p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff', | |
16415 | a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc', | |
16416 | b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1', | |
16417 | n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831', | |
16418 | hash: hash.sha256, | |
16419 | gRed: false, | |
16420 | g: [ | |
16421 | '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012', | |
16422 | '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811' | |
16423 | ] | |
16424 | }); | |
16425 | ||
16426 | defineCurve('p224', { | |
16427 | type: 'short', | |
16428 | prime: 'p224', | |
16429 | p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001', | |
16430 | a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe', | |
16431 | b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4', | |
16432 | n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d', | |
16433 | hash: hash.sha256, | |
16434 | gRed: false, | |
16435 | g: [ | |
16436 | 'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21', | |
16437 | 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34' | |
16438 | ] | |
16439 | }); | |
16440 | ||
16441 | defineCurve('p256', { | |
16442 | type: 'short', | |
16443 | prime: null, | |
16444 | p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff', | |
16445 | a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc', | |
16446 | b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b', | |
16447 | n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551', | |
16448 | hash: hash.sha256, | |
16449 | gRed: false, | |
16450 | g: [ | |
16451 | '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296', | |
16452 | '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5' | |
16453 | ] | |
16454 | }); | |
16455 | ||
16456 | defineCurve('p384', { | |
16457 | type: 'short', | |
16458 | prime: null, | |
16459 | p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16460 | 'fffffffe ffffffff 00000000 00000000 ffffffff', | |
16461 | a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16462 | 'fffffffe ffffffff 00000000 00000000 fffffffc', | |
16463 | b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' + | |
16464 | '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef', | |
16465 | n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' + | |
16466 | 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973', | |
16467 | hash: hash.sha384, | |
16468 | gRed: false, | |
16469 | g: [ | |
16470 | 'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' + | |
16471 | '5502f25d bf55296c 3a545e38 72760ab7', | |
16472 | '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' + | |
16473 | '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f' | |
16474 | ] | |
16475 | }); | |
16476 | ||
16477 | defineCurve('p521', { | |
16478 | type: 'short', | |
16479 | prime: null, | |
16480 | p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16481 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16482 | 'ffffffff ffffffff ffffffff ffffffff ffffffff', | |
16483 | a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16484 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16485 | 'ffffffff ffffffff ffffffff ffffffff fffffffc', | |
16486 | b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' + | |
16487 | '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' + | |
16488 | '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00', | |
16489 | n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + | |
16490 | 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' + | |
16491 | 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409', | |
16492 | hash: hash.sha512, | |
16493 | gRed: false, | |
16494 | g: [ | |
16495 | '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' + | |
16496 | '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' + | |
16497 | 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66', | |
16498 | '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' + | |
16499 | '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' + | |
16500 | '3fad0761 353c7086 a272c240 88be9476 9fd16650' | |
16501 | ] | |
16502 | }); | |
16503 | ||
16504 | defineCurve('curve25519', { | |
16505 | type: 'mont', | |
16506 | prime: 'p25519', | |
16507 | p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed', | |
16508 | a: '76d06', | |
16509 | b: '1', | |
16510 | n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed', | |
16511 | hash: hash.sha256, | |
16512 | gRed: false, | |
16513 | g: [ | |
16514 | '9' | |
16515 | ] | |
16516 | }); | |
16517 | ||
16518 | defineCurve('ed25519', { | |
16519 | type: 'edwards', | |
16520 | prime: 'p25519', | |
16521 | p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed', | |
16522 | a: '-1', | |
16523 | c: '1', | |
16524 | // -121665 * (121666^(-1)) (mod P) | |
16525 | d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3', | |
16526 | n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed', | |
16527 | hash: hash.sha256, | |
16528 | gRed: false, | |
16529 | g: [ | |
16530 | '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a', | |
16531 | ||
16532 | // 4/5 | |
16533 | '6666666666666666666666666666666666666666666666666666666666666658' | |
16534 | ] | |
16535 | }); | |
16536 | ||
16537 | var pre; | |
16538 | try { | |
16539 | pre = require('./precomputed/secp256k1'); | |
16540 | } catch (e) { | |
16541 | pre = undefined; | |
16542 | } | |
16543 | ||
16544 | defineCurve('secp256k1', { | |
16545 | type: 'short', | |
16546 | prime: 'k256', | |
16547 | p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f', | |
16548 | a: '0', | |
16549 | b: '7', | |
16550 | n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141', | |
16551 | h: '1', | |
16552 | hash: hash.sha256, | |
16553 | ||
16554 | // Precomputed endomorphism | |
16555 | beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee', | |
16556 | lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72', | |
16557 | basis: [ | |
16558 | { | |
16559 | a: '3086d221a7d46bcde86c90e49284eb15', | |
16560 | b: '-e4437ed6010e88286f547fa90abfe4c3' | |
16561 | }, | |
16562 | { | |
16563 | a: '114ca50f7a8e2f3f657c1108d9d44cfd8', | |
16564 | b: '3086d221a7d46bcde86c90e49284eb15' | |
16565 | } | |
16566 | ], | |
16567 | ||
16568 | gRed: false, | |
16569 | g: [ | |
16570 | '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', | |
16571 | '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8', | |
16572 | pre | |
16573 | ] | |
16574 | }); | |
16575 | ||
16576 | },{"../elliptic":86,"./precomputed/secp256k1":99,"hash.js":105}],93:[function(require,module,exports){ | |
16577 | 'use strict'; | |
16578 | ||
16579 | var BN = require('bn.js'); | |
16580 | var HmacDRBG = require('hmac-drbg'); | |
16581 | var elliptic = require('../../elliptic'); | |
16582 | var utils = elliptic.utils; | |
16583 | var assert = utils.assert; | |
16584 | ||
16585 | var KeyPair = require('./key'); | |
16586 | var Signature = require('./signature'); | |
16587 | ||
16588 | function EC(options) { | |
16589 | if (!(this instanceof EC)) | |
16590 | return new EC(options); | |
16591 | ||
16592 | // Shortcut `elliptic.ec(curve-name)` | |
16593 | if (typeof options === 'string') { | |
16594 | assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options); | |
16595 | ||
16596 | options = elliptic.curves[options]; | |
16597 | } | |
16598 | ||
16599 | // Shortcut for `elliptic.ec(elliptic.curves.curveName)` | |
16600 | if (options instanceof elliptic.curves.PresetCurve) | |
16601 | options = { curve: options }; | |
16602 | ||
16603 | this.curve = options.curve.curve; | |
16604 | this.n = this.curve.n; | |
16605 | this.nh = this.n.ushrn(1); | |
16606 | this.g = this.curve.g; | |
16607 | ||
16608 | // Point on curve | |
16609 | this.g = options.curve.g; | |
16610 | this.g.precompute(options.curve.n.bitLength() + 1); | |
16611 | ||
16612 | // Hash for function for DRBG | |
16613 | this.hash = options.hash || options.curve.hash; | |
16614 | } | |
16615 | module.exports = EC; | |
16616 | ||
16617 | EC.prototype.keyPair = function keyPair(options) { | |
16618 | return new KeyPair(this, options); | |
16619 | }; | |
16620 | ||
16621 | EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) { | |
16622 | return KeyPair.fromPrivate(this, priv, enc); | |
16623 | }; | |
16624 | ||
16625 | EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) { | |
16626 | return KeyPair.fromPublic(this, pub, enc); | |
16627 | }; | |
16628 | ||
16629 | EC.prototype.genKeyPair = function genKeyPair(options) { | |
16630 | if (!options) | |
16631 | options = {}; | |
16632 | ||
16633 | // Instantiate Hmac_DRBG | |
16634 | var drbg = new HmacDRBG({ | |
16635 | hash: this.hash, | |
16636 | pers: options.pers, | |
16637 | persEnc: options.persEnc || 'utf8', | |
16638 | entropy: options.entropy || elliptic.rand(this.hash.hmacStrength), | |
16639 | entropyEnc: options.entropy && options.entropyEnc || 'utf8', | |
16640 | nonce: this.n.toArray() | |
16641 | }); | |
16642 | ||
16643 | var bytes = this.n.byteLength(); | |
16644 | var ns2 = this.n.sub(new BN(2)); | |
16645 | do { | |
16646 | var priv = new BN(drbg.generate(bytes)); | |
16647 | if (priv.cmp(ns2) > 0) | |
16648 | continue; | |
16649 | ||
16650 | priv.iaddn(1); | |
16651 | return this.keyFromPrivate(priv); | |
16652 | } while (true); | |
16653 | }; | |
16654 | ||
16655 | EC.prototype._truncateToN = function truncateToN(msg, truncOnly) { | |
16656 | var delta = msg.byteLength() * 8 - this.n.bitLength(); | |
16657 | if (delta > 0) | |
16658 | msg = msg.ushrn(delta); | |
16659 | if (!truncOnly && msg.cmp(this.n) >= 0) | |
16660 | return msg.sub(this.n); | |
16661 | else | |
16662 | return msg; | |
16663 | }; | |
16664 | ||
16665 | EC.prototype.sign = function sign(msg, key, enc, options) { | |
16666 | if (typeof enc === 'object') { | |
16667 | options = enc; | |
16668 | enc = null; | |
16669 | } | |
16670 | if (!options) | |
16671 | options = {}; | |
16672 | ||
16673 | key = this.keyFromPrivate(key, enc); | |
16674 | msg = this._truncateToN(new BN(msg, 16)); | |
16675 | ||
16676 | // Zero-extend key to provide enough entropy | |
16677 | var bytes = this.n.byteLength(); | |
16678 | var bkey = key.getPrivate().toArray('be', bytes); | |
16679 | ||
16680 | // Zero-extend nonce to have the same byte size as N | |
16681 | var nonce = msg.toArray('be', bytes); | |
16682 | ||
16683 | // Instantiate Hmac_DRBG | |
16684 | var drbg = new HmacDRBG({ | |
16685 | hash: this.hash, | |
16686 | entropy: bkey, | |
16687 | nonce: nonce, | |
16688 | pers: options.pers, | |
16689 | persEnc: options.persEnc || 'utf8' | |
16690 | }); | |
16691 | ||
16692 | // Number of bytes to generate | |
16693 | var ns1 = this.n.sub(new BN(1)); | |
16694 | ||
16695 | for (var iter = 0; true; iter++) { | |
16696 | var k = options.k ? | |
16697 | options.k(iter) : | |
16698 | new BN(drbg.generate(this.n.byteLength())); | |
16699 | k = this._truncateToN(k, true); | |
16700 | if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) | |
16701 | continue; | |
16702 | ||
16703 | var kp = this.g.mul(k); | |
16704 | if (kp.isInfinity()) | |
16705 | continue; | |
16706 | ||
16707 | var kpX = kp.getX(); | |
16708 | var r = kpX.umod(this.n); | |
16709 | if (r.cmpn(0) === 0) | |
16710 | continue; | |
16711 | ||
16712 | var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg)); | |
16713 | s = s.umod(this.n); | |
16714 | if (s.cmpn(0) === 0) | |
16715 | continue; | |
16716 | ||
16717 | var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | | |
16718 | (kpX.cmp(r) !== 0 ? 2 : 0); | |
16719 | ||
16720 | // Use complement of `s`, if it is > `n / 2` | |
16721 | if (options.canonical && s.cmp(this.nh) > 0) { | |
16722 | s = this.n.sub(s); | |
16723 | recoveryParam ^= 1; | |
16724 | } | |
16725 | ||
16726 | return new Signature({ r: r, s: s, recoveryParam: recoveryParam }); | |
16727 | } | |
16728 | }; | |
16729 | ||
16730 | EC.prototype.verify = function verify(msg, signature, key, enc) { | |
16731 | msg = this._truncateToN(new BN(msg, 16)); | |
16732 | key = this.keyFromPublic(key, enc); | |
16733 | signature = new Signature(signature, 'hex'); | |
16734 | ||
16735 | // Perform primitive values validation | |
16736 | var r = signature.r; | |
16737 | var s = signature.s; | |
16738 | if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) | |
16739 | return false; | |
16740 | if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) | |
16741 | return false; | |
16742 | ||
16743 | // Validate signature | |
16744 | var sinv = s.invm(this.n); | |
16745 | var u1 = sinv.mul(msg).umod(this.n); | |
16746 | var u2 = sinv.mul(r).umod(this.n); | |
16747 | ||
16748 | if (!this.curve._maxwellTrick) { | |
16749 | var p = this.g.mulAdd(u1, key.getPublic(), u2); | |
16750 | if (p.isInfinity()) | |
16751 | return false; | |
16752 | ||
16753 | return p.getX().umod(this.n).cmp(r) === 0; | |
16754 | } | |
16755 | ||
16756 | // NOTE: Greg Maxwell's trick, inspired by: | |
16757 | // https://git.io/vad3K | |
16758 | ||
16759 | var p = this.g.jmulAdd(u1, key.getPublic(), u2); | |
16760 | if (p.isInfinity()) | |
16761 | return false; | |
16762 | ||
16763 | // Compare `p.x` of Jacobian point with `r`, | |
16764 | // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the | |
16765 | // inverse of `p.z^2` | |
16766 | return p.eqXToP(r); | |
16767 | }; | |
16768 | ||
16769 | EC.prototype.recoverPubKey = function(msg, signature, j, enc) { | |
16770 | assert((3 & j) === j, 'The recovery param is more than two bits'); | |
16771 | signature = new Signature(signature, enc); | |
16772 | ||
16773 | var n = this.n; | |
16774 | var e = new BN(msg); | |
16775 | var r = signature.r; | |
16776 | var s = signature.s; | |
16777 | ||
16778 | // A set LSB signifies that the y-coordinate is odd | |
16779 | var isYOdd = j & 1; | |
16780 | var isSecondKey = j >> 1; | |
16781 | if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) | |
16782 | throw new Error('Unable to find sencond key candinate'); | |
16783 | ||
16784 | // 1.1. Let x = r + jn. | |
16785 | if (isSecondKey) | |
16786 | r = this.curve.pointFromX(r.add(this.curve.n), isYOdd); | |
16787 | else | |
16788 | r = this.curve.pointFromX(r, isYOdd); | |
16789 | ||
16790 | var rInv = signature.r.invm(n); | |
16791 | var s1 = n.sub(e).mul(rInv).umod(n); | |
16792 | var s2 = s.mul(rInv).umod(n); | |
16793 | ||
16794 | // 1.6.1 Compute Q = r^-1 (sR - eG) | |
16795 | // Q = r^-1 (sR + -eG) | |
16796 | return this.g.mulAdd(s1, r, s2); | |
16797 | }; | |
16798 | ||
16799 | EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) { | |
16800 | signature = new Signature(signature, enc); | |
16801 | if (signature.recoveryParam !== null) | |
16802 | return signature.recoveryParam; | |
16803 | ||
16804 | for (var i = 0; i < 4; i++) { | |
16805 | var Qprime; | |
16806 | try { | |
16807 | Qprime = this.recoverPubKey(e, signature, i); | |
16808 | } catch (e) { | |
16809 | continue; | |
16810 | } | |
16811 | ||
16812 | if (Qprime.eq(Q)) | |
16813 | return i; | |
16814 | } | |
16815 | throw new Error('Unable to find valid recovery factor'); | |
16816 | }; | |
16817 | ||
16818 | },{"../../elliptic":86,"./key":94,"./signature":95,"bn.js":18,"hmac-drbg":117}],94:[function(require,module,exports){ | |
16819 | 'use strict'; | |
16820 | ||
16821 | var BN = require('bn.js'); | |
16822 | var elliptic = require('../../elliptic'); | |
16823 | var utils = elliptic.utils; | |
16824 | var assert = utils.assert; | |
16825 | ||
16826 | function KeyPair(ec, options) { | |
16827 | this.ec = ec; | |
16828 | this.priv = null; | |
16829 | this.pub = null; | |
16830 | ||
16831 | // KeyPair(ec, { priv: ..., pub: ... }) | |
16832 | if (options.priv) | |
16833 | this._importPrivate(options.priv, options.privEnc); | |
16834 | if (options.pub) | |
16835 | this._importPublic(options.pub, options.pubEnc); | |
16836 | } | |
16837 | module.exports = KeyPair; | |
16838 | ||
16839 | KeyPair.fromPublic = function fromPublic(ec, pub, enc) { | |
16840 | if (pub instanceof KeyPair) | |
16841 | return pub; | |
16842 | ||
16843 | return new KeyPair(ec, { | |
16844 | pub: pub, | |
16845 | pubEnc: enc | |
16846 | }); | |
16847 | }; | |
16848 | ||
16849 | KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) { | |
16850 | if (priv instanceof KeyPair) | |
16851 | return priv; | |
16852 | ||
16853 | return new KeyPair(ec, { | |
16854 | priv: priv, | |
16855 | privEnc: enc | |
16856 | }); | |
16857 | }; | |
16858 | ||
16859 | KeyPair.prototype.validate = function validate() { | |
16860 | var pub = this.getPublic(); | |
16861 | ||
16862 | if (pub.isInfinity()) | |
16863 | return { result: false, reason: 'Invalid public key' }; | |
16864 | if (!pub.validate()) | |
16865 | return { result: false, reason: 'Public key is not a point' }; | |
16866 | if (!pub.mul(this.ec.curve.n).isInfinity()) | |
16867 | return { result: false, reason: 'Public key * N != O' }; | |
16868 | ||
16869 | return { result: true, reason: null }; | |
16870 | }; | |
16871 | ||
16872 | KeyPair.prototype.getPublic = function getPublic(compact, enc) { | |
16873 | // compact is optional argument | |
16874 | if (typeof compact === 'string') { | |
16875 | enc = compact; | |
16876 | compact = null; | |
16877 | } | |
16878 | ||
16879 | if (!this.pub) | |
16880 | this.pub = this.ec.g.mul(this.priv); | |
16881 | ||
16882 | if (!enc) | |
16883 | return this.pub; | |
16884 | ||
16885 | return this.pub.encode(enc, compact); | |
16886 | }; | |
16887 | ||
16888 | KeyPair.prototype.getPrivate = function getPrivate(enc) { | |
16889 | if (enc === 'hex') | |
16890 | return this.priv.toString(16, 2); | |
16891 | else | |
16892 | return this.priv; | |
16893 | }; | |
16894 | ||
16895 | KeyPair.prototype._importPrivate = function _importPrivate(key, enc) { | |
16896 | this.priv = new BN(key, enc || 16); | |
16897 | ||
16898 | // Ensure that the priv won't be bigger than n, otherwise we may fail | |
16899 | // in fixed multiplication method | |
16900 | this.priv = this.priv.umod(this.ec.curve.n); | |
16901 | }; | |
16902 | ||
16903 | KeyPair.prototype._importPublic = function _importPublic(key, enc) { | |
16904 | if (key.x || key.y) { | |
16905 | // Montgomery points only have an `x` coordinate. | |
16906 | // Weierstrass/Edwards points on the other hand have both `x` and | |
16907 | // `y` coordinates. | |
16908 | if (this.ec.curve.type === 'mont') { | |
16909 | assert(key.x, 'Need x coordinate'); | |
16910 | } else if (this.ec.curve.type === 'short' || | |
16911 | this.ec.curve.type === 'edwards') { | |
16912 | assert(key.x && key.y, 'Need both x and y coordinate'); | |
16913 | } | |
16914 | this.pub = this.ec.curve.point(key.x, key.y); | |
16915 | return; | |
16916 | } | |
16917 | this.pub = this.ec.curve.decodePoint(key, enc); | |
16918 | }; | |
16919 | ||
16920 | // ECDH | |
16921 | KeyPair.prototype.derive = function derive(pub) { | |
16922 | return pub.mul(this.priv).getX(); | |
16923 | }; | |
16924 | ||
16925 | // ECDSA | |
16926 | KeyPair.prototype.sign = function sign(msg, enc, options) { | |
16927 | return this.ec.sign(msg, this, enc, options); | |
16928 | }; | |
16929 | ||
16930 | KeyPair.prototype.verify = function verify(msg, signature) { | |
16931 | return this.ec.verify(msg, signature, this); | |
16932 | }; | |
16933 | ||
16934 | KeyPair.prototype.inspect = function inspect() { | |
16935 | return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) + | |
16936 | ' pub: ' + (this.pub && this.pub.inspect()) + ' >'; | |
16937 | }; | |
16938 | ||
16939 | },{"../../elliptic":86,"bn.js":18}],95:[function(require,module,exports){ | |
16940 | 'use strict'; | |
16941 | ||
16942 | var BN = require('bn.js'); | |
16943 | ||
16944 | var elliptic = require('../../elliptic'); | |
16945 | var utils = elliptic.utils; | |
16946 | var assert = utils.assert; | |
16947 | ||
16948 | function Signature(options, enc) { | |
16949 | if (options instanceof Signature) | |
16950 | return options; | |
16951 | ||
16952 | if (this._importDER(options, enc)) | |
16953 | return; | |
16954 | ||
16955 | assert(options.r && options.s, 'Signature without r or s'); | |
16956 | this.r = new BN(options.r, 16); | |
16957 | this.s = new BN(options.s, 16); | |
16958 | if (options.recoveryParam === undefined) | |
16959 | this.recoveryParam = null; | |
16960 | else | |
16961 | this.recoveryParam = options.recoveryParam; | |
16962 | } | |
16963 | module.exports = Signature; | |
16964 | ||
16965 | function Position() { | |
16966 | this.place = 0; | |
16967 | } | |
16968 | ||
16969 | function getLength(buf, p) { | |
16970 | var initial = buf[p.place++]; | |
16971 | if (!(initial & 0x80)) { | |
16972 | return initial; | |
16973 | } | |
16974 | var octetLen = initial & 0xf; | |
16975 | var val = 0; | |
16976 | for (var i = 0, off = p.place; i < octetLen; i++, off++) { | |
16977 | val <<= 8; | |
16978 | val |= buf[off]; | |
16979 | } | |
16980 | p.place = off; | |
16981 | return val; | |
16982 | } | |
16983 | ||
16984 | function rmPadding(buf) { | |
16985 | var i = 0; | |
16986 | var len = buf.length - 1; | |
16987 | while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) { | |
16988 | i++; | |
16989 | } | |
16990 | if (i === 0) { | |
16991 | return buf; | |
16992 | } | |
16993 | return buf.slice(i); | |
16994 | } | |
16995 | ||
16996 | Signature.prototype._importDER = function _importDER(data, enc) { | |
16997 | data = utils.toArray(data, enc); | |
16998 | var p = new Position(); | |
16999 | if (data[p.place++] !== 0x30) { | |
17000 | return false; | |
17001 | } | |
17002 | var len = getLength(data, p); | |
17003 | if ((len + p.place) !== data.length) { | |
17004 | return false; | |
17005 | } | |
17006 | if (data[p.place++] !== 0x02) { | |
17007 | return false; | |
17008 | } | |
17009 | var rlen = getLength(data, p); | |
17010 | var r = data.slice(p.place, rlen + p.place); | |
17011 | p.place += rlen; | |
17012 | if (data[p.place++] !== 0x02) { | |
17013 | return false; | |
17014 | } | |
17015 | var slen = getLength(data, p); | |
17016 | if (data.length !== slen + p.place) { | |
17017 | return false; | |
17018 | } | |
17019 | var s = data.slice(p.place, slen + p.place); | |
17020 | if (r[0] === 0 && (r[1] & 0x80)) { | |
17021 | r = r.slice(1); | |
17022 | } | |
17023 | if (s[0] === 0 && (s[1] & 0x80)) { | |
17024 | s = s.slice(1); | |
17025 | } | |
17026 | ||
17027 | this.r = new BN(r); | |
17028 | this.s = new BN(s); | |
17029 | this.recoveryParam = null; | |
17030 | ||
17031 | return true; | |
17032 | }; | |
17033 | ||
17034 | function constructLength(arr, len) { | |
17035 | if (len < 0x80) { | |
17036 | arr.push(len); | |
17037 | return; | |
17038 | } | |
17039 | var octets = 1 + (Math.log(len) / Math.LN2 >>> 3); | |
17040 | arr.push(octets | 0x80); | |
17041 | while (--octets) { | |
17042 | arr.push((len >>> (octets << 3)) & 0xff); | |
17043 | } | |
17044 | arr.push(len); | |
17045 | } | |
17046 | ||
17047 | Signature.prototype.toDER = function toDER(enc) { | |
17048 | var r = this.r.toArray(); | |
17049 | var s = this.s.toArray(); | |
17050 | ||
17051 | // Pad values | |
17052 | if (r[0] & 0x80) | |
17053 | r = [ 0 ].concat(r); | |
17054 | // Pad values | |
17055 | if (s[0] & 0x80) | |
17056 | s = [ 0 ].concat(s); | |
17057 | ||
17058 | r = rmPadding(r); | |
17059 | s = rmPadding(s); | |
17060 | ||
17061 | while (!s[0] && !(s[1] & 0x80)) { | |
17062 | s = s.slice(1); | |
17063 | } | |
17064 | var arr = [ 0x02 ]; | |
17065 | constructLength(arr, r.length); | |
17066 | arr = arr.concat(r); | |
17067 | arr.push(0x02); | |
17068 | constructLength(arr, s.length); | |
17069 | var backHalf = arr.concat(s); | |
17070 | var res = [ 0x30 ]; | |
17071 | constructLength(res, backHalf.length); | |
17072 | res = res.concat(backHalf); | |
17073 | return utils.encode(res, enc); | |
17074 | }; | |
17075 | ||
17076 | },{"../../elliptic":86,"bn.js":18}],96:[function(require,module,exports){ | |
17077 | 'use strict'; | |
17078 | ||
17079 | var hash = require('hash.js'); | |
17080 | var elliptic = require('../../elliptic'); | |
17081 | var utils = elliptic.utils; | |
17082 | var assert = utils.assert; | |
17083 | var parseBytes = utils.parseBytes; | |
17084 | var KeyPair = require('./key'); | |
17085 | var Signature = require('./signature'); | |
17086 | ||
17087 | function EDDSA(curve) { | |
17088 | assert(curve === 'ed25519', 'only tested with ed25519 so far'); | |
17089 | ||
17090 | if (!(this instanceof EDDSA)) | |
17091 | return new EDDSA(curve); | |
17092 | ||
17093 | var curve = elliptic.curves[curve].curve; | |
17094 | this.curve = curve; | |
17095 | this.g = curve.g; | |
17096 | this.g.precompute(curve.n.bitLength() + 1); | |
17097 | ||
17098 | this.pointClass = curve.point().constructor; | |
17099 | this.encodingLength = Math.ceil(curve.n.bitLength() / 8); | |
17100 | this.hash = hash.sha512; | |
17101 | } | |
17102 | ||
17103 | module.exports = EDDSA; | |
17104 | ||
17105 | /** | |
17106 | * @param {Array|String} message - message bytes | |
17107 | * @param {Array|String|KeyPair} secret - secret bytes or a keypair | |
17108 | * @returns {Signature} - signature | |
17109 | */ | |
17110 | EDDSA.prototype.sign = function sign(message, secret) { | |
17111 | message = parseBytes(message); | |
17112 | var key = this.keyFromSecret(secret); | |
17113 | var r = this.hashInt(key.messagePrefix(), message); | |
17114 | var R = this.g.mul(r); | |
17115 | var Rencoded = this.encodePoint(R); | |
17116 | var s_ = this.hashInt(Rencoded, key.pubBytes(), message) | |
17117 | .mul(key.priv()); | |
17118 | var S = r.add(s_).umod(this.curve.n); | |
17119 | return this.makeSignature({ R: R, S: S, Rencoded: Rencoded }); | |
17120 | }; | |
17121 | ||
17122 | /** | |
17123 | * @param {Array} message - message bytes | |
17124 | * @param {Array|String|Signature} sig - sig bytes | |
17125 | * @param {Array|String|Point|KeyPair} pub - public key | |
17126 | * @returns {Boolean} - true if public key matches sig of message | |
17127 | */ | |
17128 | EDDSA.prototype.verify = function verify(message, sig, pub) { | |
17129 | message = parseBytes(message); | |
17130 | sig = this.makeSignature(sig); | |
17131 | var key = this.keyFromPublic(pub); | |
17132 | var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message); | |
17133 | var SG = this.g.mul(sig.S()); | |
17134 | var RplusAh = sig.R().add(key.pub().mul(h)); | |
17135 | return RplusAh.eq(SG); | |
17136 | }; | |
17137 | ||
17138 | EDDSA.prototype.hashInt = function hashInt() { | |
17139 | var hash = this.hash(); | |
17140 | for (var i = 0; i < arguments.length; i++) | |
17141 | hash.update(arguments[i]); | |
17142 | return utils.intFromLE(hash.digest()).umod(this.curve.n); | |
17143 | }; | |
17144 | ||
17145 | EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) { | |
17146 | return KeyPair.fromPublic(this, pub); | |
17147 | }; | |
17148 | ||
17149 | EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) { | |
17150 | return KeyPair.fromSecret(this, secret); | |
17151 | }; | |
17152 | ||
17153 | EDDSA.prototype.makeSignature = function makeSignature(sig) { | |
17154 | if (sig instanceof Signature) | |
17155 | return sig; | |
17156 | return new Signature(this, sig); | |
17157 | }; | |
17158 | ||
17159 | /** | |
17160 | * * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2 | |
17161 | * | |
17162 | * EDDSA defines methods for encoding and decoding points and integers. These are | |
17163 | * helper convenience methods, that pass along to utility functions implied | |
17164 | * parameters. | |
17165 | * | |
17166 | */ | |
17167 | EDDSA.prototype.encodePoint = function encodePoint(point) { | |
17168 | var enc = point.getY().toArray('le', this.encodingLength); | |
17169 | enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0; | |
17170 | return enc; | |
17171 | }; | |
17172 | ||
17173 | EDDSA.prototype.decodePoint = function decodePoint(bytes) { | |
17174 | bytes = utils.parseBytes(bytes); | |
17175 | ||
17176 | var lastIx = bytes.length - 1; | |
17177 | var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80); | |
17178 | var xIsOdd = (bytes[lastIx] & 0x80) !== 0; | |
17179 | ||
17180 | var y = utils.intFromLE(normed); | |
17181 | return this.curve.pointFromY(y, xIsOdd); | |
17182 | }; | |
17183 | ||
17184 | EDDSA.prototype.encodeInt = function encodeInt(num) { | |
17185 | return num.toArray('le', this.encodingLength); | |
17186 | }; | |
17187 | ||
17188 | EDDSA.prototype.decodeInt = function decodeInt(bytes) { | |
17189 | return utils.intFromLE(bytes); | |
17190 | }; | |
17191 | ||
17192 | EDDSA.prototype.isPoint = function isPoint(val) { | |
17193 | return val instanceof this.pointClass; | |
17194 | }; | |
17195 | ||
17196 | },{"../../elliptic":86,"./key":97,"./signature":98,"hash.js":105}],97:[function(require,module,exports){ | |
17197 | 'use strict'; | |
17198 | ||
17199 | var elliptic = require('../../elliptic'); | |
17200 | var utils = elliptic.utils; | |
17201 | var assert = utils.assert; | |
17202 | var parseBytes = utils.parseBytes; | |
17203 | var cachedProperty = utils.cachedProperty; | |
17204 | ||
17205 | /** | |
17206 | * @param {EDDSA} eddsa - instance | |
17207 | * @param {Object} params - public/private key parameters | |
17208 | * | |
17209 | * @param {Array<Byte>} [params.secret] - secret seed bytes | |
17210 | * @param {Point} [params.pub] - public key point (aka `A` in eddsa terms) | |
17211 | * @param {Array<Byte>} [params.pub] - public key point encoded as bytes | |
17212 | * | |
17213 | */ | |
17214 | function KeyPair(eddsa, params) { | |
17215 | this.eddsa = eddsa; | |
17216 | this._secret = parseBytes(params.secret); | |
17217 | if (eddsa.isPoint(params.pub)) | |
17218 | this._pub = params.pub; | |
17219 | else | |
17220 | this._pubBytes = parseBytes(params.pub); | |
17221 | } | |
17222 | ||
17223 | KeyPair.fromPublic = function fromPublic(eddsa, pub) { | |
17224 | if (pub instanceof KeyPair) | |
17225 | return pub; | |
17226 | return new KeyPair(eddsa, { pub: pub }); | |
17227 | }; | |
17228 | ||
17229 | KeyPair.fromSecret = function fromSecret(eddsa, secret) { | |
17230 | if (secret instanceof KeyPair) | |
17231 | return secret; | |
17232 | return new KeyPair(eddsa, { secret: secret }); | |
17233 | }; | |
17234 | ||
17235 | KeyPair.prototype.secret = function secret() { | |
17236 | return this._secret; | |
17237 | }; | |
17238 | ||
17239 | cachedProperty(KeyPair, 'pubBytes', function pubBytes() { | |
17240 | return this.eddsa.encodePoint(this.pub()); | |
17241 | }); | |
17242 | ||
17243 | cachedProperty(KeyPair, 'pub', function pub() { | |
17244 | if (this._pubBytes) | |
17245 | return this.eddsa.decodePoint(this._pubBytes); | |
17246 | return this.eddsa.g.mul(this.priv()); | |
17247 | }); | |
17248 | ||
17249 | cachedProperty(KeyPair, 'privBytes', function privBytes() { | |
17250 | var eddsa = this.eddsa; | |
17251 | var hash = this.hash(); | |
17252 | var lastIx = eddsa.encodingLength - 1; | |
17253 | ||
17254 | var a = hash.slice(0, eddsa.encodingLength); | |
17255 | a[0] &= 248; | |
17256 | a[lastIx] &= 127; | |
17257 | a[lastIx] |= 64; | |
17258 | ||
17259 | return a; | |
17260 | }); | |
17261 | ||
17262 | cachedProperty(KeyPair, 'priv', function priv() { | |
17263 | return this.eddsa.decodeInt(this.privBytes()); | |
17264 | }); | |
17265 | ||
17266 | cachedProperty(KeyPair, 'hash', function hash() { | |
17267 | return this.eddsa.hash().update(this.secret()).digest(); | |
17268 | }); | |
17269 | ||
17270 | cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() { | |
17271 | return this.hash().slice(this.eddsa.encodingLength); | |
17272 | }); | |
17273 | ||
17274 | KeyPair.prototype.sign = function sign(message) { | |
17275 | assert(this._secret, 'KeyPair can only verify'); | |
17276 | return this.eddsa.sign(message, this); | |
17277 | }; | |
17278 | ||
17279 | KeyPair.prototype.verify = function verify(message, sig) { | |
17280 | return this.eddsa.verify(message, sig, this); | |
17281 | }; | |
17282 | ||
17283 | KeyPair.prototype.getSecret = function getSecret(enc) { | |
17284 | assert(this._secret, 'KeyPair is public only'); | |
17285 | return utils.encode(this.secret(), enc); | |
17286 | }; | |
17287 | ||
17288 | KeyPair.prototype.getPublic = function getPublic(enc) { | |
17289 | return utils.encode(this.pubBytes(), enc); | |
17290 | }; | |
17291 | ||
17292 | module.exports = KeyPair; | |
17293 | ||
17294 | },{"../../elliptic":86}],98:[function(require,module,exports){ | |
17295 | 'use strict'; | |
17296 | ||
17297 | var BN = require('bn.js'); | |
17298 | var elliptic = require('../../elliptic'); | |
17299 | var utils = elliptic.utils; | |
17300 | var assert = utils.assert; | |
17301 | var cachedProperty = utils.cachedProperty; | |
17302 | var parseBytes = utils.parseBytes; | |
17303 | ||
17304 | /** | |
17305 | * @param {EDDSA} eddsa - eddsa instance | |
17306 | * @param {Array<Bytes>|Object} sig - | |
17307 | * @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes | |
17308 | * @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes | |
17309 | * @param {Array<Bytes>} [sig.Rencoded] - R point encoded | |
17310 | * @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded | |
17311 | */ | |
17312 | function Signature(eddsa, sig) { | |
17313 | this.eddsa = eddsa; | |
17314 | ||
17315 | if (typeof sig !== 'object') | |
17316 | sig = parseBytes(sig); | |
17317 | ||
17318 | if (Array.isArray(sig)) { | |
17319 | sig = { | |
17320 | R: sig.slice(0, eddsa.encodingLength), | |
17321 | S: sig.slice(eddsa.encodingLength) | |
17322 | }; | |
17323 | } | |
17324 | ||
17325 | assert(sig.R && sig.S, 'Signature without R or S'); | |
17326 | ||
17327 | if (eddsa.isPoint(sig.R)) | |
17328 | this._R = sig.R; | |
17329 | if (sig.S instanceof BN) | |
17330 | this._S = sig.S; | |
17331 | ||
17332 | this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded; | |
17333 | this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded; | |
17334 | } | |
17335 | ||
17336 | cachedProperty(Signature, 'S', function S() { | |
17337 | return this.eddsa.decodeInt(this.Sencoded()); | |
17338 | }); | |
17339 | ||
17340 | cachedProperty(Signature, 'R', function R() { | |
17341 | return this.eddsa.decodePoint(this.Rencoded()); | |
17342 | }); | |
17343 | ||
17344 | cachedProperty(Signature, 'Rencoded', function Rencoded() { | |
17345 | return this.eddsa.encodePoint(this.R()); | |
17346 | }); | |
17347 | ||
17348 | cachedProperty(Signature, 'Sencoded', function Sencoded() { | |
17349 | return this.eddsa.encodeInt(this.S()); | |
17350 | }); | |
17351 | ||
17352 | Signature.prototype.toBytes = function toBytes() { | |
17353 | return this.Rencoded().concat(this.Sencoded()); | |
17354 | }; | |
17355 | ||
17356 | Signature.prototype.toHex = function toHex() { | |
17357 | return utils.encode(this.toBytes(), 'hex').toUpperCase(); | |
17358 | }; | |
17359 | ||
17360 | module.exports = Signature; | |
17361 | ||
17362 | },{"../../elliptic":86,"bn.js":18}],99:[function(require,module,exports){ | |
17363 | module.exports = { | |
17364 | doubles: { | |
17365 | step: 4, | |
17366 | points: [ | |
17367 | [ | |
17368 | 'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a', | |
17369 | 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821' | |
17370 | ], | |
17371 | [ | |
17372 | '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508', | |
17373 | '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf' | |
17374 | ], | |
17375 | [ | |
17376 | '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739', | |
17377 | 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695' | |
17378 | ], | |
17379 | [ | |
17380 | '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640', | |
17381 | '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9' | |
17382 | ], | |
17383 | [ | |
17384 | '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c', | |
17385 | '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36' | |
17386 | ], | |
17387 | [ | |
17388 | '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda', | |
17389 | '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f' | |
17390 | ], | |
17391 | [ | |
17392 | 'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa', | |
17393 | '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999' | |
17394 | ], | |
17395 | [ | |
17396 | '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0', | |
17397 | 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09' | |
17398 | ], | |
17399 | [ | |
17400 | 'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d', | |
17401 | '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d' | |
17402 | ], | |
17403 | [ | |
17404 | 'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d', | |
17405 | 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088' | |
17406 | ], | |
17407 | [ | |
17408 | 'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1', | |
17409 | '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d' | |
17410 | ], | |
17411 | [ | |
17412 | '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0', | |
17413 | '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8' | |
17414 | ], | |
17415 | [ | |
17416 | '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047', | |
17417 | '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a' | |
17418 | ], | |
17419 | [ | |
17420 | '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862', | |
17421 | '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453' | |
17422 | ], | |
17423 | [ | |
17424 | '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7', | |
17425 | '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160' | |
17426 | ], | |
17427 | [ | |
17428 | '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd', | |
17429 | '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0' | |
17430 | ], | |
17431 | [ | |
17432 | '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83', | |
17433 | '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6' | |
17434 | ], | |
17435 | [ | |
17436 | '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a', | |
17437 | '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589' | |
17438 | ], | |
17439 | [ | |
17440 | '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8', | |
17441 | 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17' | |
17442 | ], | |
17443 | [ | |
17444 | 'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d', | |
17445 | '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda' | |
17446 | ], | |
17447 | [ | |
17448 | 'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725', | |
17449 | '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd' | |
17450 | ], | |
17451 | [ | |
17452 | '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754', | |
17453 | '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2' | |
17454 | ], | |
17455 | [ | |
17456 | '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c', | |
17457 | '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6' | |
17458 | ], | |
17459 | [ | |
17460 | 'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6', | |
17461 | '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f' | |
17462 | ], | |
17463 | [ | |
17464 | '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39', | |
17465 | 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01' | |
17466 | ], | |
17467 | [ | |
17468 | 'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891', | |
17469 | '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3' | |
17470 | ], | |
17471 | [ | |
17472 | 'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b', | |
17473 | 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f' | |
17474 | ], | |
17475 | [ | |
17476 | 'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03', | |
17477 | '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7' | |
17478 | ], | |
17479 | [ | |
17480 | 'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d', | |
17481 | 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78' | |
17482 | ], | |
17483 | [ | |
17484 | 'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070', | |
17485 | '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1' | |
17486 | ], | |
17487 | [ | |
17488 | '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4', | |
17489 | 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150' | |
17490 | ], | |
17491 | [ | |
17492 | '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da', | |
17493 | '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82' | |
17494 | ], | |
17495 | [ | |
17496 | 'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11', | |
17497 | '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc' | |
17498 | ], | |
17499 | [ | |
17500 | '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e', | |
17501 | 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b' | |
17502 | ], | |
17503 | [ | |
17504 | 'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41', | |
17505 | '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51' | |
17506 | ], | |
17507 | [ | |
17508 | 'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef', | |
17509 | '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45' | |
17510 | ], | |
17511 | [ | |
17512 | 'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8', | |
17513 | 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120' | |
17514 | ], | |
17515 | [ | |
17516 | '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d', | |
17517 | '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84' | |
17518 | ], | |
17519 | [ | |
17520 | '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96', | |
17521 | '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d' | |
17522 | ], | |
17523 | [ | |
17524 | '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd', | |
17525 | 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d' | |
17526 | ], | |
17527 | [ | |
17528 | '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5', | |
17529 | '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8' | |
17530 | ], | |
17531 | [ | |
17532 | 'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266', | |
17533 | '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8' | |
17534 | ], | |
17535 | [ | |
17536 | '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71', | |
17537 | '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac' | |
17538 | ], | |
17539 | [ | |
17540 | '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac', | |
17541 | 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f' | |
17542 | ], | |
17543 | [ | |
17544 | '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751', | |
17545 | '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962' | |
17546 | ], | |
17547 | [ | |
17548 | 'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e', | |
17549 | '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907' | |
17550 | ], | |
17551 | [ | |
17552 | '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241', | |
17553 | 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec' | |
17554 | ], | |
17555 | [ | |
17556 | 'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3', | |
17557 | 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d' | |
17558 | ], | |
17559 | [ | |
17560 | 'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f', | |
17561 | '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414' | |
17562 | ], | |
17563 | [ | |
17564 | '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19', | |
17565 | 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd' | |
17566 | ], | |
17567 | [ | |
17568 | '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be', | |
17569 | 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0' | |
17570 | ], | |
17571 | [ | |
17572 | 'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9', | |
17573 | '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811' | |
17574 | ], | |
17575 | [ | |
17576 | 'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2', | |
17577 | '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1' | |
17578 | ], | |
17579 | [ | |
17580 | 'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13', | |
17581 | '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c' | |
17582 | ], | |
17583 | [ | |
17584 | '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c', | |
17585 | 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73' | |
17586 | ], | |
17587 | [ | |
17588 | '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba', | |
17589 | '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd' | |
17590 | ], | |
17591 | [ | |
17592 | 'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151', | |
17593 | 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405' | |
17594 | ], | |
17595 | [ | |
17596 | '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073', | |
17597 | 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589' | |
17598 | ], | |
17599 | [ | |
17600 | '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458', | |
17601 | '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e' | |
17602 | ], | |
17603 | [ | |
17604 | '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b', | |
17605 | '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27' | |
17606 | ], | |
17607 | [ | |
17608 | 'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366', | |
17609 | 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1' | |
17610 | ], | |
17611 | [ | |
17612 | '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa', | |
17613 | '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482' | |
17614 | ], | |
17615 | [ | |
17616 | '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0', | |
17617 | '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945' | |
17618 | ], | |
17619 | [ | |
17620 | 'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787', | |
17621 | '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573' | |
17622 | ], | |
17623 | [ | |
17624 | 'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e', | |
17625 | 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82' | |
17626 | ] | |
17627 | ] | |
17628 | }, | |
17629 | naf: { | |
17630 | wnd: 7, | |
17631 | points: [ | |
17632 | [ | |
17633 | 'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9', | |
17634 | '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672' | |
17635 | ], | |
17636 | [ | |
17637 | '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4', | |
17638 | 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6' | |
17639 | ], | |
17640 | [ | |
17641 | '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc', | |
17642 | '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da' | |
17643 | ], | |
17644 | [ | |
17645 | 'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe', | |
17646 | 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37' | |
17647 | ], | |
17648 | [ | |
17649 | '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb', | |
17650 | 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b' | |
17651 | ], | |
17652 | [ | |
17653 | 'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8', | |
17654 | 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81' | |
17655 | ], | |
17656 | [ | |
17657 | 'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e', | |
17658 | '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58' | |
17659 | ], | |
17660 | [ | |
17661 | 'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34', | |
17662 | '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77' | |
17663 | ], | |
17664 | [ | |
17665 | '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c', | |
17666 | '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a' | |
17667 | ], | |
17668 | [ | |
17669 | '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5', | |
17670 | '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c' | |
17671 | ], | |
17672 | [ | |
17673 | '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f', | |
17674 | '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67' | |
17675 | ], | |
17676 | [ | |
17677 | '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714', | |
17678 | '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402' | |
17679 | ], | |
17680 | [ | |
17681 | 'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729', | |
17682 | 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55' | |
17683 | ], | |
17684 | [ | |
17685 | 'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db', | |
17686 | '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482' | |
17687 | ], | |
17688 | [ | |
17689 | '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4', | |
17690 | 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82' | |
17691 | ], | |
17692 | [ | |
17693 | '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5', | |
17694 | 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396' | |
17695 | ], | |
17696 | [ | |
17697 | '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479', | |
17698 | '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49' | |
17699 | ], | |
17700 | [ | |
17701 | '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d', | |
17702 | '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf' | |
17703 | ], | |
17704 | [ | |
17705 | '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f', | |
17706 | '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a' | |
17707 | ], | |
17708 | [ | |
17709 | '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb', | |
17710 | 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7' | |
17711 | ], | |
17712 | [ | |
17713 | 'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9', | |
17714 | 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933' | |
17715 | ], | |
17716 | [ | |
17717 | '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963', | |
17718 | '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a' | |
17719 | ], | |
17720 | [ | |
17721 | '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74', | |
17722 | '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6' | |
17723 | ], | |
17724 | [ | |
17725 | 'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530', | |
17726 | 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37' | |
17727 | ], | |
17728 | [ | |
17729 | '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b', | |
17730 | '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e' | |
17731 | ], | |
17732 | [ | |
17733 | 'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247', | |
17734 | 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6' | |
17735 | ], | |
17736 | [ | |
17737 | 'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1', | |
17738 | 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476' | |
17739 | ], | |
17740 | [ | |
17741 | '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120', | |
17742 | '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40' | |
17743 | ], | |
17744 | [ | |
17745 | '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435', | |
17746 | '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61' | |
17747 | ], | |
17748 | [ | |
17749 | '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18', | |
17750 | '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683' | |
17751 | ], | |
17752 | [ | |
17753 | 'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8', | |
17754 | '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5' | |
17755 | ], | |
17756 | [ | |
17757 | '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb', | |
17758 | '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b' | |
17759 | ], | |
17760 | [ | |
17761 | 'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f', | |
17762 | '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417' | |
17763 | ], | |
17764 | [ | |
17765 | '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143', | |
17766 | 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868' | |
17767 | ], | |
17768 | [ | |
17769 | '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba', | |
17770 | 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a' | |
17771 | ], | |
17772 | [ | |
17773 | 'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45', | |
17774 | 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6' | |
17775 | ], | |
17776 | [ | |
17777 | '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a', | |
17778 | '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996' | |
17779 | ], | |
17780 | [ | |
17781 | '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e', | |
17782 | 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e' | |
17783 | ], | |
17784 | [ | |
17785 | 'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8', | |
17786 | 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d' | |
17787 | ], | |
17788 | [ | |
17789 | '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c', | |
17790 | '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2' | |
17791 | ], | |
17792 | [ | |
17793 | '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519', | |
17794 | 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e' | |
17795 | ], | |
17796 | [ | |
17797 | '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab', | |
17798 | '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437' | |
17799 | ], | |
17800 | [ | |
17801 | '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca', | |
17802 | 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311' | |
17803 | ], | |
17804 | [ | |
17805 | 'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf', | |
17806 | '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4' | |
17807 | ], | |
17808 | [ | |
17809 | '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610', | |
17810 | '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575' | |
17811 | ], | |
17812 | [ | |
17813 | '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4', | |
17814 | 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d' | |
17815 | ], | |
17816 | [ | |
17817 | '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c', | |
17818 | 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d' | |
17819 | ], | |
17820 | [ | |
17821 | 'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940', | |
17822 | 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629' | |
17823 | ], | |
17824 | [ | |
17825 | 'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980', | |
17826 | 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06' | |
17827 | ], | |
17828 | [ | |
17829 | '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3', | |
17830 | '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374' | |
17831 | ], | |
17832 | [ | |
17833 | '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf', | |
17834 | '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee' | |
17835 | ], | |
17836 | [ | |
17837 | 'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63', | |
17838 | '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1' | |
17839 | ], | |
17840 | [ | |
17841 | 'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448', | |
17842 | 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b' | |
17843 | ], | |
17844 | [ | |
17845 | '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf', | |
17846 | '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661' | |
17847 | ], | |
17848 | [ | |
17849 | '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5', | |
17850 | '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6' | |
17851 | ], | |
17852 | [ | |
17853 | 'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6', | |
17854 | '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e' | |
17855 | ], | |
17856 | [ | |
17857 | '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5', | |
17858 | '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d' | |
17859 | ], | |
17860 | [ | |
17861 | 'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99', | |
17862 | 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc' | |
17863 | ], | |
17864 | [ | |
17865 | '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51', | |
17866 | 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4' | |
17867 | ], | |
17868 | [ | |
17869 | '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5', | |
17870 | '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c' | |
17871 | ], | |
17872 | [ | |
17873 | 'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5', | |
17874 | '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b' | |
17875 | ], | |
17876 | [ | |
17877 | 'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997', | |
17878 | '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913' | |
17879 | ], | |
17880 | [ | |
17881 | '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881', | |
17882 | '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154' | |
17883 | ], | |
17884 | [ | |
17885 | '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5', | |
17886 | '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865' | |
17887 | ], | |
17888 | [ | |
17889 | '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66', | |
17890 | 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc' | |
17891 | ], | |
17892 | [ | |
17893 | '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726', | |
17894 | 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224' | |
17895 | ], | |
17896 | [ | |
17897 | '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede', | |
17898 | '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e' | |
17899 | ], | |
17900 | [ | |
17901 | '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94', | |
17902 | '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6' | |
17903 | ], | |
17904 | [ | |
17905 | '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31', | |
17906 | '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511' | |
17907 | ], | |
17908 | [ | |
17909 | '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51', | |
17910 | 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b' | |
17911 | ], | |
17912 | [ | |
17913 | 'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252', | |
17914 | 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2' | |
17915 | ], | |
17916 | [ | |
17917 | '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5', | |
17918 | 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c' | |
17919 | ], | |
17920 | [ | |
17921 | 'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b', | |
17922 | '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3' | |
17923 | ], | |
17924 | [ | |
17925 | 'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4', | |
17926 | '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d' | |
17927 | ], | |
17928 | [ | |
17929 | 'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f', | |
17930 | '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700' | |
17931 | ], | |
17932 | [ | |
17933 | 'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889', | |
17934 | '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4' | |
17935 | ], | |
17936 | [ | |
17937 | '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246', | |
17938 | 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196' | |
17939 | ], | |
17940 | [ | |
17941 | '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984', | |
17942 | '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4' | |
17943 | ], | |
17944 | [ | |
17945 | '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a', | |
17946 | 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257' | |
17947 | ], | |
17948 | [ | |
17949 | 'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030', | |
17950 | 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13' | |
17951 | ], | |
17952 | [ | |
17953 | 'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197', | |
17954 | '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096' | |
17955 | ], | |
17956 | [ | |
17957 | 'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593', | |
17958 | 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38' | |
17959 | ], | |
17960 | [ | |
17961 | 'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef', | |
17962 | '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f' | |
17963 | ], | |
17964 | [ | |
17965 | '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38', | |
17966 | '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448' | |
17967 | ], | |
17968 | [ | |
17969 | 'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a', | |
17970 | '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a' | |
17971 | ], | |
17972 | [ | |
17973 | 'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111', | |
17974 | '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4' | |
17975 | ], | |
17976 | [ | |
17977 | '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502', | |
17978 | '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437' | |
17979 | ], | |
17980 | [ | |
17981 | '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea', | |
17982 | 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7' | |
17983 | ], | |
17984 | [ | |
17985 | 'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26', | |
17986 | '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d' | |
17987 | ], | |
17988 | [ | |
17989 | 'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986', | |
17990 | '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a' | |
17991 | ], | |
17992 | [ | |
17993 | 'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e', | |
17994 | '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54' | |
17995 | ], | |
17996 | [ | |
17997 | '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4', | |
17998 | '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77' | |
17999 | ], | |
18000 | [ | |
18001 | 'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda', | |
18002 | 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517' | |
18003 | ], | |
18004 | [ | |
18005 | '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859', | |
18006 | 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10' | |
18007 | ], | |
18008 | [ | |
18009 | 'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f', | |
18010 | 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125' | |
18011 | ], | |
18012 | [ | |
18013 | 'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c', | |
18014 | '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e' | |
18015 | ], | |
18016 | [ | |
18017 | '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942', | |
18018 | 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1' | |
18019 | ], | |
18020 | [ | |
18021 | 'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a', | |
18022 | '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2' | |
18023 | ], | |
18024 | [ | |
18025 | 'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80', | |
18026 | '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423' | |
18027 | ], | |
18028 | [ | |
18029 | 'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d', | |
18030 | '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8' | |
18031 | ], | |
18032 | [ | |
18033 | '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1', | |
18034 | 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758' | |
18035 | ], | |
18036 | [ | |
18037 | '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63', | |
18038 | 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375' | |
18039 | ], | |
18040 | [ | |
18041 | 'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352', | |
18042 | '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d' | |
18043 | ], | |
18044 | [ | |
18045 | '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193', | |
18046 | 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec' | |
18047 | ], | |
18048 | [ | |
18049 | '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00', | |
18050 | '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0' | |
18051 | ], | |
18052 | [ | |
18053 | '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58', | |
18054 | 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c' | |
18055 | ], | |
18056 | [ | |
18057 | 'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7', | |
18058 | 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4' | |
18059 | ], | |
18060 | [ | |
18061 | '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8', | |
18062 | 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f' | |
18063 | ], | |
18064 | [ | |
18065 | '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e', | |
18066 | '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649' | |
18067 | ], | |
18068 | [ | |
18069 | '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d', | |
18070 | 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826' | |
18071 | ], | |
18072 | [ | |
18073 | '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b', | |
18074 | '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5' | |
18075 | ], | |
18076 | [ | |
18077 | 'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f', | |
18078 | 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87' | |
18079 | ], | |
18080 | [ | |
18081 | '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6', | |
18082 | '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b' | |
18083 | ], | |
18084 | [ | |
18085 | 'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297', | |
18086 | '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc' | |
18087 | ], | |
18088 | [ | |
18089 | '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a', | |
18090 | '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c' | |
18091 | ], | |
18092 | [ | |
18093 | 'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c', | |
18094 | 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f' | |
18095 | ], | |
18096 | [ | |
18097 | 'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52', | |
18098 | '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a' | |
18099 | ], | |
18100 | [ | |
18101 | 'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb', | |
18102 | 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46' | |
18103 | ], | |
18104 | [ | |
18105 | '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065', | |
18106 | 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f' | |
18107 | ], | |
18108 | [ | |
18109 | '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917', | |
18110 | '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03' | |
18111 | ], | |
18112 | [ | |
18113 | '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9', | |
18114 | 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08' | |
18115 | ], | |
18116 | [ | |
18117 | '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3', | |
18118 | '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8' | |
18119 | ], | |
18120 | [ | |
18121 | '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57', | |
18122 | '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373' | |
18123 | ], | |
18124 | [ | |
18125 | '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66', | |
18126 | 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3' | |
18127 | ], | |
18128 | [ | |
18129 | '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8', | |
18130 | '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8' | |
18131 | ], | |
18132 | [ | |
18133 | '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721', | |
18134 | '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1' | |
18135 | ], | |
18136 | [ | |
18137 | '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180', | |
18138 | '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9' | |
18139 | ] | |
18140 | ] | |
18141 | } | |
18142 | }; | |
18143 | ||
18144 | },{}],100:[function(require,module,exports){ | |
18145 | 'use strict'; | |
18146 | ||
18147 | var utils = exports; | |
18148 | var BN = require('bn.js'); | |
18149 | var minAssert = require('minimalistic-assert'); | |
18150 | var minUtils = require('minimalistic-crypto-utils'); | |
18151 | ||
18152 | utils.assert = minAssert; | |
18153 | utils.toArray = minUtils.toArray; | |
18154 | utils.zero2 = minUtils.zero2; | |
18155 | utils.toHex = minUtils.toHex; | |
18156 | utils.encode = minUtils.encode; | |
18157 | ||
18158 | // Represent num in a w-NAF form | |
18159 | function getNAF(num, w) { | |
18160 | var naf = []; | |
18161 | var ws = 1 << (w + 1); | |
18162 | var k = num.clone(); | |
18163 | while (k.cmpn(1) >= 0) { | |
18164 | var z; | |
18165 | if (k.isOdd()) { | |
18166 | var mod = k.andln(ws - 1); | |
18167 | if (mod > (ws >> 1) - 1) | |
18168 | z = (ws >> 1) - mod; | |
18169 | else | |
18170 | z = mod; | |
18171 | k.isubn(z); | |
18172 | } else { | |
18173 | z = 0; | |
18174 | } | |
18175 | naf.push(z); | |
18176 | ||
18177 | // Optimization, shift by word if possible | |
18178 | var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1; | |
18179 | for (var i = 1; i < shift; i++) | |
18180 | naf.push(0); | |
18181 | k.iushrn(shift); | |
18182 | } | |
18183 | ||
18184 | return naf; | |
18185 | } | |
18186 | utils.getNAF = getNAF; | |
18187 | ||
18188 | // Represent k1, k2 in a Joint Sparse Form | |
18189 | function getJSF(k1, k2) { | |
18190 | var jsf = [ | |
18191 | [], | |
18192 | [] | |
18193 | ]; | |
18194 | ||
18195 | k1 = k1.clone(); | |
18196 | k2 = k2.clone(); | |
18197 | var d1 = 0; | |
18198 | var d2 = 0; | |
18199 | while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) { | |
18200 | ||
18201 | // First phase | |
18202 | var m14 = (k1.andln(3) + d1) & 3; | |
18203 | var m24 = (k2.andln(3) + d2) & 3; | |
18204 | if (m14 === 3) | |
18205 | m14 = -1; | |
18206 | if (m24 === 3) | |
18207 | m24 = -1; | |
18208 | var u1; | |
18209 | if ((m14 & 1) === 0) { | |
18210 | u1 = 0; | |
18211 | } else { | |
18212 | var m8 = (k1.andln(7) + d1) & 7; | |
18213 | if ((m8 === 3 || m8 === 5) && m24 === 2) | |
18214 | u1 = -m14; | |
18215 | else | |
18216 | u1 = m14; | |
18217 | } | |
18218 | jsf[0].push(u1); | |
18219 | ||
18220 | var u2; | |
18221 | if ((m24 & 1) === 0) { | |
18222 | u2 = 0; | |
18223 | } else { | |
18224 | var m8 = (k2.andln(7) + d2) & 7; | |
18225 | if ((m8 === 3 || m8 === 5) && m14 === 2) | |
18226 | u2 = -m24; | |
18227 | else | |
18228 | u2 = m24; | |
18229 | } | |
18230 | jsf[1].push(u2); | |
18231 | ||
18232 | // Second phase | |
18233 | if (2 * d1 === u1 + 1) | |
18234 | d1 = 1 - d1; | |
18235 | if (2 * d2 === u2 + 1) | |
18236 | d2 = 1 - d2; | |
18237 | k1.iushrn(1); | |
18238 | k2.iushrn(1); | |
18239 | } | |
18240 | ||
18241 | return jsf; | |
18242 | } | |
18243 | utils.getJSF = getJSF; | |
18244 | ||
18245 | function cachedProperty(obj, name, computer) { | |
18246 | var key = '_' + name; | |
18247 | obj.prototype[name] = function cachedProperty() { | |
18248 | return this[key] !== undefined ? this[key] : | |
18249 | this[key] = computer.call(this); | |
18250 | }; | |
18251 | } | |
18252 | utils.cachedProperty = cachedProperty; | |
18253 | ||
18254 | function parseBytes(bytes) { | |
18255 | return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') : | |
18256 | bytes; | |
18257 | } | |
18258 | utils.parseBytes = parseBytes; | |
18259 | ||
18260 | function intFromLE(bytes) { | |
18261 | return new BN(bytes, 'hex', 'le'); | |
18262 | } | |
18263 | utils.intFromLE = intFromLE; | |
18264 | ||
18265 | ||
18266 | },{"bn.js":18,"minimalistic-assert":360,"minimalistic-crypto-utils":361}],101:[function(require,module,exports){ | |
18267 | module.exports={ | |
18268 | "_args": [ | |
18269 | [ | |
18270 | "elliptic@6.4.1", | |
18271 | "/var/www/sui.li/bip39/htdocs/libs/stellar-util" | |
18272 | ] | |
18273 | ], | |
18274 | "_development": true, | |
18275 | "_from": "elliptic@6.4.1", | |
18276 | "_id": "elliptic@6.4.1", | |
18277 | "_inBundle": false, | |
18278 | "_integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", | |
18279 | "_location": "/elliptic", | |
18280 | "_phantomChildren": {}, | |
18281 | "_requested": { | |
18282 | "type": "version", | |
18283 | "registry": true, | |
18284 | "raw": "elliptic@6.4.1", | |
18285 | "name": "elliptic", | |
18286 | "escapedName": "elliptic", | |
18287 | "rawSpec": "6.4.1", | |
18288 | "saveSpec": null, | |
18289 | "fetchSpec": "6.4.1" | |
18290 | }, | |
18291 | "_requiredBy": [ | |
18292 | "/browserify-sign", | |
18293 | "/create-ecdh" | |
18294 | ], | |
18295 | "_resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", | |
18296 | "_spec": "6.4.1", | |
18297 | "_where": "/var/www/sui.li/bip39/htdocs/libs/stellar-util", | |
18298 | "author": { | |
18299 | "name": "Fedor Indutny", | |
18300 | "email": "fedor@indutny.com" | |
18301 | }, | |
18302 | "bugs": { | |
18303 | "url": "https://github.com/indutny/elliptic/issues" | |
18304 | }, | |
18305 | "dependencies": { | |
18306 | "bn.js": "^4.4.0", | |
18307 | "brorand": "^1.0.1", | |
18308 | "hash.js": "^1.0.0", | |
18309 | "hmac-drbg": "^1.0.0", | |
18310 | "inherits": "^2.0.1", | |
18311 | "minimalistic-assert": "^1.0.0", | |
18312 | "minimalistic-crypto-utils": "^1.0.0" | |
18313 | }, | |
18314 | "description": "EC cryptography", | |
18315 | "devDependencies": { | |
18316 | "brfs": "^1.4.3", | |
18317 | "coveralls": "^2.11.3", | |
18318 | "grunt": "^0.4.5", | |
18319 | "grunt-browserify": "^5.0.0", | |
18320 | "grunt-cli": "^1.2.0", | |
18321 | "grunt-contrib-connect": "^1.0.0", | |
18322 | "grunt-contrib-copy": "^1.0.0", | |
18323 | "grunt-contrib-uglify": "^1.0.1", | |
18324 | "grunt-mocha-istanbul": "^3.0.1", | |
18325 | "grunt-saucelabs": "^8.6.2", | |
18326 | "istanbul": "^0.4.2", | |
18327 | "jscs": "^2.9.0", | |
18328 | "jshint": "^2.6.0", | |
18329 | "mocha": "^2.1.0" | |
18330 | }, | |
18331 | "files": [ | |
18332 | "lib" | |
18333 | ], | |
18334 | "homepage": "https://github.com/indutny/elliptic", | |
18335 | "keywords": [ | |
18336 | "EC", | |
18337 | "Elliptic", | |
18338 | "curve", | |
18339 | "Cryptography" | |
18340 | ], | |
18341 | "license": "MIT", | |
18342 | "main": "lib/elliptic.js", | |
18343 | "name": "elliptic", | |
18344 | "repository": { | |
18345 | "type": "git", | |
18346 | "url": "git+ssh://git@github.com/indutny/elliptic.git" | |
18347 | }, | |
18348 | "scripts": { | |
18349 | "jscs": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js", | |
18350 | "jshint": "jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js", | |
18351 | "lint": "npm run jscs && npm run jshint", | |
18352 | "test": "npm run lint && npm run unit", | |
18353 | "unit": "istanbul test _mocha --reporter=spec test/index.js", | |
18354 | "version": "grunt dist && git add dist/" | |
18355 | }, | |
18356 | "version": "6.4.1" | |
18357 | } | |
18358 | ||
18359 | },{}],102:[function(require,module,exports){ | |
18360 | // Copyright Joyent, Inc. and other Node contributors. | |
18361 | // | |
18362 | // Permission is hereby granted, free of charge, to any person obtaining a | |
18363 | // copy of this software and associated documentation files (the | |
18364 | // "Software"), to deal in the Software without restriction, including | |
18365 | // without limitation the rights to use, copy, modify, merge, publish, | |
18366 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
18367 | // persons to whom the Software is furnished to do so, subject to the | |
18368 | // following conditions: | |
18369 | // | |
18370 | // The above copyright notice and this permission notice shall be included | |
18371 | // in all copies or substantial portions of the Software. | |
18372 | // | |
18373 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
18374 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
18375 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
18376 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
18377 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
18378 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
18379 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
18380 | ||
18381 | var objectCreate = Object.create || objectCreatePolyfill | |
18382 | var objectKeys = Object.keys || objectKeysPolyfill | |
18383 | var bind = Function.prototype.bind || functionBindPolyfill | |
18384 | ||
18385 | function EventEmitter() { | |
18386 | if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) { | |
18387 | this._events = objectCreate(null); | |
18388 | this._eventsCount = 0; | |
18389 | } | |
18390 | ||
18391 | this._maxListeners = this._maxListeners || undefined; | |
18392 | } | |
18393 | module.exports = EventEmitter; | |
18394 | ||
18395 | // Backwards-compat with node 0.10.x | |
18396 | EventEmitter.EventEmitter = EventEmitter; | |
18397 | ||
18398 | EventEmitter.prototype._events = undefined; | |
18399 | EventEmitter.prototype._maxListeners = undefined; | |
18400 | ||
18401 | // By default EventEmitters will print a warning if more than 10 listeners are | |
18402 | // added to it. This is a useful default which helps finding memory leaks. | |
18403 | var defaultMaxListeners = 10; | |
18404 | ||
18405 | var hasDefineProperty; | |
18406 | try { | |
18407 | var o = {}; | |
18408 | if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 }); | |
18409 | hasDefineProperty = o.x === 0; | |
18410 | } catch (err) { hasDefineProperty = false } | |
18411 | if (hasDefineProperty) { | |
18412 | Object.defineProperty(EventEmitter, 'defaultMaxListeners', { | |
18413 | enumerable: true, | |
18414 | get: function() { | |
18415 | return defaultMaxListeners; | |
18416 | }, | |
18417 | set: function(arg) { | |
18418 | // check whether the input is a positive number (whose value is zero or | |
18419 | // greater and not a NaN). | |
18420 | if (typeof arg !== 'number' || arg < 0 || arg !== arg) | |
18421 | throw new TypeError('"defaultMaxListeners" must be a positive number'); | |
18422 | defaultMaxListeners = arg; | |
18423 | } | |
18424 | }); | |
18425 | } else { | |
18426 | EventEmitter.defaultMaxListeners = defaultMaxListeners; | |
18427 | } | |
18428 | ||
18429 | // Obviously not all Emitters should be limited to 10. This function allows | |
18430 | // that to be increased. Set to zero for unlimited. | |
18431 | EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { | |
18432 | if (typeof n !== 'number' || n < 0 || isNaN(n)) | |
18433 | throw new TypeError('"n" argument must be a positive number'); | |
18434 | this._maxListeners = n; | |
18435 | return this; | |
18436 | }; | |
18437 | ||
18438 | function $getMaxListeners(that) { | |
18439 | if (that._maxListeners === undefined) | |
18440 | return EventEmitter.defaultMaxListeners; | |
18441 | return that._maxListeners; | |
18442 | } | |
18443 | ||
18444 | EventEmitter.prototype.getMaxListeners = function getMaxListeners() { | |
18445 | return $getMaxListeners(this); | |
18446 | }; | |
18447 | ||
18448 | // These standalone emit* functions are used to optimize calling of event | |
18449 | // handlers for fast cases because emit() itself often has a variable number of | |
18450 | // arguments and can be deoptimized because of that. These functions always have | |
18451 | // the same number of arguments and thus do not get deoptimized, so the code | |
18452 | // inside them can execute faster. | |
18453 | function emitNone(handler, isFn, self) { | |
18454 | if (isFn) | |
18455 | handler.call(self); | |
18456 | else { | |
18457 | var len = handler.length; | |
18458 | var listeners = arrayClone(handler, len); | |
18459 | for (var i = 0; i < len; ++i) | |
18460 | listeners[i].call(self); | |
18461 | } | |
18462 | } | |
18463 | function emitOne(handler, isFn, self, arg1) { | |
18464 | if (isFn) | |
18465 | handler.call(self, arg1); | |
18466 | else { | |
18467 | var len = handler.length; | |
18468 | var listeners = arrayClone(handler, len); | |
18469 | for (var i = 0; i < len; ++i) | |
18470 | listeners[i].call(self, arg1); | |
18471 | } | |
18472 | } | |
18473 | function emitTwo(handler, isFn, self, arg1, arg2) { | |
18474 | if (isFn) | |
18475 | handler.call(self, arg1, arg2); | |
18476 | else { | |
18477 | var len = handler.length; | |
18478 | var listeners = arrayClone(handler, len); | |
18479 | for (var i = 0; i < len; ++i) | |
18480 | listeners[i].call(self, arg1, arg2); | |
18481 | } | |
18482 | } | |
18483 | function emitThree(handler, isFn, self, arg1, arg2, arg3) { | |
18484 | if (isFn) | |
18485 | handler.call(self, arg1, arg2, arg3); | |
18486 | else { | |
18487 | var len = handler.length; | |
18488 | var listeners = arrayClone(handler, len); | |
18489 | for (var i = 0; i < len; ++i) | |
18490 | listeners[i].call(self, arg1, arg2, arg3); | |
18491 | } | |
18492 | } | |
18493 | ||
18494 | function emitMany(handler, isFn, self, args) { | |
18495 | if (isFn) | |
18496 | handler.apply(self, args); | |
18497 | else { | |
18498 | var len = handler.length; | |
18499 | var listeners = arrayClone(handler, len); | |
18500 | for (var i = 0; i < len; ++i) | |
18501 | listeners[i].apply(self, args); | |
18502 | } | |
18503 | } | |
18504 | ||
18505 | EventEmitter.prototype.emit = function emit(type) { | |
18506 | var er, handler, len, args, i, events; | |
18507 | var doError = (type === 'error'); | |
18508 | ||
18509 | events = this._events; | |
18510 | if (events) | |
18511 | doError = (doError && events.error == null); | |
18512 | else if (!doError) | |
18513 | return false; | |
18514 | ||
18515 | // If there is no 'error' event listener then throw. | |
18516 | if (doError) { | |
18517 | if (arguments.length > 1) | |
18518 | er = arguments[1]; | |
18519 | if (er instanceof Error) { | |
18520 | throw er; // Unhandled 'error' event | |
18521 | } else { | |
18522 | // At least give some kind of context to the user | |
18523 | var err = new Error('Unhandled "error" event. (' + er + ')'); | |
18524 | err.context = er; | |
18525 | throw err; | |
18526 | } | |
18527 | return false; | |
18528 | } | |
18529 | ||
18530 | handler = events[type]; | |
18531 | ||
18532 | if (!handler) | |
18533 | return false; | |
18534 | ||
18535 | var isFn = typeof handler === 'function'; | |
18536 | len = arguments.length; | |
18537 | switch (len) { | |
18538 | // fast cases | |
18539 | case 1: | |
18540 | emitNone(handler, isFn, this); | |
18541 | break; | |
18542 | case 2: | |
18543 | emitOne(handler, isFn, this, arguments[1]); | |
18544 | break; | |
18545 | case 3: | |
18546 | emitTwo(handler, isFn, this, arguments[1], arguments[2]); | |
18547 | break; | |
18548 | case 4: | |
18549 | emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); | |
18550 | break; | |
18551 | // slower | |
18552 | default: | |
18553 | args = new Array(len - 1); | |
18554 | for (i = 1; i < len; i++) | |
18555 | args[i - 1] = arguments[i]; | |
18556 | emitMany(handler, isFn, this, args); | |
18557 | } | |
18558 | ||
18559 | return true; | |
18560 | }; | |
18561 | ||
18562 | function _addListener(target, type, listener, prepend) { | |
18563 | var m; | |
18564 | var events; | |
18565 | var existing; | |
18566 | ||
18567 | if (typeof listener !== 'function') | |
18568 | throw new TypeError('"listener" argument must be a function'); | |
18569 | ||
18570 | events = target._events; | |
18571 | if (!events) { | |
18572 | events = target._events = objectCreate(null); | |
18573 | target._eventsCount = 0; | |
18574 | } else { | |
18575 | // To avoid recursion in the case that type === "newListener"! Before | |
18576 | // adding it to the listeners, first emit "newListener". | |
18577 | if (events.newListener) { | |
18578 | target.emit('newListener', type, | |
18579 | listener.listener ? listener.listener : listener); | |
18580 | ||
18581 | // Re-assign `events` because a newListener handler could have caused the | |
18582 | // this._events to be assigned to a new object | |
18583 | events = target._events; | |
18584 | } | |
18585 | existing = events[type]; | |
18586 | } | |
18587 | ||
18588 | if (!existing) { | |
18589 | // Optimize the case of one listener. Don't need the extra array object. | |
18590 | existing = events[type] = listener; | |
18591 | ++target._eventsCount; | |
18592 | } else { | |
18593 | if (typeof existing === 'function') { | |
18594 | // Adding the second element, need to change to array. | |
18595 | existing = events[type] = | |
18596 | prepend ? [listener, existing] : [existing, listener]; | |
18597 | } else { | |
18598 | // If we've already got an array, just append. | |
18599 | if (prepend) { | |
18600 | existing.unshift(listener); | |
18601 | } else { | |
18602 | existing.push(listener); | |
18603 | } | |
18604 | } | |
18605 | ||
18606 | // Check for listener leak | |
18607 | if (!existing.warned) { | |
18608 | m = $getMaxListeners(target); | |
18609 | if (m && m > 0 && existing.length > m) { | |
18610 | existing.warned = true; | |
18611 | var w = new Error('Possible EventEmitter memory leak detected. ' + | |
18612 | existing.length + ' "' + String(type) + '" listeners ' + | |
18613 | 'added. Use emitter.setMaxListeners() to ' + | |
18614 | 'increase limit.'); | |
18615 | w.name = 'MaxListenersExceededWarning'; | |
18616 | w.emitter = target; | |
18617 | w.type = type; | |
18618 | w.count = existing.length; | |
18619 | if (typeof console === 'object' && console.warn) { | |
18620 | console.warn('%s: %s', w.name, w.message); | |
18621 | } | |
18622 | } | |
18623 | } | |
18624 | } | |
18625 | ||
18626 | return target; | |
18627 | } | |
18628 | ||
18629 | EventEmitter.prototype.addListener = function addListener(type, listener) { | |
18630 | return _addListener(this, type, listener, false); | |
18631 | }; | |
18632 | ||
18633 | EventEmitter.prototype.on = EventEmitter.prototype.addListener; | |
18634 | ||
18635 | EventEmitter.prototype.prependListener = | |
18636 | function prependListener(type, listener) { | |
18637 | return _addListener(this, type, listener, true); | |
18638 | }; | |
18639 | ||
18640 | function onceWrapper() { | |
18641 | if (!this.fired) { | |
18642 | this.target.removeListener(this.type, this.wrapFn); | |
18643 | this.fired = true; | |
18644 | switch (arguments.length) { | |
18645 | case 0: | |
18646 | return this.listener.call(this.target); | |
18647 | case 1: | |
18648 | return this.listener.call(this.target, arguments[0]); | |
18649 | case 2: | |
18650 | return this.listener.call(this.target, arguments[0], arguments[1]); | |
18651 | case 3: | |
18652 | return this.listener.call(this.target, arguments[0], arguments[1], | |
18653 | arguments[2]); | |
18654 | default: | |
18655 | var args = new Array(arguments.length); | |
18656 | for (var i = 0; i < args.length; ++i) | |
18657 | args[i] = arguments[i]; | |
18658 | this.listener.apply(this.target, args); | |
18659 | } | |
18660 | } | |
18661 | } | |
18662 | ||
18663 | function _onceWrap(target, type, listener) { | |
18664 | var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; | |
18665 | var wrapped = bind.call(onceWrapper, state); | |
18666 | wrapped.listener = listener; | |
18667 | state.wrapFn = wrapped; | |
18668 | return wrapped; | |
18669 | } | |
18670 | ||
18671 | EventEmitter.prototype.once = function once(type, listener) { | |
18672 | if (typeof listener !== 'function') | |
18673 | throw new TypeError('"listener" argument must be a function'); | |
18674 | this.on(type, _onceWrap(this, type, listener)); | |
18675 | return this; | |
18676 | }; | |
18677 | ||
18678 | EventEmitter.prototype.prependOnceListener = | |
18679 | function prependOnceListener(type, listener) { | |
18680 | if (typeof listener !== 'function') | |
18681 | throw new TypeError('"listener" argument must be a function'); | |
18682 | this.prependListener(type, _onceWrap(this, type, listener)); | |
18683 | return this; | |
18684 | }; | |
18685 | ||
18686 | // Emits a 'removeListener' event if and only if the listener was removed. | |
18687 | EventEmitter.prototype.removeListener = | |
18688 | function removeListener(type, listener) { | |
18689 | var list, events, position, i, originalListener; | |
18690 | ||
18691 | if (typeof listener !== 'function') | |
18692 | throw new TypeError('"listener" argument must be a function'); | |
18693 | ||
18694 | events = this._events; | |
18695 | if (!events) | |
18696 | return this; | |
18697 | ||
18698 | list = events[type]; | |
18699 | if (!list) | |
18700 | return this; | |
18701 | ||
18702 | if (list === listener || list.listener === listener) { | |
18703 | if (--this._eventsCount === 0) | |
18704 | this._events = objectCreate(null); | |
18705 | else { | |
18706 | delete events[type]; | |
18707 | if (events.removeListener) | |
18708 | this.emit('removeListener', type, list.listener || listener); | |
18709 | } | |
18710 | } else if (typeof list !== 'function') { | |
18711 | position = -1; | |
18712 | ||
18713 | for (i = list.length - 1; i >= 0; i--) { | |
18714 | if (list[i] === listener || list[i].listener === listener) { | |
18715 | originalListener = list[i].listener; | |
18716 | position = i; | |
18717 | break; | |
18718 | } | |
18719 | } | |
18720 | ||
18721 | if (position < 0) | |
18722 | return this; | |
18723 | ||
18724 | if (position === 0) | |
18725 | list.shift(); | |
18726 | else | |
18727 | spliceOne(list, position); | |
18728 | ||
18729 | if (list.length === 1) | |
18730 | events[type] = list[0]; | |
18731 | ||
18732 | if (events.removeListener) | |
18733 | this.emit('removeListener', type, originalListener || listener); | |
18734 | } | |
18735 | ||
18736 | return this; | |
18737 | }; | |
18738 | ||
18739 | EventEmitter.prototype.removeAllListeners = | |
18740 | function removeAllListeners(type) { | |
18741 | var listeners, events, i; | |
18742 | ||
18743 | events = this._events; | |
18744 | if (!events) | |
18745 | return this; | |
18746 | ||
18747 | // not listening for removeListener, no need to emit | |
18748 | if (!events.removeListener) { | |
18749 | if (arguments.length === 0) { | |
18750 | this._events = objectCreate(null); | |
18751 | this._eventsCount = 0; | |
18752 | } else if (events[type]) { | |
18753 | if (--this._eventsCount === 0) | |
18754 | this._events = objectCreate(null); | |
18755 | else | |
18756 | delete events[type]; | |
18757 | } | |
18758 | return this; | |
18759 | } | |
18760 | ||
18761 | // emit removeListener for all listeners on all events | |
18762 | if (arguments.length === 0) { | |
18763 | var keys = objectKeys(events); | |
18764 | var key; | |
18765 | for (i = 0; i < keys.length; ++i) { | |
18766 | key = keys[i]; | |
18767 | if (key === 'removeListener') continue; | |
18768 | this.removeAllListeners(key); | |
18769 | } | |
18770 | this.removeAllListeners('removeListener'); | |
18771 | this._events = objectCreate(null); | |
18772 | this._eventsCount = 0; | |
18773 | return this; | |
18774 | } | |
18775 | ||
18776 | listeners = events[type]; | |
18777 | ||
18778 | if (typeof listeners === 'function') { | |
18779 | this.removeListener(type, listeners); | |
18780 | } else if (listeners) { | |
18781 | // LIFO order | |
18782 | for (i = listeners.length - 1; i >= 0; i--) { | |
18783 | this.removeListener(type, listeners[i]); | |
18784 | } | |
18785 | } | |
18786 | ||
18787 | return this; | |
18788 | }; | |
18789 | ||
18790 | function _listeners(target, type, unwrap) { | |
18791 | var events = target._events; | |
18792 | ||
18793 | if (!events) | |
18794 | return []; | |
18795 | ||
18796 | var evlistener = events[type]; | |
18797 | if (!evlistener) | |
18798 | return []; | |
18799 | ||
18800 | if (typeof evlistener === 'function') | |
18801 | return unwrap ? [evlistener.listener || evlistener] : [evlistener]; | |
18802 | ||
18803 | return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); | |
18804 | } | |
18805 | ||
18806 | EventEmitter.prototype.listeners = function listeners(type) { | |
18807 | return _listeners(this, type, true); | |
18808 | }; | |
18809 | ||
18810 | EventEmitter.prototype.rawListeners = function rawListeners(type) { | |
18811 | return _listeners(this, type, false); | |
18812 | }; | |
18813 | ||
18814 | EventEmitter.listenerCount = function(emitter, type) { | |
18815 | if (typeof emitter.listenerCount === 'function') { | |
18816 | return emitter.listenerCount(type); | |
18817 | } else { | |
18818 | return listenerCount.call(emitter, type); | |
18819 | } | |
18820 | }; | |
18821 | ||
18822 | EventEmitter.prototype.listenerCount = listenerCount; | |
18823 | function listenerCount(type) { | |
18824 | var events = this._events; | |
18825 | ||
18826 | if (events) { | |
18827 | var evlistener = events[type]; | |
18828 | ||
18829 | if (typeof evlistener === 'function') { | |
18830 | return 1; | |
18831 | } else if (evlistener) { | |
18832 | return evlistener.length; | |
18833 | } | |
18834 | } | |
18835 | ||
18836 | return 0; | |
18837 | } | |
18838 | ||
18839 | EventEmitter.prototype.eventNames = function eventNames() { | |
18840 | return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; | |
18841 | }; | |
18842 | ||
18843 | // About 1.5x faster than the two-arg version of Array#splice(). | |
18844 | function spliceOne(list, index) { | |
18845 | for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) | |
18846 | list[i] = list[k]; | |
18847 | list.pop(); | |
18848 | } | |
18849 | ||
18850 | function arrayClone(arr, n) { | |
18851 | var copy = new Array(n); | |
18852 | for (var i = 0; i < n; ++i) | |
18853 | copy[i] = arr[i]; | |
18854 | return copy; | |
18855 | } | |
18856 | ||
18857 | function unwrapListeners(arr) { | |
18858 | var ret = new Array(arr.length); | |
18859 | for (var i = 0; i < ret.length; ++i) { | |
18860 | ret[i] = arr[i].listener || arr[i]; | |
18861 | } | |
18862 | return ret; | |
18863 | } | |
18864 | ||
18865 | function objectCreatePolyfill(proto) { | |
18866 | var F = function() {}; | |
18867 | F.prototype = proto; | |
18868 | return new F; | |
18869 | } | |
18870 | function objectKeysPolyfill(obj) { | |
18871 | var keys = []; | |
18872 | for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) { | |
18873 | keys.push(k); | |
18874 | } | |
18875 | return k; | |
18876 | } | |
18877 | function functionBindPolyfill(context) { | |
18878 | var fn = this; | |
18879 | return function () { | |
18880 | return fn.apply(context, arguments); | |
18881 | }; | |
18882 | } | |
18883 | ||
18884 | },{}],103:[function(require,module,exports){ | |
18885 | var Buffer = require('safe-buffer').Buffer | |
18886 | var MD5 = require('md5.js') | |
18887 | ||
18888 | /* eslint-disable camelcase */ | |
18889 | function EVP_BytesToKey (password, salt, keyBits, ivLen) { | |
18890 | if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary') | |
18891 | if (salt) { | |
18892 | if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary') | |
18893 | if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length') | |
18894 | } | |
18895 | ||
18896 | var keyLen = keyBits / 8 | |
18897 | var key = Buffer.alloc(keyLen) | |
18898 | var iv = Buffer.alloc(ivLen || 0) | |
18899 | var tmp = Buffer.alloc(0) | |
18900 | ||
18901 | while (keyLen > 0 || ivLen > 0) { | |
18902 | var hash = new MD5() | |
18903 | hash.update(tmp) | |
18904 | hash.update(password) | |
18905 | if (salt) hash.update(salt) | |
18906 | tmp = hash.digest() | |
18907 | ||
18908 | var used = 0 | |
18909 | ||
18910 | if (keyLen > 0) { | |
18911 | var keyStart = key.length - keyLen | |
18912 | used = Math.min(keyLen, tmp.length) | |
18913 | tmp.copy(key, keyStart, 0, used) | |
18914 | keyLen -= used | |
18915 | } | |
18916 | ||
18917 | if (used < tmp.length && ivLen > 0) { | |
18918 | var ivStart = iv.length - ivLen | |
18919 | var length = Math.min(ivLen, tmp.length - used) | |
18920 | tmp.copy(iv, ivStart, used, used + length) | |
18921 | ivLen -= length | |
18922 | } | |
18923 | } | |
18924 | ||
18925 | tmp.fill(0) | |
18926 | return { key: key, iv: iv } | |
18927 | } | |
18928 | ||
18929 | module.exports = EVP_BytesToKey | |
18930 | ||
18931 | },{"md5.js":358,"safe-buffer":398}],104:[function(require,module,exports){ | |
18932 | 'use strict' | |
18933 | var Buffer = require('safe-buffer').Buffer | |
18934 | var Transform = require('stream').Transform | |
18935 | var inherits = require('inherits') | |
18936 | ||
18937 | function throwIfNotStringOrBuffer (val, prefix) { | |
18938 | if (!Buffer.isBuffer(val) && typeof val !== 'string') { | |
18939 | throw new TypeError(prefix + ' must be a string or a buffer') | |
18940 | } | |
18941 | } | |
18942 | ||
18943 | function HashBase (blockSize) { | |
18944 | Transform.call(this) | |
18945 | ||
18946 | this._block = Buffer.allocUnsafe(blockSize) | |
18947 | this._blockSize = blockSize | |
18948 | this._blockOffset = 0 | |
18949 | this._length = [0, 0, 0, 0] | |
18950 | ||
18951 | this._finalized = false | |
18952 | } | |
18953 | ||
18954 | inherits(HashBase, Transform) | |
18955 | ||
18956 | HashBase.prototype._transform = function (chunk, encoding, callback) { | |
18957 | var error = null | |
18958 | try { | |
18959 | this.update(chunk, encoding) | |
18960 | } catch (err) { | |
18961 | error = err | |
18962 | } | |
18963 | ||
18964 | callback(error) | |
18965 | } | |
18966 | ||
18967 | HashBase.prototype._flush = function (callback) { | |
18968 | var error = null | |
18969 | try { | |
18970 | this.push(this.digest()) | |
18971 | } catch (err) { | |
18972 | error = err | |
18973 | } | |
18974 | ||
18975 | callback(error) | |
18976 | } | |
18977 | ||
18978 | HashBase.prototype.update = function (data, encoding) { | |
18979 | throwIfNotStringOrBuffer(data, 'Data') | |
18980 | if (this._finalized) throw new Error('Digest already called') | |
18981 | if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding) | |
18982 | ||
18983 | // consume data | |
18984 | var block = this._block | |
18985 | var offset = 0 | |
18986 | while (this._blockOffset + data.length - offset >= this._blockSize) { | |
18987 | for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++] | |
18988 | this._update() | |
18989 | this._blockOffset = 0 | |
18990 | } | |
18991 | while (offset < data.length) block[this._blockOffset++] = data[offset++] | |
18992 | ||
18993 | // update length | |
18994 | for (var j = 0, carry = data.length * 8; carry > 0; ++j) { | |
18995 | this._length[j] += carry | |
18996 | carry = (this._length[j] / 0x0100000000) | 0 | |
18997 | if (carry > 0) this._length[j] -= 0x0100000000 * carry | |
18998 | } | |
18999 | ||
19000 | return this | |
19001 | } | |
19002 | ||
19003 | HashBase.prototype._update = function () { | |
19004 | throw new Error('_update is not implemented') | |
19005 | } | |
19006 | ||
19007 | HashBase.prototype.digest = function (encoding) { | |
19008 | if (this._finalized) throw new Error('Digest already called') | |
19009 | this._finalized = true | |
19010 | ||
19011 | var digest = this._digest() | |
19012 | if (encoding !== undefined) digest = digest.toString(encoding) | |
19013 | ||
19014 | // reset state | |
19015 | this._block.fill(0) | |
19016 | this._blockOffset = 0 | |
19017 | for (var i = 0; i < 4; ++i) this._length[i] = 0 | |
19018 | ||
19019 | return digest | |
19020 | } | |
19021 | ||
19022 | HashBase.prototype._digest = function () { | |
19023 | throw new Error('_digest is not implemented') | |
19024 | } | |
19025 | ||
19026 | module.exports = HashBase | |
19027 | ||
19028 | },{"inherits":119,"safe-buffer":398,"stream":437}],105:[function(require,module,exports){ | |
19029 | var hash = exports; | |
19030 | ||
19031 | hash.utils = require('./hash/utils'); | |
19032 | hash.common = require('./hash/common'); | |
19033 | hash.sha = require('./hash/sha'); | |
19034 | hash.ripemd = require('./hash/ripemd'); | |
19035 | hash.hmac = require('./hash/hmac'); | |
19036 | ||
19037 | // Proxy hash functions to the main object | |
19038 | hash.sha1 = hash.sha.sha1; | |
19039 | hash.sha256 = hash.sha.sha256; | |
19040 | hash.sha224 = hash.sha.sha224; | |
19041 | hash.sha384 = hash.sha.sha384; | |
19042 | hash.sha512 = hash.sha.sha512; | |
19043 | hash.ripemd160 = hash.ripemd.ripemd160; | |
19044 | ||
19045 | },{"./hash/common":106,"./hash/hmac":107,"./hash/ripemd":108,"./hash/sha":109,"./hash/utils":116}],106:[function(require,module,exports){ | |
19046 | 'use strict'; | |
19047 | ||
19048 | var utils = require('./utils'); | |
19049 | var assert = require('minimalistic-assert'); | |
19050 | ||
19051 | function BlockHash() { | |
19052 | this.pending = null; | |
19053 | this.pendingTotal = 0; | |
19054 | this.blockSize = this.constructor.blockSize; | |
19055 | this.outSize = this.constructor.outSize; | |
19056 | this.hmacStrength = this.constructor.hmacStrength; | |
19057 | this.padLength = this.constructor.padLength / 8; | |
19058 | this.endian = 'big'; | |
19059 | ||
19060 | this._delta8 = this.blockSize / 8; | |
19061 | this._delta32 = this.blockSize / 32; | |
19062 | } | |
19063 | exports.BlockHash = BlockHash; | |
19064 | ||
19065 | BlockHash.prototype.update = function update(msg, enc) { | |
19066 | // Convert message to array, pad it, and join into 32bit blocks | |
19067 | msg = utils.toArray(msg, enc); | |
19068 | if (!this.pending) | |
19069 | this.pending = msg; | |
19070 | else | |
19071 | this.pending = this.pending.concat(msg); | |
19072 | this.pendingTotal += msg.length; | |
19073 | ||
19074 | // Enough data, try updating | |
19075 | if (this.pending.length >= this._delta8) { | |
19076 | msg = this.pending; | |
19077 | ||
19078 | // Process pending data in blocks | |
19079 | var r = msg.length % this._delta8; | |
19080 | this.pending = msg.slice(msg.length - r, msg.length); | |
19081 | if (this.pending.length === 0) | |
19082 | this.pending = null; | |
19083 | ||
19084 | msg = utils.join32(msg, 0, msg.length - r, this.endian); | |
19085 | for (var i = 0; i < msg.length; i += this._delta32) | |
19086 | this._update(msg, i, i + this._delta32); | |
19087 | } | |
19088 | ||
19089 | return this; | |
19090 | }; | |
19091 | ||
19092 | BlockHash.prototype.digest = function digest(enc) { | |
19093 | this.update(this._pad()); | |
19094 | assert(this.pending === null); | |
19095 | ||
19096 | return this._digest(enc); | |
19097 | }; | |
19098 | ||
19099 | BlockHash.prototype._pad = function pad() { | |
19100 | var len = this.pendingTotal; | |
19101 | var bytes = this._delta8; | |
19102 | var k = bytes - ((len + this.padLength) % bytes); | |
19103 | var res = new Array(k + this.padLength); | |
19104 | res[0] = 0x80; | |
19105 | for (var i = 1; i < k; i++) | |
19106 | res[i] = 0; | |
19107 | ||
19108 | // Append length | |
19109 | len <<= 3; | |
19110 | if (this.endian === 'big') { | |
19111 | for (var t = 8; t < this.padLength; t++) | |
19112 | res[i++] = 0; | |
19113 | ||
19114 | res[i++] = 0; | |
19115 | res[i++] = 0; | |
19116 | res[i++] = 0; | |
19117 | res[i++] = 0; | |
19118 | res[i++] = (len >>> 24) & 0xff; | |
19119 | res[i++] = (len >>> 16) & 0xff; | |
19120 | res[i++] = (len >>> 8) & 0xff; | |
19121 | res[i++] = len & 0xff; | |
19122 | } else { | |
19123 | res[i++] = len & 0xff; | |
19124 | res[i++] = (len >>> 8) & 0xff; | |
19125 | res[i++] = (len >>> 16) & 0xff; | |
19126 | res[i++] = (len >>> 24) & 0xff; | |
19127 | res[i++] = 0; | |
19128 | res[i++] = 0; | |
19129 | res[i++] = 0; | |
19130 | res[i++] = 0; | |
19131 | ||
19132 | for (t = 8; t < this.padLength; t++) | |
19133 | res[i++] = 0; | |
19134 | } | |
19135 | ||
19136 | return res; | |
19137 | }; | |
19138 | ||
19139 | },{"./utils":116,"minimalistic-assert":360}],107:[function(require,module,exports){ | |
19140 | 'use strict'; | |
19141 | ||
19142 | var utils = require('./utils'); | |
19143 | var assert = require('minimalistic-assert'); | |
19144 | ||
19145 | function Hmac(hash, key, enc) { | |
19146 | if (!(this instanceof Hmac)) | |
19147 | return new Hmac(hash, key, enc); | |
19148 | this.Hash = hash; | |
19149 | this.blockSize = hash.blockSize / 8; | |
19150 | this.outSize = hash.outSize / 8; | |
19151 | this.inner = null; | |
19152 | this.outer = null; | |
19153 | ||
19154 | this._init(utils.toArray(key, enc)); | |
19155 | } | |
19156 | module.exports = Hmac; | |
19157 | ||
19158 | Hmac.prototype._init = function init(key) { | |
19159 | // Shorten key, if needed | |
19160 | if (key.length > this.blockSize) | |
19161 | key = new this.Hash().update(key).digest(); | |
19162 | assert(key.length <= this.blockSize); | |
19163 | ||
19164 | // Add padding to key | |
19165 | for (var i = key.length; i < this.blockSize; i++) | |
19166 | key.push(0); | |
19167 | ||
19168 | for (i = 0; i < key.length; i++) | |
19169 | key[i] ^= 0x36; | |
19170 | this.inner = new this.Hash().update(key); | |
19171 | ||
19172 | // 0x36 ^ 0x5c = 0x6a | |
19173 | for (i = 0; i < key.length; i++) | |
19174 | key[i] ^= 0x6a; | |
19175 | this.outer = new this.Hash().update(key); | |
19176 | }; | |
19177 | ||
19178 | Hmac.prototype.update = function update(msg, enc) { | |
19179 | this.inner.update(msg, enc); | |
19180 | return this; | |
19181 | }; | |
19182 | ||
19183 | Hmac.prototype.digest = function digest(enc) { | |
19184 | this.outer.update(this.inner.digest()); | |
19185 | return this.outer.digest(enc); | |
19186 | }; | |
19187 | ||
19188 | },{"./utils":116,"minimalistic-assert":360}],108:[function(require,module,exports){ | |
19189 | 'use strict'; | |
19190 | ||
19191 | var utils = require('./utils'); | |
19192 | var common = require('./common'); | |
19193 | ||
19194 | var rotl32 = utils.rotl32; | |
19195 | var sum32 = utils.sum32; | |
19196 | var sum32_3 = utils.sum32_3; | |
19197 | var sum32_4 = utils.sum32_4; | |
19198 | var BlockHash = common.BlockHash; | |
19199 | ||
19200 | function RIPEMD160() { | |
19201 | if (!(this instanceof RIPEMD160)) | |
19202 | return new RIPEMD160(); | |
19203 | ||
19204 | BlockHash.call(this); | |
19205 | ||
19206 | this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ]; | |
19207 | this.endian = 'little'; | |
19208 | } | |
19209 | utils.inherits(RIPEMD160, BlockHash); | |
19210 | exports.ripemd160 = RIPEMD160; | |
19211 | ||
19212 | RIPEMD160.blockSize = 512; | |
19213 | RIPEMD160.outSize = 160; | |
19214 | RIPEMD160.hmacStrength = 192; | |
19215 | RIPEMD160.padLength = 64; | |
19216 | ||
19217 | RIPEMD160.prototype._update = function update(msg, start) { | |
19218 | var A = this.h[0]; | |
19219 | var B = this.h[1]; | |
19220 | var C = this.h[2]; | |
19221 | var D = this.h[3]; | |
19222 | var E = this.h[4]; | |
19223 | var Ah = A; | |
19224 | var Bh = B; | |
19225 | var Ch = C; | |
19226 | var Dh = D; | |
19227 | var Eh = E; | |
19228 | for (var j = 0; j < 80; j++) { | |
19229 | var T = sum32( | |
19230 | rotl32( | |
19231 | sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), | |
19232 | s[j]), | |
19233 | E); | |
19234 | A = E; | |
19235 | E = D; | |
19236 | D = rotl32(C, 10); | |
19237 | C = B; | |
19238 | B = T; | |
19239 | T = sum32( | |
19240 | rotl32( | |
19241 | sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), | |
19242 | sh[j]), | |
19243 | Eh); | |
19244 | Ah = Eh; | |
19245 | Eh = Dh; | |
19246 | Dh = rotl32(Ch, 10); | |
19247 | Ch = Bh; | |
19248 | Bh = T; | |
19249 | } | |
19250 | T = sum32_3(this.h[1], C, Dh); | |
19251 | this.h[1] = sum32_3(this.h[2], D, Eh); | |
19252 | this.h[2] = sum32_3(this.h[3], E, Ah); | |
19253 | this.h[3] = sum32_3(this.h[4], A, Bh); | |
19254 | this.h[4] = sum32_3(this.h[0], B, Ch); | |
19255 | this.h[0] = T; | |
19256 | }; | |
19257 | ||
19258 | RIPEMD160.prototype._digest = function digest(enc) { | |
19259 | if (enc === 'hex') | |
19260 | return utils.toHex32(this.h, 'little'); | |
19261 | else | |
19262 | return utils.split32(this.h, 'little'); | |
19263 | }; | |
19264 | ||
19265 | function f(j, x, y, z) { | |
19266 | if (j <= 15) | |
19267 | return x ^ y ^ z; | |
19268 | else if (j <= 31) | |
19269 | return (x & y) | ((~x) & z); | |
19270 | else if (j <= 47) | |
19271 | return (x | (~y)) ^ z; | |
19272 | else if (j <= 63) | |
19273 | return (x & z) | (y & (~z)); | |
19274 | else | |
19275 | return x ^ (y | (~z)); | |
19276 | } | |
19277 | ||
19278 | function K(j) { | |
19279 | if (j <= 15) | |
19280 | return 0x00000000; | |
19281 | else if (j <= 31) | |
19282 | return 0x5a827999; | |
19283 | else if (j <= 47) | |
19284 | return 0x6ed9eba1; | |
19285 | else if (j <= 63) | |
19286 | return 0x8f1bbcdc; | |
19287 | else | |
19288 | return 0xa953fd4e; | |
19289 | } | |
19290 | ||
19291 | function Kh(j) { | |
19292 | if (j <= 15) | |
19293 | return 0x50a28be6; | |
19294 | else if (j <= 31) | |
19295 | return 0x5c4dd124; | |
19296 | else if (j <= 47) | |
19297 | return 0x6d703ef3; | |
19298 | else if (j <= 63) | |
19299 | return 0x7a6d76e9; | |
19300 | else | |
19301 | return 0x00000000; | |
19302 | } | |
19303 | ||
19304 | var r = [ | |
19305 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, | |
19306 | 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, | |
19307 | 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, | |
19308 | 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, | |
19309 | 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 | |
19310 | ]; | |
19311 | ||
19312 | var rh = [ | |
19313 | 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, | |
19314 | 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, | |
19315 | 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, | |
19316 | 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, | |
19317 | 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 | |
19318 | ]; | |
19319 | ||
19320 | var s = [ | |
19321 | 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, | |
19322 | 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, | |
19323 | 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, | |
19324 | 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, | |
19325 | 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 | |
19326 | ]; | |
19327 | ||
19328 | var sh = [ | |
19329 | 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, | |
19330 | 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, | |
19331 | 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, | |
19332 | 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, | |
19333 | 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 | |
19334 | ]; | |
19335 | ||
19336 | },{"./common":106,"./utils":116}],109:[function(require,module,exports){ | |
19337 | 'use strict'; | |
19338 | ||
19339 | exports.sha1 = require('./sha/1'); | |
19340 | exports.sha224 = require('./sha/224'); | |
19341 | exports.sha256 = require('./sha/256'); | |
19342 | exports.sha384 = require('./sha/384'); | |
19343 | exports.sha512 = require('./sha/512'); | |
19344 | ||
19345 | },{"./sha/1":110,"./sha/224":111,"./sha/256":112,"./sha/384":113,"./sha/512":114}],110:[function(require,module,exports){ | |
19346 | 'use strict'; | |
19347 | ||
19348 | var utils = require('../utils'); | |
19349 | var common = require('../common'); | |
19350 | var shaCommon = require('./common'); | |
19351 | ||
19352 | var rotl32 = utils.rotl32; | |
19353 | var sum32 = utils.sum32; | |
19354 | var sum32_5 = utils.sum32_5; | |
19355 | var ft_1 = shaCommon.ft_1; | |
19356 | var BlockHash = common.BlockHash; | |
19357 | ||
19358 | var sha1_K = [ | |
19359 | 0x5A827999, 0x6ED9EBA1, | |
19360 | 0x8F1BBCDC, 0xCA62C1D6 | |
19361 | ]; | |
19362 | ||
19363 | function SHA1() { | |
19364 | if (!(this instanceof SHA1)) | |
19365 | return new SHA1(); | |
19366 | ||
19367 | BlockHash.call(this); | |
19368 | this.h = [ | |
19369 | 0x67452301, 0xefcdab89, 0x98badcfe, | |
19370 | 0x10325476, 0xc3d2e1f0 ]; | |
19371 | this.W = new Array(80); | |
19372 | } | |
19373 | ||
19374 | utils.inherits(SHA1, BlockHash); | |
19375 | module.exports = SHA1; | |
19376 | ||
19377 | SHA1.blockSize = 512; | |
19378 | SHA1.outSize = 160; | |
19379 | SHA1.hmacStrength = 80; | |
19380 | SHA1.padLength = 64; | |
19381 | ||
19382 | SHA1.prototype._update = function _update(msg, start) { | |
19383 | var W = this.W; | |
19384 | ||
19385 | for (var i = 0; i < 16; i++) | |
19386 | W[i] = msg[start + i]; | |
19387 | ||
19388 | for(; i < W.length; i++) | |
19389 | W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1); | |
19390 | ||
19391 | var a = this.h[0]; | |
19392 | var b = this.h[1]; | |
19393 | var c = this.h[2]; | |
19394 | var d = this.h[3]; | |
19395 | var e = this.h[4]; | |
19396 | ||
19397 | for (i = 0; i < W.length; i++) { | |
19398 | var s = ~~(i / 20); | |
19399 | var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]); | |
19400 | e = d; | |
19401 | d = c; | |
19402 | c = rotl32(b, 30); | |
19403 | b = a; | |
19404 | a = t; | |
19405 | } | |
19406 | ||
19407 | this.h[0] = sum32(this.h[0], a); | |
19408 | this.h[1] = sum32(this.h[1], b); | |
19409 | this.h[2] = sum32(this.h[2], c); | |
19410 | this.h[3] = sum32(this.h[3], d); | |
19411 | this.h[4] = sum32(this.h[4], e); | |
19412 | }; | |
19413 | ||
19414 | SHA1.prototype._digest = function digest(enc) { | |
19415 | if (enc === 'hex') | |
19416 | return utils.toHex32(this.h, 'big'); | |
19417 | else | |
19418 | return utils.split32(this.h, 'big'); | |
19419 | }; | |
19420 | ||
19421 | },{"../common":106,"../utils":116,"./common":115}],111:[function(require,module,exports){ | |
19422 | 'use strict'; | |
19423 | ||
19424 | var utils = require('../utils'); | |
19425 | var SHA256 = require('./256'); | |
19426 | ||
19427 | function SHA224() { | |
19428 | if (!(this instanceof SHA224)) | |
19429 | return new SHA224(); | |
19430 | ||
19431 | SHA256.call(this); | |
19432 | this.h = [ | |
19433 | 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, | |
19434 | 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ]; | |
19435 | } | |
19436 | utils.inherits(SHA224, SHA256); | |
19437 | module.exports = SHA224; | |
19438 | ||
19439 | SHA224.blockSize = 512; | |
19440 | SHA224.outSize = 224; | |
19441 | SHA224.hmacStrength = 192; | |
19442 | SHA224.padLength = 64; | |
19443 | ||
19444 | SHA224.prototype._digest = function digest(enc) { | |
19445 | // Just truncate output | |
19446 | if (enc === 'hex') | |
19447 | return utils.toHex32(this.h.slice(0, 7), 'big'); | |
19448 | else | |
19449 | return utils.split32(this.h.slice(0, 7), 'big'); | |
19450 | }; | |
19451 | ||
19452 | ||
19453 | },{"../utils":116,"./256":112}],112:[function(require,module,exports){ | |
19454 | 'use strict'; | |
19455 | ||
19456 | var utils = require('../utils'); | |
19457 | var common = require('../common'); | |
19458 | var shaCommon = require('./common'); | |
19459 | var assert = require('minimalistic-assert'); | |
19460 | ||
19461 | var sum32 = utils.sum32; | |
19462 | var sum32_4 = utils.sum32_4; | |
19463 | var sum32_5 = utils.sum32_5; | |
19464 | var ch32 = shaCommon.ch32; | |
19465 | var maj32 = shaCommon.maj32; | |
19466 | var s0_256 = shaCommon.s0_256; | |
19467 | var s1_256 = shaCommon.s1_256; | |
19468 | var g0_256 = shaCommon.g0_256; | |
19469 | var g1_256 = shaCommon.g1_256; | |
19470 | ||
19471 | var BlockHash = common.BlockHash; | |
19472 | ||
19473 | var sha256_K = [ | |
19474 | 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, | |
19475 | 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | |
19476 | 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, | |
19477 | 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | |
19478 | 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, | |
19479 | 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | |
19480 | 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, | |
19481 | 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | |
19482 | 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, | |
19483 | 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | |
19484 | 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, | |
19485 | 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | |
19486 | 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, | |
19487 | 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | |
19488 | 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, | |
19489 | 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 | |
19490 | ]; | |
19491 | ||
19492 | function SHA256() { | |
19493 | if (!(this instanceof SHA256)) | |
19494 | return new SHA256(); | |
19495 | ||
19496 | BlockHash.call(this); | |
19497 | this.h = [ | |
19498 | 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, | |
19499 | 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 | |
19500 | ]; | |
19501 | this.k = sha256_K; | |
19502 | this.W = new Array(64); | |
19503 | } | |
19504 | utils.inherits(SHA256, BlockHash); | |
19505 | module.exports = SHA256; | |
19506 | ||
19507 | SHA256.blockSize = 512; | |
19508 | SHA256.outSize = 256; | |
19509 | SHA256.hmacStrength = 192; | |
19510 | SHA256.padLength = 64; | |
19511 | ||
19512 | SHA256.prototype._update = function _update(msg, start) { | |
19513 | var W = this.W; | |
19514 | ||
19515 | for (var i = 0; i < 16; i++) | |
19516 | W[i] = msg[start + i]; | |
19517 | for (; i < W.length; i++) | |
19518 | W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]); | |
19519 | ||
19520 | var a = this.h[0]; | |
19521 | var b = this.h[1]; | |
19522 | var c = this.h[2]; | |
19523 | var d = this.h[3]; | |
19524 | var e = this.h[4]; | |
19525 | var f = this.h[5]; | |
19526 | var g = this.h[6]; | |
19527 | var h = this.h[7]; | |
19528 | ||
19529 | assert(this.k.length === W.length); | |
19530 | for (i = 0; i < W.length; i++) { | |
19531 | var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]); | |
19532 | var T2 = sum32(s0_256(a), maj32(a, b, c)); | |
19533 | h = g; | |
19534 | g = f; | |
19535 | f = e; | |
19536 | e = sum32(d, T1); | |
19537 | d = c; | |
19538 | c = b; | |
19539 | b = a; | |
19540 | a = sum32(T1, T2); | |
19541 | } | |
19542 | ||
19543 | this.h[0] = sum32(this.h[0], a); | |
19544 | this.h[1] = sum32(this.h[1], b); | |
19545 | this.h[2] = sum32(this.h[2], c); | |
19546 | this.h[3] = sum32(this.h[3], d); | |
19547 | this.h[4] = sum32(this.h[4], e); | |
19548 | this.h[5] = sum32(this.h[5], f); | |
19549 | this.h[6] = sum32(this.h[6], g); | |
19550 | this.h[7] = sum32(this.h[7], h); | |
19551 | }; | |
19552 | ||
19553 | SHA256.prototype._digest = function digest(enc) { | |
19554 | if (enc === 'hex') | |
19555 | return utils.toHex32(this.h, 'big'); | |
19556 | else | |
19557 | return utils.split32(this.h, 'big'); | |
19558 | }; | |
19559 | ||
19560 | },{"../common":106,"../utils":116,"./common":115,"minimalistic-assert":360}],113:[function(require,module,exports){ | |
19561 | 'use strict'; | |
19562 | ||
19563 | var utils = require('../utils'); | |
19564 | ||
19565 | var SHA512 = require('./512'); | |
19566 | ||
19567 | function SHA384() { | |
19568 | if (!(this instanceof SHA384)) | |
19569 | return new SHA384(); | |
19570 | ||
19571 | SHA512.call(this); | |
19572 | this.h = [ | |
19573 | 0xcbbb9d5d, 0xc1059ed8, | |
19574 | 0x629a292a, 0x367cd507, | |
19575 | 0x9159015a, 0x3070dd17, | |
19576 | 0x152fecd8, 0xf70e5939, | |
19577 | 0x67332667, 0xffc00b31, | |
19578 | 0x8eb44a87, 0x68581511, | |
19579 | 0xdb0c2e0d, 0x64f98fa7, | |
19580 | 0x47b5481d, 0xbefa4fa4 ]; | |
19581 | } | |
19582 | utils.inherits(SHA384, SHA512); | |
19583 | module.exports = SHA384; | |
19584 | ||
19585 | SHA384.blockSize = 1024; | |
19586 | SHA384.outSize = 384; | |
19587 | SHA384.hmacStrength = 192; | |
19588 | SHA384.padLength = 128; | |
19589 | ||
19590 | SHA384.prototype._digest = function digest(enc) { | |
19591 | if (enc === 'hex') | |
19592 | return utils.toHex32(this.h.slice(0, 12), 'big'); | |
19593 | else | |
19594 | return utils.split32(this.h.slice(0, 12), 'big'); | |
19595 | }; | |
19596 | ||
19597 | },{"../utils":116,"./512":114}],114:[function(require,module,exports){ | |
19598 | 'use strict'; | |
19599 | ||
19600 | var utils = require('../utils'); | |
19601 | var common = require('../common'); | |
19602 | var assert = require('minimalistic-assert'); | |
19603 | ||
19604 | var rotr64_hi = utils.rotr64_hi; | |
19605 | var rotr64_lo = utils.rotr64_lo; | |
19606 | var shr64_hi = utils.shr64_hi; | |
19607 | var shr64_lo = utils.shr64_lo; | |
19608 | var sum64 = utils.sum64; | |
19609 | var sum64_hi = utils.sum64_hi; | |
19610 | var sum64_lo = utils.sum64_lo; | |
19611 | var sum64_4_hi = utils.sum64_4_hi; | |
19612 | var sum64_4_lo = utils.sum64_4_lo; | |
19613 | var sum64_5_hi = utils.sum64_5_hi; | |
19614 | var sum64_5_lo = utils.sum64_5_lo; | |
19615 | ||
19616 | var BlockHash = common.BlockHash; | |
19617 | ||
19618 | var sha512_K = [ | |
19619 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, | |
19620 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, | |
19621 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, | |
19622 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, | |
19623 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, | |
19624 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, | |
19625 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, | |
19626 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, | |
19627 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, | |
19628 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, | |
19629 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, | |
19630 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, | |
19631 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, | |
19632 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, | |
19633 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, | |
19634 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, | |
19635 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, | |
19636 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, | |
19637 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, | |
19638 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, | |
19639 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, | |
19640 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, | |
19641 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, | |
19642 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, | |
19643 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, | |
19644 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, | |
19645 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, | |
19646 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, | |
19647 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, | |
19648 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, | |
19649 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, | |
19650 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, | |
19651 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, | |
19652 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, | |
19653 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, | |
19654 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, | |
19655 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, | |
19656 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, | |
19657 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, | |
19658 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 | |
19659 | ]; | |
19660 | ||
19661 | function SHA512() { | |
19662 | if (!(this instanceof SHA512)) | |
19663 | return new SHA512(); | |
19664 | ||
19665 | BlockHash.call(this); | |
19666 | this.h = [ | |
19667 | 0x6a09e667, 0xf3bcc908, | |
19668 | 0xbb67ae85, 0x84caa73b, | |
19669 | 0x3c6ef372, 0xfe94f82b, | |
19670 | 0xa54ff53a, 0x5f1d36f1, | |
19671 | 0x510e527f, 0xade682d1, | |
19672 | 0x9b05688c, 0x2b3e6c1f, | |
19673 | 0x1f83d9ab, 0xfb41bd6b, | |
19674 | 0x5be0cd19, 0x137e2179 ]; | |
19675 | this.k = sha512_K; | |
19676 | this.W = new Array(160); | |
19677 | } | |
19678 | utils.inherits(SHA512, BlockHash); | |
19679 | module.exports = SHA512; | |
19680 | ||
19681 | SHA512.blockSize = 1024; | |
19682 | SHA512.outSize = 512; | |
19683 | SHA512.hmacStrength = 192; | |
19684 | SHA512.padLength = 128; | |
19685 | ||
19686 | SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) { | |
19687 | var W = this.W; | |
19688 | ||
19689 | // 32 x 32bit words | |
19690 | for (var i = 0; i < 32; i++) | |
19691 | W[i] = msg[start + i]; | |
19692 | for (; i < W.length; i += 2) { | |
19693 | var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2 | |
19694 | var c0_lo = g1_512_lo(W[i - 4], W[i - 3]); | |
19695 | var c1_hi = W[i - 14]; // i - 7 | |
19696 | var c1_lo = W[i - 13]; | |
19697 | var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15 | |
19698 | var c2_lo = g0_512_lo(W[i - 30], W[i - 29]); | |
19699 | var c3_hi = W[i - 32]; // i - 16 | |
19700 | var c3_lo = W[i - 31]; | |
19701 | ||
19702 | W[i] = sum64_4_hi( | |
19703 | c0_hi, c0_lo, | |
19704 | c1_hi, c1_lo, | |
19705 | c2_hi, c2_lo, | |
19706 | c3_hi, c3_lo); | |
19707 | W[i + 1] = sum64_4_lo( | |
19708 | c0_hi, c0_lo, | |
19709 | c1_hi, c1_lo, | |
19710 | c2_hi, c2_lo, | |
19711 | c3_hi, c3_lo); | |
19712 | } | |
19713 | }; | |
19714 | ||
19715 | SHA512.prototype._update = function _update(msg, start) { | |
19716 | this._prepareBlock(msg, start); | |
19717 | ||
19718 | var W = this.W; | |
19719 | ||
19720 | var ah = this.h[0]; | |
19721 | var al = this.h[1]; | |
19722 | var bh = this.h[2]; | |
19723 | var bl = this.h[3]; | |
19724 | var ch = this.h[4]; | |
19725 | var cl = this.h[5]; | |
19726 | var dh = this.h[6]; | |
19727 | var dl = this.h[7]; | |
19728 | var eh = this.h[8]; | |
19729 | var el = this.h[9]; | |
19730 | var fh = this.h[10]; | |
19731 | var fl = this.h[11]; | |
19732 | var gh = this.h[12]; | |
19733 | var gl = this.h[13]; | |
19734 | var hh = this.h[14]; | |
19735 | var hl = this.h[15]; | |
19736 | ||
19737 | assert(this.k.length === W.length); | |
19738 | for (var i = 0; i < W.length; i += 2) { | |
19739 | var c0_hi = hh; | |
19740 | var c0_lo = hl; | |
19741 | var c1_hi = s1_512_hi(eh, el); | |
19742 | var c1_lo = s1_512_lo(eh, el); | |
19743 | var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl); | |
19744 | var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl); | |
19745 | var c3_hi = this.k[i]; | |
19746 | var c3_lo = this.k[i + 1]; | |
19747 | var c4_hi = W[i]; | |
19748 | var c4_lo = W[i + 1]; | |
19749 | ||
19750 | var T1_hi = sum64_5_hi( | |
19751 | c0_hi, c0_lo, | |
19752 | c1_hi, c1_lo, | |
19753 | c2_hi, c2_lo, | |
19754 | c3_hi, c3_lo, | |
19755 | c4_hi, c4_lo); | |
19756 | var T1_lo = sum64_5_lo( | |
19757 | c0_hi, c0_lo, | |
19758 | c1_hi, c1_lo, | |
19759 | c2_hi, c2_lo, | |
19760 | c3_hi, c3_lo, | |
19761 | c4_hi, c4_lo); | |
19762 | ||
19763 | c0_hi = s0_512_hi(ah, al); | |
19764 | c0_lo = s0_512_lo(ah, al); | |
19765 | c1_hi = maj64_hi(ah, al, bh, bl, ch, cl); | |
19766 | c1_lo = maj64_lo(ah, al, bh, bl, ch, cl); | |
19767 | ||
19768 | var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo); | |
19769 | var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo); | |
19770 | ||
19771 | hh = gh; | |
19772 | hl = gl; | |
19773 | ||
19774 | gh = fh; | |
19775 | gl = fl; | |
19776 | ||
19777 | fh = eh; | |
19778 | fl = el; | |
19779 | ||
19780 | eh = sum64_hi(dh, dl, T1_hi, T1_lo); | |
19781 | el = sum64_lo(dl, dl, T1_hi, T1_lo); | |
19782 | ||
19783 | dh = ch; | |
19784 | dl = cl; | |
19785 | ||
19786 | ch = bh; | |
19787 | cl = bl; | |
19788 | ||
19789 | bh = ah; | |
19790 | bl = al; | |
19791 | ||
19792 | ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo); | |
19793 | al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo); | |
19794 | } | |
19795 | ||
19796 | sum64(this.h, 0, ah, al); | |
19797 | sum64(this.h, 2, bh, bl); | |
19798 | sum64(this.h, 4, ch, cl); | |
19799 | sum64(this.h, 6, dh, dl); | |
19800 | sum64(this.h, 8, eh, el); | |
19801 | sum64(this.h, 10, fh, fl); | |
19802 | sum64(this.h, 12, gh, gl); | |
19803 | sum64(this.h, 14, hh, hl); | |
19804 | }; | |
19805 | ||
19806 | SHA512.prototype._digest = function digest(enc) { | |
19807 | if (enc === 'hex') | |
19808 | return utils.toHex32(this.h, 'big'); | |
19809 | else | |
19810 | return utils.split32(this.h, 'big'); | |
19811 | }; | |
19812 | ||
19813 | function ch64_hi(xh, xl, yh, yl, zh) { | |
19814 | var r = (xh & yh) ^ ((~xh) & zh); | |
19815 | if (r < 0) | |
19816 | r += 0x100000000; | |
19817 | return r; | |
19818 | } | |
19819 | ||
19820 | function ch64_lo(xh, xl, yh, yl, zh, zl) { | |
19821 | var r = (xl & yl) ^ ((~xl) & zl); | |
19822 | if (r < 0) | |
19823 | r += 0x100000000; | |
19824 | return r; | |
19825 | } | |
19826 | ||
19827 | function maj64_hi(xh, xl, yh, yl, zh) { | |
19828 | var r = (xh & yh) ^ (xh & zh) ^ (yh & zh); | |
19829 | if (r < 0) | |
19830 | r += 0x100000000; | |
19831 | return r; | |
19832 | } | |
19833 | ||
19834 | function maj64_lo(xh, xl, yh, yl, zh, zl) { | |
19835 | var r = (xl & yl) ^ (xl & zl) ^ (yl & zl); | |
19836 | if (r < 0) | |
19837 | r += 0x100000000; | |
19838 | return r; | |
19839 | } | |
19840 | ||
19841 | function s0_512_hi(xh, xl) { | |
19842 | var c0_hi = rotr64_hi(xh, xl, 28); | |
19843 | var c1_hi = rotr64_hi(xl, xh, 2); // 34 | |
19844 | var c2_hi = rotr64_hi(xl, xh, 7); // 39 | |
19845 | ||
19846 | var r = c0_hi ^ c1_hi ^ c2_hi; | |
19847 | if (r < 0) | |
19848 | r += 0x100000000; | |
19849 | return r; | |
19850 | } | |
19851 | ||
19852 | function s0_512_lo(xh, xl) { | |
19853 | var c0_lo = rotr64_lo(xh, xl, 28); | |
19854 | var c1_lo = rotr64_lo(xl, xh, 2); // 34 | |
19855 | var c2_lo = rotr64_lo(xl, xh, 7); // 39 | |
19856 | ||
19857 | var r = c0_lo ^ c1_lo ^ c2_lo; | |
19858 | if (r < 0) | |
19859 | r += 0x100000000; | |
19860 | return r; | |
19861 | } | |
19862 | ||
19863 | function s1_512_hi(xh, xl) { | |
19864 | var c0_hi = rotr64_hi(xh, xl, 14); | |
19865 | var c1_hi = rotr64_hi(xh, xl, 18); | |
19866 | var c2_hi = rotr64_hi(xl, xh, 9); // 41 | |
19867 | ||
19868 | var r = c0_hi ^ c1_hi ^ c2_hi; | |
19869 | if (r < 0) | |
19870 | r += 0x100000000; | |
19871 | return r; | |
19872 | } | |
19873 | ||
19874 | function s1_512_lo(xh, xl) { | |
19875 | var c0_lo = rotr64_lo(xh, xl, 14); | |
19876 | var c1_lo = rotr64_lo(xh, xl, 18); | |
19877 | var c2_lo = rotr64_lo(xl, xh, 9); // 41 | |
19878 | ||
19879 | var r = c0_lo ^ c1_lo ^ c2_lo; | |
19880 | if (r < 0) | |
19881 | r += 0x100000000; | |
19882 | return r; | |
19883 | } | |
19884 | ||
19885 | function g0_512_hi(xh, xl) { | |
19886 | var c0_hi = rotr64_hi(xh, xl, 1); | |
19887 | var c1_hi = rotr64_hi(xh, xl, 8); | |
19888 | var c2_hi = shr64_hi(xh, xl, 7); | |
19889 | ||
19890 | var r = c0_hi ^ c1_hi ^ c2_hi; | |
19891 | if (r < 0) | |
19892 | r += 0x100000000; | |
19893 | return r; | |
19894 | } | |
19895 | ||
19896 | function g0_512_lo(xh, xl) { | |
19897 | var c0_lo = rotr64_lo(xh, xl, 1); | |
19898 | var c1_lo = rotr64_lo(xh, xl, 8); | |
19899 | var c2_lo = shr64_lo(xh, xl, 7); | |
19900 | ||
19901 | var r = c0_lo ^ c1_lo ^ c2_lo; | |
19902 | if (r < 0) | |
19903 | r += 0x100000000; | |
19904 | return r; | |
19905 | } | |
19906 | ||
19907 | function g1_512_hi(xh, xl) { | |
19908 | var c0_hi = rotr64_hi(xh, xl, 19); | |
19909 | var c1_hi = rotr64_hi(xl, xh, 29); // 61 | |
19910 | var c2_hi = shr64_hi(xh, xl, 6); | |
19911 | ||
19912 | var r = c0_hi ^ c1_hi ^ c2_hi; | |
19913 | if (r < 0) | |
19914 | r += 0x100000000; | |
19915 | return r; | |
19916 | } | |
19917 | ||
19918 | function g1_512_lo(xh, xl) { | |
19919 | var c0_lo = rotr64_lo(xh, xl, 19); | |
19920 | var c1_lo = rotr64_lo(xl, xh, 29); // 61 | |
19921 | var c2_lo = shr64_lo(xh, xl, 6); | |
19922 | ||
19923 | var r = c0_lo ^ c1_lo ^ c2_lo; | |
19924 | if (r < 0) | |
19925 | r += 0x100000000; | |
19926 | return r; | |
19927 | } | |
19928 | ||
19929 | },{"../common":106,"../utils":116,"minimalistic-assert":360}],115:[function(require,module,exports){ | |
19930 | 'use strict'; | |
19931 | ||
19932 | var utils = require('../utils'); | |
19933 | var rotr32 = utils.rotr32; | |
19934 | ||
19935 | function ft_1(s, x, y, z) { | |
19936 | if (s === 0) | |
19937 | return ch32(x, y, z); | |
19938 | if (s === 1 || s === 3) | |
19939 | return p32(x, y, z); | |
19940 | if (s === 2) | |
19941 | return maj32(x, y, z); | |
19942 | } | |
19943 | exports.ft_1 = ft_1; | |
19944 | ||
19945 | function ch32(x, y, z) { | |
19946 | return (x & y) ^ ((~x) & z); | |
19947 | } | |
19948 | exports.ch32 = ch32; | |
19949 | ||
19950 | function maj32(x, y, z) { | |
19951 | return (x & y) ^ (x & z) ^ (y & z); | |
19952 | } | |
19953 | exports.maj32 = maj32; | |
19954 | ||
19955 | function p32(x, y, z) { | |
19956 | return x ^ y ^ z; | |
19957 | } | |
19958 | exports.p32 = p32; | |
19959 | ||
19960 | function s0_256(x) { | |
19961 | return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22); | |
19962 | } | |
19963 | exports.s0_256 = s0_256; | |
19964 | ||
19965 | function s1_256(x) { | |
19966 | return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25); | |
19967 | } | |
19968 | exports.s1_256 = s1_256; | |
19969 | ||
19970 | function g0_256(x) { | |
19971 | return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3); | |
19972 | } | |
19973 | exports.g0_256 = g0_256; | |
19974 | ||
19975 | function g1_256(x) { | |
19976 | return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10); | |
19977 | } | |
19978 | exports.g1_256 = g1_256; | |
19979 | ||
19980 | },{"../utils":116}],116:[function(require,module,exports){ | |
19981 | 'use strict'; | |
19982 | ||
19983 | var assert = require('minimalistic-assert'); | |
19984 | var inherits = require('inherits'); | |
19985 | ||
19986 | exports.inherits = inherits; | |
19987 | ||
19988 | function isSurrogatePair(msg, i) { | |
19989 | if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) { | |
19990 | return false; | |
19991 | } | |
19992 | if (i < 0 || i + 1 >= msg.length) { | |
19993 | return false; | |
19994 | } | |
19995 | return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00; | |
19996 | } | |
19997 | ||
19998 | function toArray(msg, enc) { | |
19999 | if (Array.isArray(msg)) | |
20000 | return msg.slice(); | |
20001 | if (!msg) | |
20002 | return []; | |
20003 | var res = []; | |
20004 | if (typeof msg === 'string') { | |
20005 | if (!enc) { | |
20006 | // Inspired by stringToUtf8ByteArray() in closure-library by Google | |
20007 | // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143 | |
20008 | // Apache License 2.0 | |
20009 | // https://github.com/google/closure-library/blob/master/LICENSE | |
20010 | var p = 0; | |
20011 | for (var i = 0; i < msg.length; i++) { | |
20012 | var c = msg.charCodeAt(i); | |
20013 | if (c < 128) { | |
20014 | res[p++] = c; | |
20015 | } else if (c < 2048) { | |
20016 | res[p++] = (c >> 6) | 192; | |
20017 | res[p++] = (c & 63) | 128; | |
20018 | } else if (isSurrogatePair(msg, i)) { | |
20019 | c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF); | |
20020 | res[p++] = (c >> 18) | 240; | |
20021 | res[p++] = ((c >> 12) & 63) | 128; | |
20022 | res[p++] = ((c >> 6) & 63) | 128; | |
20023 | res[p++] = (c & 63) | 128; | |
20024 | } else { | |
20025 | res[p++] = (c >> 12) | 224; | |
20026 | res[p++] = ((c >> 6) & 63) | 128; | |
20027 | res[p++] = (c & 63) | 128; | |
20028 | } | |
20029 | } | |
20030 | } else if (enc === 'hex') { | |
20031 | msg = msg.replace(/[^a-z0-9]+/ig, ''); | |
20032 | if (msg.length % 2 !== 0) | |
20033 | msg = '0' + msg; | |
20034 | for (i = 0; i < msg.length; i += 2) | |
20035 | res.push(parseInt(msg[i] + msg[i + 1], 16)); | |
20036 | } | |
20037 | } else { | |
20038 | for (i = 0; i < msg.length; i++) | |
20039 | res[i] = msg[i] | 0; | |
20040 | } | |
20041 | return res; | |
20042 | } | |
20043 | exports.toArray = toArray; | |
20044 | ||
20045 | function toHex(msg) { | |
20046 | var res = ''; | |
20047 | for (var i = 0; i < msg.length; i++) | |
20048 | res += zero2(msg[i].toString(16)); | |
20049 | return res; | |
20050 | } | |
20051 | exports.toHex = toHex; | |
20052 | ||
20053 | function htonl(w) { | |
20054 | var res = (w >>> 24) | | |
20055 | ((w >>> 8) & 0xff00) | | |
20056 | ((w << 8) & 0xff0000) | | |
20057 | ((w & 0xff) << 24); | |
20058 | return res >>> 0; | |
20059 | } | |
20060 | exports.htonl = htonl; | |
20061 | ||
20062 | function toHex32(msg, endian) { | |
20063 | var res = ''; | |
20064 | for (var i = 0; i < msg.length; i++) { | |
20065 | var w = msg[i]; | |
20066 | if (endian === 'little') | |
20067 | w = htonl(w); | |
20068 | res += zero8(w.toString(16)); | |
20069 | } | |
20070 | return res; | |
20071 | } | |
20072 | exports.toHex32 = toHex32; | |
20073 | ||
20074 | function zero2(word) { | |
20075 | if (word.length === 1) | |
20076 | return '0' + word; | |
20077 | else | |
20078 | return word; | |
20079 | } | |
20080 | exports.zero2 = zero2; | |
20081 | ||
20082 | function zero8(word) { | |
20083 | if (word.length === 7) | |
20084 | return '0' + word; | |
20085 | else if (word.length === 6) | |
20086 | return '00' + word; | |
20087 | else if (word.length === 5) | |
20088 | return '000' + word; | |
20089 | else if (word.length === 4) | |
20090 | return '0000' + word; | |
20091 | else if (word.length === 3) | |
20092 | return '00000' + word; | |
20093 | else if (word.length === 2) | |
20094 | return '000000' + word; | |
20095 | else if (word.length === 1) | |
20096 | return '0000000' + word; | |
20097 | else | |
20098 | return word; | |
20099 | } | |
20100 | exports.zero8 = zero8; | |
20101 | ||
20102 | function join32(msg, start, end, endian) { | |
20103 | var len = end - start; | |
20104 | assert(len % 4 === 0); | |
20105 | var res = new Array(len / 4); | |
20106 | for (var i = 0, k = start; i < res.length; i++, k += 4) { | |
20107 | var w; | |
20108 | if (endian === 'big') | |
20109 | w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3]; | |
20110 | else | |
20111 | w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k]; | |
20112 | res[i] = w >>> 0; | |
20113 | } | |
20114 | return res; | |
20115 | } | |
20116 | exports.join32 = join32; | |
20117 | ||
20118 | function split32(msg, endian) { | |
20119 | var res = new Array(msg.length * 4); | |
20120 | for (var i = 0, k = 0; i < msg.length; i++, k += 4) { | |
20121 | var m = msg[i]; | |
20122 | if (endian === 'big') { | |
20123 | res[k] = m >>> 24; | |
20124 | res[k + 1] = (m >>> 16) & 0xff; | |
20125 | res[k + 2] = (m >>> 8) & 0xff; | |
20126 | res[k + 3] = m & 0xff; | |
20127 | } else { | |
20128 | res[k + 3] = m >>> 24; | |
20129 | res[k + 2] = (m >>> 16) & 0xff; | |
20130 | res[k + 1] = (m >>> 8) & 0xff; | |
20131 | res[k] = m & 0xff; | |
20132 | } | |
20133 | } | |
20134 | return res; | |
20135 | } | |
20136 | exports.split32 = split32; | |
20137 | ||
20138 | function rotr32(w, b) { | |
20139 | return (w >>> b) | (w << (32 - b)); | |
20140 | } | |
20141 | exports.rotr32 = rotr32; | |
20142 | ||
20143 | function rotl32(w, b) { | |
20144 | return (w << b) | (w >>> (32 - b)); | |
20145 | } | |
20146 | exports.rotl32 = rotl32; | |
20147 | ||
20148 | function sum32(a, b) { | |
20149 | return (a + b) >>> 0; | |
20150 | } | |
20151 | exports.sum32 = sum32; | |
20152 | ||
20153 | function sum32_3(a, b, c) { | |
20154 | return (a + b + c) >>> 0; | |
20155 | } | |
20156 | exports.sum32_3 = sum32_3; | |
20157 | ||
20158 | function sum32_4(a, b, c, d) { | |
20159 | return (a + b + c + d) >>> 0; | |
20160 | } | |
20161 | exports.sum32_4 = sum32_4; | |
20162 | ||
20163 | function sum32_5(a, b, c, d, e) { | |
20164 | return (a + b + c + d + e) >>> 0; | |
20165 | } | |
20166 | exports.sum32_5 = sum32_5; | |
20167 | ||
20168 | function sum64(buf, pos, ah, al) { | |
20169 | var bh = buf[pos]; | |
20170 | var bl = buf[pos + 1]; | |
20171 | ||
20172 | var lo = (al + bl) >>> 0; | |
20173 | var hi = (lo < al ? 1 : 0) + ah + bh; | |
20174 | buf[pos] = hi >>> 0; | |
20175 | buf[pos + 1] = lo; | |
20176 | } | |
20177 | exports.sum64 = sum64; | |
20178 | ||
20179 | function sum64_hi(ah, al, bh, bl) { | |
20180 | var lo = (al + bl) >>> 0; | |
20181 | var hi = (lo < al ? 1 : 0) + ah + bh; | |
20182 | return hi >>> 0; | |
20183 | } | |
20184 | exports.sum64_hi = sum64_hi; | |
20185 | ||
20186 | function sum64_lo(ah, al, bh, bl) { | |
20187 | var lo = al + bl; | |
20188 | return lo >>> 0; | |
20189 | } | |
20190 | exports.sum64_lo = sum64_lo; | |
20191 | ||
20192 | function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) { | |
20193 | var carry = 0; | |
20194 | var lo = al; | |
20195 | lo = (lo + bl) >>> 0; | |
20196 | carry += lo < al ? 1 : 0; | |
20197 | lo = (lo + cl) >>> 0; | |
20198 | carry += lo < cl ? 1 : 0; | |
20199 | lo = (lo + dl) >>> 0; | |
20200 | carry += lo < dl ? 1 : 0; | |
20201 | ||
20202 | var hi = ah + bh + ch + dh + carry; | |
20203 | return hi >>> 0; | |
20204 | } | |
20205 | exports.sum64_4_hi = sum64_4_hi; | |
20206 | ||
20207 | function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) { | |
20208 | var lo = al + bl + cl + dl; | |
20209 | return lo >>> 0; | |
20210 | } | |
20211 | exports.sum64_4_lo = sum64_4_lo; | |
20212 | ||
20213 | function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) { | |
20214 | var carry = 0; | |
20215 | var lo = al; | |
20216 | lo = (lo + bl) >>> 0; | |
20217 | carry += lo < al ? 1 : 0; | |
20218 | lo = (lo + cl) >>> 0; | |
20219 | carry += lo < cl ? 1 : 0; | |
20220 | lo = (lo + dl) >>> 0; | |
20221 | carry += lo < dl ? 1 : 0; | |
20222 | lo = (lo + el) >>> 0; | |
20223 | carry += lo < el ? 1 : 0; | |
20224 | ||
20225 | var hi = ah + bh + ch + dh + eh + carry; | |
20226 | return hi >>> 0; | |
20227 | } | |
20228 | exports.sum64_5_hi = sum64_5_hi; | |
20229 | ||
20230 | function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) { | |
20231 | var lo = al + bl + cl + dl + el; | |
20232 | ||
20233 | return lo >>> 0; | |
20234 | } | |
20235 | exports.sum64_5_lo = sum64_5_lo; | |
20236 | ||
20237 | function rotr64_hi(ah, al, num) { | |
20238 | var r = (al << (32 - num)) | (ah >>> num); | |
20239 | return r >>> 0; | |
20240 | } | |
20241 | exports.rotr64_hi = rotr64_hi; | |
20242 | ||
20243 | function rotr64_lo(ah, al, num) { | |
20244 | var r = (ah << (32 - num)) | (al >>> num); | |
20245 | return r >>> 0; | |
20246 | } | |
20247 | exports.rotr64_lo = rotr64_lo; | |
20248 | ||
20249 | function shr64_hi(ah, al, num) { | |
20250 | return ah >>> num; | |
20251 | } | |
20252 | exports.shr64_hi = shr64_hi; | |
20253 | ||
20254 | function shr64_lo(ah, al, num) { | |
20255 | var r = (ah << (32 - num)) | (al >>> num); | |
20256 | return r >>> 0; | |
20257 | } | |
20258 | exports.shr64_lo = shr64_lo; | |
20259 | ||
20260 | },{"inherits":119,"minimalistic-assert":360}],117:[function(require,module,exports){ | |
20261 | 'use strict'; | |
20262 | ||
20263 | var hash = require('hash.js'); | |
20264 | var utils = require('minimalistic-crypto-utils'); | |
20265 | var assert = require('minimalistic-assert'); | |
20266 | ||
20267 | function HmacDRBG(options) { | |
20268 | if (!(this instanceof HmacDRBG)) | |
20269 | return new HmacDRBG(options); | |
20270 | this.hash = options.hash; | |
20271 | this.predResist = !!options.predResist; | |
20272 | ||
20273 | this.outLen = this.hash.outSize; | |
20274 | this.minEntropy = options.minEntropy || this.hash.hmacStrength; | |
20275 | ||
20276 | this._reseed = null; | |
20277 | this.reseedInterval = null; | |
20278 | this.K = null; | |
20279 | this.V = null; | |
20280 | ||
20281 | var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex'); | |
20282 | var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex'); | |
20283 | var pers = utils.toArray(options.pers, options.persEnc || 'hex'); | |
20284 | assert(entropy.length >= (this.minEntropy / 8), | |
20285 | 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits'); | |
20286 | this._init(entropy, nonce, pers); | |
20287 | } | |
20288 | module.exports = HmacDRBG; | |
20289 | ||
20290 | HmacDRBG.prototype._init = function init(entropy, nonce, pers) { | |
20291 | var seed = entropy.concat(nonce).concat(pers); | |
20292 | ||
20293 | this.K = new Array(this.outLen / 8); | |
20294 | this.V = new Array(this.outLen / 8); | |
20295 | for (var i = 0; i < this.V.length; i++) { | |
20296 | this.K[i] = 0x00; | |
20297 | this.V[i] = 0x01; | |
20298 | } | |
20299 | ||
20300 | this._update(seed); | |
20301 | this._reseed = 1; | |
20302 | this.reseedInterval = 0x1000000000000; // 2^48 | |
20303 | }; | |
20304 | ||
20305 | HmacDRBG.prototype._hmac = function hmac() { | |
20306 | return new hash.hmac(this.hash, this.K); | |
20307 | }; | |
20308 | ||
20309 | HmacDRBG.prototype._update = function update(seed) { | |
20310 | var kmac = this._hmac() | |
20311 | .update(this.V) | |
20312 | .update([ 0x00 ]); | |
20313 | if (seed) | |
20314 | kmac = kmac.update(seed); | |
20315 | this.K = kmac.digest(); | |
20316 | this.V = this._hmac().update(this.V).digest(); | |
20317 | if (!seed) | |
20318 | return; | |
20319 | ||
20320 | this.K = this._hmac() | |
20321 | .update(this.V) | |
20322 | .update([ 0x01 ]) | |
20323 | .update(seed) | |
20324 | .digest(); | |
20325 | this.V = this._hmac().update(this.V).digest(); | |
20326 | }; | |
20327 | ||
20328 | HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) { | |
20329 | // Optional entropy enc | |
20330 | if (typeof entropyEnc !== 'string') { | |
20331 | addEnc = add; | |
20332 | add = entropyEnc; | |
20333 | entropyEnc = null; | |
20334 | } | |
20335 | ||
20336 | entropy = utils.toArray(entropy, entropyEnc); | |
20337 | add = utils.toArray(add, addEnc); | |
20338 | ||
20339 | assert(entropy.length >= (this.minEntropy / 8), | |
20340 | 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits'); | |
20341 | ||
20342 | this._update(entropy.concat(add || [])); | |
20343 | this._reseed = 1; | |
20344 | }; | |
20345 | ||
20346 | HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) { | |
20347 | if (this._reseed > this.reseedInterval) | |
20348 | throw new Error('Reseed is required'); | |
20349 | ||
20350 | // Optional encoding | |
20351 | if (typeof enc !== 'string') { | |
20352 | addEnc = add; | |
20353 | add = enc; | |
20354 | enc = null; | |
20355 | } | |
20356 | ||
20357 | // Optional additional data | |
20358 | if (add) { | |
20359 | add = utils.toArray(add, addEnc || 'hex'); | |
20360 | this._update(add); | |
20361 | } | |
20362 | ||
20363 | var temp = []; | |
20364 | while (temp.length < len) { | |
20365 | this.V = this._hmac().update(this.V).digest(); | |
20366 | temp = temp.concat(this.V); | |
20367 | } | |
20368 | ||
20369 | var res = temp.slice(0, len); | |
20370 | this._update(add); | |
20371 | this._reseed++; | |
20372 | return utils.encode(res, enc); | |
20373 | }; | |
20374 | ||
20375 | },{"hash.js":105,"minimalistic-assert":360,"minimalistic-crypto-utils":361}],118:[function(require,module,exports){ | |
20376 | exports.read = function (buffer, offset, isLE, mLen, nBytes) { | |
20377 | var e, m | |
20378 | var eLen = (nBytes * 8) - mLen - 1 | |
20379 | var eMax = (1 << eLen) - 1 | |
20380 | var eBias = eMax >> 1 | |
20381 | var nBits = -7 | |
20382 | var i = isLE ? (nBytes - 1) : 0 | |
20383 | var d = isLE ? -1 : 1 | |
20384 | var s = buffer[offset + i] | |
20385 | ||
20386 | i += d | |
20387 | ||
20388 | e = s & ((1 << (-nBits)) - 1) | |
20389 | s >>= (-nBits) | |
20390 | nBits += eLen | |
20391 | for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} | |
20392 | ||
20393 | m = e & ((1 << (-nBits)) - 1) | |
20394 | e >>= (-nBits) | |
20395 | nBits += mLen | |
20396 | for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} | |
20397 | ||
20398 | if (e === 0) { | |
20399 | e = 1 - eBias | |
20400 | } else if (e === eMax) { | |
20401 | return m ? NaN : ((s ? -1 : 1) * Infinity) | |
20402 | } else { | |
20403 | m = m + Math.pow(2, mLen) | |
20404 | e = e - eBias | |
20405 | } | |
20406 | return (s ? -1 : 1) * m * Math.pow(2, e - mLen) | |
20407 | } | |
20408 | ||
20409 | exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { | |
20410 | var e, m, c | |
20411 | var eLen = (nBytes * 8) - mLen - 1 | |
20412 | var eMax = (1 << eLen) - 1 | |
20413 | var eBias = eMax >> 1 | |
20414 | var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) | |
20415 | var i = isLE ? 0 : (nBytes - 1) | |
20416 | var d = isLE ? 1 : -1 | |
20417 | var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 | |
20418 | ||
20419 | value = Math.abs(value) | |
20420 | ||
20421 | if (isNaN(value) || value === Infinity) { | |
20422 | m = isNaN(value) ? 1 : 0 | |
20423 | e = eMax | |
20424 | } else { | |
20425 | e = Math.floor(Math.log(value) / Math.LN2) | |
20426 | if (value * (c = Math.pow(2, -e)) < 1) { | |
20427 | e-- | |
20428 | c *= 2 | |
20429 | } | |
20430 | if (e + eBias >= 1) { | |
20431 | value += rt / c | |
20432 | } else { | |
20433 | value += rt * Math.pow(2, 1 - eBias) | |
20434 | } | |
20435 | if (value * c >= 2) { | |
20436 | e++ | |
20437 | c /= 2 | |
20438 | } | |
20439 | ||
20440 | if (e + eBias >= eMax) { | |
20441 | m = 0 | |
20442 | e = eMax | |
20443 | } else if (e + eBias >= 1) { | |
20444 | m = ((value * c) - 1) * Math.pow(2, mLen) | |
20445 | e = e + eBias | |
20446 | } else { | |
20447 | m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) | |
20448 | e = 0 | |
20449 | } | |
20450 | } | |
20451 | ||
20452 | for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} | |
20453 | ||
20454 | e = (e << mLen) | m | |
20455 | eLen += mLen | |
20456 | for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} | |
20457 | ||
20458 | buffer[offset + i - d] |= s * 128 | |
20459 | } | |
20460 | ||
20461 | },{}],119:[function(require,module,exports){ | |
20462 | if (typeof Object.create === 'function') { | |
20463 | // implementation from standard node.js 'util' module | |
20464 | module.exports = function inherits(ctor, superCtor) { | |
20465 | ctor.super_ = superCtor | |
20466 | ctor.prototype = Object.create(superCtor.prototype, { | |
20467 | constructor: { | |
20468 | value: ctor, | |
20469 | enumerable: false, | |
20470 | writable: true, | |
20471 | configurable: true | |
20472 | } | |
20473 | }); | |
20474 | }; | |
20475 | } else { | |
20476 | // old school shim for old browsers | |
20477 | module.exports = function inherits(ctor, superCtor) { | |
20478 | ctor.super_ = superCtor | |
20479 | var TempCtor = function () {} | |
20480 | TempCtor.prototype = superCtor.prototype | |
20481 | ctor.prototype = new TempCtor() | |
20482 | ctor.prototype.constructor = ctor | |
20483 | } | |
20484 | } | |
20485 | ||
20486 | },{}],120:[function(require,module,exports){ | |
20487 | /*! | |
20488 | * Determine if an object is a Buffer | |
20489 | * | |
20490 | * @author Feross Aboukhadijeh <https://feross.org> | |
20491 | * @license MIT | |
20492 | */ | |
20493 | ||
20494 | // The _isBuffer check is for Safari 5-7 support, because it's missing | |
20495 | // Object.prototype.constructor. Remove this eventually | |
20496 | module.exports = function (obj) { | |
20497 | return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) | |
20498 | } | |
20499 | ||
20500 | function isBuffer (obj) { | |
20501 | return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) | |
20502 | } | |
20503 | ||
20504 | // For Node v0.10 support. Remove this eventually. | |
20505 | function isSlowBuffer (obj) { | |
20506 | return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) | |
20507 | } | |
20508 | ||
20509 | },{}],121:[function(require,module,exports){ | |
20510 | var toString = {}.toString; | |
20511 | ||
20512 | module.exports = Array.isArray || function (arr) { | |
20513 | return toString.call(arr) == '[object Array]'; | |
20514 | }; | |
20515 | ||
20516 | },{}],122:[function(require,module,exports){ | |
20517 | (function (process,global,Buffer,__argument0,__argument1,__argument2,__argument3,__dirname){ | |
20518 | var nacl_factory = { | |
20519 | instantiate: function (on_ready, optionsOpt) { | |
20520 | var options = optionsOpt || {}; | |
20521 | var undefined_reference_value = (function (v) { return v; })(); | |
20522 | var requested_total_memory = options.requested_total_memory || undefined_reference_value; | |
20523 | ||
20524 | if (typeof on_ready !== 'function') { | |
20525 | throw new Error("nacl_factory: Expects on_ready callback as first argument. New in v1.1.0."); | |
20526 | } | |
20527 | ||
20528 | return (function (window, document) { | |
20529 | var Module = { | |
20530 | TOTAL_MEMORY: requested_total_memory | |
20531 | }; | |
20532 | var nacl_raw = Module; | |
20533 | var Module; | |
20534 | if (typeof Module === 'undefined') { | |
20535 | Module = {}; | |
20536 | } | |
20537 | var root = Module; | |
20538 | if (typeof root['sodium'] !== 'object') { | |
20539 | if (typeof global === 'object') { | |
20540 | root = global; | |
20541 | } else if (typeof window === 'object') { | |
20542 | root = window; | |
20543 | } | |
20544 | } | |
20545 | if (typeof root['sodium'] === 'object' && typeof root['sodium']['totalMemory'] === 'number') { | |
20546 | Module['TOTAL_MEMORY'] = root['sodium']['totalMemory']; | |
20547 | } | |
20548 | var _Module = Module; | |
20549 | Module.ready = new Promise(function (resolve, reject) { | |
20550 | var Module = _Module; | |
20551 | Module.onAbort = reject; | |
20552 | Module.onRuntimeInitialized = function () { | |
20553 | try { | |
20554 | /* Test arbitrary wasm function */ | |
20555 | Module._crypto_secretbox_keybytes(); | |
20556 | resolve(); | |
20557 | } catch (err) { | |
20558 | reject(err); | |
20559 | } | |
20560 | }; | |
20561 | Module.useBackupModule = function () { | |
20562 | var Module = _Module; | |
20563 | Object.keys(Module).forEach(function(k) { | |
20564 | if (k !== 'getRandomValue') { | |
20565 | delete Module[k]; | |
20566 | } | |
20567 | }); | |
20568 | var Module=typeof Module!=="undefined"?Module:{};var moduleOverrides={};var key;for(key in Module){if(Module.hasOwnProperty(key)){moduleOverrides[key]=Module[key]}}Module["arguments"]=[];Module["thisProgram"]="./this.program";Module["quit"]=(function(status,toThrow){throw toThrow});Module["preRun"]=[];Module["postRun"]=[];var ENVIRONMENT_IS_WEB=false;var ENVIRONMENT_IS_WORKER=false;var ENVIRONMENT_IS_NODE=false;var ENVIRONMENT_IS_SHELL=false;ENVIRONMENT_IS_WEB=typeof window==="object";ENVIRONMENT_IS_WORKER=typeof importScripts==="function";ENVIRONMENT_IS_NODE=typeof process==="object"&&typeof require==="function"&&!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_WORKER;ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}else{return scriptDirectory+path}}if(ENVIRONMENT_IS_NODE){scriptDirectory=__dirname+"/";var nodeFS;var nodePath;Module["read"]=function shell_read(filename,binary){var ret;ret=tryParseAsDataURI(filename);if(!ret){if(!nodeFS)nodeFS=require("fs");if(!nodePath)nodePath=require("path");filename=nodePath["normalize"](filename);ret=nodeFS["readFileSync"](filename)}return binary?ret:ret.toString()};Module["readBinary"]=function readBinary(filename){var ret=Module["read"](filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};if(process["argv"].length>1){Module["thisProgram"]=process["argv"][1].replace(/\\/g,"/")}Module["arguments"]=process["argv"].slice(2);if(typeof module!=="undefined"){module["exports"]=Module}process["on"]("unhandledRejection",abort);Module["quit"]=(function(status){process["exit"](status)});Module["inspect"]=(function(){return"[Emscripten Module object]"})}else if(ENVIRONMENT_IS_SHELL){if(typeof read!="undefined"){Module["read"]=function shell_read(f){var data=tryParseAsDataURI(f);if(data){return intArrayToString(data)}return read(f)}}Module["readBinary"]=function readBinary(f){var data;data=tryParseAsDataURI(f);if(data){return data}if(typeof readbuffer==="function"){return new Uint8Array(readbuffer(f))}data=read(f,"binary");assert(typeof data==="object");return data};if(typeof scriptArgs!="undefined"){Module["arguments"]=scriptArgs}else if(typeof arguments!="undefined"){Module["arguments"]=arguments}if(typeof quit==="function"){Module["quit"]=(function(status){quit(status)})}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(document.currentScript){scriptDirectory=document.currentScript.src}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.lastIndexOf("/")+1)}else{scriptDirectory=""}Module["read"]=function shell_read(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){Module["readBinary"]=function readBinary(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}}}Module["readAsync"]=function readAsync(url,onload,onerror){var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=function xhr_onload(){if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror()};xhr.onerror=onerror;xhr.send(null)};Module["setWindowTitle"]=(function(title){document.title=title})}else{}var out=Module["print"]||(typeof console!=="undefined"?console.log.bind(console):typeof print!=="undefined"?print:null);var err=Module["printErr"]||(typeof printErr!=="undefined"?printErr:typeof console!=="undefined"&&console.warn.bind(console)||out);for(key in moduleOverrides){if(moduleOverrides.hasOwnProperty(key)){Module[key]=moduleOverrides[key]}}moduleOverrides=undefined;var STACK_ALIGN=16;function staticAlloc(size){var ret=STATICTOP;STATICTOP=STATICTOP+size+15&-16;return ret}function dynamicAlloc(size){var ret=HEAP32[DYNAMICTOP_PTR>>2];var end=ret+size+15&-16;HEAP32[DYNAMICTOP_PTR>>2]=end;if(end>=TOTAL_MEMORY){var success=enlargeMemory();if(!success){HEAP32[DYNAMICTOP_PTR>>2]=ret;return 0}}return ret}function alignMemory(size,factor){if(!factor)factor=STACK_ALIGN;var ret=size=Math.ceil(size/factor)*factor;return ret}function getNativeTypeSize(type){switch(type){case"i1":case"i8":return 1;case"i16":return 2;case"i32":return 4;case"i64":return 8;case"float":return 4;case"double":return 8;default:{if(type[type.length-1]==="*"){return 4}else if(type[0]==="i"){var bits=parseInt(type.substr(1));assert(bits%8===0);return bits/8}else{return 0}}}}function warnOnce(text){if(!warnOnce.shown)warnOnce.shown={};if(!warnOnce.shown[text]){warnOnce.shown[text]=1;err(text)}}var jsCallStartIndex=1;var functionPointers=new Array(8);var funcWrappers={};function dynCall(sig,ptr,args){if(args&&args.length){return Module["dynCall_"+sig].apply(null,[ptr].concat(args))}else{return Module["dynCall_"+sig].call(null,ptr)}}var GLOBAL_BASE=8;var ABORT=false;var EXITSTATUS=0;function assert(condition,text){if(!condition){abort("Assertion failed: "+text)}}function getCFunc(ident){var func=Module["_"+ident];assert(func,"Cannot call unknown function "+ident+", make sure it is exported");return func}var JSfuncs={"stackSave":(function(){stackSave()}),"stackRestore":(function(){stackRestore()}),"arrayToC":(function(arr){var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}),"stringToC":(function(str){var ret=0;if(str!==null&&str!==undefined&&str!==0){var len=(str.length<<2)+1;ret=stackAlloc(len);stringToUTF8(str,ret,len)}return ret})};var toC={"string":JSfuncs["stringToC"],"array":JSfuncs["arrayToC"]};function ccall(ident,returnType,argTypes,args,opts){function convertReturnValue(ret){if(returnType==="string")return Pointer_stringify(ret);if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func.apply(null,cArgs);ret=convertReturnValue(ret);if(stack!==0)stackRestore(stack);return ret}function setValue(ptr,value,type,noSafe){type=type||"i8";if(type.charAt(type.length-1)==="*")type="i32";switch(type){case"i1":HEAP8[ptr>>0]=value;break;case"i8":HEAP8[ptr>>0]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":tempI64=[value>>>0,(tempDouble=value,+Math_abs(tempDouble)>=+1?tempDouble>+0?(Math_min(+Math_floor(tempDouble/+4294967296),+4294967295)|0)>>>0:~~+Math_ceil((tempDouble- +(~~tempDouble>>>0))/+4294967296)>>>0:0)],HEAP32[ptr>>2]=tempI64[0],HEAP32[ptr+4>>2]=tempI64[1];break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;default:abort("invalid type for setValue: "+type)}}function getValue(ptr,type,noSafe){type=type||"i8";if(type.charAt(type.length-1)==="*")type="i32";switch(type){case"i1":return HEAP8[ptr>>0];case"i8":return HEAP8[ptr>>0];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":return HEAP32[ptr>>2];case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];default:abort("invalid type for getValue: "+type)}return null}var ALLOC_STATIC=2;var ALLOC_NONE=4;function Pointer_stringify(ptr,length){if(length===0||!ptr)return"";var hasUtf=0;var t;var i=0;while(1){t=HEAPU8[ptr+i>>0];hasUtf|=t;if(t==0&&!length)break;i++;if(length&&i==length)break}if(!length)length=i;var ret="";if(hasUtf<128){var MAX_CHUNK=1024;var curr;while(length>0){curr=String.fromCharCode.apply(String,HEAPU8.subarray(ptr,ptr+Math.min(length,MAX_CHUNK)));ret=ret?ret+curr:curr;ptr+=MAX_CHUNK;length-=MAX_CHUNK}return ret}return UTF8ToString(ptr)}var UTF8Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(u8Array,idx){var endPtr=idx;while(u8Array[endPtr])++endPtr;if(endPtr-idx>16&&u8Array.subarray&&UTF8Decoder){return UTF8Decoder.decode(u8Array.subarray(idx,endPtr))}else{var u0,u1,u2,u3,u4,u5;var str="";while(1){u0=u8Array[idx++];if(!u0)return str;if(!(u0&128)){str+=String.fromCharCode(u0);continue}u1=u8Array[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}u2=u8Array[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u3=u8Array[idx++]&63;if((u0&248)==240){u0=(u0&7)<<18|u1<<12|u2<<6|u3}else{u4=u8Array[idx++]&63;if((u0&252)==248){u0=(u0&3)<<24|u1<<18|u2<<12|u3<<6|u4}else{u5=u8Array[idx++]&63;u0=(u0&1)<<30|u1<<24|u2<<18|u3<<12|u4<<6|u5}}}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}}}function UTF8ToString(ptr){return UTF8ArrayToString(HEAPU8,ptr)}function stringToUTF8Array(str,outU8Array,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;outU8Array[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;outU8Array[outIdx++]=192|u>>6;outU8Array[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;outU8Array[outIdx++]=224|u>>12;outU8Array[outIdx++]=128|u>>6&63;outU8Array[outIdx++]=128|u&63}else if(u<=2097151){if(outIdx+3>=endIdx)break;outU8Array[outIdx++]=240|u>>18;outU8Array[outIdx++]=128|u>>12&63;outU8Array[outIdx++]=128|u>>6&63;outU8Array[outIdx++]=128|u&63}else if(u<=67108863){if(outIdx+4>=endIdx)break;outU8Array[outIdx++]=248|u>>24;outU8Array[outIdx++]=128|u>>18&63;outU8Array[outIdx++]=128|u>>12&63;outU8Array[outIdx++]=128|u>>6&63;outU8Array[outIdx++]=128|u&63}else{if(outIdx+5>=endIdx)break;outU8Array[outIdx++]=252|u>>30;outU8Array[outIdx++]=128|u>>24&63;outU8Array[outIdx++]=128|u>>18&63;outU8Array[outIdx++]=128|u>>12&63;outU8Array[outIdx++]=128|u>>6&63;outU8Array[outIdx++]=128|u&63}}outU8Array[outIdx]=0;return outIdx-startIdx}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127){++len}else if(u<=2047){len+=2}else if(u<=65535){len+=3}else if(u<=2097151){len+=4}else if(u<=67108863){len+=5}else{len+=6}}return len}var UTF16Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf-16le"):undefined;function demangle(func){return func}function demangleAll(text){var regex=/__Z[\w\d_]+/g;return text.replace(regex,(function(x){var y=demangle(x);return x===y?x:y+" ["+x+"]"}))}function jsStackTrace(){var err=new Error;if(!err.stack){try{throw new Error(0)}catch(e){err=e}if(!err.stack){return"(no stack trace available)"}}return err.stack.toString()}var PAGE_SIZE=16384;var WASM_PAGE_SIZE=65536;var ASMJS_PAGE_SIZE=16777216;var MIN_TOTAL_MEMORY=16777216;function alignUp(x,multiple){if(x%multiple>0){x+=multiple-x%multiple}return x}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBuffer(buf){Module["buffer"]=buffer=buf}function updateGlobalBufferViews(){Module["HEAP8"]=HEAP8=new Int8Array(buffer);Module["HEAP16"]=HEAP16=new Int16Array(buffer);Module["HEAP32"]=HEAP32=new Int32Array(buffer);Module["HEAPU8"]=HEAPU8=new Uint8Array(buffer);Module["HEAPU16"]=HEAPU16=new Uint16Array(buffer);Module["HEAPU32"]=HEAPU32=new Uint32Array(buffer);Module["HEAPF32"]=HEAPF32=new Float32Array(buffer);Module["HEAPF64"]=HEAPF64=new Float64Array(buffer)}var STATIC_BASE,STATICTOP,staticSealed;var STACK_BASE,STACKTOP,STACK_MAX;var DYNAMIC_BASE,DYNAMICTOP_PTR;STATIC_BASE=STATICTOP=STACK_BASE=STACKTOP=STACK_MAX=DYNAMIC_BASE=DYNAMICTOP_PTR=0;staticSealed=false;function abortOnCannotGrowMemory(){abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value "+TOTAL_MEMORY+", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or (4) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ")}if(!Module["reallocBuffer"])Module["reallocBuffer"]=(function(size){var ret;try{var oldHEAP8=HEAP8;ret=new ArrayBuffer(size);var temp=new Int8Array(ret);temp.set(oldHEAP8)}catch(e){return false}var success=_emscripten_replace_memory(ret);if(!success)return false;return ret});function enlargeMemory(){var PAGE_MULTIPLE=Module["usingWasm"]?WASM_PAGE_SIZE:ASMJS_PAGE_SIZE;var LIMIT=2147483648-PAGE_MULTIPLE;if(HEAP32[DYNAMICTOP_PTR>>2]>LIMIT){return false}var OLD_TOTAL_MEMORY=TOTAL_MEMORY;TOTAL_MEMORY=Math.max(TOTAL_MEMORY,MIN_TOTAL_MEMORY);while(TOTAL_MEMORY<HEAP32[DYNAMICTOP_PTR>>2]){if(TOTAL_MEMORY<=536870912){TOTAL_MEMORY=alignUp(2*TOTAL_MEMORY,PAGE_MULTIPLE)}else{TOTAL_MEMORY=Math.min(alignUp((3*TOTAL_MEMORY+2147483648)/4,PAGE_MULTIPLE),LIMIT)}}var replacement=Module["reallocBuffer"](TOTAL_MEMORY);if(!replacement||replacement.byteLength!=TOTAL_MEMORY){TOTAL_MEMORY=OLD_TOTAL_MEMORY;return false}updateGlobalBuffer(replacement);updateGlobalBufferViews();return true}var byteLength;try{byteLength=Function.prototype.call.bind(Object.getOwnPropertyDescriptor(ArrayBuffer.prototype,"byteLength").get);byteLength(new ArrayBuffer(4))}catch(e){byteLength=(function(buffer){return buffer.byteLength})}var TOTAL_STACK=Module["TOTAL_STACK"]||5242880;var TOTAL_MEMORY=Module["TOTAL_MEMORY"]||16777216;if(TOTAL_MEMORY<TOTAL_STACK)err("TOTAL_MEMORY should be larger than TOTAL_STACK, was "+TOTAL_MEMORY+"! (TOTAL_STACK="+TOTAL_STACK+")");if(Module["buffer"]){buffer=Module["buffer"]}else{{buffer=new ArrayBuffer(TOTAL_MEMORY)}Module["buffer"]=buffer}updateGlobalBufferViews();function getTotalMemory(){return TOTAL_MEMORY}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback();continue}var func=callback.func;if(typeof func==="number"){if(callback.arg===undefined){Module["dynCall_v"](func)}else{Module["dynCall_vi"](func,callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var __ATPRERUN__=[];var __ATINIT__=[];var __ATMAIN__=[];var __ATEXIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;var runtimeExited=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function ensureInitRuntime(){if(runtimeInitialized)return;runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function preMain(){callRuntimeCallbacks(__ATMAIN__)}function exitRuntime(){callRuntimeCallbacks(__ATEXIT__);runtimeExited=true}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}function writeArrayToMemory(array,buffer){HEAP8.set(array,buffer)}function writeAsciiToMemory(str,buffer,dontAddNull){for(var i=0;i<str.length;++i){HEAP8[buffer++>>0]=str.charCodeAt(i)}if(!dontAddNull)HEAP8[buffer>>0]=0}var Math_abs=Math.abs;var Math_ceil=Math.ceil;var Math_floor=Math.floor;var Math_min=Math.min;var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}Module["preloadedImages"]={};Module["preloadedAudios"]={};var memoryInitializer=null;var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return String.prototype.startsWith?filename.startsWith(dataURIPrefix):filename.indexOf(dataURIPrefix)===0}var ASM_CONSTS=[(function(){return Module.getRandomValue()}),(function(){if(Module.getRandomValue===undefined){try{var window_="object"===typeof window?window:self;var crypto_=typeof window_.crypto!=="undefined"?window_.crypto:window_.msCrypto;var randomValuesStandard=(function(){var buf=new Uint32Array(1);crypto_.getRandomValues(buf);return buf[0]>>>0});randomValuesStandard();Module.getRandomValue=randomValuesStandard}catch(e){try{var crypto=require("crypto");var randomValueNodeJS=(function(){var buf=crypto["randomBytes"](4);return(buf[0]<<24|buf[1]<<16|buf[2]<<8|buf[3])>>>0});randomValueNodeJS();Module.getRandomValue=randomValueNodeJS}catch(e){throw"No secure random number generator found"}}}})];function _emscripten_asm_const_i(code){return ASM_CONSTS[code]()}STATIC_BASE=GLOBAL_BASE;STATICTOP=STATIC_BASE+36016;__ATINIT__.push();memoryInitializer="data:application/octet-stream;base64,AAAAAAAAAAC2eFn/hXLTAL1uFf8PCmoAKcABAJjoef+8PKD/mXHO/wC34v60DUj/AAAAAAAAAACwoA7+08mG/54YjwB/aTUAYAy9AKfX+/+fTID+amXh/x78BACSDK4AAAAAAAAAAABZ8bL+CuWm/3vdKv4eFNQAUoADADDR8wB3eUD/MuOc/wBuxQFnG5AAAAAAAAAAAACFO4wBvfEk//glwwFg3DcAt0w+/8NCPQAyTKQB4aRM/0w9o/91Ph8AUZFA/3ZBDgCic9b/BoouAHzm9P8Kio8ANBrCALj0TACBjykBvvQT/3uqev9igUQAedWTAFZlHv+hZ5sAjFlD/+/lvgFDC7UAxvCJ/u5FvP9Dl+4AEyps/+VVcQEyRIf/EWoJADJnAf9QAagBI5ge/xCouQE4Wej/ZdL8ACn6RwDMqk//Di7v/1BN7wC91kv/EY35ACZQTP++VXUAVuSqAJzY0AHDz6T/lkJM/6/hEP+NUGIBTNvyAMaicgAu2pgAmyvx/pugaP8zu6UAAhGvAEJUoAH3Oh4AI0E1/kXsvwAthvUBo3vdACBuFP80F6UAutZHAOmwYADy7zYBOVmKAFMAVP+IoGQAXI54/mh8vgC1sT7/+ilVAJiCKgFg/PYAl5c//u+FPgAgOJwALae9/46FswGDVtMAu7OW/vqqDv/So04AJTSXAGNNGgDunNX/1cDRAUkuVAAUQSkBNs5PAMmDkv6qbxj/sSEy/qsmy/9O93QA0d2ZAIWAsgE6LBkAySc7Ab0T/AAx5dIBdbt1ALWzuAEActsAMF6TAPUpOAB9Dcz+9K13ACzdIP5U6hQA+aDGAex+6v8vY6j+quKZ/2az2ADijXr/ekKZ/rb1hgDj5BkB1jnr/9itOP+159IAd4Cd/4FfiP9ufjMAAqm3/weCYv5FsF7/dATjAdnykf/KrR8BaQEn/y6vRQDkLzr/1+BF/s84Rf8Q/ov/F8/U/8oUfv9f1WD/CbAhAMgFz//xKoD+IyHA//jlxAGBEXgA+2eX/wc0cP+MOEL/KOL1/9lGJf6s1gn/SEOGAZLA1v8sJnAARLhL/85a+wCV640Atao6AHT07wBcnQIAZq1iAOmJYAF/McsABZuUABeUCf/TegwAIoYa/9vMiACGCCn/4FMr/lUZ9wBtfwD+qYgwAO532//nrdUAzhL+/gi6B/9+CQcBbypIAG807P5gP40Ak79//s1OwP8Oau0Bu9tMAK/zu/5pWa0AVRlZAaLzlAACdtH+IZ4JAIujLv9dRigAbCqO/m/8jv+b35AAM+Wn/0n8m/9edAz/mKDa/5zuJf+z6s//xQCz/5qkjQDhxGgACiMZ/tHU8v9h/d7+uGXlAN4SfwGkiIf/Hs+M/pJh8wCBwBr+yVQh/28KTv+TUbL/BAQYAKHu1/8GjSEANdcO/ym10P/ni50As8vd//+5cQC94qz/cULW/8o+Lf9mQAj/Tq4Q/oV1RP+FO4wBvfEk//glwwFg3DcAt0w+/8NCPQAyTKQB4aRM/0w9o/91Ph8AUZFA/3ZBDgCic9b/BoouAHzm9P8Kio8ANBrCALj0TACBjykBvvQT/3uqev9igUQAedWTAFZlHv+hZ5sAjFlD/+/lvgFDC7UAxvCJ/u5FvP/qcTz/Jf85/0Wytv6A0LMAdhp9/gMH1v/xMk3/VcvF/9OH+v8ZMGT/u9W0/hFYaQBT0Z4BBXNiAASuPP6rN27/2bUR/xS8qgCSnGb+V9au/3J6mwHpLKoAfwjvAdbs6gCvBdsAMWo9/wZC0P8Cam7/UeoT/9drwP9Dl+4AEyps/+VVcQEyRIf/EWoJADJnAf9QAagBI5ge/xCouQE4Wej/ZdL8ACn6RwDMqk//Di7v/1BN7wC91kv/EY35ACZQTP++VXUAVuSqAJzY0AHDz6T/lkJM/6/hEP+NUGIBTNvyAMaicgAu2pgAmyvx/pugaP+yCfz+ZG7UAA4FpwDp76P/HJedAWWSCv/+nkb+R/nkAFgeMgBEOqD/vxhoAYFCgf/AMlX/CLOK/yb6yQBzUKAAg+ZxAH1YkwBaRMcA/UyeABz/dgBx+v4AQksuAObaKwDleLoBlEQrAIh87gG7a8X/VDX2/zN0/v8zu6UAAhGvAEJUoAH3Oh4AI0E1/kXsvwAthvUBo3vdACBuFP80F6UAutZHAOmwYADy7zYBOVmKAFMAVP+IoGQAXI54/mh8vgC1sT7/+ilVAJiCKgFg/PYAl5c//u+FPgAgOJwALae9/46FswGDVtMAu7OW/vqqDv9EcRX/3ro7/0IH8QFFBkgAVpxs/jenWQBtNNv+DbAX/8Qsav/vlUf/pIx9/5+tAQAzKecAkT4hAIpvXQG5U0UAkHMuAGGXEP8Y5BoAMdniAHFL6v7BmQz/tjBg/w4NGgCAw/n+RcE7AIQlUf59ajwA1vCpAaTjQgDSo04AJTSXAGNNGgDunNX/1cDRAUkuVAAUQSkBNs5PAMmDkv6qbxj/sSEy/qsmy/9O93QA0d2ZAIWAsgE6LBkAySc7Ab0T/AAx5dIBdbt1ALWzuAEActsAMF6TAPUpOAB9Dcz+9K13ACzdIP5U6hQA+aDGAex+6v+PPt0AgVnW/zeLBf5EFL//DsyyASPD2QAvM84BJvalAM4bBv6eVyQA2TSS/3171/9VPB//qw0HANr1WP78IzwAN9ag/4VlOADgIBP+k0DqABqRogFydn0A+Pz6AGVexP/GjeL+Myq2AIcMCf5trNL/xezCAfFBmgAwnC//mUM3/9qlIv5KtLMA2kJHAVh6YwDUtdv/XCrn/+8AmgD1Tbf/XlGqARLV2ACrXUcANF74ABKXof7F0UL/rvQP/qIwtwAxPfD+tl3DAMfkBgHIBRH/iS3t/2yUBABaT+3/Jz9N/zVSzwGOFnb/ZegSAVwaQwAFyFj/IaiK/5XhSAAC0Rv/LPWoAdztEf8e02n+je7dAIBQ9f5v/g4A3l++Ad8J8QCSTNT/bM1o/z91mQCQRTAAI+RvAMAhwf9w1r7+c5iXABdmWAAzSvgA4seP/syiZf/QYb0B9WgSAOb2Hv8XlEUAblg0/uK1Wf/QL1r+cqFQ/yF0+ACzmFf/RZCxAVjuGv86IHEBAU1FADt5NP+Y7lMANAjBAOcn6f/HIooA3kStAFs58v7c0n//wAf2/pcjuwDD7KUAb13OANT3hQGahdH/m+cKAEBOJgB6+WQBHhNh/z5b+QH4hU0AxT+o/nQKUgC47HH+1MvC/z1k/P4kBcr/d1uZ/4FPHQBnZ6v+7ddv/9g1RQDv8BcAwpXd/ybh3gDo/7T+dlKF/znRsQGL6IUAnrAu/sJzLgBY9+UBHGe/AN3er/6V6ywAl+QZ/tppZwCOVdIAlYG+/9VBXv51huD/UsZ1AJ3d3ACjZSQAxXIlAGispv4LtgAAUUi8/2G8EP9FBgoAx5OR/wgJcwFB1q//2a3RAFB/pgD35QT+p7d8/1oczP6vO/D/Cyn4AWwoM/+QscP+lvp+AIpbQQF4PN7/9cHvAB3Wvf+AAhkAUJqiAE3cawHqzUr/NqZn/3RICQDkXi//HsgZ/yPWWf89sIz/U+Kj/0uCrACAJhEAX4mY/9d8nwFPXQAAlFKd/sOC+/8oykz/+37gAJ1jPv7PB+H/YETDAIy6nf+DE+f/KoD+ADTbPf5my0gAjQcL/7qk1QAfencAhfKRAND86P9b1bb/jwT6/vnXSgClHm8BqwnfAOV7IgFcghr/TZstAcOLHP874E4AiBH3AGx5IABP+r3/YOP8/ibxPgA+rn3/m29d/wrmzgFhxSj/ADE5/kH6DQAS+5b/3G3S/wWupv4sgb0A6yOT/yX3jf9IjQT/Z2v/APdaBAA1LCoAAh7wAAQ7PwBYTiQAcae0AL5Hwf/HnqT/OgisAE0hDABBPwMAmU0h/6z+ZgHk3QT/Vx7+AZIpVv+KzO/+bI0R/7vyhwDS0H8ARC0O/klgPgBRPBj/qgYk/wP5GgAj1W0AFoE2/xUj4f/qPTj/OtkGAI98WADsfkIA0Sa3/yLuBv+ukWYAXxbTAMQPmf4uVOj/dSKSAef6Sv8bhmQBXLvD/6rGcAB4HCoA0UZDAB1RHwAdqGQBqa2gAGsjdQA+YDv/UQxFAYfvvv/c/BIAo9w6/4mJvP9TZm0AYAZMAOre0v+5rs0BPJ7V/w3x1gCsgYwAXWjyAMCc+wArdR4A4VGeAH/o2gDiHMsA6RuX/3UrBf/yDi//IRQGAIn7LP4bH/X/t9Z9/ih5lQC6ntX/WQjjAEVYAP7Lh+EAya7LAJNHuAASeSn+XgVOAODW8P4kBbQA+4fnAaOK1ADS+XT+WIG7ABMIMf4+DpD/n0zTANYzUgBtdeT+Z9/L/0v8DwGaR9z/Fw1bAY2oYP+1toUA+jM3AOrq1P6vP54AJ/A0AZ69JP/VKFUBILT3/xNmGgFUGGH/RRXeAJSLev/c1esB6Mv/AHk5kwDjB5oANRaTAUgB4QBShjD+Uzyd/5FIqQAiZ+8AxukvAHQTBP+4agn/t4FTACSw5gEiZ0gA26KGAPUqngAglWD+pSyQAMrvSP7XlgUAKkIkAYTXrwBWrlb/GsWc/zHoh/5ntlIA/YCwAZmyegD1+goA7BiyAIlqhAAoHSkAMh6Y/3xpJgDmv0sAjyuqACyDFP8sDRf/7f+bAZ9tZP9wtRj/aNxsADfTgwBjDNX/mJeR/+4FnwBhmwgAIWxRAAEDZwA+bSL/+pu0ACBHw/8mRpEBn1/1AEXlZQGIHPAAT+AZAE5uef/4qHwAu4D3AAKT6/5PC4QARjoMAbUIo/9PiYX/JaoL/43zVf+w59f/zJak/+/XJ/8uV5z+CKNY/6wi6ABCLGb/GzYp/uxjV/8pe6kBNHIrAHWGKACbhhoA589b/iOEJv8TZn3+JOOF/3YDcf8dDXwAmGBKAViSzv+nv9z+ohJY/7ZkFwAfdTQAUS5qAQwCBwBFUMkB0fasAAwwjQHg01gAdOKfAHpiggBB7OoB4eIJ/8/iewFZ1jsAcIdYAVr0y/8xCyYBgWy6AFlwDwFlLsz/f8wt/k//3f8zSRL/fypl//EVygCg4wcAaTLsAE80xf9oytABtA8QAGXFTv9iTcsAKbnxASPBfAAjmxf/zzXAAAt9owH5nrn/BIMwABVdb/89eecBRcgk/7kwuf9v7hX/JzIZ/2PXo/9X1B7/pJMF/4AGIwFs327/wkyyAEpltADzLzAArhkr/1Kt/QE2csD/KDdbANdssP8LOAcA4OlMANFiyv7yGX0ALMFd/ssIsQCHsBMAcEfV/847sAEEQxoADo/V/io30P88Q3gAwRWjAGOkcwAKFHYAnNTe/qAH2f9y9UwBdTt7ALDCVv7VD7AATs7P/tWBOwDp+xYBYDeY/+z/D//FWVT/XZWFAK6gcQDqY6n/mHRYAJCkU/9fHcb/Ii8P/2N4hv8F7MEA+fd+/5O7HgAy5nX/bNnb/6NRpv9IGan+m3lP/xybWf4HfhEAk0EhAS/q/QAaMxIAaVPH/6PE5gBx+KQA4v7aAL3Ry/+k997+/yOlAAS88wF/s0cAJe3+/2S68AAFOUf+Z0hJ//QSUf7l0oT/7ga0/wvlrv/j3cABETEcAKPXxP4JdgT/M/BHAHGBbf9M8OcAvLF/AH1HLAEar/MAXqkZ/hvmHQAPi3cBqKq6/6zFTP/8S7wAiXzEAEgWYP8tl/kB3JFkAEDAn/947+IAgbKSAADAfQDriuoAt52SAFPHwP+4rEj/SeGAAE0G+v+6QUMAaPbPALwgiv/aGPIAQ4pR/u2Bef8Uz5YBKccQ/wYUgACfdgUAtRCP/9wmDwAXQJP+SRoNAFfkOQHMfIAAKxjfANtjxwAWSxT/Ext+AJ0+1wBuHeYAs6f/ATb8vgDdzLb+s55B/1GdAwDC2p8Aqt8AAOALIP8mxWIAqKQlABdYBwGkum4AYCSGAOry5QD6eRMA8v5w/wMvXgEJ7wb/UYaZ/tb9qP9DfOAA9V9KABweLP4Bbdz/sllZAPwkTAAYxi7/TE1vAIbqiP8nXh0AuUjq/0ZEh//nZgf+TeeMAKcvOgGUYXb/EBvhAabOj/9ustb/tIOiAI+N4QEN2k7/cpkhAWJozACvcnUBp85LAMrEUwE6QEMAii9vAcT3gP+J4OD+nnDPAJpk/wGGJWsAxoBP/3/Rm/+j/rn+PA7zAB/bcP4d2UEAyA10/ns8xP/gO7j+8lnEAHsQS/6VEM4ARf4wAed03//RoEEByFBiACXCuP6UPyIAi/BB/9mQhP84Ji3+x3jSAGyxpv+g3gQA3H53/qVroP9S3PgB8a+IAJCNF/+pilQAoIlO/+J2UP80G4T/P2CL/5j6JwC8mw8A6DOW/igP6P/w5Qn/ia8b/0tJYQHa1AsAhwWiAWu51QAC+Wv/KPJGANvIGQAZnQ0AQ1JQ/8T5F/+RFJUAMkiSAF5MlAEY+0EAH8AXALjUyf976aIB961IAKJX2/5+hlkAnwsM/qZpHQBJG+QBcXi3/0KjbQHUjwv/n+eoAf+AWgA5Djr+WTQK//0IowEAkdL/CoFVAS61GwBniKD+frzR/yIjbwDX2xj/1AvW/mUFdgDoxYX/36dt/+1QVv9Gi14AnsG/AZsPM/8PvnMATofP//kKGwG1fekAX6wN/qrVof8n7Ir/X11X/76AXwB9D84AppafAOMPnv/Onnj/Ko2AAGWyeAGcbYMA2g4s/veozv/UcBwAcBHk/1oQJQHF3mwA/s9T/wla8//z9KwAGlhz/810egC/5sEAtGQLAdklYP+aTpwA6+of/86ysv+VwPsAtvqHAPYWaQB8wW3/AtKV/6kRqgAAYG7/dQkIATJ7KP/BvWMAIuOgADBQRv7TM+wALXr1/iyuCACtJen/nkGrAHpF1/9aUAL/g2pg/uNyhwDNMXf+sD5A/1IzEf/xFPP/gg0I/oDZ8/+iGwH+WnbxAPbG9v83EHb/yJ+dAKMRAQCMa3kAVaF2/yYAlQCcL+4ACaamAUtitf8yShkAQg8vAIvhnwBMA47/Du64AAvPNf+3wLoBqyCu/79M3QH3qtsAGawy/tkJ6QDLfkT/t1wwAH+ntwFBMf4AED9/Af4Vqv874H/+FjA//xtOgv4owx0A+oRw/iPLkABoqagAz/0e/2goJv5e5FgAzhCA/9Q3ev/fFuoA38V/AP21tQGRZnYA7Jkk/9TZSP8UJhj+ij4+AJiMBADm3GP/ARXU/5TJ5wD0ewn+AKvSADM6Jf8B/w7/9LeR/gDypgAWSoQAedgpAF/Dcv6FGJf/nOLn//cFTf/2lHP+4VxR/95Q9v6qe1n/SseNAB0UCP+KiEb/XUtcAN2TMf40fuIA5XwXAC4JtQDNQDQBg/4cAJee1ACDQE4AzhmrAADmiwC//W7+Z/enAEAoKAEqpfH/O0vk/nzzvf/EXLL/goxW/41ZOAGTxgX/y/ie/pCijQALrOIAgioV/wGnj/+QJCT/MFik/qiq3ABiR9YAW9BPAJ9MyQGmKtb/Rf8A/waAff++AYwAklPa/9fuSAF6fzUAvXSl/1QIQv/WA9D/1W6FAMOoLAGe50UAokDI/ls6aAC2Orv++eSIAMuGTP5j3ekAS/7W/lBFmgBAmPj+7IjK/51pmf6VrxQAFiMT/3x56QC6+sb+hOWLAIlQrv+lfUQAkMqU/uvv+ACHuHYAZV4R/3pIRv5FgpIAf974AUV/dv8eUtf+vEoT/+Wnwv51GUL/Qeo4/tUWnACXO13+LRwb/7p+pP8gBu8Af3JjAds0Av9jYKb+Pr5+/2zeqAFL4q4A5uLHADx12v/8+BQB1rzMAB/Chv57RcD/qa0k/jdiWwDfKmb+iQFmAJ1aGQDvekD//AbpAAc2FP9SdK4AhyU2/w+6fQDjcK//ZLTh/yrt9P/0reL++BIhAKtjlv9K6zL/dVIg/mqo7QDPbdAB5Am6AIc8qf6zXI8A9Kpo/+stfP9GY7oAdYm3AOAf1wAoCWQAGhBfAUTZVwAIlxT/GmQ6/7ClywE0dkYAByD+/vT+9f+nkML/fXEX/7B5tQCIVNEAigYe/1kwHAAhmw7/GfCaAI3NbQFGcz7/FChr/oqax/9e3+L/nasmAKOxGf4tdgP/Dt4XAdG+Uf92e+gBDdVl/3s3e/4b9qUAMmNM/4zWIP9hQUP/GAwcAK5WTgFA92AAoIdDAEI38/+TzGD/GgYh/2IzUwGZ1dD/Arg2/xnaCwAxQ/b+EpVI/w0ZSAAqT9YAKgQmARuLkP+VuxcAEqSEAPVUuP54xmj/ftpgADh16v8NHdb+RC8K/6eahP6YJsYAQrJZ/8guq/8NY1P/0rv9/6otKgGK0XwA1qKNAAzmnABmJHD+A5NDADTXe//pqzb/Yok+APfaJ//n2uwA979/AMOSVAClsFz/E9Re/xFK4wBYKJkBxpMB/85D9f7wA9r/PY3V/2G3agDD6Ov+X1aaANEwzf520fH/8HjfAdUdnwCjf5P/DdpdAFUYRP5GFFD/vQWMAVJh/v9jY7//hFSF/2vadP9wei4AaREgAMKgP/9E3icB2P1cALFpzf+VycMAKuEL/yiicwAJB1EApdrbALQWAP4dkvz/ks/hAbSHYAAfo3AAsQvb/4UMwf4rTjIAQXF5ATvZBv9uXhgBcKxvAAcPYAAkVXsAR5YV/9BJvADAC6cB1fUiAAnmXACijif/11obAGJhWQBeT9MAWp3wAF/cfgFmsOIAJB7g/iMffwDn6HMBVVOCANJJ9f8vj3L/REHFADtIPv+3ha3+XXl2/zuxUf/qRa3/zYCxANz0MwAa9NEBSd5N/6MIYP6WldMAnv7LATZ/iwCh4DsABG0W/94qLf/Qkmb/7I67ADLN9f8KSln+ME+OAN5Mgv8epj8A7AwN/zG49AC7cWYA2mX9AJk5tv4glioAGcaSAe3xOACMRAUAW6Ss/06Ruv5DNM0A28+BAW1zEQA2jzoBFfh4/7P/HgDB7EL/Af8H//3AMP8TRdkBA9YA/0BlkgHffSP/60mz//mn4gDhrwoBYaI6AGpwqwFUrAX/hYyy/4b1jgBhWn3/usu5/99NF//AXGoAD8Zz/9mY+ACrsnj/5IY1ALA2wQH6+zUA1QpkASLHagCXH/T+rOBX/w7tF//9VRr/fyd0/6xoZAD7Dkb/1NCK//3T+gCwMaUAD0x7/yXaoP9chxABCn5y/0YF4P/3+Y0ARBQ8AfHSvf/D2bsBlwNxAJdcrgDnPrL/27fhABcXIf/NtVAAObj4/0O0Af9ae13/JwCi/2D4NP9UQowAIn/k/8KKBwGmbrwAFRGbAZq+xv/WUDv/EgePAEgd4gHH2fkA6KFHAZW+yQDZr1/+cZND/4qPx/9/zAEAHbZTAc7mm/+6zDwACn1V/+hgGf//Wff/1f6vAejBUQAcK5z+DEUIAJMY+AASxjEAhjwjAHb2Ev8xWP7+5BW6/7ZBcAHbFgH/Fn40/701Mf9wGY8AJn83/+Jlo/7QhT3/iUWuAb52kf88Ytv/2Q31//qICgBU/uIAyR99AfAz+/8fg4L/Aooy/9fXsQHfDO7//JU4/3xbRP9Ifqr+d/9kAIKH6P8OT7IA+oPFAIrG0AB52Iv+dxIk/x3BegAQKi3/1fDrAea+qf/GI+T+bq1IANbd8f84lIcAwHVO/o1dz/+PQZUAFRJi/18s9AFqv00A/lUI/tZusP9JrRP+oMTH/+1akADBrHH/yJuI/uRa3QCJMUoBpN3X/9G9Bf9p7Df/Kh+BAcH/7AAu2TwAili7/+JS7P9RRZf/jr4QAQ2GCAB/ejD/UUCcAKvziwDtI/YAeo/B/tR6kgBfKf8BV4RNAATUHwARH04AJy2t/hiO2f9fCQb/41MGAGI7gv4+HiEACHPTAaJhgP8HuBf+dByo//iKl/9i9PAAunaCAHL46/9prcgBoHxH/14kpAGvQZL/7vGq/srGxQDkR4r+LfZt/8I0ngCFu7AAU/ya/lm93f+qSfwAlDp9ACREM/4qRbH/qExW/yZkzP8mNSMArxNhAOHu/f9RUYcA0hv//utJawAIz3MAUn+IAFRjFf7PE4gAZKRlAFDQTf+Ez+3/DwMP/yGmbgCcX1X/JblvAZZqI/+ml0wAcleH/5/CQAAMeh//6Adl/q13YgCaR9z+vzk1/6jooP/gIGP/2pylAJeZowDZDZQBxXFZAJUcof7PFx4AaYTj/zbmXv+Frcz/XLed/1iQ/P5mIVoAn2EDALXam//wcncAatY1/6W+cwGYW+H/WGos/9A9cQCXNHwAvxuc/2427AEOHqb/J3/PAeXHHAC85Lz+ZJ3rAPbatwFrFsH/zqBfAEzvkwDPoXUAM6YC/zR1Cv5JOOP/mMHhAIReiP9lv9EAIGvl/8YrtAFk0nYAckOZ/xdYGv9ZmlwB3HiM/5Byz//8c/r/Is5IAIqFf/8IsnwBV0thAA/lXP7wQ4P/dnvj/pJ4aP+R1f8BgbtG/9t3NgABE60ALZaUAfhTSADL6akBjms4APf5JgEt8lD/HulnAGBSRgAXyW8AUSce/6G3Tv/C6iH/ROOM/tjOdABGG+v/aJBPAKTmXf7Wh5wAmrvy/rwUg/8kba4An3DxAAVulQEkpdoAph0TAbIuSQBdKyD++L3tAGabjQDJXcP/8Yv9/w9vYv9sQaP+m0++/0muwf72KDD/a1gL/sphVf/9zBL/cfJCAG6gwv7QEroAURU8ALxop/98pmH+0oWOADjyif4pb4IAb5c6AW/Vjf+3rPH/JgbE/7kHe/8uC/YA9Wl3AQ8Cof8Izi3/EspK/1N8cwHUjZ0AUwjR/osP6P+sNq3+MveEANa91QCQuGkA3/74AP+T8P8XvEgABzM2ALwZtP7ctAD/U6AUAKO98/860cL/V0k8AGoYMQD1+dwAFq2nAHYLw/8Tfu0Abp8l/ztSLwC0u1YAvJTQAWQlhf8HcMEAgbyc/1Rqgf+F4coADuxv/ygUZQCsrDH+MzZK//u5uP9dm+D/tPngAeaykgBIOTb+sj64AHfNSAC57/3/PQ/aAMRDOP/qIKsBLtvkANBs6v8UP+j/pTXHAYXkBf80zWsASu6M/5ac2/7vrLL/+73f/iCO0//aD4oB8cRQABwkYv4W6scAPe3c//Y5JQCOEY7/nT4aACvuX/4D2Qb/1RnwASfcrv+azTD+Ew3A//QiNv6MEJsA8LUF/pvBPACmgAT/JJE4/5bw2wB4M5EAUpkqAYzskgBrXPgBvQoDAD+I8gDTJxgAE8qhAa0buv/SzO/+KdGi/7b+n/+sdDQAw2fe/s1FOwA1FikB2jDCAFDS8gDSvM8Au6Gh/tgRAQCI4XEA+rg/AN8eYv5NqKIAOzWvABPJCv+L4MIAk8Ga/9S9DP4ByK7/MoVxAV6zWgCttocAXrFxACtZ1/+I/Gr/e4ZT/gX1Qv9SMScB3ALgAGGBsQBNO1kAPR2bAcur3P9cTosAkSG1/6kYjQE3lrMAizxQ/9onYQACk2v/PPhIAK3mLwEGU7b/EGmi/onUUf+0uIYBJ96k/91p+wHvcH0APwdhAD9o4/+UOgwAWjzg/1TU/ABP16gA+N3HAXN5AQAkrHgAIKK7/zlrMf+TKhUAasYrATlKVwB+y1H/gYfDAIwfsQDdi8IAA97XAINE5wCxVrL+fJe0ALh8JgFGoxEA+fu1ASo34wDioSwAF+xuADOVjgFdBewA2rdq/kMYTQAo9dH/3nmZAKU5HgBTfTwARiZSAeUGvABt3p3/N3Y//82XugDjIZX//rD2AeOx4wAiaqP+sCtPAGpfTgG58Xr/uQ49ACQBygANsqL/9wuEAKHmXAFBAbn/1DKlAY2SQP+e8toAFaR9ANWLegFDR1cAy56yAZdcKwCYbwX/JwPv/9n/+v+wP0f/SvVNAfquEv8iMeP/9i77/5ojMAF9nT3/aiRO/2HsmQCIu3j/cYar/xPV2f7YXtH//AU9AF4DygADGrf/QL8r/x4XFQCBjU3/ZngHAcJMjAC8rzT/EVGUAOhWNwHhMKwAhioq/+4yLwCpEv4AFJNX/w7D7/9F9xcA7uWA/7ExcACoYvv/eUf4APMIkf7245n/26mx/vuLpf8Mo7n/pCir/5mfG/7zbVv/3hhwARLW5wBrnbX+w5MA/8JjaP9ZjL7/sUJ+/mq5QgAx2h8A/K6eALxP5gHuKeAA1OoIAYgLtQCmdVP/RMNeAC6EyQDwmFgApDlF/qDgKv8710P/d8ON/yS0ef7PLwj/rtLfAGXFRP//Uo0B+onpAGFWhQEQUEUAhIOfAHRdZAAtjYsAmKyd/1orWwBHmS4AJxBw/9mIYf/cxhn+sTUxAN5Yhv+ADzwAz8Cp/8B00f9qTtMByNW3/wcMev7eyzz/IW7H/vtqdQDk4QQBeDoH/93BVP5whRsAvcjJ/4uHlgDqN7D/PTJBAJhsqf/cVQH/cIfjAKIaugDPYLn+9IhrAF2ZMgHGYZcAbgtW/491rv9z1MgABcq3AO2kCv657z4A7HgS/mJ7Y/+oycL+LurWAL+FMf9jqXcAvrsjAXMVLf/5g0gAcAZ7/9Yxtf6m6SIAXMVm/v3kzf8DO8kBKmIuANslI/+pwyYAXnzBAZwr3wBfSIX+eM6/AHrF7/+xu0///i4CAfqnvgBUgRMAy3Gm//kfvf5Incr/0EdJ/88YSAAKEBIB0lFM/1jQwP9+82v/7o14/8d56v+JDDv/JNx7/5SzPP7wDB0AQgBhASQeJv9zAV3/YGfn/8WeOwHApPAAyso5/xiuMABZTZsBKkzXAPSX6QAXMFEA7380/uOCJf/4dF0BfIR2AK3+wAEG61P/bq/nAfsctgCB+V3+VLiAAEy1PgCvgLoAZDWI/m0d4gDd6ToBFGNKAAAWoACGDRUACTQ3/xFZjACvIjsAVKV3/+Di6v8HSKb/e3P/ARLW9gD6B0cB2dy5ANQjTP8mfa8AvWHSAHLuLP8pvKn+LbqaAFFcFgCEoMEAedBi/w1RLP/LnFIARzoV/9Byv/4yJpMAmtjDAGUZEgA8+tf/6YTr/2evjgEQDlwAjR9u/u7xLf+Z2e8BYagv//lVEAEcrz7/Of42AN7nfgCmLXX+Er1g/+RMMgDI9F4Axph4AUQiRf8MQaD+ZRNaAKfFeP9ENrn/Kdq8AHGoMABYab0BGlIg/7ldpAHk8O3/QrY1AKvFXP9rCekBx3iQ/04xCv9tqmn/WgQf/xz0cf9KOgsAPtz2/3mayP6Q0rL/fjmBASv6Dv9lbxwBL1bx/z1Glv81SQX/HhqeANEaVgCK7UoApF+8AI48Hf6idPj/u6+gAJcSEADRb0H+y4Yn/1hsMf+DGkf/3RvX/mhpXf8f7B/+hwDT/49/bgHUSeUA6UOn/sMB0P+EEd3/M9laAEPrMv/f0o8AszWCAelqxgDZrdz/cOUY/6+aXf5Hy/b/MEKF/wOI5v8X3XH+62/VAKp4X/773QIALYKe/mle2f/yNLT+1UQt/2gmHAD0nkwAochg/881Df+7Q5QAqjb4AHeisv9TFAsAKirAAZKfo/+36G8ATeUV/0c1jwAbTCIA9ogv/9sntv9c4MkBE44O/0W28f+jdvUACW1qAaq19/9OL+7/VNKw/9VriwAnJgsASBWWAEiCRQDNTZv+joUVAEdvrP7iKjv/swDXASGA8QDq/A0BuE8IAG4eSf/2jb0Aqs/aAUqaRf+K9jH/myBkAH1Kaf9aVT3/I+Wx/z59wf+ZVrwBSXjUANF79v6H0Sb/lzosAVxF1v8ODFj//Jmm//3PcP88TlP/43xuALRg/P81dSH+pNxS/ykBG/8mpKb/pGOp/j2QRv/AphIAa/pCAMVBMgABsxL//2gB/yuZI/9Qb6gAbq+oAClpLf/bDs3/pOmM/isBdgDpQ8MAslKf/4pXev/U7lr/kCN8/hmMpAD71yz+hUZr/2XjUP5cqTcA1yoxAHK0Vf8h6BsBrNUZAD6we/4ghRj/4b8+AF1GmQC1KmgBFr/g/8jIjP/56iUAlTmNAMM40P/+gkb/IK3w/x3cxwBuZHP/hOX5AOTp3/8l2NH+srHR/7ctpf7gYXIAiWGo/+HerAClDTEB0uvM//wEHP5GoJcA6L40/lP4Xf8+100Br6+z/6AyQgB5MNAAP6nR/wDSyADguywBSaJSAAmwj/8TTMH/HTunARgrmgAcvr4AjbyBAOjry//qAG3/NkGfADxY6P95/Zb+/OmD/8ZuKQFTTUf/yBY7/mr98v8VDM//7UK9AFrGygHhrH8ANRbKADjmhAABVrcAbb4qAPNErgFt5JoAyLF6ASOgt/+xMFX/Wtqp//iYTgDK/m4ABjQrAI5iQf8/kRYARmpdAOiKawFusz3/04HaAfLRXAAjWtkBto9q/3Rl2f9y+t3/rcwGADyWowBJrCz/725Q/+1Mmf6hjPkAlejlAIUfKP+upHcAcTPWAIHkAv5AIvMAa+P0/65qyP9UmUYBMiMQAPpK2P7svUL/mfkNAOayBP/dKe4AduN5/15XjP7+d1wASe/2/nVXgAAT05H/sS78AOVb9gFFgPf/yk02AQgLCf+ZYKYA2dat/4bAAgEAzwAAva5rAYyGZACewfMBtmarAOuaMwCOBXv/PKhZAdkOXP8T1gUB06f+ACwGyv54Euz/D3G4/7jfiwAosXf+tnta/7ClsAD3TcIAG+p4AOcA1v87Jx4AfWOR/5ZERAGN3vgAmXvS/25/mP/lIdYBh93FAIlhAgAMj8z/USm8AHNPgv9eA4QAmK+7/3yNCv9+wLP/C2fGAJUGLQDbVbsB5hKy/0i2mAADxrj/gHDgAWGh5gD+Yyb/Op/FAJdC2wA7RY//uXD5AHeIL/97goQAqEdf/3GwKAHoua0Az111AUSdbP9mBZP+MWEhAFlBb/73HqP/fNndAWb62ADGrkv+OTcSAOMF7AHl1a0AyW3aATHp7wAeN54BGbJqAJtvvAFefowA1x/uAU3wEADV8hkBJkeoAM26Xf4x04z/2wC0/4Z2pQCgk4b/broj/8bzKgDzkncAhuujAQTxh//BLsH+Z7RP/+EEuP7ydoIAkoewAepvHgBFQtX+KWB7AHleKv+yv8P/LoIqAHVUCP/pMdb+7nptAAZHWQHs03sA9A0w/neUDgByHFb/S+0Z/5HlEP6BZDX/hpZ4/qidMgAXSGj/4DEOAP97Fv+XuZf/qlC4AYa2FAApZGUBmSEQAEyabwFWzur/wKCk/qV7Xf8B2KT+QxGv/6kLO/+eKT3/SbwO/8MGif8Wkx3/FGcD//aC4/96KIAA4i8Y/iMkIACYurf/RcoUAMOFwwDeM/cAqateAbcAoP9AzRIBnFMP/8U6+f77WW7/MgpY/jMr2ABi8sYB9ZdxAKvswgHFH8f/5VEmASk7FAD9aOYAmF0O//bykv7WqfD/8GZs/qCn7ACa2rwAlunK/xsT+gECR4X/rww/AZG3xgBoeHP/gvv3ABHUp/8+e4T/92S9AJvfmACPxSEAmzss/5Zd8AF/A1f/X0fPAadVAf+8mHT/ChcXAInDXQE2YmEA8ACo/5S8fwCGa5cATP2rAFqEwACSFjYA4EI2/ua65f8ntsQAlPuC/0GDbP6AAaAAqTGn/sf+lP/7BoMAu/6B/1VSPgCyFzr//oQFAKTVJwCG/JL+JTVR/5uGUgDNp+7/Xi20/4QooQD+b3ABNkvZALPm3QHrXr//F/MwAcqRy/8ndir/dY39AP4A3gAr+zIANqnqAVBE0ACUy/P+kQeHAAb+AAD8uX8AYgiB/yYjSP/TJNwBKBpZAKhAxf4D3u//AlPX/rSfaQA6c8IAunRq/+X32/+BdsEAyq63AaahSADJa5P+7YhKAOnmagFpb6gAQOAeAQHlAwBml6//wu7k//761AC77XkAQ/tgAcUeCwC3X8wAzVmKAEDdJQH/3x7/sjDT//HIWv+n0WD/OYLdAC5yyP89uEIAN7YY/m62IQCrvuj/cl4fABLdCAAv5/4A/3BTAHYP1/+tGSj+wMEf/+4Vkv+rwXb/Zeo1/oPUcABZwGsBCNAbALXZD//nlegAjOx+AJAJx/8MT7X+k7bK/xNttv8x1OEASqPLAK/plAAacDMAwcEJ/w+H+QCW44IAzADbARjyzQDu0HX/FvRwABrlIgAlULz/Ji3O/vBa4f8dAy//KuBMALrzpwAghA//BTN9AIuHGAAG8dsArOWF//bWMgDnC8//v35TAbSjqv/1OBgBsqTT/wMQygFiOXb/jYNZ/iEzGADzlVv//TQOACOpQ/4xHlj/sxsk/6WMtwA6vZcAWB8AAEupQgBCZcf/GNjHAXnEGv8OT8v+8OJR/14cCv9TwfD/zMGD/14PVgDaKJ0AM8HRAADysQBmufcAnm10ACaHWwDfr5UA3EIB/1Y86AAZYCX/4XqiAde7qP+enS4AOKuiAOjwZQF6FgkAMwkV/zUZ7v/ZHuj+famUAA3oZgCUCSUApWGNAeSDKQDeD/P//hIRAAY87QFqA3EAO4S9AFxwHgBp0NUAMFSz/7t55/4b2G3/ot1r/knvw//6Hzn/lYdZ/7kXcwEDo53/EnD6ABk5u/+hYKQALxDzAAyN+/5D6rj/KRKhAK8GYP+grDT+GLC3/8bBVQF8eYn/lzJy/9zLPP/P7wUBACZr/zfuXv5GmF4A1dxNAXgRRf9VpL7/y+pRACYxJf49kHwAiU4x/qj3MABfpPwAaamHAP3khgBApksAUUkU/8/SCgDqapb/XiJa//6fOf7chWMAi5O0/hgXuQApOR7/vWFMAEG73//grCX/Ij5fAeeQ8ABNan7+QJhbAB1imwDi+zX/6tMF/5DL3v+ksN3+BecYALN6zQAkAYb/fUaX/mHk/ACsgRf+MFrR/5bgUgFUhh4A8cQuAGdx6v8uZXn+KHz6/4ct8v4J+aj/jGyD/4+jqwAyrcf/WN6O/8hfngCOwKP/B3WHAG98FgDsDEH+RCZB/+Ou/gD09SYA8DLQ/6E/+gA80e8AeiMTAA4h5v4Cn3EAahR//+TNYACJ0q7+tNSQ/1limgEiWIsAp6JwAUFuxQDxJakAQjiD/wrJU/6F/bv/sXAt/sT7AADE+pf/7ujW/5bRzQAc8HYAR0xTAexjWwAq+oMBYBJA/3beIwBx1sv/ene4/0ITJADMQPkAklmLAIY+hwFo6WUAvFQaADH5gQDQ1kv/z4JN/3Ov6wCrAon/r5G6ATf1h/+aVrUBZDr2/23HPP9SzIb/1zHmAYzlwP/ewfv/UYgP/7OVov8XJx3/B19L/r9R3gDxUVr/azHJ//TTnQDejJX/Qds4/r32Wv+yO50BMNs0AGIi1wAcEbv/r6kYAFxPof/syMIBk4/qAOXhBwHFqA4A6zM1Af14rgDFBqj/ynWrAKMVzgByVVr/DykK/8ITYwBBN9j+opJ0ADLO1P9Akh3/np6DAWSlgv+sF4H/fTUJ/w/BEgEaMQv/ta7JAYfJDv9kE5UA22JPACpjj/5gADD/xflT/miVT//rboj+UoAs/0EpJP5Y0woAu3m7AGKGxwCrvLP+0gvu/0J7gv406j0AMHEX/gZWeP93svUAV4HJAPKN0QDKclUAlBahAGfDMAAZMav/ikOCALZJev6UGIIA0+WaACCbngBUaT0AscIJ/6ZZVgE2U7sA+Sh1/20D1/81kiwBPy+zAMLYA/4OVIgAiLEN/0jzuv91EX3/0zrT/11P3wBaWPX/i9Fv/0beLwAK9k//xtmyAOPhCwFOfrP/Pit+AGeUIwCBCKX+9fCUAD0zjgBR0IYAD4lz/9N37P+f9fj/AoaI/+aLOgGgpP4AclWN/zGmtv+QRlQBVbYHAC41XQAJpqH/N6Ky/y24vACSHCz+qVoxAHiy8QEOe3//B/HHAb1CMv/Gj2X+vfOH/40YGP5LYVcAdvuaAe02nACrks//g8T2/4hAcQGX6DkA8NpzADE9G/9AgUkB/Kkb/yiECgFaycH//HnwAbrOKQArxmEAkWS3AMzYUP6slkEA+eXE/mh7Sf9NaGD+grQIAGh7OQDcyuX/ZvnTAFYO6P+2TtEA7+GkAGoNIP94SRH/hkPpAFP+tQC37HABMECD//HY8/9BweIAzvFk/mSGpv/tysUANw1RACB8Zv8o5LEAdrUfAeeghv93u8oAAI48/4Amvf+myZYAz3gaATa4rAAM8sz+hULmACImHwG4cFAAIDOl/r/zNwA6SZL+m6fN/2RomP/F/s//rRP3AO4KygDvl/IAXjsn//AdZv8KXJr/5VTb/6GBUADQWswB8Nuu/55mkQE1skz/NGyoAVPeawDTJG0Adjo4AAgdFgDtoMcAqtGdAIlHLwCPViAAxvICANQwiAFcrLoA5pdpAWC/5QCKUL/+8NiC/2IrBv6oxDEA/RJbAZBJeQA9kicBP2gY/7ilcP5+62IAUNVi/3s8V/9SjPUB33it/w/GhgHOPO8A5+pc/yHuE/+lcY4BsHcmAKArpv7vW2kAaz3CARkERAAPizMApIRq/yJ0Lv6oX8UAidQXAEicOgCJcEX+lmma/+zJnQAX1Jr/iFLj/uI73f9flcAAUXY0/yEr1wEOk0v/WZx5/g4STwCT0IsBl9o+/5xYCAHSuGL/FK97/2ZT5QDcQXQBlvoE/1yO3P8i90L/zOGz/pdRlwBHKOz/ij8+AAZP8P+3ubUAdjIbAD/jwAB7YzoBMuCb/xHh3/7c4E3/Dix7AY2ArwD41MgAlju3/5NhHQCWzLUA/SVHAJFVdwCayLoAAoD5/1MYfAAOV48AqDP1AXyX5//Q8MUBfL65ADA69gAU6egAfRJi/w3+H//1sYL/bI4jAKt98v6MDCL/paGiAM7NZQD3GSIBZJE5ACdGOQB2zMv/8gCiAKX0HgDGdOIAgG+Z/4w2tgE8eg//mzo5ATYyxgCr0x3/a4qn/61rx/9tocEAWUjy/85zWf/6/o7+scpe/1FZMgAHaUL/Gf7//stAF/9P3mz/J/lLAPF8MgDvmIUA3fFpAJOXYgDVoXn+8jGJAOkl+f4qtxsAuHfm/9kgo//Q++QBiT6D/09ACf5eMHEAEYoy/sH/FgD3EsUBQzdoABDNX/8wJUIAN5w/AUBSSv/INUf+70N9ABrg3gDfiV3/HuDK/wnchADGJusBZo1WADwrUQGIHBoA6SQI/s/ylACkoj8AMy7g/3IwT/8Jr+IA3gPB/y+g6P//XWn+DirmABqKUgHQK/QAGycm/2LQf/9Albb/BfrRALs8HP4xGdr/qXTN/3cSeACcdJP/hDVt/w0KygBuU6cAnduJ/wYDgv8ypx7/PJ8v/4GAnf5eA70AA6ZEAFPf1wCWWsIBD6hBAONTM//Nq0L/Nrs8AZhmLf93muEA8PeIAGTFsv+LR9//zFIQASnOKv+cwN3/2Hv0/9rauf+7uu///Kyg/8M0FgCQrrX+u2Rz/9NOsP8bB8EAk9Vo/1rJCv9Qe0IBFiG6AAEHY/4ezgoA5eoFADUe0gCKCNz+RzenAEjhVgF2vrwA/sFlAav5rP9enrf+XQJs/7BdTP9JY0//SkCB/vYuQQBj8X/+9pdm/yw10P47ZuoAmq+k/1jyIABvJgEA/7a+/3OwD/6pPIEAeu3xAFpMPwA+Snj/esNuAHcEsgDe8tIAgiEu/pwoKQCnknABMaNv/3mw6wBMzw7/AxnGASnr1QBVJNYBMVxt/8gYHv6o7MMAkSd8AezDlQBaJLj/Q1Wq/yYjGv6DfET/75sj/zbJpADEFnX/MQ/NABjgHQF+cZAAdRW2AMufjQDfh00AsOaw/77l1/9jJbX/MxWK/xm9Wf8xMKX+mC33AKps3gBQygUAG0Vn/swWgf+0/D7+0gFb/5Ju/v/bohwA3/zVATsIIQDOEPQAgdMwAGug0ABwO9EAbU3Y/iIVuf/2Yzj/s4sT/7kdMv9UWRMASvpi/+EqyP/A2c3/0hCnAGOEXwEr5jkA/gvL/2O8P/93wfv+UGk2AOi1vQG3RXD/0Kul/y9ttP97U6UAkqI0/5oLBP+X41r/kolh/j3pKf9eKjf/bKTsAJhE/gAKjIP/CmpP/vOeiQBDskL+sXvG/w8+IgDFWCr/lV+x/5gAxv+V/nH/4Vqj/33Z9wASEeAAgEJ4/sAZCf8y3c0AMdRGAOn/pAAC0QkA3TTb/qzg9P9eOM4B8rMC/x9bpAHmLor/vebcADkvPf9vC50AsVuYABzmYgBhV34AxlmR/6dPawD5TaABHenm/5YVVv48C8EAlyUk/rmW8//k1FMBrJe0AMmpmwD0POoAjusEAUPaPADAcUsBdPPP/0GsmwBRHpz/UEgh/hLnbf+OaxX+fRqE/7AQO/+WyToAzqnJANB54gAorA7/lj1e/zg5nP+NPJH/LWyV/+6Rm//RVR/+wAzSAGNiXf6YEJcA4bncAI3rLP+grBX+Rxof/w1AXf4cOMYAsT74AbYI8QCmZZT/TlGF/4He1wG8qYH/6AdhADFwPP/Z5fsAd2yKACcTe/6DMesAhFSRAILmlP8ZSrsABfU2/7nb8QESwuT/8cpmAGlxygCb608AFQmy/5wB7wDIlD0Ac/fS/zHdhwA6vQgBIy4JAFFBBf80nrn/fXQu/0qMDf/SXKz+kxdHANng/f5zbLT/kTow/tuxGP+c/zwBmpPyAP2GVwA1S+UAMMPe/x+vMv+c0nj/0CPe/xL4swECCmX/ncL4/57MZf9o/sX/Tz4EALKsZQFgkvv/QQqcAAKJpf90BOcA8tcBABMjHf8roU8AO5X2AftCsADIIQP/UG6O/8OhEQHkOEL/ey+R/oQEpABDrqwAGf1yAFdhVwH63FQAYFvI/yV9OwATQXYAoTTx/+2sBv+wv///AUGC/t++5gBl/ef/kiNtAPodTQExABMAe1qbARZWIP/a1UEAb11/ADxdqf8If7YAEboO/v2J9v/VGTD+TO4A//hcRv9j4IsAuAn/AQek0ADNg8YBV9bHAILWXwDdld4AFyar/sVu1QArc4z+17F2AGA0QgF1nu0ADkC2/y4/rv+eX77/4c2x/ysFjv+sY9T/9LuTAB0zmf/kdBj+HmXPABP2lv+G5wUAfYbiAU1BYgDsgiH/BW4+AEVsf/8HcRYAkRRT/sKh5/+DtTwA2dGx/+WU1P4Dg7gAdbG7ARwOH/+wZlAAMlSX/30fNv8VnYX/E7OLAeDoGgAidar/p/yr/0mNzv6B+iMASE/sAdzlFP8pyq3/Y0zu/8YW4P9sxsP/JI1gAeyeO/9qZFcAbuICAOPq3gCaXXf/SnCk/0NbAv8VkSH/ZtaJ/6/mZ/6j9qYAXfd0/qfgHP/cAjkBq85UAHvkEf8beHcAdwuTAbQv4f9oyLn+pQJyAE1O1AAtmrH/GMR5/lKdtgBaEL4BDJPFAF/vmP8L60cAVpJ3/6yG1gA8g8QAoeGBAB+CeP5fyDMAaefS/zoJlP8rqN3/fO2OAMbTMv4u9WcApPhUAJhG0P+0dbEARk+5APNKIACVnM8AxcShAfU17wAPXfb+i/Ax/8RYJP+iJnsAgMidAa5MZ/+tqSL+2AGr/3IzEQCI5MIAbpY4/mr2nwATuE//lk3w/5tQogAANan/HZdWAEReEABcB27+YnWV//lN5v/9CowA1nxc/iN26wBZMDkBFjWmALiQPf+z/8IA1vg9/jtu9gB5FVH+pgPkAGpAGv9F6Ib/8tw1/i7cVQBxlff/YbNn/75/CwCH0bYAXzSBAaqQzv96yMz/qGSSADyQlf5GPCgAejSx//bTZf+u7QgABzN4ABMfrQB+75z/j73LAMSAWP/pheL/Hn2t/8lsMgB7ZDv//qMDAd2Utf/WiDn+3rSJ/89YNv8cIfv/Q9Y0AdLQZABRql4AkSg1AOBv5/4jHPT/4sfD/u4R5gDZ2aT+qZ3dANouogHHz6P/bHOiAQ5gu/92PEwAuJ+YANHnR/4qpLr/upkz/t2rtv+ijq0A6y/BAAeLEAFfpED/EN2mANvFEACEHSz/ZEV1/zzrWP4oUa0AR749/7tYnQDnCxcA7XWkAOGo3/+acnT/o5jyARggqgB9YnH+qBNMABGd3P6bNAUAE2+h/0da/P+tbvAACsZ5//3/8P9Ce9IA3cLX/nmjEf/hB2MAvjG2AHMJhQHoGor/1USEACx3ev+zYjMAlVpqAEcy5v8KmXb/sUYZAKVXzQA3iuoA7h5hAHGbzwBimX8AImvb/nVyrP9MtP/+8jmz/90irP44ojH/UwP//3Hdvf+8GeT+EFhZ/0ccxv4WEZX/83n+/2vKY/8Jzg4B3C+ZAGuJJwFhMcL/lTPF/ro6C/9rK+gByAYO/7WFQf7d5Kv/ez7nAePqs/8ivdT+9Lv5AL4NUAGCWQEA34WtAAnexv9Cf0oAp9hd/5uoxgFCkQAARGYuAaxamgDYgEv/oCgzAJ4RGwF88DEA7Mqw/5d8wP8mwb4AX7Y9AKOTfP//pTP/HCgR/tdgTgBWkdr+HyTK/1YJBQBvKcj/7WxhADk+LAB1uA8BLfF0AJgB3P+dpbwA+g+DATwsff9B3Pv/SzK4ADVagP/nUML/iIF/ARUSu/8tOqH/R5MiAK75C/4jjR0A70Sx/3NuOgDuvrEBV/Wm/74x9/+SU7j/rQ4n/5LXaACO33gAlcib/9TPkQEQtdkArSBX//8jtQB336EByN9e/0YGuv/AQ1X/MqmYAJAae/8487P+FESIACeMvP790AX/yHOHASus5f+caLsAl/unADSHFwCXmUgAk8Vr/pSeBf/uj84AfpmJ/1iYxf4HRKcA/J+l/+9ONv8YPzf/Jt5eAO23DP/OzNIAEyf2/h5K5wCHbB0Bs3MAAHV2dAGEBvz/kYGhAWlDjQBSJeL/7uLk/8zWgf6ie2T/uXnqAC1s5wBCCDj/hIiAAKzgQv6vnbwA5t/i/vLbRQC4DncBUqI4AHJ7FACiZ1X/Me9j/pyH1wBv/6f+J8TWAJAmTwH5qH0Am2Gc/xc02/+WFpAALJWl/yh/twDETen/doHS/6qH5v/Wd8YA6fAjAP00B/91ZjD/Fcya/7OIsf8XAgMBlYJZ//wRnwFGPBoAkGsRALS+PP84tjv/bkc2/8YSgf+V4Ff/3xWY/4oWtv/6nM0A7C3Q/0+U8gFlRtEAZ06uAGWQrP+YiO0Bv8KIAHFQfQGYBI0Am5Y1/8R09QDvckn+E1IR/3x96v8oNL8AKtKe/5uEpQCyBSoBQFwo/yRVTf+y5HYAiUJg/nPiQgBu8EX+l29QAKeu7P/jbGv/vPJB/7dR/wA5zrX/LyK1/9XwngFHS18AnCgY/2bSUQCrx+T/miIpAOOvSwAV78MAiuVfAUzAMQB1e1cB4+GCAH0+P/8CxqsA/iQN/pG6zgCU//T/IwCmAB6W2wFc5NQAXMY8/j6FyP/JKTsAfe5t/7Sj7gGMelIACRZY/8WdL/+ZXjkAWB62AFShVQCyknwApqYH/xXQ3wCctvIAm3m5AFOcrv6aEHb/ulPoAd86ef8dF1gAI31//6oFlf6kDIL/m8QdAKFgiAAHIx0BoiX7AAMu8v8A2bwAOa7iAc7pAgA5u4j+e70J/8l1f/+6JMwA5xnYAFBOaQAThoH/lMtEAI1Rff74pcj/1pCHAJc3pv8m61sAFS6aAN/+lv8jmbT/fbAdAStiHv/Yeub/6aAMADm5DP7wcQf/BQkQ/hpbbABtxssACJMoAIGG5P98uij/cmKE/qaEFwBjRSwACfLu/7g1OwCEgWb/NCDz/pPfyP97U7P+h5DJ/40lOAGXPOP/WkmcAcusuwBQly//Xonn/yS/O//h0bX/StfV/gZ2s/+ZNsEBMgDnAGidSAGM45r/tuIQ/mDhXP9zFKr+BvpOAPhLrf81WQb/ALR2AEitAQBACM4BroXfALk+hf/WC2IAxR/QAKun9P8W57UBltq5APepYQGli/f/L3iVAWf4MwA8RRz+GbPEAHwH2v46a1EAuOmc//xKJAB2vEMAjV81/95epf4uPTUAzjtz/y/s+v9KBSABgZru/2og4gB5uz3/A6bx/kOqrP8d2LL/F8n8AP1u8wDIfTkAbcBg/zRz7gAmefP/yTghAMJ2ggBLYBn/qh7m/ic//QAkLfr/+wHvAKDUXAEt0e0A8yFX/u1Uyf/UEp3+1GN//9liEP6LrO8AqMmC/4/Bqf/ul8EB12gpAO89pf4CA/IAFsux/rHMFgCVgdX+Hwsp/wCfef6gGXL/olDIAJ2XCwCahk4B2Db8ADBnhQBp3MUA/ahN/jWzFwAYefAB/y5g/2s8h/5izfn/P/l3/3g70/9ytDf+W1XtAJXUTQE4STEAVsaWAF3RoABFzbb/9ForABQksAB6dN0AM6cnAecBP/8NxYYAA9Ei/4c7ygCnZE4AL99MALk8PgCypnsBhAyh/z2uKwDDRZAAfy+/ASIsTgA56jQB/xYo//ZekgBT5IAAPE7g/wBg0v+Zr+wAnxVJALRzxP6D4WoA/6eGAJ8IcP94RML/sMTG/3YwqP9dqQEAcMhmAUoY/gATjQT+jj4/AIOzu/9NnJv/d1akAKrQkv/QhZr/lJs6/6J46P781ZsA8Q0qAF4ygwCzqnAAjFOX/zd3VAGMI+//mS1DAeyvJwA2l2f/nipB/8Tvh/5WNcsAlWEv/tgjEf9GA0YBZyRa/ygarQC4MA0Ao9vZ/1EGAf/dqmz+6dBdAGTJ+f5WJCP/0ZoeAePJ+/8Cvaf+ZDkDAA2AKQDFZEsAlszr/5GuOwB4+JX/VTfhAHLSNf7HzHcADvdKAT/7gQBDaJcBh4JQAE9ZN/915p3/GWCPANWRBQBF8XgBlfNf/3IqFACDSAIAmjUU/0k+bQDEZpgAKQzM/3omCwH6CpEAz32UAPb03v8pIFUBcNV+AKL5VgFHxn//UQkVAWInBP/MRy0BS2+JAOo75wAgMF//zB9yAR3Etf8z8af+XW2OAGiQLQDrDLX/NHCkAEz+yv+uDqIAPeuT/ytAuf7pfdkA81in/koxCACczEIAfNZ7ACbddgGScOwAcmKxAJdZxwBXxXAAuZWhACxgpQD4sxT/vNvY/ig+DQDzjo0A5ePO/6zKI/91sOH/Um4mASr1Dv8UU2EAMasKAPJ3eAAZ6D0A1PCT/wRzOP+REe/+yhH7//kS9f9jde8AuASz//btM/8l74n/pnCm/1G8If+5+o7/NrutANBwyQD2K+QBaLhY/9Q0xP8zdWz//nWbAC5bD/9XDpD/V+PMAFMaUwGfTOMAnxvVARiXbAB1kLP+idFSACafCgBzhckA37acAW7EXf85POkABadp/5rFpABgIrr/k4UlAdxjvgABp1T/FJGrAMLF+/5fToX//Pjz/+Fdg/+7hsT/2JmqABR2nv6MAXYAVp4PAS3TKf+TAWT+cXRM/9N/bAFnDzAAwRBmAUUzX/9rgJ0AiavpAFp8kAFqobYAr0zsAciNrP+jOmgA6bQ0//D9Dv+icf7/Ju+K/jQupgDxZSH+g7qcAG/QPv98XqD/H6z+AHCuOP+8Yxv/Q4r7AH06gAGcmK7/sgz3//xUngBSxQ7+rMhT/yUnLgFqz6cAGL0iAIOykADO1QQAoeLSAEgzaf9hLbv/Trjf/7Ad+wBPoFb/dCWyAFJN1QFSVI3/4mXUAa9Yx//1XvcBrHZt/6a5vgCDtXgAV/5d/4bwSf8g9Y//i6Jn/7NiEv7ZzHAAk994/zUK8wCmjJYAfVDI/w5t2/9b2gH//Pwv/m2cdP9zMX8BzFfT/5TK2f8aVfn/DvWGAUxZqf/yLeYAO2Ks/3JJhP5OmzH/nn5UADGvK/8QtlT/nWcjAGjBbf9D3ZoAyawB/giiWAClAR3/fZvl/x6a3AFn71wA3AFt/8rGAQBeAo4BJDYsAOvinv+q+9b/uU0JAGFK8gDbo5X/8CN2/99yWP7AxwMAaiUY/8mhdv9hWWMB4Dpn/2XHk/7ePGMA6hk7ATSHGwBmA1v+qNjrAOXoiABoPIEALqjuACe/QwBLoy8Aj2Fi/zjYqAGo6fz/I28W/1xUKwAayFcBW/2YAMo4RgCOCE0AUAqvAfzHTAAWblL/gQHCAAuAPQFXDpH//d6+AQ9IrgBVo1b+OmMs/y0YvP4azQ8AE+XS/vhDwwBjR7gAmscl/5fzef8mM0v/yVWC/ixB+gA5k/P+kis7/1kcNQAhVBj/szMS/r1GUwALnLMBYoZ3AJ5vbwB3mkn/yD+M/i0NDf+awAL+UUgqAC6guf4scAYAkteVARqwaABEHFcB7DKZ/7OA+v7Owb//plyJ/jUo7wDSAcz+qK0jAI3zLQEkMm3/D/LC/+Ofev+wr8r+RjlIACjfOADQojr/t2JdAA9vDAAeCEz/hH/2/y3yZwBFtQ//CtEeAAOzeQDx6NoBe8dY/wLSygG8glH/XmXQAWckLQBMwRgBXxrx/6WiuwAkcowAykIF/yU4kwCYC/MBf1Xo//qH1AG5sXEAWtxL/0X4kgAybzIAXBZQAPQkc/6jZFL/GcEGAX89JAD9Qx7+Qeyq/6ER1/4/r4wAN38EAE9w6QBtoCgAj1MH/0Ea7v/ZqYz/Tl69/wCTvv+TR7r+ak1//+md6QGHV+3/0A3sAZttJP+0ZNoAtKMSAL5uCQERP3v/s4i0/6V7e/+QvFH+R/Bs/xlwC//j2jP/pzLq/3JPbP8fE3P/t/BjAONXj/9I2fj/ZqlfAYGVlQDuhQwB48wjANBzGgFmCOoAcFiPAZD5DgDwnqz+ZHB3AMKNmf4oOFP/ebAuACo1TP+ev5oAW9FcAK0NEAEFSOL/zP6VAFC4zwBkCXr+dmWr//zLAP6gzzYAOEj5ATiMDf8KQGv+W2U0/+G1+AGL/4QA5pERAOk4FwB3AfH/1amX/2NjCf65D7//rWdtAa4N+/+yWAf+GztE/wohAv/4YTsAGh6SAbCTCgBfec8BvFgYALle/v5zN8kAGDJGAHg1BgCOQpIA5OL5/2jA3gGtRNsAorgk/49mif+dCxcAfS1iAOtd4f44cKD/RnTzAZn5N/+BJxEB8VD0AFdFFQFe5En/TkJB/8Lj5wA9klf/rZsX/3B02/7YJgv/g7qFAF7UuwBkL1sAzP6v/94S1/6tRGz/4+RP/ybd1QCj45b+H74SAKCzCwEKWl7/3K5YAKPT5f/HiDQAgl/d/4y85/6LcYD/davs/jHcFP87FKv/5G28ABThIP7DEK4A4/6IAYcnaQCWTc7/0u7iADfUhP7vOXwAqsJd//kQ9/8Ylz7/CpcKAE+Lsv948soAGtvVAD59I/+QAmz/5iFT/1Et2AHgPhEA1tl9AGKZmf+zsGr+g12K/20+JP+yeSD/ePxGANz4JQDMWGcBgNz7/+zjBwFqMcb/PDhrAGNy7gDczF4BSbsBAFmaIgBO2aX/DsP5/wnm/f/Nh/UAGvwH/1TNGwGGAnAAJZ4gAOdb7f+/qsz/mAfeAG3AMQDBppL/6BO1/2mONP9nEBsB/cilAMPZBP80vZD/e5ug/leCNv9OeD3/DjgpABkpff9XqPUA1qVGANSpBv/b08L+SF2k/8UhZ/8rjo0Ag+GsAPRpHABEROEAiFQN/4I5KP6LTTgAVJY1ADZfnQCQDbH+X3O6AHUXdv/0pvH/C7qHALJqy/9h2l0AK/0tAKSYBACLdu8AYAEY/uuZ0/+obhT/Mu+wAHIp6ADB+jUA/qBv/oh6Kf9hbEMA15gX/4zR1AAqvaMAyioy/2pqvf++RNn/6Tp1AOXc8wHFAwQAJXg2/gSchv8kPav+pYhk/9ToDgBargoA2MZB/wwDQAB0cXP/+GcIAOd9Ev+gHMUAHrgjAd9J+f97FC7+hzgl/60N5QF3oSL/9T1JAM19cACJaIYA2fYe/+2OjwBBn2b/bKS+ANt1rf8iJXj+yEVQAB982v5KG6D/uprH/0fH/ABoUZ8BEcgnANM9wAEa7lsAlNkMADtb1f8LUbf/geZ6/3LLkQF3tEL/SIq0AOCVagB3Umj/0IwrAGIJtv/NZYb/EmUmAF/Fpv/L8ZMAPtCR/4X2+wACqQ4ADfe4AI4H/gAkyBf/WM3fAFuBNP8Vuh4Aj+TSAffq+P/mRR/+sLqH/+7NNAGLTysAEbDZ/iDzQwDyb+kALCMJ/+NyUQEERwz/Jmm/AAd1Mv9RTxAAP0RB/50kbv9N8QP/4i37AY4ZzgB4e9EBHP7u/wWAfv9b3tf/og+/AFbwSQCHuVH+LPGjANTb0v9wopsAz2V2AKhIOP/EBTQASKzy/34Wnf+SYDv/onmY/owQXwDD/sj+UpaiAHcrkf7MrE7/puCfAGgT7f/1ftD/4jvVAHXZxQCYSO0A3B8X/g5a5/+81EABPGX2/1UYVgABsW0AklMgAUu2wAB38eAAue0b/7hlUgHrJU3//YYTAOj2egA8arMAwwsMAG1C6wF9cTsAPSikAK9o8AACL7v/MgyNAMKLtf+H+mgAYVze/9mVyf/L8Xb/T5dDAHqO2v+V9e8AiirI/lAlYf98cKf/JIpX/4Idk//xV07/zGETAbHRFv/343/+Y3dT/9QZxgEQs7MAkU2s/lmZDv/avacAa+k7/yMh8/4scHD/oX9PAcyvCgAoFYr+aHTkAMdfif+Fvqj/kqXqAbdjJwC33Db+/96FAKLbef4/7wYA4WY2//sS9gAEIoEBhySDAM4yOwEPYbcAq9iH/2WYK/+W+1sAJpFfACLMJv6yjFP/GYHz/0yQJQBqJBr+dpCs/0S65f9rodX/LqNE/5Wq/QC7EQ8A2qCl/6sj9gFgDRMApct1ANZrwP/0e7EBZANoALLyYf/7TIL/000qAfpPRv8/9FABaWX2AD2IOgHuW9UADjti/6dUTQARhC7+Oa/F/7k+uABMQM8ArK/Q/q9KJQCKG9P+lH3CAApZUQCoy2X/K9XRAev1NgAeI+L/CX5GAOJ9Xv6cdRT/OfhwAeYwQP+kXKYB4Nbm/yR4jwA3CCv/+wH1AWpipQBKa2r+NQQ2/1qylgEDeHv/9AVZAXL6Pf/+mVIBTQ8RADnuWgFf3+YA7DQv/meUpP95zyQBEhC5/0sUSgC7C2UALjCB/xbv0v9N7IH/b03M/z1IYf/H2fv/KtfMAIWRyf855pIB62TGAJJJI/5sxhT/tk/S/1JniAD2bLAAIhE8/xNKcv6oqk7/ne8U/5UpqAA6eRwAT7OG/+d5h/+u0WL/83q+AKumzQDUdDAAHWxC/6LetgEOdxUA1Sf5//7f5P+3pcYAhb4wAHzQbf93r1X/CdF5ATCrvf/DR4YBiNsz/7Zbjf4xn0gAI3b1/3C64/87iR8AiSyjAHJnPP4I1ZYAogpx/8JoSADcg3T/sk9cAMv61f5dwb3/gv8i/tS8lwCIERT/FGVT/9TOpgDl7kn/l0oD/6hX1wCbvIX/poFJAPBPhf+y01H/y0ij/sGopQAOpMf+Hv/MAEFIWwGmSmb/yCoA/8Jx4/9CF9AA5dhk/xjvGgAK6T7/ewqyARokrv9328cBLaO+ABCoKgCmOcb/HBoaAH6l5wD7bGT/PeV5/zp2igBMzxEADSJw/lkQqAAl0Gn/I8nX/yhqZf4G73IAKGfi/vZ/bv8/pzoAhPCOAAWeWP+BSZ7/XlmSAOY2kgAILa0AT6kBAHO69wBUQIMAQ+D9/8+9QACaHFEBLbg2/1fU4P8AYEn/gSHrATRCUP/7rpv/BLMlAOqkXf5dr/0AxkVX/+BqLgBjHdIAPrxy/yzqCACpr/f/F22J/+W2JwDApV7+9WXZAL9YYADEXmP/au4L/jV+8wBeAWX/LpMCAMl8fP+NDNoADaadATD77f+b+nz/apSS/7YNygAcPacA2ZgI/tyCLf/I5v8BN0FX/12/Yf5y+w4AIGlcARrPjQAYzw3+FTIw/7qUdP/TK+EAJSKi/qTSKv9EF2D/ttYI//V1if9CwzIASwxT/lCMpAAJpSQB5G7jAPERWgEZNNQABt8M/4vzOQAMcUsB9re//9W/Rf/mD44AAcPE/4qrL/9AP2oBEKnW/8+uOAFYSYX/toWMALEOGf+TuDX/CuOh/3jY9P9JTekAne6LATtB6QBG+9gBKbiZ/yDLcACSk/0AV2VtASxShf/0ljX/Xpjo/ztdJ/9Yk9z/TlENASAv/P+gE3L/XWsn/3YQ0wG5d9H/49t//lhp7P+ibhf/JKZu/1vs3f9C6nQAbxP0/grpGgAgtwb+Ar/yANqcNf4pPEb/qOxvAHm5fv/ujs//N340ANyB0P5QzKT/QxeQ/toobP9/yqQAyyED/wKeAAAlYLz/wDFKAG0EAABvpwr+W9qH/8tCrf+WwuIAyf0G/65meQDNv24ANcIEAFEoLf4jZo//DGzG/xAb6P/8R7oBsG5yAI4DdQFxTY4AE5zFAVwv/AA16BYBNhLrAC4jvf/s1IEAAmDQ/sjux/87r6T/kivnAMLZNP8D3wwAijay/lXrzwDozyIAMTQy/6ZxWf8KLdj/Pq0cAG+l9gB2c1v/gFQ8AKeQywBXDfMAFh7kAbFxkv+Bqub+/JmB/5HhKwBG5wX/eml+/lb2lP9uJZr+0QNbAESRPgDkEKX/N935/rLSWwBTkuL+RZK6AF3SaP4QGa0A57omAL16jP/7DXD/aW5dAPtIqgDAF9//GAPKAeFd5ACZk8f+baoWAPhl9v+yfAz/sv5m/jcEQQB91rQAt2CTAC11F/6Ev/kAj7DL/oi3Nv+S6rEAkmVW/yx7jwEh0ZgAwFop/lMPff/VrFIA16mQABANIgAg0WT/VBL5AcUR7P/ZuuYAMaCw/292Yf/taOsATztc/kX5C/8jrEoBE3ZEAN58pf+0QiP/Vq72ACtKb/9+kFb/5OpbAPLVGP5FLOv/3LQjAAj4B/9mL1z/8M1m/3HmqwEfucn/wvZG/3oRuwCGRsf/lQOW/3U/ZwBBaHv/1DYTAQaNWABThvP/iDVnAKkbtACxMRgAbzanAMM91/8fAWwBPCpGALkDov/ClSj/9n8m/r53Jv89dwgBYKHb/yrL3QGx8qT/9Z8KAHTEAAAFXc3+gH+zAH3t9v+Votn/VyUU/ozuwAAJCcEAYQHiAB0mCgAAiD//5UjS/iaGXP9O2tABaCRU/wwFwf/yrz3/v6kuAbOTk/9xvov+fawfAANL/P7XJA8AwRsYAf9Flf9ugXYAy135AIqJQP4mRgYAmXTeAKFKewDBY0//djte/z0MKwGSsZ0ALpO/ABD/JgALMx8BPDpi/2/CTQGaW/QAjCiQAa0K+wDL0TL+bIJOAOS0WgCuB/oAH648ACmrHgB0Y1L/dsGL/7utxv7abzgAuXvYAPmeNAA0tF3/yQlb/zgtpv6Em8v/OuhuADTTWf/9AKIBCVe3AJGILAFeevUAVbyrAZNcxgAACGgAHl+uAN3mNAH39+v/ia41/yMVzP9H49YB6FLCAAsw4/+qSbj/xvv8/ixwIgCDZYP/SKi7AISHff+KaGH/7rio//NoVP+H2OL/i5DtALyJlgFQOIz/Vqmn/8JOGf/cEbT/EQ3BAHWJ1P+N4JcAMfSvAMFjr/8TY5oB/0E+/5zSN//y9AP/+g6VAJ5Y2f+dz4b+++gcAC6c+/+rOLj/7zPqAI6Kg/8Z/vMBCsnCAD9hSwDS76IAwMgfAXXW8wAYR97+Nijo/0y3b/6QDlf/1k+I/9jE1ACEG4z+gwX9AHxsE/8c10sATN43/um2PwBEq7/+NG/e/wppTf9QqusAjxhY/y3neQCUgeABPfZUAP0u2//vTCEAMZQS/uYlRQBDhhb+jpteAB+d0/7VKh7/BOT3/vywDf8nAB/+8fT//6otCv793vkA3nKEAP8vBv+0o7MBVF6X/1nRUv7lNKn/1ewAAdY45P+Hd5f/cMnBAFOgNf4Gl0IAEqIRAOlhWwCDBU4BtXg1/3VfP//tdbkAv36I/5B36QC3OWEBL8m7/6eldwEtZH4AFWIG/pGWX/94NpgA0WJoAI9vHv64lPkA69guAPjKlP85XxYA8uGjAOn36P9HqxP/Z/Qx/1RnXf9EefQBUuANAClPK//5zqf/1zQV/sAgFv/3bzwAZUom/xZbVP4dHA3/xufX/vSayADfie0A04QOAF9Azv8RPvf/6YN5AV0XTQDNzDT+Ub2IALTbigGPEl4AzCuM/ryv2wBvYo//lz+i/9MyR/4TkjUAki1T/rJS7v8QhVT/4sZd/8lhFP94diP/cjLn/6LlnP/TGgwAcidz/87UhgDF2aD/dIFe/sfX2/9L3/kB/XS1/+jXaP/kgvb/uXVWAA4FCADvHT0B7VeF/32Sif7MqN8ALqj1AJppFgDc1KH/a0UY/4natf/xVMb/gnrT/40Imf++sXYAYFmyAP8QMP56YGn/dTbo/yJ+af/MQ6YA6DSK/9OTDAAZNgcALA/X/jPsLQC+RIEBapPhABxdLf7sjQ//ET2hANxzwADskRj+b6ipAOA6P/9/pLwAUupLAeCehgDRRG4B2abZAEbhpgG7wY//EAdY/wrNjAB1wJwBETgmABt8bAGr1zf/X/3UAJuHqP/2spn+mkRKAOg9YP5phDsAIUzHAb2wgv8JaBn+S8Zm/+kBcABs3BT/cuZGAIzChf85nqT+kgZQ/6nEYQFVt4IARp7eATvt6v9gGRr/6K9h/wt5+P5YI8IA27T8/koI4wDD40kBuG6h/zHppAGANS8AUg55/8G+OgAwrnX/hBcgACgKhgEWMxn/8Auw/245kgB1j+8BnWV2/zZUTADNuBL/LwRI/05wVf/BMkIBXRA0/whphgAMbUj/Opz7AJAjzAAsoHX+MmvCAAFEpf9vbqIAnlMo/kzW6gA62M3/q2CT/yjjcgGw4/EARvm3AYhUi/88evf+jwl1/7Guif5J948A7Ll+/z4Z9/8tQDj/ofQGACI5OAFpylMAgJPQAAZnCv9KikH/YVBk/9auIf8yhkr/bpeC/m9UrABUx0v++Dtw/wjYsgEJt18A7hsI/qrN3ADD5YcAYkzt/+JbGgFS2yf/4b7HAdnIef9Rswj/jEHOALLPV/76/C7/aFluAf29nv+Q1p7/oPU2/zW3XAEVyML/kiFxAdEB/wDraiv/pzToAJ3l3QAzHhkA+t0bAUGTV/9Pe8QAQcTf/0wsEQFV8UQAyrf5/0HU1P8JIZoBRztQAK/CO/+NSAkAZKD0AObQOAA7GUv+UMLCABIDyP6gn3MAhI/3AW9dOf867QsBht6H/3qjbAF7K77/+73O/lC2SP/Q9uABETwJAKHPJgCNbVsA2A/T/4hObgBio2j/FVB5/62ytwF/jwQAaDxS/tYQDf9g7iEBnpTm/3+BPv8z/9L/Po3s/p034P9yJ/QAwLz6/+RMNQBiVFH/rcs9/pMyN//M678ANMX0AFgr0/4bv3cAvOeaAEJRoQBcwaAB+uN4AHs34gC4EUgAhagK/haHnP8pGWf/MMo6ALqVUf+8hu8A67W9/tmLvP9KMFIALtrlAL39+wAy5Qz/042/AYD0Gf+p53r+Vi+9/4S3F/8lspb/M4n9AMhOHwAWaTIAgjwAAISjW/4X57sAwE/vAJ1mpP/AUhQBGLVn//AJ6gABe6T/hekA/8ry8gA8uvUA8RDH/+B0nv6/fVv/4FbPAHkl5//jCcb/D5nv/3no2f5LcFIAXww5/jPWaf+U3GEBx2IkAJzRDP4K1DQA2bQ3/tSq6P/YFFT/nfqHAJ1jf/4BzikAlSRGATbEyf9XdAD+66uWABuj6gDKh7QA0F8A/nucXQC3PksAieu2AMzh///Wi9L/AnMI/x0MbwA0nAEA/RX7/yWlH/4MgtMAahI1/ipjmgAO2T3+2Atc/8jFcP6TJscAJPx4/mupTQABe5//z0tmAKOvxAAsAfAAeLqw/g1iTP/tfPH/6JK8/8hg4ADMHykA0MgNABXhYP+vnMQA99B+AD649P4Cq1EAVXOeADZALf8TinIAh0fNAOMvkwHa50IA/dEcAPQPrf8GD3b+EJbQ/7kWMv9WcM//S3HXAT+SK/8E4RP+4xc+/w7/1v4tCM3/V8WX/tJS1//1+Pf/gPhGAOH3VwBaeEYA1fVcAA2F4gAvtQUBXKNp/wYehf7osj3/5pUY/xIxngDkZD3+dPP7/01LXAFR25P/TKP+/o3V9gDoJZj+YSxkAMklMgHU9DkArqu3//lKcACmnB4A3t1h//NdSf77ZWT/2Nld//6Ku/+OvjT/O8ux/8heNABzcp7/pZhoAX5j4v92nfQBa8gQAMFa5QB5BlgAnCBd/n3x0/8O7Z3/pZoV/7jgFv/6GJj/cU0fAPerF//tscz/NImR/8K2cgDg6pUACm9nAcmBBADujk4ANAYo/27Vpf48z/0APtdFAGBhAP8xLcoAeHkW/+uLMAHGLSL/tjIbAYPSW/8uNoAAr3tp/8aNTv5D9O//9TZn/k4m8v8CXPn++65X/4s/kAAYbBv/ImYSASIWmABC5Xb+Mo9jAJCplQF2HpgAsgh5AQifEgBaZeb/gR13AEQkCwHotzcAF/9g/6Epwf8/i94AD7PzAP9kD/9SNYcAiTmVAWPwqv8W5uT+MbRS/z1SKwBu9dkAx309AC79NACNxdsA05/BADd5af63FIEAqXeq/8uyi/+HKLb/rA3K/0GylAAIzysAejV/AUqhMADj1oD+Vgvz/2RWBwH1RIb/PSsVAZhUXv++PPr+73bo/9aIJQFxTGv/XWhkAZDOF/9ulpoB5Ge5ANoxMv6HTYv/uQFOAAChlP9hHen/z5SV/6CoAABbgKv/BhwT/gtv9wAnu5b/iuiVAHU+RP8/2Lz/6+og/h05oP8ZDPEBqTy/ACCDjf/tn3v/XsVe/nT+A/9cs2H+eWFc/6pwDgAVlfgA+OMDAFBgbQBLwEoBDFri/6FqRAHQcn//cir//koaSv/3s5b+eYw8AJNGyP/WKKH/obzJ/41Bh//yc/wAPi/KALSV//6CN+0ApRG6/wqpwgCcbdr/cIx7/2iA3/6xjmz/eSXb/4BNEv9vbBcBW8BLAK71Fv8E7D7/K0CZAeOt/gDteoQBf1m6/45SgP78VK4AWrOxAfPWV/9nPKL/0IIO/wuCiwDOgdv/Xtmd/+/m5v90c5/+pGtfADPaAgHYfcb/jMqA/gtfRP83CV3+rpkG/8ysYABFoG4A1SYx/htQ1QB2fXIARkZD/w+OSf+Dern/8xQy/oLtKADSn4wBxZdB/1SZQgDDfloAEO7sAXa7Zv8DGIX/u0XmADjFXAHVRV7/UIrlAc4H5gDeb+YBW+l3/wlZBwECYgEAlEqF/zP2tP/ksXABOr1s/8LL7f4V0cMAkwojAVad4gAfo4v+OAdL/z5adAC1PKkAiqLU/lGnHwDNWnD/IXDjAFOXdQGx4En/rpDZ/+bMT/8WTej/ck7qAOA5fv4JMY0A8pOlAWi2jP+nhAwBe0R/AOFXJwH7bAgAxsGPAXmHz/+sFkYAMkR0/2WvKP/4aekApssHAG7F2gDX/hr+qOL9AB+PYAALZykAt4HL/mT3Sv/VfoQA0pMsAMfqGwGUL7UAm1ueATZpr/8CTpH+ZppfAIDPf/40fOz/glRHAN3z0wCYqs8A3mrHALdUXv5cyDj/irZzAY5gkgCFiOQAYRKWADf7QgCMZgQAymeXAB4T+P8zuM8AysZZADfF4f6pX/n/QkFE/7zqfgCm32QBcO/0AJAXwgA6J7YA9CwY/q9Es/+YdpoBsKKCANlyzP6tfk7/Id4e/yQCW/8Cj/MACevXAAOrlwEY1/X/qC+k/vGSzwBFgbQARPNxAJA1SP77LQ4AF26oAERET/9uRl/+rluQ/yHOX/+JKQf/E7uZ/iP/cP8Jkbn+Mp0lAAtwMQFmCL7/6vOpATxVFwBKJ70AdDHvAK3V0gAuoWz/n5YlAMR4uf8iYgb/mcM+/2HmR/9mPUwAGtTs/6RhEADGO5IAoxfEADgYPQC1YsEA+5Pl/2K9GP8uNs7/6lL2ALdnJgFtPswACvDgAJIWdf+OmngARdQjANBjdgF5/wP/SAbCAHURxf99DxcAmk+ZANZexf+5N5P/Pv5O/n9SmQBuZj//bFKh/2m71AFQiicAPP9d/0gMugDS+x8BvqeQ/+QsE/6AQ+gA1vlr/oiRVv+ELrAAvbvj/9AWjADZ03QAMlG6/ov6HwAeQMYBh5tkAKDOF/67otP/ELw/AP7QMQBVVL8A8cDy/5l+kQHqoqL/5mHYAUCHfgC+lN8BNAAr/xwnvQFAiO4Ar8S5AGLi1f9/n/QB4q88AKDpjgG088//RZhZAR9lFQCQGaT+i7/RAFsZeQAgkwUAJ7p7/z9z5v9dp8b/j9Xc/7OcE/8ZQnoA1qDZ/wItPv9qT5L+M4lj/1dk5/+vkej/ZbgB/64JfQBSJaEBJHKN/zDejv/1upoABa7d/j9ym/+HN6ABUB+HAH76swHs2i0AFByRARCTSQD5vYQBEb3A/9+Oxv9IFA//+jXt/g8LEgAb03H+1Ws4/66Tkv9gfjAAF8FtASWiXgDHnfn+GIC7/80xsv5dpCr/K3frAVi37f/a0gH/a/4qAOYKY/+iAOIA2+1bAIGyywDQMl/+ztBf//e/Wf5u6k//pT3zABR6cP/29rn+ZwR7AOlj5gHbW/z/x94W/7P16f/T8eoAb/rA/1VUiABlOjL/g62c/nctM/926RD+8lrWAF6f2wEDA+r/Ykxc/lA25gAF5Of+NRjf/3E4dgEUhAH/q9LsADjxnv+6cxP/COWuADAsAAFycqb/Bkni/81Z9ACJ40sB+K04AEp49v53Awv/UXjG/4h6Yv+S8d0BbcJO/9/xRgHWyKn/Yb4v/y9nrv9jXEj+dum0/8Ej6f4a5SD/3vzGAMwrR//HVKwAhma+AG/uYf7mKOYA481A/sgM4QCmGd4AcUUz/4+fGACnuEoAHeB0/p7Q6QDBdH7/1AuF/xY6jAHMJDP/6B4rAOtGtf9AOJL+qRJU/+IBDf/IMrD/NNX1/qjRYQC/RzcAIk6cAOiQOgG5Sr0Auo6V/kBFf/+hy5P/sJe/AIjny/6jtokAoX77/ukgQgBEz0IAHhwlAF1yYAH+XPf/LKtFAMp3C/+8djIB/1OI/0dSGgBG4wIAIOt5AbUpmgBHhuX+yv8kACmYBQCaP0n/IrZ8AHndlv8azNUBKaxXAFqdkv9tghQAR2vI//NmvQABw5H+Llh1AAjO4wC/bv3/bYAU/oZVM/+JsXAB2CIW/4MQ0P95laoAchMXAaZQH/9x8HoA6LP6AERutP7SqncA32yk/89P6f8b5eL+0WJR/09EBwCDuWQAqh2i/xGia/85FQsBZMi1/39BpgGlhswAaKeoAAGkTwCShzsBRjKA/2Z3Df7jBocAoo6z/6Bk3gAb4NsBnl3D/+qNiQAQGH3/7s4v/2ERYv90bgz/YHNNAFvj6P/4/k//XOUG/ljGiwDOS4EA+k3O/430ewGKRdwAIJcGAYOnFv/tRKf+x72WAKOriv8zvAb/Xx2J/pTiswC1a9D/hh9S/5dlLf+ByuEA4EiTADCKl//DQM7+7dqeAGodif79ven/Zw8R/8Jh/wCyLan+xuGbACcwdf+HanMAYSa1AJYvQf9TguX+9iaBAFzvmv5bY38AoW8h/+7Z8v+DucP/1b+e/ymW2gCEqYMAWVT8AatGgP+j+Mv+ATK0/3xMVQH7b1AAY0Lv/5rttv/dfoX+Ssxj/0GTd/9jOKf/T/iV/3Sb5P/tKw7+RYkL/xb68QFbeo//zfnzANQaPP8wtrABMBe//8t5mP4tStX/PloS/vWj5v+5anT/UyOfAAwhAv9QIj4AEFeu/61lVQDKJFH+oEXM/0DhuwA6zl4AVpAvAOVW9QA/kb4BJQUnAG37GgCJk+oAonmR/5B0zv/F6Ln/t76M/0kM/v+LFPL/qlrv/2FCu//1tYf+3og0APUFM/7LL04AmGXYAEkXfQD+YCEB69JJ/yvRWAEHgW0Aemjk/qryywDyzIf/yhzp/0EGfwCfkEcAZIxfAE6WDQD7a3YBtjp9/wEmbP+NvdH/CJt9AXGjW/95T77/hu9s/0wv+ACj5O8AEW8KAFiVS//X6+8Ap58Y/y+XbP9r0bwA6edj/hzKlP+uI4r/bhhE/wJFtQBrZlIAZu0HAFwk7f/dolMBN8oG/4fqh/8Y+t4AQV6o/vX40v+nbMn+/6FvAM0I/gCIDXQAZLCE/yvXfv+xhYL/nk+UAEPgJQEMzhX/PiJuAe1or/9QhG//jq5IAFTltP5ps4wAQPgP/+mKEAD1Q3v+2nnU/z9f2gHVhYn/j7ZS/zAcCwD0co0B0a9M/521lv+65QP/pJ1vAee9iwB3yr7/2mpA/0TrP/5gGqz/uy8LAdcS+/9RVFkARDqAAF5xBQFcgdD/YQ9T/gkcvADvCaQAPM2YAMCjYv+4EjwA2baLAG07eP8EwPsAqdLw/yWsXP6U0/X/s0E0AP0NcwC5rs4BcryV/+1arQArx8D/WGxxADQjTABCGZT/3QQH/5fxcv++0egAYjLHAJeW1f8SSiQBNSgHABOHQf8arEUAru1VAGNfKQADOBAAJ6Cx/8hq2v65RFT/W7o9/kOPjf8N9Kb/Y3LGAMduo//BEroAfO/2AW5EFgAC6y4B1DxrAGkqaQEO5pgABwWDAI1omv/VAwYAg+Si/7NkHAHne1X/zg7fAf1g5gAmmJUBYol6ANbNA//imLP/BoWJAJ5FjP9xopr/tPOs/xu9c/+PLtz/1Ybh/34dRQC8K4kB8kYJAFrM///nqpMAFzgT/jh9nf8ws9r/T7b9/ybUvwEp63wAYJccAIeUvgDN+Sf+NGCI/9QsiP9D0YP//IIX/9uAFP/GgXYAbGULALIFkgE+B2T/texe/hwapABMFnD/eGZPAMrA5QHIsNcAKUD0/864TgCnLT8BoCMA/zsMjv/MCZD/217lAXobcAC9aW3/QNBK//t/NwEC4sYALEzRAJeYTf/SFy4ByatF/yzT5wC+JeD/9cQ+/6m13v8i0xEAd/HF/+UjmAEVRSj/suKhAJSzwQDbwv4BKM4z/+dc+gFDmaoAFZTxAKpFUv95Euf/XHIDALg+5gDhyVf/kmCi/7Xy3ACtu90B4j6q/zh+2QF1DeP/syzvAJ2Nm/+Q3VMA69HQACoRpQH7UYUAfPXJ/mHTGP9T1qYAmiQJ//gvfwBa24z/odkm/tSTP/9CVJQBzwMBAOaGWQF/Tnr/4JsB/1KISgCynND/uhkx/94D0gHllr7/VaI0/ylUjf9Je1T+XRGWAHcTHAEgFtf/HBfM/47xNP/kNH0AHUzPANen+v6vpOYAN89pAW279f+hLNwBKWWA/6cQXgBd1mv/dkgA/lA96v95r30Ai6n7AGEnk/76xDH/pbNu/t9Gu/8Wjn0BmrOK/3awKgEKrpkAnFxmAKgNof+PECAA+sW0/8ujLAFXICQAoZkU/3v8DwAZ41AAPFiOABEWyQGazU3/Jz8vAAh6jQCAF7b+zCcT/wRwHf8XJIz/0up0/jUyP/95q2j/oNteAFdSDv7nKgUApYt//lZOJgCCPEL+yx4t/y7EegH5NaL/iI9n/tfScgDnB6D+qZgq/28t9gCOg4f/g0fM/yTiCwAAHPL/4YrV//cu2P71A7cAbPxKAc4aMP/NNvb/08Yk/3kjMgA02Mr/JouB/vJJlABD543/Ki/MAE50GQEE4b//BpPkADpYsQB6peX//FPJ/+CnYAGxuJ7/8mmzAfjG8ACFQssB/iQvAC0Yc/93Pv4AxOG6/nuNrAAaVSn/4m+3ANXnlwAEOwf/7oqUAEKTIf8f9o3/0Y10/2hwHwBYoawAU9fm/i9vlwAtJjQBhC3MAIqAbf7pdYb/876t/vHs8ABSf+z+KN+h/2624f97ru8Ah/KRATPRmgCWA3P+2aT8/zecRQFUXv//6EktARQT1P9gxTv+YPshACbHSQFArPf/dXQ4/+QREgA+imcB9uWk//R2yf5WIJ//bSKJAVXTugAKwcH+esKxAHruZv+i2qsAbNmhAZ6qIgCwL5sBteQL/wicAAAQS10AzmL/ATqaIwAM87j+Q3VC/+blewDJKm4AhuSy/rpsdv86E5r/Uqk+/3KPcwHvxDL/rTDB/5MCVP+WhpP+X+hJAG3jNP6/iQoAKMwe/kw0Yf+k634A/ny8AEq2FQF5HSP/8R4H/lXa1v8HVJb+URt1/6CfmP5CGN3/4wo8AY2HZgDQvZYBdbNcAIQWiP94xxwAFYFP/rYJQQDao6kA9pPG/2smkAFOr83/1gX6/i9YHf+kL8z/KzcG/4OGz/50ZNYAYIxLAWrckADDIBwBrFEF/8ezNP8lVMsAqnCuAAsEWwBF9BsBdYNcACGYr/+MmWv/+4cr/leKBP/G6pP+eZhU/81lmwGdCRkASGoR/myZAP+95boAwQiw/66V0QDugh0A6dZ+AT3iZgA5owQBxm8z/y1PTgFz0gr/2gkZ/56Lxv/TUrv+UIVTAJ2B5gHzhYb/KIgQAE1rT/+3VVwBsczKAKNHk/+YRb4ArDO8AfrSrP/T8nEBWVka/0BCb/50mCoAoScb/zZQ/gBq0XMBZ3xhAN3mYv8f5wYAssB4/g/Zy/98nk8AcJH3AFz6MAGjtcH/JS+O/pC9pf8ukvAABkuAACmdyP5XedUAAXHsAAUt+gCQDFIAH2znAOHvd/+nB73/u+SE/269IgBeLMwBojTFAE688f45FI0A9JIvAc5kMwB9a5T+G8NNAJj9WgEHj5D/MyUfACJ3Jv8HxXYAmbzTAJcUdP71QTT/tP1uAS+x0QChYxH/dt7KAH2z/AF7Nn7/kTm/ADe6eQAK84oAzdPl/32c8f6UnLn/4xO8/3wpIP8fIs7+ETlTAMwWJf8qYGIAd2a4AQO+HABuUtr/yMzA/8mRdgB1zJIAhCBiAcDCeQBqofgB7Vh8ABfUGgDNq1r/+DDYAY0l5v98ywD+nqge/9b4FQBwuwf/S4Xv/0rj8//6k0YA1niiAKcJs/8WnhIA2k3RAWFtUf/0IbP/OTQ5/0Gs0v/5R9H/jqnuAJ69mf+u/mf+YiEOAI1M5v9xizT/DzrUAKjXyf/4zNcB30Sg/zmat/4v53kAaqaJAFGIigClKzMA54s9ADlfO/52Yhn/lz/sAV6++v+puXIBBfo6/0tpYQHX34YAcWOjAYA+cABjapMAo8MKACHNtgDWDq7/gSbn/zW23wBiKp//9w0oALzSsQEGFQD//z2U/oktgf9ZGnT+fiZyAPsy8v55hoD/zPmn/qXr1wDKsfMAhY0+APCCvgFur/8AABSSASXSef8HJ4IAjvpU/43IzwAJX2j/C/SuAIbofgCnAXv+EMGV/+jp7wHVRnD//HSg/vLe3P/NVeMAB7k6AHb3PwF0TbH/PvXI/j8SJf9rNej+Mt3TAKLbB/4CXisAtj62/qBOyP+HjKoA67jkAK81iv5QOk3/mMkCAT/EIgAFHrgAq7CaAHk7zgAmYycArFBN/gCGlwC6IfH+Xv3f/yxy/ABsfjn/ySgN/yflG/8n7xcBl3kz/5mW+AAK6q7/dvYE/sj1JgBFofIBELKWAHE4ggCrH2kAGlhs/zEqagD7qUIARV2VABQ5/gCkGW8AWrxa/8wExQAo1TIB1GCE/1iKtP7kknz/uPb3AEF1Vv/9ZtL+/nkkAIlzA/88GNgAhhIdADviYQCwjkcAB9GhAL1UM/6b+kgA1VTr/y3e4ADulI//qio1/06ndQC6ACj/fbFn/0XhQgDjB1gBS6wGAKkt4wEQJEb/MgIJ/4vBFgCPt+f+2kUyAOw4oQHVgyoAipEs/ojlKP8xPyP/PZH1/2XAAv7op3EAmGgmAXm52gB5i9P+d/AjAEG92f67s6L/oLvmAD74Dv88TmEA//ej/+E7W/9rRzr/8S8hATJ17ADbsT/+9FqzACPC1/+9QzL/F4eBAGi9Jf+5OcIAIz7n/9z4bAAM57IAj1BbAYNdZf+QJwIB//qyAAUR7P6LIC4AzLwm/vVzNP+/cUn+v2xF/xZF9QEXy7IAqmOqAEH4bwAlbJn/QCVFAABYPv5ZlJD/v0TgAfEnNQApy+3/kX7C/90q/f8ZY5cAYf3fAUpzMf8Gr0j/O7DLAHy3+QHk5GMAgQzP/qjAw//MsBD+mOqrAE0lVf8heIf/jsLjAR/WOgDVu33/6C48/750Kv6XshP/Mz7t/szswQDC6DwArCKd/70QuP5nA1//jekk/ikZC/8Vw6YAdvUtAEPVlf+fDBL/u6TjAaAZBQAMTsMBK8XhADCOKf7Emzz/38cSAZGInAD8dan+keLuAO8XawBttbz/5nAx/kmq7f/nt+P/UNwUAMJrfwF/zWUALjTFAdKrJP9YA1r/OJeNAGC7//8qTsgA/kZGAfR9qADMRIoBfNdGAGZCyP4RNOQAddyP/sv4ewA4Eq7/upek/zPo0AGg5Cv/+R0ZAUS+PwANAAAAAP8AAAAA9QAAAAAAAPsAAAAAAAD9AAAAAPMAAAAABwAAAAAAAwAAAADzAAAAAAUAAAAAAAAAAAsAAAAAAAsAAAAA8wAAAAAAAP0AAAAAAP8AAAAAAwAAAAD1AAAAAAAAAA8AAAAAAP8AAAAA/wAAAAAHAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbolY/CsiewRcP0ifLvmPDV36wF08YzObE4AohtU/wFxxdqcD1N2E+6PAt2DRBnDyogU/osOczGTsf9d5KsA3rs////////////////////////////////////////f+3///////////////////////////////////////9/7v///////////////////////////////////////3/t0/VcGmMSWNac96Le+d4UAAAAAAAAAAAAAAAAAAAAEAZtBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGfmCWqFrme7cvNuPDr1T6V/Ug5RjGgFm6vZgx8ZzeBbmC+KQpFEN3HP+8C1pdu16VvCVjnxEfFZpII/ktVeHKuYqgfYAVuDEr6FMSTDfQxVdF2+cv6x3oCnBtybdPGbwcFpm+SGR77vxp3BD8yhDCRvLOktqoR0StypsFzaiPl2UlE+mG3GMajIJwOwx39Zv/ML4MZHkafVUWPKBmcpKRSFCrcnOCEbLvxtLE0TDThTVHMKZbsKanYuycKBhSxykqHov6JLZhqocItLwqNRbMcZ6JLRJAaZ1oU1DvRwoGoQFsGkGQhsNx5Md0gntbywNLMMHDlKqthOT8qcW/NvLmjugo90b2OleBR4yIQIAseM+v++kOtsUKT3o/m+8nhxxoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIybzzZ+YJajunyoSFrme7K/iU/nLzbjzxNh1fOvVPpdGC5q1/Ug5RH2w+K4xoBZtrvUH7q9mDH3khfhMZzeBbIq4o15gvikLNZe8jkUQ3cS87TezP+8C1vNuJgaXbtek4tUjzW8JWORnQBbbxEfFZm08Zr6SCP5IYgW3a1V4cq0ICA6OYqgfYvm9wRQFbgxKMsuROvoUxJOK0/9XDfQxVb4l78nRdvnKxlhY7/rHegDUSxyWnBtyblCZpz3Txm8HSSvGewWmb5OMlTziGR77vtdWMi8adwQ9lnKx3zKEMJHUCK1lvLOktg+SmbqqEdErU+0G93KmwXLVTEYPaiPl2q99m7lJRPpgQMrQtbcYxqD8h+5jIJwOw5A7vvsd/Wb/Cj6g98wvgxiWnCpNHkafVb4ID4FFjygZwbg4KZykpFPwv0kaFCrcnJskmXDghGy7tKsRa/G0sTd+zlZ0TDThT3mOvi1RzCmWosnc8uwpqduau7UcuycKBOzWCFIUscpJkA/FMoei/ogEwQrxLZhqokZf40HCLS8IwvlQGo1FsxxhS79YZ6JLREKllVSQGmdYqIHFXhTUO9LjRuzJwoGoQyNDSuBbBpBlTq0FRCGw3Hpnrjt9Md0gnqEib4bW8sDRjWsnFswwcOcuKQeNKqthOc+Njd0/KnFujuLLW828uaPyy713ugo90YC8XQ29jpXhyq/ChFHjIhOw5ZBoIAseMKB5jI/r/vpDpvYLe62xQpBV5xrL3o/m+K1Ny4/J4ccacYSbqzj4nygfCwCHHuIbRHuvgzdZ92up40W7uf0999bpvF3KqZ/AGppjIosV9YwquDfm+BJg/ERtHHBM1C3EbhH0EI/V32yiTJMdAe6vKMry+yRUKvp48TA0QnMRnHUO2Qj7LvtTFTCp+ZfycKX9Z7PrWOqtvy18XWEdKjBlEbIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODrenw7QbiuFlbj+vGfxGraCY3rnDKx/YZiBRZfSbgAX5yVvKNQjCSx0LFVnIPvWwREXMRYHI6G2CJO3dCfEVfs////////////////////////////////////////f+3///////////////////////////////////////9/7v///////////////////////////////////////3/N63p8O0G4rhZW4/rxn8Rq2gmN65wysf2GYgUWX0m4gEyclbyjUIwksdCxVZyD71sERFzEWByOhtgiTt3QnxHX2f/////////////////////////////////////////a/////////////////////////////////////////9v/////////////////////////////////////////U2lnRWQyNTUxOSBubyBFZDI1NTE5IGNvbGxpc2lvbnMBAAAAAAAAAAAAAAAAAAAAaG1hY3NoYTUxMjI1NgBjdXJ2ZTI1NTE5eHNhbHNhMjBwb2x5MTMwNQBTLT5idWZsZW4gPD0gQkxBS0UyQl9CTE9DS0JZVEVTAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9ibGFrZTJiLXJlZi5jAGNyeXB0b19nZW5lcmljaGFzaF9ibGFrZTJiX19maW5hbABvdXRsZW4gPD0gVUlOVDhfTUFYAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9nZW5lcmljaGFzaF9ibGFrZTJiLmMAY3J5cHRvX2dlbmVyaWNoYXNoX2JsYWtlMmJfZmluYWwAc2hhNTEyAGJsYWtlMmIAeDI1NTE5Ymxha2UyYgBwb2x5MTMwNQAkYXJnb24yaWQAJGFyZ29uMmkAJHY9ACRtPQAsdD0ALHA9ACRhcmdvbjJpZCR2PQAkYXJnb24yaSR2PQAkYXJnb24yaWQkACRhcmdvbjJpJABhcmdvbjJpAGN1cnZlMjU1MTkAeHNhbHNhMjBwb2x5MTMwNQBzaXBoYXNoMjQAZWQyNTUxOQB4c2Fsc2EyMABqcwAieyByZXR1cm4gTW9kdWxlLmdldFJhbmRvbVZhbHVlKCk7IH0iAHsgaWYgKE1vZHVsZS5nZXRSYW5kb21WYWx1ZSA9PT0gdW5kZWZpbmVkKSB7IHRyeSB7IHZhciB3aW5kb3dfID0gJ29iamVjdCcgPT09IHR5cGVvZiB3aW5kb3cgPyB3aW5kb3cgOiBzZWxmOyB2YXIgY3J5cHRvXyA9IHR5cGVvZiB3aW5kb3dfLmNyeXB0byAhPT0gJ3VuZGVmaW5lZCcgPyB3aW5kb3dfLmNyeXB0byA6IHdpbmRvd18ubXNDcnlwdG87IHZhciByYW5kb21WYWx1ZXNTdGFuZGFyZCA9IGZ1bmN0aW9uKCkgeyB2YXIgYnVmID0gbmV3IFVpbnQzMkFycmF5KDEpOyBjcnlwdG9fLmdldFJhbmRvbVZhbHVlcyhidWYpOyByZXR1cm4gYnVmWzBdID4+PiAwOyB9OyByYW5kb21WYWx1ZXNTdGFuZGFyZCgpOyBNb2R1bGUuZ2V0UmFuZG9tVmFsdWUgPSByYW5kb21WYWx1ZXNTdGFuZGFyZDsgfSBjYXRjaCAoZSkgeyB0cnkgeyB2YXIgY3J5cHRvID0gcmVxdWlyZSgnY3J5cHRvJyk7IHZhciByYW5kb21WYWx1ZU5vZGVKUyA9IGZ1bmN0aW9uKCkgeyB2YXIgYnVmID0gY3J5cHRvWydyYW5kb21CeXRlcyddKDQpOyByZXR1cm4gKGJ1ZlswXSA8PCAyNCB8IGJ1ZlsxXSA8PCAxNiB8IGJ1ZlsyXSA8PCA4IHwgYnVmWzNdKSA+Pj4gMDsgfTsgcmFuZG9tVmFsdWVOb2RlSlMoKTsgTW9kdWxlLmdldFJhbmRvbVZhbHVlID0gcmFuZG9tVmFsdWVOb2RlSlM7IH0gY2F0Y2ggKGUpIHsgdGhyb3cgJ05vIHNlY3VyZSByYW5kb20gbnVtYmVyIGdlbmVyYXRvciBmb3VuZCc7IH0gfSB9IH0ATGlic29kaXVtRFJHYnVmX2xlbiA8PSBTSVpFX01BWAByYW5kb21ieXRlcy9yYW5kb21ieXRlcy5jAHJhbmRvbWJ5dGVzAGI2NF9wb3MgPD0gYjY0X2xlbgBzb2RpdW0vY29kZWNzLmMAc29kaXVtX2JpbjJiYXNlNjQAMS4wLjE2AC4vMDEyMzQ1Njc4OUFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoAJDck";var tempDoublePtr=STATICTOP;STATICTOP+=16;function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+Pointer_stringify(condition)+", at: "+[filename?Pointer_stringify(filename):"unknown filename",line,func?Pointer_stringify(func):"unknown function"])}function _abort(){Module["abort"]()}function _emscripten_memcpy_big(dest,src,num){HEAPU8.set(HEAPU8.subarray(src,src+num),dest);return dest}function ___setErrNo(value){if(Module["___errno_location"])HEAP32[Module["___errno_location"]()>>2]=value;return value}var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};function _sysconf(name){switch(name){case 30:return PAGE_SIZE;case 85:var maxHeapSize=2*1024*1024*1024-16777216;return maxHeapSize/PAGE_SIZE;case 132:case 133:case 12:case 137:case 138:case 15:case 235:case 16:case 17:case 18:case 19:case 20:case 149:case 13:case 10:case 236:case 153:case 9:case 21:case 22:case 159:case 154:case 14:case 77:case 78:case 139:case 80:case 81:case 82:case 68:case 67:case 164:case 11:case 29:case 47:case 48:case 95:case 52:case 51:case 46:return 200809;case 79:return 0;case 27:case 246:case 127:case 128:case 23:case 24:case 160:case 161:case 181:case 182:case 242:case 183:case 184:case 243:case 244:case 245:case 165:case 178:case 179:case 49:case 50:case 168:case 169:case 175:case 170:case 171:case 172:case 97:case 76:case 32:case 173:case 35:return-1;case 176:case 177:case 7:case 155:case 8:case 157:case 125:case 126:case 92:case 93:case 129:case 130:case 131:case 94:case 91:return 1;case 74:case 60:case 69:case 70:case 4:return 1024;case 31:case 42:case 72:return 32;case 87:case 26:case 33:return 2147483647;case 34:case 1:return 47839;case 38:case 36:return 99;case 43:case 37:return 2048;case 0:return 2097152;case 3:return 65536;case 28:return 32768;case 44:return 32767;case 75:return 16384;case 39:return 1e3;case 89:return 700;case 71:return 256;case 40:return 255;case 2:return 100;case 180:return 64;case 25:return 20;case 5:return 16;case 6:return 6;case 73:return 4;case 84:{if(typeof navigator==="object")return navigator["hardwareConcurrency"]||1;return 1}}___setErrNo(ERRNO_CODES.EINVAL);return-1}DYNAMICTOP_PTR=staticAlloc(4);STACK_BASE=STACKTOP=alignMemory(STATICTOP);STACK_MAX=STACK_BASE+TOTAL_STACK;DYNAMIC_BASE=alignMemory(STACK_MAX);HEAP32[DYNAMICTOP_PTR>>2]=DYNAMIC_BASE;staticSealed=true;var ASSERTIONS=false;function intArrayToString(array){var ret=[];for(var i=0;i<array.length;i++){var chr=array[i];if(chr>255){if(ASSERTIONS){assert(false,"Character code "+chr+" ("+String.fromCharCode(chr)+") at offset "+i+" not in 0x00-0xFF.")}chr&=255}ret.push(String.fromCharCode(chr))}return ret.join("")}var decodeBase64=typeof atob==="function"?atob:(function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(i<input.length);return output});function intArrayFromBase64(s){if(typeof ENVIRONMENT_IS_NODE==="boolean"&&ENVIRONMENT_IS_NODE){var buf;try{buf=Buffer.from(s,"base64")}catch(_){buf=new Buffer(s,"base64")}return new Uint8Array(buf.buffer,buf.byteOffset,buf.byteLength)}try{var decoded=decodeBase64(s);var bytes=new Uint8Array(decoded.length);for(var i=0;i<decoded.length;++i){bytes[i]=decoded.charCodeAt(i)}return bytes}catch(_){throw new Error("Converting base64 string to bytes failed.")}}function tryParseAsDataURI(filename){if(!isDataURI(filename)){return}return intArrayFromBase64(filename.slice(dataURIPrefix.length))}Module.asmGlobalArg={"Math":Math,"Int8Array":Int8Array,"Int16Array":Int16Array,"Int32Array":Int32Array,"Uint8Array":Uint8Array,"Uint16Array":Uint16Array,"Uint32Array":Uint32Array,"Float32Array":Float32Array,"Float64Array":Float64Array,"NaN":NaN,"Infinity":Infinity,"byteLength":byteLength};Module.asmLibraryArg={"a":abort,"b":assert,"c":enlargeMemory,"d":getTotalMemory,"e":abortOnCannotGrowMemory,"f":___assert_fail,"g":___setErrNo,"h":_abort,"i":_emscripten_asm_const_i,"j":_emscripten_memcpy_big,"k":_sysconf,"l":DYNAMICTOP_PTR,"m":tempDoublePtr,"n":STACKTOP,"o":STACK_MAX};// EMSCRIPTEN_START_ASM | |
20569 | var asm=(/** @suppress {uselessCode} */ function(global,env,buffer) { | |
20570 | "almost asm";var a=global.Int8Array;var b=new a(buffer);var c=global.Int16Array;var d=new c(buffer);var e=global.Int32Array;var f=new e(buffer);var g=global.Uint8Array;var h=new g(buffer);var i=global.Uint16Array;var j=new i(buffer);var k=global.Uint32Array;var l=new k(buffer);var m=global.Float32Array;var n=new m(buffer);var o=global.Float64Array;var p=new o(buffer);var q=global.byteLength;var r=env.l|0;var s=env.m|0;var t=env.n|0;var u=env.o|0;var v=0;var w=0;var x=0;var y=0;var z=global.NaN,A=global.Infinity;var B=0,C=0,D=0,E=0,F=0.0;var G=0;var H=global.Math.floor;var I=global.Math.abs;var J=global.Math.sqrt;var K=global.Math.pow;var L=global.Math.cos;var M=global.Math.sin;var N=global.Math.tan;var O=global.Math.acos;var P=global.Math.asin;var Q=global.Math.atan;var R=global.Math.atan2;var S=global.Math.exp;var T=global.Math.log;var U=global.Math.ceil;var V=global.Math.imul;var W=global.Math.min;var X=global.Math.max;var Y=global.Math.clz32;var Z=env.a;var _=env.b;var $=env.c;var aa=env.d;var ba=env.e;var ca=env.f;var da=env.g;var ea=env.h;var fa=env.i;var ga=env.j;var ha=env.k;var ia=0.0;function ja(newBuffer){if(q(newBuffer)&16777215||q(newBuffer)<=16777215||q(newBuffer)>2147483648)return false;b=new a(newBuffer);d=new c(newBuffer);f=new e(newBuffer);h=new g(newBuffer);j=new i(newBuffer);l=new k(newBuffer);n=new m(newBuffer);p=new o(newBuffer);buffer=newBuffer;return true} | |
20571 | // EMSCRIPTEN_START_FUNCS | |
20572 | function ka(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0,oa=0,pa=0,qa=0;e=t;g=t=t+63&-64;t=t+256|0;c=0;do{h=tf(b+(c<<3)|0)|0;d=g+128+(c<<3)|0;f[d>>2]=h;f[d+4>>2]=G;c=c+1|0}while((c|0)!=16);c=g;b=a;d=c+64|0;do{f[c>>2]=f[b>>2];c=c+4|0;b=b+4|0}while((c|0)<(d|0));f[g+88>>2]=1595750129;f[g+88+4>>2]=-1521486534;N=f[a+64>>2]^-1377402159;M=f[a+64+4>>2]^1359893119;A=f[a+72>>2]^725511199;B=f[a+72+4>>2]^-1694144372;p=f[a+80>>2]^-79577749;q=f[a+80+4>>2]^528734635;X=f[a+88>>2]^327033209;W=f[a+88+4>>2]^1541459225;k=f[g+32>>2]|0;m=f[g+32+4>>2]|0;Y=Lg(k|0,m|0,f[g>>2]|0,f[g+4>>2]|0)|0;O=f[g+128>>2]|0;P=f[g+128+4>>2]|0;Y=Lg(Y|0,G|0,O|0,P|0)|0;Q=G;M=xf(Y^N,Q^M,32)|0;N=G;b=Lg(M|0,N|0,-205731576,1779033703)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;Q=Lg(m|0,k|0,Y|0,Q|0)|0;Y=f[g+128+8>>2]|0;Z=f[g+128+8+4>>2]|0;Q=Lg(Q|0,G|0,Y|0,Z|0)|0;ha=G;N=xf(Q^M,ha^N,16)|0;M=G;f[g+96>>2]=N;f[g+96+4>>2]=M;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;f[g+64>>2]=h;f[g+64+4>>2]=b;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;S=f[g+40>>2]|0;U=f[g+40+4>>2]|0;o=Lg(S|0,U|0,f[g+8>>2]|0,f[g+8+4>>2]|0)|0;c=f[g+128+16>>2]|0;d=f[g+128+16+4>>2]|0;o=Lg(o|0,G|0,c|0,d|0)|0;_=G;B=xf(o^A,_^B,32)|0;A=G;l=Lg(B|0,A|0,-2067093701,-1150833019)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;_=Lg(U|0,S|0,o|0,_|0)|0;o=f[g+128+24>>2]|0;r=f[g+128+24+4>>2]|0;_=Lg(_|0,G|0,o|0,r|0)|0;D=G;A=xf(_^B,D^A,16)|0;B=G;f[g+104>>2]=A;f[g+104+4>>2]=B;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;f[g+72>>2]=n;f[g+72+4>>2]=l;S=xf(n^U,l^S,63)|0;U=G;I=f[g+48>>2]|0;K=f[g+48+4>>2]|0;w=Lg(I|0,K|0,f[g+16>>2]|0,f[g+16+4>>2]|0)|0;la=f[g+128+32>>2]|0;ka=f[g+128+32+4>>2]|0;w=Lg(w|0,G|0,la|0,ka|0)|0;j=G;q=xf(w^p,j^q,32)|0;p=G;T=Lg(q|0,p|0,-23791573,1013904242)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;j=Lg(K|0,I|0,w|0,j|0)|0;w=f[g+128+40>>2]|0;v=f[g+128+40+4>>2]|0;j=Lg(j|0,G|0,w|0,v|0)|0;da=G;p=xf(j^q,da^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;x=f[g+56>>2]|0;y=f[g+56+4>>2]|0;z=Lg(x|0,y|0,f[g+24>>2]|0,f[g+24+4>>2]|0)|0;u=f[g+128+48>>2]|0;s=f[g+128+48+4>>2]|0;z=Lg(z|0,G|0,u|0,s|0)|0;ma=G;W=xf(z^X,ma^W,32)|0;X=G;J=Lg(W|0,X|0,1595750129,-1521486534)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;ma=Lg(y|0,x|0,z|0,ma|0)|0;z=f[g+128+56>>2]|0;C=f[g+128+56+4>>2]|0;ma=Lg(ma|0,G|0,z|0,C|0)|0;F=G;X=xf(ma^W,F^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;ha=Lg(S|0,U|0,Q|0,ha|0)|0;Q=f[g+128+64>>2]|0;R=f[g+128+64+4>>2]|0;ha=Lg(ha|0,G|0,Q|0,R|0)|0;pa=G;W=xf(ha^X,pa^W,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(U|0,S|0,ha|0,pa|0)|0;ha=f[g+128+72>>2]|0;ga=f[g+128+72+4>>2]|0;pa=Lg(pa|0,G|0,ha|0,ga|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;f[g+80>>2]=V;f[g+80+4>>2]=T;S=xf(V^U,T^S,63)|0;U=G;D=Lg(I|0,K|0,_|0,D|0)|0;_=f[g+128+80>>2]|0;$=f[g+128+80+4>>2]|0;D=Lg(D|0,G|0,_|0,$|0)|0;ia=G;M=xf(D^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(K|0,I|0,D|0,ia|0)|0;D=f[g+128+88>>2]|0;E=f[g+128+88+4>>2]|0;ia=Lg(ia|0,G|0,D|0,E|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;da=Lg(x|0,y|0,j|0,da|0)|0;j=f[g+128+96>>2]|0;i=f[g+128+96+4>>2]|0;da=Lg(da|0,G|0,j|0,i|0)|0;ea=G;B=xf(da^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(y|0,x|0,da|0,ea|0)|0;da=f[g+128+104>>2]|0;ca=f[g+128+104+4>>2]|0;ea=Lg(ea|0,G|0,da|0,ca|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;F=Lg(ma|0,F|0,k|0,m|0)|0;ma=f[g+128+112>>2]|0;na=f[g+128+112+4>>2]|0;F=Lg(F|0,G|0,ma|0,na|0)|0;aa=G;q=xf(F^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(m|0,k|0,F|0,aa|0)|0;F=f[g+128+120>>2]|0;H=f[g+128+120+4>>2]|0;aa=Lg(aa|0,G|0,F|0,H|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(ma|0,na|0,pa|0,oa|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,_|0,$|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,la|0,ka|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,Q|0,R|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,ha|0,ga|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(F|0,H|0,fa|0,ea|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,da|0,ca|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,u|0,s|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,Y|0,Z|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,j|0,i|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,O|0,P|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,c|0,d|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,D|0,E|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,z|0,C|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,w|0,v|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,o|0,r|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,D|0,E|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,Q|0,R|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,j|0,i|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,O|0,P|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,w|0,v|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,c|0,d|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,F|0,H|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,da|0,ca|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,_|0,$|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,ma|0,na|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,o|0,r|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,u|0,s|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,z|0,C|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,Y|0,Z|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,ha|0,ga|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,la|0,ka|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,z|0,C|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,ha|0,ga|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,o|0,r|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,Y|0,Z|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,da|0,ca|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,j|0,i|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,D|0,E|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,ma|0,na|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,c|0,d|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,u|0,s|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,w|0,v|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,_|0,$|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,la|0,ka|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,O|0,P|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,F|0,H|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,Q|0,R|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,ha|0,ga|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,O|0,P|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,w|0,v|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,z|0,C|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,c|0,d|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,la|0,ka|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,_|0,$|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,F|0,H|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,ma|0,na|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,Y|0,Z|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,D|0,E|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,j|0,i|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,u|0,s|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,Q|0,R|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,o|0,r|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,da|0,ca|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,c|0,d|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,j|0,i|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,u|0,s|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,_|0,$|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,O|0,P|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,D|0,E|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,Q|0,R|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,o|0,r|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,la|0,ka|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,da|0,ca|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,z|0,C|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,w|0,v|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,F|0,H|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,ma|0,na|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,Y|0,Z|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,ha|0,ga|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,j|0,i|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,w|0,v|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,Y|0,Z|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,F|0,H|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,ma|0,na|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,da|0,ca|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,la|0,ka|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,_|0,$|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,O|0,P|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,z|0,C|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,u|0,s|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,o|0,r|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,ha|0,ga|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,c|0,d|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,Q|0,R|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,D|0,E|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,da|0,ca|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,D|0,E|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,z|0,C|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,ma|0,na|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,j|0,i|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,Y|0,Z|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,o|0,r|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,ha|0,ga|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,w|0,v|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,O|0,P|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,F|0,H|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,la|0,ka|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,Q|0,R|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,u|0,s|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,c|0,d|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,_|0,$|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,u|0,s|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,F|0,H|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,ma|0,na|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,ha|0,ga|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,D|0,E|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,o|0,r|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,O|0,P|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,Q|0,R|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,j|0,i|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,c|0,d|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,da|0,ca|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,z|0,C|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,Y|0,Z|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,la|0,ka|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,_|0,$|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,w|0,v|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,_|0,$|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,c|0,d|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,Q|0,R|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,la|0,ka|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,z|0,C|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,u|0,s|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,Y|0,Z|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,w|0,v|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,F|0,H|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,D|0,E|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,ha|0,ga|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,ma|0,na|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,o|0,r|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,j|0,i|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,da|0,ca|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,O|0,P|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;oa=Lg(pa|0,oa|0,O|0,P|0)|0;oa=Lg(oa|0,G|0,k|0,m|0)|0;pa=G;M=xf(oa^N,pa^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;pa=Lg(oa|0,pa|0,Y|0,Z|0)|0;pa=Lg(pa|0,G|0,m|0,k|0)|0;oa=G;N=xf(pa^M,oa^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;qa=Lg(S|0,U|0,c|0,d|0)|0;ja=Lg(qa|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;ia=Lg(ja|0,ia|0,o|0,r|0)|0;ia=Lg(ia|0,G|0,U|0,S|0)|0;ja=G;A=xf(ia^B,ja^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;qa=Lg(I|0,K|0,la|0,ka|0)|0;fa=Lg(qa|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;ea=Lg(fa|0,ea|0,w|0,v|0)|0;ea=Lg(ea|0,G|0,K|0,I|0)|0;fa=G;p=xf(ea^q,fa^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;qa=Lg(x|0,y|0,u|0,s|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;aa=Lg(ba|0,aa|0,z|0,C|0)|0;aa=Lg(aa|0,G|0,y|0,x|0)|0;ba=G;X=xf(aa^W,ba^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;oa=Lg(pa|0,oa|0,Q|0,R|0)|0;oa=Lg(oa|0,G|0,S|0,U|0)|0;pa=G;W=xf(X^oa,W^pa,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;pa=Lg(oa|0,pa|0,ha|0,ga|0)|0;pa=Lg(pa|0,G|0,U|0,S|0)|0;oa=G;X=xf(pa^W,oa^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;S=xf(V^U,T^S,63)|0;U=G;ja=Lg(ia|0,ja|0,_|0,$|0)|0;ja=Lg(ja|0,G|0,I|0,K|0)|0;ia=G;M=xf(ja^N,ia^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;ia=Lg(ja|0,ia|0,D|0,E|0)|0;ia=Lg(ia|0,G|0,K|0,I|0)|0;ja=G;N=xf(ia^M,ja^N,16)|0;M=G;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;I=xf(L^K,J^I,63)|0;K=G;fa=Lg(ea|0,fa|0,j|0,i|0)|0;fa=Lg(fa|0,G|0,x|0,y|0)|0;ea=G;B=xf(fa^A,ea^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;ea=Lg(fa|0,ea|0,da|0,ca|0)|0;ea=Lg(ea|0,G|0,y|0,x|0)|0;fa=G;A=xf(ea^B,fa^A,16)|0;B=G;h=Lg(A|0,B|0,b|0,h|0)|0;b=G;x=xf(h^y,b^x,63)|0;y=G;qa=Lg(k|0,m|0,ma|0,na|0)|0;ba=Lg(qa|0,G|0,aa|0,ba|0)|0;aa=G;q=xf(ba^p,aa^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;aa=Lg(ba|0,aa|0,F|0,H|0)|0;aa=Lg(aa|0,G|0,m|0,k|0)|0;ba=G;p=xf(aa^q,ba^p,16)|0;q=G;n=Lg(p|0,q|0,l|0,n|0)|0;l=G;k=xf(n^m,l^k,63)|0;m=G;na=Lg(pa|0,oa|0,ma|0,na|0)|0;na=Lg(na|0,G|0,k|0,m|0)|0;ma=G;M=xf(na^N,ma^M,32)|0;N=G;b=Lg(M|0,N|0,h|0,b|0)|0;h=G;m=xf(b^k,h^m,24)|0;k=G;$=Lg(na|0,ma|0,_|0,$|0)|0;$=Lg($|0,G|0,m|0,k|0)|0;_=G;N=xf($^M,_^N,16)|0;M=G;h=Lg(N|0,M|0,b|0,h|0)|0;b=G;k=xf(h^m,b^k,63)|0;m=G;f[g+32>>2]=k;f[g+32+4>>2]=m;ka=Lg(S|0,U|0,la|0,ka|0)|0;ja=Lg(ka|0,G|0,ia|0,ja|0)|0;ia=G;B=xf(A^ja,B^ia,32)|0;A=G;l=Lg(B|0,A|0,n|0,l|0)|0;n=G;U=xf(l^S,n^U,24)|0;S=G;R=Lg(ja|0,ia|0,Q|0,R|0)|0;R=Lg(R|0,G|0,U|0,S|0)|0;Q=G;A=xf(R^B,Q^A,16)|0;B=G;n=Lg(A|0,B|0,l|0,n|0)|0;l=G;S=xf(n^U,l^S,63)|0;U=G;ga=Lg(I|0,K|0,ha|0,ga|0)|0;fa=Lg(ga|0,G|0,ea|0,fa|0)|0;ea=G;q=xf(p^fa,q^ea,32)|0;p=G;T=Lg(q|0,p|0,V|0,T|0)|0;V=G;K=xf(T^I,V^K,24)|0;I=G;H=Lg(fa|0,ea|0,F|0,H|0)|0;H=Lg(H|0,G|0,K|0,I|0)|0;F=G;p=xf(H^q,F^p,16)|0;q=G;V=Lg(p|0,q|0,T|0,V|0)|0;T=G;I=xf(V^K,T^I,63)|0;K=G;ca=Lg(x|0,y|0,da|0,ca|0)|0;ba=Lg(ca|0,G|0,aa|0,ba|0)|0;aa=G;W=xf(ba^X,aa^W,32)|0;X=G;J=Lg(W|0,X|0,L|0,J|0)|0;L=G;y=xf(J^x,L^y,24)|0;x=G;s=Lg(ba|0,aa|0,u|0,s|0)|0;s=Lg(s|0,G|0,y|0,x|0)|0;u=G;X=xf(s^W,u^X,16)|0;W=G;L=Lg(X|0,W|0,J|0,L|0)|0;J=G;x=xf(L^y,J^x,63)|0;y=G;Z=Lg($|0,_|0,Y|0,Z|0)|0;Z=Lg(Z|0,G|0,S|0,U|0)|0;Y=G;W=xf(X^Z,W^Y,32)|0;X=G;T=Lg(W|0,X|0,V|0,T|0)|0;V=G;U=xf(T^S,V^U,24)|0;S=G;i=Lg(Z|0,Y|0,j|0,i|0)|0;i=Lg(i|0,G|0,U|0,S|0)|0;j=G;f[g>>2]=i;f[g+4>>2]=j;X=xf(i^W,j^X,16)|0;W=G;f[g+120>>2]=X;f[g+120+4>>2]=W;V=Lg(X|0,W|0,T|0,V|0)|0;T=G;f[g+80>>2]=V;f[g+80+4>>2]=T;S=xf(V^U,T^S,63)|0;f[g+40>>2]=S;f[g+40+4>>2]=G;P=Lg(R|0,Q|0,O|0,P|0)|0;P=Lg(P|0,G|0,I|0,K|0)|0;O=G;M=xf(P^N,O^M,32)|0;N=G;J=Lg(M|0,N|0,L|0,J|0)|0;L=G;K=xf(J^I,L^K,24)|0;I=G;d=Lg(P|0,O|0,c|0,d|0)|0;d=Lg(d|0,G|0,K|0,I|0)|0;c=G;f[g+8>>2]=d;f[g+8+4>>2]=c;N=xf(d^M,c^N,16)|0;M=G;f[g+96>>2]=N;f[g+96+4>>2]=M;L=Lg(N|0,M|0,J|0,L|0)|0;J=G;f[g+88>>2]=L;f[g+88+4>>2]=J;I=xf(L^K,J^I,63)|0;f[g+48>>2]=I;f[g+48+4>>2]=G;E=Lg(H|0,F|0,D|0,E|0)|0;E=Lg(E|0,G|0,x|0,y|0)|0;D=G;B=xf(E^A,D^B,32)|0;A=G;b=Lg(B|0,A|0,h|0,b|0)|0;h=G;y=xf(b^x,h^y,24)|0;x=G;C=Lg(E|0,D|0,z|0,C|0)|0;C=Lg(C|0,G|0,y|0,x|0)|0;z=G;f[g+16>>2]=C;f[g+16+4>>2]=z;A=xf(C^B,z^A,16)|0;z=G;f[g+104>>2]=A;f[g+104+4>>2]=z;h=Lg(A|0,z|0,b|0,h|0)|0;b=G;f[g+64>>2]=h;f[g+64+4>>2]=b;x=xf(h^y,b^x,63)|0;f[g+56>>2]=x;f[g+56+4>>2]=G;v=Lg(k|0,m|0,w|0,v|0)|0;u=Lg(v|0,G|0,s|0,u|0)|0;s=G;q=xf(u^p,s^q,32)|0;p=G;l=Lg(q|0,p|0,n|0,l|0)|0;n=G;m=xf(l^k,n^m,24)|0;k=G;r=Lg(u|0,s|0,o|0,r|0)|0;r=Lg(r|0,G|0,m|0,k|0)|0;o=G;f[g+24>>2]=r;f[g+24+4>>2]=o;p=xf(r^q,o^p,16)|0;o=G;f[g+112>>2]=p;f[g+112+4>>2]=o;n=Lg(p|0,o|0,l|0,n|0)|0;l=G;f[g+72>>2]=n;f[g+72+4>>2]=l;k=xf(n^m,l^k,63)|0;f[g+32>>2]=k;f[g+32+4>>2]=G;b=j^f[a+4>>2]^b;f[a>>2]=i^f[a>>2]^h;f[a+4>>2]=b;b=1;while(1){qa=a+(b<<3)|0;pa=g+(b+8<<3)|0;c=c^f[qa+4>>2]^f[pa+4>>2];f[qa>>2]=d^f[qa>>2]^f[pa>>2];f[qa+4>>2]=c;c=b+1|0;if((c|0)==8)break;b=c;d=f[g+(c<<3)>>2]|0;c=f[g+(c<<3)+4>>2]|0}t=e;return}function la(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0,oa=0,pa=0,qa=0,ra=0,sa=0,ta=0,ua=0,va=0,wa=0,xa=0,ya=0,za=0,Aa=0,Ba=0,Ca=0,Da=0,Ea=0,Fa=0,Ga=0,Ha=0,Ia=0,Ja=0,Ka=0,La=0,Ma=0,Na=0,Oa=0,Pa=0,Qa=0,Ra=0,Sa=0,Ta=0,Ua=0,Va=0,Wa=0,Xa=0,Ya=0,Za=0,_a=0,$a=0,ab=0,bb=0,cb=0,db=0,eb=0,fb=0,gb=0,hb=0,ib=0,jb=0,kb=0,lb=0,mb=0,nb=0,ob=0,pb=0,qb=0,rb=0,sb=0,tb=0,ub=0,vb=0,wb=0,xb=0,yb=0,zb=0,Ab=0,Bb=0,Cb=0,Db=0,Eb=0,Fb=0,Gb=0,Hb=0,Ib=0,Jb=0,Kb=0,Lb=0,Mb=0,Nb=0,Ob=0,Pb=0,Qb=0,Rb=0,Sb=0,Tb=0,Ub=0,Vb=0,Wb=0,Xb=0,Yb=0,Zb=0,_b=0,$b=0,ac=0,bc=0,cc=0,dc=0,ec=0,fc=0,gc=0,hc=0,ic=0,jc=0,kc=0,lc=0,mc=0,nc=0,oc=0,pc=0,qc=0,rc=0,sc=0;X=Cf(b[c>>0]|0,b[c+1>>0]|0,b[c+2>>0]|0)|0;lb=we(c+2|0)|0;lb=$f(lb|0,G|0,5)|0;cb=Cf(b[c+5>>0]|0,b[c+6>>0]|0,b[c+7>>0]|0)|0;cb=$f(cb|0,G|0,2)|0;kb=we(c+7|0)|0;kb=$f(kb|0,G|0,7)|0;Ya=we(c+10|0)|0;Ya=$f(Ya|0,G|0,4)|0;L=Cf(b[c+13>>0]|0,b[c+14>>0]|0,b[c+15>>0]|0)|0;L=$f(L|0,G|0,1)|0;aa=we(c+15|0)|0;aa=$f(aa|0,G|0,6)|0;f=Cf(b[c+18>>0]|0,b[c+19>>0]|0,b[c+20>>0]|0)|0;f=$f(f|0,G|0,3)|0;M=Cf(b[c+21>>0]|0,b[c+22>>0]|0,b[c+23>>0]|0)|0;z=we(c+23|0)|0;z=$f(z|0,G|0,5)|0;da=Cf(b[c+26>>0]|0,b[c+27>>0]|0,b[c+28>>0]|0)|0;da=$f(da|0,G|0,2)|0;ha=we(c+28|0)|0;ha=$f(ha|0,G|0,7)|0;ia=G;wb=Cf(b[d>>0]|0,b[d+1>>0]|0,b[d+2>>0]|0)|0;_a=we(d+2|0)|0;_a=$f(_a|0,G|0,5)|0;Ja=Cf(b[d+5>>0]|0,b[d+6>>0]|0,b[d+7>>0]|0)|0;Ja=$f(Ja|0,G|0,2)|0;g=we(d+7|0)|0;g=$f(g|0,G|0,7)|0;h=we(d+10|0)|0;h=$f(h|0,G|0,4)|0;u=Cf(b[d+13>>0]|0,b[d+14>>0]|0,b[d+15>>0]|0)|0;u=$f(u|0,G|0,1)|0;Ca=we(d+15|0)|0;Ca=$f(Ca|0,G|0,6)|0;Z=Cf(b[d+18>>0]|0,b[d+19>>0]|0,b[d+20>>0]|0)|0;Z=$f(Z|0,G|0,3)|0;ra=Cf(b[d+21>>0]|0,b[d+22>>0]|0,b[d+23>>0]|0)|0;I=we(d+23|0)|0;I=$f(I|0,G|0,5)|0;rb=Cf(b[d+26>>0]|0,b[d+27>>0]|0,b[d+28>>0]|0)|0;rb=$f(rb|0,G|0,2)|0;U=we(d+28|0)|0;U=$f(U|0,G|0,7)|0;T=G;ua=Cf(b[e>>0]|0,b[e+1>>0]|0,b[e+2>>0]|0)|0;K=we(e+2|0)|0;K=$f(K|0,G|0,5)|0;wa=Cf(b[e+5>>0]|0,b[e+6>>0]|0,b[e+7>>0]|0)|0;wa=$f(wa|0,G|0,2)|0;oa=we(e+7|0)|0;oa=$f(oa|0,G|0,7)|0;qa=we(e+10|0)|0;qa=$f(qa|0,G|0,4)|0;Da=Cf(b[e+13>>0]|0,b[e+14>>0]|0,b[e+15>>0]|0)|0;Da=$f(Da|0,G|0,1)|0;fb=we(e+15|0)|0;fb=$f(fb|0,G|0,6)|0;l=Cf(b[e+18>>0]|0,b[e+19>>0]|0,b[e+20>>0]|0)|0;l=$f(l|0,G|0,3)|0;Ra=Cf(b[e+21>>0]|0,b[e+22>>0]|0,b[e+23>>0]|0)|0;za=we(e+23|0)|0;za=$f(za|0,G|0,5)|0;V=Cf(b[e+26>>0]|0,b[e+27>>0]|0,b[e+28>>0]|0)|0;V=$f(V|0,G|0,2)|0;ab=we(e+28|0)|0;ab=$f(ab|0,G|0,7)|0;gb=G;ta=Af(wb&2097151|0,0,X&2097151|0,0)|0;ta=Lg(ua&2097151|0,0,ta|0,G|0)|0;ua=G;rc=Af(_a&2097151|0,0,X&2097151|0,0)|0;qc=G;pc=Af(wb&2097151|0,0,lb&2097151|0,0)|0;Ga=G;E=Af(Ja&2097151|0,0,X&2097151|0,0)|0;va=G;D=Af(_a&2097151|0,0,lb&2097151|0,0)|0;kc=G;na=Af(wb&2097151|0,0,cb&2097151|0,0)|0;na=Lg(D|0,kc|0,na|0,G|0)|0;va=Lg(na|0,G|0,E|0,va|0)|0;wa=Lg(va|0,G|0,wa&2097151|0,0)|0;va=G;E=Af(g&2097151|0,0,X&2097151|0,0)|0;na=G;kc=Af(Ja&2097151|0,0,lb&2097151|0,0)|0;D=G;oc=Af(_a&2097151|0,0,cb&2097151|0,0)|0;nc=G;mc=Af(wb&2097151|0,0,kb&2097151|0,0)|0;lc=G;S=Af(h&2097151|0,0,X&2097151|0,0)|0;pa=G;bc=Af(g&2097151|0,0,lb&2097151|0,0)|0;Ea=G;dc=Af(Ja&2097151|0,0,cb&2097151|0,0)|0;p=G;ec=Af(_a&2097151|0,0,kb&2097151|0,0)|0;fc=G;cc=Af(wb&2097151|0,0,Ya&2097151|0,0)|0;cc=Lg(ec|0,fc|0,cc|0,G|0)|0;p=Lg(cc|0,G|0,dc|0,p|0)|0;Ea=Lg(p|0,G|0,bc|0,Ea|0)|0;pa=Lg(Ea|0,G|0,S|0,pa|0)|0;qa=Lg(pa|0,G|0,qa&2097151|0,0)|0;pa=G;S=Af(u&2097151|0,0,X&2097151|0,0)|0;Ea=G;bc=Af(h&2097151|0,0,lb&2097151|0,0)|0;p=G;dc=Af(g&2097151|0,0,cb&2097151|0,0)|0;cc=G;fc=Af(Ja&2097151|0,0,kb&2097151|0,0)|0;ec=G;jc=Af(_a&2097151|0,0,Ya&2097151|0,0)|0;ic=G;hc=Af(wb&2097151|0,0,L&2097151|0,0)|0;gc=G;c=Af(Ca&2097151|0,0,X&2097151|0,0)|0;$a=G;Qb=Af(u&2097151|0,0,lb&2097151|0,0)|0;i=G;Sb=Af(h&2097151|0,0,cb&2097151|0,0)|0;k=G;Ub=Af(g&2097151|0,0,kb&2097151|0,0)|0;Rb=G;Wb=Af(Ja&2097151|0,0,Ya&2097151|0,0)|0;Tb=G;Xb=Af(_a&2097151|0,0,L&2097151|0,0)|0;Yb=G;Vb=Af(wb&2097151|0,0,aa&2097151|0,0)|0;Vb=Lg(Xb|0,Yb|0,Vb|0,G|0)|0;Tb=Lg(Vb|0,G|0,Wb|0,Tb|0)|0;Rb=Lg(Tb|0,G|0,Ub|0,Rb|0)|0;k=Lg(Rb|0,G|0,Sb|0,k|0)|0;i=Lg(k|0,G|0,Qb|0,i|0)|0;$a=Lg(i|0,G|0,c|0,$a|0)|0;fb=Lg($a|0,G|0,fb&2097151|0,0)|0;$a=G;c=Af(Z&2097151|0,0,X&2097151|0,0)|0;i=G;Qb=Af(Ca&2097151|0,0,lb&2097151|0,0)|0;k=G;Sb=Af(u&2097151|0,0,cb&2097151|0,0)|0;Rb=G;Ub=Af(h&2097151|0,0,kb&2097151|0,0)|0;Tb=G;Wb=Af(g&2097151|0,0,Ya&2097151|0,0)|0;Vb=G;Yb=Af(Ja&2097151|0,0,L&2097151|0,0)|0;Xb=G;ac=Af(_a&2097151|0,0,aa&2097151|0,0)|0;$b=G;_b=Af(wb&2097151|0,0,f&2097151|0,0)|0;Zb=G;Bb=Af(ra&2097151|0,0,X&2097151|0,0)|0;j=G;y=Af(Z&2097151|0,0,lb&2097151|0,0)|0;Sa=G;zb=Af(Ca&2097151|0,0,cb&2097151|0,0)|0;Ab=G;Db=Af(u&2097151|0,0,kb&2097151|0,0)|0;x=G;Fb=Af(h&2097151|0,0,Ya&2097151|0,0)|0;Cb=G;Hb=Af(g&2097151|0,0,L&2097151|0,0)|0;Eb=G;Jb=Af(Ja&2097151|0,0,aa&2097151|0,0)|0;Gb=G;Kb=Af(_a&2097151|0,0,f&2097151|0,0)|0;Lb=G;Ib=Af(wb&2097151|0,0,M&2097151|0,0)|0;Ib=Lg(Kb|0,Lb|0,Ib|0,G|0)|0;Gb=Lg(Ib|0,G|0,Jb|0,Gb|0)|0;Eb=Lg(Gb|0,G|0,Hb|0,Eb|0)|0;Cb=Lg(Eb|0,G|0,Fb|0,Cb|0)|0;x=Lg(Cb|0,G|0,Db|0,x|0)|0;Ab=Lg(x|0,G|0,zb|0,Ab|0)|0;j=Lg(Ab|0,G|0,Bb|0,j|0)|0;Sa=Lg(j|0,G|0,y|0,Sa|0)|0;Ra=Lg(Sa|0,G|0,Ra&2097151|0,0)|0;Sa=G;y=Af(I&2097151|0,0,X&2097151|0,0)|0;j=G;Bb=Af(ra&2097151|0,0,lb&2097151|0,0)|0;Ab=G;zb=Af(Z&2097151|0,0,cb&2097151|0,0)|0;x=G;Db=Af(Ca&2097151|0,0,kb&2097151|0,0)|0;Cb=G;Fb=Af(u&2097151|0,0,Ya&2097151|0,0)|0;Eb=G;Hb=Af(h&2097151|0,0,L&2097151|0,0)|0;Gb=G;Jb=Af(g&2097151|0,0,aa&2097151|0,0)|0;Ib=G;Lb=Af(Ja&2097151|0,0,f&2097151|0,0)|0;Kb=G;Pb=Af(_a&2097151|0,0,M&2097151|0,0)|0;Ob=G;Nb=Af(wb&2097151|0,0,z&2097151|0,0)|0;Mb=G;Y=Af(rb&2097151|0,0,X&2097151|0,0)|0;W=G;C=Af(I&2097151|0,0,lb&2097151|0,0)|0;B=G;Oa=Af(ra&2097151|0,0,cb&2097151|0,0)|0;Na=G;ob=Af(Z&2097151|0,0,kb&2097151|0,0)|0;nb=G;N=Af(Ca&2097151|0,0,Ya&2097151|0,0)|0;n=G;eb=Af(u&2097151|0,0,L&2097151|0,0)|0;db=G;Ia=Af(h&2097151|0,0,aa&2097151|0,0)|0;Ha=G;Ua=Af(g&2097151|0,0,f&2097151|0,0)|0;Ta=G;A=Af(Ja&2097151|0,0,M&2097151|0,0)|0;e=G;yb=Af(_a&2097151|0,0,z&2097151|0,0)|0;tb=G;ub=Af(wb&2097151|0,0,da&2097151|0,0)|0;ub=Lg(yb|0,tb|0,ub|0,G|0)|0;e=Lg(ub|0,G|0,A|0,e|0)|0;Ta=Lg(e|0,G|0,Ua|0,Ta|0)|0;Ha=Lg(Ta|0,G|0,Ia|0,Ha|0)|0;db=Lg(Ha|0,G|0,eb|0,db|0)|0;n=Lg(db|0,G|0,N|0,n|0)|0;Na=Lg(n|0,G|0,Oa|0,Na|0)|0;nb=Lg(Na|0,G|0,ob|0,nb|0)|0;B=Lg(nb|0,G|0,C|0,B|0)|0;W=Lg(B|0,G|0,Y|0,W|0)|0;V=Lg(W|0,G|0,V&2097151|0,0)|0;W=G;X=Af(U|0,T|0,X&2097151|0,0)|0;Y=G;B=Af(rb&2097151|0,0,lb&2097151|0,0)|0;C=G;nb=Af(I&2097151|0,0,cb&2097151|0,0)|0;ob=G;Na=Af(ra&2097151|0,0,kb&2097151|0,0)|0;Oa=G;n=Af(Z&2097151|0,0,Ya&2097151|0,0)|0;N=G;db=Af(Ca&2097151|0,0,L&2097151|0,0)|0;eb=G;Ha=Af(u&2097151|0,0,aa&2097151|0,0)|0;Ia=G;Ta=Af(h&2097151|0,0,f&2097151|0,0)|0;Ua=G;e=Af(g&2097151|0,0,M&2097151|0,0)|0;A=G;ub=Af(Ja&2097151|0,0,z&2097151|0,0)|0;tb=G;yb=Af(_a&2097151|0,0,da&2097151|0,0)|0;xb=G;wb=Af(wb&2097151|0,0,ha|0,ia|0)|0;vb=G;lb=Af(U|0,T|0,lb&2097151|0,0)|0;mb=G;_=Af(rb&2097151|0,0,cb&2097151|0,0)|0;bb=G;pb=Af(I&2097151|0,0,kb&2097151|0,0)|0;r=G;ca=Af(ra&2097151|0,0,Ya&2097151|0,0)|0;R=G;Q=Af(Z&2097151|0,0,L&2097151|0,0)|0;qb=G;la=Af(Ca&2097151|0,0,aa&2097151|0,0)|0;t=G;ea=Af(u&2097151|0,0,f&2097151|0,0)|0;ma=G;Wa=Af(h&2097151|0,0,M&2097151|0,0)|0;ja=G;Za=Af(g&2097151|0,0,z&2097151|0,0)|0;Va=G;jb=Af(Ja&2097151|0,0,da&2097151|0,0)|0;Ka=G;_a=Af(_a&2097151|0,0,ha|0,ia|0)|0;_a=Lg(jb|0,Ka|0,_a|0,G|0)|0;Va=Lg(_a|0,G|0,Za|0,Va|0)|0;ja=Lg(Va|0,G|0,Wa|0,ja|0)|0;ma=Lg(ja|0,G|0,ea|0,ma|0)|0;t=Lg(ma|0,G|0,la|0,t|0)|0;R=Lg(t|0,G|0,ca|0,R|0)|0;qb=Lg(R|0,G|0,Q|0,qb|0)|0;r=Lg(qb|0,G|0,pb|0,r|0)|0;bb=Lg(r|0,G|0,_|0,bb|0)|0;mb=Lg(bb|0,G|0,lb|0,mb|0)|0;lb=G;cb=Af(U|0,T|0,cb&2097151|0,0)|0;bb=G;_=Af(rb&2097151|0,0,kb&2097151|0,0)|0;r=G;pb=Af(I&2097151|0,0,Ya&2097151|0,0)|0;qb=G;Q=Af(ra&2097151|0,0,L&2097151|0,0)|0;R=G;ca=Af(Z&2097151|0,0,aa&2097151|0,0)|0;t=G;la=Af(Ca&2097151|0,0,f&2097151|0,0)|0;ma=G;ea=Af(u&2097151|0,0,M&2097151|0,0)|0;ja=G;Wa=Af(h&2097151|0,0,z&2097151|0,0)|0;Va=G;Za=Af(g&2097151|0,0,da&2097151|0,0)|0;_a=G;Ja=Af(Ja&2097151|0,0,ha|0,ia|0)|0;Ka=G;kb=Af(U|0,T|0,kb&2097151|0,0)|0;jb=G;hb=Af(rb&2097151|0,0,Ya&2097151|0,0)|0;Xa=G;v=Af(I&2097151|0,0,L&2097151|0,0)|0;ib=G;Aa=Af(ra&2097151|0,0,aa&2097151|0,0)|0;F=G;o=Af(Z&2097151|0,0,f&2097151|0,0)|0;d=G;m=Af(Ca&2097151|0,0,M&2097151|0,0)|0;Fa=G;ba=Af(u&2097151|0,0,z&2097151|0,0)|0;$=G;sb=Af(h&2097151|0,0,da&2097151|0,0)|0;s=G;g=Af(g&2097151|0,0,ha|0,ia|0)|0;g=Lg(sb|0,s|0,g|0,G|0)|0;$=Lg(g|0,G|0,ba|0,$|0)|0;Fa=Lg($|0,G|0,m|0,Fa|0)|0;F=Lg(Fa|0,G|0,Aa|0,F|0)|0;d=Lg(F|0,G|0,o|0,d|0)|0;ib=Lg(d|0,G|0,v|0,ib|0)|0;Xa=Lg(ib|0,G|0,hb|0,Xa|0)|0;jb=Lg(Xa|0,G|0,kb|0,jb|0)|0;kb=G;Ya=Af(U|0,T|0,Ya&2097151|0,0)|0;Xa=G;hb=Af(rb&2097151|0,0,L&2097151|0,0)|0;ib=G;v=Af(I&2097151|0,0,aa&2097151|0,0)|0;d=G;o=Af(ra&2097151|0,0,f&2097151|0,0)|0;F=G;Aa=Af(Z&2097151|0,0,M&2097151|0,0)|0;Fa=G;m=Af(Ca&2097151|0,0,z&2097151|0,0)|0;$=G;ba=Af(u&2097151|0,0,da&2097151|0,0)|0;g=G;h=Af(h&2097151|0,0,ha|0,ia|0)|0;s=G;L=Af(U|0,T|0,L&2097151|0,0)|0;sb=G;Ma=Af(rb&2097151|0,0,aa&2097151|0,0)|0;J=G;ga=Af(I&2097151|0,0,f&2097151|0,0)|0;La=G;w=Af(ra&2097151|0,0,M&2097151|0,0)|0;O=G;P=Af(Z&2097151|0,0,z&2097151|0,0)|0;fa=G;q=Af(Ca&2097151|0,0,da&2097151|0,0)|0;Ba=G;u=Af(u&2097151|0,0,ha|0,ia|0)|0;u=Lg(q|0,Ba|0,u|0,G|0)|0;O=Lg(u|0,G|0,w|0,O|0)|0;fa=Lg(O|0,G|0,P|0,fa|0)|0;La=Lg(fa|0,G|0,ga|0,La|0)|0;J=Lg(La|0,G|0,Ma|0,J|0)|0;sb=Lg(J|0,G|0,L|0,sb|0)|0;L=G;aa=Af(U|0,T|0,aa&2097151|0,0)|0;J=G;Ma=Af(rb&2097151|0,0,f&2097151|0,0)|0;La=G;ga=Af(I&2097151|0,0,M&2097151|0,0)|0;fa=G;P=Af(ra&2097151|0,0,z&2097151|0,0)|0;O=G;w=Af(Z&2097151|0,0,da&2097151|0,0)|0;u=G;Ca=Af(Ca&2097151|0,0,ha|0,ia|0)|0;Ba=G;f=Af(U|0,T|0,f&2097151|0,0)|0;q=G;xa=Af(rb&2097151|0,0,M&2097151|0,0)|0;H=G;Qa=Af(I&2097151|0,0,z&2097151|0,0)|0;ya=G;sa=Af(ra&2097151|0,0,da&2097151|0,0)|0;Pa=G;Z=Af(Z&2097151|0,0,ha|0,ia|0)|0;Pa=Lg(Z|0,G|0,sa|0,Pa|0)|0;ya=Lg(Pa|0,G|0,Qa|0,ya|0)|0;H=Lg(ya|0,G|0,xa|0,H|0)|0;q=Lg(H|0,G|0,f|0,q|0)|0;f=G;M=Af(U|0,T|0,M&2097151|0,0)|0;H=G;xa=Af(rb&2097151|0,0,z&2097151|0,0)|0;ya=G;Qa=Af(I&2097151|0,0,da&2097151|0,0)|0;Pa=G;ra=Af(ra&2097151|0,0,ha|0,ia|0)|0;sa=G;z=Af(U|0,T|0,z&2097151|0,0)|0;Z=G;sc=Af(rb&2097151|0,0,da&2097151|0,0)|0;ka=G;I=Af(I&2097151|0,0,ha|0,ia|0)|0;I=Lg(sc|0,ka|0,I|0,G|0)|0;Z=Lg(I|0,G|0,z|0,Z|0)|0;z=G;da=Af(U|0,T|0,da&2097151|0,0)|0;I=G;rb=Af(rb&2097151|0,0,ha|0,ia|0)|0;rb=Lg(da|0,I|0,rb|0,G|0)|0;I=G;ia=Af(U|0,T|0,ha|0,ia|0)|0;ha=G;T=Lg(ta|0,ua|0,1048576,0)|0;U=G;da=$f(T|0,U|0,21)|0;ka=G;Ga=Lg(rc|0,qc|0,pc|0,Ga|0)|0;K=Lg(Ga|0,G|0,K&2097151|0,0)|0;ka=Lg(K|0,G|0,da|0,ka|0)|0;da=G;U=Ig(ta|0,ua|0,T&-2097152|0,U&4095|0)|0;T=G;ua=Lg(wa|0,va|0,1048576,0)|0;ta=G;K=$f(ua|0,ta|0,21)|0;Ga=G;lc=Lg(oc|0,nc|0,mc|0,lc|0)|0;D=Lg(lc|0,G|0,kc|0,D|0)|0;na=Lg(D|0,G|0,E|0,na|0)|0;oa=Lg(na|0,G|0,oa&2097151|0,0)|0;Ga=Lg(oa|0,G|0,K|0,Ga|0)|0;K=G;oa=Lg(qa|0,pa|0,1048576,0)|0;na=G;E=Nf(oa|0,na|0,21)|0;D=G;gc=Lg(jc|0,ic|0,hc|0,gc|0)|0;ec=Lg(gc|0,G|0,fc|0,ec|0)|0;cc=Lg(ec|0,G|0,dc|0,cc|0)|0;p=Lg(cc|0,G|0,bc|0,p|0)|0;Ea=Lg(p|0,G|0,S|0,Ea|0)|0;Da=Lg(Ea|0,G|0,Da&2097151|0,0)|0;D=Lg(Da|0,G|0,E|0,D|0)|0;E=G;Da=Lg(fb|0,$a|0,1048576,0)|0;Ea=G;S=Nf(Da|0,Ea|0,21)|0;p=G;Zb=Lg(ac|0,$b|0,_b|0,Zb|0)|0;Xb=Lg(Zb|0,G|0,Yb|0,Xb|0)|0;Vb=Lg(Xb|0,G|0,Wb|0,Vb|0)|0;Tb=Lg(Vb|0,G|0,Ub|0,Tb|0)|0;Rb=Lg(Tb|0,G|0,Sb|0,Rb|0)|0;k=Lg(Rb|0,G|0,Qb|0,k|0)|0;i=Lg(k|0,G|0,c|0,i|0)|0;l=Lg(i|0,G|0,l&2097151|0,0)|0;p=Lg(l|0,G|0,S|0,p|0)|0;S=G;l=Lg(Ra|0,Sa|0,1048576,0)|0;i=G;c=Nf(l|0,i|0,21)|0;k=G;Mb=Lg(Pb|0,Ob|0,Nb|0,Mb|0)|0;Kb=Lg(Mb|0,G|0,Lb|0,Kb|0)|0;Ib=Lg(Kb|0,G|0,Jb|0,Ib|0)|0;Gb=Lg(Ib|0,G|0,Hb|0,Gb|0)|0;Eb=Lg(Gb|0,G|0,Fb|0,Eb|0)|0;Cb=Lg(Eb|0,G|0,Db|0,Cb|0)|0;Ab=Lg(Cb|0,G|0,Bb|0,Ab|0)|0;x=Lg(Ab|0,G|0,zb|0,x|0)|0;j=Lg(x|0,G|0,y|0,j|0)|0;za=Lg(j|0,G|0,za&2097151|0,0)|0;k=Lg(za|0,G|0,c|0,k|0)|0;c=G;za=Lg(V|0,W|0,1048576,0)|0;j=G;y=Nf(za|0,j|0,21)|0;x=G;vb=Lg(yb|0,xb|0,wb|0,vb|0)|0;tb=Lg(vb|0,G|0,ub|0,tb|0)|0;A=Lg(tb|0,G|0,e|0,A|0)|0;Ua=Lg(A|0,G|0,Ta|0,Ua|0)|0;Ia=Lg(Ua|0,G|0,Ha|0,Ia|0)|0;eb=Lg(Ia|0,G|0,db|0,eb|0)|0;Oa=Lg(eb|0,G|0,Na|0,Oa|0)|0;N=Lg(Oa|0,G|0,n|0,N|0)|0;ob=Lg(N|0,G|0,nb|0,ob|0)|0;Y=Lg(ob|0,G|0,X|0,Y|0)|0;C=Lg(Y|0,G|0,B|0,C|0)|0;gb=Lg(C|0,G|0,ab|0,gb|0)|0;x=Lg(gb|0,G|0,y|0,x|0)|0;y=G;gb=Lg(mb|0,lb|0,1048576,0)|0;ab=G;C=Nf(gb|0,ab|0,21)|0;B=G;Ka=Lg(Za|0,_a|0,Ja|0,Ka|0)|0;Va=Lg(Ka|0,G|0,Wa|0,Va|0)|0;ja=Lg(Va|0,G|0,ea|0,ja|0)|0;ma=Lg(ja|0,G|0,la|0,ma|0)|0;R=Lg(ma|0,G|0,Q|0,R|0)|0;t=Lg(R|0,G|0,ca|0,t|0)|0;qb=Lg(t|0,G|0,pb|0,qb|0)|0;r=Lg(qb|0,G|0,_|0,r|0)|0;bb=Lg(r|0,G|0,cb|0,bb|0)|0;B=Lg(bb|0,G|0,C|0,B|0)|0;C=G;bb=Lg(jb|0,kb|0,1048576,0)|0;cb=G;r=Nf(bb|0,cb|0,21)|0;_=G;s=Lg(ba|0,g|0,h|0,s|0)|0;$=Lg(s|0,G|0,m|0,$|0)|0;F=Lg($|0,G|0,o|0,F|0)|0;Fa=Lg(F|0,G|0,Aa|0,Fa|0)|0;d=Lg(Fa|0,G|0,v|0,d|0)|0;ib=Lg(d|0,G|0,hb|0,ib|0)|0;Xa=Lg(ib|0,G|0,Ya|0,Xa|0)|0;_=Lg(Xa|0,G|0,r|0,_|0)|0;r=G;Xa=Lg(sb|0,L|0,1048576,0)|0;Ya=G;ib=Nf(Xa|0,Ya|0,21)|0;hb=G;Ba=Lg(P|0,O|0,Ca|0,Ba|0)|0;u=Lg(Ba|0,G|0,w|0,u|0)|0;fa=Lg(u|0,G|0,ga|0,fa|0)|0;La=Lg(fa|0,G|0,Ma|0,La|0)|0;J=Lg(La|0,G|0,aa|0,J|0)|0;hb=Lg(J|0,G|0,ib|0,hb|0)|0;ib=G;J=Lg(q|0,f|0,1048576,0)|0;aa=G;La=Nf(J|0,aa|0,21)|0;Ma=G;sa=Lg(Qa|0,Pa|0,ra|0,sa|0)|0;ya=Lg(sa|0,G|0,xa|0,ya|0)|0;H=Lg(ya|0,G|0,M|0,H|0)|0;Ma=Lg(H|0,G|0,La|0,Ma|0)|0;La=G;aa=Ig(q|0,f|0,J&-2097152|0,aa|0)|0;J=G;f=Lg(Z|0,z|0,1048576,0)|0;q=G;H=Nf(f|0,q|0,21)|0;H=Lg(rb|0,I|0,H|0,G|0)|0;I=G;q=Ig(Z|0,z|0,f&-2097152|0,q|0)|0;f=G;z=Lg(ia|0,ha|0,1048576,0)|0;Z=G;rb=Nf(z|0,Z|0,21)|0;M=G;Z=Ig(ia|0,ha|0,z&-2097152|0,Z|0)|0;z=G;ha=Lg(ka|0,da|0,1048576,0)|0;ia=G;ya=$f(ha|0,ia|0,21)|0;xa=G;ia=Ig(ka|0,da|0,ha&-2097152|0,ia|0)|0;ha=G;da=Lg(Ga|0,K|0,1048576,0)|0;ka=G;sa=Nf(da|0,ka|0,21)|0;ra=G;ka=Ig(Ga|0,K|0,da&-2097152|0,ka|0)|0;da=G;K=Lg(D|0,E|0,1048576,0)|0;Ga=G;Pa=Nf(K|0,Ga|0,21)|0;Qa=G;Ga=Ig(D|0,E|0,K&-2097152|0,Ga|0)|0;K=G;E=Lg(p|0,S|0,1048576,0)|0;D=G;fa=Nf(E|0,D|0,21)|0;ga=G;u=Lg(k|0,c|0,1048576,0)|0;w=G;Ba=Nf(u|0,w|0,21)|0;Ca=G;O=Lg(x|0,y|0,1048576,0)|0;P=G;d=Nf(O|0,P|0,21)|0;v=G;Fa=Lg(B|0,C|0,1048576,0)|0;Aa=G;F=Nf(Fa|0,Aa|0,21)|0;o=G;$=Lg(_|0,r|0,1048576,0)|0;m=G;s=Nf($|0,m|0,21)|0;h=G;g=Lg(hb|0,ib|0,1048576,0)|0;ba=G;qb=Nf(g|0,ba|0,21)|0;J=Lg(qb|0,G|0,aa|0,J|0)|0;aa=G;ba=Ig(hb|0,ib|0,g&-2097152|0,ba|0)|0;g=G;ib=Lg(Ma|0,La|0,1048576,0)|0;hb=G;qb=Nf(ib|0,hb|0,21)|0;f=Lg(qb|0,G|0,q|0,f|0)|0;q=G;hb=Ig(Ma|0,La|0,ib&-2097152|0,hb|0)|0;ib=G;La=Lg(H|0,I|0,1048576,0)|0;Ma=G;qb=Nf(La|0,Ma|0,21)|0;z=Lg(qb|0,G|0,Z|0,z|0)|0;Z=G;Ma=Ig(H|0,I|0,La&-2097152|0,Ma|0)|0;La=G;I=Af(rb|0,M|0,666643,0)|0;H=G;qb=Af(rb|0,M|0,470296,0)|0;pb=G;t=Af(rb|0,M|0,654183,0)|0;ca=G;R=Af(rb|0,M|0,-997805,-1)|0;Q=G;ma=Af(rb|0,M|0,136657,0)|0;la=G;M=Af(rb|0,M|0,-683901,-1)|0;M=Lg(sb|0,L|0,M|0,G|0)|0;Ya=Ig(M|0,G|0,Xa&-2097152|0,Ya|0)|0;h=Lg(Ya|0,G|0,s|0,h|0)|0;s=G;Ya=Af(z|0,Z|0,666643,0)|0;Xa=G;M=Af(z|0,Z|0,470296,0)|0;L=G;sb=Af(z|0,Z|0,654183,0)|0;rb=G;ja=Af(z|0,Z|0,-997805,-1)|0;ea=G;Va=Af(z|0,Z|0,136657,0)|0;Wa=G;Z=Af(z|0,Z|0,-683901,-1)|0;z=G;Ka=Af(Ma|0,La|0,666643,0)|0;Ja=G;_a=Af(Ma|0,La|0,470296,0)|0;Za=G;Y=Af(Ma|0,La|0,654183,0)|0;X=G;ob=Af(Ma|0,La|0,-997805,-1)|0;nb=G;N=Af(Ma|0,La|0,136657,0)|0;n=G;La=Af(Ma|0,La|0,-683901,-1)|0;Ma=G;Q=Lg(jb|0,kb|0,R|0,Q|0)|0;Wa=Lg(Q|0,G|0,Va|0,Wa|0)|0;Ma=Lg(Wa|0,G|0,La|0,Ma|0)|0;cb=Ig(Ma|0,G|0,bb&-2097152|0,cb|0)|0;o=Lg(cb|0,G|0,F|0,o|0)|0;F=G;cb=Af(f|0,q|0,666643,0)|0;bb=G;Ma=Af(f|0,q|0,470296,0)|0;La=G;Wa=Af(f|0,q|0,654183,0)|0;Va=G;Q=Af(f|0,q|0,-997805,-1)|0;R=G;kb=Af(f|0,q|0,136657,0)|0;jb=G;q=Af(f|0,q|0,-683901,-1)|0;f=G;Oa=Af(hb|0,ib|0,666643,0)|0;Na=G;eb=Af(hb|0,ib|0,470296,0)|0;db=G;Ia=Af(hb|0,ib|0,654183,0)|0;Ha=G;Ua=Af(hb|0,ib|0,-997805,-1)|0;Ta=G;A=Af(hb|0,ib|0,136657,0)|0;e=G;ib=Af(hb|0,ib|0,-683901,-1)|0;hb=G;pb=Lg(sb|0,rb|0,qb|0,pb|0)|0;nb=Lg(pb|0,G|0,ob|0,nb|0)|0;lb=Lg(nb|0,G|0,mb|0,lb|0)|0;jb=Lg(lb|0,G|0,kb|0,jb|0)|0;hb=Lg(jb|0,G|0,ib|0,hb|0)|0;ab=Ig(hb|0,G|0,gb&-2097152|0,ab|0)|0;v=Lg(ab|0,G|0,d|0,v|0)|0;d=G;ab=Af(J|0,aa|0,666643,0)|0;ab=Lg(fb|0,$a|0,ab|0,G|0)|0;Qa=Lg(ab|0,G|0,Pa|0,Qa|0)|0;Ea=Ig(Qa|0,G|0,Da&-2097152|0,Ea|0)|0;Da=G;Qa=Af(J|0,aa|0,470296,0)|0;Pa=G;ab=Af(J|0,aa|0,654183,0)|0;$a=G;bb=Lg(eb|0,db|0,cb|0,bb|0)|0;$a=Lg(bb|0,G|0,ab|0,$a|0)|0;Sa=Lg($a|0,G|0,Ra|0,Sa|0)|0;i=Ig(Sa|0,G|0,l&-2097152|0,i|0)|0;ga=Lg(i|0,G|0,fa|0,ga|0)|0;fa=G;i=Af(J|0,aa|0,-997805,-1)|0;l=G;Sa=Af(J|0,aa|0,136657,0)|0;Ra=G;Xa=Lg(_a|0,Za|0,Ya|0,Xa|0)|0;Va=Lg(Xa|0,G|0,Wa|0,Va|0)|0;Ta=Lg(Va|0,G|0,Ua|0,Ta|0)|0;Ra=Lg(Ta|0,G|0,Sa|0,Ra|0)|0;W=Lg(Ra|0,G|0,V|0,W|0)|0;Ca=Lg(W|0,G|0,Ba|0,Ca|0)|0;j=Ig(Ca|0,G|0,za&-2097152|0,j|0)|0;za=G;aa=Af(J|0,aa|0,-683901,-1)|0;J=G;Ca=Lg(Ea|0,Da|0,1048576,0)|0;Ba=G;W=Nf(Ca|0,Ba|0,21)|0;V=G;Na=Lg(Qa|0,Pa|0,Oa|0,Na|0)|0;S=Lg(Na|0,G|0,p|0,S|0)|0;D=Ig(S|0,G|0,E&-2097152|0,D|0)|0;V=Lg(D|0,G|0,W|0,V|0)|0;W=G;D=Lg(ga|0,fa|0,1048576,0)|0;E=G;S=Nf(D|0,E|0,21)|0;p=G;Ja=Lg(Ma|0,La|0,Ka|0,Ja|0)|0;Ha=Lg(Ja|0,G|0,Ia|0,Ha|0)|0;l=Lg(Ha|0,G|0,i|0,l|0)|0;c=Lg(l|0,G|0,k|0,c|0)|0;w=Ig(c|0,G|0,u&-2097152|0,w|0)|0;p=Lg(w|0,G|0,S|0,p|0)|0;S=G;w=Lg(j|0,za|0,1048576,0)|0;u=G;c=Nf(w|0,u|0,21)|0;k=G;H=Lg(M|0,L|0,I|0,H|0)|0;X=Lg(H|0,G|0,Y|0,X|0)|0;R=Lg(X|0,G|0,Q|0,R|0)|0;e=Lg(R|0,G|0,A|0,e|0)|0;J=Lg(e|0,G|0,aa|0,J|0)|0;y=Lg(J|0,G|0,x|0,y|0)|0;P=Ig(y|0,G|0,O&-2097152|0,P|0)|0;k=Lg(P|0,G|0,c|0,k|0)|0;c=G;P=Lg(v|0,d|0,1048576,0)|0;O=G;y=Nf(P|0,O|0,21)|0;x=G;ca=Lg(ja|0,ea|0,t|0,ca|0)|0;n=Lg(ca|0,G|0,N|0,n|0)|0;f=Lg(n|0,G|0,q|0,f|0)|0;C=Lg(f|0,G|0,B|0,C|0)|0;Aa=Ig(C|0,G|0,Fa&-2097152|0,Aa|0)|0;x=Lg(Aa|0,G|0,y|0,x|0)|0;y=G;O=Ig(v|0,d|0,P&-2097152|0,O|0)|0;P=G;d=Lg(o|0,F|0,1048576,0)|0;v=G;Aa=Nf(d|0,v|0,21)|0;Fa=G;la=Lg(Z|0,z|0,ma|0,la|0)|0;r=Lg(la|0,G|0,_|0,r|0)|0;m=Ig(r|0,G|0,$&-2097152|0,m|0)|0;Fa=Lg(m|0,G|0,Aa|0,Fa|0)|0;Aa=G;v=Ig(o|0,F|0,d&-2097152|0,v|0)|0;d=G;F=Lg(h|0,s|0,1048576,0)|0;o=G;m=Nf(F|0,o|0,21)|0;g=Lg(m|0,G|0,ba|0,g|0)|0;ba=G;o=Ig(h|0,s|0,F&-2097152|0,o|0)|0;F=G;s=Lg(V|0,W|0,1048576,0)|0;h=G;m=Nf(s|0,h|0,21)|0;$=G;r=Lg(p|0,S|0,1048576,0)|0;_=G;la=Nf(r|0,_|0,21)|0;ma=G;z=Lg(k|0,c|0,1048576,0)|0;Z=G;C=Nf(z|0,Z|0,21)|0;P=Lg(C|0,G|0,O|0,P|0)|0;O=G;Z=Ig(k|0,c|0,z&-2097152|0,Z|0)|0;z=G;c=Lg(x|0,y|0,1048576,0)|0;k=G;C=Nf(c|0,k|0,21)|0;d=Lg(C|0,G|0,v|0,d|0)|0;v=G;k=Ig(x|0,y|0,c&-2097152|0,k|0)|0;c=G;y=Lg(Fa|0,Aa|0,1048576,0)|0;x=G;C=Nf(y|0,x|0,21)|0;F=Lg(C|0,G|0,o|0,F|0)|0;o=G;x=Ig(Fa|0,Aa|0,y&-2097152|0,x|0)|0;y=G;Aa=Af(g|0,ba|0,666643,0)|0;Aa=Lg(Ga|0,K|0,Aa|0,G|0)|0;K=G;Ga=Af(g|0,ba|0,470296,0)|0;Fa=G;C=Af(g|0,ba|0,654183,0)|0;B=G;f=Af(g|0,ba|0,-997805,-1)|0;q=G;n=Af(g|0,ba|0,136657,0)|0;N=G;ba=Af(g|0,ba|0,-683901,-1)|0;ba=Lg(j|0,za|0,ba|0,G|0)|0;ma=Lg(ba|0,G|0,la|0,ma|0)|0;u=Ig(ma|0,G|0,w&-2097152|0,u|0)|0;w=G;ma=Af(F|0,o|0,666643,0)|0;la=G;ba=Af(F|0,o|0,470296,0)|0;ba=Lg(Aa|0,K|0,ba|0,G|0)|0;K=G;Aa=Af(F|0,o|0,654183,0)|0;za=G;j=Af(F|0,o|0,-997805,-1)|0;g=G;ca=Af(F|0,o|0,136657,0)|0;t=G;o=Af(F|0,o|0,-683901,-1)|0;F=G;ea=Af(x|0,y|0,666643,0)|0;ea=Lg(ka|0,da|0,ea|0,G|0)|0;da=G;ka=Af(x|0,y|0,470296,0)|0;ja=G;J=Af(x|0,y|0,654183,0)|0;J=Lg(ba|0,K|0,J|0,G|0)|0;K=G;ba=Af(x|0,y|0,-997805,-1)|0;aa=G;e=Af(x|0,y|0,136657,0)|0;A=G;y=Af(x|0,y|0,-683901,-1)|0;x=G;q=Lg(ga|0,fa|0,f|0,q|0)|0;$=Lg(q|0,G|0,m|0,$|0)|0;E=Ig($|0,G|0,D&-2097152|0,E|0)|0;t=Lg(E|0,G|0,ca|0,t|0)|0;x=Lg(t|0,G|0,y|0,x|0)|0;y=G;t=Af(d|0,v|0,666643,0)|0;ca=G;E=Af(d|0,v|0,470296,0)|0;D=G;$=Af(d|0,v|0,654183,0)|0;m=G;q=Af(d|0,v|0,-997805,-1)|0;f=G;fa=Af(d|0,v|0,136657,0)|0;ga=G;v=Af(d|0,v|0,-683901,-1)|0;d=G;R=Af(k|0,c|0,666643,0)|0;Q=G;X=Af(k|0,c|0,470296,0)|0;Y=G;H=Af(k|0,c|0,654183,0)|0;I=G;L=Af(k|0,c|0,-997805,-1)|0;M=G;l=Af(k|0,c|0,136657,0)|0;i=G;c=Af(k|0,c|0,-683901,-1)|0;k=G;Da=Lg(Ga|0,Fa|0,Ea|0,Da|0)|0;Ba=Ig(Da|0,G|0,Ca&-2097152|0,Ba|0)|0;za=Lg(Ba|0,G|0,Aa|0,za|0)|0;aa=Lg(za|0,G|0,ba|0,aa|0)|0;ga=Lg(aa|0,G|0,fa|0,ga|0)|0;k=Lg(ga|0,G|0,c|0,k|0)|0;c=G;ga=Af(P|0,O|0,666643,0)|0;T=Lg(ga|0,G|0,U|0,T|0)|0;U=G;ga=Af(P|0,O|0,470296,0)|0;fa=G;aa=Af(P|0,O|0,654183,0)|0;ba=G;va=Lg(ya|0,xa|0,wa|0,va|0)|0;ta=Ig(va|0,G|0,ua&-2097152|0,ta|0)|0;ba=Lg(ta|0,G|0,aa|0,ba|0)|0;ca=Lg(ba|0,G|0,t|0,ca|0)|0;Y=Lg(ca|0,G|0,X|0,Y|0)|0;X=G;ca=Af(P|0,O|0,-997805,-1)|0;t=G;ba=Af(P|0,O|0,136657,0)|0;aa=G;pa=Lg(sa|0,ra|0,qa|0,pa|0)|0;na=Ig(pa|0,G|0,oa&-2097152|0,na|0)|0;la=Lg(na|0,G|0,ma|0,la|0)|0;ja=Lg(la|0,G|0,ka|0,ja|0)|0;aa=Lg(ja|0,G|0,ba|0,aa|0)|0;m=Lg(aa|0,G|0,$|0,m|0)|0;M=Lg(m|0,G|0,L|0,M|0)|0;L=G;O=Af(P|0,O|0,-683901,-1)|0;P=G;m=Lg(T|0,U|0,1048576,0)|0;$=G;aa=Nf(m|0,$|0,21)|0;ba=G;fa=Lg(ia|0,ha|0,ga|0,fa|0)|0;Q=Lg(fa|0,G|0,R|0,Q|0)|0;ba=Lg(Q|0,G|0,aa|0,ba|0)|0;aa=G;$=Ig(T|0,U|0,m&-2097152|0,$|0)|0;m=G;U=Lg(Y|0,X|0,1048576,0)|0;T=G;Q=Nf(U|0,T|0,21)|0;R=G;t=Lg(ea|0,da|0,ca|0,t|0)|0;D=Lg(t|0,G|0,E|0,D|0)|0;I=Lg(D|0,G|0,H|0,I|0)|0;R=Lg(I|0,G|0,Q|0,R|0)|0;Q=G;I=Lg(M|0,L|0,1048576,0)|0;H=G;D=Nf(I|0,H|0,21)|0;E=G;P=Lg(J|0,K|0,O|0,P|0)|0;f=Lg(P|0,G|0,q|0,f|0)|0;i=Lg(f|0,G|0,l|0,i|0)|0;E=Lg(i|0,G|0,D|0,E|0)|0;D=G;i=Lg(k|0,c|0,1048576,0)|0;l=G;f=Nf(i|0,l|0,21)|0;q=G;B=Lg(V|0,W|0,C|0,B|0)|0;h=Ig(B|0,G|0,s&-2097152|0,h|0)|0;g=Lg(h|0,G|0,j|0,g|0)|0;A=Lg(g|0,G|0,e|0,A|0)|0;d=Lg(A|0,G|0,v|0,d|0)|0;q=Lg(d|0,G|0,f|0,q|0)|0;f=G;l=Ig(k|0,c|0,i&-2097152|0,l|0)|0;i=G;c=Lg(x|0,y|0,1048576,0)|0;k=G;d=Nf(c|0,k|0,21)|0;v=G;N=Lg(o|0,F|0,n|0,N|0)|0;S=Lg(N|0,G|0,p|0,S|0)|0;_=Ig(S|0,G|0,r&-2097152|0,_|0)|0;v=Lg(_|0,G|0,d|0,v|0)|0;d=G;k=Ig(x|0,y|0,c&-2097152|0,k|0)|0;c=G;y=Lg(u|0,w|0,1048576,0)|0;x=G;_=Nf(y|0,x|0,21)|0;_=Lg(Z|0,z|0,_|0,G|0)|0;z=G;Z=Lg(ba|0,aa|0,1048576,0)|0;r=G;S=Nf(Z|0,r|0,21)|0;p=G;N=Lg(R|0,Q|0,1048576,0)|0;n=G;F=Nf(N|0,n|0,21)|0;o=G;A=Lg(E|0,D|0,1048576,0)|0;e=G;g=Nf(A|0,e|0,21)|0;g=Lg(l|0,i|0,g|0,G|0)|0;i=G;l=Lg(q|0,f|0,1048576,0)|0;j=G;h=Nf(l|0,j|0,21)|0;h=Lg(k|0,c|0,h|0,G|0)|0;c=G;j=Ig(q|0,f|0,l&-2097152|0,j|0)|0;l=G;f=Lg(v|0,d|0,1048576,0)|0;q=G;k=Nf(f|0,q|0,21)|0;s=G;q=Ig(v|0,d|0,f&-2097152|0,q|0)|0;f=G;d=Lg(_|0,z|0,1048576,0)|0;v=G;B=Nf(d|0,v|0,21)|0;C=G;v=Ig(_|0,z|0,d&-2097152|0,v|0)|0;d=G;z=Af(B|0,C|0,666643,0)|0;z=Lg($|0,m|0,z|0,G|0)|0;m=G;$=Af(B|0,C|0,470296,0)|0;_=G;W=Af(B|0,C|0,654183,0)|0;V=G;P=Af(B|0,C|0,-997805,-1)|0;O=G;K=Af(B|0,C|0,136657,0)|0;J=G;C=Af(B|0,C|0,-683901,-1)|0;B=G;m=Nf(z|0,m|0,21)|0;t=G;_=Lg(ba|0,aa|0,$|0,_|0)|0;r=Ig(_|0,G|0,Z&-2097152|0,r|0)|0;t=Lg(r|0,G|0,m|0,t|0)|0;m=Nf(t|0,G|0,21)|0;r=G;V=Lg(Y|0,X|0,W|0,V|0)|0;T=Ig(V|0,G|0,U&-2097152|0,T|0)|0;p=Lg(T|0,G|0,S|0,p|0)|0;r=Lg(p|0,G|0,m|0,r|0)|0;m=Nf(r|0,G|0,21)|0;p=G;O=Lg(R|0,Q|0,P|0,O|0)|0;n=Ig(O|0,G|0,N&-2097152|0,n|0)|0;p=Lg(n|0,G|0,m|0,p|0)|0;m=Nf(p|0,G|0,21)|0;n=G;J=Lg(M|0,L|0,K|0,J|0)|0;H=Ig(J|0,G|0,I&-2097152|0,H|0)|0;o=Lg(H|0,G|0,F|0,o|0)|0;n=Lg(o|0,G|0,m|0,n|0)|0;m=Nf(n|0,G|0,21)|0;o=G;B=Lg(E|0,D|0,C|0,B|0)|0;e=Ig(B|0,G|0,A&-2097152|0,e|0)|0;o=Lg(e|0,G|0,m|0,o|0)|0;m=Nf(o|0,G|0,21)|0;m=Lg(g|0,i|0,m|0,G|0)|0;i=Nf(m|0,G|0,21)|0;l=Lg(i|0,G|0,j|0,l|0)|0;j=Nf(l|0,G|0,21)|0;j=Lg(h|0,c|0,j|0,G|0)|0;c=Nf(j|0,G|0,21)|0;f=Lg(c|0,G|0,q|0,f|0)|0;q=Nf(f|0,G|0,21)|0;c=G;w=Lg(k|0,s|0,u|0,w|0)|0;x=Ig(w|0,G|0,y&-2097152|0,x|0)|0;c=Lg(x|0,G|0,q|0,c|0)|0;q=Nf(c|0,G|0,21)|0;d=Lg(q|0,G|0,v|0,d|0)|0;v=Nf(d|0,G|0,21)|0;q=G;x=Af(v|0,q|0,666643,0)|0;z=Lg(x|0,G|0,z&2097151|0,0)|0;x=G;y=Af(v|0,q|0,470296,0)|0;t=Lg(y|0,G|0,t&2097151|0,0)|0;y=G;w=Af(v|0,q|0,654183,0)|0;r=Lg(w|0,G|0,r&2097151|0,0)|0;w=G;u=Af(v|0,q|0,-997805,-1)|0;p=Lg(u|0,G|0,p&2097151|0,0)|0;u=G;s=Af(v|0,q|0,136657,0)|0;n=Lg(s|0,G|0,n&2097151|0,0)|0;s=G;q=Af(v|0,q|0,-683901,-1)|0;o=Lg(q|0,G|0,o&2097151|0,0)|0;q=G;v=Nf(z|0,x|0,21)|0;v=Lg(t|0,y|0,v|0,G|0)|0;y=G;t=Nf(v|0,y|0,21)|0;t=Lg(r|0,w|0,t|0,G|0)|0;w=G;r=Nf(t|0,w|0,21)|0;r=Lg(p|0,u|0,r|0,G|0)|0;u=G;p=Nf(r|0,u|0,21)|0;p=Lg(n|0,s|0,p|0,G|0)|0;s=G;n=Nf(p|0,s|0,21)|0;n=Lg(o|0,q|0,n|0,G|0)|0;q=G;o=Nf(n|0,q|0,21)|0;m=Lg(o|0,G|0,m&2097151|0,0)|0;o=G;k=Nf(m|0,o|0,21)|0;l=Lg(k|0,G|0,l&2097151|0,0)|0;k=G;h=Nf(l|0,k|0,21)|0;j=Lg(h|0,G|0,j&2097151|0,0)|0;h=G;i=Nf(j|0,h|0,21)|0;f=Lg(i|0,G|0,f&2097151|0,0)|0;i=G;g=Nf(f|0,i|0,21)|0;c=Lg(g|0,G|0,c&2097151|0,0)|0;g=G;e=Nf(c|0,g|0,21)|0;d=Lg(e|0,G|0,d&2097151|0,0)|0;e=G;b[a>>0]=z;A=$f(z|0,x|0,8)|0;b[a+1>>0]=A;x=$f(z|0,x|0,16)|0;z=Wf(v&2097151|0,0,5)|0;b[a+2>>0]=z|x&31;x=$f(v|0,y|0,3)|0;b[a+3>>0]=x;y=$f(v|0,y|0,11)|0;b[a+4>>0]=y;v=$f(v&2097151|0,0,19)|0;y=G;x=Wf(t&2097151|0,0,2)|0;b[a+5>>0]=x|v;w=$f(t|0,w|0,6)|0;b[a+6>>0]=w;t=$f(t&2097151|0,0,14)|0;w=G;v=Wf(r&2097151|0,0,7)|0;b[a+7>>0]=v|t;t=$f(r|0,u|0,1)|0;b[a+8>>0]=t;u=$f(r|0,u|0,9)|0;b[a+9>>0]=u;r=$f(r&2097151|0,0,17)|0;u=G;t=Wf(p&2097151|0,0,4)|0;b[a+10>>0]=t|r;r=$f(p|0,s|0,4)|0;b[a+11>>0]=r;s=$f(p|0,s|0,12)|0;b[a+12>>0]=s;p=$f(p&2097151|0,0,20)|0;s=G;r=Wf(n&2097151|0,0,1)|0;b[a+13>>0]=r|p;q=$f(n|0,q|0,7)|0;b[a+14>>0]=q;n=$f(n&2097151|0,0,15)|0;q=G;p=Wf(m&2097151|0,0,6)|0;b[a+15>>0]=p|n;n=$f(m|0,o|0,2)|0;b[a+16>>0]=n;o=$f(m|0,o|0,10)|0;b[a+17>>0]=o;m=$f(m&2097151|0,0,18)|0;o=G;n=Wf(l|0,k|0,3)|0;b[a+18>>0]=n|m;m=$f(l|0,k|0,5)|0;b[a+19>>0]=m;k=$f(l|0,k|0,13)|0;b[a+20>>0]=k;b[a+21>>0]=j;k=$f(j|0,h|0,8)|0;b[a+22>>0]=k;h=$f(j|0,h|0,16)|0;j=Wf(f&2097151|0,0,5)|0;b[a+23>>0]=j|h&31;h=$f(f|0,i|0,3)|0;b[a+24>>0]=h;i=$f(f|0,i|0,11)|0;b[a+25>>0]=i;f=$f(f&2097151|0,0,19)|0;i=G;h=Wf(c&2097151|0,0,2)|0;b[a+26>>0]=h|f;g=$f(c|0,g|0,6)|0;b[a+27>>0]=g;c=$f(c&2097151|0,0,14)|0;g=G;f=Wf(d|0,e|0,7)|0;b[a+28>>0]=f|c;c=$f(d|0,e|0,1)|0;b[a+29>>0]=c;c=$f(d|0,e|0,9)|0;b[a+30>>0]=c;e=Nf(d|0,e|0,17)|0;b[a+31>>0]=e;return}function ma(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0;ef(c,b);b=d;e=a;g=b+64|0;do{f[b>>2]=f[e>>2];b=b+4|0;e=e+4|0}while((b|0)<(g|0));s=0;b=f[c>>2]|0;e=f[c+4>>2]|0;do{x=f[d+32>>2]|0;k=f[d+32+4>>2]|0;r=xf(x,k,14)|0;o=G;g=xf(x,k,18)|0;o=G^o;P=xf(x,k,41)|0;J=f[d+40>>2]|0;j=f[d+40+4>>2]|0;t=f[d+48>>2]|0;i=f[d+48+4>>2]|0;L=32816+(s<<3)|0;l=f[L>>2]|0;L=f[L+4>>2]|0;p=f[d+56>>2]|0;u=f[d+56+4>>2]|0;o=Lg(b|0,e|0,g^r^P|0,o^G|0)|0;L=Lg(o|0,G|0,l|0,L|0)|0;L=Lg(L|0,G|0,(t^J)&x^t|0,(i^j)&k^i|0)|0;u=Lg(L|0,G|0,p|0,u|0)|0;p=G;L=Lg(u|0,p|0,f[d+24>>2]|0,f[d+24+4>>2]|0)|0;l=G;f[d+24>>2]=L;f[d+24+4>>2]=l;o=f[d>>2]|0;P=f[d+4>>2]|0;r=xf(o,P,28)|0;g=G;B=xf(o,P,34)|0;g=G^g;H=xf(o,P,39)|0;n=f[d+8>>2]|0;O=f[d+8+4>>2]|0;m=f[d+16>>2]|0;N=f[d+16+4>>2]|0;p=Lg(B^r^H|0,g^G|0,u|0,p|0)|0;p=Lg(p|0,G|0,(m|n)&o|m&n|0,(N|O)&P|N&O|0)|0;u=G;f[d+56>>2]=p;f[d+56+4>>2]=u;g=xf(L,l,14)|0;H=G;r=xf(L,l,18)|0;H=G^H;B=xf(L,l,41)|0;H=H^G;e=s|1;q=f[c+(e<<3)>>2]|0;h=f[c+(e<<3)+4>>2]|0;b=f[32816+(e<<3)>>2]|0;C=f[32816+(e<<3)+4>>2]|0;i=Lg(L&(J^x)^J|0,l&(j^k)^j|0,t|0,i|0)|0;H=Lg(i|0,G|0,r^g^B|0,H|0)|0;h=Lg(H|0,G|0,q|0,h|0)|0;C=Lg(h|0,G|0,b|0,C|0)|0;b=G;N=Lg(C|0,b|0,m|0,N|0)|0;m=G;f[d+16>>2]=N;f[d+16+4>>2]=m;h=xf(p,u,28)|0;q=G;H=xf(p,u,34)|0;q=G^q;B=xf(p,u,39)|0;q=q^G;b=Lg(C|0,b|0,p&(n|o)|n&o|0,u&(O|P)|O&P|0)|0;q=Lg(b|0,G|0,H^h^B|0,q|0)|0;B=G;f[d+48>>2]=q;f[d+48+4>>2]=B;h=xf(N,m,14)|0;H=G;b=xf(N,m,18)|0;H=G^H;C=xf(N,m,41)|0;H=H^G;g=s|2;r=f[c+(g<<3)>>2]|0;i=f[c+(g<<3)+4>>2]|0;t=f[32816+(g<<3)>>2]|0;D=f[32816+(g<<3)+4>>2]|0;j=Lg(N&(L^x)^x|0,m&(l^k)^k|0,J|0,j|0)|0;H=Lg(j|0,G|0,b^h^C|0,H|0)|0;i=Lg(H|0,G|0,r|0,i|0)|0;D=Lg(i|0,G|0,t|0,D|0)|0;t=G;O=Lg(D|0,t|0,n|0,O|0)|0;n=G;f[d+8>>2]=O;f[d+8+4>>2]=n;i=xf(q,B,28)|0;r=G;H=xf(q,B,34)|0;r=G^r;C=xf(q,B,39)|0;r=r^G;t=Lg(D|0,t|0,q&(p|o)|p&o|0,B&(u|P)|u&P|0)|0;r=Lg(t|0,G|0,H^i^C|0,r|0)|0;C=G;f[d+40>>2]=r;f[d+40+4>>2]=C;i=xf(O,n,14)|0;H=G;t=xf(O,n,18)|0;H=G^H;D=xf(O,n,41)|0;H=H^G;h=s|3;b=f[c+(h<<3)>>2]|0;j=f[c+(h<<3)+4>>2]|0;J=f[32816+(h<<3)>>2]|0;v=f[32816+(h<<3)+4>>2]|0;k=Lg(O&(N^L)^L|0,n&(m^l)^l|0,x|0,k|0)|0;H=Lg(k|0,G|0,t^i^D|0,H|0)|0;j=Lg(H|0,G|0,b|0,j|0)|0;v=Lg(j|0,G|0,J|0,v|0)|0;J=G;P=Lg(v|0,J|0,o|0,P|0)|0;o=G;f[d>>2]=P;f[d+4>>2]=o;j=xf(r,C,28)|0;b=G;H=xf(r,C,34)|0;b=G^b;D=xf(r,C,39)|0;b=b^G;J=Lg(v|0,J|0,r&(q|p)|q&p|0,C&(B|u)|B&u|0)|0;b=Lg(J|0,G|0,H^j^D|0,b|0)|0;D=G;f[d+32>>2]=b;f[d+32+4>>2]=D;j=xf(P,o,14)|0;H=G;J=xf(P,o,18)|0;H=G^H;v=xf(P,o,41)|0;H=H^G;i=s|4;t=f[c+(i<<3)>>2]|0;k=f[c+(i<<3)+4>>2]|0;x=f[32816+(i<<3)>>2]|0;K=f[32816+(i<<3)+4>>2]|0;l=Lg(P&(O^N)^N|0,o&(n^m)^m|0,L|0,l|0)|0;H=Lg(l|0,G|0,J^j^v|0,H|0)|0;k=Lg(H|0,G|0,t|0,k|0)|0;K=Lg(k|0,G|0,x|0,K|0)|0;x=G;u=Lg(K|0,x|0,p|0,u|0)|0;p=G;f[d+56>>2]=u;f[d+56+4>>2]=p;k=xf(b,D,28)|0;t=G;H=xf(b,D,34)|0;t=G^t;v=xf(b,D,39)|0;t=t^G;x=Lg(K|0,x|0,b&(r|q)|r&q|0,D&(C|B)|C&B|0)|0;t=Lg(x|0,G|0,H^k^v|0,t|0)|0;v=G;f[d+24>>2]=t;f[d+24+4>>2]=v;k=xf(u,p,14)|0;H=G;x=xf(u,p,18)|0;H=G^H;K=xf(u,p,41)|0;H=H^G;j=s|5;J=f[c+(j<<3)>>2]|0;l=f[c+(j<<3)+4>>2]|0;L=f[32816+(j<<3)>>2]|0;E=f[32816+(j<<3)+4>>2]|0;m=Lg(u&(P^O)^O|0,p&(o^n)^n|0,N|0,m|0)|0;H=Lg(m|0,G|0,x^k^K|0,H|0)|0;l=Lg(H|0,G|0,J|0,l|0)|0;E=Lg(l|0,G|0,L|0,E|0)|0;L=G;B=Lg(E|0,L|0,q|0,B|0)|0;q=G;f[d+48>>2]=B;f[d+48+4>>2]=q;l=xf(t,v,28)|0;J=G;H=xf(t,v,34)|0;J=G^J;K=xf(t,v,39)|0;J=J^G;L=Lg(E|0,L|0,t&(b|r)|b&r|0,v&(D|C)|D&C|0)|0;J=Lg(L|0,G|0,H^l^K|0,J|0)|0;K=G;f[d+16>>2]=J;f[d+16+4>>2]=K;l=xf(B,q,14)|0;H=G;L=xf(B,q,18)|0;H=G^H;E=xf(B,q,41)|0;H=H^G;k=s|6;x=f[c+(k<<3)>>2]|0;m=f[c+(k<<3)+4>>2]|0;N=f[32816+(k<<3)>>2]|0;M=f[32816+(k<<3)+4>>2]|0;n=Lg(B&(u^P)^P|0,q&(p^o)^o|0,O|0,n|0)|0;H=Lg(n|0,G|0,L^l^E|0,H|0)|0;m=Lg(H|0,G|0,x|0,m|0)|0;M=Lg(m|0,G|0,N|0,M|0)|0;N=G;C=Lg(M|0,N|0,r|0,C|0)|0;r=G;f[d+40>>2]=C;f[d+40+4>>2]=r;m=xf(J,K,28)|0;x=G;H=xf(J,K,34)|0;x=G^x;E=xf(J,K,39)|0;x=x^G;N=Lg(M|0,N|0,J&(t|b)|t&b|0,K&(v|D)|v&D|0)|0;x=Lg(N|0,G|0,H^m^E|0,x|0)|0;E=G;f[d+8>>2]=x;f[d+8+4>>2]=E;m=xf(C,r,14)|0;H=G;N=xf(C,r,18)|0;H=G^H;M=xf(C,r,41)|0;H=H^G;l=s|7;L=f[c+(l<<3)>>2]|0;n=f[c+(l<<3)+4>>2]|0;O=f[32816+(l<<3)>>2]|0;Q=f[32816+(l<<3)+4>>2]|0;o=Lg(C&(B^u)^u|0,r&(q^p)^p|0,P|0,o|0)|0;H=Lg(o|0,G|0,N^m^M|0,H|0)|0;n=Lg(H|0,G|0,L|0,n|0)|0;Q=Lg(n|0,G|0,O|0,Q|0)|0;O=G;D=Lg(Q|0,O|0,b|0,D|0)|0;b=G;f[d+32>>2]=D;f[d+32+4>>2]=b;n=xf(x,E,28)|0;L=G;H=xf(x,E,34)|0;L=G^L;M=xf(x,E,39)|0;L=L^G;O=Lg(Q|0,O|0,x&(J|t)|J&t|0,E&(K|v)|K&v|0)|0;L=Lg(O|0,G|0,H^n^M|0,L|0)|0;M=G;f[d>>2]=L;f[d+4>>2]=M;n=xf(D,b,14)|0;H=G;O=xf(D,b,18)|0;H=G^H;Q=xf(D,b,41)|0;H=H^G;m=s|8;N=f[c+(m<<3)>>2]|0;o=f[c+(m<<3)+4>>2]|0;P=f[32816+(m<<3)>>2]|0;R=f[32816+(m<<3)+4>>2]|0;p=Lg(D&(C^B)^B|0,b&(r^q)^q|0,u|0,p|0)|0;H=Lg(p|0,G|0,O^n^Q|0,H|0)|0;o=Lg(H|0,G|0,N|0,o|0)|0;R=Lg(o|0,G|0,P|0,R|0)|0;P=G;v=Lg(R|0,P|0,t|0,v|0)|0;t=G;f[d+24>>2]=v;f[d+24+4>>2]=t;o=xf(L,M,28)|0;N=G;H=xf(L,M,34)|0;N=G^N;Q=xf(L,M,39)|0;N=N^G;P=Lg(R|0,P|0,L&(x|J)|x&J|0,M&(E|K)|E&K|0)|0;N=Lg(P|0,G|0,H^o^Q|0,N|0)|0;Q=G;f[d+56>>2]=N;f[d+56+4>>2]=Q;o=xf(v,t,14)|0;H=G;P=xf(v,t,18)|0;H=G^H;R=xf(v,t,41)|0;H=H^G;n=s|9;O=f[c+(n<<3)>>2]|0;p=f[c+(n<<3)+4>>2]|0;u=f[32816+(n<<3)>>2]|0;S=f[32816+(n<<3)+4>>2]|0;q=Lg(v&(D^C)^C|0,t&(b^r)^r|0,B|0,q|0)|0;H=Lg(q|0,G|0,P^o^R|0,H|0)|0;p=Lg(H|0,G|0,O|0,p|0)|0;S=Lg(p|0,G|0,u|0,S|0)|0;u=G;K=Lg(S|0,u|0,J|0,K|0)|0;J=G;f[d+16>>2]=K;f[d+16+4>>2]=J;p=xf(N,Q,28)|0;O=G;H=xf(N,Q,34)|0;O=G^O;R=xf(N,Q,39)|0;O=O^G;u=Lg(S|0,u|0,N&(L|x)|L&x|0,Q&(M|E)|M&E|0)|0;O=Lg(u|0,G|0,H^p^R|0,O|0)|0;R=G;f[d+48>>2]=O;f[d+48+4>>2]=R;p=xf(K,J,14)|0;H=G;u=xf(K,J,18)|0;H=G^H;S=xf(K,J,41)|0;H=H^G;o=s|10;P=f[c+(o<<3)>>2]|0;q=f[c+(o<<3)+4>>2]|0;B=f[32816+(o<<3)>>2]|0;w=f[32816+(o<<3)+4>>2]|0;r=Lg(K&(v^D)^D|0,J&(t^b)^b|0,C|0,r|0)|0;H=Lg(r|0,G|0,u^p^S|0,H|0)|0;q=Lg(H|0,G|0,P|0,q|0)|0;w=Lg(q|0,G|0,B|0,w|0)|0;B=G;E=Lg(w|0,B|0,x|0,E|0)|0;x=G;f[d+8>>2]=E;f[d+8+4>>2]=x;q=xf(O,R,28)|0;P=G;H=xf(O,R,34)|0;P=G^P;S=xf(O,R,39)|0;P=P^G;B=Lg(w|0,B|0,O&(N|L)|N&L|0,R&(Q|M)|Q&M|0)|0;P=Lg(B|0,G|0,H^q^S|0,P|0)|0;S=G;f[d+40>>2]=P;f[d+40+4>>2]=S;q=xf(E,x,14)|0;H=G;B=xf(E,x,18)|0;H=G^H;w=xf(E,x,41)|0;H=H^G;p=s|11;u=f[c+(p<<3)>>2]|0;r=f[c+(p<<3)+4>>2]|0;C=f[32816+(p<<3)>>2]|0;y=f[32816+(p<<3)+4>>2]|0;b=Lg(E&(K^v)^v|0,x&(J^t)^t|0,D|0,b|0)|0;H=Lg(b|0,G|0,B^q^w|0,H|0)|0;r=Lg(H|0,G|0,u|0,r|0)|0;y=Lg(r|0,G|0,C|0,y|0)|0;C=G;M=Lg(y|0,C|0,L|0,M|0)|0;L=G;f[d>>2]=M;f[d+4>>2]=L;r=xf(P,S,28)|0;u=G;H=xf(P,S,34)|0;u=G^u;w=xf(P,S,39)|0;u=u^G;C=Lg(y|0,C|0,P&(O|N)|O&N|0,S&(R|Q)|R&Q|0)|0;u=Lg(C|0,G|0,H^r^w|0,u|0)|0;w=G;f[d+32>>2]=u;f[d+32+4>>2]=w;r=xf(M,L,14)|0;H=G;C=xf(M,L,18)|0;H=G^H;y=xf(M,L,41)|0;H=H^G;q=s|12;B=f[c+(q<<3)>>2]|0;b=f[c+(q<<3)+4>>2]|0;D=f[32816+(q<<3)>>2]|0;z=f[32816+(q<<3)+4>>2]|0;t=Lg(M&(E^K)^K|0,L&(x^J)^J|0,v|0,t|0)|0;H=Lg(t|0,G|0,C^r^y|0,H|0)|0;b=Lg(H|0,G|0,B|0,b|0)|0;z=Lg(b|0,G|0,D|0,z|0)|0;D=G;Q=Lg(z|0,D|0,N|0,Q|0)|0;N=G;f[d+56>>2]=Q;f[d+56+4>>2]=N;b=xf(u,w,28)|0;B=G;H=xf(u,w,34)|0;B=G^B;y=xf(u,w,39)|0;B=B^G;D=Lg(z|0,D|0,u&(P|O)|P&O|0,w&(S|R)|S&R|0)|0;B=Lg(D|0,G|0,H^b^y|0,B|0)|0;y=G;f[d+24>>2]=B;f[d+24+4>>2]=y;b=xf(Q,N,14)|0;H=G;D=xf(Q,N,18)|0;H=G^H;z=xf(Q,N,41)|0;H=H^G;r=s|13;C=f[c+(r<<3)>>2]|0;t=f[c+(r<<3)+4>>2]|0;v=f[32816+(r<<3)>>2]|0;A=f[32816+(r<<3)+4>>2]|0;J=Lg(Q&(M^E)^E|0,N&(L^x)^x|0,K|0,J|0)|0;H=Lg(J|0,G|0,D^b^z|0,H|0)|0;t=Lg(H|0,G|0,C|0,t|0)|0;A=Lg(t|0,G|0,v|0,A|0)|0;v=G;R=Lg(A|0,v|0,O|0,R|0)|0;O=G;f[d+48>>2]=R;f[d+48+4>>2]=O;t=xf(B,y,28)|0;C=G;H=xf(B,y,34)|0;C=G^C;z=xf(B,y,39)|0;C=C^G;v=Lg(A|0,v|0,B&(u|P)|u&P|0,y&(w|S)|w&S|0)|0;C=Lg(v|0,G|0,H^t^z|0,C|0)|0;z=G;f[d+16>>2]=C;f[d+16+4>>2]=z;t=xf(R,O,14)|0;H=G;v=xf(R,O,18)|0;H=G^H;A=xf(R,O,41)|0;H=H^G;b=s|14;D=f[c+(b<<3)>>2]|0;J=f[c+(b<<3)+4>>2]|0;K=f[32816+(b<<3)>>2]|0;I=f[32816+(b<<3)+4>>2]|0;x=Lg(R&(Q^M)^M|0,O&(N^L)^L|0,E|0,x|0)|0;H=Lg(x|0,G|0,v^t^A|0,H|0)|0;J=Lg(H|0,G|0,D|0,J|0)|0;I=Lg(J|0,G|0,K|0,I|0)|0;K=G;S=Lg(I|0,K|0,P|0,S|0)|0;P=G;f[d+40>>2]=S;f[d+40+4>>2]=P;J=xf(C,z,28)|0;D=G;H=xf(C,z,34)|0;D=G^D;A=xf(C,z,39)|0;D=D^G;K=Lg(I|0,K|0,C&(B|u)|B&u|0,z&(y|w)|y&w|0)|0;D=Lg(K|0,G|0,H^J^A|0,D|0)|0;A=G;f[d+8>>2]=D;f[d+8+4>>2]=A;J=xf(S,P,14)|0;H=G;K=xf(S,P,18)|0;H=G^H;I=xf(S,P,41)|0;H=H^G;t=s|15;v=f[c+(t<<3)>>2]|0;x=f[c+(t<<3)+4>>2]|0;E=f[32816+(t<<3)>>2]|0;F=f[32816+(t<<3)+4>>2]|0;L=Lg(S&(R^Q)^Q|0,P&(O^N)^N|0,M|0,L|0)|0;H=Lg(L|0,G|0,K^J^I|0,H|0)|0;x=Lg(H|0,G|0,v|0,x|0)|0;F=Lg(x|0,G|0,E|0,F|0)|0;E=G;w=Lg(F|0,E|0,u|0,w|0)|0;f[d+32>>2]=w;f[d+32+4>>2]=G;w=xf(D,A,28)|0;u=G;x=xf(D,A,34)|0;u=G^u;v=xf(D,A,39)|0;u=u^G;y=Lg(F|0,E|0,D&(C|B)|C&B|0,A&(z|y)|z&y|0)|0;u=Lg(y|0,G|0,x^w^v|0,u|0)|0;f[d>>2]=u;f[d+4>>2]=G;if((s|0)==64)break;P=f[c+(b<<3)>>2]|0;S=f[c+(b<<3)+4>>2]|0;E=xf(P,S,19)|0;D=G;M=xf(P,S,61)|0;y=G;J=$f(P|0,S|0,6)|0;N=f[c+(n<<3)>>2]|0;C=f[c+(n<<3)+4>>2]|0;y=Lg(J^E^M|0,G^D^y|0,N|0,C|0)|0;D=G;M=f[c+(e<<3)>>2]|0;E=f[c+(e<<3)+4>>2]|0;J=xf(M,E,1)|0;L=G;H=xf(M,E,8)|0;I=G;K=$f(M|0,E|0,7)|0;I=G^L^I;L=c+(s<<3)|0;L=Lg(y|0,D|0,f[L>>2]|0,f[L+4>>2]|0)|0;I=Lg(L|0,G|0,K^J^H|0,I|0)|0;H=G;s=s+16|0;J=c+(s<<3)|0;f[J>>2]=I;f[J+4>>2]=H;J=f[c+(t<<3)>>2]|0;K=f[c+(t<<3)+4>>2]|0;L=xf(J,K,19)|0;D=G;y=xf(J,K,61)|0;F=G;w=$f(J|0,K|0,6)|0;F=G^D^F;D=f[c+(e+9<<3)>>2]|0;Q=f[c+(e+9<<3)+4>>2]|0;z=f[c+(e+1<<3)>>2]|0;A=f[c+(e+1<<3)+4>>2]|0;R=xf(z,A,1)|0;B=G;O=xf(z,A,8)|0;u=G;x=$f(z|0,A|0,7)|0;u=G^B^u;E=Lg(D|0,Q|0,M|0,E|0)|0;F=Lg(E|0,G|0,w^L^y|0,F|0)|0;u=Lg(F|0,G|0,x^R^O|0,u|0)|0;O=G;f[c+(e+16<<3)>>2]=u;f[c+(e+16<<3)+4>>2]=O;R=xf(I,H,19)|0;x=G;F=xf(I,H,61)|0;y=G;H=$f(I|0,H|0,6)|0;I=f[c+(p<<3)>>2]|0;L=f[c+(p<<3)+4>>2]|0;y=Lg(H^R^F|0,G^x^y|0,I|0,L|0)|0;x=G;F=f[c+(h<<3)>>2]|0;R=f[c+(h<<3)+4>>2]|0;H=xf(F,R,1)|0;w=G;E=xf(F,R,8)|0;M=G;Q=$f(F|0,R|0,7)|0;M=G^w^M;A=Lg(y|0,x|0,z|0,A|0)|0;M=Lg(A|0,G|0,Q^H^E|0,M|0)|0;E=G;f[c+(g+16<<3)>>2]=M;f[c+(g+16<<3)+4>>2]=E;H=xf(u,O,19)|0;Q=G;A=xf(u,O,61)|0;z=G;O=$f(u|0,O|0,6)|0;z=G^Q^z;Q=f[c+(h+9<<3)>>2]|0;u=f[c+(h+9<<3)+4>>2]|0;x=f[c+(h+1<<3)>>2]|0;y=f[c+(h+1<<3)+4>>2]|0;w=xf(x,y,1)|0;e=G;D=xf(x,y,8)|0;B=G;v=$f(x|0,y|0,7)|0;B=G^e^B;R=Lg(Q|0,u|0,F|0,R|0)|0;z=Lg(R|0,G|0,O^H^A|0,z|0)|0;B=Lg(z|0,G|0,v^w^D|0,B|0)|0;D=G;f[c+(h+16<<3)>>2]=B;f[c+(h+16<<3)+4>>2]=D;w=xf(M,E,19)|0;v=G;z=xf(M,E,61)|0;A=G;E=$f(M|0,E|0,6)|0;M=f[c+(r<<3)>>2]|0;H=f[c+(r<<3)+4>>2]|0;A=Lg(E^w^z|0,G^v^A|0,M|0,H|0)|0;v=G;z=f[c+(j<<3)>>2]|0;w=f[c+(j<<3)+4>>2]|0;E=xf(z,w,1)|0;h=G;O=xf(z,w,8)|0;R=G;F=$f(z|0,w|0,7)|0;R=G^h^R;y=Lg(A|0,v|0,x|0,y|0)|0;R=Lg(y|0,G|0,F^E^O|0,R|0)|0;O=G;f[c+(i+16<<3)>>2]=R;f[c+(i+16<<3)+4>>2]=O;E=xf(B,D,19)|0;i=G;F=xf(B,D,61)|0;y=G;D=$f(B|0,D|0,6)|0;y=G^i^y;i=f[c+(j+9<<3)>>2]|0;B=f[c+(j+9<<3)+4>>2]|0;x=f[c+(j+1<<3)>>2]|0;v=f[c+(j+1<<3)+4>>2]|0;A=xf(x,v,1)|0;h=G;u=xf(x,v,8)|0;Q=G;e=$f(x|0,v|0,7)|0;Q=G^h^Q;w=Lg(i|0,B|0,z|0,w|0)|0;y=Lg(w|0,G|0,D^E^F|0,y|0)|0;Q=Lg(y|0,G|0,e^A^u|0,Q|0)|0;u=G;f[c+(j+16<<3)>>2]=Q;f[c+(j+16<<3)+4>>2]=u;A=xf(R,O,19)|0;e=G;y=xf(R,O,61)|0;F=G;O=$f(R|0,O|0,6)|0;F=Lg(O^A^y|0,G^e^F|0,J|0,K|0)|0;e=G;y=f[c+(l<<3)>>2]|0;A=f[c+(l<<3)+4>>2]|0;O=xf(y,A,1)|0;j=G;R=xf(y,A,8)|0;E=G;D=$f(y|0,A|0,7)|0;E=G^j^E;v=Lg(F|0,e|0,x|0,v|0)|0;E=Lg(v|0,G|0,D^O^R|0,E|0)|0;R=G;f[c+(k+16<<3)>>2]=E;f[c+(k+16<<3)+4>>2]=R;O=xf(Q,u,19)|0;k=G;D=xf(Q,u,61)|0;v=G;u=$f(Q|0,u|0,6)|0;v=G^k^v;k=f[c+(l+9<<3)>>2]|0;Q=f[c+(l+9<<3)+4>>2]|0;x=f[c+(l+1<<3)>>2]|0;e=f[c+(l+1<<3)+4>>2]|0;F=xf(x,e,1)|0;j=G;w=xf(x,e,8)|0;z=G;B=$f(x|0,e|0,7)|0;z=G^j^z;A=Lg(k|0,Q|0,y|0,A|0)|0;v=Lg(A|0,G|0,u^O^D|0,v|0)|0;z=Lg(v|0,G|0,B^F^w|0,z|0)|0;w=G;f[c+(l+16<<3)>>2]=z;f[c+(l+16<<3)+4>>2]=w;F=xf(E,R,19)|0;B=G;v=xf(E,R,61)|0;D=G;R=$f(E|0,R|0,6)|0;D=Lg(R^F^v|0,G^B^D|0,f[c+(m+9<<3)>>2]|0,f[c+(m+9<<3)+4>>2]|0)|0;B=G;v=xf(N,C,1)|0;F=G;R=xf(N,C,8)|0;E=G;O=$f(N|0,C|0,7)|0;E=F^G^E;e=Lg(D|0,B|0,x|0,e|0)|0;E=Lg(e|0,G|0,v^O^R|0,E|0)|0;R=G;f[c+(m+16<<3)>>2]=E;f[c+(m+16<<3)+4>>2]=R;O=xf(z,w,19)|0;v=G;e=xf(z,w,61)|0;x=G;w=$f(z|0,w|0,6)|0;x=G^v^x;v=f[c+(n+9<<3)>>2]|0;z=f[c+(n+9<<3)+4>>2]|0;B=f[c+(n+1<<3)>>2]|0;D=f[c+(n+1<<3)+4>>2]|0;F=xf(B,D,1)|0;u=G;A=xf(B,D,8)|0;y=G;Q=$f(B|0,D|0,7)|0;y=G^u^y;C=Lg(v|0,z|0,N|0,C|0)|0;x=Lg(C|0,G|0,w^O^e|0,x|0)|0;y=Lg(x|0,G|0,Q^F^A|0,y|0)|0;A=G;f[c+(n+16<<3)>>2]=y;f[c+(n+16<<3)+4>>2]=A;F=xf(E,R,19)|0;Q=G;x=xf(E,R,61)|0;e=G;R=$f(E|0,R|0,6)|0;e=Lg(R^F^x|0,G^Q^e|0,f[c+(o+9<<3)>>2]|0,f[c+(o+9<<3)+4>>2]|0)|0;Q=G;x=xf(I,L,1)|0;F=G;R=xf(I,L,8)|0;E=G;O=$f(I|0,L|0,7)|0;E=F^G^E;D=Lg(e|0,Q|0,B|0,D|0)|0;E=Lg(D|0,G|0,x^O^R|0,E|0)|0;R=G;f[c+(o+16<<3)>>2]=E;f[c+(o+16<<3)+4>>2]=R;O=xf(y,A,19)|0;x=G;D=xf(y,A,61)|0;B=G;A=$f(y|0,A|0,6)|0;B=G^x^B;x=f[c+(p+9<<3)>>2]|0;y=f[c+(p+9<<3)+4>>2]|0;Q=f[c+(p+1<<3)>>2]|0;e=f[c+(p+1<<3)+4>>2]|0;F=xf(Q,e,1)|0;w=G;C=xf(Q,e,8)|0;N=G;z=$f(Q|0,e|0,7)|0;N=G^w^N;L=Lg(x|0,y|0,I|0,L|0)|0;B=Lg(L|0,G|0,A^O^D|0,B|0)|0;N=Lg(B|0,G|0,z^F^C|0,N|0)|0;C=G;f[c+(p+16<<3)>>2]=N;f[c+(p+16<<3)+4>>2]=C;F=xf(E,R,19)|0;z=G;B=xf(E,R,61)|0;D=G;R=$f(E|0,R|0,6)|0;D=Lg(R^F^B|0,G^z^D|0,f[c+(q+9<<3)>>2]|0,f[c+(q+9<<3)+4>>2]|0)|0;z=G;B=xf(M,H,1)|0;F=G;R=xf(M,H,8)|0;E=G;O=$f(M|0,H|0,7)|0;E=F^G^E;e=Lg(D|0,z|0,Q|0,e|0)|0;E=Lg(e|0,G|0,B^O^R|0,E|0)|0;R=G;f[c+(q+16<<3)>>2]=E;f[c+(q+16<<3)+4>>2]=R;O=xf(N,C,19)|0;B=G;e=xf(N,C,61)|0;Q=G;C=$f(N|0,C|0,6)|0;Q=G^B^Q;B=f[c+(r+9<<3)>>2]|0;N=f[c+(r+9<<3)+4>>2]|0;z=f[c+(r+1<<3)>>2]|0;D=f[c+(r+1<<3)+4>>2]|0;F=xf(z,D,1)|0;A=G;L=xf(z,D,8)|0;I=G;D=$f(z|0,D|0,7)|0;I=G^A^I;H=Lg(B|0,N|0,M|0,H|0)|0;Q=Lg(H|0,G|0,C^O^e|0,Q|0)|0;I=Lg(Q|0,G|0,D^F^L|0,I|0)|0;L=G;f[c+(r+16<<3)>>2]=I;f[c+(r+16<<3)+4>>2]=L;F=xf(E,R,19)|0;D=G;Q=xf(E,R,61)|0;e=G;R=$f(E|0,R|0,6)|0;e=G^D^e;D=f[c+(b+9<<3)>>2]|0;E=f[c+(b+9<<3)+4>>2]|0;O=xf(J,K,1)|0;C=G;H=xf(J,K,8)|0;M=G;N=$f(J|0,K|0,7)|0;M=C^G^M;S=Lg(D|0,E|0,P|0,S|0)|0;e=Lg(S|0,G|0,R^F^Q|0,e|0)|0;M=Lg(e|0,G|0,O^N^H|0,M|0)|0;f[c+(b+16<<3)>>2]=M;f[c+(b+16<<3)+4>>2]=G;M=xf(I,L,19)|0;H=G;N=xf(I,L,61)|0;O=G;L=$f(I|0,L|0,6)|0;O=G^H^O;H=f[c+(t+9<<3)>>2]|0;I=f[c+(t+9<<3)+4>>2]|0;b=f[c+(t+1<<3)>>2]|0;e=f[c+(t+1<<3)+4>>2]|0;Q=xf(b,e,1)|0;F=G;R=xf(b,e,8)|0;S=G;P=$f(b|0,e|0,7)|0;S=G^F^S;K=Lg(H|0,I|0,J|0,K|0)|0;O=Lg(K|0,G|0,L^M^N|0,O|0)|0;S=Lg(O|0,G|0,P^Q^R|0,S|0)|0;f[c+(t+16<<3)>>2]=S;f[c+(t+16<<3)+4>>2]=G}while(s>>>0<80);b=0;do{R=d+(b<<3)|0;S=a+(b<<3)|0;R=Lg(f[S>>2]|0,f[S+4>>2]|0,f[R>>2]|0,f[R+4>>2]|0)|0;f[S>>2]=R;f[S+4>>2]=G;b=b+1|0}while((b|0)!=8);return}function na(a){a=a|0;var b=0,c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0;x=t;o=t=t+63&-64;t=t+16|0;do if(a>>>0<245){n=a>>>0<11?16:a+11&-8;l=f[8878]|0;if(l>>>(n>>>3)&3|0){a=35552+((l>>>(n>>>3)&1^1)+(n>>>3)<<1<<2)|0;b=f[a+8>>2]|0;c=f[b+8>>2]|0;if((c|0)==(a|0))f[8878]=l&~(1<<(l>>>(n>>>3)&1^1)+(n>>>3));else{f[c+12>>2]=a;f[a+8>>2]=c}w=(l>>>(n>>>3)&1^1)+(n>>>3)<<3;f[b+4>>2]=w|3;f[b+w+4>>2]=f[b+w+4>>2]|1;w=b+8|0;t=x;return w|0}m=f[8880]|0;if(n>>>0>m>>>0){if(l>>>(n>>>3)|0){a=l>>>(n>>>3)<<(n>>>3)&(2<<(n>>>3)|0-(2<<(n>>>3)));e=((a&0-a)+-1|0)>>>(((a&0-a)+-1|0)>>>12&16);d=e>>>(e>>>5&8)>>>(e>>>(e>>>5&8)>>>2&4);d=(e>>>5&8|((a&0-a)+-1|0)>>>12&16|e>>>(e>>>5&8)>>>2&4|d>>>1&2|d>>>(d>>>1&2)>>>1&1)+(d>>>(d>>>1&2)>>>(d>>>(d>>>1&2)>>>1&1))|0;e=f[35552+(d<<1<<2)+8>>2]|0;a=f[e+8>>2]|0;if((a|0)==(35552+(d<<1<<2)|0)){f[8878]=l&~(1<<d);a=l&~(1<<d)}else{f[a+12>>2]=35552+(d<<1<<2);f[35552+(d<<1<<2)+8>>2]=a;a=l}f[e+4>>2]=n|3;f[e+n+4>>2]=(d<<3)-n|1;f[e+(d<<3)>>2]=(d<<3)-n;if(m|0){c=f[8883]|0;if(!(a&1<<(m>>>3))){f[8878]=a|1<<(m>>>3);a=35552+(m>>>3<<1<<2)|0;b=35552+(m>>>3<<1<<2)+8|0}else{a=f[35552+(m>>>3<<1<<2)+8>>2]|0;b=35552+(m>>>3<<1<<2)+8|0}f[b>>2]=c;f[a+12>>2]=c;f[c+8>>2]=a;f[c+12>>2]=35552+(m>>>3<<1<<2)}f[8880]=(d<<3)-n;f[8883]=e+n;w=e+8|0;t=x;return w|0}h=f[8879]|0;if(h){b=((h&0-h)+-1|0)>>>(((h&0-h)+-1|0)>>>12&16);k=b>>>(b>>>5&8)>>>(b>>>(b>>>5&8)>>>2&4);k=f[35816+((b>>>5&8|((h&0-h)+-1|0)>>>12&16|b>>>(b>>>5&8)>>>2&4|k>>>1&2|k>>>(k>>>1&2)>>>1&1)+(k>>>(k>>>1&2)>>>(k>>>(k>>>1&2)>>>1&1))<<2)>>2]|0;b=k;j=k;k=(f[k+4>>2]&-8)-n|0;while(1){a=f[b+16>>2]|0;if(!a){a=f[b+20>>2]|0;if(!a)break}i=(f[a+4>>2]&-8)-n|0;e=i>>>0<k>>>0;b=a;j=e?a:j;k=e?i:k}i=j+n|0;if(i>>>0>j>>>0){e=f[j+24>>2]|0;a=f[j+12>>2]|0;do if((a|0)==(j|0)){b=j+20|0;a=f[b>>2]|0;if(!a){b=j+16|0;a=f[b>>2]|0;if(!a){b=0;break}}while(1){d=a+20|0;c=f[d>>2]|0;if(!c){d=a+16|0;c=f[d>>2]|0;if(!c)break;else{a=c;b=d}}else{a=c;b=d}}f[b>>2]=0;b=a}else{b=f[j+8>>2]|0;f[b+12>>2]=a;f[a+8>>2]=b;b=a}while(0);do if(e|0){a=f[j+28>>2]|0;if((j|0)==(f[35816+(a<<2)>>2]|0)){f[35816+(a<<2)>>2]=b;if(!b){f[8879]=h&~(1<<a);break}}else{f[((f[e+16>>2]|0)==(j|0)?e+16|0:e+20|0)>>2]=b;if(!b)break}f[b+24>>2]=e;a=f[j+16>>2]|0;if(a|0){f[b+16>>2]=a;f[a+24>>2]=b}a=f[j+20>>2]|0;if(a|0){f[b+20>>2]=a;f[a+24>>2]=b}}while(0);if(k>>>0<16){w=k+n|0;f[j+4>>2]=w|3;w=j+w+4|0;f[w>>2]=f[w>>2]|1}else{f[j+4>>2]=n|3;f[i+4>>2]=k|1;f[i+k>>2]=k;if(m|0){c=f[8883]|0;if(!(1<<(m>>>3)&l)){f[8878]=1<<(m>>>3)|l;a=35552+(m>>>3<<1<<2)|0;b=35552+(m>>>3<<1<<2)+8|0}else{a=f[35552+(m>>>3<<1<<2)+8>>2]|0;b=35552+(m>>>3<<1<<2)+8|0}f[b>>2]=c;f[a+12>>2]=c;f[c+8>>2]=a;f[c+12>>2]=35552+(m>>>3<<1<<2)}f[8880]=k;f[8883]=i}w=j+8|0;t=x;return w|0}}}}else if(a>>>0<=4294967231){n=a+11&-8;d=f[8879]|0;if(d){if((a+11|0)>>>8)if(n>>>0>16777215)j=31;else{j=(a+11|0)>>>8<<((((a+11|0)>>>8)+1048320|0)>>>16&8);j=14-((j+520192|0)>>>16&4|(((a+11|0)>>>8)+1048320|0)>>>16&8|((j<<((j+520192|0)>>>16&4))+245760|0)>>>16&2)+(j<<((j+520192|0)>>>16&4)<<(((j<<((j+520192|0)>>>16&4))+245760|0)>>>16&2)>>>15)|0;j=n>>>(j+7|0)&1|j<<1}else j=0;a=f[35816+(j<<2)>>2]|0;a:do if(!a){c=0;a=0;b=0-n|0;s=61}else{h=0;b=0-n|0;i=n<<((j|0)==31?0:25-(j>>>1)|0);c=0;while(1){e=(f[a+4>>2]&-8)-n|0;if(e>>>0<b>>>0)if(!e){e=a;b=0;c=a;s=65;break a}else{h=a;b=e}s=f[a+20>>2]|0;a=f[a+16+(i>>>31<<2)>>2]|0;c=(s|0)==0|(s|0)==(a|0)?c:s;if(!a){a=h;s=61;break}else i=i<<1}}while(0);if((s|0)==61){if((c|0)==0&(a|0)==0){a=2<<j;if(!((a|0-a)&d))break;l=((a|0-a)&d&0-((a|0-a)&d))+-1|0;m=l>>>(l>>>12&16)>>>(l>>>(l>>>12&16)>>>5&8);c=m>>>(m>>>2&4)>>>(m>>>(m>>>2&4)>>>1&2);a=0;c=f[35816+((l>>>(l>>>12&16)>>>5&8|l>>>12&16|m>>>2&4|m>>>(m>>>2&4)>>>1&2|c>>>1&1)+(c>>>(c>>>1&1))<<2)>>2]|0}if(!c){i=a;h=b}else{e=a;s=65}}if((s|0)==65)while(1){m=(f[c+4>>2]&-8)-n|0;a=m>>>0<b>>>0;b=a?m:b;e=a?c:e;a=f[c+16>>2]|0;if(!a)a=f[c+20>>2]|0;if(!a){i=e;h=b;break}else c=a}if(((i|0)!=0?h>>>0<((f[8880]|0)-n|0)>>>0:0)?(k=i+n|0,k>>>0>i>>>0):0){g=f[i+24>>2]|0;a=f[i+12>>2]|0;do if((a|0)==(i|0)){b=i+20|0;a=f[b>>2]|0;if(!a){b=i+16|0;a=f[b>>2]|0;if(!a){a=0;break}}while(1){e=a+20|0;c=f[e>>2]|0;if(!c){e=a+16|0;c=f[e>>2]|0;if(!c)break;else{a=c;b=e}}else{a=c;b=e}}f[b>>2]=0}else{w=f[i+8>>2]|0;f[w+12>>2]=a;f[a+8>>2]=w}while(0);do if(g){b=f[i+28>>2]|0;if((i|0)==(f[35816+(b<<2)>>2]|0)){f[35816+(b<<2)>>2]=a;if(!a){f[8879]=d&~(1<<b);d=d&~(1<<b);break}}else{f[((f[g+16>>2]|0)==(i|0)?g+16|0:g+20|0)>>2]=a;if(!a)break}f[a+24>>2]=g;b=f[i+16>>2]|0;if(b|0){f[a+16>>2]=b;f[b+24>>2]=a}b=f[i+20>>2]|0;if(b){f[a+20>>2]=b;f[b+24>>2]=a}}while(0);b:do if(h>>>0<16){w=h+n|0;f[i+4>>2]=w|3;w=i+w+4|0;f[w>>2]=f[w>>2]|1}else{f[i+4>>2]=n|3;f[k+4>>2]=h|1;f[k+h>>2]=h;c=h>>>3;if(h>>>0<256){a=f[8878]|0;if(!(a&1<<c)){f[8878]=a|1<<c;a=35552+(c<<1<<2)|0;b=35552+(c<<1<<2)+8|0}else{a=f[35552+(c<<1<<2)+8>>2]|0;b=35552+(c<<1<<2)+8|0}f[b>>2]=k;f[a+12>>2]=k;f[k+8>>2]=a;f[k+12>>2]=35552+(c<<1<<2);break}a=h>>>8;if(a)if(h>>>0>16777215)c=31;else{c=a<<((a+1048320|0)>>>16&8)<<(((a<<((a+1048320|0)>>>16&8))+520192|0)>>>16&4);c=14-(((a<<((a+1048320|0)>>>16&8))+520192|0)>>>16&4|(a+1048320|0)>>>16&8|(c+245760|0)>>>16&2)+(c<<((c+245760|0)>>>16&2)>>>15)|0;c=h>>>(c+7|0)&1|c<<1}else c=0;a=35816+(c<<2)|0;f[k+28>>2]=c;f[k+16+4>>2]=0;f[k+16>>2]=0;b=1<<c;if(!(d&b)){f[8879]=d|b;f[a>>2]=k;f[k+24>>2]=a;f[k+12>>2]=k;f[k+8>>2]=k;break}a=f[a>>2]|0;c:do if((f[a+4>>2]&-8|0)!=(h|0)){d=h<<((c|0)==31?0:25-(c>>>1)|0);while(1){c=a+16+(d>>>31<<2)|0;b=f[c>>2]|0;if(!b)break;if((f[b+4>>2]&-8|0)==(h|0)){a=b;break c}else{d=d<<1;a=b}}f[c>>2]=k;f[k+24>>2]=a;f[k+12>>2]=k;f[k+8>>2]=k;break b}while(0);v=a+8|0;w=f[v>>2]|0;f[w+12>>2]=k;f[v>>2]=k;f[k+8>>2]=w;f[k+12>>2]=a;f[k+24>>2]=0}while(0);w=i+8|0;t=x;return w|0}}}else n=-1;while(0);c=f[8880]|0;if(c>>>0>=n>>>0){a=c-n|0;b=f[8883]|0;if(a>>>0>15){w=b+n|0;f[8883]=w;f[8880]=a;f[w+4>>2]=a|1;f[b+c>>2]=a;f[b+4>>2]=n|3}else{f[8880]=0;f[8883]=0;f[b+4>>2]=c|3;f[b+c+4>>2]=f[b+c+4>>2]|1}w=b+8|0;t=x;return w|0}e=f[8881]|0;if(e>>>0>n>>>0){u=e-n|0;f[8881]=u;w=f[8884]|0;v=w+n|0;f[8884]=v;f[v+4>>2]=u|1;f[w+4>>2]=n|3;w=w+8|0;t=x;return w|0}if(!(f[8996]|0)){f[8998]=4096;f[8997]=4096;f[8999]=-1;f[9e3]=-1;f[9001]=0;f[8989]=0;f[8996]=o&-16^1431655768;a=4096}else a=f[8998]|0;h=n+48|0;i=n+47|0;k=a+i|0;j=0-a|0;if((k&j)>>>0<=n>>>0){w=0;t=x;return w|0}a=f[8988]|0;if(a|0?(o=f[8986]|0,(o+(k&j)|0)>>>0<=o>>>0?1:(o+(k&j)|0)>>>0>a>>>0):0){w=0;t=x;return w|0}d:do if(!(f[8989]&4)){c=f[8884]|0;e:do if(c){b=35960;while(1){a=f[b>>2]|0;if(a>>>0<=c>>>0?(p=b+4|0,(a+(f[p>>2]|0)|0)>>>0>c>>>0):0)break;a=f[b+8>>2]|0;if(!a){s=128;break e}else b=a}if((k-e&j)>>>0<2147483647){a=be(k-e&j|0)|0;if((a|0)==((f[b>>2]|0)+(f[p>>2]|0)|0))if((a|0)==(-1|0))a=k-e&j;else{h=k-e&j;g=a;s=145;break d}else{d=a;c=k-e&j;s=136}}else a=0}else s=128;while(0);do if((s|0)==128){b=be(0)|0;if((b|0)!=(-1|0)?(r=f[8997]|0,r=((r+-1&b|0)==0?0:(r+-1+b&0-r)-b|0)+(k&j)|0,q=f[8986]|0,r>>>0>n>>>0&r>>>0<2147483647):0){p=f[8988]|0;if(p|0?(r+q|0)>>>0<=q>>>0|(r+q|0)>>>0>p>>>0:0){a=0;break}a=be(r|0)|0;if((a|0)==(b|0)){h=r;g=b;s=145;break d}else{d=a;c=r;s=136}}else a=0}while(0);do if((s|0)==136){b=0-c|0;if(!(h>>>0>c>>>0&(c>>>0<2147483647&(d|0)!=(-1|0))))if((d|0)==(-1|0)){a=0;break}else{h=c;g=d;s=145;break d}a=f[8998]|0;a=i-c+a&0-a;if(a>>>0>=2147483647){h=c;g=d;s=145;break d}if((be(a|0)|0)==(-1|0)){be(b|0)|0;a=0;break}else{h=a+c|0;g=d;s=145;break d}}while(0);f[8989]=f[8989]|4;s=143}else{a=0;s=143}while(0);if(((s|0)==143?(k&j)>>>0<2147483647:0)?(g=be(k&j|0)|0,u=be(0)|0,v=(u-g|0)>>>0>(n+40|0)>>>0,!((g|0)==(-1|0)|v^1|g>>>0<u>>>0&((g|0)!=(-1|0)&(u|0)!=(-1|0))^1)):0){h=v?u-g|0:a;s=145}if((s|0)==145){a=(f[8986]|0)+h|0;f[8986]=a;if(a>>>0>(f[8987]|0)>>>0)f[8987]=a;j=f[8884]|0;f:do if(j){a=35960;while(1){b=f[a>>2]|0;c=a+4|0;d=f[c>>2]|0;if((g|0)==(b+d|0)){s=154;break}e=f[a+8>>2]|0;if(!e)break;else a=e}if(((s|0)==154?(f[a+12>>2]&8|0)==0:0)?g>>>0>j>>>0&b>>>0<=j>>>0:0){f[c>>2]=d+h;w=(f[8881]|0)+h|0;v=(j+8&7|0)==0?0:0-(j+8)&7;f[8884]=j+v;f[8881]=w-v;f[j+v+4>>2]=w-v|1;f[j+w+4>>2]=40;f[8885]=f[9e3];break}if(g>>>0<(f[8882]|0)>>>0)f[8882]=g;c=g+h|0;a=35960;while(1){if((f[a>>2]|0)==(c|0)){s=162;break}b=f[a+8>>2]|0;if(!b)break;else a=b}if((s|0)==162?(f[a+12>>2]&8|0)==0:0){f[a>>2]=g;l=a+4|0;f[l>>2]=(f[l>>2]|0)+h;l=g+8|0;l=g+((l&7|0)==0?0:0-l&7)|0;a=c+((c+8&7|0)==0?0:0-(c+8)&7)|0;k=l+n|0;i=a-l-n|0;f[l+4>>2]=n|3;g:do if((j|0)==(a|0)){w=(f[8881]|0)+i|0;f[8881]=w;f[8884]=k;f[k+4>>2]=w|1}else{if((f[8883]|0)==(a|0)){w=(f[8880]|0)+i|0;f[8880]=w;f[8883]=k;f[k+4>>2]=w|1;f[k+w>>2]=w;break}h=f[a+4>>2]|0;if((h&3|0)==1){h:do if(h>>>0<256){b=f[a+8>>2]|0;c=f[a+12>>2]|0;if((c|0)==(b|0)){f[8878]=f[8878]&~(1<<(h>>>3));break}else{f[b+12>>2]=c;f[c+8>>2]=b;break}}else{g=f[a+24>>2]|0;b=f[a+12>>2]|0;do if((b|0)==(a|0)){b=f[a+16+4>>2]|0;if(!b){b=f[a+16>>2]|0;if(!b){b=0;break}else c=a+16|0}else c=a+16+4|0;while(1){e=b+20|0;d=f[e>>2]|0;if(!d){e=b+16|0;d=f[e>>2]|0;if(!d)break;else{b=d;c=e}}else{b=d;c=e}}f[c>>2]=0}else{w=f[a+8>>2]|0;f[w+12>>2]=b;f[b+8>>2]=w}while(0);if(!g)break;c=f[a+28>>2]|0;do if((f[35816+(c<<2)>>2]|0)!=(a|0)){f[((f[g+16>>2]|0)==(a|0)?g+16|0:g+20|0)>>2]=b;if(!b)break h}else{f[35816+(c<<2)>>2]=b;if(b|0)break;f[8879]=f[8879]&~(1<<c);break h}while(0);f[b+24>>2]=g;c=f[a+16>>2]|0;if(c|0){f[b+16>>2]=c;f[c+24>>2]=b}c=f[a+16+4>>2]|0;if(!c)break;f[b+20>>2]=c;f[c+24>>2]=b}while(0);a=a+(h&-8)|0;e=(h&-8)+i|0}else e=i;c=a+4|0;f[c>>2]=f[c>>2]&-2;f[k+4>>2]=e|1;f[k+e>>2]=e;c=e>>>3;if(e>>>0<256){a=f[8878]|0;if(!(a&1<<c)){f[8878]=a|1<<c;a=35552+(c<<1<<2)|0;b=35552+(c<<1<<2)+8|0}else{a=f[35552+(c<<1<<2)+8>>2]|0;b=35552+(c<<1<<2)+8|0}f[b>>2]=k;f[a+12>>2]=k;f[k+8>>2]=a;f[k+12>>2]=35552+(c<<1<<2);break}a=e>>>8;do if(!a)d=0;else{if(e>>>0>16777215){d=31;break}d=a<<((a+1048320|0)>>>16&8)<<(((a<<((a+1048320|0)>>>16&8))+520192|0)>>>16&4);d=14-(((a<<((a+1048320|0)>>>16&8))+520192|0)>>>16&4|(a+1048320|0)>>>16&8|(d+245760|0)>>>16&2)+(d<<((d+245760|0)>>>16&2)>>>15)|0;d=e>>>(d+7|0)&1|d<<1}while(0);a=35816+(d<<2)|0;f[k+28>>2]=d;f[k+16+4>>2]=0;f[k+16>>2]=0;b=f[8879]|0;c=1<<d;if(!(b&c)){f[8879]=b|c;f[a>>2]=k;f[k+24>>2]=a;f[k+12>>2]=k;f[k+8>>2]=k;break}a=f[a>>2]|0;i:do if((f[a+4>>2]&-8|0)!=(e|0)){d=e<<((d|0)==31?0:25-(d>>>1)|0);while(1){c=a+16+(d>>>31<<2)|0;b=f[c>>2]|0;if(!b)break;if((f[b+4>>2]&-8|0)==(e|0)){a=b;break i}else{d=d<<1;a=b}}f[c>>2]=k;f[k+24>>2]=a;f[k+12>>2]=k;f[k+8>>2]=k;break g}while(0);v=a+8|0;w=f[v>>2]|0;f[w+12>>2]=k;f[v>>2]=k;f[k+8>>2]=w;f[k+12>>2]=a;f[k+24>>2]=0}while(0);w=l+8|0;t=x;return w|0}a=35960;while(1){b=f[a>>2]|0;if(b>>>0<=j>>>0?(w=b+(f[a+4>>2]|0)|0,w>>>0>j>>>0):0)break;a=f[a+8>>2]|0}e=w+-47+((w+-47+8&7|0)==0?0:0-(w+-47+8)&7)|0;e=e>>>0<(j+16|0)>>>0?j:e;a=h+-40|0;u=g+8|0;u=(u&7|0)==0?0:0-u&7;v=g+u|0;f[8884]=v;f[8881]=a-u;f[v+4>>2]=a-u|1;f[g+a+4>>2]=40;f[8885]=f[9e3];f[e+4>>2]=27;f[e+8>>2]=f[8990];f[e+8+4>>2]=f[8991];f[e+8+8>>2]=f[8992];f[e+8+12>>2]=f[8993];f[8990]=g;f[8991]=h;f[8993]=0;f[8992]=e+8;a=e+24|0;do{v=a;a=a+4|0;f[a>>2]=7}while((v+8|0)>>>0<w>>>0);if((e|0)!=(j|0)){f[e+4>>2]=f[e+4>>2]&-2;f[j+4>>2]=e-j|1;f[e>>2]=e-j;if((e-j|0)>>>0<256){c=35552+((e-j|0)>>>3<<1<<2)|0;a=f[8878]|0;if(!(a&1<<((e-j|0)>>>3))){f[8878]=a|1<<((e-j|0)>>>3);a=c;b=c+8|0}else{a=f[c+8>>2]|0;b=c+8|0}f[b>>2]=j;f[a+12>>2]=j;f[j+8>>2]=a;f[j+12>>2]=c;break}if((e-j|0)>>>8)if((e-j|0)>>>0>16777215)d=31;else{d=(e-j|0)>>>8<<((((e-j|0)>>>8)+1048320|0)>>>16&8);d=14-((d+520192|0)>>>16&4|(((e-j|0)>>>8)+1048320|0)>>>16&8|((d<<((d+520192|0)>>>16&4))+245760|0)>>>16&2)+(d<<((d+520192|0)>>>16&4)<<(((d<<((d+520192|0)>>>16&4))+245760|0)>>>16&2)>>>15)|0;d=(e-j|0)>>>(d+7|0)&1|d<<1}else d=0;a=35816+(d<<2)|0;f[j+28>>2]=d;f[j+20>>2]=0;f[j+16>>2]=0;b=f[8879]|0;c=1<<d;if(!(b&c)){f[8879]=b|c;f[a>>2]=j;f[j+24>>2]=a;f[j+12>>2]=j;f[j+8>>2]=j;break}a=f[a>>2]|0;j:do if((f[a+4>>2]&-8|0)!=(e-j|0)){d=e-j<<((d|0)==31?0:25-(d>>>1)|0);while(1){c=a+16+(d>>>31<<2)|0;b=f[c>>2]|0;if(!b)break;if((f[b+4>>2]&-8|0)==(e-j|0)){a=b;break j}else{d=d<<1;a=b}}f[c>>2]=j;f[j+24>>2]=a;f[j+12>>2]=j;f[j+8>>2]=j;break f}while(0);v=a+8|0;w=f[v>>2]|0;f[w+12>>2]=j;f[v>>2]=j;f[j+8>>2]=w;f[j+12>>2]=a;f[j+24>>2]=0}}else{w=f[8882]|0;if((w|0)==0|g>>>0<w>>>0)f[8882]=g;f[8990]=g;f[8991]=h;f[8993]=0;f[8887]=f[8996];f[8886]=-1;f[8891]=35552;f[8890]=35552;f[8893]=35560;f[8892]=35560;f[8895]=35568;f[8894]=35568;f[8897]=35576;f[8896]=35576;f[8899]=35584;f[8898]=35584;f[8901]=35592;f[8900]=35592;f[8903]=35600;f[8902]=35600;f[8905]=35608;f[8904]=35608;f[8907]=35616;f[8906]=35616;f[8909]=35624;f[8908]=35624;f[8911]=35632;f[8910]=35632;f[8913]=35640;f[8912]=35640;f[8915]=35648;f[8914]=35648;f[8917]=35656;f[8916]=35656;f[8919]=35664;f[8918]=35664;f[8921]=35672;f[8920]=35672;f[8923]=35680;f[8922]=35680;f[8925]=35688;f[8924]=35688;f[8927]=35696;f[8926]=35696;f[8929]=35704;f[8928]=35704;f[8931]=35712;f[8930]=35712;f[8933]=35720;f[8932]=35720;f[8935]=35728;f[8934]=35728;f[8937]=35736;f[8936]=35736;f[8939]=35744;f[8938]=35744;f[8941]=35752;f[8940]=35752;f[8943]=35760;f[8942]=35760;f[8945]=35768;f[8944]=35768;f[8947]=35776;f[8946]=35776;f[8949]=35784;f[8948]=35784;f[8951]=35792;f[8950]=35792;f[8953]=35800;f[8952]=35800;w=h+-40|0;u=g+8|0;u=(u&7|0)==0?0:0-u&7;v=g+u|0;f[8884]=v;f[8881]=w-u;f[v+4>>2]=w-u|1;f[g+w+4>>2]=40;f[8885]=f[9e3]}while(0);a=f[8881]|0;if(a>>>0>n>>>0){u=a-n|0;f[8881]=u;w=f[8884]|0;v=w+n|0;f[8884]=v;f[v+4>>2]=u|1;f[w+4>>2]=n|3;w=w+8|0;t=x;return w|0}}f[9002]=12;w=0;t=x;return w|0}function oa(a){a=a|0;var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0,oa=0,pa=0,qa=0,ra=0;P=Cf(b[a>>0]|0,b[a+1>>0]|0,b[a+2>>0]|0)|0;S=we(a+2|0)|0;S=$f(S|0,G|0,5)|0;F=Cf(b[a+5>>0]|0,b[a+6>>0]|0,b[a+7>>0]|0)|0;F=$f(F|0,G|0,2)|0;m=we(a+7|0)|0;m=$f(m|0,G|0,7)|0;Q=we(a+10|0)|0;Q=$f(Q|0,G|0,4)|0;W=Cf(b[a+13>>0]|0,b[a+14>>0]|0,b[a+15>>0]|0)|0;W=$f(W|0,G|0,1)|0;v=we(a+15|0)|0;v=$f(v|0,G|0,6)|0;ha=Cf(b[a+18>>0]|0,b[a+19>>0]|0,b[a+20>>0]|0)|0;ha=$f(ha|0,G|0,3)|0;ma=Cf(b[a+21>>0]|0,b[a+22>>0]|0,b[a+23>>0]|0)|0;ea=we(a+23|0)|0;ea=$f(ea|0,G|0,5)|0;la=Cf(b[a+26>>0]|0,b[a+27>>0]|0,b[a+28>>0]|0)|0;la=$f(la|0,G|0,2)|0;$=we(a+28|0)|0;$=$f($|0,G|0,7)|0;qa=we(a+31|0)|0;qa=$f(qa|0,G|0,4)|0;z=Cf(b[a+34>>0]|0,b[a+35>>0]|0,b[a+36>>0]|0)|0;z=$f(z|0,G|0,1)|0;N=we(a+36|0)|0;N=$f(N|0,G|0,6)|0;r=Cf(b[a+39>>0]|0,b[a+40>>0]|0,b[a+41>>0]|0)|0;r=$f(r|0,G|0,3)|0;e=Cf(b[a+42>>0]|0,b[a+43>>0]|0,b[a+44>>0]|0)|0;L=we(a+44|0)|0;L=$f(L|0,G|0,5)|0;ba=Cf(b[a+47>>0]|0,b[a+48>>0]|0,b[a+49>>0]|0)|0;ba=$f(ba|0,G|0,2)|0;ra=we(a+49|0)|0;ra=$f(ra|0,G|0,7)|0;k=we(a+52|0)|0;k=$f(k|0,G|0,4)|0;x=Cf(b[a+55>>0]|0,b[a+56>>0]|0,b[a+57>>0]|0)|0;x=$f(x|0,G|0,1)|0;C=we(a+57|0)|0;C=$f(C|0,G|0,6)|0;R=we(a+60|0)|0;R=$f(R|0,G|0,3)|0;f=G;i=Af(R|0,f|0,666643,0)|0;q=G;ja=Af(R|0,f|0,470296,0)|0;s=G;A=Af(R|0,f|0,654183,0)|0;g=G;w=Af(R|0,f|0,-997805,-1)|0;j=G;c=Af(R|0,f|0,136657,0)|0;r=Lg(c|0,G|0,r&2097151|0,0)|0;c=G;f=Af(R|0,f|0,-683901,-1)|0;e=Lg(f|0,G|0,e&2097151|0,0)|0;f=G;R=Af(C&2097151|0,0,666643,0)|0;M=G;u=Af(C&2097151|0,0,470296,0)|0;Z=G;D=Af(C&2097151|0,0,654183,0)|0;d=G;U=Af(C&2097151|0,0,-997805,-1)|0;T=G;O=Af(C&2097151|0,0,136657,0)|0;p=G;C=Af(C&2097151|0,0,-683901,-1)|0;C=Lg(r|0,c|0,C|0,G|0)|0;c=G;r=Af(x&2097151|0,0,666643,0)|0;V=G;y=Af(x&2097151|0,0,470296,0)|0;aa=G;K=Af(x&2097151|0,0,654183,0)|0;h=G;na=Af(x&2097151|0,0,-997805,-1)|0;ia=G;Y=Af(x&2097151|0,0,136657,0)|0;E=G;x=Af(x&2097151|0,0,-683901,-1)|0;N=Lg(x|0,G|0,N&2097151|0,0)|0;j=Lg(N|0,G|0,w|0,j|0)|0;p=Lg(j|0,G|0,O|0,p|0)|0;O=G;j=Af(k&2097151|0,0,666643,0)|0;w=G;N=Af(k&2097151|0,0,470296,0)|0;x=G;n=Af(k&2097151|0,0,654183,0)|0;X=G;H=Af(k&2097151|0,0,-997805,-1)|0;I=G;pa=Af(k&2097151|0,0,136657,0)|0;oa=G;k=Af(k&2097151|0,0,-683901,-1)|0;l=G;o=Af(ra&2097151|0,0,666643,0)|0;B=G;fa=Af(ra&2097151|0,0,470296,0)|0;ga=G;da=Af(ra&2097151|0,0,654183,0)|0;ca=G;ka=Af(ra&2097151|0,0,-997805,-1)|0;J=G;_=Af(ra&2097151|0,0,136657,0)|0;t=G;ra=Af(ra&2097151|0,0,-683901,-1)|0;qa=Lg(ra|0,G|0,qa&2097151|0,0)|0;oa=Lg(qa|0,G|0,pa|0,oa|0)|0;ia=Lg(oa|0,G|0,na|0,ia|0)|0;s=Lg(ia|0,G|0,ja|0,s|0)|0;d=Lg(s|0,G|0,D|0,d|0)|0;D=G;s=Af(ba&2097151|0,0,666643,0)|0;v=Lg(s|0,G|0,v&2097151|0,0)|0;s=G;ja=Af(ba&2097151|0,0,470296,0)|0;ia=G;na=Af(ba&2097151|0,0,654183,0)|0;ma=Lg(na|0,G|0,ma&2097151|0,0)|0;ga=Lg(ma|0,G|0,fa|0,ga|0)|0;w=Lg(ga|0,G|0,j|0,w|0)|0;j=G;ga=Af(ba&2097151|0,0,-997805,-1)|0;fa=G;ma=Af(ba&2097151|0,0,136657,0)|0;la=Lg(ma|0,G|0,la&2097151|0,0)|0;J=Lg(la|0,G|0,ka|0,J|0)|0;X=Lg(J|0,G|0,n|0,X|0)|0;aa=Lg(X|0,G|0,y|0,aa|0)|0;M=Lg(aa|0,G|0,R|0,M|0)|0;R=G;ba=Af(ba&2097151|0,0,-683901,-1)|0;aa=G;y=Lg(v|0,s|0,1048576,0)|0;X=G;n=$f(y|0,X|0,21)|0;J=G;ha=Lg(ja|0,ia|0,ha&2097151|0,0)|0;B=Lg(ha|0,G|0,o|0,B|0)|0;J=Lg(B|0,G|0,n|0,J|0)|0;n=G;X=Ig(v|0,s|0,y&-2097152|0,X&2047|0)|0;y=G;s=Lg(w|0,j|0,1048576,0)|0;v=G;B=$f(s|0,v|0,21)|0;o=G;ea=Lg(ga|0,fa|0,ea&2097151|0,0)|0;ca=Lg(ea|0,G|0,da|0,ca|0)|0;x=Lg(ca|0,G|0,N|0,x|0)|0;V=Lg(x|0,G|0,r|0,V|0)|0;o=Lg(V|0,G|0,B|0,o|0)|0;B=G;V=Lg(M|0,R|0,1048576,0)|0;r=G;x=Nf(V|0,r|0,21)|0;N=G;$=Lg(ba|0,aa|0,$&2097151|0,0)|0;t=Lg($|0,G|0,_|0,t|0)|0;I=Lg(t|0,G|0,H|0,I|0)|0;h=Lg(I|0,G|0,K|0,h|0)|0;q=Lg(h|0,G|0,i|0,q|0)|0;Z=Lg(q|0,G|0,u|0,Z|0)|0;N=Lg(Z|0,G|0,x|0,N|0)|0;x=G;Z=Lg(d|0,D|0,1048576,0)|0;u=G;q=Nf(Z|0,u|0,21)|0;i=G;z=Lg(k|0,l|0,z&2097151|0,0)|0;E=Lg(z|0,G|0,Y|0,E|0)|0;g=Lg(E|0,G|0,A|0,g|0)|0;T=Lg(g|0,G|0,U|0,T|0)|0;i=Lg(T|0,G|0,q|0,i|0)|0;q=G;u=Ig(d|0,D|0,Z&-2097152|0,u|0)|0;Z=G;D=Lg(p|0,O|0,1048576,0)|0;d=G;T=Nf(D|0,d|0,21)|0;T=Lg(C|0,c|0,T|0,G|0)|0;c=G;d=Ig(p|0,O|0,D&-2097152|0,d|0)|0;D=G;O=Lg(e|0,f|0,1048576,0)|0;p=G;C=Nf(O|0,p|0,21)|0;L=Lg(C|0,G|0,L&2097151|0,0)|0;C=G;p=Ig(e|0,f|0,O&-2097152|0,p|0)|0;O=G;f=Lg(J|0,n|0,1048576,0)|0;e=G;U=$f(f|0,e|0,21)|0;g=G;e=Ig(J|0,n|0,f&-2097152|0,e|0)|0;f=G;n=Lg(o|0,B|0,1048576,0)|0;J=G;A=Nf(n|0,J|0,21)|0;E=G;Y=Lg(N|0,x|0,1048576,0)|0;z=G;l=Nf(Y|0,z|0,21)|0;Z=Lg(l|0,G|0,u|0,Z|0)|0;u=G;z=Ig(N|0,x|0,Y&-2097152|0,z|0)|0;Y=G;x=Lg(i|0,q|0,1048576,0)|0;N=G;l=Nf(x|0,N|0,21)|0;D=Lg(l|0,G|0,d|0,D|0)|0;d=G;N=Ig(i|0,q|0,x&-2097152|0,N|0)|0;x=G;q=Lg(T|0,c|0,1048576,0)|0;i=G;l=Nf(q|0,i|0,21)|0;O=Lg(l|0,G|0,p|0,O|0)|0;p=G;i=Ig(T|0,c|0,q&-2097152|0,i|0)|0;q=G;c=Af(L|0,C|0,666643,0)|0;W=Lg(c|0,G|0,W&2097151|0,0)|0;c=G;T=Af(L|0,C|0,470296,0)|0;T=Lg(X|0,y|0,T|0,G|0)|0;y=G;X=Af(L|0,C|0,654183,0)|0;X=Lg(e|0,f|0,X|0,G|0)|0;f=G;e=Af(L|0,C|0,-997805,-1)|0;l=G;k=Af(L|0,C|0,136657,0)|0;h=G;C=Af(L|0,C|0,-683901,-1)|0;R=Lg(C|0,G|0,M|0,R|0)|0;E=Lg(R|0,G|0,A|0,E|0)|0;r=Ig(E|0,G|0,V&-2097152|0,r|0)|0;V=G;E=Af(O|0,p|0,666643,0)|0;Q=Lg(E|0,G|0,Q&2097151|0,0)|0;E=G;A=Af(O|0,p|0,470296,0)|0;A=Lg(W|0,c|0,A|0,G|0)|0;c=G;W=Af(O|0,p|0,654183,0)|0;W=Lg(T|0,y|0,W|0,G|0)|0;y=G;T=Af(O|0,p|0,-997805,-1)|0;T=Lg(X|0,f|0,T|0,G|0)|0;f=G;X=Af(O|0,p|0,136657,0)|0;R=G;p=Af(O|0,p|0,-683901,-1)|0;O=G;M=Af(i|0,q|0,666643,0)|0;m=Lg(M|0,G|0,m&2097151|0,0)|0;M=G;C=Af(i|0,q|0,470296,0)|0;C=Lg(Q|0,E|0,C|0,G|0)|0;E=G;Q=Af(i|0,q|0,654183,0)|0;Q=Lg(A|0,c|0,Q|0,G|0)|0;c=G;A=Af(i|0,q|0,-997805,-1)|0;A=Lg(W|0,y|0,A|0,G|0)|0;y=G;W=Af(i|0,q|0,136657,0)|0;W=Lg(T|0,f|0,W|0,G|0)|0;f=G;q=Af(i|0,q|0,-683901,-1)|0;i=G;j=Lg(U|0,g|0,w|0,j|0)|0;v=Ig(j|0,G|0,s&-2097152|0,v|0)|0;l=Lg(v|0,G|0,e|0,l|0)|0;R=Lg(l|0,G|0,X|0,R|0)|0;i=Lg(R|0,G|0,q|0,i|0)|0;q=G;R=Af(D|0,d|0,666643,0)|0;F=Lg(R|0,G|0,F&2097151|0,0)|0;R=G;X=Af(D|0,d|0,470296,0)|0;X=Lg(m|0,M|0,X|0,G|0)|0;M=G;m=Af(D|0,d|0,654183,0)|0;m=Lg(C|0,E|0,m|0,G|0)|0;E=G;C=Af(D|0,d|0,-997805,-1)|0;C=Lg(Q|0,c|0,C|0,G|0)|0;c=G;Q=Af(D|0,d|0,136657,0)|0;Q=Lg(A|0,y|0,Q|0,G|0)|0;y=G;d=Af(D|0,d|0,-683901,-1)|0;d=Lg(W|0,f|0,d|0,G|0)|0;f=G;W=Af(N|0,x|0,666643,0)|0;S=Lg(W|0,G|0,S&2097151|0,0)|0;W=G;D=Af(N|0,x|0,470296,0)|0;D=Lg(F|0,R|0,D|0,G|0)|0;R=G;F=Af(N|0,x|0,654183,0)|0;F=Lg(X|0,M|0,F|0,G|0)|0;M=G;X=Af(N|0,x|0,-997805,-1)|0;X=Lg(m|0,E|0,X|0,G|0)|0;E=G;m=Af(N|0,x|0,136657,0)|0;m=Lg(C|0,c|0,m|0,G|0)|0;c=G;x=Af(N|0,x|0,-683901,-1)|0;x=Lg(Q|0,y|0,x|0,G|0)|0;y=G;Q=Af(Z|0,u|0,666643,0)|0;P=Lg(Q|0,G|0,P&2097151|0,0)|0;Q=G;N=Af(Z|0,u|0,470296,0)|0;N=Lg(S|0,W|0,N|0,G|0)|0;W=G;S=Af(Z|0,u|0,654183,0)|0;S=Lg(D|0,R|0,S|0,G|0)|0;R=G;D=Af(Z|0,u|0,-997805,-1)|0;D=Lg(F|0,M|0,D|0,G|0)|0;M=G;F=Af(Z|0,u|0,136657,0)|0;F=Lg(X|0,E|0,F|0,G|0)|0;E=G;u=Af(Z|0,u|0,-683901,-1)|0;u=Lg(m|0,c|0,u|0,G|0)|0;c=G;m=Lg(P|0,Q|0,1048576,0)|0;Z=G;X=Nf(m|0,Z|0,21)|0;X=Lg(N|0,W|0,X|0,G|0)|0;W=G;Z=Ig(P|0,Q|0,m&-2097152|0,Z|0)|0;m=G;Q=Lg(S|0,R|0,1048576,0)|0;P=G;N=Nf(Q|0,P|0,21)|0;N=Lg(D|0,M|0,N|0,G|0)|0;M=G;D=Lg(F|0,E|0,1048576,0)|0;C=G;A=Nf(D|0,C|0,21)|0;A=Lg(u|0,c|0,A|0,G|0)|0;c=G;u=Lg(x|0,y|0,1048576,0)|0;l=G;e=Nf(u|0,l|0,21)|0;e=Lg(d|0,f|0,e|0,G|0)|0;f=G;l=Ig(x|0,y|0,u&-2097152|0,l|0)|0;u=G;y=Lg(i|0,q|0,1048576,0)|0;x=G;d=Nf(y|0,x|0,21)|0;v=G;B=Lg(k|0,h|0,o|0,B|0)|0;J=Ig(B|0,G|0,n&-2097152|0,J|0)|0;O=Lg(J|0,G|0,p|0,O|0)|0;v=Lg(O|0,G|0,d|0,v|0)|0;d=G;x=Ig(i|0,q|0,y&-2097152|0,x|0)|0;y=G;q=Lg(r|0,V|0,1048576,0)|0;i=G;O=Nf(q|0,i|0,21)|0;Y=Lg(O|0,G|0,z|0,Y|0)|0;z=G;i=Ig(r|0,V|0,q&-2097152|0,i|0)|0;q=G;V=Lg(X|0,W|0,1048576,0)|0;r=G;O=Nf(V|0,r|0,21)|0;p=G;J=Lg(N|0,M|0,1048576,0)|0;n=G;B=Nf(J|0,n|0,21)|0;o=G;h=Lg(A|0,c|0,1048576,0)|0;k=G;s=Nf(h|0,k|0,21)|0;s=Lg(l|0,u|0,s|0,G|0)|0;u=G;l=Lg(e|0,f|0,1048576,0)|0;j=G;w=Nf(l|0,j|0,21)|0;w=Lg(x|0,y|0,w|0,G|0)|0;y=G;j=Ig(e|0,f|0,l&-2097152|0,j|0)|0;l=G;f=Lg(v|0,d|0,1048576,0)|0;e=G;x=Nf(f|0,e|0,21)|0;x=Lg(i|0,q|0,x|0,G|0)|0;q=G;e=Ig(v|0,d|0,f&-2097152|0,e|0)|0;f=G;d=Lg(Y|0,z|0,1048576,0)|0;v=G;i=Nf(d|0,v|0,21)|0;g=G;v=Ig(Y|0,z|0,d&-2097152|0,v|0)|0;d=G;z=Af(i|0,g|0,666643,0)|0;z=Lg(Z|0,m|0,z|0,G|0)|0;m=G;Z=Af(i|0,g|0,470296,0)|0;Y=G;U=Af(i|0,g|0,654183,0)|0;T=G;L=Af(i|0,g|0,-997805,-1)|0;K=G;I=Af(i|0,g|0,136657,0)|0;H=G;g=Af(i|0,g|0,-683901,-1)|0;i=G;m=Nf(z|0,m|0,21)|0;t=G;W=Lg(Z|0,Y|0,X|0,W|0)|0;r=Ig(W|0,G|0,V&-2097152|0,r|0)|0;t=Lg(r|0,G|0,m|0,t|0)|0;m=Nf(t|0,G|0,21)|0;r=G;R=Lg(U|0,T|0,S|0,R|0)|0;P=Ig(R|0,G|0,Q&-2097152|0,P|0)|0;p=Lg(P|0,G|0,O|0,p|0)|0;r=Lg(p|0,G|0,m|0,r|0)|0;m=Nf(r|0,G|0,21)|0;p=G;K=Lg(N|0,M|0,L|0,K|0)|0;n=Ig(K|0,G|0,J&-2097152|0,n|0)|0;p=Lg(n|0,G|0,m|0,p|0)|0;m=Nf(p|0,G|0,21)|0;n=G;E=Lg(I|0,H|0,F|0,E|0)|0;C=Ig(E|0,G|0,D&-2097152|0,C|0)|0;o=Lg(C|0,G|0,B|0,o|0)|0;n=Lg(o|0,G|0,m|0,n|0)|0;m=Nf(n|0,G|0,21)|0;o=G;i=Lg(A|0,c|0,g|0,i|0)|0;k=Ig(i|0,G|0,h&-2097152|0,k|0)|0;o=Lg(k|0,G|0,m|0,o|0)|0;m=Nf(o|0,G|0,21)|0;m=Lg(s|0,u|0,m|0,G|0)|0;u=Nf(m|0,G|0,21)|0;l=Lg(u|0,G|0,j|0,l|0)|0;j=Nf(l|0,G|0,21)|0;j=Lg(w|0,y|0,j|0,G|0)|0;y=Nf(j|0,G|0,21)|0;f=Lg(y|0,G|0,e|0,f|0)|0;e=Nf(f|0,G|0,21)|0;e=Lg(x|0,q|0,e|0,G|0)|0;q=Nf(e|0,G|0,21)|0;d=Lg(q|0,G|0,v|0,d|0)|0;v=Nf(d|0,G|0,21)|0;q=G;x=Af(v|0,q|0,666643,0)|0;z=Lg(x|0,G|0,z&2097151|0,0)|0;x=G;y=Af(v|0,q|0,470296,0)|0;t=Lg(y|0,G|0,t&2097151|0,0)|0;y=G;w=Af(v|0,q|0,654183,0)|0;r=Lg(w|0,G|0,r&2097151|0,0)|0;w=G;u=Af(v|0,q|0,-997805,-1)|0;p=Lg(u|0,G|0,p&2097151|0,0)|0;u=G;s=Af(v|0,q|0,136657,0)|0;n=Lg(s|0,G|0,n&2097151|0,0)|0;s=G;q=Af(v|0,q|0,-683901,-1)|0;o=Lg(q|0,G|0,o&2097151|0,0)|0;q=G;v=Nf(z|0,x|0,21)|0;v=Lg(t|0,y|0,v|0,G|0)|0;y=G;t=Nf(v|0,y|0,21)|0;t=Lg(r|0,w|0,t|0,G|0)|0;w=G;r=Nf(t|0,w|0,21)|0;r=Lg(p|0,u|0,r|0,G|0)|0;u=G;p=Nf(r|0,u|0,21)|0;p=Lg(n|0,s|0,p|0,G|0)|0;s=G;n=Nf(p|0,s|0,21)|0;n=Lg(o|0,q|0,n|0,G|0)|0;q=G;o=Nf(n|0,q|0,21)|0;m=Lg(o|0,G|0,m&2097151|0,0)|0;o=G;k=Nf(m|0,o|0,21)|0;l=Lg(k|0,G|0,l&2097151|0,0)|0;k=G;h=Nf(l|0,k|0,21)|0;j=Lg(h|0,G|0,j&2097151|0,0)|0;h=G;i=Nf(j|0,h|0,21)|0;f=Lg(i|0,G|0,f&2097151|0,0)|0;i=G;g=Nf(f|0,i|0,21)|0;e=Lg(g|0,G|0,e&2097151|0,0)|0;g=G;c=Nf(e|0,g|0,21)|0;d=Lg(c|0,G|0,d&2097151|0,0)|0;c=G;b[a>>0]=z;A=$f(z|0,x|0,8)|0;b[a+1>>0]=A;x=$f(z|0,x|0,16)|0;z=Wf(v&2097151|0,0,5)|0;b[a+2>>0]=z|x&31;x=$f(v|0,y|0,3)|0;b[a+3>>0]=x;y=$f(v|0,y|0,11)|0;b[a+4>>0]=y;v=$f(v&2097151|0,0,19)|0;y=G;x=Wf(t&2097151|0,0,2)|0;b[a+5>>0]=x|v;w=$f(t|0,w|0,6)|0;b[a+6>>0]=w;t=$f(t&2097151|0,0,14)|0;w=G;v=Wf(r&2097151|0,0,7)|0;b[a+7>>0]=v|t;t=$f(r|0,u|0,1)|0;b[a+8>>0]=t;u=$f(r|0,u|0,9)|0;b[a+9>>0]=u;r=$f(r&2097151|0,0,17)|0;u=G;t=Wf(p&2097151|0,0,4)|0;b[a+10>>0]=t|r;r=$f(p|0,s|0,4)|0;b[a+11>>0]=r;s=$f(p|0,s|0,12)|0;b[a+12>>0]=s;p=$f(p&2097151|0,0,20)|0;s=G;r=Wf(n&2097151|0,0,1)|0;b[a+13>>0]=r|p;q=$f(n|0,q|0,7)|0;b[a+14>>0]=q;n=$f(n&2097151|0,0,15)|0;q=G;p=Wf(m&2097151|0,0,6)|0;b[a+15>>0]=p|n;n=$f(m|0,o|0,2)|0;b[a+16>>0]=n;o=$f(m|0,o|0,10)|0;b[a+17>>0]=o;m=$f(m&2097151|0,0,18)|0;o=G;n=Wf(l|0,k|0,3)|0;b[a+18>>0]=n|m;m=$f(l|0,k|0,5)|0;b[a+19>>0]=m;k=$f(l|0,k|0,13)|0;b[a+20>>0]=k;b[a+21>>0]=j;k=$f(j|0,h|0,8)|0;b[a+22>>0]=k;h=$f(j|0,h|0,16)|0;j=Wf(f&2097151|0,0,5)|0;b[a+23>>0]=j|h&31;h=$f(f|0,i|0,3)|0;b[a+24>>0]=h;i=$f(f|0,i|0,11)|0;b[a+25>>0]=i;f=$f(f&2097151|0,0,19)|0;i=G;h=Wf(e&2097151|0,0,2)|0;b[a+26>>0]=h|f;g=$f(e|0,g|0,6)|0;b[a+27>>0]=g;e=$f(e&2097151|0,0,14)|0;g=G;f=Wf(d|0,c|0,7)|0;b[a+28>>0]=f|e;e=$f(d|0,c|0,1)|0;b[a+29>>0]=e;e=$f(d|0,c|0,9)|0;b[a+30>>0]=e;c=Nf(d|0,c|0,17)|0;b[a+31>>0]=c;return}function pa(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0,oa=0,pa=0,qa=0,ra=0,sa=0,ta=0,ua=0,va=0,wa=0,xa=0,ya=0,za=0,Aa=0,Ba=0,Ca=0,Da=0,Ea=0,Fa=0,Ga=0,Ha=0,Ia=0,Ja=0,Ka=0,La=0,Ma=0,Na=0,Oa=0,Pa=0,Qa=0,Ra=0,Sa=0,Ta=0,Ua=0,Va=0,Wa=0,Xa=0,Ya=0,Za=0,_a=0,$a=0,ab=0,bb=0,cb=0,db=0,eb=0,fb=0,gb=0,hb=0,ib=0,jb=0,kb=0,lb=0,mb=0,nb=0,ob=0,pb=0,qb=0,rb=0,sb=0,tb=0,ub=0,vb=0,wb=0,xb=0,yb=0,zb=0,Ab=0,Bb=0,Cb=0,Db=0,Eb=0,Fb=0,Gb=0,Hb=0,Ib=0,Jb=0,Kb=0,Lb=0,Mb=0,Nb=0,Ob=0,Pb=0,Qb=0,Rb=0,Sb=0,Tb=0,Ub=0,Vb=0,Wb=0,Xb=0,Yb=0,Zb=0,_b=0,$b=0,ac=0,bc=0,cc=0,dc=0,ec=0,fc=0,gc=0,hc=0,ic=0,jc=0,kc=0,lc=0,mc=0,nc=0,oc=0,pc=0,qc=0,rc=0,sc=0,tc=0,uc=0,vc=0,wc=0,xc=0,yc=0,zc=0,Ac=0,Bc=0,Cc=0,Dc=0,Ec=0,Fc=0,Gc=0,Hc=0,Ic=0,Jc=0,Kc=0,Lc=0,Mc=0,Nc=0,Oc=0,Pc=0;s=f[b>>2]|0;l=f[b+4>>2]|0;j=f[b+8>>2]|0;q=f[b+12>>2]|0;za=f[b+16>>2]|0;p=f[b+20>>2]|0;Ab=f[b+24>>2]|0;d=f[b+28>>2]|0;ga=f[b+32>>2]|0;O=f[b+36>>2]|0;J=f[c>>2]|0;Oc=f[c+4>>2]|0;ec=f[c+8>>2]|0;tb=f[c+12>>2]|0;Ja=f[c+16>>2]|0;jc=f[c+20>>2]|0;Fb=f[c+24>>2]|0;Ua=f[c+28>>2]|0;ha=f[c+32>>2]|0;Pc=f[c+36>>2]|0;Mc=Af(J|0,((J|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;Lc=G;wc=Af(Oc|0,((Oc|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;vc=G;vb=Af(ec|0,((ec|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;ub=G;La=Af(tb|0,((tb|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;Ka=G;mc=Af(Ja|0,((Ja|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;lc=G;Ib=Af(jc|0,((jc|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;Hb=G;Xa=Af(Fb|0,((Fb|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;Wa=G;ka=Af(Ua|0,((Ua|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;ja=G;Q=Af(ha|0,((ha|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;P=G;s=Af(Pc|0,((Pc|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;r=G;fc=Af(J|0,((J|0)<0)<<31>>31|0,l|0,((l|0)<0)<<31>>31|0)|0;gc=G;zb=Af(Oc|0,((Oc|0)<0)<<31>>31|0,l<<1|0,((l<<1|0)<0)<<31>>31|0)|0;yb=G;Na=Af(ec|0,((ec|0)<0)<<31>>31|0,l|0,((l|0)<0)<<31>>31|0)|0;Ma=G;oc=Af(tb|0,((tb|0)<0)<<31>>31|0,l<<1|0,((l<<1|0)<0)<<31>>31|0)|0;nc=G;Kb=Af(Ja|0,((Ja|0)<0)<<31>>31|0,l|0,((l|0)<0)<<31>>31|0)|0;Jb=G;Za=Af(jc|0,((jc|0)<0)<<31>>31|0,l<<1|0,((l<<1|0)<0)<<31>>31|0)|0;Ya=G;ma=Af(Fb|0,((Fb|0)<0)<<31>>31|0,l|0,((l|0)<0)<<31>>31|0)|0;la=G;S=Af(Ua|0,((Ua|0)<0)<<31>>31|0,l<<1|0,((l<<1|0)<0)<<31>>31|0)|0;R=G;u=Af(ha|0,((ha|0)<0)<<31>>31|0,l|0,((l|0)<0)<<31>>31|0)|0;t=G;N=((Pc*19|0)<0)<<31>>31;l=Af(Pc*19|0,N|0,l<<1|0,((l<<1|0)<0)<<31>>31|0)|0;b=G;xb=Af(J|0,((J|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;wb=G;Ra=Af(Oc|0,((Oc|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;Qa=G;qc=Af(ec|0,((ec|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;pc=G;Mb=Af(tb|0,((tb|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;Lb=G;$a=Af(Ja|0,((Ja|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;_a=G;oa=Af(jc|0,((jc|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;na=G;U=Af(Fb|0,((Fb|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;T=G;w=Af(Ua|0,((Ua|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;v=G;ia=((ha*19|0)<0)<<31>>31;yc=Af(ha*19|0,ia|0,j|0,((j|0)<0)<<31>>31|0)|0;xc=G;j=Af(Pc*19|0,N|0,j|0,((j|0)<0)<<31>>31|0)|0;k=G;Pa=Af(J|0,((J|0)<0)<<31>>31|0,q|0,((q|0)<0)<<31>>31|0)|0;Oa=G;uc=Af(Oc|0,((Oc|0)<0)<<31>>31|0,q<<1|0,((q<<1|0)<0)<<31>>31|0)|0;tc=G;Ob=Af(ec|0,((ec|0)<0)<<31>>31|0,q|0,((q|0)<0)<<31>>31|0)|0;Nb=G;bb=Af(tb|0,((tb|0)<0)<<31>>31|0,q<<1|0,((q<<1|0)<0)<<31>>31|0)|0;ab=G;qa=Af(Ja|0,((Ja|0)<0)<<31>>31|0,q|0,((q|0)<0)<<31>>31|0)|0;pa=G;W=Af(jc|0,((jc|0)<0)<<31>>31|0,q<<1|0,((q<<1|0)<0)<<31>>31|0)|0;V=G;y=Af(Fb|0,((Fb|0)<0)<<31>>31|0,q|0,((q|0)<0)<<31>>31|0)|0;x=G;Va=((Ua*19|0)<0)<<31>>31;Ac=Af(Ua*19|0,Va|0,q<<1|0,((q<<1|0)<0)<<31>>31|0)|0;zc=G;Ub=Af(ha*19|0,ia|0,q|0,((q|0)<0)<<31>>31|0)|0;Tb=G;q=Af(Pc*19|0,N|0,q<<1|0,((q<<1|0)<0)<<31>>31|0)|0;i=G;sc=Af(J|0,((J|0)<0)<<31>>31|0,za|0,((za|0)<0)<<31>>31|0)|0;rc=G;Sb=Af(Oc|0,((Oc|0)<0)<<31>>31|0,za|0,((za|0)<0)<<31>>31|0)|0;Rb=G;db=Af(ec|0,((ec|0)<0)<<31>>31|0,za|0,((za|0)<0)<<31>>31|0)|0;cb=G;sa=Af(tb|0,((tb|0)<0)<<31>>31|0,za|0,((za|0)<0)<<31>>31|0)|0;ra=G;Y=Af(Ja|0,((Ja|0)<0)<<31>>31|0,za|0,((za|0)<0)<<31>>31|0)|0;X=G;A=Af(jc|0,((jc|0)<0)<<31>>31|0,za|0,((za|0)<0)<<31>>31|0)|0;z=G;Gb=((Fb*19|0)<0)<<31>>31;Cc=Af(Fb*19|0,Gb|0,za|0,((za|0)<0)<<31>>31|0)|0;Bc=G;Wb=Af(Ua*19|0,Va|0,za|0,((za|0)<0)<<31>>31|0)|0;Vb=G;jb=Af(ha*19|0,ia|0,za|0,((za|0)<0)<<31>>31|0)|0;ib=G;za=Af(Pc*19|0,N|0,za|0,((za|0)<0)<<31>>31|0)|0;g=G;Qb=Af(J|0,((J|0)<0)<<31>>31|0,p|0,((p|0)<0)<<31>>31|0)|0;Pb=G;hb=Af(Oc|0,((Oc|0)<0)<<31>>31|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;gb=G;ua=Af(ec|0,((ec|0)<0)<<31>>31|0,p|0,((p|0)<0)<<31>>31|0)|0;ta=G;_=Af(tb|0,((tb|0)<0)<<31>>31|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;Z=G;C=Af(Ja|0,((Ja|0)<0)<<31>>31|0,p|0,((p|0)<0)<<31>>31|0)|0;B=G;kc=((jc*19|0)<0)<<31>>31;Ec=Af(jc*19|0,kc|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;Dc=G;Yb=Af(Fb*19|0,Gb|0,p|0,((p|0)<0)<<31>>31|0)|0;Xb=G;lb=Af(Ua*19|0,Va|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;kb=G;Ba=Af(ha*19|0,ia|0,p|0,((p|0)<0)<<31>>31|0)|0;Aa=G;p=Af(Pc*19|0,N|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;e=G;fb=Af(J|0,((J|0)<0)<<31>>31|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;eb=G;ya=Af(Oc|0,((Oc|0)<0)<<31>>31|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;xa=G;aa=Af(ec|0,((ec|0)<0)<<31>>31|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;$=G;E=Af(tb|0,((tb|0)<0)<<31>>31|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;D=G;Gc=Af(Ja*19|0,((Ja*19|0)<0)<<31>>31|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;Fc=G;_b=Af(jc*19|0,kc|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;Zb=G;nb=Af(Fb*19|0,Gb|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;mb=G;Da=Af(Ua*19|0,Va|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;Ca=G;m=Af(ha*19|0,ia|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;n=G;Ab=Af(Pc*19|0,N|0,Ab|0,((Ab|0)<0)<<31>>31|0)|0;h=G;wa=Af(J|0,((J|0)<0)<<31>>31|0,d|0,((d|0)<0)<<31>>31|0)|0;va=G;ea=Af(Oc|0,((Oc|0)<0)<<31>>31|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;da=G;H=Af(ec|0,((ec|0)<0)<<31>>31|0,d|0,((d|0)<0)<<31>>31|0)|0;F=G;Ic=Af(tb*19|0,((tb*19|0)<0)<<31>>31|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;Hc=G;ac=Af(Ja*19|0,((Ja*19|0)<0)<<31>>31|0,d|0,((d|0)<0)<<31>>31|0)|0;$b=G;pb=Af(jc*19|0,kc|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;ob=G;Fa=Af(Fb*19|0,Gb|0,d|0,((d|0)<0)<<31>>31|0)|0;Ea=G;M=Af(Ua*19|0,Va|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;o=G;Cb=Af(ha*19|0,ia|0,d|0,((d|0)<0)<<31>>31|0)|0;Bb=G;c=Af(Pc*19|0,N|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;d=G;ca=Af(J|0,((J|0)<0)<<31>>31|0,ga|0,((ga|0)<0)<<31>>31|0)|0;ba=G;L=Af(Oc|0,((Oc|0)<0)<<31>>31|0,ga|0,((ga|0)<0)<<31>>31|0)|0;K=G;Kc=Af(ec*19|0,((ec*19|0)<0)<<31>>31|0,ga|0,((ga|0)<0)<<31>>31|0)|0;Jc=G;cc=Af(tb*19|0,((tb*19|0)<0)<<31>>31|0,ga|0,((ga|0)<0)<<31>>31|0)|0;bc=G;rb=Af(Ja*19|0,((Ja*19|0)<0)<<31>>31|0,ga|0,((ga|0)<0)<<31>>31|0)|0;qb=G;Ha=Af(jc*19|0,kc|0,ga|0,((ga|0)<0)<<31>>31|0)|0;Ga=G;ic=Af(Fb*19|0,Gb|0,ga|0,((ga|0)<0)<<31>>31|0)|0;hc=G;Eb=Af(Ua*19|0,Va|0,ga|0,((ga|0)<0)<<31>>31|0)|0;Db=G;Ta=Af(ha*19|0,ia|0,ga|0,((ga|0)<0)<<31>>31|0)|0;Sa=G;ga=Af(Pc*19|0,N|0,ga|0,((ga|0)<0)<<31>>31|0)|0;fa=G;J=Af(J|0,((J|0)<0)<<31>>31|0,O|0,((O|0)<0)<<31>>31|0)|0;I=G;Oc=Af(Oc*19|0,((Oc*19|0)<0)<<31>>31|0,O<<1|0,((O<<1|0)<0)<<31>>31|0)|0;Nc=G;ec=Af(ec*19|0,((ec*19|0)<0)<<31>>31|0,O|0,((O|0)<0)<<31>>31|0)|0;dc=G;tb=Af(tb*19|0,((tb*19|0)<0)<<31>>31|0,O<<1|0,((O<<1|0)<0)<<31>>31|0)|0;sb=G;Ja=Af(Ja*19|0,((Ja*19|0)<0)<<31>>31|0,O|0,((O|0)<0)<<31>>31|0)|0;Ia=G;kc=Af(jc*19|0,kc|0,O<<1|0,((O<<1|0)<0)<<31>>31|0)|0;jc=G;Gb=Af(Fb*19|0,Gb|0,O|0,((O|0)<0)<<31>>31|0)|0;Fb=G;Va=Af(Ua*19|0,Va|0,O<<1|0,((O<<1|0)<0)<<31>>31|0)|0;Ua=G;ia=Af(ha*19|0,ia|0,O|0,((O|0)<0)<<31>>31|0)|0;ha=G;O=Af(Pc*19|0,N|0,O<<1|0,((O<<1|0)<0)<<31>>31|0)|0;N=G;Lc=Lg(Oc|0,Nc|0,Mc|0,Lc|0)|0;Jc=Lg(Lc|0,G|0,Kc|0,Jc|0)|0;Hc=Lg(Jc|0,G|0,Ic|0,Hc|0)|0;Fc=Lg(Hc|0,G|0,Gc|0,Fc|0)|0;Dc=Lg(Fc|0,G|0,Ec|0,Dc|0)|0;Bc=Lg(Dc|0,G|0,Cc|0,Bc|0)|0;zc=Lg(Bc|0,G|0,Ac|0,zc|0)|0;xc=Lg(zc|0,G|0,yc|0,xc|0)|0;b=Lg(xc|0,G|0,l|0,b|0)|0;l=G;gc=Lg(wc|0,vc|0,fc|0,gc|0)|0;fc=G;rc=Lg(uc|0,tc|0,sc|0,rc|0)|0;pc=Lg(rc|0,G|0,qc|0,pc|0)|0;nc=Lg(pc|0,G|0,oc|0,nc|0)|0;lc=Lg(nc|0,G|0,mc|0,lc|0)|0;jc=Lg(lc|0,G|0,kc|0,jc|0)|0;hc=Lg(jc|0,G|0,ic|0,hc|0)|0;o=Lg(hc|0,G|0,M|0,o|0)|0;n=Lg(o|0,G|0,m|0,n|0)|0;e=Lg(n|0,G|0,p|0,e|0)|0;p=G;n=Lg(b|0,l|0,33554432,0)|0;m=G;o=Nf(n|0,m|0,26)|0;M=G;dc=Lg(gc|0,fc|0,ec|0,dc|0)|0;bc=Lg(dc|0,G|0,cc|0,bc|0)|0;$b=Lg(bc|0,G|0,ac|0,$b|0)|0;Zb=Lg($b|0,G|0,_b|0,Zb|0)|0;Xb=Lg(Zb|0,G|0,Yb|0,Xb|0)|0;Vb=Lg(Xb|0,G|0,Wb|0,Vb|0)|0;Tb=Lg(Vb|0,G|0,Ub|0,Tb|0)|0;k=Lg(Tb|0,G|0,j|0,k|0)|0;M=Lg(k|0,G|0,o|0,M|0)|0;o=G;m=Ig(b|0,l|0,n&-67108864|0,m|0)|0;n=G;l=Lg(e|0,p|0,33554432,0)|0;b=G;k=Nf(l|0,b|0,26)|0;j=G;Pb=Lg(Sb|0,Rb|0,Qb|0,Pb|0)|0;Nb=Lg(Pb|0,G|0,Ob|0,Nb|0)|0;Lb=Lg(Nb|0,G|0,Mb|0,Lb|0)|0;Jb=Lg(Lb|0,G|0,Kb|0,Jb|0)|0;Hb=Lg(Jb|0,G|0,Ib|0,Hb|0)|0;Fb=Lg(Hb|0,G|0,Gb|0,Fb|0)|0;Db=Lg(Fb|0,G|0,Eb|0,Db|0)|0;Bb=Lg(Db|0,G|0,Cb|0,Bb|0)|0;h=Lg(Bb|0,G|0,Ab|0,h|0)|0;j=Lg(h|0,G|0,k|0,j|0)|0;k=G;b=Ig(e|0,p|0,l&-67108864|0,b|0)|0;l=G;p=Lg(M|0,o|0,16777216,0)|0;e=Nf(p|0,G|0,25)|0;h=G;wb=Lg(zb|0,yb|0,xb|0,wb|0)|0;ub=Lg(wb|0,G|0,vb|0,ub|0)|0;sb=Lg(ub|0,G|0,tb|0,sb|0)|0;qb=Lg(sb|0,G|0,rb|0,qb|0)|0;ob=Lg(qb|0,G|0,pb|0,ob|0)|0;mb=Lg(ob|0,G|0,nb|0,mb|0)|0;kb=Lg(mb|0,G|0,lb|0,kb|0)|0;ib=Lg(kb|0,G|0,jb|0,ib|0)|0;i=Lg(ib|0,G|0,q|0,i|0)|0;h=Lg(i|0,G|0,e|0,h|0)|0;e=G;p=Ig(M|0,o|0,p&-33554432|0,0)|0;o=G;M=Lg(j|0,k|0,16777216,0)|0;i=Nf(M|0,G|0,25)|0;q=G;eb=Lg(hb|0,gb|0,fb|0,eb|0)|0;cb=Lg(eb|0,G|0,db|0,cb|0)|0;ab=Lg(cb|0,G|0,bb|0,ab|0)|0;_a=Lg(ab|0,G|0,$a|0,_a|0)|0;Ya=Lg(_a|0,G|0,Za|0,Ya|0)|0;Wa=Lg(Ya|0,G|0,Xa|0,Wa|0)|0;Ua=Lg(Wa|0,G|0,Va|0,Ua|0)|0;Sa=Lg(Ua|0,G|0,Ta|0,Sa|0)|0;d=Lg(Sa|0,G|0,c|0,d|0)|0;q=Lg(d|0,G|0,i|0,q|0)|0;i=G;M=Ig(j|0,k|0,M&-33554432|0,0)|0;k=G;j=Lg(h|0,e|0,33554432,0)|0;d=Nf(j|0,G|0,26)|0;c=G;Oa=Lg(Ra|0,Qa|0,Pa|0,Oa|0)|0;Ma=Lg(Oa|0,G|0,Na|0,Ma|0)|0;Ka=Lg(Ma|0,G|0,La|0,Ka|0)|0;Ia=Lg(Ka|0,G|0,Ja|0,Ia|0)|0;Ga=Lg(Ia|0,G|0,Ha|0,Ga|0)|0;Ea=Lg(Ga|0,G|0,Fa|0,Ea|0)|0;Ca=Lg(Ea|0,G|0,Da|0,Ca|0)|0;Aa=Lg(Ca|0,G|0,Ba|0,Aa|0)|0;g=Lg(Aa|0,G|0,za|0,g|0)|0;c=Lg(g|0,G|0,d|0,c|0)|0;d=G;j=Ig(h|0,e|0,j&-67108864|0,0)|0;e=Lg(q|0,i|0,33554432,0)|0;h=Nf(e|0,G|0,26)|0;g=G;va=Lg(ya|0,xa|0,wa|0,va|0)|0;ta=Lg(va|0,G|0,ua|0,ta|0)|0;ra=Lg(ta|0,G|0,sa|0,ra|0)|0;pa=Lg(ra|0,G|0,qa|0,pa|0)|0;na=Lg(pa|0,G|0,oa|0,na|0)|0;la=Lg(na|0,G|0,ma|0,la|0)|0;ja=Lg(la|0,G|0,ka|0,ja|0)|0;ha=Lg(ja|0,G|0,ia|0,ha|0)|0;fa=Lg(ha|0,G|0,ga|0,fa|0)|0;g=Lg(fa|0,G|0,h|0,g|0)|0;h=G;e=Ig(q|0,i|0,e&-67108864|0,0)|0;i=Lg(c|0,d|0,16777216,0)|0;q=Nf(i|0,G|0,25)|0;l=Lg(q|0,G|0,b|0,l|0)|0;b=G;i=Ig(c|0,d|0,i&-33554432|0,0)|0;d=Lg(g|0,h|0,16777216,0)|0;c=Nf(d|0,G|0,25)|0;q=G;ba=Lg(ea|0,da|0,ca|0,ba|0)|0;$=Lg(ba|0,G|0,aa|0,$|0)|0;Z=Lg($|0,G|0,_|0,Z|0)|0;X=Lg(Z|0,G|0,Y|0,X|0)|0;V=Lg(X|0,G|0,W|0,V|0)|0;T=Lg(V|0,G|0,U|0,T|0)|0;R=Lg(T|0,G|0,S|0,R|0)|0;P=Lg(R|0,G|0,Q|0,P|0)|0;N=Lg(P|0,G|0,O|0,N|0)|0;q=Lg(N|0,G|0,c|0,q|0)|0;c=G;d=Ig(g|0,h|0,d&-33554432|0,0)|0;h=Lg(l|0,b|0,33554432,0)|0;g=$f(h|0,G|0,26)|0;g=Lg(M|0,k|0,g|0,G|0)|0;h=Ig(l|0,b|0,h&-67108864|0,0)|0;b=Lg(q|0,c|0,33554432,0)|0;l=Nf(b|0,G|0,26)|0;k=G;I=Lg(L|0,K|0,J|0,I|0)|0;F=Lg(I|0,G|0,H|0,F|0)|0;D=Lg(F|0,G|0,E|0,D|0)|0;B=Lg(D|0,G|0,C|0,B|0)|0;z=Lg(B|0,G|0,A|0,z|0)|0;x=Lg(z|0,G|0,y|0,x|0)|0;v=Lg(x|0,G|0,w|0,v|0)|0;t=Lg(v|0,G|0,u|0,t|0)|0;r=Lg(t|0,G|0,s|0,r|0)|0;k=Lg(r|0,G|0,l|0,k|0)|0;l=G;b=Ig(q|0,c|0,b&-67108864|0,0)|0;c=Lg(k|0,l|0,16777216,0)|0;q=Nf(c|0,G|0,25)|0;q=Af(q|0,G|0,19,0)|0;n=Lg(q|0,G|0,m|0,n|0)|0;m=G;c=Ig(k|0,l|0,c&-33554432|0,0)|0;l=Lg(n|0,m|0,33554432,0)|0;k=$f(l|0,G|0,26)|0;k=Lg(p|0,o|0,k|0,G|0)|0;l=Ig(n|0,m|0,l&-67108864|0,0)|0;f[a>>2]=l;f[a+4>>2]=k;f[a+8>>2]=j;f[a+12>>2]=i;f[a+16>>2]=h;f[a+20>>2]=g;f[a+24>>2]=e;f[a+28>>2]=d;f[a+32>>2]=b;f[a+36>>2]=c;return}function qa(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0;d=t;e=t=t+63&-64;t=t+2048|0;li(e+1024|0,b);Ae(e+1024|0,a);li(e,e+1024|0);Ae(e,c);a=0;do{b=a<<4;g=f[e+1024+((b|4)<<3)>>2]|0;i=f[e+1024+((b|4)<<3)+4>>2]|0;J=Ge(f[e+1024+(b<<3)>>2]|0,f[e+1024+(b<<3)+4>>2]|0,g,i)|0;N=G;D=xf(f[e+1024+((b|12)<<3)>>2]^J,f[e+1024+((b|12)<<3)+4>>2]^N,32)|0;y=G;u=Ge(f[e+1024+((b|8)<<3)>>2]|0,f[e+1024+((b|8)<<3)+4>>2]|0,D,y)|0;s=G;i=xf(u^g,s^i,24)|0;g=G;N=Ge(J,N,i,g)|0;J=G;y=xf(N^D,J^y,16)|0;D=G;f[e+1024+((b|12)<<3)>>2]=y;f[e+1024+((b|12)<<3)+4>>2]=D;s=Ge(u,s,y,D)|0;u=G;f[e+1024+((b|8)<<3)>>2]=s;f[e+1024+((b|8)<<3)+4>>2]=u;g=xf(s^i,u^g,63)|0;i=G;f[e+1024+((b|4)<<3)>>2]=g;f[e+1024+((b|4)<<3)+4>>2]=i;F=f[e+1024+((b|5)<<3)>>2]|0;I=f[e+1024+((b|5)<<3)+4>>2]|0;A=Ge(f[e+1024+((b|1)<<3)>>2]|0,f[e+1024+((b|1)<<3)+4>>2]|0,F,I)|0;E=G;v=xf(f[e+1024+((b|13)<<3)>>2]^A,f[e+1024+((b|13)<<3)+4>>2]^E,32)|0;p=G;l=Ge(f[e+1024+((b|9)<<3)>>2]|0,f[e+1024+((b|9)<<3)+4>>2]|0,v,p)|0;k=G;I=xf(l^F,k^I,24)|0;F=G;E=Ge(A,E,I,F)|0;A=G;p=xf(E^v,A^p,16)|0;v=G;k=Ge(l,k,p,v)|0;l=G;f[e+1024+((b|9)<<3)>>2]=k;f[e+1024+((b|9)<<3)+4>>2]=l;F=xf(k^I,l^F,63)|0;I=G;x=f[e+1024+((b|6)<<3)>>2]|0;z=f[e+1024+((b|6)<<3)+4>>2]|0;r=Ge(f[e+1024+((b|2)<<3)>>2]|0,f[e+1024+((b|2)<<3)+4>>2]|0,x,z)|0;w=G;m=xf(f[e+1024+((b|14)<<3)>>2]^r,f[e+1024+((b|14)<<3)+4>>2]^w,32)|0;h=G;L=Ge(f[e+1024+((b|10)<<3)>>2]|0,f[e+1024+((b|10)<<3)+4>>2]|0,m,h)|0;K=G;z=xf(L^x,K^z,24)|0;x=G;w=Ge(r,w,z,x)|0;r=G;h=xf(w^m,r^h,16)|0;m=G;K=Ge(L,K,h,m)|0;L=G;x=xf(K^z,L^x,63)|0;z=G;o=f[e+1024+((b|7)<<3)>>2]|0;q=f[e+1024+((b|7)<<3)+4>>2]|0;j=Ge(f[e+1024+((b|3)<<3)>>2]|0,f[e+1024+((b|3)<<3)+4>>2]|0,o,q)|0;n=G;M=xf(f[e+1024+((b|15)<<3)>>2]^j,f[e+1024+((b|15)<<3)+4>>2]^n,32)|0;H=G;C=Ge(f[e+1024+((b|11)<<3)>>2]|0,f[e+1024+((b|11)<<3)+4>>2]|0,M,H)|0;B=G;q=xf(C^o,B^q,24)|0;o=G;n=Ge(j,n,q,o)|0;j=G;H=xf(n^M,j^H,16)|0;M=G;B=Ge(C,B,H,M)|0;C=G;o=xf(B^q,C^o,63)|0;q=G;J=Ge(N,J,F,I)|0;N=G;M=xf(J^H,N^M,32)|0;H=G;L=Ge(K,L,M,H)|0;K=G;I=xf(L^F,K^I,24)|0;F=G;N=Ge(J,N,I,F)|0;J=G;f[e+1024+(b<<3)>>2]=N;f[e+1024+(b<<3)+4>>2]=J;H=xf(N^M,J^H,16)|0;J=G;f[e+1024+((b|15)<<3)>>2]=H;f[e+1024+((b|15)<<3)+4>>2]=J;J=Ge(L,K,H,J)|0;H=G;f[e+1024+((b|10)<<3)>>2]=J;f[e+1024+((b|10)<<3)+4>>2]=H;F=xf(J^I,H^F,63)|0;f[e+1024+((b|5)<<3)>>2]=F;f[e+1024+((b|5)<<3)+4>>2]=G;A=Ge(E,A,x,z)|0;E=G;D=xf(A^y,E^D,32)|0;y=G;C=Ge(B,C,D,y)|0;B=G;z=xf(C^x,B^z,24)|0;x=G;E=Ge(A,E,z,x)|0;A=G;f[e+1024+((b|1)<<3)>>2]=E;f[e+1024+((b|1)<<3)+4>>2]=A;y=xf(E^D,A^y,16)|0;A=G;f[e+1024+((b|12)<<3)>>2]=y;f[e+1024+((b|12)<<3)+4>>2]=A;A=Ge(C,B,y,A)|0;y=G;f[e+1024+((b|11)<<3)>>2]=A;f[e+1024+((b|11)<<3)+4>>2]=y;x=xf(A^z,y^x,63)|0;f[e+1024+((b|6)<<3)>>2]=x;f[e+1024+((b|6)<<3)+4>>2]=G;r=Ge(w,r,o,q)|0;w=G;v=xf(r^p,w^v,32)|0;p=G;u=Ge(s,u,v,p)|0;s=G;q=xf(u^o,s^q,24)|0;o=G;w=Ge(r,w,q,o)|0;r=G;f[e+1024+((b|2)<<3)>>2]=w;f[e+1024+((b|2)<<3)+4>>2]=r;p=xf(w^v,r^p,16)|0;r=G;f[e+1024+((b|13)<<3)>>2]=p;f[e+1024+((b|13)<<3)+4>>2]=r;r=Ge(u,s,p,r)|0;p=G;f[e+1024+((b|8)<<3)>>2]=r;f[e+1024+((b|8)<<3)+4>>2]=p;o=xf(r^q,p^o,63)|0;f[e+1024+((b|7)<<3)>>2]=o;f[e+1024+((b|7)<<3)+4>>2]=G;j=Ge(n,j,g,i)|0;n=G;m=xf(j^h,n^m,32)|0;h=G;l=Ge(k,l,m,h)|0;k=G;i=xf(l^g,k^i,24)|0;g=G;n=Ge(j,n,i,g)|0;j=G;f[e+1024+((b|3)<<3)>>2]=n;f[e+1024+((b|3)<<3)+4>>2]=j;h=xf(n^m,j^h,16)|0;j=G;f[e+1024+((b|14)<<3)>>2]=h;f[e+1024+((b|14)<<3)+4>>2]=j;j=Ge(l,k,h,j)|0;h=G;f[e+1024+((b|9)<<3)>>2]=j;f[e+1024+((b|9)<<3)+4>>2]=h;g=xf(j^i,h^g,63)|0;f[e+1024+((b|4)<<3)>>2]=g;f[e+1024+((b|4)<<3)+4>>2]=G;a=a+1|0}while((a|0)!=8);a=0;do{N=a<<1;K=e+1024+(N+32<<3)|0;M=f[K>>2]|0;K=f[K+4>>2]|0;j=Ge(f[e+1024+(N<<3)>>2]|0,f[e+1024+(N<<3)+4>>2]|0,M,K)|0;b=G;o=e+1024+(N+96<<3)|0;o=xf(f[o>>2]^j,f[o+4>>2]^b,32)|0;v=G;y=e+1024+(N+64<<3)|0;y=Ge(f[y>>2]|0,f[y+4>>2]|0,o,v)|0;z=G;K=xf(y^M,z^K,24)|0;M=G;b=Ge(j,b,K,M)|0;j=G;v=xf(b^o,j^v,16)|0;o=G;k=e+1024+(N+96<<3)|0;f[k>>2]=v;f[k+4>>2]=o;z=Ge(y,z,v,o)|0;y=G;k=e+1024+(N+64<<3)|0;f[k>>2]=z;f[k+4>>2]=y;M=xf(z^K,y^M,63)|0;K=G;k=e+1024+(N+32<<3)|0;f[k>>2]=M;f[k+4>>2]=K;k=e+1024+(N+33<<3)|0;l=f[k>>2]|0;k=f[k+4>>2]|0;r=Ge(f[e+1024+((N|1)<<3)>>2]|0,f[e+1024+((N|1)<<3)+4>>2]|0,l,k)|0;n=G;x=e+1024+(N+97<<3)|0;x=xf(f[x>>2]^r,f[x+4>>2]^n,32)|0;D=G;H=e+1024+(N+65<<3)|0;H=Ge(f[H>>2]|0,f[H+4>>2]|0,x,D)|0;I=G;k=xf(H^l,I^k,24)|0;l=G;n=Ge(r,n,k,l)|0;r=G;D=xf(n^x,r^D,16)|0;x=G;I=Ge(H,I,D,x)|0;H=G;A=e+1024+(N+65<<3)|0;f[A>>2]=I;f[A+4>>2]=H;l=xf(I^k,H^l,63)|0;k=G;A=e+1024+(N+16<<3)|0;s=e+1024+(N+48<<3)|0;u=f[s>>2]|0;s=f[s+4>>2]|0;A=Ge(f[A>>2]|0,f[A+4>>2]|0,u,s)|0;w=G;F=e+1024+(N+112<<3)|0;F=xf(f[F>>2]^A,f[F+4>>2]^w,32)|0;L=G;h=e+1024+(N+80<<3)|0;h=Ge(f[h>>2]|0,f[h+4>>2]|0,F,L)|0;i=G;s=xf(h^u,i^s,24)|0;u=G;w=Ge(A,w,s,u)|0;A=G;L=xf(w^F,A^L,16)|0;F=G;i=Ge(h,i,L,F)|0;h=G;u=xf(i^s,h^u,63)|0;s=G;J=e+1024+(N+17<<3)|0;B=e+1024+(N+49<<3)|0;C=f[B>>2]|0;B=f[B+4>>2]|0;J=Ge(f[J>>2]|0,f[J+4>>2]|0,C,B)|0;E=G;g=e+1024+(N+113<<3)|0;g=xf(f[g>>2]^J,f[g+4>>2]^E,32)|0;m=G;p=e+1024+(N+81<<3)|0;p=Ge(f[p>>2]|0,f[p+4>>2]|0,g,m)|0;q=G;B=xf(p^C,q^B,24)|0;C=G;E=Ge(J,E,B,C)|0;J=G;m=xf(E^g,J^m,16)|0;g=G;q=Ge(p,q,m,g)|0;p=G;C=xf(q^B,p^C,63)|0;B=G;j=Ge(b,j,l,k)|0;b=G;g=xf(j^m,b^g,32)|0;m=G;h=Ge(i,h,g,m)|0;i=G;k=xf(h^l,i^k,24)|0;l=G;b=Ge(j,b,k,l)|0;j=G;f[e+1024+(N<<3)>>2]=b;f[e+1024+(N<<3)+4>>2]=j;m=xf(b^g,j^m,16)|0;j=G;g=e+1024+(N+113<<3)|0;f[g>>2]=m;f[g+4>>2]=j;j=Ge(h,i,m,j)|0;m=G;i=e+1024+(N+80<<3)|0;f[i>>2]=j;f[i+4>>2]=m;l=xf(j^k,m^l,63)|0;m=e+1024+(N+33<<3)|0;f[m>>2]=l;f[m+4>>2]=G;r=Ge(n,r,u,s)|0;n=G;o=xf(r^v,n^o,32)|0;v=G;p=Ge(q,p,o,v)|0;q=G;s=xf(p^u,q^s,24)|0;u=G;n=Ge(r,n,s,u)|0;r=G;f[e+1024+((N|1)<<3)>>2]=n;f[e+1024+((N|1)<<3)+4>>2]=r;v=xf(n^o,r^v,16)|0;r=G;o=e+1024+(N+96<<3)|0;f[o>>2]=v;f[o+4>>2]=r;r=Ge(p,q,v,r)|0;v=G;q=e+1024+(N+81<<3)|0;f[q>>2]=r;f[q+4>>2]=v;u=xf(r^s,v^u,63)|0;v=e+1024+(N+48<<3)|0;f[v>>2]=u;f[v+4>>2]=G;A=Ge(w,A,C,B)|0;w=G;x=xf(A^D,w^x,32)|0;D=G;y=Ge(z,y,x,D)|0;z=G;B=xf(y^C,z^B,24)|0;C=G;w=Ge(A,w,B,C)|0;A=G;v=e+1024+(N+16<<3)|0;f[v>>2]=w;f[v+4>>2]=A;D=xf(w^x,A^D,16)|0;A=G;x=e+1024+(N+97<<3)|0;f[x>>2]=D;f[x+4>>2]=A;A=Ge(y,z,D,A)|0;D=G;z=e+1024+(N+64<<3)|0;f[z>>2]=A;f[z+4>>2]=D;C=xf(A^B,D^C,63)|0;D=e+1024+(N+49<<3)|0;f[D>>2]=C;f[D+4>>2]=G;J=Ge(E,J,M,K)|0;E=G;F=xf(J^L,E^F,32)|0;L=G;H=Ge(I,H,F,L)|0;I=G;K=xf(H^M,I^K,24)|0;M=G;E=Ge(J,E,K,M)|0;J=G;D=e+1024+(N+17<<3)|0;f[D>>2]=E;f[D+4>>2]=J;L=xf(E^F,J^L,16)|0;J=G;F=e+1024+(N+112<<3)|0;f[F>>2]=L;f[F+4>>2]=J;J=Ge(H,I,L,J)|0;L=G;I=e+1024+(N+65<<3)|0;f[I>>2]=J;f[I+4>>2]=L;M=xf(J^K,L^M,63)|0;N=e+1024+(N+32<<3)|0;f[N>>2]=M;f[N+4>>2]=G;a=a+1|0}while((a|0)!=8);li(c,e);Ae(c,e+1024|0);t=d;return}function ra(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0;d=t;e=t=t+63&-64;t=t+2048|0;li(e+1024|0,b);Ae(e+1024|0,a);li(e,e+1024|0);a=0;do{b=a<<4;g=f[e+1024+((b|4)<<3)>>2]|0;i=f[e+1024+((b|4)<<3)+4>>2]|0;J=Ge(f[e+1024+(b<<3)>>2]|0,f[e+1024+(b<<3)+4>>2]|0,g,i)|0;N=G;D=xf(f[e+1024+((b|12)<<3)>>2]^J,f[e+1024+((b|12)<<3)+4>>2]^N,32)|0;y=G;u=Ge(f[e+1024+((b|8)<<3)>>2]|0,f[e+1024+((b|8)<<3)+4>>2]|0,D,y)|0;s=G;i=xf(u^g,s^i,24)|0;g=G;N=Ge(J,N,i,g)|0;J=G;y=xf(N^D,J^y,16)|0;D=G;f[e+1024+((b|12)<<3)>>2]=y;f[e+1024+((b|12)<<3)+4>>2]=D;s=Ge(u,s,y,D)|0;u=G;f[e+1024+((b|8)<<3)>>2]=s;f[e+1024+((b|8)<<3)+4>>2]=u;g=xf(s^i,u^g,63)|0;i=G;f[e+1024+((b|4)<<3)>>2]=g;f[e+1024+((b|4)<<3)+4>>2]=i;F=f[e+1024+((b|5)<<3)>>2]|0;I=f[e+1024+((b|5)<<3)+4>>2]|0;A=Ge(f[e+1024+((b|1)<<3)>>2]|0,f[e+1024+((b|1)<<3)+4>>2]|0,F,I)|0;E=G;v=xf(f[e+1024+((b|13)<<3)>>2]^A,f[e+1024+((b|13)<<3)+4>>2]^E,32)|0;p=G;l=Ge(f[e+1024+((b|9)<<3)>>2]|0,f[e+1024+((b|9)<<3)+4>>2]|0,v,p)|0;k=G;I=xf(l^F,k^I,24)|0;F=G;E=Ge(A,E,I,F)|0;A=G;p=xf(E^v,A^p,16)|0;v=G;k=Ge(l,k,p,v)|0;l=G;f[e+1024+((b|9)<<3)>>2]=k;f[e+1024+((b|9)<<3)+4>>2]=l;F=xf(k^I,l^F,63)|0;I=G;x=f[e+1024+((b|6)<<3)>>2]|0;z=f[e+1024+((b|6)<<3)+4>>2]|0;r=Ge(f[e+1024+((b|2)<<3)>>2]|0,f[e+1024+((b|2)<<3)+4>>2]|0,x,z)|0;w=G;m=xf(f[e+1024+((b|14)<<3)>>2]^r,f[e+1024+((b|14)<<3)+4>>2]^w,32)|0;h=G;L=Ge(f[e+1024+((b|10)<<3)>>2]|0,f[e+1024+((b|10)<<3)+4>>2]|0,m,h)|0;K=G;z=xf(L^x,K^z,24)|0;x=G;w=Ge(r,w,z,x)|0;r=G;h=xf(w^m,r^h,16)|0;m=G;K=Ge(L,K,h,m)|0;L=G;x=xf(K^z,L^x,63)|0;z=G;o=f[e+1024+((b|7)<<3)>>2]|0;q=f[e+1024+((b|7)<<3)+4>>2]|0;j=Ge(f[e+1024+((b|3)<<3)>>2]|0,f[e+1024+((b|3)<<3)+4>>2]|0,o,q)|0;n=G;M=xf(f[e+1024+((b|15)<<3)>>2]^j,f[e+1024+((b|15)<<3)+4>>2]^n,32)|0;H=G;C=Ge(f[e+1024+((b|11)<<3)>>2]|0,f[e+1024+((b|11)<<3)+4>>2]|0,M,H)|0;B=G;q=xf(C^o,B^q,24)|0;o=G;n=Ge(j,n,q,o)|0;j=G;H=xf(n^M,j^H,16)|0;M=G;B=Ge(C,B,H,M)|0;C=G;o=xf(B^q,C^o,63)|0;q=G;J=Ge(N,J,F,I)|0;N=G;M=xf(J^H,N^M,32)|0;H=G;L=Ge(K,L,M,H)|0;K=G;I=xf(L^F,K^I,24)|0;F=G;N=Ge(J,N,I,F)|0;J=G;f[e+1024+(b<<3)>>2]=N;f[e+1024+(b<<3)+4>>2]=J;H=xf(N^M,J^H,16)|0;J=G;f[e+1024+((b|15)<<3)>>2]=H;f[e+1024+((b|15)<<3)+4>>2]=J;J=Ge(L,K,H,J)|0;H=G;f[e+1024+((b|10)<<3)>>2]=J;f[e+1024+((b|10)<<3)+4>>2]=H;F=xf(J^I,H^F,63)|0;f[e+1024+((b|5)<<3)>>2]=F;f[e+1024+((b|5)<<3)+4>>2]=G;A=Ge(E,A,x,z)|0;E=G;D=xf(A^y,E^D,32)|0;y=G;C=Ge(B,C,D,y)|0;B=G;z=xf(C^x,B^z,24)|0;x=G;E=Ge(A,E,z,x)|0;A=G;f[e+1024+((b|1)<<3)>>2]=E;f[e+1024+((b|1)<<3)+4>>2]=A;y=xf(E^D,A^y,16)|0;A=G;f[e+1024+((b|12)<<3)>>2]=y;f[e+1024+((b|12)<<3)+4>>2]=A;A=Ge(C,B,y,A)|0;y=G;f[e+1024+((b|11)<<3)>>2]=A;f[e+1024+((b|11)<<3)+4>>2]=y;x=xf(A^z,y^x,63)|0;f[e+1024+((b|6)<<3)>>2]=x;f[e+1024+((b|6)<<3)+4>>2]=G;r=Ge(w,r,o,q)|0;w=G;v=xf(r^p,w^v,32)|0;p=G;u=Ge(s,u,v,p)|0;s=G;q=xf(u^o,s^q,24)|0;o=G;w=Ge(r,w,q,o)|0;r=G;f[e+1024+((b|2)<<3)>>2]=w;f[e+1024+((b|2)<<3)+4>>2]=r;p=xf(w^v,r^p,16)|0;r=G;f[e+1024+((b|13)<<3)>>2]=p;f[e+1024+((b|13)<<3)+4>>2]=r;r=Ge(u,s,p,r)|0;p=G;f[e+1024+((b|8)<<3)>>2]=r;f[e+1024+((b|8)<<3)+4>>2]=p;o=xf(r^q,p^o,63)|0;f[e+1024+((b|7)<<3)>>2]=o;f[e+1024+((b|7)<<3)+4>>2]=G;j=Ge(n,j,g,i)|0;n=G;m=xf(j^h,n^m,32)|0;h=G;l=Ge(k,l,m,h)|0;k=G;i=xf(l^g,k^i,24)|0;g=G;n=Ge(j,n,i,g)|0;j=G;f[e+1024+((b|3)<<3)>>2]=n;f[e+1024+((b|3)<<3)+4>>2]=j;h=xf(n^m,j^h,16)|0;j=G;f[e+1024+((b|14)<<3)>>2]=h;f[e+1024+((b|14)<<3)+4>>2]=j;j=Ge(l,k,h,j)|0;h=G;f[e+1024+((b|9)<<3)>>2]=j;f[e+1024+((b|9)<<3)+4>>2]=h;g=xf(j^i,h^g,63)|0;f[e+1024+((b|4)<<3)>>2]=g;f[e+1024+((b|4)<<3)+4>>2]=G;a=a+1|0}while((a|0)!=8);a=0;do{N=a<<1;K=e+1024+(N+32<<3)|0;M=f[K>>2]|0;K=f[K+4>>2]|0;j=Ge(f[e+1024+(N<<3)>>2]|0,f[e+1024+(N<<3)+4>>2]|0,M,K)|0;b=G;o=e+1024+(N+96<<3)|0;o=xf(f[o>>2]^j,f[o+4>>2]^b,32)|0;v=G;y=e+1024+(N+64<<3)|0;y=Ge(f[y>>2]|0,f[y+4>>2]|0,o,v)|0;z=G;K=xf(y^M,z^K,24)|0;M=G;b=Ge(j,b,K,M)|0;j=G;v=xf(b^o,j^v,16)|0;o=G;k=e+1024+(N+96<<3)|0;f[k>>2]=v;f[k+4>>2]=o;z=Ge(y,z,v,o)|0;y=G;k=e+1024+(N+64<<3)|0;f[k>>2]=z;f[k+4>>2]=y;M=xf(z^K,y^M,63)|0;K=G;k=e+1024+(N+32<<3)|0;f[k>>2]=M;f[k+4>>2]=K;k=e+1024+(N+33<<3)|0;l=f[k>>2]|0;k=f[k+4>>2]|0;r=Ge(f[e+1024+((N|1)<<3)>>2]|0,f[e+1024+((N|1)<<3)+4>>2]|0,l,k)|0;n=G;x=e+1024+(N+97<<3)|0;x=xf(f[x>>2]^r,f[x+4>>2]^n,32)|0;D=G;H=e+1024+(N+65<<3)|0;H=Ge(f[H>>2]|0,f[H+4>>2]|0,x,D)|0;I=G;k=xf(H^l,I^k,24)|0;l=G;n=Ge(r,n,k,l)|0;r=G;D=xf(n^x,r^D,16)|0;x=G;I=Ge(H,I,D,x)|0;H=G;A=e+1024+(N+65<<3)|0;f[A>>2]=I;f[A+4>>2]=H;l=xf(I^k,H^l,63)|0;k=G;A=e+1024+(N+16<<3)|0;s=e+1024+(N+48<<3)|0;u=f[s>>2]|0;s=f[s+4>>2]|0;A=Ge(f[A>>2]|0,f[A+4>>2]|0,u,s)|0;w=G;F=e+1024+(N+112<<3)|0;F=xf(f[F>>2]^A,f[F+4>>2]^w,32)|0;L=G;h=e+1024+(N+80<<3)|0;h=Ge(f[h>>2]|0,f[h+4>>2]|0,F,L)|0;i=G;s=xf(h^u,i^s,24)|0;u=G;w=Ge(A,w,s,u)|0;A=G;L=xf(w^F,A^L,16)|0;F=G;i=Ge(h,i,L,F)|0;h=G;u=xf(i^s,h^u,63)|0;s=G;J=e+1024+(N+17<<3)|0;B=e+1024+(N+49<<3)|0;C=f[B>>2]|0;B=f[B+4>>2]|0;J=Ge(f[J>>2]|0,f[J+4>>2]|0,C,B)|0;E=G;g=e+1024+(N+113<<3)|0;g=xf(f[g>>2]^J,f[g+4>>2]^E,32)|0;m=G;p=e+1024+(N+81<<3)|0;p=Ge(f[p>>2]|0,f[p+4>>2]|0,g,m)|0;q=G;B=xf(p^C,q^B,24)|0;C=G;E=Ge(J,E,B,C)|0;J=G;m=xf(E^g,J^m,16)|0;g=G;q=Ge(p,q,m,g)|0;p=G;C=xf(q^B,p^C,63)|0;B=G;j=Ge(b,j,l,k)|0;b=G;g=xf(j^m,b^g,32)|0;m=G;h=Ge(i,h,g,m)|0;i=G;k=xf(h^l,i^k,24)|0;l=G;b=Ge(j,b,k,l)|0;j=G;f[e+1024+(N<<3)>>2]=b;f[e+1024+(N<<3)+4>>2]=j;m=xf(b^g,j^m,16)|0;j=G;g=e+1024+(N+113<<3)|0;f[g>>2]=m;f[g+4>>2]=j;j=Ge(h,i,m,j)|0;m=G;i=e+1024+(N+80<<3)|0;f[i>>2]=j;f[i+4>>2]=m;l=xf(j^k,m^l,63)|0;m=e+1024+(N+33<<3)|0;f[m>>2]=l;f[m+4>>2]=G;r=Ge(n,r,u,s)|0;n=G;o=xf(r^v,n^o,32)|0;v=G;p=Ge(q,p,o,v)|0;q=G;s=xf(p^u,q^s,24)|0;u=G;n=Ge(r,n,s,u)|0;r=G;f[e+1024+((N|1)<<3)>>2]=n;f[e+1024+((N|1)<<3)+4>>2]=r;v=xf(n^o,r^v,16)|0;r=G;o=e+1024+(N+96<<3)|0;f[o>>2]=v;f[o+4>>2]=r;r=Ge(p,q,v,r)|0;v=G;q=e+1024+(N+81<<3)|0;f[q>>2]=r;f[q+4>>2]=v;u=xf(r^s,v^u,63)|0;v=e+1024+(N+48<<3)|0;f[v>>2]=u;f[v+4>>2]=G;A=Ge(w,A,C,B)|0;w=G;x=xf(A^D,w^x,32)|0;D=G;y=Ge(z,y,x,D)|0;z=G;B=xf(y^C,z^B,24)|0;C=G;w=Ge(A,w,B,C)|0;A=G;v=e+1024+(N+16<<3)|0;f[v>>2]=w;f[v+4>>2]=A;D=xf(w^x,A^D,16)|0;A=G;x=e+1024+(N+97<<3)|0;f[x>>2]=D;f[x+4>>2]=A;A=Ge(y,z,D,A)|0;D=G;z=e+1024+(N+64<<3)|0;f[z>>2]=A;f[z+4>>2]=D;C=xf(A^B,D^C,63)|0;D=e+1024+(N+49<<3)|0;f[D>>2]=C;f[D+4>>2]=G;J=Ge(E,J,M,K)|0;E=G;F=xf(J^L,E^F,32)|0;L=G;H=Ge(I,H,F,L)|0;I=G;K=xf(H^M,I^K,24)|0;M=G;E=Ge(J,E,K,M)|0;J=G;D=e+1024+(N+17<<3)|0;f[D>>2]=E;f[D+4>>2]=J;L=xf(E^F,J^L,16)|0;J=G;F=e+1024+(N+112<<3)|0;f[F>>2]=L;f[F+4>>2]=J;J=Ge(H,I,L,J)|0;L=G;I=e+1024+(N+65<<3)|0;f[I>>2]=J;f[I+4>>2]=L;M=xf(J^K,L^M,63)|0;N=e+1024+(N+32<<3)|0;f[N>>2]=M;f[N+4>>2]=G;a=a+1|0}while((a|0)!=8);li(c,e);Ae(c,e+1024|0);t=d;return}function sa(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,G=0;Ff(c,b);f[d>>2]=f[a>>2];f[d+4>>2]=f[a+4>>2];f[d+8>>2]=f[a+8>>2];f[d+12>>2]=f[a+12>>2];f[d+16>>2]=f[a+16>>2];f[d+20>>2]=f[a+20>>2];f[d+24>>2]=f[a+24>>2];f[d+28>>2]=f[a+28>>2];s=0;b=f[c>>2]|0;do{v=f[d+16>>2]|0;B=ri(v,6)|0;B=(ri(v,11)|0)^B;B=B^(ri(v,25)|0);F=f[d+20>>2]|0;D=f[d+24>>2]|0;B=b+B+(f[32432+(s<<2)>>2]|0)+((D^F)&v^D)+(f[d+28>>2]|0)|0;g=B+(f[d+12>>2]|0)|0;f[d+12>>2]=g;z=f[d>>2]|0;w=ri(z,2)|0;w=(ri(z,13)|0)^w;w=w^(ri(z,22)|0);u=f[d+4>>2]|0;x=f[d+8>>2]|0;f[d+28>>2]=w+B+((x|u)&z|x&u);A=ri(g,6)|0;A=(ri(g,11)|0)^A;A=A^(ri(g,25)|0);q=s|1;A=(g&(F^v)^F)+D+A+(f[c+(q<<2)>>2]|0)+(f[32432+(q<<2)>>2]|0)|0;f[d+8>>2]=A+x;D=ri(w+B+((x|u)&z|x&u)|0,2)|0;D=(ri(w+B+((x|u)&z|x&u)|0,13)|0)^D;D=A+(w+B+((x|u)&z|x&u)&(u|z)|u&z)+(D^(ri(w+B+((x|u)&z|x&u)|0,22)|0))|0;f[d+24>>2]=D;C=ri(A+x|0,6)|0;C=(ri(A+x|0,11)|0)^C;C=C^(ri(A+x|0,25)|0);r=s|2;C=(A+x&(g^v)^v)+F+C+(f[c+(r<<2)>>2]|0)+(f[32432+(r<<2)>>2]|0)|0;f[d+4>>2]=C+u;F=ri(D,2)|0;F=(ri(D,13)|0)^F;F=C+(D&(w+B+((x|u)&z|x&u)|z)|w+B+((x|u)&z|x&u)&z)+(F^(ri(D,22)|0))|0;f[d+20>>2]=F;E=ri(C+u|0,6)|0;E=(ri(C+u|0,11)|0)^E;E=E^(ri(C+u|0,25)|0);b=s|3;E=(C+u&(A+x^g)^g)+v+E+(f[c+(b<<2)>>2]|0)+(f[32432+(b<<2)>>2]|0)|0;f[d>>2]=E+z;v=ri(F,2)|0;v=(ri(F,13)|0)^v;v=E+(F&(D|w+B+((x|u)&z|x&u))|D&w+B+((x|u)&z|x&u))+(v^(ri(F,22)|0))|0;f[d+16>>2]=v;y=ri(E+z|0,6)|0;y=(ri(E+z|0,11)|0)^y;y=y^(ri(E+z|0,25)|0);e=s|4;y=(E+z&(C+u^A+x)^A+x)+g+y+(f[c+(e<<2)>>2]|0)+(f[32432+(e<<2)>>2]|0)|0;B=y+(w+B+((x|u)&z|x&u))|0;f[d+28>>2]=B;w=ri(v,2)|0;w=(ri(v,13)|0)^w;w=y+(v&(F|D)|F&D)+(w^(ri(v,22)|0))|0;f[d+12>>2]=w;y=ri(B,6)|0;y=(ri(B,11)|0)^y;y=y^(ri(B,25)|0);g=s|5;y=(B&(E+z^C+u)^C+u)+(A+x)+y+(f[c+(g<<2)>>2]|0)+(f[32432+(g<<2)>>2]|0)|0;f[d+24>>2]=y+D;x=ri(w,2)|0;x=(ri(w,13)|0)^x;x=y+(w&(v|F)|v&F)+(x^(ri(w,22)|0))|0;f[d+8>>2]=x;A=ri(y+D|0,6)|0;A=(ri(y+D|0,11)|0)^A;A=A^(ri(y+D|0,25)|0);h=s|6;A=(y+D&(B^E+z)^E+z)+(C+u)+A+(f[c+(h<<2)>>2]|0)+(f[32432+(h<<2)>>2]|0)|0;f[d+20>>2]=A+F;u=ri(x,2)|0;u=(ri(x,13)|0)^u;u=A+(x&(w|v)|w&v)+(u^(ri(x,22)|0))|0;f[d+4>>2]=u;C=ri(A+F|0,6)|0;C=(ri(A+F|0,11)|0)^C;C=C^(ri(A+F|0,25)|0);i=s|7;C=(A+F&(y+D^B)^B)+(E+z)+C+(f[c+(i<<2)>>2]|0)+(f[32432+(i<<2)>>2]|0)|0;f[d+16>>2]=C+v;z=ri(u,2)|0;z=(ri(u,13)|0)^z;z=C+(u&(x|w)|x&w)+(z^(ri(u,22)|0))|0;f[d>>2]=z;E=ri(C+v|0,6)|0;E=(ri(C+v|0,11)|0)^E;E=E^(ri(C+v|0,25)|0);j=s|8;E=(C+v&(A+F^y+D)^y+D)+B+E+(f[c+(j<<2)>>2]|0)+(f[32432+(j<<2)>>2]|0)|0;f[d+12>>2]=E+w;B=ri(z,2)|0;B=(ri(z,13)|0)^B;B=E+(z&(u|x)|u&x)+(B^(ri(z,22)|0))|0;f[d+28>>2]=B;G=ri(E+w|0,6)|0;G=(ri(E+w|0,11)|0)^G;G=G^(ri(E+w|0,25)|0);k=s|9;G=(E+w&(C+v^A+F)^A+F)+(y+D)+G+(f[c+(k<<2)>>2]|0)+(f[32432+(k<<2)>>2]|0)|0;f[d+8>>2]=G+x;D=ri(B,2)|0;D=(ri(B,13)|0)^D;D=G+(B&(z|u)|z&u)+(D^(ri(B,22)|0))|0;f[d+24>>2]=D;y=ri(G+x|0,6)|0;y=(ri(G+x|0,11)|0)^y;y=y^(ri(G+x|0,25)|0);l=s|10;y=(G+x&(E+w^C+v)^C+v)+(A+F)+y+(f[c+(l<<2)>>2]|0)+(f[32432+(l<<2)>>2]|0)|0;f[d+4>>2]=y+u;F=ri(D,2)|0;F=(ri(D,13)|0)^F;F=y+(D&(B|z)|B&z)+(F^(ri(D,22)|0))|0;f[d+20>>2]=F;A=ri(y+u|0,6)|0;A=(ri(y+u|0,11)|0)^A;A=A^(ri(y+u|0,25)|0);m=s|11;A=(y+u&(G+x^E+w)^E+w)+(C+v)+A+(f[c+(m<<2)>>2]|0)+(f[32432+(m<<2)>>2]|0)|0;f[d>>2]=A+z;v=ri(F,2)|0;v=(ri(F,13)|0)^v;v=A+(F&(D|B)|D&B)+(v^(ri(F,22)|0))|0;f[d+16>>2]=v;C=ri(A+z|0,6)|0;C=(ri(A+z|0,11)|0)^C;C=C^(ri(A+z|0,25)|0);n=s|12;C=(A+z&(y+u^G+x)^G+x)+(E+w)+C+(f[c+(n<<2)>>2]|0)+(f[32432+(n<<2)>>2]|0)|0;f[d+28>>2]=C+B;w=ri(v,2)|0;w=(ri(v,13)|0)^w;w=C+(v&(F|D)|F&D)+(w^(ri(v,22)|0))|0;f[d+12>>2]=w;E=ri(C+B|0,6)|0;E=(ri(C+B|0,11)|0)^E;E=E^(ri(C+B|0,25)|0);o=s|13;E=(C+B&(A+z^y+u)^y+u)+(G+x)+E+(f[c+(o<<2)>>2]|0)+(f[32432+(o<<2)>>2]|0)|0;f[d+24>>2]=E+D;x=ri(w,2)|0;x=(ri(w,13)|0)^x;x=E+(w&(v|F)|v&F)+(x^(ri(w,22)|0))|0;f[d+8>>2]=x;G=ri(E+D|0,6)|0;G=(ri(E+D|0,11)|0)^G;G=G^(ri(E+D|0,25)|0);p=s|14;G=(E+D&(C+B^A+z)^A+z)+(y+u)+G+(f[c+(p<<2)>>2]|0)+(f[32432+(p<<2)>>2]|0)|0;f[d+20>>2]=G+F;u=ri(x,2)|0;u=(ri(x,13)|0)^u;u=G+(x&(w|v)|w&v)+(u^(ri(x,22)|0))|0;f[d+4>>2]=u;y=ri(G+F|0,6)|0;y=(ri(G+F|0,11)|0)^y;y=y^(ri(G+F|0,25)|0);t=s|15;y=(G+F&(E+D^C+B)^C+B)+(A+z)+y+(f[c+(t<<2)>>2]|0)+(f[32432+(t<<2)>>2]|0)|0;f[d+16>>2]=y+v;v=ri(u,2)|0;v=(ri(u,13)|0)^v;u=y+(u&(x|w)|x&w)+(v^(ri(u,22)|0))|0;f[d>>2]=u;if((s|0)==48)break;G=f[c+(p<<2)>>2]|0;E=ri(G,17)|0;E=G>>>10^E^(ri(G,19)|0);D=f[c+(k<<2)>>2]|0;y=f[c+(q<<2)>>2]|0;x=ri(y,7)|0;x=y>>>3^x^(ri(y,18)|0);x=E+D+(f[c+(s<<2)>>2]|0)+x|0;s=s+16|0;f[c+(s<<2)>>2]=x;E=f[c+(t<<2)>>2]|0;C=ri(E,17)|0;C=E>>>10^C^(ri(E,19)|0);B=f[c+(q+9<<2)>>2]|0;A=f[c+(q+1<<2)>>2]|0;z=ri(A,7)|0;z=B+y+C+(A>>>3^z^(ri(A,18)|0))|0;f[c+(q+16<<2)>>2]=z;C=ri(x,17)|0;x=x>>>10^C^(ri(x,19)|0);C=f[c+(m<<2)>>2]|0;y=f[c+(b<<2)>>2]|0;B=ri(y,7)|0;B=x+C+A+(y>>>3^B^(ri(y,18)|0))|0;f[c+(r+16<<2)>>2]=B;A=ri(z,17)|0;z=z>>>10^A^(ri(z,19)|0);A=f[c+(b+9<<2)>>2]|0;x=f[c+(b+1<<2)>>2]|0;F=ri(x,7)|0;F=A+y+z+(x>>>3^F^(ri(x,18)|0))|0;f[c+(b+16<<2)>>2]=F;b=ri(B,17)|0;b=B>>>10^b^(ri(B,19)|0);B=f[c+(o<<2)>>2]|0;z=f[c+(g<<2)>>2]|0;y=ri(z,7)|0;y=b+B+x+(z>>>3^y^(ri(z,18)|0))|0;f[c+(e+16<<2)>>2]=y;b=ri(F,17)|0;b=F>>>10^b^(ri(F,19)|0);F=f[c+(g+9<<2)>>2]|0;x=f[c+(g+1<<2)>>2]|0;A=ri(x,7)|0;A=F+z+b+(x>>>3^A^(ri(x,18)|0))|0;f[c+(g+16<<2)>>2]=A;b=ri(y,17)|0;y=(y>>>10^b^(ri(y,19)|0))+E|0;b=f[c+(i<<2)>>2]|0;z=ri(b,7)|0;z=y+x+(b>>>3^z^(ri(b,18)|0))|0;f[c+(h+16<<2)>>2]=z;x=ri(A,17)|0;A=A>>>10^x^(ri(A,19)|0);x=f[c+(i+9<<2)>>2]|0;y=f[c+(i+1<<2)>>2]|0;F=ri(y,7)|0;F=x+b+A+(y>>>3^F^(ri(y,18)|0))|0;f[c+(i+16<<2)>>2]=F;A=ri(z,17)|0;z=z>>>10^A^(ri(z,19)|0);z=z+(f[c+(j+9<<2)>>2]|0)|0;A=ri(D,7)|0;A=z+y+(A^D>>>3^(ri(D,18)|0))|0;f[c+(j+16<<2)>>2]=A;y=ri(F,17)|0;F=F>>>10^y^(ri(F,19)|0);y=f[c+(k+9<<2)>>2]|0;z=f[c+(k+1<<2)>>2]|0;b=ri(z,7)|0;b=y+D+F+(z>>>3^b^(ri(z,18)|0))|0;f[c+(k+16<<2)>>2]=b;F=ri(A,17)|0;A=A>>>10^F^(ri(A,19)|0);A=A+(f[c+(l+9<<2)>>2]|0)|0;F=ri(C,7)|0;F=A+z+(F^C>>>3^(ri(C,18)|0))|0;f[c+(l+16<<2)>>2]=F;z=ri(b,17)|0;b=b>>>10^z^(ri(b,19)|0);z=f[c+(m+9<<2)>>2]|0;A=f[c+(m+1<<2)>>2]|0;D=ri(A,7)|0;D=z+C+b+(A>>>3^D^(ri(A,18)|0))|0;f[c+(m+16<<2)>>2]=D;b=ri(F,17)|0;F=F>>>10^b^(ri(F,19)|0);F=F+(f[c+(n+9<<2)>>2]|0)|0;b=ri(B,7)|0;b=F+A+(b^B>>>3^(ri(B,18)|0))|0;f[c+(n+16<<2)>>2]=b;A=ri(D,17)|0;D=D>>>10^A^(ri(D,19)|0);A=f[c+(o+9<<2)>>2]|0;F=f[c+(o+1<<2)>>2]|0;C=ri(F,7)|0;F=A+B+D+(F>>>3^C^(ri(F,18)|0))|0;f[c+(o+16<<2)>>2]=F;C=ri(b,17)|0;b=b>>>10^C^(ri(b,19)|0);C=f[c+(p+9<<2)>>2]|0;D=ri(E,7)|0;D=C+G+b+(D^E>>>3^(ri(E,18)|0))|0;f[c+(p+16<<2)>>2]=D;D=ri(F,17)|0;F=F>>>10^D^(ri(F,19)|0);D=f[c+(t+9<<2)>>2]|0;b=f[c+(t+1<<2)>>2]|0;G=ri(b,7)|0;G=D+E+F+(b>>>3^G^(ri(b,18)|0))|0;f[c+(t+16<<2)>>2]=G}while(s>>>0<64);b=0;do{G=a+(b<<2)|0;f[G>>2]=(f[G>>2]|0)+(f[d+(b<<2)>>2]|0);b=b+1|0}while((b|0)!=8);return}function ta(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0,oa=0,pa=0,qa=0,ra=0,sa=0,ta=0,ua=0,va=0,wa=0,xa=0,ya=0,za=0,Aa=0,Ba=0,Ca=0,Da=0,Ea=0,Fa=0,Ga=0,Ha=0,Ia=0,Ja=0,Ka=0,La=0,Ma=0,Na=0,Oa=0,Pa=0,Qa=0,Ra=0,Sa=0,Ta=0,Ua=0,Va=0,Wa=0,Xa=0,Ya=0,Za=0,_a=0,$a=0,ab=0,bb=0,cb=0,db=0,eb=0;k=f[b>>2]|0;r=f[b+4>>2]|0;o=f[b+8>>2]|0;w=f[b+12>>2]|0;d=f[b+16>>2]|0;x=f[b+20>>2]|0;s=f[b+24>>2]|0;i=f[b+28>>2]|0;h=f[b+32>>2]|0;b=f[b+36>>2]|0;cb=Af(k|0,((k|0)<0)<<31>>31|0,k|0,((k|0)<0)<<31>>31|0)|0;bb=G;l=((k<<1|0)<0)<<31>>31;Ua=Af(k<<1|0,l|0,r|0,((r|0)<0)<<31>>31|0)|0;Ta=G;Oa=Af(o|0,((o|0)<0)<<31>>31|0,k<<1|0,l|0)|0;Na=G;Ea=Af(w|0,((w|0)<0)<<31>>31|0,k<<1|0,l|0)|0;Da=G;sa=Af(d|0,((d|0)<0)<<31>>31|0,k<<1|0,l|0)|0;ra=G;ia=Af(x|0,((x|0)<0)<<31>>31|0,k<<1|0,l|0)|0;ha=G;_=Af(s|0,((s|0)<0)<<31>>31|0,k<<1|0,l|0)|0;Z=G;Q=Af(i|0,((i|0)<0)<<31>>31|0,k<<1|0,l|0)|0;P=G;F=Af(h|0,((h|0)<0)<<31>>31|0,k<<1|0,l|0)|0;E=G;l=Af(b|0,((b|0)<0)<<31>>31|0,k<<1|0,l|0)|0;k=G;c=((r<<1|0)<0)<<31>>31;Ma=Af(r<<1|0,c|0,r|0,((r|0)<0)<<31>>31|0)|0;La=G;Ca=Af(r<<1|0,c|0,o|0,((o|0)<0)<<31>>31|0)|0;Ba=G;e=((w<<1|0)<0)<<31>>31;wa=Af(w<<1|0,e|0,r<<1|0,c|0)|0;va=G;ma=Af(d|0,((d|0)<0)<<31>>31|0,r<<1|0,c|0)|0;la=G;aa=Af(x<<1|0,((x<<1|0)<0)<<31>>31|0,r<<1|0,c|0)|0;$=G;S=Af(s|0,((s|0)<0)<<31>>31|0,r<<1|0,c|0)|0;R=G;I=Af(i<<1|0,((i<<1|0)<0)<<31>>31|0,r<<1|0,c|0)|0;H=G;m=Af(h|0,((h|0)<0)<<31>>31|0,r<<1|0,c|0)|0;n=G;q=((b*38|0)<0)<<31>>31;c=Af(b*38|0,q|0,r<<1|0,c|0)|0;r=G;ua=Af(o|0,((o|0)<0)<<31>>31|0,o|0,((o|0)<0)<<31>>31|0)|0;ta=G;ka=Af(o<<1|0,((o<<1|0)<0)<<31>>31|0,w|0,((w|0)<0)<<31>>31|0)|0;ja=G;ca=Af(d|0,((d|0)<0)<<31>>31|0,o<<1|0,((o<<1|0)<0)<<31>>31|0)|0;ba=G;W=Af(x|0,((x|0)<0)<<31>>31|0,o<<1|0,((o<<1|0)<0)<<31>>31|0)|0;V=G;O=Af(s|0,((s|0)<0)<<31>>31|0,o<<1|0,((o<<1|0)<0)<<31>>31|0)|0;N=G;z=Af(i|0,((i|0)<0)<<31>>31|0,o<<1|0,((o<<1|0)<0)<<31>>31|0)|0;y=G;Y=((h*19|0)<0)<<31>>31;Ya=Af(h*19|0,Y|0,o<<1|0,((o<<1|0)<0)<<31>>31|0)|0;Xa=G;o=Af(b*38|0,q|0,o|0,((o|0)<0)<<31>>31|0)|0;t=G;ea=Af(w<<1|0,e|0,w|0,((w|0)<0)<<31>>31|0)|0;da=G;U=Af(w<<1|0,e|0,d|0,((d|0)<0)<<31>>31|0)|0;T=G;K=Af(x<<1|0,((x<<1|0)<0)<<31>>31|0,w<<1|0,e|0)|0;J=G;D=Af(s|0,((s|0)<0)<<31>>31|0,w<<1|0,e|0)|0;C=G;qa=((i*38|0)<0)<<31>>31;_a=Af(i*38|0,qa|0,w<<1|0,e|0)|0;Za=G;Qa=Af(h*19|0,Y|0,w<<1|0,e|0)|0;Pa=G;e=Af(b*38|0,q|0,w<<1|0,e|0)|0;w=G;M=Af(d|0,((d|0)<0)<<31>>31|0,d|0,((d|0)<0)<<31>>31|0)|0;L=G;B=Af(d<<1|0,((d<<1|0)<0)<<31>>31|0,x|0,((x|0)<0)<<31>>31|0)|0;A=G;ab=Af(s*19|0,((s*19|0)<0)<<31>>31|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;$a=G;Sa=Af(i*38|0,qa|0,d|0,((d|0)<0)<<31>>31|0)|0;Ra=G;Ga=Af(h*19|0,Y|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;Fa=G;d=Af(b*38|0,q|0,d|0,((d|0)<0)<<31>>31|0)|0;u=G;eb=Af(x*38|0,((x*38|0)<0)<<31>>31|0,x|0,((x|0)<0)<<31>>31|0)|0;db=G;Wa=Af(s*19|0,((s*19|0)<0)<<31>>31|0,x<<1|0,((x<<1|0)<0)<<31>>31|0)|0;Va=G;Ia=Af(i*38|0,qa|0,x<<1|0,((x<<1|0)<0)<<31>>31|0)|0;Ha=G;ya=Af(h*19|0,Y|0,x<<1|0,((x<<1|0)<0)<<31>>31|0)|0;xa=G;x=Af(b*38|0,q|0,x<<1|0,((x<<1|0)<0)<<31>>31|0)|0;p=G;Ka=Af(s*19|0,((s*19|0)<0)<<31>>31|0,s|0,((s|0)<0)<<31>>31|0)|0;Ja=G;Aa=Af(i*38|0,qa|0,s|0,((s|0)<0)<<31>>31|0)|0;za=G;oa=Af(h*19|0,Y|0,s<<1|0,((s<<1|0)<0)<<31>>31|0)|0;na=G;s=Af(b*38|0,q|0,s|0,((s|0)<0)<<31>>31|0)|0;j=G;qa=Af(i*38|0,qa|0,i|0,((i|0)<0)<<31>>31|0)|0;pa=G;ga=Af(h*19|0,Y|0,i<<1|0,((i<<1|0)<0)<<31>>31|0)|0;fa=G;i=Af(b*38|0,q|0,i<<1|0,((i<<1|0)<0)<<31>>31|0)|0;v=G;Y=Af(h*19|0,Y|0,h|0,((h|0)<0)<<31>>31|0)|0;X=G;h=Af(b*38|0,q|0,h|0,((h|0)<0)<<31>>31|0)|0;g=G;b=Af(b*38|0,q|0,b|0,((b|0)<0)<<31>>31|0)|0;q=G;bb=Lg(eb|0,db|0,cb|0,bb|0)|0;$a=Lg(bb|0,G|0,ab|0,$a|0)|0;Za=Lg($a|0,G|0,_a|0,Za|0)|0;Xa=Lg(Za|0,G|0,Ya|0,Xa|0)|0;r=Lg(Xa|0,G|0,c|0,r|0)|0;c=G;Ta=Lg(Wa|0,Va|0,Ua|0,Ta|0)|0;Ra=Lg(Ta|0,G|0,Sa|0,Ra|0)|0;Pa=Lg(Ra|0,G|0,Qa|0,Pa|0)|0;t=Lg(Pa|0,G|0,o|0,t|0)|0;o=G;La=Lg(Oa|0,Na|0,Ma|0,La|0)|0;Ja=Lg(La|0,G|0,Ka|0,Ja|0)|0;Ha=Lg(Ja|0,G|0,Ia|0,Ha|0)|0;Fa=Lg(Ha|0,G|0,Ga|0,Fa|0)|0;w=Lg(Fa|0,G|0,e|0,w|0)|0;e=G;Ba=Lg(Ea|0,Da|0,Ca|0,Ba|0)|0;za=Lg(Ba|0,G|0,Aa|0,za|0)|0;xa=Lg(za|0,G|0,ya|0,xa|0)|0;u=Lg(xa|0,G|0,d|0,u|0)|0;d=G;ta=Lg(wa|0,va|0,ua|0,ta|0)|0;ra=Lg(ta|0,G|0,sa|0,ra|0)|0;pa=Lg(ra|0,G|0,qa|0,pa|0)|0;na=Lg(pa|0,G|0,oa|0,na|0)|0;p=Lg(na|0,G|0,x|0,p|0)|0;x=G;ja=Lg(ma|0,la|0,ka|0,ja|0)|0;ha=Lg(ja|0,G|0,ia|0,ha|0)|0;fa=Lg(ha|0,G|0,ga|0,fa|0)|0;j=Lg(fa|0,G|0,s|0,j|0)|0;s=G;ba=Lg(ea|0,da|0,ca|0,ba|0)|0;$=Lg(ba|0,G|0,aa|0,$|0)|0;Z=Lg($|0,G|0,_|0,Z|0)|0;X=Lg(Z|0,G|0,Y|0,X|0)|0;v=Lg(X|0,G|0,i|0,v|0)|0;i=G;T=Lg(W|0,V|0,U|0,T|0)|0;R=Lg(T|0,G|0,S|0,R|0)|0;P=Lg(R|0,G|0,Q|0,P|0)|0;g=Lg(P|0,G|0,h|0,g|0)|0;h=G;L=Lg(O|0,N|0,M|0,L|0)|0;J=Lg(L|0,G|0,K|0,J|0)|0;H=Lg(J|0,G|0,I|0,H|0)|0;E=Lg(H|0,G|0,F|0,E|0)|0;q=Lg(E|0,G|0,b|0,q|0)|0;b=G;A=Lg(D|0,C|0,B|0,A|0)|0;y=Lg(A|0,G|0,z|0,y|0)|0;n=Lg(y|0,G|0,m|0,n|0)|0;k=Lg(n|0,G|0,l|0,k|0)|0;l=G;c=Wf(r|0,c|0,1)|0;r=G;o=Wf(t|0,o|0,1)|0;t=G;e=Wf(w|0,e|0,1)|0;w=G;d=Wf(u|0,d|0,1)|0;u=G;x=Wf(p|0,x|0,1)|0;p=G;s=Wf(j|0,s|0,1)|0;j=G;i=Wf(v|0,i|0,1)|0;v=G;h=Wf(g|0,h|0,1)|0;g=G;b=Wf(q|0,b|0,1)|0;q=G;l=Wf(k|0,l|0,1)|0;k=G;n=Lg(c|0,r|0,33554432,0)|0;m=G;y=Nf(n|0,m|0,26)|0;t=Lg(y|0,G|0,o|0,t|0)|0;o=G;m=Ig(c|0,r|0,n&-67108864|0,m|0)|0;n=G;r=Lg(x|0,p|0,33554432,0)|0;c=G;y=Nf(r|0,c|0,26)|0;j=Lg(y|0,G|0,s|0,j|0)|0;s=G;c=Ig(x|0,p|0,r&-67108864|0,c|0)|0;r=G;p=Lg(t|0,o|0,16777216,0)|0;x=Nf(p|0,G|0,25)|0;w=Lg(x|0,G|0,e|0,w|0)|0;e=G;p=Ig(t|0,o|0,p&-33554432|0,0)|0;o=G;t=Lg(j|0,s|0,16777216,0)|0;x=Nf(t|0,G|0,25)|0;v=Lg(x|0,G|0,i|0,v|0)|0;i=G;t=Ig(j|0,s|0,t&-33554432|0,0)|0;s=G;j=Lg(w|0,e|0,33554432,0)|0;x=Nf(j|0,G|0,26)|0;u=Lg(x|0,G|0,d|0,u|0)|0;d=G;j=Ig(w|0,e|0,j&-67108864|0,0)|0;e=Lg(v|0,i|0,33554432,0)|0;w=Nf(e|0,G|0,26)|0;g=Lg(w|0,G|0,h|0,g|0)|0;h=G;e=Ig(v|0,i|0,e&-67108864|0,0)|0;i=Lg(u|0,d|0,16777216,0)|0;v=Nf(i|0,G|0,25)|0;r=Lg(v|0,G|0,c|0,r|0)|0;c=G;i=Ig(u|0,d|0,i&-33554432|0,0)|0;d=Lg(g|0,h|0,16777216,0)|0;u=Nf(d|0,G|0,25)|0;q=Lg(u|0,G|0,b|0,q|0)|0;b=G;d=Ig(g|0,h|0,d&-33554432|0,0)|0;h=Lg(r|0,c|0,33554432,0)|0;g=$f(h|0,G|0,26)|0;g=Lg(t|0,s|0,g|0,G|0)|0;h=Ig(r|0,c|0,h&-67108864|0,0)|0;c=Lg(q|0,b|0,33554432,0)|0;r=Nf(c|0,G|0,26)|0;k=Lg(r|0,G|0,l|0,k|0)|0;l=G;c=Ig(q|0,b|0,c&-67108864|0,0)|0;b=Lg(k|0,l|0,16777216,0)|0;q=Nf(b|0,G|0,25)|0;q=Af(q|0,G|0,19,0)|0;n=Lg(q|0,G|0,m|0,n|0)|0;m=G;b=Ig(k|0,l|0,b&-33554432|0,0)|0;l=Lg(n|0,m|0,33554432,0)|0;k=$f(l|0,G|0,26)|0;k=Lg(p|0,o|0,k|0,G|0)|0;l=Ig(n|0,m|0,l&-67108864|0,0)|0;f[a>>2]=l;f[a+4>>2]=k;f[a+8>>2]=j;f[a+12>>2]=i;f[a+16>>2]=h;f[a+20>>2]=g;f[a+24>>2]=e;f[a+28>>2]=d;f[a+32>>2]=c;f[a+36>>2]=b;return}function ua(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0,oa=0,pa=0,qa=0,ra=0,sa=0,ta=0,ua=0,va=0,wa=0,xa=0,ya=0,za=0,Aa=0,Ba=0,Ca=0,Da=0,Ea=0,Fa=0,Ga=0,Ha=0,Ia=0,Ja=0,Ka=0,La=0,Ma=0,Na=0,Oa=0,Pa=0,Qa=0,Ra=0,Sa=0,Ta=0,Ua=0,Va=0,Wa=0,Xa=0,Ya=0,Za=0,_a=0,$a=0,ab=0,bb=0,cb=0,db=0,eb=0;r=f[b>>2]|0;c=f[b+4>>2]|0;j=f[b+8>>2]|0;i=f[b+12>>2]|0;Z=f[b+16>>2]|0;p=f[b+20>>2]|0;wa=f[b+24>>2]|0;d=f[b+28>>2]|0;Q=f[b+32>>2]|0;D=f[b+36>>2]|0;cb=Af(r|0,((r|0)<0)<<31>>31|0,r|0,((r|0)<0)<<31>>31|0)|0;bb=G;s=((r<<1|0)<0)<<31>>31;Ka=Af(r<<1|0,s|0,c|0,((c|0)<0)<<31>>31|0)|0;Ja=G;Wa=Af(j|0,((j|0)<0)<<31>>31|0,r<<1|0,s|0)|0;Va=G;Ua=Af(i|0,((i|0)<0)<<31>>31|0,r<<1|0,s|0)|0;Ta=G;Oa=Af(Z|0,((Z|0)<0)<<31>>31|0,r<<1|0,s|0)|0;Na=G;Aa=Af(p|0,((p|0)<0)<<31>>31|0,r<<1|0,s|0)|0;za=G;ha=Af(wa|0,((wa|0)<0)<<31>>31|0,r<<1|0,s|0)|0;ga=G;S=Af(d|0,((d|0)<0)<<31>>31|0,r<<1|0,s|0)|0;R=G;F=Af(Q|0,((Q|0)<0)<<31>>31|0,r<<1|0,s|0)|0;E=G;s=Af(D|0,((D|0)<0)<<31>>31|0,r<<1|0,s|0)|0;r=G;l=((c<<1|0)<0)<<31>>31;ua=Af(c<<1|0,l|0,c|0,((c|0)<0)<<31>>31|0)|0;va=G;ca=Af(c<<1|0,l|0,j|0,((j|0)<0)<<31>>31|0)|0;da=G;q=((i<<1|0)<0)<<31>>31;Sa=Af(i<<1|0,q|0,c<<1|0,l|0)|0;Ra=G;Ea=Af(Z|0,((Z|0)<0)<<31>>31|0,c<<1|0,l|0)|0;Da=G;ja=Af(p<<1|0,((p<<1|0)<0)<<31>>31|0,c<<1|0,l|0)|0;ia=G;U=Af(wa|0,((wa|0)<0)<<31>>31|0,c<<1|0,l|0)|0;T=G;I=Af(d<<1|0,((d<<1|0)<0)<<31>>31|0,c<<1|0,l|0)|0;H=G;u=Af(Q|0,((Q|0)<0)<<31>>31|0,c<<1|0,l|0)|0;t=G;C=((D*38|0)<0)<<31>>31;l=Af(D*38|0,C|0,c<<1|0,l|0)|0;c=G;Qa=Af(j|0,((j|0)<0)<<31>>31|0,j|0,((j|0)<0)<<31>>31|0)|0;Pa=G;Ca=Af(j<<1|0,((j<<1|0)<0)<<31>>31|0,i|0,((i|0)<0)<<31>>31|0)|0;Ba=G;la=Af(Z|0,((Z|0)<0)<<31>>31|0,j<<1|0,((j<<1|0)<0)<<31>>31|0)|0;ka=G;Y=Af(p|0,((p|0)<0)<<31>>31|0,j<<1|0,((j<<1|0)<0)<<31>>31|0)|0;X=G;O=Af(wa|0,((wa|0)<0)<<31>>31|0,j<<1|0,((j<<1|0)<0)<<31>>31|0)|0;N=G;w=Af(d|0,((d|0)<0)<<31>>31|0,j<<1|0,((j<<1|0)<0)<<31>>31|0)|0;v=G;fa=((Q*19|0)<0)<<31>>31;Ya=Af(Q*19|0,fa|0,j<<1|0,((j<<1|0)<0)<<31>>31|0)|0;Xa=G;j=Af(D*38|0,C|0,j|0,((j|0)<0)<<31>>31|0)|0;k=G;na=Af(i<<1|0,q|0,i|0,((i|0)<0)<<31>>31|0)|0;ma=G;W=Af(i<<1|0,q|0,Z|0,((Z|0)<0)<<31>>31|0)|0;V=G;K=Af(p<<1|0,((p<<1|0)<0)<<31>>31|0,i<<1|0,q|0)|0;J=G;A=Af(wa|0,((wa|0)<0)<<31>>31|0,i<<1|0,q|0)|0;z=G;B=((d*38|0)<0)<<31>>31;_a=Af(d*38|0,B|0,i<<1|0,q|0)|0;Za=G;Ga=Af(Q*19|0,fa|0,i<<1|0,q|0)|0;Fa=G;q=Af(D*38|0,C|0,i<<1|0,q|0)|0;i=G;M=Af(Z|0,((Z|0)<0)<<31>>31|0,Z|0,((Z|0)<0)<<31>>31|0)|0;L=G;y=Af(Z<<1|0,((Z<<1|0)<0)<<31>>31|0,p|0,((p|0)<0)<<31>>31|0)|0;x=G;ab=Af(wa*19|0,((wa*19|0)<0)<<31>>31|0,Z<<1|0,((Z<<1|0)<0)<<31>>31|0)|0;$a=G;Ia=Af(d*38|0,B|0,Z|0,((Z|0)<0)<<31>>31|0)|0;Ha=G;pa=Af(Q*19|0,fa|0,Z<<1|0,((Z<<1|0)<0)<<31>>31|0)|0;oa=G;Z=Af(D*38|0,C|0,Z|0,((Z|0)<0)<<31>>31|0)|0;g=G;eb=Af(p*38|0,((p*38|0)<0)<<31>>31|0,p|0,((p|0)<0)<<31>>31|0)|0;db=G;Ma=Af(wa*19|0,((wa*19|0)<0)<<31>>31|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;La=G;ra=Af(d*38|0,B|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;qa=G;$=Af(Q*19|0,fa|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;_=G;p=Af(D*38|0,C|0,p<<1|0,((p<<1|0)<0)<<31>>31|0)|0;e=G;ta=Af(wa*19|0,((wa*19|0)<0)<<31>>31|0,wa|0,((wa|0)<0)<<31>>31|0)|0;sa=G;ba=Af(d*38|0,B|0,wa|0,((wa|0)<0)<<31>>31|0)|0;aa=G;m=Af(Q*19|0,fa|0,wa<<1|0,((wa<<1|0)<0)<<31>>31|0)|0;n=G;wa=Af(D*38|0,C|0,wa|0,((wa|0)<0)<<31>>31|0)|0;h=G;B=Af(d*38|0,B|0,d|0,((d|0)<0)<<31>>31|0)|0;o=G;ya=Af(Q*19|0,fa|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;xa=G;b=Af(D*38|0,C|0,d<<1|0,((d<<1|0)<0)<<31>>31|0)|0;d=G;fa=Af(Q*19|0,fa|0,Q|0,((Q|0)<0)<<31>>31|0)|0;ea=G;Q=Af(D*38|0,C|0,Q|0,((Q|0)<0)<<31>>31|0)|0;P=G;D=Af(D*38|0,C|0,D|0,((D|0)<0)<<31>>31|0)|0;C=G;bb=Lg(eb|0,db|0,cb|0,bb|0)|0;$a=Lg(bb|0,G|0,ab|0,$a|0)|0;Za=Lg($a|0,G|0,_a|0,Za|0)|0;Xa=Lg(Za|0,G|0,Ya|0,Xa|0)|0;c=Lg(Xa|0,G|0,l|0,c|0)|0;l=G;va=Lg(Wa|0,Va|0,ua|0,va|0)|0;ua=G;da=Lg(Ua|0,Ta|0,ca|0,da|0)|0;ca=G;Pa=Lg(Sa|0,Ra|0,Qa|0,Pa|0)|0;Na=Lg(Pa|0,G|0,Oa|0,Na|0)|0;o=Lg(Na|0,G|0,B|0,o|0)|0;n=Lg(o|0,G|0,m|0,n|0)|0;e=Lg(n|0,G|0,p|0,e|0)|0;p=G;n=Lg(c|0,l|0,33554432,0)|0;m=G;o=Nf(n|0,m|0,26)|0;B=G;Ja=Lg(Ma|0,La|0,Ka|0,Ja|0)|0;Ha=Lg(Ja|0,G|0,Ia|0,Ha|0)|0;Fa=Lg(Ha|0,G|0,Ga|0,Fa|0)|0;k=Lg(Fa|0,G|0,j|0,k|0)|0;B=Lg(k|0,G|0,o|0,B|0)|0;o=G;m=Ig(c|0,l|0,n&-67108864|0,m|0)|0;n=G;l=Lg(e|0,p|0,33554432,0)|0;c=G;k=Nf(l|0,c|0,26)|0;j=G;Ba=Lg(Ea|0,Da|0,Ca|0,Ba|0)|0;za=Lg(Ba|0,G|0,Aa|0,za|0)|0;xa=Lg(za|0,G|0,ya|0,xa|0)|0;h=Lg(xa|0,G|0,wa|0,h|0)|0;j=Lg(h|0,G|0,k|0,j|0)|0;k=G;c=Ig(e|0,p|0,l&-67108864|0,c|0)|0;l=G;p=Lg(B|0,o|0,16777216,0)|0;e=Nf(p|0,G|0,25)|0;h=G;sa=Lg(va|0,ua|0,ta|0,sa|0)|0;qa=Lg(sa|0,G|0,ra|0,qa|0)|0;oa=Lg(qa|0,G|0,pa|0,oa|0)|0;i=Lg(oa|0,G|0,q|0,i|0)|0;h=Lg(i|0,G|0,e|0,h|0)|0;e=G;p=Ig(B|0,o|0,p&-33554432|0,0)|0;o=G;B=Lg(j|0,k|0,16777216,0)|0;i=Nf(B|0,G|0,25)|0;q=G;ka=Lg(na|0,ma|0,la|0,ka|0)|0;ia=Lg(ka|0,G|0,ja|0,ia|0)|0;ga=Lg(ia|0,G|0,ha|0,ga|0)|0;ea=Lg(ga|0,G|0,fa|0,ea|0)|0;d=Lg(ea|0,G|0,b|0,d|0)|0;q=Lg(d|0,G|0,i|0,q|0)|0;i=G;B=Ig(j|0,k|0,B&-33554432|0,0)|0;k=G;j=Lg(h|0,e|0,33554432,0)|0;d=Nf(j|0,G|0,26)|0;b=G;aa=Lg(da|0,ca|0,ba|0,aa|0)|0;_=Lg(aa|0,G|0,$|0,_|0)|0;g=Lg(_|0,G|0,Z|0,g|0)|0;b=Lg(g|0,G|0,d|0,b|0)|0;d=G;j=Ig(h|0,e|0,j&-67108864|0,0)|0;e=Lg(q|0,i|0,33554432,0)|0;h=Nf(e|0,G|0,26)|0;g=G;V=Lg(Y|0,X|0,W|0,V|0)|0;T=Lg(V|0,G|0,U|0,T|0)|0;R=Lg(T|0,G|0,S|0,R|0)|0;P=Lg(R|0,G|0,Q|0,P|0)|0;g=Lg(P|0,G|0,h|0,g|0)|0;h=G;e=Ig(q|0,i|0,e&-67108864|0,0)|0;i=Lg(b|0,d|0,16777216,0)|0;q=Nf(i|0,G|0,25)|0;l=Lg(q|0,G|0,c|0,l|0)|0;c=G;i=Ig(b|0,d|0,i&-33554432|0,0)|0;d=Lg(g|0,h|0,16777216,0)|0;b=Nf(d|0,G|0,25)|0;q=G;L=Lg(O|0,N|0,M|0,L|0)|0;J=Lg(L|0,G|0,K|0,J|0)|0;H=Lg(J|0,G|0,I|0,H|0)|0;E=Lg(H|0,G|0,F|0,E|0)|0;C=Lg(E|0,G|0,D|0,C|0)|0;q=Lg(C|0,G|0,b|0,q|0)|0;b=G;d=Ig(g|0,h|0,d&-33554432|0,0)|0;h=Lg(l|0,c|0,33554432,0)|0;g=$f(h|0,G|0,26)|0;g=Lg(B|0,k|0,g|0,G|0)|0;h=Ig(l|0,c|0,h&-67108864|0,0)|0;c=Lg(q|0,b|0,33554432,0)|0;l=Nf(c|0,G|0,26)|0;k=G;x=Lg(A|0,z|0,y|0,x|0)|0;v=Lg(x|0,G|0,w|0,v|0)|0;t=Lg(v|0,G|0,u|0,t|0)|0;r=Lg(t|0,G|0,s|0,r|0)|0;k=Lg(r|0,G|0,l|0,k|0)|0;l=G;c=Ig(q|0,b|0,c&-67108864|0,0)|0;b=Lg(k|0,l|0,16777216,0)|0;q=Nf(b|0,G|0,25)|0;q=Af(q|0,G|0,19,0)|0;n=Lg(q|0,G|0,m|0,n|0)|0;m=G;b=Ig(k|0,l|0,b&-33554432|0,0)|0;l=Lg(n|0,m|0,33554432,0)|0;k=$f(l|0,G|0,26)|0;k=Lg(p|0,o|0,k|0,G|0)|0;l=Ig(n|0,m|0,l&-67108864|0,0)|0;f[a>>2]=l;f[a+4>>2]=k;f[a+8>>2]=j;f[a+12>>2]=i;f[a+16>>2]=h;f[a+20>>2]=g;f[a+24>>2]=e;f[a+28>>2]=d;f[a+32>>2]=c;f[a+36>>2]=b;return}function va(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0;m=tf(e)|0;o=G;f=tf(e+8|0)|0;g=G;d=Wf(c|0,d|0,56)|0;e=G;if((b+c+(0-(c&7))|0)==(b|0)){q=f^2037671283;j=g^1952801890;n=m^1886610805;k=o^1936682341;i=f^1852075907;r=g^1685025377;g=m^1852142177;f=o^1819895653}else{s=b;q=f^2037671283;j=g^1952801890;n=m^1886610805;l=o^1936682341;k=f^1852075907;i=g^1685025377;g=m^1852142177;f=o^1819895653;while(1){p=tf(s)|0;t=G;v=p^q;j=t^j;l=Lg(n|0,l|0,k|0,i|0)|0;r=G;n=yf(k,i,13)|0;k=G^r;r=yf(l,r,32)|0;q=G;m=Lg(v|0,j|0,g|0,f|0)|0;o=G;j=yf(v,j,16)|0;i=G^o;q=Lg(j^m|0,i|0,r|0,q|0)|0;r=G;i=yf(j^m,i,21)|0;j=r^G;o=Lg(m|0,o|0,n^l|0,k|0)|0;m=G;k=yf(n^l,k,17)|0;f=G^m;m=yf(o,m,32)|0;g=G;r=Lg(k^o|0,f|0,q|0,r|0)|0;l=G;f=yf(k^o,f,13)|0;o=G^l;l=yf(r,l,32)|0;k=G;g=Lg(m|0,g|0,q^i|0,j|0)|0;m=G;j=yf(q^i,j,16)|0;i=G^m;k=Lg(j^g|0,i|0,l|0,k|0)|0;l=G;i=yf(j^g,i,21)|0;j=l^G;m=Lg(f^r|0,o|0,g|0,m|0)|0;g=G;o=yf(f^r,o,17)|0;r=G^g;g=yf(m,g,32)|0;f=G;s=s+8|0;if((s|0)==(b+c+(0-(c&7))|0)){b=b+c+(0-(c&7))|0;q=k^i;n=k^p;k=l^t;i=o^m;break}else{q=k^i;n=k^p;l=l^t;k=o^m;i=r}}}switch(c&7){case 7:{d=Wf(h[b+6>>0]|0|0,0,48)|0|d;e=G|e;u=6;break}case 6:{u=6;break}case 5:{u=7;break}case 4:{u=8;break}case 3:{u=9;break}case 2:{u=10;break}case 1:{u=11;break}default:{}}if((u|0)==6){v=Wf(h[b+5>>0]|0|0,0,40)|0;e=G|e;d=v|d;u=7}if((u|0)==7){e=h[b+4>>0]|0|e;u=8}if((u|0)==8){v=Wf(h[b+3>>0]|0|0,0,24)|0;d=v|d;e=G|e;u=9}if((u|0)==9){v=Wf(h[b+2>>0]|0|0,0,16)|0;d=v|d;e=G|e;u=10}if((u|0)==10){v=Wf(h[b+1>>0]|0|0,0,8)|0;d=v|d;e=G|e;u=11}if((u|0)==11)d=d|(h[b>>0]|0);t=d^q;c=e^j;b=Lg(n|0,k|0,i|0,r|0)|0;v=G;u=yf(i,r,13)|0;o=G^v;v=yf(b,v,32)|0;q=G;s=Lg(t|0,c|0,g|0,f|0)|0;p=G;r=yf(t,c,16)|0;c=G^p;q=Lg(r^s|0,c|0,v|0,q|0)|0;v=G;c=yf(r^s,c,21)|0;r=v^G;p=Lg(s|0,p|0,u^b|0,o|0)|0;s=G;o=yf(u^b,o,17)|0;b=G^s;s=yf(p,s,32)|0;u=G;v=Lg(o^p|0,b|0,q|0,v|0)|0;t=G;b=yf(o^p,b,13)|0;p=G^t;t=yf(v,t,32)|0;o=G;u=Lg(s|0,u|0,q^c|0,r|0)|0;s=G;r=yf(q^c,r,16)|0;c=G^s;o=Lg(r^u|0,c|0,t|0,o|0)|0;t=G;c=yf(r^u,c,21)|0;r=t^G;s=Lg(b^v|0,p|0,u|0,s|0)|0;u=G;p=yf(b^v,p,17)|0;v=G^u;u=yf(s,u,32)|0;b=G;t=Lg(o^d|0,t^e|0,p^s|0,v|0)|0;q=G;v=yf(p^s,v,13)|0;s=G^q;q=yf(t,q,32)|0;p=G;b=Lg(u^238|0,b|0,o^c|0,r|0)|0;u=G;r=yf(o^c,r,16)|0;c=G^u;p=Lg(r^b|0,c|0,q|0,p|0)|0;q=G;c=yf(r^b,c,21)|0;r=q^G;u=Lg(b|0,u|0,v^t|0,s|0)|0;b=G;s=yf(v^t,s,17)|0;t=G^b;b=yf(u,b,32)|0;v=G;q=Lg(s^u|0,t|0,p|0,q|0)|0;o=G;t=yf(s^u,t,13)|0;u=G^o;o=yf(q,o,32)|0;s=G;v=Lg(b|0,v|0,p^c|0,r|0)|0;b=G;r=yf(p^c,r,16)|0;c=G^b;s=Lg(r^v|0,c|0,o|0,s|0)|0;o=G;c=yf(r^v,c,21)|0;r=o^G;b=Lg(t^q|0,u|0,v|0,b|0)|0;v=G;u=yf(t^q,u,17)|0;q=G^v;v=yf(b,v,32)|0;t=G;o=Lg(u^b|0,q|0,s|0,o|0)|0;p=G;q=yf(u^b,q,13)|0;b=G^p;p=yf(o,p,32)|0;u=G;t=Lg(v|0,t|0,s^c|0,r|0)|0;v=G;r=yf(s^c,r,16)|0;c=G^v;u=Lg(r^t|0,c|0,p|0,u|0)|0;p=G;c=yf(r^t,c,21)|0;r=p^G;v=Lg(q^o|0,b|0,t|0,v|0)|0;t=G;b=yf(q^o,b,17)|0;o=G^t;t=yf(v,t,32)|0;q=G;p=Lg(b^v|0,o|0,u|0,p|0)|0;s=G;o=yf(b^v,o,13)|0;v=G^s;s=yf(p,s,32)|0;b=G;q=Lg(t|0,q|0,u^c|0,r|0)|0;t=G;r=yf(u^c,r,16)|0;c=G^t;b=Lg(r^q|0,c|0,s|0,b|0)|0;s=G;c=yf(r^q,c,21)|0;r=s^G;t=Lg(o^p|0,v|0,q|0,t|0)|0;q=G;v=yf(o^p,v,17)|0;p=G^q;q=yf(t,q,32)|0;o=G;We(a,v^t^b^q^(b^c),p^s^o^r);s=Lg(v^t^221|0,p|0,b|0,s|0)|0;u=G;p=yf(v^t^221,p,13)|0;t=G^u;u=yf(s,u,32)|0;v=G;o=Lg(q|0,o|0,b^c|0,r|0)|0;q=G;r=yf(b^c,r,16)|0;c=G^q;v=Lg(r^o|0,c|0,u|0,v|0)|0;u=G;c=yf(r^o,c,21)|0;r=u^G;q=Lg(p^s|0,t|0,o|0,q|0)|0;o=G;t=yf(p^s,t,17)|0;s=G^o;o=yf(q,o,32)|0;p=G;u=Lg(t^q|0,s|0,v|0,u|0)|0;b=G;s=yf(t^q,s,13)|0;q=G^b;b=yf(u,b,32)|0;t=G;p=Lg(o|0,p|0,v^c|0,r|0)|0;o=G;r=yf(v^c,r,16)|0;c=G^o;t=Lg(r^p|0,c|0,b|0,t|0)|0;b=G;c=yf(r^p,c,21)|0;r=b^G;o=Lg(s^u|0,q|0,p|0,o|0)|0;p=G;q=yf(s^u,q,17)|0;u=G^p;p=yf(o,p,32)|0;s=G;b=Lg(q^o|0,u|0,t|0,b|0)|0;v=G;u=yf(q^o,u,13)|0;o=G^v;v=yf(b,v,32)|0;q=G;s=Lg(p|0,s|0,t^c|0,r|0)|0;p=G;r=yf(t^c,r,16)|0;c=G^p;q=Lg(r^s|0,c|0,v|0,q|0)|0;v=G;c=yf(r^s,c,21)|0;r=v^G;p=Lg(u^b|0,o|0,s|0,p|0)|0;s=G;o=yf(u^b,o,17)|0;b=G^s;s=yf(p,s,32)|0;u=G;v=Lg(o^p|0,b|0,q|0,v|0)|0;t=G;b=yf(o^p,b,13)|0;t=G^t;u=Lg(s|0,u|0,q^c|0,r|0)|0;s=G;r=yf(q^c,r,16)|0;r=yf(r^u,G^s,21)|0;c=G;s=Lg(b^v|0,t|0,u|0,s|0)|0;u=G;t=yf(b^v,t,17)|0;v=G;b=yf(s,u,32)|0;We(a+8|0,r^s^t^b,c^u^v^G);return 0}function wa(a){a=a|0;var b=0,c=0,d=0,e=0,g=0,h=0,i=0,j=0;if(!a)return;b=f[8882]|0;c=f[a+-4>>2]|0;j=a+-8+(c&-8)|0;do if(!(c&1)){d=f[a+-8>>2]|0;if(!(c&3))return;h=a+-8+(0-d)|0;g=d+(c&-8)|0;if(h>>>0<b>>>0)return;if((f[8883]|0)==(h|0)){b=f[j+4>>2]|0;if((b&3|0)!=3){i=h;b=g;break}f[8880]=g;f[j+4>>2]=b&-2;f[h+4>>2]=g|1;f[h+g>>2]=g;return}if(d>>>0<256){b=f[h+8>>2]|0;a=f[h+12>>2]|0;if((a|0)==(b|0)){f[8878]=f[8878]&~(1<<(d>>>3));i=h;b=g;break}else{f[b+12>>2]=a;f[a+8>>2]=b;i=h;b=g;break}}e=f[h+24>>2]|0;b=f[h+12>>2]|0;do if((b|0)==(h|0)){b=f[h+16+4>>2]|0;if(!b){b=f[h+16>>2]|0;if(!b){b=0;break}else a=h+16|0}else a=h+16+4|0;while(1){d=b+20|0;c=f[d>>2]|0;if(!c){d=b+16|0;c=f[d>>2]|0;if(!c)break;else{b=c;a=d}}else{b=c;a=d}}f[a>>2]=0}else{i=f[h+8>>2]|0;f[i+12>>2]=b;f[b+8>>2]=i}while(0);if(e){a=f[h+28>>2]|0;if((f[35816+(a<<2)>>2]|0)==(h|0)){f[35816+(a<<2)>>2]=b;if(!b){f[8879]=f[8879]&~(1<<a);i=h;b=g;break}}else{f[((f[e+16>>2]|0)==(h|0)?e+16|0:e+20|0)>>2]=b;if(!b){i=h;b=g;break}}f[b+24>>2]=e;a=f[h+16>>2]|0;if(a|0){f[b+16>>2]=a;f[a+24>>2]=b}a=f[h+16+4>>2]|0;if(a){f[b+20>>2]=a;f[a+24>>2]=b;i=h;b=g}else{i=h;b=g}}else{i=h;b=g}}else{i=a+-8|0;b=c&-8;h=a+-8|0}while(0);if(h>>>0>=j>>>0)return;c=f[j+4>>2]|0;if(!(c&1))return;if(!(c&2)){if((f[8884]|0)==(j|0)){j=(f[8881]|0)+b|0;f[8881]=j;f[8884]=i;f[i+4>>2]=j|1;if((i|0)!=(f[8883]|0))return;f[8883]=0;f[8880]=0;return}if((f[8883]|0)==(j|0)){j=(f[8880]|0)+b|0;f[8880]=j;f[8883]=h;f[i+4>>2]=j|1;f[h+j>>2]=j;return}e=(c&-8)+b|0;do if(c>>>0<256){a=f[j+8>>2]|0;b=f[j+12>>2]|0;if((b|0)==(a|0)){f[8878]=f[8878]&~(1<<(c>>>3));break}else{f[a+12>>2]=b;f[b+8>>2]=a;break}}else{g=f[j+24>>2]|0;b=f[j+12>>2]|0;do if((b|0)==(j|0)){b=f[j+16+4>>2]|0;if(!b){b=f[j+16>>2]|0;if(!b){a=0;break}else a=j+16|0}else a=j+16+4|0;while(1){d=b+20|0;c=f[d>>2]|0;if(!c){d=b+16|0;c=f[d>>2]|0;if(!c)break;else{b=c;a=d}}else{b=c;a=d}}f[a>>2]=0;a=b}else{a=f[j+8>>2]|0;f[a+12>>2]=b;f[b+8>>2]=a;a=b}while(0);if(g|0){b=f[j+28>>2]|0;if((f[35816+(b<<2)>>2]|0)==(j|0)){f[35816+(b<<2)>>2]=a;if(!a){f[8879]=f[8879]&~(1<<b);break}}else{f[((f[g+16>>2]|0)==(j|0)?g+16|0:g+20|0)>>2]=a;if(!a)break}f[a+24>>2]=g;b=f[j+16>>2]|0;if(b|0){f[a+16>>2]=b;f[b+24>>2]=a}b=f[j+16+4>>2]|0;if(b|0){f[a+20>>2]=b;f[b+24>>2]=a}}}while(0);f[i+4>>2]=e|1;f[h+e>>2]=e;if((i|0)==(f[8883]|0)){f[8880]=e;return}}else{f[j+4>>2]=c&-2;f[i+4>>2]=b|1;f[h+b>>2]=b;e=b}c=e>>>3;if(e>>>0<256){b=f[8878]|0;if(!(b&1<<c)){f[8878]=b|1<<c;b=35552+(c<<1<<2)|0;a=35552+(c<<1<<2)+8|0}else{b=f[35552+(c<<1<<2)+8>>2]|0;a=35552+(c<<1<<2)+8|0}f[a>>2]=i;f[b+12>>2]=i;f[i+8>>2]=b;f[i+12>>2]=35552+(c<<1<<2);return}b=e>>>8;if(b)if(e>>>0>16777215)d=31;else{d=b<<((b+1048320|0)>>>16&8)<<(((b<<((b+1048320|0)>>>16&8))+520192|0)>>>16&4);d=14-(((b<<((b+1048320|0)>>>16&8))+520192|0)>>>16&4|(b+1048320|0)>>>16&8|(d+245760|0)>>>16&2)+(d<<((d+245760|0)>>>16&2)>>>15)|0;d=e>>>(d+7|0)&1|d<<1}else d=0;b=35816+(d<<2)|0;f[i+28>>2]=d;f[i+20>>2]=0;f[i+16>>2]=0;a=f[8879]|0;c=1<<d;a:do if(!(a&c)){f[8879]=a|c;f[b>>2]=i;f[i+24>>2]=b;f[i+12>>2]=i;f[i+8>>2]=i}else{b=f[b>>2]|0;b:do if((f[b+4>>2]&-8|0)!=(e|0)){d=e<<((d|0)==31?0:25-(d>>>1)|0);while(1){c=b+16+(d>>>31<<2)|0;a=f[c>>2]|0;if(!a)break;if((f[a+4>>2]&-8|0)==(e|0)){b=a;break b}else{d=d<<1;b=a}}f[c>>2]=i;f[i+24>>2]=b;f[i+12>>2]=i;f[i+8>>2]=i;break a}while(0);h=b+8|0;j=f[h>>2]|0;f[j+12>>2]=i;f[h>>2]=i;f[i+8>>2]=j;f[i+12>>2]=b;f[i+24>>2]=0}while(0);j=(f[8886]|0)+-1|0;f[8886]=j;if(j|0)return;b=35968;while(1){b=f[b>>2]|0;if(!b)break;else b=b+8|0}f[8886]=-1;return}function xa(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0;c=f[a+4>>2]|0;do if(!(c&1)){i=f[a>>2]|0;if(!(c&3))return;if((f[8883]|0)==(a+(0-i)|0)){c=f[a+b+4>>2]|0;if((c&3|0)!=3){j=a+(0-i)|0;c=i+b|0;break}f[8880]=i+b;f[a+b+4>>2]=c&-2;f[a+(0-i)+4>>2]=i+b|1;f[a+b>>2]=i+b;return}if(i>>>0<256){c=f[a+(0-i)+8>>2]|0;d=f[a+(0-i)+12>>2]|0;if((d|0)==(c|0)){f[8878]=f[8878]&~(1<<(i>>>3));j=a+(0-i)|0;c=i+b|0;break}else{f[c+12>>2]=d;f[d+8>>2]=c;j=a+(0-i)|0;c=i+b|0;break}}h=f[a+(0-i)+24>>2]|0;c=f[a+(0-i)+12>>2]|0;do if((c|0)==(a+(0-i)|0)){d=a+(0-i)+16|0;c=f[d+4>>2]|0;if(!c){c=f[d>>2]|0;if(!c){c=0;break}}else d=d+4|0;while(1){g=c+20|0;e=f[g>>2]|0;if(!e){g=c+16|0;e=f[g>>2]|0;if(!e)break;else{c=e;d=g}}else{c=e;d=g}}f[d>>2]=0}else{j=f[a+(0-i)+8>>2]|0;f[j+12>>2]=c;f[c+8>>2]=j}while(0);if(h){d=f[a+(0-i)+28>>2]|0;if((f[35816+(d<<2)>>2]|0)==(a+(0-i)|0)){f[35816+(d<<2)>>2]=c;if(!c){f[8879]=f[8879]&~(1<<d);j=a+(0-i)|0;c=i+b|0;break}}else{f[((f[h+16>>2]|0)==(a+(0-i)|0)?h+16|0:h+20|0)>>2]=c;if(!c){j=a+(0-i)|0;c=i+b|0;break}}f[c+24>>2]=h;d=f[a+(0-i)+16>>2]|0;if(d|0){f[c+16>>2]=d;f[d+24>>2]=c}d=f[a+(0-i)+16+4>>2]|0;if(d){f[c+20>>2]=d;f[d+24>>2]=c;j=a+(0-i)|0;c=i+b|0}else{j=a+(0-i)|0;c=i+b|0}}else{j=a+(0-i)|0;c=i+b|0}}else{j=a;c=b}while(0);e=f[a+b+4>>2]|0;if(!(e&2)){if((f[8884]|0)==(a+b|0)){b=(f[8881]|0)+c|0;f[8881]=b;f[8884]=j;f[j+4>>2]=b|1;if((j|0)!=(f[8883]|0))return;f[8883]=0;f[8880]=0;return}if((f[8883]|0)==(a+b|0)){b=(f[8880]|0)+c|0;f[8880]=b;f[8883]=j;f[j+4>>2]=b|1;f[j+b>>2]=b;return}h=(e&-8)+c|0;do if(e>>>0<256){d=f[a+b+8>>2]|0;c=f[a+b+12>>2]|0;if((c|0)==(d|0)){f[8878]=f[8878]&~(1<<(e>>>3));break}else{f[d+12>>2]=c;f[c+8>>2]=d;break}}else{i=f[a+b+24>>2]|0;c=f[a+b+12>>2]|0;do if((c|0)==(a+b|0)){c=f[a+b+16+4>>2]|0;if(!c){c=f[a+b+16>>2]|0;if(!c){d=0;break}else d=a+b+16|0}else d=a+b+16+4|0;while(1){g=c+20|0;e=f[g>>2]|0;if(!e){g=c+16|0;e=f[g>>2]|0;if(!e)break;else{c=e;d=g}}else{c=e;d=g}}f[d>>2]=0;d=c}else{d=f[a+b+8>>2]|0;f[d+12>>2]=c;f[c+8>>2]=d;d=c}while(0);if(i|0){c=f[a+b+28>>2]|0;if((f[35816+(c<<2)>>2]|0)==(a+b|0)){f[35816+(c<<2)>>2]=d;if(!d){f[8879]=f[8879]&~(1<<c);break}}else{f[((f[i+16>>2]|0)==(a+b|0)?i+16|0:i+20|0)>>2]=d;if(!d)break}f[d+24>>2]=i;c=f[a+b+16>>2]|0;if(c|0){f[d+16>>2]=c;f[c+24>>2]=d}c=f[a+b+16+4>>2]|0;if(c|0){f[d+20>>2]=c;f[c+24>>2]=d}}}while(0);f[j+4>>2]=h|1;f[j+h>>2]=h;if((j|0)==(f[8883]|0)){f[8880]=h;return}}else{f[a+b+4>>2]=e&-2;f[j+4>>2]=c|1;f[j+c>>2]=c;h=c}e=h>>>3;if(h>>>0<256){c=f[8878]|0;if(!(c&1<<e)){f[8878]=c|1<<e;c=35552+(e<<1<<2)|0;d=35552+(e<<1<<2)+8|0}else{c=f[35552+(e<<1<<2)+8>>2]|0;d=35552+(e<<1<<2)+8|0}f[d>>2]=j;f[c+12>>2]=j;f[j+8>>2]=c;f[j+12>>2]=35552+(e<<1<<2);return}c=h>>>8;if(c)if(h>>>0>16777215)g=31;else{g=c<<((c+1048320|0)>>>16&8)<<(((c<<((c+1048320|0)>>>16&8))+520192|0)>>>16&4);g=14-(((c<<((c+1048320|0)>>>16&8))+520192|0)>>>16&4|(c+1048320|0)>>>16&8|(g+245760|0)>>>16&2)+(g<<((g+245760|0)>>>16&2)>>>15)|0;g=h>>>(g+7|0)&1|g<<1}else g=0;c=35816+(g<<2)|0;f[j+28>>2]=g;f[j+20>>2]=0;f[j+16>>2]=0;d=f[8879]|0;e=1<<g;if(!(d&e)){f[8879]=d|e;f[c>>2]=j;f[j+24>>2]=c;f[j+12>>2]=j;f[j+8>>2]=j;return}c=f[c>>2]|0;a:do if((f[c+4>>2]&-8|0)!=(h|0)){g=h<<((g|0)==31?0:25-(g>>>1)|0);while(1){e=c+16+(g>>>31<<2)|0;d=f[e>>2]|0;if(!d)break;if((f[d+4>>2]&-8|0)==(h|0)){c=d;break a}else{g=g<<1;c=d}}f[e>>2]=j;f[j+24>>2]=c;f[j+12>>2]=j;f[j+8>>2]=j;return}while(0);a=c+8|0;b=f[a>>2]|0;f[b+12>>2]=j;f[a>>2]=j;f[j+8>>2]=b;f[j+12>>2]=c;f[j+24>>2]=0;return}function ya(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0;m=tf(e)|0;o=G;f=tf(e+8|0)|0;g=G;d=Wf(c|0,d|0,56)|0;e=G;if((b+c+(0-(c&7))|0)==(b|0)){q=f^2037671283;j=g^1952801890;n=m^1886610805;k=o^1936682341;i=f^1852075885;r=g^1685025377;g=m^1852142177;f=o^1819895653}else{s=b;q=f^2037671283;j=g^1952801890;n=m^1886610805;l=o^1936682341;k=f^1852075885;i=g^1685025377;g=m^1852142177;f=o^1819895653;while(1){p=tf(s)|0;t=G;v=p^q;j=t^j;l=Lg(n|0,l|0,k|0,i|0)|0;r=G;n=yf(k,i,13)|0;k=G^r;r=yf(l,r,32)|0;q=G;m=Lg(v|0,j|0,g|0,f|0)|0;o=G;j=yf(v,j,16)|0;i=G^o;q=Lg(j^m|0,i|0,r|0,q|0)|0;r=G;i=yf(j^m,i,21)|0;j=r^G;o=Lg(m|0,o|0,n^l|0,k|0)|0;m=G;k=yf(n^l,k,17)|0;f=G^m;m=yf(o,m,32)|0;g=G;r=Lg(k^o|0,f|0,q|0,r|0)|0;l=G;f=yf(k^o,f,13)|0;o=G^l;l=yf(r,l,32)|0;k=G;g=Lg(m|0,g|0,q^i|0,j|0)|0;m=G;j=yf(q^i,j,16)|0;i=G^m;k=Lg(j^g|0,i|0,l|0,k|0)|0;l=G;i=yf(j^g,i,21)|0;j=l^G;m=Lg(f^r|0,o|0,g|0,m|0)|0;g=G;o=yf(f^r,o,17)|0;r=G^g;g=yf(m,g,32)|0;f=G;s=s+8|0;if((s|0)==(b+c+(0-(c&7))|0)){b=b+c+(0-(c&7))|0;q=k^i;n=k^p;k=l^t;i=o^m;break}else{q=k^i;n=k^p;l=l^t;k=o^m;i=r}}}switch(c&7){case 7:{d=Wf(h[b+6>>0]|0|0,0,48)|0|d;e=G|e;u=6;break}case 6:{u=6;break}case 5:{u=7;break}case 4:{u=8;break}case 3:{u=9;break}case 2:{u=10;break}case 1:{u=11;break}default:{}}if((u|0)==6){v=Wf(h[b+5>>0]|0|0,0,40)|0;e=G|e;d=v|d;u=7}if((u|0)==7){e=h[b+4>>0]|0|e;u=8}if((u|0)==8){v=Wf(h[b+3>>0]|0|0,0,24)|0;d=v|d;e=G|e;u=9}if((u|0)==9){v=Wf(h[b+2>>0]|0|0,0,16)|0;d=v|d;e=G|e;u=10}if((u|0)==10){v=Wf(h[b+1>>0]|0|0,0,8)|0;d=v|d;e=G|e;u=11}if((u|0)==11)d=d|(h[b>>0]|0);s=d^q;c=e^j;o=Lg(n|0,k|0,i|0,r|0)|0;p=G;q=yf(i,r,13)|0;b=G^p;p=yf(o,p,32)|0;u=G;t=Lg(s|0,c|0,g|0,f|0)|0;v=G;r=yf(s,c,16)|0;c=G^v;u=Lg(r^t|0,c|0,p|0,u|0)|0;p=G;c=yf(r^t,c,21)|0;r=p^G;v=Lg(t|0,v|0,q^o|0,b|0)|0;t=G;b=yf(q^o,b,17)|0;o=G^t;t=yf(v,t,32)|0;q=G;p=Lg(b^v|0,o|0,u|0,p|0)|0;s=G;o=yf(b^v,o,13)|0;v=G^s;s=yf(p,s,32)|0;b=G;q=Lg(t|0,q|0,u^c|0,r|0)|0;t=G;r=yf(u^c,r,16)|0;c=G^t;b=Lg(r^q|0,c|0,s|0,b|0)|0;s=G;c=yf(r^q,c,21)|0;r=s^G;t=Lg(o^p|0,v|0,q|0,t|0)|0;q=G;v=yf(o^p,v,17)|0;p=G^q;q=yf(t,q,32)|0;o=G;s=Lg(b^d|0,s^e|0,v^t|0,p|0)|0;u=G;p=yf(v^t,p,13)|0;t=G^u;u=yf(s,u,32)|0;v=G;o=Lg(q^255|0,o|0,b^c|0,r|0)|0;q=G;r=yf(b^c,r,16)|0;c=G^q;v=Lg(r^o|0,c|0,u|0,v|0)|0;u=G;c=yf(r^o,c,21)|0;r=u^G;q=Lg(o|0,q|0,p^s|0,t|0)|0;o=G;t=yf(p^s,t,17)|0;s=G^o;o=yf(q,o,32)|0;p=G;u=Lg(t^q|0,s|0,v|0,u|0)|0;b=G;s=yf(t^q,s,13)|0;q=G^b;b=yf(u,b,32)|0;t=G;p=Lg(o|0,p|0,v^c|0,r|0)|0;o=G;r=yf(v^c,r,16)|0;c=G^o;t=Lg(r^p|0,c|0,b|0,t|0)|0;b=G;c=yf(r^p,c,21)|0;r=b^G;o=Lg(s^u|0,q|0,p|0,o|0)|0;p=G;q=yf(s^u,q,17)|0;u=G^p;p=yf(o,p,32)|0;s=G;b=Lg(q^o|0,u|0,t|0,b|0)|0;v=G;u=yf(q^o,u,13)|0;o=G^v;v=yf(b,v,32)|0;q=G;s=Lg(p|0,s|0,t^c|0,r|0)|0;p=G;r=yf(t^c,r,16)|0;c=G^p;q=Lg(r^s|0,c|0,v|0,q|0)|0;v=G;c=yf(r^s,c,21)|0;r=v^G;p=Lg(u^b|0,o|0,s|0,p|0)|0;s=G;o=yf(u^b,o,17)|0;b=G^s;s=yf(p,s,32)|0;u=G;v=Lg(o^p|0,b|0,q|0,v|0)|0;t=G;b=yf(o^p,b,13)|0;t=G^t;u=Lg(s|0,u|0,q^c|0,r|0)|0;s=G;r=yf(q^c,r,16)|0;r=yf(r^u,G^s,21)|0;c=G;s=Lg(b^v|0,t|0,u|0,s|0)|0;u=G;t=yf(b^v,t,17)|0;v=G;b=yf(s,u,32)|0;We(a,r^s^t^b,c^u^v^G);return 0}function za(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0,Z=0,_=0,$=0,aa=0,ba=0,ca=0,da=0,ea=0,fa=0,ga=0,ha=0,ia=0,ja=0,ka=0,la=0,ma=0,na=0;T=t;S=t=t+63&-64;t=t+64|0;if(!((e|0)==0&(g|0)==0)){if(g>>>0>0|(g|0)==0&e>>>0>4294967295)Fj();D=f[a>>2]|0;E=f[a+4>>2]|0;F=f[a+8>>2]|0;H=f[a+12>>2]|0;I=f[a+16>>2]|0;J=f[a+20>>2]|0;K=f[a+24>>2]|0;L=f[a+28>>2]|0;M=f[a+32>>2]|0;N=f[a+36>>2]|0;O=f[a+40>>2]|0;P=f[a+44>>2]|0;Q=f[a+56>>2]|0;R=f[a+60>>2]|0;h=0;A=f[a+52>>2]|0;y=f[a+48>>2]|0;B=g;C=e;while(1){z=B>>>0<0|(B|0)==0&C>>>0<64;if(z){g=S;e=g+64|0;do{f[g>>2]=0;g=g+4|0}while((g|0)<(e|0));g=0;do{b[S+g>>0]=b[c+g>>0]|0;g=g+1|0}while(B>>>0>0|(B|0)==0&C>>>0>g>>>0);h=d;c=S;d=S}g=D;e=E;i=F;j=H;k=I;l=J;m=K;n=L;o=M;p=N;q=O;r=R;s=Q;u=A;v=y;w=P;x=20;do{la=g+k|0;aa=oi(la^v,16)|0;$=aa+o|0;ma=oi($^k,12)|0;aa=oi(ma+la^aa,8)|0;Y=oi(aa+$^ma,7)|0;ha=e+l|0;W=oi(ha^u,16)|0;V=W+p|0;ia=oi(V^l,12)|0;W=oi(ia+ha^W,8)|0;na=oi(W+V^ia,7)|0;ca=i+m|0;X=oi(ca^s,16)|0;ba=X+q|0;da=oi(ba^m,12)|0;X=oi(da+ca^X,8)|0;ja=oi(X+ba^da,7)|0;Z=j+n|0;fa=oi(Z^r,16)|0;U=fa+w|0;_=oi(U^n,12)|0;fa=oi(_+Z^fa,8)|0;ea=oi(fa+U^_,7)|0;ka=oi(fa^na+(ma+la),16)|0;ga=oi(ka+(X+ba)^na,12)|0;g=ga+(na+(ma+la))|0;r=oi(g^ka,8)|0;q=r+(ka+(X+ba))|0;l=oi(q^ga,7)|0;ga=oi(ja+(ia+ha)^aa,16)|0;ba=oi(ga+(fa+U)^ja,12)|0;e=ba+(ja+(ia+ha))|0;v=oi(e^ga,8)|0;w=v+(ga+(fa+U))|0;m=oi(w^ba,7)|0;ba=oi(ea+(da+ca)^W,16)|0;U=oi(ba+(aa+$)^ea,12)|0;i=U+(ea+(da+ca))|0;u=oi(i^ba,8)|0;o=u+(ba+(aa+$))|0;n=oi(o^U,7)|0;X=oi(_+Z+Y^X,16)|0;U=oi(X+(W+V)^Y,12)|0;j=U+(_+Z+Y)|0;s=oi(j^X,8)|0;p=s+(X+(W+V))|0;k=oi(p^U,7)|0;x=x+-2|0}while((x|0)!=0);_=(yh(c)|0)^g+D;$=(yh(c+4|0)|0)^e+E;aa=(yh(c+8|0)|0)^i+F;ba=(yh(c+12|0)|0)^j+H;ca=(yh(c+16|0)|0)^k+I;da=(yh(c+20|0)|0)^l+J;ea=(yh(c+24|0)|0)^m+K;fa=(yh(c+28|0)|0)^n+L;ga=(yh(c+32|0)|0)^o+M;ha=(yh(c+36|0)|0)^p+N;ia=(yh(c+40|0)|0)^q+O;ja=(yh(c+44|0)|0)^w+P;ka=(yh(c+48|0)|0)^v+y;la=(yh(c+52|0)|0)^u+A;ma=(yh(c+56|0)|0)^s+Q;na=(yh(c+60|0)|0)^r+R;e=y+1|0;g=A+((e|0)==0&1)|0;Qg(d,_);Qg(d+4|0,$);Qg(d+8|0,aa);Qg(d+12|0,ba);Qg(d+16|0,ca);Qg(d+20|0,da);Qg(d+24|0,ea);Qg(d+28|0,fa);Qg(d+32|0,ga);Qg(d+36|0,ha);Qg(d+40|0,ia);Qg(d+44|0,ja);Qg(d+48|0,ka);Qg(d+52|0,la);Qg(d+56|0,ma);Qg(d+60|0,na);if(B>>>0<0|(B|0)==0&C>>>0<65)break;na=Lg(C|0,B|0,-64,-1)|0;c=c+64|0;d=d+64|0;A=g;y=e;B=G;C=na}if(z?C|0:0){c=0;do{b[h+c>>0]=b[d+c>>0]|0;c=c+1|0}while((c|0)!=(C|0))}f[a+48>>2]=e;f[a+52>>2]=g}t=T;return}function Aa(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0;s=(b[a+80>>0]|0)==0?16777216:0;t=f[a+4>>2]|0;o=f[a+8>>2]|0;p=f[a+12>>2]|0;q=f[a+16>>2]|0;k=f[a+20>>2]|0;j=f[a+24>>2]|0;i=f[a+28>>2]|0;h=f[a+32>>2]|0;g=f[a+36>>2]|0;if(e>>>0>0|(e|0)==0&d>>>0>15){r=f[a>>2]|0;m=d;while(1){y=((yh(c)|0)&67108863)+k|0;z=((yh(c+3|0)|0)>>>2&67108863)+j|0;x=((yh(c+6|0)|0)>>>4&67108863)+i|0;w=((yh(c+9|0)|0)>>>6)+h|0;k=((yh(c+12|0)|0)>>>8|s)+g|0;g=Af(y|0,0,r|0,0)|0;d=G;i=Af(z|0,0,q*5|0,0)|0;d=Lg(i|0,G|0,g|0,d|0)|0;g=G;i=Af(x|0,0,p*5|0,0)|0;i=Lg(d|0,g|0,i|0,G|0)|0;g=G;d=Af(w|0,0,o*5|0,0)|0;d=Lg(i|0,g|0,d|0,G|0)|0;g=G;i=Af(k|0,0,t*5|0,0)|0;i=Lg(d|0,g|0,i|0,G|0)|0;g=G;d=Af(y|0,0,t|0,0)|0;l=G;v=Af(z|0,0,r|0,0)|0;l=Lg(v|0,G|0,d|0,l|0)|0;d=G;v=Af(x|0,0,q*5|0,0)|0;v=Lg(l|0,d|0,v|0,G|0)|0;d=G;l=Af(w|0,0,p*5|0,0)|0;l=Lg(v|0,d|0,l|0,G|0)|0;d=G;v=Af(k|0,0,o*5|0,0)|0;v=Lg(l|0,d|0,v|0,G|0)|0;d=G;l=Af(y|0,0,o|0,0)|0;n=G;u=Af(z|0,0,t|0,0)|0;n=Lg(u|0,G|0,l|0,n|0)|0;l=G;u=Af(x|0,0,r|0,0)|0;u=Lg(n|0,l|0,u|0,G|0)|0;l=G;n=Af(w|0,0,q*5|0,0)|0;n=Lg(u|0,l|0,n|0,G|0)|0;l=G;u=Af(k|0,0,p*5|0,0)|0;u=Lg(n|0,l|0,u|0,G|0)|0;l=G;n=Af(y|0,0,p|0,0)|0;h=G;j=Af(z|0,0,o|0,0)|0;h=Lg(j|0,G|0,n|0,h|0)|0;n=G;j=Af(x|0,0,t|0,0)|0;j=Lg(h|0,n|0,j|0,G|0)|0;n=G;h=Af(w|0,0,r|0,0)|0;h=Lg(j|0,n|0,h|0,G|0)|0;n=G;j=Af(k|0,0,q*5|0,0)|0;j=Lg(h|0,n|0,j|0,G|0)|0;n=G;h=Af(y|0,0,q|0,0)|0;y=G;z=Af(z|0,0,p|0,0)|0;y=Lg(z|0,G|0,h|0,y|0)|0;h=G;x=Af(x|0,0,o|0,0)|0;x=Lg(y|0,h|0,x|0,G|0)|0;h=G;w=Af(w|0,0,t|0,0)|0;w=Lg(x|0,h|0,w|0,G|0)|0;h=G;k=Af(k|0,0,r|0,0)|0;k=Lg(w|0,h|0,k|0,G|0)|0;h=G;g=$f(i|0,g|0,26)|0;g=Lg(v|0,d|0,g|0,0)|0;d=$f(g|0,G|0,26)|0;d=Lg(u|0,l|0,d|0,0)|0;l=$f(d|0,G|0,26)|0;l=Lg(j|0,n|0,l|0,0)|0;n=$f(l|0,G|0,26)|0;n=Lg(k|0,h|0,n|0,0)|0;h=$f(n|0,G|0,26)|0;m=Lg(m|0,e|0,-16,-1)|0;e=G;if(!(e>>>0>0|(e|0)==0&m>>>0>15)){k=(h*5|0)+(i&67108863)&67108863;j=(((h*5|0)+(i&67108863)|0)>>>26)+(g&67108863)|0;i=d&67108863;h=l&67108863;g=n&67108863;break}else{k=(h*5|0)+(i&67108863)&67108863;j=(((h*5|0)+(i&67108863)|0)>>>26)+(g&67108863)|0;i=d&67108863;h=l&67108863;g=n&67108863;c=c+16|0}}}f[a+20>>2]=k;f[a+24>>2]=j;f[a+28>>2]=i;f[a+32>>2]=h;f[a+36>>2]=g;return}function Ba(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0;k=we(c)|0;j=G;w=Cf(b[c+4>>0]|0,b[c+5>>0]|0,b[c+6>>0]|0)|0;w=Wf(w|0,G|0,6)|0;x=G;i=Cf(b[c+7>>0]|0,b[c+8>>0]|0,b[c+9>>0]|0)|0;i=Wf(i|0,G|0,5)|0;h=G;u=Cf(b[c+10>>0]|0,b[c+11>>0]|0,b[c+12>>0]|0)|0;u=Wf(u|0,G|0,3)|0;v=G;g=Cf(b[c+13>>0]|0,b[c+14>>0]|0,b[c+15>>0]|0)|0;g=Wf(g|0,G|0,2)|0;e=G;s=we(c+16|0)|0;t=G;l=Cf(b[c+20>>0]|0,b[c+21>>0]|0,b[c+22>>0]|0)|0;l=Wf(l|0,G|0,7)|0;d=G;m=Cf(b[c+23>>0]|0,b[c+24>>0]|0,b[c+25>>0]|0)|0;m=Wf(m|0,G|0,5)|0;r=G;n=Cf(b[c+26>>0]|0,b[c+27>>0]|0,b[c+28>>0]|0)|0;n=Wf(n|0,G|0,4)|0;o=G;p=Cf(b[c+29>>0]|0,b[c+30>>0]|0,b[c+31>>0]|0)|0;p=Wf(p|0,G|0,2)|0;q=Lg(p&33554428|0,0,16777216,0)|0;y=$f(q|0,G|0,25)|0;y=Ig(0,0,y|0,G|0)|0;j=Lg(y&19|0,0,k|0,j|0)|0;k=G;q=Ig(p&33554428|0,0,q&33554432|0,0)|0;p=G;y=Lg(w|0,x|0,16777216,0)|0;c=Nf(y|0,G|0,25)|0;h=Lg(c|0,G|0,i|0,h|0)|0;i=G;y=Ig(w|0,x|0,y&-33554432|0,0)|0;x=G;w=Lg(u|0,v|0,16777216,0)|0;c=Nf(w|0,G|0,25)|0;e=Lg(c|0,G|0,g|0,e|0)|0;g=G;w=Ig(u|0,v|0,w&-33554432|0,0)|0;v=G;u=Lg(s|0,t|0,16777216,0)|0;c=Nf(u|0,G|0,25)|0;c=Lg(l|0,d|0,c|0,G|0)|0;d=G;u=Ig(s|0,t|0,u&-33554432|0,0)|0;t=G;s=Lg(m|0,r|0,16777216,0)|0;l=Nf(s|0,G|0,25)|0;o=Lg(l|0,G|0,n|0,o|0)|0;n=G;s=Ig(m|0,r|0,s&-33554432|0,0)|0;r=G;m=Lg(j|0,k|0,33554432,0)|0;l=$f(m|0,G|0,26)|0;l=Lg(y|0,x|0,l|0,G|0)|0;m=Ig(j|0,k|0,m&-67108864|0,0)|0;k=Lg(h|0,i|0,33554432,0)|0;j=$f(k|0,G|0,26)|0;j=Lg(w|0,v|0,j|0,G|0)|0;k=Ig(h|0,i|0,k&-67108864|0,0)|0;i=Lg(e|0,g|0,33554432,0)|0;h=$f(i|0,G|0,26)|0;h=Lg(u|0,t|0,h|0,G|0)|0;i=Ig(e|0,g|0,i&-67108864|0,0)|0;g=Lg(c|0,d|0,33554432,0)|0;e=$f(g|0,G|0,26)|0;e=Lg(s|0,r|0,e|0,G|0)|0;g=Ig(c|0,d|0,g&-67108864|0,0)|0;d=Lg(o|0,n|0,33554432,0)|0;c=$f(d|0,G|0,26)|0;c=Lg(q|0,p|0,c|0,G|0)|0;d=Ig(o|0,n|0,d&-67108864|0,0)|0;f[a>>2]=m;f[a+4>>2]=l;f[a+8>>2]=k;f[a+12>>2]=j;f[a+16>>2]=i;f[a+20>>2]=h;f[a+24>>2]=g;f[a+28>>2]=e;f[a+32>>2]=d;f[a+36>>2]=c;return}function Ca(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0;j=f[b>>2]|0;v=f[b+4>>2]|0;h=f[b+8>>2]|0;t=f[b+12>>2]|0;e=f[b+16>>2]|0;r=f[b+20>>2]|0;c=f[b+24>>2]|0;l=f[b+28>>2]|0;m=f[b+32>>2]|0;x=f[b+36>>2]|0;j=Af(j|0,((j|0)<0)<<31>>31|0,121666,0)|0;i=G;v=Af(v|0,((v|0)<0)<<31>>31|0,121666,0)|0;w=G;h=Af(h|0,((h|0)<0)<<31>>31|0,121666,0)|0;g=G;t=Af(t|0,((t|0)<0)<<31>>31|0,121666,0)|0;u=G;e=Af(e|0,((e|0)<0)<<31>>31|0,121666,0)|0;d=G;r=Af(r|0,((r|0)<0)<<31>>31|0,121666,0)|0;s=G;c=Af(c|0,((c|0)<0)<<31>>31|0,121666,0)|0;b=G;l=Af(l|0,((l|0)<0)<<31>>31|0,121666,0)|0;q=G;m=Af(m|0,((m|0)<0)<<31>>31|0,121666,0)|0;n=G;x=Af(x|0,((x|0)<0)<<31>>31|0,121666,0)|0;o=G;p=Lg(x|0,o|0,16777216,0)|0;k=Nf(p|0,G|0,25)|0;k=Af(k|0,G|0,19,0)|0;i=Lg(k|0,G|0,j|0,i|0)|0;j=G;p=Ig(x|0,o|0,p&-33554432|0,0)|0;o=G;x=Lg(v|0,w|0,16777216,0)|0;k=Nf(x|0,G|0,25)|0;g=Lg(k|0,G|0,h|0,g|0)|0;h=G;x=Ig(v|0,w|0,x&-33554432|0,0)|0;w=G;v=Lg(t|0,u|0,16777216,0)|0;k=Nf(v|0,G|0,25)|0;d=Lg(k|0,G|0,e|0,d|0)|0;e=G;v=Ig(t|0,u|0,v&-33554432|0,0)|0;u=G;t=Lg(r|0,s|0,16777216,0)|0;k=Nf(t|0,G|0,25)|0;b=Lg(k|0,G|0,c|0,b|0)|0;c=G;t=Ig(r|0,s|0,t&-33554432|0,0)|0;s=G;r=Lg(l|0,q|0,16777216,0)|0;k=Nf(r|0,G|0,25)|0;n=Lg(k|0,G|0,m|0,n|0)|0;m=G;r=Ig(l|0,q|0,r&-33554432|0,0)|0;q=G;l=Lg(i|0,j|0,33554432,0)|0;k=$f(l|0,G|0,26)|0;k=Lg(x|0,w|0,k|0,G|0)|0;l=Ig(i|0,j|0,l&-67108864|0,0)|0;j=Lg(g|0,h|0,33554432,0)|0;i=$f(j|0,G|0,26)|0;i=Lg(v|0,u|0,i|0,G|0)|0;j=Ig(g|0,h|0,j&-67108864|0,0)|0;h=Lg(d|0,e|0,33554432,0)|0;g=$f(h|0,G|0,26)|0;g=Lg(t|0,s|0,g|0,G|0)|0;h=Ig(d|0,e|0,h&-67108864|0,0)|0;e=Lg(b|0,c|0,33554432,0)|0;d=$f(e|0,G|0,26)|0;d=Lg(r|0,q|0,d|0,G|0)|0;e=Ig(b|0,c|0,e&-67108864|0,0)|0;c=Lg(n|0,m|0,33554432,0)|0;b=$f(c|0,G|0,26)|0;b=Lg(p|0,o|0,b|0,G|0)|0;c=Ig(n|0,m|0,c&-67108864|0,0)|0;f[a>>2]=l;f[a+4>>2]=k;f[a+8>>2]=j;f[a+12>>2]=i;f[a+16>>2]=h;f[a+20>>2]=g;f[a+24>>2]=e;f[a+28>>2]=d;f[a+32>>2]=c;f[a+36>>2]=b;return}function Da(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0;if(!b)if(!d){if(e|0){f[e>>2]=(a>>>0)%(c>>>0);f[e+4>>2]=0}d=0;e=(a>>>0)/(c>>>0)>>>0;return (G=d,e)|0}else{if(!e){d=0;e=0;return (G=d,e)|0}f[e>>2]=a|0;f[e+4>>2]=b&0;d=0;e=0;return (G=d,e)|0}do if(c){if(d|0){h=(Y(d|0)|0)-(Y(b|0)|0)|0;if(h>>>0<=31){n=h+1|0;i=a>>>((h+1|0)>>>0)&h-31>>31|b<<31-h;m=b>>>((h+1|0)>>>0)&h-31>>31;g=0;h=a<<31-h;break}if(!e){d=0;e=0;return (G=d,e)|0}f[e>>2]=a|0;f[e+4>>2]=b|b&0;d=0;e=0;return (G=d,e)|0}if(c-1&c|0){h=(Y(c|0)|0)+33-(Y(b|0)|0)|0;n=h;i=32-h-1>>31&b>>>((h-32|0)>>>0)|(b<<32-h|a>>>(h>>>0))&h-32>>31;m=h-32>>31&b>>>(h>>>0);g=a<<64-h&32-h>>31;h=(b<<64-h|a>>>((h-32|0)>>>0))&32-h>>31|a<<32-h&h-33>>31;break}if(e|0){f[e>>2]=c-1&a;f[e+4>>2]=0}if((c|0)==1){d=b|b&0;e=a|0|0;return (G=d,e)|0}else{e=hi(c|0)|0;d=b>>>(e>>>0)|0;e=b<<32-e|a>>>(e>>>0)|0;return (G=d,e)|0}}else{if(!d){if(e|0){f[e>>2]=(b>>>0)%(c>>>0);f[e+4>>2]=0}d=0;e=(b>>>0)/(c>>>0)>>>0;return (G=d,e)|0}if(!a){if(e|0){f[e>>2]=0;f[e+4>>2]=(b>>>0)%(d>>>0)}c=0;e=(b>>>0)/(d>>>0)>>>0;return (G=c,e)|0}if(!(d-1&d)){if(e|0){f[e>>2]=a|0;f[e+4>>2]=d-1&b|b&0}c=0;e=b>>>((hi(d|0)|0)>>>0);return (G=c,e)|0}h=(Y(d|0)|0)-(Y(b|0)|0)|0;if(h>>>0<=30){n=h+1|0;i=b<<31-h|a>>>((h+1|0)>>>0);m=b>>>((h+1|0)>>>0);g=0;h=a<<31-h;break}if(!e){d=0;e=0;return (G=d,e)|0}f[e>>2]=a|0;f[e+4>>2]=b|b&0;d=0;e=0;return (G=d,e)|0}while(0);if(!n){j=h;b=m;a=0;h=0}else{k=Lg(c|0|0,d|d&0|0,-1,-1)|0;l=G;j=h;b=m;a=n;h=0;do{p=j;j=g>>>31|j<<1;g=h|g<<1;p=i<<1|p>>>31|0;o=i>>>31|b<<1|0;Ig(k|0,l|0,p|0,o|0)|0;n=G;m=n>>31|((n|0)<0?-1:0)<<1;h=m&1;i=Ig(p|0,o|0,m&(c|0)|0,(((n|0)<0?-1:0)>>31|((n|0)<0?-1:0)<<1)&(d|d&0)|0)|0;b=G;a=a-1|0}while((a|0)!=0);a=0}if(e|0){f[e>>2]=i;f[e+4>>2]=b}o=(g|0)>>>31|j<<1|(0<<1|g>>>31)&0|a;p=(g<<1|0>>>31)&-2|h;return (G=o,p)|0}function Ea(a){a=a|0;var b=0,c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0,I=0,J=0,K=0,L=0;u=t;v=t=t+63&-64;t=t+64|0;ig(v,a);b=0;d=f[v+28>>2]|0;e=f[v>>2]|0;g=f[v+48>>2]|0;h=f[v+16>>2]|0;i=f[v+32>>2]|0;j=f[v+20>>2]|0;c=f[v+4>>2]|0;k=f[v+36>>2]|0;l=f[v+52>>2]|0;m=f[v+40>>2]|0;n=f[v+24>>2]|0;o=f[v+56>>2]|0;p=f[v+8>>2]|0;q=f[v+60>>2]|0;r=f[v+44>>2]|0;s=f[v+12>>2]|0;do{F=g+e|0;F=(F<<7|F>>>25)^h;C=F+e|0;C=(C<<9|C>>>23)^i;z=(C+F<<13|(C+F|0)>>>19)^g;I=(z+C<<18|(z+C|0)>>>14)^e;B=c+j|0;B=(B<<7|B>>>25)^k;y=B+j|0;y=(y<<9|y>>>23)^l;L=(y+B<<13|(y+B|0)>>>19)^c;E=(L+y<<18|(L+y|0)>>>14)^j;x=n+m|0;x=(x<<7|x>>>25)^o;K=x+m|0;K=(K<<9|K>>>23)^p;G=(K+x<<13|(K+x|0)>>>19)^n;A=(G+K<<18|(G+K|0)>>>14)^m;J=r+q|0;J=(J<<7|J>>>25)^s;H=J+q|0;H=(H<<9|H>>>23)^d;D=(H+J<<13|(H+J|0)>>>19)^r;w=(D+H<<18|(D+H|0)>>>14)^q;c=(J+I<<7|(J+I|0)>>>25)^L;L=c+I|0;p=(L<<9|L>>>23)^K;K=p+c|0;s=(K<<13|K>>>19)^J;J=s+p|0;e=(J<<18|J>>>14)^I;n=G^(E+F<<7|(E+F|0)>>>25);G=n+E|0;d=H^(G<<9|G>>>23);G=d+n|0;h=(G<<13|G>>>19)^F;F=h+d|0;j=(F<<18|F>>>14)^E;r=D^(A+B<<7|(A+B|0)>>>25);D=r+A|0;i=(D<<9|D>>>23)^C;C=i+r|0;k=(C<<13|C>>>19)^B;B=k+i|0;m=(B<<18|B>>>14)^A;g=(w+x<<7|(w+x|0)>>>25)^z;z=g+w|0;l=(z<<9|z>>>23)^y;y=l+g|0;o=(y<<13|y>>>19)^x;x=o+l|0;q=(x<<18|x>>>14)^w;b=b+2|0}while(b>>>0<8);f[v>>2]=e;f[v+48>>2]=g;f[v+16>>2]=h;f[v+32>>2]=i;f[v+20>>2]=j;f[v+4>>2]=c;f[v+36>>2]=k;f[v+52>>2]=l;f[v+40>>2]=m;f[v+24>>2]=n;f[v+56>>2]=o;f[v+8>>2]=p;f[v+60>>2]=q;f[v+44>>2]=r;f[v+12>>2]=s;f[v+28>>2]=d;f[a>>2]=(f[a>>2]|0)+e;b=1;while(1){L=a+(b<<2)|0;f[L>>2]=(f[L>>2]|0)+c;b=b+1|0;if((b|0)==16)break;c=f[v+(b<<2)>>2]|0}t=u;return}function Fa(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,T=0,U=0,V=0,W=0,X=0,Y=0;if(!d){G=857760878;H=2036477234;I=1634760805;y=1797285236}else{I=yh(d)|0;G=yh(d+4|0)|0;H=yh(d+8|0)|0;y=yh(d+12|0)|0}z=yh(c)|0;A=yh(c+4|0)|0;B=yh(c+8|0)|0;C=yh(c+12|0)|0;D=yh(c+16|0)|0;E=yh(c+20|0)|0;F=yh(c+24|0)|0;u=yh(c+28|0)|0;v=yh(b)|0;w=yh(b+4|0)|0;x=yh(b+8|0)|0;t=yh(b+12|0)|0;d=z;c=A;b=B;f=C;g=v;h=w;i=x;j=t;k=D;l=u;m=F;n=E;o=0;p=G;q=H;r=y;s=I;do{S=(oi(s+n|0,7)|0)^f;P=(oi(S+s|0,9)|0)^i;M=(oi(P+S|0,13)|0)^n;V=(oi(M+P|0,18)|0)^s;O=(oi(d+p|0,7)|0)^j;L=(oi(O+p|0,9)|0)^m;Y=(oi(L+O|0,13)|0)^d;R=(oi(Y+L|0,18)|0)^p;K=(oi(g+q|0,7)|0)^l;X=(oi(K+q|0,9)|0)^c;U=(oi(X+K|0,13)|0)^g;N=(oi(U+X|0,18)|0)^q;W=(oi(k+r|0,7)|0)^b;T=(oi(W+r|0,9)|0)^h;Q=(oi(T+W|0,13)|0)^k;J=(oi(Q+T|0,18)|0)^r;d=(oi(W+V|0,7)|0)^Y;c=(oi(d+V|0,9)|0)^X;b=(oi(c+d|0,13)|0)^W;s=(oi(b+c|0,18)|0)^V;g=(oi(R+S|0,7)|0)^U;h=(oi(g+R|0,9)|0)^T;f=(oi(h+g|0,13)|0)^S;p=(oi(f+h|0,18)|0)^R;k=(oi(N+O|0,7)|0)^Q;i=(oi(k+N|0,9)|0)^P;j=(oi(i+k|0,13)|0)^O;q=(oi(j+i|0,18)|0)^N;n=(oi(J+K|0,7)|0)^M;m=(oi(n+J|0,9)|0)^L;l=(oi(m+n|0,13)|0)^K;r=(oi(l+m|0,18)|0)^J;o=o+2|0}while((o|0)<(e|0));Qg(a,s+I|0);Qg(a+4|0,d+z|0);Qg(a+8|0,c+A|0);Qg(a+12|0,b+B|0);Qg(a+16|0,f+C|0);Qg(a+20|0,p+G|0);Qg(a+24|0,g+v|0);Qg(a+28|0,h+w|0);Qg(a+32|0,i+x|0);Qg(a+36|0,j+t|0);Qg(a+40|0,q+H|0);Qg(a+44|0,k+D|0);Qg(a+48|0,n+E|0);Qg(a+52|0,m+F|0);Qg(a+56|0,l+u|0);Qg(a+60|0,r+y|0);return}function Ga(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0;m=t;j=t=t+63&-64;t=t+16|0;switch(e|0){case 2:{if(c>>>0<13)e=-31;else{e=a;g=34347;h=e+13|0;do{b[e>>0]=b[g>>0]|0;e=e+1|0;g=g+1|0}while((e|0)<(h|0));a=a+12|0;g=c+-12|0;h=6}break}case 1:{if(c>>>0<12)e=-31;else{e=a;g=34360;h=e+12|0;do{b[e>>0]=b[g>>0]|0;e=e+1|0;g=g+1|0}while((e|0)<(h|0));a=a+11|0;g=c+-11|0;h=6}break}default:e=-31}do if((h|0)==6){e=xb(d)|0;if(!e){td(j,19);e=Sc(j)|0;h=a+e|0;i=g-e|0;if(g>>>0<=e>>>0){e=-31;break}qb(a|0,j|0,e+1|0)|0;if(i>>>0>=4){b[h>>0]=36;b[h+1>>0]=109;b[h+2>>0]=61;b[h+3>>0]=0;td(j,f[d+44>>2]|0);g=Sc(j)|0;a=h+3+g|0;if((i+-3|0)>>>0<=g>>>0){e=-31;break}qb(h+3|0,j|0,g+1|0)|0;if((i+-3-g|0)>>>0>=4){b[a>>0]=44;b[a+1>>0]=116;b[a+2>>0]=61;b[a+3>>0]=0;td(j,f[d+40>>2]|0);e=Sc(j)|0;h=a+3+e|0;c=i+-3-g+-3-e|0;if((i+-3-g+-3|0)>>>0<=e>>>0){e=-31;break}qb(a+3|0,j|0,e+1|0)|0;if(c>>>0>=4){b[h>>0]=44;b[h+1>>0]=112;b[h+2>>0]=61;b[h+3>>0]=0;td(j,f[d+48>>2]|0);g=Sc(j)|0;if((c+-3|0)>>>0<=g>>>0){e=-31;break}qb(h+3|0,j|0,g+1|0)|0;e=h+3+g+1|0;if(((c+-3-g|0)>>>0>=2?(b[h+3+g>>0]=36,b[h+3+g+1>>0]=0,(Ta(e,c+-3-g+-1|0,f[d+16>>2]|0,f[d+20>>2]|0,3)|0)!=0):0)?(k=Sc(e)|0,l=c+-3-g+-1-k|0,l>>>0>=2):0){b[e+k>>0]=36;b[e+k+1>>0]=0;l=(Ta(e+k+1|0,l+-1|0,f[d>>2]|0,f[d+4>>2]|0,3)|0)==0;t=m;return (l?-31:0)|0}else e=-31}else e=-31}else e=-31}else e=-31}}while(0);t=m;return e|0}function Ha(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0,I=0,J=0,K=0,L=0,M=0,N=0;if(!d){d=1797285236;e=2036477234;f=857760878;g=1634760805}else{g=yh(d)|0;f=yh(d+4|0)|0;e=yh(d+8|0)|0;d=yh(d+12|0)|0}r=yh(c)|0;q=yh(c+4|0)|0;p=yh(c+8|0)|0;o=yh(c+12|0)|0;n=yh(c+16|0)|0;m=yh(c+20|0)|0;l=yh(c+24|0)|0;k=yh(c+28|0)|0;j=yh(b)|0;i=yh(b+4|0)|0;h=yh(b+8|0)|0;s=0;b=yh(b+12|0)|0;c=g;do{L=r+c|0;A=oi(j^L,16)|0;z=A+n|0;M=oi(z^r,12)|0;A=oi(M+L^A,8)|0;w=oi(A+z^M,7)|0;H=q+f|0;u=oi(i^H,16)|0;t=u+m|0;I=oi(t^q,12)|0;u=oi(I+H^u,8)|0;N=oi(u+t^I,7)|0;C=p+e|0;v=oi(h^C,16)|0;B=v+l|0;D=oi(B^p,12)|0;v=oi(D+C^v,8)|0;J=oi(v+B^D,7)|0;x=o+d|0;F=oi(b^x,16)|0;g=F+k|0;y=oi(g^o,12)|0;F=oi(y+x^F,8)|0;E=oi(F+g^y,7)|0;K=oi(F^N+(M+L),16)|0;G=oi(K+(v+B)^N,12)|0;c=G+(N+(M+L))|0;b=oi(c^K,8)|0;l=b+(K+(v+B))|0;q=oi(l^G,7)|0;G=oi(J+(I+H)^A,16)|0;B=oi(G+(F+g)^J,12)|0;f=B+(J+(I+H))|0;j=oi(f^G,8)|0;k=j+(G+(F+g))|0;p=oi(k^B,7)|0;B=oi(E+(D+C)^u,16)|0;g=oi(B+(A+z)^E,12)|0;e=g+(E+(D+C))|0;i=oi(e^B,8)|0;n=i+(B+(A+z))|0;o=oi(n^g,7)|0;v=oi(y+x+w^v,16)|0;g=oi(v+(u+t)^w,12)|0;d=g+(y+x+w)|0;h=oi(d^v,8)|0;m=h+(v+(u+t))|0;r=oi(m^g,7)|0;s=s+1|0}while((s|0)!=10);Qg(a,c);Qg(a+4|0,f);Qg(a+8|0,e);Qg(a+12|0,d);Qg(a+16|0,j);Qg(a+20|0,i);Qg(a+24|0,h);Qg(a+28|0,b);return 0}function Ia(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var f=0,g=0,h=0,i=0;h=t;i=t=t+63&-64;t=t+2272|0;Lb(i+1536|0,c);Lb(i+1280|0,e);If(i,d);Jf(i+2112|0,d);wf(i+1792|0,i+2112|0);Xc(i+2112|0,i+1792|0,i);wf(i+1952|0,i+2112|0);If(i+160|0,i+1952|0);Xc(i+2112|0,i+1792|0,i+160|0);wf(i+1952|0,i+2112|0);If(i+320|0,i+1952|0);Xc(i+2112|0,i+1792|0,i+320|0);wf(i+1952|0,i+2112|0);If(i+480|0,i+1952|0);Xc(i+2112|0,i+1792|0,i+480|0);wf(i+1952|0,i+2112|0);If(i+640|0,i+1952|0);Xc(i+2112|0,i+1792|0,i+640|0);wf(i+1952|0,i+2112|0);If(i+800|0,i+1952|0);Xc(i+2112|0,i+1792|0,i+800|0);wf(i+1952|0,i+2112|0);If(i+960|0,i+1952|0);Xc(i+2112|0,i+1792|0,i+960|0);wf(i+1952|0,i+2112|0);If(i+1120|0,i+1952|0);di(a);c=255;while(1){if(b[i+1536+c>>0]|0){f=c;g=5;break}if(b[i+1280+c>>0]|0){f=c;g=5;break}if(!c)break;else c=c+-1|0}if((g|0)==5?(f|0)>-1:0)while(1){ud(i+2112|0,a);c=b[i+1536+f>>0]|0;if(c<<24>>24<=0){if(c<<24>>24<0){wf(i+1952|0,i+2112|0);Wc(i+2112|0,i+1952|0,i+((((c<<24>>24)/-2|0)<<24>>24)*160|0)|0)}}else{wf(i+1952|0,i+2112|0);Xc(i+2112|0,i+1952|0,i+(((c&255)>>>1&255)*160|0)|0)}c=b[i+1280+f>>0]|0;if(c<<24>>24<=0){if(c<<24>>24<0){wf(i+1952|0,i+2112|0);_c(i+2112|0,i+1952|0,160+((((c<<24>>24)/-2|0)<<24>>24)*120|0)|0)}}else{wf(i+1952|0,i+2112|0);$c(i+2112|0,i+1952|0,160+(((c&255)>>>1&255)*120|0)|0)}jg(a,i+2112|0);if((f|0)>0)f=f+-1|0;else break}t=h;return}function Ja(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;m=t;l=t=t+63&-64;t=t+704|0;a:do if(!((d|0)==0&(e|0)==0)){q=f[a+72>>2]|0;o=f[a+72+4>>2]|0;k=$f(q|0,o|0,3)|0;n=Wf(d|0,e|0,3)|0;p=G;i=$f(d|0,e|0,61)|0;j=G;o=Lg(q|0,o|0,n|0,p|0)|0;q=G;f[a+72>>2]=o;f[a+72+4>>2]=q;g=f[a+64>>2]|0;h=f[a+64+4>>2]|0;if(q>>>0<p>>>0|(q|0)==(p|0)&o>>>0<n>>>0){g=Lg(g|0,h|0,1,0)|0;h=G;f[a+64>>2]=g;f[a+64+4>>2]=h}j=Lg(g|0,h|0,i|0,j|0)|0;f[a+64>>2]=j;f[a+64+4>>2]=G;j=Ig(128,0,k&127|0,0)|0;g=G;if(g>>>0>e>>>0|(g|0)==(e|0)&j>>>0>d>>>0){g=0;h=0;while(1){p=b[c+g>>0]|0;q=Lg(g|0,h|0,k&127|0,0)|0;b[a+80+q>>0]=p;g=Lg(g|0,h|0,1,0)|0;h=G;if(!(h>>>0<e>>>0|(h|0)==(e|0)&g>>>0<d>>>0))break a}}if(!((j|0)==0&(g|0)==0)){h=0;i=0;do{p=b[c+h>>0]|0;q=Lg(h|0,i|0,k&127|0,0)|0;b[a+80+q>>0]=p;h=Lg(h|0,i|0,1,0)|0;i=G}while(i>>>0<g>>>0|(i|0)==(g|0)&h>>>0<j>>>0)}ma(a,a+80|0,l,l+640|0);g=Ig(d|0,e|0,j|0,g|0)|0;h=G;if(h>>>0>0|(h|0)==0&g>>>0>127){i=c+j|0;do{ma(a,i,l,l+640|0);i=i+128|0;g=Lg(g|0,h|0,-128,-1)|0;h=G}while(h>>>0>0|(h|0)==0&g>>>0>127);j=i}else j=c+j|0;g=g&127;if(!((g|0)==0&0==0)){h=0;i=0;do{b[a+80+h>>0]=b[j+h>>0]|0;h=Lg(h|0,i|0,1,0)|0;i=G}while(i>>>0<0|(i|0)==0&h>>>0<g>>>0)}ye(l,704)}while(0);t=m;return 0}function Ka(a,c,d,e,g,h,i,j){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;var k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0;s=t;r=t=t+63&-64;t=t+16|0;f[r>>2]=0;Sh(j);if(e){l=0;n=0;m=0;k=0;a:while(1){while(1){p=b[d+k>>0]|0;if(!(j&4))o=Pc(p)|0;else o=Lc(p)|0;if((o|0)!=255)break;if(!g){o=18;break a}if(!(sh(g,p)|0)){o=19;break a}k=k+1|0;if(k>>>0>=e>>>0){o=17;break a}}n=o+(n<<6)|0;o=l+6|0;if(o>>>0>7){l=l+-2|0;if(m>>>0>=c>>>0){o=13;break}b[a+m>>0]=n>>>l;m=m+1|0}else l=o;k=k+1|0;if(k>>>0>=e>>>0){o=16;break}}if((o|0)==13){f[r>>2]=k;f[9002]=34;k=-1}else if((o|0)==16){f[r>>2]=k;k=0}else if((o|0)==17){f[r>>2]=k;k=0}else if((o|0)==18){f[r>>2]=k;k=0}else if((o|0)==19){f[r>>2]=k;k=0}if(l>>>0>4){k=-1;m=0}else o=21}else{k=0;m=0;n=0;l=0;o=21}do if((o|0)==21)if(!((1<<l)+-1&n)){if(!(k|j&2))k=vc(d,e,r,g,l>>>1)|0;if(!k)if((g|0)!=0?(q=f[r>>2]|0,q>>>0<e>>>0):0){k=q;while(1){if(!(sh(g,b[d+k>>0]|0)|0)){o=31;break}k=k+1|0;if(k>>>0>=e>>>0){o=30;break}}if((o|0)==30){f[r>>2]=k;k=0;break}else if((o|0)==31){f[r>>2]=k;k=0;break}}else k=0;else m=0}else{k=-1;m=0}while(0);l=f[r>>2]|0;if(!i){if((l|0)!=(e|0)){f[9002]=22;k=-1}}else f[i>>2]=d+l;if(h|0)f[h>>2]=m;t=s;return k|0}function La(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0,A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0;if(!d){d=1797285236;e=2036477234;f=857760878;o=1634760805}else{o=yh(d)|0;f=yh(d+4|0)|0;e=yh(d+8|0)|0;d=yh(d+12|0)|0}n=yh(c)|0;m=yh(c+4|0)|0;l=yh(c+8|0)|0;k=yh(c+12|0)|0;t=yh(c+16|0)|0;s=yh(c+20|0)|0;r=yh(c+24|0)|0;q=yh(c+28|0)|0;j=yh(b)|0;i=yh(b+4|0)|0;h=yh(b+8|0)|0;g=yh(b+12|0)|0;p=20;b=f;c=o;do{B=(oi(s+c|0,7)|0)^k;y=(oi(B+c|0,9)|0)^h;v=(oi(y+B|0,13)|0)^s;E=(oi(v+y|0,18)|0)^c;x=(oi(b+n|0,7)|0)^g;u=(oi(x+b|0,9)|0)^r;H=(oi(u+x|0,13)|0)^n;A=(oi(H+u|0,18)|0)^b;f=(oi(e+j|0,7)|0)^q;G=(oi(f+e|0,9)|0)^m;D=(oi(G+f|0,13)|0)^j;w=(oi(D+G|0,18)|0)^e;F=(oi(d+t|0,7)|0)^l;C=(oi(F+d|0,9)|0)^i;z=(oi(C+F|0,13)|0)^t;o=(oi(z+C|0,18)|0)^d;n=(oi(F+E|0,7)|0)^H;m=(oi(n+E|0,9)|0)^G;l=(oi(m+n|0,13)|0)^F;c=(oi(l+m|0,18)|0)^E;j=(oi(A+B|0,7)|0)^D;i=(oi(j+A|0,9)|0)^C;k=(oi(i+j|0,13)|0)^B;b=(oi(k+i|0,18)|0)^A;t=(oi(w+x|0,7)|0)^z;h=(oi(t+w|0,9)|0)^y;g=(oi(h+t|0,13)|0)^x;e=(oi(g+h|0,18)|0)^w;s=(oi(o+f|0,7)|0)^v;r=(oi(s+o|0,9)|0)^u;q=(oi(r+s|0,13)|0)^f;d=(oi(q+r|0,18)|0)^o;p=p+-2|0}while((p|0)!=0);Qg(a,c);Qg(a+4|0,b);Qg(a+8|0,e);Qg(a+12|0,d);Qg(a+16|0,j);Qg(a+20|0,i);Qg(a+24|0,h);Qg(a+28|0,g);return 0}function Ma(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,h=0,i=0,j=0,k=0;k=t;j=t=t+63&-64;t=t+16|0;h=f[a+20>>2]|0;i=f[a+4>>2]|0;f[a+20>>2]=0;f[a+4>>2]=0;switch(d|0){case 2:{if(!(qd(c,34312,9)|0)){c=c+9|0;g=4}else c=-32;break}case 1:{if(!(qd(c,34322,8)|0)){c=c+8|0;g=4}else c=-32;break}default:c=-26}do if((g|0)==4)if((qd(c,34331,3)|0)==0?(e=Kc(c+3|0,j+4|0)|0,(e|0)!=0):0)if((f[j+4>>2]|0)==19)if(!(qd(e,34335,3)|0)){c=Kc(e+3|0,j+4|0)|0;if(!c){c=-32;break}f[a+44>>2]=f[j+4>>2];if(!(qd(c,34339,3)|0)){c=Kc(c+3|0,j+4|0)|0;if(!c){c=-32;break}f[a+40>>2]=f[j+4>>2];if(!(qd(c,34343,3)|0)){c=Kc(c+3|0,j+4|0)|0;if(!c){c=-32;break}g=f[j+4>>2]|0;f[a+48>>2]=g;f[a+52>>2]=g;g=(b[c>>0]|0)==36;c=g?c+1|0:c;if(g){f[j+4>>2]=h;g=f[a+16>>2]|0;if(Ka(g,h,c,Sc(c)|0,0,j+4|0,j,3)|0){c=-32;break}f[a+20>>2]=f[j+4>>2];c=f[j>>2]|0;h=(b[c>>0]|0)==36;c=h?c+1|0:c;if(h){f[j+4>>2]=i;h=f[a>>2]|0;if(Ka(h,i,c,Sc(c)|0,0,j+4|0,j,3)|0){c=-32;break}f[a+4>>2]=f[j+4>>2];d=f[j>>2]|0;c=xb(a)|0;if(!c)c=(b[d>>0]|0)==0?0:-32}else c=-32}else c=-32}else c=-32}else c=-32}else c=-32;else c=-26;else c=-32;while(0);t=k;return c|0}function Na(a,c,d,e,g,h,i,j,k,l){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;var m=0,n=0,o=0,p=0,q=0;q=t;p=t=t+63&-64;t=t+352|0;if(d|0){f[d>>2]=0;f[d+4>>2]=0}if(e|0)b[e>>0]=-1;do if(!(i>>>0<0|(i|0)==0&h>>>0<17)){n=Lg(h|0,i|0,-17,-1)|0;o=G;if(o>>>0>0|(o|0)==0&n>>>0>4294967278)Fj();Wg(p+16|0,64,0,a+32|0,a)|0;Lh(p+80|0,p+16|0)|0;ye(p+16|0,64);Kg(p+80|0,j,k,l)|0;j=Ig(0,0,k|0,l|0)|0;Kg(p+80|0,35456,j&15,0)|0;j=p+16|0;m=j+64|0;do{f[j>>2]=0;j=j+4|0}while((j|0)<(m|0));b[p+16>>0]=b[g>>0]|0;Sf(p+16|0,p+16|0,64,0,a+32|0,1,a)|0;j=b[p+16>>0]|0;b[p+16>>0]=b[g>>0]|0;Kg(p+80|0,p+16|0,64,0)|0;Kg(p+80|0,g+1|0,n,o)|0;m=Lg(h|0,i|0,15,0)|0;Kg(p+80|0,35456,m&15,0)|0;We(p+336|0,k,l);Kg(p+80|0,p+336|0,8,0)|0;l=Lg(h|0,i|0,47,0)|0;We(p+336|0,l,G);Kg(p+80|0,p+336|0,8,0)|0;Kh(p+80|0,p)|0;ye(p+80|0,256);if(hd(p,g+1+n|0,16)|0){ye(p,16);j=-1;break}Sf(c,g+1|0,n,o,a+32|0,2,a)|0;Of(a+36|0,p);of(a+32|0);if(!((j&2)==0?!(ge(a+32|0,4)|0):0))Gb(a);if(d|0){f[d>>2]=n;f[d+4>>2]=o}if(e|0){b[e>>0]=j;j=0}else j=0}else j=-1;while(0);t=q;return j|0}function Oa(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0,g=0,i=0;e=t;f=t=t+63&-64;t=t+4032|0;If(f,d);Jf(f+3584|0,d);wf(f+2464|0,f+3584|0);If(f+160|0,f+2464|0);Xc(f+3424|0,d,f+160|0);wf(f+2304|0,f+3424|0);If(f+320|0,f+2304|0);Jf(f+3264|0,f+2464|0);wf(f+2144|0,f+3264|0);If(f+480|0,f+2144|0);Xc(f+3104|0,d,f+480|0);wf(f+1984|0,f+3104|0);If(f+640|0,f+1984|0);Jf(f+2944|0,f+2304|0);wf(f+1824|0,f+2944|0);If(f+800|0,f+1824|0);Xc(f+2784|0,d,f+800|0);wf(f+1664|0,f+2784|0);If(f+960|0,f+1664|0);Jf(f+2624|0,f+2144|0);wf(f+1504|0,f+2624|0);If(f+1120|0,f+1504|0);d=0;do{i=b[c+d>>0]|0;g=d<<1;b[f+1280+g>>0]=i&15;b[f+1280+(g|1)>>0]=(i&255)>>>4;d=d+1|0}while((d|0)!=32);d=0;c=0;do{i=f+1280+c|0;g=d+(h[i>>0]|0)|0;d=(g<<24)+134217728>>28;b[i>>0]=g-(d<<4);c=c+1|0}while((c|0)!=63);d=d+(h[f+1280+63>>0]|0)&255;b[f+1280+63>>0]=d;Gh(a);cc(f+1344|0,f,d);Xc(f+3864|0,a,f+1344|0);d=63;do{jg(f+3744|0,f+3864|0);ud(f+3864|0,f+3744|0);jg(f+3744|0,f+3864|0);ud(f+3864|0,f+3744|0);jg(f+3744|0,f+3864|0);ud(f+3864|0,f+3744|0);jg(f+3744|0,f+3864|0);ud(f+3864|0,f+3744|0);wf(a,f+3864|0);d=d+-1|0;cc(f+1344|0,f,b[f+1280+d>>0]|0);Xc(f+3864|0,a,f+1344|0)}while((d|0)!=0);wf(a,f+3864|0);t=e;return}function Pa(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0;m=t;l=t=t+63&-64;t=t+288|0;a:do if(!((d|0)==0&(e|0)==0)){i=f[a+32>>2]|0;g=f[a+32+4>>2]|0;j=$f(i|0,g|0,3)|0;k=Wf(d|0,e|0,3)|0;k=Lg(i|0,g|0,k|0,G|0)|0;f[a+32>>2]=k;f[a+32+4>>2]=G;k=Ig(64,0,j&63|0,0)|0;g=G;if(g>>>0>e>>>0|(g|0)==(e|0)&k>>>0>d>>>0){g=0;h=0;while(1){k=b[c+g>>0]|0;l=Lg(g|0,h|0,j&63|0,0)|0;b[a+40+l>>0]=k;g=Lg(g|0,h|0,1,0)|0;h=G;if(!(h>>>0<e>>>0|(h|0)==(e|0)&g>>>0<d>>>0))break a}}if(!((k|0)==0&(g|0)==0)){h=0;i=0;do{o=b[c+h>>0]|0;n=Lg(h|0,i|0,j&63|0,0)|0;b[a+40+n>>0]=o;h=Lg(h|0,i|0,1,0)|0;i=G}while(i>>>0<g>>>0|(i|0)==(g|0)&h>>>0<k>>>0)}sa(a,a+40|0,l,l+256|0);g=Ig(d|0,e|0,k|0,g|0)|0;h=G;if(h>>>0>0|(h|0)==0&g>>>0>63){i=c+k|0;do{sa(a,i,l,l+256|0);i=i+64|0;g=Lg(g|0,h|0,-64,-1)|0;h=G}while(h>>>0>0|(h|0)==0&g>>>0>63);j=i}else j=c+k|0;g=g&63;if(!((g|0)==0&0==0)){h=0;i=0;do{b[a+40+h>>0]=b[j+h>>0]|0;h=Lg(h|0,i|0,1,0)|0;i=G}while(i>>>0<0|(i|0)==0&h>>>0<g>>>0)}ye(l,288)}while(0);t=m;return 0}function Qa(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+400|0;if(!((a|0)==0|(b|0)==0)){Td(e,0,0,64)|0;Qg(e+384|0,f[b+48>>2]|0);Ug(e,e+384|0,4,0)|0;Qg(e+384|0,f[b+4>>2]|0);Ug(e,e+384|0,4,0)|0;Qg(e+384|0,f[b+44>>2]|0);Ug(e,e+384|0,4,0)|0;Qg(e+384|0,f[b+40>>2]|0);Ug(e,e+384|0,4,0)|0;Qg(e+384|0,19);Ug(e,e+384|0,4,0)|0;Qg(e+384|0,c);Ug(e,e+384|0,4,0)|0;Qg(e+384|0,f[b+12>>2]|0);Ug(e,e+384|0,4,0)|0;c=f[b+8>>2]|0;if(c|0?(Ug(e,c,f[b+12>>2]|0,0)|0,f[b+56>>2]&1|0):0){ye(f[b+8>>2]|0,f[b+12>>2]|0);f[b+12>>2]=0}Qg(e+384|0,f[b+20>>2]|0);Ug(e,e+384|0,4,0)|0;c=f[b+16>>2]|0;if(c|0)Ug(e,c,f[b+20>>2]|0,0)|0;Qg(e+384|0,f[b+28>>2]|0);Ug(e,e+384|0,4,0)|0;c=f[b+24>>2]|0;if(c|0?(Ug(e,c,f[b+28>>2]|0,0)|0,f[b+56>>2]&2|0):0){ye(f[b+24>>2]|0,f[b+28>>2]|0);f[b+28>>2]=0}Qg(e+384|0,f[b+36>>2]|0);Ug(e,e+384|0,4,0)|0;c=f[b+32>>2]|0;if(c|0)Ug(e,c,f[b+36>>2]|0,0)|0;Bf(e,a,64)|0}t=d;return}function Ra(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0;h=f[a+56>>2]|0;g=f[a+56+4>>2]|0;if(!((h|0)==0&(g|0)==0)){j=Ig(16,0,h|0,g|0)|0;l=G;k=l>>>0>e>>>0|(l|0)==(e|0)&j>>>0>d>>>0?d:j;l=l>>>0>e>>>0|(l|0)==(e|0)&j>>>0>d>>>0?e:l;if(!((k|0)==0&(l|0)==0)){j=0;i=0;do{n=b[c+j>>0]|0;h=Lg(h|0,g|0,j|0,i|0)|0;b[a+64+h>>0]=n;j=Lg(j|0,i|0,1,0)|0;i=G;h=f[a+56>>2]|0;g=f[a+56+4>>2]|0}while(i>>>0<l>>>0|(i|0)==(l|0)&j>>>0<k>>>0)}n=Lg(h|0,g|0,k|0,l|0)|0;j=G;f[a+56>>2]=n;f[a+56+4>>2]=j;if(!(j>>>0<0|(j|0)==0&n>>>0<16)){d=Ig(d|0,e|0,k|0,l|0)|0;e=G;Aa(a,a+64|0,16,0);f[a+56>>2]=0;f[a+56+4>>2]=0;c=c+k|0;m=7}}else m=7;if((m|0)==7){g=d&-16;if(e>>>0>0|(e|0)==0&d>>>0>15){h=Ig(d|0,e|0,g|0,e|0)|0;n=G;Aa(a,c,g,e);i=c+g|0;g=n}else{i=c;h=d;g=e}if(!((h|0)==0&(g|0)==0)){d=0;c=0;do{m=b[i+d>>0]|0;n=Lg(f[a+56>>2]|0,f[a+56+4>>2]|0,d|0,c|0)|0;b[a+64+n>>0]=m;d=Lg(d|0,c|0,1,0)|0;c=G}while(c>>>0<g>>>0|(c|0)==(g|0)&d>>>0<h>>>0);n=Lg(f[a+56>>2]|0,f[a+56+4>>2]|0,h|0,g|0)|0;f[a+56>>2]=n;f[a+56+4>>2]=G}}return}function Sa(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0,k=0;j=t;k=t=t+63&-64;t=t+528|0;f[k+512>>2]=0;Qg(k+512|0,c);if(c>>>0<65){if((Td(k,0,0,c)|0)>=0){Ug(k,k+512|0,4,0)|0;Ug(k,d,e,0)|0;Bf(k,a,c)|0}}else a:do if((Td(k,0,0,64)|0)>=0?(Ug(k,k+512|0,4,0)|0,Ug(k,d,e,0)|0,(Bf(k,k+448|0,64)|0)>=0):0){g=a;h=k+448|0;i=g+32|0;do{b[g>>0]=b[h>>0]|0;g=g+1|0;h=h+1|0}while((g|0)<(i|0));g=k+384|0;h=k+448|0;i=g+64|0;do{f[g>>2]=f[h>>2];g=g+4|0;h=h+4|0}while((g|0)<(i|0));if((c+-32|0)>>>0>64){e=c+-32|0;d=a+32|0;do{if((Se(k+448|0,64,k+384|0,64,0,0,0)|0)<0)break a;g=d;h=k+448|0;i=g+32|0;do{b[g>>0]=b[h>>0]|0;g=g+1|0;h=h+1|0}while((g|0)<(i|0));e=e+-32|0;d=d+32|0;g=k+384|0;h=k+448|0;i=g+64|0;do{f[g>>2]=f[h>>2];g=g+4|0;h=h+4|0}while((g|0)<(i|0))}while(e>>>0>64)}else{e=c+-32|0;d=a+32|0}if((Se(k+448|0,e,k+384|0,64,0,0,0)|0)>=0)qb(d|0,k+448|0,e|0)|0}while(0);ye(k,384);t=j;return}function Ta(a,c,d,e,f){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,i=0,j=0,k=0,l=0,m=0;Sh(f);i=(V((e>>>0)/3|0,-3)|0)+e|0;g=((e>>>0)/3|0)<<2;do if(i)if(!(f&2)){g=g+4|0;break}else{g=(g|2)+(i>>>1)|0;break}while(0);if(g>>>0>=c>>>0)Fj();if(!(f&4))if(e|0){k=0;l=0;i=0;f=0;do{j=k;k=k+1|0;l=l<<8|(h[d+j>>0]|0);f=f+8|0;if(f>>>0>5)while(1){f=f+-6|0;m=(af(l>>>f&63)|0)&255;j=i+1|0;b[a+i>>0]=m;if(f>>>0>5)i=j;else{i=j;break}}}while((k|0)!=(e|0));if(f){m=(af(l<<6-f&63)|0)&255;b[a+i>>0]=m;i=i+1|0}}else i=0;else if(e|0){k=0;f=0;l=0;i=0;do{m=l;l=l+1|0;k=k<<8|(h[d+m>>0]|0);f=f+8|0;if(f>>>0>5)while(1){f=f+-6|0;m=(Ze(k>>>f&63)|0)&255;j=i+1|0;b[a+i>>0]=m;if(f>>>0>5)i=j;else{i=j;break}}}while((l|0)!=(e|0));if(f){m=(Ze(k<<6-f&63)|0)&255;b[a+i>>0]=m;i=i+1|0}}else i=0;if(g>>>0<i>>>0)ca(35289,35308,230,35324);if(g>>>0>i>>>0)ec(a+i|0,61,g-i|0)|0;else g=i;m=g+1|0;ec(a+g|0,0,(m>>>0<c>>>0?c:m)-g|0)|0;return a|0}function Ua(a,c,d,e,g,i,j,k){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;i=i|0;j=j|0;k=k|0;var l=0,m=0,n=0,o=0;n=t;o=t=t+63&-64;t=t+112|0;if(!((d|0)==0&(e|0)==0)){m=o;l=m+32|0;do{b[m>>0]=b[k>>0]|0;m=m+1|0;k=k+1|0}while((m|0)<(l|0));k=h[g+4>>0]|h[g+4+1>>0]<<8|h[g+4+2>>0]<<16|h[g+4+3>>0]<<24;f[o+96>>2]=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;f[o+96+4>>2]=k;k=8;while(1){b[o+96+k>>0]=i;i=$f(i|0,j|0,8)|0;k=k+1|0;if((k|0)==16)break;else j=G}if(e>>>0>0|(e|0)==0&d>>>0>63){k=a;i=d;while(1){vh(o+32|0,o+96|0,o,0)|0;a=0;do{b[k+a>>0]=b[o+32+a>>0]^b[c+a>>0];a=a+1|0}while((a|0)!=64);a=1;j=8;while(1){d=o+96+j|0;a=a+(h[d>>0]|0)|0;b[d>>0]=a;j=j+1|0;if((j|0)==16)break;else a=a>>>8}j=Lg(i|0,e|0,-64,-1)|0;e=G;a=k+64|0;c=c+64|0;if(e>>>0>0|(e|0)==0&j>>>0>63){k=a;i=j}else break}}else j=d;if(!((j|0)==0&(e|0)==0)?(vh(o+32|0,o+96|0,o,0)|0,j|0):0){e=0;do{b[a+e>>0]=b[o+32+e>>0]^b[c+e>>0];e=e+1|0}while((e|0)!=(j|0))}ye(o+32|0,64);ye(o,32)}t=n;return 0}function Va(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0;a:do if(a|0){do if((f[a+36>>2]|0)==2){d=f[c>>2]|0;if((d|0)==0?(h[c+8>>0]|0)<=1:0){e=6;break}m=0;l=f[a+4>>2]|0}else e=6;while(0);if((e|0)==6){l=f[a+4>>2]|0;tb(a,c,l);m=1;d=f[c>>2]|0}g=b[c+8>>0]|0;d=(d|0)==0&g<<24>>24==0?2:0;e=f[a+24>>2]|0;j=V(e,f[c+4>>2]|0)|0;k=f[a+20>>2]|0;g=j+d+(V(k,g&255)|0)|0;if(d>>>0<k>>>0){k=g;g=(((g>>>0)%(e>>>0)|0|0)==0?e+-1|0:-1)+g|0;while(1){j=((k>>>0)%(e>>>0)|0|0)==1?k+-1|0:g;if(m)e=l+(d<<3)|0;else e=(f[(f[a>>2]|0)+4>>2]|0)+(j<<10)|0;i=e;o=f[i>>2]|0;i=pf(f[i+4>>2]|0,0,f[a+28>>2]|0,0)|0;n=f[c>>2]|0;g=b[c+8>>0]|0;e=f[c+4>>2]|0;i=(n|0)==0&g<<24>>24==0?e:i;f[c+12>>2]=d;g=Sb(a,n,g,d,o,((i|0)==(e|0)?(((n|0)==0&g<<24>>24==0?0:G)|0)==0:0)&1)|0;e=f[(f[a>>2]|0)+4>>2]|0;g=e+((V(f[a+24>>2]|0,i)|0)<<10)+(g<<10)|0;i=e+(k<<10)|0;if(!n)ra(e+(j<<10)|0,g,i);else qa(e+(j<<10)|0,g,i);d=d+1|0;if(d>>>0>=(f[a+20>>2]|0)>>>0)break a;k=k+1|0;g=j+1|0;e=f[a+24>>2]|0}}}while(0);return}function Wa(a,c,d,e,g,i){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;i=i|0;var j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;p=t;q=t=t+63&-64;t=t+112|0;if(!((d|0)==0&(e|0)==0)){k=q;j=k+32|0;do{b[k>>0]=b[i>>0]|0;k=k+1|0;i=i+1|0}while((k|0)<(j|0));k=h[g+4>>0]|h[g+4+1>>0]<<8|h[g+4+2>>0]<<16|h[g+4+3>>0]<<24;f[q+96>>2]=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;f[q+96+4>>2]=k;f[q+96+8>>2]=0;f[q+96+8+4>>2]=0;if(e>>>0>0|(e|0)==0&d>>>0>63){k=c;g=d;do{th(q+32|0,q+96|0,q,0)|0;i=0;do{b[a+i>>0]=b[q+32+i>>0]^b[k+i>>0];i=i+1|0}while((i|0)!=64);i=1;j=8;while(1){d=q+96+j|0;i=i+(h[d>>0]|0)|0;b[d>>0]=i;j=j+1|0;if((j|0)==16)break;else i=i>>>8}g=Lg(g|0,e|0,-64,-1)|0;e=G;a=a+64|0;k=k+64|0}while(e>>>0>0|(e|0)==0&g>>>0>63);if(!((g|0)==0&(e|0)==0)){m=a;n=g;o=k;l=10}}else{m=a;n=d;o=c;l=10}if((l|0)==10?(th(q+32|0,q+96|0,q,0)|0,n|0):0){i=0;do{b[m+i>>0]=b[q+32+i>>0]^b[o+i>>0];i=i+1|0}while((i|0)!=(n|0))}ye(q+32|0,64);ye(q,32)}t=p;return 0}function Xa(a,c,d,e,g,i){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;i=i|0;var j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;p=t;q=t=t+63&-64;t=t+112|0;if(!((d|0)==0&(e|0)==0)){k=q;j=k+32|0;do{b[k>>0]=b[i>>0]|0;k=k+1|0;i=i+1|0}while((k|0)<(j|0));k=h[g+4>>0]|h[g+4+1>>0]<<8|h[g+4+2>>0]<<16|h[g+4+3>>0]<<24;f[q+96>>2]=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;f[q+96+4>>2]=k;f[q+96+8>>2]=0;f[q+96+8+4>>2]=0;if(e>>>0>0|(e|0)==0&d>>>0>63){k=c;g=d;do{uh(q+32|0,q+96|0,q,0)|0;i=0;do{b[a+i>>0]=b[q+32+i>>0]^b[k+i>>0];i=i+1|0}while((i|0)!=64);i=1;j=8;while(1){d=q+96+j|0;i=i+(h[d>>0]|0)|0;b[d>>0]=i;j=j+1|0;if((j|0)==16)break;else i=i>>>8}g=Lg(g|0,e|0,-64,-1)|0;e=G;a=a+64|0;k=k+64|0}while(e>>>0>0|(e|0)==0&g>>>0>63);if(!((g|0)==0&(e|0)==0)){m=a;n=g;o=k;l=10}}else{m=a;n=d;o=c;l=10}if((l|0)==10?(uh(q+32|0,q+96|0,q,0)|0,n|0):0){i=0;do{b[m+i>>0]=b[q+32+i>>0]^b[o+i>>0];i=i+1|0}while((i|0)!=(n|0))}ye(q+32|0,64);ye(q,32)}t=p;return 0}function Ya(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0,g=0;g=t;f=t=t+63&-64;t=t+336|0;if(!(Jc(d)|0)){e=0;do{b[a+e>>0]=b[c+e>>0]|0;e=e+1|0}while((e|0)!=32);b[a>>0]=b[a>>0]&-8;b[a+31>>0]=b[a+31>>0]&63|64;Ba(f+288|0,d);Bg(f+240|0);ph(f+192|0);Rc(f+144|0,f+288|0);Bg(f+96|0);e=0;c=254;while(1){d=e;e=(h[a+(c>>>3)>>0]|0)>>>(c&7)&1;d=e^d;ib(f+240|0,f+144|0,d);ib(f+192|0,f+96|0,d);Vb(f+48|0,f+144|0,f+96|0);Vb(f,f+240|0,f+192|0);Wb(f+240|0,f+240|0,f+192|0);Wb(f+192|0,f+144|0,f+96|0);pa(f+96|0,f+48|0,f+240|0);pa(f+192|0,f+192|0,f);ua(f+48|0,f);ua(f,f+240|0);Wb(f+144|0,f+96|0,f+192|0);Vb(f+192|0,f+96|0,f+192|0);pa(f+240|0,f,f+48|0);Vb(f,f,f+48|0);ua(f+192|0,f+192|0);Ca(f+96|0,f);ua(f+144|0,f+144|0);Wb(f+48|0,f+48|0,f+96|0);pa(f+96|0,f+288|0,f+192|0);pa(f+192|0,f,f+48|0);if(!c)break;else c=c+-1|0}ib(f+240|0,f+144|0,e);ib(f+192|0,f+96|0,e);Za(f+192|0,f+192|0);pa(f+240|0,f+240|0,f+192|0);rb(a,f+240|0);e=0}else e=-1;t=g;return e|0}function Za(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+192|0;ua(d+144|0,b);ua(d+96|0,d+144|0);ua(d+96|0,d+96|0);pa(d+96|0,b,d+96|0);pa(d+144|0,d+144|0,d+96|0);ua(d+48|0,d+144|0);pa(d+96|0,d+96|0,d+48|0);ua(d+48|0,d+96|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=5);pa(d+96|0,d+48|0,d+96|0);ua(d+48|0,d+96|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=10);pa(d+48|0,d+48|0,d+96|0);ua(d,d+48|0);b=1;do{ua(d,d);b=b+1|0}while((b|0)!=20);pa(d+48|0,d,d+48|0);ua(d+48|0,d+48|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=10);pa(d+96|0,d+48|0,d+96|0);ua(d+48|0,d+96|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=50);pa(d+48|0,d+48|0,d+96|0);ua(d,d+48|0);b=1;do{ua(d,d);b=b+1|0}while((b|0)!=100);pa(d+48|0,d,d+48|0);ua(d+48|0,d+48|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=50);pa(d+96|0,d+48|0,d+96|0);ua(d+96|0,d+96|0);b=1;do{ua(d+96|0,d+96|0);b=b+1|0}while((b|0)!=5);pa(a,d+96|0,d+144|0);t=c;return}function _a(a,c,d,e,g,h,i,j,k,l){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;var m=0,n=0,o=0;n=t;o=t=t+63&-64;t=t+336|0;if(d|0){f[d>>2]=0;f[d+4>>2]=0}if(h>>>0>0|(h|0)==0&g>>>0>4294967278)Fj();Wg(o,64,0,a+32|0,a)|0;Lh(o+64|0,o)|0;ye(o,64);Kg(o+64|0,i,j,k)|0;i=Ig(0,0,j|0,k|0)|0;Kg(o+64|0,35456,i&15,0)|0;i=o;m=i+64|0;do{f[i>>2]=0;i=i+4|0}while((i|0)<(m|0));b[o>>0]=l;Sf(o,o,64,0,a+32|0,1,a)|0;Kg(o+64|0,o,64,0)|0;b[c>>0]=b[o>>0]|0;Sf(c+1|0,e,g,h,a+32|0,2,a)|0;Kg(o+64|0,c+1|0,g,h)|0;Kg(o+64|0,35456,g&15,0)|0;We(o+320|0,j,k);Kg(o+64|0,o+320|0,8,0)|0;k=Lg(g|0,h|0,64,0)|0;We(o+320|0,k,G);Kg(o+64|0,o+320|0,8,0)|0;Kh(o+64|0,c+1+g|0)|0;ye(o+64|0,256);Of(a+36|0,c+1+g|0);of(a+32|0);if(!((l&2)==0?!(ge(a+32|0,4)|0):0))Gb(a);if(d|0){o=Lg(g|0,h|0,17,0)|0;f[d>>2]=o;f[d+4>>2]=G}t=n;return 0}function $a(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+192|0;ua(d+144|0,b);pa(d+96|0,d+144|0,b);ua(d+144|0,d+96|0);ua(d+48|0,d+144|0);ua(d+48|0,d+48|0);pa(d+48|0,d+48|0,d+144|0);pa(d+96|0,d+48|0,b);ua(d+48|0,d+96|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=5);pa(d+96|0,d+48|0,d+96|0);ua(d+48|0,d+96|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=10);pa(d+48|0,d+48|0,d+96|0);ua(d,d+48|0);b=1;do{ua(d,d);b=b+1|0}while((b|0)!=20);pa(d+48|0,d,d+48|0);ua(d+48|0,d+48|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=10);pa(d+96|0,d+48|0,d+96|0);ua(d+48|0,d+96|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=50);pa(d+48|0,d+48|0,d+96|0);ua(d,d+48|0);b=1;do{ua(d,d);b=b+1|0}while((b|0)!=100);pa(d+48|0,d,d+48|0);ua(d+48|0,d+48|0);b=1;do{ua(d+48|0,d+48|0);b=b+1|0}while((b|0)!=50);pa(d+96|0,d+48|0,d+96|0);ua(d+96|0,d+96|0);b=1;do{ua(d+96|0,d+96|0);b=b+1|0}while((b|0)!=4);pa(a,d+96|0,d+144|0);t=c;return}function ab(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0;e=f[a+56>>2]|0;d=f[a+56+4>>2]|0;if(!((e|0)==0&(d|0)==0)){b[a+64+e>>0]=1;d=Lg(e|0,d|0,1,0)|0;g=G;if(g>>>0<0|(g|0)==0&d>>>0<16)ec(a+64+d|0,0,14-e+1|0)|0;b[a+80>>0]=1;Aa(a,a+64|0,16,0)}e=f[a+24>>2]|0;g=(f[a+28>>2]|0)+(e>>>26)|0;i=(g>>>26)+(f[a+32>>2]|0)|0;j=(i>>>26)+(f[a+36>>2]|0)|0;n=((j>>>26)*5|0)+(f[a+20>>2]|0)|0;l=(((n&67108863)+5|0)>>>26)+((n>>>26)+(e&67108863))|0;k=(j|-67108864)+(((((l>>>26)+(g&67108863)|0)>>>26)+(i&67108863)|0)>>>26)|0;m=(k>>>31)+-1&67108863;i=k>>31&(i&67108863)|m&(((l>>>26)+(g&67108863)|0)>>>26)+(i&67108863);h=Lg(k>>31&(n&67108863)|m&(n&67108863)+5|(k>>31&(n>>>26)+(e&67108863)|m&l)<<26|0,0,f[a+40>>2]|0,0)|0;d=G;e=Lg((k>>31&(n>>>26)+(e&67108863)|m&l)>>>6|(k>>31&(g&67108863)|m&(l>>>26)+(g&67108863))<<20|0,0,f[a+44>>2]|0,0)|0;d=Lg(e|0,G|0,d|0,0)|0;e=G;g=Lg((k>>31&(g&67108863)|m&(l>>>26)+(g&67108863))>>>12|i<<14|0,0,f[a+48>>2]|0,0)|0;e=Lg(g|0,G|0,e|0,0)|0;g=G;i=Lg(((k>>>31)+-1&k|k>>31&j)<<8|i>>>18|0,0,f[a+52>>2]|0,0)|0;g=Lg(i|0,G|0,g|0,0)|0;Qg(c,h);Qg(c+4|0,d);Qg(c+8|0,e);Qg(c+12|0,g);ye(a,88);return}function bb(a,b,c,d,e,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;var i=0,j=0,k=0,l=0;j=t;k=t=t+63&-64;t=t+352|0;Ha(k,g,h,0)|0;if(a>>>0>c>>>0?0<e>>>0|0==(e|0)&(a-c|0)>>>0<d>>>0:0)i=5;else if(c>>>0>a>>>0?0<e>>>0|0==(e|0)&(c-a|0)>>>0<d>>>0:0)i=5;if((i|0)==5){se(a|0,c|0,d|0)|0;c=a}f[k+32>>2]=0;f[k+32+4>>2]=0;f[k+32+8>>2]=0;f[k+32+12>>2]=0;f[k+32+16>>2]=0;f[k+32+20>>2]=0;f[k+32+24>>2]=0;f[k+32+28>>2]=0;h=e>>>0>0|(e|0)==0&d>>>0>32?32:d;i=e>>>0>0|(e|0)==0&d>>>0>32?0:e;if(!((h|0)==0&(i|0)==0)){l=~e>>>0>4294967295|(~e|0)==-1&~d>>>0>4294967263?~d:-33;qb(k+32+32|0,c|0,-2-l+1|0)|0}l=Lg(h|0,i|0,32,0)|0;wg(k+32|0,k+32|0,l,G,g+16|0,k)|0;Lh(k+96|0,k+32|0)|0;if(!((h|0)==0&(i|0)==0)){l=~e>>>0>4294967295|(~e|0)==-1&~d>>>0>4294967263?~d:-33;qb(a|0,k+32+32|0,-2-l+1|0)|0}ye(k+32|0,64);if(e>>>0>0|(e|0)==0&d>>>0>32){l=Ig(d|0,e|0,h|0,i|0)|0;Gf(a+h|0,c+h|0,l,G,g+16|0,1,0,k)|0}ye(k,32);Kg(k+96|0,a,d,e)|0;Kh(k+96|0,b)|0;ye(k+96|0,256);t=j;return 0}function cb(a,c){a=a|0;c=c|0;var d=0,e=0,f=0;e=t;f=t=t+63&-64;t=t+1760|0;If(f,c);Jf(f+1600|0,c);wf(f+1280|0,f+1600|0);Xc(f+1600|0,f+1280|0,f);wf(f+1440|0,f+1600|0);If(f+160|0,f+1440|0);Xc(f+1600|0,f+1280|0,f+160|0);wf(f+1440|0,f+1600|0);If(f+320|0,f+1440|0);Xc(f+1600|0,f+1280|0,f+320|0);wf(f+1440|0,f+1600|0);If(f+480|0,f+1440|0);Xc(f+1600|0,f+1280|0,f+480|0);wf(f+1440|0,f+1600|0);If(f+640|0,f+1440|0);Xc(f+1600|0,f+1280|0,f+640|0);wf(f+1440|0,f+1600|0);If(f+800|0,f+1440|0);Xc(f+1600|0,f+1280|0,f+800|0);wf(f+1440|0,f+1600|0);If(f+960|0,f+1440|0);Xc(f+1600|0,f+1280|0,f+960|0);wf(f+1440|0,f+1600|0);If(f+1120|0,f+1440|0);Gh(a);c=252;while(1){Jf(f+1600|0,a);d=b[31840+c>>0]|0;if(d<<24>>24<=0){if(d<<24>>24<0){wf(f+1440|0,f+1600|0);Wc(f+1600|0,f+1440|0,f+((((d<<24>>24)/-2|0)<<24>>24)*160|0)|0)}}else{wf(f+1440|0,f+1600|0);Xc(f+1600|0,f+1440|0,f+(((d&255)>>>1&255)*160|0)|0)}wf(a,f+1600|0);if(!c)break;else c=c+-1|0}t=e;return}function db(a,b,c,d,e,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;var i=0,j=0,k=0,l=0;j=t;k=t=t+63&-64;t=t+352|0;La(k,g,h,0)|0;if(a>>>0>c>>>0?0<e>>>0|0==(e|0)&(a-c|0)>>>0<d>>>0:0)i=5;else if(c>>>0>a>>>0?0<e>>>0|0==(e|0)&(c-a|0)>>>0<d>>>0:0)i=5;if((i|0)==5){se(a|0,c|0,d|0)|0;c=a}f[k+32>>2]=0;f[k+32+4>>2]=0;f[k+32+8>>2]=0;f[k+32+12>>2]=0;f[k+32+16>>2]=0;f[k+32+20>>2]=0;f[k+32+24>>2]=0;f[k+32+28>>2]=0;h=e>>>0>0|(e|0)==0&d>>>0>32?32:d;i=e>>>0>0|(e|0)==0&d>>>0>32?0:e;if(!((h|0)==0&(i|0)==0)){l=~e>>>0>4294967295|(~e|0)==-1&~d>>>0>4294967263?~d:-33;qb(k+32+32|0,c|0,-2-l+1|0)|0}l=Lg(h|0,i|0,32,0)|0;sg(k+32|0,k+32|0,l,G,g+16|0,k)|0;Lh(k+96|0,k+32|0)|0;if(!((h|0)==0&(i|0)==0)){l=~e>>>0>4294967295|(~e|0)==-1&~d>>>0>4294967263?~d:-33;qb(a|0,k+32+32|0,-2-l+1|0)|0}ye(k+32|0,64);if(e>>>0>0|(e|0)==0&d>>>0>32){l=Ig(d|0,e|0,h|0,i|0)|0;Ef(a+h|0,c+h|0,l,G,g+16|0,1,0,k)|0}ye(k,32);Kg(k+96|0,a,d,e)|0;Kh(k+96|0,b)|0;ye(k+96|0,256);t=j;return 0}function eb(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;d=t;e=t=t+63&-64;t=t+144|0;ua(e+96|0,b);ua(e+48|0,e+96|0);ua(e+48|0,e+48|0);pa(e+48|0,b,e+48|0);pa(e+96|0,e+96|0,e+48|0);ua(e+96|0,e+96|0);pa(e+96|0,e+48|0,e+96|0);ua(e+48|0,e+96|0);c=1;do{ua(e+48|0,e+48|0);c=c+1|0}while((c|0)!=5);pa(e+96|0,e+48|0,e+96|0);ua(e+48|0,e+96|0);c=1;do{ua(e+48|0,e+48|0);c=c+1|0}while((c|0)!=10);pa(e+48|0,e+48|0,e+96|0);ua(e,e+48|0);c=1;do{ua(e,e);c=c+1|0}while((c|0)!=20);pa(e+48|0,e,e+48|0);ua(e+48|0,e+48|0);c=1;do{ua(e+48|0,e+48|0);c=c+1|0}while((c|0)!=10);pa(e+96|0,e+48|0,e+96|0);ua(e+48|0,e+96|0);c=1;do{ua(e+48|0,e+48|0);c=c+1|0}while((c|0)!=50);pa(e+48|0,e+48|0,e+96|0);ua(e,e+48|0);c=1;do{ua(e,e);c=c+1|0}while((c|0)!=100);pa(e+48|0,e,e+48|0);ua(e+48|0,e+48|0);c=1;do{ua(e+48|0,e+48|0);c=c+1|0}while((c|0)!=50);pa(e+96|0,e+48|0,e+96|0);ua(e+96|0,e+96|0);ua(e+96|0,e+96|0);pa(a,e+96|0,b);t=d;return}function fb(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,i=0;g=t;i=t=t+63&-64;t=t+960|0;e=a;d=e+32|0;do{b[e>>0]=b[c>>0]|0;e=e+1|0;c=c+1|0}while((e|0)<(d|0));e=h[a+31>>0]|0;b[a+31>>0]=e&127;Ba(i+384|0,a);ta(i+384|0,i+384|0);f[i+384>>2]=(f[i+384>>2]|0)+1;Za(i+384|0,i+384|0);pa(i+336|0,32352,i+384|0);Dc(i+336|0,i+336|0);ua(i+288|0,i+336|0);pa(i+240|0,i+336|0,i+288|0);Wb(i+480|0,i+240|0,i+336|0);pa(i+288|0,i+288|0,32352);Wb(i+480|0,i+288|0,i+480|0);$a(i+480|0,i+480|0);rb(a,i+480|0);d=b[a+1>>0]&1;Dc(i+432|0,i+336|0);Fb(i+336|0,i+432|0,d);ph(i+288|0);Fb(i+288|0,32352,d);Vb(i+336|0,i+336|0,i+288|0);Bg(i+192|0);Wb(i+144|0,i+336|0,i+192|0);Vb(i+48|0,i+336|0,i+192|0);Za(i+96|0,i+144|0);pa(i,i+48|0,i+96|0);rb(a,i);b[a+31>>0]=e&128|(h[a+31>>0]|0);if(!(Hb(i+800|0,a)|0)){Jf(i+640|0,i+800|0);jg(i+520|0,i+640|0);ud(i+640|0,i+520|0);jg(i+520|0,i+640|0);ud(i+640|0,i+520|0);wf(i+800|0,i+640|0);Pd(a,i+800|0);t=g;return}else ea()}function gb(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0;i=t;h=t=t+63&-64;t=t+64|0;if(c<<24>>24?(c&255)<=64:0){if(!(fi(f[a+80>>2]|0,f[a+80+4>>2]|0)|0)){d=f[a+352>>2]|0;do if(d>>>0>128){Gd(a,128,0);ka(a,a+96|0);d=(f[a+352>>2]|0)+-128|0;f[a+352>>2]=d;if(d>>>0<129){qb(a+96|0,a+224|0,d|0)|0;e=a+96|0;g=f[a+352>>2]|0;break}else ca(34057,34089,304,34134)}else{e=a+96|0;g=d}while(0);Gd(a,g,0);Pg(a);d=f[a+352>>2]|0;ec(a+96+d|0,0,256-d|0)|0;ka(a,e);We(h,f[a>>2]|0,f[a+4>>2]|0);We(h+8|0,f[a+8>>2]|0,f[a+8+4>>2]|0);We(h+16|0,f[a+16>>2]|0,f[a+16+4>>2]|0);We(h+24|0,f[a+24>>2]|0,f[a+24+4>>2]|0);We(h+32|0,f[a+32>>2]|0,f[a+32+4>>2]|0);We(h+40|0,f[a+40>>2]|0,f[a+40+4>>2]|0);We(h+48|0,f[a+48>>2]|0,f[a+48+4>>2]|0);We(h+56|0,f[a+56>>2]|0,f[a+56+4>>2]|0);qb(b|0,h|0,c&255|0)|0;ye(a,64);ye(e,256);d=0}else d=-1;t=i;return d|0}Fj();return 0}function hb(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;var m=0,n=0,o=0;o=Af(j|0,0,i|0,0)|0;n=G;do if(n>>>0>0|(n|0)==0&o>>>0>1073741823){f[9002]=27;a=-1}else{if(h>>>0>0|(h|0)==0&g>>>0>4294967295){f[9002]=27;a=-1;break}o=Lg(g|0,h|0,-1,-1)|0;if(h>>>0<0|(h|0)==0&g>>>0<2|((o&g|0)!=0|(G&h|0)!=0)){f[9002]=22;a=-1;break}if((i|0)==0|(j|0)==0){f[9002]=22;a=-1;break}if(!(i>>>0>16777215?1:(33554431/(j>>>0)|0)>>>0<i>>>0)?!(0<h>>>0|(0==(h|0)?(33554431/(i>>>0)|0)>>>0<g>>>0:0)):0){n=V(i<<7,j)|0;o=V(i<<7,g)|0;if((n+o|0)>>>0<o>>>0){f[9002]=12;a=-1;break}m=n+o+(i<<8|64)|0;if(m>>>0<(i<<8|64)>>>0){f[9002]=12;a=-1;break}if((f[a+8>>2]|0)>>>0<m>>>0?(Mh(a),(Wd(a,m)|0)==0):0){a=-1;break}m=f[a+4>>2]|0;yc(b,c,d,e,m,n);a=0;do{ob(m+(V(i<<7,a)|0)|0,i,g,h,m+n|0,m+n+o|0);a=a+1|0}while((a|0)!=(j|0));yc(b,c,m,n,k,l);a=0;break}f[9002]=12;a=-1}while(0);return a|0}function ib(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0;x=f[a>>2]|0;v=f[a+4>>2]|0;t=f[a+8>>2]|0;r=f[a+12>>2]|0;p=f[a+16>>2]|0;n=f[a+20>>2]|0;l=f[a+24>>2]|0;j=f[a+28>>2]|0;h=f[a+32>>2]|0;e=f[a+36>>2]|0;w=f[b>>2]|0;u=f[b+4>>2]|0;s=f[b+8>>2]|0;q=f[b+12>>2]|0;o=f[b+16>>2]|0;m=f[b+20>>2]|0;k=f[b+24>>2]|0;i=f[b+28>>2]|0;g=f[b+32>>2]|0;d=f[b+36>>2]|0;f[a>>2]=(w^x)&0-c^x;f[a+4>>2]=(u^v)&0-c^v;f[a+8>>2]=(s^t)&0-c^t;f[a+12>>2]=(q^r)&0-c^r;f[a+16>>2]=(o^p)&0-c^p;f[a+20>>2]=(m^n)&0-c^n;f[a+24>>2]=(k^l)&0-c^l;f[a+28>>2]=(i^j)&0-c^j;f[a+32>>2]=(g^h)&0-c^h;f[a+36>>2]=(d^e)&0-c^e;f[b>>2]=(w^x)&0-c^w;f[b+4>>2]=(u^v)&0-c^u;f[b+8>>2]=(s^t)&0-c^s;f[b+12>>2]=(q^r)&0-c^q;f[b+16>>2]=(o^p)&0-c^o;f[b+20>>2]=(m^n)&0-c^m;f[b+24>>2]=(k^l)&0-c^k;f[b+28>>2]=(i^j)&0-c^i;f[b+32>>2]=(g^h)&0-c^g;f[b+36>>2]=(d^e)&0-c^d;return}function jb(a,c,d,e,g,i,j){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;i=i|0;j=j|0;var k=0,l=0,m=0,n=0,o=0,p=0,q=0;a:do if(e){l=0;m=0;k=0;p=0;b:while(1){while(1){n=h[d+k>>0]|0;o=(((n&223)+201&255)+65526^((n&223)+201&255)+65520)>>>8;if((o|((n^48)+65526|0)>>>8)&255|0)break;if(!((g|0)!=0&l<<24>>24==0)){n=0;break b}if(!(sh(g,n)|0)){q=17;break a}k=k+1|0;if(k>>>0<e>>>0)l=0;else{q=17;break a}}n=o&(n&223)+201|((n^48)+65526|0)>>>8&(n^48);if(m>>>0>=c>>>0){q=9;break}if(!(l<<24>>24))n=n<<4&255;else{b[a+m>>0]=n|p&255;m=m+1|0;n=p}l=~l;k=k+1|0;if(k>>>0<e>>>0)p=n;else{n=0;break}}if((q|0)==9){f[9002]=34;n=-1}if(!(l<<24>>24))if(!n){q=17;break}else{l=k;k=-1;m=0;break}else{f[9002]=22;l=k+-1|0;k=-1;m=0;break}}else{m=0;k=0;q=17}while(0);if((q|0)==17){l=k;k=0}if(!j){if((l|0)!=(e|0)){f[9002]=22;k=-1}}else f[j>>2]=d+l;if(i|0)f[i>>2]=m;return k|0}function kb(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var i=0,j=0,k=0,l=0,m=0,n=0,o=0;n=t;o=t=t+63&-64;t=t+112|0;if(!((c|0)==0&(d|0)==0)){j=o;i=j+32|0;do{b[j>>0]=b[g>>0]|0;j=j+1|0;g=g+1|0}while((j|0)<(i|0));j=h[e+4>>0]|h[e+4+1>>0]<<8|h[e+4+2>>0]<<16|h[e+4+3>>0]<<24;f[o+96>>2]=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;f[o+96+4>>2]=j;f[o+96+8>>2]=0;f[o+96+8+4>>2]=0;if(d>>>0>0|(d|0)==0&c>>>0>63){do{th(a,o+96|0,o,0)|0;g=1;i=8;while(1){j=o+96+i|0;g=g+(h[j>>0]|0)|0;b[j>>0]=g;i=i+1|0;if((i|0)==16)break;else g=g>>>8}c=Lg(c|0,d|0,-64,-1)|0;d=G;a=a+64|0}while(d>>>0>0|(d|0)==0&c>>>0>63);if(!((c|0)==0&(d|0)==0)){l=a;m=c;k=8}}else{l=a;m=c;k=8}if((k|0)==8?(th(o+32|0,o+96|0,o,0)|0,m|0):0){g=0;do{b[l+g>>0]=b[o+32+g>>0]|0;g=g+1|0}while((g|0)!=(m|0))}ye(o+32|0,64);ye(o,32)}t=n;return 0}function lb(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var i=0,j=0,k=0,l=0,m=0,n=0,o=0;n=t;o=t=t+63&-64;t=t+112|0;if(!((c|0)==0&(d|0)==0)){j=o;i=j+32|0;do{b[j>>0]=b[g>>0]|0;j=j+1|0;g=g+1|0}while((j|0)<(i|0));j=h[e+4>>0]|h[e+4+1>>0]<<8|h[e+4+2>>0]<<16|h[e+4+3>>0]<<24;f[o+96>>2]=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;f[o+96+4>>2]=j;f[o+96+8>>2]=0;f[o+96+8+4>>2]=0;if(d>>>0>0|(d|0)==0&c>>>0>63){do{uh(a,o+96|0,o,0)|0;g=1;i=8;while(1){j=o+96+i|0;g=g+(h[j>>0]|0)|0;b[j>>0]=g;i=i+1|0;if((i|0)==16)break;else g=g>>>8}c=Lg(c|0,d|0,-64,-1)|0;d=G;a=a+64|0}while(d>>>0>0|(d|0)==0&c>>>0>63);if(!((c|0)==0&(d|0)==0)){l=a;m=c;k=8}}else{l=a;m=c;k=8}if((k|0)==8?(uh(o+32|0,o+96|0,o,0)|0,m|0):0){g=0;do{b[l+g>>0]=b[o+32+g>>0]|0;g=g+1|0}while((g|0)!=(m|0))}ye(o+32|0,64);ye(o,32)}t=n;return 0}function mb(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var i=0,j=0,k=0,l=0,m=0,n=0,o=0;n=t;o=t=t+63&-64;t=t+112|0;if(!((c|0)==0&(d|0)==0)){j=o;i=j+32|0;do{b[j>>0]=b[g>>0]|0;j=j+1|0;g=g+1|0}while((j|0)<(i|0));j=h[e+4>>0]|h[e+4+1>>0]<<8|h[e+4+2>>0]<<16|h[e+4+3>>0]<<24;f[o+96>>2]=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;f[o+96+4>>2]=j;f[o+96+8>>2]=0;f[o+96+8+4>>2]=0;if(d>>>0>0|(d|0)==0&c>>>0>63){do{vh(a,o+96|0,o,0)|0;g=1;i=8;while(1){j=o+96+i|0;g=g+(h[j>>0]|0)|0;b[j>>0]=g;i=i+1|0;if((i|0)==16)break;else g=g>>>8}c=Lg(c|0,d|0,-64,-1)|0;d=G;a=a+64|0}while(d>>>0>0|(d|0)==0&c>>>0>63);if(!((c|0)==0&(d|0)==0)){l=a;m=c;k=8}}else{l=a;m=c;k=8}if((k|0)==8?(vh(o+32|0,o+96|0,o,0)|0,m|0):0){g=0;do{b[l+g>>0]=b[o+32+g>>0]|0;g=g+1|0}while((g|0)!=(m|0))}ye(o+32|0,64);ye(o,32)}t=n;return 0}function nb(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0,j=0,k=0;j=t;i=t=t+63&-64;t=t+96|0;Ha(i,f,g,0)|0;hh(i+32|0,32,0,f+16|0,i)|0;if(!(vg(c,b,d,e,i+32|0)|0))if(!a)c=0;else{if(b>>>0>=a>>>0?0<e>>>0|0==(e|0)&(b-a|0)>>>0<d>>>0:0)h=8;else if(a>>>0>=b>>>0?0<e>>>0|0==(e|0)&(a-b|0)>>>0<d>>>0:0)h=8;if((h|0)==8){se(a|0,b|0,d|0)|0;b=a}c=e>>>0>0|(e|0)==0&d>>>0>32?32:d;g=e>>>0>0|(e|0)==0&d>>>0>32?0:e;if((c|0)==0&(g|0)==0)wg(i+32|0,i+32|0,32,0,f+16|0,i)|0;else{h=~e>>>0>4294967295|(~e|0)==-1&~d>>>0>4294967263?~d:-33;qb(i+32+32|0,b|0,-2-h+1|0)|0;k=Lg(c|0,g|0,32,0)|0;wg(i+32|0,i+32|0,k,G,f+16|0,i)|0;qb(a|0,i+32+32|0,-2-h+1|0)|0}if(e>>>0>0|(e|0)==0&d>>>0>32){k=Ig(d|0,e|0,c|0,g|0)|0;Gf(a+c|0,b+c|0,k,G,f+16|0,1,0,i)|0}ye(i,32);c=0}else{ye(i,32);c=-1}t=j;return c|0}function ob(a,b,c,d,e,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0,j=0,k=0,l=0;if(b<<5|0){h=0;do{k=yh(a+(h<<2)|0)|0;f[g+(h<<2)>>2]=k;h=h+1|0}while((h|0)!=(b<<5|0))}if(!((c|0)==0&(d|0)==0)){h=0;i=0;do{rf(e+((V(b<<5,h)|0)<<2)|0,g,b<<7);sd(g,g+(b<<5<<2)|0,g+(b<<6<<2)|0,b);rf(e+((V(h|1,b<<5)|0)<<2)|0,g+(b<<5<<2)|0,b<<7);sd(g+(b<<5<<2)|0,g,g+(b<<6<<2)|0,b);h=Lg(h|0,i|0,2,0)|0;i=G}while(i>>>0<d>>>0|(i|0)==(d|0)&h>>>0<c>>>0);h=Lg(c|0,d|0,-1,-1)|0;i=G;j=0;k=0;do{l=oh(g,b)|0;$e(g,e+((V(b<<5,l&h)|0)<<2)|0,b<<7);sd(g,g+(b<<5<<2)|0,g+(b<<6<<2)|0,b);l=oh(g+(b<<5<<2)|0,b)|0;$e(g+(b<<5<<2)|0,e+((V(b<<5,l&h)|0)<<2)|0,b<<7);sd(g+(b<<5<<2)|0,g,g+(b<<6<<2)|0,b);j=Lg(j|0,k|0,2,0)|0;k=G}while(k>>>0<d>>>0|(k|0)==(d|0)&j>>>0<c>>>0)}if(b<<5|0){h=0;do{Qg(a+(h<<2)|0,f[g+(h<<2)>>2]|0);h=h+1|0}while((h|0)!=(b<<5|0))}return}function pb(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0,j=0,k=0;j=t;i=t=t+63&-64;t=t+96|0;La(i,f,g,0)|0;ch(i+32|0,32,0,f+16|0,i)|0;if(!(vg(c,b,d,e,i+32|0)|0))if(!a)c=0;else{if(b>>>0>=a>>>0?0<e>>>0|0==(e|0)&(b-a|0)>>>0<d>>>0:0)h=8;else if(a>>>0>=b>>>0?0<e>>>0|0==(e|0)&(a-b|0)>>>0<d>>>0:0)h=8;if((h|0)==8){se(a|0,b|0,d|0)|0;b=a}c=e>>>0>0|(e|0)==0&d>>>0>32?32:d;g=e>>>0>0|(e|0)==0&d>>>0>32?0:e;if((c|0)==0&(g|0)==0)sg(i+32|0,i+32|0,32,0,f+16|0,i)|0;else{h=~e>>>0>4294967295|(~e|0)==-1&~d>>>0>4294967263?~d:-33;qb(i+32+32|0,b|0,-2-h+1|0)|0;k=Lg(c|0,g|0,32,0)|0;sg(i+32|0,i+32|0,k,G,f+16|0,i)|0;qb(a|0,i+32+32|0,-2-h+1|0)|0}if(e>>>0>0|(e|0)==0&d>>>0>32){k=Ig(d|0,e|0,c|0,g|0)|0;Ef(a+c|0,b+c|0,k,G,f+16|0,1,0,i)|0}ye(i,32);c=0}else{ye(i,32);c=-1}t=j;return c|0}function qb(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,h=0;if((d|0)>=8192)return ga(a|0,c|0,d|0)|0;h=a|0;g=a+d|0;if((a&3)==(c&3)){while(a&3){if(!d)return h|0;b[a>>0]=b[c>>0]|0;a=a+1|0;c=c+1|0;d=d-1|0}d=g&-4|0;e=d-64|0;while((a|0)<=(e|0)){f[a>>2]=f[c>>2];f[a+4>>2]=f[c+4>>2];f[a+8>>2]=f[c+8>>2];f[a+12>>2]=f[c+12>>2];f[a+16>>2]=f[c+16>>2];f[a+20>>2]=f[c+20>>2];f[a+24>>2]=f[c+24>>2];f[a+28>>2]=f[c+28>>2];f[a+32>>2]=f[c+32>>2];f[a+36>>2]=f[c+36>>2];f[a+40>>2]=f[c+40>>2];f[a+44>>2]=f[c+44>>2];f[a+48>>2]=f[c+48>>2];f[a+52>>2]=f[c+52>>2];f[a+56>>2]=f[c+56>>2];f[a+60>>2]=f[c+60>>2];a=a+64|0;c=c+64|0}while((a|0)<(d|0)){f[a>>2]=f[c>>2];a=a+4|0;c=c+4|0}}else{d=g-4|0;while((a|0)<(d|0)){b[a>>0]=b[c>>0]|0;b[a+1>>0]=b[c+1>>0]|0;b[a+2>>0]=b[c+2>>0]|0;b[a+3>>0]=b[c+3>>0]|0;a=a+4|0;c=c+4|0}}while((a|0)<(g|0)){b[a>>0]=b[c>>0]|0;a=a+1|0;c=c+1|0}return h|0}function rb(a,c){a=a|0;c=c|0;var d=0,e=0,g=0;d=t;g=t=t+63&-64;t=t+48|0;vb(g,c);c=f[g>>2]|0;b[a>>0]=c;b[a+1>>0]=c>>>8;b[a+2>>0]=c>>>16;e=f[g+4>>2]|0;b[a+3>>0]=e<<2|c>>>24;b[a+4>>0]=e>>>6;b[a+5>>0]=e>>>14;c=f[g+8>>2]|0;b[a+6>>0]=c<<3|e>>>22;b[a+7>>0]=c>>>5;b[a+8>>0]=c>>>13;e=f[g+12>>2]|0;b[a+9>>0]=e<<5|c>>>21;b[a+10>>0]=e>>>3;b[a+11>>0]=e>>>11;c=f[g+16>>2]|0;b[a+12>>0]=c<<6|e>>>19;b[a+13>>0]=c>>>2;b[a+14>>0]=c>>>10;b[a+15>>0]=c>>>18;c=f[g+20>>2]|0;b[a+16>>0]=c;b[a+17>>0]=c>>>8;b[a+18>>0]=c>>>16;e=f[g+24>>2]|0;b[a+19>>0]=e<<1|c>>>24;b[a+20>>0]=e>>>7;b[a+21>>0]=e>>>15;c=f[g+28>>2]|0;b[a+22>>0]=c<<3|e>>>23;b[a+23>>0]=c>>>5;b[a+24>>0]=c>>>13;e=f[g+32>>2]|0;b[a+25>>0]=e<<4|c>>>21;b[a+26>>0]=e>>>4;b[a+27>>0]=e>>>12;c=f[g+36>>2]|0;b[a+28>>0]=c<<6|e>>>20;b[a+29>>0]=c>>>2;b[a+30>>0]=c>>>10;b[a+31>>0]=c>>>18;t=d;return}function sb(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,g=0,h=0,i=0,j=0,k=0,l=0;l=t;k=t=t+63&-64;t=t+64|0;e=k+8|0;g=e+52|0;do{f[e>>2]=0;e=e+4|0}while((e|0)<(g|0));e=Sc(a)|0;f[k+36>>2]=e;f[k+20>>2]=e;f[k+4>>2]=e;g=na(e)|0;f[k+32>>2]=g;h=na(e)|0;f[k+16>>2]=h;i=na(e)|0;f[k>>2]=i;do if((g|0)==0|((h|0)==0|(i|0)==0)){wa(g);wa(h);wa(i);e=-22}else{j=na(e)|0;if(!j){wa(g);wa(h);wa(i);e=-22;break}e=Ma(k,a,d)|0;if(e|0){wa(f[k+32>>2]|0);wa(f[k+16>>2]|0);wa(f[k>>2]|0);wa(j);break}d=Db(f[k+40>>2]|0,f[k+44>>2]|0,f[k+52>>2]|0,b,c,f[k+16>>2]|0,f[k+20>>2]|0,j,f[k+4>>2]|0,0,0,d)|0;wa(f[k+32>>2]|0);wa(f[k+16>>2]|0);if((d|0)==0?(hd(j,f[k>>2]|0,f[k+4>>2]|0)|0)==0:0)e=0;else e=-35;wa(j);wa(f[k>>2]|0)}while(0);t=l;return e|0}function tb(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,i=0,j=0;e=t;g=t=t+63&-64;t=t+4096|0;ui(g+3072|0);ui(g+2048|0);if((a|0)!=0&(b|0)!=0?(f[g+2048>>2]=f[b>>2],f[g+2048+4>>2]=0,f[g+2048+8>>2]=f[b+4>>2],f[g+2048+8+4>>2]=0,f[g+2048+16>>2]=h[b+8>>0],f[g+2048+16+4>>2]=0,f[g+2048+24>>2]=f[a+16>>2],f[g+2048+24+4>>2]=0,f[g+2048+32>>2]=f[a+8>>2],f[g+2048+32+4>>2]=0,f[g+2048+40>>2]=f[a+36>>2],f[g+2048+40+4>>2]=0,f[a+20>>2]|0):0){b=0;do{d=b&127;if(!d){i=Lg(f[g+2048+48>>2]|0,f[g+2048+48+4>>2]|0,1,0)|0;f[g+2048+48>>2]=i;f[g+2048+48+4>>2]=G;ui(g);ui(g+1024|0);qa(g+3072|0,g+2048|0,g);qa(g+3072|0,g,g+1024|0)}j=f[g+1024+(d<<3)+4>>2]|0;i=c+(b<<3)|0;f[i>>2]=f[g+1024+(d<<3)>>2];f[i+4>>2]=j;b=b+1|0}while(b>>>0<(f[a+20>>2]|0)>>>0)}t=e;return}function ub(a,c){a=a|0;c=c|0;var d=0,e=0,f=0,g=0,i=0;e=t;f=t=t+63&-64;t=t+464|0;d=0;do{i=b[c+d>>0]|0;g=d<<1;b[f+g>>0]=i&15;b[f+(g|1)>>0]=(i&255)>>>4;d=d+1|0}while((d|0)!=32);d=0;c=0;do{i=f+c|0;g=d+(h[i>>0]|0)|0;d=(g<<24)+134217728>>28;b[i>>0]=g-(d<<4);c=c+1|0}while((c|0)!=63);b[f+63>>0]=d+(h[f+63>>0]|0);Gh(a);d=1;do{Fh(f+64|0,d>>>1,b[f+d>>0]|0);$c(f+304|0,a,f+64|0);wf(a,f+304|0);d=d+2|0}while(d>>>0<64);Jf(f+304|0,a);jg(f+184|0,f+304|0);ud(f+304|0,f+184|0);jg(f+184|0,f+304|0);ud(f+304|0,f+184|0);jg(f+184|0,f+304|0);ud(f+304|0,f+184|0);wf(a,f+304|0);d=0;do{Fh(f+64|0,d>>>1,b[f+d>>0]|0);$c(f+304|0,a,f+64|0);wf(a,f+304|0);d=d+2|0}while(d>>>0<64);t=e;return}function vb(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0;l=f[b>>2]|0;n=f[b+4>>2]|0;j=f[b+8>>2]|0;i=f[b+12>>2]|0;h=f[b+16>>2]|0;m=f[b+20>>2]|0;e=f[b+24>>2]|0;d=f[b+28>>2]|0;c=f[b+32>>2]|0;b=f[b+36>>2]|0;k=(((((((((((((((b*19|0)+16777216|0)>>>25)+l>>26)+n>>25)+j>>26)+i>>25)+h>>26)+m>>25)+e>>26)+d>>25)+c>>26)+b>>25)*19|0)+l>>26)+n|0;g=((((k>>25)+j>>26)+i>>25)+h>>26)+m|0;f[a>>2]=((((((((((((((b*19|0)+16777216|0)>>>25)+l>>26)+n>>25)+j>>26)+i>>25)+h>>26)+m>>25)+e>>26)+d>>25)+c>>26)+b>>25)*19|0)+l&67108863;f[a+4>>2]=k&33554431;f[a+8>>2]=(k>>25)+j&67108863;f[a+12>>2]=((k>>25)+j>>26)+i&33554431;f[a+16>>2]=(((k>>25)+j>>26)+i>>25)+h&67108863;f[a+20>>2]=g&33554431;f[a+24>>2]=(g>>25)+e&67108863;f[a+28>>2]=((g>>25)+e>>26)+d&33554431;f[a+32>>2]=(((g>>25)+e>>26)+d>>25)+c&67108863;f[a+36>>2]=((((g>>25)+e>>26)+d>>25)+c>>26)+b&33554431;return}function wb(a,b,c,d,e,f,g,h,i,j,k){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;var l=0;l=t;t=t+352|0;Wg(l+16|0,64,0,j,k)|0;Lh(l+80|0,l+16|0)|0;ye(l+16|0,64);Kg(l+80|0,g,h,i)|0;b=Ig(0,0,h|0,i|0)|0;Kg(l+80|0,35424,b&15,0)|0;Kg(l+80|0,c,d,e)|0;b=Ig(0,0,d|0,e|0)|0;Kg(l+80|0,35424,b&15,0)|0;We(l+336|0,h,i);Kg(l+80|0,l+336|0,8,0)|0;We(l+336|0,d,e);Kg(l+80|0,l+336|0,8,0)|0;Kh(l+80|0,l)|0;ye(l+80|0,256);b=ki(l,f)|0;ye(l,16);do if(a)if(!b){Sf(a,c,d,e,j,1,k)|0;b=0;break}else{ec(a|0,0,d|0)|0;b=-1;break}while(0);t=l;return b|0}function xb(a){a=a|0;var b=0,c=0;do if(a)if(f[a>>2]|0)if((f[a+4>>2]|0)>>>0>=16){if((f[a+8>>2]|0)==0?f[a+12>>2]|0:0){b=-18;break}b=f[a+20>>2]|0;if(!(f[a+16>>2]|0))return ((b|0)==0?-6:-19)|0;if(b>>>0>=8){if((f[a+24>>2]|0)==0?f[a+28>>2]|0:0){b=-20;break}if((f[a+32>>2]|0)==0?f[a+36>>2]|0:0){b=-21;break}b=f[a+44>>2]|0;if(b>>>0>=8)if(b>>>0<=2097152){c=f[a+48>>2]|0;if(b>>>0>=c<<3>>>0)if(f[a+40>>2]|0)if(c)if(c>>>0>16777215)b=-17;else{a=f[a+52>>2]|0;return ((a|0)==0?-28:a>>>0>16777215?-29:0)|0}else b=-16;else b=-12;else b=-14}else b=-15;else b=-14}else b=-6}else b=-2;else b=-1;else b=-25;while(0);return b|0}function yb(a,c,d,e,g,h){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;var i=0,j=0;i=t;j=t=t+63&-64;t=t+192|0;if((c+-1&255)>63)Fj();if((d|0)!=0&e<<24>>24!=0?(e&255)<=64:0){b[j+128>>0]=c;b[j+128+1>>0]=e;b[j+128+2>>0]=1;b[j+128+3>>0]=1;Dh(j+128+4|0);We(j+128+8|0,0,0);f[j+128+16>>2]=0;f[j+128+16+4>>2]=0;f[j+128+16+8>>2]=0;f[j+128+16+12>>2]=0;if(!g){f[j+128+32>>2]=0;f[j+128+32+4>>2]=0;f[j+128+32+8>>2]=0;f[j+128+32+12>>2]=0}else Kf(j+128|0,g);if(!h){f[j+128+48>>2]=0;f[j+128+48+4>>2]=0;f[j+128+48+8>>2]=0;f[j+128+48+12>>2]=0}else Hf(j+128|0,h);ie(a,j+128|0);ec(j+(e&255)|0,0,128-(e&255)|0)|0;qb(j|0,d|0,e&255|0)|0;Nb(a,j,128,0);ye(j,128);t=i;return}Fj()}function zb(a,b,c,d,e,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0,j=0;h=b>>>0>0|(b|0)==0&a>>>0>32768?a:32768;b=b>>>0>0|(b|0)==0&a>>>0>32768?b:0;f[g>>2]=8;a:do if(b>>>0<0|(b|0)==0&h>>>0<c>>>5>>>0){f[e>>2]=1;a=Nh(h|0,b|0,f[g>>2]<<2|0,0)|0;f[d>>2]=1;a=$f(a|0,G|0,1)|0;b=G;c=1;do{g=Wf(1,0,c|0)|0;e=G;c=c+1|0;if(e>>>0>b>>>0|(e|0)==(b|0)&g>>>0>a>>>0)break a;f[d>>2]=c}while(c>>>0<63)}else{f[d>>2]=1;a=1;while(1){i=Wf(1,0,a|0)|0;j=G;if(j>>>0>0|(j|0)==0&i>>>0>c>>>11>>>0)break;a=a+1|0;f[d>>2]=a;if(a>>>0>=63){a=63;break}}d=$f(h|0,b|0,2)|0;d=$f(d|0,G|0,a|0)|0;i=G;j=i>>>0<0|(i|0)==0&d>>>0<1073741823?d:1073741823;f[e>>2]=(j>>>0)/((f[g>>2]|0)>>>0)|0}while(0);return}function Ab(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,h=0,i=0;i=t;t=t+192|0;if(d>>>0>128){Ne(a)|0;Ja(a,c,d,0)|0;df(a,i)|0;d=64;c=i}Ne(a)|0;e=i+64|0;g=e+128|0;do{f[e>>2]=909522486;e=e+4|0}while((e|0)<(g|0));h=(d|0)==0;if(!h?(b[i+64>>0]=b[c>>0]^54,(d|0)!=1):0){e=1;do{g=i+64+e|0;b[g>>0]=b[g>>0]^b[c+e>>0];e=e+1|0}while((e|0)!=(d|0))}Ja(a,i+64|0,128,0)|0;Ne(a+208|0)|0;e=i+64|0;g=e+128|0;do{f[e>>2]=1549556828;e=e+4|0}while((e|0)<(g|0));if(!h?(b[i+64>>0]=b[c>>0]^92,(d|0)!=1):0){e=1;do{h=i+64+e|0;b[h>>0]=b[h>>0]^b[c+e>>0];e=e+1|0}while((e|0)!=(d|0))}Ja(a+208|0,i+64|0,128,0)|0;ye(i+64|0,128);ye(i,64);t=i;return 0}function Bb(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,h=0,i=0;i=t;t=t+96|0;if(d>>>0>64){de(a)|0;Pa(a,c,d,0)|0;gf(a,i)|0;d=32;c=i}de(a)|0;e=i+32|0;g=e+64|0;do{f[e>>2]=909522486;e=e+4|0}while((e|0)<(g|0));h=(d|0)==0;if(!h?(b[i+32>>0]=b[c>>0]^54,(d|0)!=1):0){e=1;do{g=i+32+e|0;b[g>>0]=b[g>>0]^b[c+e>>0];e=e+1|0}while((e|0)!=(d|0))}Pa(a,i+32|0,64,0)|0;de(a+104|0)|0;e=i+32|0;g=e+64|0;do{f[e>>2]=1549556828;e=e+4|0}while((e|0)<(g|0));if(!h?(b[i+32>>0]=b[c>>0]^92,(d|0)!=1):0){e=1;do{h=i+32+e|0;b[h>>0]=b[h>>0]^b[c+e>>0];e=e+1|0}while((e|0)!=(d|0))}Pa(a+104|0,i+32|0,64,0)|0;ye(i+32|0,64);ye(i,32);t=i;return 0}function Cb(a){a=a|0;var b=0,c=0,d=0,e=0;if(a>>>0>=4294967168){f[9002]=12;e=0;return e|0}e=a>>>0<11?16:a+11&-8;d=na(e+76|0)|0;if(!d){e=0;return e|0}do if(d&63){c=((d+63&-64)+-8-(d+-8)|0)>>>0>15?(d+63&-64)+-8|0:(d+63&-64)+56|0;a=c-(d+-8)|0;b=f[d+-4>>2]|0;if(!(b&3)){f[c>>2]=(f[d+-8>>2]|0)+a;f[c+4>>2]=(b&-8)-a;a=c;break}else{f[c+4>>2]=(b&-8)-a|f[c+4>>2]&1|2;f[c+((b&-8)-a)+4>>2]=f[c+((b&-8)-a)+4>>2]|1;f[d+-4>>2]=a|f[d+-4>>2]&1|2;f[c+4>>2]=f[c+4>>2]|1;xa(d+-8|0,a);a=c;break}}else{a=d+-8|0;c=d+-8|0}while(0);a=a+4|0;b=f[a>>2]|0;if(b&3|0?(b&-8)>>>0>(e+16|0)>>>0:0){d=c+e|0;f[a>>2]=e|b&1|2;f[d+4>>2]=(b&-8)-e|3;a=c+(b&-8)+4|0;f[a>>2]=f[a>>2]|1;xa(d,(b&-8)-e|0)}e=c+8|0;return e|0}function Db(a,b,c,d,e,g,h,i,j,k,l,m){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;m=m|0;var n=0,o=0,p=0;p=t;o=t=t+63&-64;t=t+64|0;n=na(j)|0;do if(!n)a=-22;else{f[o>>2]=n;f[o+4>>2]=j;f[o+8>>2]=d;f[o+12>>2]=e;f[o+16>>2]=g;f[o+20>>2]=h;f[o+24>>2]=0;f[o+24+4>>2]=0;f[o+24+8>>2]=0;f[o+24+12>>2]=0;f[o+40>>2]=a;f[o+44>>2]=b;f[o+48>>2]=c;f[o+52>>2]=c;f[o+56>>2]=0;a=Qb(o,m)|0;if(a|0){ye(n,j);wa(n);break}if(i|0)qb(i|0,n|0,j|0)|0;if((k|0)!=0&(l|0)!=0?Ga(k,l,o,m)|0:0){ye(n,j);ye(k,l);wa(n);a=-31;break}ye(n,j);wa(n);a=0}while(0);t=p;return a|0}function Eb(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;e=t;c=t=t+63&-64;t=t+288|0;Ba(a+40|0,b);Bg(a+80|0);ua(c+240|0,a+40|0);pa(c+192|0,c+240|0,16);Vb(c+240|0,c+240|0,a+80|0);Wb(c+192|0,c+192|0,a+80|0);ua(c+144|0,c+192|0);pa(c+144|0,c+144|0,c+192|0);ua(a,c+144|0);pa(a,a,c+192|0);pa(a,a,c+240|0);eb(a,a);pa(a,a,c+144|0);pa(a,a,c+240|0);ua(c+96|0,a);pa(c+96|0,c+96|0,c+192|0);Vb(c+48|0,c+96|0,c+240|0);if(!(Mf(c+48|0)|0)){Wb(c,c+96|0,c+240|0);if(!(Mf(c)|0))a=-1;else{pa(a,a,64);d=4}}else d=4;if((d|0)==4){d=Xf(a)|0;if((d|0)==((h[b+31>>0]|0)>>>7|0))Dc(a,a);pa(a+120|0,a,a+40|0);a=0}t=e;return a|0}function Fb(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0;w=f[a>>2]|0;u=f[a+4>>2]|0;s=f[a+8>>2]|0;q=f[a+12>>2]|0;o=f[a+16>>2]|0;m=f[a+20>>2]|0;k=f[a+24>>2]|0;i=f[a+28>>2]|0;g=f[a+32>>2]|0;d=f[a+36>>2]|0;v=(f[b+4>>2]^u)&0-c;t=(f[b+8>>2]^s)&0-c;r=(f[b+12>>2]^q)&0-c;p=(f[b+16>>2]^o)&0-c;n=(f[b+20>>2]^m)&0-c;l=(f[b+24>>2]^k)&0-c;j=(f[b+28>>2]^i)&0-c;h=(f[b+32>>2]^g)&0-c;e=(f[b+36>>2]^d)&0-c;f[a>>2]=(f[b>>2]^w)&0-c^w;f[a+4>>2]=v^u;f[a+8>>2]=t^s;f[a+12>>2]=r^q;f[a+16>>2]=p^o;f[a+20>>2]=n^m;f[a+24>>2]=l^k;f[a+28>>2]=j^i;f[a+32>>2]=h^g;f[a+36>>2]=e^d;return}function Gb(a){a=a|0;var c=0,d=0,e=0,g=0,i=0;d=t;e=t=t+63&-64;t=t+48|0;c=e;g=a;i=c+32|0;do{b[c>>0]=b[g>>0]|0;c=c+1|0;g=g+1|0}while((c|0)<(i|0));c=h[a+36+4>>0]|h[a+36+4+1>>0]<<8|h[a+36+4+2>>0]<<16|h[a+36+4+3>>0]<<24;f[e+32>>2]=h[a+36>>0]|h[a+36+1>>0]<<8|h[a+36+2>>0]<<16|h[a+36+3>>0]<<24;f[e+32+4>>2]=c;pg(e,e,40,0,a+32|0,a)|0;c=a;g=e;i=c+32|0;do{b[c>>0]=b[g>>0]|0;c=c+1|0;g=g+1|0}while((c|0)<(i|0));g=f[e+32>>2]|0;i=f[e+32+4>>2]|0;b[a+36>>0]=g;b[a+36+1>>0]=g>>8;b[a+36+2>>0]=g>>16;b[a+36+3>>0]=g>>24;b[a+36+4>>0]=i;b[a+36+4+1>>0]=i>>8;b[a+36+4+2>>0]=i>>16;b[a+36+4+3>>0]=i>>24;yg(a);t=d;return}function Hb(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0;e=t;g=t=t+63&-64;t=t+384|0;Ba(a+40|0,b);Bg(a+80|0);ua(g+336|0,a+40|0);pa(g+288|0,g+336|0,16);Vb(g+336|0,g+336|0,a+80|0);Wb(g+288|0,g+288|0,a+80|0);ua(g+240|0,g+288|0);pa(g+240|0,g+240|0,g+288|0);ua(a,g+240|0);pa(a,a,g+288|0);pa(a,a,g+336|0);eb(a,a);pa(a,a,g+240|0);pa(a,a,g+336|0);ua(g+192|0,a);pa(g+192|0,g+192|0,g+288|0);Vb(g+144|0,g+192|0,g+336|0);Wb(g+96|0,g+192|0,g+336|0);c=Mf(g+144|0)|0;d=Mf(g+96|0)|0;pa(g,a,64);Fb(a,g,1-c|0);Dc(g+48|0,a);f=Xf(a)|0;Fb(a,g+48|0,(h[b+31>>0]|0)>>>7^f);pa(a+120|0,a,a+40|0);t=e;return (d|c)+-1|0}function Ib(a,b,c,d,e,g,h,i,j,k,l,m){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;m=m|0;k=t;t=t+336|0;Wg(k,64,0,l,m)|0;Lh(k+64|0,k)|0;ye(k,64);Kg(k+64|0,h,i,j)|0;h=Ig(0,0,i|0,j|0)|0;Kg(k+64|0,35424,h&15,0)|0;Sf(a,d,e,g,l,1,m)|0;Kg(k+64|0,a,e,g)|0;h=Ig(0,0,e|0,g|0)|0;Kg(k+64|0,35424,h&15,0)|0;We(k+320|0,i,j);Kg(k+64|0,k+320|0,8,0)|0;We(k+320|0,e,g);Kg(k+64|0,k+320|0,8,0)|0;Kh(k+64|0,b)|0;ye(k+64|0,256);if(c|0){f[c>>2]=16;f[c+4>>2]=0}t=k;return 0}function Jb(a,b,c,d,e,f,g,h,i,j,k){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;var l=0;l=t;t=t+352|0;hh(l+16|0,64,0,j,k)|0;Lh(l+80|0,l+16|0)|0;ye(l+16|0,64);Kg(l+80|0,g,h,i)|0;We(l+336|0,h,i);Kg(l+80|0,l+336|0,8,0)|0;Kg(l+80|0,c,d,e)|0;We(l+336|0,d,e);Kg(l+80|0,l+336|0,8,0)|0;Kh(l+80|0,l)|0;ye(l+80|0,256);b=ki(l,f)|0;ye(l,16);do if(a)if(!b){Gf(a,c,d,e,j,1,0,k)|0;b=0;break}else{ec(a|0,0,d|0)|0;b=-1;break}while(0);t=l;return b|0}function Kb(a){a=a|0;var c=0,d=0,e=0,g=0;a:do if(1){c=35349;d=65;do{if((b[c>>0]|0)==(a&255)<<24>>24){g=6;break a}c=c+1|0;d=d+-1|0;e=(d|0)!=0}while(e&(c&3|0)!=0);if(e)g=6;else c=0}else{c=35349;d=65;g=6}while(0);b:do if((g|0)==6)if((b[c>>0]|0)!=(a&255)<<24>>24){e=V(a&255,16843009)|0;c:do if(d>>>0>3){do{g=f[c>>2]^e;if((g&-2139062144^-2139062144)&g+-16843009|0)break c;c=c+4|0;d=d+-4|0}while(d>>>0>3);if(!d){c=0;break b}}while(0);while(1){if((b[c>>0]|0)==(a&255)<<24>>24)break b;d=d+-1|0;if(!d){c=0;break}else c=c+1|0}}while(0);return c|0}function Lb(a,c){a=a|0;c=c|0;var d=0,e=0,f=0,g=0,i=0;d=0;do{b[a+d>>0]=(h[c+(d>>>3)>>0]|0)>>>(d&7)&1;d=d+1|0}while((d|0)!=256);g=0;do{i=a+g|0;a:do if(b[i>>0]|0){f=1;do{d=f+g|0;if(d>>>0>=256)break a;c=b[a+d>>0]|0;b:do if(c<<24>>24){c=c<<24>>24<<f;e=b[i>>0]|0;if((c+e|0)<16){b[i>>0]=c+e;b[a+d>>0]=0;break}if((e-c|0)<-15)break a;b[i>>0]=e-c;while(1){c=a+d|0;if(!(b[c>>0]|0))break;b[c>>0]=0;d=d+1|0;if(d>>>0>=256)break b}b[c>>0]=1}while(0);f=f+1|0}while(f>>>0<7)}while(0);g=g+1|0}while((g|0)!=256);return}function Mb(a,b,c,d,e,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;var i=0,j=0;i=t;j=t=t+63&-64;t=t+560|0;Gg(j+192|0,h);He(j+128|0,g,32,0)|0;Ja(j+192|0,j+128+32|0,32,0)|0;Ja(j+192|0,c,d,e)|0;df(j+192|0,j+64|0)|0;se(a+32|0,g+32|0,32)|0;oa(j+64|0);ub(j+400|0,j+64|0);Pd(a,j+400|0);Gg(j+192|0,h);Ja(j+192|0,a,64,0)|0;Ja(j+192|0,c,d,e)|0;df(j+192|0,j)|0;oa(j);rh(j+128|0);la(a+32|0,j,j+128|0,j+64|0);ye(j+128|0,64);ye(j+64|0,64);if(b|0){f[b>>2]=64;f[b+4>>2]=0}t=i;return}function Nb(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0;a:do if(!((d|0)==0&(e|0)==0)){g=f[a+352>>2]|0;j=e;while(1){i=256-g|0;e=a+96+g|0;if(!(j>>>0>0|(j|0)==0&d>>>0>i>>>0))break;qb(e|0,c|0,i|0)|0;f[a+352>>2]=(f[a+352>>2]|0)+i;Gd(a,128,0);ka(a,a+96|0);e=a+96|0;g=a+224|0;h=e+128|0;do{b[e>>0]=b[g>>0]|0;e=e+1|0;g=g+1|0}while((e|0)<(h|0));g=(f[a+352>>2]|0)+-128|0;f[a+352>>2]=g;e=Ig(d|0,j|0,i|0,0)|0;j=G;if((e|0)==0&(j|0)==0)break a;else{c=c+i|0;d=e}}qb(e|0,c|0,d|0)|0;f[a+352>>2]=(f[a+352>>2]|0)+d}while(0);return}function Ob(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0,j=0;j=t;i=t=t+63&-64;t=t+64|0;h=Sc(a)|0;if(!(c>>>0>0|(c|0)==0&b>>>0>4294967295|h>>>0>127)){c=i;g=c+60|0;do{f[c>>2]=0;c=c+4|0}while((c|0)<(g|0));g=Zf(h)|0;if(!g)c=-1;else{f[i+16>>2]=g;f[i+8>>2]=g;f[i>>2]=g;f[i+20>>2]=h;f[i+12>>2]=h;f[i+4>>2]=h;f[i+24>>2]=0;f[i+24+4>>2]=0;f[i+24+8>>2]=0;f[i+24+12>>2]=0;if(!(Ma(i,a,e)|0))if((f[i+40>>2]|0)==(b|0))c=(f[i+44>>2]|0)!=(d>>>10|0)&1;else c=1;else{f[9002]=22;c=-1}wa(g)}}else{f[9002]=22;c=-1}t=j;return c|0}function Pb(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0;h=t;g=t=t+63&-64;t=t+592|0;if(((((ce(a+32|0)|0)!=0?(Zb(a)|0)==0:0)?(hf(e)|0)!=0:0)?(Zb(e)|0)==0:0)?(Eb(g+424|0,e)|0)==0:0){Gg(g+96|0,f);Ja(g+96|0,a,32,0)|0;Ja(g+96|0,e,32,0)|0;Ja(g+96|0,b,c,d)|0;df(g+96|0,g+32|0)|0;oa(g+32|0);Ia(g+304|0,g+32|0,g+424|0,a+32|0);Pd(g,g+304|0);f=ji(g,a)|0;a=((g|0)==(a|0)?-1:f)|(hd(a,g,32)|0)}else a=-1;t=h;return a|0}function Qb(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0;e=t;d=t=t+63&-64;t=t+48|0;c=xb(a)|0;if(!c)if((b+-1|0)>>>0<=1){g=f[a+44>>2]|0;c=f[a+48>>2]|0;g=((g>>>0<c<<3>>>0?c<<3:g)>>>0)/(c<<2>>>0)|0;h=V(g,c<<2)|0;f[d>>2]=0;f[d+8>>2]=f[a+40>>2];f[d+12>>2]=-1;f[d+16>>2]=h;f[d+20>>2]=g;f[d+24>>2]=g<<2;f[d+28>>2]=c;f[d+32>>2]=f[a+52>>2];f[d+36>>2]=b;c=Ic(d,a)|0;if(!c){if(f[d+8>>2]|0){c=0;do{nc(d,c);c=c+1|0}while(c>>>0<(f[d+8>>2]|0)>>>0)}mc(a,d);c=0}}else c=-26;t=e;return c|0}function Rb(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0;o=t;n=t=t+63&-64;t=t+48|0;m=$d(e,n+40|0,n+36|0,n+32|0)|0;if(m){j=Wf(1,0,f[n+40>>2]|0)|0;k=G;h=si(m)|0;if(!h)h=Sc(m)|0;else h=h-m|0;i=h+(m-e)|0;if((!((i+45|0)>>>0>102|(i+45|0)>>>0<h>>>0)?(hb(a,c,d,m,h,j,k,f[n+36>>2]|0,f[n+32>>2]|0,n,32)|0)==0:0)?(qb(g|0,e|0,i|0)|0,b[g+i>>0]=36,l=zd(g+i+1|0,g+102-(g+i+1)|0,n)|0,ye(n,32),(l|0)!=0&l>>>0<(g+102|0)>>>0):0)b[l>>0]=0;else g=0}else g=0;t=o;return g|0}function Sb(a,b,c,d,e,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0;do if(!b){if(!(c<<24>>24)){h=d+-1|0;break}h=V(f[a+20>>2]|0,c&255)|0;if(!g){h=h+(((d|0)==0)<<31>>31)|0;break}else{h=d+-1+h|0;break}}else{h=(f[a+24>>2]|0)-(f[a+20>>2]|0)|0;if(!g){h=h+(((d|0)==0)<<31>>31)|0;break}else{h=d+-1+h|0;break}}while(0);Af(e|0,0,e|0,0)|0;Af(G|0,0,h|0,0)|0;g=Ig(h+-1|0,0,G|0,0)|0;if((b|0)==0|c<<24>>24==3){h=0;d=0}else{h=V(f[a+20>>2]|0,(c&255)+1|0)|0;d=0}c=Lg(g|0,G|0,h|0,d|0)|0;a=pf(c|0,G|0,f[a+24>>2]|0,0)|0;return a|0}function Tb(a,c){a=a|0;c=c|0;var d=0,e=0;a:do if(!(c&255))a=a+(Sc(a)|0)|0;else{if(a&3)do{e=b[a>>0]|0;if(e<<24>>24==0?1:e<<24>>24==(c&255)<<24>>24)break a;a=a+1|0}while((a&3|0)!=0);e=V(c&255,16843009)|0;d=f[a>>2]|0;b:do if(!((d&-2139062144^-2139062144)&d+-16843009))do{d=d^e;if((d&-2139062144^-2139062144)&d+-16843009|0)break b;a=a+4|0;d=f[a>>2]|0}while(!((d&-2139062144^-2139062144)&d+-16843009|0));while(0);while(1){e=b[a>>0]|0;if(e<<24>>24==0?1:e<<24>>24==(c&255)<<24>>24)break;else a=a+1|0}}while(0);return a|0}function Ub(a,c,d,e,g,h,i){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;var j=0,k=0,l=0,m=0;m=t;k=t=t+63&-64;t=t+128|0;j=a;l=j+102|0;do{b[j>>0]=0;j=j+1|0}while((j|0)<(l|0));do if(!(e>>>0>0|(e|0)==0&d>>>0>4294967295)){zb(g,h,i,k+104|0,k+100|0,k+96|0);uf(k+64|0,32);if(!(Mc(f[k+104>>2]|0,f[k+96>>2]|0,f[k+100>>2]|0,k+64|0,k)|0)){f[9002]=22;a=-1;break}zi(k+108|0);l=(Rb(k+108|0,c,d,k,a)|0)==0;Ai(k+108|0);if(l){f[9002]=22;a=-1}else a=0}else{f[9002]=27;a=-1}while(0);t=m;return a|0}function Vb(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0;m=(f[b+4>>2]|0)-(f[c+4>>2]|0)|0;l=(f[b+8>>2]|0)-(f[c+8>>2]|0)|0;k=(f[b+12>>2]|0)-(f[c+12>>2]|0)|0;j=(f[b+16>>2]|0)-(f[c+16>>2]|0)|0;i=(f[b+20>>2]|0)-(f[c+20>>2]|0)|0;h=(f[b+24>>2]|0)-(f[c+24>>2]|0)|0;g=(f[b+28>>2]|0)-(f[c+28>>2]|0)|0;e=(f[b+32>>2]|0)-(f[c+32>>2]|0)|0;d=(f[b+36>>2]|0)-(f[c+36>>2]|0)|0;f[a>>2]=(f[b>>2]|0)-(f[c>>2]|0);f[a+4>>2]=m;f[a+8>>2]=l;f[a+12>>2]=k;f[a+16>>2]=j;f[a+20>>2]=i;f[a+24>>2]=h;f[a+28>>2]=g;f[a+32>>2]=e;f[a+36>>2]=d;return}function Wb(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0;m=(f[c+4>>2]|0)+(f[b+4>>2]|0)|0;l=(f[c+8>>2]|0)+(f[b+8>>2]|0)|0;k=(f[c+12>>2]|0)+(f[b+12>>2]|0)|0;j=(f[c+16>>2]|0)+(f[b+16>>2]|0)|0;i=(f[c+20>>2]|0)+(f[b+20>>2]|0)|0;h=(f[c+24>>2]|0)+(f[b+24>>2]|0)|0;g=(f[c+28>>2]|0)+(f[b+28>>2]|0)|0;e=(f[c+32>>2]|0)+(f[b+32>>2]|0)|0;d=(f[c+36>>2]|0)+(f[b+36>>2]|0)|0;f[a>>2]=(f[c>>2]|0)+(f[b>>2]|0);f[a+4>>2]=m;f[a+8>>2]=l;f[a+12>>2]=k;f[a+16>>2]=j;f[a+20>>2]=i;f[a+24>>2]=h;f[a+28>>2]=g;f[a+32>>2]=e;f[a+36>>2]=d;return}function Xb(a,b,c,d,e,g,h,i,j,k,l,m){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;m=m|0;k=t;t=t+336|0;hh(k,64,0,l,m)|0;Lh(k+64|0,k)|0;ye(k,64);Kg(k+64|0,h,i,j)|0;We(k+320|0,i,j);Kg(k+64|0,k+320|0,8,0)|0;Gf(a,d,e,g,l,1,0,m)|0;Kg(k+64|0,a,e,g)|0;We(k+320|0,e,g);Kg(k+64|0,k+320|0,8,0)|0;Kh(k+64|0,b)|0;ye(k+64|0,256);if(c|0){f[c>>2]=16;f[c+4>>2]=0}t=k;return 0}function Yb(a,c,d){a=a|0;c=c|0;d=d|0;var e=0;uf(c,24);Ha(a,c,d,0)|0;yg(a);e=h[c+16>>0]|h[c+16+1>>0]<<8|h[c+16+2>>0]<<16|h[c+16+3>>0]<<24;d=h[c+16+4>>0]|h[c+16+4+1>>0]<<8|h[c+16+4+2>>0]<<16|h[c+16+4+3>>0]<<24;b[a+36>>0]=e;b[a+36+1>>0]=e>>8;b[a+36+2>>0]=e>>16;b[a+36+3>>0]=e>>24;b[a+36+4>>0]=d;b[a+36+4+1>>0]=d>>8;b[a+36+4+2>>0]=d>>16;b[a+36+4+3>>0]=d>>24;b[a+44>>0]=0;b[a+44+1>>0]=0;b[a+44+2>>0]=0;b[a+44+3>>0]=0;b[a+44+4>>0]=0;b[a+44+4+1>>0]=0;b[a+44+4+2>>0]=0;b[a+44+4+3>>0]=0;return 0}function Zb(a){a=a|0;var c=0,d=0,e=0,f=0,g=0,i=0;f=t;g=t=t+63&-64;t=t+16|0;b[g>>0]=0;b[g+1>>0]=0;b[g+2>>0]=0;b[g+3>>0]=0;b[g+4>>0]=0;b[g+5>>0]=0;b[g+6>>0]=0;d=0;do{e=b[a+d>>0]|0;c=0;do{i=g+c|0;b[i>>0]=b[i>>0]|b[32096+(c<<5)+d>>0]^e;c=c+1|0}while((c|0)!=7);d=d+1|0}while((d|0)!=31);d=b[a+31>>0]&127;c=0;do{i=g+c|0;b[i>>0]=b[i>>0]|d^b[32096+(c<<5)+31>>0];c=c+1|0}while((c|0)!=7);c=0;d=0;do{c=(h[g+d>>0]|0)+-1|c;d=d+1|0}while((d|0)!=7);t=f;return c>>>8&1|0}function _b(a,c,d){a=a|0;c=c|0;d=d|0;var e=0;Ha(a,c,d,0)|0;yg(a);e=h[c+16>>0]|h[c+16+1>>0]<<8|h[c+16+2>>0]<<16|h[c+16+3>>0]<<24;d=h[c+16+4>>0]|h[c+16+4+1>>0]<<8|h[c+16+4+2>>0]<<16|h[c+16+4+3>>0]<<24;b[a+36>>0]=e;b[a+36+1>>0]=e>>8;b[a+36+2>>0]=e>>16;b[a+36+3>>0]=e>>24;b[a+36+4>>0]=d;b[a+36+4+1>>0]=d>>8;b[a+36+4+2>>0]=d>>16;b[a+36+4+3>>0]=d>>24;b[a+44>>0]=0;b[a+44+1>>0]=0;b[a+44+2>>0]=0;b[a+44+3>>0]=0;b[a+44+4>>0]=0;b[a+44+4+1>>0]=0;b[a+44+4+2>>0]=0;b[a+44+4+3>>0]=0;return 0}function $b(a,c,d,e,f){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0;i=t;h=t=t+63&-64;t=t+480|0;g=(a|0)==0?c:a;c=(c|0)==0?g:c;if(!g)Fj();if(!(Oh(h+448|0,e,f)|0)){jh(h,0,0,64)|0;Yg(h,h+448|0,32,0)|0;ye(h+448|0,32);Yg(h,f,32,0)|0;Yg(h,d,32,0)|0;Bh(h,h+384|0,64)|0;ye(h,384);a=0;do{b[c+a>>0]=b[h+384+a>>0]|0;b[g+a>>0]=b[h+384+(a+32)>>0]|0;a=a+1|0}while((a|0)!=32);ye(h+384|0,64);a=0}else a=-1;t=i;return a|0}function ac(a,c,d,e,f){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0;i=t;h=t=t+63&-64;t=t+480|0;g=(a|0)==0?c:a;c=(c|0)==0?g:c;if(!g)Fj();if(!(Oh(h+448|0,e,f)|0)){jh(h,0,0,64)|0;Yg(h,h+448|0,32,0)|0;ye(h+448|0,32);Yg(h,d,32,0)|0;Yg(h,f,32,0)|0;Bh(h,h+384|0,64)|0;ye(h,384);a=0;do{b[g+a>>0]=b[h+384+a>>0]|0;b[c+a>>0]=b[h+384+(a+32)>>0]|0;a=a+1|0}while((a|0)!=32);ye(h+384|0,64);a=0}else a=-1;t=i;return a|0}function bc(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0;g=t;h=t=t+63&-64;t=t+64|0;if((c+-1&255)>63)Fj();b[h>>0]=c;b[h+1>>0]=0;b[h+2>>0]=1;b[h+3>>0]=1;Dh(h+4|0);We(h+8|0,0,0);f[h+16>>2]=0;f[h+16+4>>2]=0;f[h+16+8>>2]=0;f[h+16+12>>2]=0;if(!d){f[h+32>>2]=0;f[h+32+4>>2]=0;f[h+32+8>>2]=0;f[h+32+12>>2]=0}else Kf(h,d);if(!e){f[h+48>>2]=0;f[h+48+4>>2]=0;f[h+48+8>>2]=0;f[h+48+12>>2]=0}else Hf(h,e);ie(a,h);t=g;return}function cc(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0;d=t;f=t=t+63&-64;t=t+160|0;e=Li(c)|0;c=(c<<24>>24)-((0-(e&255)&c<<24>>24)<<1)&255;zh(a);nf(a,b,gi(c,1)|0);nf(a,b+160|0,gi(c,2)|0);nf(a,b+320|0,gi(c,3)|0);nf(a,b+480|0,gi(c,4)|0);nf(a,b+640|0,gi(c,5)|0);nf(a,b+800|0,gi(c,6)|0);nf(a,b+960|0,gi(c,7)|0);nf(a,b+1120|0,gi(c,8)|0);Rc(f,a+40|0);Rc(f+40|0,a);Rc(f+80|0,a+80|0);Dc(f+120|0,a+120|0);nf(a,f,e);t=d;return} | |
20573 | function dc(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;ec(a|0,0,b|0)|0;do if(!(c>>>0>0|(c|0)==0&b>>>0>4294967295)){if(c>>>0<0|(c|0)==0&b>>>0<16){f[9002]=22;a=-1;break}if((j|g)>>>0>0|(j|g|0)==0&(i|e)>>>0>4294967295|k>>>0>2147483648){f[9002]=27;a=-1;break}if(j>>>0<0|(j|0)==0&i>>>0<3|k>>>0<8192){f[9002]=22;a=-1;break}if((l|0)==1){a=((fg(i,k>>>10,d,e,h,a,b)|0)!=0)<<31>>31;break}else{f[9002]=22;a=-1;break}}else{f[9002]=27;a=-1}while(0);return a|0}function ec(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0;e=a+d|0;c=c&255;if((d|0)>=67){while(a&3){b[a>>0]=c;a=a+1|0}g=c|c<<8|c<<16|c<<24;while((a|0)<=((e&-4)-64|0)){f[a>>2]=g;f[a+4>>2]=g;f[a+8>>2]=g;f[a+12>>2]=g;f[a+16>>2]=g;f[a+20>>2]=g;f[a+24>>2]=g;f[a+28>>2]=g;f[a+32>>2]=g;f[a+36>>2]=g;f[a+40>>2]=g;f[a+44>>2]=g;f[a+48>>2]=g;f[a+52>>2]=g;f[a+56>>2]=g;f[a+60>>2]=g;a=a+64|0}while((a|0)<(e&-4|0)){f[a>>2]=g;a=a+4|0}}while((a|0)<(e|0)){b[a>>0]=c;a=a+1|0}return e-d|0}function fc(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;ec(a|0,0,b|0)|0;do if(!(c>>>0>0|(c|0)==0&b>>>0>4294967295)){if(c>>>0<0|(c|0)==0&b>>>0<16){f[9002]=22;a=-1;break}if((j|g)>>>0>0|(j|g|0)==0&(i|e)>>>0>4294967295|k>>>0>2147483648){f[9002]=27;a=-1;break}if((i|0)==0&(j|0)==0|k>>>0<8192){f[9002]=22;a=-1;break}if((l|0)==2){a=((cg(i,k>>>10,d,e,h,a,b)|0)!=0)<<31>>31;break}else{f[9002]=22;a=-1;break}}else{f[9002]=27;a=-1}while(0);return a|0}function gc(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var g=0,h=0,i=0;h=t;i=t=t+63&-64;t=t+192|0;if((c+-1&255)>63)Fj();if((e+-1&255)>63|(d|0)==0)Fj();else{b[i+128>>0]=c;b[i+128+1>>0]=e;b[i+128+2>>0]=1;b[i+128+3>>0]=1;Dh(i+128+4|0);We(i+128+8|0,0,0);c=i+128+16|0;g=c+48|0;do{f[c>>2]=0;c=c+4|0}while((c|0)<(g|0));ie(a,i+128|0);ec(i+(e&255)|0,0,128-(e&255)|0)|0;qb(i|0,d|0,e&255|0)|0;Nb(a,i,128,0);ye(i,128);t=h;return}}function hc(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var i=0,j=0,k=0,l=0;l=t;k=t=t+63&-64;t=t+16|0;if(e){if(!(e+-1&e))i=e+-1&d;else i=(d>>>0)%(e>>>0)|0;j=e+-1-i|0;if(j>>>0>=~d>>>0)Fj();if((j+d|0)>>>0<g>>>0){if(a|0)f[a>>2]=j+d+1;b[k>>0]=0;i=0;do{g=((i^j)+-1|0)>>>24;a=c+(j+d)+(0-i)|0;b[a>>0]=g&128|b[k>>0]&b[a>>0]&255;b[k>>0]=g|(h[k>>0]|0);i=i+1|0}while((i|0)!=(e|0));i=0}else i=-1}else i=-1;t=l;return i|0}function ic(a,c){a=a|0;c=c|0;var d=0;d=(yh(c)|0)&67108863;f[a>>2]=d;d=(yh(c+3|0)|0)>>>2&67108611;f[a+4>>2]=d;d=(yh(c+6|0)|0)>>>4&67092735;f[a+8>>2]=d;d=(yh(c+9|0)|0)>>>6&66076671;f[a+12>>2]=d;d=(yh(c+12|0)|0)>>>8&1048575;f[a+16>>2]=d;f[a+20>>2]=0;f[a+20+4>>2]=0;f[a+20+8>>2]=0;f[a+20+12>>2]=0;f[a+20+16>>2]=0;d=yh(c+16|0)|0;f[a+40>>2]=d;d=yh(c+20|0)|0;f[a+44>>2]=d;d=yh(c+24|0)|0;f[a+48>>2]=d;c=yh(c+28|0)|0;f[a+52>>2]=c;f[a+56>>2]=0;f[a+56+4>>2]=0;b[a+80>>0]=0;return}function jc(a,b,c,d,e,g,h,i,j,k){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;var l=0,m=0;m=t;l=t=t+63&-64;t=t+16|0;ec(a|0,0,b|0)|0;do if(!((g|c)>>>0>0|(g|c|0)==0&(e|b)>>>0>4294967295))if(c>>>0<0|(c|0)==0&b>>>0<16){f[9002]=22;a=-1;break}else{zb(i,j,k,l+8|0,l+4|0,l);k=Wf(1,0,f[l+8>>2]|0)|0;a=Hd(d,e,h,32,k,G,f[l>>2]|0,f[l+4>>2]|0,a,b)|0;break}else{f[9002]=27;a=-1}while(0);t=m;return a|0}function kc(a,b,c,d,e,f,g,h,i){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;i=i|0;var j=0,k=0;j=t;k=t=t+63&-64;t=t+384|0;if((b|0)==0&((e|0)!=0|(f|0)!=0))Fj();if(!a)Fj();if((d+-1&255)>63)Fj();if(!((c|0)!=0|g<<24>>24==0))Fj();if((g&255)>64)Fj();if(!(g<<24>>24))bc(k,d,h,i);else yb(k,d,c,g,h,i);Nb(k,b,e,f);gb(k,a,d)|0;t=j;return}function lc(a,b,c,d,e,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0,j=0;do if(!(e>>>0<0|(e|0)==0&d>>>0<64)?(h=Lg(d|0,e|0,-64,-1)|0,i=G,!(i>>>0>0|(i|0)==0&h>>>0>4294967231)):0){if(tg(c,c+64|0,h,i,g)|0){if(!a){j=10;break}ec(a|0,0,h|0)|0;j=10;break}if(b|0){f[b>>2]=h;f[b+4>>2]=i}if(!a)a=0;else{se(a|0,c+64|0,h|0)|0;a=0}}else j=10;while(0);if((j|0)==10)if(!b)a=-1;else{f[b>>2]=0;f[b+4>>2]=0;a=-1}return a|0}function mc(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0;d=t;e=t=t+63&-64;t=t+2048|0;if((a|0)!=0&(b|0)!=0){li(e+1024|0,(f[(f[b>>2]|0)+4>>2]|0)+(f[b+24>>2]<<10)+-1024|0);if((f[b+28>>2]|0)>>>0>1){c=1;do{g=f[b+24>>2]|0;g=g+-1+(V(g,c)|0)|0;Ae(e+1024|0,(f[(f[b>>2]|0)+4>>2]|0)+(g<<10)|0);c=c+1|0}while(c>>>0<(f[b+28>>2]|0)>>>0)}sf(e,e+1024|0);Sa(f[a>>2]|0,f[a+4>>2]|0,e,1024);ye(e+1024|0,1024);ye(e,1024);og(b,f[a+56>>2]|0)}t=d;return}function nc(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0;g=t;h=t=t+63&-64;t=t+32|0;if(a|0?(d=f[a+28>>2]|0,d|0):0){f[h>>2]=c;e=0;c=d;do{b[h+8>>0]=e;if(!c)c=0;else{d=0;do{f[h+4>>2]=d;f[h+12>>2]=0;f[h+16>>2]=f[h>>2];f[h+16+4>>2]=f[h+4>>2];f[h+16+8>>2]=f[h+8>>2];f[h+16+12>>2]=f[h+12>>2];Va(a,h+16|0);d=d+1|0;c=f[a+28>>2]|0}while(d>>>0<c>>>0)}e=e+1|0}while((e|0)!=4)}t=g;return}function oc(a,b,c,d,e,g,i,j,k,l,m,n){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;i=i|0;j=j|0;k=k|0;l=l|0;m=m|0;n=n|0;l=t;t=t+48|0;f[l+32>>2]=0;Ha(l,m,n,0)|0;n=h[m+16+4>>0]|h[m+16+4+1>>0]<<8|h[m+16+4+2>>0]<<16|h[m+16+4+3>>0]<<24;f[l+32+4>>2]=h[m+16>>0]|h[m+16+1>>0]<<8|h[m+16+2>>0]<<16|h[m+16+3>>0]<<24;f[l+32+4+4>>2]=n;Ib(a,b,c,d,e,g,i,j,k,0,l+32|0,l)|0;ye(l,32);t=l;return 0}function pc(a,b,c,d,e,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;var i=0,j=0,k=0;j=t;i=t=t+63&-64;t=t+32|0;k=h[e+4>>0]|h[e+4+1>>0]<<8|h[e+4+2>>0]<<16|h[e+4+3>>0]<<24;f[i+16>>2]=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;f[i+16+4>>2]=k;f[i+16+8>>2]=0;f[i+16+8+4>>2]=0;We(i,c,d);f[i+8>>2]=0;f[i+8+4>>2]=0;if((b+-16|0)>>>0>48){f[9002]=22;a=-1}else a=he(a,b,0,0,0,g,32,i,i+16|0)|0;t=j;return a|0}function qc(a,b,c,d,e,g,i,j,k,l,m){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;i=i|0;j=j|0;k=k|0;l=l|0;m=m|0;b=t;t=t+48|0;f[b+32>>2]=0;Ha(b,l,m,0)|0;m=h[l+16+4>>0]|h[l+16+4+1>>0]<<8|h[l+16+4+2>>0]<<16|h[l+16+4+3>>0]<<24;f[b+32+4>>2]=h[l+16>>0]|h[l+16+1>>0]<<8|h[l+16+2>>0]<<16|h[l+16+3>>0]<<24;f[b+32+4+4>>2]=m;l=wb(a,0,c,d,e,g,i,j,k,b+32|0,b)|0;ye(b,32);t=b;return l|0}function rc(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0;d=t;f=t=t+63&-64;t=t+128|0;e=Li(c)|0;c=(c<<24>>24)-((0-(e&255)&c<<24>>24)<<1)&255;Wh(a);ag(a,b,gi(c,1)|0);ag(a,b+120|0,gi(c,2)|0);ag(a,b+240|0,gi(c,3)|0);ag(a,b+360|0,gi(c,4)|0);ag(a,b+480|0,gi(c,5)|0);ag(a,b+600|0,gi(c,6)|0);ag(a,b+720|0,gi(c,7)|0);ag(a,b+840|0,gi(c,8)|0);Rc(f,a+40|0);Rc(f+40|0,a);Dc(f+80|0,a+80|0);ag(a,f,e);t=d;return}function sc(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;var m=0,n=0,o=0;if(g>>>0>0|(g|0)==0&e>>>0>15){m=Lg(e|0,g|0,-16,-1)|0;n=G;g=qc(a,0,d,m,n,d+e+-16|0,h,i,j,k,l)|0;if(!b)c=g;else{c=g;a=(g|0)==0?m:0;g=(g|0)==0?n:0;o=4}}else if(!b)c=-1;else{c=-1;a=0;g=0;o=4}if((o|0)==4){f[b>>2]=a;f[b+4>>2]=g}return c|0}function tc(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;var m=0,n=0,o=0;if(g>>>0>0|(g|0)==0&e>>>0>15){m=Lg(e|0,g|0,-16,-1)|0;n=G;g=wb(a,0,d,m,n,d+e+-16|0,h,i,j,k,l)|0;if(!b)c=g;else{c=g;a=(g|0)==0?m:0;g=(g|0)==0?n:0;o=4}}else if(!b)c=-1;else{c=-1;a=0;g=0;o=4}if((o|0)==4){f[b>>2]=a;f[b+4>>2]=g}return c|0}function uc(a,c,d,e,g,h,i){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;var j=0,k=0,l=0,m=0;m=t;k=t=t+63&-64;t=t+16|0;j=a;l=j+128|0;do{b[j>>0]=0;j=j+1|0}while((j|0)<(l|0));do if(!((h|e)>>>0>0|(h|e|0)==0&(g|d)>>>0>4294967295|i>>>0>2147483648))if(h>>>0<0|(h|0)==0&g>>>0<3|i>>>0<8192){f[9002]=22;a=-1;break}else{uf(k,16);a=((rg(g,i>>>10,c,d,k,a)|0)!=0)<<31>>31;break}else{f[9002]=27;a=-1}while(0);t=m;return a|0}function vc(a,c,d,e,g){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0;a:do if(g){i=f[d>>2]|0;while(1){if(i>>>0>=c>>>0){h=4;break}h=b[a+i>>0]|0;if(h<<24>>24!=61){if(!e){h=9;break}if(!(sh(e,h<<24>>24)|0)){h=9;break}}else g=g+-1|0;i=i+1|0;f[d>>2]=i;if(!g){g=0;break a}}if((h|0)==4){f[9002]=34;g=-1;break}else if((h|0)==9){f[9002]=22;g=-1;break}}else g=0;while(0);return g|0}function wc(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;var m=0,n=0,o=0;if(g>>>0>0|(g|0)==0&e>>>0>15){m=Lg(e|0,g|0,-16,-1)|0;n=G;g=Jb(a,0,d,m,n,d+e+-16|0,h,i,j,k,l)|0;if(!b)c=g;else{c=g;a=(g|0)==0?m:0;g=(g|0)==0?n:0;o=4}}else if(!b)c=-1;else{c=-1;a=0;g=0;o=4}if((o|0)==4){f[b>>2]=a;f[b+4>>2]=g}return c|0}function xc(a,c,d,e,g,h,i){a=a|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;var j=0,k=0,l=0,m=0;m=t;k=t=t+63&-64;t=t+16|0;j=a;l=j+128|0;do{b[j>>0]=0;j=j+1|0}while((j|0)<(l|0));do if(!((h|e)>>>0>0|(h|e|0)==0&(g|d)>>>0>4294967295|i>>>0>2147483648))if((g|0)==0&(h|0)==0|i>>>0<8192){f[9002]=22;a=-1;break}else{uf(k,16);a=((qg(g,i>>>10,c,d,k,a)|0)!=0)<<31>>31;break}else{f[9002]=27;a=-1}while(0);t=m;return a|0}function yc(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0;g=t;h=t=t+63&-64;t=t+464|0;Bb(h+240|0,a,b)|0;bh(h+240|0,c,d,0)|0;if(f|0){a=0;b=0;do{a=a+1|0;Mg(h+448|0,a);qb(h+32|0,h+240|0,208)|0;bh(h+32|0,h+448|0,4,0)|0;Ve(h+32|0,h)|0;d=f-b|0;qb(e+b|0,h|0,(d>>>0<32?d:32)|0)|0;b=a<<5}while(b>>>0<f>>>0)}ye(h+240|0,208);t=g;return}function zc(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;e=t;d=t=t+63&-64;t=t+16|0;do if((((a|0)!=0?(b|0)!=0:0)?((b<<10>>>0)/(b>>>0)|0|0)==1024:0)?(c=na(12)|0,f[a>>2]=c,(c|0)!=0):0){f[c+4>>2]=0;f[c>>2]=0;c=Uf(d,b<<10)|0;f[9002]=c;if(c|0){f[d>>2]=0;c=-22;break}c=f[d>>2]|0;if(c){f[f[a>>2]>>2]=c;f[(f[a>>2]|0)+4>>2]=c;f[(f[a>>2]|0)+8>>2]=b<<10;c=0}else c=-22}else c=-22;while(0);t=e;return c|0}function Ac(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0;h=t;i=t=t+63&-64;t=t+384|0;if((b|0)==0&((e|0)!=0|(f|0)!=0))Fj();if(!a)Fj();if((d+-1&255)>63)Fj();if(!((c|0)!=0|g<<24>>24==0))Fj();if((g&255)>64)Fj();if(!(g<<24>>24))ed(i,d);else gc(i,d,c,g);Nb(i,b,e,f);gb(i,a,d)|0;t=h;return}function Bc(a,c,d,e,f){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0,j=0,k=0;k=t;h=t=t+63&-64;t=t+96|0;if(!(_g(h+32|0,h)|0)){g=a;i=h+32|0;j=g+32|0;do{b[g>>0]=b[i>>0]|0;g=g+1|0;i=i+1|0}while((g|0)<(j|0));le(h+64|0,h+32|0,f);a=qe(a+32|0,c,d,e,h+64|0,f,h)|0;ye(h,32);ye(h+32|0,32);ye(h+64|0,24)}else a=-1;t=k;return a|0}function Cc(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0;f=t;e=t=t+63&-64;t=t+320|0;if((((hf(d)|0)!=0?(Zb(d)|0)==0:0)?(Hb(e,d)|0)==0:0)?(Df(e)|0)!=0:0){d=0;do{b[a+d>>0]=b[c+d>>0]|0;d=d+1|0}while((d|0)!=32);rh(a);Oa(e+160|0,a,e);Pd(a,e+160|0);if(!(jf(a)|0))d=((ge(c,32)|0)!=0)<<31>>31;else d=-1}else d=-1;t=f;return d|0}function Dc(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0;l=0-(f[b+4>>2]|0)|0;k=0-(f[b+8>>2]|0)|0;j=0-(f[b+12>>2]|0)|0;i=0-(f[b+16>>2]|0)|0;h=0-(f[b+20>>2]|0)|0;g=0-(f[b+24>>2]|0)|0;e=0-(f[b+28>>2]|0)|0;d=0-(f[b+32>>2]|0)|0;c=0-(f[b+36>>2]|0)|0;f[a>>2]=0-(f[b>>2]|0);f[a+4>>2]=l;f[a+8>>2]=k;f[a+12>>2]=j;f[a+16>>2]=i;f[a+20>>2]=h;f[a+24>>2]=g;f[a+28>>2]=e;f[a+32>>2]=d;f[a+36>>2]=c;return}function Ec(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;d=t;e=t=t+63&-64;t=t+1024|0;if(f[b+28>>2]|0){c=0;do{Qg(a+64|0,0);Qg(a+68|0,c);Sa(e,1024,a,72);ff((f[(f[b>>2]|0)+4>>2]|0)+((V(f[b+24>>2]|0,c)|0)<<10)|0,e);Qg(a+64|0,1);Sa(e,1024,a,72);ff((f[(f[b>>2]|0)+4>>2]|0)+((V(f[b+24>>2]|0,c)|0)+1<<10)|0,e);c=c+1|0}while(c>>>0<(f[b+28>>2]|0)>>>0)}ye(e,1024);t=d;return}function Fc(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,g=0,i=0,j=0,k=0,l=0,m=0;l=t;k=t=t+63&-64;t=t+16|0;f[k>>2]=0;if((d+-1|0)>>>0<c>>>0){i=0;j=0;e=0;while(1){e=e&255;g=h[b+(c+-1)+(0-i)>>0]|0;m=((f[k>>2]|0)+511&e+511&(g^128)+511)>>>8&1;f[k>>2]=i&0-m|f[k>>2];j=m|j&255;i=i+1|0;if((i|0)==(d|0))break;else e=e|g}f[a>>2]=c+-1-(f[k>>2]|0);e=j+-1|0}else e=-1;t=l;return e|0}function Gc(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;d=f[a+32>>2]|0;c=f[a+32+4>>2]|0;e=$f(d|0,c|0,3)|0;if((e&63)>>>0<56){if(56-(e&63)|0)qb(a+40+(e&63)|0,32688,56-(e&63)|0)|0}else{if(64-(e&63)|0)qb(a+40+(e&63)|0,32688,64-(e&63)|0)|0;sa(a,a+40|0,b,b+256|0);c=a+40|0;d=c+56|0;do{f[c>>2]=0;c=c+4|0}while((c|0)<(d|0));d=f[a+32>>2]|0;c=f[a+32+4>>2]|0}jd(a+96|0,d,c);sa(a,a+40|0,b,b+256|0);return}function Hc(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,g=0;g=t;e=t=t+63&-64;t=t+32|0;zb(b,c,d,e+20|0,e+12|0,e+4|0);do if((gg(a)|0)==101){if(!($d(a,e+16|0,e,e+8|0)|0)){f[9002]=22;a=-1;break}if((f[e+20>>2]|0)==(f[e+16>>2]|0)?(f[e+4>>2]|0)==(f[e>>2]|0):0)a=(f[e+12>>2]|0)!=(f[e+8>>2]|0)&1;else a=1}else{f[9002]=22;a=-1}while(0);t=g;return a|0}function Ic(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;e=t;d=t=t+63&-64;t=t+80|0;do if(!((a|0)==0|(b|0)==0)){c=na(f[a+20>>2]<<3)|0;f[a+4>>2]=c;if(c){c=zc(a,f[a+16>>2]|0)|0;if(!c){Qa(d,b,f[a+36>>2]|0);ye(d+64|0,8);Ec(d,a);ye(d,72);c=0;break}else{og(a,f[b+56>>2]|0);break}}else c=-22}else c=-25;while(0);t=e;return c|0}function Jc(a){a=a|0;var c=0,d=0,e=0,f=0,g=0,i=0;f=t;g=t=t+63&-64;t=t+16|0;c=g;d=c+12|0;do{b[c>>0]=0;c=c+1|0}while((c|0)<(d|0));d=0;do{e=b[a+d>>0]|0;c=0;do{i=g+c|0;b[i>>0]=b[i>>0]|b[33584+(c<<5)+d>>0]^e;c=c+1|0}while((c|0)!=12);d=d+1|0}while((d|0)!=32);c=0;d=0;do{c=(h[g+d>>0]|0)+-1|c;d=d+1|0}while((d|0)!=12);t=f;return c>>>8&1|0}function Kc(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0,i=0;i=b[a>>0]|0;a:do if((i+-48&255)<=9){g=0;h=a;e=i;while(1){d=(e<<24>>24)+-48|0;e=g*10|0;if(!(g>>>0<429496730&(d>>>0>~e>>>0^1))){d=0;break a}g=(d>>>0>~e>>>0?0:d)+e|0;d=h+1|0;e=b[d>>0]|0;if((e+-48&255)>9)break;else h=d}if((d|0)!=(a|0)?(h|0)==(a|0)|i<<24>>24!=48:0)f[c>>2]=g;else d=0}else d=0;while(0);return d|0}function Lc(a){a=a|0;return ((0-((0-(a^95)|0)>>>8&63^63|(0-(a^45)|0)>>>8&62^62|((a+65439|0)>>>8^255)&a+185&((122-a|0)>>>8&255^255)|((a+-65|0)>>>8^255)&a+-65&((90-a|0)>>>8&255^255)|((a+65488|0)>>>8^255)&a+4&((57-a|0)>>>8&255^255))|0)>>>8&255^255)&(0-(a^65)|0)>>>8|((0-(a^95)|0)>>>8&63^63|(0-(a^45)|0)>>>8&62^62|((a+65439|0)>>>8^255)&a+185&((122-a|0)>>>8&255^255)|((a+-65|0)>>>8^255)&a+-65&((90-a|0)>>>8&255^255)|((a+65488|0)>>>8^255)&a+4&((57-a|0)>>>8&255^255))|0}function Mc(a,c,d,e,f){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0,j=0,k=0;if((((a>>>0<=63?(j=Af(d|0,0,c|0,0)|0,k=G,!(k>>>0>0|(k|0)==0&j>>>0>1073741823)):0)?(b[f>>0]=36,b[f+1>>0]=55,b[f+2>>0]=36,b[f+3>>0]=b[35349+a>>0]|0,g=Ed(f+4|0,54,c,30)|0,(g|0)!=0):0)?(h=Ed(g,f+58-g|0,d,30)|0,(h|0)!=0):0)?(i=zd(h,f+58-h|0,e)|0,(i|0)!=0&i>>>0<(f+58|0)>>>0):0)b[i>>0]=0;else f=0;return f|0}function Nc(a,b,c,d,e,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;var h=0,i=0;h=t;i=t=t+63&-64;t=t+16|0;se(a+64|0,c|0,d|0)|0;lg(a,i,a+64|0,d,e,g)|0;if((f[i>>2]|0)==64&(f[i+4>>2]|0)==0)if(b|0){a=Lg(d|0,e|0,64,0)|0;f[b>>2]=a;f[b+4>>2]=G;a=0}else a=0;else{if(b|0){f[b>>2]=0;f[b+4>>2]=0}ec(a|0,0,d+64|0)|0;a=-1}t=h;return a|0}function Oc(a,c,d,e,f,g){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0,j=0;i=t;h=t=t+63&-64;t=t+32|0;if(!(e>>>0<0|(e|0)==0&d>>>0<32)?(me(h,32,0,f,g)|0,j=Lg(d|0,e|0,-32,-1)|0,(vg(c+16|0,c+32|0,j,G,h)|0)==0):0){kg(a,c,d,e,f,g)|0;c=a+32|0;do{b[a>>0]=0;a=a+1|0}while((a|0)<(c|0));a=0}else a=-1;t=i;return a|0}function Pc(a){a=a|0;return ((0-((0-(a^47)|0)>>>8&63^63|(0-(a^43)|0)>>>8&62^62|((a+65439|0)>>>8^255)&a+185&((122-a|0)>>>8&255^255)|((a+-65|0)>>>8^255)&a+-65&((90-a|0)>>>8&255^255)|((a+65488|0)>>>8^255)&a+4&((57-a|0)>>>8&255^255))|0)>>>8&255^255)&(0-(a^65)|0)>>>8|((0-(a^47)|0)>>>8&63^63|(0-(a^43)|0)>>>8&62^62|((a+65439|0)>>>8^255)&a+185&((122-a|0)>>>8&255^255)|((a+-65|0)>>>8^255)&a+-65&((90-a|0)>>>8&255^255)|((a+65488|0)>>>8^255)&a+4&((57-a|0)>>>8&255^255))|0}function Qc(a,b,c,e){a=a|0;b=b|0;c=c|0;e=e|0;var g=0,h=0,i=0;i=t;g=t=t+63&-64;t=t+128|0;if((gg(a)|0)==101){zi(g+104|0);e=g;h=e+100|0;do{f[e>>2]=0;e=e+4|0}while((e|0)<(h|0));d[g+100>>1]=0;c=(Rb(g+104|0,b,c,a,g)|0)==0;Ai(g+104|0);if(!c){e=hd(g,a,102)|0;ye(g,102)}else e=-1}else e=-1;t=i;return e|0}function Rc(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0;l=f[b+4>>2]|0;k=f[b+8>>2]|0;j=f[b+12>>2]|0;i=f[b+16>>2]|0;h=f[b+20>>2]|0;g=f[b+24>>2]|0;e=f[b+28>>2]|0;d=f[b+32>>2]|0;c=f[b+36>>2]|0;f[a>>2]=f[b>>2];f[a+4>>2]=l;f[a+8>>2]=k;f[a+12>>2]=j;f[a+16>>2]=i;f[a+20>>2]=h;f[a+24>>2]=g;f[a+28>>2]=e;f[a+32>>2]=d;f[a+36>>2]=c;return}function Sc(a){a=a|0;var c=0,d=0,e=0;a:do if(!(a&3)){c=a;e=5}else{c=a;d=a;while(1){if(!(b[c>>0]|0)){c=d;break a}c=c+1|0;d=c;if(!(d&3)){e=5;break}}}while(0);if((e|0)==5){while(1){d=f[c>>2]|0;if(!((d&-2139062144^-2139062144)&d+-16843009))c=c+4|0;else break}if((d&255)<<24>>24)do c=c+1|0;while((b[c>>0]|0)!=0)}return c-a|0}function Tc(a,c,d,e,f){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0,j=0;j=t;t=t+96|0;if(!(Qh(j+32|0,j)|0)){g=a;h=j+32|0;i=g+32|0;do{b[g>>0]=b[h>>0]|0;g=g+1|0;h=h+1|0}while((g|0)<(i|0));le(j+64|0,j+32|0,f);a=Xe(a+32|0,c,d,e,j+64|0,f,j)|0;ye(j,32);ye(j+32|0,32);ye(j+64|0,24)}else a=-1;t=j;return a|0}function Uc(a,b){a=a|0;b=b|0;var c=0;f[a>>2]=1634760805;f[a+4>>2]=857760878;f[a+8>>2]=2036477234;f[a+12>>2]=1797285236;c=yh(b)|0;f[a+16>>2]=c;c=yh(b+4|0)|0;f[a+20>>2]=c;c=yh(b+8|0)|0;f[a+24>>2]=c;c=yh(b+12|0)|0;f[a+28>>2]=c;c=yh(b+16|0)|0;f[a+32>>2]=c;c=yh(b+20|0)|0;f[a+36>>2]=c;c=yh(b+24|0)|0;f[a+40>>2]=c;b=yh(b+28|0)|0;f[a+44>>2]=b;return}function Vc(a,b){a=a|0;b=b|0;var c=0,d=0;c=$f(f[a+72>>2]|0,f[a+72+4>>2]|0,3)|0;if((c&127)>>>0<112){if(112-(c&127)|0)qb(a+80+(c&127)|0,33456,112-(c&127)|0)|0}else{if(128-(c&127)|0)qb(a+80+(c&127)|0,33456,128-(c&127)|0)|0;ma(a,a+80|0,b,b+640|0);c=a+80|0;d=c+112|0;do{f[c>>2]=0;c=c+4|0}while((c|0)<(d|0))}Te(a+192|0,a+64|0,16);ma(a,a+80|0,b,b+640|0);return}function Wc(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+48|0;Wb(a,b+40|0,b);Vb(a+40|0,b+40|0,b);pa(a+80|0,a,c+40|0);pa(a+40|0,a+40|0,c);pa(a+120|0,c+120|0,b+120|0);pa(a,b+80|0,c+80|0);Wb(e,a,a);Vb(a,a+80|0,a+40|0);Wb(a+40|0,a+80|0,a+40|0);Vb(a+80|0,e,a+120|0);Wb(a+120|0,e,a+120|0);t=d;return}function Xc(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+48|0;Wb(a,b+40|0,b);Vb(a+40|0,b+40|0,b);pa(a+80|0,a,c);pa(a+40|0,a+40|0,c+40|0);pa(a+120|0,c+120|0,b+120|0);pa(a,b+80|0,c+80|0);Wb(e,a,a);Vb(a,a+80|0,a+40|0);Wb(a+40|0,a+80|0,a+40|0);Wb(a+80|0,e,a+120|0);Vb(a+120|0,e,a+120|0);t=d;return}function Yc(a){a=a|0;var b=0,c=0,d=0,e=0,f=0,g=0,i=0;f=h[a+7>>0]|0;g=Wf(h[a+6>>0]|0|0,0,8)|0;i=G;e=Wf(h[a+5>>0]|0|0,0,16)|0;i=i|G;d=Wf(h[a+4>>0]|0|0,0,24)|0;i=i|G|(h[a+3>>0]|0);c=Wf(h[a+2>>0]|0|0,0,40)|0;i=i|G;b=Wf(h[a+1>>0]|0|0,0,48)|0;i=i|G;a=Wf(h[a>>0]|0|0,0,56)|0;G=i|G;return g|f|e|d|c|b|a|0}function Zc(a,b){a=a|0;b=b|0;var c=0,d=0;d=t;c=t=t+63&-64;t=t+256|0;if(((Zb(b)|0)==0?(Eb(c+88|0,b)|0)==0:0)?(Df(c+88|0)|0)!=0:0){Bg(c);Vb(c,c,c+88+40|0);Za(c,c);Bg(c+48|0);Wb(c+48|0,c+48|0,c+88+40|0);pa(c+48|0,c+48|0,c);rb(a,c+48|0);a=0}else a=-1;t=d;return a|0}function _c(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+48|0;Wb(a,b+40|0,b);Vb(a+40|0,b+40|0,b);pa(a+80|0,a,c+40|0);pa(a+40|0,a+40|0,c);pa(a+120|0,c+80|0,b+120|0);Wb(e,b+80|0,b+80|0);Vb(a,a+80|0,a+40|0);Wb(a+40|0,a+80|0,a+40|0);Vb(a+80|0,e,a+120|0);Wb(a+120|0,e,a+120|0);t=d;return}function $c(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+48|0;Wb(a,b+40|0,b);Vb(a+40|0,b+40|0,b);pa(a+80|0,a,c);pa(a+40|0,a+40|0,c+40|0);pa(a+120|0,c+80|0,b+120|0);Wb(e,b+80|0,b+80|0);Vb(a,a+80|0,a+40|0);Wb(a+40|0,a+80|0,a+40|0);Wb(a+80|0,e,a+120|0);Vb(a+120|0,e,a+120|0);t=d;return}function ad(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;e=t;d=t=t+63&-64;t=t+800|0;if((((Hb(d+640|0,b)|0)==0?(cd(d+640|0)|0)!=0:0)?(Hb(d+480|0,c)|0)==0:0)?(cd(d+480|0)|0)!=0:0){If(d,d+480|0);Wc(d+160|0,d+640|0,d);wf(d+320|0,d+160|0);Pd(a,d+320|0);a=0}else a=-1;t=e;return a|0}function bd(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;e=t;d=t=t+63&-64;t=t+800|0;if((((Hb(d+640|0,b)|0)==0?(cd(d+640|0)|0)!=0:0)?(Hb(d+480|0,c)|0)==0:0)?(cd(d+480|0)|0)!=0:0){If(d,d+480|0);Xc(d+160|0,d+640|0,d);wf(d+320|0,d+160|0);Pd(a,d+320|0);a=0}else a=-1;t=e;return a|0}function cd(a){a=a|0;var b=0,c=0;b=t;c=t=t+63&-64;t=t+288|0;ua(c+240|0,a);ua(c+192|0,a+40|0);ua(c+144|0,a+80|0);Vb(c+48|0,c+192|0,c+240|0);pa(c+48|0,c+48|0,c+144|0);pa(c,c+240|0,c+192|0);pa(c,c,16);ua(c+96|0,c+144|0);Wb(c,c,c+96|0);Vb(c+48|0,c+48|0,c);a=Mf(c+48|0)|0;t=b;return a|0}function dd(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;if(!(e>>>0<2147483647&e<<1>>>0<c>>>0))Fj();if(!e)c=0;else{c=0;do{g=h[d+c>>0]|0;f=c<<1;b[a+f>>0]=(g>>>4)+87+(((g>>>4)+65526|0)>>>8&217);b[a+(f|1)>>0]=(((g&15)<<8)+22272+((g&15)+65526&55552)|0)>>>8;c=c+1|0}while((c|0)!=(e|0));c=e<<1}b[a+c>>0]=0;return a|0}function ed(a,c){a=a|0;c=c|0;var d=0,e=0,g=0;e=t;g=t=t+63&-64;t=t+64|0;if((c+-1&255)>63)Fj();else{b[g>>0]=c;b[g+1>>0]=0;b[g+2>>0]=1;b[g+3>>0]=1;Dh(g+4|0);We(g+8|0,0,0);c=g+16|0;d=c+48|0;do{f[c>>2]=0;c=c+4|0}while((c|0)<(d|0));ie(a,g);t=e;return}}function fd(a,c){a=a|0;c=c|0;var d=0,e=0,f=0;e=t;f=t=t+63&-64;t=t+208|0;d=0;do{b[a+d>>0]=b[c+d>>0]|0;d=d+1|0}while((d|0)!=32);b[a>>0]=b[a>>0]&-8;b[a+31>>0]=b[a+31>>0]&63|64;ub(f+40|0,a);Re(f,f+40+40|0,f+40+80|0);rb(a,f);t=e;return 0}function gd(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;if(e>>>0>0|(e|0)==0&d>>>0>4294967279)Fj();oc(a,a+d|0,0,c,d,e,g,h,i,0,k,l)|0;if(b|0){k=Lg(d|0,e|0,16,0)|0;f[b>>2]=k;f[b+4>>2]=G}return 0}function hd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0;e=t;g=t=t+63&-64;t=t+16|0;f[g+4>>2]=a;f[g>>2]=c;b[g+8>>0]=0;if(d|0){a=0;do{b[g+8>>0]=b[g+8>>0]|b[(f[g>>2]|0)+a>>0]^b[(f[g+4>>2]|0)+a>>0];a=a+1|0}while((a|0)!=(d|0))}t=e;return (((h[g+8>>0]|0)+511|0)>>>8&1)+-1|0}function id(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;if(e>>>0>0|(e|0)==0&d>>>0>4294967279)Fj();Ib(a,a+d|0,0,c,d,e,g,h,i,0,k,l)|0;if(b|0){k=Lg(d|0,e|0,16,0)|0;f[b>>2]=k;f[b+4>>2]=G}return 0}function jd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0;b[a+7>>0]=c;e=$f(c|0,d|0,8)|0;b[a+6>>0]=e;e=$f(c|0,d|0,16)|0;b[a+5>>0]=e;e=$f(c|0,d|0,24)|0;b[a+4>>0]=e;b[a+3>>0]=d;e=$f(c|0,d|0,40)|0;b[a+2>>0]=e;e=$f(c|0,d|0,48)|0;b[a+1>>0]=e;d=$f(c|0,d|0,56)|0;b[a>>0]=d;return}function kd(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0;h=t;g=t=t+63&-64;t=t+32|0;if(d>>>0<0|(d|0)==0&c>>>0<48)a=-1;else{c=Lg(c|0,d|0,-32,-1)|0;d=G;le(g,b,e);a=_d(a,b+32|0,c,d,g,b,f)|0}t=h;return a|0}function ld(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0,j=0;j=t;i=t=t+63&-64;t=t+32|0;if(!(ne(i,g,h)|0)){a=mf(a,b,c,d,e,f,i)|0;ye(i,32)}else a=-1;t=j;return a|0}function md(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0,j=0;j=t;i=t=t+63&-64;t=t+32|0;if(!(ne(i,g,h)|0)){qf(a,b,c,d,e,f,i)|0;ye(i,32);a=0}else a=-1;t=j;return a|0}function nd(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;if(e>>>0>0|(e|0)==0&d>>>0>4294967279)Fj();Xb(a,a+d|0,0,c,d,e,g,h,i,0,k,l)|0;if(b|0){k=Lg(d|0,e|0,16,0)|0;f[b>>2]=k;f[b+4>>2]=G}return 0}function od(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0,j=0;i=t;j=t=t+63&-64;t=t+80|0;if(!((c|0)==0&(d|0)==0)){Qg(j+64|0,f);Qg(j+64+4|0,g);Uc(j,h);je(j,e,j+64|0);za(j,b,a,c,d);ye(j,64)}t=i;return 0}function pd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0;e=t;g=t=t+63&-64;t=t+16|0;f[g+8>>2]=a;f[g+4>>2]=c;f[g>>2]=0;a=0;do{f[g>>2]=f[g>>2]|(b[(f[g+4>>2]|0)+a>>0]^b[(f[g+8>>2]|0)+a>>0])&255;a=a+1|0}while((a|0)!=(d|0));t=e;return (((f[g>>2]|0)+511|0)>>>8&1)+-1|0}function qd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0;e=b[a>>0]|0;a:do if(!(e<<24>>24))e=0;else while(1){d=d+-1|0;f=b[c>>0]|0;if(!(e<<24>>24==f<<24>>24&((d|0)!=0&f<<24>>24!=0)))break a;a=a+1|0;c=c+1|0;e=b[a>>0]|0;if(!(e<<24>>24)){e=0;break}}while(0);return (e&255)-(h[c>>0]|0)|0}function rd(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0;h=t;e=t=t+63&-64;t=t+16|0;g=0;d=0;while(1){if(Og(e,b[c>>0]|0)|0){d=3;break}c=c+1|0;g=f[e>>2]<<d|g;d=d+6|0;if(d>>>0>=30){d=5;break}}if((d|0)==3){f[a>>2]=0;c=0}else if((d|0)==5)f[a>>2]=g;t=h;return c|0}function sd(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0,g=0;ig(c,a+((d<<5)+-16<<2)|0);if(d<<1|0){e=0;do{g=e<<4;zf(c,a+(g<<2)|0);Ea(c);f=e<<3;ig(b+(f<<2)|0,c);zf(c,a+((g|16)<<2)|0);Ea(c);ig(b+(f+(d<<4)<<2)|0,c);e=e+2|0}while(e>>>0<d<<1>>>0)}return}function td(a,c){a=a|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0;f=t;g=t=t+63&-64;t=t+16|0;e=10;while(1){h=c;c=(c>>>0)/10|0;i=(h+(V(c,-10)|0)|48)&255;d=e+-1|0;b[g+d>>0]=i;if(!(h>>>0>9&(d|0)!=0))break;else e=d}i=11-e|0;qb(a|0,g+d|0,i|0)|0;b[a+i>>0]=0;t=f;return}function ud(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+48|0;ua(a,b);ua(a+80|0,b+40|0);ta(a+120|0,b+80|0);Wb(a+40|0,b,b+40|0);ua(d,a+40|0);Wb(a+40|0,a+80|0,a);Vb(a+80|0,a+80|0,a);Vb(a,d,a+40|0);Vb(a+120|0,a+120|0,a+80|0);t=c;return}function vd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0;f=t;e=t=t+63&-64;t=t+16|0;b[e>>0]=0;if(!(Ya(a,c,d)|0)){c=0;do{b[e>>0]=b[e>>0]|b[a+c>>0];c=c+1|0}while((c|0)!=32);c=0-(((h[e>>0]|0)+511|0)>>>8&1)|0}else c=-1;t=f;return c|0}function wd(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;do if(!(c>>>0>64|(d+-1|0)>>>0>63))if((b|0)==0|(c|0)==0){bc(a,d&255,e,f);a=0;break}else{yb(a,d&255,b,c&255,e,f);a=0;break}else a=-1;while(0);return a|0}function xd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0,g=0,h=0;g=t;h=t=t+63&-64;t=t+64|0;He(h,d,32,0)|0;d=c;e=h;f=d+32|0;do{b[d>>0]=b[e>>0]|0;d=d+1|0;e=e+1|0}while((d|0)<(f|0));ye(h,64);h=Jh(a,c)|0;t=g;return h|0}function yd(a,c,d,e,f,g){a=a|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;if(e>>>0<0|(e|0)==0&d>>>0<32)a=-1;else{kg(a,c,d,e,f,g)|0;c=Lg(d|0,e|0,-32,-1)|0;Eg(a+16|0,a+32|0,c,G,a)|0;c=a+16|0;do{b[a>>0]=0;a=a+1|0}while((a|0)<(c|0));a=0}return a|0}function zd(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0;e=0;g=a;while(1){a=0;d=0;do{f=e;e=e+1|0;d=(h[c+f>>0]|0)<<a|d;a=a+8|0;f=e>>>0<32}while(f&a>>>0<24);a=Ed(g,b,d,a)|0;if(!a){a=0;break}b=b+g-a|0;if(!f)break;else g=a}return a|0}function Ad(a,b,c,d,e,g,h,i,j,k,l){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;g=g|0;h=h|0;i=i|0;j=j|0;k=k|0;l=l|0;switch(l|0){case 1:{a=dc(a,b,c,d,e,g,h,i,j,k,1)|0;break}case 2:{a=fc(a,b,c,d,e,g,h,i,j,k,2)|0;break}default:{f[9002]=22;a=-1}}return a|0}function Bd(a,c){a=a|0;c=c|0;var d=0,e=0,f=0;e=t;f=t=t+63&-64;t=t+64|0;He(f,c,32,0)|0;b[f>>0]=b[f>>0]&-8;b[f+31>>0]=b[f+31>>0]&63|64;c=f;d=a+32|0;do{b[a>>0]=b[c>>0]|0;a=a+1|0;c=c+1|0}while((a|0)<(d|0));ye(f,64);t=e;return 0}function Cd(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0;h=t;g=t=t+63&-64;t=t+32|0;if(d>>>0<0|(d|0)==0&c>>>0<48)a=-1;else{c=Lg(c|0,d|0,-32,-1)|0;d=G;le(g,b,e);a=ve(a,b+32|0,c,d,g,b,f)|0}t=h;return a|0}function Dd(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0;h=t;i=t=t+63&-64;t=t+80|0;if(!((c|0)==0&(d|0)==0)){Qg(i+64|0,f);Uc(i,g);Be(i,e,i+64|0);za(i,b,a,c,d);ye(i,64)}t=h;return 0}function Ed(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;a:do if(e){f=0;while(1){if(!c){a=0;break a}g=a+1|0;b[a>>0]=b[35349+(d&63)>>0]|0;f=f+6|0;if(f>>>0>=e>>>0){a=g;break}else{d=d>>>6;c=c+-1|0;a=g}}}while(0);return a|0}function Fd(a,c){a=a|0;c=c|0;var d=0,e=0,f=0;e=t;f=t=t+63&-64;t=t+160|0;d=0;do{b[a+d>>0]=b[c+d>>0]|0;d=d+1|0}while((d|0)!=32);rh(a);ub(f,a);Pd(a,f);f=((ge(c,32)|0)!=0)<<31>>31;t=e;return f|0}function Gd(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=Lg(f[a+64>>2]|0,f[a+64+4>>2]|0,b|0,c|0)|0;e=G;f[a+64>>2]=d;f[a+64+4>>2]=e;c=Lg(f[a+72>>2]|0,f[a+72+4>>2]|0,(e>>>0<c>>>0|(e|0)==(c|0)&d>>>0<b>>>0)&1|0,0)|0;f[a+72>>2]=c;f[a+72+4>>2]=G;return}function Hd(a,b,c,d,e,f,g,h,i,j){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;i=i|0;j=j|0;var k=0,l=0;k=t;l=t=t+63&-64;t=t+16|0;zi(l);j=hb(l,a,b,c,d,e,f,g,h,i,j)|0;Ai(l);t=k;return j|0}function Id(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0;i=t;h=t=t+63&-64;t=t+32|0;if(!(oe(h,f,g)|0)){a=ng(a,b,c,d,e,h)|0;ye(h,32)}else a=-1;t=i;return a|0}function Jd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,f=0;e=t;f=t=t+63&-64;t=t+160|0;He(c,d,32,0)|0;b[c>>0]=b[c>>0]&-8;b[c+31>>0]=b[c+31>>0]&63|64;ub(f,c);Pd(a,f);se(c|0,d|0,32)|0;se(c+32|0,a|0,32)|0;t=e;return 0}function Kd(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;var h=0,i=0;i=t;h=t=t+63&-64;t=t+32|0;if(!(oe(h,f,g)|0)){a=xg(a,b,c,d,e,h)|0;ye(h,32)}else a=-1;t=i;return a|0}function Ld(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0,j=0;i=t;j=t=t+63&-64;t=t+32|0;La(j,e,h,0)|0;h=Ef(a,b,c,d,e+16|0,f,g,j)|0;ye(j,32);t=i;return h|0}function Md(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;do if(qd(a,34372,10)|0)if(!(qd(a,34383,9)|0)){a=ih(a,b,c,d)|0;break}else{f[9002]=22;a=-1;break}else a=fh(a,b,c,d)|0;while(0);return a|0}function Nd(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;f=t;g=t=t+63&-64;t=t+64|0;if(!((b|0)==0&(c|0)==0)){Uc(g,e);Be(g,d,0);ec(a|0,0,b|0)|0;za(g,a,a,b,c);ye(g,64)}t=f;return 0}function Od(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;a:do if(d>>>0>0|(d|0)==0&c>>>0>4294967295){f[9002]=27;a=-1}else{switch($h(a,b,c)|0){case 0:{a=0;break a}case -35:{f[9002]=22;break}default:{}}a=-1}while(0);return a|0}function Pd(a,c){a=a|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+144|0;Za(e+96|0,c+80|0);pa(e+48|0,c,e+96|0);pa(e,c+40|0,e+96|0);rb(a,e);c=(Xf(e+48|0)|0)<<7;b[a+31>>0]=c^(h[a+31>>0]|0);t=d;return}function Qd(a){a=a|0;var b=0,c=0;c=t;b=t=t+63&-64;t=t+160|0;if((((hf(a)|0)!=0?(Zb(a)|0)==0:0)?(Hb(b,a)|0)==0:0)?(cd(b)|0)!=0:0)a=(Df(b)|0)!=0&1;else a=0;t=c;return a|0}function Rd(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;a:do if(d>>>0>0|(d|0)==0&c>>>0>4294967295){f[9002]=27;a=-1}else{switch(ai(a,b,c)|0){case 0:{a=0;break a}case -35:{f[9002]=22;break}default:{}}a=-1}while(0);return a|0}function Sd(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0;switch(h|0){case 1:{i=uc(a,b,c,d,e,f,g)|0;break}case 2:{i=xc(a,b,c,d,e,f,g)|0;break}default:Fj()}return i|0}function Td(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;do if(!(c>>>0>64|(d+-1|0)>>>0>63))if((b|0)==0|(c|0)==0){ed(a,d&255);a=0;break}else{gc(a,d&255,b,c&255);a=0;break}else a=-1;while(0);return a|0}function Ud(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;f=t;g=t=t+63&-64;t=t+64|0;if(!((b|0)==0&(c|0)==0)){Uc(g,e);je(g,d,0);ec(a|0,0,b|0)|0;za(g,a,a,b,c);ye(g,64)}t=f;return 0}function Vd(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0,j=0;i=t;j=t=t+63&-64;t=t+32|0;Ha(j,e,h,0)|0;h=Gf(a,b,c,d,e+16|0,f,g,j)|0;t=i;return h|0}function Wd(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;d=t;c=t=t+63&-64;t=t+16|0;e=Uf(c,b)|0;f[9002]=e;if(!e)c=f[c>>2]|0;else{f[c>>2]=0;c=0}f[a>>2]=c;f[a+4>>2]=c;f[a+8>>2]=(c|0)==0?0:b;t=d;return c|0}function Xd(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;do if(qd(a,34372,10)|0)if(!(qd(a,34383,9)|0)){a=Rd(a,b,c,d)|0;break}else{f[9002]=22;a=-1;break}else a=Od(a,b,c,d)|0;while(0);return a|0}function Yd(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0;i=t;t=t+32|0;if(!(qh(i,g,h)|0)){a=Pf(a,b,c,d,e,f,i)|0;ye(i,32)}else a=-1;t=i;return a|0}function Zd(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;var i=0;i=t;t=t+32|0;if(!(qh(i,g,h)|0)){Tf(a,b,c,d,e,f,i)|0;ye(i,32);a=0}else a=-1;t=i;return a|0}function _d(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;if(d>>>0<0|(d|0)==0&c>>>0<16)a=-1;else{d=Lg(c|0,d|0,-16,-1)|0;a=ld(a,b+16|0,b,d,G,e,f,g)|0}return a|0}function $d(a,c,d,e){a=a|0;c=c|0;d=d|0;e=e|0;var f=0;if(((((b[a>>0]|0)==36?(b[a+1>>0]|0)==55:0)?(b[a+2>>0]|0)==36:0)?(Og(c,b[a+3>>0]|0)|0)==0:0)?(f=rd(d,a+4|0)|0,(f|0)!=0):0)a=rd(e,f)|0;else a=0;return a|0}function ae(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0<0|(d|0)==0&c>>>0<16)a=-1;else{d=Lg(c|0,d|0,-16,-1)|0;a=mf(a,b+16|0,b,d,G,e,f)|0}return a|0}function be(a){a=a|0;var b=0;b=f[r>>2]|0;if((a|0)>0&(b+a|0)<(b|0)|(b+a|0)<0){ba()|0;da(12);return -1}f[r>>2]=b+a;if((b+a|0)>(aa()|0)?($()|0)==0:0){f[r>>2]=b;da(12);return -1}return b|0}function ce(a){a=a|0;var c=0,d=0,e=0,f=0,g=0;d=32;c=1;e=0;while(1){d=d+-1|0;f=b[a+d>>0]|0;g=b[32320+d>>0]|0;c=c&255;e=(f&255)-(g&255)>>8&c|e&255;if(!d)break;else c=(((g^f)&255)+65535|0)>>>8&c}return (e|0)!=0|0}function de(a){a=a|0;f[a+32>>2]=0;f[a+32+4>>2]=0;f[a>>2]=f[8100];f[a+4>>2]=f[8101];f[a+8>>2]=f[8102];f[a+12>>2]=f[8103];f[a+16>>2]=f[8104];f[a+20>>2]=f[8105];f[a+24>>2]=f[8106];f[a+28>>2]=f[8107];return 0}function ee(){}function fe(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;c=V(b&65535,a&65535)|0;e=(c>>>16)+(V(b&65535,a>>>16)|0)|0;d=V(b>>>16,a&65535)|0;return (G=(e>>>16)+(V(b>>>16,a>>>16)|0)+(((e&65535)+d|0)>>>16)|0,e+d<<16|c&65535|0)|0}function ge(a,c){a=a|0;c=c|0;var d=0,e=0,f=0;e=t;f=t=t+63&-64;t=t+16|0;b[f>>0]=0;d=0;do{b[f>>0]=b[f>>0]|b[a+d>>0];d=d+1|0}while((d|0)!=(c|0));t=e;return ((h[f>>0]|0)+511|0)>>>8&1|0}function he(a,b,c,d,e,f,g,h,i){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;i=i|0;if((b+-1|0)>>>0>63|g>>>0>64)a=-1;else{kc(a,c,f,b&255,d,e,g&255,h,i);a=0}return a|0}function ie(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0;vf(a);c=0;do{g=tf(b+(c<<3)|0)|0;d=a+(c<<3)|0;e=f[d+4>>2]^G;f[d>>2]=f[d>>2]^g;f[d+4>>2]=e;c=c+1|0}while((c|0)!=8);return}function je(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;if(!c){f[a+48>>2]=0;c=0}else{d=yh(c)|0;f[a+48>>2]=d;c=yh(c+4|0)|0}f[a+52>>2]=c;d=yh(b)|0;f[a+56>>2]=d;d=yh(b+4|0)|0;f[a+60>>2]=d;return}function ke(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0<0|(d|0)==0&c>>>0<16)a=-1;else{d=Lg(c|0,d|0,-16,-1)|0;a=nb(a,b+16|0,b,d,G,e,f)|0}return a|0}function le(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+384|0;jh(e,0,0,24)|0;Yg(e,b,32,0)|0;Yg(e,c,32,0)|0;Bh(e,a,24)|0;t=d;return}function me(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;f=t;g=t=t+63&-64;t=t+32|0;La(g,d,e,0)|0;e=ch(a,b,c,d+16|0,g)|0;ye(g,32);t=f;return e|0}function ne(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;e=t;d=t=t+63&-64;t=t+32|0;if(!(vd(d,c,b)|0)){Ha(a,35488,d,0)|0;a=0}else a=-1;t=e;return a|0}function oe(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;e=t;d=t=t+63&-64;t=t+32|0;if(!(vd(d,c,b)|0)){La(a,35440,d,0)|0;a=0}else a=-1;t=e;return a|0}function pe(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=t;t=t+32|0;Me(f,b,c,d,e)|0;e=ji(a,f)|0;e=((f|0)==(a|0)?-1:e)|(hd(f,a,32)|0);t=f;return e|0}function qe(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;if(d>>>0>0|(d|0)==0&c>>>0>4294967279)Fj();else return md(a+16|0,a,b,c,d,e,f,g)|0;return 0}function re(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0>0|(d|0)==0&c>>>0>4294967279)Fj();else{qf(a+16|0,a,b,c,d,e,f)|0;return 0}return 0}function se(a,c,d){a=a|0;c=c|0;d=d|0;var e=0;if((c|0)<(a|0)&(a|0)<(c+d|0)){e=a;c=c+d|0;a=a+d|0;while((d|0)>0){a=a-1|0;c=c-1|0;d=d-1|0;b[a>>0]=b[c>>0]|0}a=e}else qb(a,c,d)|0;return a|0}function te(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=t;t=t+64|0;Le(f,b,c,d,e)|0;e=ii(a,f)|0;e=((f|0)==(a|0)?-1:e)|(hd(f,a,64)|0);t=f;return e|0}function ue(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=t;t=t+32|0;Je(f,b,c,d,e)|0;e=ji(a,f)|0;e=((f|0)==(a|0)?-1:e)|(hd(f,a,32)|0);t=f;return e|0}function ve(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;if(d>>>0<0|(d|0)==0&c>>>0<16)a=-1;else{d=Lg(c|0,d|0,-16,-1)|0;a=Yd(a,b+16|0,b,d,G,e,f,g)|0}return a|0}function we(a){a=a|0;var b=0,c=0,d=0,e=0;c=h[a>>0]|0;d=Wf(h[a+1>>0]|0|0,0,8)|0;e=G;b=Wf(h[a+2>>0]|0|0,0,16)|0;e=e|G;a=Wf(h[a+3>>0]|0|0,0,24)|0;G=e|G;return d|c|b|a|0}function xe(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;f=t;g=t=t+63&-64;t=t+16|0;Ke(g,b,c,d,e)|0;e=ki(a,g)|0;t=f;return e|0}function ye(a,c){a=a|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+16|0;f[e>>2]=a;if(c|0){a=0;do{b[(f[e>>2]|0)+a>>0]=0;a=a+1|0}while((a|0)!=(c|0))}t=d;return}function ze(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0<0|(d|0)==0&c>>>0<16)a=-1;else{d=Lg(c|0,d|0,-16,-1)|0;a=Pf(a,b+16|0,b,d,G,e,f)|0}return a|0}function Ae(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,g=0;c=0;do{g=b+(c<<3)|0;d=a+(c<<3)|0;e=f[d+4>>2]^f[g+4>>2];f[d>>2]=f[d>>2]^f[g>>2];f[d+4>>2]=e;c=c+1|0}while((c|0)!=128);return}function Be(a,b,c){a=a|0;b=b|0;c=c|0;if(!c)c=0;else c=yh(c)|0;f[a+48>>2]=c;c=yh(b)|0;f[a+52>>2]=c;c=yh(b+4|0)|0;f[a+56>>2]=c;b=yh(b+8|0)|0;f[a+60>>2]=b;return}function Ce(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;f=t;g=t=t+63&-64;t=t+32|0;Ha(g,d,e,0)|0;e=hh(a,b,c,d+16|0,g)|0;t=f;return e|0}function De(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0<0|(d|0)==0&c>>>0<16)a=-1;else{d=Lg(c|0,d|0,-16,-1)|0;a=pb(a,b+16|0,b,d,G,e,f)|0}return a|0}function Ee(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0>0|(d|0)==0&c>>>0>4294967279)Fj();else{bb(a+16|0,a,b,c,d,e,f)|0;return 0}return 0}function Fe(a,c){a=a|0;c=c|0;var d=0,e=0;e=t;t=t+64|0;Ue(a,e)|0;a=e;d=c+32|0;do{b[c>>0]=b[a>>0]|0;c=c+1|0;a=a+1|0}while((c|0)<(d|0));t=e;return 0}function Ge(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;f=Lg(c|0,d|0,a|0,b|0)|0;e=G;d=Wf(a|0,b|0,1)|0;d=Af(d&-2|0,G&1|0,c|0,0)|0;d=Lg(f|0,e|0,d|0,G|0)|0;return d|0}function He(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=t;f=t=t+63&-64;t=t+208|0;Ne(f)|0;Ja(f,b,c,d)|0;df(f,a)|0;t=e;return 0}function Ie(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=t;f=t=t+63&-64;t=t+112|0;de(f)|0;Pa(f,b,c,d)|0;gf(f,a)|0;t=e;return 0}function Je(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=t;t=t+208|0;Bb(f,e,32)|0;bh(f,b,c,d)|0;Ve(f,a)|0;t=f;return 0}function Ke(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;f=t;g=t=t+63&-64;t=t+96|0;ic(g,e);Ra(g,b,c,d);ab(g,a);t=f;return 0}function Le(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=t;t=t+416|0;Ab(f,e,32)|0;eh(f,b,c,d)|0;Ue(f,a)|0;t=f;return 0}function Me(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=t;t=t+416|0;wh(f,e,32)|0;lh(f,b,c,d)|0;Fe(f,a)|0;t=f;return 0}function Ne(a){a=a|0;var b=0,c=0;f[a+64>>2]=0;f[a+64+4>>2]=0;f[a+64+8>>2]=0;f[a+64+12>>2]=0;b=32752;c=a+64|0;do{f[a>>2]=f[b>>2];a=a+4|0;b=b+4|0}while((a|0)<(c|0));return 0}function Oe(a,c){a=a|0;c=c|0;var d=0;a:do if(!c)c=0;else{d=c;while(1){d=d+-1|0;c=a+d|0;if((b[c>>0]|0)==36)break a;if(!d){c=0;break}}}while(0);return c|0}function Pe(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=t;f=t=t+63&-64;t=t+64|0;df(a,f)|0;Mb(b,c,f,64,0,d,1);t=e;return 0}function Qe(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+64|0;df(a,e)|0;c=Pb(b,e,64,0,c,1)|0;t=d;return c|0}function Re(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=t;e=t=t+63&-64;t=t+96|0;Wb(e+48|0,c,b);Vb(e,c,b);Za(e,e);pa(a,e+48|0,e);t=d;return}function Se(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;if((b+-1|0)>>>0>63|g>>>0>64)a=-1;else{Ac(a,c,f,b&255,d,e,g&255);a=0}return a|0}function Te(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;if(c>>>3|0){d=0;do{e=b+(d<<3)|0;jd(a+(d<<3)|0,f[e>>2]|0,f[e+4>>2]|0);d=d+1|0}while((d|0)!=(c>>>3|0))}return}function Ue(a,b){a=a|0;b=b|0;var c=0;c=t;t=t+64|0;df(a,c)|0;Ja(a+208|0,c,64,0)|0;df(a+208|0,b)|0;ye(c,64);t=c;return 0}function Ve(a,b){a=a|0;b=b|0;var c=0;c=t;t=t+32|0;gf(a,c)|0;Pa(a+104|0,c,32,0)|0;gf(a+104|0,b)|0;ye(c,32);t=c;return 0}function We(a,c,d){a=a|0;c=c|0;d=d|0;b[a>>0]=c;b[a+1>>0]=c>>8;b[a+2>>0]=c>>16;b[a+3>>0]=c>>24;b[a+4>>0]=d;b[a+4+1>>0]=d>>8;b[a+4+2>>0]=d>>16;b[a+4+3>>0]=d>>24;return}function Xe(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;if(d>>>0>0|(d|0)==0&c>>>0>4294967279)Fj();else return Zd(a+16|0,a,b,c,d,e,f,g)|0;return 0}function Ye(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0>0|(d|0)==0&c>>>0>4294967279)Fj();else{Tf(a+16|0,a,b,c,d,e,f)|0;return 0}return 0}function Ze(a){a=a|0;return (0-(a^62)|0)>>>8&45^45|(a+65510|0)>>>8&255&a+65|(0-(a^63)|0)>>>8&95^95|(a+65484|0)>>>8&a+71&((a+65510|0)>>>8&255^255)|(a+65474|0)>>>8&a+252&((a+65484|0)>>>8&255^255)|0}function _e(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(d>>>0>0|(d|0)==0&c>>>0>4294967279)Fj();else{db(a+16|0,a,b,c,d,e,f)|0;return 0}return 0}function $e(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;if(c>>>2|0){d=0;do{e=a+(d<<2)|0;f[e>>2]=f[e>>2]^f[b+(d<<2)>>2];d=d+1|0}while((d|0)!=(c>>>2|0))}return}function af(a){a=a|0;return (0-(a^62)|0)>>>8&43^43|(a+65510|0)>>>8&255&a+65|(0-(a^63)|0)>>>8&47^47|(a+65484|0)>>>8&a+71&((a+65510|0)>>>8&255^255)|(a+65474|0)>>>8&a+252&((a+65484|0)>>>8&255^255)|0}function bf(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+32|0;uf(d,32);Jd(a,b,d)|0;ye(d,32);t=c;return 0}function cf(a,b){a=a|0;b=b|0;if(b|0){b=f[a>>2]|0;if(b|0)ye(f[b+4>>2]|0,f[a+16>>2]<<10);b=f[a+4>>2]|0;if(b|0)ye(b,f[a+20>>2]<<3)}return}function df(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+704|0;Vc(a,d);Te(b,a,64);ye(d,704);ye(a,208);t=c;return 0}function ef(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;c=0;do{e=Yc(b+(c<<3)|0)|0;d=a+(c<<3)|0;f[d>>2]=e;f[d+4>>2]=G;c=c+1|0}while((c|0)!=16);return}function ff(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;c=0;do{e=tf(b+(c<<3)|0)|0;d=a+(c<<3)|0;f[d>>2]=e;f[d+4>>2]=G;c=c+1|0}while((c|0)!=128);return}function gf(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+288|0;Gc(a,d);Vf(b,a);ye(d,288);ye(a,104);t=c;return 0}function hf(a){a=a|0;var c=0,d=0;c=b[a+31>>0]&127^127;d=30;do{c=c|~b[a+d>>0];d=d+-1|0}while((d|0)!=0);return (236-(h[a>>0]|0)&(c&255)+511)>>>8&1^1|0}function jf(a){a=a|0;var c=0,d=0;c=1;d=b[a>>0]^1;do{d=b[a+c>>0]|d;c=c+1|0}while((c|0)!=31);return (((b[a+31>>0]&127|d)&255)+511|0)>>>8&1|0}function kf(a){a=a|0;var b=0;if(a>>>0<2)a=0;else{do b=Hi()|0;while(b>>>0<(((0-a|0)>>>0)%(a>>>0)|0)>>>0);a=(b>>>0)%(a>>>0)|0}return a|0}function lf(a,b){a=a|0;b=b|0;var c=0;Sh(b);c=(V((a>>>0)/3|0,-3)|0)+a|0;return (((a>>>0)/3|0)<<2|1)+(4-(3-c&0-(b>>>1&1))&0-((c>>>1|c)&1))|0}function mf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return nb(a,b,c,d,e,f,g)|0}function nf(a,b,c){a=a|0;b=b|0;c=c|0;Fb(a,b,c&255);Fb(a+40|0,b+40|0,c&255);Fb(a+80|0,b+80|0,c&255);Fb(a+120|0,b+120|0,c&255);return}function of(a){a=a|0;var c=0,d=0,e=0;d=0;c=1;while(1){e=a+d|0;c=c+(h[e>>0]|0)|0;b[e>>0]=c;d=d+1|0;if((d|0)==4)break;else c=c>>>8}return}function pf(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;e=t;t=t+16|0;Da(a,b,c,d,e|0)|0;t=e;return (G=f[e+4>>2]|0,f[e>>2]|0)|0}function qf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;bb(a,b,c,d,e,f,g)|0;return 0}function rf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;if(c>>>2|0){d=0;do{f[a+(d<<2)>>2]=f[b+(d<<2)>>2];d=d+1|0}while((d|0)!=(c>>>2|0))}return}function sf(a,b){a=a|0;b=b|0;var c=0,d=0;c=0;do{d=b+(c<<3)|0;We(a+(c<<3)|0,f[d>>2]|0,f[d+4>>2]|0);c=c+1|0}while((c|0)!=128);return}function tf(a){a=a|0;G=h[a+4>>0]|h[a+4+1>>0]<<8|h[a+4+2>>0]<<16|h[a+4+3>>0]<<24;return h[a>>0]|h[a+1>>0]<<8|h[a+2>>0]<<16|h[a+3>>0]<<24|0}function uf(a,c){a=a|0;c=c|0;var d=0,e=0;if(c|0){d=0;do{e=(Hi()|0)&255;b[a+d>>0]=e;d=d+1|0}while((d|0)!=(c|0))}return}function vf(a){a=a|0;var b=0,c=0,d=0;b=a;c=32752;d=b+64|0;do{f[b>>2]=f[c>>2];b=b+4|0;c=c+4|0}while((b|0)<(d|0));ec(a+64|0,0,293)|0;return}function wf(a,b){a=a|0;b=b|0;pa(a,b,b+120|0);pa(a+40|0,b+40|0,b+80|0);pa(a+80|0,b+80|0,b+120|0);pa(a+120|0,b,b+40|0);return}function xf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=$f(a|0,b|0,c|0)|0;e=G;c=Wf(a|0,b|0,64-c|0)|0;G=G|e;return c|d|0}function yf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=Wf(a|0,b|0,c|0)|0;e=G;c=$f(a|0,b|0,64-c|0)|0;G=G|e;return c|d|0}function zf(a,b){a=a|0;b=b|0;var c=0,d=0;c=0;do{d=a+(c<<2)|0;f[d>>2]=f[d>>2]^f[b+(c<<2)>>2];c=c+1|0}while((c|0)!=16);return}function Af(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=fe(a,c)|0;f=G;return (G=(V(b,c)|0)+(V(d,a)|0)+f|f&0,e|0|0)|0}function Bf(a,b,c){a=a|0;b=b|0;c=c|0;if(c>>>0<256)return gb(a,b,c&255)|0;else ca(34168,34188,103,34241);return 0}function Cf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;b=Wf(b&255|0,0,8)|0;d=G;c=Wf(c&255|0,0,16)|0;G=d|G;return b|a&255|c|0}function Df(a){a=a|0;var b=0,c=0;b=t;c=t=t+63&-64;t=t+160|0;cb(c,a);a=Mf(c)|0;t=b;return a|0}function Ef(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;return Ua(a,b,c,d,e,f,g,h)|0}function Ff(a,b){a=a|0;b=b|0;var c=0,d=0;c=0;do{d=$g(b+(c<<2)|0)|0;f[a+(c<<2)>>2]=d;c=c+1|0}while((c|0)!=16);return}function Gf(a,b,c,d,e,f,g,h){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;h=h|0;return od(a,b,c,d,e,f,g,h)|0}function Hf(a,c){a=a|0;c=c|0;var d=0;d=a+48|0;a=d+16|0;do{b[d>>0]=b[c>>0]|0;d=d+1|0;c=c+1|0}while((d|0)<(a|0));return}function If(a,b){a=a|0;b=b|0;Wb(a,b+40|0,b);Vb(a+40|0,b+40|0,b);Rc(a+80|0,b+80|0);pa(a+120|0,b+120|0,112);return}function Jf(a,b){a=a|0;b=b|0;var c=0,d=0;c=t;d=t=t+63&-64;t=t+128|0;Vg(d,b);ud(a,d);t=c;return}function Kf(a,c){a=a|0;c=c|0;var d=0;d=a+32|0;a=d+16|0;do{b[d>>0]=b[c>>0]|0;d=d+1|0;c=c+1|0}while((d|0)<(a|0));return}function Lf(){var a=0;a=ha(30)|0;if((a|0)>0)f[8877]=a;else a=f[8877]|0;if(a>>>0<16)Fj();else{uf(35472,16);return}}function Mf(a){a=a|0;var b=0,c=0;b=t;c=t=t+63&-64;t=t+32|0;rb(c,a);a=ge(c,32)|0;t=b;return a|0}function Nf(a,b,c){a=a|0;b=b|0;c=c|0;if((c|0)<32){G=b>>c;return a>>>c|(b&(1<<c)-1)<<32-c}G=(b|0)<0?-1:0;return b>>c-32|0}function Of(a,c){a=a|0;c=c|0;var d=0,e=0;d=0;do{e=a+d|0;b[e>>0]=b[e>>0]^b[c+d>>0];d=d+1|0}while((d|0)!=8);return}function Pf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return pb(a,b,c,d,e,f,g)|0}function Qf(){var a=0,b=0;a=t;b=t=t+63&-64;t=t+16|0;Ih(b);if(f[b>>2]|0)Ih(b);t=a;return}function Rf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return Id(a,b,c,d,e,f,g)|0}function Sf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return Dd(a,b,c,d,e,f,g)|0}function Tf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;db(a,b,c,d,e,f,g)|0;return 0}function Uf(a,b){a=a|0;b=b|0;var c=0;if(b>>>0<=4294967168?(c=Cb(b)|0,(c|0)!=0):0){f[a>>2]=c;a=0}else a=12;return a|0}function Vf(a,b){a=a|0;b=b|0;var c=0;c=0;do{Mg(a+(c<<2)|0,f[b+(c<<2)>>2]|0);c=c+1|0}while((c|0)!=8);return}function Wf(a,b,c){a=a|0;b=b|0;c=c|0;if((c|0)<32){G=b<<c|(a&(1<<c)-1<<32-c)>>>32-c;return a<<c}G=a<<c-32;return 0}function Xf(a){a=a|0;var c=0,d=0;d=t;c=t=t+63&-64;t=t+32|0;rb(c,a);t=d;return b[c>>0]&1|0}function Yf(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return Kd(a,b,c,d,e,f,g)|0}function Zf(a){a=a|0;var b=0;b=na(a)|0;if(!b)return b|0;if(!(f[b+-4>>2]&3))return b|0;ec(b|0,0,a|0)|0;return b|0}function _f(){var a=0;if(!(f[8876]|0)){qi();Gi();Lf();f[8876]=1;a=0}else a=1;return a|0}function $f(a,b,c){a=a|0;b=b|0;c=c|0;if((c|0)<32){G=b>>>c;return a>>>c|(b&(1<<c)-1)<<32-c}G=0;return b>>>c-32|0}function ag(a,b,c){a=a|0;b=b|0;c=c|0;Fb(a,b,c&255);Fb(a+40|0,b+40|0,c&255);Fb(a+80|0,b+80|0,c&255);return}function bg(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return Se(a,b,c,d,e,f,g)|0}function cg(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return Db(a,b,1,c,d,e,16,f,g,0,0,2)|0}function dg(a,b,c){a=a|0;b=b|0;c=c|0;if(c>>>0<1|(c|0)==1&b>>>0<0){uf(a,b);return}else ca(35231,35251,204,35277)}function eg(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return xc(a,b,c,d,e,f,g)|0}function fg(a,b,c,d,e,f,g){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;g=g|0;return Db(a,b,1,c,d,e,16,f,g,0,0,1)|0}function gg(a){a=a|0;var c=0;c=0;while(1){if(!(b[a+c>>0]|0))break;c=c+1|0;if(c>>>0>=102){c=102;break}}return c|0}function hg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Vd(a,b,c,d,e,0,0,f)|0}function ig(a,b){a=a|0;b=b|0;var c=0;c=0;do{f[a+(c<<2)>>2]=f[b+(c<<2)>>2];c=c+1|0}while((c|0)!=16);return}function jg(a,b){a=a|0;b=b|0;pa(a,b,b+120|0);pa(a+40|0,b+40|0,b+80|0);pa(a+80|0,b+80|0,b+120|0);return}function kg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Ld(a,b,c,d,e,0,0,f)|0}function lg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;Mb(a,b,c,d,e,f,0);return 0}function mg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return pc(a,b,c,d,e,f)|0}function ng(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Oc(a,b,c,d,e,f)|0}function og(a,b){a=a|0;b=b|0;cf(a,b&4);wa(f[a+4>>2]|0);f[a+4>>2]=0;Hh(f[a>>2]|0);f[a>>2]=0;return}function pg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Dd(a,b,c,d,e,0,f)|0}function qg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Db(a,b,1,c,d,e,16,0,32,f,128,2)|0}function rg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Db(a,b,1,c,d,e,16,0,32,f,128,1)|0}function sg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Ua(a,b,c,d,e,0,0,f)|0}function tg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return Pb(a,b,c,d,e,0)|0}function ug(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;lg(a,b,c,d,e,f)|0;return 0}function vg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return xe(a,b,c,d,e)|0}function wg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return od(a,b,c,d,e,0,0,f)|0}function xg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return yd(a,b,c,d,e,f)|0}function yg(a){a=a|0;b[a+32>>0]=1;b[a+32+1>>0]=0;b[a+32+2>>0]=0;b[a+32+3>>0]=0;return}function zg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return ng(a,b,c,d,e,f)|0}function Ag(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return kg(a,b,c,d,e,f)|0}function Bg(a){a=a|0;var b=0;f[a>>2]=1;a=a+4|0;b=a+36|0;do{f[a>>2]=0;a=a+4|0}while((a|0)<(b|0));return}function Cg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return tg(a,b,c,d,e)|0}function Dg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return lc(a,b,c,d,e,f)|0}function Eg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return Ke(a,b,c,d,e)|0}function Fg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return vg(a,b,c,d,e)|0}function Gg(a,b){a=a|0;b=b|0;Ne(a)|0;if(b|0)Ja(a,33968,34,0)|0;return}function Hg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return xg(a,b,c,d,e,f)|0}function Ig(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;d=b-d-(c>>>0>a>>>0|0)>>>0;return (G=d,a-c>>>0|0)|0}function Jg(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;return Nc(a,b,c,d,e,f)|0}function Kg(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return gh(a,b,c,d)|0}function Lg(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return (G=b+d+(a+c>>>0>>>0<a>>>0|0)>>>0,a+c>>>0|0)|0}function Mg(a,c){a=a|0;c=c|0;b[a+3>>0]=c;b[a+2>>0]=c>>>8;b[a+1>>0]=c>>>16;b[a>>0]=c>>>24;return}function Ng(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return pe(a,b,c,d,e)|0}function Og(a,b){a=a|0;b=b|0;b=Kb(b&255)|0;f[a>>2]=(b|0)==0?0:b-35349|0;return ((b|0)==0)<<31>>31|0}function Pg(a){a=a|0;if(b[a+356>>0]|0)ei(a);f[a+80>>2]=-1;f[a+80+4>>2]=-1;return}function Qg(a,c){a=a|0;c=c|0;b[a>>0]=c;b[a+1>>0]=c>>8;b[a+2>>0]=c>>16;b[a+3>>0]=c>>24;return}function Rg(a,b,c){a=a|0;b=b|0;c=c|0;bg(b,32,c,32,0,0,0)|0;return Uh(a,b)|0}function Sg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;ya(a,b,c,d,e)|0;return 0}function Tg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return Eg(a,b,c,d,e)|0}function Ug(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Nb(a,b,c,d);return 0}function Vg(a,b){a=a|0;b=b|0;Rc(a,b);Rc(a+40|0,b+40|0);Rc(a+80|0,b+80|0);return}function Wg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return Nd(a,b,c,d,e)|0}function Xg(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Pe(a,b,c,d)|0;return 0}function Yg(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Ug(a,b,c,d)|0;return 0}function Zg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;Me(a,b,c,d,e)|0;return 0}function _g(a,b){a=a|0;b=b|0;uf(b,32);return Jh(a,b)|0}function $g(a){a=a|0;return (h[a+2>>0]|0)<<8|(h[a+3>>0]|0)|(h[a+1>>0]|0)<<16|(h[a>>0]|0)<<24|0}function ah(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return Kg(a,b,c,d)|0}function bh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Pa(a,b,c,d)|0;return 0}function ch(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return mb(a,b,c,d,e)|0}function dh(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return me(a,b,c,d,e)|0}function eh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Ja(a,b,c,d)|0;return 0}function fh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return Ob(a,b,c,d,2)|0}function gh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Ra(a,b,c,d);return 0}function hh(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return Ud(a,b,c,d,e)|0}function ih(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return Ob(a,b,c,d,1)|0}function jh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return Td(a,b,c,d)|0}function kh(a,b,c){a=a|0;b=b|0;c=c|0;return xd(a,b,c)|0}function lh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;eh(a,b,c,d)|0;return 0}function mh(a,b){a=a|0;b=b|0;fb(a,b);return 0-(Zb(a)|0)|0}function nh(a,b,c){a=a|0;b=b|0;c=c|0;Wg(a,b,0,35219,c)|0;return}function oh(a,b){a=a|0;b=b|0;G=f[a+-64+(b<<7)+4>>2]|0;return f[a+-64+(b<<7)>>2]|0}function ph(a){a=a|0;var b=0;b=a+40|0;do{f[a>>2]=0;a=a+4|0}while((a|0)<(b|0));return}function qh(a,b,c){a=a|0;b=b|0;c=c|0;return oe(a,b,c)|0}function rh(a){a=a|0;b[a>>0]=b[a>>0]&-8;b[a+31>>0]=b[a+31>>0]&63|64;return}function sh(a,c){a=a|0;c=c|0;a=Tb(a,c)|0;return ((b[a>>0]|0)==(c&255)<<24>>24?a:0)|0}function th(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Fa(a,b,c,d,12);return 0}function uh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Fa(a,b,c,d,8);return 0}function vh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Fa(a,b,c,d,20);return 0}function wh(a,b,c){a=a|0;b=b|0;c=c|0;Ab(a,b,c)|0;return 0}function xh(a,b,c){a=a|0;b=b|0;c=c|0;Jd(a,b,c)|0;return 0}function yh(a){a=a|0;return h[a>>0]|h[a+1>>0]<<8|h[a+2>>0]<<16|h[a+3>>0]<<24|0}function zh(a){a=a|0;Bg(a);Bg(a+40|0);Bg(a+80|0);ph(a+120|0);return}function Ah(a,b,c){a=a|0;b=b|0;c=c|0;return Qe(a,b,c)|0}function Bh(a,b,c){a=a|0;b=b|0;c=c|0;return Bf(a,b,c)|0}function Ch(a){a=a|0;var b=0;b=t;t=t+a|0;t=t+15&-16;return b|0}function Dh(a){a=a|0;b[a>>0]=0;b[a+1>>0]=0;b[a+2>>0]=0;b[a+3>>0]=0;return}function Eh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;He(a,b,c,d)|0;return 0}function Fh(a,b,c){a=a|0;b=b|0;c=c|0;rc(a,1120+(b*960|0)|0,c);return}function Gh(a){a=a|0;ph(a);Bg(a+40|0);Bg(a+80|0);ph(a+120|0);return}function Hh(a){a=a|0;var b=0;if(a|0?(b=f[a>>2]|0,b|0):0)wa(b);wa(a);return}function Ih(a){a=a|0;f[a>>2]=0;f[a+4>>2]=0;f[a+8>>2]=0;f[a+12>>2]=0;return}function Jh(a,b){a=a|0;b=b|0;return fd(a,b)|0}function Kh(a,b){a=a|0;b=b|0;return Xh(a,b)|0}function Lh(a,b){a=a|0;b=b|0;return bi(a,b)|0}function Mh(a){a=a|0;var b=0;b=f[a>>2]|0;if(b|0)wa(b);Zh(a);return}function Nh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return Da(a,b,c,d,0)|0}function Oh(a,b,c){a=a|0;b=b|0;c=c|0;return vd(a,b,c)|0}function Ph(a,b){a=a|0;b=b|0;uf(b,32);return Uh(a,b)|0}function Qh(a,b){a=a|0;b=b|0;return _g(a,b)|0}function Rh(a,b){a=a|0;b=b|0;return Kh(a,b)|0}function Sh(a){a=a|0;if((a&-7|0)==1)return;else Fj()}function Th(a,b){a=a|0;b=b|0;se(a|0,b+32|0,32)|0;return 0}function Uh(a,b){a=a|0;b=b|0;return Jh(a,b)|0}function Vh(a,b){a=a|0;b=b|0;return Lh(a,b)|0}function Wh(a){a=a|0;Bg(a);Bg(a+40|0);ph(a+80|0);return}function Xh(a,b){a=a|0;b=b|0;ab(a,b);return 0}function Yh(a,b){a=a|0;b=b|0;if(!v){v=a;w=b}}function Zh(a){a=a|0;f[a+4>>2]=0;f[a>>2]=0;f[a+8>>2]=0;return}function _h(a,b){a=a|0;b=b|0;se(a|0,b|0,32)|0;return 0}function $h(a,b,c){a=a|0;b=b|0;c=c|0;return sb(a,b,c,2)|0}function ai(a,b,c){a=a|0;b=b|0;c=c|0;return sb(a,b,c,1)|0}function bi(a,b){a=a|0;b=b|0;ic(a,b);return 0}function ci(a,b){a=a|0;b=b|0;bf(a,b)|0;return 0}function di(a){a=a|0;ph(a);Bg(a+40|0);Bg(a+80|0);return}function ei(a){a=a|0;f[a+88>>2]=-1;f[a+88+4>>2]=-1;return}function fi(a,b){a=a|0;b=b|0;return ((a|0)!=0|(b|0)!=0)&1|0}function gi(a,b){a=a|0;b=b|0;return (((b^a)&255)+-1|0)>>>31&255|0}function hi(a){a=a|0;return (a?31-(Y(a^a-1)|0)|0:32)|0}function ii(a,b){a=a|0;b=b|0;return pd(a,b,64)|0}function ji(a,b){a=a|0;b=b|0;return pd(a,b,32)|0}function ki(a,b){a=a|0;b=b|0;return pd(a,b,16)|0}function li(a,b){a=a|0;b=b|0;qb(a|0,b|0,1024)|0;return}function mi(a){a=a|0;Ne(a)|0;return 0}function ni(a,b){a=a|0;b=b|0;t=a;u=b}function oi(a,b){a=a|0;b=b|0;return a>>>(32-b|0)|a<<b|0}function pi(a){a=a|0;mi(a)|0;return 0}function qi(){Qf();return}function ri(a,b){a=a|0;b=b|0;return a<<32-b|a>>>b|0}function si(a){a=a|0;return Oe(a,(Sc(a)|0)+1|0)|0}function ti(a){a=a|0;uf(a,16);return}function ui(a){a=a|0;ec(a|0,0,1024)|0;return}function vi(){return 524288}function wi(a){a=a|0;uf(a,32);return}function xi(){return -18}function yi(){return 16777216}function zi(a){a=a|0;Zh(a);return}function Ai(a){a=a|0;Mh(a);return}function Bi(){return 32768}function Ci(){return 52}function Di(){return 33554432}function Ei(){return 35414}function Fi(){return 536870912}function Gi(){fa(1)|0;return}function Hi(){return fa(0)|0}function Ii(){return 134217728}function Ji(){return 17}function Ki(){return 102}function Li(a){a=a|0;return (a&255)>>>7|0}function Mi(){return 1073741824}function Ni(){return 67108864}function Oi(){return 12}function Pi(){return 268435456}function Qi(){return 6}function Ri(){return -2147483648}function Si(){return 34456}function Ti(){return 34383}function Ui(){return 416}function Vi(a){a=a|0;t=a}function Wi(){return 4}function Xi(){return 34303}function Yi(a){a=a|0;G=a}function Zi(){return 34401}function _i(){return 3}function $i(){return 256}function aj(){return 104}function bj(){return 384}function cj(){return 34429}function dj(){return 34412}function ej(){return 10}function fj(){return 8192}function gj(){return 34447}function hj(){return 34372}function ij(){return 34393}function jj(){return 1}function kj(){return 35342}function lj(){return 34439}function mj(){return 2}function nj(){return 34274}function oj(){return 34016}function pj(){return 208}function qj(){return 128}function rj(){return -1}function sj(){return 34281}function tj(){return 34030}function uj(){return 34289}function vj(){return 8}function wj(){return 24}function xj(){return G|0}function yj(){return 48}function zj(){return 16}function Aj(){return 36008}function Bj(){return t|0}function Cj(){return 64}function Dj(){return 32}function Ej(){return 0}function Fj(){ea()} | |
20574 | ||
20575 | // EMSCRIPTEN_END_FUNCS | |
20576 | return{___errno_location:Aj,___muldi3:Af,___udivdi3:Nh,___uremdi3:pf,_bitshift64Ashr:Nf,_bitshift64Lshr:$f,_bitshift64Shl:Wf,_crypto_aead_chacha20poly1305_abytes:zj,_crypto_aead_chacha20poly1305_decrypt:wc,_crypto_aead_chacha20poly1305_decrypt_detached:Jb,_crypto_aead_chacha20poly1305_encrypt:nd,_crypto_aead_chacha20poly1305_encrypt_detached:Xb,_crypto_aead_chacha20poly1305_ietf_abytes:zj,_crypto_aead_chacha20poly1305_ietf_decrypt:tc,_crypto_aead_chacha20poly1305_ietf_decrypt_detached:wb,_crypto_aead_chacha20poly1305_ietf_encrypt:id,_crypto_aead_chacha20poly1305_ietf_encrypt_detached:Ib,_crypto_aead_chacha20poly1305_ietf_keybytes:Dj,_crypto_aead_chacha20poly1305_ietf_keygen:wi,_crypto_aead_chacha20poly1305_ietf_npubbytes:Oi,_crypto_aead_chacha20poly1305_ietf_nsecbytes:Ej,_crypto_aead_chacha20poly1305_keybytes:Dj,_crypto_aead_chacha20poly1305_keygen:wi,_crypto_aead_chacha20poly1305_npubbytes:vj,_crypto_aead_chacha20poly1305_nsecbytes:Ej,_crypto_aead_xchacha20poly1305_ietf_abytes:zj,_crypto_aead_xchacha20poly1305_ietf_decrypt:sc,_crypto_aead_xchacha20poly1305_ietf_decrypt_detached:qc,_crypto_aead_xchacha20poly1305_ietf_encrypt:gd,_crypto_aead_xchacha20poly1305_ietf_encrypt_detached:oc,_crypto_aead_xchacha20poly1305_ietf_keybytes:Dj,_crypto_aead_xchacha20poly1305_ietf_keygen:wi,_crypto_aead_xchacha20poly1305_ietf_npubbytes:wj,_crypto_aead_xchacha20poly1305_ietf_nsecbytes:Ej,_crypto_auth:Zg,_crypto_auth_bytes:Dj,_crypto_auth_hmacsha256:Je,_crypto_auth_hmacsha256_bytes:Dj,_crypto_auth_hmacsha256_final:Ve,_crypto_auth_hmacsha256_init:Bb,_crypto_auth_hmacsha256_keybytes:Dj,_crypto_auth_hmacsha256_keygen:wi,_crypto_auth_hmacsha256_statebytes:pj,_crypto_auth_hmacsha256_update:bh,_crypto_auth_hmacsha256_verify:ue,_crypto_auth_hmacsha512:Le,_crypto_auth_hmacsha512256:Me,_crypto_auth_hmacsha512256_bytes:Dj,_crypto_auth_hmacsha512256_final:Fe,_crypto_auth_hmacsha512256_init:wh,_crypto_auth_hmacsha512256_keybytes:Dj,_crypto_auth_hmacsha512256_keygen:wi,_crypto_auth_hmacsha512256_statebytes:Ui,_crypto_auth_hmacsha512256_update:lh,_crypto_auth_hmacsha512256_verify:pe,_crypto_auth_hmacsha512_bytes:Cj,_crypto_auth_hmacsha512_final:Ue,_crypto_auth_hmacsha512_init:Ab,_crypto_auth_hmacsha512_keybytes:Dj,_crypto_auth_hmacsha512_keygen:wi,_crypto_auth_hmacsha512_statebytes:Ui,_crypto_auth_hmacsha512_update:eh,_crypto_auth_hmacsha512_verify:te,_crypto_auth_keybytes:Dj,_crypto_auth_keygen:wi,_crypto_auth_primitive:oj,_crypto_auth_verify:Ng,_crypto_box:Yf,_crypto_box_afternm:Hg,_crypto_box_beforenm:qh,_crypto_box_beforenmbytes:Dj,_crypto_box_boxzerobytes:zj,_crypto_box_curve25519xchacha20poly1305_beforenm:ne,_crypto_box_curve25519xchacha20poly1305_beforenmbytes:Dj,_crypto_box_curve25519xchacha20poly1305_detached:md,_crypto_box_curve25519xchacha20poly1305_detached_afternm:qf,_crypto_box_curve25519xchacha20poly1305_easy:qe,_crypto_box_curve25519xchacha20poly1305_easy_afternm:re,_crypto_box_curve25519xchacha20poly1305_keypair:_g,_crypto_box_curve25519xchacha20poly1305_macbytes:zj,_crypto_box_curve25519xchacha20poly1305_noncebytes:wj,_crypto_box_curve25519xchacha20poly1305_open_detached:ld,_crypto_box_curve25519xchacha20poly1305_open_detached_afternm:mf,_crypto_box_curve25519xchacha20poly1305_open_easy:_d,_crypto_box_curve25519xchacha20poly1305_open_easy_afternm:ae,_crypto_box_curve25519xchacha20poly1305_publickeybytes:Dj,_crypto_box_curve25519xchacha20poly1305_seal:Bc,_crypto_box_curve25519xchacha20poly1305_seal_open:kd,_crypto_box_curve25519xchacha20poly1305_sealbytes:yj,_crypto_box_curve25519xchacha20poly1305_secretkeybytes:Dj,_crypto_box_curve25519xchacha20poly1305_seed_keypair:xd,_crypto_box_curve25519xchacha20poly1305_seedbytes:Dj,_crypto_box_curve25519xsalsa20poly1305:Kd,_crypto_box_curve25519xsalsa20poly1305_afternm:xg,_crypto_box_curve25519xsalsa20poly1305_beforenm:oe,_crypto_box_curve25519xsalsa20poly1305_beforenmbytes:Dj,_crypto_box_curve25519xsalsa20poly1305_boxzerobytes:zj,_crypto_box_curve25519xsalsa20poly1305_keypair:_g,_crypto_box_curve25519xsalsa20poly1305_macbytes:zj,_crypto_box_curve25519xsalsa20poly1305_noncebytes:wj,_crypto_box_curve25519xsalsa20poly1305_open:Id,_crypto_box_curve25519xsalsa20poly1305_open_afternm:ng,_crypto_box_curve25519xsalsa20poly1305_publickeybytes:Dj,_crypto_box_curve25519xsalsa20poly1305_secretkeybytes:Dj,_crypto_box_curve25519xsalsa20poly1305_seed_keypair:xd,_crypto_box_curve25519xsalsa20poly1305_seedbytes:Dj,_crypto_box_curve25519xsalsa20poly1305_zerobytes:Dj,_crypto_box_detached:Zd,_crypto_box_detached_afternm:Tf,_crypto_box_easy:Xe,_crypto_box_easy_afternm:Ye,_crypto_box_keypair:Qh,_crypto_box_macbytes:zj,_crypto_box_noncebytes:wj,_crypto_box_open:Rf,_crypto_box_open_afternm:zg,_crypto_box_open_detached:Yd,_crypto_box_open_detached_afternm:Pf,_crypto_box_open_easy:ve,_crypto_box_open_easy_afternm:ze,_crypto_box_primitive:tj,_crypto_box_publickeybytes:Dj,_crypto_box_seal:Tc,_crypto_box_seal_open:Cd,_crypto_box_sealbytes:yj,_crypto_box_secretkeybytes:Dj,_crypto_box_seed_keypair:kh,_crypto_box_seedbytes:Dj,_crypto_box_zerobytes:Dj,_crypto_core_ed25519_add:bd,_crypto_core_ed25519_bytes:Dj,_crypto_core_ed25519_from_uniform:mh,_crypto_core_ed25519_is_valid_point:Qd,_crypto_core_ed25519_sub:ad,_crypto_core_ed25519_uniformbytes:Dj,_crypto_core_hchacha20:Ha,_crypto_core_hchacha20_constbytes:zj,_crypto_core_hchacha20_inputbytes:zj,_crypto_core_hchacha20_keybytes:Dj,_crypto_core_hchacha20_outputbytes:Dj,_crypto_core_hsalsa20:La,_crypto_core_hsalsa20_constbytes:zj,_crypto_core_hsalsa20_inputbytes:zj,_crypto_core_hsalsa20_keybytes:Dj,_crypto_core_hsalsa20_outputbytes:Dj,_crypto_core_salsa20:vh,_crypto_core_salsa2012:th,_crypto_core_salsa2012_constbytes:zj,_crypto_core_salsa2012_inputbytes:zj,_crypto_core_salsa2012_keybytes:Dj,_crypto_core_salsa2012_outputbytes:Cj,_crypto_core_salsa208:uh,_crypto_core_salsa208_constbytes:zj,_crypto_core_salsa208_inputbytes:zj,_crypto_core_salsa208_keybytes:Dj,_crypto_core_salsa208_outputbytes:Cj,_crypto_core_salsa20_constbytes:zj,_crypto_core_salsa20_inputbytes:zj,_crypto_core_salsa20_keybytes:Dj,_crypto_core_salsa20_outputbytes:Cj,_crypto_generichash:bg,_crypto_generichash_blake2b:Se,_crypto_generichash_blake2b_bytes:Dj,_crypto_generichash_blake2b_bytes_max:Cj,_crypto_generichash_blake2b_bytes_min:zj,_crypto_generichash_blake2b_final:Bf,_crypto_generichash_blake2b_init:Td,_crypto_generichash_blake2b_init_salt_personal:wd,_crypto_generichash_blake2b_keybytes:Dj,_crypto_generichash_blake2b_keybytes_max:Cj,_crypto_generichash_blake2b_keybytes_min:zj,_crypto_generichash_blake2b_keygen:wi,_crypto_generichash_blake2b_personalbytes:zj,_crypto_generichash_blake2b_salt_personal:he,_crypto_generichash_blake2b_saltbytes:zj,_crypto_generichash_blake2b_statebytes:bj,_crypto_generichash_blake2b_update:Ug,_crypto_generichash_bytes:Dj,_crypto_generichash_bytes_max:Cj,_crypto_generichash_bytes_min:zj,_crypto_generichash_final:Bh,_crypto_generichash_init:jh,_crypto_generichash_keybytes:Dj,_crypto_generichash_keybytes_max:Cj,_crypto_generichash_keybytes_min:zj,_crypto_generichash_keygen:wi,_crypto_generichash_primitive:sj,_crypto_generichash_statebytes:bj,_crypto_generichash_update:Yg,_crypto_hash:Eh,_crypto_hash_bytes:Cj,_crypto_hash_primitive:nj,_crypto_hash_sha256:Ie,_crypto_hash_sha256_bytes:Dj,_crypto_hash_sha256_final:gf,_crypto_hash_sha256_init:de,_crypto_hash_sha256_statebytes:aj,_crypto_hash_sha256_update:Pa,_crypto_hash_sha512:He,_crypto_hash_sha512_bytes:Cj,_crypto_hash_sha512_final:df,_crypto_hash_sha512_init:Ne,_crypto_hash_sha512_statebytes:pj,_crypto_hash_sha512_update:Ja,_crypto_kdf_blake2b_bytes_max:Cj,_crypto_kdf_blake2b_bytes_min:zj,_crypto_kdf_blake2b_contextbytes:vj,_crypto_kdf_blake2b_derive_from_key:pc,_crypto_kdf_blake2b_keybytes:Dj,_crypto_kdf_bytes_max:Cj,_crypto_kdf_bytes_min:zj,_crypto_kdf_contextbytes:vj,_crypto_kdf_derive_from_key:mg,_crypto_kdf_keybytes:Dj,_crypto_kdf_keygen:wi,_crypto_kdf_primitive:sj,_crypto_kx_client_session_keys:ac,_crypto_kx_keypair:Ph,_crypto_kx_primitive:uj,_crypto_kx_publickeybytes:Dj,_crypto_kx_secretkeybytes:Dj,_crypto_kx_seed_keypair:Rg,_crypto_kx_seedbytes:Dj,_crypto_kx_server_session_keys:$b,_crypto_kx_sessionkeybytes:Dj,_crypto_onetimeauth:Tg,_crypto_onetimeauth_bytes:zj,_crypto_onetimeauth_final:Rh,_crypto_onetimeauth_init:Vh,_crypto_onetimeauth_keybytes:Dj,_crypto_onetimeauth_keygen:wi,_crypto_onetimeauth_poly1305:Eg,_crypto_onetimeauth_poly1305_bytes:zj,_crypto_onetimeauth_poly1305_final:Kh,_crypto_onetimeauth_poly1305_init:Lh,_crypto_onetimeauth_poly1305_keybytes:Dj,_crypto_onetimeauth_poly1305_keygen:wi,_crypto_onetimeauth_poly1305_statebytes:$i,_crypto_onetimeauth_poly1305_update:Kg,_crypto_onetimeauth_poly1305_verify:vg,_crypto_onetimeauth_primitive:Xi,_crypto_onetimeauth_statebytes:$i,_crypto_onetimeauth_update:ah,_crypto_onetimeauth_verify:Fg,_crypto_pwhash:Ad,_crypto_pwhash_alg_argon2i13:jj,_crypto_pwhash_alg_argon2id13:mj,_crypto_pwhash_alg_default:mj,_crypto_pwhash_argon2i:dc,_crypto_pwhash_argon2i_alg_argon2i13:jj,_crypto_pwhash_argon2i_bytes_max:rj,_crypto_pwhash_argon2i_bytes_min:zj,_crypto_pwhash_argon2i_memlimit_interactive:Di,_crypto_pwhash_argon2i_memlimit_max:Ri,_crypto_pwhash_argon2i_memlimit_min:fj,_crypto_pwhash_argon2i_memlimit_moderate:Ii,_crypto_pwhash_argon2i_memlimit_sensitive:Fi,_crypto_pwhash_argon2i_opslimit_interactive:Wi,_crypto_pwhash_argon2i_opslimit_max:rj,_crypto_pwhash_argon2i_opslimit_min:_i,_crypto_pwhash_argon2i_opslimit_moderate:Qi,_crypto_pwhash_argon2i_opslimit_sensitive:vj,_crypto_pwhash_argon2i_passwd_max:rj,_crypto_pwhash_argon2i_passwd_min:Ej,_crypto_pwhash_argon2i_saltbytes:zj,_crypto_pwhash_argon2i_str:uc,_crypto_pwhash_argon2i_str_needs_rehash:ih,_crypto_pwhash_argon2i_str_verify:Rd,_crypto_pwhash_argon2i_strbytes:qj,_crypto_pwhash_argon2i_strprefix:Ti,_crypto_pwhash_argon2id:fc,_crypto_pwhash_argon2id_alg_argon2id13:mj,_crypto_pwhash_argon2id_bytes_max:rj,_crypto_pwhash_argon2id_bytes_min:zj,_crypto_pwhash_argon2id_memlimit_interactive:Ni,_crypto_pwhash_argon2id_memlimit_max:Ri,_crypto_pwhash_argon2id_memlimit_min:fj,_crypto_pwhash_argon2id_memlimit_moderate:Pi,_crypto_pwhash_argon2id_memlimit_sensitive:Mi,_crypto_pwhash_argon2id_opslimit_interactive:mj,_crypto_pwhash_argon2id_opslimit_max:rj,_crypto_pwhash_argon2id_opslimit_min:jj,_crypto_pwhash_argon2id_opslimit_moderate:_i,_crypto_pwhash_argon2id_opslimit_sensitive:Wi,_crypto_pwhash_argon2id_passwd_max:rj,_crypto_pwhash_argon2id_passwd_min:Ej,_crypto_pwhash_argon2id_saltbytes:zj,_crypto_pwhash_argon2id_str:xc,_crypto_pwhash_argon2id_str_needs_rehash:fh,_crypto_pwhash_argon2id_str_verify:Od,_crypto_pwhash_argon2id_strbytes:qj,_crypto_pwhash_argon2id_strprefix:hj,_crypto_pwhash_bytes_max:rj,_crypto_pwhash_bytes_min:zj,_crypto_pwhash_memlimit_interactive:Ni,_crypto_pwhash_memlimit_max:Ri,_crypto_pwhash_memlimit_min:fj,_crypto_pwhash_memlimit_moderate:Pi,_crypto_pwhash_memlimit_sensitive:Mi,_crypto_pwhash_opslimit_interactive:mj,_crypto_pwhash_opslimit_max:rj,_crypto_pwhash_opslimit_min:jj,_crypto_pwhash_opslimit_moderate:_i,_crypto_pwhash_opslimit_sensitive:Wi,_crypto_pwhash_passwd_max:rj,_crypto_pwhash_passwd_min:Ej,_crypto_pwhash_primitive:ij,_crypto_pwhash_saltbytes:zj,_crypto_pwhash_scryptsalsa208sha256:jc,_crypto_pwhash_scryptsalsa208sha256_bytes_max:rj,_crypto_pwhash_scryptsalsa208sha256_bytes_min:zj,_crypto_pwhash_scryptsalsa208sha256_ll:Hd,_crypto_pwhash_scryptsalsa208sha256_memlimit_interactive:yi,_crypto_pwhash_scryptsalsa208sha256_memlimit_max:rj,_crypto_pwhash_scryptsalsa208sha256_memlimit_min:yi,_crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive:Mi,_crypto_pwhash_scryptsalsa208sha256_opslimit_interactive:vi,_crypto_pwhash_scryptsalsa208sha256_opslimit_max:rj,_crypto_pwhash_scryptsalsa208sha256_opslimit_min:Bi,_crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive:Di,_crypto_pwhash_scryptsalsa208sha256_passwd_max:rj,_crypto_pwhash_scryptsalsa208sha256_passwd_min:Ej,_crypto_pwhash_scryptsalsa208sha256_saltbytes:Dj,_crypto_pwhash_scryptsalsa208sha256_str:Ub,_crypto_pwhash_scryptsalsa208sha256_str_needs_rehash:Hc,_crypto_pwhash_scryptsalsa208sha256_str_verify:Qc,_crypto_pwhash_scryptsalsa208sha256_strbytes:Ki,_crypto_pwhash_scryptsalsa208sha256_strprefix:Ei,_crypto_pwhash_str:eg,_crypto_pwhash_str_alg:Sd,_crypto_pwhash_str_needs_rehash:Md,_crypto_pwhash_str_verify:Xd,_crypto_pwhash_strbytes:qj,_crypto_pwhash_strprefix:hj,_crypto_scalarmult:Oh,_crypto_scalarmult_base:Uh,_crypto_scalarmult_bytes:Dj,_crypto_scalarmult_curve25519:vd,_crypto_scalarmult_curve25519_base:Jh,_crypto_scalarmult_curve25519_bytes:Dj,_crypto_scalarmult_curve25519_scalarbytes:Dj,_crypto_scalarmult_ed25519:Cc,_crypto_scalarmult_ed25519_base:Fd,_crypto_scalarmult_ed25519_bytes:Dj,_crypto_scalarmult_ed25519_scalarbytes:Dj,_crypto_scalarmult_primitive:Zi,_crypto_scalarmult_scalarbytes:Dj,_crypto_secretbox:xg,_crypto_secretbox_boxzerobytes:zj,_crypto_secretbox_detached:db,_crypto_secretbox_easy:_e,_crypto_secretbox_keybytes:Dj,_crypto_secretbox_keygen:wi,_crypto_secretbox_macbytes:zj,_crypto_secretbox_noncebytes:wj,_crypto_secretbox_open:ng,_crypto_secretbox_open_detached:pb,_crypto_secretbox_open_easy:De,_crypto_secretbox_primitive:dj,_crypto_secretbox_xchacha20poly1305_detached:bb,_crypto_secretbox_xchacha20poly1305_easy:Ee,_crypto_secretbox_xchacha20poly1305_keybytes:Dj,_crypto_secretbox_xchacha20poly1305_macbytes:zj,_crypto_secretbox_xchacha20poly1305_noncebytes:wj,_crypto_secretbox_xchacha20poly1305_open_detached:nb,_crypto_secretbox_xchacha20poly1305_open_easy:ke,_crypto_secretbox_xsalsa20poly1305:yd,_crypto_secretbox_xsalsa20poly1305_boxzerobytes:zj,_crypto_secretbox_xsalsa20poly1305_keybytes:Dj,_crypto_secretbox_xsalsa20poly1305_keygen:wi,_crypto_secretbox_xsalsa20poly1305_macbytes:zj,_crypto_secretbox_xsalsa20poly1305_noncebytes:wj,_crypto_secretbox_xsalsa20poly1305_open:Oc,_crypto_secretbox_xsalsa20poly1305_zerobytes:Dj,_crypto_secretbox_zerobytes:Dj,_crypto_secretstream_xchacha20poly1305_abytes:Ji,_crypto_secretstream_xchacha20poly1305_headerbytes:wj,_crypto_secretstream_xchacha20poly1305_init_pull:_b,_crypto_secretstream_xchacha20poly1305_init_push:Yb,_crypto_secretstream_xchacha20poly1305_keybytes:Dj,_crypto_secretstream_xchacha20poly1305_keygen:wi,_crypto_secretstream_xchacha20poly1305_messagebytes_max:xi,_crypto_secretstream_xchacha20poly1305_pull:Na,_crypto_secretstream_xchacha20poly1305_push:_a,_crypto_secretstream_xchacha20poly1305_rekey:Gb,_crypto_secretstream_xchacha20poly1305_statebytes:Ci,_crypto_secretstream_xchacha20poly1305_tag_final:_i,_crypto_secretstream_xchacha20poly1305_tag_message:Ej,_crypto_secretstream_xchacha20poly1305_tag_push:jj,_crypto_secretstream_xchacha20poly1305_tag_rekey:mj,_crypto_shorthash:Sg,_crypto_shorthash_bytes:vj,_crypto_shorthash_keybytes:zj,_crypto_shorthash_keygen:ti,_crypto_shorthash_primitive:cj,_crypto_shorthash_siphash24:ya,_crypto_shorthash_siphash24_bytes:vj,_crypto_shorthash_siphash24_keybytes:zj,_crypto_shorthash_siphashx24:va,_crypto_shorthash_siphashx24_bytes:zj,_crypto_shorthash_siphashx24_keybytes:zj,_crypto_sign:Jg,_crypto_sign_bytes:Cj,_crypto_sign_detached:ug,_crypto_sign_ed25519:Nc,_crypto_sign_ed25519_bytes:Cj,_crypto_sign_ed25519_detached:lg,_crypto_sign_ed25519_keypair:bf,_crypto_sign_ed25519_open:lc,_crypto_sign_ed25519_pk_to_curve25519:Zc,_crypto_sign_ed25519_publickeybytes:Dj,_crypto_sign_ed25519_secretkeybytes:Cj,_crypto_sign_ed25519_seed_keypair:Jd,_crypto_sign_ed25519_seedbytes:Dj,_crypto_sign_ed25519_sk_to_curve25519:Bd,_crypto_sign_ed25519_sk_to_pk:Th,_crypto_sign_ed25519_sk_to_seed:_h,_crypto_sign_ed25519_verify_detached:tg,_crypto_sign_ed25519ph_final_create:Pe,_crypto_sign_ed25519ph_final_verify:Qe,_crypto_sign_ed25519ph_init:mi,_crypto_sign_ed25519ph_statebytes:pj,_crypto_sign_ed25519ph_update:eh,_crypto_sign_final_create:Xg,_crypto_sign_final_verify:Ah,_crypto_sign_init:pi,_crypto_sign_keypair:ci,_crypto_sign_open:Dg,_crypto_sign_primitive:lj,_crypto_sign_publickeybytes:Dj,_crypto_sign_secretkeybytes:Cj,_crypto_sign_seed_keypair:xh,_crypto_sign_seedbytes:Dj,_crypto_sign_statebytes:pj,_crypto_sign_update:lh,_crypto_sign_verify_detached:Cg,_crypto_stream:dh,_crypto_stream_chacha20:hh,_crypto_stream_chacha20_ietf:Wg,_crypto_stream_chacha20_ietf_keybytes:Dj,_crypto_stream_chacha20_ietf_keygen:wi,_crypto_stream_chacha20_ietf_noncebytes:Oi,_crypto_stream_chacha20_ietf_xor:pg,_crypto_stream_chacha20_ietf_xor_ic:Sf,_crypto_stream_chacha20_keybytes:Dj,_crypto_stream_chacha20_keygen:wi,_crypto_stream_chacha20_noncebytes:vj,_crypto_stream_chacha20_xor:wg,_crypto_stream_chacha20_xor_ic:Gf,_crypto_stream_keybytes:Dj,_crypto_stream_keygen:wi,_crypto_stream_noncebytes:wj,_crypto_stream_primitive:gj,_crypto_stream_salsa20:ch,_crypto_stream_salsa2012:kb,_crypto_stream_salsa2012_keybytes:Dj,_crypto_stream_salsa2012_keygen:wi,_crypto_stream_salsa2012_noncebytes:vj,_crypto_stream_salsa2012_xor:Wa,_crypto_stream_salsa208:lb,_crypto_stream_salsa208_keybytes:Dj,_crypto_stream_salsa208_keygen:wi,_crypto_stream_salsa208_messagebytes_max:rj,_crypto_stream_salsa208_noncebytes:vj,_crypto_stream_salsa208_xor:Xa,_crypto_stream_salsa20_keybytes:Dj,_crypto_stream_salsa20_keygen:wi,_crypto_stream_salsa20_noncebytes:vj,_crypto_stream_salsa20_xor:sg,_crypto_stream_salsa20_xor_ic:Ef,_crypto_stream_xchacha20:Ce,_crypto_stream_xchacha20_keybytes:Dj,_crypto_stream_xchacha20_keygen:wi,_crypto_stream_xchacha20_noncebytes:wj,_crypto_stream_xchacha20_xor:hg,_crypto_stream_xchacha20_xor_ic:Vd,_crypto_stream_xor:Ag,_crypto_stream_xsalsa20:me,_crypto_stream_xsalsa20_keybytes:Dj,_crypto_stream_xsalsa20_keygen:wi,_crypto_stream_xsalsa20_noncebytes:wj,_crypto_stream_xsalsa20_xor:kg,_crypto_stream_xsalsa20_xor_ic:Ld,_crypto_verify_16:ki,_crypto_verify_16_bytes:zj,_crypto_verify_32:ji,_crypto_verify_32_bytes:Dj,_crypto_verify_64:ii,_crypto_verify_64_bytes:Cj,_emscripten_replace_memory:ja,_free:wa,_i64Add:Lg,_i64Subtract:Ig,_malloc:na,_memcpy:qb,_memmove:se,_memset:ec,_randombytes:dg,_randombytes_buf:uf,_randombytes_buf_deterministic:nh,_randombytes_close:Ej,_randombytes_implementation_name:Si,_randombytes_random:Hi,_randombytes_seedbytes:Dj,_randombytes_stir:Gi,_randombytes_uniform:kf,_sbrk:be,_sodium_base642bin:Ka,_sodium_base64_encoded_len:lf,_sodium_bin2base64:Ta,_sodium_bin2hex:dd,_sodium_hex2bin:jb,_sodium_init:_f,_sodium_library_minimal:Ej,_sodium_library_version_major:ej,_sodium_library_version_minor:jj,_sodium_pad:hc,_sodium_unpad:Fc,_sodium_version_string:kj,establishStackSpace:ni,getTempRet0:xj,runPostSets:ee,setTempRet0:Yi,setThrew:Yh,stackAlloc:Ch,stackRestore:Vi,stackSave:Bj}}) | |
20577 | ||
20578 | ||
20579 | // EMSCRIPTEN_END_ASM | |
20580 | (Module.asmGlobalArg,Module.asmLibraryArg,buffer);var ___errno_location=Module["___errno_location"]=asm["___errno_location"];var ___muldi3=Module["___muldi3"]=asm["___muldi3"];var ___udivdi3=Module["___udivdi3"]=asm["___udivdi3"];var ___uremdi3=Module["___uremdi3"]=asm["___uremdi3"];var _bitshift64Ashr=Module["_bitshift64Ashr"]=asm["_bitshift64Ashr"];var _bitshift64Lshr=Module["_bitshift64Lshr"]=asm["_bitshift64Lshr"];var _bitshift64Shl=Module["_bitshift64Shl"]=asm["_bitshift64Shl"];var _crypto_aead_chacha20poly1305_abytes=Module["_crypto_aead_chacha20poly1305_abytes"]=asm["_crypto_aead_chacha20poly1305_abytes"];var _crypto_aead_chacha20poly1305_decrypt=Module["_crypto_aead_chacha20poly1305_decrypt"]=asm["_crypto_aead_chacha20poly1305_decrypt"];var _crypto_aead_chacha20poly1305_decrypt_detached=Module["_crypto_aead_chacha20poly1305_decrypt_detached"]=asm["_crypto_aead_chacha20poly1305_decrypt_detached"];var _crypto_aead_chacha20poly1305_encrypt=Module["_crypto_aead_chacha20poly1305_encrypt"]=asm["_crypto_aead_chacha20poly1305_encrypt"];var _crypto_aead_chacha20poly1305_encrypt_detached=Module["_crypto_aead_chacha20poly1305_encrypt_detached"]=asm["_crypto_aead_chacha20poly1305_encrypt_detached"];var _crypto_aead_chacha20poly1305_ietf_abytes=Module["_crypto_aead_chacha20poly1305_ietf_abytes"]=asm["_crypto_aead_chacha20poly1305_ietf_abytes"];var _crypto_aead_chacha20poly1305_ietf_decrypt=Module["_crypto_aead_chacha20poly1305_ietf_decrypt"]=asm["_crypto_aead_chacha20poly1305_ietf_decrypt"];var _crypto_aead_chacha20poly1305_ietf_decrypt_detached=Module["_crypto_aead_chacha20poly1305_ietf_decrypt_detached"]=asm["_crypto_aead_chacha20poly1305_ietf_decrypt_detached"];var _crypto_aead_chacha20poly1305_ietf_encrypt=Module["_crypto_aead_chacha20poly1305_ietf_encrypt"]=asm["_crypto_aead_chacha20poly1305_ietf_encrypt"];var _crypto_aead_chacha20poly1305_ietf_encrypt_detached=Module["_crypto_aead_chacha20poly1305_ietf_encrypt_detached"]=asm["_crypto_aead_chacha20poly1305_ietf_encrypt_detached"];var _crypto_aead_chacha20poly1305_ietf_keybytes=Module["_crypto_aead_chacha20poly1305_ietf_keybytes"]=asm["_crypto_aead_chacha20poly1305_ietf_keybytes"];var _crypto_aead_chacha20poly1305_ietf_keygen=Module["_crypto_aead_chacha20poly1305_ietf_keygen"]=asm["_crypto_aead_chacha20poly1305_ietf_keygen"];var _crypto_aead_chacha20poly1305_ietf_npubbytes=Module["_crypto_aead_chacha20poly1305_ietf_npubbytes"]=asm["_crypto_aead_chacha20poly1305_ietf_npubbytes"];var _crypto_aead_chacha20poly1305_ietf_nsecbytes=Module["_crypto_aead_chacha20poly1305_ietf_nsecbytes"]=asm["_crypto_aead_chacha20poly1305_ietf_nsecbytes"];var _crypto_aead_chacha20poly1305_keybytes=Module["_crypto_aead_chacha20poly1305_keybytes"]=asm["_crypto_aead_chacha20poly1305_keybytes"];var _crypto_aead_chacha20poly1305_keygen=Module["_crypto_aead_chacha20poly1305_keygen"]=asm["_crypto_aead_chacha20poly1305_keygen"];var _crypto_aead_chacha20poly1305_npubbytes=Module["_crypto_aead_chacha20poly1305_npubbytes"]=asm["_crypto_aead_chacha20poly1305_npubbytes"];var _crypto_aead_chacha20poly1305_nsecbytes=Module["_crypto_aead_chacha20poly1305_nsecbytes"]=asm["_crypto_aead_chacha20poly1305_nsecbytes"];var _crypto_aead_xchacha20poly1305_ietf_abytes=Module["_crypto_aead_xchacha20poly1305_ietf_abytes"]=asm["_crypto_aead_xchacha20poly1305_ietf_abytes"];var _crypto_aead_xchacha20poly1305_ietf_decrypt=Module["_crypto_aead_xchacha20poly1305_ietf_decrypt"]=asm["_crypto_aead_xchacha20poly1305_ietf_decrypt"];var _crypto_aead_xchacha20poly1305_ietf_decrypt_detached=Module["_crypto_aead_xchacha20poly1305_ietf_decrypt_detached"]=asm["_crypto_aead_xchacha20poly1305_ietf_decrypt_detached"];var _crypto_aead_xchacha20poly1305_ietf_encrypt=Module["_crypto_aead_xchacha20poly1305_ietf_encrypt"]=asm["_crypto_aead_xchacha20poly1305_ietf_encrypt"];var _crypto_aead_xchacha20poly1305_ietf_encrypt_detached=Module["_crypto_aead_xchacha20poly1305_ietf_encrypt_detached"]=asm["_crypto_aead_xchacha20poly1305_ietf_encrypt_detached"];var _crypto_aead_xchacha20poly1305_ietf_keybytes=Module["_crypto_aead_xchacha20poly1305_ietf_keybytes"]=asm["_crypto_aead_xchacha20poly1305_ietf_keybytes"];var _crypto_aead_xchacha20poly1305_ietf_keygen=Module["_crypto_aead_xchacha20poly1305_ietf_keygen"]=asm["_crypto_aead_xchacha20poly1305_ietf_keygen"];var _crypto_aead_xchacha20poly1305_ietf_npubbytes=Module["_crypto_aead_xchacha20poly1305_ietf_npubbytes"]=asm["_crypto_aead_xchacha20poly1305_ietf_npubbytes"];var _crypto_aead_xchacha20poly1305_ietf_nsecbytes=Module["_crypto_aead_xchacha20poly1305_ietf_nsecbytes"]=asm["_crypto_aead_xchacha20poly1305_ietf_nsecbytes"];var _crypto_auth=Module["_crypto_auth"]=asm["_crypto_auth"];var _crypto_auth_bytes=Module["_crypto_auth_bytes"]=asm["_crypto_auth_bytes"];var _crypto_auth_hmacsha256=Module["_crypto_auth_hmacsha256"]=asm["_crypto_auth_hmacsha256"];var _crypto_auth_hmacsha256_bytes=Module["_crypto_auth_hmacsha256_bytes"]=asm["_crypto_auth_hmacsha256_bytes"];var _crypto_auth_hmacsha256_final=Module["_crypto_auth_hmacsha256_final"]=asm["_crypto_auth_hmacsha256_final"];var _crypto_auth_hmacsha256_init=Module["_crypto_auth_hmacsha256_init"]=asm["_crypto_auth_hmacsha256_init"];var _crypto_auth_hmacsha256_keybytes=Module["_crypto_auth_hmacsha256_keybytes"]=asm["_crypto_auth_hmacsha256_keybytes"];var _crypto_auth_hmacsha256_keygen=Module["_crypto_auth_hmacsha256_keygen"]=asm["_crypto_auth_hmacsha256_keygen"];var _crypto_auth_hmacsha256_statebytes=Module["_crypto_auth_hmacsha256_statebytes"]=asm["_crypto_auth_hmacsha256_statebytes"];var _crypto_auth_hmacsha256_update=Module["_crypto_auth_hmacsha256_update"]=asm["_crypto_auth_hmacsha256_update"];var _crypto_auth_hmacsha256_verify=Module["_crypto_auth_hmacsha256_verify"]=asm["_crypto_auth_hmacsha256_verify"];var _crypto_auth_hmacsha512=Module["_crypto_auth_hmacsha512"]=asm["_crypto_auth_hmacsha512"];var _crypto_auth_hmacsha512256=Module["_crypto_auth_hmacsha512256"]=asm["_crypto_auth_hmacsha512256"];var _crypto_auth_hmacsha512256_bytes=Module["_crypto_auth_hmacsha512256_bytes"]=asm["_crypto_auth_hmacsha512256_bytes"];var _crypto_auth_hmacsha512256_final=Module["_crypto_auth_hmacsha512256_final"]=asm["_crypto_auth_hmacsha512256_final"];var _crypto_auth_hmacsha512256_init=Module["_crypto_auth_hmacsha512256_init"]=asm["_crypto_auth_hmacsha512256_init"];var _crypto_auth_hmacsha512256_keybytes=Module["_crypto_auth_hmacsha512256_keybytes"]=asm["_crypto_auth_hmacsha512256_keybytes"];var _crypto_auth_hmacsha512256_keygen=Module["_crypto_auth_hmacsha512256_keygen"]=asm["_crypto_auth_hmacsha512256_keygen"];var _crypto_auth_hmacsha512256_statebytes=Module["_crypto_auth_hmacsha512256_statebytes"]=asm["_crypto_auth_hmacsha512256_statebytes"];var _crypto_auth_hmacsha512256_update=Module["_crypto_auth_hmacsha512256_update"]=asm["_crypto_auth_hmacsha512256_update"];var _crypto_auth_hmacsha512256_verify=Module["_crypto_auth_hmacsha512256_verify"]=asm["_crypto_auth_hmacsha512256_verify"];var _crypto_auth_hmacsha512_bytes=Module["_crypto_auth_hmacsha512_bytes"]=asm["_crypto_auth_hmacsha512_bytes"];var _crypto_auth_hmacsha512_final=Module["_crypto_auth_hmacsha512_final"]=asm["_crypto_auth_hmacsha512_final"];var _crypto_auth_hmacsha512_init=Module["_crypto_auth_hmacsha512_init"]=asm["_crypto_auth_hmacsha512_init"];var _crypto_auth_hmacsha512_keybytes=Module["_crypto_auth_hmacsha512_keybytes"]=asm["_crypto_auth_hmacsha512_keybytes"];var _crypto_auth_hmacsha512_keygen=Module["_crypto_auth_hmacsha512_keygen"]=asm["_crypto_auth_hmacsha512_keygen"];var _crypto_auth_hmacsha512_statebytes=Module["_crypto_auth_hmacsha512_statebytes"]=asm["_crypto_auth_hmacsha512_statebytes"];var _crypto_auth_hmacsha512_update=Module["_crypto_auth_hmacsha512_update"]=asm["_crypto_auth_hmacsha512_update"];var _crypto_auth_hmacsha512_verify=Module["_crypto_auth_hmacsha512_verify"]=asm["_crypto_auth_hmacsha512_verify"];var _crypto_auth_keybytes=Module["_crypto_auth_keybytes"]=asm["_crypto_auth_keybytes"];var _crypto_auth_keygen=Module["_crypto_auth_keygen"]=asm["_crypto_auth_keygen"];var _crypto_auth_primitive=Module["_crypto_auth_primitive"]=asm["_crypto_auth_primitive"];var _crypto_auth_verify=Module["_crypto_auth_verify"]=asm["_crypto_auth_verify"];var _crypto_box=Module["_crypto_box"]=asm["_crypto_box"];var _crypto_box_afternm=Module["_crypto_box_afternm"]=asm["_crypto_box_afternm"];var _crypto_box_beforenm=Module["_crypto_box_beforenm"]=asm["_crypto_box_beforenm"];var _crypto_box_beforenmbytes=Module["_crypto_box_beforenmbytes"]=asm["_crypto_box_beforenmbytes"];var _crypto_box_boxzerobytes=Module["_crypto_box_boxzerobytes"]=asm["_crypto_box_boxzerobytes"];var _crypto_box_curve25519xchacha20poly1305_beforenm=Module["_crypto_box_curve25519xchacha20poly1305_beforenm"]=asm["_crypto_box_curve25519xchacha20poly1305_beforenm"];var _crypto_box_curve25519xchacha20poly1305_beforenmbytes=Module["_crypto_box_curve25519xchacha20poly1305_beforenmbytes"]=asm["_crypto_box_curve25519xchacha20poly1305_beforenmbytes"];var _crypto_box_curve25519xchacha20poly1305_detached=Module["_crypto_box_curve25519xchacha20poly1305_detached"]=asm["_crypto_box_curve25519xchacha20poly1305_detached"];var _crypto_box_curve25519xchacha20poly1305_detached_afternm=Module["_crypto_box_curve25519xchacha20poly1305_detached_afternm"]=asm["_crypto_box_curve25519xchacha20poly1305_detached_afternm"];var _crypto_box_curve25519xchacha20poly1305_easy=Module["_crypto_box_curve25519xchacha20poly1305_easy"]=asm["_crypto_box_curve25519xchacha20poly1305_easy"];var _crypto_box_curve25519xchacha20poly1305_easy_afternm=Module["_crypto_box_curve25519xchacha20poly1305_easy_afternm"]=asm["_crypto_box_curve25519xchacha20poly1305_easy_afternm"];var _crypto_box_curve25519xchacha20poly1305_keypair=Module["_crypto_box_curve25519xchacha20poly1305_keypair"]=asm["_crypto_box_curve25519xchacha20poly1305_keypair"];var _crypto_box_curve25519xchacha20poly1305_macbytes=Module["_crypto_box_curve25519xchacha20poly1305_macbytes"]=asm["_crypto_box_curve25519xchacha20poly1305_macbytes"];var _crypto_box_curve25519xchacha20poly1305_noncebytes=Module["_crypto_box_curve25519xchacha20poly1305_noncebytes"]=asm["_crypto_box_curve25519xchacha20poly1305_noncebytes"];var _crypto_box_curve25519xchacha20poly1305_open_detached=Module["_crypto_box_curve25519xchacha20poly1305_open_detached"]=asm["_crypto_box_curve25519xchacha20poly1305_open_detached"];var _crypto_box_curve25519xchacha20poly1305_open_detached_afternm=Module["_crypto_box_curve25519xchacha20poly1305_open_detached_afternm"]=asm["_crypto_box_curve25519xchacha20poly1305_open_detached_afternm"];var _crypto_box_curve25519xchacha20poly1305_open_easy=Module["_crypto_box_curve25519xchacha20poly1305_open_easy"]=asm["_crypto_box_curve25519xchacha20poly1305_open_easy"];var _crypto_box_curve25519xchacha20poly1305_open_easy_afternm=Module["_crypto_box_curve25519xchacha20poly1305_open_easy_afternm"]=asm["_crypto_box_curve25519xchacha20poly1305_open_easy_afternm"];var _crypto_box_curve25519xchacha20poly1305_publickeybytes=Module["_crypto_box_curve25519xchacha20poly1305_publickeybytes"]=asm["_crypto_box_curve25519xchacha20poly1305_publickeybytes"];var _crypto_box_curve25519xchacha20poly1305_seal=Module["_crypto_box_curve25519xchacha20poly1305_seal"]=asm["_crypto_box_curve25519xchacha20poly1305_seal"];var _crypto_box_curve25519xchacha20poly1305_seal_open=Module["_crypto_box_curve25519xchacha20poly1305_seal_open"]=asm["_crypto_box_curve25519xchacha20poly1305_seal_open"];var _crypto_box_curve25519xchacha20poly1305_sealbytes=Module["_crypto_box_curve25519xchacha20poly1305_sealbytes"]=asm["_crypto_box_curve25519xchacha20poly1305_sealbytes"];var _crypto_box_curve25519xchacha20poly1305_secretkeybytes=Module["_crypto_box_curve25519xchacha20poly1305_secretkeybytes"]=asm["_crypto_box_curve25519xchacha20poly1305_secretkeybytes"];var _crypto_box_curve25519xchacha20poly1305_seed_keypair=Module["_crypto_box_curve25519xchacha20poly1305_seed_keypair"]=asm["_crypto_box_curve25519xchacha20poly1305_seed_keypair"];var _crypto_box_curve25519xchacha20poly1305_seedbytes=Module["_crypto_box_curve25519xchacha20poly1305_seedbytes"]=asm["_crypto_box_curve25519xchacha20poly1305_seedbytes"];var _crypto_box_curve25519xsalsa20poly1305=Module["_crypto_box_curve25519xsalsa20poly1305"]=asm["_crypto_box_curve25519xsalsa20poly1305"];var _crypto_box_curve25519xsalsa20poly1305_afternm=Module["_crypto_box_curve25519xsalsa20poly1305_afternm"]=asm["_crypto_box_curve25519xsalsa20poly1305_afternm"];var _crypto_box_curve25519xsalsa20poly1305_beforenm=Module["_crypto_box_curve25519xsalsa20poly1305_beforenm"]=asm["_crypto_box_curve25519xsalsa20poly1305_beforenm"];var _crypto_box_curve25519xsalsa20poly1305_beforenmbytes=Module["_crypto_box_curve25519xsalsa20poly1305_beforenmbytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_beforenmbytes"];var _crypto_box_curve25519xsalsa20poly1305_boxzerobytes=Module["_crypto_box_curve25519xsalsa20poly1305_boxzerobytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_boxzerobytes"];var _crypto_box_curve25519xsalsa20poly1305_keypair=Module["_crypto_box_curve25519xsalsa20poly1305_keypair"]=asm["_crypto_box_curve25519xsalsa20poly1305_keypair"];var _crypto_box_curve25519xsalsa20poly1305_macbytes=Module["_crypto_box_curve25519xsalsa20poly1305_macbytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_macbytes"];var _crypto_box_curve25519xsalsa20poly1305_noncebytes=Module["_crypto_box_curve25519xsalsa20poly1305_noncebytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_noncebytes"];var _crypto_box_curve25519xsalsa20poly1305_open=Module["_crypto_box_curve25519xsalsa20poly1305_open"]=asm["_crypto_box_curve25519xsalsa20poly1305_open"];var _crypto_box_curve25519xsalsa20poly1305_open_afternm=Module["_crypto_box_curve25519xsalsa20poly1305_open_afternm"]=asm["_crypto_box_curve25519xsalsa20poly1305_open_afternm"];var _crypto_box_curve25519xsalsa20poly1305_publickeybytes=Module["_crypto_box_curve25519xsalsa20poly1305_publickeybytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_publickeybytes"];var _crypto_box_curve25519xsalsa20poly1305_secretkeybytes=Module["_crypto_box_curve25519xsalsa20poly1305_secretkeybytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_secretkeybytes"];var _crypto_box_curve25519xsalsa20poly1305_seed_keypair=Module["_crypto_box_curve25519xsalsa20poly1305_seed_keypair"]=asm["_crypto_box_curve25519xsalsa20poly1305_seed_keypair"];var _crypto_box_curve25519xsalsa20poly1305_seedbytes=Module["_crypto_box_curve25519xsalsa20poly1305_seedbytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_seedbytes"];var _crypto_box_curve25519xsalsa20poly1305_zerobytes=Module["_crypto_box_curve25519xsalsa20poly1305_zerobytes"]=asm["_crypto_box_curve25519xsalsa20poly1305_zerobytes"];var _crypto_box_detached=Module["_crypto_box_detached"]=asm["_crypto_box_detached"];var _crypto_box_detached_afternm=Module["_crypto_box_detached_afternm"]=asm["_crypto_box_detached_afternm"];var _crypto_box_easy=Module["_crypto_box_easy"]=asm["_crypto_box_easy"];var _crypto_box_easy_afternm=Module["_crypto_box_easy_afternm"]=asm["_crypto_box_easy_afternm"];var _crypto_box_keypair=Module["_crypto_box_keypair"]=asm["_crypto_box_keypair"];var _crypto_box_macbytes=Module["_crypto_box_macbytes"]=asm["_crypto_box_macbytes"];var _crypto_box_noncebytes=Module["_crypto_box_noncebytes"]=asm["_crypto_box_noncebytes"];var _crypto_box_open=Module["_crypto_box_open"]=asm["_crypto_box_open"];var _crypto_box_open_afternm=Module["_crypto_box_open_afternm"]=asm["_crypto_box_open_afternm"];var _crypto_box_open_detached=Module["_crypto_box_open_detached"]=asm["_crypto_box_open_detached"];var _crypto_box_open_detached_afternm=Module["_crypto_box_open_detached_afternm"]=asm["_crypto_box_open_detached_afternm"];var _crypto_box_open_easy=Module["_crypto_box_open_easy"]=asm["_crypto_box_open_easy"];var _crypto_box_open_easy_afternm=Module["_crypto_box_open_easy_afternm"]=asm["_crypto_box_open_easy_afternm"];var _crypto_box_primitive=Module["_crypto_box_primitive"]=asm["_crypto_box_primitive"];var _crypto_box_publickeybytes=Module["_crypto_box_publickeybytes"]=asm["_crypto_box_publickeybytes"];var _crypto_box_seal=Module["_crypto_box_seal"]=asm["_crypto_box_seal"];var _crypto_box_seal_open=Module["_crypto_box_seal_open"]=asm["_crypto_box_seal_open"];var _crypto_box_sealbytes=Module["_crypto_box_sealbytes"]=asm["_crypto_box_sealbytes"];var _crypto_box_secretkeybytes=Module["_crypto_box_secretkeybytes"]=asm["_crypto_box_secretkeybytes"];var _crypto_box_seed_keypair=Module["_crypto_box_seed_keypair"]=asm["_crypto_box_seed_keypair"];var _crypto_box_seedbytes=Module["_crypto_box_seedbytes"]=asm["_crypto_box_seedbytes"];var _crypto_box_zerobytes=Module["_crypto_box_zerobytes"]=asm["_crypto_box_zerobytes"];var _crypto_core_ed25519_add=Module["_crypto_core_ed25519_add"]=asm["_crypto_core_ed25519_add"];var _crypto_core_ed25519_bytes=Module["_crypto_core_ed25519_bytes"]=asm["_crypto_core_ed25519_bytes"];var _crypto_core_ed25519_from_uniform=Module["_crypto_core_ed25519_from_uniform"]=asm["_crypto_core_ed25519_from_uniform"];var _crypto_core_ed25519_is_valid_point=Module["_crypto_core_ed25519_is_valid_point"]=asm["_crypto_core_ed25519_is_valid_point"];var _crypto_core_ed25519_sub=Module["_crypto_core_ed25519_sub"]=asm["_crypto_core_ed25519_sub"];var _crypto_core_ed25519_uniformbytes=Module["_crypto_core_ed25519_uniformbytes"]=asm["_crypto_core_ed25519_uniformbytes"];var _crypto_core_hchacha20=Module["_crypto_core_hchacha20"]=asm["_crypto_core_hchacha20"];var _crypto_core_hchacha20_constbytes=Module["_crypto_core_hchacha20_constbytes"]=asm["_crypto_core_hchacha20_constbytes"];var _crypto_core_hchacha20_inputbytes=Module["_crypto_core_hchacha20_inputbytes"]=asm["_crypto_core_hchacha20_inputbytes"];var _crypto_core_hchacha20_keybytes=Module["_crypto_core_hchacha20_keybytes"]=asm["_crypto_core_hchacha20_keybytes"];var _crypto_core_hchacha20_outputbytes=Module["_crypto_core_hchacha20_outputbytes"]=asm["_crypto_core_hchacha20_outputbytes"];var _crypto_core_hsalsa20=Module["_crypto_core_hsalsa20"]=asm["_crypto_core_hsalsa20"];var _crypto_core_hsalsa20_constbytes=Module["_crypto_core_hsalsa20_constbytes"]=asm["_crypto_core_hsalsa20_constbytes"];var _crypto_core_hsalsa20_inputbytes=Module["_crypto_core_hsalsa20_inputbytes"]=asm["_crypto_core_hsalsa20_inputbytes"];var _crypto_core_hsalsa20_keybytes=Module["_crypto_core_hsalsa20_keybytes"]=asm["_crypto_core_hsalsa20_keybytes"];var _crypto_core_hsalsa20_outputbytes=Module["_crypto_core_hsalsa20_outputbytes"]=asm["_crypto_core_hsalsa20_outputbytes"];var _crypto_core_salsa20=Module["_crypto_core_salsa20"]=asm["_crypto_core_salsa20"];var _crypto_core_salsa2012=Module["_crypto_core_salsa2012"]=asm["_crypto_core_salsa2012"];var _crypto_core_salsa2012_constbytes=Module["_crypto_core_salsa2012_constbytes"]=asm["_crypto_core_salsa2012_constbytes"];var _crypto_core_salsa2012_inputbytes=Module["_crypto_core_salsa2012_inputbytes"]=asm["_crypto_core_salsa2012_inputbytes"];var _crypto_core_salsa2012_keybytes=Module["_crypto_core_salsa2012_keybytes"]=asm["_crypto_core_salsa2012_keybytes"];var _crypto_core_salsa2012_outputbytes=Module["_crypto_core_salsa2012_outputbytes"]=asm["_crypto_core_salsa2012_outputbytes"];var _crypto_core_salsa208=Module["_crypto_core_salsa208"]=asm["_crypto_core_salsa208"];var _crypto_core_salsa208_constbytes=Module["_crypto_core_salsa208_constbytes"]=asm["_crypto_core_salsa208_constbytes"];var _crypto_core_salsa208_inputbytes=Module["_crypto_core_salsa208_inputbytes"]=asm["_crypto_core_salsa208_inputbytes"];var _crypto_core_salsa208_keybytes=Module["_crypto_core_salsa208_keybytes"]=asm["_crypto_core_salsa208_keybytes"];var _crypto_core_salsa208_outputbytes=Module["_crypto_core_salsa208_outputbytes"]=asm["_crypto_core_salsa208_outputbytes"];var _crypto_core_salsa20_constbytes=Module["_crypto_core_salsa20_constbytes"]=asm["_crypto_core_salsa20_constbytes"];var _crypto_core_salsa20_inputbytes=Module["_crypto_core_salsa20_inputbytes"]=asm["_crypto_core_salsa20_inputbytes"];var _crypto_core_salsa20_keybytes=Module["_crypto_core_salsa20_keybytes"]=asm["_crypto_core_salsa20_keybytes"];var _crypto_core_salsa20_outputbytes=Module["_crypto_core_salsa20_outputbytes"]=asm["_crypto_core_salsa20_outputbytes"];var _crypto_generichash=Module["_crypto_generichash"]=asm["_crypto_generichash"];var _crypto_generichash_blake2b=Module["_crypto_generichash_blake2b"]=asm["_crypto_generichash_blake2b"];var _crypto_generichash_blake2b_bytes=Module["_crypto_generichash_blake2b_bytes"]=asm["_crypto_generichash_blake2b_bytes"];var _crypto_generichash_blake2b_bytes_max=Module["_crypto_generichash_blake2b_bytes_max"]=asm["_crypto_generichash_blake2b_bytes_max"];var _crypto_generichash_blake2b_bytes_min=Module["_crypto_generichash_blake2b_bytes_min"]=asm["_crypto_generichash_blake2b_bytes_min"];var _crypto_generichash_blake2b_final=Module["_crypto_generichash_blake2b_final"]=asm["_crypto_generichash_blake2b_final"];var _crypto_generichash_blake2b_init=Module["_crypto_generichash_blake2b_init"]=asm["_crypto_generichash_blake2b_init"];var _crypto_generichash_blake2b_init_salt_personal=Module["_crypto_generichash_blake2b_init_salt_personal"]=asm["_crypto_generichash_blake2b_init_salt_personal"];var _crypto_generichash_blake2b_keybytes=Module["_crypto_generichash_blake2b_keybytes"]=asm["_crypto_generichash_blake2b_keybytes"];var _crypto_generichash_blake2b_keybytes_max=Module["_crypto_generichash_blake2b_keybytes_max"]=asm["_crypto_generichash_blake2b_keybytes_max"];var _crypto_generichash_blake2b_keybytes_min=Module["_crypto_generichash_blake2b_keybytes_min"]=asm["_crypto_generichash_blake2b_keybytes_min"];var _crypto_generichash_blake2b_keygen=Module["_crypto_generichash_blake2b_keygen"]=asm["_crypto_generichash_blake2b_keygen"];var _crypto_generichash_blake2b_personalbytes=Module["_crypto_generichash_blake2b_personalbytes"]=asm["_crypto_generichash_blake2b_personalbytes"];var _crypto_generichash_blake2b_salt_personal=Module["_crypto_generichash_blake2b_salt_personal"]=asm["_crypto_generichash_blake2b_salt_personal"];var _crypto_generichash_blake2b_saltbytes=Module["_crypto_generichash_blake2b_saltbytes"]=asm["_crypto_generichash_blake2b_saltbytes"];var _crypto_generichash_blake2b_statebytes=Module["_crypto_generichash_blake2b_statebytes"]=asm["_crypto_generichash_blake2b_statebytes"];var _crypto_generichash_blake2b_update=Module["_crypto_generichash_blake2b_update"]=asm["_crypto_generichash_blake2b_update"];var _crypto_generichash_bytes=Module["_crypto_generichash_bytes"]=asm["_crypto_generichash_bytes"];var _crypto_generichash_bytes_max=Module["_crypto_generichash_bytes_max"]=asm["_crypto_generichash_bytes_max"];var _crypto_generichash_bytes_min=Module["_crypto_generichash_bytes_min"]=asm["_crypto_generichash_bytes_min"];var _crypto_generichash_final=Module["_crypto_generichash_final"]=asm["_crypto_generichash_final"];var _crypto_generichash_init=Module["_crypto_generichash_init"]=asm["_crypto_generichash_init"];var _crypto_generichash_keybytes=Module["_crypto_generichash_keybytes"]=asm["_crypto_generichash_keybytes"];var _crypto_generichash_keybytes_max=Module["_crypto_generichash_keybytes_max"]=asm["_crypto_generichash_keybytes_max"];var _crypto_generichash_keybytes_min=Module["_crypto_generichash_keybytes_min"]=asm["_crypto_generichash_keybytes_min"];var _crypto_generichash_keygen=Module["_crypto_generichash_keygen"]=asm["_crypto_generichash_keygen"];var _crypto_generichash_primitive=Module["_crypto_generichash_primitive"]=asm["_crypto_generichash_primitive"];var _crypto_generichash_statebytes=Module["_crypto_generichash_statebytes"]=asm["_crypto_generichash_statebytes"];var _crypto_generichash_update=Module["_crypto_generichash_update"]=asm["_crypto_generichash_update"];var _crypto_hash=Module["_crypto_hash"]=asm["_crypto_hash"];var _crypto_hash_bytes=Module["_crypto_hash_bytes"]=asm["_crypto_hash_bytes"];var _crypto_hash_primitive=Module["_crypto_hash_primitive"]=asm["_crypto_hash_primitive"];var _crypto_hash_sha256=Module["_crypto_hash_sha256"]=asm["_crypto_hash_sha256"];var _crypto_hash_sha256_bytes=Module["_crypto_hash_sha256_bytes"]=asm["_crypto_hash_sha256_bytes"];var _crypto_hash_sha256_final=Module["_crypto_hash_sha256_final"]=asm["_crypto_hash_sha256_final"];var _crypto_hash_sha256_init=Module["_crypto_hash_sha256_init"]=asm["_crypto_hash_sha256_init"];var _crypto_hash_sha256_statebytes=Module["_crypto_hash_sha256_statebytes"]=asm["_crypto_hash_sha256_statebytes"];var _crypto_hash_sha256_update=Module["_crypto_hash_sha256_update"]=asm["_crypto_hash_sha256_update"];var _crypto_hash_sha512=Module["_crypto_hash_sha512"]=asm["_crypto_hash_sha512"];var _crypto_hash_sha512_bytes=Module["_crypto_hash_sha512_bytes"]=asm["_crypto_hash_sha512_bytes"];var _crypto_hash_sha512_final=Module["_crypto_hash_sha512_final"]=asm["_crypto_hash_sha512_final"];var _crypto_hash_sha512_init=Module["_crypto_hash_sha512_init"]=asm["_crypto_hash_sha512_init"];var _crypto_hash_sha512_statebytes=Module["_crypto_hash_sha512_statebytes"]=asm["_crypto_hash_sha512_statebytes"];var _crypto_hash_sha512_update=Module["_crypto_hash_sha512_update"]=asm["_crypto_hash_sha512_update"];var _crypto_kdf_blake2b_bytes_max=Module["_crypto_kdf_blake2b_bytes_max"]=asm["_crypto_kdf_blake2b_bytes_max"];var _crypto_kdf_blake2b_bytes_min=Module["_crypto_kdf_blake2b_bytes_min"]=asm["_crypto_kdf_blake2b_bytes_min"];var _crypto_kdf_blake2b_contextbytes=Module["_crypto_kdf_blake2b_contextbytes"]=asm["_crypto_kdf_blake2b_contextbytes"];var _crypto_kdf_blake2b_derive_from_key=Module["_crypto_kdf_blake2b_derive_from_key"]=asm["_crypto_kdf_blake2b_derive_from_key"];var _crypto_kdf_blake2b_keybytes=Module["_crypto_kdf_blake2b_keybytes"]=asm["_crypto_kdf_blake2b_keybytes"];var _crypto_kdf_bytes_max=Module["_crypto_kdf_bytes_max"]=asm["_crypto_kdf_bytes_max"];var _crypto_kdf_bytes_min=Module["_crypto_kdf_bytes_min"]=asm["_crypto_kdf_bytes_min"];var _crypto_kdf_contextbytes=Module["_crypto_kdf_contextbytes"]=asm["_crypto_kdf_contextbytes"];var _crypto_kdf_derive_from_key=Module["_crypto_kdf_derive_from_key"]=asm["_crypto_kdf_derive_from_key"];var _crypto_kdf_keybytes=Module["_crypto_kdf_keybytes"]=asm["_crypto_kdf_keybytes"];var _crypto_kdf_keygen=Module["_crypto_kdf_keygen"]=asm["_crypto_kdf_keygen"];var _crypto_kdf_primitive=Module["_crypto_kdf_primitive"]=asm["_crypto_kdf_primitive"];var _crypto_kx_client_session_keys=Module["_crypto_kx_client_session_keys"]=asm["_crypto_kx_client_session_keys"];var _crypto_kx_keypair=Module["_crypto_kx_keypair"]=asm["_crypto_kx_keypair"];var _crypto_kx_primitive=Module["_crypto_kx_primitive"]=asm["_crypto_kx_primitive"];var _crypto_kx_publickeybytes=Module["_crypto_kx_publickeybytes"]=asm["_crypto_kx_publickeybytes"];var _crypto_kx_secretkeybytes=Module["_crypto_kx_secretkeybytes"]=asm["_crypto_kx_secretkeybytes"];var _crypto_kx_seed_keypair=Module["_crypto_kx_seed_keypair"]=asm["_crypto_kx_seed_keypair"];var _crypto_kx_seedbytes=Module["_crypto_kx_seedbytes"]=asm["_crypto_kx_seedbytes"];var _crypto_kx_server_session_keys=Module["_crypto_kx_server_session_keys"]=asm["_crypto_kx_server_session_keys"];var _crypto_kx_sessionkeybytes=Module["_crypto_kx_sessionkeybytes"]=asm["_crypto_kx_sessionkeybytes"];var _crypto_onetimeauth=Module["_crypto_onetimeauth"]=asm["_crypto_onetimeauth"];var _crypto_onetimeauth_bytes=Module["_crypto_onetimeauth_bytes"]=asm["_crypto_onetimeauth_bytes"];var _crypto_onetimeauth_final=Module["_crypto_onetimeauth_final"]=asm["_crypto_onetimeauth_final"];var _crypto_onetimeauth_init=Module["_crypto_onetimeauth_init"]=asm["_crypto_onetimeauth_init"];var _crypto_onetimeauth_keybytes=Module["_crypto_onetimeauth_keybytes"]=asm["_crypto_onetimeauth_keybytes"];var _crypto_onetimeauth_keygen=Module["_crypto_onetimeauth_keygen"]=asm["_crypto_onetimeauth_keygen"];var _crypto_onetimeauth_poly1305=Module["_crypto_onetimeauth_poly1305"]=asm["_crypto_onetimeauth_poly1305"];var _crypto_onetimeauth_poly1305_bytes=Module["_crypto_onetimeauth_poly1305_bytes"]=asm["_crypto_onetimeauth_poly1305_bytes"];var _crypto_onetimeauth_poly1305_final=Module["_crypto_onetimeauth_poly1305_final"]=asm["_crypto_onetimeauth_poly1305_final"];var _crypto_onetimeauth_poly1305_init=Module["_crypto_onetimeauth_poly1305_init"]=asm["_crypto_onetimeauth_poly1305_init"];var _crypto_onetimeauth_poly1305_keybytes=Module["_crypto_onetimeauth_poly1305_keybytes"]=asm["_crypto_onetimeauth_poly1305_keybytes"];var _crypto_onetimeauth_poly1305_keygen=Module["_crypto_onetimeauth_poly1305_keygen"]=asm["_crypto_onetimeauth_poly1305_keygen"];var _crypto_onetimeauth_poly1305_statebytes=Module["_crypto_onetimeauth_poly1305_statebytes"]=asm["_crypto_onetimeauth_poly1305_statebytes"];var _crypto_onetimeauth_poly1305_update=Module["_crypto_onetimeauth_poly1305_update"]=asm["_crypto_onetimeauth_poly1305_update"];var _crypto_onetimeauth_poly1305_verify=Module["_crypto_onetimeauth_poly1305_verify"]=asm["_crypto_onetimeauth_poly1305_verify"];var _crypto_onetimeauth_primitive=Module["_crypto_onetimeauth_primitive"]=asm["_crypto_onetimeauth_primitive"];var _crypto_onetimeauth_statebytes=Module["_crypto_onetimeauth_statebytes"]=asm["_crypto_onetimeauth_statebytes"];var _crypto_onetimeauth_update=Module["_crypto_onetimeauth_update"]=asm["_crypto_onetimeauth_update"];var _crypto_onetimeauth_verify=Module["_crypto_onetimeauth_verify"]=asm["_crypto_onetimeauth_verify"];var _crypto_pwhash=Module["_crypto_pwhash"]=asm["_crypto_pwhash"];var _crypto_pwhash_alg_argon2i13=Module["_crypto_pwhash_alg_argon2i13"]=asm["_crypto_pwhash_alg_argon2i13"];var _crypto_pwhash_alg_argon2id13=Module["_crypto_pwhash_alg_argon2id13"]=asm["_crypto_pwhash_alg_argon2id13"];var _crypto_pwhash_alg_default=Module["_crypto_pwhash_alg_default"]=asm["_crypto_pwhash_alg_default"];var _crypto_pwhash_argon2i=Module["_crypto_pwhash_argon2i"]=asm["_crypto_pwhash_argon2i"];var _crypto_pwhash_argon2i_alg_argon2i13=Module["_crypto_pwhash_argon2i_alg_argon2i13"]=asm["_crypto_pwhash_argon2i_alg_argon2i13"];var _crypto_pwhash_argon2i_bytes_max=Module["_crypto_pwhash_argon2i_bytes_max"]=asm["_crypto_pwhash_argon2i_bytes_max"];var _crypto_pwhash_argon2i_bytes_min=Module["_crypto_pwhash_argon2i_bytes_min"]=asm["_crypto_pwhash_argon2i_bytes_min"];var _crypto_pwhash_argon2i_memlimit_interactive=Module["_crypto_pwhash_argon2i_memlimit_interactive"]=asm["_crypto_pwhash_argon2i_memlimit_interactive"];var _crypto_pwhash_argon2i_memlimit_max=Module["_crypto_pwhash_argon2i_memlimit_max"]=asm["_crypto_pwhash_argon2i_memlimit_max"];var _crypto_pwhash_argon2i_memlimit_min=Module["_crypto_pwhash_argon2i_memlimit_min"]=asm["_crypto_pwhash_argon2i_memlimit_min"];var _crypto_pwhash_argon2i_memlimit_moderate=Module["_crypto_pwhash_argon2i_memlimit_moderate"]=asm["_crypto_pwhash_argon2i_memlimit_moderate"];var _crypto_pwhash_argon2i_memlimit_sensitive=Module["_crypto_pwhash_argon2i_memlimit_sensitive"]=asm["_crypto_pwhash_argon2i_memlimit_sensitive"];var _crypto_pwhash_argon2i_opslimit_interactive=Module["_crypto_pwhash_argon2i_opslimit_interactive"]=asm["_crypto_pwhash_argon2i_opslimit_interactive"];var _crypto_pwhash_argon2i_opslimit_max=Module["_crypto_pwhash_argon2i_opslimit_max"]=asm["_crypto_pwhash_argon2i_opslimit_max"];var _crypto_pwhash_argon2i_opslimit_min=Module["_crypto_pwhash_argon2i_opslimit_min"]=asm["_crypto_pwhash_argon2i_opslimit_min"];var _crypto_pwhash_argon2i_opslimit_moderate=Module["_crypto_pwhash_argon2i_opslimit_moderate"]=asm["_crypto_pwhash_argon2i_opslimit_moderate"];var _crypto_pwhash_argon2i_opslimit_sensitive=Module["_crypto_pwhash_argon2i_opslimit_sensitive"]=asm["_crypto_pwhash_argon2i_opslimit_sensitive"];var _crypto_pwhash_argon2i_passwd_max=Module["_crypto_pwhash_argon2i_passwd_max"]=asm["_crypto_pwhash_argon2i_passwd_max"];var _crypto_pwhash_argon2i_passwd_min=Module["_crypto_pwhash_argon2i_passwd_min"]=asm["_crypto_pwhash_argon2i_passwd_min"];var _crypto_pwhash_argon2i_saltbytes=Module["_crypto_pwhash_argon2i_saltbytes"]=asm["_crypto_pwhash_argon2i_saltbytes"];var _crypto_pwhash_argon2i_str=Module["_crypto_pwhash_argon2i_str"]=asm["_crypto_pwhash_argon2i_str"];var _crypto_pwhash_argon2i_str_needs_rehash=Module["_crypto_pwhash_argon2i_str_needs_rehash"]=asm["_crypto_pwhash_argon2i_str_needs_rehash"];var _crypto_pwhash_argon2i_str_verify=Module["_crypto_pwhash_argon2i_str_verify"]=asm["_crypto_pwhash_argon2i_str_verify"];var _crypto_pwhash_argon2i_strbytes=Module["_crypto_pwhash_argon2i_strbytes"]=asm["_crypto_pwhash_argon2i_strbytes"];var _crypto_pwhash_argon2i_strprefix=Module["_crypto_pwhash_argon2i_strprefix"]=asm["_crypto_pwhash_argon2i_strprefix"];var _crypto_pwhash_argon2id=Module["_crypto_pwhash_argon2id"]=asm["_crypto_pwhash_argon2id"];var _crypto_pwhash_argon2id_alg_argon2id13=Module["_crypto_pwhash_argon2id_alg_argon2id13"]=asm["_crypto_pwhash_argon2id_alg_argon2id13"];var _crypto_pwhash_argon2id_bytes_max=Module["_crypto_pwhash_argon2id_bytes_max"]=asm["_crypto_pwhash_argon2id_bytes_max"];var _crypto_pwhash_argon2id_bytes_min=Module["_crypto_pwhash_argon2id_bytes_min"]=asm["_crypto_pwhash_argon2id_bytes_min"];var _crypto_pwhash_argon2id_memlimit_interactive=Module["_crypto_pwhash_argon2id_memlimit_interactive"]=asm["_crypto_pwhash_argon2id_memlimit_interactive"];var _crypto_pwhash_argon2id_memlimit_max=Module["_crypto_pwhash_argon2id_memlimit_max"]=asm["_crypto_pwhash_argon2id_memlimit_max"];var _crypto_pwhash_argon2id_memlimit_min=Module["_crypto_pwhash_argon2id_memlimit_min"]=asm["_crypto_pwhash_argon2id_memlimit_min"];var _crypto_pwhash_argon2id_memlimit_moderate=Module["_crypto_pwhash_argon2id_memlimit_moderate"]=asm["_crypto_pwhash_argon2id_memlimit_moderate"];var _crypto_pwhash_argon2id_memlimit_sensitive=Module["_crypto_pwhash_argon2id_memlimit_sensitive"]=asm["_crypto_pwhash_argon2id_memlimit_sensitive"];var _crypto_pwhash_argon2id_opslimit_interactive=Module["_crypto_pwhash_argon2id_opslimit_interactive"]=asm["_crypto_pwhash_argon2id_opslimit_interactive"];var _crypto_pwhash_argon2id_opslimit_max=Module["_crypto_pwhash_argon2id_opslimit_max"]=asm["_crypto_pwhash_argon2id_opslimit_max"];var _crypto_pwhash_argon2id_opslimit_min=Module["_crypto_pwhash_argon2id_opslimit_min"]=asm["_crypto_pwhash_argon2id_opslimit_min"];var _crypto_pwhash_argon2id_opslimit_moderate=Module["_crypto_pwhash_argon2id_opslimit_moderate"]=asm["_crypto_pwhash_argon2id_opslimit_moderate"];var _crypto_pwhash_argon2id_opslimit_sensitive=Module["_crypto_pwhash_argon2id_opslimit_sensitive"]=asm["_crypto_pwhash_argon2id_opslimit_sensitive"];var _crypto_pwhash_argon2id_passwd_max=Module["_crypto_pwhash_argon2id_passwd_max"]=asm["_crypto_pwhash_argon2id_passwd_max"];var _crypto_pwhash_argon2id_passwd_min=Module["_crypto_pwhash_argon2id_passwd_min"]=asm["_crypto_pwhash_argon2id_passwd_min"];var _crypto_pwhash_argon2id_saltbytes=Module["_crypto_pwhash_argon2id_saltbytes"]=asm["_crypto_pwhash_argon2id_saltbytes"];var _crypto_pwhash_argon2id_str=Module["_crypto_pwhash_argon2id_str"]=asm["_crypto_pwhash_argon2id_str"];var _crypto_pwhash_argon2id_str_needs_rehash=Module["_crypto_pwhash_argon2id_str_needs_rehash"]=asm["_crypto_pwhash_argon2id_str_needs_rehash"];var _crypto_pwhash_argon2id_str_verify=Module["_crypto_pwhash_argon2id_str_verify"]=asm["_crypto_pwhash_argon2id_str_verify"];var _crypto_pwhash_argon2id_strbytes=Module["_crypto_pwhash_argon2id_strbytes"]=asm["_crypto_pwhash_argon2id_strbytes"];var _crypto_pwhash_argon2id_strprefix=Module["_crypto_pwhash_argon2id_strprefix"]=asm["_crypto_pwhash_argon2id_strprefix"];var _crypto_pwhash_bytes_max=Module["_crypto_pwhash_bytes_max"]=asm["_crypto_pwhash_bytes_max"];var _crypto_pwhash_bytes_min=Module["_crypto_pwhash_bytes_min"]=asm["_crypto_pwhash_bytes_min"];var _crypto_pwhash_memlimit_interactive=Module["_crypto_pwhash_memlimit_interactive"]=asm["_crypto_pwhash_memlimit_interactive"];var _crypto_pwhash_memlimit_max=Module["_crypto_pwhash_memlimit_max"]=asm["_crypto_pwhash_memlimit_max"];var _crypto_pwhash_memlimit_min=Module["_crypto_pwhash_memlimit_min"]=asm["_crypto_pwhash_memlimit_min"];var _crypto_pwhash_memlimit_moderate=Module["_crypto_pwhash_memlimit_moderate"]=asm["_crypto_pwhash_memlimit_moderate"];var _crypto_pwhash_memlimit_sensitive=Module["_crypto_pwhash_memlimit_sensitive"]=asm["_crypto_pwhash_memlimit_sensitive"];var _crypto_pwhash_opslimit_interactive=Module["_crypto_pwhash_opslimit_interactive"]=asm["_crypto_pwhash_opslimit_interactive"];var _crypto_pwhash_opslimit_max=Module["_crypto_pwhash_opslimit_max"]=asm["_crypto_pwhash_opslimit_max"];var _crypto_pwhash_opslimit_min=Module["_crypto_pwhash_opslimit_min"]=asm["_crypto_pwhash_opslimit_min"];var _crypto_pwhash_opslimit_moderate=Module["_crypto_pwhash_opslimit_moderate"]=asm["_crypto_pwhash_opslimit_moderate"];var _crypto_pwhash_opslimit_sensitive=Module["_crypto_pwhash_opslimit_sensitive"]=asm["_crypto_pwhash_opslimit_sensitive"];var _crypto_pwhash_passwd_max=Module["_crypto_pwhash_passwd_max"]=asm["_crypto_pwhash_passwd_max"];var _crypto_pwhash_passwd_min=Module["_crypto_pwhash_passwd_min"]=asm["_crypto_pwhash_passwd_min"];var _crypto_pwhash_primitive=Module["_crypto_pwhash_primitive"]=asm["_crypto_pwhash_primitive"];var _crypto_pwhash_saltbytes=Module["_crypto_pwhash_saltbytes"]=asm["_crypto_pwhash_saltbytes"];var _crypto_pwhash_scryptsalsa208sha256=Module["_crypto_pwhash_scryptsalsa208sha256"]=asm["_crypto_pwhash_scryptsalsa208sha256"];var _crypto_pwhash_scryptsalsa208sha256_bytes_max=Module["_crypto_pwhash_scryptsalsa208sha256_bytes_max"]=asm["_crypto_pwhash_scryptsalsa208sha256_bytes_max"];var _crypto_pwhash_scryptsalsa208sha256_bytes_min=Module["_crypto_pwhash_scryptsalsa208sha256_bytes_min"]=asm["_crypto_pwhash_scryptsalsa208sha256_bytes_min"];var _crypto_pwhash_scryptsalsa208sha256_ll=Module["_crypto_pwhash_scryptsalsa208sha256_ll"]=asm["_crypto_pwhash_scryptsalsa208sha256_ll"];var _crypto_pwhash_scryptsalsa208sha256_memlimit_interactive=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_interactive"]=asm["_crypto_pwhash_scryptsalsa208sha256_memlimit_interactive"];var _crypto_pwhash_scryptsalsa208sha256_memlimit_max=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_max"]=asm["_crypto_pwhash_scryptsalsa208sha256_memlimit_max"];var _crypto_pwhash_scryptsalsa208sha256_memlimit_min=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_min"]=asm["_crypto_pwhash_scryptsalsa208sha256_memlimit_min"];var _crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive"]=asm["_crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive"];var _crypto_pwhash_scryptsalsa208sha256_opslimit_interactive=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_interactive"]=asm["_crypto_pwhash_scryptsalsa208sha256_opslimit_interactive"];var _crypto_pwhash_scryptsalsa208sha256_opslimit_max=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_max"]=asm["_crypto_pwhash_scryptsalsa208sha256_opslimit_max"];var _crypto_pwhash_scryptsalsa208sha256_opslimit_min=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_min"]=asm["_crypto_pwhash_scryptsalsa208sha256_opslimit_min"];var _crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive"]=asm["_crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive"];var _crypto_pwhash_scryptsalsa208sha256_passwd_max=Module["_crypto_pwhash_scryptsalsa208sha256_passwd_max"]=asm["_crypto_pwhash_scryptsalsa208sha256_passwd_max"];var _crypto_pwhash_scryptsalsa208sha256_passwd_min=Module["_crypto_pwhash_scryptsalsa208sha256_passwd_min"]=asm["_crypto_pwhash_scryptsalsa208sha256_passwd_min"];var _crypto_pwhash_scryptsalsa208sha256_saltbytes=Module["_crypto_pwhash_scryptsalsa208sha256_saltbytes"]=asm["_crypto_pwhash_scryptsalsa208sha256_saltbytes"];var _crypto_pwhash_scryptsalsa208sha256_str=Module["_crypto_pwhash_scryptsalsa208sha256_str"]=asm["_crypto_pwhash_scryptsalsa208sha256_str"];var _crypto_pwhash_scryptsalsa208sha256_str_needs_rehash=Module["_crypto_pwhash_scryptsalsa208sha256_str_needs_rehash"]=asm["_crypto_pwhash_scryptsalsa208sha256_str_needs_rehash"];var _crypto_pwhash_scryptsalsa208sha256_str_verify=Module["_crypto_pwhash_scryptsalsa208sha256_str_verify"]=asm["_crypto_pwhash_scryptsalsa208sha256_str_verify"];var _crypto_pwhash_scryptsalsa208sha256_strbytes=Module["_crypto_pwhash_scryptsalsa208sha256_strbytes"]=asm["_crypto_pwhash_scryptsalsa208sha256_strbytes"];var _crypto_pwhash_scryptsalsa208sha256_strprefix=Module["_crypto_pwhash_scryptsalsa208sha256_strprefix"]=asm["_crypto_pwhash_scryptsalsa208sha256_strprefix"];var _crypto_pwhash_str=Module["_crypto_pwhash_str"]=asm["_crypto_pwhash_str"];var _crypto_pwhash_str_alg=Module["_crypto_pwhash_str_alg"]=asm["_crypto_pwhash_str_alg"];var _crypto_pwhash_str_needs_rehash=Module["_crypto_pwhash_str_needs_rehash"]=asm["_crypto_pwhash_str_needs_rehash"];var _crypto_pwhash_str_verify=Module["_crypto_pwhash_str_verify"]=asm["_crypto_pwhash_str_verify"];var _crypto_pwhash_strbytes=Module["_crypto_pwhash_strbytes"]=asm["_crypto_pwhash_strbytes"];var _crypto_pwhash_strprefix=Module["_crypto_pwhash_strprefix"]=asm["_crypto_pwhash_strprefix"];var _crypto_scalarmult=Module["_crypto_scalarmult"]=asm["_crypto_scalarmult"];var _crypto_scalarmult_base=Module["_crypto_scalarmult_base"]=asm["_crypto_scalarmult_base"];var _crypto_scalarmult_bytes=Module["_crypto_scalarmult_bytes"]=asm["_crypto_scalarmult_bytes"];var _crypto_scalarmult_curve25519=Module["_crypto_scalarmult_curve25519"]=asm["_crypto_scalarmult_curve25519"];var _crypto_scalarmult_curve25519_base=Module["_crypto_scalarmult_curve25519_base"]=asm["_crypto_scalarmult_curve25519_base"];var _crypto_scalarmult_curve25519_bytes=Module["_crypto_scalarmult_curve25519_bytes"]=asm["_crypto_scalarmult_curve25519_bytes"];var _crypto_scalarmult_curve25519_scalarbytes=Module["_crypto_scalarmult_curve25519_scalarbytes"]=asm["_crypto_scalarmult_curve25519_scalarbytes"];var _crypto_scalarmult_ed25519=Module["_crypto_scalarmult_ed25519"]=asm["_crypto_scalarmult_ed25519"];var _crypto_scalarmult_ed25519_base=Module["_crypto_scalarmult_ed25519_base"]=asm["_crypto_scalarmult_ed25519_base"];var _crypto_scalarmult_ed25519_bytes=Module["_crypto_scalarmult_ed25519_bytes"]=asm["_crypto_scalarmult_ed25519_bytes"];var _crypto_scalarmult_ed25519_scalarbytes=Module["_crypto_scalarmult_ed25519_scalarbytes"]=asm["_crypto_scalarmult_ed25519_scalarbytes"];var _crypto_scalarmult_primitive=Module["_crypto_scalarmult_primitive"]=asm["_crypto_scalarmult_primitive"];var _crypto_scalarmult_scalarbytes=Module["_crypto_scalarmult_scalarbytes"]=asm["_crypto_scalarmult_scalarbytes"];var _crypto_secretbox=Module["_crypto_secretbox"]=asm["_crypto_secretbox"];var _crypto_secretbox_boxzerobytes=Module["_crypto_secretbox_boxzerobytes"]=asm["_crypto_secretbox_boxzerobytes"];var _crypto_secretbox_detached=Module["_crypto_secretbox_detached"]=asm["_crypto_secretbox_detached"];var _crypto_secretbox_easy=Module["_crypto_secretbox_easy"]=asm["_crypto_secretbox_easy"];var _crypto_secretbox_keybytes=Module["_crypto_secretbox_keybytes"]=asm["_crypto_secretbox_keybytes"];var _crypto_secretbox_keygen=Module["_crypto_secretbox_keygen"]=asm["_crypto_secretbox_keygen"];var _crypto_secretbox_macbytes=Module["_crypto_secretbox_macbytes"]=asm["_crypto_secretbox_macbytes"];var _crypto_secretbox_noncebytes=Module["_crypto_secretbox_noncebytes"]=asm["_crypto_secretbox_noncebytes"];var _crypto_secretbox_open=Module["_crypto_secretbox_open"]=asm["_crypto_secretbox_open"];var _crypto_secretbox_open_detached=Module["_crypto_secretbox_open_detached"]=asm["_crypto_secretbox_open_detached"];var _crypto_secretbox_open_easy=Module["_crypto_secretbox_open_easy"]=asm["_crypto_secretbox_open_easy"];var _crypto_secretbox_primitive=Module["_crypto_secretbox_primitive"]=asm["_crypto_secretbox_primitive"];var _crypto_secretbox_xchacha20poly1305_detached=Module["_crypto_secretbox_xchacha20poly1305_detached"]=asm["_crypto_secretbox_xchacha20poly1305_detached"];var _crypto_secretbox_xchacha20poly1305_easy=Module["_crypto_secretbox_xchacha20poly1305_easy"]=asm["_crypto_secretbox_xchacha20poly1305_easy"];var _crypto_secretbox_xchacha20poly1305_keybytes=Module["_crypto_secretbox_xchacha20poly1305_keybytes"]=asm["_crypto_secretbox_xchacha20poly1305_keybytes"];var _crypto_secretbox_xchacha20poly1305_macbytes=Module["_crypto_secretbox_xchacha20poly1305_macbytes"]=asm["_crypto_secretbox_xchacha20poly1305_macbytes"];var _crypto_secretbox_xchacha20poly1305_noncebytes=Module["_crypto_secretbox_xchacha20poly1305_noncebytes"]=asm["_crypto_secretbox_xchacha20poly1305_noncebytes"];var _crypto_secretbox_xchacha20poly1305_open_detached=Module["_crypto_secretbox_xchacha20poly1305_open_detached"]=asm["_crypto_secretbox_xchacha20poly1305_open_detached"];var _crypto_secretbox_xchacha20poly1305_open_easy=Module["_crypto_secretbox_xchacha20poly1305_open_easy"]=asm["_crypto_secretbox_xchacha20poly1305_open_easy"];var _crypto_secretbox_xsalsa20poly1305=Module["_crypto_secretbox_xsalsa20poly1305"]=asm["_crypto_secretbox_xsalsa20poly1305"];var _crypto_secretbox_xsalsa20poly1305_boxzerobytes=Module["_crypto_secretbox_xsalsa20poly1305_boxzerobytes"]=asm["_crypto_secretbox_xsalsa20poly1305_boxzerobytes"];var _crypto_secretbox_xsalsa20poly1305_keybytes=Module["_crypto_secretbox_xsalsa20poly1305_keybytes"]=asm["_crypto_secretbox_xsalsa20poly1305_keybytes"];var _crypto_secretbox_xsalsa20poly1305_keygen=Module["_crypto_secretbox_xsalsa20poly1305_keygen"]=asm["_crypto_secretbox_xsalsa20poly1305_keygen"];var _crypto_secretbox_xsalsa20poly1305_macbytes=Module["_crypto_secretbox_xsalsa20poly1305_macbytes"]=asm["_crypto_secretbox_xsalsa20poly1305_macbytes"];var _crypto_secretbox_xsalsa20poly1305_noncebytes=Module["_crypto_secretbox_xsalsa20poly1305_noncebytes"]=asm["_crypto_secretbox_xsalsa20poly1305_noncebytes"];var _crypto_secretbox_xsalsa20poly1305_open=Module["_crypto_secretbox_xsalsa20poly1305_open"]=asm["_crypto_secretbox_xsalsa20poly1305_open"];var _crypto_secretbox_xsalsa20poly1305_zerobytes=Module["_crypto_secretbox_xsalsa20poly1305_zerobytes"]=asm["_crypto_secretbox_xsalsa20poly1305_zerobytes"];var _crypto_secretbox_zerobytes=Module["_crypto_secretbox_zerobytes"]=asm["_crypto_secretbox_zerobytes"];var _crypto_secretstream_xchacha20poly1305_abytes=Module["_crypto_secretstream_xchacha20poly1305_abytes"]=asm["_crypto_secretstream_xchacha20poly1305_abytes"];var _crypto_secretstream_xchacha20poly1305_headerbytes=Module["_crypto_secretstream_xchacha20poly1305_headerbytes"]=asm["_crypto_secretstream_xchacha20poly1305_headerbytes"];var _crypto_secretstream_xchacha20poly1305_init_pull=Module["_crypto_secretstream_xchacha20poly1305_init_pull"]=asm["_crypto_secretstream_xchacha20poly1305_init_pull"];var _crypto_secretstream_xchacha20poly1305_init_push=Module["_crypto_secretstream_xchacha20poly1305_init_push"]=asm["_crypto_secretstream_xchacha20poly1305_init_push"];var _crypto_secretstream_xchacha20poly1305_keybytes=Module["_crypto_secretstream_xchacha20poly1305_keybytes"]=asm["_crypto_secretstream_xchacha20poly1305_keybytes"];var _crypto_secretstream_xchacha20poly1305_keygen=Module["_crypto_secretstream_xchacha20poly1305_keygen"]=asm["_crypto_secretstream_xchacha20poly1305_keygen"];var _crypto_secretstream_xchacha20poly1305_messagebytes_max=Module["_crypto_secretstream_xchacha20poly1305_messagebytes_max"]=asm["_crypto_secretstream_xchacha20poly1305_messagebytes_max"];var _crypto_secretstream_xchacha20poly1305_pull=Module["_crypto_secretstream_xchacha20poly1305_pull"]=asm["_crypto_secretstream_xchacha20poly1305_pull"];var _crypto_secretstream_xchacha20poly1305_push=Module["_crypto_secretstream_xchacha20poly1305_push"]=asm["_crypto_secretstream_xchacha20poly1305_push"];var _crypto_secretstream_xchacha20poly1305_rekey=Module["_crypto_secretstream_xchacha20poly1305_rekey"]=asm["_crypto_secretstream_xchacha20poly1305_rekey"];var _crypto_secretstream_xchacha20poly1305_statebytes=Module["_crypto_secretstream_xchacha20poly1305_statebytes"]=asm["_crypto_secretstream_xchacha20poly1305_statebytes"];var _crypto_secretstream_xchacha20poly1305_tag_final=Module["_crypto_secretstream_xchacha20poly1305_tag_final"]=asm["_crypto_secretstream_xchacha20poly1305_tag_final"];var _crypto_secretstream_xchacha20poly1305_tag_message=Module["_crypto_secretstream_xchacha20poly1305_tag_message"]=asm["_crypto_secretstream_xchacha20poly1305_tag_message"];var _crypto_secretstream_xchacha20poly1305_tag_push=Module["_crypto_secretstream_xchacha20poly1305_tag_push"]=asm["_crypto_secretstream_xchacha20poly1305_tag_push"];var _crypto_secretstream_xchacha20poly1305_tag_rekey=Module["_crypto_secretstream_xchacha20poly1305_tag_rekey"]=asm["_crypto_secretstream_xchacha20poly1305_tag_rekey"];var _crypto_shorthash=Module["_crypto_shorthash"]=asm["_crypto_shorthash"];var _crypto_shorthash_bytes=Module["_crypto_shorthash_bytes"]=asm["_crypto_shorthash_bytes"];var _crypto_shorthash_keybytes=Module["_crypto_shorthash_keybytes"]=asm["_crypto_shorthash_keybytes"];var _crypto_shorthash_keygen=Module["_crypto_shorthash_keygen"]=asm["_crypto_shorthash_keygen"];var _crypto_shorthash_primitive=Module["_crypto_shorthash_primitive"]=asm["_crypto_shorthash_primitive"];var _crypto_shorthash_siphash24=Module["_crypto_shorthash_siphash24"]=asm["_crypto_shorthash_siphash24"];var _crypto_shorthash_siphash24_bytes=Module["_crypto_shorthash_siphash24_bytes"]=asm["_crypto_shorthash_siphash24_bytes"];var _crypto_shorthash_siphash24_keybytes=Module["_crypto_shorthash_siphash24_keybytes"]=asm["_crypto_shorthash_siphash24_keybytes"];var _crypto_shorthash_siphashx24=Module["_crypto_shorthash_siphashx24"]=asm["_crypto_shorthash_siphashx24"];var _crypto_shorthash_siphashx24_bytes=Module["_crypto_shorthash_siphashx24_bytes"]=asm["_crypto_shorthash_siphashx24_bytes"];var _crypto_shorthash_siphashx24_keybytes=Module["_crypto_shorthash_siphashx24_keybytes"]=asm["_crypto_shorthash_siphashx24_keybytes"];var _crypto_sign=Module["_crypto_sign"]=asm["_crypto_sign"];var _crypto_sign_bytes=Module["_crypto_sign_bytes"]=asm["_crypto_sign_bytes"];var _crypto_sign_detached=Module["_crypto_sign_detached"]=asm["_crypto_sign_detached"];var _crypto_sign_ed25519=Module["_crypto_sign_ed25519"]=asm["_crypto_sign_ed25519"];var _crypto_sign_ed25519_bytes=Module["_crypto_sign_ed25519_bytes"]=asm["_crypto_sign_ed25519_bytes"];var _crypto_sign_ed25519_detached=Module["_crypto_sign_ed25519_detached"]=asm["_crypto_sign_ed25519_detached"];var _crypto_sign_ed25519_keypair=Module["_crypto_sign_ed25519_keypair"]=asm["_crypto_sign_ed25519_keypair"];var _crypto_sign_ed25519_open=Module["_crypto_sign_ed25519_open"]=asm["_crypto_sign_ed25519_open"];var _crypto_sign_ed25519_pk_to_curve25519=Module["_crypto_sign_ed25519_pk_to_curve25519"]=asm["_crypto_sign_ed25519_pk_to_curve25519"];var _crypto_sign_ed25519_publickeybytes=Module["_crypto_sign_ed25519_publickeybytes"]=asm["_crypto_sign_ed25519_publickeybytes"];var _crypto_sign_ed25519_secretkeybytes=Module["_crypto_sign_ed25519_secretkeybytes"]=asm["_crypto_sign_ed25519_secretkeybytes"];var _crypto_sign_ed25519_seed_keypair=Module["_crypto_sign_ed25519_seed_keypair"]=asm["_crypto_sign_ed25519_seed_keypair"];var _crypto_sign_ed25519_seedbytes=Module["_crypto_sign_ed25519_seedbytes"]=asm["_crypto_sign_ed25519_seedbytes"];var _crypto_sign_ed25519_sk_to_curve25519=Module["_crypto_sign_ed25519_sk_to_curve25519"]=asm["_crypto_sign_ed25519_sk_to_curve25519"];var _crypto_sign_ed25519_sk_to_pk=Module["_crypto_sign_ed25519_sk_to_pk"]=asm["_crypto_sign_ed25519_sk_to_pk"];var _crypto_sign_ed25519_sk_to_seed=Module["_crypto_sign_ed25519_sk_to_seed"]=asm["_crypto_sign_ed25519_sk_to_seed"];var _crypto_sign_ed25519_verify_detached=Module["_crypto_sign_ed25519_verify_detached"]=asm["_crypto_sign_ed25519_verify_detached"];var _crypto_sign_ed25519ph_final_create=Module["_crypto_sign_ed25519ph_final_create"]=asm["_crypto_sign_ed25519ph_final_create"];var _crypto_sign_ed25519ph_final_verify=Module["_crypto_sign_ed25519ph_final_verify"]=asm["_crypto_sign_ed25519ph_final_verify"];var _crypto_sign_ed25519ph_init=Module["_crypto_sign_ed25519ph_init"]=asm["_crypto_sign_ed25519ph_init"];var _crypto_sign_ed25519ph_statebytes=Module["_crypto_sign_ed25519ph_statebytes"]=asm["_crypto_sign_ed25519ph_statebytes"];var _crypto_sign_ed25519ph_update=Module["_crypto_sign_ed25519ph_update"]=asm["_crypto_sign_ed25519ph_update"];var _crypto_sign_final_create=Module["_crypto_sign_final_create"]=asm["_crypto_sign_final_create"];var _crypto_sign_final_verify=Module["_crypto_sign_final_verify"]=asm["_crypto_sign_final_verify"];var _crypto_sign_init=Module["_crypto_sign_init"]=asm["_crypto_sign_init"];var _crypto_sign_keypair=Module["_crypto_sign_keypair"]=asm["_crypto_sign_keypair"];var _crypto_sign_open=Module["_crypto_sign_open"]=asm["_crypto_sign_open"];var _crypto_sign_primitive=Module["_crypto_sign_primitive"]=asm["_crypto_sign_primitive"];var _crypto_sign_publickeybytes=Module["_crypto_sign_publickeybytes"]=asm["_crypto_sign_publickeybytes"];var _crypto_sign_secretkeybytes=Module["_crypto_sign_secretkeybytes"]=asm["_crypto_sign_secretkeybytes"];var _crypto_sign_seed_keypair=Module["_crypto_sign_seed_keypair"]=asm["_crypto_sign_seed_keypair"];var _crypto_sign_seedbytes=Module["_crypto_sign_seedbytes"]=asm["_crypto_sign_seedbytes"];var _crypto_sign_statebytes=Module["_crypto_sign_statebytes"]=asm["_crypto_sign_statebytes"];var _crypto_sign_update=Module["_crypto_sign_update"]=asm["_crypto_sign_update"];var _crypto_sign_verify_detached=Module["_crypto_sign_verify_detached"]=asm["_crypto_sign_verify_detached"];var _crypto_stream=Module["_crypto_stream"]=asm["_crypto_stream"];var _crypto_stream_chacha20=Module["_crypto_stream_chacha20"]=asm["_crypto_stream_chacha20"];var _crypto_stream_chacha20_ietf=Module["_crypto_stream_chacha20_ietf"]=asm["_crypto_stream_chacha20_ietf"];var _crypto_stream_chacha20_ietf_keybytes=Module["_crypto_stream_chacha20_ietf_keybytes"]=asm["_crypto_stream_chacha20_ietf_keybytes"];var _crypto_stream_chacha20_ietf_keygen=Module["_crypto_stream_chacha20_ietf_keygen"]=asm["_crypto_stream_chacha20_ietf_keygen"];var _crypto_stream_chacha20_ietf_noncebytes=Module["_crypto_stream_chacha20_ietf_noncebytes"]=asm["_crypto_stream_chacha20_ietf_noncebytes"];var _crypto_stream_chacha20_ietf_xor=Module["_crypto_stream_chacha20_ietf_xor"]=asm["_crypto_stream_chacha20_ietf_xor"];var _crypto_stream_chacha20_ietf_xor_ic=Module["_crypto_stream_chacha20_ietf_xor_ic"]=asm["_crypto_stream_chacha20_ietf_xor_ic"];var _crypto_stream_chacha20_keybytes=Module["_crypto_stream_chacha20_keybytes"]=asm["_crypto_stream_chacha20_keybytes"];var _crypto_stream_chacha20_keygen=Module["_crypto_stream_chacha20_keygen"]=asm["_crypto_stream_chacha20_keygen"];var _crypto_stream_chacha20_noncebytes=Module["_crypto_stream_chacha20_noncebytes"]=asm["_crypto_stream_chacha20_noncebytes"];var _crypto_stream_chacha20_xor=Module["_crypto_stream_chacha20_xor"]=asm["_crypto_stream_chacha20_xor"];var _crypto_stream_chacha20_xor_ic=Module["_crypto_stream_chacha20_xor_ic"]=asm["_crypto_stream_chacha20_xor_ic"];var _crypto_stream_keybytes=Module["_crypto_stream_keybytes"]=asm["_crypto_stream_keybytes"];var _crypto_stream_keygen=Module["_crypto_stream_keygen"]=asm["_crypto_stream_keygen"];var _crypto_stream_noncebytes=Module["_crypto_stream_noncebytes"]=asm["_crypto_stream_noncebytes"];var _crypto_stream_primitive=Module["_crypto_stream_primitive"]=asm["_crypto_stream_primitive"];var _crypto_stream_salsa20=Module["_crypto_stream_salsa20"]=asm["_crypto_stream_salsa20"];var _crypto_stream_salsa2012=Module["_crypto_stream_salsa2012"]=asm["_crypto_stream_salsa2012"];var _crypto_stream_salsa2012_keybytes=Module["_crypto_stream_salsa2012_keybytes"]=asm["_crypto_stream_salsa2012_keybytes"];var _crypto_stream_salsa2012_keygen=Module["_crypto_stream_salsa2012_keygen"]=asm["_crypto_stream_salsa2012_keygen"];var _crypto_stream_salsa2012_noncebytes=Module["_crypto_stream_salsa2012_noncebytes"]=asm["_crypto_stream_salsa2012_noncebytes"];var _crypto_stream_salsa2012_xor=Module["_crypto_stream_salsa2012_xor"]=asm["_crypto_stream_salsa2012_xor"];var _crypto_stream_salsa208=Module["_crypto_stream_salsa208"]=asm["_crypto_stream_salsa208"];var _crypto_stream_salsa208_keybytes=Module["_crypto_stream_salsa208_keybytes"]=asm["_crypto_stream_salsa208_keybytes"];var _crypto_stream_salsa208_keygen=Module["_crypto_stream_salsa208_keygen"]=asm["_crypto_stream_salsa208_keygen"];var _crypto_stream_salsa208_messagebytes_max=Module["_crypto_stream_salsa208_messagebytes_max"]=asm["_crypto_stream_salsa208_messagebytes_max"];var _crypto_stream_salsa208_noncebytes=Module["_crypto_stream_salsa208_noncebytes"]=asm["_crypto_stream_salsa208_noncebytes"];var _crypto_stream_salsa208_xor=Module["_crypto_stream_salsa208_xor"]=asm["_crypto_stream_salsa208_xor"];var _crypto_stream_salsa20_keybytes=Module["_crypto_stream_salsa20_keybytes"]=asm["_crypto_stream_salsa20_keybytes"];var _crypto_stream_salsa20_keygen=Module["_crypto_stream_salsa20_keygen"]=asm["_crypto_stream_salsa20_keygen"];var _crypto_stream_salsa20_noncebytes=Module["_crypto_stream_salsa20_noncebytes"]=asm["_crypto_stream_salsa20_noncebytes"];var _crypto_stream_salsa20_xor=Module["_crypto_stream_salsa20_xor"]=asm["_crypto_stream_salsa20_xor"];var _crypto_stream_salsa20_xor_ic=Module["_crypto_stream_salsa20_xor_ic"]=asm["_crypto_stream_salsa20_xor_ic"];var _crypto_stream_xchacha20=Module["_crypto_stream_xchacha20"]=asm["_crypto_stream_xchacha20"];var _crypto_stream_xchacha20_keybytes=Module["_crypto_stream_xchacha20_keybytes"]=asm["_crypto_stream_xchacha20_keybytes"];var _crypto_stream_xchacha20_keygen=Module["_crypto_stream_xchacha20_keygen"]=asm["_crypto_stream_xchacha20_keygen"];var _crypto_stream_xchacha20_noncebytes=Module["_crypto_stream_xchacha20_noncebytes"]=asm["_crypto_stream_xchacha20_noncebytes"];var _crypto_stream_xchacha20_xor=Module["_crypto_stream_xchacha20_xor"]=asm["_crypto_stream_xchacha20_xor"];var _crypto_stream_xchacha20_xor_ic=Module["_crypto_stream_xchacha20_xor_ic"]=asm["_crypto_stream_xchacha20_xor_ic"];var _crypto_stream_xor=Module["_crypto_stream_xor"]=asm["_crypto_stream_xor"];var _crypto_stream_xsalsa20=Module["_crypto_stream_xsalsa20"]=asm["_crypto_stream_xsalsa20"];var _crypto_stream_xsalsa20_keybytes=Module["_crypto_stream_xsalsa20_keybytes"]=asm["_crypto_stream_xsalsa20_keybytes"];var _crypto_stream_xsalsa20_keygen=Module["_crypto_stream_xsalsa20_keygen"]=asm["_crypto_stream_xsalsa20_keygen"];var _crypto_stream_xsalsa20_noncebytes=Module["_crypto_stream_xsalsa20_noncebytes"]=asm["_crypto_stream_xsalsa20_noncebytes"];var _crypto_stream_xsalsa20_xor=Module["_crypto_stream_xsalsa20_xor"]=asm["_crypto_stream_xsalsa20_xor"];var _crypto_stream_xsalsa20_xor_ic=Module["_crypto_stream_xsalsa20_xor_ic"]=asm["_crypto_stream_xsalsa20_xor_ic"];var _crypto_verify_16=Module["_crypto_verify_16"]=asm["_crypto_verify_16"];var _crypto_verify_16_bytes=Module["_crypto_verify_16_bytes"]=asm["_crypto_verify_16_bytes"];var _crypto_verify_32=Module["_crypto_verify_32"]=asm["_crypto_verify_32"];var _crypto_verify_32_bytes=Module["_crypto_verify_32_bytes"]=asm["_crypto_verify_32_bytes"];var _crypto_verify_64=Module["_crypto_verify_64"]=asm["_crypto_verify_64"];var _crypto_verify_64_bytes=Module["_crypto_verify_64_bytes"]=asm["_crypto_verify_64_bytes"];var _emscripten_replace_memory=Module["_emscripten_replace_memory"]=asm["_emscripten_replace_memory"];var _free=Module["_free"]=asm["_free"];var _i64Add=Module["_i64Add"]=asm["_i64Add"];var _i64Subtract=Module["_i64Subtract"]=asm["_i64Subtract"];var _malloc=Module["_malloc"]=asm["_malloc"];var _memcpy=Module["_memcpy"]=asm["_memcpy"];var _memmove=Module["_memmove"]=asm["_memmove"];var _memset=Module["_memset"]=asm["_memset"];var _randombytes=Module["_randombytes"]=asm["_randombytes"];var _randombytes_buf=Module["_randombytes_buf"]=asm["_randombytes_buf"];var _randombytes_buf_deterministic=Module["_randombytes_buf_deterministic"]=asm["_randombytes_buf_deterministic"];var _randombytes_close=Module["_randombytes_close"]=asm["_randombytes_close"];var _randombytes_implementation_name=Module["_randombytes_implementation_name"]=asm["_randombytes_implementation_name"];var _randombytes_random=Module["_randombytes_random"]=asm["_randombytes_random"];var _randombytes_seedbytes=Module["_randombytes_seedbytes"]=asm["_randombytes_seedbytes"];var _randombytes_stir=Module["_randombytes_stir"]=asm["_randombytes_stir"];var _randombytes_uniform=Module["_randombytes_uniform"]=asm["_randombytes_uniform"];var _sbrk=Module["_sbrk"]=asm["_sbrk"];var _sodium_base642bin=Module["_sodium_base642bin"]=asm["_sodium_base642bin"];var _sodium_base64_encoded_len=Module["_sodium_base64_encoded_len"]=asm["_sodium_base64_encoded_len"];var _sodium_bin2base64=Module["_sodium_bin2base64"]=asm["_sodium_bin2base64"];var _sodium_bin2hex=Module["_sodium_bin2hex"]=asm["_sodium_bin2hex"];var _sodium_hex2bin=Module["_sodium_hex2bin"]=asm["_sodium_hex2bin"];var _sodium_init=Module["_sodium_init"]=asm["_sodium_init"];var _sodium_library_minimal=Module["_sodium_library_minimal"]=asm["_sodium_library_minimal"];var _sodium_library_version_major=Module["_sodium_library_version_major"]=asm["_sodium_library_version_major"];var _sodium_library_version_minor=Module["_sodium_library_version_minor"]=asm["_sodium_library_version_minor"];var _sodium_pad=Module["_sodium_pad"]=asm["_sodium_pad"];var _sodium_unpad=Module["_sodium_unpad"]=asm["_sodium_unpad"];var _sodium_version_string=Module["_sodium_version_string"]=asm["_sodium_version_string"];var establishStackSpace=Module["establishStackSpace"]=asm["establishStackSpace"];var getTempRet0=Module["getTempRet0"]=asm["getTempRet0"];var runPostSets=Module["runPostSets"]=asm["runPostSets"];var setTempRet0=Module["setTempRet0"]=asm["setTempRet0"];var setThrew=Module["setThrew"]=asm["setThrew"];var stackAlloc=Module["stackAlloc"]=asm["stackAlloc"];var stackRestore=Module["stackRestore"]=asm["stackRestore"];var stackSave=Module["stackSave"]=asm["stackSave"];Module["asm"]=asm;Module["setValue"]=setValue;Module["getValue"]=getValue;Module["Pointer_stringify"]=Pointer_stringify;if(memoryInitializer){if(!isDataURI(memoryInitializer)){memoryInitializer=locateFile(memoryInitializer)}if(ENVIRONMENT_IS_NODE||ENVIRONMENT_IS_SHELL){var data=Module["readBinary"](memoryInitializer);HEAPU8.set(data,GLOBAL_BASE)}else{addRunDependency("memory initializer");var applyMemoryInitializer=(function(data){if(data.byteLength)data=new Uint8Array(data);HEAPU8.set(data,GLOBAL_BASE);if(Module["memoryInitializerRequest"])delete Module["memoryInitializerRequest"].response;removeRunDependency("memory initializer")});function doBrowserLoad(){Module["readAsync"](memoryInitializer,applyMemoryInitializer,(function(){throw"could not load memory initializer "+memoryInitializer}))}var memoryInitializerBytes=tryParseAsDataURI(memoryInitializer);if(memoryInitializerBytes){applyMemoryInitializer(memoryInitializerBytes.buffer)}else if(Module["memoryInitializerRequest"]){function useRequest(){var request=Module["memoryInitializerRequest"];var response=request.response;if(request.status!==200&&request.status!==0){var data=tryParseAsDataURI(Module["memoryInitializerRequestURL"]);if(data){response=data.buffer}else{console.warn("a problem seems to have happened with Module.memoryInitializerRequest, status: "+request.status+", retrying "+memoryInitializer);doBrowserLoad();return}}applyMemoryInitializer(response)}if(Module["memoryInitializerRequest"].response){setTimeout(useRequest,0)}else{Module["memoryInitializerRequest"].addEventListener("load",useRequest)}}else{doBrowserLoad()}}}function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}ExitStatus.prototype=new Error;ExitStatus.prototype.constructor=ExitStatus;var initialStackTop;dependenciesFulfilled=function runCaller(){if(!Module["calledRun"])run();if(!Module["calledRun"])dependenciesFulfilled=runCaller};function run(args){args=args||Module["arguments"];if(runDependencies>0){return}preRun();if(runDependencies>0)return;if(Module["calledRun"])return;function doRun(){if(Module["calledRun"])return;Module["calledRun"]=true;if(ABORT)return;ensureInitRuntime();preMain();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout((function(){setTimeout((function(){Module["setStatus"]("")}),1);doRun()}),1)}else{doRun()}}Module["run"]=run;function abort(what){if(Module["onAbort"]){Module["onAbort"](what)}if(what!==undefined){out(what);err(what);what=JSON.stringify(what)}else{what=""}ABORT=true;EXITSTATUS=1;throw"abort("+what+"). Build with -s ASSERTIONS=1 for more info."}Module["abort"]=abort;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}Module["noExitRuntime"]=true;run() | |
20581 | }; | |
20582 | var Module=typeof Module!=="undefined"?Module:{};var moduleOverrides={};var key;for(key in Module){if(Module.hasOwnProperty(key)){moduleOverrides[key]=Module[key]}}Module["arguments"]=[];Module["thisProgram"]="./this.program";Module["quit"]=(function(status,toThrow){throw toThrow});Module["preRun"]=[];Module["postRun"]=[];var ENVIRONMENT_IS_WEB=false;var ENVIRONMENT_IS_WORKER=false;var ENVIRONMENT_IS_NODE=false;var ENVIRONMENT_IS_SHELL=false;ENVIRONMENT_IS_WEB=typeof window==="object";ENVIRONMENT_IS_WORKER=typeof importScripts==="function";ENVIRONMENT_IS_NODE=typeof process==="object"&&typeof require==="function"&&!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_WORKER;ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}else{return scriptDirectory+path}}if(ENVIRONMENT_IS_NODE){scriptDirectory=__dirname+"/";var nodeFS;var nodePath;Module["read"]=function shell_read(filename,binary){var ret;ret=tryParseAsDataURI(filename);if(!ret){if(!nodeFS)nodeFS=require("fs");if(!nodePath)nodePath=require("path");filename=nodePath["normalize"](filename);ret=nodeFS["readFileSync"](filename)}return binary?ret:ret.toString()};Module["readBinary"]=function readBinary(filename){var ret=Module["read"](filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};if(process["argv"].length>1){Module["thisProgram"]=process["argv"][1].replace(/\\/g,"/")}Module["arguments"]=process["argv"].slice(2);if(typeof module!=="undefined"){module["exports"]=Module}process["on"]("unhandledRejection",abort);Module["quit"]=(function(status){process["exit"](status)});Module["inspect"]=(function(){return"[Emscripten Module object]"})}else if(ENVIRONMENT_IS_SHELL){if(typeof read!="undefined"){Module["read"]=function shell_read(f){var data=tryParseAsDataURI(f);if(data){return intArrayToString(data)}return read(f)}}Module["readBinary"]=function readBinary(f){var data;data=tryParseAsDataURI(f);if(data){return data}if(typeof readbuffer==="function"){return new Uint8Array(readbuffer(f))}data=read(f,"binary");assert(typeof data==="object");return data};if(typeof scriptArgs!="undefined"){Module["arguments"]=scriptArgs}else if(typeof arguments!="undefined"){Module["arguments"]=arguments}if(typeof quit==="function"){Module["quit"]=(function(status){quit(status)})}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(document.currentScript){scriptDirectory=document.currentScript.src}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.lastIndexOf("/")+1)}else{scriptDirectory=""}Module["read"]=function shell_read(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){Module["readBinary"]=function readBinary(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}}}Module["readAsync"]=function readAsync(url,onload,onerror){var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=function xhr_onload(){if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror()};xhr.onerror=onerror;xhr.send(null)};Module["setWindowTitle"]=(function(title){document.title=title})}else{}var out=Module["print"]||(typeof console!=="undefined"?console.log.bind(console):typeof print!=="undefined"?print:null);var err=Module["printErr"]||(typeof printErr!=="undefined"?printErr:typeof console!=="undefined"&&console.warn.bind(console)||out);for(key in moduleOverrides){if(moduleOverrides.hasOwnProperty(key)){Module[key]=moduleOverrides[key]}}moduleOverrides=undefined;var STACK_ALIGN=16;function staticAlloc(size){var ret=STATICTOP;STATICTOP=STATICTOP+size+15&-16;return ret}function alignMemory(size,factor){if(!factor)factor=STACK_ALIGN;var ret=size=Math.ceil(size/factor)*factor;return ret}var asm2wasmImports={"f64-rem":(function(x,y){return x%y}),"debugger":(function(){debugger})};var functionPointers=new Array(8);var GLOBAL_BASE=1024;var ABORT=false;var EXITSTATUS=0;function assert(condition,text){if(!condition){abort("Assertion failed: "+text)}}function setValue(ptr,value,type,noSafe){type=type||"i8";if(type.charAt(type.length-1)==="*")type="i32";switch(type){case"i1":HEAP8[ptr>>0]=value;break;case"i8":HEAP8[ptr>>0]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":tempI64=[value>>>0,(tempDouble=value,+Math_abs(tempDouble)>=1?tempDouble>0?(Math_min(+Math_floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math_ceil((tempDouble- +(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[ptr>>2]=tempI64[0],HEAP32[ptr+4>>2]=tempI64[1];break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;default:abort("invalid type for setValue: "+type)}}function getValue(ptr,type,noSafe){type=type||"i8";if(type.charAt(type.length-1)==="*")type="i32";switch(type){case"i1":return HEAP8[ptr>>0];case"i8":return HEAP8[ptr>>0];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":return HEAP32[ptr>>2];case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];default:abort("invalid type for getValue: "+type)}return null}function Pointer_stringify(ptr,length){if(length===0||!ptr)return"";var hasUtf=0;var t;var i=0;while(1){t=HEAPU8[ptr+i>>0];hasUtf|=t;if(t==0&&!length)break;i++;if(length&&i==length)break}if(!length)length=i;var ret="";if(hasUtf<128){var MAX_CHUNK=1024;var curr;while(length>0){curr=String.fromCharCode.apply(String,HEAPU8.subarray(ptr,ptr+Math.min(length,MAX_CHUNK)));ret=ret?ret+curr:curr;ptr+=MAX_CHUNK;length-=MAX_CHUNK}return ret}return UTF8ToString(ptr)}var UTF8Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(u8Array,idx){var endPtr=idx;while(u8Array[endPtr])++endPtr;if(endPtr-idx>16&&u8Array.subarray&&UTF8Decoder){return UTF8Decoder.decode(u8Array.subarray(idx,endPtr))}else{var u0,u1,u2,u3,u4,u5;var str="";while(1){u0=u8Array[idx++];if(!u0)return str;if(!(u0&128)){str+=String.fromCharCode(u0);continue}u1=u8Array[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}u2=u8Array[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u3=u8Array[idx++]&63;if((u0&248)==240){u0=(u0&7)<<18|u1<<12|u2<<6|u3}else{u4=u8Array[idx++]&63;if((u0&252)==248){u0=(u0&3)<<24|u1<<18|u2<<12|u3<<6|u4}else{u5=u8Array[idx++]&63;u0=(u0&1)<<30|u1<<24|u2<<18|u3<<12|u4<<6|u5}}}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}}}function UTF8ToString(ptr){return UTF8ArrayToString(HEAPU8,ptr)}var UTF16Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf-16le"):undefined;var PAGE_SIZE=16384;var WASM_PAGE_SIZE=65536;var ASMJS_PAGE_SIZE=16777216;var MIN_TOTAL_MEMORY=16777216;function alignUp(x,multiple){if(x%multiple>0){x+=multiple-x%multiple}return x}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBuffer(buf){Module["buffer"]=buffer=buf}function updateGlobalBufferViews(){Module["HEAP8"]=HEAP8=new Int8Array(buffer);Module["HEAP16"]=HEAP16=new Int16Array(buffer);Module["HEAP32"]=HEAP32=new Int32Array(buffer);Module["HEAPU8"]=HEAPU8=new Uint8Array(buffer);Module["HEAPU16"]=HEAPU16=new Uint16Array(buffer);Module["HEAPU32"]=HEAPU32=new Uint32Array(buffer);Module["HEAPF32"]=HEAPF32=new Float32Array(buffer);Module["HEAPF64"]=HEAPF64=new Float64Array(buffer)}var STATIC_BASE,STATICTOP,staticSealed;var STACK_BASE,STACKTOP,STACK_MAX;var DYNAMIC_BASE,DYNAMICTOP_PTR;STATIC_BASE=STATICTOP=STACK_BASE=STACKTOP=STACK_MAX=DYNAMIC_BASE=DYNAMICTOP_PTR=0;staticSealed=false;function abortOnCannotGrowMemory(){abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value "+TOTAL_MEMORY+", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ")}if(!Module["reallocBuffer"])Module["reallocBuffer"]=(function(size){var ret;try{var oldHEAP8=HEAP8;ret=new ArrayBuffer(size);var temp=new Int8Array(ret);temp.set(oldHEAP8)}catch(e){return false}var success=_emscripten_replace_memory(ret);if(!success)return false;return ret});function enlargeMemory(){var PAGE_MULTIPLE=Module["usingWasm"]?WASM_PAGE_SIZE:ASMJS_PAGE_SIZE;var LIMIT=2147483648-PAGE_MULTIPLE;if(HEAP32[DYNAMICTOP_PTR>>2]>LIMIT){return false}var OLD_TOTAL_MEMORY=TOTAL_MEMORY;TOTAL_MEMORY=Math.max(TOTAL_MEMORY,MIN_TOTAL_MEMORY);while(TOTAL_MEMORY<HEAP32[DYNAMICTOP_PTR>>2]){if(TOTAL_MEMORY<=536870912){TOTAL_MEMORY=alignUp(2*TOTAL_MEMORY,PAGE_MULTIPLE)}else{TOTAL_MEMORY=Math.min(alignUp((3*TOTAL_MEMORY+2147483648)/4,PAGE_MULTIPLE),LIMIT)}}var replacement=Module["reallocBuffer"](TOTAL_MEMORY);if(!replacement||replacement.byteLength!=TOTAL_MEMORY){TOTAL_MEMORY=OLD_TOTAL_MEMORY;return false}updateGlobalBuffer(replacement);updateGlobalBufferViews();return true}var byteLength;try{byteLength=Function.prototype.call.bind(Object.getOwnPropertyDescriptor(ArrayBuffer.prototype,"byteLength").get);byteLength(new ArrayBuffer(4))}catch(e){byteLength=(function(buffer){return buffer.byteLength})}var TOTAL_STACK=Module["TOTAL_STACK"]||5242880;var TOTAL_MEMORY=Module["TOTAL_MEMORY"]||16777216;if(TOTAL_MEMORY<TOTAL_STACK)err("TOTAL_MEMORY should be larger than TOTAL_STACK, was "+TOTAL_MEMORY+"! (TOTAL_STACK="+TOTAL_STACK+")");if(Module["buffer"]){buffer=Module["buffer"]}else{if(typeof WebAssembly==="object"&&typeof WebAssembly.Memory==="function"){Module["wasmMemory"]=new WebAssembly.Memory({"initial":TOTAL_MEMORY/WASM_PAGE_SIZE});buffer=Module["wasmMemory"].buffer}else{buffer=new ArrayBuffer(TOTAL_MEMORY)}Module["buffer"]=buffer}updateGlobalBufferViews();function getTotalMemory(){return TOTAL_MEMORY}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback();continue}var func=callback.func;if(typeof func==="number"){if(callback.arg===undefined){Module["dynCall_v"](func)}else{Module["dynCall_vi"](func,callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var __ATPRERUN__=[];var __ATINIT__=[];var __ATMAIN__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function ensureInitRuntime(){if(runtimeInitialized)return;runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function preMain(){callRuntimeCallbacks(__ATMAIN__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var Math_abs=Math.abs;var Math_ceil=Math.ceil;var Math_floor=Math.floor;var Math_min=Math.min;var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}Module["preloadedImages"]={};Module["preloadedAudios"]={};var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return String.prototype.startsWith?filename.startsWith(dataURIPrefix):filename.indexOf(dataURIPrefix)===0}function integrateWasmJS(){var wasmTextFile="";var wasmBinaryFile="data:application/octet-stream;base64,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";var asmjsCodeFile="";if(!isDataURI(wasmTextFile)){wasmTextFile=locateFile(wasmTextFile)}if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}if(!isDataURI(asmjsCodeFile)){asmjsCodeFile=locateFile(asmjsCodeFile)}var wasmPageSize=64*1024;var info={"global":null,"env":null,"asm2wasm":asm2wasmImports,"parent":Module};var exports=null;function mergeMemory(newBuffer){var oldBuffer=Module["buffer"];if(newBuffer.byteLength<oldBuffer.byteLength){err("the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here")}var oldView=new Int8Array(oldBuffer);var newView=new Int8Array(newBuffer);newView.set(oldView);updateGlobalBuffer(newBuffer);updateGlobalBufferViews()}function getBinary(){try{if(Module["wasmBinary"]){return new Uint8Array(Module["wasmBinary"])}var binary=tryParseAsDataURI(wasmBinaryFile);if(binary){return binary}if(Module["readBinary"]){return Module["readBinary"](wasmBinaryFile)}else{throw"both async and sync fetching of the wasm failed"}}catch(err){abort(err)}}function getBinaryPromise(){if(!Module["wasmBinary"]&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)&&typeof fetch==="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then((function(response){if(!response["ok"]){throw"failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()})).catch((function(){return getBinary()}))}return new Promise((function(resolve,reject){resolve(getBinary())}))}function doNativeWasm(global,env,providedBuffer){if(typeof WebAssembly!=="object"){err("no native wasm support detected");return false}if(!(Module["wasmMemory"]instanceof WebAssembly.Memory)){err("no native wasm Memory in use");return false}env["memory"]=Module["wasmMemory"];info["global"]={"NaN":NaN,"Infinity":Infinity};info["global.Math"]=Math;info["env"]=env;function receiveInstance(instance,module){exports=instance.exports;if(exports.memory)mergeMemory(exports.memory);Module["asm"]=exports;Module["usingWasm"]=true;removeRunDependency("wasm-instantiate")}addRunDependency("wasm-instantiate");if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}function receiveInstantiatedSource(output){receiveInstance(output["instance"],output["module"])}function instantiateArrayBuffer(receiver){getBinaryPromise().then((function(binary){return WebAssembly.instantiate(binary,info)})).then(receiver,(function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason)}))}if(!Module["wasmBinary"]&&typeof WebAssembly.instantiateStreaming==="function"&&!isDataURI(wasmBinaryFile)&&typeof fetch==="function"){WebAssembly.instantiateStreaming(fetch(wasmBinaryFile,{credentials:"same-origin"}),info).then(receiveInstantiatedSource,(function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");instantiateArrayBuffer(receiveInstantiatedSource)}))}else{instantiateArrayBuffer(receiveInstantiatedSource)}return{}}Module["asmPreload"]=Module["asm"];var asmjsReallocBuffer=Module["reallocBuffer"];var wasmReallocBuffer=(function(size){var PAGE_MULTIPLE=Module["usingWasm"]?WASM_PAGE_SIZE:ASMJS_PAGE_SIZE;size=alignUp(size,PAGE_MULTIPLE);var old=Module["buffer"];var oldSize=old.byteLength;if(Module["usingWasm"]){try{var result=Module["wasmMemory"].grow((size-oldSize)/wasmPageSize);if(result!==(-1|0)){return Module["buffer"]=Module["wasmMemory"].buffer}else{return null}}catch(e){return null}}});Module["reallocBuffer"]=(function(size){if(finalMethod==="asmjs"){return asmjsReallocBuffer(size)}else{return wasmReallocBuffer(size)}});var finalMethod="";Module["asm"]=(function(global,env,providedBuffer){if(!env["table"]){var TABLE_SIZE=Module["wasmTableSize"];if(TABLE_SIZE===undefined)TABLE_SIZE=1024;var MAX_TABLE_SIZE=Module["wasmMaxTableSize"];if(typeof WebAssembly==="object"&&typeof WebAssembly.Table==="function"){if(MAX_TABLE_SIZE!==undefined){env["table"]=new WebAssembly.Table({"initial":TABLE_SIZE,"maximum":MAX_TABLE_SIZE,"element":"anyfunc"})}else{env["table"]=new WebAssembly.Table({"initial":TABLE_SIZE,element:"anyfunc"})}}else{env["table"]=new Array(TABLE_SIZE)}Module["wasmTable"]=env["table"]}if(!env["__memory_base"]){env["__memory_base"]=Module["STATIC_BASE"]}if(!env["__table_base"]){env["__table_base"]=0}var exports;exports=doNativeWasm(global,env,providedBuffer);assert(exports,"no binaryen method succeeded.");return exports})}integrateWasmJS();var ASM_CONSTS=[(function(){return Module.getRandomValue()}),(function(){if(Module.getRandomValue===undefined){try{var window_="object"===typeof window?window:self;var crypto_=typeof window_.crypto!=="undefined"?window_.crypto:window_.msCrypto;var randomValuesStandard=(function(){var buf=new Uint32Array(1);crypto_.getRandomValues(buf);return buf[0]>>>0});randomValuesStandard();Module.getRandomValue=randomValuesStandard}catch(e){try{var crypto=require("crypto");var randomValueNodeJS=(function(){var buf=crypto["randomBytes"](4);return(buf[0]<<24|buf[1]<<16|buf[2]<<8|buf[3])>>>0});randomValueNodeJS();Module.getRandomValue=randomValueNodeJS}catch(e){throw"No secure random number generator found"}}}})];function _emscripten_asm_const_i(code){return ASM_CONSTS[code]()}STATIC_BASE=GLOBAL_BASE;STATICTOP=STATIC_BASE+37024;__ATINIT__.push();var STATIC_BUMP=37024;Module["STATIC_BASE"]=STATIC_BASE;Module["STATIC_BUMP"]=STATIC_BUMP;STATICTOP+=16;function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+Pointer_stringify(condition)+", at: "+[filename?Pointer_stringify(filename):"unknown filename",line,func?Pointer_stringify(func):"unknown function"])}function _abort(){Module["abort"]()}function _emscripten_memcpy_big(dest,src,num){HEAPU8.set(HEAPU8.subarray(src,src+num),dest);return dest}function ___setErrNo(value){if(Module["___errno_location"])HEAP32[Module["___errno_location"]()>>2]=value;return value}var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};function _sysconf(name){switch(name){case 30:return PAGE_SIZE;case 85:var maxHeapSize=2*1024*1024*1024-65536;return maxHeapSize/PAGE_SIZE;case 132:case 133:case 12:case 137:case 138:case 15:case 235:case 16:case 17:case 18:case 19:case 20:case 149:case 13:case 10:case 236:case 153:case 9:case 21:case 22:case 159:case 154:case 14:case 77:case 78:case 139:case 80:case 81:case 82:case 68:case 67:case 164:case 11:case 29:case 47:case 48:case 95:case 52:case 51:case 46:return 200809;case 79:return 0;case 27:case 246:case 127:case 128:case 23:case 24:case 160:case 161:case 181:case 182:case 242:case 183:case 184:case 243:case 244:case 245:case 165:case 178:case 179:case 49:case 50:case 168:case 169:case 175:case 170:case 171:case 172:case 97:case 76:case 32:case 173:case 35:return-1;case 176:case 177:case 7:case 155:case 8:case 157:case 125:case 126:case 92:case 93:case 129:case 130:case 131:case 94:case 91:return 1;case 74:case 60:case 69:case 70:case 4:return 1024;case 31:case 42:case 72:return 32;case 87:case 26:case 33:return 2147483647;case 34:case 1:return 47839;case 38:case 36:return 99;case 43:case 37:return 2048;case 0:return 2097152;case 3:return 65536;case 28:return 32768;case 44:return 32767;case 75:return 16384;case 39:return 1e3;case 89:return 700;case 71:return 256;case 40:return 255;case 2:return 100;case 180:return 64;case 25:return 20;case 5:return 16;case 6:return 6;case 73:return 4;case 84:{if(typeof navigator==="object")return navigator["hardwareConcurrency"]||1;return 1}}___setErrNo(ERRNO_CODES.EINVAL);return-1}DYNAMICTOP_PTR=staticAlloc(4);STACK_BASE=STACKTOP=alignMemory(STATICTOP);STACK_MAX=STACK_BASE+TOTAL_STACK;DYNAMIC_BASE=alignMemory(STACK_MAX);HEAP32[DYNAMICTOP_PTR>>2]=DYNAMIC_BASE;staticSealed=true;var ASSERTIONS=false;function intArrayToString(array){var ret=[];for(var i=0;i<array.length;i++){var chr=array[i];if(chr>255){if(ASSERTIONS){assert(false,"Character code "+chr+" ("+String.fromCharCode(chr)+") at offset "+i+" not in 0x00-0xFF.")}chr&=255}ret.push(String.fromCharCode(chr))}return ret.join("")}var decodeBase64=typeof atob==="function"?atob:(function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(i<input.length);return output});function intArrayFromBase64(s){if(typeof ENVIRONMENT_IS_NODE==="boolean"&&ENVIRONMENT_IS_NODE){var buf;try{buf=Buffer.from(s,"base64")}catch(_){buf=new Buffer(s,"base64")}return new Uint8Array(buf.buffer,buf.byteOffset,buf.byteLength)}try{var decoded=decodeBase64(s);var bytes=new Uint8Array(decoded.length);for(var i=0;i<decoded.length;++i){bytes[i]=decoded.charCodeAt(i)}return bytes}catch(_){throw new Error("Converting base64 string to bytes failed.")}}function tryParseAsDataURI(filename){if(!isDataURI(filename)){return}return intArrayFromBase64(filename.slice(dataURIPrefix.length))}Module["wasmTableSize"]=0;Module["wasmMaxTableSize"]=0;Module.asmGlobalArg={};Module.asmLibraryArg={"k":enlargeMemory,"j":getTotalMemory,"i":abortOnCannotGrowMemory,"e":___assert_fail,"f":___setErrNo,"c":_abort,"d":_emscripten_asm_const_i,"h":_emscripten_memcpy_big,"g":_sysconf,"a":DYNAMICTOP_PTR,"b":STACKTOP};var asm=Module["asm"](Module.asmGlobalArg,Module.asmLibraryArg,buffer);Module["asm"]=asm;var ___errno_location=Module["___errno_location"]=(function(){return Module["asm"]["l"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_abytes=Module["_crypto_aead_chacha20poly1305_abytes"]=(function(){return Module["asm"]["m"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_decrypt=Module["_crypto_aead_chacha20poly1305_decrypt"]=(function(){return Module["asm"]["n"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_decrypt_detached=Module["_crypto_aead_chacha20poly1305_decrypt_detached"]=(function(){return Module["asm"]["o"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_encrypt=Module["_crypto_aead_chacha20poly1305_encrypt"]=(function(){return Module["asm"]["p"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_encrypt_detached=Module["_crypto_aead_chacha20poly1305_encrypt_detached"]=(function(){return Module["asm"]["q"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_abytes=Module["_crypto_aead_chacha20poly1305_ietf_abytes"]=(function(){return Module["asm"]["r"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_decrypt=Module["_crypto_aead_chacha20poly1305_ietf_decrypt"]=(function(){return Module["asm"]["s"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_decrypt_detached=Module["_crypto_aead_chacha20poly1305_ietf_decrypt_detached"]=(function(){return Module["asm"]["t"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_encrypt=Module["_crypto_aead_chacha20poly1305_ietf_encrypt"]=(function(){return Module["asm"]["u"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_encrypt_detached=Module["_crypto_aead_chacha20poly1305_ietf_encrypt_detached"]=(function(){return Module["asm"]["v"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_keybytes=Module["_crypto_aead_chacha20poly1305_ietf_keybytes"]=(function(){return Module["asm"]["w"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_keygen=Module["_crypto_aead_chacha20poly1305_ietf_keygen"]=(function(){return Module["asm"]["x"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_npubbytes=Module["_crypto_aead_chacha20poly1305_ietf_npubbytes"]=(function(){return Module["asm"]["y"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_ietf_nsecbytes=Module["_crypto_aead_chacha20poly1305_ietf_nsecbytes"]=(function(){return Module["asm"]["z"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_keybytes=Module["_crypto_aead_chacha20poly1305_keybytes"]=(function(){return Module["asm"]["A"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_keygen=Module["_crypto_aead_chacha20poly1305_keygen"]=(function(){return Module["asm"]["B"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_npubbytes=Module["_crypto_aead_chacha20poly1305_npubbytes"]=(function(){return Module["asm"]["C"].apply(null,arguments)});var _crypto_aead_chacha20poly1305_nsecbytes=Module["_crypto_aead_chacha20poly1305_nsecbytes"]=(function(){return Module["asm"]["D"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_abytes=Module["_crypto_aead_xchacha20poly1305_ietf_abytes"]=(function(){return Module["asm"]["E"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_decrypt=Module["_crypto_aead_xchacha20poly1305_ietf_decrypt"]=(function(){return Module["asm"]["F"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_decrypt_detached=Module["_crypto_aead_xchacha20poly1305_ietf_decrypt_detached"]=(function(){return Module["asm"]["G"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_encrypt=Module["_crypto_aead_xchacha20poly1305_ietf_encrypt"]=(function(){return Module["asm"]["H"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_encrypt_detached=Module["_crypto_aead_xchacha20poly1305_ietf_encrypt_detached"]=(function(){return Module["asm"]["I"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_keybytes=Module["_crypto_aead_xchacha20poly1305_ietf_keybytes"]=(function(){return Module["asm"]["J"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_keygen=Module["_crypto_aead_xchacha20poly1305_ietf_keygen"]=(function(){return Module["asm"]["K"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_npubbytes=Module["_crypto_aead_xchacha20poly1305_ietf_npubbytes"]=(function(){return Module["asm"]["L"].apply(null,arguments)});var _crypto_aead_xchacha20poly1305_ietf_nsecbytes=Module["_crypto_aead_xchacha20poly1305_ietf_nsecbytes"]=(function(){return Module["asm"]["M"].apply(null,arguments)});var _crypto_auth=Module["_crypto_auth"]=(function(){return Module["asm"]["N"].apply(null,arguments)});var _crypto_auth_bytes=Module["_crypto_auth_bytes"]=(function(){return Module["asm"]["O"].apply(null,arguments)});var _crypto_auth_hmacsha256=Module["_crypto_auth_hmacsha256"]=(function(){return Module["asm"]["P"].apply(null,arguments)});var _crypto_auth_hmacsha256_bytes=Module["_crypto_auth_hmacsha256_bytes"]=(function(){return Module["asm"]["Q"].apply(null,arguments)});var _crypto_auth_hmacsha256_final=Module["_crypto_auth_hmacsha256_final"]=(function(){return Module["asm"]["R"].apply(null,arguments)});var _crypto_auth_hmacsha256_init=Module["_crypto_auth_hmacsha256_init"]=(function(){return Module["asm"]["S"].apply(null,arguments)});var _crypto_auth_hmacsha256_keybytes=Module["_crypto_auth_hmacsha256_keybytes"]=(function(){return Module["asm"]["T"].apply(null,arguments)});var _crypto_auth_hmacsha256_keygen=Module["_crypto_auth_hmacsha256_keygen"]=(function(){return Module["asm"]["U"].apply(null,arguments)});var _crypto_auth_hmacsha256_statebytes=Module["_crypto_auth_hmacsha256_statebytes"]=(function(){return Module["asm"]["V"].apply(null,arguments)});var _crypto_auth_hmacsha256_update=Module["_crypto_auth_hmacsha256_update"]=(function(){return Module["asm"]["W"].apply(null,arguments)});var _crypto_auth_hmacsha256_verify=Module["_crypto_auth_hmacsha256_verify"]=(function(){return Module["asm"]["X"].apply(null,arguments)});var _crypto_auth_hmacsha512=Module["_crypto_auth_hmacsha512"]=(function(){return Module["asm"]["Y"].apply(null,arguments)});var _crypto_auth_hmacsha512256=Module["_crypto_auth_hmacsha512256"]=(function(){return Module["asm"]["Z"].apply(null,arguments)});var _crypto_auth_hmacsha512256_bytes=Module["_crypto_auth_hmacsha512256_bytes"]=(function(){return Module["asm"]["_"].apply(null,arguments)});var _crypto_auth_hmacsha512256_final=Module["_crypto_auth_hmacsha512256_final"]=(function(){return Module["asm"]["$"].apply(null,arguments)});var _crypto_auth_hmacsha512256_init=Module["_crypto_auth_hmacsha512256_init"]=(function(){return Module["asm"]["aa"].apply(null,arguments)});var _crypto_auth_hmacsha512256_keybytes=Module["_crypto_auth_hmacsha512256_keybytes"]=(function(){return Module["asm"]["ba"].apply(null,arguments)});var _crypto_auth_hmacsha512256_keygen=Module["_crypto_auth_hmacsha512256_keygen"]=(function(){return Module["asm"]["ca"].apply(null,arguments)});var _crypto_auth_hmacsha512256_statebytes=Module["_crypto_auth_hmacsha512256_statebytes"]=(function(){return Module["asm"]["da"].apply(null,arguments)});var _crypto_auth_hmacsha512256_update=Module["_crypto_auth_hmacsha512256_update"]=(function(){return Module["asm"]["ea"].apply(null,arguments)});var _crypto_auth_hmacsha512256_verify=Module["_crypto_auth_hmacsha512256_verify"]=(function(){return Module["asm"]["fa"].apply(null,arguments)});var _crypto_auth_hmacsha512_bytes=Module["_crypto_auth_hmacsha512_bytes"]=(function(){return Module["asm"]["ga"].apply(null,arguments)});var _crypto_auth_hmacsha512_final=Module["_crypto_auth_hmacsha512_final"]=(function(){return Module["asm"]["ha"].apply(null,arguments)});var _crypto_auth_hmacsha512_init=Module["_crypto_auth_hmacsha512_init"]=(function(){return Module["asm"]["ia"].apply(null,arguments)});var _crypto_auth_hmacsha512_keybytes=Module["_crypto_auth_hmacsha512_keybytes"]=(function(){return Module["asm"]["ja"].apply(null,arguments)});var _crypto_auth_hmacsha512_keygen=Module["_crypto_auth_hmacsha512_keygen"]=(function(){return Module["asm"]["ka"].apply(null,arguments)});var _crypto_auth_hmacsha512_statebytes=Module["_crypto_auth_hmacsha512_statebytes"]=(function(){return Module["asm"]["la"].apply(null,arguments)});var _crypto_auth_hmacsha512_update=Module["_crypto_auth_hmacsha512_update"]=(function(){return Module["asm"]["ma"].apply(null,arguments)});var _crypto_auth_hmacsha512_verify=Module["_crypto_auth_hmacsha512_verify"]=(function(){return Module["asm"]["na"].apply(null,arguments)});var _crypto_auth_keybytes=Module["_crypto_auth_keybytes"]=(function(){return Module["asm"]["oa"].apply(null,arguments)});var _crypto_auth_keygen=Module["_crypto_auth_keygen"]=(function(){return Module["asm"]["pa"].apply(null,arguments)});var _crypto_auth_primitive=Module["_crypto_auth_primitive"]=(function(){return Module["asm"]["qa"].apply(null,arguments)});var _crypto_auth_verify=Module["_crypto_auth_verify"]=(function(){return Module["asm"]["ra"].apply(null,arguments)});var _crypto_box=Module["_crypto_box"]=(function(){return Module["asm"]["sa"].apply(null,arguments)});var _crypto_box_afternm=Module["_crypto_box_afternm"]=(function(){return Module["asm"]["ta"].apply(null,arguments)});var _crypto_box_beforenm=Module["_crypto_box_beforenm"]=(function(){return Module["asm"]["ua"].apply(null,arguments)});var _crypto_box_beforenmbytes=Module["_crypto_box_beforenmbytes"]=(function(){return Module["asm"]["va"].apply(null,arguments)});var _crypto_box_boxzerobytes=Module["_crypto_box_boxzerobytes"]=(function(){return Module["asm"]["wa"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_beforenm=Module["_crypto_box_curve25519xchacha20poly1305_beforenm"]=(function(){return Module["asm"]["xa"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_beforenmbytes=Module["_crypto_box_curve25519xchacha20poly1305_beforenmbytes"]=(function(){return Module["asm"]["ya"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_detached=Module["_crypto_box_curve25519xchacha20poly1305_detached"]=(function(){return Module["asm"]["za"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_detached_afternm=Module["_crypto_box_curve25519xchacha20poly1305_detached_afternm"]=(function(){return Module["asm"]["Aa"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_easy=Module["_crypto_box_curve25519xchacha20poly1305_easy"]=(function(){return Module["asm"]["Ba"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_easy_afternm=Module["_crypto_box_curve25519xchacha20poly1305_easy_afternm"]=(function(){return Module["asm"]["Ca"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_keypair=Module["_crypto_box_curve25519xchacha20poly1305_keypair"]=(function(){return Module["asm"]["Da"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_macbytes=Module["_crypto_box_curve25519xchacha20poly1305_macbytes"]=(function(){return Module["asm"]["Ea"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_noncebytes=Module["_crypto_box_curve25519xchacha20poly1305_noncebytes"]=(function(){return Module["asm"]["Fa"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_open_detached=Module["_crypto_box_curve25519xchacha20poly1305_open_detached"]=(function(){return Module["asm"]["Ga"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_open_detached_afternm=Module["_crypto_box_curve25519xchacha20poly1305_open_detached_afternm"]=(function(){return Module["asm"]["Ha"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_open_easy=Module["_crypto_box_curve25519xchacha20poly1305_open_easy"]=(function(){return Module["asm"]["Ia"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_open_easy_afternm=Module["_crypto_box_curve25519xchacha20poly1305_open_easy_afternm"]=(function(){return Module["asm"]["Ja"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_publickeybytes=Module["_crypto_box_curve25519xchacha20poly1305_publickeybytes"]=(function(){return Module["asm"]["Ka"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_seal=Module["_crypto_box_curve25519xchacha20poly1305_seal"]=(function(){return Module["asm"]["La"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_seal_open=Module["_crypto_box_curve25519xchacha20poly1305_seal_open"]=(function(){return Module["asm"]["Ma"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_sealbytes=Module["_crypto_box_curve25519xchacha20poly1305_sealbytes"]=(function(){return Module["asm"]["Na"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_secretkeybytes=Module["_crypto_box_curve25519xchacha20poly1305_secretkeybytes"]=(function(){return Module["asm"]["Oa"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_seed_keypair=Module["_crypto_box_curve25519xchacha20poly1305_seed_keypair"]=(function(){return Module["asm"]["Pa"].apply(null,arguments)});var _crypto_box_curve25519xchacha20poly1305_seedbytes=Module["_crypto_box_curve25519xchacha20poly1305_seedbytes"]=(function(){return Module["asm"]["Qa"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305=Module["_crypto_box_curve25519xsalsa20poly1305"]=(function(){return Module["asm"]["Ra"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_afternm=Module["_crypto_box_curve25519xsalsa20poly1305_afternm"]=(function(){return Module["asm"]["Sa"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_beforenm=Module["_crypto_box_curve25519xsalsa20poly1305_beforenm"]=(function(){return Module["asm"]["Ta"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_beforenmbytes=Module["_crypto_box_curve25519xsalsa20poly1305_beforenmbytes"]=(function(){return Module["asm"]["Ua"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_boxzerobytes=Module["_crypto_box_curve25519xsalsa20poly1305_boxzerobytes"]=(function(){return Module["asm"]["Va"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_keypair=Module["_crypto_box_curve25519xsalsa20poly1305_keypair"]=(function(){return Module["asm"]["Wa"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_macbytes=Module["_crypto_box_curve25519xsalsa20poly1305_macbytes"]=(function(){return Module["asm"]["Xa"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_noncebytes=Module["_crypto_box_curve25519xsalsa20poly1305_noncebytes"]=(function(){return Module["asm"]["Ya"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_open=Module["_crypto_box_curve25519xsalsa20poly1305_open"]=(function(){return Module["asm"]["Za"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_open_afternm=Module["_crypto_box_curve25519xsalsa20poly1305_open_afternm"]=(function(){return Module["asm"]["_a"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_publickeybytes=Module["_crypto_box_curve25519xsalsa20poly1305_publickeybytes"]=(function(){return Module["asm"]["$a"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_secretkeybytes=Module["_crypto_box_curve25519xsalsa20poly1305_secretkeybytes"]=(function(){return Module["asm"]["ab"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_seed_keypair=Module["_crypto_box_curve25519xsalsa20poly1305_seed_keypair"]=(function(){return Module["asm"]["bb"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_seedbytes=Module["_crypto_box_curve25519xsalsa20poly1305_seedbytes"]=(function(){return Module["asm"]["cb"].apply(null,arguments)});var _crypto_box_curve25519xsalsa20poly1305_zerobytes=Module["_crypto_box_curve25519xsalsa20poly1305_zerobytes"]=(function(){return Module["asm"]["db"].apply(null,arguments)});var _crypto_box_detached=Module["_crypto_box_detached"]=(function(){return Module["asm"]["eb"].apply(null,arguments)});var _crypto_box_detached_afternm=Module["_crypto_box_detached_afternm"]=(function(){return Module["asm"]["fb"].apply(null,arguments)});var _crypto_box_easy=Module["_crypto_box_easy"]=(function(){return Module["asm"]["gb"].apply(null,arguments)});var _crypto_box_easy_afternm=Module["_crypto_box_easy_afternm"]=(function(){return Module["asm"]["hb"].apply(null,arguments)});var _crypto_box_keypair=Module["_crypto_box_keypair"]=(function(){return Module["asm"]["ib"].apply(null,arguments)});var _crypto_box_macbytes=Module["_crypto_box_macbytes"]=(function(){return Module["asm"]["jb"].apply(null,arguments)});var _crypto_box_noncebytes=Module["_crypto_box_noncebytes"]=(function(){return Module["asm"]["kb"].apply(null,arguments)});var _crypto_box_open=Module["_crypto_box_open"]=(function(){return Module["asm"]["lb"].apply(null,arguments)});var _crypto_box_open_afternm=Module["_crypto_box_open_afternm"]=(function(){return Module["asm"]["mb"].apply(null,arguments)});var _crypto_box_open_detached=Module["_crypto_box_open_detached"]=(function(){return Module["asm"]["nb"].apply(null,arguments)});var _crypto_box_open_detached_afternm=Module["_crypto_box_open_detached_afternm"]=(function(){return Module["asm"]["ob"].apply(null,arguments)});var _crypto_box_open_easy=Module["_crypto_box_open_easy"]=(function(){return Module["asm"]["pb"].apply(null,arguments)});var _crypto_box_open_easy_afternm=Module["_crypto_box_open_easy_afternm"]=(function(){return Module["asm"]["qb"].apply(null,arguments)});var _crypto_box_primitive=Module["_crypto_box_primitive"]=(function(){return Module["asm"]["rb"].apply(null,arguments)});var _crypto_box_publickeybytes=Module["_crypto_box_publickeybytes"]=(function(){return Module["asm"]["sb"].apply(null,arguments)});var _crypto_box_seal=Module["_crypto_box_seal"]=(function(){return Module["asm"]["tb"].apply(null,arguments)});var _crypto_box_seal_open=Module["_crypto_box_seal_open"]=(function(){return Module["asm"]["ub"].apply(null,arguments)});var _crypto_box_sealbytes=Module["_crypto_box_sealbytes"]=(function(){return Module["asm"]["vb"].apply(null,arguments)});var _crypto_box_secretkeybytes=Module["_crypto_box_secretkeybytes"]=(function(){return Module["asm"]["wb"].apply(null,arguments)});var _crypto_box_seed_keypair=Module["_crypto_box_seed_keypair"]=(function(){return Module["asm"]["xb"].apply(null,arguments)});var _crypto_box_seedbytes=Module["_crypto_box_seedbytes"]=(function(){return Module["asm"]["yb"].apply(null,arguments)});var _crypto_box_zerobytes=Module["_crypto_box_zerobytes"]=(function(){return Module["asm"]["zb"].apply(null,arguments)});var _crypto_core_ed25519_add=Module["_crypto_core_ed25519_add"]=(function(){return Module["asm"]["Ab"].apply(null,arguments)});var _crypto_core_ed25519_bytes=Module["_crypto_core_ed25519_bytes"]=(function(){return Module["asm"]["Bb"].apply(null,arguments)});var _crypto_core_ed25519_from_uniform=Module["_crypto_core_ed25519_from_uniform"]=(function(){return Module["asm"]["Cb"].apply(null,arguments)});var _crypto_core_ed25519_is_valid_point=Module["_crypto_core_ed25519_is_valid_point"]=(function(){return Module["asm"]["Db"].apply(null,arguments)});var _crypto_core_ed25519_sub=Module["_crypto_core_ed25519_sub"]=(function(){return Module["asm"]["Eb"].apply(null,arguments)});var _crypto_core_ed25519_uniformbytes=Module["_crypto_core_ed25519_uniformbytes"]=(function(){return Module["asm"]["Fb"].apply(null,arguments)});var _crypto_core_hchacha20=Module["_crypto_core_hchacha20"]=(function(){return Module["asm"]["Gb"].apply(null,arguments)});var _crypto_core_hchacha20_constbytes=Module["_crypto_core_hchacha20_constbytes"]=(function(){return Module["asm"]["Hb"].apply(null,arguments)});var _crypto_core_hchacha20_inputbytes=Module["_crypto_core_hchacha20_inputbytes"]=(function(){return Module["asm"]["Ib"].apply(null,arguments)});var _crypto_core_hchacha20_keybytes=Module["_crypto_core_hchacha20_keybytes"]=(function(){return Module["asm"]["Jb"].apply(null,arguments)});var _crypto_core_hchacha20_outputbytes=Module["_crypto_core_hchacha20_outputbytes"]=(function(){return Module["asm"]["Kb"].apply(null,arguments)});var _crypto_core_hsalsa20=Module["_crypto_core_hsalsa20"]=(function(){return Module["asm"]["Lb"].apply(null,arguments)});var _crypto_core_hsalsa20_constbytes=Module["_crypto_core_hsalsa20_constbytes"]=(function(){return Module["asm"]["Mb"].apply(null,arguments)});var _crypto_core_hsalsa20_inputbytes=Module["_crypto_core_hsalsa20_inputbytes"]=(function(){return Module["asm"]["Nb"].apply(null,arguments)});var _crypto_core_hsalsa20_keybytes=Module["_crypto_core_hsalsa20_keybytes"]=(function(){return Module["asm"]["Ob"].apply(null,arguments)});var _crypto_core_hsalsa20_outputbytes=Module["_crypto_core_hsalsa20_outputbytes"]=(function(){return Module["asm"]["Pb"].apply(null,arguments)});var _crypto_core_salsa20=Module["_crypto_core_salsa20"]=(function(){return Module["asm"]["Qb"].apply(null,arguments)});var _crypto_core_salsa2012=Module["_crypto_core_salsa2012"]=(function(){return Module["asm"]["Rb"].apply(null,arguments)});var _crypto_core_salsa2012_constbytes=Module["_crypto_core_salsa2012_constbytes"]=(function(){return Module["asm"]["Sb"].apply(null,arguments)});var _crypto_core_salsa2012_inputbytes=Module["_crypto_core_salsa2012_inputbytes"]=(function(){return Module["asm"]["Tb"].apply(null,arguments)});var _crypto_core_salsa2012_keybytes=Module["_crypto_core_salsa2012_keybytes"]=(function(){return Module["asm"]["Ub"].apply(null,arguments)});var _crypto_core_salsa2012_outputbytes=Module["_crypto_core_salsa2012_outputbytes"]=(function(){return Module["asm"]["Vb"].apply(null,arguments)});var _crypto_core_salsa208=Module["_crypto_core_salsa208"]=(function(){return Module["asm"]["Wb"].apply(null,arguments)});var _crypto_core_salsa208_constbytes=Module["_crypto_core_salsa208_constbytes"]=(function(){return Module["asm"]["Xb"].apply(null,arguments)});var _crypto_core_salsa208_inputbytes=Module["_crypto_core_salsa208_inputbytes"]=(function(){return Module["asm"]["Yb"].apply(null,arguments)});var _crypto_core_salsa208_keybytes=Module["_crypto_core_salsa208_keybytes"]=(function(){return Module["asm"]["Zb"].apply(null,arguments)});var _crypto_core_salsa208_outputbytes=Module["_crypto_core_salsa208_outputbytes"]=(function(){return Module["asm"]["_b"].apply(null,arguments)});var _crypto_core_salsa20_constbytes=Module["_crypto_core_salsa20_constbytes"]=(function(){return Module["asm"]["$b"].apply(null,arguments)});var _crypto_core_salsa20_inputbytes=Module["_crypto_core_salsa20_inputbytes"]=(function(){return Module["asm"]["ac"].apply(null,arguments)});var _crypto_core_salsa20_keybytes=Module["_crypto_core_salsa20_keybytes"]=(function(){return Module["asm"]["bc"].apply(null,arguments)});var _crypto_core_salsa20_outputbytes=Module["_crypto_core_salsa20_outputbytes"]=(function(){return Module["asm"]["cc"].apply(null,arguments)});var _crypto_generichash=Module["_crypto_generichash"]=(function(){return Module["asm"]["dc"].apply(null,arguments)});var _crypto_generichash_blake2b=Module["_crypto_generichash_blake2b"]=(function(){return Module["asm"]["ec"].apply(null,arguments)});var _crypto_generichash_blake2b_bytes=Module["_crypto_generichash_blake2b_bytes"]=(function(){return Module["asm"]["fc"].apply(null,arguments)});var _crypto_generichash_blake2b_bytes_max=Module["_crypto_generichash_blake2b_bytes_max"]=(function(){return Module["asm"]["gc"].apply(null,arguments)});var _crypto_generichash_blake2b_bytes_min=Module["_crypto_generichash_blake2b_bytes_min"]=(function(){return Module["asm"]["hc"].apply(null,arguments)});var _crypto_generichash_blake2b_final=Module["_crypto_generichash_blake2b_final"]=(function(){return Module["asm"]["ic"].apply(null,arguments)});var _crypto_generichash_blake2b_init=Module["_crypto_generichash_blake2b_init"]=(function(){return Module["asm"]["jc"].apply(null,arguments)});var _crypto_generichash_blake2b_init_salt_personal=Module["_crypto_generichash_blake2b_init_salt_personal"]=(function(){return Module["asm"]["kc"].apply(null,arguments)});var _crypto_generichash_blake2b_keybytes=Module["_crypto_generichash_blake2b_keybytes"]=(function(){return Module["asm"]["lc"].apply(null,arguments)});var _crypto_generichash_blake2b_keybytes_max=Module["_crypto_generichash_blake2b_keybytes_max"]=(function(){return Module["asm"]["mc"].apply(null,arguments)});var _crypto_generichash_blake2b_keybytes_min=Module["_crypto_generichash_blake2b_keybytes_min"]=(function(){return Module["asm"]["nc"].apply(null,arguments)});var _crypto_generichash_blake2b_keygen=Module["_crypto_generichash_blake2b_keygen"]=(function(){return Module["asm"]["oc"].apply(null,arguments)});var _crypto_generichash_blake2b_personalbytes=Module["_crypto_generichash_blake2b_personalbytes"]=(function(){return Module["asm"]["pc"].apply(null,arguments)});var _crypto_generichash_blake2b_salt_personal=Module["_crypto_generichash_blake2b_salt_personal"]=(function(){return Module["asm"]["qc"].apply(null,arguments)});var _crypto_generichash_blake2b_saltbytes=Module["_crypto_generichash_blake2b_saltbytes"]=(function(){return Module["asm"]["rc"].apply(null,arguments)});var _crypto_generichash_blake2b_statebytes=Module["_crypto_generichash_blake2b_statebytes"]=(function(){return Module["asm"]["sc"].apply(null,arguments)});var _crypto_generichash_blake2b_update=Module["_crypto_generichash_blake2b_update"]=(function(){return Module["asm"]["tc"].apply(null,arguments)});var _crypto_generichash_bytes=Module["_crypto_generichash_bytes"]=(function(){return Module["asm"]["uc"].apply(null,arguments)});var _crypto_generichash_bytes_max=Module["_crypto_generichash_bytes_max"]=(function(){return Module["asm"]["vc"].apply(null,arguments)});var _crypto_generichash_bytes_min=Module["_crypto_generichash_bytes_min"]=(function(){return Module["asm"]["wc"].apply(null,arguments)});var _crypto_generichash_final=Module["_crypto_generichash_final"]=(function(){return Module["asm"]["xc"].apply(null,arguments)});var _crypto_generichash_init=Module["_crypto_generichash_init"]=(function(){return Module["asm"]["yc"].apply(null,arguments)});var _crypto_generichash_keybytes=Module["_crypto_generichash_keybytes"]=(function(){return Module["asm"]["zc"].apply(null,arguments)});var _crypto_generichash_keybytes_max=Module["_crypto_generichash_keybytes_max"]=(function(){return Module["asm"]["Ac"].apply(null,arguments)});var _crypto_generichash_keybytes_min=Module["_crypto_generichash_keybytes_min"]=(function(){return Module["asm"]["Bc"].apply(null,arguments)});var _crypto_generichash_keygen=Module["_crypto_generichash_keygen"]=(function(){return Module["asm"]["Cc"].apply(null,arguments)});var _crypto_generichash_primitive=Module["_crypto_generichash_primitive"]=(function(){return Module["asm"]["Dc"].apply(null,arguments)});var _crypto_generichash_statebytes=Module["_crypto_generichash_statebytes"]=(function(){return Module["asm"]["Ec"].apply(null,arguments)});var _crypto_generichash_update=Module["_crypto_generichash_update"]=(function(){return Module["asm"]["Fc"].apply(null,arguments)});var _crypto_hash=Module["_crypto_hash"]=(function(){return Module["asm"]["Gc"].apply(null,arguments)});var _crypto_hash_bytes=Module["_crypto_hash_bytes"]=(function(){return Module["asm"]["Hc"].apply(null,arguments)});var _crypto_hash_primitive=Module["_crypto_hash_primitive"]=(function(){return Module["asm"]["Ic"].apply(null,arguments)});var _crypto_hash_sha256=Module["_crypto_hash_sha256"]=(function(){return Module["asm"]["Jc"].apply(null,arguments)});var _crypto_hash_sha256_bytes=Module["_crypto_hash_sha256_bytes"]=(function(){return Module["asm"]["Kc"].apply(null,arguments)});var _crypto_hash_sha256_final=Module["_crypto_hash_sha256_final"]=(function(){return Module["asm"]["Lc"].apply(null,arguments)});var _crypto_hash_sha256_init=Module["_crypto_hash_sha256_init"]=(function(){return Module["asm"]["Mc"].apply(null,arguments)});var _crypto_hash_sha256_statebytes=Module["_crypto_hash_sha256_statebytes"]=(function(){return Module["asm"]["Nc"].apply(null,arguments)});var _crypto_hash_sha256_update=Module["_crypto_hash_sha256_update"]=(function(){return Module["asm"]["Oc"].apply(null,arguments)});var _crypto_hash_sha512=Module["_crypto_hash_sha512"]=(function(){return Module["asm"]["Pc"].apply(null,arguments)});var _crypto_hash_sha512_bytes=Module["_crypto_hash_sha512_bytes"]=(function(){return Module["asm"]["Qc"].apply(null,arguments)});var _crypto_hash_sha512_final=Module["_crypto_hash_sha512_final"]=(function(){return Module["asm"]["Rc"].apply(null,arguments)});var _crypto_hash_sha512_init=Module["_crypto_hash_sha512_init"]=(function(){return Module["asm"]["Sc"].apply(null,arguments)});var _crypto_hash_sha512_statebytes=Module["_crypto_hash_sha512_statebytes"]=(function(){return Module["asm"]["Tc"].apply(null,arguments)});var _crypto_hash_sha512_update=Module["_crypto_hash_sha512_update"]=(function(){return Module["asm"]["Uc"].apply(null,arguments)});var _crypto_kdf_blake2b_bytes_max=Module["_crypto_kdf_blake2b_bytes_max"]=(function(){return Module["asm"]["Vc"].apply(null,arguments)});var _crypto_kdf_blake2b_bytes_min=Module["_crypto_kdf_blake2b_bytes_min"]=(function(){return Module["asm"]["Wc"].apply(null,arguments)});var _crypto_kdf_blake2b_contextbytes=Module["_crypto_kdf_blake2b_contextbytes"]=(function(){return Module["asm"]["Xc"].apply(null,arguments)});var _crypto_kdf_blake2b_derive_from_key=Module["_crypto_kdf_blake2b_derive_from_key"]=(function(){return Module["asm"]["Yc"].apply(null,arguments)});var _crypto_kdf_blake2b_keybytes=Module["_crypto_kdf_blake2b_keybytes"]=(function(){return Module["asm"]["Zc"].apply(null,arguments)});var _crypto_kdf_bytes_max=Module["_crypto_kdf_bytes_max"]=(function(){return Module["asm"]["_c"].apply(null,arguments)});var _crypto_kdf_bytes_min=Module["_crypto_kdf_bytes_min"]=(function(){return Module["asm"]["$c"].apply(null,arguments)});var _crypto_kdf_contextbytes=Module["_crypto_kdf_contextbytes"]=(function(){return Module["asm"]["ad"].apply(null,arguments)});var _crypto_kdf_derive_from_key=Module["_crypto_kdf_derive_from_key"]=(function(){return Module["asm"]["bd"].apply(null,arguments)});var _crypto_kdf_keybytes=Module["_crypto_kdf_keybytes"]=(function(){return Module["asm"]["cd"].apply(null,arguments)});var _crypto_kdf_keygen=Module["_crypto_kdf_keygen"]=(function(){return Module["asm"]["dd"].apply(null,arguments)});var _crypto_kdf_primitive=Module["_crypto_kdf_primitive"]=(function(){return Module["asm"]["ed"].apply(null,arguments)});var _crypto_kx_client_session_keys=Module["_crypto_kx_client_session_keys"]=(function(){return Module["asm"]["fd"].apply(null,arguments)});var _crypto_kx_keypair=Module["_crypto_kx_keypair"]=(function(){return Module["asm"]["gd"].apply(null,arguments)});var _crypto_kx_primitive=Module["_crypto_kx_primitive"]=(function(){return Module["asm"]["hd"].apply(null,arguments)});var _crypto_kx_publickeybytes=Module["_crypto_kx_publickeybytes"]=(function(){return Module["asm"]["id"].apply(null,arguments)});var _crypto_kx_secretkeybytes=Module["_crypto_kx_secretkeybytes"]=(function(){return Module["asm"]["jd"].apply(null,arguments)});var _crypto_kx_seed_keypair=Module["_crypto_kx_seed_keypair"]=(function(){return Module["asm"]["kd"].apply(null,arguments)});var _crypto_kx_seedbytes=Module["_crypto_kx_seedbytes"]=(function(){return Module["asm"]["ld"].apply(null,arguments)});var _crypto_kx_server_session_keys=Module["_crypto_kx_server_session_keys"]=(function(){return Module["asm"]["md"].apply(null,arguments)});var _crypto_kx_sessionkeybytes=Module["_crypto_kx_sessionkeybytes"]=(function(){return Module["asm"]["nd"].apply(null,arguments)});var _crypto_onetimeauth=Module["_crypto_onetimeauth"]=(function(){return Module["asm"]["od"].apply(null,arguments)});var _crypto_onetimeauth_bytes=Module["_crypto_onetimeauth_bytes"]=(function(){return Module["asm"]["pd"].apply(null,arguments)});var _crypto_onetimeauth_final=Module["_crypto_onetimeauth_final"]=(function(){return Module["asm"]["qd"].apply(null,arguments)});var _crypto_onetimeauth_init=Module["_crypto_onetimeauth_init"]=(function(){return Module["asm"]["rd"].apply(null,arguments)});var _crypto_onetimeauth_keybytes=Module["_crypto_onetimeauth_keybytes"]=(function(){return Module["asm"]["sd"].apply(null,arguments)});var _crypto_onetimeauth_keygen=Module["_crypto_onetimeauth_keygen"]=(function(){return Module["asm"]["td"].apply(null,arguments)});var _crypto_onetimeauth_poly1305=Module["_crypto_onetimeauth_poly1305"]=(function(){return Module["asm"]["ud"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_bytes=Module["_crypto_onetimeauth_poly1305_bytes"]=(function(){return Module["asm"]["vd"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_final=Module["_crypto_onetimeauth_poly1305_final"]=(function(){return Module["asm"]["wd"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_init=Module["_crypto_onetimeauth_poly1305_init"]=(function(){return Module["asm"]["xd"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_keybytes=Module["_crypto_onetimeauth_poly1305_keybytes"]=(function(){return Module["asm"]["yd"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_keygen=Module["_crypto_onetimeauth_poly1305_keygen"]=(function(){return Module["asm"]["zd"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_statebytes=Module["_crypto_onetimeauth_poly1305_statebytes"]=(function(){return Module["asm"]["Ad"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_update=Module["_crypto_onetimeauth_poly1305_update"]=(function(){return Module["asm"]["Bd"].apply(null,arguments)});var _crypto_onetimeauth_poly1305_verify=Module["_crypto_onetimeauth_poly1305_verify"]=(function(){return Module["asm"]["Cd"].apply(null,arguments)});var _crypto_onetimeauth_primitive=Module["_crypto_onetimeauth_primitive"]=(function(){return Module["asm"]["Dd"].apply(null,arguments)});var _crypto_onetimeauth_statebytes=Module["_crypto_onetimeauth_statebytes"]=(function(){return Module["asm"]["Ed"].apply(null,arguments)});var _crypto_onetimeauth_update=Module["_crypto_onetimeauth_update"]=(function(){return Module["asm"]["Fd"].apply(null,arguments)});var _crypto_onetimeauth_verify=Module["_crypto_onetimeauth_verify"]=(function(){return Module["asm"]["Gd"].apply(null,arguments)});var _crypto_pwhash=Module["_crypto_pwhash"]=(function(){return Module["asm"]["Hd"].apply(null,arguments)});var _crypto_pwhash_alg_argon2i13=Module["_crypto_pwhash_alg_argon2i13"]=(function(){return Module["asm"]["Id"].apply(null,arguments)});var _crypto_pwhash_alg_argon2id13=Module["_crypto_pwhash_alg_argon2id13"]=(function(){return Module["asm"]["Jd"].apply(null,arguments)});var _crypto_pwhash_alg_default=Module["_crypto_pwhash_alg_default"]=(function(){return Module["asm"]["Kd"].apply(null,arguments)});var _crypto_pwhash_argon2i=Module["_crypto_pwhash_argon2i"]=(function(){return Module["asm"]["Ld"].apply(null,arguments)});var _crypto_pwhash_argon2i_alg_argon2i13=Module["_crypto_pwhash_argon2i_alg_argon2i13"]=(function(){return Module["asm"]["Md"].apply(null,arguments)});var _crypto_pwhash_argon2i_bytes_max=Module["_crypto_pwhash_argon2i_bytes_max"]=(function(){return Module["asm"]["Nd"].apply(null,arguments)});var _crypto_pwhash_argon2i_bytes_min=Module["_crypto_pwhash_argon2i_bytes_min"]=(function(){return Module["asm"]["Od"].apply(null,arguments)});var _crypto_pwhash_argon2i_memlimit_interactive=Module["_crypto_pwhash_argon2i_memlimit_interactive"]=(function(){return Module["asm"]["Pd"].apply(null,arguments)});var _crypto_pwhash_argon2i_memlimit_max=Module["_crypto_pwhash_argon2i_memlimit_max"]=(function(){return Module["asm"]["Qd"].apply(null,arguments)});var _crypto_pwhash_argon2i_memlimit_min=Module["_crypto_pwhash_argon2i_memlimit_min"]=(function(){return Module["asm"]["Rd"].apply(null,arguments)});var _crypto_pwhash_argon2i_memlimit_moderate=Module["_crypto_pwhash_argon2i_memlimit_moderate"]=(function(){return Module["asm"]["Sd"].apply(null,arguments)});var _crypto_pwhash_argon2i_memlimit_sensitive=Module["_crypto_pwhash_argon2i_memlimit_sensitive"]=(function(){return Module["asm"]["Td"].apply(null,arguments)});var _crypto_pwhash_argon2i_opslimit_interactive=Module["_crypto_pwhash_argon2i_opslimit_interactive"]=(function(){return Module["asm"]["Ud"].apply(null,arguments)});var _crypto_pwhash_argon2i_opslimit_max=Module["_crypto_pwhash_argon2i_opslimit_max"]=(function(){return Module["asm"]["Vd"].apply(null,arguments)});var _crypto_pwhash_argon2i_opslimit_min=Module["_crypto_pwhash_argon2i_opslimit_min"]=(function(){return Module["asm"]["Wd"].apply(null,arguments)});var _crypto_pwhash_argon2i_opslimit_moderate=Module["_crypto_pwhash_argon2i_opslimit_moderate"]=(function(){return Module["asm"]["Xd"].apply(null,arguments)});var _crypto_pwhash_argon2i_opslimit_sensitive=Module["_crypto_pwhash_argon2i_opslimit_sensitive"]=(function(){return Module["asm"]["Yd"].apply(null,arguments)});var _crypto_pwhash_argon2i_passwd_max=Module["_crypto_pwhash_argon2i_passwd_max"]=(function(){return Module["asm"]["Zd"].apply(null,arguments)});var _crypto_pwhash_argon2i_passwd_min=Module["_crypto_pwhash_argon2i_passwd_min"]=(function(){return Module["asm"]["_d"].apply(null,arguments)});var _crypto_pwhash_argon2i_saltbytes=Module["_crypto_pwhash_argon2i_saltbytes"]=(function(){return Module["asm"]["$d"].apply(null,arguments)});var _crypto_pwhash_argon2i_str=Module["_crypto_pwhash_argon2i_str"]=(function(){return Module["asm"]["ae"].apply(null,arguments)});var _crypto_pwhash_argon2i_str_needs_rehash=Module["_crypto_pwhash_argon2i_str_needs_rehash"]=(function(){return Module["asm"]["be"].apply(null,arguments)});var _crypto_pwhash_argon2i_str_verify=Module["_crypto_pwhash_argon2i_str_verify"]=(function(){return Module["asm"]["ce"].apply(null,arguments)});var _crypto_pwhash_argon2i_strbytes=Module["_crypto_pwhash_argon2i_strbytes"]=(function(){return Module["asm"]["de"].apply(null,arguments)});var _crypto_pwhash_argon2i_strprefix=Module["_crypto_pwhash_argon2i_strprefix"]=(function(){return Module["asm"]["ee"].apply(null,arguments)});var _crypto_pwhash_argon2id=Module["_crypto_pwhash_argon2id"]=(function(){return Module["asm"]["fe"].apply(null,arguments)});var _crypto_pwhash_argon2id_alg_argon2id13=Module["_crypto_pwhash_argon2id_alg_argon2id13"]=(function(){return Module["asm"]["ge"].apply(null,arguments)});var _crypto_pwhash_argon2id_bytes_max=Module["_crypto_pwhash_argon2id_bytes_max"]=(function(){return Module["asm"]["he"].apply(null,arguments)});var _crypto_pwhash_argon2id_bytes_min=Module["_crypto_pwhash_argon2id_bytes_min"]=(function(){return Module["asm"]["ie"].apply(null,arguments)});var _crypto_pwhash_argon2id_memlimit_interactive=Module["_crypto_pwhash_argon2id_memlimit_interactive"]=(function(){return Module["asm"]["je"].apply(null,arguments)});var _crypto_pwhash_argon2id_memlimit_max=Module["_crypto_pwhash_argon2id_memlimit_max"]=(function(){return Module["asm"]["ke"].apply(null,arguments)});var _crypto_pwhash_argon2id_memlimit_min=Module["_crypto_pwhash_argon2id_memlimit_min"]=(function(){return Module["asm"]["le"].apply(null,arguments)});var _crypto_pwhash_argon2id_memlimit_moderate=Module["_crypto_pwhash_argon2id_memlimit_moderate"]=(function(){return Module["asm"]["me"].apply(null,arguments)});var _crypto_pwhash_argon2id_memlimit_sensitive=Module["_crypto_pwhash_argon2id_memlimit_sensitive"]=(function(){return Module["asm"]["ne"].apply(null,arguments)});var _crypto_pwhash_argon2id_opslimit_interactive=Module["_crypto_pwhash_argon2id_opslimit_interactive"]=(function(){return Module["asm"]["oe"].apply(null,arguments)});var _crypto_pwhash_argon2id_opslimit_max=Module["_crypto_pwhash_argon2id_opslimit_max"]=(function(){return Module["asm"]["pe"].apply(null,arguments)});var _crypto_pwhash_argon2id_opslimit_min=Module["_crypto_pwhash_argon2id_opslimit_min"]=(function(){return Module["asm"]["qe"].apply(null,arguments)});var _crypto_pwhash_argon2id_opslimit_moderate=Module["_crypto_pwhash_argon2id_opslimit_moderate"]=(function(){return Module["asm"]["re"].apply(null,arguments)});var _crypto_pwhash_argon2id_opslimit_sensitive=Module["_crypto_pwhash_argon2id_opslimit_sensitive"]=(function(){return Module["asm"]["se"].apply(null,arguments)});var _crypto_pwhash_argon2id_passwd_max=Module["_crypto_pwhash_argon2id_passwd_max"]=(function(){return Module["asm"]["te"].apply(null,arguments)});var _crypto_pwhash_argon2id_passwd_min=Module["_crypto_pwhash_argon2id_passwd_min"]=(function(){return Module["asm"]["ue"].apply(null,arguments)});var _crypto_pwhash_argon2id_saltbytes=Module["_crypto_pwhash_argon2id_saltbytes"]=(function(){return Module["asm"]["ve"].apply(null,arguments)});var _crypto_pwhash_argon2id_str=Module["_crypto_pwhash_argon2id_str"]=(function(){return Module["asm"]["we"].apply(null,arguments)});var _crypto_pwhash_argon2id_str_needs_rehash=Module["_crypto_pwhash_argon2id_str_needs_rehash"]=(function(){return Module["asm"]["xe"].apply(null,arguments)});var _crypto_pwhash_argon2id_str_verify=Module["_crypto_pwhash_argon2id_str_verify"]=(function(){return Module["asm"]["ye"].apply(null,arguments)});var _crypto_pwhash_argon2id_strbytes=Module["_crypto_pwhash_argon2id_strbytes"]=(function(){return Module["asm"]["ze"].apply(null,arguments)});var _crypto_pwhash_argon2id_strprefix=Module["_crypto_pwhash_argon2id_strprefix"]=(function(){return Module["asm"]["Ae"].apply(null,arguments)});var _crypto_pwhash_bytes_max=Module["_crypto_pwhash_bytes_max"]=(function(){return Module["asm"]["Be"].apply(null,arguments)});var _crypto_pwhash_bytes_min=Module["_crypto_pwhash_bytes_min"]=(function(){return Module["asm"]["Ce"].apply(null,arguments)});var _crypto_pwhash_memlimit_interactive=Module["_crypto_pwhash_memlimit_interactive"]=(function(){return Module["asm"]["De"].apply(null,arguments)});var _crypto_pwhash_memlimit_max=Module["_crypto_pwhash_memlimit_max"]=(function(){return Module["asm"]["Ee"].apply(null,arguments)});var _crypto_pwhash_memlimit_min=Module["_crypto_pwhash_memlimit_min"]=(function(){return Module["asm"]["Fe"].apply(null,arguments)});var _crypto_pwhash_memlimit_moderate=Module["_crypto_pwhash_memlimit_moderate"]=(function(){return Module["asm"]["Ge"].apply(null,arguments)});var _crypto_pwhash_memlimit_sensitive=Module["_crypto_pwhash_memlimit_sensitive"]=(function(){return Module["asm"]["He"].apply(null,arguments)});var _crypto_pwhash_opslimit_interactive=Module["_crypto_pwhash_opslimit_interactive"]=(function(){return Module["asm"]["Ie"].apply(null,arguments)});var _crypto_pwhash_opslimit_max=Module["_crypto_pwhash_opslimit_max"]=(function(){return Module["asm"]["Je"].apply(null,arguments)});var _crypto_pwhash_opslimit_min=Module["_crypto_pwhash_opslimit_min"]=(function(){return Module["asm"]["Ke"].apply(null,arguments)});var _crypto_pwhash_opslimit_moderate=Module["_crypto_pwhash_opslimit_moderate"]=(function(){return Module["asm"]["Le"].apply(null,arguments)});var _crypto_pwhash_opslimit_sensitive=Module["_crypto_pwhash_opslimit_sensitive"]=(function(){return Module["asm"]["Me"].apply(null,arguments)});var _crypto_pwhash_passwd_max=Module["_crypto_pwhash_passwd_max"]=(function(){return Module["asm"]["Ne"].apply(null,arguments)});var _crypto_pwhash_passwd_min=Module["_crypto_pwhash_passwd_min"]=(function(){return Module["asm"]["Oe"].apply(null,arguments)});var _crypto_pwhash_primitive=Module["_crypto_pwhash_primitive"]=(function(){return Module["asm"]["Pe"].apply(null,arguments)});var _crypto_pwhash_saltbytes=Module["_crypto_pwhash_saltbytes"]=(function(){return Module["asm"]["Qe"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256=Module["_crypto_pwhash_scryptsalsa208sha256"]=(function(){return Module["asm"]["Re"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_bytes_max=Module["_crypto_pwhash_scryptsalsa208sha256_bytes_max"]=(function(){return Module["asm"]["Se"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_bytes_min=Module["_crypto_pwhash_scryptsalsa208sha256_bytes_min"]=(function(){return Module["asm"]["Te"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_ll=Module["_crypto_pwhash_scryptsalsa208sha256_ll"]=(function(){return Module["asm"]["Ue"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_memlimit_interactive=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_interactive"]=(function(){return Module["asm"]["Ve"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_memlimit_max=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_max"]=(function(){return Module["asm"]["We"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_memlimit_min=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_min"]=(function(){return Module["asm"]["Xe"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive=Module["_crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive"]=(function(){return Module["asm"]["Ye"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_opslimit_interactive=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_interactive"]=(function(){return Module["asm"]["Ze"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_opslimit_max=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_max"]=(function(){return Module["asm"]["_e"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_opslimit_min=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_min"]=(function(){return Module["asm"]["$e"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive=Module["_crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive"]=(function(){return Module["asm"]["af"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_passwd_max=Module["_crypto_pwhash_scryptsalsa208sha256_passwd_max"]=(function(){return Module["asm"]["bf"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_passwd_min=Module["_crypto_pwhash_scryptsalsa208sha256_passwd_min"]=(function(){return Module["asm"]["cf"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_saltbytes=Module["_crypto_pwhash_scryptsalsa208sha256_saltbytes"]=(function(){return Module["asm"]["df"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_str=Module["_crypto_pwhash_scryptsalsa208sha256_str"]=(function(){return Module["asm"]["ef"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_str_needs_rehash=Module["_crypto_pwhash_scryptsalsa208sha256_str_needs_rehash"]=(function(){return Module["asm"]["ff"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_str_verify=Module["_crypto_pwhash_scryptsalsa208sha256_str_verify"]=(function(){return Module["asm"]["gf"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_strbytes=Module["_crypto_pwhash_scryptsalsa208sha256_strbytes"]=(function(){return Module["asm"]["hf"].apply(null,arguments)});var _crypto_pwhash_scryptsalsa208sha256_strprefix=Module["_crypto_pwhash_scryptsalsa208sha256_strprefix"]=(function(){return Module["asm"]["jf"].apply(null,arguments)});var _crypto_pwhash_str=Module["_crypto_pwhash_str"]=(function(){return Module["asm"]["kf"].apply(null,arguments)});var _crypto_pwhash_str_alg=Module["_crypto_pwhash_str_alg"]=(function(){return Module["asm"]["lf"].apply(null,arguments)});var _crypto_pwhash_str_needs_rehash=Module["_crypto_pwhash_str_needs_rehash"]=(function(){return Module["asm"]["mf"].apply(null,arguments)});var _crypto_pwhash_str_verify=Module["_crypto_pwhash_str_verify"]=(function(){return Module["asm"]["nf"].apply(null,arguments)});var _crypto_pwhash_strbytes=Module["_crypto_pwhash_strbytes"]=(function(){return Module["asm"]["of"].apply(null,arguments)});var _crypto_pwhash_strprefix=Module["_crypto_pwhash_strprefix"]=(function(){return Module["asm"]["pf"].apply(null,arguments)});var _crypto_scalarmult=Module["_crypto_scalarmult"]=(function(){return Module["asm"]["qf"].apply(null,arguments)});var _crypto_scalarmult_base=Module["_crypto_scalarmult_base"]=(function(){return Module["asm"]["rf"].apply(null,arguments)});var _crypto_scalarmult_bytes=Module["_crypto_scalarmult_bytes"]=(function(){return Module["asm"]["sf"].apply(null,arguments)});var _crypto_scalarmult_curve25519=Module["_crypto_scalarmult_curve25519"]=(function(){return Module["asm"]["tf"].apply(null,arguments)});var _crypto_scalarmult_curve25519_base=Module["_crypto_scalarmult_curve25519_base"]=(function(){return Module["asm"]["uf"].apply(null,arguments)});var _crypto_scalarmult_curve25519_bytes=Module["_crypto_scalarmult_curve25519_bytes"]=(function(){return Module["asm"]["vf"].apply(null,arguments)});var _crypto_scalarmult_curve25519_scalarbytes=Module["_crypto_scalarmult_curve25519_scalarbytes"]=(function(){return Module["asm"]["wf"].apply(null,arguments)});var _crypto_scalarmult_ed25519=Module["_crypto_scalarmult_ed25519"]=(function(){return Module["asm"]["xf"].apply(null,arguments)});var _crypto_scalarmult_ed25519_base=Module["_crypto_scalarmult_ed25519_base"]=(function(){return Module["asm"]["yf"].apply(null,arguments)});var _crypto_scalarmult_ed25519_bytes=Module["_crypto_scalarmult_ed25519_bytes"]=(function(){return Module["asm"]["zf"].apply(null,arguments)});var _crypto_scalarmult_ed25519_scalarbytes=Module["_crypto_scalarmult_ed25519_scalarbytes"]=(function(){return Module["asm"]["Af"].apply(null,arguments)});var _crypto_scalarmult_primitive=Module["_crypto_scalarmult_primitive"]=(function(){return Module["asm"]["Bf"].apply(null,arguments)});var _crypto_scalarmult_scalarbytes=Module["_crypto_scalarmult_scalarbytes"]=(function(){return Module["asm"]["Cf"].apply(null,arguments)});var _crypto_secretbox=Module["_crypto_secretbox"]=(function(){return Module["asm"]["Df"].apply(null,arguments)});var _crypto_secretbox_boxzerobytes=Module["_crypto_secretbox_boxzerobytes"]=(function(){return Module["asm"]["Ef"].apply(null,arguments)});var _crypto_secretbox_detached=Module["_crypto_secretbox_detached"]=(function(){return Module["asm"]["Ff"].apply(null,arguments)});var _crypto_secretbox_easy=Module["_crypto_secretbox_easy"]=(function(){return Module["asm"]["Gf"].apply(null,arguments)});var _crypto_secretbox_keybytes=Module["_crypto_secretbox_keybytes"]=(function(){return Module["asm"]["Hf"].apply(null,arguments)});var _crypto_secretbox_keygen=Module["_crypto_secretbox_keygen"]=(function(){return Module["asm"]["If"].apply(null,arguments)});var _crypto_secretbox_macbytes=Module["_crypto_secretbox_macbytes"]=(function(){return Module["asm"]["Jf"].apply(null,arguments)});var _crypto_secretbox_noncebytes=Module["_crypto_secretbox_noncebytes"]=(function(){return Module["asm"]["Kf"].apply(null,arguments)});var _crypto_secretbox_open=Module["_crypto_secretbox_open"]=(function(){return Module["asm"]["Lf"].apply(null,arguments)});var _crypto_secretbox_open_detached=Module["_crypto_secretbox_open_detached"]=(function(){return Module["asm"]["Mf"].apply(null,arguments)});var _crypto_secretbox_open_easy=Module["_crypto_secretbox_open_easy"]=(function(){return Module["asm"]["Nf"].apply(null,arguments)});var _crypto_secretbox_primitive=Module["_crypto_secretbox_primitive"]=(function(){return Module["asm"]["Of"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_detached=Module["_crypto_secretbox_xchacha20poly1305_detached"]=(function(){return Module["asm"]["Pf"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_easy=Module["_crypto_secretbox_xchacha20poly1305_easy"]=(function(){return Module["asm"]["Qf"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_keybytes=Module["_crypto_secretbox_xchacha20poly1305_keybytes"]=(function(){return Module["asm"]["Rf"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_macbytes=Module["_crypto_secretbox_xchacha20poly1305_macbytes"]=(function(){return Module["asm"]["Sf"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_noncebytes=Module["_crypto_secretbox_xchacha20poly1305_noncebytes"]=(function(){return Module["asm"]["Tf"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_open_detached=Module["_crypto_secretbox_xchacha20poly1305_open_detached"]=(function(){return Module["asm"]["Uf"].apply(null,arguments)});var _crypto_secretbox_xchacha20poly1305_open_easy=Module["_crypto_secretbox_xchacha20poly1305_open_easy"]=(function(){return Module["asm"]["Vf"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305=Module["_crypto_secretbox_xsalsa20poly1305"]=(function(){return Module["asm"]["Wf"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_boxzerobytes=Module["_crypto_secretbox_xsalsa20poly1305_boxzerobytes"]=(function(){return Module["asm"]["Xf"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_keybytes=Module["_crypto_secretbox_xsalsa20poly1305_keybytes"]=(function(){return Module["asm"]["Yf"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_keygen=Module["_crypto_secretbox_xsalsa20poly1305_keygen"]=(function(){return Module["asm"]["Zf"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_macbytes=Module["_crypto_secretbox_xsalsa20poly1305_macbytes"]=(function(){return Module["asm"]["_f"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_noncebytes=Module["_crypto_secretbox_xsalsa20poly1305_noncebytes"]=(function(){return Module["asm"]["$f"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_open=Module["_crypto_secretbox_xsalsa20poly1305_open"]=(function(){return Module["asm"]["ag"].apply(null,arguments)});var _crypto_secretbox_xsalsa20poly1305_zerobytes=Module["_crypto_secretbox_xsalsa20poly1305_zerobytes"]=(function(){return Module["asm"]["bg"].apply(null,arguments)});var _crypto_secretbox_zerobytes=Module["_crypto_secretbox_zerobytes"]=(function(){return Module["asm"]["cg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_abytes=Module["_crypto_secretstream_xchacha20poly1305_abytes"]=(function(){return Module["asm"]["dg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_headerbytes=Module["_crypto_secretstream_xchacha20poly1305_headerbytes"]=(function(){return Module["asm"]["eg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_init_pull=Module["_crypto_secretstream_xchacha20poly1305_init_pull"]=(function(){return Module["asm"]["fg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_init_push=Module["_crypto_secretstream_xchacha20poly1305_init_push"]=(function(){return Module["asm"]["gg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_keybytes=Module["_crypto_secretstream_xchacha20poly1305_keybytes"]=(function(){return Module["asm"]["hg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_keygen=Module["_crypto_secretstream_xchacha20poly1305_keygen"]=(function(){return Module["asm"]["ig"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_messagebytes_max=Module["_crypto_secretstream_xchacha20poly1305_messagebytes_max"]=(function(){return Module["asm"]["jg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_pull=Module["_crypto_secretstream_xchacha20poly1305_pull"]=(function(){return Module["asm"]["kg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_push=Module["_crypto_secretstream_xchacha20poly1305_push"]=(function(){return Module["asm"]["lg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_rekey=Module["_crypto_secretstream_xchacha20poly1305_rekey"]=(function(){return Module["asm"]["mg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_statebytes=Module["_crypto_secretstream_xchacha20poly1305_statebytes"]=(function(){return Module["asm"]["ng"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_tag_final=Module["_crypto_secretstream_xchacha20poly1305_tag_final"]=(function(){return Module["asm"]["og"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_tag_message=Module["_crypto_secretstream_xchacha20poly1305_tag_message"]=(function(){return Module["asm"]["pg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_tag_push=Module["_crypto_secretstream_xchacha20poly1305_tag_push"]=(function(){return Module["asm"]["qg"].apply(null,arguments)});var _crypto_secretstream_xchacha20poly1305_tag_rekey=Module["_crypto_secretstream_xchacha20poly1305_tag_rekey"]=(function(){return Module["asm"]["rg"].apply(null,arguments)});var _crypto_shorthash=Module["_crypto_shorthash"]=(function(){return Module["asm"]["sg"].apply(null,arguments)});var _crypto_shorthash_bytes=Module["_crypto_shorthash_bytes"]=(function(){return Module["asm"]["tg"].apply(null,arguments)});var _crypto_shorthash_keybytes=Module["_crypto_shorthash_keybytes"]=(function(){return Module["asm"]["ug"].apply(null,arguments)});var _crypto_shorthash_keygen=Module["_crypto_shorthash_keygen"]=(function(){return Module["asm"]["vg"].apply(null,arguments)});var _crypto_shorthash_primitive=Module["_crypto_shorthash_primitive"]=(function(){return Module["asm"]["wg"].apply(null,arguments)});var _crypto_shorthash_siphash24=Module["_crypto_shorthash_siphash24"]=(function(){return Module["asm"]["xg"].apply(null,arguments)});var _crypto_shorthash_siphash24_bytes=Module["_crypto_shorthash_siphash24_bytes"]=(function(){return Module["asm"]["yg"].apply(null,arguments)});var _crypto_shorthash_siphash24_keybytes=Module["_crypto_shorthash_siphash24_keybytes"]=(function(){return Module["asm"]["zg"].apply(null,arguments)});var _crypto_shorthash_siphashx24=Module["_crypto_shorthash_siphashx24"]=(function(){return Module["asm"]["Ag"].apply(null,arguments)});var _crypto_shorthash_siphashx24_bytes=Module["_crypto_shorthash_siphashx24_bytes"]=(function(){return Module["asm"]["Bg"].apply(null,arguments)});var _crypto_shorthash_siphashx24_keybytes=Module["_crypto_shorthash_siphashx24_keybytes"]=(function(){return Module["asm"]["Cg"].apply(null,arguments)});var _crypto_sign=Module["_crypto_sign"]=(function(){return Module["asm"]["Dg"].apply(null,arguments)});var _crypto_sign_bytes=Module["_crypto_sign_bytes"]=(function(){return Module["asm"]["Eg"].apply(null,arguments)});var _crypto_sign_detached=Module["_crypto_sign_detached"]=(function(){return Module["asm"]["Fg"].apply(null,arguments)});var _crypto_sign_ed25519=Module["_crypto_sign_ed25519"]=(function(){return Module["asm"]["Gg"].apply(null,arguments)});var _crypto_sign_ed25519_bytes=Module["_crypto_sign_ed25519_bytes"]=(function(){return Module["asm"]["Hg"].apply(null,arguments)});var _crypto_sign_ed25519_detached=Module["_crypto_sign_ed25519_detached"]=(function(){return Module["asm"]["Ig"].apply(null,arguments)});var _crypto_sign_ed25519_keypair=Module["_crypto_sign_ed25519_keypair"]=(function(){return Module["asm"]["Jg"].apply(null,arguments)});var _crypto_sign_ed25519_open=Module["_crypto_sign_ed25519_open"]=(function(){return Module["asm"]["Kg"].apply(null,arguments)});var _crypto_sign_ed25519_pk_to_curve25519=Module["_crypto_sign_ed25519_pk_to_curve25519"]=(function(){return Module["asm"]["Lg"].apply(null,arguments)});var _crypto_sign_ed25519_publickeybytes=Module["_crypto_sign_ed25519_publickeybytes"]=(function(){return Module["asm"]["Mg"].apply(null,arguments)});var _crypto_sign_ed25519_secretkeybytes=Module["_crypto_sign_ed25519_secretkeybytes"]=(function(){return Module["asm"]["Ng"].apply(null,arguments)});var _crypto_sign_ed25519_seed_keypair=Module["_crypto_sign_ed25519_seed_keypair"]=(function(){return Module["asm"]["Og"].apply(null,arguments)});var _crypto_sign_ed25519_seedbytes=Module["_crypto_sign_ed25519_seedbytes"]=(function(){return Module["asm"]["Pg"].apply(null,arguments)});var _crypto_sign_ed25519_sk_to_curve25519=Module["_crypto_sign_ed25519_sk_to_curve25519"]=(function(){return Module["asm"]["Qg"].apply(null,arguments)});var _crypto_sign_ed25519_sk_to_pk=Module["_crypto_sign_ed25519_sk_to_pk"]=(function(){return Module["asm"]["Rg"].apply(null,arguments)});var _crypto_sign_ed25519_sk_to_seed=Module["_crypto_sign_ed25519_sk_to_seed"]=(function(){return Module["asm"]["Sg"].apply(null,arguments)});var _crypto_sign_ed25519_verify_detached=Module["_crypto_sign_ed25519_verify_detached"]=(function(){return Module["asm"]["Tg"].apply(null,arguments)});var _crypto_sign_ed25519ph_final_create=Module["_crypto_sign_ed25519ph_final_create"]=(function(){return Module["asm"]["Ug"].apply(null,arguments)});var _crypto_sign_ed25519ph_final_verify=Module["_crypto_sign_ed25519ph_final_verify"]=(function(){return Module["asm"]["Vg"].apply(null,arguments)});var _crypto_sign_ed25519ph_init=Module["_crypto_sign_ed25519ph_init"]=(function(){return Module["asm"]["Wg"].apply(null,arguments)});var _crypto_sign_ed25519ph_statebytes=Module["_crypto_sign_ed25519ph_statebytes"]=(function(){return Module["asm"]["Xg"].apply(null,arguments)});var _crypto_sign_ed25519ph_update=Module["_crypto_sign_ed25519ph_update"]=(function(){return Module["asm"]["Yg"].apply(null,arguments)});var _crypto_sign_final_create=Module["_crypto_sign_final_create"]=(function(){return Module["asm"]["Zg"].apply(null,arguments)});var _crypto_sign_final_verify=Module["_crypto_sign_final_verify"]=(function(){return Module["asm"]["_g"].apply(null,arguments)});var _crypto_sign_init=Module["_crypto_sign_init"]=(function(){return Module["asm"]["$g"].apply(null,arguments)});var _crypto_sign_keypair=Module["_crypto_sign_keypair"]=(function(){return Module["asm"]["ah"].apply(null,arguments)});var _crypto_sign_open=Module["_crypto_sign_open"]=(function(){return Module["asm"]["bh"].apply(null,arguments)});var _crypto_sign_primitive=Module["_crypto_sign_primitive"]=(function(){return Module["asm"]["ch"].apply(null,arguments)});var _crypto_sign_publickeybytes=Module["_crypto_sign_publickeybytes"]=(function(){return Module["asm"]["dh"].apply(null,arguments)});var _crypto_sign_secretkeybytes=Module["_crypto_sign_secretkeybytes"]=(function(){return Module["asm"]["eh"].apply(null,arguments)});var _crypto_sign_seed_keypair=Module["_crypto_sign_seed_keypair"]=(function(){return Module["asm"]["fh"].apply(null,arguments)});var _crypto_sign_seedbytes=Module["_crypto_sign_seedbytes"]=(function(){return Module["asm"]["gh"].apply(null,arguments)});var _crypto_sign_statebytes=Module["_crypto_sign_statebytes"]=(function(){return Module["asm"]["hh"].apply(null,arguments)});var _crypto_sign_update=Module["_crypto_sign_update"]=(function(){return Module["asm"]["ih"].apply(null,arguments)});var _crypto_sign_verify_detached=Module["_crypto_sign_verify_detached"]=(function(){return Module["asm"]["jh"].apply(null,arguments)});var _crypto_stream=Module["_crypto_stream"]=(function(){return Module["asm"]["kh"].apply(null,arguments)});var _crypto_stream_chacha20=Module["_crypto_stream_chacha20"]=(function(){return Module["asm"]["lh"].apply(null,arguments)});var _crypto_stream_chacha20_ietf=Module["_crypto_stream_chacha20_ietf"]=(function(){return Module["asm"]["mh"].apply(null,arguments)});var _crypto_stream_chacha20_ietf_keybytes=Module["_crypto_stream_chacha20_ietf_keybytes"]=(function(){return Module["asm"]["nh"].apply(null,arguments)});var _crypto_stream_chacha20_ietf_keygen=Module["_crypto_stream_chacha20_ietf_keygen"]=(function(){return Module["asm"]["oh"].apply(null,arguments)});var _crypto_stream_chacha20_ietf_noncebytes=Module["_crypto_stream_chacha20_ietf_noncebytes"]=(function(){return Module["asm"]["ph"].apply(null,arguments)});var _crypto_stream_chacha20_ietf_xor=Module["_crypto_stream_chacha20_ietf_xor"]=(function(){return Module["asm"]["qh"].apply(null,arguments)});var _crypto_stream_chacha20_ietf_xor_ic=Module["_crypto_stream_chacha20_ietf_xor_ic"]=(function(){return Module["asm"]["rh"].apply(null,arguments)});var _crypto_stream_chacha20_keybytes=Module["_crypto_stream_chacha20_keybytes"]=(function(){return Module["asm"]["sh"].apply(null,arguments)});var _crypto_stream_chacha20_keygen=Module["_crypto_stream_chacha20_keygen"]=(function(){return Module["asm"]["th"].apply(null,arguments)});var _crypto_stream_chacha20_noncebytes=Module["_crypto_stream_chacha20_noncebytes"]=(function(){return Module["asm"]["uh"].apply(null,arguments)});var _crypto_stream_chacha20_xor=Module["_crypto_stream_chacha20_xor"]=(function(){return Module["asm"]["vh"].apply(null,arguments)});var _crypto_stream_chacha20_xor_ic=Module["_crypto_stream_chacha20_xor_ic"]=(function(){return Module["asm"]["wh"].apply(null,arguments)});var _crypto_stream_keybytes=Module["_crypto_stream_keybytes"]=(function(){return Module["asm"]["xh"].apply(null,arguments)});var _crypto_stream_keygen=Module["_crypto_stream_keygen"]=(function(){return Module["asm"]["yh"].apply(null,arguments)});var _crypto_stream_noncebytes=Module["_crypto_stream_noncebytes"]=(function(){return Module["asm"]["zh"].apply(null,arguments)});var _crypto_stream_primitive=Module["_crypto_stream_primitive"]=(function(){return Module["asm"]["Ah"].apply(null,arguments)});var _crypto_stream_salsa20=Module["_crypto_stream_salsa20"]=(function(){return Module["asm"]["Bh"].apply(null,arguments)});var _crypto_stream_salsa2012=Module["_crypto_stream_salsa2012"]=(function(){return Module["asm"]["Ch"].apply(null,arguments)});var _crypto_stream_salsa2012_keybytes=Module["_crypto_stream_salsa2012_keybytes"]=(function(){return Module["asm"]["Dh"].apply(null,arguments)});var _crypto_stream_salsa2012_keygen=Module["_crypto_stream_salsa2012_keygen"]=(function(){return Module["asm"]["Eh"].apply(null,arguments)});var _crypto_stream_salsa2012_noncebytes=Module["_crypto_stream_salsa2012_noncebytes"]=(function(){return Module["asm"]["Fh"].apply(null,arguments)});var _crypto_stream_salsa2012_xor=Module["_crypto_stream_salsa2012_xor"]=(function(){return Module["asm"]["Gh"].apply(null,arguments)});var _crypto_stream_salsa208=Module["_crypto_stream_salsa208"]=(function(){return Module["asm"]["Hh"].apply(null,arguments)});var _crypto_stream_salsa208_keybytes=Module["_crypto_stream_salsa208_keybytes"]=(function(){return Module["asm"]["Ih"].apply(null,arguments)});var _crypto_stream_salsa208_keygen=Module["_crypto_stream_salsa208_keygen"]=(function(){return Module["asm"]["Jh"].apply(null,arguments)});var _crypto_stream_salsa208_messagebytes_max=Module["_crypto_stream_salsa208_messagebytes_max"]=(function(){return Module["asm"]["Kh"].apply(null,arguments)});var _crypto_stream_salsa208_noncebytes=Module["_crypto_stream_salsa208_noncebytes"]=(function(){return Module["asm"]["Lh"].apply(null,arguments)});var _crypto_stream_salsa208_xor=Module["_crypto_stream_salsa208_xor"]=(function(){return Module["asm"]["Mh"].apply(null,arguments)});var _crypto_stream_salsa20_keybytes=Module["_crypto_stream_salsa20_keybytes"]=(function(){return Module["asm"]["Nh"].apply(null,arguments)});var _crypto_stream_salsa20_keygen=Module["_crypto_stream_salsa20_keygen"]=(function(){return Module["asm"]["Oh"].apply(null,arguments)});var _crypto_stream_salsa20_noncebytes=Module["_crypto_stream_salsa20_noncebytes"]=(function(){return Module["asm"]["Ph"].apply(null,arguments)});var _crypto_stream_salsa20_xor=Module["_crypto_stream_salsa20_xor"]=(function(){return Module["asm"]["Qh"].apply(null,arguments)});var _crypto_stream_salsa20_xor_ic=Module["_crypto_stream_salsa20_xor_ic"]=(function(){return Module["asm"]["Rh"].apply(null,arguments)});var _crypto_stream_xchacha20=Module["_crypto_stream_xchacha20"]=(function(){return Module["asm"]["Sh"].apply(null,arguments)});var _crypto_stream_xchacha20_keybytes=Module["_crypto_stream_xchacha20_keybytes"]=(function(){return Module["asm"]["Th"].apply(null,arguments)});var _crypto_stream_xchacha20_keygen=Module["_crypto_stream_xchacha20_keygen"]=(function(){return Module["asm"]["Uh"].apply(null,arguments)});var _crypto_stream_xchacha20_noncebytes=Module["_crypto_stream_xchacha20_noncebytes"]=(function(){return Module["asm"]["Vh"].apply(null,arguments)});var _crypto_stream_xchacha20_xor=Module["_crypto_stream_xchacha20_xor"]=(function(){return Module["asm"]["Wh"].apply(null,arguments)});var _crypto_stream_xchacha20_xor_ic=Module["_crypto_stream_xchacha20_xor_ic"]=(function(){return Module["asm"]["Xh"].apply(null,arguments)});var _crypto_stream_xor=Module["_crypto_stream_xor"]=(function(){return Module["asm"]["Yh"].apply(null,arguments)});var _crypto_stream_xsalsa20=Module["_crypto_stream_xsalsa20"]=(function(){return Module["asm"]["Zh"].apply(null,arguments)});var _crypto_stream_xsalsa20_keybytes=Module["_crypto_stream_xsalsa20_keybytes"]=(function(){return Module["asm"]["_h"].apply(null,arguments)});var _crypto_stream_xsalsa20_keygen=Module["_crypto_stream_xsalsa20_keygen"]=(function(){return Module["asm"]["$h"].apply(null,arguments)});var _crypto_stream_xsalsa20_noncebytes=Module["_crypto_stream_xsalsa20_noncebytes"]=(function(){return Module["asm"]["ai"].apply(null,arguments)});var _crypto_stream_xsalsa20_xor=Module["_crypto_stream_xsalsa20_xor"]=(function(){return Module["asm"]["bi"].apply(null,arguments)});var _crypto_stream_xsalsa20_xor_ic=Module["_crypto_stream_xsalsa20_xor_ic"]=(function(){return Module["asm"]["ci"].apply(null,arguments)});var _crypto_verify_16=Module["_crypto_verify_16"]=(function(){return Module["asm"]["di"].apply(null,arguments)});var _crypto_verify_16_bytes=Module["_crypto_verify_16_bytes"]=(function(){return Module["asm"]["ei"].apply(null,arguments)});var _crypto_verify_32=Module["_crypto_verify_32"]=(function(){return Module["asm"]["fi"].apply(null,arguments)});var _crypto_verify_32_bytes=Module["_crypto_verify_32_bytes"]=(function(){return Module["asm"]["gi"].apply(null,arguments)});var _crypto_verify_64=Module["_crypto_verify_64"]=(function(){return Module["asm"]["hi"].apply(null,arguments)});var _crypto_verify_64_bytes=Module["_crypto_verify_64_bytes"]=(function(){return Module["asm"]["ii"].apply(null,arguments)});var _emscripten_replace_memory=Module["_emscripten_replace_memory"]=(function(){return Module["asm"]["_emscripten_replace_memory"].apply(null,arguments)});var _free=Module["_free"]=(function(){return Module["asm"]["ji"].apply(null,arguments)});var _malloc=Module["_malloc"]=(function(){return Module["asm"]["ki"].apply(null,arguments)});var _randombytes=Module["_randombytes"]=(function(){return Module["asm"]["li"].apply(null,arguments)});var _randombytes_buf=Module["_randombytes_buf"]=(function(){return Module["asm"]["mi"].apply(null,arguments)});var _randombytes_buf_deterministic=Module["_randombytes_buf_deterministic"]=(function(){return Module["asm"]["ni"].apply(null,arguments)});var _randombytes_close=Module["_randombytes_close"]=(function(){return Module["asm"]["oi"].apply(null,arguments)});var _randombytes_implementation_name=Module["_randombytes_implementation_name"]=(function(){return Module["asm"]["pi"].apply(null,arguments)});var _randombytes_random=Module["_randombytes_random"]=(function(){return Module["asm"]["qi"].apply(null,arguments)});var _randombytes_seedbytes=Module["_randombytes_seedbytes"]=(function(){return Module["asm"]["ri"].apply(null,arguments)});var _randombytes_stir=Module["_randombytes_stir"]=(function(){return Module["asm"]["si"].apply(null,arguments)});var _randombytes_uniform=Module["_randombytes_uniform"]=(function(){return Module["asm"]["ti"].apply(null,arguments)});var _sodium_base642bin=Module["_sodium_base642bin"]=(function(){return Module["asm"]["ui"].apply(null,arguments)});var _sodium_base64_encoded_len=Module["_sodium_base64_encoded_len"]=(function(){return Module["asm"]["vi"].apply(null,arguments)});var _sodium_bin2base64=Module["_sodium_bin2base64"]=(function(){return Module["asm"]["wi"].apply(null,arguments)});var _sodium_bin2hex=Module["_sodium_bin2hex"]=(function(){return Module["asm"]["xi"].apply(null,arguments)});var _sodium_hex2bin=Module["_sodium_hex2bin"]=(function(){return Module["asm"]["yi"].apply(null,arguments)});var _sodium_init=Module["_sodium_init"]=(function(){return Module["asm"]["zi"].apply(null,arguments)});var _sodium_library_minimal=Module["_sodium_library_minimal"]=(function(){return Module["asm"]["Ai"].apply(null,arguments)});var _sodium_library_version_major=Module["_sodium_library_version_major"]=(function(){return Module["asm"]["Bi"].apply(null,arguments)});var _sodium_library_version_minor=Module["_sodium_library_version_minor"]=(function(){return Module["asm"]["Ci"].apply(null,arguments)});var _sodium_pad=Module["_sodium_pad"]=(function(){return Module["asm"]["Di"].apply(null,arguments)});var _sodium_unpad=Module["_sodium_unpad"]=(function(){return Module["asm"]["Ei"].apply(null,arguments)});var _sodium_version_string=Module["_sodium_version_string"]=(function(){return Module["asm"]["Fi"].apply(null,arguments)});Module["asm"]=asm;Module["setValue"]=setValue;Module["getValue"]=getValue;Module["Pointer_stringify"]=Pointer_stringify;function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}ExitStatus.prototype=new Error;ExitStatus.prototype.constructor=ExitStatus;dependenciesFulfilled=function runCaller(){if(!Module["calledRun"])run();if(!Module["calledRun"])dependenciesFulfilled=runCaller};function run(args){args=args||Module["arguments"];if(runDependencies>0){return}preRun();if(runDependencies>0)return;if(Module["calledRun"])return;function doRun(){if(Module["calledRun"])return;Module["calledRun"]=true;if(ABORT)return;ensureInitRuntime();preMain();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout((function(){setTimeout((function(){Module["setStatus"]("")}),1);doRun()}),1)}else{doRun()}}Module["run"]=run;function abort(what){if(Module["onAbort"]){Module["onAbort"](what)}if(what!==undefined){out(what);err(what);what=JSON.stringify(what)}else{what=""}ABORT=true;EXITSTATUS=1;throw"abort("+what+"). Build with -s ASSERTIONS=1 for more info."}Module["abort"]=abort;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}Module["noExitRuntime"]=true;run() | |
20583 | }).catch(function () { | |
20584 | _Module.useBackupModule(); | |
20585 | }); | |
20586 | function nacl_cooked(nacl_raw) { | |
20587 | 'use strict'; | |
20588 | var exports = {}; | |
20589 | ||
20590 | //--------------------------------------------------------------------------- | |
20591 | // Horrifying UTF-8 and hex codecs | |
20592 | ||
20593 | function encode_utf8(s) { | |
20594 | return encode_latin1(unescape(encodeURIComponent(s))); | |
20595 | } | |
20596 | ||
20597 | function encode_latin1(s) { | |
20598 | var result = new Uint8Array(s.length); | |
20599 | for (var i = 0; i < s.length; i++) { | |
20600 | var c = s.charCodeAt(i); | |
20601 | if ((c & 0xff) !== c) throw {message: "Cannot encode string in Latin1", str: s}; | |
20602 | result[i] = (c & 0xff); | |
20603 | } | |
20604 | return result; | |
20605 | } | |
20606 | ||
20607 | function decode_utf8(bs) { | |
20608 | return decodeURIComponent(escape(decode_latin1(bs))); | |
20609 | } | |
20610 | ||
20611 | function decode_latin1(bs) { | |
20612 | var encoded = []; | |
20613 | for (var i = 0; i < bs.length; i++) { | |
20614 | encoded.push(String.fromCharCode(bs[i])); | |
20615 | } | |
20616 | return encoded.join(''); | |
20617 | } | |
20618 | ||
20619 | function to_hex(bs) { | |
20620 | var encoded = []; | |
20621 | for (var i = 0; i < bs.length; i++) { | |
20622 | encoded.push("0123456789abcdef"[(bs[i] >> 4) & 15]); | |
20623 | encoded.push("0123456789abcdef"[bs[i] & 15]); | |
20624 | } | |
20625 | return encoded.join(''); | |
20626 | } | |
20627 | ||
20628 | function from_hex(s) { | |
20629 | var result = new Uint8Array(s.length / 2); | |
20630 | for (var i = 0; i < s.length / 2; i++) { | |
20631 | result[i] = parseInt(s.substr(2*i,2),16); | |
20632 | } | |
20633 | return result; | |
20634 | } | |
20635 | ||
20636 | //--------------------------------------------------------------------------- | |
20637 | // Allocation | |
20638 | ||
20639 | function MALLOC(nbytes) { | |
20640 | var result = nacl_raw._malloc(nbytes); | |
20641 | if (result === 0) { | |
20642 | throw {message: "malloc() failed", nbytes: nbytes}; | |
20643 | } | |
20644 | return result; | |
20645 | } | |
20646 | ||
20647 | function FREE(pointer) { | |
20648 | nacl_raw._free(pointer); | |
20649 | } | |
20650 | ||
20651 | //--------------------------------------------------------------------------- | |
20652 | ||
20653 | function injectBytes(bs, leftPadding) { | |
20654 | var p = leftPadding || 0; | |
20655 | var address = MALLOC(bs.length + p); | |
20656 | nacl_raw.HEAPU8.set(bs, address + p); | |
20657 | for (var i = address; i < address + p; i++) { | |
20658 | nacl_raw.HEAPU8[i] = 0; | |
20659 | } | |
20660 | return address; | |
20661 | } | |
20662 | ||
20663 | function check_injectBytes(function_name, what, thing, expected_length, leftPadding) { | |
20664 | check_length(function_name, what, thing, expected_length); | |
20665 | return injectBytes(thing, leftPadding); | |
20666 | } | |
20667 | ||
20668 | function extractBytes(address, length) { | |
20669 | var result = new Uint8Array(length); | |
20670 | result.set(nacl_raw.HEAPU8.subarray(address, address + length)); | |
20671 | return result; | |
20672 | } | |
20673 | ||
20674 | //--------------------------------------------------------------------------- | |
20675 | ||
20676 | function check(function_name, result) { | |
20677 | if (result !== 0) { | |
20678 | throw {message: "nacl_raw." + function_name + " signalled an error"}; | |
20679 | } | |
20680 | } | |
20681 | ||
20682 | function check_length(function_name, what, thing, expected_length) { | |
20683 | if (thing.length !== expected_length) { | |
20684 | throw {message: "nacl." + function_name + " expected " + | |
20685 | expected_length + "-byte " + what + " but got length " + thing.length}; | |
20686 | } | |
20687 | } | |
20688 | ||
20689 | function Target(length) { | |
20690 | this.length = length; | |
20691 | this.address = MALLOC(length); | |
20692 | } | |
20693 | ||
20694 | Target.prototype.extractBytes = function (offset) { | |
20695 | var result = extractBytes(this.address + (offset || 0), this.length - (offset || 0)); | |
20696 | FREE(this.address); | |
20697 | this.address = null; | |
20698 | return result; | |
20699 | }; | |
20700 | ||
20701 | function free_all(addresses) { | |
20702 | for (var i = 0; i < addresses.length; i++) { | |
20703 | FREE(addresses[i]); | |
20704 | } | |
20705 | } | |
20706 | ||
20707 | //--------------------------------------------------------------------------- | |
20708 | // Randomness | |
20709 | ||
20710 | function random_bytes(count) { | |
20711 | var bs = new Target(count); | |
20712 | nacl_raw._randombytes_buf(bs.address, count); | |
20713 | return bs.extractBytes(); | |
20714 | } | |
20715 | ||
20716 | nacl_raw._randombytes_stir(); | |
20717 | ||
20718 | //--------------------------------------------------------------------------- | |
20719 | // Boxing | |
20720 | ||
20721 | function crypto_box_keypair() { | |
20722 | var pk = new Target(nacl_raw._crypto_box_publickeybytes()); | |
20723 | var sk = new Target(nacl_raw._crypto_box_secretkeybytes()); | |
20724 | check("_crypto_box_keypair", nacl_raw._crypto_box_keypair(pk.address, sk.address)); | |
20725 | return {boxPk: pk.extractBytes(), boxSk: sk.extractBytes()}; | |
20726 | } | |
20727 | ||
20728 | function crypto_box_random_nonce() { | |
20729 | return random_bytes(nacl_raw._crypto_box_noncebytes()); | |
20730 | } | |
20731 | ||
20732 | function crypto_box(msg, nonce, pk, sk) { | |
20733 | var m = injectBytes(msg, nacl_raw._crypto_box_zerobytes()); | |
20734 | var na = check_injectBytes("crypto_box", "nonce", nonce, nacl_raw._crypto_box_noncebytes()); | |
20735 | var pka = check_injectBytes("crypto_box", "pk", pk, nacl_raw._crypto_box_publickeybytes()); | |
20736 | var ska = check_injectBytes("crypto_box", "sk", sk, nacl_raw._crypto_box_secretkeybytes()); | |
20737 | var c = new Target(msg.length + nacl_raw._crypto_box_zerobytes()); | |
20738 | check("_crypto_box", nacl_raw._crypto_box(c.address, m, c.length, 0, na, pka, ska)); | |
20739 | free_all([m, na, pka, ska]); | |
20740 | return c.extractBytes(nacl_raw._crypto_box_boxzerobytes()); | |
20741 | } | |
20742 | ||
20743 | function crypto_box_open(ciphertext, nonce, pk, sk) { | |
20744 | var c = injectBytes(ciphertext, nacl_raw._crypto_box_boxzerobytes()); | |
20745 | var na = check_injectBytes("crypto_box_open", | |
20746 | "nonce", nonce, nacl_raw._crypto_box_noncebytes()); | |
20747 | var pka = check_injectBytes("crypto_box_open", | |
20748 | "pk", pk, nacl_raw._crypto_box_publickeybytes()); | |
20749 | var ska = check_injectBytes("crypto_box_open", | |
20750 | "sk", sk, nacl_raw._crypto_box_secretkeybytes()); | |
20751 | var m = new Target(ciphertext.length + nacl_raw._crypto_box_boxzerobytes()); | |
20752 | check("_crypto_box_open", nacl_raw._crypto_box_open(m.address, c, m.length, 0, na, pka, ska)); | |
20753 | free_all([c, na, pka, ska]); | |
20754 | return m.extractBytes(nacl_raw._crypto_box_zerobytes()); | |
20755 | } | |
20756 | ||
20757 | function crypto_box_precompute(pk, sk) { | |
20758 | var pka = check_injectBytes("crypto_box_precompute", | |
20759 | "pk", pk, nacl_raw._crypto_box_publickeybytes()); | |
20760 | var ska = check_injectBytes("crypto_box_precompute", | |
20761 | "sk", sk, nacl_raw._crypto_box_secretkeybytes()); | |
20762 | var k = new Target(nacl_raw._crypto_box_beforenmbytes()); | |
20763 | check("_crypto_box_beforenm", | |
20764 | nacl_raw._crypto_box_beforenm(k.address, pka, ska)); | |
20765 | free_all([pka, ska]); | |
20766 | return {boxK: k.extractBytes()}; | |
20767 | } | |
20768 | ||
20769 | function crypto_box_precomputed(msg, nonce, state) { | |
20770 | var m = injectBytes(msg, nacl_raw._crypto_box_zerobytes()); | |
20771 | var na = check_injectBytes("crypto_box_precomputed", | |
20772 | "nonce", nonce, nacl_raw._crypto_box_noncebytes()); | |
20773 | var ka = check_injectBytes("crypto_box_precomputed", | |
20774 | "boxK", state.boxK, nacl_raw._crypto_box_beforenmbytes()); | |
20775 | var c = new Target(msg.length + nacl_raw._crypto_box_zerobytes()); | |
20776 | check("_crypto_box_afternm", | |
20777 | nacl_raw._crypto_box_afternm(c.address, m, c.length, 0, na, ka)); | |
20778 | free_all([m, na, ka]); | |
20779 | return c.extractBytes(nacl_raw._crypto_box_boxzerobytes()); | |
20780 | } | |
20781 | ||
20782 | function crypto_box_open_precomputed(ciphertext, nonce, state) { | |
20783 | var c = injectBytes(ciphertext, nacl_raw._crypto_box_boxzerobytes()); | |
20784 | var na = check_injectBytes("crypto_box_open_precomputed", | |
20785 | "nonce", nonce, nacl_raw._crypto_box_noncebytes()); | |
20786 | var ka = check_injectBytes("crypto_box_open_precomputed", | |
20787 | "boxK", state.boxK, nacl_raw._crypto_box_beforenmbytes()); | |
20788 | var m = new Target(ciphertext.length + nacl_raw._crypto_box_boxzerobytes()); | |
20789 | check("_crypto_box_open_afternm", | |
20790 | nacl_raw._crypto_box_open_afternm(m.address, c, m.length, 0, na, ka)); | |
20791 | free_all([c, na, ka]); | |
20792 | return m.extractBytes(nacl_raw._crypto_box_zerobytes()); | |
20793 | } | |
20794 | ||
20795 | //--------------------------------------------------------------------------- | |
20796 | // Hashing | |
20797 | ||
20798 | function crypto_hash(bs) { | |
20799 | var address = injectBytes(bs); | |
20800 | var hash = new Target(nacl_raw._crypto_hash_bytes()); | |
20801 | check("_crypto_hash", nacl_raw._crypto_hash(hash.address, address, bs.length, 0)); | |
20802 | FREE(address); | |
20803 | return hash.extractBytes(); | |
20804 | } | |
20805 | ||
20806 | function crypto_hash_sha256(bs) { | |
20807 | var address = injectBytes(bs); | |
20808 | var hash = new Target(nacl_raw._crypto_hash_sha256_bytes()); | |
20809 | check("_crypto_hash_sha256", | |
20810 | nacl_raw._crypto_hash_sha256(hash.address, address, bs.length, 0)); | |
20811 | FREE(address); | |
20812 | return hash.extractBytes(); | |
20813 | } | |
20814 | ||
20815 | function crypto_hash_string(s) { | |
20816 | return crypto_hash(encode_utf8(s)); | |
20817 | } | |
20818 | ||
20819 | //--------------------------------------------------------------------------- | |
20820 | // Symmetric-key encryption | |
20821 | ||
20822 | function crypto_stream_random_nonce() { | |
20823 | return random_bytes(nacl_raw._crypto_stream_noncebytes()); | |
20824 | } | |
20825 | ||
20826 | function crypto_stream(len, nonce, key) { | |
20827 | var na = check_injectBytes("crypto_stream", | |
20828 | "nonce", nonce, nacl_raw._crypto_stream_noncebytes()); | |
20829 | var ka = check_injectBytes("crypto_stream", | |
20830 | "key", key, nacl_raw._crypto_stream_keybytes()); | |
20831 | var out = new Target(len); | |
20832 | check("_crypto_stream", nacl_raw._crypto_stream(out.address, len, 0, na, ka)); | |
20833 | free_all([na, ka]); | |
20834 | return out.extractBytes(); | |
20835 | } | |
20836 | ||
20837 | function crypto_stream_xor(msg, nonce, key) { | |
20838 | var na = check_injectBytes("crypto_stream_xor", | |
20839 | "nonce", nonce, nacl_raw._crypto_stream_noncebytes()); | |
20840 | var ka = check_injectBytes("crypto_stream_xor", | |
20841 | "key", key, nacl_raw._crypto_stream_keybytes()); | |
20842 | var ma = injectBytes(msg); | |
20843 | var out = new Target(msg.length); | |
20844 | check("_crypto_stream_xor", | |
20845 | nacl_raw._crypto_stream_xor(out.address, ma, msg.length, 0, na, ka)); | |
20846 | free_all([na, ka, ma]); | |
20847 | return out.extractBytes(); | |
20848 | } | |
20849 | ||
20850 | //--------------------------------------------------------------------------- | |
20851 | // One-time authentication | |
20852 | ||
20853 | function crypto_onetimeauth(msg, key) { | |
20854 | var ka = check_injectBytes("crypto_onetimeauth", | |
20855 | "key", key, nacl_raw._crypto_onetimeauth_keybytes()); | |
20856 | var ma = injectBytes(msg); | |
20857 | var authenticator = new Target(nacl_raw._crypto_onetimeauth_bytes()); | |
20858 | check("_crypto_onetimeauth", | |
20859 | nacl_raw._crypto_onetimeauth(authenticator.address, ma, msg.length, 0, ka)); | |
20860 | free_all([ka, ma]); | |
20861 | return authenticator.extractBytes(); | |
20862 | } | |
20863 | ||
20864 | function crypto_onetimeauth_verify(authenticator, msg, key) { | |
20865 | if (authenticator.length != nacl_raw._crypto_onetimeauth_bytes()) return false; | |
20866 | var ka = check_injectBytes("crypto_onetimeauth_verify", | |
20867 | "key", key, nacl_raw._crypto_onetimeauth_keybytes()); | |
20868 | var ma = injectBytes(msg); | |
20869 | var aa = injectBytes(authenticator); | |
20870 | var result = nacl_raw._crypto_onetimeauth_verify(aa, ma, msg.length, 0, ka); | |
20871 | free_all([ka, ma, aa]); | |
20872 | return (result == 0); | |
20873 | } | |
20874 | ||
20875 | //--------------------------------------------------------------------------- | |
20876 | // Authentication | |
20877 | ||
20878 | function crypto_auth(msg, key) { | |
20879 | var ka = check_injectBytes("crypto_auth", "key", key, nacl_raw._crypto_auth_keybytes()); | |
20880 | var ma = injectBytes(msg); | |
20881 | var authenticator = new Target(nacl_raw._crypto_auth_bytes()); | |
20882 | check("_crypto_auth", nacl_raw._crypto_auth(authenticator.address, ma, msg.length, 0, ka)); | |
20883 | free_all([ka, ma]); | |
20884 | return authenticator.extractBytes(); | |
20885 | } | |
20886 | ||
20887 | function crypto_auth_verify(authenticator, msg, key) { | |
20888 | if (authenticator.length != nacl_raw._crypto_auth_bytes()) return false; | |
20889 | var ka = check_injectBytes("crypto_auth_verify", | |
20890 | "key", key, nacl_raw._crypto_auth_keybytes()); | |
20891 | var ma = injectBytes(msg); | |
20892 | var aa = injectBytes(authenticator); | |
20893 | var result = nacl_raw._crypto_auth_verify(aa, ma, msg.length, 0, ka); | |
20894 | free_all([ka, ma, aa]); | |
20895 | return (result == 0); | |
20896 | } | |
20897 | ||
20898 | //--------------------------------------------------------------------------- | |
20899 | // Authenticated symmetric-key encryption | |
20900 | ||
20901 | function crypto_secretbox_random_nonce() { | |
20902 | return random_bytes(nacl_raw._crypto_secretbox_noncebytes()); | |
20903 | } | |
20904 | ||
20905 | function crypto_secretbox(msg, nonce, key) { | |
20906 | var m = injectBytes(msg, nacl_raw._crypto_secretbox_zerobytes()); | |
20907 | var na = check_injectBytes("crypto_secretbox", | |
20908 | "nonce", nonce, nacl_raw._crypto_secretbox_noncebytes()); | |
20909 | var ka = check_injectBytes("crypto_secretbox", | |
20910 | "key", key, nacl_raw._crypto_secretbox_keybytes()); | |
20911 | var c = new Target(msg.length + nacl_raw._crypto_secretbox_zerobytes()); | |
20912 | check("_crypto_secretbox", nacl_raw._crypto_secretbox(c.address, m, c.length, 0, na, ka)); | |
20913 | free_all([m, na, ka]); | |
20914 | return c.extractBytes(nacl_raw._crypto_secretbox_boxzerobytes()); | |
20915 | } | |
20916 | ||
20917 | function crypto_secretbox_open(ciphertext, nonce, key) { | |
20918 | var c = injectBytes(ciphertext, nacl_raw._crypto_secretbox_boxzerobytes()); | |
20919 | var na = check_injectBytes("crypto_secretbox_open", | |
20920 | "nonce", nonce, nacl_raw._crypto_secretbox_noncebytes()); | |
20921 | var ka = check_injectBytes("crypto_secretbox_open", | |
20922 | "key", key, nacl_raw._crypto_secretbox_keybytes()); | |
20923 | var m = new Target(ciphertext.length + nacl_raw._crypto_secretbox_boxzerobytes()); | |
20924 | check("_crypto_secretbox_open", | |
20925 | nacl_raw._crypto_secretbox_open(m.address, c, m.length, 0, na, ka)); | |
20926 | free_all([c, na, ka]); | |
20927 | return m.extractBytes(nacl_raw._crypto_secretbox_zerobytes()); | |
20928 | } | |
20929 | ||
20930 | //--------------------------------------------------------------------------- | |
20931 | // Boxing with ephemeral keys | |
20932 | ||
20933 | function crypto_box_seal(msg, pk) { | |
20934 | var m = injectBytes(msg); | |
20935 | var pka = check_injectBytes("crypto_box_seal", | |
20936 | "pk", pk, nacl_raw._crypto_box_publickeybytes()); | |
20937 | var c = new Target(msg.length + nacl_raw._crypto_box_sealbytes()); | |
20938 | check("_crypto_box_seal", nacl_raw._crypto_box_seal(c.address, m, msg.length, 0, pka)); | |
20939 | free_all([m, pka]); | |
20940 | return c.extractBytes(); | |
20941 | } | |
20942 | ||
20943 | function crypto_box_seal_open(ciphertext, pk, sk) { | |
20944 | var c = injectBytes(ciphertext); | |
20945 | var pka = check_injectBytes("crypto_box_seal_open", | |
20946 | "pk", pk, nacl_raw._crypto_box_publickeybytes()); | |
20947 | var ska = check_injectBytes("crypto_box_seal_open", | |
20948 | "sk", sk, nacl_raw._crypto_box_secretkeybytes()); | |
20949 | var m = new Target(ciphertext.length - nacl_raw._crypto_box_sealbytes()); | |
20950 | check("_crypto_box_seal_open", | |
20951 | nacl_raw._crypto_box_seal_open(m.address, c, ciphertext.length, 0, pka, ska)); | |
20952 | free_all([c, pka, ska]); | |
20953 | return m.extractBytes(); | |
20954 | } | |
20955 | ||
20956 | //--------------------------------------------------------------------------- | |
20957 | // Signing | |
20958 | ||
20959 | function crypto_sign_keypair() { | |
20960 | var pk = new Target(nacl_raw._crypto_sign_publickeybytes()); | |
20961 | var sk = new Target(nacl_raw._crypto_sign_secretkeybytes()); | |
20962 | check("_crypto_sign_keypair", nacl_raw._crypto_sign_keypair(pk.address, sk.address)); | |
20963 | return {signPk: pk.extractBytes(), signSk: sk.extractBytes()}; | |
20964 | } | |
20965 | ||
20966 | function crypto_sign(msg, sk) { | |
20967 | var ma = injectBytes(msg); | |
20968 | var ska = check_injectBytes("crypto_sign", "sk", sk, nacl_raw._crypto_sign_secretkeybytes()); | |
20969 | var sm = new Target(msg.length + nacl_raw._crypto_sign_bytes()); | |
20970 | var smlen = new Target(8); | |
20971 | check("_crypto_sign", | |
20972 | nacl_raw._crypto_sign(sm.address, smlen.address, ma, msg.length, 0, ska)); | |
20973 | free_all([ma, ska]); | |
20974 | sm.length = nacl_raw.HEAPU32[smlen.address >> 2]; | |
20975 | FREE(smlen.address); | |
20976 | return sm.extractBytes(); | |
20977 | } | |
20978 | ||
20979 | function crypto_sign_detached(msg, sk) { | |
20980 | // WARNING: Experimental. Works for ed25519 but not necessarily other implementations. | |
20981 | var signed_msg = crypto_sign(msg, sk); | |
20982 | return signed_msg.subarray(0, nacl_raw._crypto_sign_bytes()); | |
20983 | } | |
20984 | ||
20985 | function crypto_sign_open(sm, pk) { | |
20986 | var sma = injectBytes(sm); | |
20987 | var pka = check_injectBytes("crypto_sign_open", | |
20988 | "pk", pk, nacl_raw._crypto_sign_publickeybytes()); | |
20989 | var m = new Target(sm.length); | |
20990 | var mlen = new Target(8); | |
20991 | if (nacl_raw._crypto_sign_open(m.address, mlen.address, sma, sm.length, 0, pka) === 0) { | |
20992 | free_all([sma, pka]); | |
20993 | m.length = nacl_raw.HEAPU32[mlen.address >> 2]; | |
20994 | FREE(mlen.address); | |
20995 | return m.extractBytes(); | |
20996 | } else { | |
20997 | free_all([sma, pka, m.address, mlen.address]); | |
20998 | return null; | |
20999 | } | |
21000 | } | |
21001 | ||
21002 | function crypto_sign_verify_detached(detached_signature, msg, pk) { | |
21003 | // WARNING: Experimental. Works for ed25519 but not necessarily other implementations. | |
21004 | var signed_msg = new Uint8Array(detached_signature.length + msg.length); | |
21005 | signed_msg.set(detached_signature, 0); | |
21006 | signed_msg.set(msg, detached_signature.length); | |
21007 | return crypto_sign_open(signed_msg, pk) !== null; | |
21008 | } | |
21009 | ||
21010 | //--------------------------------------------------------------------------- | |
21011 | // Keys | |
21012 | ||
21013 | function crypto_sign_seed_keypair(bs) { | |
21014 | var seeda = check_injectBytes("crypto_sign_seed_keypair", | |
21015 | "seed", bs, nacl_raw._crypto_sign_secretkeybytes() / 2); | |
21016 | var pk = new Target(nacl_raw._crypto_sign_publickeybytes()); | |
21017 | var sk = new Target(nacl_raw._crypto_sign_secretkeybytes()); | |
21018 | check("_crypto_sign_seed_keypair", | |
21019 | nacl_raw._crypto_sign_seed_keypair(pk.address, sk.address, seeda)); | |
21020 | FREE(seeda); | |
21021 | return {signPk: pk.extractBytes(), signSk: sk.extractBytes()}; | |
21022 | } | |
21023 | ||
21024 | function crypto_box_seed_keypair(bs) { | |
21025 | var hash = new Uint8Array(crypto_hash(bs)); | |
21026 | return crypto_box_keypair_from_raw_sk(hash.subarray(0, | |
21027 | nacl_raw._crypto_box_secretkeybytes())); | |
21028 | } | |
21029 | ||
21030 | function crypto_box_keypair_from_raw_sk(sk) { | |
21031 | return {boxPk: crypto_scalarmult_base(sk), boxSk: sk}; | |
21032 | } | |
21033 | ||
21034 | //--------------------------------------------------------------------------- | |
21035 | // Scalarmult | |
21036 | ||
21037 | function crypto_scalarmult(n,p) { | |
21038 | var na = check_injectBytes("crypto_scalarmult", "n", n, | |
21039 | nacl_raw._crypto_scalarmult_curve25519_scalarbytes()); | |
21040 | var pa = check_injectBytes("crypto_scalarmult", "p", p, | |
21041 | nacl_raw._crypto_scalarmult_curve25519_bytes()); | |
21042 | var q = new Target(nacl_raw._crypto_scalarmult_curve25519_bytes()); | |
21043 | check("_crypto_scalarmult_curve25519", | |
21044 | nacl_raw._crypto_scalarmult_curve25519(q.address, na, pa)); | |
21045 | FREE(na); | |
21046 | FREE(pa); | |
21047 | return q.extractBytes(); | |
21048 | } | |
21049 | ||
21050 | function crypto_scalarmult_base(n) { | |
21051 | var na = check_injectBytes("crypto_scalarmult_base", "n", n, | |
21052 | nacl_raw._crypto_scalarmult_curve25519_scalarbytes()); | |
21053 | var q = new Target(nacl_raw._crypto_scalarmult_curve25519_bytes()); | |
21054 | check("_crypto_scalarmult_curve25519_base", | |
21055 | nacl_raw._crypto_scalarmult_curve25519_base(q.address, na)); | |
21056 | FREE(na); | |
21057 | return q.extractBytes(); | |
21058 | } | |
21059 | ||
21060 | //--------------------------------------------------------------------------- | |
21061 | ||
21062 | exports.crypto_auth_BYTES = nacl_raw._crypto_auth_bytes(); | |
21063 | exports.crypto_auth_KEYBYTES = nacl_raw._crypto_auth_keybytes(); | |
21064 | exports.crypto_box_BEFORENMBYTES = nacl_raw._crypto_box_beforenmbytes(); | |
21065 | exports.crypto_box_BOXZEROBYTES = nacl_raw._crypto_box_boxzerobytes(); | |
21066 | exports.crypto_box_NONCEBYTES = nacl_raw._crypto_box_noncebytes(); | |
21067 | exports.crypto_box_PUBLICKEYBYTES = nacl_raw._crypto_box_publickeybytes(); | |
21068 | exports.crypto_box_SECRETKEYBYTES = nacl_raw._crypto_box_secretkeybytes(); | |
21069 | exports.crypto_box_ZEROBYTES = nacl_raw._crypto_box_zerobytes(); | |
21070 | exports.crypto_hash_BYTES = nacl_raw._crypto_hash_bytes(); | |
21071 | exports.crypto_hash_sha256_BYTES = nacl_raw._crypto_hash_sha256_bytes(); | |
21072 | // exports.crypto_hashblocks_BLOCKBYTES = nacl_raw._crypto_hashblocks_blockbytes(); | |
21073 | // exports.crypto_hashblocks_STATEBYTES = nacl_raw._crypto_hashblocks_statebytes(); | |
21074 | exports.crypto_onetimeauth_BYTES = nacl_raw._crypto_onetimeauth_bytes(); | |
21075 | exports.crypto_onetimeauth_KEYBYTES = nacl_raw._crypto_onetimeauth_keybytes(); | |
21076 | exports.crypto_secretbox_BOXZEROBYTES = nacl_raw._crypto_secretbox_boxzerobytes(); | |
21077 | exports.crypto_secretbox_KEYBYTES = nacl_raw._crypto_secretbox_keybytes(); | |
21078 | exports.crypto_secretbox_NONCEBYTES = nacl_raw._crypto_secretbox_noncebytes(); | |
21079 | exports.crypto_secretbox_ZEROBYTES = nacl_raw._crypto_secretbox_zerobytes(); | |
21080 | exports.crypto_sign_BYTES = nacl_raw._crypto_sign_bytes(); | |
21081 | exports.crypto_sign_PUBLICKEYBYTES = nacl_raw._crypto_sign_publickeybytes(); | |
21082 | exports.crypto_sign_SECRETKEYBYTES = nacl_raw._crypto_sign_secretkeybytes(); | |
21083 | // exports.crypto_stream_BEFORENMBYTES = nacl_raw._crypto_stream_beforenmbytes(); | |
21084 | exports.crypto_stream_KEYBYTES = nacl_raw._crypto_stream_keybytes(); | |
21085 | exports.crypto_stream_NONCEBYTES = nacl_raw._crypto_stream_noncebytes(); | |
21086 | exports.crypto_scalarmult_SCALARBYTES = nacl_raw._crypto_scalarmult_curve25519_scalarbytes(); | |
21087 | exports.crypto_scalarmult_BYTES = nacl_raw._crypto_scalarmult_curve25519_bytes(); | |
21088 | ||
21089 | exports.encode_utf8 = encode_utf8; | |
21090 | exports.encode_latin1 = encode_latin1; | |
21091 | exports.decode_utf8 = decode_utf8; | |
21092 | exports.decode_latin1 = decode_latin1; | |
21093 | exports.to_hex = to_hex; | |
21094 | exports.from_hex = from_hex; | |
21095 | ||
21096 | exports.random_bytes = random_bytes; | |
21097 | ||
21098 | exports.crypto_box_keypair = crypto_box_keypair; | |
21099 | exports.crypto_box_random_nonce = crypto_box_random_nonce; | |
21100 | exports.crypto_box = crypto_box; | |
21101 | exports.crypto_box_open = crypto_box_open; | |
21102 | exports.crypto_box_precompute = crypto_box_precompute; | |
21103 | exports.crypto_box_precomputed = crypto_box_precomputed; | |
21104 | exports.crypto_box_open_precomputed = crypto_box_open_precomputed; | |
21105 | ||
21106 | exports.crypto_stream_random_nonce = crypto_stream_random_nonce; | |
21107 | exports.crypto_stream = crypto_stream; | |
21108 | exports.crypto_stream_xor = crypto_stream_xor; | |
21109 | ||
21110 | exports.crypto_onetimeauth = crypto_onetimeauth; | |
21111 | exports.crypto_onetimeauth_verify = crypto_onetimeauth_verify; | |
21112 | ||
21113 | exports.crypto_auth = crypto_auth; | |
21114 | exports.crypto_auth_verify = crypto_auth_verify; | |
21115 | ||
21116 | exports.crypto_secretbox_random_nonce = crypto_secretbox_random_nonce; | |
21117 | exports.crypto_secretbox = crypto_secretbox; | |
21118 | exports.crypto_secretbox_open = crypto_secretbox_open; | |
21119 | ||
21120 | exports.crypto_box_seal = crypto_box_seal; | |
21121 | exports.crypto_box_seal_open = crypto_box_seal_open; | |
21122 | ||
21123 | exports.crypto_sign_keypair = crypto_sign_keypair; | |
21124 | exports.crypto_sign = crypto_sign; | |
21125 | exports.crypto_sign_detached = crypto_sign_detached; | |
21126 | exports.crypto_sign_open = crypto_sign_open; | |
21127 | exports.crypto_sign_verify_detached = crypto_sign_verify_detached; | |
21128 | ||
21129 | exports.crypto_hash = crypto_hash; | |
21130 | exports.crypto_hash_sha256 = crypto_hash_sha256; | |
21131 | exports.crypto_hash_string = crypto_hash_string; | |
21132 | ||
21133 | exports.crypto_sign_seed_keypair = crypto_sign_seed_keypair; | |
21134 | exports.crypto_box_seed_keypair = crypto_box_seed_keypair; | |
21135 | exports.crypto_box_keypair_from_raw_sk = crypto_box_keypair_from_raw_sk; | |
21136 | // Backwards-compatibility: | |
21137 | exports.crypto_sign_keypair_from_seed = crypto_sign_seed_keypair; | |
21138 | exports.crypto_box_keypair_from_seed = crypto_box_seed_keypair; | |
21139 | ||
21140 | exports.crypto_scalarmult = crypto_scalarmult; | |
21141 | exports.crypto_scalarmult_base = crypto_scalarmult_base; | |
21142 | ||
21143 | return exports; | |
21144 | } | |
21145 | return nacl_raw.ready.then(function () { | |
21146 | var nacl = nacl_cooked(nacl_raw); | |
21147 | nacl.nacl_raw = nacl_raw; | |
21148 | on_ready(nacl); | |
21149 | return nacl; | |
21150 | }); | |
21151 | })((typeof window !== 'undefined') ? window : undefined_reference_value, | |
21152 | (typeof document !== 'undefined') ? document : undefined_reference_value); | |
21153 | } | |
21154 | }; | |
21155 | ||
21156 | // export common.js module to allow one js file for browser and node.js | |
21157 | if (typeof module !== 'undefined' && module.exports) { | |
21158 | module.exports = nacl_factory; | |
21159 | } | |
21160 | ||
21161 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],"/node_modules/js-nacl/lib") | |
21162 | },{"_process":374,"buffer":50,"crypto":72,"fs":48,"path":367}],123:[function(require,module,exports){ | |
21163 | "use strict"; | |
21164 | ||
21165 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21166 | ||
21167 | 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; }; })(); | |
21168 | ||
21169 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
21170 | ||
21171 | Object.defineProperty(exports, "__esModule", { | |
21172 | value: true | |
21173 | }); | |
21174 | ||
21175 | var every = _interopRequire(require("lodash/every")); | |
21176 | ||
21177 | var each = _interopRequire(require("lodash/each")); | |
21178 | ||
21179 | var times = _interopRequire(require("lodash/times")); | |
21180 | ||
21181 | var isArray = _interopRequire(require("lodash/isArray")); | |
21182 | ||
21183 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21184 | ||
21185 | var Array = exports.Array = (function () { | |
21186 | function Array(childType, length) { | |
21187 | _classCallCheck(this, Array); | |
21188 | ||
21189 | this._childType = childType; | |
21190 | this._length = length; | |
21191 | } | |
21192 | ||
21193 | _createClass(Array, { | |
21194 | read: { | |
21195 | value: function read(io) { | |
21196 | var _this = this; | |
21197 | ||
21198 | return times(this._length, function () { | |
21199 | return _this._childType.read(io); | |
21200 | }); | |
21201 | } | |
21202 | }, | |
21203 | write: { | |
21204 | value: function write(value, io) { | |
21205 | var _this = this; | |
21206 | ||
21207 | if (!isArray(value)) { | |
21208 | throw new Error("XDR Write Error: value is not array"); | |
21209 | } | |
21210 | ||
21211 | if (value.length !== this._length) { | |
21212 | throw new Error("XDR Write Error: Got array of size " + value.length + "," + ("expected " + this._length)); | |
21213 | } | |
21214 | ||
21215 | each(value, function (child) { | |
21216 | return _this._childType.write(child, io); | |
21217 | }); | |
21218 | } | |
21219 | }, | |
21220 | isValid: { | |
21221 | value: function isValid(value) { | |
21222 | var _this = this; | |
21223 | ||
21224 | if (!isArray(value)) { | |
21225 | return false; | |
21226 | } | |
21227 | if (value.length !== this._length) { | |
21228 | return false; | |
21229 | } | |
21230 | ||
21231 | return every(value, function (child) { | |
21232 | return _this._childType.isValid(child); | |
21233 | }); | |
21234 | } | |
21235 | } | |
21236 | }); | |
21237 | ||
21238 | return Array; | |
21239 | })(); | |
21240 | ||
21241 | includeIoMixin(Array.prototype); | |
21242 | },{"./io-mixin":133,"lodash/each":312,"lodash/every":314,"lodash/isArray":323,"lodash/times":350}],124:[function(require,module,exports){ | |
21243 | "use strict"; | |
21244 | ||
21245 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21246 | ||
21247 | Object.defineProperty(exports, "__esModule", { | |
21248 | value: true | |
21249 | }); | |
21250 | ||
21251 | var Int = require("./int").Int; | |
21252 | ||
21253 | var isBoolean = _interopRequire(require("lodash/isBoolean")); | |
21254 | ||
21255 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21256 | ||
21257 | var Bool = { | |
21258 | read: function read(io) { | |
21259 | var value = Int.read(io); | |
21260 | ||
21261 | switch (value) { | |
21262 | case 0: | |
21263 | return false; | |
21264 | case 1: | |
21265 | return true; | |
21266 | default: | |
21267 | throw new Error("XDR Read Error: Got " + value + " when trying to read a bool"); | |
21268 | } | |
21269 | }, | |
21270 | ||
21271 | write: function write(value, io) { | |
21272 | var intVal = value ? 1 : 0; | |
21273 | return Int.write(intVal, io); | |
21274 | }, | |
21275 | ||
21276 | isValid: function isValid(value) { | |
21277 | return isBoolean(value); | |
21278 | } | |
21279 | }; | |
21280 | ||
21281 | exports.Bool = Bool; | |
21282 | includeIoMixin(Bool); | |
21283 | },{"./int":132,"./io-mixin":133,"lodash/isBoolean":325}],125:[function(require,module,exports){ | |
21284 | "use strict"; | |
21285 | ||
21286 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21287 | ||
21288 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | |
21289 | ||
21290 | 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; }; | |
21291 | ||
21292 | 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; }; })(); | |
21293 | ||
21294 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
21295 | ||
21296 | exports.config = config; | |
21297 | Object.defineProperty(exports, "__esModule", { | |
21298 | value: true | |
21299 | }); | |
21300 | ||
21301 | var XDR = _interopRequireWildcard(require("./types")); | |
21302 | ||
21303 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
21304 | ||
21305 | var isPlainObject = _interopRequire(require("lodash/isPlainObject")); | |
21306 | ||
21307 | var isArray = _interopRequire(require("lodash/isArray")); | |
21308 | ||
21309 | var each = _interopRequire(require("lodash/each")); | |
21310 | ||
21311 | var map = _interopRequire(require("lodash/map")); | |
21312 | ||
21313 | var pick = _interopRequire(require("lodash/pick")); | |
21314 | ||
21315 | function config(fn) { | |
21316 | var types = arguments[1] === undefined ? {} : arguments[1]; | |
21317 | ||
21318 | if (fn) { | |
21319 | var builder = new TypeBuilder(types); | |
21320 | fn(builder); | |
21321 | builder.resolve(); | |
21322 | } | |
21323 | ||
21324 | return types; | |
21325 | } | |
21326 | ||
21327 | var Reference = exports.Reference = (function () { | |
21328 | function Reference() { | |
21329 | _classCallCheck(this, Reference); | |
21330 | } | |
21331 | ||
21332 | _createClass(Reference, { | |
21333 | resolve: { | |
21334 | /* jshint unused: false */ | |
21335 | ||
21336 | value: function resolve(context) { | |
21337 | throw new Error("implement resolve in child class"); | |
21338 | } | |
21339 | } | |
21340 | }); | |
21341 | ||
21342 | return Reference; | |
21343 | })(); | |
21344 | ||
21345 | var SimpleReference = (function (_Reference) { | |
21346 | function SimpleReference(name) { | |
21347 | _classCallCheck(this, SimpleReference); | |
21348 | ||
21349 | this.name = name; | |
21350 | } | |
21351 | ||
21352 | _inherits(SimpleReference, _Reference); | |
21353 | ||
21354 | _createClass(SimpleReference, { | |
21355 | resolve: { | |
21356 | value: function resolve(context) { | |
21357 | var defn = context.definitions[this.name]; | |
21358 | return defn.resolve(context); | |
21359 | } | |
21360 | } | |
21361 | }); | |
21362 | ||
21363 | return SimpleReference; | |
21364 | })(Reference); | |
21365 | ||
21366 | var ArrayReference = (function (_Reference2) { | |
21367 | function ArrayReference(childReference, length) { | |
21368 | var variable = arguments[2] === undefined ? false : arguments[2]; | |
21369 | ||
21370 | _classCallCheck(this, ArrayReference); | |
21371 | ||
21372 | this.childReference = childReference; | |
21373 | this.length = length; | |
21374 | this.variable = variable; | |
21375 | } | |
21376 | ||
21377 | _inherits(ArrayReference, _Reference2); | |
21378 | ||
21379 | _createClass(ArrayReference, { | |
21380 | resolve: { | |
21381 | value: function resolve(context) { | |
21382 | var resolvedChild = this.childReference; | |
21383 | var length = this.length; | |
21384 | ||
21385 | if (resolvedChild instanceof Reference) { | |
21386 | resolvedChild = resolvedChild.resolve(context); | |
21387 | } | |
21388 | ||
21389 | if (length instanceof Reference) { | |
21390 | length = length.resolve(context); | |
21391 | } | |
21392 | ||
21393 | if (this.variable) { | |
21394 | return new XDR.VarArray(resolvedChild, length); | |
21395 | } else { | |
21396 | return new XDR.Array(resolvedChild, length); | |
21397 | } | |
21398 | } | |
21399 | } | |
21400 | }); | |
21401 | ||
21402 | return ArrayReference; | |
21403 | })(Reference); | |
21404 | ||
21405 | var OptionReference = (function (_Reference3) { | |
21406 | function OptionReference(childReference) { | |
21407 | _classCallCheck(this, OptionReference); | |
21408 | ||
21409 | this.childReference = childReference; | |
21410 | this.name = childReference.name; | |
21411 | } | |
21412 | ||
21413 | _inherits(OptionReference, _Reference3); | |
21414 | ||
21415 | _createClass(OptionReference, { | |
21416 | resolve: { | |
21417 | value: function resolve(context) { | |
21418 | var resolvedChild = this.childReference; | |
21419 | ||
21420 | if (resolvedChild instanceof Reference) { | |
21421 | resolvedChild = resolvedChild.resolve(context); | |
21422 | } | |
21423 | ||
21424 | return new XDR.Option(resolvedChild); | |
21425 | } | |
21426 | } | |
21427 | }); | |
21428 | ||
21429 | return OptionReference; | |
21430 | })(Reference); | |
21431 | ||
21432 | var SizedReference = (function (_Reference4) { | |
21433 | function SizedReference(sizedType, length) { | |
21434 | _classCallCheck(this, SizedReference); | |
21435 | ||
21436 | this.sizedType = sizedType; | |
21437 | this.length = length; | |
21438 | } | |
21439 | ||
21440 | _inherits(SizedReference, _Reference4); | |
21441 | ||
21442 | _createClass(SizedReference, { | |
21443 | resolve: { | |
21444 | value: function resolve(context) { | |
21445 | var length = this.length; | |
21446 | ||
21447 | if (length instanceof Reference) { | |
21448 | length = length.resolve(context); | |
21449 | } | |
21450 | ||
21451 | return new this.sizedType(length); | |
21452 | } | |
21453 | } | |
21454 | }); | |
21455 | ||
21456 | return SizedReference; | |
21457 | })(Reference); | |
21458 | ||
21459 | var Definition = (function () { | |
21460 | function Definition(constructor, name, config) { | |
21461 | _classCallCheck(this, Definition); | |
21462 | ||
21463 | this.constructor = constructor; | |
21464 | this.name = name; | |
21465 | this.config = config; | |
21466 | } | |
21467 | ||
21468 | _createClass(Definition, { | |
21469 | resolve: { | |
21470 | ||
21471 | // resolve calls the constructor of this definition with the provided context | |
21472 | // and this definitions config values. The definitions constructor should | |
21473 | // populate the final type on `context.results`, and may refer to other | |
21474 | // definitions through `context.definitions` | |
21475 | ||
21476 | value: function resolve(context) { | |
21477 | if (this.name in context.results) { | |
21478 | return context.results[this.name]; | |
21479 | } | |
21480 | ||
21481 | return this.constructor(context, this.name, this.config); | |
21482 | } | |
21483 | } | |
21484 | }); | |
21485 | ||
21486 | return Definition; | |
21487 | })(); | |
21488 | ||
21489 | var TypeBuilder = (function () { | |
21490 | function TypeBuilder(destination) { | |
21491 | _classCallCheck(this, TypeBuilder); | |
21492 | ||
21493 | this._destination = destination; | |
21494 | this._definitions = {}; | |
21495 | } | |
21496 | ||
21497 | _createClass(TypeBuilder, { | |
21498 | "enum": { | |
21499 | value: function _enum(name, members) { | |
21500 | var result = new Definition(XDR.Enum.create, name, members); | |
21501 | this.define(name, result); | |
21502 | } | |
21503 | }, | |
21504 | struct: { | |
21505 | value: function struct(name, members) { | |
21506 | var result = new Definition(XDR.Struct.create, name, members); | |
21507 | this.define(name, result); | |
21508 | } | |
21509 | }, | |
21510 | union: { | |
21511 | value: function union(name, config) { | |
21512 | var result = new Definition(XDR.Union.create, name, config); | |
21513 | this.define(name, result); | |
21514 | } | |
21515 | }, | |
21516 | typedef: { | |
21517 | value: function typedef(name, config) { | |
21518 | // let the reference resoltion system do it's thing | |
21519 | // the "constructor" for a typedef just returns the resolved value | |
21520 | var createTypedef = function (context, name, value) { | |
21521 | if (value instanceof Reference) { | |
21522 | value = value.resolve(context); | |
21523 | } | |
21524 | context.results[name] = value; | |
21525 | return value; | |
21526 | }; | |
21527 | ||
21528 | var result = new Definition(createTypedef, name, config); | |
21529 | this.define(name, result); | |
21530 | } | |
21531 | }, | |
21532 | "const": { | |
21533 | value: function _const(name, config) { | |
21534 | var createConst = function (context, name, value) { | |
21535 | context.results[name] = value; | |
21536 | return value; | |
21537 | }; | |
21538 | ||
21539 | var result = new Definition(createConst, name, config); | |
21540 | this.define(name, result); | |
21541 | } | |
21542 | }, | |
21543 | "void": { | |
21544 | value: function _void() { | |
21545 | return XDR.Void; | |
21546 | } | |
21547 | }, | |
21548 | bool: { | |
21549 | value: function bool() { | |
21550 | return XDR.Bool; | |
21551 | } | |
21552 | }, | |
21553 | int: { | |
21554 | value: function int() { | |
21555 | return XDR.Int; | |
21556 | } | |
21557 | }, | |
21558 | hyper: { | |
21559 | value: function hyper() { | |
21560 | return XDR.Hyper; | |
21561 | } | |
21562 | }, | |
21563 | uint: { | |
21564 | value: function uint() { | |
21565 | return XDR.UnsignedInt; | |
21566 | } | |
21567 | }, | |
21568 | uhyper: { | |
21569 | value: function uhyper() { | |
21570 | return XDR.UnsignedHyper; | |
21571 | } | |
21572 | }, | |
21573 | float: { | |
21574 | value: function float() { | |
21575 | return XDR.Float; | |
21576 | } | |
21577 | }, | |
21578 | double: { | |
21579 | value: function double() { | |
21580 | return XDR.Double; | |
21581 | } | |
21582 | }, | |
21583 | quadruple: { | |
21584 | value: function quadruple() { | |
21585 | return XDR.Quadruple; | |
21586 | } | |
21587 | }, | |
21588 | string: { | |
21589 | value: function string(length) { | |
21590 | return new SizedReference(XDR.String, length); | |
21591 | } | |
21592 | }, | |
21593 | opaque: { | |
21594 | value: function opaque(length) { | |
21595 | return new SizedReference(XDR.Opaque, length); | |
21596 | } | |
21597 | }, | |
21598 | varOpaque: { | |
21599 | value: function varOpaque(length) { | |
21600 | return new SizedReference(XDR.VarOpaque, length); | |
21601 | } | |
21602 | }, | |
21603 | array: { | |
21604 | value: function array(childType, length) { | |
21605 | return new ArrayReference(childType, length); | |
21606 | } | |
21607 | }, | |
21608 | varArray: { | |
21609 | value: function varArray(childType, maxLength) { | |
21610 | return new ArrayReference(childType, maxLength, true); | |
21611 | } | |
21612 | }, | |
21613 | option: { | |
21614 | value: function option(childType) { | |
21615 | return new OptionReference(childType); | |
21616 | } | |
21617 | }, | |
21618 | define: { | |
21619 | value: function define(name, definition) { | |
21620 | if (isUndefined(this._destination[name])) { | |
21621 | this._definitions[name] = definition; | |
21622 | } else { | |
21623 | throw new Error("XDR Error:" + name + " is already defined"); | |
21624 | } | |
21625 | } | |
21626 | }, | |
21627 | lookup: { | |
21628 | value: function lookup(name) { | |
21629 | return new SimpleReference(name); | |
21630 | } | |
21631 | }, | |
21632 | resolve: { | |
21633 | value: function resolve() { | |
21634 | var _this = this; | |
21635 | ||
21636 | each(this._definitions, function (defn, name) { | |
21637 | defn.resolve({ | |
21638 | definitions: _this._definitions, | |
21639 | results: _this._destination | |
21640 | }); | |
21641 | }); | |
21642 | } | |
21643 | } | |
21644 | }); | |
21645 | ||
21646 | return TypeBuilder; | |
21647 | })(); | |
21648 | },{"./types":139,"lodash/each":312,"lodash/isArray":323,"lodash/isPlainObject":335,"lodash/isUndefined":340,"lodash/map":343,"lodash/pick":346}],126:[function(require,module,exports){ | |
21649 | (function (Buffer){ | |
21650 | "use strict"; | |
21651 | ||
21652 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21653 | ||
21654 | 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; }; })(); | |
21655 | ||
21656 | 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; }; | |
21657 | ||
21658 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
21659 | ||
21660 | Object.defineProperty(exports, "__esModule", { | |
21661 | value: true | |
21662 | }); | |
21663 | ||
21664 | var BaseCursor = _interopRequire(require("cursor")); | |
21665 | ||
21666 | var calculatePadding = require("./util").calculatePadding; | |
21667 | ||
21668 | var Cursor = exports.Cursor = (function (_BaseCursor) { | |
21669 | function Cursor() { | |
21670 | _classCallCheck(this, Cursor); | |
21671 | ||
21672 | if (_BaseCursor != null) { | |
21673 | _BaseCursor.apply(this, arguments); | |
21674 | } | |
21675 | } | |
21676 | ||
21677 | _inherits(Cursor, _BaseCursor); | |
21678 | ||
21679 | _createClass(Cursor, { | |
21680 | writeBufferPadded: { | |
21681 | value: function writeBufferPadded(buffer) { | |
21682 | var padding = calculatePadding(buffer.length); | |
21683 | var paddingBuffer = Buffer.alloc(padding); | |
21684 | ||
21685 | return this.copyFrom(new Cursor(buffer)).copyFrom(new Cursor(paddingBuffer)); | |
21686 | } | |
21687 | } | |
21688 | }); | |
21689 | ||
21690 | return Cursor; | |
21691 | })(BaseCursor); | |
21692 | }).call(this,require("buffer").Buffer) | |
21693 | },{"./util":143,"buffer":50,"cursor":73}],127:[function(require,module,exports){ | |
21694 | "use strict"; | |
21695 | ||
21696 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21697 | ||
21698 | Object.defineProperty(exports, "__esModule", { | |
21699 | value: true | |
21700 | }); | |
21701 | ||
21702 | var isNumber = _interopRequire(require("lodash/isNumber")); | |
21703 | ||
21704 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21705 | ||
21706 | var Double = { | |
21707 | ||
21708 | read: function read(io) { | |
21709 | return io.readDoubleBE(); | |
21710 | }, | |
21711 | ||
21712 | write: function write(value, io) { | |
21713 | if (!isNumber(value)) { | |
21714 | throw new Error("XDR Write Error: not a number"); | |
21715 | } | |
21716 | ||
21717 | io.writeDoubleBE(value); | |
21718 | }, | |
21719 | ||
21720 | isValid: function isValid(value) { | |
21721 | return isNumber(value); | |
21722 | } }; | |
21723 | ||
21724 | exports.Double = Double; | |
21725 | includeIoMixin(Double); | |
21726 | },{"./io-mixin":133,"lodash/isNumber":332}],128:[function(require,module,exports){ | |
21727 | "use strict"; | |
21728 | ||
21729 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21730 | ||
21731 | 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); } }; | |
21732 | ||
21733 | 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; }; | |
21734 | ||
21735 | 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; }; })(); | |
21736 | ||
21737 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
21738 | ||
21739 | Object.defineProperty(exports, "__esModule", { | |
21740 | value: true | |
21741 | }); | |
21742 | ||
21743 | var Int = require("./int").Int; | |
21744 | ||
21745 | var each = _interopRequire(require("lodash/each")); | |
21746 | ||
21747 | var vals = _interopRequire(require("lodash/values")); | |
21748 | ||
21749 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21750 | ||
21751 | var Enum = exports.Enum = (function () { | |
21752 | function Enum(name, value) { | |
21753 | _classCallCheck(this, Enum); | |
21754 | ||
21755 | this.name = name; | |
21756 | this.value = value; | |
21757 | } | |
21758 | ||
21759 | _createClass(Enum, null, { | |
21760 | read: { | |
21761 | value: function read(io) { | |
21762 | var intVal = Int.read(io); | |
21763 | ||
21764 | if (!this._byValue.has(intVal)) { | |
21765 | throw new Error("XDR Read Error: Unknown " + this.enumName + " member for value " + intVal); | |
21766 | } | |
21767 | ||
21768 | return this._byValue.get(intVal); | |
21769 | } | |
21770 | }, | |
21771 | write: { | |
21772 | value: function write(value, io) { | |
21773 | if (!(value instanceof this)) { | |
21774 | throw new Error("XDR Write Error: Unknown " + value + " is not a " + this.enumName); | |
21775 | } | |
21776 | ||
21777 | Int.write(value.value, io); | |
21778 | } | |
21779 | }, | |
21780 | isValid: { | |
21781 | value: function isValid(value) { | |
21782 | return value instanceof this; | |
21783 | } | |
21784 | }, | |
21785 | members: { | |
21786 | value: function members() { | |
21787 | return this._members; | |
21788 | } | |
21789 | }, | |
21790 | values: { | |
21791 | value: function values() { | |
21792 | return vals(this._members); | |
21793 | } | |
21794 | }, | |
21795 | fromName: { | |
21796 | value: function fromName(name) { | |
21797 | var result = this._members[name]; | |
21798 | ||
21799 | if (!result) { | |
21800 | throw new Error("" + name + " is not a member of " + this.enumName); | |
21801 | } | |
21802 | ||
21803 | return result; | |
21804 | } | |
21805 | }, | |
21806 | fromValue: { | |
21807 | value: function fromValue(value) { | |
21808 | var result = this._byValue.get(value); | |
21809 | ||
21810 | if (!result) { | |
21811 | throw new Error("" + value + " is not a value of any member of " + this.enumName); | |
21812 | } | |
21813 | ||
21814 | return result; | |
21815 | } | |
21816 | }, | |
21817 | create: { | |
21818 | value: function create(context, name, members) { | |
21819 | var ChildEnum = (function (_Enum) { | |
21820 | var _class = function ChildEnum() { | |
21821 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
21822 | args[_key] = arguments[_key]; | |
21823 | } | |
21824 | ||
21825 | _classCallCheck(this, _class); | |
21826 | ||
21827 | _get(Object.getPrototypeOf(_class.prototype), "constructor", this).apply(this, args); | |
21828 | }; | |
21829 | ||
21830 | _inherits(_class, _Enum); | |
21831 | ||
21832 | return _class; | |
21833 | })(Enum); | |
21834 | ||
21835 | ChildEnum.enumName = name; | |
21836 | context.results[name] = ChildEnum; | |
21837 | ||
21838 | ChildEnum._members = {}; | |
21839 | ChildEnum._byValue = new Map(); | |
21840 | ||
21841 | each(members, function (value, key) { | |
21842 | var inst = new ChildEnum(key, value); | |
21843 | ChildEnum._members[key] = inst; | |
21844 | ChildEnum._byValue.set(value, inst); | |
21845 | ChildEnum[key] = function () { | |
21846 | return inst; | |
21847 | }; | |
21848 | }); | |
21849 | ||
21850 | return ChildEnum; | |
21851 | } | |
21852 | } | |
21853 | }); | |
21854 | ||
21855 | return Enum; | |
21856 | })(); | |
21857 | ||
21858 | includeIoMixin(Enum); | |
21859 | },{"./int":132,"./io-mixin":133,"lodash/each":312,"lodash/values":356}],129:[function(require,module,exports){ | |
21860 | "use strict"; | |
21861 | ||
21862 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21863 | ||
21864 | Object.defineProperty(exports, "__esModule", { | |
21865 | value: true | |
21866 | }); | |
21867 | ||
21868 | var isNumber = _interopRequire(require("lodash/isNumber")); | |
21869 | ||
21870 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21871 | ||
21872 | var Float = { | |
21873 | ||
21874 | read: function read(io) { | |
21875 | return io.readFloatBE(); | |
21876 | }, | |
21877 | ||
21878 | write: function write(value, io) { | |
21879 | if (!isNumber(value)) { | |
21880 | throw new Error("XDR Write Error: not a number"); | |
21881 | } | |
21882 | ||
21883 | io.writeFloatBE(value); | |
21884 | }, | |
21885 | ||
21886 | isValid: function isValid(value) { | |
21887 | return isNumber(value); | |
21888 | } }; | |
21889 | ||
21890 | exports.Float = Float; | |
21891 | includeIoMixin(Float); | |
21892 | },{"./io-mixin":133,"lodash/isNumber":332}],130:[function(require,module,exports){ | |
21893 | "use strict"; | |
21894 | ||
21895 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21896 | ||
21897 | 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; }; })(); | |
21898 | ||
21899 | 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); } }; | |
21900 | ||
21901 | 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; }; | |
21902 | ||
21903 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
21904 | ||
21905 | Object.defineProperty(exports, "__esModule", { | |
21906 | value: true | |
21907 | }); | |
21908 | ||
21909 | var Long = _interopRequire(require("long")); | |
21910 | ||
21911 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21912 | ||
21913 | var Hyper = exports.Hyper = (function (_Long) { | |
21914 | function Hyper(low, high) { | |
21915 | _classCallCheck(this, Hyper); | |
21916 | ||
21917 | _get(Object.getPrototypeOf(Hyper.prototype), "constructor", this).call(this, low, high, false); | |
21918 | } | |
21919 | ||
21920 | _inherits(Hyper, _Long); | |
21921 | ||
21922 | _createClass(Hyper, null, { | |
21923 | read: { | |
21924 | value: function read(io) { | |
21925 | var high = io.readInt32BE(); | |
21926 | var low = io.readInt32BE(); | |
21927 | return this.fromBits(low, high); | |
21928 | } | |
21929 | }, | |
21930 | write: { | |
21931 | value: function write(value, io) { | |
21932 | if (!(value instanceof this)) { | |
21933 | throw new Error("XDR Write Error: " + value + " is not a Hyper"); | |
21934 | } | |
21935 | ||
21936 | io.writeInt32BE(value.high); | |
21937 | io.writeInt32BE(value.low); | |
21938 | } | |
21939 | }, | |
21940 | fromString: { | |
21941 | value: function fromString(string) { | |
21942 | if (!/^-?\d+$/.test(string)) { | |
21943 | throw new Error("Invalid hyper string: " + string); | |
21944 | } | |
21945 | var result = _get(Object.getPrototypeOf(Hyper), "fromString", this).call(this, string, false); | |
21946 | return new this(result.low, result.high); | |
21947 | } | |
21948 | }, | |
21949 | fromBits: { | |
21950 | value: function fromBits(low, high) { | |
21951 | var result = _get(Object.getPrototypeOf(Hyper), "fromBits", this).call(this, low, high, false); | |
21952 | return new this(result.low, result.high); | |
21953 | } | |
21954 | }, | |
21955 | isValid: { | |
21956 | value: function isValid(value) { | |
21957 | return value instanceof this; | |
21958 | } | |
21959 | } | |
21960 | }); | |
21961 | ||
21962 | return Hyper; | |
21963 | })(Long); | |
21964 | ||
21965 | includeIoMixin(Hyper); | |
21966 | ||
21967 | Hyper.MAX_VALUE = new Hyper(Long.MAX_VALUE.low, Long.MAX_VALUE.high); | |
21968 | Hyper.MIN_VALUE = new Hyper(Long.MIN_VALUE.low, Long.MIN_VALUE.high); | |
21969 | },{"./io-mixin":133,"long":357}],131:[function(require,module,exports){ | |
21970 | "use strict"; | |
21971 | ||
21972 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | |
21973 | ||
21974 | 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; }; | |
21975 | ||
21976 | Object.defineProperty(exports, "__esModule", { | |
21977 | value: true | |
21978 | }); | |
21979 | ||
21980 | _defaults(exports, _interopRequireWildcard(require("./types"))); | |
21981 | ||
21982 | var _config = require("./config"); | |
21983 | ||
21984 | _defaults(exports, _interopRequireWildcard(_config)); | |
21985 | ||
21986 | var config = _config.config; | |
21987 | },{"./config":125,"./types":139}],132:[function(require,module,exports){ | |
21988 | "use strict"; | |
21989 | ||
21990 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
21991 | ||
21992 | Object.defineProperty(exports, "__esModule", { | |
21993 | value: true | |
21994 | }); | |
21995 | ||
21996 | var isNumber = _interopRequire(require("lodash/isNumber")); | |
21997 | ||
21998 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
21999 | ||
22000 | var Int = { | |
22001 | ||
22002 | read: function read(io) { | |
22003 | return io.readInt32BE(); | |
22004 | }, | |
22005 | ||
22006 | write: function write(value, io) { | |
22007 | if (!isNumber(value)) { | |
22008 | throw new Error("XDR Write Error: not a number"); | |
22009 | } | |
22010 | ||
22011 | if (Math.floor(value) !== value) { | |
22012 | throw new Error("XDR Write Error: not an integer"); | |
22013 | } | |
22014 | ||
22015 | io.writeInt32BE(value); | |
22016 | }, | |
22017 | ||
22018 | isValid: function isValid(value) { | |
22019 | if (!isNumber(value)) { | |
22020 | return false; | |
22021 | } | |
22022 | if (Math.floor(value) !== value) { | |
22023 | return false; | |
22024 | } | |
22025 | ||
22026 | return value >= Int.MIN_VALUE && value <= Int.MAX_VALUE; | |
22027 | } }; | |
22028 | ||
22029 | exports.Int = Int; | |
22030 | Int.MAX_VALUE = Math.pow(2, 31) - 1; | |
22031 | Int.MIN_VALUE = -Math.pow(2, 31); | |
22032 | ||
22033 | includeIoMixin(Int); | |
22034 | },{"./io-mixin":133,"lodash/isNumber":332}],133:[function(require,module,exports){ | |
22035 | (function (Buffer){ | |
22036 | "use strict"; | |
22037 | ||
22038 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22039 | ||
22040 | module.exports = includeIoMixin; | |
22041 | ||
22042 | var Cursor = require("./cursor").Cursor; | |
22043 | ||
22044 | var extend = _interopRequire(require("lodash/extend")); | |
22045 | ||
22046 | var isFunction = _interopRequire(require("lodash/isFunction")); | |
22047 | ||
22048 | //TODO: build a system to grow a buffer as we write to it | |
22049 | var BUFFER_SIZE = Math.pow(2, 16); | |
22050 | ||
22051 | var staticMethods = { | |
22052 | toXDR: function toXDR(val) { | |
22053 | var cursor = new Cursor(BUFFER_SIZE); | |
22054 | this.write(val, cursor); | |
22055 | var bytesWritten = cursor.tell(); | |
22056 | cursor.rewind(); | |
22057 | ||
22058 | return cursor.slice(bytesWritten).buffer(); | |
22059 | }, | |
22060 | ||
22061 | fromXDR: function fromXDR(input) { | |
22062 | var format = arguments[1] === undefined ? "raw" : arguments[1]; | |
22063 | ||
22064 | var buffer = undefined; | |
22065 | switch (format) { | |
22066 | case "raw": | |
22067 | buffer = input;break; | |
22068 | case "hex": | |
22069 | buffer = Buffer.from(input, "hex");break; | |
22070 | case "base64": | |
22071 | buffer = Buffer.from(input, "base64");break; | |
22072 | default: | |
22073 | throw new Error("Invalid format " + format + ", must be \"raw\", \"hex\", \"base64\""); | |
22074 | } | |
22075 | ||
22076 | var cursor = new Cursor(buffer); | |
22077 | var result = this.read(cursor); | |
22078 | ||
22079 | //TODO: error out if the entire buffer isn't consumed | |
22080 | ||
22081 | return result; | |
22082 | } }; | |
22083 | ||
22084 | var instanceMethods = { | |
22085 | toXDR: function toXDR() { | |
22086 | var format = arguments[0] === undefined ? "raw" : arguments[0]; | |
22087 | ||
22088 | var buffer = this.constructor.toXDR(this); | |
22089 | switch (format) { | |
22090 | case "raw": | |
22091 | return buffer; | |
22092 | case "hex": | |
22093 | return buffer.toString("hex"); | |
22094 | case "base64": | |
22095 | return buffer.toString("base64"); | |
22096 | default: | |
22097 | throw new Error("Invalid format " + format + ", must be \"raw\", \"hex\", \"base64\""); | |
22098 | } | |
22099 | } | |
22100 | }; | |
22101 | ||
22102 | function includeIoMixin(obj) { | |
22103 | extend(obj, staticMethods); | |
22104 | ||
22105 | if (isFunction(obj)) { | |
22106 | extend(obj.prototype, instanceMethods); | |
22107 | } | |
22108 | } | |
22109 | }).call(this,require("buffer").Buffer) | |
22110 | },{"./cursor":126,"buffer":50,"lodash/extend":315,"lodash/isFunction":328}],134:[function(require,module,exports){ | |
22111 | (function (Buffer){ | |
22112 | "use strict"; | |
22113 | ||
22114 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22115 | ||
22116 | 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; }; })(); | |
22117 | ||
22118 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22119 | ||
22120 | Object.defineProperty(exports, "__esModule", { | |
22121 | value: true | |
22122 | }); | |
22123 | ||
22124 | var _util = require("./util"); | |
22125 | ||
22126 | var calculatePadding = _util.calculatePadding; | |
22127 | var slicePadding = _util.slicePadding; | |
22128 | ||
22129 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22130 | ||
22131 | var Opaque = exports.Opaque = (function () { | |
22132 | function Opaque(length) { | |
22133 | _classCallCheck(this, Opaque); | |
22134 | ||
22135 | this._length = length; | |
22136 | this._padding = calculatePadding(length); | |
22137 | } | |
22138 | ||
22139 | _createClass(Opaque, { | |
22140 | read: { | |
22141 | value: function read(io) { | |
22142 | var result = io.slice(this._length); | |
22143 | slicePadding(io, this._padding); | |
22144 | return result.buffer(); | |
22145 | } | |
22146 | }, | |
22147 | write: { | |
22148 | value: function write(value, io) { | |
22149 | if (value.length !== this._length) { | |
22150 | throw new Error("XDR Write Error: Got " + value.length + " bytes, expected " + this._length); | |
22151 | } | |
22152 | ||
22153 | io.writeBufferPadded(value); | |
22154 | } | |
22155 | }, | |
22156 | isValid: { | |
22157 | value: function isValid(value) { | |
22158 | return Buffer.isBuffer(value) && value.length === this._length; | |
22159 | } | |
22160 | } | |
22161 | }); | |
22162 | ||
22163 | return Opaque; | |
22164 | })(); | |
22165 | ||
22166 | includeIoMixin(Opaque.prototype); | |
22167 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | |
22168 | },{"../../is-buffer/index.js":120,"./io-mixin":133,"./util":143}],135:[function(require,module,exports){ | |
22169 | "use strict"; | |
22170 | ||
22171 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22172 | ||
22173 | 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; }; })(); | |
22174 | ||
22175 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22176 | ||
22177 | Object.defineProperty(exports, "__esModule", { | |
22178 | value: true | |
22179 | }); | |
22180 | ||
22181 | var Bool = require("./bool").Bool; | |
22182 | ||
22183 | var isNull = _interopRequire(require("lodash/isNull")); | |
22184 | ||
22185 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
22186 | ||
22187 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22188 | ||
22189 | var Option = exports.Option = (function () { | |
22190 | function Option(childType) { | |
22191 | _classCallCheck(this, Option); | |
22192 | ||
22193 | this._childType = childType; | |
22194 | } | |
22195 | ||
22196 | _createClass(Option, { | |
22197 | read: { | |
22198 | value: function read(io) { | |
22199 | if (Bool.read(io)) { | |
22200 | return this._childType.read(io); | |
22201 | } | |
22202 | } | |
22203 | }, | |
22204 | write: { | |
22205 | value: function write(value, io) { | |
22206 | var isPresent = !(isNull(value) || isUndefined(value)); | |
22207 | ||
22208 | Bool.write(isPresent, io); | |
22209 | ||
22210 | if (isPresent) { | |
22211 | this._childType.write(value, io); | |
22212 | } | |
22213 | } | |
22214 | }, | |
22215 | isValid: { | |
22216 | value: function isValid(value) { | |
22217 | if (isNull(value)) { | |
22218 | return true; | |
22219 | } | |
22220 | if (isUndefined(value)) { | |
22221 | return true; | |
22222 | } | |
22223 | ||
22224 | return this._childType.isValid(value); | |
22225 | } | |
22226 | } | |
22227 | }); | |
22228 | ||
22229 | return Option; | |
22230 | })(); | |
22231 | ||
22232 | includeIoMixin(Option.prototype); | |
22233 | },{"./bool":124,"./io-mixin":133,"lodash/isNull":331,"lodash/isUndefined":340}],136:[function(require,module,exports){ | |
22234 | "use strict"; | |
22235 | ||
22236 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22237 | ||
22238 | Object.defineProperty(exports, "__esModule", { | |
22239 | value: true | |
22240 | }); | |
22241 | ||
22242 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22243 | ||
22244 | var Quadruple = { | |
22245 | /* jshint unused: false */ | |
22246 | ||
22247 | read: function read(io) { | |
22248 | throw new Error("XDR Read Error: quadruple not supported"); | |
22249 | }, | |
22250 | ||
22251 | write: function write(value, io) { | |
22252 | throw new Error("XDR Write Error: quadruple not supported"); | |
22253 | }, | |
22254 | ||
22255 | isValid: function isValid(value) { | |
22256 | return false; | |
22257 | } }; | |
22258 | ||
22259 | exports.Quadruple = Quadruple; | |
22260 | includeIoMixin(Quadruple); | |
22261 | },{"./io-mixin":133}],137:[function(require,module,exports){ | |
22262 | (function (Buffer){ | |
22263 | "use strict"; | |
22264 | ||
22265 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22266 | ||
22267 | 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; }; })(); | |
22268 | ||
22269 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22270 | ||
22271 | Object.defineProperty(exports, "__esModule", { | |
22272 | value: true | |
22273 | }); | |
22274 | ||
22275 | var Int = require("./int").Int; | |
22276 | ||
22277 | var UnsignedInt = require("./unsigned-int").UnsignedInt; | |
22278 | ||
22279 | var _util = require("./util"); | |
22280 | ||
22281 | var calculatePadding = _util.calculatePadding; | |
22282 | var slicePadding = _util.slicePadding; | |
22283 | ||
22284 | var isString = _interopRequire(require("lodash/isString")); | |
22285 | ||
22286 | var isArray = _interopRequire(require("lodash/isArray")); | |
22287 | ||
22288 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22289 | ||
22290 | var String = exports.String = (function () { | |
22291 | function String() { | |
22292 | var maxLength = arguments[0] === undefined ? UnsignedInt.MAX_VALUE : arguments[0]; | |
22293 | ||
22294 | _classCallCheck(this, String); | |
22295 | ||
22296 | this._maxLength = maxLength; | |
22297 | } | |
22298 | ||
22299 | _createClass(String, { | |
22300 | read: { | |
22301 | value: function read(io) { | |
22302 | var length = Int.read(io); | |
22303 | ||
22304 | if (length > this._maxLength) { | |
22305 | throw new Error("XDR Read Error: Saw " + length + " length String," + ("max allowed is " + this._maxLength)); | |
22306 | } | |
22307 | var padding = calculatePadding(length); | |
22308 | var result = io.slice(length); | |
22309 | slicePadding(io, padding); | |
22310 | return result.buffer(); | |
22311 | } | |
22312 | }, | |
22313 | readString: { | |
22314 | value: function readString(io) { | |
22315 | return this.read(io).toString("utf8"); | |
22316 | } | |
22317 | }, | |
22318 | write: { | |
22319 | value: function write(value, io) { | |
22320 | if (value.length > this._maxLength) { | |
22321 | throw new Error("XDR Write Error: Got " + value.length + " bytes," + ("max allows is " + this._maxLength)); | |
22322 | } | |
22323 | ||
22324 | var buffer = undefined; | |
22325 | if (isString(value)) { | |
22326 | buffer = Buffer.from(value, "utf8"); | |
22327 | } else { | |
22328 | buffer = Buffer.from(value); | |
22329 | } | |
22330 | ||
22331 | Int.write(buffer.length, io); | |
22332 | io.writeBufferPadded(buffer); | |
22333 | } | |
22334 | }, | |
22335 | isValid: { | |
22336 | value: function isValid(value) { | |
22337 | var buffer = undefined; | |
22338 | if (isString(value)) { | |
22339 | buffer = Buffer.from(value, "utf8"); | |
22340 | } else if (isArray(value) || Buffer.isBuffer(value)) { | |
22341 | buffer = Buffer.from(value); | |
22342 | } else { | |
22343 | return false; | |
22344 | } | |
22345 | return buffer.length <= this._maxLength; | |
22346 | } | |
22347 | } | |
22348 | }); | |
22349 | ||
22350 | return String; | |
22351 | })(); | |
22352 | ||
22353 | includeIoMixin(String.prototype); | |
22354 | }).call(this,require("buffer").Buffer) | |
22355 | },{"./int":132,"./io-mixin":133,"./unsigned-int":142,"./util":143,"buffer":50,"lodash/isArray":323,"lodash/isString":337}],138:[function(require,module,exports){ | |
22356 | "use strict"; | |
22357 | ||
22358 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22359 | ||
22360 | 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"); } }; | |
22361 | ||
22362 | 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); } }; | |
22363 | ||
22364 | 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; }; | |
22365 | ||
22366 | 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; }; })(); | |
22367 | ||
22368 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22369 | ||
22370 | Object.defineProperty(exports, "__esModule", { | |
22371 | value: true | |
22372 | }); | |
22373 | ||
22374 | var each = _interopRequire(require("lodash/each")); | |
22375 | ||
22376 | var map = _interopRequire(require("lodash/map")); | |
22377 | ||
22378 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
22379 | ||
22380 | var fromPairs = _interopRequire(require("lodash/fromPairs")); | |
22381 | ||
22382 | var Reference = require("./config").Reference; | |
22383 | ||
22384 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22385 | ||
22386 | var Struct = exports.Struct = (function () { | |
22387 | function Struct(attributes) { | |
22388 | _classCallCheck(this, Struct); | |
22389 | ||
22390 | this._attributes = attributes || {}; | |
22391 | } | |
22392 | ||
22393 | _createClass(Struct, null, { | |
22394 | read: { | |
22395 | value: function read(io) { | |
22396 | var fields = map(this._fields, function (field) { | |
22397 | var _field = _slicedToArray(field, 2); | |
22398 | ||
22399 | var name = _field[0]; | |
22400 | var type = _field[1]; | |
22401 | ||
22402 | var value = type.read(io); | |
22403 | return [name, value]; | |
22404 | }); | |
22405 | ||
22406 | return new this(fromPairs(fields)); | |
22407 | } | |
22408 | }, | |
22409 | write: { | |
22410 | value: function write(value, io) { | |
22411 | if (!(value instanceof this)) { | |
22412 | throw new Error("XDR Write Error: " + value + " is not a " + this.structName); | |
22413 | } | |
22414 | each(this._fields, function (field) { | |
22415 | var _field = _slicedToArray(field, 2); | |
22416 | ||
22417 | var name = _field[0]; | |
22418 | var type = _field[1]; | |
22419 | ||
22420 | var attribute = value._attributes[name]; | |
22421 | type.write(attribute, io); | |
22422 | }); | |
22423 | } | |
22424 | }, | |
22425 | isValid: { | |
22426 | value: function isValid(value) { | |
22427 | return value instanceof this; | |
22428 | } | |
22429 | }, | |
22430 | create: { | |
22431 | value: function create(context, name, fields) { | |
22432 | var ChildStruct = (function (_Struct) { | |
22433 | var _class = function ChildStruct() { | |
22434 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
22435 | args[_key] = arguments[_key]; | |
22436 | } | |
22437 | ||
22438 | _classCallCheck(this, _class); | |
22439 | ||
22440 | _get(Object.getPrototypeOf(_class.prototype), "constructor", this).apply(this, args); | |
22441 | }; | |
22442 | ||
22443 | _inherits(_class, _Struct); | |
22444 | ||
22445 | return _class; | |
22446 | })(Struct); | |
22447 | ||
22448 | ChildStruct.structName = name; | |
22449 | ||
22450 | context.results[name] = ChildStruct; | |
22451 | ||
22452 | ChildStruct._fields = fields.map(function (_ref) { | |
22453 | var _ref2 = _slicedToArray(_ref, 2); | |
22454 | ||
22455 | var name = _ref2[0]; | |
22456 | var field = _ref2[1]; | |
22457 | ||
22458 | if (field instanceof Reference) { | |
22459 | field = field.resolve(context); | |
22460 | } | |
22461 | ||
22462 | return [name, field]; | |
22463 | }); | |
22464 | ||
22465 | each(ChildStruct._fields, function (field) { | |
22466 | var _field = _slicedToArray(field, 1); | |
22467 | ||
22468 | var fieldName = _field[0]; | |
22469 | ||
22470 | ChildStruct.prototype[fieldName] = readOrWriteAttribute(fieldName); | |
22471 | }); | |
22472 | ||
22473 | return ChildStruct; | |
22474 | } | |
22475 | } | |
22476 | }); | |
22477 | ||
22478 | return Struct; | |
22479 | })(); | |
22480 | ||
22481 | includeIoMixin(Struct); | |
22482 | ||
22483 | function readOrWriteAttribute(name) { | |
22484 | return function (value) { | |
22485 | if (!isUndefined(value)) { | |
22486 | this._attributes[name] = value; | |
22487 | } | |
22488 | ||
22489 | return this._attributes[name]; | |
22490 | }; | |
22491 | } | |
22492 | },{"./config":125,"./io-mixin":133,"lodash/each":312,"lodash/fromPairs":318,"lodash/isUndefined":340,"lodash/map":343}],139:[function(require,module,exports){ | |
22493 | "use strict"; | |
22494 | ||
22495 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | |
22496 | ||
22497 | 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; }; | |
22498 | ||
22499 | Object.defineProperty(exports, "__esModule", { | |
22500 | value: true | |
22501 | }); | |
22502 | ||
22503 | _defaults(exports, _interopRequireWildcard(require("./int"))); | |
22504 | ||
22505 | _defaults(exports, _interopRequireWildcard(require("./hyper"))); | |
22506 | ||
22507 | _defaults(exports, _interopRequireWildcard(require("./unsigned-int"))); | |
22508 | ||
22509 | _defaults(exports, _interopRequireWildcard(require("./unsigned-hyper"))); | |
22510 | ||
22511 | _defaults(exports, _interopRequireWildcard(require("./float"))); | |
22512 | ||
22513 | _defaults(exports, _interopRequireWildcard(require("./double"))); | |
22514 | ||
22515 | _defaults(exports, _interopRequireWildcard(require("./quadruple"))); | |
22516 | ||
22517 | _defaults(exports, _interopRequireWildcard(require("./bool"))); | |
22518 | ||
22519 | _defaults(exports, _interopRequireWildcard(require("./string"))); | |
22520 | ||
22521 | _defaults(exports, _interopRequireWildcard(require("./opaque"))); | |
22522 | ||
22523 | _defaults(exports, _interopRequireWildcard(require("./var-opaque"))); | |
22524 | ||
22525 | _defaults(exports, _interopRequireWildcard(require("./array"))); | |
22526 | ||
22527 | _defaults(exports, _interopRequireWildcard(require("./var-array"))); | |
22528 | ||
22529 | _defaults(exports, _interopRequireWildcard(require("./option"))); | |
22530 | ||
22531 | _defaults(exports, _interopRequireWildcard(require("./void"))); | |
22532 | ||
22533 | _defaults(exports, _interopRequireWildcard(require("./enum"))); | |
22534 | ||
22535 | _defaults(exports, _interopRequireWildcard(require("./struct"))); | |
22536 | ||
22537 | _defaults(exports, _interopRequireWildcard(require("./union"))); | |
22538 | },{"./array":123,"./bool":124,"./double":127,"./enum":128,"./float":129,"./hyper":130,"./int":132,"./opaque":134,"./option":135,"./quadruple":136,"./string":137,"./struct":138,"./union":140,"./unsigned-hyper":141,"./unsigned-int":142,"./var-array":144,"./var-opaque":145,"./void":146}],140:[function(require,module,exports){ | |
22539 | "use strict"; | |
22540 | ||
22541 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22542 | ||
22543 | 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"); } }; | |
22544 | ||
22545 | 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); } }; | |
22546 | ||
22547 | 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; }; | |
22548 | ||
22549 | 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; }; })(); | |
22550 | ||
22551 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22552 | ||
22553 | Object.defineProperty(exports, "__esModule", { | |
22554 | value: true | |
22555 | }); | |
22556 | ||
22557 | var each = _interopRequire(require("lodash/each")); | |
22558 | ||
22559 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
22560 | ||
22561 | var isString = _interopRequire(require("lodash/isString")); | |
22562 | ||
22563 | var Void = require("./void").Void; | |
22564 | ||
22565 | var Reference = require("./config").Reference; | |
22566 | ||
22567 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22568 | ||
22569 | var Union = exports.Union = (function () { | |
22570 | function Union(aSwitch, value) { | |
22571 | _classCallCheck(this, Union); | |
22572 | ||
22573 | this.set(aSwitch, value); | |
22574 | } | |
22575 | ||
22576 | _createClass(Union, { | |
22577 | set: { | |
22578 | value: function set(aSwitch, value) { | |
22579 | if (isString(aSwitch)) { | |
22580 | aSwitch = this.constructor._switchOn.fromName(aSwitch); | |
22581 | } | |
22582 | ||
22583 | this._switch = aSwitch; | |
22584 | this._arm = this.constructor.armForSwitch(this._switch); | |
22585 | this._armType = this.constructor.armTypeForArm(this._arm); | |
22586 | this._value = value; | |
22587 | } | |
22588 | }, | |
22589 | get: { | |
22590 | value: function get() { | |
22591 | var armName = arguments[0] === undefined ? this._arm : arguments[0]; | |
22592 | ||
22593 | if (this._arm !== Void && this._arm !== armName) { | |
22594 | throw new Error("" + armName + " not set"); | |
22595 | } | |
22596 | return this._value; | |
22597 | } | |
22598 | }, | |
22599 | "switch": { | |
22600 | value: function _switch() { | |
22601 | return this._switch; | |
22602 | } | |
22603 | }, | |
22604 | arm: { | |
22605 | value: function arm() { | |
22606 | return this._arm; | |
22607 | } | |
22608 | }, | |
22609 | armType: { | |
22610 | value: function armType() { | |
22611 | return this._armType; | |
22612 | } | |
22613 | }, | |
22614 | value: { | |
22615 | value: function value() { | |
22616 | return this._value; | |
22617 | } | |
22618 | } | |
22619 | }, { | |
22620 | armForSwitch: { | |
22621 | value: function armForSwitch(aSwitch) { | |
22622 | if (this._switches.has(aSwitch)) { | |
22623 | return this._switches.get(aSwitch); | |
22624 | } else if (this._defaultArm) { | |
22625 | return this._defaultArm; | |
22626 | } else { | |
22627 | throw new Error("Bad union switch: " + aSwitch); | |
22628 | } | |
22629 | } | |
22630 | }, | |
22631 | armTypeForArm: { | |
22632 | value: function armTypeForArm(arm) { | |
22633 | if (arm === Void) { | |
22634 | return Void; | |
22635 | } else { | |
22636 | return this._arms[arm]; | |
22637 | } | |
22638 | } | |
22639 | }, | |
22640 | read: { | |
22641 | value: function read(io) { | |
22642 | var aSwitch = this._switchOn.read(io); | |
22643 | var arm = this.armForSwitch(aSwitch); | |
22644 | var armType = this.armTypeForArm(arm); | |
22645 | var value = armType.read(io); | |
22646 | return new this(aSwitch, value); | |
22647 | } | |
22648 | }, | |
22649 | write: { | |
22650 | value: function write(value, io) { | |
22651 | if (!(value instanceof this)) { | |
22652 | throw new Error("XDR Write Error: " + value + " is not a " + this.unionName); | |
22653 | } | |
22654 | ||
22655 | this._switchOn.write(value["switch"](), io); | |
22656 | value.armType().write(value.value(), io); | |
22657 | } | |
22658 | }, | |
22659 | isValid: { | |
22660 | value: function isValid(value) { | |
22661 | return value instanceof this; | |
22662 | } | |
22663 | }, | |
22664 | create: { | |
22665 | value: function create(context, name, config) { | |
22666 | var ChildUnion = (function (_Union) { | |
22667 | var _class = function ChildUnion() { | |
22668 | for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
22669 | args[_key] = arguments[_key]; | |
22670 | } | |
22671 | ||
22672 | _classCallCheck(this, _class); | |
22673 | ||
22674 | _get(Object.getPrototypeOf(_class.prototype), "constructor", this).apply(this, args); | |
22675 | }; | |
22676 | ||
22677 | _inherits(_class, _Union); | |
22678 | ||
22679 | return _class; | |
22680 | })(Union); | |
22681 | ||
22682 | ChildUnion.unionName = name; | |
22683 | context.results[name] = ChildUnion; | |
22684 | ||
22685 | if (config.switchOn instanceof Reference) { | |
22686 | ChildUnion._switchOn = config.switchOn.resolve(context); | |
22687 | } else { | |
22688 | ChildUnion._switchOn = config.switchOn; | |
22689 | } | |
22690 | ||
22691 | ChildUnion._switches = new Map(); | |
22692 | ChildUnion._arms = {}; | |
22693 | ||
22694 | each(config.arms, function (value, name) { | |
22695 | if (value instanceof Reference) { | |
22696 | value = value.resolve(context); | |
22697 | } | |
22698 | ||
22699 | ChildUnion._arms[name] = value; | |
22700 | }); | |
22701 | ||
22702 | // resolve default arm | |
22703 | var defaultArm = config.defaultArm; | |
22704 | if (defaultArm instanceof Reference) { | |
22705 | defaultArm = defaultArm.resolve(context); | |
22706 | } | |
22707 | ||
22708 | ChildUnion._defaultArm = defaultArm; | |
22709 | ||
22710 | each(config.switches, function (_ref) { | |
22711 | var _ref2 = _slicedToArray(_ref, 2); | |
22712 | ||
22713 | var aSwitch = _ref2[0]; | |
22714 | var armName = _ref2[1]; | |
22715 | ||
22716 | if (isString(aSwitch)) { | |
22717 | aSwitch = ChildUnion._switchOn.fromName(aSwitch); | |
22718 | } | |
22719 | ||
22720 | ChildUnion._switches.set(aSwitch, armName); | |
22721 | }); | |
22722 | ||
22723 | // add enum-based helpers | |
22724 | // NOTE: we don't have good notation for "is a subclass of XDR.Enum", | |
22725 | // and so we use the following check (does _switchOn have a `values` | |
22726 | // attribute) to approximate the intent. | |
22727 | if (!isUndefined(ChildUnion._switchOn.values)) { | |
22728 | each(ChildUnion._switchOn.values(), function (aSwitch) { | |
22729 | // Add enum-based constrocutors | |
22730 | ChildUnion[aSwitch.name] = function (value) { | |
22731 | return new ChildUnion(aSwitch, value); | |
22732 | }; | |
22733 | ||
22734 | // Add enum-based "set" helpers | |
22735 | ChildUnion.prototype[aSwitch.name] = function (value) { | |
22736 | return this.set(aSwitch, value); | |
22737 | }; | |
22738 | }); | |
22739 | } | |
22740 | ||
22741 | // Add arm accessor helpers | |
22742 | each(ChildUnion._arms, function (type, name) { | |
22743 | if (type === Void) { | |
22744 | return; | |
22745 | } | |
22746 | ||
22747 | ChildUnion.prototype[name] = function () { | |
22748 | return this.get(name); | |
22749 | }; | |
22750 | }); | |
22751 | ||
22752 | return ChildUnion; | |
22753 | } | |
22754 | } | |
22755 | }); | |
22756 | ||
22757 | return Union; | |
22758 | })(); | |
22759 | ||
22760 | includeIoMixin(Union); | |
22761 | },{"./config":125,"./io-mixin":133,"./void":146,"lodash/each":312,"lodash/isString":337,"lodash/isUndefined":340}],141:[function(require,module,exports){ | |
22762 | "use strict"; | |
22763 | ||
22764 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22765 | ||
22766 | 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; }; })(); | |
22767 | ||
22768 | 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); } }; | |
22769 | ||
22770 | 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; }; | |
22771 | ||
22772 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22773 | ||
22774 | Object.defineProperty(exports, "__esModule", { | |
22775 | value: true | |
22776 | }); | |
22777 | ||
22778 | var Long = _interopRequire(require("long")); | |
22779 | ||
22780 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22781 | ||
22782 | var UnsignedHyper = exports.UnsignedHyper = (function (_Long) { | |
22783 | function UnsignedHyper(low, high) { | |
22784 | _classCallCheck(this, UnsignedHyper); | |
22785 | ||
22786 | _get(Object.getPrototypeOf(UnsignedHyper.prototype), "constructor", this).call(this, low, high, true); | |
22787 | } | |
22788 | ||
22789 | _inherits(UnsignedHyper, _Long); | |
22790 | ||
22791 | _createClass(UnsignedHyper, null, { | |
22792 | read: { | |
22793 | value: function read(io) { | |
22794 | var high = io.readInt32BE(); | |
22795 | var low = io.readInt32BE(); | |
22796 | return this.fromBits(low, high); | |
22797 | } | |
22798 | }, | |
22799 | write: { | |
22800 | value: function write(value, io) { | |
22801 | if (!(value instanceof this)) { | |
22802 | throw new Error("XDR Write Error: " + value + " is not an UnsignedHyper"); | |
22803 | } | |
22804 | ||
22805 | io.writeInt32BE(value.high); | |
22806 | io.writeInt32BE(value.low); | |
22807 | } | |
22808 | }, | |
22809 | fromString: { | |
22810 | value: function fromString(string) { | |
22811 | if (!/^\d+$/.test(string)) { | |
22812 | throw new Error("Invalid hyper string: " + string); | |
22813 | } | |
22814 | var result = _get(Object.getPrototypeOf(UnsignedHyper), "fromString", this).call(this, string, true); | |
22815 | return new this(result.low, result.high); | |
22816 | } | |
22817 | }, | |
22818 | fromBits: { | |
22819 | value: function fromBits(low, high) { | |
22820 | var result = _get(Object.getPrototypeOf(UnsignedHyper), "fromBits", this).call(this, low, high, true); | |
22821 | return new this(result.low, result.high); | |
22822 | } | |
22823 | }, | |
22824 | isValid: { | |
22825 | value: function isValid(value) { | |
22826 | return value instanceof this; | |
22827 | } | |
22828 | } | |
22829 | }); | |
22830 | ||
22831 | return UnsignedHyper; | |
22832 | })(Long); | |
22833 | ||
22834 | includeIoMixin(UnsignedHyper); | |
22835 | ||
22836 | UnsignedHyper.MAX_VALUE = new UnsignedHyper(Long.MAX_UNSIGNED_VALUE.low, Long.MAX_UNSIGNED_VALUE.high); | |
22837 | ||
22838 | UnsignedHyper.MIN_VALUE = new UnsignedHyper(Long.MIN_VALUE.low, Long.MIN_VALUE.high); | |
22839 | },{"./io-mixin":133,"long":357}],142:[function(require,module,exports){ | |
22840 | "use strict"; | |
22841 | ||
22842 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22843 | ||
22844 | Object.defineProperty(exports, "__esModule", { | |
22845 | value: true | |
22846 | }); | |
22847 | ||
22848 | var isNumber = _interopRequire(require("lodash/isNumber")); | |
22849 | ||
22850 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22851 | ||
22852 | var UnsignedInt = { | |
22853 | ||
22854 | read: function read(io) { | |
22855 | return io.readUInt32BE(); | |
22856 | }, | |
22857 | ||
22858 | write: function write(value, io) { | |
22859 | if (!isNumber(value)) { | |
22860 | throw new Error("XDR Write Error: not a number"); | |
22861 | } | |
22862 | ||
22863 | if (Math.floor(value) !== value) { | |
22864 | throw new Error("XDR Write Error: not an integer"); | |
22865 | } | |
22866 | ||
22867 | if (value < 0) { | |
22868 | throw new Error("XDR Write Error: negative number " + value); | |
22869 | } | |
22870 | ||
22871 | io.writeUInt32BE(value); | |
22872 | }, | |
22873 | ||
22874 | isValid: function isValid(value) { | |
22875 | if (!isNumber(value)) { | |
22876 | return false; | |
22877 | } | |
22878 | if (Math.floor(value) !== value) { | |
22879 | return false; | |
22880 | } | |
22881 | ||
22882 | return value >= UnsignedInt.MIN_VALUE && value <= UnsignedInt.MAX_VALUE; | |
22883 | } }; | |
22884 | ||
22885 | exports.UnsignedInt = UnsignedInt; | |
22886 | UnsignedInt.MAX_VALUE = Math.pow(2, 32) - 1; | |
22887 | UnsignedInt.MIN_VALUE = 0; | |
22888 | ||
22889 | includeIoMixin(UnsignedInt); | |
22890 | },{"./io-mixin":133,"lodash/isNumber":332}],143:[function(require,module,exports){ | |
22891 | "use strict"; | |
22892 | ||
22893 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22894 | ||
22895 | exports.calculatePadding = calculatePadding; | |
22896 | exports.slicePadding = slicePadding; | |
22897 | Object.defineProperty(exports, "__esModule", { | |
22898 | value: true | |
22899 | }); | |
22900 | ||
22901 | var every = _interopRequire(require("lodash/every")); | |
22902 | ||
22903 | function calculatePadding(length) { | |
22904 | switch (length % 4) { | |
22905 | case 0: | |
22906 | return 0; | |
22907 | case 1: | |
22908 | return 3; | |
22909 | case 2: | |
22910 | return 2; | |
22911 | case 3: | |
22912 | return 1; | |
22913 | } | |
22914 | } | |
22915 | ||
22916 | function slicePadding(io, length) { | |
22917 | var padding = io.slice(length); | |
22918 | var allZero = every(padding.buffer(), function (byte) { | |
22919 | return byte === 0; | |
22920 | }); | |
22921 | ||
22922 | if (allZero !== true) { | |
22923 | throw new Error("XDR Read Error: invalid padding"); | |
22924 | } | |
22925 | } | |
22926 | },{"lodash/every":314}],144:[function(require,module,exports){ | |
22927 | "use strict"; | |
22928 | ||
22929 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
22930 | ||
22931 | 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; }; })(); | |
22932 | ||
22933 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
22934 | ||
22935 | Object.defineProperty(exports, "__esModule", { | |
22936 | value: true | |
22937 | }); | |
22938 | ||
22939 | var Int = require("./int").Int; | |
22940 | ||
22941 | var UnsignedInt = require("./unsigned-int").UnsignedInt; | |
22942 | ||
22943 | var every = _interopRequire(require("lodash/every")); | |
22944 | ||
22945 | var each = _interopRequire(require("lodash/each")); | |
22946 | ||
22947 | var times = _interopRequire(require("lodash/times")); | |
22948 | ||
22949 | var isArray = _interopRequire(require("lodash/isArray")); | |
22950 | ||
22951 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
22952 | ||
22953 | var VarArray = exports.VarArray = (function () { | |
22954 | function VarArray(childType) { | |
22955 | var maxLength = arguments[1] === undefined ? UnsignedInt.MAX_VALUE : arguments[1]; | |
22956 | ||
22957 | _classCallCheck(this, VarArray); | |
22958 | ||
22959 | this._childType = childType; | |
22960 | this._maxLength = maxLength; | |
22961 | } | |
22962 | ||
22963 | _createClass(VarArray, { | |
22964 | read: { | |
22965 | value: function read(io) { | |
22966 | var _this = this; | |
22967 | ||
22968 | var length = Int.read(io); | |
22969 | ||
22970 | if (length > this._maxLength) { | |
22971 | throw new Error("XDR Read Error: Saw " + length + " length VarArray," + ("max allowed is " + this._maxLength)); | |
22972 | } | |
22973 | ||
22974 | return times(length, function () { | |
22975 | return _this._childType.read(io); | |
22976 | }); | |
22977 | } | |
22978 | }, | |
22979 | write: { | |
22980 | value: function write(value, io) { | |
22981 | var _this = this; | |
22982 | ||
22983 | if (!isArray(value)) { | |
22984 | throw new Error("XDR Write Error: value is not array"); | |
22985 | } | |
22986 | ||
22987 | if (value.length > this._maxLength) { | |
22988 | throw new Error("XDR Write Error: Got array of size " + value.length + "," + ("max allowed is " + this._maxLength)); | |
22989 | } | |
22990 | ||
22991 | Int.write(value.length, io); | |
22992 | each(value, function (child) { | |
22993 | return _this._childType.write(child, io); | |
22994 | }); | |
22995 | } | |
22996 | }, | |
22997 | isValid: { | |
22998 | value: function isValid(value) { | |
22999 | var _this = this; | |
23000 | ||
23001 | if (!isArray(value)) { | |
23002 | return false; | |
23003 | } | |
23004 | if (value.length > this._maxLength) { | |
23005 | return false; | |
23006 | } | |
23007 | ||
23008 | return every(value, function (child) { | |
23009 | return _this._childType.isValid(child); | |
23010 | }); | |
23011 | } | |
23012 | } | |
23013 | }); | |
23014 | ||
23015 | return VarArray; | |
23016 | })(); | |
23017 | ||
23018 | includeIoMixin(VarArray.prototype); | |
23019 | },{"./int":132,"./io-mixin":133,"./unsigned-int":142,"lodash/each":312,"lodash/every":314,"lodash/isArray":323,"lodash/times":350}],145:[function(require,module,exports){ | |
23020 | (function (Buffer){ | |
23021 | "use strict"; | |
23022 | ||
23023 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
23024 | ||
23025 | 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; }; })(); | |
23026 | ||
23027 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
23028 | ||
23029 | Object.defineProperty(exports, "__esModule", { | |
23030 | value: true | |
23031 | }); | |
23032 | ||
23033 | var Int = require("./int").Int; | |
23034 | ||
23035 | var UnsignedInt = require("./unsigned-int").UnsignedInt; | |
23036 | ||
23037 | var _util = require("./util"); | |
23038 | ||
23039 | var calculatePadding = _util.calculatePadding; | |
23040 | var slicePadding = _util.slicePadding; | |
23041 | ||
23042 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
23043 | ||
23044 | var VarOpaque = exports.VarOpaque = (function () { | |
23045 | function VarOpaque() { | |
23046 | var maxLength = arguments[0] === undefined ? UnsignedInt.MAX_VALUE : arguments[0]; | |
23047 | ||
23048 | _classCallCheck(this, VarOpaque); | |
23049 | ||
23050 | this._maxLength = maxLength; | |
23051 | } | |
23052 | ||
23053 | _createClass(VarOpaque, { | |
23054 | read: { | |
23055 | value: function read(io) { | |
23056 | var length = Int.read(io); | |
23057 | ||
23058 | if (length > this._maxLength) { | |
23059 | throw new Error("XDR Read Error: Saw " + length + " length VarOpaque," + ("max allowed is " + this._maxLength)); | |
23060 | } | |
23061 | var padding = calculatePadding(length); | |
23062 | var result = io.slice(length); | |
23063 | slicePadding(io, padding); | |
23064 | return result.buffer(); | |
23065 | } | |
23066 | }, | |
23067 | write: { | |
23068 | value: function write(value, io) { | |
23069 | if (value.length > this._maxLength) { | |
23070 | throw new Error("XDR Write Error: Got " + value.length + " bytes," + ("max allows is " + this._maxLength)); | |
23071 | } | |
23072 | Int.write(value.length, io); | |
23073 | io.writeBufferPadded(value); | |
23074 | } | |
23075 | }, | |
23076 | isValid: { | |
23077 | value: function isValid(value) { | |
23078 | return Buffer.isBuffer(value) && value.length <= this._maxLength; | |
23079 | } | |
23080 | } | |
23081 | }); | |
23082 | ||
23083 | return VarOpaque; | |
23084 | })(); | |
23085 | ||
23086 | includeIoMixin(VarOpaque.prototype); | |
23087 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | |
23088 | },{"../../is-buffer/index.js":120,"./int":132,"./io-mixin":133,"./unsigned-int":142,"./util":143}],146:[function(require,module,exports){ | |
23089 | "use strict"; | |
23090 | ||
23091 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
23092 | ||
23093 | Object.defineProperty(exports, "__esModule", { | |
23094 | value: true | |
23095 | }); | |
23096 | ||
23097 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
23098 | ||
23099 | var includeIoMixin = _interopRequire(require("./io-mixin")); | |
23100 | ||
23101 | var Void = { | |
23102 | /* jshint unused: false */ | |
23103 | ||
23104 | read: function read(io) { | |
23105 | return undefined; | |
23106 | }, | |
23107 | ||
23108 | write: function write(value, io) { | |
23109 | if (!isUndefined(value)) { | |
23110 | throw new Error("XDR Write Error: trying to write value to a void slot"); | |
23111 | } | |
23112 | }, | |
23113 | ||
23114 | isValid: function isValid(value) { | |
23115 | return isUndefined(value); | |
23116 | } }; | |
23117 | ||
23118 | exports.Void = Void; | |
23119 | includeIoMixin(Void); | |
23120 | },{"./io-mixin":133,"lodash/isUndefined":340}],147:[function(require,module,exports){ | |
23121 | var getNative = require('./_getNative'), | |
23122 | root = require('./_root'); | |
23123 | ||
23124 | /* Built-in method references that are verified to be native. */ | |
23125 | var DataView = getNative(root, 'DataView'); | |
23126 | ||
23127 | module.exports = DataView; | |
23128 | ||
23129 | },{"./_getNative":245,"./_root":290}],148:[function(require,module,exports){ | |
23130 | var hashClear = require('./_hashClear'), | |
23131 | hashDelete = require('./_hashDelete'), | |
23132 | hashGet = require('./_hashGet'), | |
23133 | hashHas = require('./_hashHas'), | |
23134 | hashSet = require('./_hashSet'); | |
23135 | ||
23136 | /** | |
23137 | * Creates a hash object. | |
23138 | * | |
23139 | * @private | |
23140 | * @constructor | |
23141 | * @param {Array} [entries] The key-value pairs to cache. | |
23142 | */ | |
23143 | function Hash(entries) { | |
23144 | var index = -1, | |
23145 | length = entries == null ? 0 : entries.length; | |
23146 | ||
23147 | this.clear(); | |
23148 | while (++index < length) { | |
23149 | var entry = entries[index]; | |
23150 | this.set(entry[0], entry[1]); | |
23151 | } | |
23152 | } | |
23153 | ||
23154 | // Add methods to `Hash`. | |
23155 | Hash.prototype.clear = hashClear; | |
23156 | Hash.prototype['delete'] = hashDelete; | |
23157 | Hash.prototype.get = hashGet; | |
23158 | Hash.prototype.has = hashHas; | |
23159 | Hash.prototype.set = hashSet; | |
23160 | ||
23161 | module.exports = Hash; | |
23162 | ||
23163 | },{"./_hashClear":254,"./_hashDelete":255,"./_hashGet":256,"./_hashHas":257,"./_hashSet":258}],149:[function(require,module,exports){ | |
23164 | var listCacheClear = require('./_listCacheClear'), | |
23165 | listCacheDelete = require('./_listCacheDelete'), | |
23166 | listCacheGet = require('./_listCacheGet'), | |
23167 | listCacheHas = require('./_listCacheHas'), | |
23168 | listCacheSet = require('./_listCacheSet'); | |
23169 | ||
23170 | /** | |
23171 | * Creates an list cache object. | |
23172 | * | |
23173 | * @private | |
23174 | * @constructor | |
23175 | * @param {Array} [entries] The key-value pairs to cache. | |
23176 | */ | |
23177 | function ListCache(entries) { | |
23178 | var index = -1, | |
23179 | length = entries == null ? 0 : entries.length; | |
23180 | ||
23181 | this.clear(); | |
23182 | while (++index < length) { | |
23183 | var entry = entries[index]; | |
23184 | this.set(entry[0], entry[1]); | |
23185 | } | |
23186 | } | |
23187 | ||
23188 | // Add methods to `ListCache`. | |
23189 | ListCache.prototype.clear = listCacheClear; | |
23190 | ListCache.prototype['delete'] = listCacheDelete; | |
23191 | ListCache.prototype.get = listCacheGet; | |
23192 | ListCache.prototype.has = listCacheHas; | |
23193 | ListCache.prototype.set = listCacheSet; | |
23194 | ||
23195 | module.exports = ListCache; | |
23196 | ||
23197 | },{"./_listCacheClear":270,"./_listCacheDelete":271,"./_listCacheGet":272,"./_listCacheHas":273,"./_listCacheSet":274}],150:[function(require,module,exports){ | |
23198 | var getNative = require('./_getNative'), | |
23199 | root = require('./_root'); | |
23200 | ||
23201 | /* Built-in method references that are verified to be native. */ | |
23202 | var Map = getNative(root, 'Map'); | |
23203 | ||
23204 | module.exports = Map; | |
23205 | ||
23206 | },{"./_getNative":245,"./_root":290}],151:[function(require,module,exports){ | |
23207 | var mapCacheClear = require('./_mapCacheClear'), | |
23208 | mapCacheDelete = require('./_mapCacheDelete'), | |
23209 | mapCacheGet = require('./_mapCacheGet'), | |
23210 | mapCacheHas = require('./_mapCacheHas'), | |
23211 | mapCacheSet = require('./_mapCacheSet'); | |
23212 | ||
23213 | /** | |
23214 | * Creates a map cache object to store key-value pairs. | |
23215 | * | |
23216 | * @private | |
23217 | * @constructor | |
23218 | * @param {Array} [entries] The key-value pairs to cache. | |
23219 | */ | |
23220 | function MapCache(entries) { | |
23221 | var index = -1, | |
23222 | length = entries == null ? 0 : entries.length; | |
23223 | ||
23224 | this.clear(); | |
23225 | while (++index < length) { | |
23226 | var entry = entries[index]; | |
23227 | this.set(entry[0], entry[1]); | |
23228 | } | |
23229 | } | |
23230 | ||
23231 | // Add methods to `MapCache`. | |
23232 | MapCache.prototype.clear = mapCacheClear; | |
23233 | MapCache.prototype['delete'] = mapCacheDelete; | |
23234 | MapCache.prototype.get = mapCacheGet; | |
23235 | MapCache.prototype.has = mapCacheHas; | |
23236 | MapCache.prototype.set = mapCacheSet; | |
23237 | ||
23238 | module.exports = MapCache; | |
23239 | ||
23240 | },{"./_mapCacheClear":275,"./_mapCacheDelete":276,"./_mapCacheGet":277,"./_mapCacheHas":278,"./_mapCacheSet":279}],152:[function(require,module,exports){ | |
23241 | var getNative = require('./_getNative'), | |
23242 | root = require('./_root'); | |
23243 | ||
23244 | /* Built-in method references that are verified to be native. */ | |
23245 | var Promise = getNative(root, 'Promise'); | |
23246 | ||
23247 | module.exports = Promise; | |
23248 | ||
23249 | },{"./_getNative":245,"./_root":290}],153:[function(require,module,exports){ | |
23250 | var getNative = require('./_getNative'), | |
23251 | root = require('./_root'); | |
23252 | ||
23253 | /* Built-in method references that are verified to be native. */ | |
23254 | var Set = getNative(root, 'Set'); | |
23255 | ||
23256 | module.exports = Set; | |
23257 | ||
23258 | },{"./_getNative":245,"./_root":290}],154:[function(require,module,exports){ | |
23259 | var MapCache = require('./_MapCache'), | |
23260 | setCacheAdd = require('./_setCacheAdd'), | |
23261 | setCacheHas = require('./_setCacheHas'); | |
23262 | ||
23263 | /** | |
23264 | * | |
23265 | * Creates an array cache object to store unique values. | |
23266 | * | |
23267 | * @private | |
23268 | * @constructor | |
23269 | * @param {Array} [values] The values to cache. | |
23270 | */ | |
23271 | function SetCache(values) { | |
23272 | var index = -1, | |
23273 | length = values == null ? 0 : values.length; | |
23274 | ||
23275 | this.__data__ = new MapCache; | |
23276 | while (++index < length) { | |
23277 | this.add(values[index]); | |
23278 | } | |
23279 | } | |
23280 | ||
23281 | // Add methods to `SetCache`. | |
23282 | SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; | |
23283 | SetCache.prototype.has = setCacheHas; | |
23284 | ||
23285 | module.exports = SetCache; | |
23286 | ||
23287 | },{"./_MapCache":151,"./_setCacheAdd":291,"./_setCacheHas":292}],155:[function(require,module,exports){ | |
23288 | var ListCache = require('./_ListCache'), | |
23289 | stackClear = require('./_stackClear'), | |
23290 | stackDelete = require('./_stackDelete'), | |
23291 | stackGet = require('./_stackGet'), | |
23292 | stackHas = require('./_stackHas'), | |
23293 | stackSet = require('./_stackSet'); | |
23294 | ||
23295 | /** | |
23296 | * Creates a stack cache object to store key-value pairs. | |
23297 | * | |
23298 | * @private | |
23299 | * @constructor | |
23300 | * @param {Array} [entries] The key-value pairs to cache. | |
23301 | */ | |
23302 | function Stack(entries) { | |
23303 | var data = this.__data__ = new ListCache(entries); | |
23304 | this.size = data.size; | |
23305 | } | |
23306 | ||
23307 | // Add methods to `Stack`. | |
23308 | Stack.prototype.clear = stackClear; | |
23309 | Stack.prototype['delete'] = stackDelete; | |
23310 | Stack.prototype.get = stackGet; | |
23311 | Stack.prototype.has = stackHas; | |
23312 | Stack.prototype.set = stackSet; | |
23313 | ||
23314 | module.exports = Stack; | |
23315 | ||
23316 | },{"./_ListCache":149,"./_stackClear":296,"./_stackDelete":297,"./_stackGet":298,"./_stackHas":299,"./_stackSet":300}],156:[function(require,module,exports){ | |
23317 | var root = require('./_root'); | |
23318 | ||
23319 | /** Built-in value references. */ | |
23320 | var Symbol = root.Symbol; | |
23321 | ||
23322 | module.exports = Symbol; | |
23323 | ||
23324 | },{"./_root":290}],157:[function(require,module,exports){ | |
23325 | var root = require('./_root'); | |
23326 | ||
23327 | /** Built-in value references. */ | |
23328 | var Uint8Array = root.Uint8Array; | |
23329 | ||
23330 | module.exports = Uint8Array; | |
23331 | ||
23332 | },{"./_root":290}],158:[function(require,module,exports){ | |
23333 | var getNative = require('./_getNative'), | |
23334 | root = require('./_root'); | |
23335 | ||
23336 | /* Built-in method references that are verified to be native. */ | |
23337 | var WeakMap = getNative(root, 'WeakMap'); | |
23338 | ||
23339 | module.exports = WeakMap; | |
23340 | ||
23341 | },{"./_getNative":245,"./_root":290}],159:[function(require,module,exports){ | |
23342 | /** | |
23343 | * A faster alternative to `Function#apply`, this function invokes `func` | |
23344 | * with the `this` binding of `thisArg` and the arguments of `args`. | |
23345 | * | |
23346 | * @private | |
23347 | * @param {Function} func The function to invoke. | |
23348 | * @param {*} thisArg The `this` binding of `func`. | |
23349 | * @param {Array} args The arguments to invoke `func` with. | |
23350 | * @returns {*} Returns the result of `func`. | |
23351 | */ | |
23352 | function apply(func, thisArg, args) { | |
23353 | switch (args.length) { | |
23354 | case 0: return func.call(thisArg); | |
23355 | case 1: return func.call(thisArg, args[0]); | |
23356 | case 2: return func.call(thisArg, args[0], args[1]); | |
23357 | case 3: return func.call(thisArg, args[0], args[1], args[2]); | |
23358 | } | |
23359 | return func.apply(thisArg, args); | |
23360 | } | |
23361 | ||
23362 | module.exports = apply; | |
23363 | ||
23364 | },{}],160:[function(require,module,exports){ | |
23365 | /** | |
23366 | * A specialized version of `_.forEach` for arrays without support for | |
23367 | * iteratee shorthands. | |
23368 | * | |
23369 | * @private | |
23370 | * @param {Array} [array] The array to iterate over. | |
23371 | * @param {Function} iteratee The function invoked per iteration. | |
23372 | * @returns {Array} Returns `array`. | |
23373 | */ | |
23374 | function arrayEach(array, iteratee) { | |
23375 | var index = -1, | |
23376 | length = array == null ? 0 : array.length; | |
23377 | ||
23378 | while (++index < length) { | |
23379 | if (iteratee(array[index], index, array) === false) { | |
23380 | break; | |
23381 | } | |
23382 | } | |
23383 | return array; | |
23384 | } | |
23385 | ||
23386 | module.exports = arrayEach; | |
23387 | ||
23388 | },{}],161:[function(require,module,exports){ | |
23389 | /** | |
23390 | * A specialized version of `_.every` for arrays without support for | |
23391 | * iteratee shorthands. | |
23392 | * | |
23393 | * @private | |
23394 | * @param {Array} [array] The array to iterate over. | |
23395 | * @param {Function} predicate The function invoked per iteration. | |
23396 | * @returns {boolean} Returns `true` if all elements pass the predicate check, | |
23397 | * else `false`. | |
23398 | */ | |
23399 | function arrayEvery(array, predicate) { | |
23400 | var index = -1, | |
23401 | length = array == null ? 0 : array.length; | |
23402 | ||
23403 | while (++index < length) { | |
23404 | if (!predicate(array[index], index, array)) { | |
23405 | return false; | |
23406 | } | |
23407 | } | |
23408 | return true; | |
23409 | } | |
23410 | ||
23411 | module.exports = arrayEvery; | |
23412 | ||
23413 | },{}],162:[function(require,module,exports){ | |
23414 | /** | |
23415 | * A specialized version of `_.filter` for arrays without support for | |
23416 | * iteratee shorthands. | |
23417 | * | |
23418 | * @private | |
23419 | * @param {Array} [array] The array to iterate over. | |
23420 | * @param {Function} predicate The function invoked per iteration. | |
23421 | * @returns {Array} Returns the new filtered array. | |
23422 | */ | |
23423 | function arrayFilter(array, predicate) { | |
23424 | var index = -1, | |
23425 | length = array == null ? 0 : array.length, | |
23426 | resIndex = 0, | |
23427 | result = []; | |
23428 | ||
23429 | while (++index < length) { | |
23430 | var value = array[index]; | |
23431 | if (predicate(value, index, array)) { | |
23432 | result[resIndex++] = value; | |
23433 | } | |
23434 | } | |
23435 | return result; | |
23436 | } | |
23437 | ||
23438 | module.exports = arrayFilter; | |
23439 | ||
23440 | },{}],163:[function(require,module,exports){ | |
23441 | var baseTimes = require('./_baseTimes'), | |
23442 | isArguments = require('./isArguments'), | |
23443 | isArray = require('./isArray'), | |
23444 | isBuffer = require('./isBuffer'), | |
23445 | isIndex = require('./_isIndex'), | |
23446 | isTypedArray = require('./isTypedArray'); | |
23447 | ||
23448 | /** Used for built-in method references. */ | |
23449 | var objectProto = Object.prototype; | |
23450 | ||
23451 | /** Used to check objects for own properties. */ | |
23452 | var hasOwnProperty = objectProto.hasOwnProperty; | |
23453 | ||
23454 | /** | |
23455 | * Creates an array of the enumerable property names of the array-like `value`. | |
23456 | * | |
23457 | * @private | |
23458 | * @param {*} value The value to query. | |
23459 | * @param {boolean} inherited Specify returning inherited property names. | |
23460 | * @returns {Array} Returns the array of property names. | |
23461 | */ | |
23462 | function arrayLikeKeys(value, inherited) { | |
23463 | var isArr = isArray(value), | |
23464 | isArg = !isArr && isArguments(value), | |
23465 | isBuff = !isArr && !isArg && isBuffer(value), | |
23466 | isType = !isArr && !isArg && !isBuff && isTypedArray(value), | |
23467 | skipIndexes = isArr || isArg || isBuff || isType, | |
23468 | result = skipIndexes ? baseTimes(value.length, String) : [], | |
23469 | length = result.length; | |
23470 | ||
23471 | for (var key in value) { | |
23472 | if ((inherited || hasOwnProperty.call(value, key)) && | |
23473 | !(skipIndexes && ( | |
23474 | // Safari 9 has enumerable `arguments.length` in strict mode. | |
23475 | key == 'length' || | |
23476 | // Node.js 0.10 has enumerable non-index properties on buffers. | |
23477 | (isBuff && (key == 'offset' || key == 'parent')) || | |
23478 | // PhantomJS 2 has enumerable non-index properties on typed arrays. | |
23479 | (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || | |
23480 | // Skip index properties. | |
23481 | isIndex(key, length) | |
23482 | ))) { | |
23483 | result.push(key); | |
23484 | } | |
23485 | } | |
23486 | return result; | |
23487 | } | |
23488 | ||
23489 | module.exports = arrayLikeKeys; | |
23490 | ||
23491 | },{"./_baseTimes":211,"./_isIndex":263,"./isArguments":322,"./isArray":323,"./isBuffer":326,"./isTypedArray":339}],164:[function(require,module,exports){ | |
23492 | /** | |
23493 | * A specialized version of `_.map` for arrays without support for iteratee | |
23494 | * shorthands. | |
23495 | * | |
23496 | * @private | |
23497 | * @param {Array} [array] The array to iterate over. | |
23498 | * @param {Function} iteratee The function invoked per iteration. | |
23499 | * @returns {Array} Returns the new mapped array. | |
23500 | */ | |
23501 | function arrayMap(array, iteratee) { | |
23502 | var index = -1, | |
23503 | length = array == null ? 0 : array.length, | |
23504 | result = Array(length); | |
23505 | ||
23506 | while (++index < length) { | |
23507 | result[index] = iteratee(array[index], index, array); | |
23508 | } | |
23509 | return result; | |
23510 | } | |
23511 | ||
23512 | module.exports = arrayMap; | |
23513 | ||
23514 | },{}],165:[function(require,module,exports){ | |
23515 | /** | |
23516 | * Appends the elements of `values` to `array`. | |
23517 | * | |
23518 | * @private | |
23519 | * @param {Array} array The array to modify. | |
23520 | * @param {Array} values The values to append. | |
23521 | * @returns {Array} Returns `array`. | |
23522 | */ | |
23523 | function arrayPush(array, values) { | |
23524 | var index = -1, | |
23525 | length = values.length, | |
23526 | offset = array.length; | |
23527 | ||
23528 | while (++index < length) { | |
23529 | array[offset + index] = values[index]; | |
23530 | } | |
23531 | return array; | |
23532 | } | |
23533 | ||
23534 | module.exports = arrayPush; | |
23535 | ||
23536 | },{}],166:[function(require,module,exports){ | |
23537 | /** | |
23538 | * A specialized version of `_.some` for arrays without support for iteratee | |
23539 | * shorthands. | |
23540 | * | |
23541 | * @private | |
23542 | * @param {Array} [array] The array to iterate over. | |
23543 | * @param {Function} predicate The function invoked per iteration. | |
23544 | * @returns {boolean} Returns `true` if any element passes the predicate check, | |
23545 | * else `false`. | |
23546 | */ | |
23547 | function arraySome(array, predicate) { | |
23548 | var index = -1, | |
23549 | length = array == null ? 0 : array.length; | |
23550 | ||
23551 | while (++index < length) { | |
23552 | if (predicate(array[index], index, array)) { | |
23553 | return true; | |
23554 | } | |
23555 | } | |
23556 | return false; | |
23557 | } | |
23558 | ||
23559 | module.exports = arraySome; | |
23560 | ||
23561 | },{}],167:[function(require,module,exports){ | |
23562 | var baseProperty = require('./_baseProperty'); | |
23563 | ||
23564 | /** | |
23565 | * Gets the size of an ASCII `string`. | |
23566 | * | |
23567 | * @private | |
23568 | * @param {string} string The string inspect. | |
23569 | * @returns {number} Returns the string size. | |
23570 | */ | |
23571 | var asciiSize = baseProperty('length'); | |
23572 | ||
23573 | module.exports = asciiSize; | |
23574 | ||
23575 | },{"./_baseProperty":204}],168:[function(require,module,exports){ | |
23576 | /** | |
23577 | * Converts an ASCII `string` to an array. | |
23578 | * | |
23579 | * @private | |
23580 | * @param {string} string The string to convert. | |
23581 | * @returns {Array} Returns the converted array. | |
23582 | */ | |
23583 | function asciiToArray(string) { | |
23584 | return string.split(''); | |
23585 | } | |
23586 | ||
23587 | module.exports = asciiToArray; | |
23588 | ||
23589 | },{}],169:[function(require,module,exports){ | |
23590 | var baseAssignValue = require('./_baseAssignValue'), | |
23591 | eq = require('./eq'); | |
23592 | ||
23593 | /** Used for built-in method references. */ | |
23594 | var objectProto = Object.prototype; | |
23595 | ||
23596 | /** Used to check objects for own properties. */ | |
23597 | var hasOwnProperty = objectProto.hasOwnProperty; | |
23598 | ||
23599 | /** | |
23600 | * Assigns `value` to `key` of `object` if the existing value is not equivalent | |
23601 | * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) | |
23602 | * for equality comparisons. | |
23603 | * | |
23604 | * @private | |
23605 | * @param {Object} object The object to modify. | |
23606 | * @param {string} key The key of the property to assign. | |
23607 | * @param {*} value The value to assign. | |
23608 | */ | |
23609 | function assignValue(object, key, value) { | |
23610 | var objValue = object[key]; | |
23611 | if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || | |
23612 | (value === undefined && !(key in object))) { | |
23613 | baseAssignValue(object, key, value); | |
23614 | } | |
23615 | } | |
23616 | ||
23617 | module.exports = assignValue; | |
23618 | ||
23619 | },{"./_baseAssignValue":173,"./eq":313}],170:[function(require,module,exports){ | |
23620 | var eq = require('./eq'); | |
23621 | ||
23622 | /** | |
23623 | * Gets the index at which the `key` is found in `array` of key-value pairs. | |
23624 | * | |
23625 | * @private | |
23626 | * @param {Array} array The array to inspect. | |
23627 | * @param {*} key The key to search for. | |
23628 | * @returns {number} Returns the index of the matched value, else `-1`. | |
23629 | */ | |
23630 | function assocIndexOf(array, key) { | |
23631 | var length = array.length; | |
23632 | while (length--) { | |
23633 | if (eq(array[length][0], key)) { | |
23634 | return length; | |
23635 | } | |
23636 | } | |
23637 | return -1; | |
23638 | } | |
23639 | ||
23640 | module.exports = assocIndexOf; | |
23641 | ||
23642 | },{"./eq":313}],171:[function(require,module,exports){ | |
23643 | var copyObject = require('./_copyObject'), | |
23644 | keys = require('./keys'); | |
23645 | ||
23646 | /** | |
23647 | * The base implementation of `_.assign` without support for multiple sources | |
23648 | * or `customizer` functions. | |
23649 | * | |
23650 | * @private | |
23651 | * @param {Object} object The destination object. | |
23652 | * @param {Object} source The source object. | |
23653 | * @returns {Object} Returns `object`. | |
23654 | */ | |
23655 | function baseAssign(object, source) { | |
23656 | return object && copyObject(source, keys(source), object); | |
23657 | } | |
23658 | ||
23659 | module.exports = baseAssign; | |
23660 | ||
23661 | },{"./_copyObject":227,"./keys":341}],172:[function(require,module,exports){ | |
23662 | var copyObject = require('./_copyObject'), | |
23663 | keysIn = require('./keysIn'); | |
23664 | ||
23665 | /** | |
23666 | * The base implementation of `_.assignIn` without support for multiple sources | |
23667 | * or `customizer` functions. | |
23668 | * | |
23669 | * @private | |
23670 | * @param {Object} object The destination object. | |
23671 | * @param {Object} source The source object. | |
23672 | * @returns {Object} Returns `object`. | |
23673 | */ | |
23674 | function baseAssignIn(object, source) { | |
23675 | return object && copyObject(source, keysIn(source), object); | |
23676 | } | |
23677 | ||
23678 | module.exports = baseAssignIn; | |
23679 | ||
23680 | },{"./_copyObject":227,"./keysIn":342}],173:[function(require,module,exports){ | |
23681 | var defineProperty = require('./_defineProperty'); | |
23682 | ||
23683 | /** | |
23684 | * The base implementation of `assignValue` and `assignMergeValue` without | |
23685 | * value checks. | |
23686 | * | |
23687 | * @private | |
23688 | * @param {Object} object The object to modify. | |
23689 | * @param {string} key The key of the property to assign. | |
23690 | * @param {*} value The value to assign. | |
23691 | */ | |
23692 | function baseAssignValue(object, key, value) { | |
23693 | if (key == '__proto__' && defineProperty) { | |
23694 | defineProperty(object, key, { | |
23695 | 'configurable': true, | |
23696 | 'enumerable': true, | |
23697 | 'value': value, | |
23698 | 'writable': true | |
23699 | }); | |
23700 | } else { | |
23701 | object[key] = value; | |
23702 | } | |
23703 | } | |
23704 | ||
23705 | module.exports = baseAssignValue; | |
23706 | ||
23707 | },{"./_defineProperty":235}],174:[function(require,module,exports){ | |
23708 | var Stack = require('./_Stack'), | |
23709 | arrayEach = require('./_arrayEach'), | |
23710 | assignValue = require('./_assignValue'), | |
23711 | baseAssign = require('./_baseAssign'), | |
23712 | baseAssignIn = require('./_baseAssignIn'), | |
23713 | cloneBuffer = require('./_cloneBuffer'), | |
23714 | copyArray = require('./_copyArray'), | |
23715 | copySymbols = require('./_copySymbols'), | |
23716 | copySymbolsIn = require('./_copySymbolsIn'), | |
23717 | getAllKeys = require('./_getAllKeys'), | |
23718 | getAllKeysIn = require('./_getAllKeysIn'), | |
23719 | getTag = require('./_getTag'), | |
23720 | initCloneArray = require('./_initCloneArray'), | |
23721 | initCloneByTag = require('./_initCloneByTag'), | |
23722 | initCloneObject = require('./_initCloneObject'), | |
23723 | isArray = require('./isArray'), | |
23724 | isBuffer = require('./isBuffer'), | |
23725 | isMap = require('./isMap'), | |
23726 | isObject = require('./isObject'), | |
23727 | isSet = require('./isSet'), | |
23728 | keys = require('./keys'); | |
23729 | ||
23730 | /** Used to compose bitmasks for cloning. */ | |
23731 | var CLONE_DEEP_FLAG = 1, | |
23732 | CLONE_FLAT_FLAG = 2, | |
23733 | CLONE_SYMBOLS_FLAG = 4; | |
23734 | ||
23735 | /** `Object#toString` result references. */ | |
23736 | var argsTag = '[object Arguments]', | |
23737 | arrayTag = '[object Array]', | |
23738 | boolTag = '[object Boolean]', | |
23739 | dateTag = '[object Date]', | |
23740 | errorTag = '[object Error]', | |
23741 | funcTag = '[object Function]', | |
23742 | genTag = '[object GeneratorFunction]', | |
23743 | mapTag = '[object Map]', | |
23744 | numberTag = '[object Number]', | |
23745 | objectTag = '[object Object]', | |
23746 | regexpTag = '[object RegExp]', | |
23747 | setTag = '[object Set]', | |
23748 | stringTag = '[object String]', | |
23749 | symbolTag = '[object Symbol]', | |
23750 | weakMapTag = '[object WeakMap]'; | |
23751 | ||
23752 | var arrayBufferTag = '[object ArrayBuffer]', | |
23753 | dataViewTag = '[object DataView]', | |
23754 | float32Tag = '[object Float32Array]', | |
23755 | float64Tag = '[object Float64Array]', | |
23756 | int8Tag = '[object Int8Array]', | |
23757 | int16Tag = '[object Int16Array]', | |
23758 | int32Tag = '[object Int32Array]', | |
23759 | uint8Tag = '[object Uint8Array]', | |
23760 | uint8ClampedTag = '[object Uint8ClampedArray]', | |
23761 | uint16Tag = '[object Uint16Array]', | |
23762 | uint32Tag = '[object Uint32Array]'; | |
23763 | ||
23764 | /** Used to identify `toStringTag` values supported by `_.clone`. */ | |
23765 | var cloneableTags = {}; | |
23766 | cloneableTags[argsTag] = cloneableTags[arrayTag] = | |
23767 | cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = | |
23768 | cloneableTags[boolTag] = cloneableTags[dateTag] = | |
23769 | cloneableTags[float32Tag] = cloneableTags[float64Tag] = | |
23770 | cloneableTags[int8Tag] = cloneableTags[int16Tag] = | |
23771 | cloneableTags[int32Tag] = cloneableTags[mapTag] = | |
23772 | cloneableTags[numberTag] = cloneableTags[objectTag] = | |
23773 | cloneableTags[regexpTag] = cloneableTags[setTag] = | |
23774 | cloneableTags[stringTag] = cloneableTags[symbolTag] = | |
23775 | cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = | |
23776 | cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; | |
23777 | cloneableTags[errorTag] = cloneableTags[funcTag] = | |
23778 | cloneableTags[weakMapTag] = false; | |
23779 | ||
23780 | /** | |
23781 | * The base implementation of `_.clone` and `_.cloneDeep` which tracks | |
23782 | * traversed objects. | |
23783 | * | |
23784 | * @private | |
23785 | * @param {*} value The value to clone. | |
23786 | * @param {boolean} bitmask The bitmask flags. | |
23787 | * 1 - Deep clone | |
23788 | * 2 - Flatten inherited properties | |
23789 | * 4 - Clone symbols | |
23790 | * @param {Function} [customizer] The function to customize cloning. | |
23791 | * @param {string} [key] The key of `value`. | |
23792 | * @param {Object} [object] The parent object of `value`. | |
23793 | * @param {Object} [stack] Tracks traversed objects and their clone counterparts. | |
23794 | * @returns {*} Returns the cloned value. | |
23795 | */ | |
23796 | function baseClone(value, bitmask, customizer, key, object, stack) { | |
23797 | var result, | |
23798 | isDeep = bitmask & CLONE_DEEP_FLAG, | |
23799 | isFlat = bitmask & CLONE_FLAT_FLAG, | |
23800 | isFull = bitmask & CLONE_SYMBOLS_FLAG; | |
23801 | ||
23802 | if (customizer) { | |
23803 | result = object ? customizer(value, key, object, stack) : customizer(value); | |
23804 | } | |
23805 | if (result !== undefined) { | |
23806 | return result; | |
23807 | } | |
23808 | if (!isObject(value)) { | |
23809 | return value; | |
23810 | } | |
23811 | var isArr = isArray(value); | |
23812 | if (isArr) { | |
23813 | result = initCloneArray(value); | |
23814 | if (!isDeep) { | |
23815 | return copyArray(value, result); | |
23816 | } | |
23817 | } else { | |
23818 | var tag = getTag(value), | |
23819 | isFunc = tag == funcTag || tag == genTag; | |
23820 | ||
23821 | if (isBuffer(value)) { | |
23822 | return cloneBuffer(value, isDeep); | |
23823 | } | |
23824 | if (tag == objectTag || tag == argsTag || (isFunc && !object)) { | |
23825 | result = (isFlat || isFunc) ? {} : initCloneObject(value); | |
23826 | if (!isDeep) { | |
23827 | return isFlat | |
23828 | ? copySymbolsIn(value, baseAssignIn(result, value)) | |
23829 | : copySymbols(value, baseAssign(result, value)); | |
23830 | } | |
23831 | } else { | |
23832 | if (!cloneableTags[tag]) { | |
23833 | return object ? value : {}; | |
23834 | } | |
23835 | result = initCloneByTag(value, tag, isDeep); | |
23836 | } | |
23837 | } | |
23838 | // Check for circular references and return its corresponding clone. | |
23839 | stack || (stack = new Stack); | |
23840 | var stacked = stack.get(value); | |
23841 | if (stacked) { | |
23842 | return stacked; | |
23843 | } | |
23844 | stack.set(value, result); | |
23845 | ||
23846 | if (isSet(value)) { | |
23847 | value.forEach(function(subValue) { | |
23848 | result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); | |
23849 | }); | |
23850 | ||
23851 | return result; | |
23852 | } | |
23853 | ||
23854 | if (isMap(value)) { | |
23855 | value.forEach(function(subValue, key) { | |
23856 | result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); | |
23857 | }); | |
23858 | ||
23859 | return result; | |
23860 | } | |
23861 | ||
23862 | var keysFunc = isFull | |
23863 | ? (isFlat ? getAllKeysIn : getAllKeys) | |
23864 | : (isFlat ? keysIn : keys); | |
23865 | ||
23866 | var props = isArr ? undefined : keysFunc(value); | |
23867 | arrayEach(props || value, function(subValue, key) { | |
23868 | if (props) { | |
23869 | key = subValue; | |
23870 | subValue = value[key]; | |
23871 | } | |
23872 | // Recursively populate clone (susceptible to call stack limits). | |
23873 | assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); | |
23874 | }); | |
23875 | return result; | |
23876 | } | |
23877 | ||
23878 | module.exports = baseClone; | |
23879 | ||
23880 | },{"./_Stack":155,"./_arrayEach":160,"./_assignValue":169,"./_baseAssign":171,"./_baseAssignIn":172,"./_cloneBuffer":221,"./_copyArray":226,"./_copySymbols":228,"./_copySymbolsIn":229,"./_getAllKeys":241,"./_getAllKeysIn":242,"./_getTag":250,"./_initCloneArray":259,"./_initCloneByTag":260,"./_initCloneObject":261,"./isArray":323,"./isBuffer":326,"./isMap":330,"./isObject":333,"./isSet":336,"./keys":341}],175:[function(require,module,exports){ | |
23881 | var isObject = require('./isObject'); | |
23882 | ||
23883 | /** Built-in value references. */ | |
23884 | var objectCreate = Object.create; | |
23885 | ||
23886 | /** | |
23887 | * The base implementation of `_.create` without support for assigning | |
23888 | * properties to the created object. | |
23889 | * | |
23890 | * @private | |
23891 | * @param {Object} proto The object to inherit from. | |
23892 | * @returns {Object} Returns the new object. | |
23893 | */ | |
23894 | var baseCreate = (function() { | |
23895 | function object() {} | |
23896 | return function(proto) { | |
23897 | if (!isObject(proto)) { | |
23898 | return {}; | |
23899 | } | |
23900 | if (objectCreate) { | |
23901 | return objectCreate(proto); | |
23902 | } | |
23903 | object.prototype = proto; | |
23904 | var result = new object; | |
23905 | object.prototype = undefined; | |
23906 | return result; | |
23907 | }; | |
23908 | }()); | |
23909 | ||
23910 | module.exports = baseCreate; | |
23911 | ||
23912 | },{"./isObject":333}],176:[function(require,module,exports){ | |
23913 | var baseForOwn = require('./_baseForOwn'), | |
23914 | createBaseEach = require('./_createBaseEach'); | |
23915 | ||
23916 | /** | |
23917 | * The base implementation of `_.forEach` without support for iteratee shorthands. | |
23918 | * | |
23919 | * @private | |
23920 | * @param {Array|Object} collection The collection to iterate over. | |
23921 | * @param {Function} iteratee The function invoked per iteration. | |
23922 | * @returns {Array|Object} Returns `collection`. | |
23923 | */ | |
23924 | var baseEach = createBaseEach(baseForOwn); | |
23925 | ||
23926 | module.exports = baseEach; | |
23927 | ||
23928 | },{"./_baseForOwn":181,"./_createBaseEach":232}],177:[function(require,module,exports){ | |
23929 | var baseEach = require('./_baseEach'); | |
23930 | ||
23931 | /** | |
23932 | * The base implementation of `_.every` without support for iteratee shorthands. | |
23933 | * | |
23934 | * @private | |
23935 | * @param {Array|Object} collection The collection to iterate over. | |
23936 | * @param {Function} predicate The function invoked per iteration. | |
23937 | * @returns {boolean} Returns `true` if all elements pass the predicate check, | |
23938 | * else `false` | |
23939 | */ | |
23940 | function baseEvery(collection, predicate) { | |
23941 | var result = true; | |
23942 | baseEach(collection, function(value, index, collection) { | |
23943 | result = !!predicate(value, index, collection); | |
23944 | return result; | |
23945 | }); | |
23946 | return result; | |
23947 | } | |
23948 | ||
23949 | module.exports = baseEvery; | |
23950 | ||
23951 | },{"./_baseEach":176}],178:[function(require,module,exports){ | |
23952 | /** | |
23953 | * The base implementation of `_.findIndex` and `_.findLastIndex` without | |
23954 | * support for iteratee shorthands. | |
23955 | * | |
23956 | * @private | |
23957 | * @param {Array} array The array to inspect. | |
23958 | * @param {Function} predicate The function invoked per iteration. | |
23959 | * @param {number} fromIndex The index to search from. | |
23960 | * @param {boolean} [fromRight] Specify iterating from right to left. | |
23961 | * @returns {number} Returns the index of the matched value, else `-1`. | |
23962 | */ | |
23963 | function baseFindIndex(array, predicate, fromIndex, fromRight) { | |
23964 | var length = array.length, | |
23965 | index = fromIndex + (fromRight ? 1 : -1); | |
23966 | ||
23967 | while ((fromRight ? index-- : ++index < length)) { | |
23968 | if (predicate(array[index], index, array)) { | |
23969 | return index; | |
23970 | } | |
23971 | } | |
23972 | return -1; | |
23973 | } | |
23974 | ||
23975 | module.exports = baseFindIndex; | |
23976 | ||
23977 | },{}],179:[function(require,module,exports){ | |
23978 | var arrayPush = require('./_arrayPush'), | |
23979 | isFlattenable = require('./_isFlattenable'); | |
23980 | ||
23981 | /** | |
23982 | * The base implementation of `_.flatten` with support for restricting flattening. | |
23983 | * | |
23984 | * @private | |
23985 | * @param {Array} array The array to flatten. | |
23986 | * @param {number} depth The maximum recursion depth. | |
23987 | * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. | |
23988 | * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. | |
23989 | * @param {Array} [result=[]] The initial result value. | |
23990 | * @returns {Array} Returns the new flattened array. | |
23991 | */ | |
23992 | function baseFlatten(array, depth, predicate, isStrict, result) { | |
23993 | var index = -1, | |
23994 | length = array.length; | |
23995 | ||
23996 | predicate || (predicate = isFlattenable); | |
23997 | result || (result = []); | |
23998 | ||
23999 | while (++index < length) { | |
24000 | var value = array[index]; | |
24001 | if (depth > 0 && predicate(value)) { | |
24002 | if (depth > 1) { | |
24003 | // Recursively flatten arrays (susceptible to call stack limits). | |
24004 | baseFlatten(value, depth - 1, predicate, isStrict, result); | |
24005 | } else { | |
24006 | arrayPush(result, value); | |
24007 | } | |
24008 | } else if (!isStrict) { | |
24009 | result[result.length] = value; | |
24010 | } | |
24011 | } | |
24012 | return result; | |
24013 | } | |
24014 | ||
24015 | module.exports = baseFlatten; | |
24016 | ||
24017 | },{"./_arrayPush":165,"./_isFlattenable":262}],180:[function(require,module,exports){ | |
24018 | var createBaseFor = require('./_createBaseFor'); | |
24019 | ||
24020 | /** | |
24021 | * The base implementation of `baseForOwn` which iterates over `object` | |
24022 | * properties returned by `keysFunc` and invokes `iteratee` for each property. | |
24023 | * Iteratee functions may exit iteration early by explicitly returning `false`. | |
24024 | * | |
24025 | * @private | |
24026 | * @param {Object} object The object to iterate over. | |
24027 | * @param {Function} iteratee The function invoked per iteration. | |
24028 | * @param {Function} keysFunc The function to get the keys of `object`. | |
24029 | * @returns {Object} Returns `object`. | |
24030 | */ | |
24031 | var baseFor = createBaseFor(); | |
24032 | ||
24033 | module.exports = baseFor; | |
24034 | ||
24035 | },{"./_createBaseFor":233}],181:[function(require,module,exports){ | |
24036 | var baseFor = require('./_baseFor'), | |
24037 | keys = require('./keys'); | |
24038 | ||
24039 | /** | |
24040 | * The base implementation of `_.forOwn` without support for iteratee shorthands. | |
24041 | * | |
24042 | * @private | |
24043 | * @param {Object} object The object to iterate over. | |
24044 | * @param {Function} iteratee The function invoked per iteration. | |
24045 | * @returns {Object} Returns `object`. | |
24046 | */ | |
24047 | function baseForOwn(object, iteratee) { | |
24048 | return object && baseFor(object, iteratee, keys); | |
24049 | } | |
24050 | ||
24051 | module.exports = baseForOwn; | |
24052 | ||
24053 | },{"./_baseFor":180,"./keys":341}],182:[function(require,module,exports){ | |
24054 | var castPath = require('./_castPath'), | |
24055 | toKey = require('./_toKey'); | |
24056 | ||
24057 | /** | |
24058 | * The base implementation of `_.get` without support for default values. | |
24059 | * | |
24060 | * @private | |
24061 | * @param {Object} object The object to query. | |
24062 | * @param {Array|string} path The path of the property to get. | |
24063 | * @returns {*} Returns the resolved value. | |
24064 | */ | |
24065 | function baseGet(object, path) { | |
24066 | path = castPath(path, object); | |
24067 | ||
24068 | var index = 0, | |
24069 | length = path.length; | |
24070 | ||
24071 | while (object != null && index < length) { | |
24072 | object = object[toKey(path[index++])]; | |
24073 | } | |
24074 | return (index && index == length) ? object : undefined; | |
24075 | } | |
24076 | ||
24077 | module.exports = baseGet; | |
24078 | ||
24079 | },{"./_castPath":217,"./_toKey":305}],183:[function(require,module,exports){ | |
24080 | var arrayPush = require('./_arrayPush'), | |
24081 | isArray = require('./isArray'); | |
24082 | ||
24083 | /** | |
24084 | * The base implementation of `getAllKeys` and `getAllKeysIn` which uses | |
24085 | * `keysFunc` and `symbolsFunc` to get the enumerable property names and | |
24086 | * symbols of `object`. | |
24087 | * | |
24088 | * @private | |
24089 | * @param {Object} object The object to query. | |
24090 | * @param {Function} keysFunc The function to get the keys of `object`. | |
24091 | * @param {Function} symbolsFunc The function to get the symbols of `object`. | |
24092 | * @returns {Array} Returns the array of property names and symbols. | |
24093 | */ | |
24094 | function baseGetAllKeys(object, keysFunc, symbolsFunc) { | |
24095 | var result = keysFunc(object); | |
24096 | return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); | |
24097 | } | |
24098 | ||
24099 | module.exports = baseGetAllKeys; | |
24100 | ||
24101 | },{"./_arrayPush":165,"./isArray":323}],184:[function(require,module,exports){ | |
24102 | var Symbol = require('./_Symbol'), | |
24103 | getRawTag = require('./_getRawTag'), | |
24104 | objectToString = require('./_objectToString'); | |
24105 | ||
24106 | /** `Object#toString` result references. */ | |
24107 | var nullTag = '[object Null]', | |
24108 | undefinedTag = '[object Undefined]'; | |
24109 | ||
24110 | /** Built-in value references. */ | |
24111 | var symToStringTag = Symbol ? Symbol.toStringTag : undefined; | |
24112 | ||
24113 | /** | |
24114 | * The base implementation of `getTag` without fallbacks for buggy environments. | |
24115 | * | |
24116 | * @private | |
24117 | * @param {*} value The value to query. | |
24118 | * @returns {string} Returns the `toStringTag`. | |
24119 | */ | |
24120 | function baseGetTag(value) { | |
24121 | if (value == null) { | |
24122 | return value === undefined ? undefinedTag : nullTag; | |
24123 | } | |
24124 | return (symToStringTag && symToStringTag in Object(value)) | |
24125 | ? getRawTag(value) | |
24126 | : objectToString(value); | |
24127 | } | |
24128 | ||
24129 | module.exports = baseGetTag; | |
24130 | ||
24131 | },{"./_Symbol":156,"./_getRawTag":247,"./_objectToString":287}],185:[function(require,module,exports){ | |
24132 | /** | |
24133 | * The base implementation of `_.hasIn` without support for deep paths. | |
24134 | * | |
24135 | * @private | |
24136 | * @param {Object} [object] The object to query. | |
24137 | * @param {Array|string} key The key to check. | |
24138 | * @returns {boolean} Returns `true` if `key` exists, else `false`. | |
24139 | */ | |
24140 | function baseHasIn(object, key) { | |
24141 | return object != null && key in Object(object); | |
24142 | } | |
24143 | ||
24144 | module.exports = baseHasIn; | |
24145 | ||
24146 | },{}],186:[function(require,module,exports){ | |
24147 | var baseFindIndex = require('./_baseFindIndex'), | |
24148 | baseIsNaN = require('./_baseIsNaN'), | |
24149 | strictIndexOf = require('./_strictIndexOf'); | |
24150 | ||
24151 | /** | |
24152 | * The base implementation of `_.indexOf` without `fromIndex` bounds checks. | |
24153 | * | |
24154 | * @private | |
24155 | * @param {Array} array The array to inspect. | |
24156 | * @param {*} value The value to search for. | |
24157 | * @param {number} fromIndex The index to search from. | |
24158 | * @returns {number} Returns the index of the matched value, else `-1`. | |
24159 | */ | |
24160 | function baseIndexOf(array, value, fromIndex) { | |
24161 | return value === value | |
24162 | ? strictIndexOf(array, value, fromIndex) | |
24163 | : baseFindIndex(array, baseIsNaN, fromIndex); | |
24164 | } | |
24165 | ||
24166 | module.exports = baseIndexOf; | |
24167 | ||
24168 | },{"./_baseFindIndex":178,"./_baseIsNaN":192,"./_strictIndexOf":301}],187:[function(require,module,exports){ | |
24169 | var baseGetTag = require('./_baseGetTag'), | |
24170 | isObjectLike = require('./isObjectLike'); | |
24171 | ||
24172 | /** `Object#toString` result references. */ | |
24173 | var argsTag = '[object Arguments]'; | |
24174 | ||
24175 | /** | |
24176 | * The base implementation of `_.isArguments`. | |
24177 | * | |
24178 | * @private | |
24179 | * @param {*} value The value to check. | |
24180 | * @returns {boolean} Returns `true` if `value` is an `arguments` object, | |
24181 | */ | |
24182 | function baseIsArguments(value) { | |
24183 | return isObjectLike(value) && baseGetTag(value) == argsTag; | |
24184 | } | |
24185 | ||
24186 | module.exports = baseIsArguments; | |
24187 | ||
24188 | },{"./_baseGetTag":184,"./isObjectLike":334}],188:[function(require,module,exports){ | |
24189 | var baseIsEqualDeep = require('./_baseIsEqualDeep'), | |
24190 | isObjectLike = require('./isObjectLike'); | |
24191 | ||
24192 | /** | |
24193 | * The base implementation of `_.isEqual` which supports partial comparisons | |
24194 | * and tracks traversed objects. | |
24195 | * | |
24196 | * @private | |
24197 | * @param {*} value The value to compare. | |
24198 | * @param {*} other The other value to compare. | |
24199 | * @param {boolean} bitmask The bitmask flags. | |
24200 | * 1 - Unordered comparison | |
24201 | * 2 - Partial comparison | |
24202 | * @param {Function} [customizer] The function to customize comparisons. | |
24203 | * @param {Object} [stack] Tracks traversed `value` and `other` objects. | |
24204 | * @returns {boolean} Returns `true` if the values are equivalent, else `false`. | |
24205 | */ | |
24206 | function baseIsEqual(value, other, bitmask, customizer, stack) { | |
24207 | if (value === other) { | |
24208 | return true; | |
24209 | } | |
24210 | if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { | |
24211 | return value !== value && other !== other; | |
24212 | } | |
24213 | return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); | |
24214 | } | |
24215 | ||
24216 | module.exports = baseIsEqual; | |
24217 | ||
24218 | },{"./_baseIsEqualDeep":189,"./isObjectLike":334}],189:[function(require,module,exports){ | |
24219 | var Stack = require('./_Stack'), | |
24220 | equalArrays = require('./_equalArrays'), | |
24221 | equalByTag = require('./_equalByTag'), | |
24222 | equalObjects = require('./_equalObjects'), | |
24223 | getTag = require('./_getTag'), | |
24224 | isArray = require('./isArray'), | |
24225 | isBuffer = require('./isBuffer'), | |
24226 | isTypedArray = require('./isTypedArray'); | |
24227 | ||
24228 | /** Used to compose bitmasks for value comparisons. */ | |
24229 | var COMPARE_PARTIAL_FLAG = 1; | |
24230 | ||
24231 | /** `Object#toString` result references. */ | |
24232 | var argsTag = '[object Arguments]', | |
24233 | arrayTag = '[object Array]', | |
24234 | objectTag = '[object Object]'; | |
24235 | ||
24236 | /** Used for built-in method references. */ | |
24237 | var objectProto = Object.prototype; | |
24238 | ||
24239 | /** Used to check objects for own properties. */ | |
24240 | var hasOwnProperty = objectProto.hasOwnProperty; | |
24241 | ||
24242 | /** | |
24243 | * A specialized version of `baseIsEqual` for arrays and objects which performs | |
24244 | * deep comparisons and tracks traversed objects enabling objects with circular | |
24245 | * references to be compared. | |
24246 | * | |
24247 | * @private | |
24248 | * @param {Object} object The object to compare. | |
24249 | * @param {Object} other The other object to compare. | |
24250 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | |
24251 | * @param {Function} customizer The function to customize comparisons. | |
24252 | * @param {Function} equalFunc The function to determine equivalents of values. | |
24253 | * @param {Object} [stack] Tracks traversed `object` and `other` objects. | |
24254 | * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. | |
24255 | */ | |
24256 | function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { | |
24257 | var objIsArr = isArray(object), | |
24258 | othIsArr = isArray(other), | |
24259 | objTag = objIsArr ? arrayTag : getTag(object), | |
24260 | othTag = othIsArr ? arrayTag : getTag(other); | |
24261 | ||
24262 | objTag = objTag == argsTag ? objectTag : objTag; | |
24263 | othTag = othTag == argsTag ? objectTag : othTag; | |
24264 | ||
24265 | var objIsObj = objTag == objectTag, | |
24266 | othIsObj = othTag == objectTag, | |
24267 | isSameTag = objTag == othTag; | |
24268 | ||
24269 | if (isSameTag && isBuffer(object)) { | |
24270 | if (!isBuffer(other)) { | |
24271 | return false; | |
24272 | } | |
24273 | objIsArr = true; | |
24274 | objIsObj = false; | |
24275 | } | |
24276 | if (isSameTag && !objIsObj) { | |
24277 | stack || (stack = new Stack); | |
24278 | return (objIsArr || isTypedArray(object)) | |
24279 | ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) | |
24280 | : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); | |
24281 | } | |
24282 | if (!(bitmask & COMPARE_PARTIAL_FLAG)) { | |
24283 | var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), | |
24284 | othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); | |
24285 | ||
24286 | if (objIsWrapped || othIsWrapped) { | |
24287 | var objUnwrapped = objIsWrapped ? object.value() : object, | |
24288 | othUnwrapped = othIsWrapped ? other.value() : other; | |
24289 | ||
24290 | stack || (stack = new Stack); | |
24291 | return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); | |
24292 | } | |
24293 | } | |
24294 | if (!isSameTag) { | |
24295 | return false; | |
24296 | } | |
24297 | stack || (stack = new Stack); | |
24298 | return equalObjects(object, other, bitmask, customizer, equalFunc, stack); | |
24299 | } | |
24300 | ||
24301 | module.exports = baseIsEqualDeep; | |
24302 | ||
24303 | },{"./_Stack":155,"./_equalArrays":236,"./_equalByTag":237,"./_equalObjects":238,"./_getTag":250,"./isArray":323,"./isBuffer":326,"./isTypedArray":339}],190:[function(require,module,exports){ | |
24304 | var getTag = require('./_getTag'), | |
24305 | isObjectLike = require('./isObjectLike'); | |
24306 | ||
24307 | /** `Object#toString` result references. */ | |
24308 | var mapTag = '[object Map]'; | |
24309 | ||
24310 | /** | |
24311 | * The base implementation of `_.isMap` without Node.js optimizations. | |
24312 | * | |
24313 | * @private | |
24314 | * @param {*} value The value to check. | |
24315 | * @returns {boolean} Returns `true` if `value` is a map, else `false`. | |
24316 | */ | |
24317 | function baseIsMap(value) { | |
24318 | return isObjectLike(value) && getTag(value) == mapTag; | |
24319 | } | |
24320 | ||
24321 | module.exports = baseIsMap; | |
24322 | ||
24323 | },{"./_getTag":250,"./isObjectLike":334}],191:[function(require,module,exports){ | |
24324 | var Stack = require('./_Stack'), | |
24325 | baseIsEqual = require('./_baseIsEqual'); | |
24326 | ||
24327 | /** Used to compose bitmasks for value comparisons. */ | |
24328 | var COMPARE_PARTIAL_FLAG = 1, | |
24329 | COMPARE_UNORDERED_FLAG = 2; | |
24330 | ||
24331 | /** | |
24332 | * The base implementation of `_.isMatch` without support for iteratee shorthands. | |
24333 | * | |
24334 | * @private | |
24335 | * @param {Object} object The object to inspect. | |
24336 | * @param {Object} source The object of property values to match. | |
24337 | * @param {Array} matchData The property names, values, and compare flags to match. | |
24338 | * @param {Function} [customizer] The function to customize comparisons. | |
24339 | * @returns {boolean} Returns `true` if `object` is a match, else `false`. | |
24340 | */ | |
24341 | function baseIsMatch(object, source, matchData, customizer) { | |
24342 | var index = matchData.length, | |
24343 | length = index, | |
24344 | noCustomizer = !customizer; | |
24345 | ||
24346 | if (object == null) { | |
24347 | return !length; | |
24348 | } | |
24349 | object = Object(object); | |
24350 | while (index--) { | |
24351 | var data = matchData[index]; | |
24352 | if ((noCustomizer && data[2]) | |
24353 | ? data[1] !== object[data[0]] | |
24354 | : !(data[0] in object) | |
24355 | ) { | |
24356 | return false; | |
24357 | } | |
24358 | } | |
24359 | while (++index < length) { | |
24360 | data = matchData[index]; | |
24361 | var key = data[0], | |
24362 | objValue = object[key], | |
24363 | srcValue = data[1]; | |
24364 | ||
24365 | if (noCustomizer && data[2]) { | |
24366 | if (objValue === undefined && !(key in object)) { | |
24367 | return false; | |
24368 | } | |
24369 | } else { | |
24370 | var stack = new Stack; | |
24371 | if (customizer) { | |
24372 | var result = customizer(objValue, srcValue, key, object, source, stack); | |
24373 | } | |
24374 | if (!(result === undefined | |
24375 | ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) | |
24376 | : result | |
24377 | )) { | |
24378 | return false; | |
24379 | } | |
24380 | } | |
24381 | } | |
24382 | return true; | |
24383 | } | |
24384 | ||
24385 | module.exports = baseIsMatch; | |
24386 | ||
24387 | },{"./_Stack":155,"./_baseIsEqual":188}],192:[function(require,module,exports){ | |
24388 | /** | |
24389 | * The base implementation of `_.isNaN` without support for number objects. | |
24390 | * | |
24391 | * @private | |
24392 | * @param {*} value The value to check. | |
24393 | * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. | |
24394 | */ | |
24395 | function baseIsNaN(value) { | |
24396 | return value !== value; | |
24397 | } | |
24398 | ||
24399 | module.exports = baseIsNaN; | |
24400 | ||
24401 | },{}],193:[function(require,module,exports){ | |
24402 | var isFunction = require('./isFunction'), | |
24403 | isMasked = require('./_isMasked'), | |
24404 | isObject = require('./isObject'), | |
24405 | toSource = require('./_toSource'); | |
24406 | ||
24407 | /** | |
24408 | * Used to match `RegExp` | |
24409 | * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). | |
24410 | */ | |
24411 | var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; | |
24412 | ||
24413 | /** Used to detect host constructors (Safari). */ | |
24414 | var reIsHostCtor = /^\[object .+?Constructor\]$/; | |
24415 | ||
24416 | /** Used for built-in method references. */ | |
24417 | var funcProto = Function.prototype, | |
24418 | objectProto = Object.prototype; | |
24419 | ||
24420 | /** Used to resolve the decompiled source of functions. */ | |
24421 | var funcToString = funcProto.toString; | |
24422 | ||
24423 | /** Used to check objects for own properties. */ | |
24424 | var hasOwnProperty = objectProto.hasOwnProperty; | |
24425 | ||
24426 | /** Used to detect if a method is native. */ | |
24427 | var reIsNative = RegExp('^' + | |
24428 | funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') | |
24429 | .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' | |
24430 | ); | |
24431 | ||
24432 | /** | |
24433 | * The base implementation of `_.isNative` without bad shim checks. | |
24434 | * | |
24435 | * @private | |
24436 | * @param {*} value The value to check. | |
24437 | * @returns {boolean} Returns `true` if `value` is a native function, | |
24438 | * else `false`. | |
24439 | */ | |
24440 | function baseIsNative(value) { | |
24441 | if (!isObject(value) || isMasked(value)) { | |
24442 | return false; | |
24443 | } | |
24444 | var pattern = isFunction(value) ? reIsNative : reIsHostCtor; | |
24445 | return pattern.test(toSource(value)); | |
24446 | } | |
24447 | ||
24448 | module.exports = baseIsNative; | |
24449 | ||
24450 | },{"./_isMasked":267,"./_toSource":306,"./isFunction":328,"./isObject":333}],194:[function(require,module,exports){ | |
24451 | var getTag = require('./_getTag'), | |
24452 | isObjectLike = require('./isObjectLike'); | |
24453 | ||
24454 | /** `Object#toString` result references. */ | |
24455 | var setTag = '[object Set]'; | |
24456 | ||
24457 | /** | |
24458 | * The base implementation of `_.isSet` without Node.js optimizations. | |
24459 | * | |
24460 | * @private | |
24461 | * @param {*} value The value to check. | |
24462 | * @returns {boolean} Returns `true` if `value` is a set, else `false`. | |
24463 | */ | |
24464 | function baseIsSet(value) { | |
24465 | return isObjectLike(value) && getTag(value) == setTag; | |
24466 | } | |
24467 | ||
24468 | module.exports = baseIsSet; | |
24469 | ||
24470 | },{"./_getTag":250,"./isObjectLike":334}],195:[function(require,module,exports){ | |
24471 | var baseGetTag = require('./_baseGetTag'), | |
24472 | isLength = require('./isLength'), | |
24473 | isObjectLike = require('./isObjectLike'); | |
24474 | ||
24475 | /** `Object#toString` result references. */ | |
24476 | var argsTag = '[object Arguments]', | |
24477 | arrayTag = '[object Array]', | |
24478 | boolTag = '[object Boolean]', | |
24479 | dateTag = '[object Date]', | |
24480 | errorTag = '[object Error]', | |
24481 | funcTag = '[object Function]', | |
24482 | mapTag = '[object Map]', | |
24483 | numberTag = '[object Number]', | |
24484 | objectTag = '[object Object]', | |
24485 | regexpTag = '[object RegExp]', | |
24486 | setTag = '[object Set]', | |
24487 | stringTag = '[object String]', | |
24488 | weakMapTag = '[object WeakMap]'; | |
24489 | ||
24490 | var arrayBufferTag = '[object ArrayBuffer]', | |
24491 | dataViewTag = '[object DataView]', | |
24492 | float32Tag = '[object Float32Array]', | |
24493 | float64Tag = '[object Float64Array]', | |
24494 | int8Tag = '[object Int8Array]', | |
24495 | int16Tag = '[object Int16Array]', | |
24496 | int32Tag = '[object Int32Array]', | |
24497 | uint8Tag = '[object Uint8Array]', | |
24498 | uint8ClampedTag = '[object Uint8ClampedArray]', | |
24499 | uint16Tag = '[object Uint16Array]', | |
24500 | uint32Tag = '[object Uint32Array]'; | |
24501 | ||
24502 | /** Used to identify `toStringTag` values of typed arrays. */ | |
24503 | var typedArrayTags = {}; | |
24504 | typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = | |
24505 | typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = | |
24506 | typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = | |
24507 | typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = | |
24508 | typedArrayTags[uint32Tag] = true; | |
24509 | typedArrayTags[argsTag] = typedArrayTags[arrayTag] = | |
24510 | typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = | |
24511 | typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = | |
24512 | typedArrayTags[errorTag] = typedArrayTags[funcTag] = | |
24513 | typedArrayTags[mapTag] = typedArrayTags[numberTag] = | |
24514 | typedArrayTags[objectTag] = typedArrayTags[regexpTag] = | |
24515 | typedArrayTags[setTag] = typedArrayTags[stringTag] = | |
24516 | typedArrayTags[weakMapTag] = false; | |
24517 | ||
24518 | /** | |
24519 | * The base implementation of `_.isTypedArray` without Node.js optimizations. | |
24520 | * | |
24521 | * @private | |
24522 | * @param {*} value The value to check. | |
24523 | * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. | |
24524 | */ | |
24525 | function baseIsTypedArray(value) { | |
24526 | return isObjectLike(value) && | |
24527 | isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; | |
24528 | } | |
24529 | ||
24530 | module.exports = baseIsTypedArray; | |
24531 | ||
24532 | },{"./_baseGetTag":184,"./isLength":329,"./isObjectLike":334}],196:[function(require,module,exports){ | |
24533 | var baseMatches = require('./_baseMatches'), | |
24534 | baseMatchesProperty = require('./_baseMatchesProperty'), | |
24535 | identity = require('./identity'), | |
24536 | isArray = require('./isArray'), | |
24537 | property = require('./property'); | |
24538 | ||
24539 | /** | |
24540 | * The base implementation of `_.iteratee`. | |
24541 | * | |
24542 | * @private | |
24543 | * @param {*} [value=_.identity] The value to convert to an iteratee. | |
24544 | * @returns {Function} Returns the iteratee. | |
24545 | */ | |
24546 | function baseIteratee(value) { | |
24547 | // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. | |
24548 | // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. | |
24549 | if (typeof value == 'function') { | |
24550 | return value; | |
24551 | } | |
24552 | if (value == null) { | |
24553 | return identity; | |
24554 | } | |
24555 | if (typeof value == 'object') { | |
24556 | return isArray(value) | |
24557 | ? baseMatchesProperty(value[0], value[1]) | |
24558 | : baseMatches(value); | |
24559 | } | |
24560 | return property(value); | |
24561 | } | |
24562 | ||
24563 | module.exports = baseIteratee; | |
24564 | ||
24565 | },{"./_baseMatches":200,"./_baseMatchesProperty":201,"./identity":321,"./isArray":323,"./property":347}],197:[function(require,module,exports){ | |
24566 | var isPrototype = require('./_isPrototype'), | |
24567 | nativeKeys = require('./_nativeKeys'); | |
24568 | ||
24569 | /** Used for built-in method references. */ | |
24570 | var objectProto = Object.prototype; | |
24571 | ||
24572 | /** Used to check objects for own properties. */ | |
24573 | var hasOwnProperty = objectProto.hasOwnProperty; | |
24574 | ||
24575 | /** | |
24576 | * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. | |
24577 | * | |
24578 | * @private | |
24579 | * @param {Object} object The object to query. | |
24580 | * @returns {Array} Returns the array of property names. | |
24581 | */ | |
24582 | function baseKeys(object) { | |
24583 | if (!isPrototype(object)) { | |
24584 | return nativeKeys(object); | |
24585 | } | |
24586 | var result = []; | |
24587 | for (var key in Object(object)) { | |
24588 | if (hasOwnProperty.call(object, key) && key != 'constructor') { | |
24589 | result.push(key); | |
24590 | } | |
24591 | } | |
24592 | return result; | |
24593 | } | |
24594 | ||
24595 | module.exports = baseKeys; | |
24596 | ||
24597 | },{"./_isPrototype":268,"./_nativeKeys":284}],198:[function(require,module,exports){ | |
24598 | var isObject = require('./isObject'), | |
24599 | isPrototype = require('./_isPrototype'), | |
24600 | nativeKeysIn = require('./_nativeKeysIn'); | |
24601 | ||
24602 | /** Used for built-in method references. */ | |
24603 | var objectProto = Object.prototype; | |
24604 | ||
24605 | /** Used to check objects for own properties. */ | |
24606 | var hasOwnProperty = objectProto.hasOwnProperty; | |
24607 | ||
24608 | /** | |
24609 | * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. | |
24610 | * | |
24611 | * @private | |
24612 | * @param {Object} object The object to query. | |
24613 | * @returns {Array} Returns the array of property names. | |
24614 | */ | |
24615 | function baseKeysIn(object) { | |
24616 | if (!isObject(object)) { | |
24617 | return nativeKeysIn(object); | |
24618 | } | |
24619 | var isProto = isPrototype(object), | |
24620 | result = []; | |
24621 | ||
24622 | for (var key in object) { | |
24623 | if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { | |
24624 | result.push(key); | |
24625 | } | |
24626 | } | |
24627 | return result; | |
24628 | } | |
24629 | ||
24630 | module.exports = baseKeysIn; | |
24631 | ||
24632 | },{"./_isPrototype":268,"./_nativeKeysIn":285,"./isObject":333}],199:[function(require,module,exports){ | |
24633 | var baseEach = require('./_baseEach'), | |
24634 | isArrayLike = require('./isArrayLike'); | |
24635 | ||
24636 | /** | |
24637 | * The base implementation of `_.map` without support for iteratee shorthands. | |
24638 | * | |
24639 | * @private | |
24640 | * @param {Array|Object} collection The collection to iterate over. | |
24641 | * @param {Function} iteratee The function invoked per iteration. | |
24642 | * @returns {Array} Returns the new mapped array. | |
24643 | */ | |
24644 | function baseMap(collection, iteratee) { | |
24645 | var index = -1, | |
24646 | result = isArrayLike(collection) ? Array(collection.length) : []; | |
24647 | ||
24648 | baseEach(collection, function(value, key, collection) { | |
24649 | result[++index] = iteratee(value, key, collection); | |
24650 | }); | |
24651 | return result; | |
24652 | } | |
24653 | ||
24654 | module.exports = baseMap; | |
24655 | ||
24656 | },{"./_baseEach":176,"./isArrayLike":324}],200:[function(require,module,exports){ | |
24657 | var baseIsMatch = require('./_baseIsMatch'), | |
24658 | getMatchData = require('./_getMatchData'), | |
24659 | matchesStrictComparable = require('./_matchesStrictComparable'); | |
24660 | ||
24661 | /** | |
24662 | * The base implementation of `_.matches` which doesn't clone `source`. | |
24663 | * | |
24664 | * @private | |
24665 | * @param {Object} source The object of property values to match. | |
24666 | * @returns {Function} Returns the new spec function. | |
24667 | */ | |
24668 | function baseMatches(source) { | |
24669 | var matchData = getMatchData(source); | |
24670 | if (matchData.length == 1 && matchData[0][2]) { | |
24671 | return matchesStrictComparable(matchData[0][0], matchData[0][1]); | |
24672 | } | |
24673 | return function(object) { | |
24674 | return object === source || baseIsMatch(object, source, matchData); | |
24675 | }; | |
24676 | } | |
24677 | ||
24678 | module.exports = baseMatches; | |
24679 | ||
24680 | },{"./_baseIsMatch":191,"./_getMatchData":244,"./_matchesStrictComparable":281}],201:[function(require,module,exports){ | |
24681 | var baseIsEqual = require('./_baseIsEqual'), | |
24682 | get = require('./get'), | |
24683 | hasIn = require('./hasIn'), | |
24684 | isKey = require('./_isKey'), | |
24685 | isStrictComparable = require('./_isStrictComparable'), | |
24686 | matchesStrictComparable = require('./_matchesStrictComparable'), | |
24687 | toKey = require('./_toKey'); | |
24688 | ||
24689 | /** Used to compose bitmasks for value comparisons. */ | |
24690 | var COMPARE_PARTIAL_FLAG = 1, | |
24691 | COMPARE_UNORDERED_FLAG = 2; | |
24692 | ||
24693 | /** | |
24694 | * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. | |
24695 | * | |
24696 | * @private | |
24697 | * @param {string} path The path of the property to get. | |
24698 | * @param {*} srcValue The value to match. | |
24699 | * @returns {Function} Returns the new spec function. | |
24700 | */ | |
24701 | function baseMatchesProperty(path, srcValue) { | |
24702 | if (isKey(path) && isStrictComparable(srcValue)) { | |
24703 | return matchesStrictComparable(toKey(path), srcValue); | |
24704 | } | |
24705 | return function(object) { | |
24706 | var objValue = get(object, path); | |
24707 | return (objValue === undefined && objValue === srcValue) | |
24708 | ? hasIn(object, path) | |
24709 | : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); | |
24710 | }; | |
24711 | } | |
24712 | ||
24713 | module.exports = baseMatchesProperty; | |
24714 | ||
24715 | },{"./_baseIsEqual":188,"./_isKey":265,"./_isStrictComparable":269,"./_matchesStrictComparable":281,"./_toKey":305,"./get":319,"./hasIn":320}],202:[function(require,module,exports){ | |
24716 | var basePickBy = require('./_basePickBy'), | |
24717 | hasIn = require('./hasIn'); | |
24718 | ||
24719 | /** | |
24720 | * The base implementation of `_.pick` without support for individual | |
24721 | * property identifiers. | |
24722 | * | |
24723 | * @private | |
24724 | * @param {Object} object The source object. | |
24725 | * @param {string[]} paths The property paths to pick. | |
24726 | * @returns {Object} Returns the new object. | |
24727 | */ | |
24728 | function basePick(object, paths) { | |
24729 | return basePickBy(object, paths, function(value, path) { | |
24730 | return hasIn(object, path); | |
24731 | }); | |
24732 | } | |
24733 | ||
24734 | module.exports = basePick; | |
24735 | ||
24736 | },{"./_basePickBy":203,"./hasIn":320}],203:[function(require,module,exports){ | |
24737 | var baseGet = require('./_baseGet'), | |
24738 | baseSet = require('./_baseSet'), | |
24739 | castPath = require('./_castPath'); | |
24740 | ||
24741 | /** | |
24742 | * The base implementation of `_.pickBy` without support for iteratee shorthands. | |
24743 | * | |
24744 | * @private | |
24745 | * @param {Object} object The source object. | |
24746 | * @param {string[]} paths The property paths to pick. | |
24747 | * @param {Function} predicate The function invoked per property. | |
24748 | * @returns {Object} Returns the new object. | |
24749 | */ | |
24750 | function basePickBy(object, paths, predicate) { | |
24751 | var index = -1, | |
24752 | length = paths.length, | |
24753 | result = {}; | |
24754 | ||
24755 | while (++index < length) { | |
24756 | var path = paths[index], | |
24757 | value = baseGet(object, path); | |
24758 | ||
24759 | if (predicate(value, path)) { | |
24760 | baseSet(result, castPath(path, object), value); | |
24761 | } | |
24762 | } | |
24763 | return result; | |
24764 | } | |
24765 | ||
24766 | module.exports = basePickBy; | |
24767 | ||
24768 | },{"./_baseGet":182,"./_baseSet":208,"./_castPath":217}],204:[function(require,module,exports){ | |
24769 | /** | |
24770 | * The base implementation of `_.property` without support for deep paths. | |
24771 | * | |
24772 | * @private | |
24773 | * @param {string} key The key of the property to get. | |
24774 | * @returns {Function} Returns the new accessor function. | |
24775 | */ | |
24776 | function baseProperty(key) { | |
24777 | return function(object) { | |
24778 | return object == null ? undefined : object[key]; | |
24779 | }; | |
24780 | } | |
24781 | ||
24782 | module.exports = baseProperty; | |
24783 | ||
24784 | },{}],205:[function(require,module,exports){ | |
24785 | var baseGet = require('./_baseGet'); | |
24786 | ||
24787 | /** | |
24788 | * A specialized version of `baseProperty` which supports deep paths. | |
24789 | * | |
24790 | * @private | |
24791 | * @param {Array|string} path The path of the property to get. | |
24792 | * @returns {Function} Returns the new accessor function. | |
24793 | */ | |
24794 | function basePropertyDeep(path) { | |
24795 | return function(object) { | |
24796 | return baseGet(object, path); | |
24797 | }; | |
24798 | } | |
24799 | ||
24800 | module.exports = basePropertyDeep; | |
24801 | ||
24802 | },{"./_baseGet":182}],206:[function(require,module,exports){ | |
24803 | /** Used as references for various `Number` constants. */ | |
24804 | var MAX_SAFE_INTEGER = 9007199254740991; | |
24805 | ||
24806 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
24807 | var nativeFloor = Math.floor; | |
24808 | ||
24809 | /** | |
24810 | * The base implementation of `_.repeat` which doesn't coerce arguments. | |
24811 | * | |
24812 | * @private | |
24813 | * @param {string} string The string to repeat. | |
24814 | * @param {number} n The number of times to repeat the string. | |
24815 | * @returns {string} Returns the repeated string. | |
24816 | */ | |
24817 | function baseRepeat(string, n) { | |
24818 | var result = ''; | |
24819 | if (!string || n < 1 || n > MAX_SAFE_INTEGER) { | |
24820 | return result; | |
24821 | } | |
24822 | // Leverage the exponentiation by squaring algorithm for a faster repeat. | |
24823 | // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. | |
24824 | do { | |
24825 | if (n % 2) { | |
24826 | result += string; | |
24827 | } | |
24828 | n = nativeFloor(n / 2); | |
24829 | if (n) { | |
24830 | string += string; | |
24831 | } | |
24832 | } while (n); | |
24833 | ||
24834 | return result; | |
24835 | } | |
24836 | ||
24837 | module.exports = baseRepeat; | |
24838 | ||
24839 | },{}],207:[function(require,module,exports){ | |
24840 | var identity = require('./identity'), | |
24841 | overRest = require('./_overRest'), | |
24842 | setToString = require('./_setToString'); | |
24843 | ||
24844 | /** | |
24845 | * The base implementation of `_.rest` which doesn't validate or coerce arguments. | |
24846 | * | |
24847 | * @private | |
24848 | * @param {Function} func The function to apply a rest parameter to. | |
24849 | * @param {number} [start=func.length-1] The start position of the rest parameter. | |
24850 | * @returns {Function} Returns the new function. | |
24851 | */ | |
24852 | function baseRest(func, start) { | |
24853 | return setToString(overRest(func, start, identity), func + ''); | |
24854 | } | |
24855 | ||
24856 | module.exports = baseRest; | |
24857 | ||
24858 | },{"./_overRest":289,"./_setToString":294,"./identity":321}],208:[function(require,module,exports){ | |
24859 | var assignValue = require('./_assignValue'), | |
24860 | castPath = require('./_castPath'), | |
24861 | isIndex = require('./_isIndex'), | |
24862 | isObject = require('./isObject'), | |
24863 | toKey = require('./_toKey'); | |
24864 | ||
24865 | /** | |
24866 | * The base implementation of `_.set`. | |
24867 | * | |
24868 | * @private | |
24869 | * @param {Object} object The object to modify. | |
24870 | * @param {Array|string} path The path of the property to set. | |
24871 | * @param {*} value The value to set. | |
24872 | * @param {Function} [customizer] The function to customize path creation. | |
24873 | * @returns {Object} Returns `object`. | |
24874 | */ | |
24875 | function baseSet(object, path, value, customizer) { | |
24876 | if (!isObject(object)) { | |
24877 | return object; | |
24878 | } | |
24879 | path = castPath(path, object); | |
24880 | ||
24881 | var index = -1, | |
24882 | length = path.length, | |
24883 | lastIndex = length - 1, | |
24884 | nested = object; | |
24885 | ||
24886 | while (nested != null && ++index < length) { | |
24887 | var key = toKey(path[index]), | |
24888 | newValue = value; | |
24889 | ||
24890 | if (index != lastIndex) { | |
24891 | var objValue = nested[key]; | |
24892 | newValue = customizer ? customizer(objValue, key, nested) : undefined; | |
24893 | if (newValue === undefined) { | |
24894 | newValue = isObject(objValue) | |
24895 | ? objValue | |
24896 | : (isIndex(path[index + 1]) ? [] : {}); | |
24897 | } | |
24898 | } | |
24899 | assignValue(nested, key, newValue); | |
24900 | nested = nested[key]; | |
24901 | } | |
24902 | return object; | |
24903 | } | |
24904 | ||
24905 | module.exports = baseSet; | |
24906 | ||
24907 | },{"./_assignValue":169,"./_castPath":217,"./_isIndex":263,"./_toKey":305,"./isObject":333}],209:[function(require,module,exports){ | |
24908 | var constant = require('./constant'), | |
24909 | defineProperty = require('./_defineProperty'), | |
24910 | identity = require('./identity'); | |
24911 | ||
24912 | /** | |
24913 | * The base implementation of `setToString` without support for hot loop shorting. | |
24914 | * | |
24915 | * @private | |
24916 | * @param {Function} func The function to modify. | |
24917 | * @param {Function} string The `toString` result. | |
24918 | * @returns {Function} Returns `func`. | |
24919 | */ | |
24920 | var baseSetToString = !defineProperty ? identity : function(func, string) { | |
24921 | return defineProperty(func, 'toString', { | |
24922 | 'configurable': true, | |
24923 | 'enumerable': false, | |
24924 | 'value': constant(string), | |
24925 | 'writable': true | |
24926 | }); | |
24927 | }; | |
24928 | ||
24929 | module.exports = baseSetToString; | |
24930 | ||
24931 | },{"./_defineProperty":235,"./constant":311,"./identity":321}],210:[function(require,module,exports){ | |
24932 | /** | |
24933 | * The base implementation of `_.slice` without an iteratee call guard. | |
24934 | * | |
24935 | * @private | |
24936 | * @param {Array} array The array to slice. | |
24937 | * @param {number} [start=0] The start position. | |
24938 | * @param {number} [end=array.length] The end position. | |
24939 | * @returns {Array} Returns the slice of `array`. | |
24940 | */ | |
24941 | function baseSlice(array, start, end) { | |
24942 | var index = -1, | |
24943 | length = array.length; | |
24944 | ||
24945 | if (start < 0) { | |
24946 | start = -start > length ? 0 : (length + start); | |
24947 | } | |
24948 | end = end > length ? length : end; | |
24949 | if (end < 0) { | |
24950 | end += length; | |
24951 | } | |
24952 | length = start > end ? 0 : ((end - start) >>> 0); | |
24953 | start >>>= 0; | |
24954 | ||
24955 | var result = Array(length); | |
24956 | while (++index < length) { | |
24957 | result[index] = array[index + start]; | |
24958 | } | |
24959 | return result; | |
24960 | } | |
24961 | ||
24962 | module.exports = baseSlice; | |
24963 | ||
24964 | },{}],211:[function(require,module,exports){ | |
24965 | /** | |
24966 | * The base implementation of `_.times` without support for iteratee shorthands | |
24967 | * or max array length checks. | |
24968 | * | |
24969 | * @private | |
24970 | * @param {number} n The number of times to invoke `iteratee`. | |
24971 | * @param {Function} iteratee The function invoked per iteration. | |
24972 | * @returns {Array} Returns the array of results. | |
24973 | */ | |
24974 | function baseTimes(n, iteratee) { | |
24975 | var index = -1, | |
24976 | result = Array(n); | |
24977 | ||
24978 | while (++index < n) { | |
24979 | result[index] = iteratee(index); | |
24980 | } | |
24981 | return result; | |
24982 | } | |
24983 | ||
24984 | module.exports = baseTimes; | |
24985 | ||
24986 | },{}],212:[function(require,module,exports){ | |
24987 | var Symbol = require('./_Symbol'), | |
24988 | arrayMap = require('./_arrayMap'), | |
24989 | isArray = require('./isArray'), | |
24990 | isSymbol = require('./isSymbol'); | |
24991 | ||
24992 | /** Used as references for various `Number` constants. */ | |
24993 | var INFINITY = 1 / 0; | |
24994 | ||
24995 | /** Used to convert symbols to primitives and strings. */ | |
24996 | var symbolProto = Symbol ? Symbol.prototype : undefined, | |
24997 | symbolToString = symbolProto ? symbolProto.toString : undefined; | |
24998 | ||
24999 | /** | |
25000 | * The base implementation of `_.toString` which doesn't convert nullish | |
25001 | * values to empty strings. | |
25002 | * | |
25003 | * @private | |
25004 | * @param {*} value The value to process. | |
25005 | * @returns {string} Returns the string. | |
25006 | */ | |
25007 | function baseToString(value) { | |
25008 | // Exit early for strings to avoid a performance hit in some environments. | |
25009 | if (typeof value == 'string') { | |
25010 | return value; | |
25011 | } | |
25012 | if (isArray(value)) { | |
25013 | // Recursively convert values (susceptible to call stack limits). | |
25014 | return arrayMap(value, baseToString) + ''; | |
25015 | } | |
25016 | if (isSymbol(value)) { | |
25017 | return symbolToString ? symbolToString.call(value) : ''; | |
25018 | } | |
25019 | var result = (value + ''); | |
25020 | return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; | |
25021 | } | |
25022 | ||
25023 | module.exports = baseToString; | |
25024 | ||
25025 | },{"./_Symbol":156,"./_arrayMap":164,"./isArray":323,"./isSymbol":338}],213:[function(require,module,exports){ | |
25026 | /** | |
25027 | * The base implementation of `_.unary` without support for storing metadata. | |
25028 | * | |
25029 | * @private | |
25030 | * @param {Function} func The function to cap arguments for. | |
25031 | * @returns {Function} Returns the new capped function. | |
25032 | */ | |
25033 | function baseUnary(func) { | |
25034 | return function(value) { | |
25035 | return func(value); | |
25036 | }; | |
25037 | } | |
25038 | ||
25039 | module.exports = baseUnary; | |
25040 | ||
25041 | },{}],214:[function(require,module,exports){ | |
25042 | var arrayMap = require('./_arrayMap'); | |
25043 | ||
25044 | /** | |
25045 | * The base implementation of `_.values` and `_.valuesIn` which creates an | |
25046 | * array of `object` property values corresponding to the property names | |
25047 | * of `props`. | |
25048 | * | |
25049 | * @private | |
25050 | * @param {Object} object The object to query. | |
25051 | * @param {Array} props The property names to get values for. | |
25052 | * @returns {Object} Returns the array of property values. | |
25053 | */ | |
25054 | function baseValues(object, props) { | |
25055 | return arrayMap(props, function(key) { | |
25056 | return object[key]; | |
25057 | }); | |
25058 | } | |
25059 | ||
25060 | module.exports = baseValues; | |
25061 | ||
25062 | },{"./_arrayMap":164}],215:[function(require,module,exports){ | |
25063 | /** | |
25064 | * Checks if a `cache` value for `key` exists. | |
25065 | * | |
25066 | * @private | |
25067 | * @param {Object} cache The cache to query. | |
25068 | * @param {string} key The key of the entry to check. | |
25069 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | |
25070 | */ | |
25071 | function cacheHas(cache, key) { | |
25072 | return cache.has(key); | |
25073 | } | |
25074 | ||
25075 | module.exports = cacheHas; | |
25076 | ||
25077 | },{}],216:[function(require,module,exports){ | |
25078 | var identity = require('./identity'); | |
25079 | ||
25080 | /** | |
25081 | * Casts `value` to `identity` if it's not a function. | |
25082 | * | |
25083 | * @private | |
25084 | * @param {*} value The value to inspect. | |
25085 | * @returns {Function} Returns cast function. | |
25086 | */ | |
25087 | function castFunction(value) { | |
25088 | return typeof value == 'function' ? value : identity; | |
25089 | } | |
25090 | ||
25091 | module.exports = castFunction; | |
25092 | ||
25093 | },{"./identity":321}],217:[function(require,module,exports){ | |
25094 | var isArray = require('./isArray'), | |
25095 | isKey = require('./_isKey'), | |
25096 | stringToPath = require('./_stringToPath'), | |
25097 | toString = require('./toString'); | |
25098 | ||
25099 | /** | |
25100 | * Casts `value` to a path array if it's not one. | |
25101 | * | |
25102 | * @private | |
25103 | * @param {*} value The value to inspect. | |
25104 | * @param {Object} [object] The object to query keys on. | |
25105 | * @returns {Array} Returns the cast property path array. | |
25106 | */ | |
25107 | function castPath(value, object) { | |
25108 | if (isArray(value)) { | |
25109 | return value; | |
25110 | } | |
25111 | return isKey(value, object) ? [value] : stringToPath(toString(value)); | |
25112 | } | |
25113 | ||
25114 | module.exports = castPath; | |
25115 | ||
25116 | },{"./_isKey":265,"./_stringToPath":304,"./isArray":323,"./toString":354}],218:[function(require,module,exports){ | |
25117 | var baseSlice = require('./_baseSlice'); | |
25118 | ||
25119 | /** | |
25120 | * Casts `array` to a slice if it's needed. | |
25121 | * | |
25122 | * @private | |
25123 | * @param {Array} array The array to inspect. | |
25124 | * @param {number} start The start position. | |
25125 | * @param {number} [end=array.length] The end position. | |
25126 | * @returns {Array} Returns the cast slice. | |
25127 | */ | |
25128 | function castSlice(array, start, end) { | |
25129 | var length = array.length; | |
25130 | end = end === undefined ? length : end; | |
25131 | return (!start && end >= length) ? array : baseSlice(array, start, end); | |
25132 | } | |
25133 | ||
25134 | module.exports = castSlice; | |
25135 | ||
25136 | },{"./_baseSlice":210}],219:[function(require,module,exports){ | |
25137 | var baseIndexOf = require('./_baseIndexOf'); | |
25138 | ||
25139 | /** | |
25140 | * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol | |
25141 | * that is not found in the character symbols. | |
25142 | * | |
25143 | * @private | |
25144 | * @param {Array} strSymbols The string symbols to inspect. | |
25145 | * @param {Array} chrSymbols The character symbols to find. | |
25146 | * @returns {number} Returns the index of the last unmatched string symbol. | |
25147 | */ | |
25148 | function charsEndIndex(strSymbols, chrSymbols) { | |
25149 | var index = strSymbols.length; | |
25150 | ||
25151 | while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} | |
25152 | return index; | |
25153 | } | |
25154 | ||
25155 | module.exports = charsEndIndex; | |
25156 | ||
25157 | },{"./_baseIndexOf":186}],220:[function(require,module,exports){ | |
25158 | var Uint8Array = require('./_Uint8Array'); | |
25159 | ||
25160 | /** | |
25161 | * Creates a clone of `arrayBuffer`. | |
25162 | * | |
25163 | * @private | |
25164 | * @param {ArrayBuffer} arrayBuffer The array buffer to clone. | |
25165 | * @returns {ArrayBuffer} Returns the cloned array buffer. | |
25166 | */ | |
25167 | function cloneArrayBuffer(arrayBuffer) { | |
25168 | var result = new arrayBuffer.constructor(arrayBuffer.byteLength); | |
25169 | new Uint8Array(result).set(new Uint8Array(arrayBuffer)); | |
25170 | return result; | |
25171 | } | |
25172 | ||
25173 | module.exports = cloneArrayBuffer; | |
25174 | ||
25175 | },{"./_Uint8Array":157}],221:[function(require,module,exports){ | |
25176 | var root = require('./_root'); | |
25177 | ||
25178 | /** Detect free variable `exports`. */ | |
25179 | var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; | |
25180 | ||
25181 | /** Detect free variable `module`. */ | |
25182 | var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; | |
25183 | ||
25184 | /** Detect the popular CommonJS extension `module.exports`. */ | |
25185 | var moduleExports = freeModule && freeModule.exports === freeExports; | |
25186 | ||
25187 | /** Built-in value references. */ | |
25188 | var Buffer = moduleExports ? root.Buffer : undefined, | |
25189 | allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined; | |
25190 | ||
25191 | /** | |
25192 | * Creates a clone of `buffer`. | |
25193 | * | |
25194 | * @private | |
25195 | * @param {Buffer} buffer The buffer to clone. | |
25196 | * @param {boolean} [isDeep] Specify a deep clone. | |
25197 | * @returns {Buffer} Returns the cloned buffer. | |
25198 | */ | |
25199 | function cloneBuffer(buffer, isDeep) { | |
25200 | if (isDeep) { | |
25201 | return buffer.slice(); | |
25202 | } | |
25203 | var length = buffer.length, | |
25204 | result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); | |
25205 | ||
25206 | buffer.copy(result); | |
25207 | return result; | |
25208 | } | |
25209 | ||
25210 | module.exports = cloneBuffer; | |
25211 | ||
25212 | },{"./_root":290}],222:[function(require,module,exports){ | |
25213 | var cloneArrayBuffer = require('./_cloneArrayBuffer'); | |
25214 | ||
25215 | /** | |
25216 | * Creates a clone of `dataView`. | |
25217 | * | |
25218 | * @private | |
25219 | * @param {Object} dataView The data view to clone. | |
25220 | * @param {boolean} [isDeep] Specify a deep clone. | |
25221 | * @returns {Object} Returns the cloned data view. | |
25222 | */ | |
25223 | function cloneDataView(dataView, isDeep) { | |
25224 | var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; | |
25225 | return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); | |
25226 | } | |
25227 | ||
25228 | module.exports = cloneDataView; | |
25229 | ||
25230 | },{"./_cloneArrayBuffer":220}],223:[function(require,module,exports){ | |
25231 | /** Used to match `RegExp` flags from their coerced string values. */ | |
25232 | var reFlags = /\w*$/; | |
25233 | ||
25234 | /** | |
25235 | * Creates a clone of `regexp`. | |
25236 | * | |
25237 | * @private | |
25238 | * @param {Object} regexp The regexp to clone. | |
25239 | * @returns {Object} Returns the cloned regexp. | |
25240 | */ | |
25241 | function cloneRegExp(regexp) { | |
25242 | var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); | |
25243 | result.lastIndex = regexp.lastIndex; | |
25244 | return result; | |
25245 | } | |
25246 | ||
25247 | module.exports = cloneRegExp; | |
25248 | ||
25249 | },{}],224:[function(require,module,exports){ | |
25250 | var Symbol = require('./_Symbol'); | |
25251 | ||
25252 | /** Used to convert symbols to primitives and strings. */ | |
25253 | var symbolProto = Symbol ? Symbol.prototype : undefined, | |
25254 | symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; | |
25255 | ||
25256 | /** | |
25257 | * Creates a clone of the `symbol` object. | |
25258 | * | |
25259 | * @private | |
25260 | * @param {Object} symbol The symbol object to clone. | |
25261 | * @returns {Object} Returns the cloned symbol object. | |
25262 | */ | |
25263 | function cloneSymbol(symbol) { | |
25264 | return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; | |
25265 | } | |
25266 | ||
25267 | module.exports = cloneSymbol; | |
25268 | ||
25269 | },{"./_Symbol":156}],225:[function(require,module,exports){ | |
25270 | var cloneArrayBuffer = require('./_cloneArrayBuffer'); | |
25271 | ||
25272 | /** | |
25273 | * Creates a clone of `typedArray`. | |
25274 | * | |
25275 | * @private | |
25276 | * @param {Object} typedArray The typed array to clone. | |
25277 | * @param {boolean} [isDeep] Specify a deep clone. | |
25278 | * @returns {Object} Returns the cloned typed array. | |
25279 | */ | |
25280 | function cloneTypedArray(typedArray, isDeep) { | |
25281 | var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; | |
25282 | return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); | |
25283 | } | |
25284 | ||
25285 | module.exports = cloneTypedArray; | |
25286 | ||
25287 | },{"./_cloneArrayBuffer":220}],226:[function(require,module,exports){ | |
25288 | /** | |
25289 | * Copies the values of `source` to `array`. | |
25290 | * | |
25291 | * @private | |
25292 | * @param {Array} source The array to copy values from. | |
25293 | * @param {Array} [array=[]] The array to copy values to. | |
25294 | * @returns {Array} Returns `array`. | |
25295 | */ | |
25296 | function copyArray(source, array) { | |
25297 | var index = -1, | |
25298 | length = source.length; | |
25299 | ||
25300 | array || (array = Array(length)); | |
25301 | while (++index < length) { | |
25302 | array[index] = source[index]; | |
25303 | } | |
25304 | return array; | |
25305 | } | |
25306 | ||
25307 | module.exports = copyArray; | |
25308 | ||
25309 | },{}],227:[function(require,module,exports){ | |
25310 | var assignValue = require('./_assignValue'), | |
25311 | baseAssignValue = require('./_baseAssignValue'); | |
25312 | ||
25313 | /** | |
25314 | * Copies properties of `source` to `object`. | |
25315 | * | |
25316 | * @private | |
25317 | * @param {Object} source The object to copy properties from. | |
25318 | * @param {Array} props The property identifiers to copy. | |
25319 | * @param {Object} [object={}] The object to copy properties to. | |
25320 | * @param {Function} [customizer] The function to customize copied values. | |
25321 | * @returns {Object} Returns `object`. | |
25322 | */ | |
25323 | function copyObject(source, props, object, customizer) { | |
25324 | var isNew = !object; | |
25325 | object || (object = {}); | |
25326 | ||
25327 | var index = -1, | |
25328 | length = props.length; | |
25329 | ||
25330 | while (++index < length) { | |
25331 | var key = props[index]; | |
25332 | ||
25333 | var newValue = customizer | |
25334 | ? customizer(object[key], source[key], key, object, source) | |
25335 | : undefined; | |
25336 | ||
25337 | if (newValue === undefined) { | |
25338 | newValue = source[key]; | |
25339 | } | |
25340 | if (isNew) { | |
25341 | baseAssignValue(object, key, newValue); | |
25342 | } else { | |
25343 | assignValue(object, key, newValue); | |
25344 | } | |
25345 | } | |
25346 | return object; | |
25347 | } | |
25348 | ||
25349 | module.exports = copyObject; | |
25350 | ||
25351 | },{"./_assignValue":169,"./_baseAssignValue":173}],228:[function(require,module,exports){ | |
25352 | var copyObject = require('./_copyObject'), | |
25353 | getSymbols = require('./_getSymbols'); | |
25354 | ||
25355 | /** | |
25356 | * Copies own symbols of `source` to `object`. | |
25357 | * | |
25358 | * @private | |
25359 | * @param {Object} source The object to copy symbols from. | |
25360 | * @param {Object} [object={}] The object to copy symbols to. | |
25361 | * @returns {Object} Returns `object`. | |
25362 | */ | |
25363 | function copySymbols(source, object) { | |
25364 | return copyObject(source, getSymbols(source), object); | |
25365 | } | |
25366 | ||
25367 | module.exports = copySymbols; | |
25368 | ||
25369 | },{"./_copyObject":227,"./_getSymbols":248}],229:[function(require,module,exports){ | |
25370 | var copyObject = require('./_copyObject'), | |
25371 | getSymbolsIn = require('./_getSymbolsIn'); | |
25372 | ||
25373 | /** | |
25374 | * Copies own and inherited symbols of `source` to `object`. | |
25375 | * | |
25376 | * @private | |
25377 | * @param {Object} source The object to copy symbols from. | |
25378 | * @param {Object} [object={}] The object to copy symbols to. | |
25379 | * @returns {Object} Returns `object`. | |
25380 | */ | |
25381 | function copySymbolsIn(source, object) { | |
25382 | return copyObject(source, getSymbolsIn(source), object); | |
25383 | } | |
25384 | ||
25385 | module.exports = copySymbolsIn; | |
25386 | ||
25387 | },{"./_copyObject":227,"./_getSymbolsIn":249}],230:[function(require,module,exports){ | |
25388 | var root = require('./_root'); | |
25389 | ||
25390 | /** Used to detect overreaching core-js shims. */ | |
25391 | var coreJsData = root['__core-js_shared__']; | |
25392 | ||
25393 | module.exports = coreJsData; | |
25394 | ||
25395 | },{"./_root":290}],231:[function(require,module,exports){ | |
25396 | var baseRest = require('./_baseRest'), | |
25397 | isIterateeCall = require('./_isIterateeCall'); | |
25398 | ||
25399 | /** | |
25400 | * Creates a function like `_.assign`. | |
25401 | * | |
25402 | * @private | |
25403 | * @param {Function} assigner The function to assign values. | |
25404 | * @returns {Function} Returns the new assigner function. | |
25405 | */ | |
25406 | function createAssigner(assigner) { | |
25407 | return baseRest(function(object, sources) { | |
25408 | var index = -1, | |
25409 | length = sources.length, | |
25410 | customizer = length > 1 ? sources[length - 1] : undefined, | |
25411 | guard = length > 2 ? sources[2] : undefined; | |
25412 | ||
25413 | customizer = (assigner.length > 3 && typeof customizer == 'function') | |
25414 | ? (length--, customizer) | |
25415 | : undefined; | |
25416 | ||
25417 | if (guard && isIterateeCall(sources[0], sources[1], guard)) { | |
25418 | customizer = length < 3 ? undefined : customizer; | |
25419 | length = 1; | |
25420 | } | |
25421 | object = Object(object); | |
25422 | while (++index < length) { | |
25423 | var source = sources[index]; | |
25424 | if (source) { | |
25425 | assigner(object, source, index, customizer); | |
25426 | } | |
25427 | } | |
25428 | return object; | |
25429 | }); | |
25430 | } | |
25431 | ||
25432 | module.exports = createAssigner; | |
25433 | ||
25434 | },{"./_baseRest":207,"./_isIterateeCall":264}],232:[function(require,module,exports){ | |
25435 | var isArrayLike = require('./isArrayLike'); | |
25436 | ||
25437 | /** | |
25438 | * Creates a `baseEach` or `baseEachRight` function. | |
25439 | * | |
25440 | * @private | |
25441 | * @param {Function} eachFunc The function to iterate over a collection. | |
25442 | * @param {boolean} [fromRight] Specify iterating from right to left. | |
25443 | * @returns {Function} Returns the new base function. | |
25444 | */ | |
25445 | function createBaseEach(eachFunc, fromRight) { | |
25446 | return function(collection, iteratee) { | |
25447 | if (collection == null) { | |
25448 | return collection; | |
25449 | } | |
25450 | if (!isArrayLike(collection)) { | |
25451 | return eachFunc(collection, iteratee); | |
25452 | } | |
25453 | var length = collection.length, | |
25454 | index = fromRight ? length : -1, | |
25455 | iterable = Object(collection); | |
25456 | ||
25457 | while ((fromRight ? index-- : ++index < length)) { | |
25458 | if (iteratee(iterable[index], index, iterable) === false) { | |
25459 | break; | |
25460 | } | |
25461 | } | |
25462 | return collection; | |
25463 | }; | |
25464 | } | |
25465 | ||
25466 | module.exports = createBaseEach; | |
25467 | ||
25468 | },{"./isArrayLike":324}],233:[function(require,module,exports){ | |
25469 | /** | |
25470 | * Creates a base function for methods like `_.forIn` and `_.forOwn`. | |
25471 | * | |
25472 | * @private | |
25473 | * @param {boolean} [fromRight] Specify iterating from right to left. | |
25474 | * @returns {Function} Returns the new base function. | |
25475 | */ | |
25476 | function createBaseFor(fromRight) { | |
25477 | return function(object, iteratee, keysFunc) { | |
25478 | var index = -1, | |
25479 | iterable = Object(object), | |
25480 | props = keysFunc(object), | |
25481 | length = props.length; | |
25482 | ||
25483 | while (length--) { | |
25484 | var key = props[fromRight ? length : ++index]; | |
25485 | if (iteratee(iterable[key], key, iterable) === false) { | |
25486 | break; | |
25487 | } | |
25488 | } | |
25489 | return object; | |
25490 | }; | |
25491 | } | |
25492 | ||
25493 | module.exports = createBaseFor; | |
25494 | ||
25495 | },{}],234:[function(require,module,exports){ | |
25496 | var baseRepeat = require('./_baseRepeat'), | |
25497 | baseToString = require('./_baseToString'), | |
25498 | castSlice = require('./_castSlice'), | |
25499 | hasUnicode = require('./_hasUnicode'), | |
25500 | stringSize = require('./_stringSize'), | |
25501 | stringToArray = require('./_stringToArray'); | |
25502 | ||
25503 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
25504 | var nativeCeil = Math.ceil; | |
25505 | ||
25506 | /** | |
25507 | * Creates the padding for `string` based on `length`. The `chars` string | |
25508 | * is truncated if the number of characters exceeds `length`. | |
25509 | * | |
25510 | * @private | |
25511 | * @param {number} length The padding length. | |
25512 | * @param {string} [chars=' '] The string used as padding. | |
25513 | * @returns {string} Returns the padding for `string`. | |
25514 | */ | |
25515 | function createPadding(length, chars) { | |
25516 | chars = chars === undefined ? ' ' : baseToString(chars); | |
25517 | ||
25518 | var charsLength = chars.length; | |
25519 | if (charsLength < 2) { | |
25520 | return charsLength ? baseRepeat(chars, length) : chars; | |
25521 | } | |
25522 | var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); | |
25523 | return hasUnicode(chars) | |
25524 | ? castSlice(stringToArray(result), 0, length).join('') | |
25525 | : result.slice(0, length); | |
25526 | } | |
25527 | ||
25528 | module.exports = createPadding; | |
25529 | ||
25530 | },{"./_baseRepeat":206,"./_baseToString":212,"./_castSlice":218,"./_hasUnicode":253,"./_stringSize":302,"./_stringToArray":303}],235:[function(require,module,exports){ | |
25531 | var getNative = require('./_getNative'); | |
25532 | ||
25533 | var defineProperty = (function() { | |
25534 | try { | |
25535 | var func = getNative(Object, 'defineProperty'); | |
25536 | func({}, '', {}); | |
25537 | return func; | |
25538 | } catch (e) {} | |
25539 | }()); | |
25540 | ||
25541 | module.exports = defineProperty; | |
25542 | ||
25543 | },{"./_getNative":245}],236:[function(require,module,exports){ | |
25544 | var SetCache = require('./_SetCache'), | |
25545 | arraySome = require('./_arraySome'), | |
25546 | cacheHas = require('./_cacheHas'); | |
25547 | ||
25548 | /** Used to compose bitmasks for value comparisons. */ | |
25549 | var COMPARE_PARTIAL_FLAG = 1, | |
25550 | COMPARE_UNORDERED_FLAG = 2; | |
25551 | ||
25552 | /** | |
25553 | * A specialized version of `baseIsEqualDeep` for arrays with support for | |
25554 | * partial deep comparisons. | |
25555 | * | |
25556 | * @private | |
25557 | * @param {Array} array The array to compare. | |
25558 | * @param {Array} other The other array to compare. | |
25559 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | |
25560 | * @param {Function} customizer The function to customize comparisons. | |
25561 | * @param {Function} equalFunc The function to determine equivalents of values. | |
25562 | * @param {Object} stack Tracks traversed `array` and `other` objects. | |
25563 | * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. | |
25564 | */ | |
25565 | function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { | |
25566 | var isPartial = bitmask & COMPARE_PARTIAL_FLAG, | |
25567 | arrLength = array.length, | |
25568 | othLength = other.length; | |
25569 | ||
25570 | if (arrLength != othLength && !(isPartial && othLength > arrLength)) { | |
25571 | return false; | |
25572 | } | |
25573 | // Assume cyclic values are equal. | |
25574 | var stacked = stack.get(array); | |
25575 | if (stacked && stack.get(other)) { | |
25576 | return stacked == other; | |
25577 | } | |
25578 | var index = -1, | |
25579 | result = true, | |
25580 | seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; | |
25581 | ||
25582 | stack.set(array, other); | |
25583 | stack.set(other, array); | |
25584 | ||
25585 | // Ignore non-index properties. | |
25586 | while (++index < arrLength) { | |
25587 | var arrValue = array[index], | |
25588 | othValue = other[index]; | |
25589 | ||
25590 | if (customizer) { | |
25591 | var compared = isPartial | |
25592 | ? customizer(othValue, arrValue, index, other, array, stack) | |
25593 | : customizer(arrValue, othValue, index, array, other, stack); | |
25594 | } | |
25595 | if (compared !== undefined) { | |
25596 | if (compared) { | |
25597 | continue; | |
25598 | } | |
25599 | result = false; | |
25600 | break; | |
25601 | } | |
25602 | // Recursively compare arrays (susceptible to call stack limits). | |
25603 | if (seen) { | |
25604 | if (!arraySome(other, function(othValue, othIndex) { | |
25605 | if (!cacheHas(seen, othIndex) && | |
25606 | (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { | |
25607 | return seen.push(othIndex); | |
25608 | } | |
25609 | })) { | |
25610 | result = false; | |
25611 | break; | |
25612 | } | |
25613 | } else if (!( | |
25614 | arrValue === othValue || | |
25615 | equalFunc(arrValue, othValue, bitmask, customizer, stack) | |
25616 | )) { | |
25617 | result = false; | |
25618 | break; | |
25619 | } | |
25620 | } | |
25621 | stack['delete'](array); | |
25622 | stack['delete'](other); | |
25623 | return result; | |
25624 | } | |
25625 | ||
25626 | module.exports = equalArrays; | |
25627 | ||
25628 | },{"./_SetCache":154,"./_arraySome":166,"./_cacheHas":215}],237:[function(require,module,exports){ | |
25629 | var Symbol = require('./_Symbol'), | |
25630 | Uint8Array = require('./_Uint8Array'), | |
25631 | eq = require('./eq'), | |
25632 | equalArrays = require('./_equalArrays'), | |
25633 | mapToArray = require('./_mapToArray'), | |
25634 | setToArray = require('./_setToArray'); | |
25635 | ||
25636 | /** Used to compose bitmasks for value comparisons. */ | |
25637 | var COMPARE_PARTIAL_FLAG = 1, | |
25638 | COMPARE_UNORDERED_FLAG = 2; | |
25639 | ||
25640 | /** `Object#toString` result references. */ | |
25641 | var boolTag = '[object Boolean]', | |
25642 | dateTag = '[object Date]', | |
25643 | errorTag = '[object Error]', | |
25644 | mapTag = '[object Map]', | |
25645 | numberTag = '[object Number]', | |
25646 | regexpTag = '[object RegExp]', | |
25647 | setTag = '[object Set]', | |
25648 | stringTag = '[object String]', | |
25649 | symbolTag = '[object Symbol]'; | |
25650 | ||
25651 | var arrayBufferTag = '[object ArrayBuffer]', | |
25652 | dataViewTag = '[object DataView]'; | |
25653 | ||
25654 | /** Used to convert symbols to primitives and strings. */ | |
25655 | var symbolProto = Symbol ? Symbol.prototype : undefined, | |
25656 | symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; | |
25657 | ||
25658 | /** | |
25659 | * A specialized version of `baseIsEqualDeep` for comparing objects of | |
25660 | * the same `toStringTag`. | |
25661 | * | |
25662 | * **Note:** This function only supports comparing values with tags of | |
25663 | * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. | |
25664 | * | |
25665 | * @private | |
25666 | * @param {Object} object The object to compare. | |
25667 | * @param {Object} other The other object to compare. | |
25668 | * @param {string} tag The `toStringTag` of the objects to compare. | |
25669 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | |
25670 | * @param {Function} customizer The function to customize comparisons. | |
25671 | * @param {Function} equalFunc The function to determine equivalents of values. | |
25672 | * @param {Object} stack Tracks traversed `object` and `other` objects. | |
25673 | * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. | |
25674 | */ | |
25675 | function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { | |
25676 | switch (tag) { | |
25677 | case dataViewTag: | |
25678 | if ((object.byteLength != other.byteLength) || | |
25679 | (object.byteOffset != other.byteOffset)) { | |
25680 | return false; | |
25681 | } | |
25682 | object = object.buffer; | |
25683 | other = other.buffer; | |
25684 | ||
25685 | case arrayBufferTag: | |
25686 | if ((object.byteLength != other.byteLength) || | |
25687 | !equalFunc(new Uint8Array(object), new Uint8Array(other))) { | |
25688 | return false; | |
25689 | } | |
25690 | return true; | |
25691 | ||
25692 | case boolTag: | |
25693 | case dateTag: | |
25694 | case numberTag: | |
25695 | // Coerce booleans to `1` or `0` and dates to milliseconds. | |
25696 | // Invalid dates are coerced to `NaN`. | |
25697 | return eq(+object, +other); | |
25698 | ||
25699 | case errorTag: | |
25700 | return object.name == other.name && object.message == other.message; | |
25701 | ||
25702 | case regexpTag: | |
25703 | case stringTag: | |
25704 | // Coerce regexes to strings and treat strings, primitives and objects, | |
25705 | // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring | |
25706 | // for more details. | |
25707 | return object == (other + ''); | |
25708 | ||
25709 | case mapTag: | |
25710 | var convert = mapToArray; | |
25711 | ||
25712 | case setTag: | |
25713 | var isPartial = bitmask & COMPARE_PARTIAL_FLAG; | |
25714 | convert || (convert = setToArray); | |
25715 | ||
25716 | if (object.size != other.size && !isPartial) { | |
25717 | return false; | |
25718 | } | |
25719 | // Assume cyclic values are equal. | |
25720 | var stacked = stack.get(object); | |
25721 | if (stacked) { | |
25722 | return stacked == other; | |
25723 | } | |
25724 | bitmask |= COMPARE_UNORDERED_FLAG; | |
25725 | ||
25726 | // Recursively compare objects (susceptible to call stack limits). | |
25727 | stack.set(object, other); | |
25728 | var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); | |
25729 | stack['delete'](object); | |
25730 | return result; | |
25731 | ||
25732 | case symbolTag: | |
25733 | if (symbolValueOf) { | |
25734 | return symbolValueOf.call(object) == symbolValueOf.call(other); | |
25735 | } | |
25736 | } | |
25737 | return false; | |
25738 | } | |
25739 | ||
25740 | module.exports = equalByTag; | |
25741 | ||
25742 | },{"./_Symbol":156,"./_Uint8Array":157,"./_equalArrays":236,"./_mapToArray":280,"./_setToArray":293,"./eq":313}],238:[function(require,module,exports){ | |
25743 | var getAllKeys = require('./_getAllKeys'); | |
25744 | ||
25745 | /** Used to compose bitmasks for value comparisons. */ | |
25746 | var COMPARE_PARTIAL_FLAG = 1; | |
25747 | ||
25748 | /** Used for built-in method references. */ | |
25749 | var objectProto = Object.prototype; | |
25750 | ||
25751 | /** Used to check objects for own properties. */ | |
25752 | var hasOwnProperty = objectProto.hasOwnProperty; | |
25753 | ||
25754 | /** | |
25755 | * A specialized version of `baseIsEqualDeep` for objects with support for | |
25756 | * partial deep comparisons. | |
25757 | * | |
25758 | * @private | |
25759 | * @param {Object} object The object to compare. | |
25760 | * @param {Object} other The other object to compare. | |
25761 | * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. | |
25762 | * @param {Function} customizer The function to customize comparisons. | |
25763 | * @param {Function} equalFunc The function to determine equivalents of values. | |
25764 | * @param {Object} stack Tracks traversed `object` and `other` objects. | |
25765 | * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. | |
25766 | */ | |
25767 | function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { | |
25768 | var isPartial = bitmask & COMPARE_PARTIAL_FLAG, | |
25769 | objProps = getAllKeys(object), | |
25770 | objLength = objProps.length, | |
25771 | othProps = getAllKeys(other), | |
25772 | othLength = othProps.length; | |
25773 | ||
25774 | if (objLength != othLength && !isPartial) { | |
25775 | return false; | |
25776 | } | |
25777 | var index = objLength; | |
25778 | while (index--) { | |
25779 | var key = objProps[index]; | |
25780 | if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { | |
25781 | return false; | |
25782 | } | |
25783 | } | |
25784 | // Assume cyclic values are equal. | |
25785 | var stacked = stack.get(object); | |
25786 | if (stacked && stack.get(other)) { | |
25787 | return stacked == other; | |
25788 | } | |
25789 | var result = true; | |
25790 | stack.set(object, other); | |
25791 | stack.set(other, object); | |
25792 | ||
25793 | var skipCtor = isPartial; | |
25794 | while (++index < objLength) { | |
25795 | key = objProps[index]; | |
25796 | var objValue = object[key], | |
25797 | othValue = other[key]; | |
25798 | ||
25799 | if (customizer) { | |
25800 | var compared = isPartial | |
25801 | ? customizer(othValue, objValue, key, other, object, stack) | |
25802 | : customizer(objValue, othValue, key, object, other, stack); | |
25803 | } | |
25804 | // Recursively compare objects (susceptible to call stack limits). | |
25805 | if (!(compared === undefined | |
25806 | ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) | |
25807 | : compared | |
25808 | )) { | |
25809 | result = false; | |
25810 | break; | |
25811 | } | |
25812 | skipCtor || (skipCtor = key == 'constructor'); | |
25813 | } | |
25814 | if (result && !skipCtor) { | |
25815 | var objCtor = object.constructor, | |
25816 | othCtor = other.constructor; | |
25817 | ||
25818 | // Non `Object` object instances with different constructors are not equal. | |
25819 | if (objCtor != othCtor && | |
25820 | ('constructor' in object && 'constructor' in other) && | |
25821 | !(typeof objCtor == 'function' && objCtor instanceof objCtor && | |
25822 | typeof othCtor == 'function' && othCtor instanceof othCtor)) { | |
25823 | result = false; | |
25824 | } | |
25825 | } | |
25826 | stack['delete'](object); | |
25827 | stack['delete'](other); | |
25828 | return result; | |
25829 | } | |
25830 | ||
25831 | module.exports = equalObjects; | |
25832 | ||
25833 | },{"./_getAllKeys":241}],239:[function(require,module,exports){ | |
25834 | var flatten = require('./flatten'), | |
25835 | overRest = require('./_overRest'), | |
25836 | setToString = require('./_setToString'); | |
25837 | ||
25838 | /** | |
25839 | * A specialized version of `baseRest` which flattens the rest array. | |
25840 | * | |
25841 | * @private | |
25842 | * @param {Function} func The function to apply a rest parameter to. | |
25843 | * @returns {Function} Returns the new function. | |
25844 | */ | |
25845 | function flatRest(func) { | |
25846 | return setToString(overRest(func, undefined, flatten), func + ''); | |
25847 | } | |
25848 | ||
25849 | module.exports = flatRest; | |
25850 | ||
25851 | },{"./_overRest":289,"./_setToString":294,"./flatten":316}],240:[function(require,module,exports){ | |
25852 | (function (global){ | |
25853 | /** Detect free variable `global` from Node.js. */ | |
25854 | var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; | |
25855 | ||
25856 | module.exports = freeGlobal; | |
25857 | ||
25858 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
25859 | },{}],241:[function(require,module,exports){ | |
25860 | var baseGetAllKeys = require('./_baseGetAllKeys'), | |
25861 | getSymbols = require('./_getSymbols'), | |
25862 | keys = require('./keys'); | |
25863 | ||
25864 | /** | |
25865 | * Creates an array of own enumerable property names and symbols of `object`. | |
25866 | * | |
25867 | * @private | |
25868 | * @param {Object} object The object to query. | |
25869 | * @returns {Array} Returns the array of property names and symbols. | |
25870 | */ | |
25871 | function getAllKeys(object) { | |
25872 | return baseGetAllKeys(object, keys, getSymbols); | |
25873 | } | |
25874 | ||
25875 | module.exports = getAllKeys; | |
25876 | ||
25877 | },{"./_baseGetAllKeys":183,"./_getSymbols":248,"./keys":341}],242:[function(require,module,exports){ | |
25878 | var baseGetAllKeys = require('./_baseGetAllKeys'), | |
25879 | getSymbolsIn = require('./_getSymbolsIn'), | |
25880 | keysIn = require('./keysIn'); | |
25881 | ||
25882 | /** | |
25883 | * Creates an array of own and inherited enumerable property names and | |
25884 | * symbols of `object`. | |
25885 | * | |
25886 | * @private | |
25887 | * @param {Object} object The object to query. | |
25888 | * @returns {Array} Returns the array of property names and symbols. | |
25889 | */ | |
25890 | function getAllKeysIn(object) { | |
25891 | return baseGetAllKeys(object, keysIn, getSymbolsIn); | |
25892 | } | |
25893 | ||
25894 | module.exports = getAllKeysIn; | |
25895 | ||
25896 | },{"./_baseGetAllKeys":183,"./_getSymbolsIn":249,"./keysIn":342}],243:[function(require,module,exports){ | |
25897 | var isKeyable = require('./_isKeyable'); | |
25898 | ||
25899 | /** | |
25900 | * Gets the data for `map`. | |
25901 | * | |
25902 | * @private | |
25903 | * @param {Object} map The map to query. | |
25904 | * @param {string} key The reference key. | |
25905 | * @returns {*} Returns the map data. | |
25906 | */ | |
25907 | function getMapData(map, key) { | |
25908 | var data = map.__data__; | |
25909 | return isKeyable(key) | |
25910 | ? data[typeof key == 'string' ? 'string' : 'hash'] | |
25911 | : data.map; | |
25912 | } | |
25913 | ||
25914 | module.exports = getMapData; | |
25915 | ||
25916 | },{"./_isKeyable":266}],244:[function(require,module,exports){ | |
25917 | var isStrictComparable = require('./_isStrictComparable'), | |
25918 | keys = require('./keys'); | |
25919 | ||
25920 | /** | |
25921 | * Gets the property names, values, and compare flags of `object`. | |
25922 | * | |
25923 | * @private | |
25924 | * @param {Object} object The object to query. | |
25925 | * @returns {Array} Returns the match data of `object`. | |
25926 | */ | |
25927 | function getMatchData(object) { | |
25928 | var result = keys(object), | |
25929 | length = result.length; | |
25930 | ||
25931 | while (length--) { | |
25932 | var key = result[length], | |
25933 | value = object[key]; | |
25934 | ||
25935 | result[length] = [key, value, isStrictComparable(value)]; | |
25936 | } | |
25937 | return result; | |
25938 | } | |
25939 | ||
25940 | module.exports = getMatchData; | |
25941 | ||
25942 | },{"./_isStrictComparable":269,"./keys":341}],245:[function(require,module,exports){ | |
25943 | var baseIsNative = require('./_baseIsNative'), | |
25944 | getValue = require('./_getValue'); | |
25945 | ||
25946 | /** | |
25947 | * Gets the native function at `key` of `object`. | |
25948 | * | |
25949 | * @private | |
25950 | * @param {Object} object The object to query. | |
25951 | * @param {string} key The key of the method to get. | |
25952 | * @returns {*} Returns the function if it's native, else `undefined`. | |
25953 | */ | |
25954 | function getNative(object, key) { | |
25955 | var value = getValue(object, key); | |
25956 | return baseIsNative(value) ? value : undefined; | |
25957 | } | |
25958 | ||
25959 | module.exports = getNative; | |
25960 | ||
25961 | },{"./_baseIsNative":193,"./_getValue":251}],246:[function(require,module,exports){ | |
25962 | var overArg = require('./_overArg'); | |
25963 | ||
25964 | /** Built-in value references. */ | |
25965 | var getPrototype = overArg(Object.getPrototypeOf, Object); | |
25966 | ||
25967 | module.exports = getPrototype; | |
25968 | ||
25969 | },{"./_overArg":288}],247:[function(require,module,exports){ | |
25970 | var Symbol = require('./_Symbol'); | |
25971 | ||
25972 | /** Used for built-in method references. */ | |
25973 | var objectProto = Object.prototype; | |
25974 | ||
25975 | /** Used to check objects for own properties. */ | |
25976 | var hasOwnProperty = objectProto.hasOwnProperty; | |
25977 | ||
25978 | /** | |
25979 | * Used to resolve the | |
25980 | * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) | |
25981 | * of values. | |
25982 | */ | |
25983 | var nativeObjectToString = objectProto.toString; | |
25984 | ||
25985 | /** Built-in value references. */ | |
25986 | var symToStringTag = Symbol ? Symbol.toStringTag : undefined; | |
25987 | ||
25988 | /** | |
25989 | * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. | |
25990 | * | |
25991 | * @private | |
25992 | * @param {*} value The value to query. | |
25993 | * @returns {string} Returns the raw `toStringTag`. | |
25994 | */ | |
25995 | function getRawTag(value) { | |
25996 | var isOwn = hasOwnProperty.call(value, symToStringTag), | |
25997 | tag = value[symToStringTag]; | |
25998 | ||
25999 | try { | |
26000 | value[symToStringTag] = undefined; | |
26001 | var unmasked = true; | |
26002 | } catch (e) {} | |
26003 | ||
26004 | var result = nativeObjectToString.call(value); | |
26005 | if (unmasked) { | |
26006 | if (isOwn) { | |
26007 | value[symToStringTag] = tag; | |
26008 | } else { | |
26009 | delete value[symToStringTag]; | |
26010 | } | |
26011 | } | |
26012 | return result; | |
26013 | } | |
26014 | ||
26015 | module.exports = getRawTag; | |
26016 | ||
26017 | },{"./_Symbol":156}],248:[function(require,module,exports){ | |
26018 | var arrayFilter = require('./_arrayFilter'), | |
26019 | stubArray = require('./stubArray'); | |
26020 | ||
26021 | /** Used for built-in method references. */ | |
26022 | var objectProto = Object.prototype; | |
26023 | ||
26024 | /** Built-in value references. */ | |
26025 | var propertyIsEnumerable = objectProto.propertyIsEnumerable; | |
26026 | ||
26027 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
26028 | var nativeGetSymbols = Object.getOwnPropertySymbols; | |
26029 | ||
26030 | /** | |
26031 | * Creates an array of the own enumerable symbols of `object`. | |
26032 | * | |
26033 | * @private | |
26034 | * @param {Object} object The object to query. | |
26035 | * @returns {Array} Returns the array of symbols. | |
26036 | */ | |
26037 | var getSymbols = !nativeGetSymbols ? stubArray : function(object) { | |
26038 | if (object == null) { | |
26039 | return []; | |
26040 | } | |
26041 | object = Object(object); | |
26042 | return arrayFilter(nativeGetSymbols(object), function(symbol) { | |
26043 | return propertyIsEnumerable.call(object, symbol); | |
26044 | }); | |
26045 | }; | |
26046 | ||
26047 | module.exports = getSymbols; | |
26048 | ||
26049 | },{"./_arrayFilter":162,"./stubArray":348}],249:[function(require,module,exports){ | |
26050 | var arrayPush = require('./_arrayPush'), | |
26051 | getPrototype = require('./_getPrototype'), | |
26052 | getSymbols = require('./_getSymbols'), | |
26053 | stubArray = require('./stubArray'); | |
26054 | ||
26055 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
26056 | var nativeGetSymbols = Object.getOwnPropertySymbols; | |
26057 | ||
26058 | /** | |
26059 | * Creates an array of the own and inherited enumerable symbols of `object`. | |
26060 | * | |
26061 | * @private | |
26062 | * @param {Object} object The object to query. | |
26063 | * @returns {Array} Returns the array of symbols. | |
26064 | */ | |
26065 | var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { | |
26066 | var result = []; | |
26067 | while (object) { | |
26068 | arrayPush(result, getSymbols(object)); | |
26069 | object = getPrototype(object); | |
26070 | } | |
26071 | return result; | |
26072 | }; | |
26073 | ||
26074 | module.exports = getSymbolsIn; | |
26075 | ||
26076 | },{"./_arrayPush":165,"./_getPrototype":246,"./_getSymbols":248,"./stubArray":348}],250:[function(require,module,exports){ | |
26077 | var DataView = require('./_DataView'), | |
26078 | Map = require('./_Map'), | |
26079 | Promise = require('./_Promise'), | |
26080 | Set = require('./_Set'), | |
26081 | WeakMap = require('./_WeakMap'), | |
26082 | baseGetTag = require('./_baseGetTag'), | |
26083 | toSource = require('./_toSource'); | |
26084 | ||
26085 | /** `Object#toString` result references. */ | |
26086 | var mapTag = '[object Map]', | |
26087 | objectTag = '[object Object]', | |
26088 | promiseTag = '[object Promise]', | |
26089 | setTag = '[object Set]', | |
26090 | weakMapTag = '[object WeakMap]'; | |
26091 | ||
26092 | var dataViewTag = '[object DataView]'; | |
26093 | ||
26094 | /** Used to detect maps, sets, and weakmaps. */ | |
26095 | var dataViewCtorString = toSource(DataView), | |
26096 | mapCtorString = toSource(Map), | |
26097 | promiseCtorString = toSource(Promise), | |
26098 | setCtorString = toSource(Set), | |
26099 | weakMapCtorString = toSource(WeakMap); | |
26100 | ||
26101 | /** | |
26102 | * Gets the `toStringTag` of `value`. | |
26103 | * | |
26104 | * @private | |
26105 | * @param {*} value The value to query. | |
26106 | * @returns {string} Returns the `toStringTag`. | |
26107 | */ | |
26108 | var getTag = baseGetTag; | |
26109 | ||
26110 | // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. | |
26111 | if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || | |
26112 | (Map && getTag(new Map) != mapTag) || | |
26113 | (Promise && getTag(Promise.resolve()) != promiseTag) || | |
26114 | (Set && getTag(new Set) != setTag) || | |
26115 | (WeakMap && getTag(new WeakMap) != weakMapTag)) { | |
26116 | getTag = function(value) { | |
26117 | var result = baseGetTag(value), | |
26118 | Ctor = result == objectTag ? value.constructor : undefined, | |
26119 | ctorString = Ctor ? toSource(Ctor) : ''; | |
26120 | ||
26121 | if (ctorString) { | |
26122 | switch (ctorString) { | |
26123 | case dataViewCtorString: return dataViewTag; | |
26124 | case mapCtorString: return mapTag; | |
26125 | case promiseCtorString: return promiseTag; | |
26126 | case setCtorString: return setTag; | |
26127 | case weakMapCtorString: return weakMapTag; | |
26128 | } | |
26129 | } | |
26130 | return result; | |
26131 | }; | |
26132 | } | |
26133 | ||
26134 | module.exports = getTag; | |
26135 | ||
26136 | },{"./_DataView":147,"./_Map":150,"./_Promise":152,"./_Set":153,"./_WeakMap":158,"./_baseGetTag":184,"./_toSource":306}],251:[function(require,module,exports){ | |
26137 | /** | |
26138 | * Gets the value at `key` of `object`. | |
26139 | * | |
26140 | * @private | |
26141 | * @param {Object} [object] The object to query. | |
26142 | * @param {string} key The key of the property to get. | |
26143 | * @returns {*} Returns the property value. | |
26144 | */ | |
26145 | function getValue(object, key) { | |
26146 | return object == null ? undefined : object[key]; | |
26147 | } | |
26148 | ||
26149 | module.exports = getValue; | |
26150 | ||
26151 | },{}],252:[function(require,module,exports){ | |
26152 | var castPath = require('./_castPath'), | |
26153 | isArguments = require('./isArguments'), | |
26154 | isArray = require('./isArray'), | |
26155 | isIndex = require('./_isIndex'), | |
26156 | isLength = require('./isLength'), | |
26157 | toKey = require('./_toKey'); | |
26158 | ||
26159 | /** | |
26160 | * Checks if `path` exists on `object`. | |
26161 | * | |
26162 | * @private | |
26163 | * @param {Object} object The object to query. | |
26164 | * @param {Array|string} path The path to check. | |
26165 | * @param {Function} hasFunc The function to check properties. | |
26166 | * @returns {boolean} Returns `true` if `path` exists, else `false`. | |
26167 | */ | |
26168 | function hasPath(object, path, hasFunc) { | |
26169 | path = castPath(path, object); | |
26170 | ||
26171 | var index = -1, | |
26172 | length = path.length, | |
26173 | result = false; | |
26174 | ||
26175 | while (++index < length) { | |
26176 | var key = toKey(path[index]); | |
26177 | if (!(result = object != null && hasFunc(object, key))) { | |
26178 | break; | |
26179 | } | |
26180 | object = object[key]; | |
26181 | } | |
26182 | if (result || ++index != length) { | |
26183 | return result; | |
26184 | } | |
26185 | length = object == null ? 0 : object.length; | |
26186 | return !!length && isLength(length) && isIndex(key, length) && | |
26187 | (isArray(object) || isArguments(object)); | |
26188 | } | |
26189 | ||
26190 | module.exports = hasPath; | |
26191 | ||
26192 | },{"./_castPath":217,"./_isIndex":263,"./_toKey":305,"./isArguments":322,"./isArray":323,"./isLength":329}],253:[function(require,module,exports){ | |
26193 | /** Used to compose unicode character classes. */ | |
26194 | var rsAstralRange = '\\ud800-\\udfff', | |
26195 | rsComboMarksRange = '\\u0300-\\u036f', | |
26196 | reComboHalfMarksRange = '\\ufe20-\\ufe2f', | |
26197 | rsComboSymbolsRange = '\\u20d0-\\u20ff', | |
26198 | rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, | |
26199 | rsVarRange = '\\ufe0e\\ufe0f'; | |
26200 | ||
26201 | /** Used to compose unicode capture groups. */ | |
26202 | var rsZWJ = '\\u200d'; | |
26203 | ||
26204 | /** 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/). */ | |
26205 | var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); | |
26206 | ||
26207 | /** | |
26208 | * Checks if `string` contains Unicode symbols. | |
26209 | * | |
26210 | * @private | |
26211 | * @param {string} string The string to inspect. | |
26212 | * @returns {boolean} Returns `true` if a symbol is found, else `false`. | |
26213 | */ | |
26214 | function hasUnicode(string) { | |
26215 | return reHasUnicode.test(string); | |
26216 | } | |
26217 | ||
26218 | module.exports = hasUnicode; | |
26219 | ||
26220 | },{}],254:[function(require,module,exports){ | |
26221 | var nativeCreate = require('./_nativeCreate'); | |
26222 | ||
26223 | /** | |
26224 | * Removes all key-value entries from the hash. | |
26225 | * | |
26226 | * @private | |
26227 | * @name clear | |
26228 | * @memberOf Hash | |
26229 | */ | |
26230 | function hashClear() { | |
26231 | this.__data__ = nativeCreate ? nativeCreate(null) : {}; | |
26232 | this.size = 0; | |
26233 | } | |
26234 | ||
26235 | module.exports = hashClear; | |
26236 | ||
26237 | },{"./_nativeCreate":283}],255:[function(require,module,exports){ | |
26238 | /** | |
26239 | * Removes `key` and its value from the hash. | |
26240 | * | |
26241 | * @private | |
26242 | * @name delete | |
26243 | * @memberOf Hash | |
26244 | * @param {Object} hash The hash to modify. | |
26245 | * @param {string} key The key of the value to remove. | |
26246 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | |
26247 | */ | |
26248 | function hashDelete(key) { | |
26249 | var result = this.has(key) && delete this.__data__[key]; | |
26250 | this.size -= result ? 1 : 0; | |
26251 | return result; | |
26252 | } | |
26253 | ||
26254 | module.exports = hashDelete; | |
26255 | ||
26256 | },{}],256:[function(require,module,exports){ | |
26257 | var nativeCreate = require('./_nativeCreate'); | |
26258 | ||
26259 | /** Used to stand-in for `undefined` hash values. */ | |
26260 | var HASH_UNDEFINED = '__lodash_hash_undefined__'; | |
26261 | ||
26262 | /** Used for built-in method references. */ | |
26263 | var objectProto = Object.prototype; | |
26264 | ||
26265 | /** Used to check objects for own properties. */ | |
26266 | var hasOwnProperty = objectProto.hasOwnProperty; | |
26267 | ||
26268 | /** | |
26269 | * Gets the hash value for `key`. | |
26270 | * | |
26271 | * @private | |
26272 | * @name get | |
26273 | * @memberOf Hash | |
26274 | * @param {string} key The key of the value to get. | |
26275 | * @returns {*} Returns the entry value. | |
26276 | */ | |
26277 | function hashGet(key) { | |
26278 | var data = this.__data__; | |
26279 | if (nativeCreate) { | |
26280 | var result = data[key]; | |
26281 | return result === HASH_UNDEFINED ? undefined : result; | |
26282 | } | |
26283 | return hasOwnProperty.call(data, key) ? data[key] : undefined; | |
26284 | } | |
26285 | ||
26286 | module.exports = hashGet; | |
26287 | ||
26288 | },{"./_nativeCreate":283}],257:[function(require,module,exports){ | |
26289 | var nativeCreate = require('./_nativeCreate'); | |
26290 | ||
26291 | /** Used for built-in method references. */ | |
26292 | var objectProto = Object.prototype; | |
26293 | ||
26294 | /** Used to check objects for own properties. */ | |
26295 | var hasOwnProperty = objectProto.hasOwnProperty; | |
26296 | ||
26297 | /** | |
26298 | * Checks if a hash value for `key` exists. | |
26299 | * | |
26300 | * @private | |
26301 | * @name has | |
26302 | * @memberOf Hash | |
26303 | * @param {string} key The key of the entry to check. | |
26304 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | |
26305 | */ | |
26306 | function hashHas(key) { | |
26307 | var data = this.__data__; | |
26308 | return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); | |
26309 | } | |
26310 | ||
26311 | module.exports = hashHas; | |
26312 | ||
26313 | },{"./_nativeCreate":283}],258:[function(require,module,exports){ | |
26314 | var nativeCreate = require('./_nativeCreate'); | |
26315 | ||
26316 | /** Used to stand-in for `undefined` hash values. */ | |
26317 | var HASH_UNDEFINED = '__lodash_hash_undefined__'; | |
26318 | ||
26319 | /** | |
26320 | * Sets the hash `key` to `value`. | |
26321 | * | |
26322 | * @private | |
26323 | * @name set | |
26324 | * @memberOf Hash | |
26325 | * @param {string} key The key of the value to set. | |
26326 | * @param {*} value The value to set. | |
26327 | * @returns {Object} Returns the hash instance. | |
26328 | */ | |
26329 | function hashSet(key, value) { | |
26330 | var data = this.__data__; | |
26331 | this.size += this.has(key) ? 0 : 1; | |
26332 | data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; | |
26333 | return this; | |
26334 | } | |
26335 | ||
26336 | module.exports = hashSet; | |
26337 | ||
26338 | },{"./_nativeCreate":283}],259:[function(require,module,exports){ | |
26339 | /** Used for built-in method references. */ | |
26340 | var objectProto = Object.prototype; | |
26341 | ||
26342 | /** Used to check objects for own properties. */ | |
26343 | var hasOwnProperty = objectProto.hasOwnProperty; | |
26344 | ||
26345 | /** | |
26346 | * Initializes an array clone. | |
26347 | * | |
26348 | * @private | |
26349 | * @param {Array} array The array to clone. | |
26350 | * @returns {Array} Returns the initialized clone. | |
26351 | */ | |
26352 | function initCloneArray(array) { | |
26353 | var length = array.length, | |
26354 | result = new array.constructor(length); | |
26355 | ||
26356 | // Add properties assigned by `RegExp#exec`. | |
26357 | if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { | |
26358 | result.index = array.index; | |
26359 | result.input = array.input; | |
26360 | } | |
26361 | return result; | |
26362 | } | |
26363 | ||
26364 | module.exports = initCloneArray; | |
26365 | ||
26366 | },{}],260:[function(require,module,exports){ | |
26367 | var cloneArrayBuffer = require('./_cloneArrayBuffer'), | |
26368 | cloneDataView = require('./_cloneDataView'), | |
26369 | cloneRegExp = require('./_cloneRegExp'), | |
26370 | cloneSymbol = require('./_cloneSymbol'), | |
26371 | cloneTypedArray = require('./_cloneTypedArray'); | |
26372 | ||
26373 | /** `Object#toString` result references. */ | |
26374 | var boolTag = '[object Boolean]', | |
26375 | dateTag = '[object Date]', | |
26376 | mapTag = '[object Map]', | |
26377 | numberTag = '[object Number]', | |
26378 | regexpTag = '[object RegExp]', | |
26379 | setTag = '[object Set]', | |
26380 | stringTag = '[object String]', | |
26381 | symbolTag = '[object Symbol]'; | |
26382 | ||
26383 | var arrayBufferTag = '[object ArrayBuffer]', | |
26384 | dataViewTag = '[object DataView]', | |
26385 | float32Tag = '[object Float32Array]', | |
26386 | float64Tag = '[object Float64Array]', | |
26387 | int8Tag = '[object Int8Array]', | |
26388 | int16Tag = '[object Int16Array]', | |
26389 | int32Tag = '[object Int32Array]', | |
26390 | uint8Tag = '[object Uint8Array]', | |
26391 | uint8ClampedTag = '[object Uint8ClampedArray]', | |
26392 | uint16Tag = '[object Uint16Array]', | |
26393 | uint32Tag = '[object Uint32Array]'; | |
26394 | ||
26395 | /** | |
26396 | * Initializes an object clone based on its `toStringTag`. | |
26397 | * | |
26398 | * **Note:** This function only supports cloning values with tags of | |
26399 | * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. | |
26400 | * | |
26401 | * @private | |
26402 | * @param {Object} object The object to clone. | |
26403 | * @param {string} tag The `toStringTag` of the object to clone. | |
26404 | * @param {boolean} [isDeep] Specify a deep clone. | |
26405 | * @returns {Object} Returns the initialized clone. | |
26406 | */ | |
26407 | function initCloneByTag(object, tag, isDeep) { | |
26408 | var Ctor = object.constructor; | |
26409 | switch (tag) { | |
26410 | case arrayBufferTag: | |
26411 | return cloneArrayBuffer(object); | |
26412 | ||
26413 | case boolTag: | |
26414 | case dateTag: | |
26415 | return new Ctor(+object); | |
26416 | ||
26417 | case dataViewTag: | |
26418 | return cloneDataView(object, isDeep); | |
26419 | ||
26420 | case float32Tag: case float64Tag: | |
26421 | case int8Tag: case int16Tag: case int32Tag: | |
26422 | case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: | |
26423 | return cloneTypedArray(object, isDeep); | |
26424 | ||
26425 | case mapTag: | |
26426 | return new Ctor; | |
26427 | ||
26428 | case numberTag: | |
26429 | case stringTag: | |
26430 | return new Ctor(object); | |
26431 | ||
26432 | case regexpTag: | |
26433 | return cloneRegExp(object); | |
26434 | ||
26435 | case setTag: | |
26436 | return new Ctor; | |
26437 | ||
26438 | case symbolTag: | |
26439 | return cloneSymbol(object); | |
26440 | } | |
26441 | } | |
26442 | ||
26443 | module.exports = initCloneByTag; | |
26444 | ||
26445 | },{"./_cloneArrayBuffer":220,"./_cloneDataView":222,"./_cloneRegExp":223,"./_cloneSymbol":224,"./_cloneTypedArray":225}],261:[function(require,module,exports){ | |
26446 | var baseCreate = require('./_baseCreate'), | |
26447 | getPrototype = require('./_getPrototype'), | |
26448 | isPrototype = require('./_isPrototype'); | |
26449 | ||
26450 | /** | |
26451 | * Initializes an object clone. | |
26452 | * | |
26453 | * @private | |
26454 | * @param {Object} object The object to clone. | |
26455 | * @returns {Object} Returns the initialized clone. | |
26456 | */ | |
26457 | function initCloneObject(object) { | |
26458 | return (typeof object.constructor == 'function' && !isPrototype(object)) | |
26459 | ? baseCreate(getPrototype(object)) | |
26460 | : {}; | |
26461 | } | |
26462 | ||
26463 | module.exports = initCloneObject; | |
26464 | ||
26465 | },{"./_baseCreate":175,"./_getPrototype":246,"./_isPrototype":268}],262:[function(require,module,exports){ | |
26466 | var Symbol = require('./_Symbol'), | |
26467 | isArguments = require('./isArguments'), | |
26468 | isArray = require('./isArray'); | |
26469 | ||
26470 | /** Built-in value references. */ | |
26471 | var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined; | |
26472 | ||
26473 | /** | |
26474 | * Checks if `value` is a flattenable `arguments` object or array. | |
26475 | * | |
26476 | * @private | |
26477 | * @param {*} value The value to check. | |
26478 | * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. | |
26479 | */ | |
26480 | function isFlattenable(value) { | |
26481 | return isArray(value) || isArguments(value) || | |
26482 | !!(spreadableSymbol && value && value[spreadableSymbol]); | |
26483 | } | |
26484 | ||
26485 | module.exports = isFlattenable; | |
26486 | ||
26487 | },{"./_Symbol":156,"./isArguments":322,"./isArray":323}],263:[function(require,module,exports){ | |
26488 | /** Used as references for various `Number` constants. */ | |
26489 | var MAX_SAFE_INTEGER = 9007199254740991; | |
26490 | ||
26491 | /** Used to detect unsigned integer values. */ | |
26492 | var reIsUint = /^(?:0|[1-9]\d*)$/; | |
26493 | ||
26494 | /** | |
26495 | * Checks if `value` is a valid array-like index. | |
26496 | * | |
26497 | * @private | |
26498 | * @param {*} value The value to check. | |
26499 | * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. | |
26500 | * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. | |
26501 | */ | |
26502 | function isIndex(value, length) { | |
26503 | var type = typeof value; | |
26504 | length = length == null ? MAX_SAFE_INTEGER : length; | |
26505 | ||
26506 | return !!length && | |
26507 | (type == 'number' || | |
26508 | (type != 'symbol' && reIsUint.test(value))) && | |
26509 | (value > -1 && value % 1 == 0 && value < length); | |
26510 | } | |
26511 | ||
26512 | module.exports = isIndex; | |
26513 | ||
26514 | },{}],264:[function(require,module,exports){ | |
26515 | var eq = require('./eq'), | |
26516 | isArrayLike = require('./isArrayLike'), | |
26517 | isIndex = require('./_isIndex'), | |
26518 | isObject = require('./isObject'); | |
26519 | ||
26520 | /** | |
26521 | * Checks if the given arguments are from an iteratee call. | |
26522 | * | |
26523 | * @private | |
26524 | * @param {*} value The potential iteratee value argument. | |
26525 | * @param {*} index The potential iteratee index or key argument. | |
26526 | * @param {*} object The potential iteratee object argument. | |
26527 | * @returns {boolean} Returns `true` if the arguments are from an iteratee call, | |
26528 | * else `false`. | |
26529 | */ | |
26530 | function isIterateeCall(value, index, object) { | |
26531 | if (!isObject(object)) { | |
26532 | return false; | |
26533 | } | |
26534 | var type = typeof index; | |
26535 | if (type == 'number' | |
26536 | ? (isArrayLike(object) && isIndex(index, object.length)) | |
26537 | : (type == 'string' && index in object) | |
26538 | ) { | |
26539 | return eq(object[index], value); | |
26540 | } | |
26541 | return false; | |
26542 | } | |
26543 | ||
26544 | module.exports = isIterateeCall; | |
26545 | ||
26546 | },{"./_isIndex":263,"./eq":313,"./isArrayLike":324,"./isObject":333}],265:[function(require,module,exports){ | |
26547 | var isArray = require('./isArray'), | |
26548 | isSymbol = require('./isSymbol'); | |
26549 | ||
26550 | /** Used to match property names within property paths. */ | |
26551 | var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, | |
26552 | reIsPlainProp = /^\w*$/; | |
26553 | ||
26554 | /** | |
26555 | * Checks if `value` is a property name and not a property path. | |
26556 | * | |
26557 | * @private | |
26558 | * @param {*} value The value to check. | |
26559 | * @param {Object} [object] The object to query keys on. | |
26560 | * @returns {boolean} Returns `true` if `value` is a property name, else `false`. | |
26561 | */ | |
26562 | function isKey(value, object) { | |
26563 | if (isArray(value)) { | |
26564 | return false; | |
26565 | } | |
26566 | var type = typeof value; | |
26567 | if (type == 'number' || type == 'symbol' || type == 'boolean' || | |
26568 | value == null || isSymbol(value)) { | |
26569 | return true; | |
26570 | } | |
26571 | return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || | |
26572 | (object != null && value in Object(object)); | |
26573 | } | |
26574 | ||
26575 | module.exports = isKey; | |
26576 | ||
26577 | },{"./isArray":323,"./isSymbol":338}],266:[function(require,module,exports){ | |
26578 | /** | |
26579 | * Checks if `value` is suitable for use as unique object key. | |
26580 | * | |
26581 | * @private | |
26582 | * @param {*} value The value to check. | |
26583 | * @returns {boolean} Returns `true` if `value` is suitable, else `false`. | |
26584 | */ | |
26585 | function isKeyable(value) { | |
26586 | var type = typeof value; | |
26587 | return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') | |
26588 | ? (value !== '__proto__') | |
26589 | : (value === null); | |
26590 | } | |
26591 | ||
26592 | module.exports = isKeyable; | |
26593 | ||
26594 | },{}],267:[function(require,module,exports){ | |
26595 | var coreJsData = require('./_coreJsData'); | |
26596 | ||
26597 | /** Used to detect methods masquerading as native. */ | |
26598 | var maskSrcKey = (function() { | |
26599 | var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); | |
26600 | return uid ? ('Symbol(src)_1.' + uid) : ''; | |
26601 | }()); | |
26602 | ||
26603 | /** | |
26604 | * Checks if `func` has its source masked. | |
26605 | * | |
26606 | * @private | |
26607 | * @param {Function} func The function to check. | |
26608 | * @returns {boolean} Returns `true` if `func` is masked, else `false`. | |
26609 | */ | |
26610 | function isMasked(func) { | |
26611 | return !!maskSrcKey && (maskSrcKey in func); | |
26612 | } | |
26613 | ||
26614 | module.exports = isMasked; | |
26615 | ||
26616 | },{"./_coreJsData":230}],268:[function(require,module,exports){ | |
26617 | /** Used for built-in method references. */ | |
26618 | var objectProto = Object.prototype; | |
26619 | ||
26620 | /** | |
26621 | * Checks if `value` is likely a prototype object. | |
26622 | * | |
26623 | * @private | |
26624 | * @param {*} value The value to check. | |
26625 | * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. | |
26626 | */ | |
26627 | function isPrototype(value) { | |
26628 | var Ctor = value && value.constructor, | |
26629 | proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; | |
26630 | ||
26631 | return value === proto; | |
26632 | } | |
26633 | ||
26634 | module.exports = isPrototype; | |
26635 | ||
26636 | },{}],269:[function(require,module,exports){ | |
26637 | var isObject = require('./isObject'); | |
26638 | ||
26639 | /** | |
26640 | * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. | |
26641 | * | |
26642 | * @private | |
26643 | * @param {*} value The value to check. | |
26644 | * @returns {boolean} Returns `true` if `value` if suitable for strict | |
26645 | * equality comparisons, else `false`. | |
26646 | */ | |
26647 | function isStrictComparable(value) { | |
26648 | return value === value && !isObject(value); | |
26649 | } | |
26650 | ||
26651 | module.exports = isStrictComparable; | |
26652 | ||
26653 | },{"./isObject":333}],270:[function(require,module,exports){ | |
26654 | /** | |
26655 | * Removes all key-value entries from the list cache. | |
26656 | * | |
26657 | * @private | |
26658 | * @name clear | |
26659 | * @memberOf ListCache | |
26660 | */ | |
26661 | function listCacheClear() { | |
26662 | this.__data__ = []; | |
26663 | this.size = 0; | |
26664 | } | |
26665 | ||
26666 | module.exports = listCacheClear; | |
26667 | ||
26668 | },{}],271:[function(require,module,exports){ | |
26669 | var assocIndexOf = require('./_assocIndexOf'); | |
26670 | ||
26671 | /** Used for built-in method references. */ | |
26672 | var arrayProto = Array.prototype; | |
26673 | ||
26674 | /** Built-in value references. */ | |
26675 | var splice = arrayProto.splice; | |
26676 | ||
26677 | /** | |
26678 | * Removes `key` and its value from the list cache. | |
26679 | * | |
26680 | * @private | |
26681 | * @name delete | |
26682 | * @memberOf ListCache | |
26683 | * @param {string} key The key of the value to remove. | |
26684 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | |
26685 | */ | |
26686 | function listCacheDelete(key) { | |
26687 | var data = this.__data__, | |
26688 | index = assocIndexOf(data, key); | |
26689 | ||
26690 | if (index < 0) { | |
26691 | return false; | |
26692 | } | |
26693 | var lastIndex = data.length - 1; | |
26694 | if (index == lastIndex) { | |
26695 | data.pop(); | |
26696 | } else { | |
26697 | splice.call(data, index, 1); | |
26698 | } | |
26699 | --this.size; | |
26700 | return true; | |
26701 | } | |
26702 | ||
26703 | module.exports = listCacheDelete; | |
26704 | ||
26705 | },{"./_assocIndexOf":170}],272:[function(require,module,exports){ | |
26706 | var assocIndexOf = require('./_assocIndexOf'); | |
26707 | ||
26708 | /** | |
26709 | * Gets the list cache value for `key`. | |
26710 | * | |
26711 | * @private | |
26712 | * @name get | |
26713 | * @memberOf ListCache | |
26714 | * @param {string} key The key of the value to get. | |
26715 | * @returns {*} Returns the entry value. | |
26716 | */ | |
26717 | function listCacheGet(key) { | |
26718 | var data = this.__data__, | |
26719 | index = assocIndexOf(data, key); | |
26720 | ||
26721 | return index < 0 ? undefined : data[index][1]; | |
26722 | } | |
26723 | ||
26724 | module.exports = listCacheGet; | |
26725 | ||
26726 | },{"./_assocIndexOf":170}],273:[function(require,module,exports){ | |
26727 | var assocIndexOf = require('./_assocIndexOf'); | |
26728 | ||
26729 | /** | |
26730 | * Checks if a list cache value for `key` exists. | |
26731 | * | |
26732 | * @private | |
26733 | * @name has | |
26734 | * @memberOf ListCache | |
26735 | * @param {string} key The key of the entry to check. | |
26736 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | |
26737 | */ | |
26738 | function listCacheHas(key) { | |
26739 | return assocIndexOf(this.__data__, key) > -1; | |
26740 | } | |
26741 | ||
26742 | module.exports = listCacheHas; | |
26743 | ||
26744 | },{"./_assocIndexOf":170}],274:[function(require,module,exports){ | |
26745 | var assocIndexOf = require('./_assocIndexOf'); | |
26746 | ||
26747 | /** | |
26748 | * Sets the list cache `key` to `value`. | |
26749 | * | |
26750 | * @private | |
26751 | * @name set | |
26752 | * @memberOf ListCache | |
26753 | * @param {string} key The key of the value to set. | |
26754 | * @param {*} value The value to set. | |
26755 | * @returns {Object} Returns the list cache instance. | |
26756 | */ | |
26757 | function listCacheSet(key, value) { | |
26758 | var data = this.__data__, | |
26759 | index = assocIndexOf(data, key); | |
26760 | ||
26761 | if (index < 0) { | |
26762 | ++this.size; | |
26763 | data.push([key, value]); | |
26764 | } else { | |
26765 | data[index][1] = value; | |
26766 | } | |
26767 | return this; | |
26768 | } | |
26769 | ||
26770 | module.exports = listCacheSet; | |
26771 | ||
26772 | },{"./_assocIndexOf":170}],275:[function(require,module,exports){ | |
26773 | var Hash = require('./_Hash'), | |
26774 | ListCache = require('./_ListCache'), | |
26775 | Map = require('./_Map'); | |
26776 | ||
26777 | /** | |
26778 | * Removes all key-value entries from the map. | |
26779 | * | |
26780 | * @private | |
26781 | * @name clear | |
26782 | * @memberOf MapCache | |
26783 | */ | |
26784 | function mapCacheClear() { | |
26785 | this.size = 0; | |
26786 | this.__data__ = { | |
26787 | 'hash': new Hash, | |
26788 | 'map': new (Map || ListCache), | |
26789 | 'string': new Hash | |
26790 | }; | |
26791 | } | |
26792 | ||
26793 | module.exports = mapCacheClear; | |
26794 | ||
26795 | },{"./_Hash":148,"./_ListCache":149,"./_Map":150}],276:[function(require,module,exports){ | |
26796 | var getMapData = require('./_getMapData'); | |
26797 | ||
26798 | /** | |
26799 | * Removes `key` and its value from the map. | |
26800 | * | |
26801 | * @private | |
26802 | * @name delete | |
26803 | * @memberOf MapCache | |
26804 | * @param {string} key The key of the value to remove. | |
26805 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | |
26806 | */ | |
26807 | function mapCacheDelete(key) { | |
26808 | var result = getMapData(this, key)['delete'](key); | |
26809 | this.size -= result ? 1 : 0; | |
26810 | return result; | |
26811 | } | |
26812 | ||
26813 | module.exports = mapCacheDelete; | |
26814 | ||
26815 | },{"./_getMapData":243}],277:[function(require,module,exports){ | |
26816 | var getMapData = require('./_getMapData'); | |
26817 | ||
26818 | /** | |
26819 | * Gets the map value for `key`. | |
26820 | * | |
26821 | * @private | |
26822 | * @name get | |
26823 | * @memberOf MapCache | |
26824 | * @param {string} key The key of the value to get. | |
26825 | * @returns {*} Returns the entry value. | |
26826 | */ | |
26827 | function mapCacheGet(key) { | |
26828 | return getMapData(this, key).get(key); | |
26829 | } | |
26830 | ||
26831 | module.exports = mapCacheGet; | |
26832 | ||
26833 | },{"./_getMapData":243}],278:[function(require,module,exports){ | |
26834 | var getMapData = require('./_getMapData'); | |
26835 | ||
26836 | /** | |
26837 | * Checks if a map value for `key` exists. | |
26838 | * | |
26839 | * @private | |
26840 | * @name has | |
26841 | * @memberOf MapCache | |
26842 | * @param {string} key The key of the entry to check. | |
26843 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | |
26844 | */ | |
26845 | function mapCacheHas(key) { | |
26846 | return getMapData(this, key).has(key); | |
26847 | } | |
26848 | ||
26849 | module.exports = mapCacheHas; | |
26850 | ||
26851 | },{"./_getMapData":243}],279:[function(require,module,exports){ | |
26852 | var getMapData = require('./_getMapData'); | |
26853 | ||
26854 | /** | |
26855 | * Sets the map `key` to `value`. | |
26856 | * | |
26857 | * @private | |
26858 | * @name set | |
26859 | * @memberOf MapCache | |
26860 | * @param {string} key The key of the value to set. | |
26861 | * @param {*} value The value to set. | |
26862 | * @returns {Object} Returns the map cache instance. | |
26863 | */ | |
26864 | function mapCacheSet(key, value) { | |
26865 | var data = getMapData(this, key), | |
26866 | size = data.size; | |
26867 | ||
26868 | data.set(key, value); | |
26869 | this.size += data.size == size ? 0 : 1; | |
26870 | return this; | |
26871 | } | |
26872 | ||
26873 | module.exports = mapCacheSet; | |
26874 | ||
26875 | },{"./_getMapData":243}],280:[function(require,module,exports){ | |
26876 | /** | |
26877 | * Converts `map` to its key-value pairs. | |
26878 | * | |
26879 | * @private | |
26880 | * @param {Object} map The map to convert. | |
26881 | * @returns {Array} Returns the key-value pairs. | |
26882 | */ | |
26883 | function mapToArray(map) { | |
26884 | var index = -1, | |
26885 | result = Array(map.size); | |
26886 | ||
26887 | map.forEach(function(value, key) { | |
26888 | result[++index] = [key, value]; | |
26889 | }); | |
26890 | return result; | |
26891 | } | |
26892 | ||
26893 | module.exports = mapToArray; | |
26894 | ||
26895 | },{}],281:[function(require,module,exports){ | |
26896 | /** | |
26897 | * A specialized version of `matchesProperty` for source values suitable | |
26898 | * for strict equality comparisons, i.e. `===`. | |
26899 | * | |
26900 | * @private | |
26901 | * @param {string} key The key of the property to get. | |
26902 | * @param {*} srcValue The value to match. | |
26903 | * @returns {Function} Returns the new spec function. | |
26904 | */ | |
26905 | function matchesStrictComparable(key, srcValue) { | |
26906 | return function(object) { | |
26907 | if (object == null) { | |
26908 | return false; | |
26909 | } | |
26910 | return object[key] === srcValue && | |
26911 | (srcValue !== undefined || (key in Object(object))); | |
26912 | }; | |
26913 | } | |
26914 | ||
26915 | module.exports = matchesStrictComparable; | |
26916 | ||
26917 | },{}],282:[function(require,module,exports){ | |
26918 | var memoize = require('./memoize'); | |
26919 | ||
26920 | /** Used as the maximum memoize cache size. */ | |
26921 | var MAX_MEMOIZE_SIZE = 500; | |
26922 | ||
26923 | /** | |
26924 | * A specialized version of `_.memoize` which clears the memoized function's | |
26925 | * cache when it exceeds `MAX_MEMOIZE_SIZE`. | |
26926 | * | |
26927 | * @private | |
26928 | * @param {Function} func The function to have its output memoized. | |
26929 | * @returns {Function} Returns the new memoized function. | |
26930 | */ | |
26931 | function memoizeCapped(func) { | |
26932 | var result = memoize(func, function(key) { | |
26933 | if (cache.size === MAX_MEMOIZE_SIZE) { | |
26934 | cache.clear(); | |
26935 | } | |
26936 | return key; | |
26937 | }); | |
26938 | ||
26939 | var cache = result.cache; | |
26940 | return result; | |
26941 | } | |
26942 | ||
26943 | module.exports = memoizeCapped; | |
26944 | ||
26945 | },{"./memoize":344}],283:[function(require,module,exports){ | |
26946 | var getNative = require('./_getNative'); | |
26947 | ||
26948 | /* Built-in method references that are verified to be native. */ | |
26949 | var nativeCreate = getNative(Object, 'create'); | |
26950 | ||
26951 | module.exports = nativeCreate; | |
26952 | ||
26953 | },{"./_getNative":245}],284:[function(require,module,exports){ | |
26954 | var overArg = require('./_overArg'); | |
26955 | ||
26956 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
26957 | var nativeKeys = overArg(Object.keys, Object); | |
26958 | ||
26959 | module.exports = nativeKeys; | |
26960 | ||
26961 | },{"./_overArg":288}],285:[function(require,module,exports){ | |
26962 | /** | |
26963 | * This function is like | |
26964 | * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) | |
26965 | * except that it includes inherited enumerable properties. | |
26966 | * | |
26967 | * @private | |
26968 | * @param {Object} object The object to query. | |
26969 | * @returns {Array} Returns the array of property names. | |
26970 | */ | |
26971 | function nativeKeysIn(object) { | |
26972 | var result = []; | |
26973 | if (object != null) { | |
26974 | for (var key in Object(object)) { | |
26975 | result.push(key); | |
26976 | } | |
26977 | } | |
26978 | return result; | |
26979 | } | |
26980 | ||
26981 | module.exports = nativeKeysIn; | |
26982 | ||
26983 | },{}],286:[function(require,module,exports){ | |
26984 | var freeGlobal = require('./_freeGlobal'); | |
26985 | ||
26986 | /** Detect free variable `exports`. */ | |
26987 | var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; | |
26988 | ||
26989 | /** Detect free variable `module`. */ | |
26990 | var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; | |
26991 | ||
26992 | /** Detect the popular CommonJS extension `module.exports`. */ | |
26993 | var moduleExports = freeModule && freeModule.exports === freeExports; | |
26994 | ||
26995 | /** Detect free variable `process` from Node.js. */ | |
26996 | var freeProcess = moduleExports && freeGlobal.process; | |
26997 | ||
26998 | /** Used to access faster Node.js helpers. */ | |
26999 | var nodeUtil = (function() { | |
27000 | try { | |
27001 | // Use `util.types` for Node.js 10+. | |
27002 | var types = freeModule && freeModule.require && freeModule.require('util').types; | |
27003 | ||
27004 | if (types) { | |
27005 | return types; | |
27006 | } | |
27007 | ||
27008 | // Legacy `process.binding('util')` for Node.js < 10. | |
27009 | return freeProcess && freeProcess.binding && freeProcess.binding('util'); | |
27010 | } catch (e) {} | |
27011 | }()); | |
27012 | ||
27013 | module.exports = nodeUtil; | |
27014 | ||
27015 | },{"./_freeGlobal":240}],287:[function(require,module,exports){ | |
27016 | /** Used for built-in method references. */ | |
27017 | var objectProto = Object.prototype; | |
27018 | ||
27019 | /** | |
27020 | * Used to resolve the | |
27021 | * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) | |
27022 | * of values. | |
27023 | */ | |
27024 | var nativeObjectToString = objectProto.toString; | |
27025 | ||
27026 | /** | |
27027 | * Converts `value` to a string using `Object.prototype.toString`. | |
27028 | * | |
27029 | * @private | |
27030 | * @param {*} value The value to convert. | |
27031 | * @returns {string} Returns the converted string. | |
27032 | */ | |
27033 | function objectToString(value) { | |
27034 | return nativeObjectToString.call(value); | |
27035 | } | |
27036 | ||
27037 | module.exports = objectToString; | |
27038 | ||
27039 | },{}],288:[function(require,module,exports){ | |
27040 | /** | |
27041 | * Creates a unary function that invokes `func` with its argument transformed. | |
27042 | * | |
27043 | * @private | |
27044 | * @param {Function} func The function to wrap. | |
27045 | * @param {Function} transform The argument transform. | |
27046 | * @returns {Function} Returns the new function. | |
27047 | */ | |
27048 | function overArg(func, transform) { | |
27049 | return function(arg) { | |
27050 | return func(transform(arg)); | |
27051 | }; | |
27052 | } | |
27053 | ||
27054 | module.exports = overArg; | |
27055 | ||
27056 | },{}],289:[function(require,module,exports){ | |
27057 | var apply = require('./_apply'); | |
27058 | ||
27059 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
27060 | var nativeMax = Math.max; | |
27061 | ||
27062 | /** | |
27063 | * A specialized version of `baseRest` which transforms the rest array. | |
27064 | * | |
27065 | * @private | |
27066 | * @param {Function} func The function to apply a rest parameter to. | |
27067 | * @param {number} [start=func.length-1] The start position of the rest parameter. | |
27068 | * @param {Function} transform The rest array transform. | |
27069 | * @returns {Function} Returns the new function. | |
27070 | */ | |
27071 | function overRest(func, start, transform) { | |
27072 | start = nativeMax(start === undefined ? (func.length - 1) : start, 0); | |
27073 | return function() { | |
27074 | var args = arguments, | |
27075 | index = -1, | |
27076 | length = nativeMax(args.length - start, 0), | |
27077 | array = Array(length); | |
27078 | ||
27079 | while (++index < length) { | |
27080 | array[index] = args[start + index]; | |
27081 | } | |
27082 | index = -1; | |
27083 | var otherArgs = Array(start + 1); | |
27084 | while (++index < start) { | |
27085 | otherArgs[index] = args[index]; | |
27086 | } | |
27087 | otherArgs[start] = transform(array); | |
27088 | return apply(func, this, otherArgs); | |
27089 | }; | |
27090 | } | |
27091 | ||
27092 | module.exports = overRest; | |
27093 | ||
27094 | },{"./_apply":159}],290:[function(require,module,exports){ | |
27095 | var freeGlobal = require('./_freeGlobal'); | |
27096 | ||
27097 | /** Detect free variable `self`. */ | |
27098 | var freeSelf = typeof self == 'object' && self && self.Object === Object && self; | |
27099 | ||
27100 | /** Used as a reference to the global object. */ | |
27101 | var root = freeGlobal || freeSelf || Function('return this')(); | |
27102 | ||
27103 | module.exports = root; | |
27104 | ||
27105 | },{"./_freeGlobal":240}],291:[function(require,module,exports){ | |
27106 | /** Used to stand-in for `undefined` hash values. */ | |
27107 | var HASH_UNDEFINED = '__lodash_hash_undefined__'; | |
27108 | ||
27109 | /** | |
27110 | * Adds `value` to the array cache. | |
27111 | * | |
27112 | * @private | |
27113 | * @name add | |
27114 | * @memberOf SetCache | |
27115 | * @alias push | |
27116 | * @param {*} value The value to cache. | |
27117 | * @returns {Object} Returns the cache instance. | |
27118 | */ | |
27119 | function setCacheAdd(value) { | |
27120 | this.__data__.set(value, HASH_UNDEFINED); | |
27121 | return this; | |
27122 | } | |
27123 | ||
27124 | module.exports = setCacheAdd; | |
27125 | ||
27126 | },{}],292:[function(require,module,exports){ | |
27127 | /** | |
27128 | * Checks if `value` is in the array cache. | |
27129 | * | |
27130 | * @private | |
27131 | * @name has | |
27132 | * @memberOf SetCache | |
27133 | * @param {*} value The value to search for. | |
27134 | * @returns {number} Returns `true` if `value` is found, else `false`. | |
27135 | */ | |
27136 | function setCacheHas(value) { | |
27137 | return this.__data__.has(value); | |
27138 | } | |
27139 | ||
27140 | module.exports = setCacheHas; | |
27141 | ||
27142 | },{}],293:[function(require,module,exports){ | |
27143 | /** | |
27144 | * Converts `set` to an array of its values. | |
27145 | * | |
27146 | * @private | |
27147 | * @param {Object} set The set to convert. | |
27148 | * @returns {Array} Returns the values. | |
27149 | */ | |
27150 | function setToArray(set) { | |
27151 | var index = -1, | |
27152 | result = Array(set.size); | |
27153 | ||
27154 | set.forEach(function(value) { | |
27155 | result[++index] = value; | |
27156 | }); | |
27157 | return result; | |
27158 | } | |
27159 | ||
27160 | module.exports = setToArray; | |
27161 | ||
27162 | },{}],294:[function(require,module,exports){ | |
27163 | var baseSetToString = require('./_baseSetToString'), | |
27164 | shortOut = require('./_shortOut'); | |
27165 | ||
27166 | /** | |
27167 | * Sets the `toString` method of `func` to return `string`. | |
27168 | * | |
27169 | * @private | |
27170 | * @param {Function} func The function to modify. | |
27171 | * @param {Function} string The `toString` result. | |
27172 | * @returns {Function} Returns `func`. | |
27173 | */ | |
27174 | var setToString = shortOut(baseSetToString); | |
27175 | ||
27176 | module.exports = setToString; | |
27177 | ||
27178 | },{"./_baseSetToString":209,"./_shortOut":295}],295:[function(require,module,exports){ | |
27179 | /** Used to detect hot functions by number of calls within a span of milliseconds. */ | |
27180 | var HOT_COUNT = 800, | |
27181 | HOT_SPAN = 16; | |
27182 | ||
27183 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
27184 | var nativeNow = Date.now; | |
27185 | ||
27186 | /** | |
27187 | * Creates a function that'll short out and invoke `identity` instead | |
27188 | * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` | |
27189 | * milliseconds. | |
27190 | * | |
27191 | * @private | |
27192 | * @param {Function} func The function to restrict. | |
27193 | * @returns {Function} Returns the new shortable function. | |
27194 | */ | |
27195 | function shortOut(func) { | |
27196 | var count = 0, | |
27197 | lastCalled = 0; | |
27198 | ||
27199 | return function() { | |
27200 | var stamp = nativeNow(), | |
27201 | remaining = HOT_SPAN - (stamp - lastCalled); | |
27202 | ||
27203 | lastCalled = stamp; | |
27204 | if (remaining > 0) { | |
27205 | if (++count >= HOT_COUNT) { | |
27206 | return arguments[0]; | |
27207 | } | |
27208 | } else { | |
27209 | count = 0; | |
27210 | } | |
27211 | return func.apply(undefined, arguments); | |
27212 | }; | |
27213 | } | |
27214 | ||
27215 | module.exports = shortOut; | |
27216 | ||
27217 | },{}],296:[function(require,module,exports){ | |
27218 | var ListCache = require('./_ListCache'); | |
27219 | ||
27220 | /** | |
27221 | * Removes all key-value entries from the stack. | |
27222 | * | |
27223 | * @private | |
27224 | * @name clear | |
27225 | * @memberOf Stack | |
27226 | */ | |
27227 | function stackClear() { | |
27228 | this.__data__ = new ListCache; | |
27229 | this.size = 0; | |
27230 | } | |
27231 | ||
27232 | module.exports = stackClear; | |
27233 | ||
27234 | },{"./_ListCache":149}],297:[function(require,module,exports){ | |
27235 | /** | |
27236 | * Removes `key` and its value from the stack. | |
27237 | * | |
27238 | * @private | |
27239 | * @name delete | |
27240 | * @memberOf Stack | |
27241 | * @param {string} key The key of the value to remove. | |
27242 | * @returns {boolean} Returns `true` if the entry was removed, else `false`. | |
27243 | */ | |
27244 | function stackDelete(key) { | |
27245 | var data = this.__data__, | |
27246 | result = data['delete'](key); | |
27247 | ||
27248 | this.size = data.size; | |
27249 | return result; | |
27250 | } | |
27251 | ||
27252 | module.exports = stackDelete; | |
27253 | ||
27254 | },{}],298:[function(require,module,exports){ | |
27255 | /** | |
27256 | * Gets the stack value for `key`. | |
27257 | * | |
27258 | * @private | |
27259 | * @name get | |
27260 | * @memberOf Stack | |
27261 | * @param {string} key The key of the value to get. | |
27262 | * @returns {*} Returns the entry value. | |
27263 | */ | |
27264 | function stackGet(key) { | |
27265 | return this.__data__.get(key); | |
27266 | } | |
27267 | ||
27268 | module.exports = stackGet; | |
27269 | ||
27270 | },{}],299:[function(require,module,exports){ | |
27271 | /** | |
27272 | * Checks if a stack value for `key` exists. | |
27273 | * | |
27274 | * @private | |
27275 | * @name has | |
27276 | * @memberOf Stack | |
27277 | * @param {string} key The key of the entry to check. | |
27278 | * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | |
27279 | */ | |
27280 | function stackHas(key) { | |
27281 | return this.__data__.has(key); | |
27282 | } | |
27283 | ||
27284 | module.exports = stackHas; | |
27285 | ||
27286 | },{}],300:[function(require,module,exports){ | |
27287 | var ListCache = require('./_ListCache'), | |
27288 | Map = require('./_Map'), | |
27289 | MapCache = require('./_MapCache'); | |
27290 | ||
27291 | /** Used as the size to enable large array optimizations. */ | |
27292 | var LARGE_ARRAY_SIZE = 200; | |
27293 | ||
27294 | /** | |
27295 | * Sets the stack `key` to `value`. | |
27296 | * | |
27297 | * @private | |
27298 | * @name set | |
27299 | * @memberOf Stack | |
27300 | * @param {string} key The key of the value to set. | |
27301 | * @param {*} value The value to set. | |
27302 | * @returns {Object} Returns the stack cache instance. | |
27303 | */ | |
27304 | function stackSet(key, value) { | |
27305 | var data = this.__data__; | |
27306 | if (data instanceof ListCache) { | |
27307 | var pairs = data.__data__; | |
27308 | if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { | |
27309 | pairs.push([key, value]); | |
27310 | this.size = ++data.size; | |
27311 | return this; | |
27312 | } | |
27313 | data = this.__data__ = new MapCache(pairs); | |
27314 | } | |
27315 | data.set(key, value); | |
27316 | this.size = data.size; | |
27317 | return this; | |
27318 | } | |
27319 | ||
27320 | module.exports = stackSet; | |
27321 | ||
27322 | },{"./_ListCache":149,"./_Map":150,"./_MapCache":151}],301:[function(require,module,exports){ | |
27323 | /** | |
27324 | * A specialized version of `_.indexOf` which performs strict equality | |
27325 | * comparisons of values, i.e. `===`. | |
27326 | * | |
27327 | * @private | |
27328 | * @param {Array} array The array to inspect. | |
27329 | * @param {*} value The value to search for. | |
27330 | * @param {number} fromIndex The index to search from. | |
27331 | * @returns {number} Returns the index of the matched value, else `-1`. | |
27332 | */ | |
27333 | function strictIndexOf(array, value, fromIndex) { | |
27334 | var index = fromIndex - 1, | |
27335 | length = array.length; | |
27336 | ||
27337 | while (++index < length) { | |
27338 | if (array[index] === value) { | |
27339 | return index; | |
27340 | } | |
27341 | } | |
27342 | return -1; | |
27343 | } | |
27344 | ||
27345 | module.exports = strictIndexOf; | |
27346 | ||
27347 | },{}],302:[function(require,module,exports){ | |
27348 | var asciiSize = require('./_asciiSize'), | |
27349 | hasUnicode = require('./_hasUnicode'), | |
27350 | unicodeSize = require('./_unicodeSize'); | |
27351 | ||
27352 | /** | |
27353 | * Gets the number of symbols in `string`. | |
27354 | * | |
27355 | * @private | |
27356 | * @param {string} string The string to inspect. | |
27357 | * @returns {number} Returns the string size. | |
27358 | */ | |
27359 | function stringSize(string) { | |
27360 | return hasUnicode(string) | |
27361 | ? unicodeSize(string) | |
27362 | : asciiSize(string); | |
27363 | } | |
27364 | ||
27365 | module.exports = stringSize; | |
27366 | ||
27367 | },{"./_asciiSize":167,"./_hasUnicode":253,"./_unicodeSize":307}],303:[function(require,module,exports){ | |
27368 | var asciiToArray = require('./_asciiToArray'), | |
27369 | hasUnicode = require('./_hasUnicode'), | |
27370 | unicodeToArray = require('./_unicodeToArray'); | |
27371 | ||
27372 | /** | |
27373 | * Converts `string` to an array. | |
27374 | * | |
27375 | * @private | |
27376 | * @param {string} string The string to convert. | |
27377 | * @returns {Array} Returns the converted array. | |
27378 | */ | |
27379 | function stringToArray(string) { | |
27380 | return hasUnicode(string) | |
27381 | ? unicodeToArray(string) | |
27382 | : asciiToArray(string); | |
27383 | } | |
27384 | ||
27385 | module.exports = stringToArray; | |
27386 | ||
27387 | },{"./_asciiToArray":168,"./_hasUnicode":253,"./_unicodeToArray":308}],304:[function(require,module,exports){ | |
27388 | var memoizeCapped = require('./_memoizeCapped'); | |
27389 | ||
27390 | /** Used to match property names within property paths. */ | |
27391 | var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; | |
27392 | ||
27393 | /** Used to match backslashes in property paths. */ | |
27394 | var reEscapeChar = /\\(\\)?/g; | |
27395 | ||
27396 | /** | |
27397 | * Converts `string` to a property path array. | |
27398 | * | |
27399 | * @private | |
27400 | * @param {string} string The string to convert. | |
27401 | * @returns {Array} Returns the property path array. | |
27402 | */ | |
27403 | var stringToPath = memoizeCapped(function(string) { | |
27404 | var result = []; | |
27405 | if (string.charCodeAt(0) === 46 /* . */) { | |
27406 | result.push(''); | |
27407 | } | |
27408 | string.replace(rePropName, function(match, number, quote, subString) { | |
27409 | result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); | |
27410 | }); | |
27411 | return result; | |
27412 | }); | |
27413 | ||
27414 | module.exports = stringToPath; | |
27415 | ||
27416 | },{"./_memoizeCapped":282}],305:[function(require,module,exports){ | |
27417 | var isSymbol = require('./isSymbol'); | |
27418 | ||
27419 | /** Used as references for various `Number` constants. */ | |
27420 | var INFINITY = 1 / 0; | |
27421 | ||
27422 | /** | |
27423 | * Converts `value` to a string key if it's not a string or symbol. | |
27424 | * | |
27425 | * @private | |
27426 | * @param {*} value The value to inspect. | |
27427 | * @returns {string|symbol} Returns the key. | |
27428 | */ | |
27429 | function toKey(value) { | |
27430 | if (typeof value == 'string' || isSymbol(value)) { | |
27431 | return value; | |
27432 | } | |
27433 | var result = (value + ''); | |
27434 | return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; | |
27435 | } | |
27436 | ||
27437 | module.exports = toKey; | |
27438 | ||
27439 | },{"./isSymbol":338}],306:[function(require,module,exports){ | |
27440 | /** Used for built-in method references. */ | |
27441 | var funcProto = Function.prototype; | |
27442 | ||
27443 | /** Used to resolve the decompiled source of functions. */ | |
27444 | var funcToString = funcProto.toString; | |
27445 | ||
27446 | /** | |
27447 | * Converts `func` to its source code. | |
27448 | * | |
27449 | * @private | |
27450 | * @param {Function} func The function to convert. | |
27451 | * @returns {string} Returns the source code. | |
27452 | */ | |
27453 | function toSource(func) { | |
27454 | if (func != null) { | |
27455 | try { | |
27456 | return funcToString.call(func); | |
27457 | } catch (e) {} | |
27458 | try { | |
27459 | return (func + ''); | |
27460 | } catch (e) {} | |
27461 | } | |
27462 | return ''; | |
27463 | } | |
27464 | ||
27465 | module.exports = toSource; | |
27466 | ||
27467 | },{}],307:[function(require,module,exports){ | |
27468 | /** Used to compose unicode character classes. */ | |
27469 | var rsAstralRange = '\\ud800-\\udfff', | |
27470 | rsComboMarksRange = '\\u0300-\\u036f', | |
27471 | reComboHalfMarksRange = '\\ufe20-\\ufe2f', | |
27472 | rsComboSymbolsRange = '\\u20d0-\\u20ff', | |
27473 | rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, | |
27474 | rsVarRange = '\\ufe0e\\ufe0f'; | |
27475 | ||
27476 | /** Used to compose unicode capture groups. */ | |
27477 | var rsAstral = '[' + rsAstralRange + ']', | |
27478 | rsCombo = '[' + rsComboRange + ']', | |
27479 | rsFitz = '\\ud83c[\\udffb-\\udfff]', | |
27480 | rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', | |
27481 | rsNonAstral = '[^' + rsAstralRange + ']', | |
27482 | rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', | |
27483 | rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', | |
27484 | rsZWJ = '\\u200d'; | |
27485 | ||
27486 | /** Used to compose unicode regexes. */ | |
27487 | var reOptMod = rsModifier + '?', | |
27488 | rsOptVar = '[' + rsVarRange + ']?', | |
27489 | rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', | |
27490 | rsSeq = rsOptVar + reOptMod + rsOptJoin, | |
27491 | rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; | |
27492 | ||
27493 | /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ | |
27494 | var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); | |
27495 | ||
27496 | /** | |
27497 | * Gets the size of a Unicode `string`. | |
27498 | * | |
27499 | * @private | |
27500 | * @param {string} string The string inspect. | |
27501 | * @returns {number} Returns the string size. | |
27502 | */ | |
27503 | function unicodeSize(string) { | |
27504 | var result = reUnicode.lastIndex = 0; | |
27505 | while (reUnicode.test(string)) { | |
27506 | ++result; | |
27507 | } | |
27508 | return result; | |
27509 | } | |
27510 | ||
27511 | module.exports = unicodeSize; | |
27512 | ||
27513 | },{}],308:[function(require,module,exports){ | |
27514 | /** Used to compose unicode character classes. */ | |
27515 | var rsAstralRange = '\\ud800-\\udfff', | |
27516 | rsComboMarksRange = '\\u0300-\\u036f', | |
27517 | reComboHalfMarksRange = '\\ufe20-\\ufe2f', | |
27518 | rsComboSymbolsRange = '\\u20d0-\\u20ff', | |
27519 | rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, | |
27520 | rsVarRange = '\\ufe0e\\ufe0f'; | |
27521 | ||
27522 | /** Used to compose unicode capture groups. */ | |
27523 | var rsAstral = '[' + rsAstralRange + ']', | |
27524 | rsCombo = '[' + rsComboRange + ']', | |
27525 | rsFitz = '\\ud83c[\\udffb-\\udfff]', | |
27526 | rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', | |
27527 | rsNonAstral = '[^' + rsAstralRange + ']', | |
27528 | rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', | |
27529 | rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', | |
27530 | rsZWJ = '\\u200d'; | |
27531 | ||
27532 | /** Used to compose unicode regexes. */ | |
27533 | var reOptMod = rsModifier + '?', | |
27534 | rsOptVar = '[' + rsVarRange + ']?', | |
27535 | rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', | |
27536 | rsSeq = rsOptVar + reOptMod + rsOptJoin, | |
27537 | rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; | |
27538 | ||
27539 | /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ | |
27540 | var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); | |
27541 | ||
27542 | /** | |
27543 | * Converts a Unicode `string` to an array. | |
27544 | * | |
27545 | * @private | |
27546 | * @param {string} string The string to convert. | |
27547 | * @returns {Array} Returns the converted array. | |
27548 | */ | |
27549 | function unicodeToArray(string) { | |
27550 | return string.match(reUnicode) || []; | |
27551 | } | |
27552 | ||
27553 | module.exports = unicodeToArray; | |
27554 | ||
27555 | },{}],309:[function(require,module,exports){ | |
27556 | var copyObject = require('./_copyObject'), | |
27557 | createAssigner = require('./_createAssigner'), | |
27558 | keysIn = require('./keysIn'); | |
27559 | ||
27560 | /** | |
27561 | * This method is like `_.assign` except that it iterates over own and | |
27562 | * inherited source properties. | |
27563 | * | |
27564 | * **Note:** This method mutates `object`. | |
27565 | * | |
27566 | * @static | |
27567 | * @memberOf _ | |
27568 | * @since 4.0.0 | |
27569 | * @alias extend | |
27570 | * @category Object | |
27571 | * @param {Object} object The destination object. | |
27572 | * @param {...Object} [sources] The source objects. | |
27573 | * @returns {Object} Returns `object`. | |
27574 | * @see _.assign | |
27575 | * @example | |
27576 | * | |
27577 | * function Foo() { | |
27578 | * this.a = 1; | |
27579 | * } | |
27580 | * | |
27581 | * function Bar() { | |
27582 | * this.c = 3; | |
27583 | * } | |
27584 | * | |
27585 | * Foo.prototype.b = 2; | |
27586 | * Bar.prototype.d = 4; | |
27587 | * | |
27588 | * _.assignIn({ 'a': 0 }, new Foo, new Bar); | |
27589 | * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } | |
27590 | */ | |
27591 | var assignIn = createAssigner(function(object, source) { | |
27592 | copyObject(source, keysIn(source), object); | |
27593 | }); | |
27594 | ||
27595 | module.exports = assignIn; | |
27596 | ||
27597 | },{"./_copyObject":227,"./_createAssigner":231,"./keysIn":342}],310:[function(require,module,exports){ | |
27598 | var baseClone = require('./_baseClone'); | |
27599 | ||
27600 | /** Used to compose bitmasks for cloning. */ | |
27601 | var CLONE_SYMBOLS_FLAG = 4; | |
27602 | ||
27603 | /** | |
27604 | * Creates a shallow clone of `value`. | |
27605 | * | |
27606 | * **Note:** This method is loosely based on the | |
27607 | * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) | |
27608 | * and supports cloning arrays, array buffers, booleans, date objects, maps, | |
27609 | * numbers, `Object` objects, regexes, sets, strings, symbols, and typed | |
27610 | * arrays. The own enumerable properties of `arguments` objects are cloned | |
27611 | * as plain objects. An empty object is returned for uncloneable values such | |
27612 | * as error objects, functions, DOM nodes, and WeakMaps. | |
27613 | * | |
27614 | * @static | |
27615 | * @memberOf _ | |
27616 | * @since 0.1.0 | |
27617 | * @category Lang | |
27618 | * @param {*} value The value to clone. | |
27619 | * @returns {*} Returns the cloned value. | |
27620 | * @see _.cloneDeep | |
27621 | * @example | |
27622 | * | |
27623 | * var objects = [{ 'a': 1 }, { 'b': 2 }]; | |
27624 | * | |
27625 | * var shallow = _.clone(objects); | |
27626 | * console.log(shallow[0] === objects[0]); | |
27627 | * // => true | |
27628 | */ | |
27629 | function clone(value) { | |
27630 | return baseClone(value, CLONE_SYMBOLS_FLAG); | |
27631 | } | |
27632 | ||
27633 | module.exports = clone; | |
27634 | ||
27635 | },{"./_baseClone":174}],311:[function(require,module,exports){ | |
27636 | /** | |
27637 | * Creates a function that returns `value`. | |
27638 | * | |
27639 | * @static | |
27640 | * @memberOf _ | |
27641 | * @since 2.4.0 | |
27642 | * @category Util | |
27643 | * @param {*} value The value to return from the new function. | |
27644 | * @returns {Function} Returns the new constant function. | |
27645 | * @example | |
27646 | * | |
27647 | * var objects = _.times(2, _.constant({ 'a': 1 })); | |
27648 | * | |
27649 | * console.log(objects); | |
27650 | * // => [{ 'a': 1 }, { 'a': 1 }] | |
27651 | * | |
27652 | * console.log(objects[0] === objects[1]); | |
27653 | * // => true | |
27654 | */ | |
27655 | function constant(value) { | |
27656 | return function() { | |
27657 | return value; | |
27658 | }; | |
27659 | } | |
27660 | ||
27661 | module.exports = constant; | |
27662 | ||
27663 | },{}],312:[function(require,module,exports){ | |
27664 | module.exports = require('./forEach'); | |
27665 | ||
27666 | },{"./forEach":317}],313:[function(require,module,exports){ | |
27667 | /** | |
27668 | * Performs a | |
27669 | * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) | |
27670 | * comparison between two values to determine if they are equivalent. | |
27671 | * | |
27672 | * @static | |
27673 | * @memberOf _ | |
27674 | * @since 4.0.0 | |
27675 | * @category Lang | |
27676 | * @param {*} value The value to compare. | |
27677 | * @param {*} other The other value to compare. | |
27678 | * @returns {boolean} Returns `true` if the values are equivalent, else `false`. | |
27679 | * @example | |
27680 | * | |
27681 | * var object = { 'a': 1 }; | |
27682 | * var other = { 'a': 1 }; | |
27683 | * | |
27684 | * _.eq(object, object); | |
27685 | * // => true | |
27686 | * | |
27687 | * _.eq(object, other); | |
27688 | * // => false | |
27689 | * | |
27690 | * _.eq('a', 'a'); | |
27691 | * // => true | |
27692 | * | |
27693 | * _.eq('a', Object('a')); | |
27694 | * // => false | |
27695 | * | |
27696 | * _.eq(NaN, NaN); | |
27697 | * // => true | |
27698 | */ | |
27699 | function eq(value, other) { | |
27700 | return value === other || (value !== value && other !== other); | |
27701 | } | |
27702 | ||
27703 | module.exports = eq; | |
27704 | ||
27705 | },{}],314:[function(require,module,exports){ | |
27706 | var arrayEvery = require('./_arrayEvery'), | |
27707 | baseEvery = require('./_baseEvery'), | |
27708 | baseIteratee = require('./_baseIteratee'), | |
27709 | isArray = require('./isArray'), | |
27710 | isIterateeCall = require('./_isIterateeCall'); | |
27711 | ||
27712 | /** | |
27713 | * Checks if `predicate` returns truthy for **all** elements of `collection`. | |
27714 | * Iteration is stopped once `predicate` returns falsey. The predicate is | |
27715 | * invoked with three arguments: (value, index|key, collection). | |
27716 | * | |
27717 | * **Note:** This method returns `true` for | |
27718 | * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because | |
27719 | * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of | |
27720 | * elements of empty collections. | |
27721 | * | |
27722 | * @static | |
27723 | * @memberOf _ | |
27724 | * @since 0.1.0 | |
27725 | * @category Collection | |
27726 | * @param {Array|Object} collection The collection to iterate over. | |
27727 | * @param {Function} [predicate=_.identity] The function invoked per iteration. | |
27728 | * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. | |
27729 | * @returns {boolean} Returns `true` if all elements pass the predicate check, | |
27730 | * else `false`. | |
27731 | * @example | |
27732 | * | |
27733 | * _.every([true, 1, null, 'yes'], Boolean); | |
27734 | * // => false | |
27735 | * | |
27736 | * var users = [ | |
27737 | * { 'user': 'barney', 'age': 36, 'active': false }, | |
27738 | * { 'user': 'fred', 'age': 40, 'active': false } | |
27739 | * ]; | |
27740 | * | |
27741 | * // The `_.matches` iteratee shorthand. | |
27742 | * _.every(users, { 'user': 'barney', 'active': false }); | |
27743 | * // => false | |
27744 | * | |
27745 | * // The `_.matchesProperty` iteratee shorthand. | |
27746 | * _.every(users, ['active', false]); | |
27747 | * // => true | |
27748 | * | |
27749 | * // The `_.property` iteratee shorthand. | |
27750 | * _.every(users, 'active'); | |
27751 | * // => false | |
27752 | */ | |
27753 | function every(collection, predicate, guard) { | |
27754 | var func = isArray(collection) ? arrayEvery : baseEvery; | |
27755 | if (guard && isIterateeCall(collection, predicate, guard)) { | |
27756 | predicate = undefined; | |
27757 | } | |
27758 | return func(collection, baseIteratee(predicate, 3)); | |
27759 | } | |
27760 | ||
27761 | module.exports = every; | |
27762 | ||
27763 | },{"./_arrayEvery":161,"./_baseEvery":177,"./_baseIteratee":196,"./_isIterateeCall":264,"./isArray":323}],315:[function(require,module,exports){ | |
27764 | module.exports = require('./assignIn'); | |
27765 | ||
27766 | },{"./assignIn":309}],316:[function(require,module,exports){ | |
27767 | var baseFlatten = require('./_baseFlatten'); | |
27768 | ||
27769 | /** | |
27770 | * Flattens `array` a single level deep. | |
27771 | * | |
27772 | * @static | |
27773 | * @memberOf _ | |
27774 | * @since 0.1.0 | |
27775 | * @category Array | |
27776 | * @param {Array} array The array to flatten. | |
27777 | * @returns {Array} Returns the new flattened array. | |
27778 | * @example | |
27779 | * | |
27780 | * _.flatten([1, [2, [3, [4]], 5]]); | |
27781 | * // => [1, 2, [3, [4]], 5] | |
27782 | */ | |
27783 | function flatten(array) { | |
27784 | var length = array == null ? 0 : array.length; | |
27785 | return length ? baseFlatten(array, 1) : []; | |
27786 | } | |
27787 | ||
27788 | module.exports = flatten; | |
27789 | ||
27790 | },{"./_baseFlatten":179}],317:[function(require,module,exports){ | |
27791 | var arrayEach = require('./_arrayEach'), | |
27792 | baseEach = require('./_baseEach'), | |
27793 | castFunction = require('./_castFunction'), | |
27794 | isArray = require('./isArray'); | |
27795 | ||
27796 | /** | |
27797 | * Iterates over elements of `collection` and invokes `iteratee` for each element. | |
27798 | * The iteratee is invoked with three arguments: (value, index|key, collection). | |
27799 | * Iteratee functions may exit iteration early by explicitly returning `false`. | |
27800 | * | |
27801 | * **Note:** As with other "Collections" methods, objects with a "length" | |
27802 | * property are iterated like arrays. To avoid this behavior use `_.forIn` | |
27803 | * or `_.forOwn` for object iteration. | |
27804 | * | |
27805 | * @static | |
27806 | * @memberOf _ | |
27807 | * @since 0.1.0 | |
27808 | * @alias each | |
27809 | * @category Collection | |
27810 | * @param {Array|Object} collection The collection to iterate over. | |
27811 | * @param {Function} [iteratee=_.identity] The function invoked per iteration. | |
27812 | * @returns {Array|Object} Returns `collection`. | |
27813 | * @see _.forEachRight | |
27814 | * @example | |
27815 | * | |
27816 | * _.forEach([1, 2], function(value) { | |
27817 | * console.log(value); | |
27818 | * }); | |
27819 | * // => Logs `1` then `2`. | |
27820 | * | |
27821 | * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { | |
27822 | * console.log(key); | |
27823 | * }); | |
27824 | * // => Logs 'a' then 'b' (iteration order is not guaranteed). | |
27825 | */ | |
27826 | function forEach(collection, iteratee) { | |
27827 | var func = isArray(collection) ? arrayEach : baseEach; | |
27828 | return func(collection, castFunction(iteratee)); | |
27829 | } | |
27830 | ||
27831 | module.exports = forEach; | |
27832 | ||
27833 | },{"./_arrayEach":160,"./_baseEach":176,"./_castFunction":216,"./isArray":323}],318:[function(require,module,exports){ | |
27834 | /** | |
27835 | * The inverse of `_.toPairs`; this method returns an object composed | |
27836 | * from key-value `pairs`. | |
27837 | * | |
27838 | * @static | |
27839 | * @memberOf _ | |
27840 | * @since 4.0.0 | |
27841 | * @category Array | |
27842 | * @param {Array} pairs The key-value pairs. | |
27843 | * @returns {Object} Returns the new object. | |
27844 | * @example | |
27845 | * | |
27846 | * _.fromPairs([['a', 1], ['b', 2]]); | |
27847 | * // => { 'a': 1, 'b': 2 } | |
27848 | */ | |
27849 | function fromPairs(pairs) { | |
27850 | var index = -1, | |
27851 | length = pairs == null ? 0 : pairs.length, | |
27852 | result = {}; | |
27853 | ||
27854 | while (++index < length) { | |
27855 | var pair = pairs[index]; | |
27856 | result[pair[0]] = pair[1]; | |
27857 | } | |
27858 | return result; | |
27859 | } | |
27860 | ||
27861 | module.exports = fromPairs; | |
27862 | ||
27863 | },{}],319:[function(require,module,exports){ | |
27864 | var baseGet = require('./_baseGet'); | |
27865 | ||
27866 | /** | |
27867 | * Gets the value at `path` of `object`. If the resolved value is | |
27868 | * `undefined`, the `defaultValue` is returned in its place. | |
27869 | * | |
27870 | * @static | |
27871 | * @memberOf _ | |
27872 | * @since 3.7.0 | |
27873 | * @category Object | |
27874 | * @param {Object} object The object to query. | |
27875 | * @param {Array|string} path The path of the property to get. | |
27876 | * @param {*} [defaultValue] The value returned for `undefined` resolved values. | |
27877 | * @returns {*} Returns the resolved value. | |
27878 | * @example | |
27879 | * | |
27880 | * var object = { 'a': [{ 'b': { 'c': 3 } }] }; | |
27881 | * | |
27882 | * _.get(object, 'a[0].b.c'); | |
27883 | * // => 3 | |
27884 | * | |
27885 | * _.get(object, ['a', '0', 'b', 'c']); | |
27886 | * // => 3 | |
27887 | * | |
27888 | * _.get(object, 'a.b.c', 'default'); | |
27889 | * // => 'default' | |
27890 | */ | |
27891 | function get(object, path, defaultValue) { | |
27892 | var result = object == null ? undefined : baseGet(object, path); | |
27893 | return result === undefined ? defaultValue : result; | |
27894 | } | |
27895 | ||
27896 | module.exports = get; | |
27897 | ||
27898 | },{"./_baseGet":182}],320:[function(require,module,exports){ | |
27899 | var baseHasIn = require('./_baseHasIn'), | |
27900 | hasPath = require('./_hasPath'); | |
27901 | ||
27902 | /** | |
27903 | * Checks if `path` is a direct or inherited property of `object`. | |
27904 | * | |
27905 | * @static | |
27906 | * @memberOf _ | |
27907 | * @since 4.0.0 | |
27908 | * @category Object | |
27909 | * @param {Object} object The object to query. | |
27910 | * @param {Array|string} path The path to check. | |
27911 | * @returns {boolean} Returns `true` if `path` exists, else `false`. | |
27912 | * @example | |
27913 | * | |
27914 | * var object = _.create({ 'a': _.create({ 'b': 2 }) }); | |
27915 | * | |
27916 | * _.hasIn(object, 'a'); | |
27917 | * // => true | |
27918 | * | |
27919 | * _.hasIn(object, 'a.b'); | |
27920 | * // => true | |
27921 | * | |
27922 | * _.hasIn(object, ['a', 'b']); | |
27923 | * // => true | |
27924 | * | |
27925 | * _.hasIn(object, 'b'); | |
27926 | * // => false | |
27927 | */ | |
27928 | function hasIn(object, path) { | |
27929 | return object != null && hasPath(object, path, baseHasIn); | |
27930 | } | |
27931 | ||
27932 | module.exports = hasIn; | |
27933 | ||
27934 | },{"./_baseHasIn":185,"./_hasPath":252}],321:[function(require,module,exports){ | |
27935 | /** | |
27936 | * This method returns the first argument it receives. | |
27937 | * | |
27938 | * @static | |
27939 | * @since 0.1.0 | |
27940 | * @memberOf _ | |
27941 | * @category Util | |
27942 | * @param {*} value Any value. | |
27943 | * @returns {*} Returns `value`. | |
27944 | * @example | |
27945 | * | |
27946 | * var object = { 'a': 1 }; | |
27947 | * | |
27948 | * console.log(_.identity(object) === object); | |
27949 | * // => true | |
27950 | */ | |
27951 | function identity(value) { | |
27952 | return value; | |
27953 | } | |
27954 | ||
27955 | module.exports = identity; | |
27956 | ||
27957 | },{}],322:[function(require,module,exports){ | |
27958 | var baseIsArguments = require('./_baseIsArguments'), | |
27959 | isObjectLike = require('./isObjectLike'); | |
27960 | ||
27961 | /** Used for built-in method references. */ | |
27962 | var objectProto = Object.prototype; | |
27963 | ||
27964 | /** Used to check objects for own properties. */ | |
27965 | var hasOwnProperty = objectProto.hasOwnProperty; | |
27966 | ||
27967 | /** Built-in value references. */ | |
27968 | var propertyIsEnumerable = objectProto.propertyIsEnumerable; | |
27969 | ||
27970 | /** | |
27971 | * Checks if `value` is likely an `arguments` object. | |
27972 | * | |
27973 | * @static | |
27974 | * @memberOf _ | |
27975 | * @since 0.1.0 | |
27976 | * @category Lang | |
27977 | * @param {*} value The value to check. | |
27978 | * @returns {boolean} Returns `true` if `value` is an `arguments` object, | |
27979 | * else `false`. | |
27980 | * @example | |
27981 | * | |
27982 | * _.isArguments(function() { return arguments; }()); | |
27983 | * // => true | |
27984 | * | |
27985 | * _.isArguments([1, 2, 3]); | |
27986 | * // => false | |
27987 | */ | |
27988 | var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { | |
27989 | return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && | |
27990 | !propertyIsEnumerable.call(value, 'callee'); | |
27991 | }; | |
27992 | ||
27993 | module.exports = isArguments; | |
27994 | ||
27995 | },{"./_baseIsArguments":187,"./isObjectLike":334}],323:[function(require,module,exports){ | |
27996 | /** | |
27997 | * Checks if `value` is classified as an `Array` object. | |
27998 | * | |
27999 | * @static | |
28000 | * @memberOf _ | |
28001 | * @since 0.1.0 | |
28002 | * @category Lang | |
28003 | * @param {*} value The value to check. | |
28004 | * @returns {boolean} Returns `true` if `value` is an array, else `false`. | |
28005 | * @example | |
28006 | * | |
28007 | * _.isArray([1, 2, 3]); | |
28008 | * // => true | |
28009 | * | |
28010 | * _.isArray(document.body.children); | |
28011 | * // => false | |
28012 | * | |
28013 | * _.isArray('abc'); | |
28014 | * // => false | |
28015 | * | |
28016 | * _.isArray(_.noop); | |
28017 | * // => false | |
28018 | */ | |
28019 | var isArray = Array.isArray; | |
28020 | ||
28021 | module.exports = isArray; | |
28022 | ||
28023 | },{}],324:[function(require,module,exports){ | |
28024 | var isFunction = require('./isFunction'), | |
28025 | isLength = require('./isLength'); | |
28026 | ||
28027 | /** | |
28028 | * Checks if `value` is array-like. A value is considered array-like if it's | |
28029 | * not a function and has a `value.length` that's an integer greater than or | |
28030 | * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. | |
28031 | * | |
28032 | * @static | |
28033 | * @memberOf _ | |
28034 | * @since 4.0.0 | |
28035 | * @category Lang | |
28036 | * @param {*} value The value to check. | |
28037 | * @returns {boolean} Returns `true` if `value` is array-like, else `false`. | |
28038 | * @example | |
28039 | * | |
28040 | * _.isArrayLike([1, 2, 3]); | |
28041 | * // => true | |
28042 | * | |
28043 | * _.isArrayLike(document.body.children); | |
28044 | * // => true | |
28045 | * | |
28046 | * _.isArrayLike('abc'); | |
28047 | * // => true | |
28048 | * | |
28049 | * _.isArrayLike(_.noop); | |
28050 | * // => false | |
28051 | */ | |
28052 | function isArrayLike(value) { | |
28053 | return value != null && isLength(value.length) && !isFunction(value); | |
28054 | } | |
28055 | ||
28056 | module.exports = isArrayLike; | |
28057 | ||
28058 | },{"./isFunction":328,"./isLength":329}],325:[function(require,module,exports){ | |
28059 | var baseGetTag = require('./_baseGetTag'), | |
28060 | isObjectLike = require('./isObjectLike'); | |
28061 | ||
28062 | /** `Object#toString` result references. */ | |
28063 | var boolTag = '[object Boolean]'; | |
28064 | ||
28065 | /** | |
28066 | * Checks if `value` is classified as a boolean primitive or object. | |
28067 | * | |
28068 | * @static | |
28069 | * @memberOf _ | |
28070 | * @since 0.1.0 | |
28071 | * @category Lang | |
28072 | * @param {*} value The value to check. | |
28073 | * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. | |
28074 | * @example | |
28075 | * | |
28076 | * _.isBoolean(false); | |
28077 | * // => true | |
28078 | * | |
28079 | * _.isBoolean(null); | |
28080 | * // => false | |
28081 | */ | |
28082 | function isBoolean(value) { | |
28083 | return value === true || value === false || | |
28084 | (isObjectLike(value) && baseGetTag(value) == boolTag); | |
28085 | } | |
28086 | ||
28087 | module.exports = isBoolean; | |
28088 | ||
28089 | },{"./_baseGetTag":184,"./isObjectLike":334}],326:[function(require,module,exports){ | |
28090 | var root = require('./_root'), | |
28091 | stubFalse = require('./stubFalse'); | |
28092 | ||
28093 | /** Detect free variable `exports`. */ | |
28094 | var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; | |
28095 | ||
28096 | /** Detect free variable `module`. */ | |
28097 | var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; | |
28098 | ||
28099 | /** Detect the popular CommonJS extension `module.exports`. */ | |
28100 | var moduleExports = freeModule && freeModule.exports === freeExports; | |
28101 | ||
28102 | /** Built-in value references. */ | |
28103 | var Buffer = moduleExports ? root.Buffer : undefined; | |
28104 | ||
28105 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
28106 | var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; | |
28107 | ||
28108 | /** | |
28109 | * Checks if `value` is a buffer. | |
28110 | * | |
28111 | * @static | |
28112 | * @memberOf _ | |
28113 | * @since 4.3.0 | |
28114 | * @category Lang | |
28115 | * @param {*} value The value to check. | |
28116 | * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. | |
28117 | * @example | |
28118 | * | |
28119 | * _.isBuffer(new Buffer(2)); | |
28120 | * // => true | |
28121 | * | |
28122 | * _.isBuffer(new Uint8Array(2)); | |
28123 | * // => false | |
28124 | */ | |
28125 | var isBuffer = nativeIsBuffer || stubFalse; | |
28126 | ||
28127 | module.exports = isBuffer; | |
28128 | ||
28129 | },{"./_root":290,"./stubFalse":349}],327:[function(require,module,exports){ | |
28130 | var root = require('./_root'); | |
28131 | ||
28132 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
28133 | var nativeIsFinite = root.isFinite; | |
28134 | ||
28135 | /** | |
28136 | * Checks if `value` is a finite primitive number. | |
28137 | * | |
28138 | * **Note:** This method is based on | |
28139 | * [`Number.isFinite`](https://mdn.io/Number/isFinite). | |
28140 | * | |
28141 | * @static | |
28142 | * @memberOf _ | |
28143 | * @since 0.1.0 | |
28144 | * @category Lang | |
28145 | * @param {*} value The value to check. | |
28146 | * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. | |
28147 | * @example | |
28148 | * | |
28149 | * _.isFinite(3); | |
28150 | * // => true | |
28151 | * | |
28152 | * _.isFinite(Number.MIN_VALUE); | |
28153 | * // => true | |
28154 | * | |
28155 | * _.isFinite(Infinity); | |
28156 | * // => false | |
28157 | * | |
28158 | * _.isFinite('3'); | |
28159 | * // => false | |
28160 | */ | |
28161 | function isFinite(value) { | |
28162 | return typeof value == 'number' && nativeIsFinite(value); | |
28163 | } | |
28164 | ||
28165 | module.exports = isFinite; | |
28166 | ||
28167 | },{"./_root":290}],328:[function(require,module,exports){ | |
28168 | var baseGetTag = require('./_baseGetTag'), | |
28169 | isObject = require('./isObject'); | |
28170 | ||
28171 | /** `Object#toString` result references. */ | |
28172 | var asyncTag = '[object AsyncFunction]', | |
28173 | funcTag = '[object Function]', | |
28174 | genTag = '[object GeneratorFunction]', | |
28175 | proxyTag = '[object Proxy]'; | |
28176 | ||
28177 | /** | |
28178 | * Checks if `value` is classified as a `Function` object. | |
28179 | * | |
28180 | * @static | |
28181 | * @memberOf _ | |
28182 | * @since 0.1.0 | |
28183 | * @category Lang | |
28184 | * @param {*} value The value to check. | |
28185 | * @returns {boolean} Returns `true` if `value` is a function, else `false`. | |
28186 | * @example | |
28187 | * | |
28188 | * _.isFunction(_); | |
28189 | * // => true | |
28190 | * | |
28191 | * _.isFunction(/abc/); | |
28192 | * // => false | |
28193 | */ | |
28194 | function isFunction(value) { | |
28195 | if (!isObject(value)) { | |
28196 | return false; | |
28197 | } | |
28198 | // The use of `Object#toString` avoids issues with the `typeof` operator | |
28199 | // in Safari 9 which returns 'object' for typed arrays and other constructors. | |
28200 | var tag = baseGetTag(value); | |
28201 | return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; | |
28202 | } | |
28203 | ||
28204 | module.exports = isFunction; | |
28205 | ||
28206 | },{"./_baseGetTag":184,"./isObject":333}],329:[function(require,module,exports){ | |
28207 | /** Used as references for various `Number` constants. */ | |
28208 | var MAX_SAFE_INTEGER = 9007199254740991; | |
28209 | ||
28210 | /** | |
28211 | * Checks if `value` is a valid array-like length. | |
28212 | * | |
28213 | * **Note:** This method is loosely based on | |
28214 | * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). | |
28215 | * | |
28216 | * @static | |
28217 | * @memberOf _ | |
28218 | * @since 4.0.0 | |
28219 | * @category Lang | |
28220 | * @param {*} value The value to check. | |
28221 | * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. | |
28222 | * @example | |
28223 | * | |
28224 | * _.isLength(3); | |
28225 | * // => true | |
28226 | * | |
28227 | * _.isLength(Number.MIN_VALUE); | |
28228 | * // => false | |
28229 | * | |
28230 | * _.isLength(Infinity); | |
28231 | * // => false | |
28232 | * | |
28233 | * _.isLength('3'); | |
28234 | * // => false | |
28235 | */ | |
28236 | function isLength(value) { | |
28237 | return typeof value == 'number' && | |
28238 | value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; | |
28239 | } | |
28240 | ||
28241 | module.exports = isLength; | |
28242 | ||
28243 | },{}],330:[function(require,module,exports){ | |
28244 | var baseIsMap = require('./_baseIsMap'), | |
28245 | baseUnary = require('./_baseUnary'), | |
28246 | nodeUtil = require('./_nodeUtil'); | |
28247 | ||
28248 | /* Node.js helper references. */ | |
28249 | var nodeIsMap = nodeUtil && nodeUtil.isMap; | |
28250 | ||
28251 | /** | |
28252 | * Checks if `value` is classified as a `Map` object. | |
28253 | * | |
28254 | * @static | |
28255 | * @memberOf _ | |
28256 | * @since 4.3.0 | |
28257 | * @category Lang | |
28258 | * @param {*} value The value to check. | |
28259 | * @returns {boolean} Returns `true` if `value` is a map, else `false`. | |
28260 | * @example | |
28261 | * | |
28262 | * _.isMap(new Map); | |
28263 | * // => true | |
28264 | * | |
28265 | * _.isMap(new WeakMap); | |
28266 | * // => false | |
28267 | */ | |
28268 | var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; | |
28269 | ||
28270 | module.exports = isMap; | |
28271 | ||
28272 | },{"./_baseIsMap":190,"./_baseUnary":213,"./_nodeUtil":286}],331:[function(require,module,exports){ | |
28273 | /** | |
28274 | * Checks if `value` is `null`. | |
28275 | * | |
28276 | * @static | |
28277 | * @memberOf _ | |
28278 | * @since 0.1.0 | |
28279 | * @category Lang | |
28280 | * @param {*} value The value to check. | |
28281 | * @returns {boolean} Returns `true` if `value` is `null`, else `false`. | |
28282 | * @example | |
28283 | * | |
28284 | * _.isNull(null); | |
28285 | * // => true | |
28286 | * | |
28287 | * _.isNull(void 0); | |
28288 | * // => false | |
28289 | */ | |
28290 | function isNull(value) { | |
28291 | return value === null; | |
28292 | } | |
28293 | ||
28294 | module.exports = isNull; | |
28295 | ||
28296 | },{}],332:[function(require,module,exports){ | |
28297 | var baseGetTag = require('./_baseGetTag'), | |
28298 | isObjectLike = require('./isObjectLike'); | |
28299 | ||
28300 | /** `Object#toString` result references. */ | |
28301 | var numberTag = '[object Number]'; | |
28302 | ||
28303 | /** | |
28304 | * Checks if `value` is classified as a `Number` primitive or object. | |
28305 | * | |
28306 | * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are | |
28307 | * classified as numbers, use the `_.isFinite` method. | |
28308 | * | |
28309 | * @static | |
28310 | * @memberOf _ | |
28311 | * @since 0.1.0 | |
28312 | * @category Lang | |
28313 | * @param {*} value The value to check. | |
28314 | * @returns {boolean} Returns `true` if `value` is a number, else `false`. | |
28315 | * @example | |
28316 | * | |
28317 | * _.isNumber(3); | |
28318 | * // => true | |
28319 | * | |
28320 | * _.isNumber(Number.MIN_VALUE); | |
28321 | * // => true | |
28322 | * | |
28323 | * _.isNumber(Infinity); | |
28324 | * // => true | |
28325 | * | |
28326 | * _.isNumber('3'); | |
28327 | * // => false | |
28328 | */ | |
28329 | function isNumber(value) { | |
28330 | return typeof value == 'number' || | |
28331 | (isObjectLike(value) && baseGetTag(value) == numberTag); | |
28332 | } | |
28333 | ||
28334 | module.exports = isNumber; | |
28335 | ||
28336 | },{"./_baseGetTag":184,"./isObjectLike":334}],333:[function(require,module,exports){ | |
28337 | /** | |
28338 | * Checks if `value` is the | |
28339 | * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) | |
28340 | * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) | |
28341 | * | |
28342 | * @static | |
28343 | * @memberOf _ | |
28344 | * @since 0.1.0 | |
28345 | * @category Lang | |
28346 | * @param {*} value The value to check. | |
28347 | * @returns {boolean} Returns `true` if `value` is an object, else `false`. | |
28348 | * @example | |
28349 | * | |
28350 | * _.isObject({}); | |
28351 | * // => true | |
28352 | * | |
28353 | * _.isObject([1, 2, 3]); | |
28354 | * // => true | |
28355 | * | |
28356 | * _.isObject(_.noop); | |
28357 | * // => true | |
28358 | * | |
28359 | * _.isObject(null); | |
28360 | * // => false | |
28361 | */ | |
28362 | function isObject(value) { | |
28363 | var type = typeof value; | |
28364 | return value != null && (type == 'object' || type == 'function'); | |
28365 | } | |
28366 | ||
28367 | module.exports = isObject; | |
28368 | ||
28369 | },{}],334:[function(require,module,exports){ | |
28370 | /** | |
28371 | * Checks if `value` is object-like. A value is object-like if it's not `null` | |
28372 | * and has a `typeof` result of "object". | |
28373 | * | |
28374 | * @static | |
28375 | * @memberOf _ | |
28376 | * @since 4.0.0 | |
28377 | * @category Lang | |
28378 | * @param {*} value The value to check. | |
28379 | * @returns {boolean} Returns `true` if `value` is object-like, else `false`. | |
28380 | * @example | |
28381 | * | |
28382 | * _.isObjectLike({}); | |
28383 | * // => true | |
28384 | * | |
28385 | * _.isObjectLike([1, 2, 3]); | |
28386 | * // => true | |
28387 | * | |
28388 | * _.isObjectLike(_.noop); | |
28389 | * // => false | |
28390 | * | |
28391 | * _.isObjectLike(null); | |
28392 | * // => false | |
28393 | */ | |
28394 | function isObjectLike(value) { | |
28395 | return value != null && typeof value == 'object'; | |
28396 | } | |
28397 | ||
28398 | module.exports = isObjectLike; | |
28399 | ||
28400 | },{}],335:[function(require,module,exports){ | |
28401 | var baseGetTag = require('./_baseGetTag'), | |
28402 | getPrototype = require('./_getPrototype'), | |
28403 | isObjectLike = require('./isObjectLike'); | |
28404 | ||
28405 | /** `Object#toString` result references. */ | |
28406 | var objectTag = '[object Object]'; | |
28407 | ||
28408 | /** Used for built-in method references. */ | |
28409 | var funcProto = Function.prototype, | |
28410 | objectProto = Object.prototype; | |
28411 | ||
28412 | /** Used to resolve the decompiled source of functions. */ | |
28413 | var funcToString = funcProto.toString; | |
28414 | ||
28415 | /** Used to check objects for own properties. */ | |
28416 | var hasOwnProperty = objectProto.hasOwnProperty; | |
28417 | ||
28418 | /** Used to infer the `Object` constructor. */ | |
28419 | var objectCtorString = funcToString.call(Object); | |
28420 | ||
28421 | /** | |
28422 | * Checks if `value` is a plain object, that is, an object created by the | |
28423 | * `Object` constructor or one with a `[[Prototype]]` of `null`. | |
28424 | * | |
28425 | * @static | |
28426 | * @memberOf _ | |
28427 | * @since 0.8.0 | |
28428 | * @category Lang | |
28429 | * @param {*} value The value to check. | |
28430 | * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. | |
28431 | * @example | |
28432 | * | |
28433 | * function Foo() { | |
28434 | * this.a = 1; | |
28435 | * } | |
28436 | * | |
28437 | * _.isPlainObject(new Foo); | |
28438 | * // => false | |
28439 | * | |
28440 | * _.isPlainObject([1, 2, 3]); | |
28441 | * // => false | |
28442 | * | |
28443 | * _.isPlainObject({ 'x': 0, 'y': 0 }); | |
28444 | * // => true | |
28445 | * | |
28446 | * _.isPlainObject(Object.create(null)); | |
28447 | * // => true | |
28448 | */ | |
28449 | function isPlainObject(value) { | |
28450 | if (!isObjectLike(value) || baseGetTag(value) != objectTag) { | |
28451 | return false; | |
28452 | } | |
28453 | var proto = getPrototype(value); | |
28454 | if (proto === null) { | |
28455 | return true; | |
28456 | } | |
28457 | var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; | |
28458 | return typeof Ctor == 'function' && Ctor instanceof Ctor && | |
28459 | funcToString.call(Ctor) == objectCtorString; | |
28460 | } | |
28461 | ||
28462 | module.exports = isPlainObject; | |
28463 | ||
28464 | },{"./_baseGetTag":184,"./_getPrototype":246,"./isObjectLike":334}],336:[function(require,module,exports){ | |
28465 | var baseIsSet = require('./_baseIsSet'), | |
28466 | baseUnary = require('./_baseUnary'), | |
28467 | nodeUtil = require('./_nodeUtil'); | |
28468 | ||
28469 | /* Node.js helper references. */ | |
28470 | var nodeIsSet = nodeUtil && nodeUtil.isSet; | |
28471 | ||
28472 | /** | |
28473 | * Checks if `value` is classified as a `Set` object. | |
28474 | * | |
28475 | * @static | |
28476 | * @memberOf _ | |
28477 | * @since 4.3.0 | |
28478 | * @category Lang | |
28479 | * @param {*} value The value to check. | |
28480 | * @returns {boolean} Returns `true` if `value` is a set, else `false`. | |
28481 | * @example | |
28482 | * | |
28483 | * _.isSet(new Set); | |
28484 | * // => true | |
28485 | * | |
28486 | * _.isSet(new WeakSet); | |
28487 | * // => false | |
28488 | */ | |
28489 | var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; | |
28490 | ||
28491 | module.exports = isSet; | |
28492 | ||
28493 | },{"./_baseIsSet":194,"./_baseUnary":213,"./_nodeUtil":286}],337:[function(require,module,exports){ | |
28494 | var baseGetTag = require('./_baseGetTag'), | |
28495 | isArray = require('./isArray'), | |
28496 | isObjectLike = require('./isObjectLike'); | |
28497 | ||
28498 | /** `Object#toString` result references. */ | |
28499 | var stringTag = '[object String]'; | |
28500 | ||
28501 | /** | |
28502 | * Checks if `value` is classified as a `String` primitive or object. | |
28503 | * | |
28504 | * @static | |
28505 | * @since 0.1.0 | |
28506 | * @memberOf _ | |
28507 | * @category Lang | |
28508 | * @param {*} value The value to check. | |
28509 | * @returns {boolean} Returns `true` if `value` is a string, else `false`. | |
28510 | * @example | |
28511 | * | |
28512 | * _.isString('abc'); | |
28513 | * // => true | |
28514 | * | |
28515 | * _.isString(1); | |
28516 | * // => false | |
28517 | */ | |
28518 | function isString(value) { | |
28519 | return typeof value == 'string' || | |
28520 | (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); | |
28521 | } | |
28522 | ||
28523 | module.exports = isString; | |
28524 | ||
28525 | },{"./_baseGetTag":184,"./isArray":323,"./isObjectLike":334}],338:[function(require,module,exports){ | |
28526 | var baseGetTag = require('./_baseGetTag'), | |
28527 | isObjectLike = require('./isObjectLike'); | |
28528 | ||
28529 | /** `Object#toString` result references. */ | |
28530 | var symbolTag = '[object Symbol]'; | |
28531 | ||
28532 | /** | |
28533 | * Checks if `value` is classified as a `Symbol` primitive or object. | |
28534 | * | |
28535 | * @static | |
28536 | * @memberOf _ | |
28537 | * @since 4.0.0 | |
28538 | * @category Lang | |
28539 | * @param {*} value The value to check. | |
28540 | * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. | |
28541 | * @example | |
28542 | * | |
28543 | * _.isSymbol(Symbol.iterator); | |
28544 | * // => true | |
28545 | * | |
28546 | * _.isSymbol('abc'); | |
28547 | * // => false | |
28548 | */ | |
28549 | function isSymbol(value) { | |
28550 | return typeof value == 'symbol' || | |
28551 | (isObjectLike(value) && baseGetTag(value) == symbolTag); | |
28552 | } | |
28553 | ||
28554 | module.exports = isSymbol; | |
28555 | ||
28556 | },{"./_baseGetTag":184,"./isObjectLike":334}],339:[function(require,module,exports){ | |
28557 | var baseIsTypedArray = require('./_baseIsTypedArray'), | |
28558 | baseUnary = require('./_baseUnary'), | |
28559 | nodeUtil = require('./_nodeUtil'); | |
28560 | ||
28561 | /* Node.js helper references. */ | |
28562 | var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; | |
28563 | ||
28564 | /** | |
28565 | * Checks if `value` is classified as a typed array. | |
28566 | * | |
28567 | * @static | |
28568 | * @memberOf _ | |
28569 | * @since 3.0.0 | |
28570 | * @category Lang | |
28571 | * @param {*} value The value to check. | |
28572 | * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. | |
28573 | * @example | |
28574 | * | |
28575 | * _.isTypedArray(new Uint8Array); | |
28576 | * // => true | |
28577 | * | |
28578 | * _.isTypedArray([]); | |
28579 | * // => false | |
28580 | */ | |
28581 | var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; | |
28582 | ||
28583 | module.exports = isTypedArray; | |
28584 | ||
28585 | },{"./_baseIsTypedArray":195,"./_baseUnary":213,"./_nodeUtil":286}],340:[function(require,module,exports){ | |
28586 | /** | |
28587 | * Checks if `value` is `undefined`. | |
28588 | * | |
28589 | * @static | |
28590 | * @since 0.1.0 | |
28591 | * @memberOf _ | |
28592 | * @category Lang | |
28593 | * @param {*} value The value to check. | |
28594 | * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. | |
28595 | * @example | |
28596 | * | |
28597 | * _.isUndefined(void 0); | |
28598 | * // => true | |
28599 | * | |
28600 | * _.isUndefined(null); | |
28601 | * // => false | |
28602 | */ | |
28603 | function isUndefined(value) { | |
28604 | return value === undefined; | |
28605 | } | |
28606 | ||
28607 | module.exports = isUndefined; | |
28608 | ||
28609 | },{}],341:[function(require,module,exports){ | |
28610 | var arrayLikeKeys = require('./_arrayLikeKeys'), | |
28611 | baseKeys = require('./_baseKeys'), | |
28612 | isArrayLike = require('./isArrayLike'); | |
28613 | ||
28614 | /** | |
28615 | * Creates an array of the own enumerable property names of `object`. | |
28616 | * | |
28617 | * **Note:** Non-object values are coerced to objects. See the | |
28618 | * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) | |
28619 | * for more details. | |
28620 | * | |
28621 | * @static | |
28622 | * @since 0.1.0 | |
28623 | * @memberOf _ | |
28624 | * @category Object | |
28625 | * @param {Object} object The object to query. | |
28626 | * @returns {Array} Returns the array of property names. | |
28627 | * @example | |
28628 | * | |
28629 | * function Foo() { | |
28630 | * this.a = 1; | |
28631 | * this.b = 2; | |
28632 | * } | |
28633 | * | |
28634 | * Foo.prototype.c = 3; | |
28635 | * | |
28636 | * _.keys(new Foo); | |
28637 | * // => ['a', 'b'] (iteration order is not guaranteed) | |
28638 | * | |
28639 | * _.keys('hi'); | |
28640 | * // => ['0', '1'] | |
28641 | */ | |
28642 | function keys(object) { | |
28643 | return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); | |
28644 | } | |
28645 | ||
28646 | module.exports = keys; | |
28647 | ||
28648 | },{"./_arrayLikeKeys":163,"./_baseKeys":197,"./isArrayLike":324}],342:[function(require,module,exports){ | |
28649 | var arrayLikeKeys = require('./_arrayLikeKeys'), | |
28650 | baseKeysIn = require('./_baseKeysIn'), | |
28651 | isArrayLike = require('./isArrayLike'); | |
28652 | ||
28653 | /** | |
28654 | * Creates an array of the own and inherited enumerable property names of `object`. | |
28655 | * | |
28656 | * **Note:** Non-object values are coerced to objects. | |
28657 | * | |
28658 | * @static | |
28659 | * @memberOf _ | |
28660 | * @since 3.0.0 | |
28661 | * @category Object | |
28662 | * @param {Object} object The object to query. | |
28663 | * @returns {Array} Returns the array of property names. | |
28664 | * @example | |
28665 | * | |
28666 | * function Foo() { | |
28667 | * this.a = 1; | |
28668 | * this.b = 2; | |
28669 | * } | |
28670 | * | |
28671 | * Foo.prototype.c = 3; | |
28672 | * | |
28673 | * _.keysIn(new Foo); | |
28674 | * // => ['a', 'b', 'c'] (iteration order is not guaranteed) | |
28675 | */ | |
28676 | function keysIn(object) { | |
28677 | return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); | |
28678 | } | |
28679 | ||
28680 | module.exports = keysIn; | |
28681 | ||
28682 | },{"./_arrayLikeKeys":163,"./_baseKeysIn":198,"./isArrayLike":324}],343:[function(require,module,exports){ | |
28683 | var arrayMap = require('./_arrayMap'), | |
28684 | baseIteratee = require('./_baseIteratee'), | |
28685 | baseMap = require('./_baseMap'), | |
28686 | isArray = require('./isArray'); | |
28687 | ||
28688 | /** | |
28689 | * Creates an array of values by running each element in `collection` thru | |
28690 | * `iteratee`. The iteratee is invoked with three arguments: | |
28691 | * (value, index|key, collection). | |
28692 | * | |
28693 | * Many lodash methods are guarded to work as iteratees for methods like | |
28694 | * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. | |
28695 | * | |
28696 | * The guarded methods are: | |
28697 | * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, | |
28698 | * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, | |
28699 | * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, | |
28700 | * `template`, `trim`, `trimEnd`, `trimStart`, and `words` | |
28701 | * | |
28702 | * @static | |
28703 | * @memberOf _ | |
28704 | * @since 0.1.0 | |
28705 | * @category Collection | |
28706 | * @param {Array|Object} collection The collection to iterate over. | |
28707 | * @param {Function} [iteratee=_.identity] The function invoked per iteration. | |
28708 | * @returns {Array} Returns the new mapped array. | |
28709 | * @example | |
28710 | * | |
28711 | * function square(n) { | |
28712 | * return n * n; | |
28713 | * } | |
28714 | * | |
28715 | * _.map([4, 8], square); | |
28716 | * // => [16, 64] | |
28717 | * | |
28718 | * _.map({ 'a': 4, 'b': 8 }, square); | |
28719 | * // => [16, 64] (iteration order is not guaranteed) | |
28720 | * | |
28721 | * var users = [ | |
28722 | * { 'user': 'barney' }, | |
28723 | * { 'user': 'fred' } | |
28724 | * ]; | |
28725 | * | |
28726 | * // The `_.property` iteratee shorthand. | |
28727 | * _.map(users, 'user'); | |
28728 | * // => ['barney', 'fred'] | |
28729 | */ | |
28730 | function map(collection, iteratee) { | |
28731 | var func = isArray(collection) ? arrayMap : baseMap; | |
28732 | return func(collection, baseIteratee(iteratee, 3)); | |
28733 | } | |
28734 | ||
28735 | module.exports = map; | |
28736 | ||
28737 | },{"./_arrayMap":164,"./_baseIteratee":196,"./_baseMap":199,"./isArray":323}],344:[function(require,module,exports){ | |
28738 | var MapCache = require('./_MapCache'); | |
28739 | ||
28740 | /** Error message constants. */ | |
28741 | var FUNC_ERROR_TEXT = 'Expected a function'; | |
28742 | ||
28743 | /** | |
28744 | * Creates a function that memoizes the result of `func`. If `resolver` is | |
28745 | * provided, it determines the cache key for storing the result based on the | |
28746 | * arguments provided to the memoized function. By default, the first argument | |
28747 | * provided to the memoized function is used as the map cache key. The `func` | |
28748 | * is invoked with the `this` binding of the memoized function. | |
28749 | * | |
28750 | * **Note:** The cache is exposed as the `cache` property on the memoized | |
28751 | * function. Its creation may be customized by replacing the `_.memoize.Cache` | |
28752 | * constructor with one whose instances implement the | |
28753 | * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) | |
28754 | * method interface of `clear`, `delete`, `get`, `has`, and `set`. | |
28755 | * | |
28756 | * @static | |
28757 | * @memberOf _ | |
28758 | * @since 0.1.0 | |
28759 | * @category Function | |
28760 | * @param {Function} func The function to have its output memoized. | |
28761 | * @param {Function} [resolver] The function to resolve the cache key. | |
28762 | * @returns {Function} Returns the new memoized function. | |
28763 | * @example | |
28764 | * | |
28765 | * var object = { 'a': 1, 'b': 2 }; | |
28766 | * var other = { 'c': 3, 'd': 4 }; | |
28767 | * | |
28768 | * var values = _.memoize(_.values); | |
28769 | * values(object); | |
28770 | * // => [1, 2] | |
28771 | * | |
28772 | * values(other); | |
28773 | * // => [3, 4] | |
28774 | * | |
28775 | * object.a = 2; | |
28776 | * values(object); | |
28777 | * // => [1, 2] | |
28778 | * | |
28779 | * // Modify the result cache. | |
28780 | * values.cache.set(object, ['a', 'b']); | |
28781 | * values(object); | |
28782 | * // => ['a', 'b'] | |
28783 | * | |
28784 | * // Replace `_.memoize.Cache`. | |
28785 | * _.memoize.Cache = WeakMap; | |
28786 | */ | |
28787 | function memoize(func, resolver) { | |
28788 | if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { | |
28789 | throw new TypeError(FUNC_ERROR_TEXT); | |
28790 | } | |
28791 | var memoized = function() { | |
28792 | var args = arguments, | |
28793 | key = resolver ? resolver.apply(this, args) : args[0], | |
28794 | cache = memoized.cache; | |
28795 | ||
28796 | if (cache.has(key)) { | |
28797 | return cache.get(key); | |
28798 | } | |
28799 | var result = func.apply(this, args); | |
28800 | memoized.cache = cache.set(key, result) || cache; | |
28801 | return result; | |
28802 | }; | |
28803 | memoized.cache = new (memoize.Cache || MapCache); | |
28804 | return memoized; | |
28805 | } | |
28806 | ||
28807 | // Expose `MapCache`. | |
28808 | memoize.Cache = MapCache; | |
28809 | ||
28810 | module.exports = memoize; | |
28811 | ||
28812 | },{"./_MapCache":151}],345:[function(require,module,exports){ | |
28813 | var createPadding = require('./_createPadding'), | |
28814 | stringSize = require('./_stringSize'), | |
28815 | toInteger = require('./toInteger'), | |
28816 | toString = require('./toString'); | |
28817 | ||
28818 | /** | |
28819 | * Pads `string` on the right side if it's shorter than `length`. Padding | |
28820 | * characters are truncated if they exceed `length`. | |
28821 | * | |
28822 | * @static | |
28823 | * @memberOf _ | |
28824 | * @since 4.0.0 | |
28825 | * @category String | |
28826 | * @param {string} [string=''] The string to pad. | |
28827 | * @param {number} [length=0] The padding length. | |
28828 | * @param {string} [chars=' '] The string used as padding. | |
28829 | * @returns {string} Returns the padded string. | |
28830 | * @example | |
28831 | * | |
28832 | * _.padEnd('abc', 6); | |
28833 | * // => 'abc ' | |
28834 | * | |
28835 | * _.padEnd('abc', 6, '_-'); | |
28836 | * // => 'abc_-_' | |
28837 | * | |
28838 | * _.padEnd('abc', 3); | |
28839 | * // => 'abc' | |
28840 | */ | |
28841 | function padEnd(string, length, chars) { | |
28842 | string = toString(string); | |
28843 | length = toInteger(length); | |
28844 | ||
28845 | var strLength = length ? stringSize(string) : 0; | |
28846 | return (length && strLength < length) | |
28847 | ? (string + createPadding(length - strLength, chars)) | |
28848 | : string; | |
28849 | } | |
28850 | ||
28851 | module.exports = padEnd; | |
28852 | ||
28853 | },{"./_createPadding":234,"./_stringSize":302,"./toInteger":352,"./toString":354}],346:[function(require,module,exports){ | |
28854 | var basePick = require('./_basePick'), | |
28855 | flatRest = require('./_flatRest'); | |
28856 | ||
28857 | /** | |
28858 | * Creates an object composed of the picked `object` properties. | |
28859 | * | |
28860 | * @static | |
28861 | * @since 0.1.0 | |
28862 | * @memberOf _ | |
28863 | * @category Object | |
28864 | * @param {Object} object The source object. | |
28865 | * @param {...(string|string[])} [paths] The property paths to pick. | |
28866 | * @returns {Object} Returns the new object. | |
28867 | * @example | |
28868 | * | |
28869 | * var object = { 'a': 1, 'b': '2', 'c': 3 }; | |
28870 | * | |
28871 | * _.pick(object, ['a', 'c']); | |
28872 | * // => { 'a': 1, 'c': 3 } | |
28873 | */ | |
28874 | var pick = flatRest(function(object, paths) { | |
28875 | return object == null ? {} : basePick(object, paths); | |
28876 | }); | |
28877 | ||
28878 | module.exports = pick; | |
28879 | ||
28880 | },{"./_basePick":202,"./_flatRest":239}],347:[function(require,module,exports){ | |
28881 | var baseProperty = require('./_baseProperty'), | |
28882 | basePropertyDeep = require('./_basePropertyDeep'), | |
28883 | isKey = require('./_isKey'), | |
28884 | toKey = require('./_toKey'); | |
28885 | ||
28886 | /** | |
28887 | * Creates a function that returns the value at `path` of a given object. | |
28888 | * | |
28889 | * @static | |
28890 | * @memberOf _ | |
28891 | * @since 2.4.0 | |
28892 | * @category Util | |
28893 | * @param {Array|string} path The path of the property to get. | |
28894 | * @returns {Function} Returns the new accessor function. | |
28895 | * @example | |
28896 | * | |
28897 | * var objects = [ | |
28898 | * { 'a': { 'b': 2 } }, | |
28899 | * { 'a': { 'b': 1 } } | |
28900 | * ]; | |
28901 | * | |
28902 | * _.map(objects, _.property('a.b')); | |
28903 | * // => [2, 1] | |
28904 | * | |
28905 | * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b'); | |
28906 | * // => [1, 2] | |
28907 | */ | |
28908 | function property(path) { | |
28909 | return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); | |
28910 | } | |
28911 | ||
28912 | module.exports = property; | |
28913 | ||
28914 | },{"./_baseProperty":204,"./_basePropertyDeep":205,"./_isKey":265,"./_toKey":305}],348:[function(require,module,exports){ | |
28915 | /** | |
28916 | * This method returns a new empty array. | |
28917 | * | |
28918 | * @static | |
28919 | * @memberOf _ | |
28920 | * @since 4.13.0 | |
28921 | * @category Util | |
28922 | * @returns {Array} Returns the new empty array. | |
28923 | * @example | |
28924 | * | |
28925 | * var arrays = _.times(2, _.stubArray); | |
28926 | * | |
28927 | * console.log(arrays); | |
28928 | * // => [[], []] | |
28929 | * | |
28930 | * console.log(arrays[0] === arrays[1]); | |
28931 | * // => false | |
28932 | */ | |
28933 | function stubArray() { | |
28934 | return []; | |
28935 | } | |
28936 | ||
28937 | module.exports = stubArray; | |
28938 | ||
28939 | },{}],349:[function(require,module,exports){ | |
28940 | /** | |
28941 | * This method returns `false`. | |
28942 | * | |
28943 | * @static | |
28944 | * @memberOf _ | |
28945 | * @since 4.13.0 | |
28946 | * @category Util | |
28947 | * @returns {boolean} Returns `false`. | |
28948 | * @example | |
28949 | * | |
28950 | * _.times(2, _.stubFalse); | |
28951 | * // => [false, false] | |
28952 | */ | |
28953 | function stubFalse() { | |
28954 | return false; | |
28955 | } | |
28956 | ||
28957 | module.exports = stubFalse; | |
28958 | ||
28959 | },{}],350:[function(require,module,exports){ | |
28960 | var baseTimes = require('./_baseTimes'), | |
28961 | castFunction = require('./_castFunction'), | |
28962 | toInteger = require('./toInteger'); | |
28963 | ||
28964 | /** Used as references for various `Number` constants. */ | |
28965 | var MAX_SAFE_INTEGER = 9007199254740991; | |
28966 | ||
28967 | /** Used as references for the maximum length and index of an array. */ | |
28968 | var MAX_ARRAY_LENGTH = 4294967295; | |
28969 | ||
28970 | /* Built-in method references for those with the same name as other `lodash` methods. */ | |
28971 | var nativeMin = Math.min; | |
28972 | ||
28973 | /** | |
28974 | * Invokes the iteratee `n` times, returning an array of the results of | |
28975 | * each invocation. The iteratee is invoked with one argument; (index). | |
28976 | * | |
28977 | * @static | |
28978 | * @since 0.1.0 | |
28979 | * @memberOf _ | |
28980 | * @category Util | |
28981 | * @param {number} n The number of times to invoke `iteratee`. | |
28982 | * @param {Function} [iteratee=_.identity] The function invoked per iteration. | |
28983 | * @returns {Array} Returns the array of results. | |
28984 | * @example | |
28985 | * | |
28986 | * _.times(3, String); | |
28987 | * // => ['0', '1', '2'] | |
28988 | * | |
28989 | * _.times(4, _.constant(0)); | |
28990 | * // => [0, 0, 0, 0] | |
28991 | */ | |
28992 | function times(n, iteratee) { | |
28993 | n = toInteger(n); | |
28994 | if (n < 1 || n > MAX_SAFE_INTEGER) { | |
28995 | return []; | |
28996 | } | |
28997 | var index = MAX_ARRAY_LENGTH, | |
28998 | length = nativeMin(n, MAX_ARRAY_LENGTH); | |
28999 | ||
29000 | iteratee = castFunction(iteratee); | |
29001 | n -= MAX_ARRAY_LENGTH; | |
29002 | ||
29003 | var result = baseTimes(length, iteratee); | |
29004 | while (++index < n) { | |
29005 | iteratee(index); | |
29006 | } | |
29007 | return result; | |
29008 | } | |
29009 | ||
29010 | module.exports = times; | |
29011 | ||
29012 | },{"./_baseTimes":211,"./_castFunction":216,"./toInteger":352}],351:[function(require,module,exports){ | |
29013 | var toNumber = require('./toNumber'); | |
29014 | ||
29015 | /** Used as references for various `Number` constants. */ | |
29016 | var INFINITY = 1 / 0, | |
29017 | MAX_INTEGER = 1.7976931348623157e+308; | |
29018 | ||
29019 | /** | |
29020 | * Converts `value` to a finite number. | |
29021 | * | |
29022 | * @static | |
29023 | * @memberOf _ | |
29024 | * @since 4.12.0 | |
29025 | * @category Lang | |
29026 | * @param {*} value The value to convert. | |
29027 | * @returns {number} Returns the converted number. | |
29028 | * @example | |
29029 | * | |
29030 | * _.toFinite(3.2); | |
29031 | * // => 3.2 | |
29032 | * | |
29033 | * _.toFinite(Number.MIN_VALUE); | |
29034 | * // => 5e-324 | |
29035 | * | |
29036 | * _.toFinite(Infinity); | |
29037 | * // => 1.7976931348623157e+308 | |
29038 | * | |
29039 | * _.toFinite('3.2'); | |
29040 | * // => 3.2 | |
29041 | */ | |
29042 | function toFinite(value) { | |
29043 | if (!value) { | |
29044 | return value === 0 ? value : 0; | |
29045 | } | |
29046 | value = toNumber(value); | |
29047 | if (value === INFINITY || value === -INFINITY) { | |
29048 | var sign = (value < 0 ? -1 : 1); | |
29049 | return sign * MAX_INTEGER; | |
29050 | } | |
29051 | return value === value ? value : 0; | |
29052 | } | |
29053 | ||
29054 | module.exports = toFinite; | |
29055 | ||
29056 | },{"./toNumber":353}],352:[function(require,module,exports){ | |
29057 | var toFinite = require('./toFinite'); | |
29058 | ||
29059 | /** | |
29060 | * Converts `value` to an integer. | |
29061 | * | |
29062 | * **Note:** This method is loosely based on | |
29063 | * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). | |
29064 | * | |
29065 | * @static | |
29066 | * @memberOf _ | |
29067 | * @since 4.0.0 | |
29068 | * @category Lang | |
29069 | * @param {*} value The value to convert. | |
29070 | * @returns {number} Returns the converted integer. | |
29071 | * @example | |
29072 | * | |
29073 | * _.toInteger(3.2); | |
29074 | * // => 3 | |
29075 | * | |
29076 | * _.toInteger(Number.MIN_VALUE); | |
29077 | * // => 0 | |
29078 | * | |
29079 | * _.toInteger(Infinity); | |
29080 | * // => 1.7976931348623157e+308 | |
29081 | * | |
29082 | * _.toInteger('3.2'); | |
29083 | * // => 3 | |
29084 | */ | |
29085 | function toInteger(value) { | |
29086 | var result = toFinite(value), | |
29087 | remainder = result % 1; | |
29088 | ||
29089 | return result === result ? (remainder ? result - remainder : result) : 0; | |
29090 | } | |
29091 | ||
29092 | module.exports = toInteger; | |
29093 | ||
29094 | },{"./toFinite":351}],353:[function(require,module,exports){ | |
29095 | var isObject = require('./isObject'), | |
29096 | isSymbol = require('./isSymbol'); | |
29097 | ||
29098 | /** Used as references for various `Number` constants. */ | |
29099 | var NAN = 0 / 0; | |
29100 | ||
29101 | /** Used to match leading and trailing whitespace. */ | |
29102 | var reTrim = /^\s+|\s+$/g; | |
29103 | ||
29104 | /** Used to detect bad signed hexadecimal string values. */ | |
29105 | var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; | |
29106 | ||
29107 | /** Used to detect binary string values. */ | |
29108 | var reIsBinary = /^0b[01]+$/i; | |
29109 | ||
29110 | /** Used to detect octal string values. */ | |
29111 | var reIsOctal = /^0o[0-7]+$/i; | |
29112 | ||
29113 | /** Built-in method references without a dependency on `root`. */ | |
29114 | var freeParseInt = parseInt; | |
29115 | ||
29116 | /** | |
29117 | * Converts `value` to a number. | |
29118 | * | |
29119 | * @static | |
29120 | * @memberOf _ | |
29121 | * @since 4.0.0 | |
29122 | * @category Lang | |
29123 | * @param {*} value The value to process. | |
29124 | * @returns {number} Returns the number. | |
29125 | * @example | |
29126 | * | |
29127 | * _.toNumber(3.2); | |
29128 | * // => 3.2 | |
29129 | * | |
29130 | * _.toNumber(Number.MIN_VALUE); | |
29131 | * // => 5e-324 | |
29132 | * | |
29133 | * _.toNumber(Infinity); | |
29134 | * // => Infinity | |
29135 | * | |
29136 | * _.toNumber('3.2'); | |
29137 | * // => 3.2 | |
29138 | */ | |
29139 | function toNumber(value) { | |
29140 | if (typeof value == 'number') { | |
29141 | return value; | |
29142 | } | |
29143 | if (isSymbol(value)) { | |
29144 | return NAN; | |
29145 | } | |
29146 | if (isObject(value)) { | |
29147 | var other = typeof value.valueOf == 'function' ? value.valueOf() : value; | |
29148 | value = isObject(other) ? (other + '') : other; | |
29149 | } | |
29150 | if (typeof value != 'string') { | |
29151 | return value === 0 ? value : +value; | |
29152 | } | |
29153 | value = value.replace(reTrim, ''); | |
29154 | var isBinary = reIsBinary.test(value); | |
29155 | return (isBinary || reIsOctal.test(value)) | |
29156 | ? freeParseInt(value.slice(2), isBinary ? 2 : 8) | |
29157 | : (reIsBadHex.test(value) ? NAN : +value); | |
29158 | } | |
29159 | ||
29160 | module.exports = toNumber; | |
29161 | ||
29162 | },{"./isObject":333,"./isSymbol":338}],354:[function(require,module,exports){ | |
29163 | var baseToString = require('./_baseToString'); | |
29164 | ||
29165 | /** | |
29166 | * Converts `value` to a string. An empty string is returned for `null` | |
29167 | * and `undefined` values. The sign of `-0` is preserved. | |
29168 | * | |
29169 | * @static | |
29170 | * @memberOf _ | |
29171 | * @since 4.0.0 | |
29172 | * @category Lang | |
29173 | * @param {*} value The value to convert. | |
29174 | * @returns {string} Returns the converted string. | |
29175 | * @example | |
29176 | * | |
29177 | * _.toString(null); | |
29178 | * // => '' | |
29179 | * | |
29180 | * _.toString(-0); | |
29181 | * // => '-0' | |
29182 | * | |
29183 | * _.toString([1, 2, 3]); | |
29184 | * // => '1,2,3' | |
29185 | */ | |
29186 | function toString(value) { | |
29187 | return value == null ? '' : baseToString(value); | |
29188 | } | |
29189 | ||
29190 | module.exports = toString; | |
29191 | ||
29192 | },{"./_baseToString":212}],355:[function(require,module,exports){ | |
29193 | var baseToString = require('./_baseToString'), | |
29194 | castSlice = require('./_castSlice'), | |
29195 | charsEndIndex = require('./_charsEndIndex'), | |
29196 | stringToArray = require('./_stringToArray'), | |
29197 | toString = require('./toString'); | |
29198 | ||
29199 | /** Used to match leading and trailing whitespace. */ | |
29200 | var reTrimEnd = /\s+$/; | |
29201 | ||
29202 | /** | |
29203 | * Removes trailing whitespace or specified characters from `string`. | |
29204 | * | |
29205 | * @static | |
29206 | * @memberOf _ | |
29207 | * @since 4.0.0 | |
29208 | * @category String | |
29209 | * @param {string} [string=''] The string to trim. | |
29210 | * @param {string} [chars=whitespace] The characters to trim. | |
29211 | * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. | |
29212 | * @returns {string} Returns the trimmed string. | |
29213 | * @example | |
29214 | * | |
29215 | * _.trimEnd(' abc '); | |
29216 | * // => ' abc' | |
29217 | * | |
29218 | * _.trimEnd('-_-abc-_-', '_-'); | |
29219 | * // => '-_-abc' | |
29220 | */ | |
29221 | function trimEnd(string, chars, guard) { | |
29222 | string = toString(string); | |
29223 | if (string && (guard || chars === undefined)) { | |
29224 | return string.replace(reTrimEnd, ''); | |
29225 | } | |
29226 | if (!string || !(chars = baseToString(chars))) { | |
29227 | return string; | |
29228 | } | |
29229 | var strSymbols = stringToArray(string), | |
29230 | end = charsEndIndex(strSymbols, stringToArray(chars)) + 1; | |
29231 | ||
29232 | return castSlice(strSymbols, 0, end).join(''); | |
29233 | } | |
29234 | ||
29235 | module.exports = trimEnd; | |
29236 | ||
29237 | },{"./_baseToString":212,"./_castSlice":218,"./_charsEndIndex":219,"./_stringToArray":303,"./toString":354}],356:[function(require,module,exports){ | |
29238 | var baseValues = require('./_baseValues'), | |
29239 | keys = require('./keys'); | |
29240 | ||
29241 | /** | |
29242 | * Creates an array of the own enumerable string keyed property values of `object`. | |
29243 | * | |
29244 | * **Note:** Non-object values are coerced to objects. | |
29245 | * | |
29246 | * @static | |
29247 | * @since 0.1.0 | |
29248 | * @memberOf _ | |
29249 | * @category Object | |
29250 | * @param {Object} object The object to query. | |
29251 | * @returns {Array} Returns the array of property values. | |
29252 | * @example | |
29253 | * | |
29254 | * function Foo() { | |
29255 | * this.a = 1; | |
29256 | * this.b = 2; | |
29257 | * } | |
29258 | * | |
29259 | * Foo.prototype.c = 3; | |
29260 | * | |
29261 | * _.values(new Foo); | |
29262 | * // => [1, 2] (iteration order is not guaranteed) | |
29263 | * | |
29264 | * _.values('hi'); | |
29265 | * // => ['h', 'i'] | |
29266 | */ | |
29267 | function values(object) { | |
29268 | return object == null ? [] : baseValues(object, keys(object)); | |
29269 | } | |
29270 | ||
29271 | module.exports = values; | |
29272 | ||
29273 | },{"./_baseValues":214,"./keys":341}],357:[function(require,module,exports){ | |
29274 | /* | |
29275 | Copyright 2013 Daniel Wirtz <dcode@dcode.io> | |
29276 | Copyright 2009 The Closure Library Authors. All Rights Reserved. | |
29277 | ||
29278 | Licensed under the Apache License, Version 2.0 (the "License"); | |
29279 | you may not use this file except in compliance with the License. | |
29280 | You may obtain a copy of the License at | |
29281 | ||
29282 | http://www.apache.org/licenses/LICENSE-2.0 | |
29283 | ||
29284 | Unless required by applicable law or agreed to in writing, software | |
29285 | distributed under the License is distributed on an "AS-IS" BASIS, | |
29286 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
29287 | See the License for the specific language governing permissions and | |
29288 | limitations under the License. | |
29289 | */ | |
29290 | ||
29291 | /** | |
29292 | * @license Long.js (c) 2013 Daniel Wirtz <dcode@dcode.io> | |
29293 | * Released under the Apache License, Version 2.0 | |
29294 | * see: https://github.com/dcodeIO/Long.js for details | |
29295 | */ | |
29296 | (function(global, factory) { | |
29297 | ||
29298 | /* AMD */ if (typeof define === 'function' && define["amd"]) | |
29299 | define([], factory); | |
29300 | /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"]) | |
29301 | module["exports"] = factory(); | |
29302 | /* Global */ else | |
29303 | (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory(); | |
29304 | ||
29305 | })(this, function() { | |
29306 | "use strict"; | |
29307 | ||
29308 | /** | |
29309 | * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers. | |
29310 | * See the from* functions below for more convenient ways of constructing Longs. | |
29311 | * @exports Long | |
29312 | * @class A Long class for representing a 64 bit two's-complement integer value. | |
29313 | * @param {number} low The low (signed) 32 bits of the long | |
29314 | * @param {number} high The high (signed) 32 bits of the long | |
29315 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | |
29316 | * @constructor | |
29317 | */ | |
29318 | function Long(low, high, unsigned) { | |
29319 | ||
29320 | /** | |
29321 | * The low 32 bits as a signed value. | |
29322 | * @type {number} | |
29323 | * @expose | |
29324 | */ | |
29325 | this.low = low|0; | |
29326 | ||
29327 | /** | |
29328 | * The high 32 bits as a signed value. | |
29329 | * @type {number} | |
29330 | * @expose | |
29331 | */ | |
29332 | this.high = high|0; | |
29333 | ||
29334 | /** | |
29335 | * Whether unsigned or not. | |
29336 | * @type {boolean} | |
29337 | * @expose | |
29338 | */ | |
29339 | this.unsigned = !!unsigned; | |
29340 | } | |
29341 | ||
29342 | // The internal representation of a long is the two given signed, 32-bit values. | |
29343 | // We use 32-bit pieces because these are the size of integers on which | |
29344 | // Javascript performs bit-operations. For operations like addition and | |
29345 | // multiplication, we split each number into 16 bit pieces, which can easily be | |
29346 | // multiplied within Javascript's floating-point representation without overflow | |
29347 | // or change in sign. | |
29348 | // | |
29349 | // In the algorithms below, we frequently reduce the negative case to the | |
29350 | // positive case by negating the input(s) and then post-processing the result. | |
29351 | // Note that we must ALWAYS check specially whether those values are MIN_VALUE | |
29352 | // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as | |
29353 | // a positive number, it overflows back into a negative). Not handling this | |
29354 | // case would often result in infinite recursion. | |
29355 | // | |
29356 | // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from* | |
29357 | // methods on which they depend. | |
29358 | ||
29359 | /** | |
29360 | * An indicator used to reliably determine if an object is a Long or not. | |
29361 | * @type {boolean} | |
29362 | * @const | |
29363 | * @expose | |
29364 | * @private | |
29365 | */ | |
29366 | Long.__isLong__; | |
29367 | ||
29368 | Object.defineProperty(Long.prototype, "__isLong__", { | |
29369 | value: true, | |
29370 | enumerable: false, | |
29371 | configurable: false | |
29372 | }); | |
29373 | ||
29374 | /** | |
29375 | * Tests if the specified object is a Long. | |
29376 | * @param {*} obj Object | |
29377 | * @returns {boolean} | |
29378 | * @expose | |
29379 | */ | |
29380 | Long.isLong = function isLong(obj) { | |
29381 | return (obj && obj["__isLong__"]) === true; | |
29382 | }; | |
29383 | ||
29384 | /** | |
29385 | * A cache of the Long representations of small integer values. | |
29386 | * @type {!Object} | |
29387 | * @inner | |
29388 | */ | |
29389 | var INT_CACHE = {}; | |
29390 | ||
29391 | /** | |
29392 | * A cache of the Long representations of small unsigned integer values. | |
29393 | * @type {!Object} | |
29394 | * @inner | |
29395 | */ | |
29396 | var UINT_CACHE = {}; | |
29397 | ||
29398 | /** | |
29399 | * Returns a Long representing the given 32 bit integer value. | |
29400 | * @param {number} value The 32 bit integer in question | |
29401 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | |
29402 | * @returns {!Long} The corresponding Long value | |
29403 | * @expose | |
29404 | */ | |
29405 | Long.fromInt = function fromInt(value, unsigned) { | |
29406 | var obj, cachedObj; | |
29407 | if (!unsigned) { | |
29408 | value = value | 0; | |
29409 | if (-128 <= value && value < 128) { | |
29410 | cachedObj = INT_CACHE[value]; | |
29411 | if (cachedObj) | |
29412 | return cachedObj; | |
29413 | } | |
29414 | obj = new Long(value, value < 0 ? -1 : 0, false); | |
29415 | if (-128 <= value && value < 128) | |
29416 | INT_CACHE[value] = obj; | |
29417 | return obj; | |
29418 | } else { | |
29419 | value = value >>> 0; | |
29420 | if (0 <= value && value < 256) { | |
29421 | cachedObj = UINT_CACHE[value]; | |
29422 | if (cachedObj) | |
29423 | return cachedObj; | |
29424 | } | |
29425 | obj = new Long(value, (value | 0) < 0 ? -1 : 0, true); | |
29426 | if (0 <= value && value < 256) | |
29427 | UINT_CACHE[value] = obj; | |
29428 | return obj; | |
29429 | } | |
29430 | }; | |
29431 | ||
29432 | /** | |
29433 | * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned. | |
29434 | * @param {number} value The number in question | |
29435 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | |
29436 | * @returns {!Long} The corresponding Long value | |
29437 | * @expose | |
29438 | */ | |
29439 | Long.fromNumber = function fromNumber(value, unsigned) { | |
29440 | unsigned = !!unsigned; | |
29441 | if (isNaN(value) || !isFinite(value)) | |
29442 | return Long.ZERO; | |
29443 | if (!unsigned && value <= -TWO_PWR_63_DBL) | |
29444 | return Long.MIN_VALUE; | |
29445 | if (!unsigned && value + 1 >= TWO_PWR_63_DBL) | |
29446 | return Long.MAX_VALUE; | |
29447 | if (unsigned && value >= TWO_PWR_64_DBL) | |
29448 | return Long.MAX_UNSIGNED_VALUE; | |
29449 | if (value < 0) | |
29450 | return Long.fromNumber(-value, unsigned).negate(); | |
29451 | return new Long((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned); | |
29452 | }; | |
29453 | ||
29454 | /** | |
29455 | * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is | |
29456 | * assumed to use 32 bits. | |
29457 | * @param {number} lowBits The low 32 bits | |
29458 | * @param {number} highBits The high 32 bits | |
29459 | * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed | |
29460 | * @returns {!Long} The corresponding Long value | |
29461 | * @expose | |
29462 | */ | |
29463 | Long.fromBits = function fromBits(lowBits, highBits, unsigned) { | |
29464 | return new Long(lowBits, highBits, unsigned); | |
29465 | }; | |
29466 | ||
29467 | /** | |
29468 | * Returns a Long representation of the given string, written using the specified radix. | |
29469 | * @param {string} str The textual representation of the Long | |
29470 | * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed | |
29471 | * @param {number=} radix The radix in which the text is written (2-36), defaults to 10 | |
29472 | * @returns {!Long} The corresponding Long value | |
29473 | * @expose | |
29474 | */ | |
29475 | Long.fromString = function fromString(str, unsigned, radix) { | |
29476 | if (str.length === 0) | |
29477 | throw Error('number format error: empty string'); | |
29478 | if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") | |
29479 | return Long.ZERO; | |
29480 | if (typeof unsigned === 'number') // For goog.math.long compatibility | |
29481 | radix = unsigned, | |
29482 | unsigned = false; | |
29483 | radix = radix || 10; | |
29484 | if (radix < 2 || 36 < radix) | |
29485 | throw Error('radix out of range: ' + radix); | |
29486 | ||
29487 | var p; | |
29488 | if ((p = str.indexOf('-')) > 0) | |
29489 | throw Error('number format error: interior "-" character: ' + str); | |
29490 | else if (p === 0) | |
29491 | return Long.fromString(str.substring(1), unsigned, radix).negate(); | |
29492 | ||
29493 | // Do several (8) digits each time through the loop, so as to | |
29494 | // minimize the calls to the very expensive emulated div. | |
29495 | var radixToPower = Long.fromNumber(Math.pow(radix, 8)); | |
29496 | ||
29497 | var result = Long.ZERO; | |
29498 | for (var i = 0; i < str.length; i += 8) { | |
29499 | var size = Math.min(8, str.length - i); | |
29500 | var value = parseInt(str.substring(i, i + size), radix); | |
29501 | if (size < 8) { | |
29502 | var power = Long.fromNumber(Math.pow(radix, size)); | |
29503 | result = result.multiply(power).add(Long.fromNumber(value)); | |
29504 | } else { | |
29505 | result = result.multiply(radixToPower); | |
29506 | result = result.add(Long.fromNumber(value)); | |
29507 | } | |
29508 | } | |
29509 | result.unsigned = unsigned; | |
29510 | return result; | |
29511 | }; | |
29512 | ||
29513 | /** | |
29514 | * Converts the specified value to a Long. | |
29515 | * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value | |
29516 | * @returns {!Long} | |
29517 | * @expose | |
29518 | */ | |
29519 | Long.fromValue = function fromValue(val) { | |
29520 | if (val /* is compatible */ instanceof Long) | |
29521 | return val; | |
29522 | if (typeof val === 'number') | |
29523 | return Long.fromNumber(val); | |
29524 | if (typeof val === 'string') | |
29525 | return Long.fromString(val); | |
29526 | // Throws for non-objects, converts non-instanceof Long: | |
29527 | return new Long(val.low, val.high, val.unsigned); | |
29528 | }; | |
29529 | ||
29530 | // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be | |
29531 | // no runtime penalty for these. | |
29532 | ||
29533 | /** | |
29534 | * @type {number} | |
29535 | * @const | |
29536 | * @inner | |
29537 | */ | |
29538 | var TWO_PWR_16_DBL = 1 << 16; | |
29539 | ||
29540 | /** | |
29541 | * @type {number} | |
29542 | * @const | |
29543 | * @inner | |
29544 | */ | |
29545 | var TWO_PWR_24_DBL = 1 << 24; | |
29546 | ||
29547 | /** | |
29548 | * @type {number} | |
29549 | * @const | |
29550 | * @inner | |
29551 | */ | |
29552 | var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; | |
29553 | ||
29554 | /** | |
29555 | * @type {number} | |
29556 | * @const | |
29557 | * @inner | |
29558 | */ | |
29559 | var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; | |
29560 | ||
29561 | /** | |
29562 | * @type {number} | |
29563 | * @const | |
29564 | * @inner | |
29565 | */ | |
29566 | var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; | |
29567 | ||
29568 | /** | |
29569 | * @type {!Long} | |
29570 | * @const | |
29571 | * @inner | |
29572 | */ | |
29573 | var TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL); | |
29574 | ||
29575 | /** | |
29576 | * Signed zero. | |
29577 | * @type {!Long} | |
29578 | * @expose | |
29579 | */ | |
29580 | Long.ZERO = Long.fromInt(0); | |
29581 | ||
29582 | /** | |
29583 | * Unsigned zero. | |
29584 | * @type {!Long} | |
29585 | * @expose | |
29586 | */ | |
29587 | Long.UZERO = Long.fromInt(0, true); | |
29588 | ||
29589 | /** | |
29590 | * Signed one. | |
29591 | * @type {!Long} | |
29592 | * @expose | |
29593 | */ | |
29594 | Long.ONE = Long.fromInt(1); | |
29595 | ||
29596 | /** | |
29597 | * Unsigned one. | |
29598 | * @type {!Long} | |
29599 | * @expose | |
29600 | */ | |
29601 | Long.UONE = Long.fromInt(1, true); | |
29602 | ||
29603 | /** | |
29604 | * Signed negative one. | |
29605 | * @type {!Long} | |
29606 | * @expose | |
29607 | */ | |
29608 | Long.NEG_ONE = Long.fromInt(-1); | |
29609 | ||
29610 | /** | |
29611 | * Maximum signed value. | |
29612 | * @type {!Long} | |
29613 | * @expose | |
29614 | */ | |
29615 | Long.MAX_VALUE = Long.fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false); | |
29616 | ||
29617 | /** | |
29618 | * Maximum unsigned value. | |
29619 | * @type {!Long} | |
29620 | * @expose | |
29621 | */ | |
29622 | Long.MAX_UNSIGNED_VALUE = Long.fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true); | |
29623 | ||
29624 | /** | |
29625 | * Minimum signed value. | |
29626 | * @type {!Long} | |
29627 | * @expose | |
29628 | */ | |
29629 | Long.MIN_VALUE = Long.fromBits(0, 0x80000000|0, false); | |
29630 | ||
29631 | /** | |
29632 | * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. | |
29633 | * @returns {number} | |
29634 | * @expose | |
29635 | */ | |
29636 | Long.prototype.toInt = function toInt() { | |
29637 | return this.unsigned ? this.low >>> 0 : this.low; | |
29638 | }; | |
29639 | ||
29640 | /** | |
29641 | * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). | |
29642 | * @returns {number} | |
29643 | * @expose | |
29644 | */ | |
29645 | Long.prototype.toNumber = function toNumber() { | |
29646 | if (this.unsigned) { | |
29647 | return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0); | |
29648 | } | |
29649 | return this.high * TWO_PWR_32_DBL + (this.low >>> 0); | |
29650 | }; | |
29651 | ||
29652 | /** | |
29653 | * Converts the Long to a string written in the specified radix. | |
29654 | * @param {number=} radix Radix (2-36), defaults to 10 | |
29655 | * @returns {string} | |
29656 | * @override | |
29657 | * @throws {RangeError} If `radix` is out of range | |
29658 | * @expose | |
29659 | */ | |
29660 | Long.prototype.toString = function toString(radix) { | |
29661 | radix = radix || 10; | |
29662 | if (radix < 2 || 36 < radix) | |
29663 | throw RangeError('radix out of range: ' + radix); | |
29664 | if (this.isZero()) | |
29665 | return '0'; | |
29666 | var rem; | |
29667 | if (this.isNegative()) { // Unsigned Longs are never negative | |
29668 | if (this.equals(Long.MIN_VALUE)) { | |
29669 | // We need to change the Long value before it can be negated, so we remove | |
29670 | // the bottom-most digit in this base and then recurse to do the rest. | |
29671 | var radixLong = Long.fromNumber(radix); | |
29672 | var div = this.divide(radixLong); | |
29673 | rem = div.multiply(radixLong).subtract(this); | |
29674 | return div.toString(radix) + rem.toInt().toString(radix); | |
29675 | } else | |
29676 | return '-' + this.negate().toString(radix); | |
29677 | } | |
29678 | ||
29679 | // Do several (6) digits each time through the loop, so as to | |
29680 | // minimize the calls to the very expensive emulated div. | |
29681 | var radixToPower = Long.fromNumber(Math.pow(radix, 6), this.unsigned); | |
29682 | rem = this; | |
29683 | var result = ''; | |
29684 | while (true) { | |
29685 | var remDiv = rem.divide(radixToPower), | |
29686 | intval = rem.subtract(remDiv.multiply(radixToPower)).toInt() >>> 0, | |
29687 | digits = intval.toString(radix); | |
29688 | rem = remDiv; | |
29689 | if (rem.isZero()) | |
29690 | return digits + result; | |
29691 | else { | |
29692 | while (digits.length < 6) | |
29693 | digits = '0' + digits; | |
29694 | result = '' + digits + result; | |
29695 | } | |
29696 | } | |
29697 | }; | |
29698 | ||
29699 | /** | |
29700 | * Gets the high 32 bits as a signed integer. | |
29701 | * @returns {number} Signed high bits | |
29702 | * @expose | |
29703 | */ | |
29704 | Long.prototype.getHighBits = function getHighBits() { | |
29705 | return this.high; | |
29706 | }; | |
29707 | ||
29708 | /** | |
29709 | * Gets the high 32 bits as an unsigned integer. | |
29710 | * @returns {number} Unsigned high bits | |
29711 | * @expose | |
29712 | */ | |
29713 | Long.prototype.getHighBitsUnsigned = function getHighBitsUnsigned() { | |
29714 | return this.high >>> 0; | |
29715 | }; | |
29716 | ||
29717 | /** | |
29718 | * Gets the low 32 bits as a signed integer. | |
29719 | * @returns {number} Signed low bits | |
29720 | * @expose | |
29721 | */ | |
29722 | Long.prototype.getLowBits = function getLowBits() { | |
29723 | return this.low; | |
29724 | }; | |
29725 | ||
29726 | /** | |
29727 | * Gets the low 32 bits as an unsigned integer. | |
29728 | * @returns {number} Unsigned low bits | |
29729 | * @expose | |
29730 | */ | |
29731 | Long.prototype.getLowBitsUnsigned = function getLowBitsUnsigned() { | |
29732 | return this.low >>> 0; | |
29733 | }; | |
29734 | ||
29735 | /** | |
29736 | * Gets the number of bits needed to represent the absolute value of this Long. | |
29737 | * @returns {number} | |
29738 | * @expose | |
29739 | */ | |
29740 | Long.prototype.getNumBitsAbs = function getNumBitsAbs() { | |
29741 | if (this.isNegative()) // Unsigned Longs are never negative | |
29742 | return this.equals(Long.MIN_VALUE) ? 64 : this.negate().getNumBitsAbs(); | |
29743 | var val = this.high != 0 ? this.high : this.low; | |
29744 | for (var bit = 31; bit > 0; bit--) | |
29745 | if ((val & (1 << bit)) != 0) | |
29746 | break; | |
29747 | return this.high != 0 ? bit + 33 : bit + 1; | |
29748 | }; | |
29749 | ||
29750 | /** | |
29751 | * Tests if this Long's value equals zero. | |
29752 | * @returns {boolean} | |
29753 | * @expose | |
29754 | */ | |
29755 | Long.prototype.isZero = function isZero() { | |
29756 | return this.high === 0 && this.low === 0; | |
29757 | }; | |
29758 | ||
29759 | /** | |
29760 | * Tests if this Long's value is negative. | |
29761 | * @returns {boolean} | |
29762 | * @expose | |
29763 | */ | |
29764 | Long.prototype.isNegative = function isNegative() { | |
29765 | return !this.unsigned && this.high < 0; | |
29766 | }; | |
29767 | ||
29768 | /** | |
29769 | * Tests if this Long's value is positive. | |
29770 | * @returns {boolean} | |
29771 | * @expose | |
29772 | */ | |
29773 | Long.prototype.isPositive = function isPositive() { | |
29774 | return this.unsigned || this.high >= 0; | |
29775 | }; | |
29776 | ||
29777 | /** | |
29778 | * Tests if this Long's value is odd. | |
29779 | * @returns {boolean} | |
29780 | * @expose | |
29781 | */ | |
29782 | Long.prototype.isOdd = function isOdd() { | |
29783 | return (this.low & 1) === 1; | |
29784 | }; | |
29785 | ||
29786 | /** | |
29787 | * Tests if this Long's value is even. | |
29788 | * @returns {boolean} | |
29789 | * @expose | |
29790 | */ | |
29791 | Long.prototype.isEven = function isEven() { | |
29792 | return (this.low & 1) === 0; | |
29793 | }; | |
29794 | ||
29795 | /** | |
29796 | * Tests if this Long's value equals the specified's. | |
29797 | * @param {!Long|number|string} other Other value | |
29798 | * @returns {boolean} | |
29799 | * @expose | |
29800 | */ | |
29801 | Long.prototype.equals = function equals(other) { | |
29802 | if (!Long.isLong(other)) | |
29803 | other = Long.fromValue(other); | |
29804 | if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1) | |
29805 | return false; | |
29806 | return this.high === other.high && this.low === other.low; | |
29807 | }; | |
29808 | ||
29809 | /** | |
29810 | * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}. | |
29811 | * @function | |
29812 | * @param {!Long|number|string} other Other value | |
29813 | * @returns {boolean} | |
29814 | * @expose | |
29815 | */ | |
29816 | Long.eq = Long.prototype.equals; | |
29817 | ||
29818 | /** | |
29819 | * Tests if this Long's value differs from the specified's. | |
29820 | * @param {!Long|number|string} other Other value | |
29821 | * @returns {boolean} | |
29822 | * @expose | |
29823 | */ | |
29824 | Long.prototype.notEquals = function notEquals(other) { | |
29825 | return !this.equals(/* validates */ other); | |
29826 | }; | |
29827 | ||
29828 | /** | |
29829 | * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. | |
29830 | * @function | |
29831 | * @param {!Long|number|string} other Other value | |
29832 | * @returns {boolean} | |
29833 | * @expose | |
29834 | */ | |
29835 | Long.neq = Long.prototype.notEquals; | |
29836 | ||
29837 | /** | |
29838 | * Tests if this Long's value is less than the specified's. | |
29839 | * @param {!Long|number|string} other Other value | |
29840 | * @returns {boolean} | |
29841 | * @expose | |
29842 | */ | |
29843 | Long.prototype.lessThan = function lessThan(other) { | |
29844 | return this.compare(/* validates */ other) < 0; | |
29845 | }; | |
29846 | ||
29847 | /** | |
29848 | * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}. | |
29849 | * @function | |
29850 | * @param {!Long|number|string} other Other value | |
29851 | * @returns {boolean} | |
29852 | * @expose | |
29853 | */ | |
29854 | Long.prototype.lt = Long.prototype.lessThan; | |
29855 | ||
29856 | /** | |
29857 | * Tests if this Long's value is less than or equal the specified's. | |
29858 | * @param {!Long|number|string} other Other value | |
29859 | * @returns {boolean} | |
29860 | * @expose | |
29861 | */ | |
29862 | Long.prototype.lessThanOrEqual = function lessThanOrEqual(other) { | |
29863 | return this.compare(/* validates */ other) <= 0; | |
29864 | }; | |
29865 | ||
29866 | /** | |
29867 | * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. | |
29868 | * @function | |
29869 | * @param {!Long|number|string} other Other value | |
29870 | * @returns {boolean} | |
29871 | * @expose | |
29872 | */ | |
29873 | Long.prototype.lte = Long.prototype.lessThanOrEqual; | |
29874 | ||
29875 | /** | |
29876 | * Tests if this Long's value is greater than the specified's. | |
29877 | * @param {!Long|number|string} other Other value | |
29878 | * @returns {boolean} | |
29879 | * @expose | |
29880 | */ | |
29881 | Long.prototype.greaterThan = function greaterThan(other) { | |
29882 | return this.compare(/* validates */ other) > 0; | |
29883 | }; | |
29884 | ||
29885 | /** | |
29886 | * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}. | |
29887 | * @function | |
29888 | * @param {!Long|number|string} other Other value | |
29889 | * @returns {boolean} | |
29890 | * @expose | |
29891 | */ | |
29892 | Long.prototype.gt = Long.prototype.greaterThan; | |
29893 | ||
29894 | /** | |
29895 | * Tests if this Long's value is greater than or equal the specified's. | |
29896 | * @param {!Long|number|string} other Other value | |
29897 | * @returns {boolean} | |
29898 | * @expose | |
29899 | */ | |
29900 | Long.prototype.greaterThanOrEqual = function greaterThanOrEqual(other) { | |
29901 | return this.compare(/* validates */ other) >= 0; | |
29902 | }; | |
29903 | ||
29904 | /** | |
29905 | * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. | |
29906 | * @function | |
29907 | * @param {!Long|number|string} other Other value | |
29908 | * @returns {boolean} | |
29909 | * @expose | |
29910 | */ | |
29911 | Long.prototype.gte = Long.prototype.greaterThanOrEqual; | |
29912 | ||
29913 | /** | |
29914 | * Compares this Long's value with the specified's. | |
29915 | * @param {!Long|number|string} other Other value | |
29916 | * @returns {number} 0 if they are the same, 1 if the this is greater and -1 | |
29917 | * if the given one is greater | |
29918 | * @expose | |
29919 | */ | |
29920 | Long.prototype.compare = function compare(other) { | |
29921 | if (!Long.isLong(other)) | |
29922 | other = Long.fromValue(other); | |
29923 | if (this.equals(other)) | |
29924 | return 0; | |
29925 | var thisNeg = this.isNegative(), | |
29926 | otherNeg = other.isNegative(); | |
29927 | if (thisNeg && !otherNeg) | |
29928 | return -1; | |
29929 | if (!thisNeg && otherNeg) | |
29930 | return 1; | |
29931 | // At this point the sign bits are the same | |
29932 | if (!this.unsigned) | |
29933 | return this.subtract(other).isNegative() ? -1 : 1; | |
29934 | // Both are positive if at least one is unsigned | |
29935 | return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1; | |
29936 | }; | |
29937 | ||
29938 | /** | |
29939 | * Negates this Long's value. | |
29940 | * @returns {!Long} Negated Long | |
29941 | * @expose | |
29942 | */ | |
29943 | Long.prototype.negate = function negate() { | |
29944 | if (!this.unsigned && this.equals(Long.MIN_VALUE)) | |
29945 | return Long.MIN_VALUE; | |
29946 | return this.not().add(Long.ONE); | |
29947 | }; | |
29948 | ||
29949 | /** | |
29950 | * Negates this Long's value. This is an alias of {@link Long#negate}. | |
29951 | * @function | |
29952 | * @returns {!Long} Negated Long | |
29953 | * @expose | |
29954 | */ | |
29955 | Long.prototype.neg = Long.prototype.negate; | |
29956 | ||
29957 | /** | |
29958 | * Returns the sum of this and the specified Long. | |
29959 | * @param {!Long|number|string} addend Addend | |
29960 | * @returns {!Long} Sum | |
29961 | * @expose | |
29962 | */ | |
29963 | Long.prototype.add = function add(addend) { | |
29964 | if (!Long.isLong(addend)) | |
29965 | addend = Long.fromValue(addend); | |
29966 | ||
29967 | // Divide each number into 4 chunks of 16 bits, and then sum the chunks. | |
29968 | ||
29969 | var a48 = this.high >>> 16; | |
29970 | var a32 = this.high & 0xFFFF; | |
29971 | var a16 = this.low >>> 16; | |
29972 | var a00 = this.low & 0xFFFF; | |
29973 | ||
29974 | var b48 = addend.high >>> 16; | |
29975 | var b32 = addend.high & 0xFFFF; | |
29976 | var b16 = addend.low >>> 16; | |
29977 | var b00 = addend.low & 0xFFFF; | |
29978 | ||
29979 | var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | |
29980 | c00 += a00 + b00; | |
29981 | c16 += c00 >>> 16; | |
29982 | c00 &= 0xFFFF; | |
29983 | c16 += a16 + b16; | |
29984 | c32 += c16 >>> 16; | |
29985 | c16 &= 0xFFFF; | |
29986 | c32 += a32 + b32; | |
29987 | c48 += c32 >>> 16; | |
29988 | c32 &= 0xFFFF; | |
29989 | c48 += a48 + b48; | |
29990 | c48 &= 0xFFFF; | |
29991 | return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); | |
29992 | }; | |
29993 | ||
29994 | /** | |
29995 | * Returns the difference of this and the specified Long. | |
29996 | * @param {!Long|number|string} subtrahend Subtrahend | |
29997 | * @returns {!Long} Difference | |
29998 | * @expose | |
29999 | */ | |
30000 | Long.prototype.subtract = function subtract(subtrahend) { | |
30001 | if (!Long.isLong(subtrahend)) | |
30002 | subtrahend = Long.fromValue(subtrahend); | |
30003 | return this.add(subtrahend.negate()); | |
30004 | }; | |
30005 | ||
30006 | /** | |
30007 | * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}. | |
30008 | * @function | |
30009 | * @param {!Long|number|string} subtrahend Subtrahend | |
30010 | * @returns {!Long} Difference | |
30011 | * @expose | |
30012 | */ | |
30013 | Long.prototype.sub = Long.prototype.subtract; | |
30014 | ||
30015 | /** | |
30016 | * Returns the product of this and the specified Long. | |
30017 | * @param {!Long|number|string} multiplier Multiplier | |
30018 | * @returns {!Long} Product | |
30019 | * @expose | |
30020 | */ | |
30021 | Long.prototype.multiply = function multiply(multiplier) { | |
30022 | if (this.isZero()) | |
30023 | return Long.ZERO; | |
30024 | if (!Long.isLong(multiplier)) | |
30025 | multiplier = Long.fromValue(multiplier); | |
30026 | if (multiplier.isZero()) | |
30027 | return Long.ZERO; | |
30028 | if (this.equals(Long.MIN_VALUE)) | |
30029 | return multiplier.isOdd() ? Long.MIN_VALUE : Long.ZERO; | |
30030 | if (multiplier.equals(Long.MIN_VALUE)) | |
30031 | return this.isOdd() ? Long.MIN_VALUE : Long.ZERO; | |
30032 | ||
30033 | if (this.isNegative()) { | |
30034 | if (multiplier.isNegative()) | |
30035 | return this.negate().multiply(multiplier.negate()); | |
30036 | else | |
30037 | return this.negate().multiply(multiplier).negate(); | |
30038 | } else if (multiplier.isNegative()) | |
30039 | return this.multiply(multiplier.negate()).negate(); | |
30040 | ||
30041 | // If both longs are small, use float multiplication | |
30042 | if (this.lessThan(TWO_PWR_24) && multiplier.lessThan(TWO_PWR_24)) | |
30043 | return Long.fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); | |
30044 | ||
30045 | // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. | |
30046 | // We can skip products that would overflow. | |
30047 | ||
30048 | var a48 = this.high >>> 16; | |
30049 | var a32 = this.high & 0xFFFF; | |
30050 | var a16 = this.low >>> 16; | |
30051 | var a00 = this.low & 0xFFFF; | |
30052 | ||
30053 | var b48 = multiplier.high >>> 16; | |
30054 | var b32 = multiplier.high & 0xFFFF; | |
30055 | var b16 = multiplier.low >>> 16; | |
30056 | var b00 = multiplier.low & 0xFFFF; | |
30057 | ||
30058 | var c48 = 0, c32 = 0, c16 = 0, c00 = 0; | |
30059 | c00 += a00 * b00; | |
30060 | c16 += c00 >>> 16; | |
30061 | c00 &= 0xFFFF; | |
30062 | c16 += a16 * b00; | |
30063 | c32 += c16 >>> 16; | |
30064 | c16 &= 0xFFFF; | |
30065 | c16 += a00 * b16; | |
30066 | c32 += c16 >>> 16; | |
30067 | c16 &= 0xFFFF; | |
30068 | c32 += a32 * b00; | |
30069 | c48 += c32 >>> 16; | |
30070 | c32 &= 0xFFFF; | |
30071 | c32 += a16 * b16; | |
30072 | c48 += c32 >>> 16; | |
30073 | c32 &= 0xFFFF; | |
30074 | c32 += a00 * b32; | |
30075 | c48 += c32 >>> 16; | |
30076 | c32 &= 0xFFFF; | |
30077 | c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; | |
30078 | c48 &= 0xFFFF; | |
30079 | return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); | |
30080 | }; | |
30081 | ||
30082 | /** | |
30083 | * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}. | |
30084 | * @function | |
30085 | * @param {!Long|number|string} multiplier Multiplier | |
30086 | * @returns {!Long} Product | |
30087 | * @expose | |
30088 | */ | |
30089 | Long.prototype.mul = Long.prototype.multiply; | |
30090 | ||
30091 | /** | |
30092 | * Returns this Long divided by the specified. | |
30093 | * @param {!Long|number|string} divisor Divisor | |
30094 | * @returns {!Long} Quotient | |
30095 | * @expose | |
30096 | */ | |
30097 | Long.prototype.divide = function divide(divisor) { | |
30098 | if (!Long.isLong(divisor)) | |
30099 | divisor = Long.fromValue(divisor); | |
30100 | if (divisor.isZero()) | |
30101 | throw(new Error('division by zero')); | |
30102 | if (this.isZero()) | |
30103 | return this.unsigned ? Long.UZERO : Long.ZERO; | |
30104 | var approx, rem, res; | |
30105 | if (this.equals(Long.MIN_VALUE)) { | |
30106 | if (divisor.equals(Long.ONE) || divisor.equals(Long.NEG_ONE)) | |
30107 | return Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE | |
30108 | else if (divisor.equals(Long.MIN_VALUE)) | |
30109 | return Long.ONE; | |
30110 | else { | |
30111 | // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. | |
30112 | var halfThis = this.shiftRight(1); | |
30113 | approx = halfThis.divide(divisor).shiftLeft(1); | |
30114 | if (approx.equals(Long.ZERO)) { | |
30115 | return divisor.isNegative() ? Long.ONE : Long.NEG_ONE; | |
30116 | } else { | |
30117 | rem = this.subtract(divisor.multiply(approx)); | |
30118 | res = approx.add(rem.divide(divisor)); | |
30119 | return res; | |
30120 | } | |
30121 | } | |
30122 | } else if (divisor.equals(Long.MIN_VALUE)) | |
30123 | return this.unsigned ? Long.UZERO : Long.ZERO; | |
30124 | if (this.isNegative()) { | |
30125 | if (divisor.isNegative()) | |
30126 | return this.negate().divide(divisor.negate()); | |
30127 | return this.negate().divide(divisor).negate(); | |
30128 | } else if (divisor.isNegative()) | |
30129 | return this.divide(divisor.negate()).negate(); | |
30130 | ||
30131 | // Repeat the following until the remainder is less than other: find a | |
30132 | // floating-point that approximates remainder / other *from below*, add this | |
30133 | // into the result, and subtract it from the remainder. It is critical that | |
30134 | // the approximate value is less than or equal to the real value so that the | |
30135 | // remainder never becomes negative. | |
30136 | res = Long.ZERO; | |
30137 | rem = this; | |
30138 | while (rem.greaterThanOrEqual(divisor)) { | |
30139 | // Approximate the result of division. This may be a little greater or | |
30140 | // smaller than the actual value. | |
30141 | approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); | |
30142 | ||
30143 | // We will tweak the approximate result by changing it in the 48-th digit or | |
30144 | // the smallest non-fractional digit, whichever is larger. | |
30145 | var log2 = Math.ceil(Math.log(approx) / Math.LN2), | |
30146 | delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48), | |
30147 | ||
30148 | // Decrease the approximation until it is smaller than the remainder. Note | |
30149 | // that if it is too large, the product overflows and is negative. | |
30150 | approxRes = Long.fromNumber(approx), | |
30151 | approxRem = approxRes.multiply(divisor); | |
30152 | while (approxRem.isNegative() || approxRem.greaterThan(rem)) { | |
30153 | approx -= delta; | |
30154 | approxRes = Long.fromNumber(approx, this.unsigned); | |
30155 | approxRem = approxRes.multiply(divisor); | |
30156 | } | |
30157 | ||
30158 | // We know the answer can't be zero... and actually, zero would cause | |
30159 | // infinite recursion since we would make no progress. | |
30160 | if (approxRes.isZero()) | |
30161 | approxRes = Long.ONE; | |
30162 | ||
30163 | res = res.add(approxRes); | |
30164 | rem = rem.subtract(approxRem); | |
30165 | } | |
30166 | return res; | |
30167 | }; | |
30168 | ||
30169 | /** | |
30170 | * Returns this Long divided by the specified. This is an alias of {@link Long#divide}. | |
30171 | * @function | |
30172 | * @param {!Long|number|string} divisor Divisor | |
30173 | * @returns {!Long} Quotient | |
30174 | * @expose | |
30175 | */ | |
30176 | Long.prototype.div = Long.prototype.divide; | |
30177 | ||
30178 | /** | |
30179 | * Returns this Long modulo the specified. | |
30180 | * @param {!Long|number|string} divisor Divisor | |
30181 | * @returns {!Long} Remainder | |
30182 | * @expose | |
30183 | */ | |
30184 | Long.prototype.modulo = function modulo(divisor) { | |
30185 | if (!Long.isLong(divisor)) | |
30186 | divisor = Long.fromValue(divisor); | |
30187 | return this.subtract(this.divide(divisor).multiply(divisor)); | |
30188 | }; | |
30189 | ||
30190 | /** | |
30191 | * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. | |
30192 | * @function | |
30193 | * @param {!Long|number|string} divisor Divisor | |
30194 | * @returns {!Long} Remainder | |
30195 | * @expose | |
30196 | */ | |
30197 | Long.prototype.mod = Long.prototype.modulo; | |
30198 | ||
30199 | /** | |
30200 | * Returns the bitwise NOT of this Long. | |
30201 | * @returns {!Long} | |
30202 | * @expose | |
30203 | */ | |
30204 | Long.prototype.not = function not() { | |
30205 | return Long.fromBits(~this.low, ~this.high, this.unsigned); | |
30206 | }; | |
30207 | ||
30208 | /** | |
30209 | * Returns the bitwise AND of this Long and the specified. | |
30210 | * @param {!Long|number|string} other Other Long | |
30211 | * @returns {!Long} | |
30212 | * @expose | |
30213 | */ | |
30214 | Long.prototype.and = function and(other) { | |
30215 | if (!Long.isLong(other)) | |
30216 | other = Long.fromValue(other); | |
30217 | return Long.fromBits(this.low & other.low, this.high & other.high, this.unsigned); | |
30218 | }; | |
30219 | ||
30220 | /** | |
30221 | * Returns the bitwise OR of this Long and the specified. | |
30222 | * @param {!Long|number|string} other Other Long | |
30223 | * @returns {!Long} | |
30224 | * @expose | |
30225 | */ | |
30226 | Long.prototype.or = function or(other) { | |
30227 | if (!Long.isLong(other)) | |
30228 | other = Long.fromValue(other); | |
30229 | return Long.fromBits(this.low | other.low, this.high | other.high, this.unsigned); | |
30230 | }; | |
30231 | ||
30232 | /** | |
30233 | * Returns the bitwise XOR of this Long and the given one. | |
30234 | * @param {!Long|number|string} other Other Long | |
30235 | * @returns {!Long} | |
30236 | * @expose | |
30237 | */ | |
30238 | Long.prototype.xor = function xor(other) { | |
30239 | if (!Long.isLong(other)) | |
30240 | other = Long.fromValue(other); | |
30241 | return Long.fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); | |
30242 | }; | |
30243 | ||
30244 | /** | |
30245 | * Returns this Long with bits shifted to the left by the given amount. | |
30246 | * @param {number|!Long} numBits Number of bits | |
30247 | * @returns {!Long} Shifted Long | |
30248 | * @expose | |
30249 | */ | |
30250 | Long.prototype.shiftLeft = function shiftLeft(numBits) { | |
30251 | if (Long.isLong(numBits)) | |
30252 | numBits = numBits.toInt(); | |
30253 | if ((numBits &= 63) === 0) | |
30254 | return this; | |
30255 | else if (numBits < 32) | |
30256 | return Long.fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned); | |
30257 | else | |
30258 | return Long.fromBits(0, this.low << (numBits - 32), this.unsigned); | |
30259 | }; | |
30260 | ||
30261 | /** | |
30262 | * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}. | |
30263 | * @function | |
30264 | * @param {number|!Long} numBits Number of bits | |
30265 | * @returns {!Long} Shifted Long | |
30266 | * @expose | |
30267 | */ | |
30268 | Long.prototype.shl = Long.prototype.shiftLeft; | |
30269 | ||
30270 | /** | |
30271 | * Returns this Long with bits arithmetically shifted to the right by the given amount. | |
30272 | * @param {number|!Long} numBits Number of bits | |
30273 | * @returns {!Long} Shifted Long | |
30274 | * @expose | |
30275 | */ | |
30276 | Long.prototype.shiftRight = function shiftRight(numBits) { | |
30277 | if (Long.isLong(numBits)) | |
30278 | numBits = numBits.toInt(); | |
30279 | if ((numBits &= 63) === 0) | |
30280 | return this; | |
30281 | else if (numBits < 32) | |
30282 | return Long.fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned); | |
30283 | else | |
30284 | return Long.fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned); | |
30285 | }; | |
30286 | ||
30287 | /** | |
30288 | * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}. | |
30289 | * @function | |
30290 | * @param {number|!Long} numBits Number of bits | |
30291 | * @returns {!Long} Shifted Long | |
30292 | * @expose | |
30293 | */ | |
30294 | Long.prototype.shr = Long.prototype.shiftRight; | |
30295 | ||
30296 | /** | |
30297 | * Returns this Long with bits logically shifted to the right by the given amount. | |
30298 | * @param {number|!Long} numBits Number of bits | |
30299 | * @returns {!Long} Shifted Long | |
30300 | * @expose | |
30301 | */ | |
30302 | Long.prototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { | |
30303 | if (Long.isLong(numBits)) | |
30304 | numBits = numBits.toInt(); | |
30305 | numBits &= 63; | |
30306 | if (numBits === 0) | |
30307 | return this; | |
30308 | else { | |
30309 | var high = this.high; | |
30310 | if (numBits < 32) { | |
30311 | var low = this.low; | |
30312 | return Long.fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned); | |
30313 | } else if (numBits === 32) | |
30314 | return Long.fromBits(high, 0, this.unsigned); | |
30315 | else | |
30316 | return Long.fromBits(high >>> (numBits - 32), 0, this.unsigned); | |
30317 | } | |
30318 | }; | |
30319 | ||
30320 | /** | |
30321 | * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. | |
30322 | * @function | |
30323 | * @param {number|!Long} numBits Number of bits | |
30324 | * @returns {!Long} Shifted Long | |
30325 | * @expose | |
30326 | */ | |
30327 | Long.prototype.shru = Long.prototype.shiftRightUnsigned; | |
30328 | ||
30329 | /** | |
30330 | * Converts this Long to signed. | |
30331 | * @returns {!Long} Signed long | |
30332 | * @expose | |
30333 | */ | |
30334 | Long.prototype.toSigned = function toSigned() { | |
30335 | if (!this.unsigned) | |
30336 | return this; | |
30337 | return new Long(this.low, this.high, false); | |
30338 | }; | |
30339 | ||
30340 | /** | |
30341 | * Converts this Long to unsigned. | |
30342 | * @returns {!Long} Unsigned long | |
30343 | * @expose | |
30344 | */ | |
30345 | Long.prototype.toUnsigned = function toUnsigned() { | |
30346 | if (this.unsigned) | |
30347 | return this; | |
30348 | return new Long(this.low, this.high, true); | |
30349 | }; | |
30350 | ||
30351 | return Long; | |
30352 | }); | |
30353 | ||
30354 | },{}],358:[function(require,module,exports){ | |
30355 | 'use strict' | |
30356 | var inherits = require('inherits') | |
30357 | var HashBase = require('hash-base') | |
30358 | var Buffer = require('safe-buffer').Buffer | |
30359 | ||
30360 | var ARRAY16 = new Array(16) | |
30361 | ||
30362 | function MD5 () { | |
30363 | HashBase.call(this, 64) | |
30364 | ||
30365 | // state | |
30366 | this._a = 0x67452301 | |
30367 | this._b = 0xefcdab89 | |
30368 | this._c = 0x98badcfe | |
30369 | this._d = 0x10325476 | |
30370 | } | |
30371 | ||
30372 | inherits(MD5, HashBase) | |
30373 | ||
30374 | MD5.prototype._update = function () { | |
30375 | var M = ARRAY16 | |
30376 | for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4) | |
30377 | ||
30378 | var a = this._a | |
30379 | var b = this._b | |
30380 | var c = this._c | |
30381 | var d = this._d | |
30382 | ||
30383 | a = fnF(a, b, c, d, M[0], 0xd76aa478, 7) | |
30384 | d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12) | |
30385 | c = fnF(c, d, a, b, M[2], 0x242070db, 17) | |
30386 | b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22) | |
30387 | a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7) | |
30388 | d = fnF(d, a, b, c, M[5], 0x4787c62a, 12) | |
30389 | c = fnF(c, d, a, b, M[6], 0xa8304613, 17) | |
30390 | b = fnF(b, c, d, a, M[7], 0xfd469501, 22) | |
30391 | a = fnF(a, b, c, d, M[8], 0x698098d8, 7) | |
30392 | d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12) | |
30393 | c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17) | |
30394 | b = fnF(b, c, d, a, M[11], 0x895cd7be, 22) | |
30395 | a = fnF(a, b, c, d, M[12], 0x6b901122, 7) | |
30396 | d = fnF(d, a, b, c, M[13], 0xfd987193, 12) | |
30397 | c = fnF(c, d, a, b, M[14], 0xa679438e, 17) | |
30398 | b = fnF(b, c, d, a, M[15], 0x49b40821, 22) | |
30399 | ||
30400 | a = fnG(a, b, c, d, M[1], 0xf61e2562, 5) | |
30401 | d = fnG(d, a, b, c, M[6], 0xc040b340, 9) | |
30402 | c = fnG(c, d, a, b, M[11], 0x265e5a51, 14) | |
30403 | b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20) | |
30404 | a = fnG(a, b, c, d, M[5], 0xd62f105d, 5) | |
30405 | d = fnG(d, a, b, c, M[10], 0x02441453, 9) | |
30406 | c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14) | |
30407 | b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20) | |
30408 | a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5) | |
30409 | d = fnG(d, a, b, c, M[14], 0xc33707d6, 9) | |
30410 | c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14) | |
30411 | b = fnG(b, c, d, a, M[8], 0x455a14ed, 20) | |
30412 | a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5) | |
30413 | d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9) | |
30414 | c = fnG(c, d, a, b, M[7], 0x676f02d9, 14) | |
30415 | b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20) | |
30416 | ||
30417 | a = fnH(a, b, c, d, M[5], 0xfffa3942, 4) | |
30418 | d = fnH(d, a, b, c, M[8], 0x8771f681, 11) | |
30419 | c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16) | |
30420 | b = fnH(b, c, d, a, M[14], 0xfde5380c, 23) | |
30421 | a = fnH(a, b, c, d, M[1], 0xa4beea44, 4) | |
30422 | d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11) | |
30423 | c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16) | |
30424 | b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23) | |
30425 | a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4) | |
30426 | d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11) | |
30427 | c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16) | |
30428 | b = fnH(b, c, d, a, M[6], 0x04881d05, 23) | |
30429 | a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4) | |
30430 | d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11) | |
30431 | c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16) | |
30432 | b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23) | |
30433 | ||
30434 | a = fnI(a, b, c, d, M[0], 0xf4292244, 6) | |
30435 | d = fnI(d, a, b, c, M[7], 0x432aff97, 10) | |
30436 | c = fnI(c, d, a, b, M[14], 0xab9423a7, 15) | |
30437 | b = fnI(b, c, d, a, M[5], 0xfc93a039, 21) | |
30438 | a = fnI(a, b, c, d, M[12], 0x655b59c3, 6) | |
30439 | d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10) | |
30440 | c = fnI(c, d, a, b, M[10], 0xffeff47d, 15) | |
30441 | b = fnI(b, c, d, a, M[1], 0x85845dd1, 21) | |
30442 | a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6) | |
30443 | d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10) | |
30444 | c = fnI(c, d, a, b, M[6], 0xa3014314, 15) | |
30445 | b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21) | |
30446 | a = fnI(a, b, c, d, M[4], 0xf7537e82, 6) | |
30447 | d = fnI(d, a, b, c, M[11], 0xbd3af235, 10) | |
30448 | c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15) | |
30449 | b = fnI(b, c, d, a, M[9], 0xeb86d391, 21) | |
30450 | ||
30451 | this._a = (this._a + a) | 0 | |
30452 | this._b = (this._b + b) | 0 | |
30453 | this._c = (this._c + c) | 0 | |
30454 | this._d = (this._d + d) | 0 | |
30455 | } | |
30456 | ||
30457 | MD5.prototype._digest = function () { | |
30458 | // create padding and handle blocks | |
30459 | this._block[this._blockOffset++] = 0x80 | |
30460 | if (this._blockOffset > 56) { | |
30461 | this._block.fill(0, this._blockOffset, 64) | |
30462 | this._update() | |
30463 | this._blockOffset = 0 | |
30464 | } | |
30465 | ||
30466 | this._block.fill(0, this._blockOffset, 56) | |
30467 | this._block.writeUInt32LE(this._length[0], 56) | |
30468 | this._block.writeUInt32LE(this._length[1], 60) | |
30469 | this._update() | |
30470 | ||
30471 | // produce result | |
30472 | var buffer = Buffer.allocUnsafe(16) | |
30473 | buffer.writeInt32LE(this._a, 0) | |
30474 | buffer.writeInt32LE(this._b, 4) | |
30475 | buffer.writeInt32LE(this._c, 8) | |
30476 | buffer.writeInt32LE(this._d, 12) | |
30477 | return buffer | |
30478 | } | |
30479 | ||
30480 | function rotl (x, n) { | |
30481 | return (x << n) | (x >>> (32 - n)) | |
30482 | } | |
30483 | ||
30484 | function fnF (a, b, c, d, m, k, s) { | |
30485 | return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0 | |
30486 | } | |
30487 | ||
30488 | function fnG (a, b, c, d, m, k, s) { | |
30489 | return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0 | |
30490 | } | |
30491 | ||
30492 | function fnH (a, b, c, d, m, k, s) { | |
30493 | return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0 | |
30494 | } | |
30495 | ||
30496 | function fnI (a, b, c, d, m, k, s) { | |
30497 | return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0 | |
30498 | } | |
30499 | ||
30500 | module.exports = MD5 | |
30501 | ||
30502 | },{"hash-base":104,"inherits":119,"safe-buffer":398}],359:[function(require,module,exports){ | |
30503 | var bn = require('bn.js'); | |
30504 | var brorand = require('brorand'); | |
30505 | ||
30506 | function MillerRabin(rand) { | |
30507 | this.rand = rand || new brorand.Rand(); | |
30508 | } | |
30509 | module.exports = MillerRabin; | |
30510 | ||
30511 | MillerRabin.create = function create(rand) { | |
30512 | return new MillerRabin(rand); | |
30513 | }; | |
30514 | ||
30515 | MillerRabin.prototype._randbelow = function _randbelow(n) { | |
30516 | var len = n.bitLength(); | |
30517 | var min_bytes = Math.ceil(len / 8); | |
30518 | ||
30519 | // Generage random bytes until a number less than n is found. | |
30520 | // This ensures that 0..n-1 have an equal probability of being selected. | |
30521 | do | |
30522 | var a = new bn(this.rand.generate(min_bytes)); | |
30523 | while (a.cmp(n) >= 0); | |
30524 | ||
30525 | return a; | |
30526 | }; | |
30527 | ||
30528 | MillerRabin.prototype._randrange = function _randrange(start, stop) { | |
30529 | // Generate a random number greater than or equal to start and less than stop. | |
30530 | var size = stop.sub(start); | |
30531 | return start.add(this._randbelow(size)); | |
30532 | }; | |
30533 | ||
30534 | MillerRabin.prototype.test = function test(n, k, cb) { | |
30535 | var len = n.bitLength(); | |
30536 | var red = bn.mont(n); | |
30537 | var rone = new bn(1).toRed(red); | |
30538 | ||
30539 | if (!k) | |
30540 | k = Math.max(1, (len / 48) | 0); | |
30541 | ||
30542 | // Find d and s, (n - 1) = (2 ^ s) * d; | |
30543 | var n1 = n.subn(1); | |
30544 | for (var s = 0; !n1.testn(s); s++) {} | |
30545 | var d = n.shrn(s); | |
30546 | ||
30547 | var rn1 = n1.toRed(red); | |
30548 | ||
30549 | var prime = true; | |
30550 | for (; k > 0; k--) { | |
30551 | var a = this._randrange(new bn(2), n1); | |
30552 | if (cb) | |
30553 | cb(a); | |
30554 | ||
30555 | var x = a.toRed(red).redPow(d); | |
30556 | if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) | |
30557 | continue; | |
30558 | ||
30559 | for (var i = 1; i < s; i++) { | |
30560 | x = x.redSqr(); | |
30561 | ||
30562 | if (x.cmp(rone) === 0) | |
30563 | return false; | |
30564 | if (x.cmp(rn1) === 0) | |
30565 | break; | |
30566 | } | |
30567 | ||
30568 | if (i === s) | |
30569 | return false; | |
30570 | } | |
30571 | ||
30572 | return prime; | |
30573 | }; | |
30574 | ||
30575 | MillerRabin.prototype.getDivisor = function getDivisor(n, k) { | |
30576 | var len = n.bitLength(); | |
30577 | var red = bn.mont(n); | |
30578 | var rone = new bn(1).toRed(red); | |
30579 | ||
30580 | if (!k) | |
30581 | k = Math.max(1, (len / 48) | 0); | |
30582 | ||
30583 | // Find d and s, (n - 1) = (2 ^ s) * d; | |
30584 | var n1 = n.subn(1); | |
30585 | for (var s = 0; !n1.testn(s); s++) {} | |
30586 | var d = n.shrn(s); | |
30587 | ||
30588 | var rn1 = n1.toRed(red); | |
30589 | ||
30590 | for (; k > 0; k--) { | |
30591 | var a = this._randrange(new bn(2), n1); | |
30592 | ||
30593 | var g = n.gcd(a); | |
30594 | if (g.cmpn(1) !== 0) | |
30595 | return g; | |
30596 | ||
30597 | var x = a.toRed(red).redPow(d); | |
30598 | if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) | |
30599 | continue; | |
30600 | ||
30601 | for (var i = 1; i < s; i++) { | |
30602 | x = x.redSqr(); | |
30603 | ||
30604 | if (x.cmp(rone) === 0) | |
30605 | return x.fromRed().subn(1).gcd(n); | |
30606 | if (x.cmp(rn1) === 0) | |
30607 | break; | |
30608 | } | |
30609 | ||
30610 | if (i === s) { | |
30611 | x = x.redSqr(); | |
30612 | return x.fromRed().subn(1).gcd(n); | |
30613 | } | |
30614 | } | |
30615 | ||
30616 | return false; | |
30617 | }; | |
30618 | ||
30619 | },{"bn.js":18,"brorand":19}],360:[function(require,module,exports){ | |
30620 | module.exports = assert; | |
30621 | ||
30622 | function assert(val, msg) { | |
30623 | if (!val) | |
30624 | throw new Error(msg || 'Assertion failed'); | |
30625 | } | |
30626 | ||
30627 | assert.equal = function assertEqual(l, r, msg) { | |
30628 | if (l != r) | |
30629 | throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r)); | |
30630 | }; | |
30631 | ||
30632 | },{}],361:[function(require,module,exports){ | |
30633 | 'use strict'; | |
30634 | ||
30635 | var utils = exports; | |
30636 | ||
30637 | function toArray(msg, enc) { | |
30638 | if (Array.isArray(msg)) | |
30639 | return msg.slice(); | |
30640 | if (!msg) | |
30641 | return []; | |
30642 | var res = []; | |
30643 | if (typeof msg !== 'string') { | |
30644 | for (var i = 0; i < msg.length; i++) | |
30645 | res[i] = msg[i] | 0; | |
30646 | return res; | |
30647 | } | |
30648 | if (enc === 'hex') { | |
30649 | msg = msg.replace(/[^a-z0-9]+/ig, ''); | |
30650 | if (msg.length % 2 !== 0) | |
30651 | msg = '0' + msg; | |
30652 | for (var i = 0; i < msg.length; i += 2) | |
30653 | res.push(parseInt(msg[i] + msg[i + 1], 16)); | |
30654 | } else { | |
30655 | for (var i = 0; i < msg.length; i++) { | |
30656 | var c = msg.charCodeAt(i); | |
30657 | var hi = c >> 8; | |
30658 | var lo = c & 0xff; | |
30659 | if (hi) | |
30660 | res.push(hi, lo); | |
30661 | else | |
30662 | res.push(lo); | |
30663 | } | |
30664 | } | |
30665 | return res; | |
30666 | } | |
30667 | utils.toArray = toArray; | |
30668 | ||
30669 | function zero2(word) { | |
30670 | if (word.length === 1) | |
30671 | return '0' + word; | |
30672 | else | |
30673 | return word; | |
30674 | } | |
30675 | utils.zero2 = zero2; | |
30676 | ||
30677 | function toHex(msg) { | |
30678 | var res = ''; | |
30679 | for (var i = 0; i < msg.length; i++) | |
30680 | res += zero2(msg[i].toString(16)); | |
30681 | return res; | |
30682 | } | |
30683 | utils.toHex = toHex; | |
30684 | ||
30685 | utils.encode = function encode(arr, enc) { | |
30686 | if (enc === 'hex') | |
30687 | return toHex(arr); | |
30688 | else | |
30689 | return arr; | |
30690 | }; | |
30691 | ||
30692 | },{}],362:[function(require,module,exports){ | |
30693 | module.exports={"2.16.840.1.101.3.4.1.1": "aes-128-ecb", | |
30694 | "2.16.840.1.101.3.4.1.2": "aes-128-cbc", | |
30695 | "2.16.840.1.101.3.4.1.3": "aes-128-ofb", | |
30696 | "2.16.840.1.101.3.4.1.4": "aes-128-cfb", | |
30697 | "2.16.840.1.101.3.4.1.21": "aes-192-ecb", | |
30698 | "2.16.840.1.101.3.4.1.22": "aes-192-cbc", | |
30699 | "2.16.840.1.101.3.4.1.23": "aes-192-ofb", | |
30700 | "2.16.840.1.101.3.4.1.24": "aes-192-cfb", | |
30701 | "2.16.840.1.101.3.4.1.41": "aes-256-ecb", | |
30702 | "2.16.840.1.101.3.4.1.42": "aes-256-cbc", | |
30703 | "2.16.840.1.101.3.4.1.43": "aes-256-ofb", | |
30704 | "2.16.840.1.101.3.4.1.44": "aes-256-cfb" | |
30705 | } | |
30706 | },{}],363:[function(require,module,exports){ | |
30707 | // from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js | |
30708 | // Fedor, you are amazing. | |
30709 | 'use strict' | |
30710 | ||
30711 | var asn1 = require('asn1.js') | |
30712 | ||
30713 | exports.certificate = require('./certificate') | |
30714 | ||
30715 | var RSAPrivateKey = asn1.define('RSAPrivateKey', function () { | |
30716 | this.seq().obj( | |
30717 | this.key('version').int(), | |
30718 | this.key('modulus').int(), | |
30719 | this.key('publicExponent').int(), | |
30720 | this.key('privateExponent').int(), | |
30721 | this.key('prime1').int(), | |
30722 | this.key('prime2').int(), | |
30723 | this.key('exponent1').int(), | |
30724 | this.key('exponent2').int(), | |
30725 | this.key('coefficient').int() | |
30726 | ) | |
30727 | }) | |
30728 | exports.RSAPrivateKey = RSAPrivateKey | |
30729 | ||
30730 | var RSAPublicKey = asn1.define('RSAPublicKey', function () { | |
30731 | this.seq().obj( | |
30732 | this.key('modulus').int(), | |
30733 | this.key('publicExponent').int() | |
30734 | ) | |
30735 | }) | |
30736 | exports.RSAPublicKey = RSAPublicKey | |
30737 | ||
30738 | var PublicKey = asn1.define('SubjectPublicKeyInfo', function () { | |
30739 | this.seq().obj( | |
30740 | this.key('algorithm').use(AlgorithmIdentifier), | |
30741 | this.key('subjectPublicKey').bitstr() | |
30742 | ) | |
30743 | }) | |
30744 | exports.PublicKey = PublicKey | |
30745 | ||
30746 | var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () { | |
30747 | this.seq().obj( | |
30748 | this.key('algorithm').objid(), | |
30749 | this.key('none').null_().optional(), | |
30750 | this.key('curve').objid().optional(), | |
30751 | this.key('params').seq().obj( | |
30752 | this.key('p').int(), | |
30753 | this.key('q').int(), | |
30754 | this.key('g').int() | |
30755 | ).optional() | |
30756 | ) | |
30757 | }) | |
30758 | ||
30759 | var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () { | |
30760 | this.seq().obj( | |
30761 | this.key('version').int(), | |
30762 | this.key('algorithm').use(AlgorithmIdentifier), | |
30763 | this.key('subjectPrivateKey').octstr() | |
30764 | ) | |
30765 | }) | |
30766 | exports.PrivateKey = PrivateKeyInfo | |
30767 | var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () { | |
30768 | this.seq().obj( | |
30769 | this.key('algorithm').seq().obj( | |
30770 | this.key('id').objid(), | |
30771 | this.key('decrypt').seq().obj( | |
30772 | this.key('kde').seq().obj( | |
30773 | this.key('id').objid(), | |
30774 | this.key('kdeparams').seq().obj( | |
30775 | this.key('salt').octstr(), | |
30776 | this.key('iters').int() | |
30777 | ) | |
30778 | ), | |
30779 | this.key('cipher').seq().obj( | |
30780 | this.key('algo').objid(), | |
30781 | this.key('iv').octstr() | |
30782 | ) | |
30783 | ) | |
30784 | ), | |
30785 | this.key('subjectPrivateKey').octstr() | |
30786 | ) | |
30787 | }) | |
30788 | ||
30789 | exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo | |
30790 | ||
30791 | var DSAPrivateKey = asn1.define('DSAPrivateKey', function () { | |
30792 | this.seq().obj( | |
30793 | this.key('version').int(), | |
30794 | this.key('p').int(), | |
30795 | this.key('q').int(), | |
30796 | this.key('g').int(), | |
30797 | this.key('pub_key').int(), | |
30798 | this.key('priv_key').int() | |
30799 | ) | |
30800 | }) | |
30801 | exports.DSAPrivateKey = DSAPrivateKey | |
30802 | ||
30803 | exports.DSAparam = asn1.define('DSAparam', function () { | |
30804 | this.int() | |
30805 | }) | |
30806 | ||
30807 | var ECPrivateKey = asn1.define('ECPrivateKey', function () { | |
30808 | this.seq().obj( | |
30809 | this.key('version').int(), | |
30810 | this.key('privateKey').octstr(), | |
30811 | this.key('parameters').optional().explicit(0).use(ECParameters), | |
30812 | this.key('publicKey').optional().explicit(1).bitstr() | |
30813 | ) | |
30814 | }) | |
30815 | exports.ECPrivateKey = ECPrivateKey | |
30816 | ||
30817 | var ECParameters = asn1.define('ECParameters', function () { | |
30818 | this.choice({ | |
30819 | namedCurve: this.objid() | |
30820 | }) | |
30821 | }) | |
30822 | ||
30823 | exports.signature = asn1.define('signature', function () { | |
30824 | this.seq().obj( | |
30825 | this.key('r').int(), | |
30826 | this.key('s').int() | |
30827 | ) | |
30828 | }) | |
30829 | ||
30830 | },{"./certificate":364,"asn1.js":1}],364:[function(require,module,exports){ | |
30831 | // from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js | |
30832 | // thanks to @Rantanen | |
30833 | ||
30834 | 'use strict' | |
30835 | ||
30836 | var asn = require('asn1.js') | |
30837 | ||
30838 | var Time = asn.define('Time', function () { | |
30839 | this.choice({ | |
30840 | utcTime: this.utctime(), | |
30841 | generalTime: this.gentime() | |
30842 | }) | |
30843 | }) | |
30844 | ||
30845 | var AttributeTypeValue = asn.define('AttributeTypeValue', function () { | |
30846 | this.seq().obj( | |
30847 | this.key('type').objid(), | |
30848 | this.key('value').any() | |
30849 | ) | |
30850 | }) | |
30851 | ||
30852 | var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () { | |
30853 | this.seq().obj( | |
30854 | this.key('algorithm').objid(), | |
30855 | this.key('parameters').optional() | |
30856 | ) | |
30857 | }) | |
30858 | ||
30859 | var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () { | |
30860 | this.seq().obj( | |
30861 | this.key('algorithm').use(AlgorithmIdentifier), | |
30862 | this.key('subjectPublicKey').bitstr() | |
30863 | ) | |
30864 | }) | |
30865 | ||
30866 | var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () { | |
30867 | this.setof(AttributeTypeValue) | |
30868 | }) | |
30869 | ||
30870 | var RDNSequence = asn.define('RDNSequence', function () { | |
30871 | this.seqof(RelativeDistinguishedName) | |
30872 | }) | |
30873 | ||
30874 | var Name = asn.define('Name', function () { | |
30875 | this.choice({ | |
30876 | rdnSequence: this.use(RDNSequence) | |
30877 | }) | |
30878 | }) | |
30879 | ||
30880 | var Validity = asn.define('Validity', function () { | |
30881 | this.seq().obj( | |
30882 | this.key('notBefore').use(Time), | |
30883 | this.key('notAfter').use(Time) | |
30884 | ) | |
30885 | }) | |
30886 | ||
30887 | var Extension = asn.define('Extension', function () { | |
30888 | this.seq().obj( | |
30889 | this.key('extnID').objid(), | |
30890 | this.key('critical').bool().def(false), | |
30891 | this.key('extnValue').octstr() | |
30892 | ) | |
30893 | }) | |
30894 | ||
30895 | var TBSCertificate = asn.define('TBSCertificate', function () { | |
30896 | this.seq().obj( | |
30897 | this.key('version').explicit(0).int(), | |
30898 | this.key('serialNumber').int(), | |
30899 | this.key('signature').use(AlgorithmIdentifier), | |
30900 | this.key('issuer').use(Name), | |
30901 | this.key('validity').use(Validity), | |
30902 | this.key('subject').use(Name), | |
30903 | this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo), | |
30904 | this.key('issuerUniqueID').implicit(1).bitstr().optional(), | |
30905 | this.key('subjectUniqueID').implicit(2).bitstr().optional(), | |
30906 | this.key('extensions').explicit(3).seqof(Extension).optional() | |
30907 | ) | |
30908 | }) | |
30909 | ||
30910 | var X509Certificate = asn.define('X509Certificate', function () { | |
30911 | this.seq().obj( | |
30912 | this.key('tbsCertificate').use(TBSCertificate), | |
30913 | this.key('signatureAlgorithm').use(AlgorithmIdentifier), | |
30914 | this.key('signatureValue').bitstr() | |
30915 | ) | |
30916 | }) | |
30917 | ||
30918 | module.exports = X509Certificate | |
30919 | ||
30920 | },{"asn1.js":1}],365:[function(require,module,exports){ | |
30921 | (function (Buffer){ | |
30922 | // adapted from https://github.com/apatil/pemstrip | |
30923 | 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 | |
30924 | var startRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----/m | |
30925 | var fullRegex = /^-----BEGIN ((?:.* KEY)|CERTIFICATE)-----([0-9A-z\n\r\+\/\=]+)-----END \1-----$/m | |
30926 | var evp = require('evp_bytestokey') | |
30927 | var ciphers = require('browserify-aes') | |
30928 | module.exports = function (okey, password) { | |
30929 | var key = okey.toString() | |
30930 | var match = key.match(findProc) | |
30931 | var decrypted | |
30932 | if (!match) { | |
30933 | var match2 = key.match(fullRegex) | |
30934 | decrypted = new Buffer(match2[2].replace(/[\r\n]/g, ''), 'base64') | |
30935 | } else { | |
30936 | var suite = 'aes' + match[1] | |
30937 | var iv = new Buffer(match[2], 'hex') | |
30938 | var cipherText = new Buffer(match[3].replace(/[\r\n]/g, ''), 'base64') | |
30939 | var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key | |
30940 | var out = [] | |
30941 | var cipher = ciphers.createDecipheriv(suite, cipherKey, iv) | |
30942 | out.push(cipher.update(cipherText)) | |
30943 | out.push(cipher.final()) | |
30944 | decrypted = Buffer.concat(out) | |
30945 | } | |
30946 | var tag = key.match(startRegex)[1] | |
30947 | return { | |
30948 | tag: tag, | |
30949 | data: decrypted | |
30950 | } | |
30951 | } | |
30952 | ||
30953 | }).call(this,require("buffer").Buffer) | |
30954 | },{"browserify-aes":23,"buffer":50,"evp_bytestokey":103}],366:[function(require,module,exports){ | |
30955 | (function (Buffer){ | |
30956 | var asn1 = require('./asn1') | |
30957 | var aesid = require('./aesid.json') | |
30958 | var fixProc = require('./fixProc') | |
30959 | var ciphers = require('browserify-aes') | |
30960 | var compat = require('pbkdf2') | |
30961 | module.exports = parseKeys | |
30962 | ||
30963 | function parseKeys (buffer) { | |
30964 | var password | |
30965 | if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) { | |
30966 | password = buffer.passphrase | |
30967 | buffer = buffer.key | |
30968 | } | |
30969 | if (typeof buffer === 'string') { | |
30970 | buffer = new Buffer(buffer) | |
30971 | } | |
30972 | ||
30973 | var stripped = fixProc(buffer, password) | |
30974 | ||
30975 | var type = stripped.tag | |
30976 | var data = stripped.data | |
30977 | var subtype, ndata | |
30978 | switch (type) { | |
30979 | case 'CERTIFICATE': | |
30980 | ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo | |
30981 | // falls through | |
30982 | case 'PUBLIC KEY': | |
30983 | if (!ndata) { | |
30984 | ndata = asn1.PublicKey.decode(data, 'der') | |
30985 | } | |
30986 | subtype = ndata.algorithm.algorithm.join('.') | |
30987 | switch (subtype) { | |
30988 | case '1.2.840.113549.1.1.1': | |
30989 | return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der') | |
30990 | case '1.2.840.10045.2.1': | |
30991 | ndata.subjectPrivateKey = ndata.subjectPublicKey | |
30992 | return { | |
30993 | type: 'ec', | |
30994 | data: ndata | |
30995 | } | |
30996 | case '1.2.840.10040.4.1': | |
30997 | ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der') | |
30998 | return { | |
30999 | type: 'dsa', | |
31000 | data: ndata.algorithm.params | |
31001 | } | |
31002 | default: throw new Error('unknown key id ' + subtype) | |
31003 | } | |
31004 | throw new Error('unknown key type ' + type) | |
31005 | case 'ENCRYPTED PRIVATE KEY': | |
31006 | data = asn1.EncryptedPrivateKey.decode(data, 'der') | |
31007 | data = decrypt(data, password) | |
31008 | // falls through | |
31009 | case 'PRIVATE KEY': | |
31010 | ndata = asn1.PrivateKey.decode(data, 'der') | |
31011 | subtype = ndata.algorithm.algorithm.join('.') | |
31012 | switch (subtype) { | |
31013 | case '1.2.840.113549.1.1.1': | |
31014 | return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der') | |
31015 | case '1.2.840.10045.2.1': | |
31016 | return { | |
31017 | curve: ndata.algorithm.curve, | |
31018 | privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey | |
31019 | } | |
31020 | case '1.2.840.10040.4.1': | |
31021 | ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der') | |
31022 | return { | |
31023 | type: 'dsa', | |
31024 | params: ndata.algorithm.params | |
31025 | } | |
31026 | default: throw new Error('unknown key id ' + subtype) | |
31027 | } | |
31028 | throw new Error('unknown key type ' + type) | |
31029 | case 'RSA PUBLIC KEY': | |
31030 | return asn1.RSAPublicKey.decode(data, 'der') | |
31031 | case 'RSA PRIVATE KEY': | |
31032 | return asn1.RSAPrivateKey.decode(data, 'der') | |
31033 | case 'DSA PRIVATE KEY': | |
31034 | return { | |
31035 | type: 'dsa', | |
31036 | params: asn1.DSAPrivateKey.decode(data, 'der') | |
31037 | } | |
31038 | case 'EC PRIVATE KEY': | |
31039 | data = asn1.ECPrivateKey.decode(data, 'der') | |
31040 | return { | |
31041 | curve: data.parameters.value, | |
31042 | privateKey: data.privateKey | |
31043 | } | |
31044 | default: throw new Error('unknown key type ' + type) | |
31045 | } | |
31046 | } | |
31047 | parseKeys.signature = asn1.signature | |
31048 | function decrypt (data, password) { | |
31049 | var salt = data.algorithm.decrypt.kde.kdeparams.salt | |
31050 | var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10) | |
31051 | var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')] | |
31052 | var iv = data.algorithm.decrypt.cipher.iv | |
31053 | var cipherText = data.subjectPrivateKey | |
31054 | var keylen = parseInt(algo.split('-')[1], 10) / 8 | |
31055 | var key = compat.pbkdf2Sync(password, salt, iters, keylen) | |
31056 | var cipher = ciphers.createDecipheriv(algo, key, iv) | |
31057 | var out = [] | |
31058 | out.push(cipher.update(cipherText)) | |
31059 | out.push(cipher.final()) | |
31060 | return Buffer.concat(out) | |
31061 | } | |
31062 | ||
31063 | }).call(this,require("buffer").Buffer) | |
31064 | },{"./aesid.json":362,"./asn1":363,"./fixProc":365,"browserify-aes":23,"buffer":50,"pbkdf2":368}],367:[function(require,module,exports){ | |
31065 | (function (process){ | |
31066 | // .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1, | |
31067 | // backported and transplited with Babel, with backwards-compat fixes | |
31068 | ||
31069 | // Copyright Joyent, Inc. and other Node contributors. | |
31070 | // | |
31071 | // Permission is hereby granted, free of charge, to any person obtaining a | |
31072 | // copy of this software and associated documentation files (the | |
31073 | // "Software"), to deal in the Software without restriction, including | |
31074 | // without limitation the rights to use, copy, modify, merge, publish, | |
31075 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
31076 | // persons to whom the Software is furnished to do so, subject to the | |
31077 | // following conditions: | |
31078 | // | |
31079 | // The above copyright notice and this permission notice shall be included | |
31080 | // in all copies or substantial portions of the Software. | |
31081 | // | |
31082 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
31083 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
31084 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
31085 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
31086 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
31087 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
31088 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
31089 | ||
31090 | // resolves . and .. elements in a path array with directory names there | |
31091 | // must be no slashes, empty elements, or device names (c:\) in the array | |
31092 | // (so also no leading and trailing slashes - it does not distinguish | |
31093 | // relative and absolute paths) | |
31094 | function normalizeArray(parts, allowAboveRoot) { | |
31095 | // if the path tries to go above the root, `up` ends up > 0 | |
31096 | var up = 0; | |
31097 | for (var i = parts.length - 1; i >= 0; i--) { | |
31098 | var last = parts[i]; | |
31099 | if (last === '.') { | |
31100 | parts.splice(i, 1); | |
31101 | } else if (last === '..') { | |
31102 | parts.splice(i, 1); | |
31103 | up++; | |
31104 | } else if (up) { | |
31105 | parts.splice(i, 1); | |
31106 | up--; | |
31107 | } | |
31108 | } | |
31109 | ||
31110 | // if the path is allowed to go above the root, restore leading ..s | |
31111 | if (allowAboveRoot) { | |
31112 | for (; up--; up) { | |
31113 | parts.unshift('..'); | |
31114 | } | |
31115 | } | |
31116 | ||
31117 | return parts; | |
31118 | } | |
31119 | ||
31120 | // path.resolve([from ...], to) | |
31121 | // posix version | |
31122 | exports.resolve = function() { | |
31123 | var resolvedPath = '', | |
31124 | resolvedAbsolute = false; | |
31125 | ||
31126 | for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { | |
31127 | var path = (i >= 0) ? arguments[i] : process.cwd(); | |
31128 | ||
31129 | // Skip empty and invalid entries | |
31130 | if (typeof path !== 'string') { | |
31131 | throw new TypeError('Arguments to path.resolve must be strings'); | |
31132 | } else if (!path) { | |
31133 | continue; | |
31134 | } | |
31135 | ||
31136 | resolvedPath = path + '/' + resolvedPath; | |
31137 | resolvedAbsolute = path.charAt(0) === '/'; | |
31138 | } | |
31139 | ||
31140 | // At this point the path should be resolved to a full absolute path, but | |
31141 | // handle relative paths to be safe (might happen when process.cwd() fails) | |
31142 | ||
31143 | // Normalize the path | |
31144 | resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { | |
31145 | return !!p; | |
31146 | }), !resolvedAbsolute).join('/'); | |
31147 | ||
31148 | return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; | |
31149 | }; | |
31150 | ||
31151 | // path.normalize(path) | |
31152 | // posix version | |
31153 | exports.normalize = function(path) { | |
31154 | var isAbsolute = exports.isAbsolute(path), | |
31155 | trailingSlash = substr(path, -1) === '/'; | |
31156 | ||
31157 | // Normalize the path | |
31158 | path = normalizeArray(filter(path.split('/'), function(p) { | |
31159 | return !!p; | |
31160 | }), !isAbsolute).join('/'); | |
31161 | ||
31162 | if (!path && !isAbsolute) { | |
31163 | path = '.'; | |
31164 | } | |
31165 | if (path && trailingSlash) { | |
31166 | path += '/'; | |
31167 | } | |
31168 | ||
31169 | return (isAbsolute ? '/' : '') + path; | |
31170 | }; | |
31171 | ||
31172 | // posix version | |
31173 | exports.isAbsolute = function(path) { | |
31174 | return path.charAt(0) === '/'; | |
31175 | }; | |
31176 | ||
31177 | // posix version | |
31178 | exports.join = function() { | |
31179 | var paths = Array.prototype.slice.call(arguments, 0); | |
31180 | return exports.normalize(filter(paths, function(p, index) { | |
31181 | if (typeof p !== 'string') { | |
31182 | throw new TypeError('Arguments to path.join must be strings'); | |
31183 | } | |
31184 | return p; | |
31185 | }).join('/')); | |
31186 | }; | |
31187 | ||
31188 | ||
31189 | // path.relative(from, to) | |
31190 | // posix version | |
31191 | exports.relative = function(from, to) { | |
31192 | from = exports.resolve(from).substr(1); | |
31193 | to = exports.resolve(to).substr(1); | |
31194 | ||
31195 | function trim(arr) { | |
31196 | var start = 0; | |
31197 | for (; start < arr.length; start++) { | |
31198 | if (arr[start] !== '') break; | |
31199 | } | |
31200 | ||
31201 | var end = arr.length - 1; | |
31202 | for (; end >= 0; end--) { | |
31203 | if (arr[end] !== '') break; | |
31204 | } | |
31205 | ||
31206 | if (start > end) return []; | |
31207 | return arr.slice(start, end - start + 1); | |
31208 | } | |
31209 | ||
31210 | var fromParts = trim(from.split('/')); | |
31211 | var toParts = trim(to.split('/')); | |
31212 | ||
31213 | var length = Math.min(fromParts.length, toParts.length); | |
31214 | var samePartsLength = length; | |
31215 | for (var i = 0; i < length; i++) { | |
31216 | if (fromParts[i] !== toParts[i]) { | |
31217 | samePartsLength = i; | |
31218 | break; | |
31219 | } | |
31220 | } | |
31221 | ||
31222 | var outputParts = []; | |
31223 | for (var i = samePartsLength; i < fromParts.length; i++) { | |
31224 | outputParts.push('..'); | |
31225 | } | |
31226 | ||
31227 | outputParts = outputParts.concat(toParts.slice(samePartsLength)); | |
31228 | ||
31229 | return outputParts.join('/'); | |
31230 | }; | |
31231 | ||
31232 | exports.sep = '/'; | |
31233 | exports.delimiter = ':'; | |
31234 | ||
31235 | exports.dirname = function (path) { | |
31236 | if (typeof path !== 'string') path = path + ''; | |
31237 | if (path.length === 0) return '.'; | |
31238 | var code = path.charCodeAt(0); | |
31239 | var hasRoot = code === 47 /*/*/; | |
31240 | var end = -1; | |
31241 | var matchedSlash = true; | |
31242 | for (var i = path.length - 1; i >= 1; --i) { | |
31243 | code = path.charCodeAt(i); | |
31244 | if (code === 47 /*/*/) { | |
31245 | if (!matchedSlash) { | |
31246 | end = i; | |
31247 | break; | |
31248 | } | |
31249 | } else { | |
31250 | // We saw the first non-path separator | |
31251 | matchedSlash = false; | |
31252 | } | |
31253 | } | |
31254 | ||
31255 | if (end === -1) return hasRoot ? '/' : '.'; | |
31256 | if (hasRoot && end === 1) { | |
31257 | // return '//'; | |
31258 | // Backwards-compat fix: | |
31259 | return '/'; | |
31260 | } | |
31261 | return path.slice(0, end); | |
31262 | }; | |
31263 | ||
31264 | function basename(path) { | |
31265 | if (typeof path !== 'string') path = path + ''; | |
31266 | ||
31267 | var start = 0; | |
31268 | var end = -1; | |
31269 | var matchedSlash = true; | |
31270 | var i; | |
31271 | ||
31272 | for (i = path.length - 1; i >= 0; --i) { | |
31273 | if (path.charCodeAt(i) === 47 /*/*/) { | |
31274 | // If we reached a path separator that was not part of a set of path | |
31275 | // separators at the end of the string, stop now | |
31276 | if (!matchedSlash) { | |
31277 | start = i + 1; | |
31278 | break; | |
31279 | } | |
31280 | } else if (end === -1) { | |
31281 | // We saw the first non-path separator, mark this as the end of our | |
31282 | // path component | |
31283 | matchedSlash = false; | |
31284 | end = i + 1; | |
31285 | } | |
31286 | } | |
31287 | ||
31288 | if (end === -1) return ''; | |
31289 | return path.slice(start, end); | |
31290 | } | |
31291 | ||
31292 | // Uses a mixed approach for backwards-compatibility, as ext behavior changed | |
31293 | // in new Node.js versions, so only basename() above is backported here | |
31294 | exports.basename = function (path, ext) { | |
31295 | var f = basename(path); | |
31296 | if (ext && f.substr(-1 * ext.length) === ext) { | |
31297 | f = f.substr(0, f.length - ext.length); | |
31298 | } | |
31299 | return f; | |
31300 | }; | |
31301 | ||
31302 | exports.extname = function (path) { | |
31303 | if (typeof path !== 'string') path = path + ''; | |
31304 | var startDot = -1; | |
31305 | var startPart = 0; | |
31306 | var end = -1; | |
31307 | var matchedSlash = true; | |
31308 | // Track the state of characters (if any) we see before our first dot and | |
31309 | // after any path separator we find | |
31310 | var preDotState = 0; | |
31311 | for (var i = path.length - 1; i >= 0; --i) { | |
31312 | var code = path.charCodeAt(i); | |
31313 | if (code === 47 /*/*/) { | |
31314 | // If we reached a path separator that was not part of a set of path | |
31315 | // separators at the end of the string, stop now | |
31316 | if (!matchedSlash) { | |
31317 | startPart = i + 1; | |
31318 | break; | |
31319 | } | |
31320 | continue; | |
31321 | } | |
31322 | if (end === -1) { | |
31323 | // We saw the first non-path separator, mark this as the end of our | |
31324 | // extension | |
31325 | matchedSlash = false; | |
31326 | end = i + 1; | |
31327 | } | |
31328 | if (code === 46 /*.*/) { | |
31329 | // If this is our first dot, mark it as the start of our extension | |
31330 | if (startDot === -1) | |
31331 | startDot = i; | |
31332 | else if (preDotState !== 1) | |
31333 | preDotState = 1; | |
31334 | } else if (startDot !== -1) { | |
31335 | // We saw a non-dot and non-path separator before our dot, so we should | |
31336 | // have a good chance at having a non-empty extension | |
31337 | preDotState = -1; | |
31338 | } | |
31339 | } | |
31340 | ||
31341 | if (startDot === -1 || end === -1 || | |
31342 | // We saw a non-dot character immediately before the dot | |
31343 | preDotState === 0 || | |
31344 | // The (right-most) trimmed path component is exactly '..' | |
31345 | preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { | |
31346 | return ''; | |
31347 | } | |
31348 | return path.slice(startDot, end); | |
31349 | }; | |
31350 | ||
31351 | function filter (xs, f) { | |
31352 | if (xs.filter) return xs.filter(f); | |
31353 | var res = []; | |
31354 | for (var i = 0; i < xs.length; i++) { | |
31355 | if (f(xs[i], i, xs)) res.push(xs[i]); | |
31356 | } | |
31357 | return res; | |
31358 | } | |
31359 | ||
31360 | // String.prototype.substr - negative index don't work in IE8 | |
31361 | var substr = 'ab'.substr(-1) === 'b' | |
31362 | ? function (str, start, len) { return str.substr(start, len) } | |
31363 | : function (str, start, len) { | |
31364 | if (start < 0) start = str.length + start; | |
31365 | return str.substr(start, len); | |
31366 | } | |
31367 | ; | |
31368 | ||
31369 | }).call(this,require('_process')) | |
31370 | },{"_process":374}],368:[function(require,module,exports){ | |
31371 | exports.pbkdf2 = require('./lib/async') | |
31372 | exports.pbkdf2Sync = require('./lib/sync') | |
31373 | ||
31374 | },{"./lib/async":369,"./lib/sync":372}],369:[function(require,module,exports){ | |
31375 | (function (process,global){ | |
31376 | var checkParameters = require('./precondition') | |
31377 | var defaultEncoding = require('./default-encoding') | |
31378 | var sync = require('./sync') | |
31379 | var Buffer = require('safe-buffer').Buffer | |
31380 | ||
31381 | var ZERO_BUF | |
31382 | var subtle = global.crypto && global.crypto.subtle | |
31383 | var toBrowser = { | |
31384 | 'sha': 'SHA-1', | |
31385 | 'sha-1': 'SHA-1', | |
31386 | 'sha1': 'SHA-1', | |
31387 | 'sha256': 'SHA-256', | |
31388 | 'sha-256': 'SHA-256', | |
31389 | 'sha384': 'SHA-384', | |
31390 | 'sha-384': 'SHA-384', | |
31391 | 'sha-512': 'SHA-512', | |
31392 | 'sha512': 'SHA-512' | |
31393 | } | |
31394 | var checks = [] | |
31395 | function checkNative (algo) { | |
31396 | if (global.process && !global.process.browser) { | |
31397 | return Promise.resolve(false) | |
31398 | } | |
31399 | if (!subtle || !subtle.importKey || !subtle.deriveBits) { | |
31400 | return Promise.resolve(false) | |
31401 | } | |
31402 | if (checks[algo] !== undefined) { | |
31403 | return checks[algo] | |
31404 | } | |
31405 | ZERO_BUF = ZERO_BUF || Buffer.alloc(8) | |
31406 | var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo) | |
31407 | .then(function () { | |
31408 | return true | |
31409 | }).catch(function () { | |
31410 | return false | |
31411 | }) | |
31412 | checks[algo] = prom | |
31413 | return prom | |
31414 | } | |
31415 | ||
31416 | function browserPbkdf2 (password, salt, iterations, length, algo) { | |
31417 | return subtle.importKey( | |
31418 | 'raw', password, {name: 'PBKDF2'}, false, ['deriveBits'] | |
31419 | ).then(function (key) { | |
31420 | return subtle.deriveBits({ | |
31421 | name: 'PBKDF2', | |
31422 | salt: salt, | |
31423 | iterations: iterations, | |
31424 | hash: { | |
31425 | name: algo | |
31426 | } | |
31427 | }, key, length << 3) | |
31428 | }).then(function (res) { | |
31429 | return Buffer.from(res) | |
31430 | }) | |
31431 | } | |
31432 | ||
31433 | function resolvePromise (promise, callback) { | |
31434 | promise.then(function (out) { | |
31435 | process.nextTick(function () { | |
31436 | callback(null, out) | |
31437 | }) | |
31438 | }, function (e) { | |
31439 | process.nextTick(function () { | |
31440 | callback(e) | |
31441 | }) | |
31442 | }) | |
31443 | } | |
31444 | module.exports = function (password, salt, iterations, keylen, digest, callback) { | |
31445 | if (typeof digest === 'function') { | |
31446 | callback = digest | |
31447 | digest = undefined | |
31448 | } | |
31449 | ||
31450 | digest = digest || 'sha1' | |
31451 | var algo = toBrowser[digest.toLowerCase()] | |
31452 | ||
31453 | if (!algo || typeof global.Promise !== 'function') { | |
31454 | return process.nextTick(function () { | |
31455 | var out | |
31456 | try { | |
31457 | out = sync(password, salt, iterations, keylen, digest) | |
31458 | } catch (e) { | |
31459 | return callback(e) | |
31460 | } | |
31461 | callback(null, out) | |
31462 | }) | |
31463 | } | |
31464 | ||
31465 | checkParameters(password, salt, iterations, keylen) | |
31466 | if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2') | |
31467 | if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding) | |
31468 | if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding) | |
31469 | ||
31470 | resolvePromise(checkNative(algo).then(function (resp) { | |
31471 | if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo) | |
31472 | ||
31473 | return sync(password, salt, iterations, keylen, digest) | |
31474 | }), callback) | |
31475 | } | |
31476 | ||
31477 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
31478 | },{"./default-encoding":370,"./precondition":371,"./sync":372,"_process":374,"safe-buffer":398}],370:[function(require,module,exports){ | |
31479 | (function (process){ | |
31480 | var defaultEncoding | |
31481 | /* istanbul ignore next */ | |
31482 | if (process.browser) { | |
31483 | defaultEncoding = 'utf-8' | |
31484 | } else { | |
31485 | var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10) | |
31486 | ||
31487 | defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary' | |
31488 | } | |
31489 | module.exports = defaultEncoding | |
31490 | ||
31491 | }).call(this,require('_process')) | |
31492 | },{"_process":374}],371:[function(require,module,exports){ | |
31493 | (function (Buffer){ | |
31494 | var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs | |
31495 | ||
31496 | function checkBuffer (buf, name) { | |
31497 | if (typeof buf !== 'string' && !Buffer.isBuffer(buf)) { | |
31498 | throw new TypeError(name + ' must be a buffer or string') | |
31499 | } | |
31500 | } | |
31501 | ||
31502 | module.exports = function (password, salt, iterations, keylen) { | |
31503 | checkBuffer(password, 'Password') | |
31504 | checkBuffer(salt, 'Salt') | |
31505 | ||
31506 | if (typeof iterations !== 'number') { | |
31507 | throw new TypeError('Iterations not a number') | |
31508 | } | |
31509 | ||
31510 | if (iterations < 0) { | |
31511 | throw new TypeError('Bad iterations') | |
31512 | } | |
31513 | ||
31514 | if (typeof keylen !== 'number') { | |
31515 | throw new TypeError('Key length not a number') | |
31516 | } | |
31517 | ||
31518 | if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */ | |
31519 | throw new TypeError('Bad key length') | |
31520 | } | |
31521 | } | |
31522 | ||
31523 | }).call(this,{"isBuffer":require("../../is-buffer/index.js")}) | |
31524 | },{"../../is-buffer/index.js":120}],372:[function(require,module,exports){ | |
31525 | var md5 = require('create-hash/md5') | |
31526 | var RIPEMD160 = require('ripemd160') | |
31527 | var sha = require('sha.js') | |
31528 | ||
31529 | var checkParameters = require('./precondition') | |
31530 | var defaultEncoding = require('./default-encoding') | |
31531 | var Buffer = require('safe-buffer').Buffer | |
31532 | var ZEROS = Buffer.alloc(128) | |
31533 | var sizes = { | |
31534 | md5: 16, | |
31535 | sha1: 20, | |
31536 | sha224: 28, | |
31537 | sha256: 32, | |
31538 | sha384: 48, | |
31539 | sha512: 64, | |
31540 | rmd160: 20, | |
31541 | ripemd160: 20 | |
31542 | } | |
31543 | ||
31544 | function Hmac (alg, key, saltLen) { | |
31545 | var hash = getDigest(alg) | |
31546 | var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64 | |
31547 | ||
31548 | if (key.length > blocksize) { | |
31549 | key = hash(key) | |
31550 | } else if (key.length < blocksize) { | |
31551 | key = Buffer.concat([key, ZEROS], blocksize) | |
31552 | } | |
31553 | ||
31554 | var ipad = Buffer.allocUnsafe(blocksize + sizes[alg]) | |
31555 | var opad = Buffer.allocUnsafe(blocksize + sizes[alg]) | |
31556 | for (var i = 0; i < blocksize; i++) { | |
31557 | ipad[i] = key[i] ^ 0x36 | |
31558 | opad[i] = key[i] ^ 0x5C | |
31559 | } | |
31560 | ||
31561 | var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4) | |
31562 | ipad.copy(ipad1, 0, 0, blocksize) | |
31563 | this.ipad1 = ipad1 | |
31564 | this.ipad2 = ipad | |
31565 | this.opad = opad | |
31566 | this.alg = alg | |
31567 | this.blocksize = blocksize | |
31568 | this.hash = hash | |
31569 | this.size = sizes[alg] | |
31570 | } | |
31571 | ||
31572 | Hmac.prototype.run = function (data, ipad) { | |
31573 | data.copy(ipad, this.blocksize) | |
31574 | var h = this.hash(ipad) | |
31575 | h.copy(this.opad, this.blocksize) | |
31576 | return this.hash(this.opad) | |
31577 | } | |
31578 | ||
31579 | function getDigest (alg) { | |
31580 | function shaFunc (data) { | |
31581 | return sha(alg).update(data).digest() | |
31582 | } | |
31583 | function rmd160Func (data) { | |
31584 | return new RIPEMD160().update(data).digest() | |
31585 | } | |
31586 | ||
31587 | if (alg === 'rmd160' || alg === 'ripemd160') return rmd160Func | |
31588 | if (alg === 'md5') return md5 | |
31589 | return shaFunc | |
31590 | } | |
31591 | ||
31592 | function pbkdf2 (password, salt, iterations, keylen, digest) { | |
31593 | checkParameters(password, salt, iterations, keylen) | |
31594 | ||
31595 | if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding) | |
31596 | if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding) | |
31597 | ||
31598 | digest = digest || 'sha1' | |
31599 | ||
31600 | var hmac = new Hmac(digest, password, salt.length) | |
31601 | ||
31602 | var DK = Buffer.allocUnsafe(keylen) | |
31603 | var block1 = Buffer.allocUnsafe(salt.length + 4) | |
31604 | salt.copy(block1, 0, 0, salt.length) | |
31605 | ||
31606 | var destPos = 0 | |
31607 | var hLen = sizes[digest] | |
31608 | var l = Math.ceil(keylen / hLen) | |
31609 | ||
31610 | for (var i = 1; i <= l; i++) { | |
31611 | block1.writeUInt32BE(i, salt.length) | |
31612 | ||
31613 | var T = hmac.run(block1, hmac.ipad1) | |
31614 | var U = T | |
31615 | ||
31616 | for (var j = 1; j < iterations; j++) { | |
31617 | U = hmac.run(U, hmac.ipad2) | |
31618 | for (var k = 0; k < hLen; k++) T[k] ^= U[k] | |
31619 | } | |
31620 | ||
31621 | T.copy(DK, destPos) | |
31622 | destPos += hLen | |
31623 | } | |
31624 | ||
31625 | return DK | |
31626 | } | |
31627 | ||
31628 | module.exports = pbkdf2 | |
31629 | ||
31630 | },{"./default-encoding":370,"./precondition":371,"create-hash/md5":69,"ripemd160":397,"safe-buffer":398,"sha.js":400}],373:[function(require,module,exports){ | |
31631 | (function (process){ | |
31632 | 'use strict'; | |
31633 | ||
31634 | if (!process.version || | |
31635 | process.version.indexOf('v0.') === 0 || | |
31636 | process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { | |
31637 | module.exports = { nextTick: nextTick }; | |
31638 | } else { | |
31639 | module.exports = process | |
31640 | } | |
31641 | ||
31642 | function nextTick(fn, arg1, arg2, arg3) { | |
31643 | if (typeof fn !== 'function') { | |
31644 | throw new TypeError('"callback" argument must be a function'); | |
31645 | } | |
31646 | var len = arguments.length; | |
31647 | var args, i; | |
31648 | switch (len) { | |
31649 | case 0: | |
31650 | case 1: | |
31651 | return process.nextTick(fn); | |
31652 | case 2: | |
31653 | return process.nextTick(function afterTickOne() { | |
31654 | fn.call(null, arg1); | |
31655 | }); | |
31656 | case 3: | |
31657 | return process.nextTick(function afterTickTwo() { | |
31658 | fn.call(null, arg1, arg2); | |
31659 | }); | |
31660 | case 4: | |
31661 | return process.nextTick(function afterTickThree() { | |
31662 | fn.call(null, arg1, arg2, arg3); | |
31663 | }); | |
31664 | default: | |
31665 | args = new Array(len - 1); | |
31666 | i = 0; | |
31667 | while (i < args.length) { | |
31668 | args[i++] = arguments[i]; | |
31669 | } | |
31670 | return process.nextTick(function afterTick() { | |
31671 | fn.apply(null, args); | |
31672 | }); | |
31673 | } | |
31674 | } | |
31675 | ||
31676 | ||
31677 | }).call(this,require('_process')) | |
31678 | },{"_process":374}],374:[function(require,module,exports){ | |
31679 | // shim for using process in browser | |
31680 | var process = module.exports = {}; | |
31681 | ||
31682 | // cached from whatever global is present so that test runners that stub it | |
31683 | // don't break things. But we need to wrap it in a try catch in case it is | |
31684 | // wrapped in strict mode code which doesn't define any globals. It's inside a | |
31685 | // function because try/catches deoptimize in certain engines. | |
31686 | ||
31687 | var cachedSetTimeout; | |
31688 | var cachedClearTimeout; | |
31689 | ||
31690 | function defaultSetTimout() { | |
31691 | throw new Error('setTimeout has not been defined'); | |
31692 | } | |
31693 | function defaultClearTimeout () { | |
31694 | throw new Error('clearTimeout has not been defined'); | |
31695 | } | |
31696 | (function () { | |
31697 | try { | |
31698 | if (typeof setTimeout === 'function') { | |
31699 | cachedSetTimeout = setTimeout; | |
31700 | } else { | |
31701 | cachedSetTimeout = defaultSetTimout; | |
31702 | } | |
31703 | } catch (e) { | |
31704 | cachedSetTimeout = defaultSetTimout; | |
31705 | } | |
31706 | try { | |
31707 | if (typeof clearTimeout === 'function') { | |
31708 | cachedClearTimeout = clearTimeout; | |
31709 | } else { | |
31710 | cachedClearTimeout = defaultClearTimeout; | |
31711 | } | |
31712 | } catch (e) { | |
31713 | cachedClearTimeout = defaultClearTimeout; | |
31714 | } | |
31715 | } ()) | |
31716 | function runTimeout(fun) { | |
31717 | if (cachedSetTimeout === setTimeout) { | |
31718 | //normal enviroments in sane situations | |
31719 | return setTimeout(fun, 0); | |
31720 | } | |
31721 | // if setTimeout wasn't available but was latter defined | |
31722 | if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { | |
31723 | cachedSetTimeout = setTimeout; | |
31724 | return setTimeout(fun, 0); | |
31725 | } | |
31726 | try { | |
31727 | // when when somebody has screwed with setTimeout but no I.E. maddness | |
31728 | return cachedSetTimeout(fun, 0); | |
31729 | } catch(e){ | |
31730 | try { | |
31731 | // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | |
31732 | return cachedSetTimeout.call(null, fun, 0); | |
31733 | } catch(e){ | |
31734 | // 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 | |
31735 | return cachedSetTimeout.call(this, fun, 0); | |
31736 | } | |
31737 | } | |
31738 | ||
31739 | ||
31740 | } | |
31741 | function runClearTimeout(marker) { | |
31742 | if (cachedClearTimeout === clearTimeout) { | |
31743 | //normal enviroments in sane situations | |
31744 | return clearTimeout(marker); | |
31745 | } | |
31746 | // if clearTimeout wasn't available but was latter defined | |
31747 | if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { | |
31748 | cachedClearTimeout = clearTimeout; | |
31749 | return clearTimeout(marker); | |
31750 | } | |
31751 | try { | |
31752 | // when when somebody has screwed with setTimeout but no I.E. maddness | |
31753 | return cachedClearTimeout(marker); | |
31754 | } catch (e){ | |
31755 | try { | |
31756 | // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | |
31757 | return cachedClearTimeout.call(null, marker); | |
31758 | } catch (e){ | |
31759 | // 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. | |
31760 | // Some versions of I.E. have different rules for clearTimeout vs setTimeout | |
31761 | return cachedClearTimeout.call(this, marker); | |
31762 | } | |
31763 | } | |
31764 | ||
31765 | ||
31766 | ||
31767 | } | |
31768 | var queue = []; | |
31769 | var draining = false; | |
31770 | var currentQueue; | |
31771 | var queueIndex = -1; | |
31772 | ||
31773 | function cleanUpNextTick() { | |
31774 | if (!draining || !currentQueue) { | |
31775 | return; | |
31776 | } | |
31777 | draining = false; | |
31778 | if (currentQueue.length) { | |
31779 | queue = currentQueue.concat(queue); | |
31780 | } else { | |
31781 | queueIndex = -1; | |
31782 | } | |
31783 | if (queue.length) { | |
31784 | drainQueue(); | |
31785 | } | |
31786 | } | |
31787 | ||
31788 | function drainQueue() { | |
31789 | if (draining) { | |
31790 | return; | |
31791 | } | |
31792 | var timeout = runTimeout(cleanUpNextTick); | |
31793 | draining = true; | |
31794 | ||
31795 | var len = queue.length; | |
31796 | while(len) { | |
31797 | currentQueue = queue; | |
31798 | queue = []; | |
31799 | while (++queueIndex < len) { | |
31800 | if (currentQueue) { | |
31801 | currentQueue[queueIndex].run(); | |
31802 | } | |
31803 | } | |
31804 | queueIndex = -1; | |
31805 | len = queue.length; | |
31806 | } | |
31807 | currentQueue = null; | |
31808 | draining = false; | |
31809 | runClearTimeout(timeout); | |
31810 | } | |
31811 | ||
31812 | process.nextTick = function (fun) { | |
31813 | var args = new Array(arguments.length - 1); | |
31814 | if (arguments.length > 1) { | |
31815 | for (var i = 1; i < arguments.length; i++) { | |
31816 | args[i - 1] = arguments[i]; | |
31817 | } | |
31818 | } | |
31819 | queue.push(new Item(fun, args)); | |
31820 | if (queue.length === 1 && !draining) { | |
31821 | runTimeout(drainQueue); | |
31822 | } | |
31823 | }; | |
31824 | ||
31825 | // v8 likes predictible objects | |
31826 | function Item(fun, array) { | |
31827 | this.fun = fun; | |
31828 | this.array = array; | |
31829 | } | |
31830 | Item.prototype.run = function () { | |
31831 | this.fun.apply(null, this.array); | |
31832 | }; | |
31833 | process.title = 'browser'; | |
31834 | process.browser = true; | |
31835 | process.env = {}; | |
31836 | process.argv = []; | |
31837 | process.version = ''; // empty string to avoid regexp issues | |
31838 | process.versions = {}; | |
31839 | ||
31840 | function noop() {} | |
31841 | ||
31842 | process.on = noop; | |
31843 | process.addListener = noop; | |
31844 | process.once = noop; | |
31845 | process.off = noop; | |
31846 | process.removeListener = noop; | |
31847 | process.removeAllListeners = noop; | |
31848 | process.emit = noop; | |
31849 | process.prependListener = noop; | |
31850 | process.prependOnceListener = noop; | |
31851 | ||
31852 | process.listeners = function (name) { return [] } | |
31853 | ||
31854 | process.binding = function (name) { | |
31855 | throw new Error('process.binding is not supported'); | |
31856 | }; | |
31857 | ||
31858 | process.cwd = function () { return '/' }; | |
31859 | process.chdir = function (dir) { | |
31860 | throw new Error('process.chdir is not supported'); | |
31861 | }; | |
31862 | process.umask = function() { return 0; }; | |
31863 | ||
31864 | },{}],375:[function(require,module,exports){ | |
31865 | exports.publicEncrypt = require('./publicEncrypt') | |
31866 | exports.privateDecrypt = require('./privateDecrypt') | |
31867 | ||
31868 | exports.privateEncrypt = function privateEncrypt (key, buf) { | |
31869 | return exports.publicEncrypt(key, buf, true) | |
31870 | } | |
31871 | ||
31872 | exports.publicDecrypt = function publicDecrypt (key, buf) { | |
31873 | return exports.privateDecrypt(key, buf, true) | |
31874 | } | |
31875 | ||
31876 | },{"./privateDecrypt":377,"./publicEncrypt":378}],376:[function(require,module,exports){ | |
31877 | var createHash = require('create-hash') | |
31878 | var Buffer = require('safe-buffer').Buffer | |
31879 | ||
31880 | module.exports = function (seed, len) { | |
31881 | var t = Buffer.alloc(0) | |
31882 | var i = 0 | |
31883 | var c | |
31884 | while (t.length < len) { | |
31885 | c = i2ops(i++) | |
31886 | t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]) | |
31887 | } | |
31888 | return t.slice(0, len) | |
31889 | } | |
31890 | ||
31891 | function i2ops (c) { | |
31892 | var out = Buffer.allocUnsafe(4) | |
31893 | out.writeUInt32BE(c, 0) | |
31894 | return out | |
31895 | } | |
31896 | ||
31897 | },{"create-hash":68,"safe-buffer":398}],377:[function(require,module,exports){ | |
31898 | var parseKeys = require('parse-asn1') | |
31899 | var mgf = require('./mgf') | |
31900 | var xor = require('./xor') | |
31901 | var BN = require('bn.js') | |
31902 | var crt = require('browserify-rsa') | |
31903 | var createHash = require('create-hash') | |
31904 | var withPublic = require('./withPublic') | |
31905 | var Buffer = require('safe-buffer').Buffer | |
31906 | ||
31907 | module.exports = function privateDecrypt (privateKey, enc, reverse) { | |
31908 | var padding | |
31909 | if (privateKey.padding) { | |
31910 | padding = privateKey.padding | |
31911 | } else if (reverse) { | |
31912 | padding = 1 | |
31913 | } else { | |
31914 | padding = 4 | |
31915 | } | |
31916 | ||
31917 | var key = parseKeys(privateKey) | |
31918 | var k = key.modulus.byteLength() | |
31919 | if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) { | |
31920 | throw new Error('decryption error') | |
31921 | } | |
31922 | var msg | |
31923 | if (reverse) { | |
31924 | msg = withPublic(new BN(enc), key) | |
31925 | } else { | |
31926 | msg = crt(enc, key) | |
31927 | } | |
31928 | var zBuffer = Buffer.alloc(k - msg.length) | |
31929 | msg = Buffer.concat([zBuffer, msg], k) | |
31930 | if (padding === 4) { | |
31931 | return oaep(key, msg) | |
31932 | } else if (padding === 1) { | |
31933 | return pkcs1(key, msg, reverse) | |
31934 | } else if (padding === 3) { | |
31935 | return msg | |
31936 | } else { | |
31937 | throw new Error('unknown padding') | |
31938 | } | |
31939 | } | |
31940 | ||
31941 | function oaep (key, msg) { | |
31942 | var k = key.modulus.byteLength() | |
31943 | var iHash = createHash('sha1').update(Buffer.alloc(0)).digest() | |
31944 | var hLen = iHash.length | |
31945 | if (msg[0] !== 0) { | |
31946 | throw new Error('decryption error') | |
31947 | } | |
31948 | var maskedSeed = msg.slice(1, hLen + 1) | |
31949 | var maskedDb = msg.slice(hLen + 1) | |
31950 | var seed = xor(maskedSeed, mgf(maskedDb, hLen)) | |
31951 | var db = xor(maskedDb, mgf(seed, k - hLen - 1)) | |
31952 | if (compare(iHash, db.slice(0, hLen))) { | |
31953 | throw new Error('decryption error') | |
31954 | } | |
31955 | var i = hLen | |
31956 | while (db[i] === 0) { | |
31957 | i++ | |
31958 | } | |
31959 | if (db[i++] !== 1) { | |
31960 | throw new Error('decryption error') | |
31961 | } | |
31962 | return db.slice(i) | |
31963 | } | |
31964 | ||
31965 | function pkcs1 (key, msg, reverse) { | |
31966 | var p1 = msg.slice(0, 2) | |
31967 | var i = 2 | |
31968 | var status = 0 | |
31969 | while (msg[i++] !== 0) { | |
31970 | if (i >= msg.length) { | |
31971 | status++ | |
31972 | break | |
31973 | } | |
31974 | } | |
31975 | var ps = msg.slice(2, i - 1) | |
31976 | ||
31977 | if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) { | |
31978 | status++ | |
31979 | } | |
31980 | if (ps.length < 8) { | |
31981 | status++ | |
31982 | } | |
31983 | if (status) { | |
31984 | throw new Error('decryption error') | |
31985 | } | |
31986 | return msg.slice(i) | |
31987 | } | |
31988 | function compare (a, b) { | |
31989 | a = Buffer.from(a) | |
31990 | b = Buffer.from(b) | |
31991 | var dif = 0 | |
31992 | var len = a.length | |
31993 | if (a.length !== b.length) { | |
31994 | dif++ | |
31995 | len = Math.min(a.length, b.length) | |
31996 | } | |
31997 | var i = -1 | |
31998 | while (++i < len) { | |
31999 | dif += (a[i] ^ b[i]) | |
32000 | } | |
32001 | return dif | |
32002 | } | |
32003 | ||
32004 | },{"./mgf":376,"./withPublic":379,"./xor":380,"bn.js":18,"browserify-rsa":41,"create-hash":68,"parse-asn1":366,"safe-buffer":398}],378:[function(require,module,exports){ | |
32005 | var parseKeys = require('parse-asn1') | |
32006 | var randomBytes = require('randombytes') | |
32007 | var createHash = require('create-hash') | |
32008 | var mgf = require('./mgf') | |
32009 | var xor = require('./xor') | |
32010 | var BN = require('bn.js') | |
32011 | var withPublic = require('./withPublic') | |
32012 | var crt = require('browserify-rsa') | |
32013 | var Buffer = require('safe-buffer').Buffer | |
32014 | ||
32015 | module.exports = function publicEncrypt (publicKey, msg, reverse) { | |
32016 | var padding | |
32017 | if (publicKey.padding) { | |
32018 | padding = publicKey.padding | |
32019 | } else if (reverse) { | |
32020 | padding = 1 | |
32021 | } else { | |
32022 | padding = 4 | |
32023 | } | |
32024 | var key = parseKeys(publicKey) | |
32025 | var paddedMsg | |
32026 | if (padding === 4) { | |
32027 | paddedMsg = oaep(key, msg) | |
32028 | } else if (padding === 1) { | |
32029 | paddedMsg = pkcs1(key, msg, reverse) | |
32030 | } else if (padding === 3) { | |
32031 | paddedMsg = new BN(msg) | |
32032 | if (paddedMsg.cmp(key.modulus) >= 0) { | |
32033 | throw new Error('data too long for modulus') | |
32034 | } | |
32035 | } else { | |
32036 | throw new Error('unknown padding') | |
32037 | } | |
32038 | if (reverse) { | |
32039 | return crt(paddedMsg, key) | |
32040 | } else { | |
32041 | return withPublic(paddedMsg, key) | |
32042 | } | |
32043 | } | |
32044 | ||
32045 | function oaep (key, msg) { | |
32046 | var k = key.modulus.byteLength() | |
32047 | var mLen = msg.length | |
32048 | var iHash = createHash('sha1').update(Buffer.alloc(0)).digest() | |
32049 | var hLen = iHash.length | |
32050 | var hLen2 = 2 * hLen | |
32051 | if (mLen > k - hLen2 - 2) { | |
32052 | throw new Error('message too long') | |
32053 | } | |
32054 | var ps = Buffer.alloc(k - mLen - hLen2 - 2) | |
32055 | var dblen = k - hLen - 1 | |
32056 | var seed = randomBytes(hLen) | |
32057 | var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen)) | |
32058 | var maskedSeed = xor(seed, mgf(maskedDb, hLen)) | |
32059 | return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k)) | |
32060 | } | |
32061 | function pkcs1 (key, msg, reverse) { | |
32062 | var mLen = msg.length | |
32063 | var k = key.modulus.byteLength() | |
32064 | if (mLen > k - 11) { | |
32065 | throw new Error('message too long') | |
32066 | } | |
32067 | var ps | |
32068 | if (reverse) { | |
32069 | ps = Buffer.alloc(k - mLen - 3, 0xff) | |
32070 | } else { | |
32071 | ps = nonZero(k - mLen - 3) | |
32072 | } | |
32073 | return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k)) | |
32074 | } | |
32075 | function nonZero (len) { | |
32076 | var out = Buffer.allocUnsafe(len) | |
32077 | var i = 0 | |
32078 | var cache = randomBytes(len * 2) | |
32079 | var cur = 0 | |
32080 | var num | |
32081 | while (i < len) { | |
32082 | if (cur === cache.length) { | |
32083 | cache = randomBytes(len * 2) | |
32084 | cur = 0 | |
32085 | } | |
32086 | num = cache[cur++] | |
32087 | if (num) { | |
32088 | out[i++] = num | |
32089 | } | |
32090 | } | |
32091 | return out | |
32092 | } | |
32093 | ||
32094 | },{"./mgf":376,"./withPublic":379,"./xor":380,"bn.js":18,"browserify-rsa":41,"create-hash":68,"parse-asn1":366,"randombytes":381,"safe-buffer":398}],379:[function(require,module,exports){ | |
32095 | var BN = require('bn.js') | |
32096 | var Buffer = require('safe-buffer').Buffer | |
32097 | ||
32098 | function withPublic (paddedMsg, key) { | |
32099 | return Buffer.from(paddedMsg | |
32100 | .toRed(BN.mont(key.modulus)) | |
32101 | .redPow(new BN(key.publicExponent)) | |
32102 | .fromRed() | |
32103 | .toArray()) | |
32104 | } | |
32105 | ||
32106 | module.exports = withPublic | |
32107 | ||
32108 | },{"bn.js":18,"safe-buffer":398}],380:[function(require,module,exports){ | |
32109 | module.exports = function xor (a, b) { | |
32110 | var len = a.length | |
32111 | var i = -1 | |
32112 | while (++i < len) { | |
32113 | a[i] ^= b[i] | |
32114 | } | |
32115 | return a | |
32116 | } | |
32117 | ||
32118 | },{}],381:[function(require,module,exports){ | |
32119 | (function (process,global){ | |
32120 | 'use strict' | |
32121 | ||
32122 | function oldBrowser () { | |
32123 | throw new Error('Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11') | |
32124 | } | |
32125 | ||
32126 | var Buffer = require('safe-buffer').Buffer | |
32127 | var crypto = global.crypto || global.msCrypto | |
32128 | ||
32129 | if (crypto && crypto.getRandomValues) { | |
32130 | module.exports = randomBytes | |
32131 | } else { | |
32132 | module.exports = oldBrowser | |
32133 | } | |
32134 | ||
32135 | function randomBytes (size, cb) { | |
32136 | // phantomjs needs to throw | |
32137 | if (size > 65536) throw new Error('requested too many random bytes') | |
32138 | // in case browserify isn't using the Uint8Array version | |
32139 | var rawBytes = new global.Uint8Array(size) | |
32140 | ||
32141 | // This will not work in older browsers. | |
32142 | // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues | |
32143 | if (size > 0) { // getRandomValues fails on IE if size == 0 | |
32144 | crypto.getRandomValues(rawBytes) | |
32145 | } | |
32146 | ||
32147 | // XXX: phantomjs doesn't like a buffer being passed here | |
32148 | var bytes = Buffer.from(rawBytes.buffer) | |
32149 | ||
32150 | if (typeof cb === 'function') { | |
32151 | return process.nextTick(function () { | |
32152 | cb(null, bytes) | |
32153 | }) | |
32154 | } | |
32155 | ||
32156 | return bytes | |
32157 | } | |
32158 | ||
32159 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
32160 | },{"_process":374,"safe-buffer":398}],382:[function(require,module,exports){ | |
32161 | (function (process,global){ | |
32162 | 'use strict' | |
32163 | ||
32164 | function oldBrowser () { | |
32165 | throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11') | |
32166 | } | |
32167 | var safeBuffer = require('safe-buffer') | |
32168 | var randombytes = require('randombytes') | |
32169 | var Buffer = safeBuffer.Buffer | |
32170 | var kBufferMaxLength = safeBuffer.kMaxLength | |
32171 | var crypto = global.crypto || global.msCrypto | |
32172 | var kMaxUint32 = Math.pow(2, 32) - 1 | |
32173 | function assertOffset (offset, length) { | |
32174 | if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare | |
32175 | throw new TypeError('offset must be a number') | |
32176 | } | |
32177 | ||
32178 | if (offset > kMaxUint32 || offset < 0) { | |
32179 | throw new TypeError('offset must be a uint32') | |
32180 | } | |
32181 | ||
32182 | if (offset > kBufferMaxLength || offset > length) { | |
32183 | throw new RangeError('offset out of range') | |
32184 | } | |
32185 | } | |
32186 | ||
32187 | function assertSize (size, offset, length) { | |
32188 | if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare | |
32189 | throw new TypeError('size must be a number') | |
32190 | } | |
32191 | ||
32192 | if (size > kMaxUint32 || size < 0) { | |
32193 | throw new TypeError('size must be a uint32') | |
32194 | } | |
32195 | ||
32196 | if (size + offset > length || size > kBufferMaxLength) { | |
32197 | throw new RangeError('buffer too small') | |
32198 | } | |
32199 | } | |
32200 | if ((crypto && crypto.getRandomValues) || !process.browser) { | |
32201 | exports.randomFill = randomFill | |
32202 | exports.randomFillSync = randomFillSync | |
32203 | } else { | |
32204 | exports.randomFill = oldBrowser | |
32205 | exports.randomFillSync = oldBrowser | |
32206 | } | |
32207 | function randomFill (buf, offset, size, cb) { | |
32208 | if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) { | |
32209 | throw new TypeError('"buf" argument must be a Buffer or Uint8Array') | |
32210 | } | |
32211 | ||
32212 | if (typeof offset === 'function') { | |
32213 | cb = offset | |
32214 | offset = 0 | |
32215 | size = buf.length | |
32216 | } else if (typeof size === 'function') { | |
32217 | cb = size | |
32218 | size = buf.length - offset | |
32219 | } else if (typeof cb !== 'function') { | |
32220 | throw new TypeError('"cb" argument must be a function') | |
32221 | } | |
32222 | assertOffset(offset, buf.length) | |
32223 | assertSize(size, offset, buf.length) | |
32224 | return actualFill(buf, offset, size, cb) | |
32225 | } | |
32226 | ||
32227 | function actualFill (buf, offset, size, cb) { | |
32228 | if (process.browser) { | |
32229 | var ourBuf = buf.buffer | |
32230 | var uint = new Uint8Array(ourBuf, offset, size) | |
32231 | crypto.getRandomValues(uint) | |
32232 | if (cb) { | |
32233 | process.nextTick(function () { | |
32234 | cb(null, buf) | |
32235 | }) | |
32236 | return | |
32237 | } | |
32238 | return buf | |
32239 | } | |
32240 | if (cb) { | |
32241 | randombytes(size, function (err, bytes) { | |
32242 | if (err) { | |
32243 | return cb(err) | |
32244 | } | |
32245 | bytes.copy(buf, offset) | |
32246 | cb(null, buf) | |
32247 | }) | |
32248 | return | |
32249 | } | |
32250 | var bytes = randombytes(size) | |
32251 | bytes.copy(buf, offset) | |
32252 | return buf | |
32253 | } | |
32254 | function randomFillSync (buf, offset, size) { | |
32255 | if (typeof offset === 'undefined') { | |
32256 | offset = 0 | |
32257 | } | |
32258 | if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) { | |
32259 | throw new TypeError('"buf" argument must be a Buffer or Uint8Array') | |
32260 | } | |
32261 | ||
32262 | assertOffset(offset, buf.length) | |
32263 | ||
32264 | if (size === undefined) size = buf.length - offset | |
32265 | ||
32266 | assertSize(size, offset, buf.length) | |
32267 | ||
32268 | return actualFill(buf, offset, size) | |
32269 | } | |
32270 | ||
32271 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
32272 | },{"_process":374,"randombytes":381,"safe-buffer":398}],383:[function(require,module,exports){ | |
32273 | module.exports = require('./lib/_stream_duplex.js'); | |
32274 | ||
32275 | },{"./lib/_stream_duplex.js":384}],384:[function(require,module,exports){ | |
32276 | // Copyright Joyent, Inc. and other Node contributors. | |
32277 | // | |
32278 | // Permission is hereby granted, free of charge, to any person obtaining a | |
32279 | // copy of this software and associated documentation files (the | |
32280 | // "Software"), to deal in the Software without restriction, including | |
32281 | // without limitation the rights to use, copy, modify, merge, publish, | |
32282 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
32283 | // persons to whom the Software is furnished to do so, subject to the | |
32284 | // following conditions: | |
32285 | // | |
32286 | // The above copyright notice and this permission notice shall be included | |
32287 | // in all copies or substantial portions of the Software. | |
32288 | // | |
32289 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
32290 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
32291 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
32292 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
32293 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
32294 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
32295 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
32296 | ||
32297 | // a duplex stream is just a stream that is both readable and writable. | |
32298 | // Since JS doesn't have multiple prototypal inheritance, this class | |
32299 | // prototypally inherits from Readable, and then parasitically from | |
32300 | // Writable. | |
32301 | ||
32302 | 'use strict'; | |
32303 | ||
32304 | /*<replacement>*/ | |
32305 | ||
32306 | var pna = require('process-nextick-args'); | |
32307 | /*</replacement>*/ | |
32308 | ||
32309 | /*<replacement>*/ | |
32310 | var objectKeys = Object.keys || function (obj) { | |
32311 | var keys = []; | |
32312 | for (var key in obj) { | |
32313 | keys.push(key); | |
32314 | }return keys; | |
32315 | }; | |
32316 | /*</replacement>*/ | |
32317 | ||
32318 | module.exports = Duplex; | |
32319 | ||
32320 | /*<replacement>*/ | |
32321 | var util = require('core-util-is'); | |
32322 | util.inherits = require('inherits'); | |
32323 | /*</replacement>*/ | |
32324 | ||
32325 | var Readable = require('./_stream_readable'); | |
32326 | var Writable = require('./_stream_writable'); | |
32327 | ||
32328 | util.inherits(Duplex, Readable); | |
32329 | ||
32330 | { | |
32331 | // avoid scope creep, the keys array can then be collected | |
32332 | var keys = objectKeys(Writable.prototype); | |
32333 | for (var v = 0; v < keys.length; v++) { | |
32334 | var method = keys[v]; | |
32335 | if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; | |
32336 | } | |
32337 | } | |
32338 | ||
32339 | function Duplex(options) { | |
32340 | if (!(this instanceof Duplex)) return new Duplex(options); | |
32341 | ||
32342 | Readable.call(this, options); | |
32343 | Writable.call(this, options); | |
32344 | ||
32345 | if (options && options.readable === false) this.readable = false; | |
32346 | ||
32347 | if (options && options.writable === false) this.writable = false; | |
32348 | ||
32349 | this.allowHalfOpen = true; | |
32350 | if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; | |
32351 | ||
32352 | this.once('end', onend); | |
32353 | } | |
32354 | ||
32355 | Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { | |
32356 | // making it explicit this property is not enumerable | |
32357 | // because otherwise some prototype manipulation in | |
32358 | // userland will fail | |
32359 | enumerable: false, | |
32360 | get: function () { | |
32361 | return this._writableState.highWaterMark; | |
32362 | } | |
32363 | }); | |
32364 | ||
32365 | // the no-half-open enforcer | |
32366 | function onend() { | |
32367 | // if we allow half-open state, or if the writable side ended, | |
32368 | // then we're ok. | |
32369 | if (this.allowHalfOpen || this._writableState.ended) return; | |
32370 | ||
32371 | // no more data can be written. | |
32372 | // But allow more writes to happen in this tick. | |
32373 | pna.nextTick(onEndNT, this); | |
32374 | } | |
32375 | ||
32376 | function onEndNT(self) { | |
32377 | self.end(); | |
32378 | } | |
32379 | ||
32380 | Object.defineProperty(Duplex.prototype, 'destroyed', { | |
32381 | get: function () { | |
32382 | if (this._readableState === undefined || this._writableState === undefined) { | |
32383 | return false; | |
32384 | } | |
32385 | return this._readableState.destroyed && this._writableState.destroyed; | |
32386 | }, | |
32387 | set: function (value) { | |
32388 | // we ignore the value if the stream | |
32389 | // has not been initialized yet | |
32390 | if (this._readableState === undefined || this._writableState === undefined) { | |
32391 | return; | |
32392 | } | |
32393 | ||
32394 | // backward compatibility, the user is explicitly | |
32395 | // managing destroyed | |
32396 | this._readableState.destroyed = value; | |
32397 | this._writableState.destroyed = value; | |
32398 | } | |
32399 | }); | |
32400 | ||
32401 | Duplex.prototype._destroy = function (err, cb) { | |
32402 | this.push(null); | |
32403 | this.end(); | |
32404 | ||
32405 | pna.nextTick(cb, err); | |
32406 | }; | |
32407 | },{"./_stream_readable":386,"./_stream_writable":388,"core-util-is":52,"inherits":119,"process-nextick-args":373}],385:[function(require,module,exports){ | |
32408 | // Copyright Joyent, Inc. and other Node contributors. | |
32409 | // | |
32410 | // Permission is hereby granted, free of charge, to any person obtaining a | |
32411 | // copy of this software and associated documentation files (the | |
32412 | // "Software"), to deal in the Software without restriction, including | |
32413 | // without limitation the rights to use, copy, modify, merge, publish, | |
32414 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
32415 | // persons to whom the Software is furnished to do so, subject to the | |
32416 | // following conditions: | |
32417 | // | |
32418 | // The above copyright notice and this permission notice shall be included | |
32419 | // in all copies or substantial portions of the Software. | |
32420 | // | |
32421 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
32422 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
32423 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
32424 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
32425 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
32426 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
32427 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
32428 | ||
32429 | // a passthrough stream. | |
32430 | // basically just the most minimal sort of Transform stream. | |
32431 | // Every written chunk gets output as-is. | |
32432 | ||
32433 | 'use strict'; | |
32434 | ||
32435 | module.exports = PassThrough; | |
32436 | ||
32437 | var Transform = require('./_stream_transform'); | |
32438 | ||
32439 | /*<replacement>*/ | |
32440 | var util = require('core-util-is'); | |
32441 | util.inherits = require('inherits'); | |
32442 | /*</replacement>*/ | |
32443 | ||
32444 | util.inherits(PassThrough, Transform); | |
32445 | ||
32446 | function PassThrough(options) { | |
32447 | if (!(this instanceof PassThrough)) return new PassThrough(options); | |
32448 | ||
32449 | Transform.call(this, options); | |
32450 | } | |
32451 | ||
32452 | PassThrough.prototype._transform = function (chunk, encoding, cb) { | |
32453 | cb(null, chunk); | |
32454 | }; | |
32455 | },{"./_stream_transform":387,"core-util-is":52,"inherits":119}],386:[function(require,module,exports){ | |
32456 | (function (process,global){ | |
32457 | // Copyright Joyent, Inc. and other Node contributors. | |
32458 | // | |
32459 | // Permission is hereby granted, free of charge, to any person obtaining a | |
32460 | // copy of this software and associated documentation files (the | |
32461 | // "Software"), to deal in the Software without restriction, including | |
32462 | // without limitation the rights to use, copy, modify, merge, publish, | |
32463 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
32464 | // persons to whom the Software is furnished to do so, subject to the | |
32465 | // following conditions: | |
32466 | // | |
32467 | // The above copyright notice and this permission notice shall be included | |
32468 | // in all copies or substantial portions of the Software. | |
32469 | // | |
32470 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
32471 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
32472 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
32473 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
32474 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
32475 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
32476 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
32477 | ||
32478 | 'use strict'; | |
32479 | ||
32480 | /*<replacement>*/ | |
32481 | ||
32482 | var pna = require('process-nextick-args'); | |
32483 | /*</replacement>*/ | |
32484 | ||
32485 | module.exports = Readable; | |
32486 | ||
32487 | /*<replacement>*/ | |
32488 | var isArray = require('isarray'); | |
32489 | /*</replacement>*/ | |
32490 | ||
32491 | /*<replacement>*/ | |
32492 | var Duplex; | |
32493 | /*</replacement>*/ | |
32494 | ||
32495 | Readable.ReadableState = ReadableState; | |
32496 | ||
32497 | /*<replacement>*/ | |
32498 | var EE = require('events').EventEmitter; | |
32499 | ||
32500 | var EElistenerCount = function (emitter, type) { | |
32501 | return emitter.listeners(type).length; | |
32502 | }; | |
32503 | /*</replacement>*/ | |
32504 | ||
32505 | /*<replacement>*/ | |
32506 | var Stream = require('./internal/streams/stream'); | |
32507 | /*</replacement>*/ | |
32508 | ||
32509 | /*<replacement>*/ | |
32510 | ||
32511 | var Buffer = require('safe-buffer').Buffer; | |
32512 | var OurUint8Array = global.Uint8Array || function () {}; | |
32513 | function _uint8ArrayToBuffer(chunk) { | |
32514 | return Buffer.from(chunk); | |
32515 | } | |
32516 | function _isUint8Array(obj) { | |
32517 | return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; | |
32518 | } | |
32519 | ||
32520 | /*</replacement>*/ | |
32521 | ||
32522 | /*<replacement>*/ | |
32523 | var util = require('core-util-is'); | |
32524 | util.inherits = require('inherits'); | |
32525 | /*</replacement>*/ | |
32526 | ||
32527 | /*<replacement>*/ | |
32528 | var debugUtil = require('util'); | |
32529 | var debug = void 0; | |
32530 | if (debugUtil && debugUtil.debuglog) { | |
32531 | debug = debugUtil.debuglog('stream'); | |
32532 | } else { | |
32533 | debug = function () {}; | |
32534 | } | |
32535 | /*</replacement>*/ | |
32536 | ||
32537 | var BufferList = require('./internal/streams/BufferList'); | |
32538 | var destroyImpl = require('./internal/streams/destroy'); | |
32539 | var StringDecoder; | |
32540 | ||
32541 | util.inherits(Readable, Stream); | |
32542 | ||
32543 | var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; | |
32544 | ||
32545 | function prependListener(emitter, event, fn) { | |
32546 | // Sadly this is not cacheable as some libraries bundle their own | |
32547 | // event emitter implementation with them. | |
32548 | if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); | |
32549 | ||
32550 | // This is a hack to make sure that our error handler is attached before any | |
32551 | // userland ones. NEVER DO THIS. This is here only because this code needs | |
32552 | // to continue to work with older versions of Node.js that do not include | |
32553 | // the prependListener() method. The goal is to eventually remove this hack. | |
32554 | 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]]; | |
32555 | } | |
32556 | ||
32557 | function ReadableState(options, stream) { | |
32558 | Duplex = Duplex || require('./_stream_duplex'); | |
32559 | ||
32560 | options = options || {}; | |
32561 | ||
32562 | // Duplex streams are both readable and writable, but share | |
32563 | // the same options object. | |
32564 | // However, some cases require setting options to different | |
32565 | // values for the readable and the writable sides of the duplex stream. | |
32566 | // These options can be provided separately as readableXXX and writableXXX. | |
32567 | var isDuplex = stream instanceof Duplex; | |
32568 | ||
32569 | // object stream flag. Used to make read(n) ignore n and to | |
32570 | // make all the buffer merging and length checks go away | |
32571 | this.objectMode = !!options.objectMode; | |
32572 | ||
32573 | if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; | |
32574 | ||
32575 | // the point at which it stops calling _read() to fill the buffer | |
32576 | // Note: 0 is a valid value, means "don't call _read preemptively ever" | |
32577 | var hwm = options.highWaterMark; | |
32578 | var readableHwm = options.readableHighWaterMark; | |
32579 | var defaultHwm = this.objectMode ? 16 : 16 * 1024; | |
32580 | ||
32581 | if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm; | |
32582 | ||
32583 | // cast to ints. | |
32584 | this.highWaterMark = Math.floor(this.highWaterMark); | |
32585 | ||
32586 | // A linked list is used to store data chunks instead of an array because the | |
32587 | // linked list can remove elements from the beginning faster than | |
32588 | // array.shift() | |
32589 | this.buffer = new BufferList(); | |
32590 | this.length = 0; | |
32591 | this.pipes = null; | |
32592 | this.pipesCount = 0; | |
32593 | this.flowing = null; | |
32594 | this.ended = false; | |
32595 | this.endEmitted = false; | |
32596 | this.reading = false; | |
32597 | ||
32598 | // a flag to be able to tell if the event 'readable'/'data' is emitted | |
32599 | // immediately, or on a later tick. We set this to true at first, because | |
32600 | // any actions that shouldn't happen until "later" should generally also | |
32601 | // not happen before the first read call. | |
32602 | this.sync = true; | |
32603 | ||
32604 | // whenever we return null, then we set a flag to say | |
32605 | // that we're awaiting a 'readable' event emission. | |
32606 | this.needReadable = false; | |
32607 | this.emittedReadable = false; | |
32608 | this.readableListening = false; | |
32609 | this.resumeScheduled = false; | |
32610 | ||
32611 | // has it been destroyed | |
32612 | this.destroyed = false; | |
32613 | ||
32614 | // Crypto is kind of old and crusty. Historically, its default string | |
32615 | // encoding is 'binary' so we have to make this configurable. | |
32616 | // Everything else in the universe uses 'utf8', though. | |
32617 | this.defaultEncoding = options.defaultEncoding || 'utf8'; | |
32618 | ||
32619 | // the number of writers that are awaiting a drain event in .pipe()s | |
32620 | this.awaitDrain = 0; | |
32621 | ||
32622 | // if true, a maybeReadMore has been scheduled | |
32623 | this.readingMore = false; | |
32624 | ||
32625 | this.decoder = null; | |
32626 | this.encoding = null; | |
32627 | if (options.encoding) { | |
32628 | if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; | |
32629 | this.decoder = new StringDecoder(options.encoding); | |
32630 | this.encoding = options.encoding; | |
32631 | } | |
32632 | } | |
32633 | ||
32634 | function Readable(options) { | |
32635 | Duplex = Duplex || require('./_stream_duplex'); | |
32636 | ||
32637 | if (!(this instanceof Readable)) return new Readable(options); | |
32638 | ||
32639 | this._readableState = new ReadableState(options, this); | |
32640 | ||
32641 | // legacy | |
32642 | this.readable = true; | |
32643 | ||
32644 | if (options) { | |
32645 | if (typeof options.read === 'function') this._read = options.read; | |
32646 | ||
32647 | if (typeof options.destroy === 'function') this._destroy = options.destroy; | |
32648 | } | |
32649 | ||
32650 | Stream.call(this); | |
32651 | } | |
32652 | ||
32653 | Object.defineProperty(Readable.prototype, 'destroyed', { | |
32654 | get: function () { | |
32655 | if (this._readableState === undefined) { | |
32656 | return false; | |
32657 | } | |
32658 | return this._readableState.destroyed; | |
32659 | }, | |
32660 | set: function (value) { | |
32661 | // we ignore the value if the stream | |
32662 | // has not been initialized yet | |
32663 | if (!this._readableState) { | |
32664 | return; | |
32665 | } | |
32666 | ||
32667 | // backward compatibility, the user is explicitly | |
32668 | // managing destroyed | |
32669 | this._readableState.destroyed = value; | |
32670 | } | |
32671 | }); | |
32672 | ||
32673 | Readable.prototype.destroy = destroyImpl.destroy; | |
32674 | Readable.prototype._undestroy = destroyImpl.undestroy; | |
32675 | Readable.prototype._destroy = function (err, cb) { | |
32676 | this.push(null); | |
32677 | cb(err); | |
32678 | }; | |
32679 | ||
32680 | // Manually shove something into the read() buffer. | |
32681 | // This returns true if the highWaterMark has not been hit yet, | |
32682 | // similar to how Writable.write() returns true if you should | |
32683 | // write() some more. | |
32684 | Readable.prototype.push = function (chunk, encoding) { | |
32685 | var state = this._readableState; | |
32686 | var skipChunkCheck; | |
32687 | ||
32688 | if (!state.objectMode) { | |
32689 | if (typeof chunk === 'string') { | |
32690 | encoding = encoding || state.defaultEncoding; | |
32691 | if (encoding !== state.encoding) { | |
32692 | chunk = Buffer.from(chunk, encoding); | |
32693 | encoding = ''; | |
32694 | } | |
32695 | skipChunkCheck = true; | |
32696 | } | |
32697 | } else { | |
32698 | skipChunkCheck = true; | |
32699 | } | |
32700 | ||
32701 | return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); | |
32702 | }; | |
32703 | ||
32704 | // Unshift should *always* be something directly out of read() | |
32705 | Readable.prototype.unshift = function (chunk) { | |
32706 | return readableAddChunk(this, chunk, null, true, false); | |
32707 | }; | |
32708 | ||
32709 | function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { | |
32710 | var state = stream._readableState; | |
32711 | if (chunk === null) { | |
32712 | state.reading = false; | |
32713 | onEofChunk(stream, state); | |
32714 | } else { | |
32715 | var er; | |
32716 | if (!skipChunkCheck) er = chunkInvalid(state, chunk); | |
32717 | if (er) { | |
32718 | stream.emit('error', er); | |
32719 | } else if (state.objectMode || chunk && chunk.length > 0) { | |
32720 | if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { | |
32721 | chunk = _uint8ArrayToBuffer(chunk); | |
32722 | } | |
32723 | ||
32724 | if (addToFront) { | |
32725 | if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); | |
32726 | } else if (state.ended) { | |
32727 | stream.emit('error', new Error('stream.push() after EOF')); | |
32728 | } else { | |
32729 | state.reading = false; | |
32730 | if (state.decoder && !encoding) { | |
32731 | chunk = state.decoder.write(chunk); | |
32732 | if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); | |
32733 | } else { | |
32734 | addChunk(stream, state, chunk, false); | |
32735 | } | |
32736 | } | |
32737 | } else if (!addToFront) { | |
32738 | state.reading = false; | |
32739 | } | |
32740 | } | |
32741 | ||
32742 | return needMoreData(state); | |
32743 | } | |
32744 | ||
32745 | function addChunk(stream, state, chunk, addToFront) { | |
32746 | if (state.flowing && state.length === 0 && !state.sync) { | |
32747 | stream.emit('data', chunk); | |
32748 | stream.read(0); | |
32749 | } else { | |
32750 | // update the buffer info. | |
32751 | state.length += state.objectMode ? 1 : chunk.length; | |
32752 | if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); | |
32753 | ||
32754 | if (state.needReadable) emitReadable(stream); | |
32755 | } | |
32756 | maybeReadMore(stream, state); | |
32757 | } | |
32758 | ||
32759 | function chunkInvalid(state, chunk) { | |
32760 | var er; | |
32761 | if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { | |
32762 | er = new TypeError('Invalid non-string/buffer chunk'); | |
32763 | } | |
32764 | return er; | |
32765 | } | |
32766 | ||
32767 | // if it's past the high water mark, we can push in some more. | |
32768 | // Also, if we have no data yet, we can stand some | |
32769 | // more bytes. This is to work around cases where hwm=0, | |
32770 | // such as the repl. Also, if the push() triggered a | |
32771 | // readable event, and the user called read(largeNumber) such that | |
32772 | // needReadable was set, then we ought to push more, so that another | |
32773 | // 'readable' event will be triggered. | |
32774 | function needMoreData(state) { | |
32775 | return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); | |
32776 | } | |
32777 | ||
32778 | Readable.prototype.isPaused = function () { | |
32779 | return this._readableState.flowing === false; | |
32780 | }; | |
32781 | ||
32782 | // backwards compatibility. | |
32783 | Readable.prototype.setEncoding = function (enc) { | |
32784 | if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; | |
32785 | this._readableState.decoder = new StringDecoder(enc); | |
32786 | this._readableState.encoding = enc; | |
32787 | return this; | |
32788 | }; | |
32789 | ||
32790 | // Don't raise the hwm > 8MB | |
32791 | var MAX_HWM = 0x800000; | |
32792 | function computeNewHighWaterMark(n) { | |
32793 | if (n >= MAX_HWM) { | |
32794 | n = MAX_HWM; | |
32795 | } else { | |
32796 | // Get the next highest power of 2 to prevent increasing hwm excessively in | |
32797 | // tiny amounts | |
32798 | n--; | |
32799 | n |= n >>> 1; | |
32800 | n |= n >>> 2; | |
32801 | n |= n >>> 4; | |
32802 | n |= n >>> 8; | |
32803 | n |= n >>> 16; | |
32804 | n++; | |
32805 | } | |
32806 | return n; | |
32807 | } | |
32808 | ||
32809 | // This function is designed to be inlinable, so please take care when making | |
32810 | // changes to the function body. | |
32811 | function howMuchToRead(n, state) { | |
32812 | if (n <= 0 || state.length === 0 && state.ended) return 0; | |
32813 | if (state.objectMode) return 1; | |
32814 | if (n !== n) { | |
32815 | // Only flow one buffer at a time | |
32816 | if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; | |
32817 | } | |
32818 | // If we're asking for more than the current hwm, then raise the hwm. | |
32819 | if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); | |
32820 | if (n <= state.length) return n; | |
32821 | // Don't have enough | |
32822 | if (!state.ended) { | |
32823 | state.needReadable = true; | |
32824 | return 0; | |
32825 | } | |
32826 | return state.length; | |
32827 | } | |
32828 | ||
32829 | // you can override either this method, or the async _read(n) below. | |
32830 | Readable.prototype.read = function (n) { | |
32831 | debug('read', n); | |
32832 | n = parseInt(n, 10); | |
32833 | var state = this._readableState; | |
32834 | var nOrig = n; | |
32835 | ||
32836 | if (n !== 0) state.emittedReadable = false; | |
32837 | ||
32838 | // if we're doing read(0) to trigger a readable event, but we | |
32839 | // already have a bunch of data in the buffer, then just trigger | |
32840 | // the 'readable' event and move on. | |
32841 | if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { | |
32842 | debug('read: emitReadable', state.length, state.ended); | |
32843 | if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); | |
32844 | return null; | |
32845 | } | |
32846 | ||
32847 | n = howMuchToRead(n, state); | |
32848 | ||
32849 | // if we've ended, and we're now clear, then finish it up. | |
32850 | if (n === 0 && state.ended) { | |
32851 | if (state.length === 0) endReadable(this); | |
32852 | return null; | |
32853 | } | |
32854 | ||
32855 | // All the actual chunk generation logic needs to be | |
32856 | // *below* the call to _read. The reason is that in certain | |
32857 | // synthetic stream cases, such as passthrough streams, _read | |
32858 | // may be a completely synchronous operation which may change | |
32859 | // the state of the read buffer, providing enough data when | |
32860 | // before there was *not* enough. | |
32861 | // | |
32862 | // So, the steps are: | |
32863 | // 1. Figure out what the state of things will be after we do | |
32864 | // a read from the buffer. | |
32865 | // | |
32866 | // 2. If that resulting state will trigger a _read, then call _read. | |
32867 | // Note that this may be asynchronous, or synchronous. Yes, it is | |
32868 | // deeply ugly to write APIs this way, but that still doesn't mean | |
32869 | // that the Readable class should behave improperly, as streams are | |
32870 | // designed to be sync/async agnostic. | |
32871 | // Take note if the _read call is sync or async (ie, if the read call | |
32872 | // has returned yet), so that we know whether or not it's safe to emit | |
32873 | // 'readable' etc. | |
32874 | // | |
32875 | // 3. Actually pull the requested chunks out of the buffer and return. | |
32876 | ||
32877 | // if we need a readable event, then we need to do some reading. | |
32878 | var doRead = state.needReadable; | |
32879 | debug('need readable', doRead); | |
32880 | ||
32881 | // if we currently have less than the highWaterMark, then also read some | |
32882 | if (state.length === 0 || state.length - n < state.highWaterMark) { | |
32883 | doRead = true; | |
32884 | debug('length less than watermark', doRead); | |
32885 | } | |
32886 | ||
32887 | // however, if we've ended, then there's no point, and if we're already | |
32888 | // reading, then it's unnecessary. | |
32889 | if (state.ended || state.reading) { | |
32890 | doRead = false; | |
32891 | debug('reading or ended', doRead); | |
32892 | } else if (doRead) { | |
32893 | debug('do read'); | |
32894 | state.reading = true; | |
32895 | state.sync = true; | |
32896 | // if the length is currently zero, then we *need* a readable event. | |
32897 | if (state.length === 0) state.needReadable = true; | |
32898 | // call internal read method | |
32899 | this._read(state.highWaterMark); | |
32900 | state.sync = false; | |
32901 | // If _read pushed data synchronously, then `reading` will be false, | |
32902 | // and we need to re-evaluate how much data we can return to the user. | |
32903 | if (!state.reading) n = howMuchToRead(nOrig, state); | |
32904 | } | |
32905 | ||
32906 | var ret; | |
32907 | if (n > 0) ret = fromList(n, state);else ret = null; | |
32908 | ||
32909 | if (ret === null) { | |
32910 | state.needReadable = true; | |
32911 | n = 0; | |
32912 | } else { | |
32913 | state.length -= n; | |
32914 | } | |
32915 | ||
32916 | if (state.length === 0) { | |
32917 | // If we have nothing in the buffer, then we want to know | |
32918 | // as soon as we *do* get something into the buffer. | |
32919 | if (!state.ended) state.needReadable = true; | |
32920 | ||
32921 | // If we tried to read() past the EOF, then emit end on the next tick. | |
32922 | if (nOrig !== n && state.ended) endReadable(this); | |
32923 | } | |
32924 | ||
32925 | if (ret !== null) this.emit('data', ret); | |
32926 | ||
32927 | return ret; | |
32928 | }; | |
32929 | ||
32930 | function onEofChunk(stream, state) { | |
32931 | if (state.ended) return; | |
32932 | if (state.decoder) { | |
32933 | var chunk = state.decoder.end(); | |
32934 | if (chunk && chunk.length) { | |
32935 | state.buffer.push(chunk); | |
32936 | state.length += state.objectMode ? 1 : chunk.length; | |
32937 | } | |
32938 | } | |
32939 | state.ended = true; | |
32940 | ||
32941 | // emit 'readable' now to make sure it gets picked up. | |
32942 | emitReadable(stream); | |
32943 | } | |
32944 | ||
32945 | // Don't emit readable right away in sync mode, because this can trigger | |
32946 | // another read() call => stack overflow. This way, it might trigger | |
32947 | // a nextTick recursion warning, but that's not so bad. | |
32948 | function emitReadable(stream) { | |
32949 | var state = stream._readableState; | |
32950 | state.needReadable = false; | |
32951 | if (!state.emittedReadable) { | |
32952 | debug('emitReadable', state.flowing); | |
32953 | state.emittedReadable = true; | |
32954 | if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream); | |
32955 | } | |
32956 | } | |
32957 | ||
32958 | function emitReadable_(stream) { | |
32959 | debug('emit readable'); | |
32960 | stream.emit('readable'); | |
32961 | flow(stream); | |
32962 | } | |
32963 | ||
32964 | // at this point, the user has presumably seen the 'readable' event, | |
32965 | // and called read() to consume some data. that may have triggered | |
32966 | // in turn another _read(n) call, in which case reading = true if | |
32967 | // it's in progress. | |
32968 | // However, if we're not ended, or reading, and the length < hwm, | |
32969 | // then go ahead and try to read some more preemptively. | |
32970 | function maybeReadMore(stream, state) { | |
32971 | if (!state.readingMore) { | |
32972 | state.readingMore = true; | |
32973 | pna.nextTick(maybeReadMore_, stream, state); | |
32974 | } | |
32975 | } | |
32976 | ||
32977 | function maybeReadMore_(stream, state) { | |
32978 | var len = state.length; | |
32979 | while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { | |
32980 | debug('maybeReadMore read 0'); | |
32981 | stream.read(0); | |
32982 | if (len === state.length) | |
32983 | // didn't get any data, stop spinning. | |
32984 | break;else len = state.length; | |
32985 | } | |
32986 | state.readingMore = false; | |
32987 | } | |
32988 | ||
32989 | // abstract method. to be overridden in specific implementation classes. | |
32990 | // call cb(er, data) where data is <= n in length. | |
32991 | // for virtual (non-string, non-buffer) streams, "length" is somewhat | |
32992 | // arbitrary, and perhaps not very meaningful. | |
32993 | Readable.prototype._read = function (n) { | |
32994 | this.emit('error', new Error('_read() is not implemented')); | |
32995 | }; | |
32996 | ||
32997 | Readable.prototype.pipe = function (dest, pipeOpts) { | |
32998 | var src = this; | |
32999 | var state = this._readableState; | |
33000 | ||
33001 | switch (state.pipesCount) { | |
33002 | case 0: | |
33003 | state.pipes = dest; | |
33004 | break; | |
33005 | case 1: | |
33006 | state.pipes = [state.pipes, dest]; | |
33007 | break; | |
33008 | default: | |
33009 | state.pipes.push(dest); | |
33010 | break; | |
33011 | } | |
33012 | state.pipesCount += 1; | |
33013 | debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); | |
33014 | ||
33015 | var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; | |
33016 | ||
33017 | var endFn = doEnd ? onend : unpipe; | |
33018 | if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn); | |
33019 | ||
33020 | dest.on('unpipe', onunpipe); | |
33021 | function onunpipe(readable, unpipeInfo) { | |
33022 | debug('onunpipe'); | |
33023 | if (readable === src) { | |
33024 | if (unpipeInfo && unpipeInfo.hasUnpiped === false) { | |
33025 | unpipeInfo.hasUnpiped = true; | |
33026 | cleanup(); | |
33027 | } | |
33028 | } | |
33029 | } | |
33030 | ||
33031 | function onend() { | |
33032 | debug('onend'); | |
33033 | dest.end(); | |
33034 | } | |
33035 | ||
33036 | // when the dest drains, it reduces the awaitDrain counter | |
33037 | // on the source. This would be more elegant with a .once() | |
33038 | // handler in flow(), but adding and removing repeatedly is | |
33039 | // too slow. | |
33040 | var ondrain = pipeOnDrain(src); | |
33041 | dest.on('drain', ondrain); | |
33042 | ||
33043 | var cleanedUp = false; | |
33044 | function cleanup() { | |
33045 | debug('cleanup'); | |
33046 | // cleanup event handlers once the pipe is broken | |
33047 | dest.removeListener('close', onclose); | |
33048 | dest.removeListener('finish', onfinish); | |
33049 | dest.removeListener('drain', ondrain); | |
33050 | dest.removeListener('error', onerror); | |
33051 | dest.removeListener('unpipe', onunpipe); | |
33052 | src.removeListener('end', onend); | |
33053 | src.removeListener('end', unpipe); | |
33054 | src.removeListener('data', ondata); | |
33055 | ||
33056 | cleanedUp = true; | |
33057 | ||
33058 | // if the reader is waiting for a drain event from this | |
33059 | // specific writer, then it would cause it to never start | |
33060 | // flowing again. | |
33061 | // So, if this is awaiting a drain, then we just call it now. | |
33062 | // If we don't know, then assume that we are waiting for one. | |
33063 | if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); | |
33064 | } | |
33065 | ||
33066 | // If the user pushes more data while we're writing to dest then we'll end up | |
33067 | // in ondata again. However, we only want to increase awaitDrain once because | |
33068 | // dest will only emit one 'drain' event for the multiple writes. | |
33069 | // => Introduce a guard on increasing awaitDrain. | |
33070 | var increasedAwaitDrain = false; | |
33071 | src.on('data', ondata); | |
33072 | function ondata(chunk) { | |
33073 | debug('ondata'); | |
33074 | increasedAwaitDrain = false; | |
33075 | var ret = dest.write(chunk); | |
33076 | if (false === ret && !increasedAwaitDrain) { | |
33077 | // If the user unpiped during `dest.write()`, it is possible | |
33078 | // to get stuck in a permanently paused state if that write | |
33079 | // also returned false. | |
33080 | // => Check whether `dest` is still a piping destination. | |
33081 | if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { | |
33082 | debug('false write response, pause', src._readableState.awaitDrain); | |
33083 | src._readableState.awaitDrain++; | |
33084 | increasedAwaitDrain = true; | |
33085 | } | |
33086 | src.pause(); | |
33087 | } | |
33088 | } | |
33089 | ||
33090 | // if the dest has an error, then stop piping into it. | |
33091 | // however, don't suppress the throwing behavior for this. | |
33092 | function onerror(er) { | |
33093 | debug('onerror', er); | |
33094 | unpipe(); | |
33095 | dest.removeListener('error', onerror); | |
33096 | if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); | |
33097 | } | |
33098 | ||
33099 | // Make sure our error handler is attached before userland ones. | |
33100 | prependListener(dest, 'error', onerror); | |
33101 | ||
33102 | // Both close and finish should trigger unpipe, but only once. | |
33103 | function onclose() { | |
33104 | dest.removeListener('finish', onfinish); | |
33105 | unpipe(); | |
33106 | } | |
33107 | dest.once('close', onclose); | |
33108 | function onfinish() { | |
33109 | debug('onfinish'); | |
33110 | dest.removeListener('close', onclose); | |
33111 | unpipe(); | |
33112 | } | |
33113 | dest.once('finish', onfinish); | |
33114 | ||
33115 | function unpipe() { | |
33116 | debug('unpipe'); | |
33117 | src.unpipe(dest); | |
33118 | } | |
33119 | ||
33120 | // tell the dest that it's being piped to | |
33121 | dest.emit('pipe', src); | |
33122 | ||
33123 | // start the flow if it hasn't been started already. | |
33124 | if (!state.flowing) { | |
33125 | debug('pipe resume'); | |
33126 | src.resume(); | |
33127 | } | |
33128 | ||
33129 | return dest; | |
33130 | }; | |
33131 | ||
33132 | function pipeOnDrain(src) { | |
33133 | return function () { | |
33134 | var state = src._readableState; | |
33135 | debug('pipeOnDrain', state.awaitDrain); | |
33136 | if (state.awaitDrain) state.awaitDrain--; | |
33137 | if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { | |
33138 | state.flowing = true; | |
33139 | flow(src); | |
33140 | } | |
33141 | }; | |
33142 | } | |
33143 | ||
33144 | Readable.prototype.unpipe = function (dest) { | |
33145 | var state = this._readableState; | |
33146 | var unpipeInfo = { hasUnpiped: false }; | |
33147 | ||
33148 | // if we're not piping anywhere, then do nothing. | |
33149 | if (state.pipesCount === 0) return this; | |
33150 | ||
33151 | // just one destination. most common case. | |
33152 | if (state.pipesCount === 1) { | |
33153 | // passed in one, but it's not the right one. | |
33154 | if (dest && dest !== state.pipes) return this; | |
33155 | ||
33156 | if (!dest) dest = state.pipes; | |
33157 | ||
33158 | // got a match. | |
33159 | state.pipes = null; | |
33160 | state.pipesCount = 0; | |
33161 | state.flowing = false; | |
33162 | if (dest) dest.emit('unpipe', this, unpipeInfo); | |
33163 | return this; | |
33164 | } | |
33165 | ||
33166 | // slow case. multiple pipe destinations. | |
33167 | ||
33168 | if (!dest) { | |
33169 | // remove all. | |
33170 | var dests = state.pipes; | |
33171 | var len = state.pipesCount; | |
33172 | state.pipes = null; | |
33173 | state.pipesCount = 0; | |
33174 | state.flowing = false; | |
33175 | ||
33176 | for (var i = 0; i < len; i++) { | |
33177 | dests[i].emit('unpipe', this, unpipeInfo); | |
33178 | }return this; | |
33179 | } | |
33180 | ||
33181 | // try to find the right one. | |
33182 | var index = indexOf(state.pipes, dest); | |
33183 | if (index === -1) return this; | |
33184 | ||
33185 | state.pipes.splice(index, 1); | |
33186 | state.pipesCount -= 1; | |
33187 | if (state.pipesCount === 1) state.pipes = state.pipes[0]; | |
33188 | ||
33189 | dest.emit('unpipe', this, unpipeInfo); | |
33190 | ||
33191 | return this; | |
33192 | }; | |
33193 | ||
33194 | // set up data events if they are asked for | |
33195 | // Ensure readable listeners eventually get something | |
33196 | Readable.prototype.on = function (ev, fn) { | |
33197 | var res = Stream.prototype.on.call(this, ev, fn); | |
33198 | ||
33199 | if (ev === 'data') { | |
33200 | // Start flowing on next tick if stream isn't explicitly paused | |
33201 | if (this._readableState.flowing !== false) this.resume(); | |
33202 | } else if (ev === 'readable') { | |
33203 | var state = this._readableState; | |
33204 | if (!state.endEmitted && !state.readableListening) { | |
33205 | state.readableListening = state.needReadable = true; | |
33206 | state.emittedReadable = false; | |
33207 | if (!state.reading) { | |
33208 | pna.nextTick(nReadingNextTick, this); | |
33209 | } else if (state.length) { | |
33210 | emitReadable(this); | |
33211 | } | |
33212 | } | |
33213 | } | |
33214 | ||
33215 | return res; | |
33216 | }; | |
33217 | Readable.prototype.addListener = Readable.prototype.on; | |
33218 | ||
33219 | function nReadingNextTick(self) { | |
33220 | debug('readable nexttick read 0'); | |
33221 | self.read(0); | |
33222 | } | |
33223 | ||
33224 | // pause() and resume() are remnants of the legacy readable stream API | |
33225 | // If the user uses them, then switch into old mode. | |
33226 | Readable.prototype.resume = function () { | |
33227 | var state = this._readableState; | |
33228 | if (!state.flowing) { | |
33229 | debug('resume'); | |
33230 | state.flowing = true; | |
33231 | resume(this, state); | |
33232 | } | |
33233 | return this; | |
33234 | }; | |
33235 | ||
33236 | function resume(stream, state) { | |
33237 | if (!state.resumeScheduled) { | |
33238 | state.resumeScheduled = true; | |
33239 | pna.nextTick(resume_, stream, state); | |
33240 | } | |
33241 | } | |
33242 | ||
33243 | function resume_(stream, state) { | |
33244 | if (!state.reading) { | |
33245 | debug('resume read 0'); | |
33246 | stream.read(0); | |
33247 | } | |
33248 | ||
33249 | state.resumeScheduled = false; | |
33250 | state.awaitDrain = 0; | |
33251 | stream.emit('resume'); | |
33252 | flow(stream); | |
33253 | if (state.flowing && !state.reading) stream.read(0); | |
33254 | } | |
33255 | ||
33256 | Readable.prototype.pause = function () { | |
33257 | debug('call pause flowing=%j', this._readableState.flowing); | |
33258 | if (false !== this._readableState.flowing) { | |
33259 | debug('pause'); | |
33260 | this._readableState.flowing = false; | |
33261 | this.emit('pause'); | |
33262 | } | |
33263 | return this; | |
33264 | }; | |
33265 | ||
33266 | function flow(stream) { | |
33267 | var state = stream._readableState; | |
33268 | debug('flow', state.flowing); | |
33269 | while (state.flowing && stream.read() !== null) {} | |
33270 | } | |
33271 | ||
33272 | // wrap an old-style stream as the async data source. | |
33273 | // This is *not* part of the readable stream interface. | |
33274 | // It is an ugly unfortunate mess of history. | |
33275 | Readable.prototype.wrap = function (stream) { | |
33276 | var _this = this; | |
33277 | ||
33278 | var state = this._readableState; | |
33279 | var paused = false; | |
33280 | ||
33281 | stream.on('end', function () { | |
33282 | debug('wrapped end'); | |
33283 | if (state.decoder && !state.ended) { | |
33284 | var chunk = state.decoder.end(); | |
33285 | if (chunk && chunk.length) _this.push(chunk); | |
33286 | } | |
33287 | ||
33288 | _this.push(null); | |
33289 | }); | |
33290 | ||
33291 | stream.on('data', function (chunk) { | |
33292 | debug('wrapped data'); | |
33293 | if (state.decoder) chunk = state.decoder.write(chunk); | |
33294 | ||
33295 | // don't skip over falsy values in objectMode | |
33296 | if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; | |
33297 | ||
33298 | var ret = _this.push(chunk); | |
33299 | if (!ret) { | |
33300 | paused = true; | |
33301 | stream.pause(); | |
33302 | } | |
33303 | }); | |
33304 | ||
33305 | // proxy all the other methods. | |
33306 | // important when wrapping filters and duplexes. | |
33307 | for (var i in stream) { | |
33308 | if (this[i] === undefined && typeof stream[i] === 'function') { | |
33309 | this[i] = function (method) { | |
33310 | return function () { | |
33311 | return stream[method].apply(stream, arguments); | |
33312 | }; | |
33313 | }(i); | |
33314 | } | |
33315 | } | |
33316 | ||
33317 | // proxy certain important events. | |
33318 | for (var n = 0; n < kProxyEvents.length; n++) { | |
33319 | stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); | |
33320 | } | |
33321 | ||
33322 | // when we try to consume some more bytes, simply unpause the | |
33323 | // underlying stream. | |
33324 | this._read = function (n) { | |
33325 | debug('wrapped _read', n); | |
33326 | if (paused) { | |
33327 | paused = false; | |
33328 | stream.resume(); | |
33329 | } | |
33330 | }; | |
33331 | ||
33332 | return this; | |
33333 | }; | |
33334 | ||
33335 | Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { | |
33336 | // making it explicit this property is not enumerable | |
33337 | // because otherwise some prototype manipulation in | |
33338 | // userland will fail | |
33339 | enumerable: false, | |
33340 | get: function () { | |
33341 | return this._readableState.highWaterMark; | |
33342 | } | |
33343 | }); | |
33344 | ||
33345 | // exposed for testing purposes only. | |
33346 | Readable._fromList = fromList; | |
33347 | ||
33348 | // Pluck off n bytes from an array of buffers. | |
33349 | // Length is the combined lengths of all the buffers in the list. | |
33350 | // This function is designed to be inlinable, so please take care when making | |
33351 | // changes to the function body. | |
33352 | function fromList(n, state) { | |
33353 | // nothing buffered | |
33354 | if (state.length === 0) return null; | |
33355 | ||
33356 | var ret; | |
33357 | if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { | |
33358 | // read it all, truncate the list | |
33359 | 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); | |
33360 | state.buffer.clear(); | |
33361 | } else { | |
33362 | // read part of list | |
33363 | ret = fromListPartial(n, state.buffer, state.decoder); | |
33364 | } | |
33365 | ||
33366 | return ret; | |
33367 | } | |
33368 | ||
33369 | // Extracts only enough buffered data to satisfy the amount requested. | |
33370 | // This function is designed to be inlinable, so please take care when making | |
33371 | // changes to the function body. | |
33372 | function fromListPartial(n, list, hasStrings) { | |
33373 | var ret; | |
33374 | if (n < list.head.data.length) { | |
33375 | // slice is the same for buffers and strings | |
33376 | ret = list.head.data.slice(0, n); | |
33377 | list.head.data = list.head.data.slice(n); | |
33378 | } else if (n === list.head.data.length) { | |
33379 | // first chunk is a perfect match | |
33380 | ret = list.shift(); | |
33381 | } else { | |
33382 | // result spans more than one buffer | |
33383 | ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); | |
33384 | } | |
33385 | return ret; | |
33386 | } | |
33387 | ||
33388 | // Copies a specified amount of characters from the list of buffered data | |
33389 | // chunks. | |
33390 | // This function is designed to be inlinable, so please take care when making | |
33391 | // changes to the function body. | |
33392 | function copyFromBufferString(n, list) { | |
33393 | var p = list.head; | |
33394 | var c = 1; | |
33395 | var ret = p.data; | |
33396 | n -= ret.length; | |
33397 | while (p = p.next) { | |
33398 | var str = p.data; | |
33399 | var nb = n > str.length ? str.length : n; | |
33400 | if (nb === str.length) ret += str;else ret += str.slice(0, n); | |
33401 | n -= nb; | |
33402 | if (n === 0) { | |
33403 | if (nb === str.length) { | |
33404 | ++c; | |
33405 | if (p.next) list.head = p.next;else list.head = list.tail = null; | |
33406 | } else { | |
33407 | list.head = p; | |
33408 | p.data = str.slice(nb); | |
33409 | } | |
33410 | break; | |
33411 | } | |
33412 | ++c; | |
33413 | } | |
33414 | list.length -= c; | |
33415 | return ret; | |
33416 | } | |
33417 | ||
33418 | // Copies a specified amount of bytes from the list of buffered data chunks. | |
33419 | // This function is designed to be inlinable, so please take care when making | |
33420 | // changes to the function body. | |
33421 | function copyFromBuffer(n, list) { | |
33422 | var ret = Buffer.allocUnsafe(n); | |
33423 | var p = list.head; | |
33424 | var c = 1; | |
33425 | p.data.copy(ret); | |
33426 | n -= p.data.length; | |
33427 | while (p = p.next) { | |
33428 | var buf = p.data; | |
33429 | var nb = n > buf.length ? buf.length : n; | |
33430 | buf.copy(ret, ret.length - n, 0, nb); | |
33431 | n -= nb; | |
33432 | if (n === 0) { | |
33433 | if (nb === buf.length) { | |
33434 | ++c; | |
33435 | if (p.next) list.head = p.next;else list.head = list.tail = null; | |
33436 | } else { | |
33437 | list.head = p; | |
33438 | p.data = buf.slice(nb); | |
33439 | } | |
33440 | break; | |
33441 | } | |
33442 | ++c; | |
33443 | } | |
33444 | list.length -= c; | |
33445 | return ret; | |
33446 | } | |
33447 | ||
33448 | function endReadable(stream) { | |
33449 | var state = stream._readableState; | |
33450 | ||
33451 | // If we get here before consuming all the bytes, then that is a | |
33452 | // bug in node. Should never happen. | |
33453 | if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); | |
33454 | ||
33455 | if (!state.endEmitted) { | |
33456 | state.ended = true; | |
33457 | pna.nextTick(endReadableNT, state, stream); | |
33458 | } | |
33459 | } | |
33460 | ||
33461 | function endReadableNT(state, stream) { | |
33462 | // Check that we didn't get one last unshift. | |
33463 | if (!state.endEmitted && state.length === 0) { | |
33464 | state.endEmitted = true; | |
33465 | stream.readable = false; | |
33466 | stream.emit('end'); | |
33467 | } | |
33468 | } | |
33469 | ||
33470 | function indexOf(xs, x) { | |
33471 | for (var i = 0, l = xs.length; i < l; i++) { | |
33472 | if (xs[i] === x) return i; | |
33473 | } | |
33474 | return -1; | |
33475 | } | |
33476 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
33477 | },{"./_stream_duplex":384,"./internal/streams/BufferList":389,"./internal/streams/destroy":390,"./internal/streams/stream":391,"_process":374,"core-util-is":52,"events":102,"inherits":119,"isarray":121,"process-nextick-args":373,"safe-buffer":398,"string_decoder/":392,"util":20}],387:[function(require,module,exports){ | |
33478 | // Copyright Joyent, Inc. and other Node contributors. | |
33479 | // | |
33480 | // Permission is hereby granted, free of charge, to any person obtaining a | |
33481 | // copy of this software and associated documentation files (the | |
33482 | // "Software"), to deal in the Software without restriction, including | |
33483 | // without limitation the rights to use, copy, modify, merge, publish, | |
33484 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
33485 | // persons to whom the Software is furnished to do so, subject to the | |
33486 | // following conditions: | |
33487 | // | |
33488 | // The above copyright notice and this permission notice shall be included | |
33489 | // in all copies or substantial portions of the Software. | |
33490 | // | |
33491 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
33492 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
33493 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
33494 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
33495 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
33496 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
33497 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
33498 | ||
33499 | // a transform stream is a readable/writable stream where you do | |
33500 | // something with the data. Sometimes it's called a "filter", | |
33501 | // but that's not a great name for it, since that implies a thing where | |
33502 | // some bits pass through, and others are simply ignored. (That would | |
33503 | // be a valid example of a transform, of course.) | |
33504 | // | |
33505 | // While the output is causally related to the input, it's not a | |
33506 | // necessarily symmetric or synchronous transformation. For example, | |
33507 | // a zlib stream might take multiple plain-text writes(), and then | |
33508 | // emit a single compressed chunk some time in the future. | |
33509 | // | |
33510 | // Here's how this works: | |
33511 | // | |
33512 | // The Transform stream has all the aspects of the readable and writable | |
33513 | // stream classes. When you write(chunk), that calls _write(chunk,cb) | |
33514 | // internally, and returns false if there's a lot of pending writes | |
33515 | // buffered up. When you call read(), that calls _read(n) until | |
33516 | // there's enough pending readable data buffered up. | |
33517 | // | |
33518 | // In a transform stream, the written data is placed in a buffer. When | |
33519 | // _read(n) is called, it transforms the queued up data, calling the | |
33520 | // buffered _write cb's as it consumes chunks. If consuming a single | |
33521 | // written chunk would result in multiple output chunks, then the first | |
33522 | // outputted bit calls the readcb, and subsequent chunks just go into | |
33523 | // the read buffer, and will cause it to emit 'readable' if necessary. | |
33524 | // | |
33525 | // This way, back-pressure is actually determined by the reading side, | |
33526 | // since _read has to be called to start processing a new chunk. However, | |
33527 | // a pathological inflate type of transform can cause excessive buffering | |
33528 | // here. For example, imagine a stream where every byte of input is | |
33529 | // interpreted as an integer from 0-255, and then results in that many | |
33530 | // bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in | |
33531 | // 1kb of data being output. In this case, you could write a very small | |
33532 | // amount of input, and end up with a very large amount of output. In | |
33533 | // such a pathological inflating mechanism, there'd be no way to tell | |
33534 | // the system to stop doing the transform. A single 4MB write could | |
33535 | // cause the system to run out of memory. | |
33536 | // | |
33537 | // However, even in such a pathological case, only a single written chunk | |
33538 | // would be consumed, and then the rest would wait (un-transformed) until | |
33539 | // the results of the previous transformed chunk were consumed. | |
33540 | ||
33541 | 'use strict'; | |
33542 | ||
33543 | module.exports = Transform; | |
33544 | ||
33545 | var Duplex = require('./_stream_duplex'); | |
33546 | ||
33547 | /*<replacement>*/ | |
33548 | var util = require('core-util-is'); | |
33549 | util.inherits = require('inherits'); | |
33550 | /*</replacement>*/ | |
33551 | ||
33552 | util.inherits(Transform, Duplex); | |
33553 | ||
33554 | function afterTransform(er, data) { | |
33555 | var ts = this._transformState; | |
33556 | ts.transforming = false; | |
33557 | ||
33558 | var cb = ts.writecb; | |
33559 | ||
33560 | if (!cb) { | |
33561 | return this.emit('error', new Error('write callback called multiple times')); | |
33562 | } | |
33563 | ||
33564 | ts.writechunk = null; | |
33565 | ts.writecb = null; | |
33566 | ||
33567 | if (data != null) // single equals check for both `null` and `undefined` | |
33568 | this.push(data); | |
33569 | ||
33570 | cb(er); | |
33571 | ||
33572 | var rs = this._readableState; | |
33573 | rs.reading = false; | |
33574 | if (rs.needReadable || rs.length < rs.highWaterMark) { | |
33575 | this._read(rs.highWaterMark); | |
33576 | } | |
33577 | } | |
33578 | ||
33579 | function Transform(options) { | |
33580 | if (!(this instanceof Transform)) return new Transform(options); | |
33581 | ||
33582 | Duplex.call(this, options); | |
33583 | ||
33584 | this._transformState = { | |
33585 | afterTransform: afterTransform.bind(this), | |
33586 | needTransform: false, | |
33587 | transforming: false, | |
33588 | writecb: null, | |
33589 | writechunk: null, | |
33590 | writeencoding: null | |
33591 | }; | |
33592 | ||
33593 | // start out asking for a readable event once data is transformed. | |
33594 | this._readableState.needReadable = true; | |
33595 | ||
33596 | // we have implemented the _read method, and done the other things | |
33597 | // that Readable wants before the first _read call, so unset the | |
33598 | // sync guard flag. | |
33599 | this._readableState.sync = false; | |
33600 | ||
33601 | if (options) { | |
33602 | if (typeof options.transform === 'function') this._transform = options.transform; | |
33603 | ||
33604 | if (typeof options.flush === 'function') this._flush = options.flush; | |
33605 | } | |
33606 | ||
33607 | // When the writable side finishes, then flush out anything remaining. | |
33608 | this.on('prefinish', prefinish); | |
33609 | } | |
33610 | ||
33611 | function prefinish() { | |
33612 | var _this = this; | |
33613 | ||
33614 | if (typeof this._flush === 'function') { | |
33615 | this._flush(function (er, data) { | |
33616 | done(_this, er, data); | |
33617 | }); | |
33618 | } else { | |
33619 | done(this, null, null); | |
33620 | } | |
33621 | } | |
33622 | ||
33623 | Transform.prototype.push = function (chunk, encoding) { | |
33624 | this._transformState.needTransform = false; | |
33625 | return Duplex.prototype.push.call(this, chunk, encoding); | |
33626 | }; | |
33627 | ||
33628 | // This is the part where you do stuff! | |
33629 | // override this function in implementation classes. | |
33630 | // 'chunk' is an input chunk. | |
33631 | // | |
33632 | // Call `push(newChunk)` to pass along transformed output | |
33633 | // to the readable side. You may call 'push' zero or more times. | |
33634 | // | |
33635 | // Call `cb(err)` when you are done with this chunk. If you pass | |
33636 | // an error, then that'll put the hurt on the whole operation. If you | |
33637 | // never call cb(), then you'll never get another chunk. | |
33638 | Transform.prototype._transform = function (chunk, encoding, cb) { | |
33639 | throw new Error('_transform() is not implemented'); | |
33640 | }; | |
33641 | ||
33642 | Transform.prototype._write = function (chunk, encoding, cb) { | |
33643 | var ts = this._transformState; | |
33644 | ts.writecb = cb; | |
33645 | ts.writechunk = chunk; | |
33646 | ts.writeencoding = encoding; | |
33647 | if (!ts.transforming) { | |
33648 | var rs = this._readableState; | |
33649 | if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); | |
33650 | } | |
33651 | }; | |
33652 | ||
33653 | // Doesn't matter what the args are here. | |
33654 | // _transform does all the work. | |
33655 | // That we got here means that the readable side wants more data. | |
33656 | Transform.prototype._read = function (n) { | |
33657 | var ts = this._transformState; | |
33658 | ||
33659 | if (ts.writechunk !== null && ts.writecb && !ts.transforming) { | |
33660 | ts.transforming = true; | |
33661 | this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); | |
33662 | } else { | |
33663 | // mark that we need a transform, so that any data that comes in | |
33664 | // will get processed, now that we've asked for it. | |
33665 | ts.needTransform = true; | |
33666 | } | |
33667 | }; | |
33668 | ||
33669 | Transform.prototype._destroy = function (err, cb) { | |
33670 | var _this2 = this; | |
33671 | ||
33672 | Duplex.prototype._destroy.call(this, err, function (err2) { | |
33673 | cb(err2); | |
33674 | _this2.emit('close'); | |
33675 | }); | |
33676 | }; | |
33677 | ||
33678 | function done(stream, er, data) { | |
33679 | if (er) return stream.emit('error', er); | |
33680 | ||
33681 | if (data != null) // single equals check for both `null` and `undefined` | |
33682 | stream.push(data); | |
33683 | ||
33684 | // if there's nothing in the write buffer, then that means | |
33685 | // that nothing more will ever be provided | |
33686 | if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0'); | |
33687 | ||
33688 | if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming'); | |
33689 | ||
33690 | return stream.push(null); | |
33691 | } | |
33692 | },{"./_stream_duplex":384,"core-util-is":52,"inherits":119}],388:[function(require,module,exports){ | |
33693 | (function (process,global,setImmediate){ | |
33694 | // Copyright Joyent, Inc. and other Node contributors. | |
33695 | // | |
33696 | // Permission is hereby granted, free of charge, to any person obtaining a | |
33697 | // copy of this software and associated documentation files (the | |
33698 | // "Software"), to deal in the Software without restriction, including | |
33699 | // without limitation the rights to use, copy, modify, merge, publish, | |
33700 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
33701 | // persons to whom the Software is furnished to do so, subject to the | |
33702 | // following conditions: | |
33703 | // | |
33704 | // The above copyright notice and this permission notice shall be included | |
33705 | // in all copies or substantial portions of the Software. | |
33706 | // | |
33707 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
33708 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
33709 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
33710 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
33711 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
33712 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
33713 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
33714 | ||
33715 | // A bit simpler than readable streams. | |
33716 | // Implement an async ._write(chunk, encoding, cb), and it'll handle all | |
33717 | // the drain event emission and buffering. | |
33718 | ||
33719 | 'use strict'; | |
33720 | ||
33721 | /*<replacement>*/ | |
33722 | ||
33723 | var pna = require('process-nextick-args'); | |
33724 | /*</replacement>*/ | |
33725 | ||
33726 | module.exports = Writable; | |
33727 | ||
33728 | /* <replacement> */ | |
33729 | function WriteReq(chunk, encoding, cb) { | |
33730 | this.chunk = chunk; | |
33731 | this.encoding = encoding; | |
33732 | this.callback = cb; | |
33733 | this.next = null; | |
33734 | } | |
33735 | ||
33736 | // It seems a linked list but it is not | |
33737 | // there will be only 2 of these for each stream | |
33738 | function CorkedRequest(state) { | |
33739 | var _this = this; | |
33740 | ||
33741 | this.next = null; | |
33742 | this.entry = null; | |
33743 | this.finish = function () { | |
33744 | onCorkedFinish(_this, state); | |
33745 | }; | |
33746 | } | |
33747 | /* </replacement> */ | |
33748 | ||
33749 | /*<replacement>*/ | |
33750 | var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; | |
33751 | /*</replacement>*/ | |
33752 | ||
33753 | /*<replacement>*/ | |
33754 | var Duplex; | |
33755 | /*</replacement>*/ | |
33756 | ||
33757 | Writable.WritableState = WritableState; | |
33758 | ||
33759 | /*<replacement>*/ | |
33760 | var util = require('core-util-is'); | |
33761 | util.inherits = require('inherits'); | |
33762 | /*</replacement>*/ | |
33763 | ||
33764 | /*<replacement>*/ | |
33765 | var internalUtil = { | |
33766 | deprecate: require('util-deprecate') | |
33767 | }; | |
33768 | /*</replacement>*/ | |
33769 | ||
33770 | /*<replacement>*/ | |
33771 | var Stream = require('./internal/streams/stream'); | |
33772 | /*</replacement>*/ | |
33773 | ||
33774 | /*<replacement>*/ | |
33775 | ||
33776 | var Buffer = require('safe-buffer').Buffer; | |
33777 | var OurUint8Array = global.Uint8Array || function () {}; | |
33778 | function _uint8ArrayToBuffer(chunk) { | |
33779 | return Buffer.from(chunk); | |
33780 | } | |
33781 | function _isUint8Array(obj) { | |
33782 | return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; | |
33783 | } | |
33784 | ||
33785 | /*</replacement>*/ | |
33786 | ||
33787 | var destroyImpl = require('./internal/streams/destroy'); | |
33788 | ||
33789 | util.inherits(Writable, Stream); | |
33790 | ||
33791 | function nop() {} | |
33792 | ||
33793 | function WritableState(options, stream) { | |
33794 | Duplex = Duplex || require('./_stream_duplex'); | |
33795 | ||
33796 | options = options || {}; | |
33797 | ||
33798 | // Duplex streams are both readable and writable, but share | |
33799 | // the same options object. | |
33800 | // However, some cases require setting options to different | |
33801 | // values for the readable and the writable sides of the duplex stream. | |
33802 | // These options can be provided separately as readableXXX and writableXXX. | |
33803 | var isDuplex = stream instanceof Duplex; | |
33804 | ||
33805 | // object stream flag to indicate whether or not this stream | |
33806 | // contains buffers or objects. | |
33807 | this.objectMode = !!options.objectMode; | |
33808 | ||
33809 | if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; | |
33810 | ||
33811 | // the point at which write() starts returning false | |
33812 | // Note: 0 is a valid value, means that we always return false if | |
33813 | // the entire buffer is not flushed immediately on write() | |
33814 | var hwm = options.highWaterMark; | |
33815 | var writableHwm = options.writableHighWaterMark; | |
33816 | var defaultHwm = this.objectMode ? 16 : 16 * 1024; | |
33817 | ||
33818 | if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm; | |
33819 | ||
33820 | // cast to ints. | |
33821 | this.highWaterMark = Math.floor(this.highWaterMark); | |
33822 | ||
33823 | // if _final has been called | |
33824 | this.finalCalled = false; | |
33825 | ||
33826 | // drain event flag. | |
33827 | this.needDrain = false; | |
33828 | // at the start of calling end() | |
33829 | this.ending = false; | |
33830 | // when end() has been called, and returned | |
33831 | this.ended = false; | |
33832 | // when 'finish' is emitted | |
33833 | this.finished = false; | |
33834 | ||
33835 | // has it been destroyed | |
33836 | this.destroyed = false; | |
33837 | ||
33838 | // should we decode strings into buffers before passing to _write? | |
33839 | // this is here so that some node-core streams can optimize string | |
33840 | // handling at a lower level. | |
33841 | var noDecode = options.decodeStrings === false; | |
33842 | this.decodeStrings = !noDecode; | |
33843 | ||
33844 | // Crypto is kind of old and crusty. Historically, its default string | |
33845 | // encoding is 'binary' so we have to make this configurable. | |
33846 | // Everything else in the universe uses 'utf8', though. | |
33847 | this.defaultEncoding = options.defaultEncoding || 'utf8'; | |
33848 | ||
33849 | // not an actual buffer we keep track of, but a measurement | |
33850 | // of how much we're waiting to get pushed to some underlying | |
33851 | // socket or file. | |
33852 | this.length = 0; | |
33853 | ||
33854 | // a flag to see when we're in the middle of a write. | |
33855 | this.writing = false; | |
33856 | ||
33857 | // when true all writes will be buffered until .uncork() call | |
33858 | this.corked = 0; | |
33859 | ||
33860 | // a flag to be able to tell if the onwrite cb is called immediately, | |
33861 | // or on a later tick. We set this to true at first, because any | |
33862 | // actions that shouldn't happen until "later" should generally also | |
33863 | // not happen before the first write call. | |
33864 | this.sync = true; | |
33865 | ||
33866 | // a flag to know if we're processing previously buffered items, which | |
33867 | // may call the _write() callback in the same tick, so that we don't | |
33868 | // end up in an overlapped onwrite situation. | |
33869 | this.bufferProcessing = false; | |
33870 | ||
33871 | // the callback that's passed to _write(chunk,cb) | |
33872 | this.onwrite = function (er) { | |
33873 | onwrite(stream, er); | |
33874 | }; | |
33875 | ||
33876 | // the callback that the user supplies to write(chunk,encoding,cb) | |
33877 | this.writecb = null; | |
33878 | ||
33879 | // the amount that is being written when _write is called. | |
33880 | this.writelen = 0; | |
33881 | ||
33882 | this.bufferedRequest = null; | |
33883 | this.lastBufferedRequest = null; | |
33884 | ||
33885 | // number of pending user-supplied write callbacks | |
33886 | // this must be 0 before 'finish' can be emitted | |
33887 | this.pendingcb = 0; | |
33888 | ||
33889 | // emit prefinish if the only thing we're waiting for is _write cbs | |
33890 | // This is relevant for synchronous Transform streams | |
33891 | this.prefinished = false; | |
33892 | ||
33893 | // True if the error was already emitted and should not be thrown again | |
33894 | this.errorEmitted = false; | |
33895 | ||
33896 | // count buffered requests | |
33897 | this.bufferedRequestCount = 0; | |
33898 | ||
33899 | // allocate the first CorkedRequest, there is always | |
33900 | // one allocated and free to use, and we maintain at most two | |
33901 | this.corkedRequestsFree = new CorkedRequest(this); | |
33902 | } | |
33903 | ||
33904 | WritableState.prototype.getBuffer = function getBuffer() { | |
33905 | var current = this.bufferedRequest; | |
33906 | var out = []; | |
33907 | while (current) { | |
33908 | out.push(current); | |
33909 | current = current.next; | |
33910 | } | |
33911 | return out; | |
33912 | }; | |
33913 | ||
33914 | (function () { | |
33915 | try { | |
33916 | Object.defineProperty(WritableState.prototype, 'buffer', { | |
33917 | get: internalUtil.deprecate(function () { | |
33918 | return this.getBuffer(); | |
33919 | }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') | |
33920 | }); | |
33921 | } catch (_) {} | |
33922 | })(); | |
33923 | ||
33924 | // Test _writableState for inheritance to account for Duplex streams, | |
33925 | // whose prototype chain only points to Readable. | |
33926 | var realHasInstance; | |
33927 | if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { | |
33928 | realHasInstance = Function.prototype[Symbol.hasInstance]; | |
33929 | Object.defineProperty(Writable, Symbol.hasInstance, { | |
33930 | value: function (object) { | |
33931 | if (realHasInstance.call(this, object)) return true; | |
33932 | if (this !== Writable) return false; | |
33933 | ||
33934 | return object && object._writableState instanceof WritableState; | |
33935 | } | |
33936 | }); | |
33937 | } else { | |
33938 | realHasInstance = function (object) { | |
33939 | return object instanceof this; | |
33940 | }; | |
33941 | } | |
33942 | ||
33943 | function Writable(options) { | |
33944 | Duplex = Duplex || require('./_stream_duplex'); | |
33945 | ||
33946 | // Writable ctor is applied to Duplexes, too. | |
33947 | // `realHasInstance` is necessary because using plain `instanceof` | |
33948 | // would return false, as no `_writableState` property is attached. | |
33949 | ||
33950 | // Trying to use the custom `instanceof` for Writable here will also break the | |
33951 | // Node.js LazyTransform implementation, which has a non-trivial getter for | |
33952 | // `_writableState` that would lead to infinite recursion. | |
33953 | if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { | |
33954 | return new Writable(options); | |
33955 | } | |
33956 | ||
33957 | this._writableState = new WritableState(options, this); | |
33958 | ||
33959 | // legacy. | |
33960 | this.writable = true; | |
33961 | ||
33962 | if (options) { | |
33963 | if (typeof options.write === 'function') this._write = options.write; | |
33964 | ||
33965 | if (typeof options.writev === 'function') this._writev = options.writev; | |
33966 | ||
33967 | if (typeof options.destroy === 'function') this._destroy = options.destroy; | |
33968 | ||
33969 | if (typeof options.final === 'function') this._final = options.final; | |
33970 | } | |
33971 | ||
33972 | Stream.call(this); | |
33973 | } | |
33974 | ||
33975 | // Otherwise people can pipe Writable streams, which is just wrong. | |
33976 | Writable.prototype.pipe = function () { | |
33977 | this.emit('error', new Error('Cannot pipe, not readable')); | |
33978 | }; | |
33979 | ||
33980 | function writeAfterEnd(stream, cb) { | |
33981 | var er = new Error('write after end'); | |
33982 | // TODO: defer error events consistently everywhere, not just the cb | |
33983 | stream.emit('error', er); | |
33984 | pna.nextTick(cb, er); | |
33985 | } | |
33986 | ||
33987 | // Checks that a user-supplied chunk is valid, especially for the particular | |
33988 | // mode the stream is in. Currently this means that `null` is never accepted | |
33989 | // and undefined/non-string values are only allowed in object mode. | |
33990 | function validChunk(stream, state, chunk, cb) { | |
33991 | var valid = true; | |
33992 | var er = false; | |
33993 | ||
33994 | if (chunk === null) { | |
33995 | er = new TypeError('May not write null values to stream'); | |
33996 | } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { | |
33997 | er = new TypeError('Invalid non-string/buffer chunk'); | |
33998 | } | |
33999 | if (er) { | |
34000 | stream.emit('error', er); | |
34001 | pna.nextTick(cb, er); | |
34002 | valid = false; | |
34003 | } | |
34004 | return valid; | |
34005 | } | |
34006 | ||
34007 | Writable.prototype.write = function (chunk, encoding, cb) { | |
34008 | var state = this._writableState; | |
34009 | var ret = false; | |
34010 | var isBuf = !state.objectMode && _isUint8Array(chunk); | |
34011 | ||
34012 | if (isBuf && !Buffer.isBuffer(chunk)) { | |
34013 | chunk = _uint8ArrayToBuffer(chunk); | |
34014 | } | |
34015 | ||
34016 | if (typeof encoding === 'function') { | |
34017 | cb = encoding; | |
34018 | encoding = null; | |
34019 | } | |
34020 | ||
34021 | if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; | |
34022 | ||
34023 | if (typeof cb !== 'function') cb = nop; | |
34024 | ||
34025 | if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { | |
34026 | state.pendingcb++; | |
34027 | ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); | |
34028 | } | |
34029 | ||
34030 | return ret; | |
34031 | }; | |
34032 | ||
34033 | Writable.prototype.cork = function () { | |
34034 | var state = this._writableState; | |
34035 | ||
34036 | state.corked++; | |
34037 | }; | |
34038 | ||
34039 | Writable.prototype.uncork = function () { | |
34040 | var state = this._writableState; | |
34041 | ||
34042 | if (state.corked) { | |
34043 | state.corked--; | |
34044 | ||
34045 | if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); | |
34046 | } | |
34047 | }; | |
34048 | ||
34049 | Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { | |
34050 | // node::ParseEncoding() requires lower case. | |
34051 | if (typeof encoding === 'string') encoding = encoding.toLowerCase(); | |
34052 | 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); | |
34053 | this._writableState.defaultEncoding = encoding; | |
34054 | return this; | |
34055 | }; | |
34056 | ||
34057 | function decodeChunk(state, chunk, encoding) { | |
34058 | if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { | |
34059 | chunk = Buffer.from(chunk, encoding); | |
34060 | } | |
34061 | return chunk; | |
34062 | } | |
34063 | ||
34064 | Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { | |
34065 | // making it explicit this property is not enumerable | |
34066 | // because otherwise some prototype manipulation in | |
34067 | // userland will fail | |
34068 | enumerable: false, | |
34069 | get: function () { | |
34070 | return this._writableState.highWaterMark; | |
34071 | } | |
34072 | }); | |
34073 | ||
34074 | // if we're already writing something, then just put this | |
34075 | // in the queue, and wait our turn. Otherwise, call _write | |
34076 | // If we return false, then we need a drain event, so set that flag. | |
34077 | function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { | |
34078 | if (!isBuf) { | |
34079 | var newChunk = decodeChunk(state, chunk, encoding); | |
34080 | if (chunk !== newChunk) { | |
34081 | isBuf = true; | |
34082 | encoding = 'buffer'; | |
34083 | chunk = newChunk; | |
34084 | } | |
34085 | } | |
34086 | var len = state.objectMode ? 1 : chunk.length; | |
34087 | ||
34088 | state.length += len; | |
34089 | ||
34090 | var ret = state.length < state.highWaterMark; | |
34091 | // we must ensure that previous needDrain will not be reset to false. | |
34092 | if (!ret) state.needDrain = true; | |
34093 | ||
34094 | if (state.writing || state.corked) { | |
34095 | var last = state.lastBufferedRequest; | |
34096 | state.lastBufferedRequest = { | |
34097 | chunk: chunk, | |
34098 | encoding: encoding, | |
34099 | isBuf: isBuf, | |
34100 | callback: cb, | |
34101 | next: null | |
34102 | }; | |
34103 | if (last) { | |
34104 | last.next = state.lastBufferedRequest; | |
34105 | } else { | |
34106 | state.bufferedRequest = state.lastBufferedRequest; | |
34107 | } | |
34108 | state.bufferedRequestCount += 1; | |
34109 | } else { | |
34110 | doWrite(stream, state, false, len, chunk, encoding, cb); | |
34111 | } | |
34112 | ||
34113 | return ret; | |
34114 | } | |
34115 | ||
34116 | function doWrite(stream, state, writev, len, chunk, encoding, cb) { | |
34117 | state.writelen = len; | |
34118 | state.writecb = cb; | |
34119 | state.writing = true; | |
34120 | state.sync = true; | |
34121 | if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); | |
34122 | state.sync = false; | |
34123 | } | |
34124 | ||
34125 | function onwriteError(stream, state, sync, er, cb) { | |
34126 | --state.pendingcb; | |
34127 | ||
34128 | if (sync) { | |
34129 | // defer the callback if we are being called synchronously | |
34130 | // to avoid piling up things on the stack | |
34131 | pna.nextTick(cb, er); | |
34132 | // this can emit finish, and it will always happen | |
34133 | // after error | |
34134 | pna.nextTick(finishMaybe, stream, state); | |
34135 | stream._writableState.errorEmitted = true; | |
34136 | stream.emit('error', er); | |
34137 | } else { | |
34138 | // the caller expect this to happen before if | |
34139 | // it is async | |
34140 | cb(er); | |
34141 | stream._writableState.errorEmitted = true; | |
34142 | stream.emit('error', er); | |
34143 | // this can emit finish, but finish must | |
34144 | // always follow error | |
34145 | finishMaybe(stream, state); | |
34146 | } | |
34147 | } | |
34148 | ||
34149 | function onwriteStateUpdate(state) { | |
34150 | state.writing = false; | |
34151 | state.writecb = null; | |
34152 | state.length -= state.writelen; | |
34153 | state.writelen = 0; | |
34154 | } | |
34155 | ||
34156 | function onwrite(stream, er) { | |
34157 | var state = stream._writableState; | |
34158 | var sync = state.sync; | |
34159 | var cb = state.writecb; | |
34160 | ||
34161 | onwriteStateUpdate(state); | |
34162 | ||
34163 | if (er) onwriteError(stream, state, sync, er, cb);else { | |
34164 | // Check if we're actually ready to finish, but don't emit yet | |
34165 | var finished = needFinish(state); | |
34166 | ||
34167 | if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { | |
34168 | clearBuffer(stream, state); | |
34169 | } | |
34170 | ||
34171 | if (sync) { | |
34172 | /*<replacement>*/ | |
34173 | asyncWrite(afterWrite, stream, state, finished, cb); | |
34174 | /*</replacement>*/ | |
34175 | } else { | |
34176 | afterWrite(stream, state, finished, cb); | |
34177 | } | |
34178 | } | |
34179 | } | |
34180 | ||
34181 | function afterWrite(stream, state, finished, cb) { | |
34182 | if (!finished) onwriteDrain(stream, state); | |
34183 | state.pendingcb--; | |
34184 | cb(); | |
34185 | finishMaybe(stream, state); | |
34186 | } | |
34187 | ||
34188 | // Must force callback to be called on nextTick, so that we don't | |
34189 | // emit 'drain' before the write() consumer gets the 'false' return | |
34190 | // value, and has a chance to attach a 'drain' listener. | |
34191 | function onwriteDrain(stream, state) { | |
34192 | if (state.length === 0 && state.needDrain) { | |
34193 | state.needDrain = false; | |
34194 | stream.emit('drain'); | |
34195 | } | |
34196 | } | |
34197 | ||
34198 | // if there's something in the buffer waiting, then process it | |
34199 | function clearBuffer(stream, state) { | |
34200 | state.bufferProcessing = true; | |
34201 | var entry = state.bufferedRequest; | |
34202 | ||
34203 | if (stream._writev && entry && entry.next) { | |
34204 | // Fast case, write everything using _writev() | |
34205 | var l = state.bufferedRequestCount; | |
34206 | var buffer = new Array(l); | |
34207 | var holder = state.corkedRequestsFree; | |
34208 | holder.entry = entry; | |
34209 | ||
34210 | var count = 0; | |
34211 | var allBuffers = true; | |
34212 | while (entry) { | |
34213 | buffer[count] = entry; | |
34214 | if (!entry.isBuf) allBuffers = false; | |
34215 | entry = entry.next; | |
34216 | count += 1; | |
34217 | } | |
34218 | buffer.allBuffers = allBuffers; | |
34219 | ||
34220 | doWrite(stream, state, true, state.length, buffer, '', holder.finish); | |
34221 | ||
34222 | // doWrite is almost always async, defer these to save a bit of time | |
34223 | // as the hot path ends with doWrite | |
34224 | state.pendingcb++; | |
34225 | state.lastBufferedRequest = null; | |
34226 | if (holder.next) { | |
34227 | state.corkedRequestsFree = holder.next; | |
34228 | holder.next = null; | |
34229 | } else { | |
34230 | state.corkedRequestsFree = new CorkedRequest(state); | |
34231 | } | |
34232 | state.bufferedRequestCount = 0; | |
34233 | } else { | |
34234 | // Slow case, write chunks one-by-one | |
34235 | while (entry) { | |
34236 | var chunk = entry.chunk; | |
34237 | var encoding = entry.encoding; | |
34238 | var cb = entry.callback; | |
34239 | var len = state.objectMode ? 1 : chunk.length; | |
34240 | ||
34241 | doWrite(stream, state, false, len, chunk, encoding, cb); | |
34242 | entry = entry.next; | |
34243 | state.bufferedRequestCount--; | |
34244 | // if we didn't call the onwrite immediately, then | |
34245 | // it means that we need to wait until it does. | |
34246 | // also, that means that the chunk and cb are currently | |
34247 | // being processed, so move the buffer counter past them. | |
34248 | if (state.writing) { | |
34249 | break; | |
34250 | } | |
34251 | } | |
34252 | ||
34253 | if (entry === null) state.lastBufferedRequest = null; | |
34254 | } | |
34255 | ||
34256 | state.bufferedRequest = entry; | |
34257 | state.bufferProcessing = false; | |
34258 | } | |
34259 | ||
34260 | Writable.prototype._write = function (chunk, encoding, cb) { | |
34261 | cb(new Error('_write() is not implemented')); | |
34262 | }; | |
34263 | ||
34264 | Writable.prototype._writev = null; | |
34265 | ||
34266 | Writable.prototype.end = function (chunk, encoding, cb) { | |
34267 | var state = this._writableState; | |
34268 | ||
34269 | if (typeof chunk === 'function') { | |
34270 | cb = chunk; | |
34271 | chunk = null; | |
34272 | encoding = null; | |
34273 | } else if (typeof encoding === 'function') { | |
34274 | cb = encoding; | |
34275 | encoding = null; | |
34276 | } | |
34277 | ||
34278 | if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); | |
34279 | ||
34280 | // .end() fully uncorks | |
34281 | if (state.corked) { | |
34282 | state.corked = 1; | |
34283 | this.uncork(); | |
34284 | } | |
34285 | ||
34286 | // ignore unnecessary end() calls. | |
34287 | if (!state.ending && !state.finished) endWritable(this, state, cb); | |
34288 | }; | |
34289 | ||
34290 | function needFinish(state) { | |
34291 | return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; | |
34292 | } | |
34293 | function callFinal(stream, state) { | |
34294 | stream._final(function (err) { | |
34295 | state.pendingcb--; | |
34296 | if (err) { | |
34297 | stream.emit('error', err); | |
34298 | } | |
34299 | state.prefinished = true; | |
34300 | stream.emit('prefinish'); | |
34301 | finishMaybe(stream, state); | |
34302 | }); | |
34303 | } | |
34304 | function prefinish(stream, state) { | |
34305 | if (!state.prefinished && !state.finalCalled) { | |
34306 | if (typeof stream._final === 'function') { | |
34307 | state.pendingcb++; | |
34308 | state.finalCalled = true; | |
34309 | pna.nextTick(callFinal, stream, state); | |
34310 | } else { | |
34311 | state.prefinished = true; | |
34312 | stream.emit('prefinish'); | |
34313 | } | |
34314 | } | |
34315 | } | |
34316 | ||
34317 | function finishMaybe(stream, state) { | |
34318 | var need = needFinish(state); | |
34319 | if (need) { | |
34320 | prefinish(stream, state); | |
34321 | if (state.pendingcb === 0) { | |
34322 | state.finished = true; | |
34323 | stream.emit('finish'); | |
34324 | } | |
34325 | } | |
34326 | return need; | |
34327 | } | |
34328 | ||
34329 | function endWritable(stream, state, cb) { | |
34330 | state.ending = true; | |
34331 | finishMaybe(stream, state); | |
34332 | if (cb) { | |
34333 | if (state.finished) pna.nextTick(cb);else stream.once('finish', cb); | |
34334 | } | |
34335 | state.ended = true; | |
34336 | stream.writable = false; | |
34337 | } | |
34338 | ||
34339 | function onCorkedFinish(corkReq, state, err) { | |
34340 | var entry = corkReq.entry; | |
34341 | corkReq.entry = null; | |
34342 | while (entry) { | |
34343 | var cb = entry.callback; | |
34344 | state.pendingcb--; | |
34345 | cb(err); | |
34346 | entry = entry.next; | |
34347 | } | |
34348 | if (state.corkedRequestsFree) { | |
34349 | state.corkedRequestsFree.next = corkReq; | |
34350 | } else { | |
34351 | state.corkedRequestsFree = corkReq; | |
34352 | } | |
34353 | } | |
34354 | ||
34355 | Object.defineProperty(Writable.prototype, 'destroyed', { | |
34356 | get: function () { | |
34357 | if (this._writableState === undefined) { | |
34358 | return false; | |
34359 | } | |
34360 | return this._writableState.destroyed; | |
34361 | }, | |
34362 | set: function (value) { | |
34363 | // we ignore the value if the stream | |
34364 | // has not been initialized yet | |
34365 | if (!this._writableState) { | |
34366 | return; | |
34367 | } | |
34368 | ||
34369 | // backward compatibility, the user is explicitly | |
34370 | // managing destroyed | |
34371 | this._writableState.destroyed = value; | |
34372 | } | |
34373 | }); | |
34374 | ||
34375 | Writable.prototype.destroy = destroyImpl.destroy; | |
34376 | Writable.prototype._undestroy = destroyImpl.undestroy; | |
34377 | Writable.prototype._destroy = function (err, cb) { | |
34378 | this.end(); | |
34379 | cb(err); | |
34380 | }; | |
34381 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate) | |
34382 | },{"./_stream_duplex":384,"./internal/streams/destroy":390,"./internal/streams/stream":391,"_process":374,"core-util-is":52,"inherits":119,"process-nextick-args":373,"safe-buffer":398,"timers":439,"util-deprecate":441}],389:[function(require,module,exports){ | |
34383 | 'use strict'; | |
34384 | ||
34385 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
34386 | ||
34387 | var Buffer = require('safe-buffer').Buffer; | |
34388 | var util = require('util'); | |
34389 | ||
34390 | function copyBuffer(src, target, offset) { | |
34391 | src.copy(target, offset); | |
34392 | } | |
34393 | ||
34394 | module.exports = function () { | |
34395 | function BufferList() { | |
34396 | _classCallCheck(this, BufferList); | |
34397 | ||
34398 | this.head = null; | |
34399 | this.tail = null; | |
34400 | this.length = 0; | |
34401 | } | |
34402 | ||
34403 | BufferList.prototype.push = function push(v) { | |
34404 | var entry = { data: v, next: null }; | |
34405 | if (this.length > 0) this.tail.next = entry;else this.head = entry; | |
34406 | this.tail = entry; | |
34407 | ++this.length; | |
34408 | }; | |
34409 | ||
34410 | BufferList.prototype.unshift = function unshift(v) { | |
34411 | var entry = { data: v, next: this.head }; | |
34412 | if (this.length === 0) this.tail = entry; | |
34413 | this.head = entry; | |
34414 | ++this.length; | |
34415 | }; | |
34416 | ||
34417 | BufferList.prototype.shift = function shift() { | |
34418 | if (this.length === 0) return; | |
34419 | var ret = this.head.data; | |
34420 | if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; | |
34421 | --this.length; | |
34422 | return ret; | |
34423 | }; | |
34424 | ||
34425 | BufferList.prototype.clear = function clear() { | |
34426 | this.head = this.tail = null; | |
34427 | this.length = 0; | |
34428 | }; | |
34429 | ||
34430 | BufferList.prototype.join = function join(s) { | |
34431 | if (this.length === 0) return ''; | |
34432 | var p = this.head; | |
34433 | var ret = '' + p.data; | |
34434 | while (p = p.next) { | |
34435 | ret += s + p.data; | |
34436 | }return ret; | |
34437 | }; | |
34438 | ||
34439 | BufferList.prototype.concat = function concat(n) { | |
34440 | if (this.length === 0) return Buffer.alloc(0); | |
34441 | if (this.length === 1) return this.head.data; | |
34442 | var ret = Buffer.allocUnsafe(n >>> 0); | |
34443 | var p = this.head; | |
34444 | var i = 0; | |
34445 | while (p) { | |
34446 | copyBuffer(p.data, ret, i); | |
34447 | i += p.data.length; | |
34448 | p = p.next; | |
34449 | } | |
34450 | return ret; | |
34451 | }; | |
34452 | ||
34453 | return BufferList; | |
34454 | }(); | |
34455 | ||
34456 | if (util && util.inspect && util.inspect.custom) { | |
34457 | module.exports.prototype[util.inspect.custom] = function () { | |
34458 | var obj = util.inspect({ length: this.length }); | |
34459 | return this.constructor.name + ' ' + obj; | |
34460 | }; | |
34461 | } | |
34462 | },{"safe-buffer":398,"util":20}],390:[function(require,module,exports){ | |
34463 | 'use strict'; | |
34464 | ||
34465 | /*<replacement>*/ | |
34466 | ||
34467 | var pna = require('process-nextick-args'); | |
34468 | /*</replacement>*/ | |
34469 | ||
34470 | // undocumented cb() API, needed for core, not for public API | |
34471 | function destroy(err, cb) { | |
34472 | var _this = this; | |
34473 | ||
34474 | var readableDestroyed = this._readableState && this._readableState.destroyed; | |
34475 | var writableDestroyed = this._writableState && this._writableState.destroyed; | |
34476 | ||
34477 | if (readableDestroyed || writableDestroyed) { | |
34478 | if (cb) { | |
34479 | cb(err); | |
34480 | } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { | |
34481 | pna.nextTick(emitErrorNT, this, err); | |
34482 | } | |
34483 | return this; | |
34484 | } | |
34485 | ||
34486 | // we set destroyed to true before firing error callbacks in order | |
34487 | // to make it re-entrance safe in case destroy() is called within callbacks | |
34488 | ||
34489 | if (this._readableState) { | |
34490 | this._readableState.destroyed = true; | |
34491 | } | |
34492 | ||
34493 | // if this is a duplex stream mark the writable part as destroyed as well | |
34494 | if (this._writableState) { | |
34495 | this._writableState.destroyed = true; | |
34496 | } | |
34497 | ||
34498 | this._destroy(err || null, function (err) { | |
34499 | if (!cb && err) { | |
34500 | pna.nextTick(emitErrorNT, _this, err); | |
34501 | if (_this._writableState) { | |
34502 | _this._writableState.errorEmitted = true; | |
34503 | } | |
34504 | } else if (cb) { | |
34505 | cb(err); | |
34506 | } | |
34507 | }); | |
34508 | ||
34509 | return this; | |
34510 | } | |
34511 | ||
34512 | function undestroy() { | |
34513 | if (this._readableState) { | |
34514 | this._readableState.destroyed = false; | |
34515 | this._readableState.reading = false; | |
34516 | this._readableState.ended = false; | |
34517 | this._readableState.endEmitted = false; | |
34518 | } | |
34519 | ||
34520 | if (this._writableState) { | |
34521 | this._writableState.destroyed = false; | |
34522 | this._writableState.ended = false; | |
34523 | this._writableState.ending = false; | |
34524 | this._writableState.finished = false; | |
34525 | this._writableState.errorEmitted = false; | |
34526 | } | |
34527 | } | |
34528 | ||
34529 | function emitErrorNT(self, err) { | |
34530 | self.emit('error', err); | |
34531 | } | |
34532 | ||
34533 | module.exports = { | |
34534 | destroy: destroy, | |
34535 | undestroy: undestroy | |
34536 | }; | |
34537 | },{"process-nextick-args":373}],391:[function(require,module,exports){ | |
34538 | module.exports = require('events').EventEmitter; | |
34539 | ||
34540 | },{"events":102}],392:[function(require,module,exports){ | |
34541 | // Copyright Joyent, Inc. and other Node contributors. | |
34542 | // | |
34543 | // Permission is hereby granted, free of charge, to any person obtaining a | |
34544 | // copy of this software and associated documentation files (the | |
34545 | // "Software"), to deal in the Software without restriction, including | |
34546 | // without limitation the rights to use, copy, modify, merge, publish, | |
34547 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
34548 | // persons to whom the Software is furnished to do so, subject to the | |
34549 | // following conditions: | |
34550 | // | |
34551 | // The above copyright notice and this permission notice shall be included | |
34552 | // in all copies or substantial portions of the Software. | |
34553 | // | |
34554 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
34555 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
34556 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
34557 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
34558 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
34559 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
34560 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
34561 | ||
34562 | 'use strict'; | |
34563 | ||
34564 | /*<replacement>*/ | |
34565 | ||
34566 | var Buffer = require('safe-buffer').Buffer; | |
34567 | /*</replacement>*/ | |
34568 | ||
34569 | var isEncoding = Buffer.isEncoding || function (encoding) { | |
34570 | encoding = '' + encoding; | |
34571 | switch (encoding && encoding.toLowerCase()) { | |
34572 | 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': | |
34573 | return true; | |
34574 | default: | |
34575 | return false; | |
34576 | } | |
34577 | }; | |
34578 | ||
34579 | function _normalizeEncoding(enc) { | |
34580 | if (!enc) return 'utf8'; | |
34581 | var retried; | |
34582 | while (true) { | |
34583 | switch (enc) { | |
34584 | case 'utf8': | |
34585 | case 'utf-8': | |
34586 | return 'utf8'; | |
34587 | case 'ucs2': | |
34588 | case 'ucs-2': | |
34589 | case 'utf16le': | |
34590 | case 'utf-16le': | |
34591 | return 'utf16le'; | |
34592 | case 'latin1': | |
34593 | case 'binary': | |
34594 | return 'latin1'; | |
34595 | case 'base64': | |
34596 | case 'ascii': | |
34597 | case 'hex': | |
34598 | return enc; | |
34599 | default: | |
34600 | if (retried) return; // undefined | |
34601 | enc = ('' + enc).toLowerCase(); | |
34602 | retried = true; | |
34603 | } | |
34604 | } | |
34605 | }; | |
34606 | ||
34607 | // Do not cache `Buffer.isEncoding` when checking encoding names as some | |
34608 | // modules monkey-patch it to support additional encodings | |
34609 | function normalizeEncoding(enc) { | |
34610 | var nenc = _normalizeEncoding(enc); | |
34611 | if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); | |
34612 | return nenc || enc; | |
34613 | } | |
34614 | ||
34615 | // StringDecoder provides an interface for efficiently splitting a series of | |
34616 | // buffers into a series of JS strings without breaking apart multi-byte | |
34617 | // characters. | |
34618 | exports.StringDecoder = StringDecoder; | |
34619 | function StringDecoder(encoding) { | |
34620 | this.encoding = normalizeEncoding(encoding); | |
34621 | var nb; | |
34622 | switch (this.encoding) { | |
34623 | case 'utf16le': | |
34624 | this.text = utf16Text; | |
34625 | this.end = utf16End; | |
34626 | nb = 4; | |
34627 | break; | |
34628 | case 'utf8': | |
34629 | this.fillLast = utf8FillLast; | |
34630 | nb = 4; | |
34631 | break; | |
34632 | case 'base64': | |
34633 | this.text = base64Text; | |
34634 | this.end = base64End; | |
34635 | nb = 3; | |
34636 | break; | |
34637 | default: | |
34638 | this.write = simpleWrite; | |
34639 | this.end = simpleEnd; | |
34640 | return; | |
34641 | } | |
34642 | this.lastNeed = 0; | |
34643 | this.lastTotal = 0; | |
34644 | this.lastChar = Buffer.allocUnsafe(nb); | |
34645 | } | |
34646 | ||
34647 | StringDecoder.prototype.write = function (buf) { | |
34648 | if (buf.length === 0) return ''; | |
34649 | var r; | |
34650 | var i; | |
34651 | if (this.lastNeed) { | |
34652 | r = this.fillLast(buf); | |
34653 | if (r === undefined) return ''; | |
34654 | i = this.lastNeed; | |
34655 | this.lastNeed = 0; | |
34656 | } else { | |
34657 | i = 0; | |
34658 | } | |
34659 | if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); | |
34660 | return r || ''; | |
34661 | }; | |
34662 | ||
34663 | StringDecoder.prototype.end = utf8End; | |
34664 | ||
34665 | // Returns only complete characters in a Buffer | |
34666 | StringDecoder.prototype.text = utf8Text; | |
34667 | ||
34668 | // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer | |
34669 | StringDecoder.prototype.fillLast = function (buf) { | |
34670 | if (this.lastNeed <= buf.length) { | |
34671 | buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); | |
34672 | return this.lastChar.toString(this.encoding, 0, this.lastTotal); | |
34673 | } | |
34674 | buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); | |
34675 | this.lastNeed -= buf.length; | |
34676 | }; | |
34677 | ||
34678 | // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a | |
34679 | // continuation byte. If an invalid byte is detected, -2 is returned. | |
34680 | function utf8CheckByte(byte) { | |
34681 | 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; | |
34682 | return byte >> 6 === 0x02 ? -1 : -2; | |
34683 | } | |
34684 | ||
34685 | // Checks at most 3 bytes at the end of a Buffer in order to detect an | |
34686 | // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) | |
34687 | // needed to complete the UTF-8 character (if applicable) are returned. | |
34688 | function utf8CheckIncomplete(self, buf, i) { | |
34689 | var j = buf.length - 1; | |
34690 | if (j < i) return 0; | |
34691 | var nb = utf8CheckByte(buf[j]); | |
34692 | if (nb >= 0) { | |
34693 | if (nb > 0) self.lastNeed = nb - 1; | |
34694 | return nb; | |
34695 | } | |
34696 | if (--j < i || nb === -2) return 0; | |
34697 | nb = utf8CheckByte(buf[j]); | |
34698 | if (nb >= 0) { | |
34699 | if (nb > 0) self.lastNeed = nb - 2; | |
34700 | return nb; | |
34701 | } | |
34702 | if (--j < i || nb === -2) return 0; | |
34703 | nb = utf8CheckByte(buf[j]); | |
34704 | if (nb >= 0) { | |
34705 | if (nb > 0) { | |
34706 | if (nb === 2) nb = 0;else self.lastNeed = nb - 3; | |
34707 | } | |
34708 | return nb; | |
34709 | } | |
34710 | return 0; | |
34711 | } | |
34712 | ||
34713 | // Validates as many continuation bytes for a multi-byte UTF-8 character as | |
34714 | // needed or are available. If we see a non-continuation byte where we expect | |
34715 | // one, we "replace" the validated continuation bytes we've seen so far with | |
34716 | // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding | |
34717 | // behavior. The continuation byte check is included three times in the case | |
34718 | // where all of the continuation bytes for a character exist in the same buffer. | |
34719 | // It is also done this way as a slight performance increase instead of using a | |
34720 | // loop. | |
34721 | function utf8CheckExtraBytes(self, buf, p) { | |
34722 | if ((buf[0] & 0xC0) !== 0x80) { | |
34723 | self.lastNeed = 0; | |
34724 | return '\ufffd'; | |
34725 | } | |
34726 | if (self.lastNeed > 1 && buf.length > 1) { | |
34727 | if ((buf[1] & 0xC0) !== 0x80) { | |
34728 | self.lastNeed = 1; | |
34729 | return '\ufffd'; | |
34730 | } | |
34731 | if (self.lastNeed > 2 && buf.length > 2) { | |
34732 | if ((buf[2] & 0xC0) !== 0x80) { | |
34733 | self.lastNeed = 2; | |
34734 | return '\ufffd'; | |
34735 | } | |
34736 | } | |
34737 | } | |
34738 | } | |
34739 | ||
34740 | // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. | |
34741 | function utf8FillLast(buf) { | |
34742 | var p = this.lastTotal - this.lastNeed; | |
34743 | var r = utf8CheckExtraBytes(this, buf, p); | |
34744 | if (r !== undefined) return r; | |
34745 | if (this.lastNeed <= buf.length) { | |
34746 | buf.copy(this.lastChar, p, 0, this.lastNeed); | |
34747 | return this.lastChar.toString(this.encoding, 0, this.lastTotal); | |
34748 | } | |
34749 | buf.copy(this.lastChar, p, 0, buf.length); | |
34750 | this.lastNeed -= buf.length; | |
34751 | } | |
34752 | ||
34753 | // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a | |
34754 | // partial character, the character's bytes are buffered until the required | |
34755 | // number of bytes are available. | |
34756 | function utf8Text(buf, i) { | |
34757 | var total = utf8CheckIncomplete(this, buf, i); | |
34758 | if (!this.lastNeed) return buf.toString('utf8', i); | |
34759 | this.lastTotal = total; | |
34760 | var end = buf.length - (total - this.lastNeed); | |
34761 | buf.copy(this.lastChar, 0, end); | |
34762 | return buf.toString('utf8', i, end); | |
34763 | } | |
34764 | ||
34765 | // For UTF-8, a replacement character is added when ending on a partial | |
34766 | // character. | |
34767 | function utf8End(buf) { | |
34768 | var r = buf && buf.length ? this.write(buf) : ''; | |
34769 | if (this.lastNeed) return r + '\ufffd'; | |
34770 | return r; | |
34771 | } | |
34772 | ||
34773 | // UTF-16LE typically needs two bytes per character, but even if we have an even | |
34774 | // number of bytes available, we need to check if we end on a leading/high | |
34775 | // surrogate. In that case, we need to wait for the next two bytes in order to | |
34776 | // decode the last character properly. | |
34777 | function utf16Text(buf, i) { | |
34778 | if ((buf.length - i) % 2 === 0) { | |
34779 | var r = buf.toString('utf16le', i); | |
34780 | if (r) { | |
34781 | var c = r.charCodeAt(r.length - 1); | |
34782 | if (c >= 0xD800 && c <= 0xDBFF) { | |
34783 | this.lastNeed = 2; | |
34784 | this.lastTotal = 4; | |
34785 | this.lastChar[0] = buf[buf.length - 2]; | |
34786 | this.lastChar[1] = buf[buf.length - 1]; | |
34787 | return r.slice(0, -1); | |
34788 | } | |
34789 | } | |
34790 | return r; | |
34791 | } | |
34792 | this.lastNeed = 1; | |
34793 | this.lastTotal = 2; | |
34794 | this.lastChar[0] = buf[buf.length - 1]; | |
34795 | return buf.toString('utf16le', i, buf.length - 1); | |
34796 | } | |
34797 | ||
34798 | // For UTF-16LE we do not explicitly append special replacement characters if we | |
34799 | // end on a partial character, we simply let v8 handle that. | |
34800 | function utf16End(buf) { | |
34801 | var r = buf && buf.length ? this.write(buf) : ''; | |
34802 | if (this.lastNeed) { | |
34803 | var end = this.lastTotal - this.lastNeed; | |
34804 | return r + this.lastChar.toString('utf16le', 0, end); | |
34805 | } | |
34806 | return r; | |
34807 | } | |
34808 | ||
34809 | function base64Text(buf, i) { | |
34810 | var n = (buf.length - i) % 3; | |
34811 | if (n === 0) return buf.toString('base64', i); | |
34812 | this.lastNeed = 3 - n; | |
34813 | this.lastTotal = 3; | |
34814 | if (n === 1) { | |
34815 | this.lastChar[0] = buf[buf.length - 1]; | |
34816 | } else { | |
34817 | this.lastChar[0] = buf[buf.length - 2]; | |
34818 | this.lastChar[1] = buf[buf.length - 1]; | |
34819 | } | |
34820 | return buf.toString('base64', i, buf.length - n); | |
34821 | } | |
34822 | ||
34823 | function base64End(buf) { | |
34824 | var r = buf && buf.length ? this.write(buf) : ''; | |
34825 | if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); | |
34826 | return r; | |
34827 | } | |
34828 | ||
34829 | // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) | |
34830 | function simpleWrite(buf) { | |
34831 | return buf.toString(this.encoding); | |
34832 | } | |
34833 | ||
34834 | function simpleEnd(buf) { | |
34835 | return buf && buf.length ? this.write(buf) : ''; | |
34836 | } | |
34837 | },{"safe-buffer":398}],393:[function(require,module,exports){ | |
34838 | module.exports = require('./readable').PassThrough | |
34839 | ||
34840 | },{"./readable":394}],394:[function(require,module,exports){ | |
34841 | exports = module.exports = require('./lib/_stream_readable.js'); | |
34842 | exports.Stream = exports; | |
34843 | exports.Readable = exports; | |
34844 | exports.Writable = require('./lib/_stream_writable.js'); | |
34845 | exports.Duplex = require('./lib/_stream_duplex.js'); | |
34846 | exports.Transform = require('./lib/_stream_transform.js'); | |
34847 | exports.PassThrough = require('./lib/_stream_passthrough.js'); | |
34848 | ||
34849 | },{"./lib/_stream_duplex.js":384,"./lib/_stream_passthrough.js":385,"./lib/_stream_readable.js":386,"./lib/_stream_transform.js":387,"./lib/_stream_writable.js":388}],395:[function(require,module,exports){ | |
34850 | module.exports = require('./readable').Transform | |
34851 | ||
34852 | },{"./readable":394}],396:[function(require,module,exports){ | |
34853 | module.exports = require('./lib/_stream_writable.js'); | |
34854 | ||
34855 | },{"./lib/_stream_writable.js":388}],397:[function(require,module,exports){ | |
34856 | 'use strict' | |
34857 | var Buffer = require('buffer').Buffer | |
34858 | var inherits = require('inherits') | |
34859 | var HashBase = require('hash-base') | |
34860 | ||
34861 | var ARRAY16 = new Array(16) | |
34862 | ||
34863 | var zl = [ | |
34864 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, | |
34865 | 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, | |
34866 | 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, | |
34867 | 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, | |
34868 | 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 | |
34869 | ] | |
34870 | ||
34871 | var zr = [ | |
34872 | 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, | |
34873 | 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, | |
34874 | 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, | |
34875 | 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, | |
34876 | 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 | |
34877 | ] | |
34878 | ||
34879 | var sl = [ | |
34880 | 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, | |
34881 | 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, | |
34882 | 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, | |
34883 | 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, | |
34884 | 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 | |
34885 | ] | |
34886 | ||
34887 | var sr = [ | |
34888 | 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, | |
34889 | 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, | |
34890 | 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, | |
34891 | 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, | |
34892 | 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 | |
34893 | ] | |
34894 | ||
34895 | var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e] | |
34896 | var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000] | |
34897 | ||
34898 | function RIPEMD160 () { | |
34899 | HashBase.call(this, 64) | |
34900 | ||
34901 | // state | |
34902 | this._a = 0x67452301 | |
34903 | this._b = 0xefcdab89 | |
34904 | this._c = 0x98badcfe | |
34905 | this._d = 0x10325476 | |
34906 | this._e = 0xc3d2e1f0 | |
34907 | } | |
34908 | ||
34909 | inherits(RIPEMD160, HashBase) | |
34910 | ||
34911 | RIPEMD160.prototype._update = function () { | |
34912 | var words = ARRAY16 | |
34913 | for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4) | |
34914 | ||
34915 | var al = this._a | 0 | |
34916 | var bl = this._b | 0 | |
34917 | var cl = this._c | 0 | |
34918 | var dl = this._d | 0 | |
34919 | var el = this._e | 0 | |
34920 | ||
34921 | var ar = this._a | 0 | |
34922 | var br = this._b | 0 | |
34923 | var cr = this._c | 0 | |
34924 | var dr = this._d | 0 | |
34925 | var er = this._e | 0 | |
34926 | ||
34927 | // computation | |
34928 | for (var i = 0; i < 80; i += 1) { | |
34929 | var tl | |
34930 | var tr | |
34931 | if (i < 16) { | |
34932 | tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]) | |
34933 | tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]) | |
34934 | } else if (i < 32) { | |
34935 | tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]) | |
34936 | tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]) | |
34937 | } else if (i < 48) { | |
34938 | tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]) | |
34939 | tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]) | |
34940 | } else if (i < 64) { | |
34941 | tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]) | |
34942 | tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]) | |
34943 | } else { // if (i<80) { | |
34944 | tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]) | |
34945 | tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]) | |
34946 | } | |
34947 | ||
34948 | al = el | |
34949 | el = dl | |
34950 | dl = rotl(cl, 10) | |
34951 | cl = bl | |
34952 | bl = tl | |
34953 | ||
34954 | ar = er | |
34955 | er = dr | |
34956 | dr = rotl(cr, 10) | |
34957 | cr = br | |
34958 | br = tr | |
34959 | } | |
34960 | ||
34961 | // update state | |
34962 | var t = (this._b + cl + dr) | 0 | |
34963 | this._b = (this._c + dl + er) | 0 | |
34964 | this._c = (this._d + el + ar) | 0 | |
34965 | this._d = (this._e + al + br) | 0 | |
34966 | this._e = (this._a + bl + cr) | 0 | |
34967 | this._a = t | |
34968 | } | |
34969 | ||
34970 | RIPEMD160.prototype._digest = function () { | |
34971 | // create padding and handle blocks | |
34972 | this._block[this._blockOffset++] = 0x80 | |
34973 | if (this._blockOffset > 56) { | |
34974 | this._block.fill(0, this._blockOffset, 64) | |
34975 | this._update() | |
34976 | this._blockOffset = 0 | |
34977 | } | |
34978 | ||
34979 | this._block.fill(0, this._blockOffset, 56) | |
34980 | this._block.writeUInt32LE(this._length[0], 56) | |
34981 | this._block.writeUInt32LE(this._length[1], 60) | |
34982 | this._update() | |
34983 | ||
34984 | // produce result | |
34985 | var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20) | |
34986 | buffer.writeInt32LE(this._a, 0) | |
34987 | buffer.writeInt32LE(this._b, 4) | |
34988 | buffer.writeInt32LE(this._c, 8) | |
34989 | buffer.writeInt32LE(this._d, 12) | |
34990 | buffer.writeInt32LE(this._e, 16) | |
34991 | return buffer | |
34992 | } | |
34993 | ||
34994 | function rotl (x, n) { | |
34995 | return (x << n) | (x >>> (32 - n)) | |
34996 | } | |
34997 | ||
34998 | function fn1 (a, b, c, d, e, m, k, s) { | |
34999 | return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0 | |
35000 | } | |
35001 | ||
35002 | function fn2 (a, b, c, d, e, m, k, s) { | |
35003 | return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0 | |
35004 | } | |
35005 | ||
35006 | function fn3 (a, b, c, d, e, m, k, s) { | |
35007 | return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0 | |
35008 | } | |
35009 | ||
35010 | function fn4 (a, b, c, d, e, m, k, s) { | |
35011 | return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0 | |
35012 | } | |
35013 | ||
35014 | function fn5 (a, b, c, d, e, m, k, s) { | |
35015 | return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0 | |
35016 | } | |
35017 | ||
35018 | module.exports = RIPEMD160 | |
35019 | ||
35020 | },{"buffer":50,"hash-base":104,"inherits":119}],398:[function(require,module,exports){ | |
35021 | /* eslint-disable node/no-deprecated-api */ | |
35022 | var buffer = require('buffer') | |
35023 | var Buffer = buffer.Buffer | |
35024 | ||
35025 | // alternative to using Object.keys for old browsers | |
35026 | function copyProps (src, dst) { | |
35027 | for (var key in src) { | |
35028 | dst[key] = src[key] | |
35029 | } | |
35030 | } | |
35031 | if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { | |
35032 | module.exports = buffer | |
35033 | } else { | |
35034 | // Copy properties from require('buffer') | |
35035 | copyProps(buffer, exports) | |
35036 | exports.Buffer = SafeBuffer | |
35037 | } | |
35038 | ||
35039 | function SafeBuffer (arg, encodingOrOffset, length) { | |
35040 | return Buffer(arg, encodingOrOffset, length) | |
35041 | } | |
35042 | ||
35043 | // Copy static methods from Buffer | |
35044 | copyProps(Buffer, SafeBuffer) | |
35045 | ||
35046 | SafeBuffer.from = function (arg, encodingOrOffset, length) { | |
35047 | if (typeof arg === 'number') { | |
35048 | throw new TypeError('Argument must not be a number') | |
35049 | } | |
35050 | return Buffer(arg, encodingOrOffset, length) | |
35051 | } | |
35052 | ||
35053 | SafeBuffer.alloc = function (size, fill, encoding) { | |
35054 | if (typeof size !== 'number') { | |
35055 | throw new TypeError('Argument must be a number') | |
35056 | } | |
35057 | var buf = Buffer(size) | |
35058 | if (fill !== undefined) { | |
35059 | if (typeof encoding === 'string') { | |
35060 | buf.fill(fill, encoding) | |
35061 | } else { | |
35062 | buf.fill(fill) | |
35063 | } | |
35064 | } else { | |
35065 | buf.fill(0) | |
35066 | } | |
35067 | return buf | |
35068 | } | |
35069 | ||
35070 | SafeBuffer.allocUnsafe = function (size) { | |
35071 | if (typeof size !== 'number') { | |
35072 | throw new TypeError('Argument must be a number') | |
35073 | } | |
35074 | return Buffer(size) | |
35075 | } | |
35076 | ||
35077 | SafeBuffer.allocUnsafeSlow = function (size) { | |
35078 | if (typeof size !== 'number') { | |
35079 | throw new TypeError('Argument must be a number') | |
35080 | } | |
35081 | return buffer.SlowBuffer(size) | |
35082 | } | |
35083 | ||
35084 | },{"buffer":50}],399:[function(require,module,exports){ | |
35085 | var Buffer = require('safe-buffer').Buffer | |
35086 | ||
35087 | // prototype class for hash functions | |
35088 | function Hash (blockSize, finalSize) { | |
35089 | this._block = Buffer.alloc(blockSize) | |
35090 | this._finalSize = finalSize | |
35091 | this._blockSize = blockSize | |
35092 | this._len = 0 | |
35093 | } | |
35094 | ||
35095 | Hash.prototype.update = function (data, enc) { | |
35096 | if (typeof data === 'string') { | |
35097 | enc = enc || 'utf8' | |
35098 | data = Buffer.from(data, enc) | |
35099 | } | |
35100 | ||
35101 | var block = this._block | |
35102 | var blockSize = this._blockSize | |
35103 | var length = data.length | |
35104 | var accum = this._len | |
35105 | ||
35106 | for (var offset = 0; offset < length;) { | |
35107 | var assigned = accum % blockSize | |
35108 | var remainder = Math.min(length - offset, blockSize - assigned) | |
35109 | ||
35110 | for (var i = 0; i < remainder; i++) { | |
35111 | block[assigned + i] = data[offset + i] | |
35112 | } | |
35113 | ||
35114 | accum += remainder | |
35115 | offset += remainder | |
35116 | ||
35117 | if ((accum % blockSize) === 0) { | |
35118 | this._update(block) | |
35119 | } | |
35120 | } | |
35121 | ||
35122 | this._len += length | |
35123 | return this | |
35124 | } | |
35125 | ||
35126 | Hash.prototype.digest = function (enc) { | |
35127 | var rem = this._len % this._blockSize | |
35128 | ||
35129 | this._block[rem] = 0x80 | |
35130 | ||
35131 | // zero (rem + 1) trailing bits, where (rem + 1) is the smallest | |
35132 | // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize | |
35133 | this._block.fill(0, rem + 1) | |
35134 | ||
35135 | if (rem >= this._finalSize) { | |
35136 | this._update(this._block) | |
35137 | this._block.fill(0) | |
35138 | } | |
35139 | ||
35140 | var bits = this._len * 8 | |
35141 | ||
35142 | // uint32 | |
35143 | if (bits <= 0xffffffff) { | |
35144 | this._block.writeUInt32BE(bits, this._blockSize - 4) | |
35145 | ||
35146 | // uint64 | |
35147 | } else { | |
35148 | var lowBits = (bits & 0xffffffff) >>> 0 | |
35149 | var highBits = (bits - lowBits) / 0x100000000 | |
35150 | ||
35151 | this._block.writeUInt32BE(highBits, this._blockSize - 8) | |
35152 | this._block.writeUInt32BE(lowBits, this._blockSize - 4) | |
35153 | } | |
35154 | ||
35155 | this._update(this._block) | |
35156 | var hash = this._hash() | |
35157 | ||
35158 | return enc ? hash.toString(enc) : hash | |
35159 | } | |
35160 | ||
35161 | Hash.prototype._update = function () { | |
35162 | throw new Error('_update must be implemented by subclass') | |
35163 | } | |
35164 | ||
35165 | module.exports = Hash | |
35166 | ||
35167 | },{"safe-buffer":398}],400:[function(require,module,exports){ | |
35168 | var exports = module.exports = function SHA (algorithm) { | |
35169 | algorithm = algorithm.toLowerCase() | |
35170 | ||
35171 | var Algorithm = exports[algorithm] | |
35172 | if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)') | |
35173 | ||
35174 | return new Algorithm() | |
35175 | } | |
35176 | ||
35177 | exports.sha = require('./sha') | |
35178 | exports.sha1 = require('./sha1') | |
35179 | exports.sha224 = require('./sha224') | |
35180 | exports.sha256 = require('./sha256') | |
35181 | exports.sha384 = require('./sha384') | |
35182 | exports.sha512 = require('./sha512') | |
35183 | ||
35184 | },{"./sha":401,"./sha1":402,"./sha224":403,"./sha256":404,"./sha384":405,"./sha512":406}],401:[function(require,module,exports){ | |
35185 | /* | |
35186 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined | |
35187 | * in FIPS PUB 180-1 | |
35188 | * This source code is derived from sha1.js of the same repository. | |
35189 | * The difference between SHA-0 and SHA-1 is just a bitwise rotate left | |
35190 | * operation was added. | |
35191 | */ | |
35192 | ||
35193 | var inherits = require('inherits') | |
35194 | var Hash = require('./hash') | |
35195 | var Buffer = require('safe-buffer').Buffer | |
35196 | ||
35197 | var K = [ | |
35198 | 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 | |
35199 | ] | |
35200 | ||
35201 | var W = new Array(80) | |
35202 | ||
35203 | function Sha () { | |
35204 | this.init() | |
35205 | this._w = W | |
35206 | ||
35207 | Hash.call(this, 64, 56) | |
35208 | } | |
35209 | ||
35210 | inherits(Sha, Hash) | |
35211 | ||
35212 | Sha.prototype.init = function () { | |
35213 | this._a = 0x67452301 | |
35214 | this._b = 0xefcdab89 | |
35215 | this._c = 0x98badcfe | |
35216 | this._d = 0x10325476 | |
35217 | this._e = 0xc3d2e1f0 | |
35218 | ||
35219 | return this | |
35220 | } | |
35221 | ||
35222 | function rotl5 (num) { | |
35223 | return (num << 5) | (num >>> 27) | |
35224 | } | |
35225 | ||
35226 | function rotl30 (num) { | |
35227 | return (num << 30) | (num >>> 2) | |
35228 | } | |
35229 | ||
35230 | function ft (s, b, c, d) { | |
35231 | if (s === 0) return (b & c) | ((~b) & d) | |
35232 | if (s === 2) return (b & c) | (b & d) | (c & d) | |
35233 | return b ^ c ^ d | |
35234 | } | |
35235 | ||
35236 | Sha.prototype._update = function (M) { | |
35237 | var W = this._w | |
35238 | ||
35239 | var a = this._a | 0 | |
35240 | var b = this._b | 0 | |
35241 | var c = this._c | 0 | |
35242 | var d = this._d | 0 | |
35243 | var e = this._e | 0 | |
35244 | ||
35245 | for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) | |
35246 | for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16] | |
35247 | ||
35248 | for (var j = 0; j < 80; ++j) { | |
35249 | var s = ~~(j / 20) | |
35250 | var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0 | |
35251 | ||
35252 | e = d | |
35253 | d = c | |
35254 | c = rotl30(b) | |
35255 | b = a | |
35256 | a = t | |
35257 | } | |
35258 | ||
35259 | this._a = (a + this._a) | 0 | |
35260 | this._b = (b + this._b) | 0 | |
35261 | this._c = (c + this._c) | 0 | |
35262 | this._d = (d + this._d) | 0 | |
35263 | this._e = (e + this._e) | 0 | |
35264 | } | |
35265 | ||
35266 | Sha.prototype._hash = function () { | |
35267 | var H = Buffer.allocUnsafe(20) | |
35268 | ||
35269 | H.writeInt32BE(this._a | 0, 0) | |
35270 | H.writeInt32BE(this._b | 0, 4) | |
35271 | H.writeInt32BE(this._c | 0, 8) | |
35272 | H.writeInt32BE(this._d | 0, 12) | |
35273 | H.writeInt32BE(this._e | 0, 16) | |
35274 | ||
35275 | return H | |
35276 | } | |
35277 | ||
35278 | module.exports = Sha | |
35279 | ||
35280 | },{"./hash":399,"inherits":119,"safe-buffer":398}],402:[function(require,module,exports){ | |
35281 | /* | |
35282 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined | |
35283 | * in FIPS PUB 180-1 | |
35284 | * Version 2.1a Copyright Paul Johnston 2000 - 2002. | |
35285 | * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet | |
35286 | * Distributed under the BSD License | |
35287 | * See http://pajhome.org.uk/crypt/md5 for details. | |
35288 | */ | |
35289 | ||
35290 | var inherits = require('inherits') | |
35291 | var Hash = require('./hash') | |
35292 | var Buffer = require('safe-buffer').Buffer | |
35293 | ||
35294 | var K = [ | |
35295 | 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0 | |
35296 | ] | |
35297 | ||
35298 | var W = new Array(80) | |
35299 | ||
35300 | function Sha1 () { | |
35301 | this.init() | |
35302 | this._w = W | |
35303 | ||
35304 | Hash.call(this, 64, 56) | |
35305 | } | |
35306 | ||
35307 | inherits(Sha1, Hash) | |
35308 | ||
35309 | Sha1.prototype.init = function () { | |
35310 | this._a = 0x67452301 | |
35311 | this._b = 0xefcdab89 | |
35312 | this._c = 0x98badcfe | |
35313 | this._d = 0x10325476 | |
35314 | this._e = 0xc3d2e1f0 | |
35315 | ||
35316 | return this | |
35317 | } | |
35318 | ||
35319 | function rotl1 (num) { | |
35320 | return (num << 1) | (num >>> 31) | |
35321 | } | |
35322 | ||
35323 | function rotl5 (num) { | |
35324 | return (num << 5) | (num >>> 27) | |
35325 | } | |
35326 | ||
35327 | function rotl30 (num) { | |
35328 | return (num << 30) | (num >>> 2) | |
35329 | } | |
35330 | ||
35331 | function ft (s, b, c, d) { | |
35332 | if (s === 0) return (b & c) | ((~b) & d) | |
35333 | if (s === 2) return (b & c) | (b & d) | (c & d) | |
35334 | return b ^ c ^ d | |
35335 | } | |
35336 | ||
35337 | Sha1.prototype._update = function (M) { | |
35338 | var W = this._w | |
35339 | ||
35340 | var a = this._a | 0 | |
35341 | var b = this._b | 0 | |
35342 | var c = this._c | 0 | |
35343 | var d = this._d | 0 | |
35344 | var e = this._e | 0 | |
35345 | ||
35346 | for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) | |
35347 | for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]) | |
35348 | ||
35349 | for (var j = 0; j < 80; ++j) { | |
35350 | var s = ~~(j / 20) | |
35351 | var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0 | |
35352 | ||
35353 | e = d | |
35354 | d = c | |
35355 | c = rotl30(b) | |
35356 | b = a | |
35357 | a = t | |
35358 | } | |
35359 | ||
35360 | this._a = (a + this._a) | 0 | |
35361 | this._b = (b + this._b) | 0 | |
35362 | this._c = (c + this._c) | 0 | |
35363 | this._d = (d + this._d) | 0 | |
35364 | this._e = (e + this._e) | 0 | |
35365 | } | |
35366 | ||
35367 | Sha1.prototype._hash = function () { | |
35368 | var H = Buffer.allocUnsafe(20) | |
35369 | ||
35370 | H.writeInt32BE(this._a | 0, 0) | |
35371 | H.writeInt32BE(this._b | 0, 4) | |
35372 | H.writeInt32BE(this._c | 0, 8) | |
35373 | H.writeInt32BE(this._d | 0, 12) | |
35374 | H.writeInt32BE(this._e | 0, 16) | |
35375 | ||
35376 | return H | |
35377 | } | |
35378 | ||
35379 | module.exports = Sha1 | |
35380 | ||
35381 | },{"./hash":399,"inherits":119,"safe-buffer":398}],403:[function(require,module,exports){ | |
35382 | /** | |
35383 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined | |
35384 | * in FIPS 180-2 | |
35385 | * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. | |
35386 | * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet | |
35387 | * | |
35388 | */ | |
35389 | ||
35390 | var inherits = require('inherits') | |
35391 | var Sha256 = require('./sha256') | |
35392 | var Hash = require('./hash') | |
35393 | var Buffer = require('safe-buffer').Buffer | |
35394 | ||
35395 | var W = new Array(64) | |
35396 | ||
35397 | function Sha224 () { | |
35398 | this.init() | |
35399 | ||
35400 | this._w = W // new Array(64) | |
35401 | ||
35402 | Hash.call(this, 64, 56) | |
35403 | } | |
35404 | ||
35405 | inherits(Sha224, Sha256) | |
35406 | ||
35407 | Sha224.prototype.init = function () { | |
35408 | this._a = 0xc1059ed8 | |
35409 | this._b = 0x367cd507 | |
35410 | this._c = 0x3070dd17 | |
35411 | this._d = 0xf70e5939 | |
35412 | this._e = 0xffc00b31 | |
35413 | this._f = 0x68581511 | |
35414 | this._g = 0x64f98fa7 | |
35415 | this._h = 0xbefa4fa4 | |
35416 | ||
35417 | return this | |
35418 | } | |
35419 | ||
35420 | Sha224.prototype._hash = function () { | |
35421 | var H = Buffer.allocUnsafe(28) | |
35422 | ||
35423 | H.writeInt32BE(this._a, 0) | |
35424 | H.writeInt32BE(this._b, 4) | |
35425 | H.writeInt32BE(this._c, 8) | |
35426 | H.writeInt32BE(this._d, 12) | |
35427 | H.writeInt32BE(this._e, 16) | |
35428 | H.writeInt32BE(this._f, 20) | |
35429 | H.writeInt32BE(this._g, 24) | |
35430 | ||
35431 | return H | |
35432 | } | |
35433 | ||
35434 | module.exports = Sha224 | |
35435 | ||
35436 | },{"./hash":399,"./sha256":404,"inherits":119,"safe-buffer":398}],404:[function(require,module,exports){ | |
35437 | /** | |
35438 | * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined | |
35439 | * in FIPS 180-2 | |
35440 | * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. | |
35441 | * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet | |
35442 | * | |
35443 | */ | |
35444 | ||
35445 | var inherits = require('inherits') | |
35446 | var Hash = require('./hash') | |
35447 | var Buffer = require('safe-buffer').Buffer | |
35448 | ||
35449 | var K = [ | |
35450 | 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, | |
35451 | 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, | |
35452 | 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, | |
35453 | 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, | |
35454 | 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, | |
35455 | 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, | |
35456 | 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, | |
35457 | 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, | |
35458 | 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, | |
35459 | 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, | |
35460 | 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, | |
35461 | 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, | |
35462 | 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, | |
35463 | 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, | |
35464 | 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, | |
35465 | 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 | |
35466 | ] | |
35467 | ||
35468 | var W = new Array(64) | |
35469 | ||
35470 | function Sha256 () { | |
35471 | this.init() | |
35472 | ||
35473 | this._w = W // new Array(64) | |
35474 | ||
35475 | Hash.call(this, 64, 56) | |
35476 | } | |
35477 | ||
35478 | inherits(Sha256, Hash) | |
35479 | ||
35480 | Sha256.prototype.init = function () { | |
35481 | this._a = 0x6a09e667 | |
35482 | this._b = 0xbb67ae85 | |
35483 | this._c = 0x3c6ef372 | |
35484 | this._d = 0xa54ff53a | |
35485 | this._e = 0x510e527f | |
35486 | this._f = 0x9b05688c | |
35487 | this._g = 0x1f83d9ab | |
35488 | this._h = 0x5be0cd19 | |
35489 | ||
35490 | return this | |
35491 | } | |
35492 | ||
35493 | function ch (x, y, z) { | |
35494 | return z ^ (x & (y ^ z)) | |
35495 | } | |
35496 | ||
35497 | function maj (x, y, z) { | |
35498 | return (x & y) | (z & (x | y)) | |
35499 | } | |
35500 | ||
35501 | function sigma0 (x) { | |
35502 | return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10) | |
35503 | } | |
35504 | ||
35505 | function sigma1 (x) { | |
35506 | return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7) | |
35507 | } | |
35508 | ||
35509 | function gamma0 (x) { | |
35510 | return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3) | |
35511 | } | |
35512 | ||
35513 | function gamma1 (x) { | |
35514 | return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10) | |
35515 | } | |
35516 | ||
35517 | Sha256.prototype._update = function (M) { | |
35518 | var W = this._w | |
35519 | ||
35520 | var a = this._a | 0 | |
35521 | var b = this._b | 0 | |
35522 | var c = this._c | 0 | |
35523 | var d = this._d | 0 | |
35524 | var e = this._e | 0 | |
35525 | var f = this._f | 0 | |
35526 | var g = this._g | 0 | |
35527 | var h = this._h | 0 | |
35528 | ||
35529 | for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4) | |
35530 | for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0 | |
35531 | ||
35532 | for (var j = 0; j < 64; ++j) { | |
35533 | var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0 | |
35534 | var T2 = (sigma0(a) + maj(a, b, c)) | 0 | |
35535 | ||
35536 | h = g | |
35537 | g = f | |
35538 | f = e | |
35539 | e = (d + T1) | 0 | |
35540 | d = c | |
35541 | c = b | |
35542 | b = a | |
35543 | a = (T1 + T2) | 0 | |
35544 | } | |
35545 | ||
35546 | this._a = (a + this._a) | 0 | |
35547 | this._b = (b + this._b) | 0 | |
35548 | this._c = (c + this._c) | 0 | |
35549 | this._d = (d + this._d) | 0 | |
35550 | this._e = (e + this._e) | 0 | |
35551 | this._f = (f + this._f) | 0 | |
35552 | this._g = (g + this._g) | 0 | |
35553 | this._h = (h + this._h) | 0 | |
35554 | } | |
35555 | ||
35556 | Sha256.prototype._hash = function () { | |
35557 | var H = Buffer.allocUnsafe(32) | |
35558 | ||
35559 | H.writeInt32BE(this._a, 0) | |
35560 | H.writeInt32BE(this._b, 4) | |
35561 | H.writeInt32BE(this._c, 8) | |
35562 | H.writeInt32BE(this._d, 12) | |
35563 | H.writeInt32BE(this._e, 16) | |
35564 | H.writeInt32BE(this._f, 20) | |
35565 | H.writeInt32BE(this._g, 24) | |
35566 | H.writeInt32BE(this._h, 28) | |
35567 | ||
35568 | return H | |
35569 | } | |
35570 | ||
35571 | module.exports = Sha256 | |
35572 | ||
35573 | },{"./hash":399,"inherits":119,"safe-buffer":398}],405:[function(require,module,exports){ | |
35574 | var inherits = require('inherits') | |
35575 | var SHA512 = require('./sha512') | |
35576 | var Hash = require('./hash') | |
35577 | var Buffer = require('safe-buffer').Buffer | |
35578 | ||
35579 | var W = new Array(160) | |
35580 | ||
35581 | function Sha384 () { | |
35582 | this.init() | |
35583 | this._w = W | |
35584 | ||
35585 | Hash.call(this, 128, 112) | |
35586 | } | |
35587 | ||
35588 | inherits(Sha384, SHA512) | |
35589 | ||
35590 | Sha384.prototype.init = function () { | |
35591 | this._ah = 0xcbbb9d5d | |
35592 | this._bh = 0x629a292a | |
35593 | this._ch = 0x9159015a | |
35594 | this._dh = 0x152fecd8 | |
35595 | this._eh = 0x67332667 | |
35596 | this._fh = 0x8eb44a87 | |
35597 | this._gh = 0xdb0c2e0d | |
35598 | this._hh = 0x47b5481d | |
35599 | ||
35600 | this._al = 0xc1059ed8 | |
35601 | this._bl = 0x367cd507 | |
35602 | this._cl = 0x3070dd17 | |
35603 | this._dl = 0xf70e5939 | |
35604 | this._el = 0xffc00b31 | |
35605 | this._fl = 0x68581511 | |
35606 | this._gl = 0x64f98fa7 | |
35607 | this._hl = 0xbefa4fa4 | |
35608 | ||
35609 | return this | |
35610 | } | |
35611 | ||
35612 | Sha384.prototype._hash = function () { | |
35613 | var H = Buffer.allocUnsafe(48) | |
35614 | ||
35615 | function writeInt64BE (h, l, offset) { | |
35616 | H.writeInt32BE(h, offset) | |
35617 | H.writeInt32BE(l, offset + 4) | |
35618 | } | |
35619 | ||
35620 | writeInt64BE(this._ah, this._al, 0) | |
35621 | writeInt64BE(this._bh, this._bl, 8) | |
35622 | writeInt64BE(this._ch, this._cl, 16) | |
35623 | writeInt64BE(this._dh, this._dl, 24) | |
35624 | writeInt64BE(this._eh, this._el, 32) | |
35625 | writeInt64BE(this._fh, this._fl, 40) | |
35626 | ||
35627 | return H | |
35628 | } | |
35629 | ||
35630 | module.exports = Sha384 | |
35631 | ||
35632 | },{"./hash":399,"./sha512":406,"inherits":119,"safe-buffer":398}],406:[function(require,module,exports){ | |
35633 | var inherits = require('inherits') | |
35634 | var Hash = require('./hash') | |
35635 | var Buffer = require('safe-buffer').Buffer | |
35636 | ||
35637 | var K = [ | |
35638 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, | |
35639 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, | |
35640 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, | |
35641 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, | |
35642 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, | |
35643 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, | |
35644 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, | |
35645 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, | |
35646 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, | |
35647 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, | |
35648 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, | |
35649 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, | |
35650 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, | |
35651 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, | |
35652 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, | |
35653 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, | |
35654 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, | |
35655 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, | |
35656 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, | |
35657 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, | |
35658 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, | |
35659 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, | |
35660 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, | |
35661 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, | |
35662 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, | |
35663 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, | |
35664 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, | |
35665 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, | |
35666 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, | |
35667 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, | |
35668 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, | |
35669 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, | |
35670 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, | |
35671 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, | |
35672 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, | |
35673 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, | |
35674 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, | |
35675 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, | |
35676 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, | |
35677 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 | |
35678 | ] | |
35679 | ||
35680 | var W = new Array(160) | |
35681 | ||
35682 | function Sha512 () { | |
35683 | this.init() | |
35684 | this._w = W | |
35685 | ||
35686 | Hash.call(this, 128, 112) | |
35687 | } | |
35688 | ||
35689 | inherits(Sha512, Hash) | |
35690 | ||
35691 | Sha512.prototype.init = function () { | |
35692 | this._ah = 0x6a09e667 | |
35693 | this._bh = 0xbb67ae85 | |
35694 | this._ch = 0x3c6ef372 | |
35695 | this._dh = 0xa54ff53a | |
35696 | this._eh = 0x510e527f | |
35697 | this._fh = 0x9b05688c | |
35698 | this._gh = 0x1f83d9ab | |
35699 | this._hh = 0x5be0cd19 | |
35700 | ||
35701 | this._al = 0xf3bcc908 | |
35702 | this._bl = 0x84caa73b | |
35703 | this._cl = 0xfe94f82b | |
35704 | this._dl = 0x5f1d36f1 | |
35705 | this._el = 0xade682d1 | |
35706 | this._fl = 0x2b3e6c1f | |
35707 | this._gl = 0xfb41bd6b | |
35708 | this._hl = 0x137e2179 | |
35709 | ||
35710 | return this | |
35711 | } | |
35712 | ||
35713 | function Ch (x, y, z) { | |
35714 | return z ^ (x & (y ^ z)) | |
35715 | } | |
35716 | ||
35717 | function maj (x, y, z) { | |
35718 | return (x & y) | (z & (x | y)) | |
35719 | } | |
35720 | ||
35721 | function sigma0 (x, xl) { | |
35722 | return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25) | |
35723 | } | |
35724 | ||
35725 | function sigma1 (x, xl) { | |
35726 | return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23) | |
35727 | } | |
35728 | ||
35729 | function Gamma0 (x, xl) { | |
35730 | return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7) | |
35731 | } | |
35732 | ||
35733 | function Gamma0l (x, xl) { | |
35734 | return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25) | |
35735 | } | |
35736 | ||
35737 | function Gamma1 (x, xl) { | |
35738 | return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6) | |
35739 | } | |
35740 | ||
35741 | function Gamma1l (x, xl) { | |
35742 | return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26) | |
35743 | } | |
35744 | ||
35745 | function getCarry (a, b) { | |
35746 | return (a >>> 0) < (b >>> 0) ? 1 : 0 | |
35747 | } | |
35748 | ||
35749 | Sha512.prototype._update = function (M) { | |
35750 | var W = this._w | |
35751 | ||
35752 | var ah = this._ah | 0 | |
35753 | var bh = this._bh | 0 | |
35754 | var ch = this._ch | 0 | |
35755 | var dh = this._dh | 0 | |
35756 | var eh = this._eh | 0 | |
35757 | var fh = this._fh | 0 | |
35758 | var gh = this._gh | 0 | |
35759 | var hh = this._hh | 0 | |
35760 | ||
35761 | var al = this._al | 0 | |
35762 | var bl = this._bl | 0 | |
35763 | var cl = this._cl | 0 | |
35764 | var dl = this._dl | 0 | |
35765 | var el = this._el | 0 | |
35766 | var fl = this._fl | 0 | |
35767 | var gl = this._gl | 0 | |
35768 | var hl = this._hl | 0 | |
35769 | ||
35770 | for (var i = 0; i < 32; i += 2) { | |
35771 | W[i] = M.readInt32BE(i * 4) | |
35772 | W[i + 1] = M.readInt32BE(i * 4 + 4) | |
35773 | } | |
35774 | for (; i < 160; i += 2) { | |
35775 | var xh = W[i - 15 * 2] | |
35776 | var xl = W[i - 15 * 2 + 1] | |
35777 | var gamma0 = Gamma0(xh, xl) | |
35778 | var gamma0l = Gamma0l(xl, xh) | |
35779 | ||
35780 | xh = W[i - 2 * 2] | |
35781 | xl = W[i - 2 * 2 + 1] | |
35782 | var gamma1 = Gamma1(xh, xl) | |
35783 | var gamma1l = Gamma1l(xl, xh) | |
35784 | ||
35785 | // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] | |
35786 | var Wi7h = W[i - 7 * 2] | |
35787 | var Wi7l = W[i - 7 * 2 + 1] | |
35788 | ||
35789 | var Wi16h = W[i - 16 * 2] | |
35790 | var Wi16l = W[i - 16 * 2 + 1] | |
35791 | ||
35792 | var Wil = (gamma0l + Wi7l) | 0 | |
35793 | var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0 | |
35794 | Wil = (Wil + gamma1l) | 0 | |
35795 | Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0 | |
35796 | Wil = (Wil + Wi16l) | 0 | |
35797 | Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0 | |
35798 | ||
35799 | W[i] = Wih | |
35800 | W[i + 1] = Wil | |
35801 | } | |
35802 | ||
35803 | for (var j = 0; j < 160; j += 2) { | |
35804 | Wih = W[j] | |
35805 | Wil = W[j + 1] | |
35806 | ||
35807 | var majh = maj(ah, bh, ch) | |
35808 | var majl = maj(al, bl, cl) | |
35809 | ||
35810 | var sigma0h = sigma0(ah, al) | |
35811 | var sigma0l = sigma0(al, ah) | |
35812 | var sigma1h = sigma1(eh, el) | |
35813 | var sigma1l = sigma1(el, eh) | |
35814 | ||
35815 | // t1 = h + sigma1 + ch + K[j] + W[j] | |
35816 | var Kih = K[j] | |
35817 | var Kil = K[j + 1] | |
35818 | ||
35819 | var chh = Ch(eh, fh, gh) | |
35820 | var chl = Ch(el, fl, gl) | |
35821 | ||
35822 | var t1l = (hl + sigma1l) | 0 | |
35823 | var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0 | |
35824 | t1l = (t1l + chl) | 0 | |
35825 | t1h = (t1h + chh + getCarry(t1l, chl)) | 0 | |
35826 | t1l = (t1l + Kil) | 0 | |
35827 | t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0 | |
35828 | t1l = (t1l + Wil) | 0 | |
35829 | t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0 | |
35830 | ||
35831 | // t2 = sigma0 + maj | |
35832 | var t2l = (sigma0l + majl) | 0 | |
35833 | var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0 | |
35834 | ||
35835 | hh = gh | |
35836 | hl = gl | |
35837 | gh = fh | |
35838 | gl = fl | |
35839 | fh = eh | |
35840 | fl = el | |
35841 | el = (dl + t1l) | 0 | |
35842 | eh = (dh + t1h + getCarry(el, dl)) | 0 | |
35843 | dh = ch | |
35844 | dl = cl | |
35845 | ch = bh | |
35846 | cl = bl | |
35847 | bh = ah | |
35848 | bl = al | |
35849 | al = (t1l + t2l) | 0 | |
35850 | ah = (t1h + t2h + getCarry(al, t1l)) | 0 | |
35851 | } | |
35852 | ||
35853 | this._al = (this._al + al) | 0 | |
35854 | this._bl = (this._bl + bl) | 0 | |
35855 | this._cl = (this._cl + cl) | 0 | |
35856 | this._dl = (this._dl + dl) | 0 | |
35857 | this._el = (this._el + el) | 0 | |
35858 | this._fl = (this._fl + fl) | 0 | |
35859 | this._gl = (this._gl + gl) | 0 | |
35860 | this._hl = (this._hl + hl) | 0 | |
35861 | ||
35862 | this._ah = (this._ah + ah + getCarry(this._al, al)) | 0 | |
35863 | this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0 | |
35864 | this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0 | |
35865 | this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0 | |
35866 | this._eh = (this._eh + eh + getCarry(this._el, el)) | 0 | |
35867 | this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0 | |
35868 | this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0 | |
35869 | this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0 | |
35870 | } | |
35871 | ||
35872 | Sha512.prototype._hash = function () { | |
35873 | var H = Buffer.allocUnsafe(64) | |
35874 | ||
35875 | function writeInt64BE (h, l, offset) { | |
35876 | H.writeInt32BE(h, offset) | |
35877 | H.writeInt32BE(l, offset + 4) | |
35878 | } | |
35879 | ||
35880 | writeInt64BE(this._ah, this._al, 0) | |
35881 | writeInt64BE(this._bh, this._bl, 8) | |
35882 | writeInt64BE(this._ch, this._cl, 16) | |
35883 | writeInt64BE(this._dh, this._dl, 24) | |
35884 | writeInt64BE(this._eh, this._el, 32) | |
35885 | writeInt64BE(this._fh, this._fl, 40) | |
35886 | writeInt64BE(this._gh, this._gl, 48) | |
35887 | writeInt64BE(this._hh, this._hl, 56) | |
35888 | ||
35889 | return H | |
35890 | } | |
35891 | ||
35892 | module.exports = Sha512 | |
35893 | ||
35894 | },{"./hash":399,"inherits":119,"safe-buffer":398}],407:[function(require,module,exports){ | |
35895 | "use strict"; | |
35896 | ||
35897 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
35898 | ||
35899 | 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; }; })(); | |
35900 | ||
35901 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
35902 | ||
35903 | Object.defineProperty(exports, "__esModule", { | |
35904 | value: true | |
35905 | }); | |
35906 | ||
35907 | var BigNumber = _interopRequire(require("bignumber.js")); | |
35908 | ||
35909 | var isString = _interopRequire(require("lodash/isString")); | |
35910 | ||
35911 | var Keypair = require("./keypair").Keypair; | |
35912 | ||
35913 | var StrKey = require("./strkey").StrKey; | |
35914 | ||
35915 | /** | |
35916 | * Create a new Account object. | |
35917 | * | |
35918 | * `Account` represents a single account in Stellar network and its sequence number. | |
35919 | * Account tracks the sequence number as it is used by {@link TransactionBuilder}. | |
35920 | * See [Accounts](https://stellar.org/developers/learn/concepts/accounts.html) for more information about how | |
35921 | * accounts work in Stellar. | |
35922 | * @constructor | |
35923 | * @param {string} accountId ID of the account (ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`) | |
35924 | * @param {string} sequence current sequence number of the account | |
35925 | */ | |
35926 | ||
35927 | var Account = exports.Account = (function () { | |
35928 | function Account(accountId, sequence) { | |
35929 | _classCallCheck(this, Account); | |
35930 | ||
35931 | if (!StrKey.isValidEd25519PublicKey(accountId)) { | |
35932 | throw new Error("accountId is invalid"); | |
35933 | } | |
35934 | if (!isString(sequence)) { | |
35935 | throw new Error("sequence must be of type string"); | |
35936 | } | |
35937 | this._accountId = accountId; | |
35938 | this.sequence = new BigNumber(sequence); | |
35939 | } | |
35940 | ||
35941 | _createClass(Account, { | |
35942 | accountId: { | |
35943 | ||
35944 | /** | |
35945 | * Returns Stellar account ID, ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA` | |
35946 | * @returns {string} | |
35947 | */ | |
35948 | ||
35949 | value: function accountId() { | |
35950 | return this._accountId; | |
35951 | } | |
35952 | }, | |
35953 | sequenceNumber: { | |
35954 | ||
35955 | /** | |
35956 | * @returns {string} | |
35957 | */ | |
35958 | ||
35959 | value: function sequenceNumber() { | |
35960 | return this.sequence.toString(); | |
35961 | } | |
35962 | }, | |
35963 | incrementSequenceNumber: { | |
35964 | ||
35965 | /** | |
35966 | * Increments sequence number in this object by one. | |
35967 | */ | |
35968 | ||
35969 | value: function incrementSequenceNumber() { | |
35970 | this.sequence = this.sequence.add(1); | |
35971 | } | |
35972 | } | |
35973 | }); | |
35974 | ||
35975 | return Account; | |
35976 | })(); | |
35977 | },{"./keypair":413,"./strkey":431,"bignumber.js":17,"lodash/isString":337}],408:[function(require,module,exports){ | |
35978 | "use strict"; | |
35979 | ||
35980 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
35981 | ||
35982 | 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; }; })(); | |
35983 | ||
35984 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
35985 | ||
35986 | Object.defineProperty(exports, "__esModule", { | |
35987 | value: true | |
35988 | }); | |
35989 | ||
35990 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | |
35991 | ||
35992 | var Keypair = require("./keypair").Keypair; | |
35993 | ||
35994 | var StrKey = require("./strkey").StrKey; | |
35995 | ||
35996 | var clone = _interopRequire(require("lodash/clone")); | |
35997 | ||
35998 | var padEnd = _interopRequire(require("lodash/padEnd")); | |
35999 | ||
36000 | var trimEnd = _interopRequire(require("lodash/trimEnd")); | |
36001 | ||
36002 | /** | |
36003 | * Asset class represents an asset, either the native asset (`XLM`) | |
36004 | * or an asset code / issuer account ID pair. | |
36005 | * | |
36006 | * An asset code describes an asset code and issuer pair. In the case of the native | |
36007 | * asset XLM, the issuer will be null. | |
36008 | * | |
36009 | * @constructor | |
36010 | * @param {string} code - The asset code. | |
36011 | * @param {string} issuer - The account ID of the issuer. | |
36012 | */ | |
36013 | ||
36014 | var Asset = exports.Asset = (function () { | |
36015 | function Asset(code, issuer) { | |
36016 | _classCallCheck(this, Asset); | |
36017 | ||
36018 | if (!/^[a-zA-Z0-9]{1,12}$/.test(code)) { | |
36019 | throw new Error("Asset code is invalid (maximum alphanumeric, 12 characters at max)"); | |
36020 | } | |
36021 | if (String(code).toLowerCase() !== "xlm" && !issuer) { | |
36022 | throw new Error("Issuer cannot be null"); | |
36023 | } | |
36024 | if (issuer && !StrKey.isValidEd25519PublicKey(issuer)) { | |
36025 | throw new Error("Issuer is invalid"); | |
36026 | } | |
36027 | ||
36028 | this.code = code; | |
36029 | this.issuer = issuer; | |
36030 | } | |
36031 | ||
36032 | _createClass(Asset, { | |
36033 | toXDRObject: { | |
36034 | ||
36035 | /** | |
36036 | * Returns the xdr object for this asset. | |
36037 | * @returns {xdr.Asset} | |
36038 | */ | |
36039 | ||
36040 | value: function toXDRObject() { | |
36041 | if (this.isNative()) { | |
36042 | return xdr.Asset.assetTypeNative(); | |
36043 | } | |
36044 | ||
36045 | var xdrType = undefined, | |
36046 | xdrTypeString = undefined; | |
36047 | if (this.code.length <= 4) { | |
36048 | xdrType = xdr.AssetAlphaNum4; | |
36049 | xdrTypeString = "assetTypeCreditAlphanum4"; | |
36050 | } else { | |
36051 | xdrType = xdr.AssetAlphaNum12; | |
36052 | xdrTypeString = "assetTypeCreditAlphanum12"; | |
36053 | } | |
36054 | ||
36055 | // pad code with null bytes if necessary | |
36056 | var padLength = this.code.length <= 4 ? 4 : 12; | |
36057 | var paddedCode = padEnd(this.code, padLength, "\u0000"); | |
36058 | ||
36059 | var assetType = new xdrType({ | |
36060 | assetCode: paddedCode, | |
36061 | issuer: Keypair.fromPublicKey(this.issuer).xdrAccountId() | |
36062 | }); | |
36063 | ||
36064 | return new xdr.Asset(xdrTypeString, assetType); | |
36065 | } | |
36066 | }, | |
36067 | getCode: { | |
36068 | ||
36069 | /** | |
36070 | * Return the asset code | |
36071 | * @returns {string} | |
36072 | */ | |
36073 | ||
36074 | value: function getCode() { | |
36075 | return clone(this.code); | |
36076 | } | |
36077 | }, | |
36078 | getIssuer: { | |
36079 | ||
36080 | /** | |
36081 | * Return the asset issuer | |
36082 | * @returns {string} | |
36083 | */ | |
36084 | ||
36085 | value: function getIssuer() { | |
36086 | return clone(this.issuer); | |
36087 | } | |
36088 | }, | |
36089 | getAssetType: { | |
36090 | ||
36091 | /** | |
36092 | * Return the asset type. Can be one of following types: | |
36093 | * | |
36094 | * * `native` | |
36095 | * * `credit_alphanum4` | |
36096 | * * `credit_alphanum12` | |
36097 | * | |
36098 | * @see [Assets concept](https://www.stellar.org/developers/learn/concepts/assets.html) | |
36099 | * @returns {string} | |
36100 | */ | |
36101 | ||
36102 | value: function getAssetType() { | |
36103 | if (this.isNative()) { | |
36104 | return "native"; | |
36105 | } | |
36106 | if (this.code.length >= 1 && this.code.length <= 4) { | |
36107 | return "credit_alphanum4"; | |
36108 | } | |
36109 | if (this.code.length >= 5 && this.code.length <= 12) { | |
36110 | return "credit_alphanum12"; | |
36111 | } | |
36112 | } | |
36113 | }, | |
36114 | isNative: { | |
36115 | ||
36116 | /** | |
36117 | * Returns true if this asset object is the native asset. | |
36118 | * @returns {boolean} | |
36119 | */ | |
36120 | ||
36121 | value: function isNative() { | |
36122 | return !this.issuer; | |
36123 | } | |
36124 | }, | |
36125 | equals: { | |
36126 | ||
36127 | /** | |
36128 | * Returns true if this asset equals the given asset. | |
36129 | * @param {Asset} asset Asset to compare | |
36130 | * @returns {boolean} | |
36131 | */ | |
36132 | ||
36133 | value: function equals(asset) { | |
36134 | return this.code == asset.getCode() && this.issuer == asset.getIssuer(); | |
36135 | } | |
36136 | } | |
36137 | }, { | |
36138 | native: { | |
36139 | ||
36140 | /** | |
36141 | * Returns an asset object for the native asset. | |
36142 | * @Return {Asset} | |
36143 | */ | |
36144 | ||
36145 | value: function native() { | |
36146 | return new Asset("XLM"); | |
36147 | } | |
36148 | }, | |
36149 | fromOperation: { | |
36150 | ||
36151 | /** | |
36152 | * Returns an asset object from its XDR object representation. | |
36153 | * @param {xdr.Asset} assetXdr - The asset xdr object. | |
36154 | * @returns {Asset} | |
36155 | */ | |
36156 | ||
36157 | value: function fromOperation(assetXdr) { | |
36158 | var anum = undefined, | |
36159 | code = undefined, | |
36160 | issuer = undefined; | |
36161 | switch (assetXdr["switch"]()) { | |
36162 | case xdr.AssetType.assetTypeNative(): | |
36163 | return this.native(); | |
36164 | case xdr.AssetType.assetTypeCreditAlphanum4(): | |
36165 | anum = assetXdr.alphaNum4(); | |
36166 | /* falls through */ | |
36167 | case xdr.AssetType.assetTypeCreditAlphanum12(): | |
36168 | anum = anum || assetXdr.alphaNum12(); | |
36169 | issuer = StrKey.encodeEd25519PublicKey(anum.issuer().ed25519()); | |
36170 | code = trimEnd(anum.assetCode(), "\u0000"); | |
36171 | return new this(code, issuer); | |
36172 | default: | |
36173 | throw new Error("Invalid asset type: " + assetXdr["switch"]().name); | |
36174 | } | |
36175 | } | |
36176 | } | |
36177 | }); | |
36178 | ||
36179 | return Asset; | |
36180 | })(); | |
36181 | },{"./generated/stellar-xdr_generated":410,"./keypair":413,"./strkey":431,"lodash/clone":310,"lodash/padEnd":345,"lodash/trimEnd":355}],409:[function(require,module,exports){ | |
36182 | (function (Buffer){ | |
36183 | "use strict"; | |
36184 | ||
36185 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
36186 | ||
36187 | exports.decodeBase58Check = decodeBase58Check; | |
36188 | Object.defineProperty(exports, "__esModule", { | |
36189 | value: true | |
36190 | }); | |
36191 | ||
36192 | var bs58 = _interopRequire(require("./vendor/bs58")); | |
36193 | ||
36194 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
36195 | ||
36196 | var hash = require("./hashing").hash; | |
36197 | ||
36198 | var verifyChecksum = require("./util/checksum").verifyChecksum; | |
36199 | ||
36200 | var versionBytes = { | |
36201 | accountId: 0, // decimal 0 | |
36202 | none: 1, // decimal 1 | |
36203 | seed: 33 }; | |
36204 | ||
36205 | function decodeBase58Check(versionByteName, encoded) { | |
36206 | var decoded = bs58.decode(encoded); | |
36207 | var versionByte = decoded[0]; | |
36208 | var payload = decoded.slice(0, decoded.length - 4); | |
36209 | var data = payload.slice(1); | |
36210 | var checksum = decoded.slice(decoded.length - 4); | |
36211 | ||
36212 | var expectedVersion = versionBytes[versionByteName]; | |
36213 | ||
36214 | if (isUndefined(expectedVersion)) { | |
36215 | throw new Error("" + versionByteName + " is not a valid version byte name. expected one of \"accountId\", \"seed\", or \"none\""); | |
36216 | } | |
36217 | ||
36218 | if (versionByte !== expectedVersion) { | |
36219 | throw new Error("invalid version byte. expected " + expectedVersion + ", got " + versionByte); | |
36220 | } | |
36221 | ||
36222 | var expectedChecksum = calculateChecksum(payload); | |
36223 | ||
36224 | if (!verifyChecksum(expectedChecksum, checksum)) { | |
36225 | throw new Error("invalid checksum"); | |
36226 | } | |
36227 | ||
36228 | if (versionByteName === "accountId" && decoded.length !== 37) { | |
36229 | throw new Error("Decoded address length is invalid. Expected 37, got " + decoded.length); | |
36230 | } | |
36231 | ||
36232 | return Buffer.from(data); | |
36233 | } | |
36234 | ||
36235 | function calculateChecksum(payload) { | |
36236 | var inner = hash(payload); | |
36237 | var outer = hash(inner); | |
36238 | return outer.slice(0, 4); | |
36239 | } | |
36240 | // decimal 33 | |
36241 | }).call(this,require("buffer").Buffer) | |
36242 | },{"./hashing":411,"./util/checksum":434,"./vendor/bs58":436,"buffer":50,"lodash/isUndefined":340}],410:[function(require,module,exports){ | |
36243 | "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; | |
36244 | },{"js-xdr":131}],411:[function(require,module,exports){ | |
36245 | "use strict"; | |
36246 | ||
36247 | exports.hash = hash; | |
36248 | Object.defineProperty(exports, "__esModule", { | |
36249 | value: true | |
36250 | }); | |
36251 | ||
36252 | var sha256 = require("sha.js").sha256; | |
36253 | ||
36254 | function hash(data) { | |
36255 | var hasher = new sha256(); | |
36256 | hasher.update(data, "utf8"); | |
36257 | return hasher.digest(); | |
36258 | } | |
36259 | },{"sha.js":400}],412:[function(require,module,exports){ | |
36260 | "use strict"; | |
36261 | ||
36262 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | |
36263 | ||
36264 | 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; }; | |
36265 | ||
36266 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
36267 | ||
36268 | Object.defineProperty(exports, "__esModule", { | |
36269 | value: true | |
36270 | }); | |
36271 | ||
36272 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | |
36273 | ||
36274 | exports.xdr = xdr; | |
36275 | exports.hash = require("./hashing").hash; | |
36276 | ||
36277 | var _signing = require("./signing"); | |
36278 | ||
36279 | exports.sign = _signing.sign; | |
36280 | exports.verify = _signing.verify; | |
36281 | exports.FastSigning = _signing.FastSigning; | |
36282 | exports.Keypair = require("./keypair").Keypair; | |
36283 | ||
36284 | var _jsXdr = require("js-xdr"); | |
36285 | ||
36286 | exports.UnsignedHyper = _jsXdr.UnsignedHyper; | |
36287 | exports.Hyper = _jsXdr.Hyper; | |
36288 | exports.Transaction = require("./transaction").Transaction; | |
36289 | ||
36290 | var _transaction_builder = require("./transaction_builder"); | |
36291 | ||
36292 | exports.TransactionBuilder = _transaction_builder.TransactionBuilder; | |
36293 | exports.TimeoutInfinite = _transaction_builder.TimeoutInfinite; | |
36294 | exports.Asset = require("./asset").Asset; | |
36295 | ||
36296 | var _operation = require("./operation"); | |
36297 | ||
36298 | exports.Operation = _operation.Operation; | |
36299 | exports.AuthRequiredFlag = _operation.AuthRequiredFlag; | |
36300 | exports.AuthRevocableFlag = _operation.AuthRevocableFlag; | |
36301 | exports.AuthImmutableFlag = _operation.AuthImmutableFlag; | |
36302 | ||
36303 | _defaults(exports, _interopRequireWildcard(require("./memo"))); | |
36304 | ||
36305 | exports.Account = require("./account").Account; | |
36306 | ||
36307 | var _network = require("./network"); | |
36308 | ||
36309 | exports.Network = _network.Network; | |
36310 | exports.Networks = _network.Networks; | |
36311 | exports.StrKey = require("./strkey").StrKey; | |
36312 | exports["default"] = module.exports; | |
36313 | },{"./account":407,"./asset":408,"./generated/stellar-xdr_generated":410,"./hashing":411,"./keypair":413,"./memo":414,"./network":415,"./operation":416,"./signing":430,"./strkey":431,"./transaction":432,"./transaction_builder":433,"js-xdr":131}],413:[function(require,module,exports){ | |
36314 | (function (Buffer){ | |
36315 | "use strict"; | |
36316 | ||
36317 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
36318 | ||
36319 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | |
36320 | ||
36321 | 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; }; })(); | |
36322 | ||
36323 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
36324 | ||
36325 | Object.defineProperty(exports, "__esModule", { | |
36326 | value: true | |
36327 | }); | |
36328 | ||
36329 | var Network = require("./network").Network; | |
36330 | ||
36331 | var _signing = require("./signing"); | |
36332 | ||
36333 | var sign = _signing.sign; | |
36334 | var verify = _signing.verify; | |
36335 | ||
36336 | var base58 = _interopRequireWildcard(require("./base58")); | |
36337 | ||
36338 | var StrKey = require("./strkey").StrKey; | |
36339 | ||
36340 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | |
36341 | ||
36342 | var nacl = _interopRequire(require("tweetnacl")); | |
36343 | ||
36344 | /** | |
36345 | * `Keypair` represents public (and secret) keys of the account. | |
36346 | * | |
36347 | * Currently `Keypair` only supports ed25519 but in a future this class can be abstraction layer for other | |
36348 | * public-key signature systems. | |
36349 | * | |
36350 | * Use more convenient methods to create `Keypair` object: | |
36351 | * * `{@link Keypair.fromPublicKey}` | |
36352 | * * `{@link Keypair.fromSecret}` | |
36353 | * * `{@link Keypair.random}` | |
36354 | * | |
36355 | * @constructor | |
36356 | * @param {object} keys At least one of keys must be provided. | |
36357 | * @param {string} keys.type Public-key signature system name. (currently only `ed25519` keys are supported) | |
36358 | * @param {Buffer} [keys.publicKey] Raw public key | |
36359 | * @param {Buffer} [keys.secretKey] Raw secret key (32-byte secret seed in ed25519`) | |
36360 | */ | |
36361 | ||
36362 | var Keypair = exports.Keypair = (function () { | |
36363 | function Keypair(keys) { | |
36364 | _classCallCheck(this, Keypair); | |
36365 | ||
36366 | if (keys.type != "ed25519") { | |
36367 | throw new Error("Invalid keys type"); | |
36368 | } | |
36369 | ||
36370 | this.type = keys.type; | |
36371 | ||
36372 | if (keys.secretKey) { | |
36373 | keys.secretKey = Buffer.from(keys.secretKey); | |
36374 | ||
36375 | if (keys.secretKey.length != 32) { | |
36376 | throw new Error("secretKey length is invalid"); | |
36377 | } | |
36378 | ||
36379 | var secretKeyUint8 = new Uint8Array(keys.secretKey); | |
36380 | var naclKeys = nacl.sign.keyPair.fromSeed(secretKeyUint8); | |
36381 | ||
36382 | this._secretSeed = keys.secretKey; | |
36383 | this._secretKey = Buffer.from(naclKeys.secretKey); | |
36384 | this._publicKey = Buffer.from(naclKeys.publicKey); | |
36385 | ||
36386 | if (keys.publicKey && !this._publicKey.equals(Buffer.from(keys.publicKey))) { | |
36387 | throw new Error("secretKey does not match publicKey"); | |
36388 | } | |
36389 | } else { | |
36390 | this._publicKey = Buffer.from(keys.publicKey); | |
36391 | ||
36392 | if (this._publicKey.length != 32) { | |
36393 | throw new Error("publicKey length is invalid"); | |
36394 | } | |
36395 | } | |
36396 | } | |
36397 | ||
36398 | _createClass(Keypair, { | |
36399 | xdrAccountId: { | |
36400 | value: function xdrAccountId() { | |
36401 | return new xdr.AccountId.publicKeyTypeEd25519(this._publicKey); | |
36402 | } | |
36403 | }, | |
36404 | xdrPublicKey: { | |
36405 | value: function xdrPublicKey() { | |
36406 | return new xdr.PublicKey.publicKeyTypeEd25519(this._publicKey); | |
36407 | } | |
36408 | }, | |
36409 | rawPublicKey: { | |
36410 | ||
36411 | /** | |
36412 | * Returns raw public key | |
36413 | * @returns {Buffer} | |
36414 | */ | |
36415 | ||
36416 | value: function rawPublicKey() { | |
36417 | return this._publicKey; | |
36418 | } | |
36419 | }, | |
36420 | signatureHint: { | |
36421 | value: function signatureHint() { | |
36422 | var a = this.xdrAccountId().toXDR(); | |
36423 | ||
36424 | return a.slice(a.length - 4); | |
36425 | } | |
36426 | }, | |
36427 | publicKey: { | |
36428 | ||
36429 | /** | |
36430 | * Returns public key associated with this `Keypair` object. | |
36431 | * @returns {string} | |
36432 | */ | |
36433 | ||
36434 | value: function publicKey() { | |
36435 | return StrKey.encodeEd25519PublicKey(this._publicKey); | |
36436 | } | |
36437 | }, | |
36438 | secret: { | |
36439 | ||
36440 | /** | |
36441 | * Returns secret key associated with this `Keypair` object | |
36442 | * @returns {string} | |
36443 | */ | |
36444 | ||
36445 | value: function secret() { | |
36446 | if (!this._secretSeed) { | |
36447 | throw new Error("no secret key available"); | |
36448 | } | |
36449 | ||
36450 | if (this.type == "ed25519") { | |
36451 | return StrKey.encodeEd25519SecretSeed(this._secretSeed); | |
36452 | } | |
36453 | ||
36454 | throw new Error("Invalid Keypair type"); | |
36455 | } | |
36456 | }, | |
36457 | rawSecretKey: { | |
36458 | ||
36459 | /** | |
36460 | * Returns raw secret key. | |
36461 | * @returns {Buffer} | |
36462 | */ | |
36463 | ||
36464 | value: function rawSecretKey() { | |
36465 | return this._secretSeed; | |
36466 | } | |
36467 | }, | |
36468 | canSign: { | |
36469 | ||
36470 | /** | |
36471 | * Returns `true` if this `Keypair` object contains secret key and can sign. | |
36472 | * @returns {boolean} | |
36473 | */ | |
36474 | ||
36475 | value: function canSign() { | |
36476 | return !!this._secretKey; | |
36477 | } | |
36478 | }, | |
36479 | sign: { | |
36480 | ||
36481 | /** | |
36482 | * Signs data. | |
36483 | * @param {Buffer} data Data to sign | |
36484 | * @returns {Buffer} | |
36485 | */ | |
36486 | ||
36487 | value: (function (_sign) { | |
36488 | var _signWrapper = function sign(_x) { | |
36489 | return _sign.apply(this, arguments); | |
36490 | }; | |
36491 | ||
36492 | _signWrapper.toString = function () { | |
36493 | return _sign.toString(); | |
36494 | }; | |
36495 | ||
36496 | return _signWrapper; | |
36497 | })(function (data) { | |
36498 | if (!this.canSign()) { | |
36499 | throw new Error("cannot sign: no secret key available"); | |
36500 | } | |
36501 | ||
36502 | return sign(data, this._secretKey); | |
36503 | }) | |
36504 | }, | |
36505 | verify: { | |
36506 | ||
36507 | /** | |
36508 | * Verifies if `signature` for `data` is valid. | |
36509 | * @param {Buffer} data Signed data | |
36510 | * @param {Buffer} signature Signature | |
36511 | * @returns {boolean} | |
36512 | */ | |
36513 | ||
36514 | value: (function (_verify) { | |
36515 | var _verifyWrapper = function verify(_x2, _x3) { | |
36516 | return _verify.apply(this, arguments); | |
36517 | }; | |
36518 | ||
36519 | _verifyWrapper.toString = function () { | |
36520 | return _verify.toString(); | |
36521 | }; | |
36522 | ||
36523 | return _verifyWrapper; | |
36524 | })(function (data, signature) { | |
36525 | return verify(data, signature, this._publicKey); | |
36526 | }) | |
36527 | }, | |
36528 | signDecorated: { | |
36529 | value: function signDecorated(data) { | |
36530 | var signature = this.sign(data); | |
36531 | var hint = this.signatureHint(); | |
36532 | ||
36533 | return new xdr.DecoratedSignature({ hint: hint, signature: signature }); | |
36534 | } | |
36535 | } | |
36536 | }, { | |
36537 | fromSecret: { | |
36538 | ||
36539 | /** | |
36540 | * Creates a new `Keypair` instance from secret. This can either be secret key or secret seed depending | |
36541 | * on underlying public-key signature system. Currently `Keypair` only supports ed25519. | |
36542 | * @param {string} secret secret key (ex. `SDAKFNYEIAORZKKCYRILFQKLLOCNPL5SWJ3YY5NM3ZH6GJSZGXHZEPQS`) | |
36543 | * @returns {Keypair} | |
36544 | */ | |
36545 | ||
36546 | value: function fromSecret(secret) { | |
36547 | var rawSecret = StrKey.decodeEd25519SecretSeed(secret); | |
36548 | return this.fromRawEd25519Seed(rawSecret); | |
36549 | } | |
36550 | }, | |
36551 | fromBase58Seed: { | |
36552 | ||
36553 | /** | |
36554 | * Base58 address encoding is **DEPRECATED**! Use this method only for transition to strkey encoding. | |
36555 | * @param {string} seed Base58 secret seed | |
36556 | * @deprecated Use {@link Keypair.fromSecret} | |
36557 | * @returns {Keypair} | |
36558 | */ | |
36559 | ||
36560 | value: function fromBase58Seed(seed) { | |
36561 | var rawSeed = base58.decodeBase58Check("seed", seed); | |
36562 | return this.fromRawEd25519Seed(rawSeed); | |
36563 | } | |
36564 | }, | |
36565 | fromRawEd25519Seed: { | |
36566 | ||
36567 | /** | |
36568 | * Creates a new `Keypair` object from ed25519 secret key seed raw bytes. | |
36569 | * | |
36570 | * @param {Buffer} rawSeed Raw 32-byte ed25519 secret key seed | |
36571 | * @returns {Keypair} | |
36572 | */ | |
36573 | ||
36574 | value: function fromRawEd25519Seed(rawSeed) { | |
36575 | return new this({ type: "ed25519", secretKey: rawSeed }); | |
36576 | } | |
36577 | }, | |
36578 | master: { | |
36579 | ||
36580 | /** | |
36581 | * Returns `Keypair` object representing network master key. | |
36582 | * @returns {Keypair} | |
36583 | */ | |
36584 | ||
36585 | value: function master() { | |
36586 | if (Network.current() === null) { | |
36587 | throw new Error("No network selected. Use `Network.use`, `Network.usePublicNetwork` or `Network.useTestNetwork` helper methods to select network."); | |
36588 | } | |
36589 | return this.fromRawEd25519Seed(Network.current().networkId()); | |
36590 | } | |
36591 | }, | |
36592 | fromPublicKey: { | |
36593 | ||
36594 | /** | |
36595 | * Creates a new `Keypair` object from public key. | |
36596 | * @param {string} publicKey public key (ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`) | |
36597 | * @returns {Keypair} | |
36598 | */ | |
36599 | ||
36600 | value: function fromPublicKey(publicKey) { | |
36601 | publicKey = StrKey.decodeEd25519PublicKey(publicKey); | |
36602 | if (publicKey.length !== 32) { | |
36603 | throw new Error("Invalid Stellar public key"); | |
36604 | } | |
36605 | return new this({ type: "ed25519", publicKey: publicKey }); | |
36606 | } | |
36607 | }, | |
36608 | random: { | |
36609 | ||
36610 | /** | |
36611 | * Create a random `Keypair` object. | |
36612 | * @returns {Keypair} | |
36613 | */ | |
36614 | ||
36615 | value: function random() { | |
36616 | var secret = nacl.randomBytes(32); | |
36617 | return this.fromRawEd25519Seed(secret); | |
36618 | } | |
36619 | } | |
36620 | }); | |
36621 | ||
36622 | return Keypair; | |
36623 | })(); | |
36624 | }).call(this,require("buffer").Buffer) | |
36625 | },{"./base58":409,"./generated/stellar-xdr_generated":410,"./network":415,"./signing":430,"./strkey":431,"buffer":50,"tweetnacl":440}],414:[function(require,module,exports){ | |
36626 | (function (Buffer){ | |
36627 | "use strict"; | |
36628 | ||
36629 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
36630 | ||
36631 | 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; }; })(); | |
36632 | ||
36633 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
36634 | ||
36635 | Object.defineProperty(exports, "__esModule", { | |
36636 | value: true | |
36637 | }); | |
36638 | ||
36639 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | |
36640 | ||
36641 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
36642 | ||
36643 | var isNull = _interopRequire(require("lodash/isNull")); | |
36644 | ||
36645 | var isString = _interopRequire(require("lodash/isString")); | |
36646 | ||
36647 | var clone = _interopRequire(require("lodash/clone")); | |
36648 | ||
36649 | var UnsignedHyper = require("js-xdr").UnsignedHyper; | |
36650 | ||
36651 | var BigNumber = _interopRequire(require("bignumber.js")); | |
36652 | ||
36653 | /** | |
36654 | * Type of {@link Memo}. | |
36655 | */ | |
36656 | var MemoNone = "none"; | |
36657 | exports.MemoNone = MemoNone; | |
36658 | /** | |
36659 | * Type of {@link Memo}. | |
36660 | */ | |
36661 | var MemoID = "id"; | |
36662 | exports.MemoID = MemoID; | |
36663 | /** | |
36664 | * Type of {@link Memo}. | |
36665 | */ | |
36666 | var MemoText = "text"; | |
36667 | exports.MemoText = MemoText; | |
36668 | /** | |
36669 | * Type of {@link Memo}. | |
36670 | */ | |
36671 | var MemoHash = "hash"; | |
36672 | exports.MemoHash = MemoHash; | |
36673 | /** | |
36674 | * Type of {@link Memo}. | |
36675 | */ | |
36676 | var MemoReturn = "return"; | |
36677 | ||
36678 | exports.MemoReturn = MemoReturn; | |
36679 | /** | |
36680 | * `Memo` represents memos attached to transactions. | |
36681 | * | |
36682 | * @param {string} type - `MemoNone`, `MemoID`, `MemoText`, `MemoHash` or `MemoReturn` | |
36683 | * @param {*} value - `string` for `MemoID`, `MemoText`, buffer of hex string for `MemoHash` or `MemoReturn` | |
36684 | * @see [Transactions concept](https://www.stellar.org/developers/learn/concepts/transactions.html) | |
36685 | * @class Memo | |
36686 | */ | |
36687 | ||
36688 | var Memo = exports.Memo = (function () { | |
36689 | function Memo(type) { | |
36690 | var value = arguments[1] === undefined ? null : arguments[1]; | |
36691 | ||
36692 | _classCallCheck(this, Memo); | |
36693 | ||
36694 | this._type = type; | |
36695 | this._value = value; | |
36696 | ||
36697 | switch (this._type) { | |
36698 | case MemoNone: | |
36699 | break; | |
36700 | case MemoID: | |
36701 | Memo._validateIdValue(value); | |
36702 | break; | |
36703 | case MemoText: | |
36704 | Memo._validateTextValue(value); | |
36705 | break; | |
36706 | case MemoHash: | |
36707 | case MemoReturn: | |
36708 | Memo._validateHashValue(value); | |
36709 | // We want MemoHash and MemoReturn to have Buffer as a value | |
36710 | if (isString(value)) { | |
36711 | this._value = Buffer.from(value, "hex"); | |
36712 | } | |
36713 | break; | |
36714 | default: | |
36715 | throw new Error("Invalid memo type"); | |
36716 | } | |
36717 | } | |
36718 | ||
36719 | _createClass(Memo, { | |
36720 | type: { | |
36721 | ||
36722 | /** | |
36723 | * Contains memo type: `MemoNone`, `MemoID`, `MemoText`, `MemoHash` or `MemoReturn` | |
36724 | */ | |
36725 | ||
36726 | get: function () { | |
36727 | return clone(this._type); | |
36728 | }, | |
36729 | set: function (type) { | |
36730 | throw new Error("Memo is immutable"); | |
36731 | } | |
36732 | }, | |
36733 | value: { | |
36734 | ||
36735 | /** | |
36736 | * Contains memo value: | |
36737 | * * `null` for `MemoNone`, | |
36738 | * * `string` for `MemoID`, | |
36739 | * * `Buffer` for `MemoText` after decoding using `fromXDRObject`, original value otherwise, | |
36740 | * * `Buffer` for `MemoHash`, `MemoReturn`. | |
36741 | */ | |
36742 | ||
36743 | get: function () { | |
36744 | switch (this._type) { | |
36745 | case MemoNone: | |
36746 | return null; | |
36747 | case MemoID: | |
36748 | case MemoText: | |
36749 | return clone(this._value); | |
36750 | case MemoHash: | |
36751 | case MemoReturn: | |
36752 | return Buffer.from(this._value); | |
36753 | default: | |
36754 | throw new Error("Invalid memo type"); | |
36755 | } | |
36756 | }, | |
36757 | set: function (value) { | |
36758 | throw new Error("Memo is immutable"); | |
36759 | } | |
36760 | }, | |
36761 | toXDRObject: { | |
36762 | ||
36763 | /** | |
36764 | * Returns XDR memo object. | |
36765 | * @returns {xdr.Memo} | |
36766 | */ | |
36767 | ||
36768 | value: function toXDRObject() { | |
36769 | switch (this._type) { | |
36770 | case MemoNone: | |
36771 | return xdr.Memo.memoNone(); | |
36772 | case MemoID: | |
36773 | return xdr.Memo.memoId(UnsignedHyper.fromString(this._value)); | |
36774 | case MemoText: | |
36775 | return xdr.Memo.memoText(this._value); | |
36776 | case MemoHash: | |
36777 | return xdr.Memo.memoHash(this._value); | |
36778 | case MemoReturn: | |
36779 | return xdr.Memo.memoReturn(this._value); | |
36780 | } | |
36781 | } | |
36782 | } | |
36783 | }, { | |
36784 | _validateIdValue: { | |
36785 | value: function _validateIdValue(value) { | |
36786 | var error = new Error("Expects a int64 as a string. Got " + value); | |
36787 | ||
36788 | if (!isString(value)) { | |
36789 | throw error; | |
36790 | } | |
36791 | ||
36792 | var number = undefined; | |
36793 | try { | |
36794 | number = new BigNumber(value); | |
36795 | } catch (e) { | |
36796 | throw error; | |
36797 | } | |
36798 | ||
36799 | // Infinity | |
36800 | if (!number.isFinite()) { | |
36801 | throw error; | |
36802 | } | |
36803 | ||
36804 | // NaN | |
36805 | if (number.isNaN()) { | |
36806 | throw error; | |
36807 | } | |
36808 | } | |
36809 | }, | |
36810 | _validateTextValue: { | |
36811 | value: function _validateTextValue(value) { | |
36812 | if (!xdr.Memo.armTypeForArm("text").isValid(value)) { | |
36813 | throw new Error("Expects string, array or buffer, max 28 bytes"); | |
36814 | } | |
36815 | } | |
36816 | }, | |
36817 | _validateHashValue: { | |
36818 | value: function _validateHashValue(value) { | |
36819 | var error = new Error("Expects a 32 byte hash value or hex encoded string. Got " + value); | |
36820 | ||
36821 | if (value === null || isUndefined(value)) { | |
36822 | throw error; | |
36823 | } | |
36824 | ||
36825 | var valueBuffer = undefined; | |
36826 | if (isString(value)) { | |
36827 | if (!/^[0-9A-Fa-f]{64}$/g.test(value)) { | |
36828 | throw error; | |
36829 | } | |
36830 | valueBuffer = Buffer.from(value, "hex"); | |
36831 | } else if (Buffer.isBuffer(value)) { | |
36832 | valueBuffer = Buffer.from(value); | |
36833 | } else { | |
36834 | throw error; | |
36835 | } | |
36836 | ||
36837 | if (!valueBuffer.length || valueBuffer.length != 32) { | |
36838 | throw error; | |
36839 | } | |
36840 | } | |
36841 | }, | |
36842 | none: { | |
36843 | ||
36844 | /** | |
36845 | * Returns an empty memo (`MemoNone`). | |
36846 | * @returns {Memo} | |
36847 | */ | |
36848 | ||
36849 | value: function none() { | |
36850 | return new Memo(MemoNone); | |
36851 | } | |
36852 | }, | |
36853 | text: { | |
36854 | ||
36855 | /** | |
36856 | * Creates and returns a `MemoText` memo. | |
36857 | * @param {string} text - memo text | |
36858 | * @returns {Memo} | |
36859 | */ | |
36860 | ||
36861 | value: (function (_text) { | |
36862 | var _textWrapper = function text(_x) { | |
36863 | return _text.apply(this, arguments); | |
36864 | }; | |
36865 | ||
36866 | _textWrapper.toString = function () { | |
36867 | return _text.toString(); | |
36868 | }; | |
36869 | ||
36870 | return _textWrapper; | |
36871 | })(function (text) { | |
36872 | return new Memo(MemoText, text); | |
36873 | }) | |
36874 | }, | |
36875 | id: { | |
36876 | ||
36877 | /** | |
36878 | * Creates and returns a `MemoID` memo. | |
36879 | * @param {string} id - 64-bit number represented as a string | |
36880 | * @returns {Memo} | |
36881 | */ | |
36882 | ||
36883 | value: (function (_id) { | |
36884 | var _idWrapper = function id(_x2) { | |
36885 | return _id.apply(this, arguments); | |
36886 | }; | |
36887 | ||
36888 | _idWrapper.toString = function () { | |
36889 | return _id.toString(); | |
36890 | }; | |
36891 | ||
36892 | return _idWrapper; | |
36893 | })(function (id) { | |
36894 | return new Memo(MemoID, id); | |
36895 | }) | |
36896 | }, | |
36897 | hash: { | |
36898 | ||
36899 | /** | |
36900 | * Creates and returns a `MemoHash` memo. | |
36901 | * @param {array|string} hash - 32 byte hash or hex encoded string | |
36902 | * @returns {Memo} | |
36903 | */ | |
36904 | ||
36905 | value: (function (_hash) { | |
36906 | var _hashWrapper = function hash(_x3) { | |
36907 | return _hash.apply(this, arguments); | |
36908 | }; | |
36909 | ||
36910 | _hashWrapper.toString = function () { | |
36911 | return _hash.toString(); | |
36912 | }; | |
36913 | ||
36914 | return _hashWrapper; | |
36915 | })(function (hash) { | |
36916 | return new Memo(MemoHash, hash); | |
36917 | }) | |
36918 | }, | |
36919 | "return": { | |
36920 | ||
36921 | /** | |
36922 | * Creates and returns a `MemoReturn` memo. | |
36923 | * @param {array|string} hash - 32 byte hash or hex encoded string | |
36924 | * @returns {Memo} | |
36925 | */ | |
36926 | ||
36927 | value: function _return(hash) { | |
36928 | return new Memo(MemoReturn, hash); | |
36929 | } | |
36930 | }, | |
36931 | fromXDRObject: { | |
36932 | ||
36933 | /** | |
36934 | * Returns {@link Memo} from XDR memo object. | |
36935 | * @param {xdr.Memo} | |
36936 | * @returns {Memo} | |
36937 | */ | |
36938 | ||
36939 | value: function fromXDRObject(object) { | |
36940 | switch (object.arm()) { | |
36941 | case "id": | |
36942 | return Memo.id(object.value().toString()); | |
36943 | case "text": | |
36944 | return Memo.text(object.value()); | |
36945 | case "hash": | |
36946 | return Memo.hash(object.value()); | |
36947 | case "retHash": | |
36948 | return Memo["return"](object.value()); | |
36949 | } | |
36950 | ||
36951 | if (typeof object.value() === "undefined") { | |
36952 | return Memo.none(); | |
36953 | } | |
36954 | ||
36955 | throw new Error("Unknown type"); | |
36956 | } | |
36957 | } | |
36958 | }); | |
36959 | ||
36960 | return Memo; | |
36961 | })(); | |
36962 | }).call(this,require("buffer").Buffer) | |
36963 | },{"./generated/stellar-xdr_generated":410,"bignumber.js":17,"buffer":50,"js-xdr":131,"lodash/clone":310,"lodash/isNull":331,"lodash/isString":337,"lodash/isUndefined":340}],415:[function(require,module,exports){ | |
36964 | "use strict"; | |
36965 | ||
36966 | 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; }; })(); | |
36967 | ||
36968 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
36969 | ||
36970 | Object.defineProperty(exports, "__esModule", { | |
36971 | value: true | |
36972 | }); | |
36973 | ||
36974 | var hash = require("./hashing").hash; | |
36975 | ||
36976 | /** | |
36977 | * Contains passphrases for common networks: | |
36978 | * * `Networks.PUBLIC`: `Public Global Stellar Network ; September 2015` | |
36979 | * * `Networks.TESTNET`: `Test SDF Network ; September 2015` | |
36980 | * @type {{PUBLIC: string, TESTNET: string}} | |
36981 | */ | |
36982 | var Networks = { | |
36983 | PUBLIC: "Public Global Stellar Network ; September 2015", | |
36984 | TESTNET: "Test SDF Network ; September 2015" | |
36985 | }; | |
36986 | ||
36987 | exports.Networks = Networks; | |
36988 | var current = null; | |
36989 | ||
36990 | /** | |
36991 | * The Network class provides helper methods to get the passphrase or id for different | |
36992 | * stellar networks. It also provides the {@link Network.current} class method that returns the network | |
36993 | * that will be used by this process for the purposes of generating signatures. | |
36994 | * | |
36995 | * You should select network your app will use before adding the first signature. You can use the `use`, | |
36996 | * `usePublicNetwork` and `useTestNetwork` helper methods. | |
36997 | * | |
36998 | * Creates a new `Network` object. | |
36999 | * @constructor | |
37000 | * @param {string} networkPassphrase Network passphrase | |
37001 | */ | |
37002 | ||
37003 | var Network = exports.Network = (function () { | |
37004 | function Network(networkPassphrase) { | |
37005 | _classCallCheck(this, Network); | |
37006 | ||
37007 | this._networkPassphrase = networkPassphrase; | |
37008 | } | |
37009 | ||
37010 | _createClass(Network, { | |
37011 | networkPassphrase: { | |
37012 | ||
37013 | /** | |
37014 | * Returns network passphrase. | |
37015 | * @returns {string} | |
37016 | */ | |
37017 | ||
37018 | value: function networkPassphrase() { | |
37019 | return this._networkPassphrase; | |
37020 | } | |
37021 | }, | |
37022 | networkId: { | |
37023 | ||
37024 | /** | |
37025 | * Returns Network ID. Network ID is SHA-256 hash of network passphrase. | |
37026 | * @returns {string} | |
37027 | */ | |
37028 | ||
37029 | value: function networkId() { | |
37030 | return hash(this.networkPassphrase()); | |
37031 | } | |
37032 | } | |
37033 | }, { | |
37034 | usePublicNetwork: { | |
37035 | ||
37036 | /** | |
37037 | * Use Stellar Public Network | |
37038 | */ | |
37039 | ||
37040 | value: function usePublicNetwork() { | |
37041 | this.use(new Network(Networks.PUBLIC)); | |
37042 | } | |
37043 | }, | |
37044 | useTestNetwork: { | |
37045 | ||
37046 | /** | |
37047 | * Use test network. | |
37048 | */ | |
37049 | ||
37050 | value: function useTestNetwork() { | |
37051 | this.use(new Network(Networks.TESTNET)); | |
37052 | } | |
37053 | }, | |
37054 | use: { | |
37055 | ||
37056 | /** | |
37057 | * Use network defined by Network object. | |
37058 | * @param {Network} network Network to use | |
37059 | */ | |
37060 | ||
37061 | value: function use(network) { | |
37062 | current = network; | |
37063 | } | |
37064 | }, | |
37065 | current: { | |
37066 | ||
37067 | /** | |
37068 | * Returns currently selected network. | |
37069 | * @returns {Network} | |
37070 | */ | |
37071 | ||
37072 | value: (function (_current) { | |
37073 | var _currentWrapper = function current() { | |
37074 | return _current.apply(this, arguments); | |
37075 | }; | |
37076 | ||
37077 | _currentWrapper.toString = function () { | |
37078 | return _current.toString(); | |
37079 | }; | |
37080 | ||
37081 | return _currentWrapper; | |
37082 | })(function () { | |
37083 | return current; | |
37084 | }) | |
37085 | } | |
37086 | }); | |
37087 | ||
37088 | return Network; | |
37089 | })(); | |
37090 | },{"./hashing":411}],416:[function(require,module,exports){ | |
37091 | "use strict"; | |
37092 | ||
37093 | var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; }; | |
37094 | ||
37095 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37096 | ||
37097 | 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; }; })(); | |
37098 | ||
37099 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
37100 | ||
37101 | Object.defineProperty(exports, "__esModule", { | |
37102 | value: true | |
37103 | }); | |
37104 | ||
37105 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | |
37106 | ||
37107 | var Keypair = require("./keypair").Keypair; | |
37108 | ||
37109 | var hash = require("./hashing").hash; | |
37110 | ||
37111 | var StrKey = require("./strkey").StrKey; | |
37112 | ||
37113 | var Hyper = require("js-xdr").Hyper; | |
37114 | ||
37115 | var Asset = require("./asset").Asset; | |
37116 | ||
37117 | var BigNumber = _interopRequire(require("bignumber.js")); | |
37118 | ||
37119 | var best_r = require("./util/continued_fraction").best_r; | |
37120 | ||
37121 | var trimEnd = _interopRequire(require("lodash/trimEnd")); | |
37122 | ||
37123 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
37124 | ||
37125 | var isString = _interopRequire(require("lodash/isString")); | |
37126 | ||
37127 | var isNumber = _interopRequire(require("lodash/isNumber")); | |
37128 | ||
37129 | var isFinite = _interopRequire(require("lodash/isFinite")); | |
37130 | ||
37131 | var ops = _interopRequireWildcard(require("./operations/index")); | |
37132 | ||
37133 | var ONE = 10000000; | |
37134 | var MAX_INT64 = "9223372036854775807"; | |
37135 | ||
37136 | /** | |
37137 | * When set using `{@link Operation.setOptions}` option, requires the issuing account to | |
37138 | * give other accounts permission before they can hold the issuing account’s credit. | |
37139 | * @constant | |
37140 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | |
37141 | */ | |
37142 | var AuthRequiredFlag = 1 << 0; | |
37143 | exports.AuthRequiredFlag = AuthRequiredFlag; | |
37144 | /** | |
37145 | * When set using `{@link Operation.setOptions}` option, allows the issuing account to | |
37146 | * revoke its credit held by other accounts. | |
37147 | * @constant | |
37148 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | |
37149 | */ | |
37150 | var AuthRevocableFlag = 1 << 1; | |
37151 | exports.AuthRevocableFlag = AuthRevocableFlag; | |
37152 | /** | |
37153 | * When set using `{@link Operation.setOptions}` option, then none of the authorization flags | |
37154 | * can be set and the account can never be deleted. | |
37155 | * @constant | |
37156 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | |
37157 | */ | |
37158 | var AuthImmutableFlag = 1 << 2; | |
37159 | ||
37160 | exports.AuthImmutableFlag = AuthImmutableFlag; | |
37161 | /** | |
37162 | * `Operation` class represents [operations](https://www.stellar.org/developers/learn/concepts/operations.html) in Stellar network. | |
37163 | * Use one of static methods to create operations: | |
37164 | * * `{@link Operation.createAccount}` | |
37165 | * * `{@link Operation.payment}` | |
37166 | * * `{@link Operation.pathPayment}` | |
37167 | * * `{@link Operation.manageOffer}` | |
37168 | * * `{@link Operation.createPassiveOffer}` | |
37169 | * * `{@link Operation.setOptions}` | |
37170 | * * `{@link Operation.changeTrust}` | |
37171 | * * `{@link Operation.allowTrust}` | |
37172 | * * `{@link Operation.accountMerge}` | |
37173 | * * `{@link Operation.inflation}` | |
37174 | * * `{@link Operation.manageData}` | |
37175 | * * `{@link Operation.bumpSequence}` | |
37176 | * | |
37177 | * @class Operation | |
37178 | */ | |
37179 | ||
37180 | var Operation = exports.Operation = (function () { | |
37181 | function Operation() { | |
37182 | _classCallCheck(this, Operation); | |
37183 | } | |
37184 | ||
37185 | _createClass(Operation, null, { | |
37186 | setSourceAccount: { | |
37187 | value: function setSourceAccount(opAttributes, opts) { | |
37188 | if (opts.source) { | |
37189 | if (!StrKey.isValidEd25519PublicKey(opts.source)) { | |
37190 | throw new Error("Source address is invalid"); | |
37191 | } | |
37192 | opAttributes.sourceAccount = Keypair.fromPublicKey(opts.source).xdrAccountId(); | |
37193 | } | |
37194 | } | |
37195 | }, | |
37196 | fromXDRObject: { | |
37197 | ||
37198 | /** | |
37199 | * Converts the XDR Operation object to the opts object used to create the XDR | |
37200 | * operation. | |
37201 | * @param {xdr.Operation} operation - An XDR Operation. | |
37202 | * @return {Operation} | |
37203 | */ | |
37204 | ||
37205 | value: function fromXDRObject(operation) { | |
37206 | function accountIdtoAddress(accountId) { | |
37207 | return StrKey.encodeEd25519PublicKey(accountId.ed25519()); | |
37208 | } | |
37209 | ||
37210 | var result = {}; | |
37211 | if (operation.sourceAccount()) { | |
37212 | result.source = accountIdtoAddress(operation.sourceAccount()); | |
37213 | } | |
37214 | ||
37215 | var attrs = operation.body().value(); | |
37216 | switch (operation.body()["switch"]().name) { | |
37217 | case "createAccount": | |
37218 | result.type = "createAccount"; | |
37219 | result.destination = accountIdtoAddress(attrs.destination()); | |
37220 | result.startingBalance = this._fromXDRAmount(attrs.startingBalance()); | |
37221 | break; | |
37222 | case "payment": | |
37223 | result.type = "payment"; | |
37224 | result.destination = accountIdtoAddress(attrs.destination()); | |
37225 | result.asset = Asset.fromOperation(attrs.asset()); | |
37226 | result.amount = this._fromXDRAmount(attrs.amount()); | |
37227 | break; | |
37228 | case "pathPayment": | |
37229 | result.type = "pathPayment"; | |
37230 | result.sendAsset = Asset.fromOperation(attrs.sendAsset()); | |
37231 | result.sendMax = this._fromXDRAmount(attrs.sendMax()); | |
37232 | result.destination = accountIdtoAddress(attrs.destination()); | |
37233 | result.destAsset = Asset.fromOperation(attrs.destAsset()); | |
37234 | result.destAmount = this._fromXDRAmount(attrs.destAmount()); | |
37235 | var path = attrs.path(); | |
37236 | result.path = []; | |
37237 | for (var i in path) { | |
37238 | result.path.push(Asset.fromOperation(path[i])); | |
37239 | } | |
37240 | break; | |
37241 | case "changeTrust": | |
37242 | result.type = "changeTrust"; | |
37243 | result.line = Asset.fromOperation(attrs.line()); | |
37244 | result.limit = this._fromXDRAmount(attrs.limit()); | |
37245 | break; | |
37246 | case "allowTrust": | |
37247 | result.type = "allowTrust"; | |
37248 | result.trustor = accountIdtoAddress(attrs.trustor()); | |
37249 | result.assetCode = attrs.asset().value().toString(); | |
37250 | result.assetCode = trimEnd(result.assetCode, "\u0000"); | |
37251 | result.authorize = attrs.authorize(); | |
37252 | break; | |
37253 | case "setOption": | |
37254 | result.type = "setOptions"; | |
37255 | if (attrs.inflationDest()) { | |
37256 | result.inflationDest = accountIdtoAddress(attrs.inflationDest()); | |
37257 | } | |
37258 | ||
37259 | result.clearFlags = attrs.clearFlags(); | |
37260 | result.setFlags = attrs.setFlags(); | |
37261 | result.masterWeight = attrs.masterWeight(); | |
37262 | result.lowThreshold = attrs.lowThreshold(); | |
37263 | result.medThreshold = attrs.medThreshold(); | |
37264 | result.highThreshold = attrs.highThreshold(); | |
37265 | // home_domain is checked by iscntrl in stellar-core | |
37266 | result.homeDomain = attrs.homeDomain() !== undefined ? attrs.homeDomain().toString("ascii") : undefined; | |
37267 | ||
37268 | if (attrs.signer()) { | |
37269 | var signer = {}; | |
37270 | var arm = attrs.signer().key().arm(); | |
37271 | if (arm == "ed25519") { | |
37272 | signer.ed25519PublicKey = accountIdtoAddress(attrs.signer().key()); | |
37273 | } else if (arm == "preAuthTx") { | |
37274 | signer.preAuthTx = attrs.signer().key().preAuthTx(); | |
37275 | } else if (arm == "hashX") { | |
37276 | signer.sha256Hash = attrs.signer().key().hashX(); | |
37277 | } | |
37278 | ||
37279 | signer.weight = attrs.signer().weight(); | |
37280 | result.signer = signer; | |
37281 | } | |
37282 | break; | |
37283 | case "manageOffer": | |
37284 | result.type = "manageOffer"; | |
37285 | result.selling = Asset.fromOperation(attrs.selling()); | |
37286 | result.buying = Asset.fromOperation(attrs.buying()); | |
37287 | result.amount = this._fromXDRAmount(attrs.amount()); | |
37288 | result.price = this._fromXDRPrice(attrs.price()); | |
37289 | result.offerId = attrs.offerId().toString(); | |
37290 | break; | |
37291 | case "createPassiveOffer": | |
37292 | result.type = "createPassiveOffer"; | |
37293 | result.selling = Asset.fromOperation(attrs.selling()); | |
37294 | result.buying = Asset.fromOperation(attrs.buying()); | |
37295 | result.amount = this._fromXDRAmount(attrs.amount()); | |
37296 | result.price = this._fromXDRPrice(attrs.price()); | |
37297 | break; | |
37298 | case "accountMerge": | |
37299 | result.type = "accountMerge"; | |
37300 | result.destination = accountIdtoAddress(attrs); | |
37301 | break; | |
37302 | case "manageDatum": | |
37303 | result.type = "manageData"; | |
37304 | // manage_data.name is checked by iscntrl in stellar-core | |
37305 | result.name = attrs.dataName().toString("ascii"); | |
37306 | result.value = attrs.dataValue(); | |
37307 | break; | |
37308 | case "inflation": | |
37309 | result.type = "inflation"; | |
37310 | break; | |
37311 | case "bumpSequence": | |
37312 | result.type = "bumpSequence"; | |
37313 | result.bumpTo = attrs.bumpTo().toString(); | |
37314 | break; | |
37315 | default: | |
37316 | throw new Error("Unknown operation"); | |
37317 | } | |
37318 | return result; | |
37319 | } | |
37320 | }, | |
37321 | isValidAmount: { | |
37322 | value: function isValidAmount(value) { | |
37323 | var allowZero = arguments[1] === undefined ? false : arguments[1]; | |
37324 | ||
37325 | if (!isString(value)) { | |
37326 | return false; | |
37327 | } | |
37328 | ||
37329 | var amount = undefined; | |
37330 | try { | |
37331 | amount = new BigNumber(value); | |
37332 | } catch (e) { | |
37333 | return false; | |
37334 | } | |
37335 | ||
37336 | switch (true) { | |
37337 | // == 0 | |
37338 | case !allowZero && amount.isZero(): | |
37339 | // < 0 | |
37340 | case amount.isNegative(): | |
37341 | // > Max value | |
37342 | case amount.times(ONE).greaterThan(new BigNumber(MAX_INT64).toString()): | |
37343 | // Decimal places (max 7) | |
37344 | case amount.decimalPlaces() > 7: | |
37345 | // NaN or Infinity | |
37346 | case amount.isNaN() || !amount.isFinite(): | |
37347 | return false; | |
37348 | default: | |
37349 | return true; | |
37350 | } | |
37351 | } | |
37352 | }, | |
37353 | constructAmountRequirementsError: { | |
37354 | value: function constructAmountRequirementsError(arg) { | |
37355 | return "" + arg + " argument must be of type String, represent a positive number and have at most 7 digits after the decimal"; | |
37356 | } | |
37357 | }, | |
37358 | _checkUnsignedIntValue: { | |
37359 | ||
37360 | /** | |
37361 | * Returns value converted to uint32 value or undefined. | |
37362 | * If `value` is not `Number`, `String` or `Undefined` then throws an error. | |
37363 | * Used in {@link Operation.setOptions}. | |
37364 | * @private | |
37365 | * @param {string} name Name of the property (used in error message only) | |
37366 | * @param {*} value Value to check | |
37367 | * @param {function(value, name)} isValidFunction Function to check other constraints (the argument will be a `Number`) | |
37368 | * @returns {undefined|Number} | |
37369 | * @private | |
37370 | */ | |
37371 | ||
37372 | value: function _checkUnsignedIntValue(name, value) { | |
37373 | var isValidFunction = arguments[2] === undefined ? null : arguments[2]; | |
37374 | ||
37375 | if (isUndefined(value)) { | |
37376 | return undefined; | |
37377 | } | |
37378 | ||
37379 | if (isString(value)) { | |
37380 | value = parseFloat(value); | |
37381 | } | |
37382 | ||
37383 | switch (true) { | |
37384 | case !isNumber(value) || !isFinite(value) || value % 1 !== 0: | |
37385 | throw new Error("" + name + " value is invalid"); | |
37386 | case value < 0: | |
37387 | throw new Error("" + name + " value must be unsigned"); | |
37388 | case !isValidFunction || isValidFunction && isValidFunction(value, name): | |
37389 | return value; | |
37390 | default: | |
37391 | throw new Error("" + name + " value is invalid"); | |
37392 | } | |
37393 | } | |
37394 | }, | |
37395 | _toXDRAmount: { | |
37396 | ||
37397 | /** | |
37398 | * @private | |
37399 | */ | |
37400 | ||
37401 | value: function _toXDRAmount(value) { | |
37402 | var amount = new BigNumber(value).mul(ONE); | |
37403 | return Hyper.fromString(amount.toString()); | |
37404 | } | |
37405 | }, | |
37406 | _fromXDRAmount: { | |
37407 | ||
37408 | /** | |
37409 | * @private | |
37410 | */ | |
37411 | ||
37412 | value: function _fromXDRAmount(value) { | |
37413 | return new BigNumber(value).div(ONE).toString(); | |
37414 | } | |
37415 | }, | |
37416 | _fromXDRPrice: { | |
37417 | ||
37418 | /** | |
37419 | * @private | |
37420 | */ | |
37421 | ||
37422 | value: function _fromXDRPrice(price) { | |
37423 | var n = new BigNumber(price.n()); | |
37424 | return n.div(new BigNumber(price.d())).toString(); | |
37425 | } | |
37426 | }, | |
37427 | _toXDRPrice: { | |
37428 | ||
37429 | /** | |
37430 | * @private | |
37431 | */ | |
37432 | ||
37433 | value: function _toXDRPrice(price) { | |
37434 | var xdrObject = undefined; | |
37435 | if (price.n && price.d) { | |
37436 | xdrObject = new xdr.Price(price); | |
37437 | } else { | |
37438 | price = new BigNumber(price); | |
37439 | var approx = best_r(price); | |
37440 | xdrObject = new xdr.Price({ | |
37441 | n: parseInt(approx[0]), | |
37442 | d: parseInt(approx[1]) | |
37443 | }); | |
37444 | } | |
37445 | ||
37446 | if (xdrObject.n() < 0 || xdrObject.d() < 0) { | |
37447 | throw new Error("price must be positive"); | |
37448 | } | |
37449 | ||
37450 | return xdrObject; | |
37451 | } | |
37452 | } | |
37453 | }); | |
37454 | ||
37455 | return Operation; | |
37456 | })(); | |
37457 | ||
37458 | // Attach all imported operations as static methods on the Operation class | |
37459 | Operation.accountMerge = ops.accountMerge; | |
37460 | Operation.allowTrust = ops.allowTrust; | |
37461 | Operation.bumpSequence = ops.bumpSequence; | |
37462 | Operation.changeTrust = ops.changeTrust; | |
37463 | Operation.createAccount = ops.createAccount; | |
37464 | Operation.createPassiveOffer = ops.createPassiveOffer; | |
37465 | Operation.inflation = ops.inflation; | |
37466 | Operation.manageData = ops.manageData; | |
37467 | Operation.manageOffer = ops.manageOffer; | |
37468 | Operation.pathPayment = ops.pathPayment; | |
37469 | Operation.payment = ops.payment; | |
37470 | Operation.setOptions = ops.setOptions; | |
37471 | },{"./asset":408,"./generated/stellar-xdr_generated":410,"./hashing":411,"./keypair":413,"./operations/index":423,"./strkey":431,"./util/continued_fraction":435,"bignumber.js":17,"js-xdr":131,"lodash/isFinite":327,"lodash/isNumber":332,"lodash/isString":337,"lodash/isUndefined":340,"lodash/trimEnd":355}],417:[function(require,module,exports){ | |
37472 | "use strict"; | |
37473 | ||
37474 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37475 | ||
37476 | Object.defineProperty(exports, "__esModule", { | |
37477 | value: true | |
37478 | }); | |
37479 | ||
37480 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37481 | ||
37482 | var Keypair = require("../keypair").Keypair; | |
37483 | ||
37484 | var StrKey = require("../strkey").StrKey; | |
37485 | ||
37486 | /** | |
37487 | * Transfers native balance to destination account. | |
37488 | * @function | |
37489 | * @alias Operation.accountMerge | |
37490 | * @param {object} opts | |
37491 | * @param {string} opts.destination - Destination to merge the source account into. | |
37492 | * @param {string} [opts.source] - The source account (defaults to transaction source). | |
37493 | * @returns {xdr.AccountMergeOp} | |
37494 | */ | |
37495 | var accountMerge = function accountMerge(opts) { | |
37496 | var opAttributes = {}; | |
37497 | if (!StrKey.isValidEd25519PublicKey(opts.destination)) { | |
37498 | throw new Error("destination is invalid"); | |
37499 | } | |
37500 | opAttributes.body = xdr.OperationBody.accountMerge(Keypair.fromPublicKey(opts.destination).xdrAccountId()); | |
37501 | this.setSourceAccount(opAttributes, opts); | |
37502 | ||
37503 | return new xdr.Operation(opAttributes); | |
37504 | }; | |
37505 | exports.accountMerge = accountMerge; | |
37506 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"../strkey":431}],418:[function(require,module,exports){ | |
37507 | "use strict"; | |
37508 | ||
37509 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37510 | ||
37511 | Object.defineProperty(exports, "__esModule", { | |
37512 | value: true | |
37513 | }); | |
37514 | ||
37515 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37516 | ||
37517 | var Keypair = require("../keypair").Keypair; | |
37518 | ||
37519 | var StrKey = require("../strkey").StrKey; | |
37520 | ||
37521 | var padEnd = _interopRequire(require("lodash/padEnd")); | |
37522 | ||
37523 | /** | |
37524 | * Returns an XDR AllowTrustOp. An "allow trust" operation authorizes another | |
37525 | * account to hold your account's credit for a given asset. | |
37526 | * @function | |
37527 | * @alias Operation.allowTrust | |
37528 | * @param {object} opts | |
37529 | * @param {string} opts.trustor - The trusting account (the one being authorized) | |
37530 | * @param {string} opts.assetCode - The asset code being authorized. | |
37531 | * @param {boolean} opts.authorize - True to authorize the line, false to deauthorize. | |
37532 | * @param {string} [opts.source] - The source account (defaults to transaction source). | |
37533 | * @returns {xdr.AllowTrustOp} | |
37534 | */ | |
37535 | var allowTrust = function allowTrust(opts) { | |
37536 | if (!StrKey.isValidEd25519PublicKey(opts.trustor)) { | |
37537 | throw new Error("trustor is invalid"); | |
37538 | } | |
37539 | var attributes = {}; | |
37540 | attributes.trustor = Keypair.fromPublicKey(opts.trustor).xdrAccountId(); | |
37541 | if (opts.assetCode.length <= 4) { | |
37542 | var code = padEnd(opts.assetCode, 4, "\u0000"); | |
37543 | attributes.asset = xdr.AllowTrustOpAsset.assetTypeCreditAlphanum4(code); | |
37544 | } else if (opts.assetCode.length <= 12) { | |
37545 | var code = padEnd(opts.assetCode, 12, "\u0000"); | |
37546 | attributes.asset = xdr.AllowTrustOpAsset.assetTypeCreditAlphanum12(code); | |
37547 | } else { | |
37548 | throw new Error("Asset code must be 12 characters at max."); | |
37549 | } | |
37550 | attributes.authorize = opts.authorize; | |
37551 | var allowTrustOp = new xdr.AllowTrustOp(attributes); | |
37552 | ||
37553 | var opAttributes = {}; | |
37554 | opAttributes.body = xdr.OperationBody.allowTrust(allowTrustOp); | |
37555 | this.setSourceAccount(opAttributes, opts); | |
37556 | ||
37557 | return new xdr.Operation(opAttributes); | |
37558 | }; | |
37559 | exports.allowTrust = allowTrust; | |
37560 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"../strkey":431,"lodash/padEnd":345}],419:[function(require,module,exports){ | |
37561 | "use strict"; | |
37562 | ||
37563 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37564 | ||
37565 | Object.defineProperty(exports, "__esModule", { | |
37566 | value: true | |
37567 | }); | |
37568 | ||
37569 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37570 | ||
37571 | var Hyper = require("js-xdr").Hyper; | |
37572 | ||
37573 | var BigNumber = _interopRequire(require("bignumber.js")); | |
37574 | ||
37575 | var isString = _interopRequire(require("lodash/isString")); | |
37576 | ||
37577 | /** | |
37578 | * This operation bumps sequence number. | |
37579 | * @function | |
37580 | * @alias Operation.bumpSequence | |
37581 | * @param {object} opts | |
37582 | * @param {string} opts.bumpTo - Sequence number to bump to. | |
37583 | * @param {string} [opts.source] - The optional source account. | |
37584 | * @returns {xdr.BumpSequenceOp} | |
37585 | */ | |
37586 | var bumpSequence = function bumpSequence(opts) { | |
37587 | var attributes = {}; | |
37588 | ||
37589 | if (!isString(opts.bumpTo)) { | |
37590 | throw new Error("bumpTo must be a string"); | |
37591 | } | |
37592 | ||
37593 | try { | |
37594 | new BigNumber(opts.bumpTo); | |
37595 | } catch (e) { | |
37596 | throw new Error("bumpTo must be a stringified number"); | |
37597 | } | |
37598 | ||
37599 | attributes.bumpTo = Hyper.fromString(opts.bumpTo); | |
37600 | ||
37601 | var bumpSequenceOp = new xdr.BumpSequenceOp(attributes); | |
37602 | ||
37603 | var opAttributes = {}; | |
37604 | opAttributes.body = xdr.OperationBody.bumpSequence(bumpSequenceOp); | |
37605 | this.setSourceAccount(opAttributes, opts); | |
37606 | ||
37607 | return new xdr.Operation(opAttributes); | |
37608 | }; | |
37609 | exports.bumpSequence = bumpSequence; | |
37610 | },{"../generated/stellar-xdr_generated":410,"bignumber.js":17,"js-xdr":131,"lodash/isString":337}],420:[function(require,module,exports){ | |
37611 | "use strict"; | |
37612 | ||
37613 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37614 | ||
37615 | Object.defineProperty(exports, "__esModule", { | |
37616 | value: true | |
37617 | }); | |
37618 | ||
37619 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37620 | ||
37621 | var Keypair = require("../keypair").Keypair; | |
37622 | ||
37623 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
37624 | ||
37625 | var Hyper = require("js-xdr").Hyper; | |
37626 | ||
37627 | var BigNumber = _interopRequire(require("bignumber.js")); | |
37628 | ||
37629 | var MAX_INT64 = "9223372036854775807"; | |
37630 | ||
37631 | /** | |
37632 | * Returns an XDR ChangeTrustOp. A "change trust" operation adds, removes, or updates a | |
37633 | * trust line for a given asset from the source account to another. The issuer being | |
37634 | * trusted and the asset code are in the given Asset object. | |
37635 | * @function | |
37636 | * @alias Operation.changeTrust | |
37637 | * @param {object} opts | |
37638 | * @param {Asset} opts.asset - The asset for the trust line. | |
37639 | * @param {string} [opts.limit] - The limit for the asset, defaults to max int64. | |
37640 | * If the limit is set to "0" it deletes the trustline. | |
37641 | * @param {string} [opts.source] - The source account (defaults to transaction source). | |
37642 | * @returns {xdr.ChangeTrustOp} | |
37643 | */ | |
37644 | var changeTrust = function changeTrust(opts) { | |
37645 | var attributes = {}; | |
37646 | attributes.line = opts.asset.toXDRObject(); | |
37647 | if (!isUndefined(opts.limit) && !this.isValidAmount(opts.limit, true)) { | |
37648 | throw new TypeError(this.constructAmountRequirementsError("limit")); | |
37649 | } | |
37650 | ||
37651 | if (opts.limit) { | |
37652 | attributes.limit = this._toXDRAmount(opts.limit); | |
37653 | } else { | |
37654 | attributes.limit = Hyper.fromString(new BigNumber(MAX_INT64).toString()); | |
37655 | } | |
37656 | ||
37657 | if (opts.source) { | |
37658 | attributes.source = opts.source.masterKeypair; | |
37659 | } | |
37660 | var changeTrustOP = new xdr.ChangeTrustOp(attributes); | |
37661 | ||
37662 | var opAttributes = {}; | |
37663 | opAttributes.body = xdr.OperationBody.changeTrust(changeTrustOP); | |
37664 | this.setSourceAccount(opAttributes, opts); | |
37665 | ||
37666 | return new xdr.Operation(opAttributes); | |
37667 | }; | |
37668 | exports.changeTrust = changeTrust; | |
37669 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"bignumber.js":17,"js-xdr":131,"lodash/isUndefined":340}],421:[function(require,module,exports){ | |
37670 | "use strict"; | |
37671 | ||
37672 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37673 | ||
37674 | Object.defineProperty(exports, "__esModule", { | |
37675 | value: true | |
37676 | }); | |
37677 | ||
37678 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37679 | ||
37680 | var Keypair = require("../keypair").Keypair; | |
37681 | ||
37682 | var StrKey = require("../strkey").StrKey; | |
37683 | ||
37684 | /** | |
37685 | * Create and fund a non existent account. | |
37686 | * @function | |
37687 | * @alias Operation.createAccount | |
37688 | * @param {object} opts | |
37689 | * @param {string} opts.destination - Destination account ID to create an account for. | |
37690 | * @param {string} opts.startingBalance - Amount in XLM the account should be funded for. Must be greater | |
37691 | * than the [reserve balance amount](https://www.stellar.org/developers/learn/concepts/fees.html). | |
37692 | * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account. | |
37693 | * @returns {xdr.CreateAccountOp} | |
37694 | */ | |
37695 | var createAccount = (function (_createAccount) { | |
37696 | var _createAccountWrapper = function createAccount(_x) { | |
37697 | return _createAccount.apply(this, arguments); | |
37698 | }; | |
37699 | ||
37700 | _createAccountWrapper.toString = function () { | |
37701 | return _createAccount.toString(); | |
37702 | }; | |
37703 | ||
37704 | return _createAccountWrapper; | |
37705 | })(function (opts) { | |
37706 | if (!StrKey.isValidEd25519PublicKey(opts.destination)) { | |
37707 | throw new Error("destination is invalid"); | |
37708 | } | |
37709 | if (!this.isValidAmount(opts.startingBalance)) { | |
37710 | throw new TypeError(this.constructAmountRequirementsError("startingBalance")); | |
37711 | } | |
37712 | var attributes = {}; | |
37713 | attributes.destination = Keypair.fromPublicKey(opts.destination).xdrAccountId(); | |
37714 | attributes.startingBalance = this._toXDRAmount(opts.startingBalance); | |
37715 | var createAccount = new xdr.CreateAccountOp(attributes); | |
37716 | ||
37717 | var opAttributes = {}; | |
37718 | opAttributes.body = xdr.OperationBody.createAccount(createAccount); | |
37719 | this.setSourceAccount(opAttributes, opts); | |
37720 | ||
37721 | return new xdr.Operation(opAttributes); | |
37722 | }); | |
37723 | exports.createAccount = createAccount; | |
37724 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"../strkey":431}],422:[function(require,module,exports){ | |
37725 | "use strict"; | |
37726 | ||
37727 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37728 | ||
37729 | Object.defineProperty(exports, "__esModule", { | |
37730 | value: true | |
37731 | }); | |
37732 | ||
37733 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37734 | ||
37735 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
37736 | ||
37737 | /** | |
37738 | * Returns a XDR CreatePasiveOfferOp. A "create passive offer" operation creates an | |
37739 | * offer that won't consume a counter offer that exactly matches this offer. This is | |
37740 | * useful for offers just used as 1:1 exchanges for path payments. Use manage offer | |
37741 | * to manage this offer after using this operation to create it. | |
37742 | * @function | |
37743 | * @alias Operation.createPassiveOffer | |
37744 | * @param {object} opts | |
37745 | * @param {Asset} opts.selling - What you're selling. | |
37746 | * @param {Asset} opts.buying - What you're buying. | |
37747 | * @param {string} opts.amount - The total amount you're selling. If 0, deletes the offer. | |
37748 | * @param {number|string|BigNumber|Object} opts.price - Price of 1 unit of `selling` in terms of `buying`. | |
37749 | * @param {number} opts.price.n - If `opts.price` is an object: the price numerator | |
37750 | * @param {number} opts.price.d - If `opts.price` is an object: the price denominator | |
37751 | * @param {string} [opts.source] - The source account (defaults to transaction source). | |
37752 | * @throws {Error} Throws `Error` when the best rational approximation of `price` cannot be found. | |
37753 | * @returns {xdr.CreatePassiveOfferOp} | |
37754 | */ | |
37755 | var createPassiveOffer = function createPassiveOffer(opts) { | |
37756 | var attributes = {}; | |
37757 | attributes.selling = opts.selling.toXDRObject(); | |
37758 | attributes.buying = opts.buying.toXDRObject(); | |
37759 | if (!this.isValidAmount(opts.amount)) { | |
37760 | throw new TypeError(this.constructAmountRequirementsError("amount")); | |
37761 | } | |
37762 | attributes.amount = this._toXDRAmount(opts.amount); | |
37763 | if (isUndefined(opts.price)) { | |
37764 | throw new TypeError("price argument is required"); | |
37765 | } | |
37766 | attributes.price = this._toXDRPrice(opts.price); | |
37767 | var createPassiveOfferOp = new xdr.CreatePassiveOfferOp(attributes); | |
37768 | ||
37769 | var opAttributes = {}; | |
37770 | opAttributes.body = xdr.OperationBody.createPassiveOffer(createPassiveOfferOp); | |
37771 | this.setSourceAccount(opAttributes, opts); | |
37772 | ||
37773 | return new xdr.Operation(opAttributes); | |
37774 | }; | |
37775 | exports.createPassiveOffer = createPassiveOffer; | |
37776 | },{"../generated/stellar-xdr_generated":410,"lodash/isUndefined":340}],423:[function(require,module,exports){ | |
37777 | "use strict"; | |
37778 | ||
37779 | Object.defineProperty(exports, "__esModule", { | |
37780 | value: true | |
37781 | }); | |
37782 | exports.accountMerge = require("./account_merge").accountMerge; | |
37783 | exports.allowTrust = require("./allow_trust").allowTrust; | |
37784 | exports.bumpSequence = require("./bump_sequence").bumpSequence; | |
37785 | exports.changeTrust = require("./change_trust").changeTrust; | |
37786 | exports.createAccount = require("./create_account").createAccount; | |
37787 | exports.createPassiveOffer = require("./create_passive_offer").createPassiveOffer; | |
37788 | exports.inflation = require("./inflation").inflation; | |
37789 | exports.manageData = require("./manage_data").manageData; | |
37790 | exports.manageOffer = require("./manage_offer").manageOffer; | |
37791 | exports.pathPayment = require("./path_payment").pathPayment; | |
37792 | exports.payment = require("./payment").payment; | |
37793 | exports.setOptions = require("./set_options").setOptions; | |
37794 | },{"./account_merge":417,"./allow_trust":418,"./bump_sequence":419,"./change_trust":420,"./create_account":421,"./create_passive_offer":422,"./inflation":424,"./manage_data":425,"./manage_offer":426,"./path_payment":427,"./payment":428,"./set_options":429}],424:[function(require,module,exports){ | |
37795 | "use strict"; | |
37796 | ||
37797 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37798 | ||
37799 | Object.defineProperty(exports, "__esModule", { | |
37800 | value: true | |
37801 | }); | |
37802 | ||
37803 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37804 | ||
37805 | /** | |
37806 | * This operation generates the inflation. | |
37807 | * @function | |
37808 | * @alias Operation.inflation | |
37809 | * @param {object} [opts] | |
37810 | * @param {string} [opts.source] - The optional source account. | |
37811 | * @returns {xdr.InflationOp} | |
37812 | */ | |
37813 | var inflation = function inflation() { | |
37814 | var opts = arguments[0] === undefined ? {} : arguments[0]; | |
37815 | ||
37816 | var opAttributes = {}; | |
37817 | opAttributes.body = xdr.OperationBody.inflation(); | |
37818 | this.setSourceAccount(opAttributes, opts); | |
37819 | return new xdr.Operation(opAttributes); | |
37820 | }; | |
37821 | exports.inflation = inflation; | |
37822 | },{"../generated/stellar-xdr_generated":410}],425:[function(require,module,exports){ | |
37823 | (function (Buffer){ | |
37824 | "use strict"; | |
37825 | ||
37826 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37827 | ||
37828 | Object.defineProperty(exports, "__esModule", { | |
37829 | value: true | |
37830 | }); | |
37831 | ||
37832 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37833 | ||
37834 | var isString = _interopRequire(require("lodash/isString")); | |
37835 | ||
37836 | /** | |
37837 | * This operation adds data entry to the ledger. | |
37838 | * @function | |
37839 | * @alias Operation.manageData | |
37840 | * @param {object} opts | |
37841 | * @param {string} opts.name - The name of the data entry. | |
37842 | * @param {string|Buffer} opts.value - The value of the data entry. | |
37843 | * @param {string} [opts.source] - The optional source account. | |
37844 | * @returns {xdr.ManageDataOp} | |
37845 | */ | |
37846 | var manageData = function manageData(opts) { | |
37847 | var attributes = {}; | |
37848 | ||
37849 | if (!(isString(opts.name) && opts.name.length <= 64)) { | |
37850 | throw new Error("name must be a string, up to 64 characters"); | |
37851 | } | |
37852 | attributes.dataName = opts.name; | |
37853 | ||
37854 | if (!isString(opts.value) && !Buffer.isBuffer(opts.value) && opts.value !== null) { | |
37855 | throw new Error("value must be a string, Buffer or null"); | |
37856 | } | |
37857 | ||
37858 | if (isString(opts.value)) { | |
37859 | attributes.dataValue = Buffer.from(opts.value); | |
37860 | } else { | |
37861 | attributes.dataValue = opts.value; | |
37862 | } | |
37863 | ||
37864 | if (attributes.dataValue !== null && attributes.dataValue.length > 64) { | |
37865 | throw new Error("value cannot be longer that 64 bytes"); | |
37866 | } | |
37867 | ||
37868 | var manageDataOp = new xdr.ManageDataOp(attributes); | |
37869 | ||
37870 | var opAttributes = {}; | |
37871 | opAttributes.body = xdr.OperationBody.manageDatum(manageDataOp); | |
37872 | this.setSourceAccount(opAttributes, opts); | |
37873 | ||
37874 | return new xdr.Operation(opAttributes); | |
37875 | }; | |
37876 | exports.manageData = manageData; | |
37877 | }).call(this,require("buffer").Buffer) | |
37878 | },{"../generated/stellar-xdr_generated":410,"buffer":50,"lodash/isString":337}],426:[function(require,module,exports){ | |
37879 | "use strict"; | |
37880 | ||
37881 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37882 | ||
37883 | Object.defineProperty(exports, "__esModule", { | |
37884 | value: true | |
37885 | }); | |
37886 | ||
37887 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37888 | ||
37889 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
37890 | ||
37891 | var UnsignedHyper = require("js-xdr").UnsignedHyper; | |
37892 | ||
37893 | /** | |
37894 | * Returns a XDR ManageOfferOp. A "manage offer" operation creates, updates, or | |
37895 | * deletes an offer. | |
37896 | * @function | |
37897 | * @alias Operation.manageOffer | |
37898 | * @param {object} opts | |
37899 | * @param {Asset} opts.selling - What you're selling. | |
37900 | * @param {Asset} opts.buying - What you're buying. | |
37901 | * @param {string} opts.amount - The total amount you're selling. If 0, deletes the offer. | |
37902 | * @param {number|string|BigNumber|Object} opts.price - Price of 1 unit of `selling` in terms of `buying`. | |
37903 | * @param {number} opts.price.n - If `opts.price` is an object: the price numerator | |
37904 | * @param {number} opts.price.d - If `opts.price` is an object: the price denominator | |
37905 | * @param {number|string} [opts.offerId ] - If `0`, will create a new offer (default). Otherwise, edits an exisiting offer. | |
37906 | * @param {string} [opts.source] - The source account (defaults to transaction source). | |
37907 | * @throws {Error} Throws `Error` when the best rational approximation of `price` cannot be found. | |
37908 | * @returns {xdr.ManageOfferOp} | |
37909 | */ | |
37910 | var manageOffer = function manageOffer(opts) { | |
37911 | var attributes = {}; | |
37912 | attributes.selling = opts.selling.toXDRObject(); | |
37913 | attributes.buying = opts.buying.toXDRObject(); | |
37914 | if (!this.isValidAmount(opts.amount, true)) { | |
37915 | throw new TypeError(this.constructAmountRequirementsError("amount")); | |
37916 | } | |
37917 | attributes.amount = this._toXDRAmount(opts.amount); | |
37918 | if (isUndefined(opts.price)) { | |
37919 | throw new TypeError("price argument is required"); | |
37920 | } | |
37921 | attributes.price = this._toXDRPrice(opts.price); | |
37922 | ||
37923 | if (!isUndefined(opts.offerId)) { | |
37924 | opts.offerId = opts.offerId.toString(); | |
37925 | } else { | |
37926 | opts.offerId = "0"; | |
37927 | } | |
37928 | attributes.offerId = UnsignedHyper.fromString(opts.offerId); | |
37929 | var manageOfferOp = new xdr.ManageOfferOp(attributes); | |
37930 | ||
37931 | var opAttributes = {}; | |
37932 | opAttributes.body = xdr.OperationBody.manageOffer(manageOfferOp); | |
37933 | this.setSourceAccount(opAttributes, opts); | |
37934 | ||
37935 | return new xdr.Operation(opAttributes); | |
37936 | }; | |
37937 | exports.manageOffer = manageOffer; | |
37938 | },{"../generated/stellar-xdr_generated":410,"js-xdr":131,"lodash/isUndefined":340}],427:[function(require,module,exports){ | |
37939 | "use strict"; | |
37940 | ||
37941 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
37942 | ||
37943 | Object.defineProperty(exports, "__esModule", { | |
37944 | value: true | |
37945 | }); | |
37946 | ||
37947 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
37948 | ||
37949 | var Keypair = require("../keypair").Keypair; | |
37950 | ||
37951 | var StrKey = require("../strkey").StrKey; | |
37952 | ||
37953 | /** | |
37954 | * Returns a XDR PaymentOp. A "payment" operation send the specified amount to the | |
37955 | * destination account, optionally through a path. XLM payments create the destination | |
37956 | * account if it does not exist. | |
37957 | * @function | |
37958 | * @alias Operation.pathPayment | |
37959 | * @param {object} opts | |
37960 | * @param {Asset} opts.sendAsset - The asset to pay with. | |
37961 | * @param {string} opts.sendMax - The maximum amount of sendAsset to send. | |
37962 | * @param {string} opts.destination - The destination account to send to. | |
37963 | * @param {Asset} opts.destAsset - The asset the destination will receive. | |
37964 | * @param {string} opts.destAmount - The amount the destination receives. | |
37965 | * @param {Asset[]} opts.path - An array of Asset objects to use as the path. | |
37966 | * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account. | |
37967 | * @returns {xdr.PathPaymentOp} | |
37968 | */ | |
37969 | var pathPayment = function pathPayment(opts) { | |
37970 | switch (true) { | |
37971 | case !opts.sendAsset: | |
37972 | throw new Error("Must specify a send asset"); | |
37973 | case !this.isValidAmount(opts.sendMax): | |
37974 | throw new TypeError(this.constructAmountRequirementsError("sendMax")); | |
37975 | case !StrKey.isValidEd25519PublicKey(opts.destination): | |
37976 | throw new Error("destination is invalid"); | |
37977 | case !opts.destAsset: | |
37978 | throw new Error("Must provide a destAsset for a payment operation"); | |
37979 | case !this.isValidAmount(opts.destAmount): | |
37980 | throw new TypeError(this.constructAmountRequirementsError("destAmount")); | |
37981 | } | |
37982 | ||
37983 | var attributes = {}; | |
37984 | attributes.sendAsset = opts.sendAsset.toXDRObject(); | |
37985 | attributes.sendMax = this._toXDRAmount(opts.sendMax); | |
37986 | attributes.destination = Keypair.fromPublicKey(opts.destination).xdrAccountId(); | |
37987 | attributes.destAsset = opts.destAsset.toXDRObject(); | |
37988 | attributes.destAmount = this._toXDRAmount(opts.destAmount); | |
37989 | ||
37990 | var path = opts.path ? opts.path : []; | |
37991 | attributes.path = path.map(function (x) { | |
37992 | return x.toXDRObject(); | |
37993 | }); | |
37994 | ||
37995 | var payment = new xdr.PathPaymentOp(attributes); | |
37996 | ||
37997 | var opAttributes = {}; | |
37998 | opAttributes.body = xdr.OperationBody.pathPayment(payment); | |
37999 | this.setSourceAccount(opAttributes, opts); | |
38000 | ||
38001 | return new xdr.Operation(opAttributes); | |
38002 | }; | |
38003 | exports.pathPayment = pathPayment; | |
38004 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"../strkey":431}],428:[function(require,module,exports){ | |
38005 | "use strict"; | |
38006 | ||
38007 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
38008 | ||
38009 | Object.defineProperty(exports, "__esModule", { | |
38010 | value: true | |
38011 | }); | |
38012 | ||
38013 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
38014 | ||
38015 | var Keypair = require("../keypair").Keypair; | |
38016 | ||
38017 | var StrKey = require("../strkey").StrKey; | |
38018 | ||
38019 | /** | |
38020 | * Create a payment operation. | |
38021 | * @function | |
38022 | * @alias Operation.payment | |
38023 | * @param {object} opts | |
38024 | * @param {string} opts.destination - The destination account ID. | |
38025 | * @param {Asset} opts.asset - The asset to send. | |
38026 | * @param {string} opts.amount - The amount to send. | |
38027 | * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account. | |
38028 | * @returns {xdr.PaymentOp} | |
38029 | */ | |
38030 | var payment = (function (_payment) { | |
38031 | var _paymentWrapper = function payment(_x) { | |
38032 | return _payment.apply(this, arguments); | |
38033 | }; | |
38034 | ||
38035 | _paymentWrapper.toString = function () { | |
38036 | return _payment.toString(); | |
38037 | }; | |
38038 | ||
38039 | return _paymentWrapper; | |
38040 | })(function (opts) { | |
38041 | if (!StrKey.isValidEd25519PublicKey(opts.destination)) { | |
38042 | throw new Error("destination is invalid"); | |
38043 | } | |
38044 | if (!opts.asset) { | |
38045 | throw new Error("Must provide an asset for a payment operation"); | |
38046 | } | |
38047 | if (!this.isValidAmount(opts.amount)) { | |
38048 | throw new TypeError(this.constructAmountRequirementsError("amount")); | |
38049 | } | |
38050 | ||
38051 | var attributes = {}; | |
38052 | attributes.destination = Keypair.fromPublicKey(opts.destination).xdrAccountId(); | |
38053 | attributes.asset = opts.asset.toXDRObject(); | |
38054 | attributes.amount = this._toXDRAmount(opts.amount); | |
38055 | var payment = new xdr.PaymentOp(attributes); | |
38056 | ||
38057 | var opAttributes = {}; | |
38058 | opAttributes.body = xdr.OperationBody.payment(payment); | |
38059 | this.setSourceAccount(opAttributes, opts); | |
38060 | ||
38061 | return new xdr.Operation(opAttributes); | |
38062 | }); | |
38063 | exports.payment = payment; | |
38064 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"../strkey":431}],429:[function(require,module,exports){ | |
38065 | (function (Buffer){ | |
38066 | "use strict"; | |
38067 | ||
38068 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
38069 | ||
38070 | Object.defineProperty(exports, "__esModule", { | |
38071 | value: true | |
38072 | }); | |
38073 | ||
38074 | var xdr = _interopRequire(require("../generated/stellar-xdr_generated")); | |
38075 | ||
38076 | var Keypair = require("../keypair").Keypair; | |
38077 | ||
38078 | var StrKey = require("../strkey").StrKey; | |
38079 | ||
38080 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
38081 | ||
38082 | var isString = _interopRequire(require("lodash/isString")); | |
38083 | ||
38084 | /** | |
38085 | * Returns an XDR SetOptionsOp. A "set options" operations set or clear account flags, | |
38086 | * set the account's inflation destination, and/or add new signers to the account. | |
38087 | * The flags used in `opts.clearFlags` and `opts.setFlags` can be the following: | |
38088 | * - `{@link AuthRequiredFlag}` | |
38089 | * - `{@link AuthRevocableFlag}` | |
38090 | * - `{@link AuthImmutableFlag}` | |
38091 | * | |
38092 | * It's possible to set/clear multiple flags at once using logical or. | |
38093 | * @function | |
38094 | * @alias Operation.setOptions | |
38095 | * @param {object} opts | |
38096 | * @param {string} [opts.inflationDest] - Set this account ID as the account's inflation destination. | |
38097 | * @param {(number|string)} [opts.clearFlags] - Bitmap integer for which account flags to clear. | |
38098 | * @param {(number|string)} [opts.setFlags] - Bitmap integer for which account flags to set. | |
38099 | * @param {number|string} [opts.masterWeight] - The master key weight. | |
38100 | * @param {number|string} [opts.lowThreshold] - The sum weight for the low threshold. | |
38101 | * @param {number|string} [opts.medThreshold] - The sum weight for the medium threshold. | |
38102 | * @param {number|string} [opts.highThreshold] - The sum weight for the high threshold. | |
38103 | * @param {object} [opts.signer] - Add or remove a signer from the account. The signer is | |
38104 | * deleted if the weight is 0. Only one of `ed25519PublicKey`, `sha256Hash`, `preAuthTx` should be defined. | |
38105 | * @param {string} [opts.signer.ed25519PublicKey] - The ed25519 public key of the signer. | |
38106 | * @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. | |
38107 | * @param {Buffer|string} [opts.signer.preAuthTx] - Hash (Buffer or hex string) of transaction that will unlock funds. | |
38108 | * @param {number|string} [opts.signer.weight] - The weight of the new signer (0 to delete or 1-255) | |
38109 | * @param {string} [opts.homeDomain] - sets the home domain used for reverse federation lookup. | |
38110 | * @param {string} [opts.source] - The source account (defaults to transaction source). | |
38111 | * @returns {xdr.SetOptionsOp} | |
38112 | * @see [Account flags](https://www.stellar.org/developers/guides/concepts/accounts.html#flags) | |
38113 | */ | |
38114 | var setOptions = function setOptions(opts) { | |
38115 | var attributes = {}; | |
38116 | ||
38117 | if (opts.inflationDest) { | |
38118 | if (!StrKey.isValidEd25519PublicKey(opts.inflationDest)) { | |
38119 | throw new Error("inflationDest is invalid"); | |
38120 | } | |
38121 | attributes.inflationDest = Keypair.fromPublicKey(opts.inflationDest).xdrAccountId(); | |
38122 | } | |
38123 | ||
38124 | var weightCheckFunction = function (value, name) { | |
38125 | if (value >= 0 && value <= 255) { | |
38126 | return true; | |
38127 | } else { | |
38128 | throw new Error("" + name + " value must be between 0 and 255"); | |
38129 | } | |
38130 | }; | |
38131 | ||
38132 | attributes.clearFlags = this._checkUnsignedIntValue("clearFlags", opts.clearFlags); | |
38133 | attributes.setFlags = this._checkUnsignedIntValue("setFlags", opts.setFlags); | |
38134 | attributes.masterWeight = this._checkUnsignedIntValue("masterWeight", opts.masterWeight, weightCheckFunction); | |
38135 | attributes.lowThreshold = this._checkUnsignedIntValue("lowThreshold", opts.lowThreshold, weightCheckFunction); | |
38136 | attributes.medThreshold = this._checkUnsignedIntValue("medThreshold", opts.medThreshold, weightCheckFunction); | |
38137 | attributes.highThreshold = this._checkUnsignedIntValue("highThreshold", opts.highThreshold, weightCheckFunction); | |
38138 | ||
38139 | if (!isUndefined(opts.homeDomain) && !isString(opts.homeDomain)) { | |
38140 | throw new TypeError("homeDomain argument must be of type String"); | |
38141 | } | |
38142 | attributes.homeDomain = opts.homeDomain; | |
38143 | ||
38144 | if (opts.signer) { | |
38145 | var weight = this._checkUnsignedIntValue("signer.weight", opts.signer.weight, weightCheckFunction); | |
38146 | var key = undefined; | |
38147 | ||
38148 | var setValues = 0; | |
38149 | ||
38150 | if (opts.signer.ed25519PublicKey) { | |
38151 | if (!StrKey.isValidEd25519PublicKey(opts.signer.ed25519PublicKey)) { | |
38152 | throw new Error("signer.ed25519PublicKey is invalid."); | |
38153 | } | |
38154 | var rawKey = StrKey.decodeEd25519PublicKey(opts.signer.ed25519PublicKey); | |
38155 | key = new xdr.SignerKey.signerKeyTypeEd25519(rawKey); | |
38156 | setValues++; | |
38157 | } | |
38158 | ||
38159 | if (opts.signer.preAuthTx) { | |
38160 | if (isString(opts.signer.preAuthTx)) { | |
38161 | opts.signer.preAuthTx = Buffer.from(opts.signer.preAuthTx, "hex"); | |
38162 | } | |
38163 | ||
38164 | if (!(Buffer.isBuffer(opts.signer.preAuthTx) && opts.signer.preAuthTx.length == 32)) { | |
38165 | throw new Error("signer.preAuthTx must be 32 bytes Buffer."); | |
38166 | } | |
38167 | key = new xdr.SignerKey.signerKeyTypePreAuthTx(opts.signer.preAuthTx); | |
38168 | setValues++; | |
38169 | } | |
38170 | ||
38171 | if (opts.signer.sha256Hash) { | |
38172 | if (isString(opts.signer.sha256Hash)) { | |
38173 | opts.signer.sha256Hash = Buffer.from(opts.signer.sha256Hash, "hex"); | |
38174 | } | |
38175 | ||
38176 | if (!(Buffer.isBuffer(opts.signer.sha256Hash) && opts.signer.sha256Hash.length == 32)) { | |
38177 | throw new Error("signer.sha256Hash must be 32 bytes Buffer."); | |
38178 | } | |
38179 | key = new xdr.SignerKey.signerKeyTypeHashX(opts.signer.sha256Hash); | |
38180 | setValues++; | |
38181 | } | |
38182 | ||
38183 | if (setValues != 1) { | |
38184 | throw new Error("Signer object must contain exactly one of signer.ed25519PublicKey, signer.sha256Hash, signer.preAuthTx."); | |
38185 | } | |
38186 | ||
38187 | attributes.signer = new xdr.Signer({ key: key, weight: weight }); | |
38188 | } | |
38189 | ||
38190 | var setOptionsOp = new xdr.SetOptionsOp(attributes); | |
38191 | ||
38192 | var opAttributes = {}; | |
38193 | opAttributes.body = xdr.OperationBody.setOption(setOptionsOp); | |
38194 | this.setSourceAccount(opAttributes, opts); | |
38195 | ||
38196 | return new xdr.Operation(opAttributes); | |
38197 | }; | |
38198 | exports.setOptions = setOptions; | |
38199 | }).call(this,require("buffer").Buffer) | |
38200 | },{"../generated/stellar-xdr_generated":410,"../keypair":413,"../strkey":431,"buffer":50,"lodash/isString":337,"lodash/isUndefined":340}],430:[function(require,module,exports){ | |
38201 | (function (Buffer){ | |
38202 | "use strict"; | |
38203 | ||
38204 | exports.sign = sign; | |
38205 | exports.verify = verify; | |
38206 | Object.defineProperty(exports, "__esModule", { | |
38207 | value: true | |
38208 | }); | |
38209 | // This module provides the signing functionality used by the stellar network | |
38210 | // The code below may look a little strange... this is because we try to provide | |
38211 | // the most efficient signing method possible. First, we try to load the | |
38212 | // native ed25519 package for node.js environments, and if that fails we | |
38213 | // fallback to tweetnacl.js | |
38214 | ||
38215 | var actualMethods = {}; | |
38216 | ||
38217 | /** | |
38218 | * Use this flag to check if fast signing (provided by `ed25519` package) is available. | |
38219 | * If your app is signing a large number of transaction or verifying a large number | |
38220 | * of signatures make sure `ed25519` package is installed. | |
38221 | */ | |
38222 | var FastSigning = checkFastSigning(); | |
38223 | ||
38224 | exports.FastSigning = FastSigning; | |
38225 | ||
38226 | function sign(data, secretKey) { | |
38227 | return actualMethods.sign(data, secretKey); | |
38228 | } | |
38229 | ||
38230 | function verify(data, signature, publicKey) { | |
38231 | return actualMethods.verify(data, signature, publicKey); | |
38232 | } | |
38233 | ||
38234 | function checkFastSigning() { | |
38235 | return typeof window === "undefined" ? checkFastSigningNode() : checkFastSigningBrowser(); | |
38236 | } | |
38237 | ||
38238 | function checkFastSigningNode() { | |
38239 | // NOTE: we use commonjs style require here because es6 imports | |
38240 | // can only occur at the top level. thanks, obama. | |
38241 | var ed25519 = undefined; | |
38242 | try { | |
38243 | ed25519 = require("ed25519"); | |
38244 | } catch (err) { | |
38245 | return checkFastSigningBrowser(); | |
38246 | } | |
38247 | ||
38248 | actualMethods.sign = function (data, secretKey) { | |
38249 | return ed25519.Sign(Buffer.from(data), secretKey); | |
38250 | }; | |
38251 | ||
38252 | actualMethods.verify = function (data, signature, publicKey) { | |
38253 | data = Buffer.from(data); | |
38254 | try { | |
38255 | return ed25519.Verify(data, signature, publicKey); | |
38256 | } catch (e) { | |
38257 | return false; | |
38258 | } | |
38259 | }; | |
38260 | ||
38261 | return true; | |
38262 | } | |
38263 | ||
38264 | function checkFastSigningBrowser() { | |
38265 | // fallback to tweetnacl.js if we're in the browser or | |
38266 | // if there was a failure installing ed25519 | |
38267 | var nacl = require("tweetnacl"); | |
38268 | ||
38269 | actualMethods.sign = function (data, secretKey) { | |
38270 | data = Buffer.from(data); | |
38271 | data = new Uint8Array(data.toJSON().data); | |
38272 | secretKey = new Uint8Array(secretKey.toJSON().data); | |
38273 | ||
38274 | var signature = nacl.sign.detached(data, secretKey); | |
38275 | ||
38276 | return Buffer.from(signature); | |
38277 | }; | |
38278 | ||
38279 | actualMethods.verify = function (data, signature, publicKey) { | |
38280 | data = Buffer.from(data); | |
38281 | data = new Uint8Array(data.toJSON().data); | |
38282 | signature = new Uint8Array(signature.toJSON().data); | |
38283 | publicKey = new Uint8Array(publicKey.toJSON().data); | |
38284 | ||
38285 | return nacl.sign.detached.verify(data, signature, publicKey); | |
38286 | }; | |
38287 | ||
38288 | return false; | |
38289 | } | |
38290 | }).call(this,require("buffer").Buffer) | |
38291 | },{"buffer":50,"ed25519":20,"tweetnacl":440}],431:[function(require,module,exports){ | |
38292 | (function (Buffer){ | |
38293 | "use strict"; | |
38294 | ||
38295 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
38296 | ||
38297 | 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; }; })(); | |
38298 | ||
38299 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
38300 | ||
38301 | exports.decodeCheck = decodeCheck; | |
38302 | exports.encodeCheck = encodeCheck; | |
38303 | Object.defineProperty(exports, "__esModule", { | |
38304 | value: true | |
38305 | }); | |
38306 | ||
38307 | var base32 = _interopRequire(require("base32.js")); | |
38308 | ||
38309 | var crc = _interopRequire(require("crc")); | |
38310 | ||
38311 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
38312 | ||
38313 | var isNull = _interopRequire(require("lodash/isNull")); | |
38314 | ||
38315 | var isString = _interopRequire(require("lodash/isString")); | |
38316 | ||
38317 | var verifyChecksum = require("./util/checksum").verifyChecksum; | |
38318 | ||
38319 | var versionBytes = { | |
38320 | ed25519PublicKey: 6 << 3, // G | |
38321 | ed25519SecretSeed: 18 << 3, // S | |
38322 | preAuthTx: 19 << 3, // T | |
38323 | sha256Hash: 23 << 3 // X | |
38324 | }; | |
38325 | ||
38326 | /** | |
38327 | * StrKey is a helper class that allows encoding and decoding strkey. | |
38328 | */ | |
38329 | ||
38330 | var StrKey = exports.StrKey = (function () { | |
38331 | function StrKey() { | |
38332 | _classCallCheck(this, StrKey); | |
38333 | } | |
38334 | ||
38335 | _createClass(StrKey, null, { | |
38336 | encodeEd25519PublicKey: { | |
38337 | /** | |
38338 | * Encodes data to strkey ed25519 public key. | |
38339 | * @param {Buffer} data data to encode | |
38340 | * @returns {string} | |
38341 | */ | |
38342 | ||
38343 | value: function encodeEd25519PublicKey(data) { | |
38344 | return encodeCheck("ed25519PublicKey", data); | |
38345 | } | |
38346 | }, | |
38347 | decodeEd25519PublicKey: { | |
38348 | ||
38349 | /** | |
38350 | * Decodes strkey ed25519 public key to raw data. | |
38351 | * @param {string} data data to decode | |
38352 | * @returns {Buffer} | |
38353 | */ | |
38354 | ||
38355 | value: function decodeEd25519PublicKey(data) { | |
38356 | return decodeCheck("ed25519PublicKey", data); | |
38357 | } | |
38358 | }, | |
38359 | isValidEd25519PublicKey: { | |
38360 | ||
38361 | /** | |
38362 | * Returns true if the given Stellar public key is a valid ed25519 public key. | |
38363 | * @param {string} publicKey public key to check | |
38364 | * @returns {boolean} | |
38365 | */ | |
38366 | ||
38367 | value: function isValidEd25519PublicKey(publicKey) { | |
38368 | return isValid("ed25519PublicKey", publicKey); | |
38369 | } | |
38370 | }, | |
38371 | encodeEd25519SecretSeed: { | |
38372 | ||
38373 | /** | |
38374 | * Encodes data to strkey ed25519 seed. | |
38375 | * @param {Buffer} data data to encode | |
38376 | * @returns {string} | |
38377 | */ | |
38378 | ||
38379 | value: function encodeEd25519SecretSeed(data) { | |
38380 | return encodeCheck("ed25519SecretSeed", data); | |
38381 | } | |
38382 | }, | |
38383 | decodeEd25519SecretSeed: { | |
38384 | ||
38385 | /** | |
38386 | * Decodes strkey ed25519 seed to raw data. | |
38387 | * @param {string} data data to decode | |
38388 | * @returns {Buffer} | |
38389 | */ | |
38390 | ||
38391 | value: function decodeEd25519SecretSeed(data) { | |
38392 | return decodeCheck("ed25519SecretSeed", data); | |
38393 | } | |
38394 | }, | |
38395 | isValidEd25519SecretSeed: { | |
38396 | ||
38397 | /** | |
38398 | * Returns true if the given Stellar secret key is a valid ed25519 secret seed. | |
38399 | * @param {string} seed seed to check | |
38400 | * @returns {boolean} | |
38401 | */ | |
38402 | ||
38403 | value: function isValidEd25519SecretSeed(seed) { | |
38404 | return isValid("ed25519SecretSeed", seed); | |
38405 | } | |
38406 | }, | |
38407 | encodePreAuthTx: { | |
38408 | ||
38409 | /** | |
38410 | * Encodes data to strkey preAuthTx. | |
38411 | * @param {Buffer} data data to encode | |
38412 | * @returns {string} | |
38413 | */ | |
38414 | ||
38415 | value: function encodePreAuthTx(data) { | |
38416 | return encodeCheck("preAuthTx", data); | |
38417 | } | |
38418 | }, | |
38419 | decodePreAuthTx: { | |
38420 | ||
38421 | /** | |
38422 | * Decodes strkey PreAuthTx to raw data. | |
38423 | * @param {string} data data to decode | |
38424 | * @returns {Buffer} | |
38425 | */ | |
38426 | ||
38427 | value: function decodePreAuthTx(data) { | |
38428 | return decodeCheck("preAuthTx", data); | |
38429 | } | |
38430 | }, | |
38431 | encodeSha256Hash: { | |
38432 | ||
38433 | /** | |
38434 | * Encodes data to strkey sha256 hash. | |
38435 | * @param {Buffer} data data to encode | |
38436 | * @returns {string} | |
38437 | */ | |
38438 | ||
38439 | value: function encodeSha256Hash(data) { | |
38440 | return encodeCheck("sha256Hash", data); | |
38441 | } | |
38442 | }, | |
38443 | decodeSha256Hash: { | |
38444 | ||
38445 | /** | |
38446 | * Decodes strkey sha256 hash to raw data. | |
38447 | * @param {string} data data to decode | |
38448 | * @returns {Buffer} | |
38449 | */ | |
38450 | ||
38451 | value: function decodeSha256Hash(data) { | |
38452 | return decodeCheck("sha256Hash", data); | |
38453 | } | |
38454 | } | |
38455 | }); | |
38456 | ||
38457 | return StrKey; | |
38458 | })(); | |
38459 | ||
38460 | function isValid(versionByteName, encoded) { | |
38461 | if (encoded && encoded.length != 56) { | |
38462 | return false; | |
38463 | } | |
38464 | ||
38465 | try { | |
38466 | var decoded = decodeCheck(versionByteName, encoded); | |
38467 | if (decoded.length !== 32) { | |
38468 | return false; | |
38469 | } | |
38470 | } catch (err) { | |
38471 | return false; | |
38472 | } | |
38473 | return true; | |
38474 | } | |
38475 | ||
38476 | function decodeCheck(versionByteName, encoded) { | |
38477 | if (!isString(encoded)) { | |
38478 | throw new TypeError("encoded argument must be of type String"); | |
38479 | } | |
38480 | ||
38481 | var decoded = base32.decode(encoded); | |
38482 | var versionByte = decoded[0]; | |
38483 | var payload = decoded.slice(0, -2); | |
38484 | var data = payload.slice(1); | |
38485 | var checksum = decoded.slice(-2); | |
38486 | ||
38487 | if (encoded != base32.encode(decoded)) { | |
38488 | throw new Error("invalid encoded string"); | |
38489 | } | |
38490 | ||
38491 | var expectedVersion = versionBytes[versionByteName]; | |
38492 | ||
38493 | if (isUndefined(expectedVersion)) { | |
38494 | throw new Error("" + versionByteName + " is not a valid version byte name. expected one of \"accountId\" or \"seed\""); | |
38495 | } | |
38496 | ||
38497 | if (versionByte !== expectedVersion) { | |
38498 | throw new Error("invalid version byte. expected " + expectedVersion + ", got " + versionByte); | |
38499 | } | |
38500 | ||
38501 | var expectedChecksum = calculateChecksum(payload); | |
38502 | ||
38503 | if (!verifyChecksum(expectedChecksum, checksum)) { | |
38504 | throw new Error("invalid checksum"); | |
38505 | } | |
38506 | ||
38507 | return Buffer.from(data); | |
38508 | } | |
38509 | ||
38510 | function encodeCheck(versionByteName, data) { | |
38511 | if (isNull(data) || isUndefined(data)) { | |
38512 | throw new Error("cannot encode null data"); | |
38513 | } | |
38514 | ||
38515 | var versionByte = versionBytes[versionByteName]; | |
38516 | ||
38517 | if (isUndefined(versionByte)) { | |
38518 | throw new Error("" + versionByteName + " is not a valid version byte name. expected one of \"ed25519PublicKey\", \"ed25519SecretSeed\", \"preAuthTx\", \"sha256Hash\""); | |
38519 | } | |
38520 | ||
38521 | data = Buffer.from(data); | |
38522 | var versionBuffer = Buffer.from([versionByte]); | |
38523 | var payload = Buffer.concat([versionBuffer, data]); | |
38524 | var checksum = calculateChecksum(payload); | |
38525 | var unencoded = Buffer.concat([payload, checksum]); | |
38526 | ||
38527 | return base32.encode(unencoded); | |
38528 | } | |
38529 | ||
38530 | function calculateChecksum(payload) { | |
38531 | // This code calculates CRC16-XModem checksum of payload | |
38532 | // and returns it as Buffer in little-endian order. | |
38533 | var checksum = Buffer.alloc(2); | |
38534 | checksum.writeUInt16LE(crc.crc16xmodem(payload), 0); | |
38535 | return checksum; | |
38536 | } | |
38537 | }).call(this,require("buffer").Buffer) | |
38538 | },{"./util/checksum":434,"base32.js":15,"buffer":50,"crc":66,"lodash/isNull":331,"lodash/isString":337,"lodash/isUndefined":340}],432:[function(require,module,exports){ | |
38539 | (function (Buffer){ | |
38540 | "use strict"; | |
38541 | ||
38542 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
38543 | ||
38544 | 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; }; })(); | |
38545 | ||
38546 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
38547 | ||
38548 | Object.defineProperty(exports, "__esModule", { | |
38549 | value: true | |
38550 | }); | |
38551 | ||
38552 | var _index = require("./index"); | |
38553 | ||
38554 | var xdr = _index.xdr; | |
38555 | var hash = _index.hash; | |
38556 | ||
38557 | var StrKey = require("./strkey").StrKey; | |
38558 | ||
38559 | var Operation = require("./operation").Operation; | |
38560 | ||
38561 | var Network = require("./network").Network; | |
38562 | ||
38563 | var Memo = require("./memo").Memo; | |
38564 | ||
38565 | var map = _interopRequire(require("lodash/map")); | |
38566 | ||
38567 | var each = _interopRequire(require("lodash/each")); | |
38568 | ||
38569 | var isString = _interopRequire(require("lodash/isString")); | |
38570 | ||
38571 | var crypto = _interopRequire(require("crypto")); | |
38572 | ||
38573 | /** | |
38574 | * A new Transaction object is created from a transaction envelope or via {@link TransactionBuilder}. | |
38575 | * Once a Transaction has been created from an envelope, its attributes and operations | |
38576 | * should not be changed. You should only add signers (using {@link Transaction#sign}) to a Transaction object before | |
38577 | * submitting to the network or forwarding on to additional signers. | |
38578 | * @constructor | |
38579 | * @param {string|xdr.TransactionEnvelope} envelope - The transaction envelope object or base64 encoded string. | |
38580 | */ | |
38581 | ||
38582 | var Transaction = exports.Transaction = (function () { | |
38583 | function Transaction(envelope) { | |
38584 | _classCallCheck(this, Transaction); | |
38585 | ||
38586 | if (typeof envelope === "string") { | |
38587 | var buffer = Buffer.from(envelope, "base64"); | |
38588 | envelope = xdr.TransactionEnvelope.fromXDR(buffer); | |
38589 | } | |
38590 | // since this transaction is immutable, save the tx | |
38591 | this.tx = envelope.tx(); | |
38592 | this.source = StrKey.encodeEd25519PublicKey(envelope.tx().sourceAccount().ed25519()); | |
38593 | this.fee = this.tx.fee(); | |
38594 | this._memo = this.tx.memo(); | |
38595 | this.sequence = this.tx.seqNum().toString(); | |
38596 | ||
38597 | var timeBounds = this.tx.timeBounds(); | |
38598 | if (timeBounds) { | |
38599 | this.timeBounds = { | |
38600 | minTime: timeBounds.minTime().toString(), | |
38601 | maxTime: timeBounds.maxTime().toString() | |
38602 | }; | |
38603 | } | |
38604 | ||
38605 | var operations = this.tx.operations() || []; | |
38606 | this.operations = map(operations, function (op) { | |
38607 | return Operation.fromXDRObject(op); | |
38608 | }); | |
38609 | ||
38610 | var signatures = envelope.signatures() || []; | |
38611 | this.signatures = map(signatures, function (s) { | |
38612 | return s; | |
38613 | }); | |
38614 | } | |
38615 | ||
38616 | _createClass(Transaction, { | |
38617 | memo: { | |
38618 | get: function () { | |
38619 | return Memo.fromXDRObject(this._memo); | |
38620 | }, | |
38621 | set: function (value) { | |
38622 | throw new Error("Transaction is immutable"); | |
38623 | } | |
38624 | }, | |
38625 | sign: { | |
38626 | ||
38627 | /** | |
38628 | * Signs the transaction with the given {@link Keypair}. | |
38629 | * @param {...Keypair} keypairs Keypairs of signers | |
38630 | * @returns {void} | |
38631 | */ | |
38632 | ||
38633 | value: function sign() { | |
38634 | var _this = this; | |
38635 | ||
38636 | for (var _len = arguments.length, keypairs = Array(_len), _key = 0; _key < _len; _key++) { | |
38637 | keypairs[_key] = arguments[_key]; | |
38638 | } | |
38639 | ||
38640 | var txHash = this.hash(); | |
38641 | var newSigs = each(keypairs, function (kp) { | |
38642 | var sig = kp.signDecorated(txHash); | |
38643 | _this.signatures.push(sig); | |
38644 | }); | |
38645 | } | |
38646 | }, | |
38647 | signHashX: { | |
38648 | ||
38649 | /** | |
38650 | * Add `hashX` signer preimage as signature. | |
38651 | * @param {Buffer|String} preimage Preimage of hash used as signer | |
38652 | * @returns {void} | |
38653 | */ | |
38654 | ||
38655 | value: function signHashX(preimage) { | |
38656 | if (isString(preimage)) { | |
38657 | preimage = Buffer.from(preimage, "hex"); | |
38658 | } | |
38659 | ||
38660 | if (preimage.length > 64) { | |
38661 | throw new Error("preimage cannnot be longer than 64 bytes"); | |
38662 | } | |
38663 | ||
38664 | var signature = preimage; | |
38665 | var hash = crypto.createHash("sha256").update(preimage).digest(); | |
38666 | var hint = hash.slice(hash.length - 4); | |
38667 | this.signatures.push(new xdr.DecoratedSignature({ hint: hint, signature: signature })); | |
38668 | } | |
38669 | }, | |
38670 | hash: { | |
38671 | ||
38672 | /** | |
38673 | * Returns a hash for this transaction, suitable for signing. | |
38674 | * @returns {Buffer} | |
38675 | */ | |
38676 | ||
38677 | value: (function (_hash) { | |
38678 | var _hashWrapper = function hash() { | |
38679 | return _hash.apply(this, arguments); | |
38680 | }; | |
38681 | ||
38682 | _hashWrapper.toString = function () { | |
38683 | return _hash.toString(); | |
38684 | }; | |
38685 | ||
38686 | return _hashWrapper; | |
38687 | })(function () { | |
38688 | return hash(this.signatureBase()); | |
38689 | }) | |
38690 | }, | |
38691 | signatureBase: { | |
38692 | ||
38693 | /** | |
38694 | * Returns the "signature base" of this transaction, which is the value | |
38695 | * that, when hashed, should be signed to create a signature that | |
38696 | * validators on the Stellar Network will accept. | |
38697 | * | |
38698 | * It is composed of a 4 prefix bytes followed by the xdr-encoded form | |
38699 | * of this transaction. | |
38700 | * @returns {Buffer} | |
38701 | */ | |
38702 | ||
38703 | value: function signatureBase() { | |
38704 | if (Network.current() === null) { | |
38705 | throw new Error("No network selected. Use `Network.use`, `Network.usePublicNetwork` or `Network.useTestNetwork` helper methods to select network."); | |
38706 | } | |
38707 | ||
38708 | return Buffer.concat([Network.current().networkId(), xdr.EnvelopeType.envelopeTypeTx().toXDR(), this.tx.toXDR()]); | |
38709 | } | |
38710 | }, | |
38711 | toEnvelope: { | |
38712 | ||
38713 | /** | |
38714 | * To envelope returns a xdr.TransactionEnvelope which can be submitted to the network. | |
38715 | * @returns {xdr.TransactionEnvelope} | |
38716 | */ | |
38717 | ||
38718 | value: function toEnvelope() { | |
38719 | var tx = this.tx; | |
38720 | var signatures = this.signatures; | |
38721 | var envelope = new xdr.TransactionEnvelope({ tx: tx, signatures: signatures }); | |
38722 | ||
38723 | return envelope; | |
38724 | } | |
38725 | } | |
38726 | }); | |
38727 | ||
38728 | return Transaction; | |
38729 | })(); | |
38730 | }).call(this,require("buffer").Buffer) | |
38731 | },{"./index":412,"./memo":414,"./network":415,"./operation":416,"./strkey":431,"buffer":50,"crypto":72,"lodash/each":312,"lodash/isString":337,"lodash/map":343}],433:[function(require,module,exports){ | |
38732 | "use strict"; | |
38733 | ||
38734 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
38735 | ||
38736 | 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; }; })(); | |
38737 | ||
38738 | var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }; | |
38739 | ||
38740 | Object.defineProperty(exports, "__esModule", { | |
38741 | value: true | |
38742 | }); | |
38743 | ||
38744 | var xdr = _interopRequire(require("./generated/stellar-xdr_generated")); | |
38745 | ||
38746 | var UnsignedHyper = require("js-xdr").UnsignedHyper; | |
38747 | ||
38748 | var hash = require("./hashing").hash; | |
38749 | ||
38750 | var Keypair = require("./keypair").Keypair; | |
38751 | ||
38752 | var Account = require("./account").Account; | |
38753 | ||
38754 | var Operation = require("./operation").Operation; | |
38755 | ||
38756 | var Transaction = require("./transaction").Transaction; | |
38757 | ||
38758 | var Memo = require("./memo").Memo; | |
38759 | ||
38760 | var BigNumber = _interopRequire(require("bignumber.js")); | |
38761 | ||
38762 | var clone = _interopRequire(require("lodash/clone")); | |
38763 | ||
38764 | var map = _interopRequire(require("lodash/map")); | |
38765 | ||
38766 | var isUndefined = _interopRequire(require("lodash/isUndefined")); | |
38767 | ||
38768 | var BASE_FEE = 100; // Stroops | |
38769 | ||
38770 | /** | |
38771 | * @constant | |
38772 | * @see {@link TransactionBuilder#setTimeout} | |
38773 | * @see [Timeout](https://www.stellar.org/developers/horizon/reference/endpoints/transactions-create.html#timeout) | |
38774 | */ | |
38775 | var TimeoutInfinite = 0; | |
38776 | ||
38777 | exports.TimeoutInfinite = TimeoutInfinite; | |
38778 | /** | |
38779 | * <p>Transaction builder helps constructs a new `{@link Transaction}` using the given {@link Account} | |
38780 | * as the transaction's "source account". The transaction will use the current sequence | |
38781 | * number of the given account as its sequence number and increment the given account's | |
38782 | * sequence number by one. The given source account must include a private key for signing | |
38783 | * the transaction or an error will be thrown.</p> | |
38784 | * | |
38785 | * <p>Operations can be added to the transaction via their corresponding builder methods, and | |
38786 | * each returns the TransactionBuilder object so they can be chained together. After adding | |
38787 | * the desired operations, call the `build()` method on the `TransactionBuilder` to return a fully | |
38788 | * constructed `{@link Transaction}` that can be signed. The returned transaction will contain the | |
38789 | * sequence number of the source account and include the signature from the source account.</p> | |
38790 | * | |
38791 | * <p>The following code example creates a new transaction with {@link Operation.createAccount} and | |
38792 | * {@link Operation.payment} operations. | |
38793 | * The Transaction's source account first funds `destinationA`, then sends | |
38794 | * a payment to `destinationB`. The built transaction is then signed by `sourceKeypair`.</p> | |
38795 | * | |
38796 | * ``` | |
38797 | * var transaction = new TransactionBuilder(source) | |
38798 | * .addOperation(Operation.createAccount({ | |
38799 | destination: destinationA, | |
38800 | startingBalance: "20" | |
38801 | }) // <- funds and creates destinationA | |
38802 | .addOperation(Operation.payment({ | |
38803 | destination: destinationB, | |
38804 | amount: "100" | |
38805 | asset: Asset.native() | |
38806 | }) // <- sends 100 XLM to destinationB | |
38807 | * .setTimeout(30) | |
38808 | * .build(); | |
38809 | * | |
38810 | * transaction.sign(sourceKeypair); | |
38811 | * ``` | |
38812 | * @constructor | |
38813 | * @param {Account} sourceAccount - The source account for this transaction. | |
38814 | * @param {object} [opts] | |
38815 | * @param {number} [opts.fee] - The max fee willing to pay per operation in this transaction (**in stroops**). | |
38816 | * @param {object} [opts.timebounds] - The timebounds for the validity of this transaction. | |
38817 | * @param {number|string} [opts.timebounds.minTime] - 64 bit unix timestamp | |
38818 | * @param {number|string} [opts.timebounds.maxTime] - 64 bit unix timestamp | |
38819 | * @param {Memo} [opts.memo] - The memo for the transaction | |
38820 | */ | |
38821 | ||
38822 | var TransactionBuilder = exports.TransactionBuilder = (function () { | |
38823 | function TransactionBuilder(sourceAccount) { | |
38824 | var opts = arguments[1] === undefined ? {} : arguments[1]; | |
38825 | ||
38826 | _classCallCheck(this, TransactionBuilder); | |
38827 | ||
38828 | if (!sourceAccount) { | |
38829 | throw new Error("must specify source account for the transaction"); | |
38830 | } | |
38831 | this.source = sourceAccount; | |
38832 | this.operations = []; | |
38833 | this.baseFee = isUndefined(opts.fee) ? BASE_FEE : opts.fee; | |
38834 | this.timebounds = clone(opts.timebounds); | |
38835 | this.memo = opts.memo || Memo.none(); | |
38836 | this.timeoutSet = false; | |
38837 | } | |
38838 | ||
38839 | _createClass(TransactionBuilder, { | |
38840 | addOperation: { | |
38841 | ||
38842 | /** | |
38843 | * Adds an operation to the transaction. | |
38844 | * @param {xdr.Operation} operation The xdr operation object, use {@link Operation} static methods. | |
38845 | * @returns {TransactionBuilder} | |
38846 | */ | |
38847 | ||
38848 | value: function addOperation(operation) { | |
38849 | this.operations.push(operation); | |
38850 | return this; | |
38851 | } | |
38852 | }, | |
38853 | addMemo: { | |
38854 | ||
38855 | /** | |
38856 | * Adds a memo to the transaction. | |
38857 | * @param {Memo} memo {@link Memo} object | |
38858 | * @returns {TransactionBuilder} | |
38859 | */ | |
38860 | ||
38861 | value: function addMemo(memo) { | |
38862 | this.memo = memo; | |
38863 | return this; | |
38864 | } | |
38865 | }, | |
38866 | setTimeout: { | |
38867 | ||
38868 | /** | |
38869 | * Because of the distributed nature of the Stellar network it is possible that the status of your transaction | |
38870 | * will be determined after a long time if the network is highly congested. | |
38871 | * If you want to be sure to receive the status of the transaction within a given period you should set the | |
38872 | * {@link TimeBounds} with <code>maxTime</code> on the transaction (this is what <code>setTimeout</code> does | |
38873 | * internally; if there's <code>minTime</code> set but no <code>maxTime</code> it will be added). | |
38874 | * Call to <code>TransactionBuilder.setTimeout</code> is required if Transaction does not have <code>max_time</code> set. | |
38875 | * If you don't want to set timeout, use <code>{@link TimeoutInfinite}</code>. In general you should set | |
38876 | * <code>{@link TimeoutInfinite}</code> only in smart contracts. | |
38877 | * | |
38878 | * Please note that Horizon may still return <code>504 Gateway Timeout</code> error, even for short timeouts. | |
38879 | * In such case you need to resubmit the same transaction again without making any changes to receive a status. | |
38880 | * This method is using the machine system time (UTC), make sure it is set correctly. | |
38881 | * @param {timeout} Timeout in seconds. | |
38882 | * @return {TransactionBuilder} | |
38883 | * @see TimeoutInfinite | |
38884 | */ | |
38885 | ||
38886 | value: function setTimeout(timeout) { | |
38887 | if (this.timebounds != null && this.timebounds.maxTime > 0) { | |
38888 | throw new Error("TimeBounds.max_time has been already set - setting timeout would overwrite it."); | |
38889 | } | |
38890 | ||
38891 | if (timeout < 0) { | |
38892 | throw new Error("timeout cannot be negative"); | |
38893 | } | |
38894 | ||
38895 | this.timeoutSet = true; | |
38896 | if (timeout > 0) { | |
38897 | var timeoutTimestamp = Math.floor(Date.now() / 1000) + timeout; | |
38898 | if (this.timebounds == null) { | |
38899 | this.timebounds = { minTime: 0, maxTime: timeoutTimestamp }; | |
38900 | } else { | |
38901 | this.timebounds = { minTime: this.timebounds.minTime, maxTime: timeoutTimestamp }; | |
38902 | } | |
38903 | } | |
38904 | ||
38905 | return this; | |
38906 | } | |
38907 | }, | |
38908 | build: { | |
38909 | ||
38910 | /** | |
38911 | * This will build the transaction. | |
38912 | * It will also increment the source account's sequence number by 1. | |
38913 | * @returns {Transaction} This method will return the built {@link Transaction}. | |
38914 | */ | |
38915 | ||
38916 | value: function build() { | |
38917 | // Ensure setTimeout called or maxTime is set | |
38918 | if ((this.timebounds == null || this.timebounds != null && this.timebounds.maxTime == 0) && !this.timeoutSet) { | |
38919 | throw new Error("TimeBounds has to be set or you must call setTimeout(TimeoutInfinite)."); | |
38920 | } | |
38921 | ||
38922 | var sequenceNumber = new BigNumber(this.source.sequenceNumber()).add(1); | |
38923 | ||
38924 | var attrs = { | |
38925 | sourceAccount: Keypair.fromPublicKey(this.source.accountId()).xdrAccountId(), | |
38926 | fee: this.baseFee * this.operations.length, | |
38927 | seqNum: xdr.SequenceNumber.fromString(sequenceNumber.toString()), | |
38928 | memo: this.memo ? this.memo.toXDRObject() : null, | |
38929 | ext: new xdr.TransactionExt(0) | |
38930 | }; | |
38931 | ||
38932 | if (this.timebounds) { | |
38933 | this.timebounds.minTime = UnsignedHyper.fromString(this.timebounds.minTime.toString()); | |
38934 | this.timebounds.maxTime = UnsignedHyper.fromString(this.timebounds.maxTime.toString()); | |
38935 | attrs.timeBounds = new xdr.TimeBounds(this.timebounds); | |
38936 | } | |
38937 | ||
38938 | var xtx = new xdr.Transaction(attrs); | |
38939 | xtx.operations(this.operations); | |
38940 | ||
38941 | var xenv = new xdr.TransactionEnvelope({ tx: xtx }); | |
38942 | var tx = new Transaction(xenv); | |
38943 | ||
38944 | this.source.incrementSequenceNumber(); | |
38945 | ||
38946 | return tx; | |
38947 | } | |
38948 | } | |
38949 | }); | |
38950 | ||
38951 | return TransactionBuilder; | |
38952 | })(); | |
38953 | },{"./account":407,"./generated/stellar-xdr_generated":410,"./hashing":411,"./keypair":413,"./memo":414,"./operation":416,"./transaction":432,"bignumber.js":17,"js-xdr":131,"lodash/clone":310,"lodash/isUndefined":340,"lodash/map":343}],434:[function(require,module,exports){ | |
38954 | "use strict"; | |
38955 | ||
38956 | exports.verifyChecksum = verifyChecksum; | |
38957 | Object.defineProperty(exports, "__esModule", { | |
38958 | value: true | |
38959 | }); | |
38960 | ||
38961 | function verifyChecksum(expected, actual) { | |
38962 | if (expected.length !== actual.length) { | |
38963 | return false; | |
38964 | } | |
38965 | ||
38966 | if (expected.length === 0) { | |
38967 | return true; | |
38968 | } | |
38969 | ||
38970 | for (var i = 0; i < expected.length; i++) { | |
38971 | if (expected[i] !== actual[i]) { | |
38972 | return false; | |
38973 | } | |
38974 | } | |
38975 | ||
38976 | return true; | |
38977 | } | |
38978 | },{}],435:[function(require,module,exports){ | |
38979 | "use strict"; | |
38980 | ||
38981 | var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; }; | |
38982 | ||
38983 | 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"); } }; | |
38984 | ||
38985 | /** | |
38986 | * Calculates and returns the best rational approximation of the given real number. | |
38987 | * @private | |
38988 | * @param {string|number|BigNumber} number | |
38989 | * @throws Error Throws `Error` when the best rational approximation cannot be found. | |
38990 | * @returns {array} first element is n (numerator), second element is d (denominator) | |
38991 | */ | |
38992 | exports.best_r = best_r; | |
38993 | Object.defineProperty(exports, "__esModule", { | |
38994 | value: true | |
38995 | }); | |
38996 | ||
38997 | var BigNumber = _interopRequire(require("bignumber.js")); | |
38998 | ||
38999 | var MAX_INT = (1 << 31 >>> 0) - 1; | |
39000 | function best_r(number) { | |
39001 | number = new BigNumber(number); | |
39002 | var a; | |
39003 | var f; | |
39004 | var fractions = [[new BigNumber(0), new BigNumber(1)], [new BigNumber(1), new BigNumber(0)]]; | |
39005 | var i = 2; | |
39006 | while (true) { | |
39007 | if (number.gt(MAX_INT)) { | |
39008 | break; | |
39009 | } | |
39010 | a = number.floor(); | |
39011 | f = number.sub(a); | |
39012 | var h = a.mul(fractions[i - 1][0]).add(fractions[i - 2][0]); | |
39013 | var k = a.mul(fractions[i - 1][1]).add(fractions[i - 2][1]); | |
39014 | if (h.gt(MAX_INT) || k.gt(MAX_INT)) { | |
39015 | break; | |
39016 | } | |
39017 | fractions.push([h, k]); | |
39018 | if (f.eq(0)) { | |
39019 | break; | |
39020 | } | |
39021 | number = new BigNumber(1).div(f); | |
39022 | i++; | |
39023 | } | |
39024 | ||
39025 | var _fractions = _slicedToArray(fractions[fractions.length - 1], 2); | |
39026 | ||
39027 | var n = _fractions[0]; | |
39028 | var d = _fractions[1]; | |
39029 | ||
39030 | if (n.isZero() || d.isZero()) { | |
39031 | throw new Error("Couldn't find approximation"); | |
39032 | } | |
39033 | ||
39034 | return [n.toNumber(), d.toNumber()]; | |
39035 | } | |
39036 | },{"bignumber.js":17}],436:[function(require,module,exports){ | |
39037 | // vendored from http://cryptocoinjs.com/modules/misc/bs58/ | |
39038 | ||
39039 | // Base58 encoding/decoding | |
39040 | // Originally written by Mike Hearn for BitcoinJ | |
39041 | // Copyright (c) 2011 Google Inc | |
39042 | // Ported to JavaScript by Stefan Thomas | |
39043 | // Merged Buffer refactorings from base58-native by Stephen Pair | |
39044 | // Copyright (c) 2013 BitPay Inc | |
39045 | ||
39046 | "use strict"; | |
39047 | ||
39048 | var ALPHABET = "gsphnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCr65jkm8oFqi1tuvAxyz"; | |
39049 | var ALPHABET_MAP = {}; | |
39050 | for (var i = 0; i < ALPHABET.length; ++i) { | |
39051 | ALPHABET_MAP[ALPHABET.charAt(i)] = i; | |
39052 | } | |
39053 | var BASE = 58; | |
39054 | ||
39055 | function decode(string) { | |
39056 | if (string.length === 0) { | |
39057 | return []; | |
39058 | }var i, | |
39059 | j, | |
39060 | bytes = [0]; | |
39061 | for (i = 0; i < string.length; ++i) { | |
39062 | var c = string[i]; | |
39063 | if (!(c in ALPHABET_MAP)) throw new Error("Non-base58 character"); | |
39064 | ||
39065 | for (j = 0; j < bytes.length; ++j) bytes[j] *= BASE; | |
39066 | bytes[0] += ALPHABET_MAP[c]; | |
39067 | ||
39068 | var carry = 0; | |
39069 | for (j = 0; j < bytes.length; ++j) { | |
39070 | bytes[j] += carry; | |
39071 | ||
39072 | carry = bytes[j] >> 8; | |
39073 | bytes[j] &= 255; | |
39074 | } | |
39075 | ||
39076 | while (carry) { | |
39077 | bytes.push(carry & 255); | |
39078 | ||
39079 | carry >>= 8; | |
39080 | } | |
39081 | } | |
39082 | ||
39083 | // deal with leading zeros | |
39084 | for (i = 0; string[i] === "g" && i < string.length - 1; ++i) bytes.push(0); | |
39085 | ||
39086 | return bytes.reverse(); | |
39087 | } | |
39088 | ||
39089 | module.exports = { decode: decode }; | |
39090 | },{}],437:[function(require,module,exports){ | |
39091 | // Copyright Joyent, Inc. and other Node contributors. | |
39092 | // | |
39093 | // Permission is hereby granted, free of charge, to any person obtaining a | |
39094 | // copy of this software and associated documentation files (the | |
39095 | // "Software"), to deal in the Software without restriction, including | |
39096 | // without limitation the rights to use, copy, modify, merge, publish, | |
39097 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
39098 | // persons to whom the Software is furnished to do so, subject to the | |
39099 | // following conditions: | |
39100 | // | |
39101 | // The above copyright notice and this permission notice shall be included | |
39102 | // in all copies or substantial portions of the Software. | |
39103 | // | |
39104 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
39105 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
39106 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
39107 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
39108 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
39109 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
39110 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
39111 | ||
39112 | module.exports = Stream; | |
39113 | ||
39114 | var EE = require('events').EventEmitter; | |
39115 | var inherits = require('inherits'); | |
39116 | ||
39117 | inherits(Stream, EE); | |
39118 | Stream.Readable = require('readable-stream/readable.js'); | |
39119 | Stream.Writable = require('readable-stream/writable.js'); | |
39120 | Stream.Duplex = require('readable-stream/duplex.js'); | |
39121 | Stream.Transform = require('readable-stream/transform.js'); | |
39122 | Stream.PassThrough = require('readable-stream/passthrough.js'); | |
39123 | ||
39124 | // Backwards-compat with node 0.4.x | |
39125 | Stream.Stream = Stream; | |
39126 | ||
39127 | ||
39128 | ||
39129 | // old-style streams. Note that the pipe method (the only relevant | |
39130 | // part of this class) is overridden in the Readable class. | |
39131 | ||
39132 | function Stream() { | |
39133 | EE.call(this); | |
39134 | } | |
39135 | ||
39136 | Stream.prototype.pipe = function(dest, options) { | |
39137 | var source = this; | |
39138 | ||
39139 | function ondata(chunk) { | |
39140 | if (dest.writable) { | |
39141 | if (false === dest.write(chunk) && source.pause) { | |
39142 | source.pause(); | |
39143 | } | |
39144 | } | |
39145 | } | |
39146 | ||
39147 | source.on('data', ondata); | |
39148 | ||
39149 | function ondrain() { | |
39150 | if (source.readable && source.resume) { | |
39151 | source.resume(); | |
39152 | } | |
39153 | } | |
39154 | ||
39155 | dest.on('drain', ondrain); | |
39156 | ||
39157 | // If the 'end' option is not supplied, dest.end() will be called when | |
39158 | // source gets the 'end' or 'close' events. Only dest.end() once. | |
39159 | if (!dest._isStdio && (!options || options.end !== false)) { | |
39160 | source.on('end', onend); | |
39161 | source.on('close', onclose); | |
39162 | } | |
39163 | ||
39164 | var didOnEnd = false; | |
39165 | function onend() { | |
39166 | if (didOnEnd) return; | |
39167 | didOnEnd = true; | |
39168 | ||
39169 | dest.end(); | |
39170 | } | |
39171 | ||
39172 | ||
39173 | function onclose() { | |
39174 | if (didOnEnd) return; | |
39175 | didOnEnd = true; | |
39176 | ||
39177 | if (typeof dest.destroy === 'function') dest.destroy(); | |
39178 | } | |
39179 | ||
39180 | // don't leave dangling pipes when there are errors. | |
39181 | function onerror(er) { | |
39182 | cleanup(); | |
39183 | if (EE.listenerCount(this, 'error') === 0) { | |
39184 | throw er; // Unhandled stream error in pipe. | |
39185 | } | |
39186 | } | |
39187 | ||
39188 | source.on('error', onerror); | |
39189 | dest.on('error', onerror); | |
39190 | ||
39191 | // remove all the event listeners that were added. | |
39192 | function cleanup() { | |
39193 | source.removeListener('data', ondata); | |
39194 | dest.removeListener('drain', ondrain); | |
39195 | ||
39196 | source.removeListener('end', onend); | |
39197 | source.removeListener('close', onclose); | |
39198 | ||
39199 | source.removeListener('error', onerror); | |
39200 | dest.removeListener('error', onerror); | |
39201 | ||
39202 | source.removeListener('end', cleanup); | |
39203 | source.removeListener('close', cleanup); | |
39204 | ||
39205 | dest.removeListener('close', cleanup); | |
39206 | } | |
39207 | ||
39208 | source.on('end', cleanup); | |
39209 | source.on('close', cleanup); | |
39210 | ||
39211 | dest.on('close', cleanup); | |
39212 | ||
39213 | dest.emit('pipe', source); | |
39214 | ||
39215 | // Allow for unix-like usage: A.pipe(B).pipe(C) | |
39216 | return dest; | |
39217 | }; | |
39218 | ||
39219 | },{"events":102,"inherits":119,"readable-stream/duplex.js":383,"readable-stream/passthrough.js":393,"readable-stream/readable.js":394,"readable-stream/transform.js":395,"readable-stream/writable.js":396}],438:[function(require,module,exports){ | |
39220 | arguments[4][392][0].apply(exports,arguments) | |
39221 | },{"dup":392,"safe-buffer":398}],439:[function(require,module,exports){ | |
39222 | (function (setImmediate,clearImmediate){ | |
39223 | var nextTick = require('process/browser.js').nextTick; | |
39224 | var apply = Function.prototype.apply; | |
39225 | var slice = Array.prototype.slice; | |
39226 | var immediateIds = {}; | |
39227 | var nextImmediateId = 0; | |
39228 | ||
39229 | // DOM APIs, for completeness | |
39230 | ||
39231 | exports.setTimeout = function() { | |
39232 | return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); | |
39233 | }; | |
39234 | exports.setInterval = function() { | |
39235 | return new Timeout(apply.call(setInterval, window, arguments), clearInterval); | |
39236 | }; | |
39237 | exports.clearTimeout = | |
39238 | exports.clearInterval = function(timeout) { timeout.close(); }; | |
39239 | ||
39240 | function Timeout(id, clearFn) { | |
39241 | this._id = id; | |
39242 | this._clearFn = clearFn; | |
39243 | } | |
39244 | Timeout.prototype.unref = Timeout.prototype.ref = function() {}; | |
39245 | Timeout.prototype.close = function() { | |
39246 | this._clearFn.call(window, this._id); | |
39247 | }; | |
39248 | ||
39249 | // Does not start the time, just sets up the members needed. | |
39250 | exports.enroll = function(item, msecs) { | |
39251 | clearTimeout(item._idleTimeoutId); | |
39252 | item._idleTimeout = msecs; | |
39253 | }; | |
39254 | ||
39255 | exports.unenroll = function(item) { | |
39256 | clearTimeout(item._idleTimeoutId); | |
39257 | item._idleTimeout = -1; | |
39258 | }; | |
39259 | ||
39260 | exports._unrefActive = exports.active = function(item) { | |
39261 | clearTimeout(item._idleTimeoutId); | |
39262 | ||
39263 | var msecs = item._idleTimeout; | |
39264 | if (msecs >= 0) { | |
39265 | item._idleTimeoutId = setTimeout(function onTimeout() { | |
39266 | if (item._onTimeout) | |
39267 | item._onTimeout(); | |
39268 | }, msecs); | |
39269 | } | |
39270 | }; | |
39271 | ||
39272 | // That's not how node.js implements it but the exposed api is the same. | |
39273 | exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { | |
39274 | var id = nextImmediateId++; | |
39275 | var args = arguments.length < 2 ? false : slice.call(arguments, 1); | |
39276 | ||
39277 | immediateIds[id] = true; | |
39278 | ||
39279 | nextTick(function onNextTick() { | |
39280 | if (immediateIds[id]) { | |
39281 | // fn.call() is faster so we optimize for the common use-case | |
39282 | // @see http://jsperf.com/call-apply-segu | |
39283 | if (args) { | |
39284 | fn.apply(null, args); | |
39285 | } else { | |
39286 | fn.call(null); | |
39287 | } | |
39288 | // Prevent ids from leaking | |
39289 | exports.clearImmediate(id); | |
39290 | } | |
39291 | }); | |
39292 | ||
39293 | return id; | |
39294 | }; | |
39295 | ||
39296 | exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { | |
39297 | delete immediateIds[id]; | |
39298 | }; | |
39299 | }).call(this,require("timers").setImmediate,require("timers").clearImmediate) | |
39300 | },{"process/browser.js":374,"timers":439}],440:[function(require,module,exports){ | |
39301 | (function(nacl) { | |
39302 | 'use strict'; | |
39303 | ||
39304 | // Ported in 2014 by Dmitry Chestnykh and Devi Mandiri. | |
39305 | // Public domain. | |
39306 | // | |
39307 | // Implementation derived from TweetNaCl version 20140427. | |
39308 | // See for details: http://tweetnacl.cr.yp.to/ | |
39309 | ||
39310 | var gf = function(init) { | |
39311 | var i, r = new Float64Array(16); | |
39312 | if (init) for (i = 0; i < init.length; i++) r[i] = init[i]; | |
39313 | return r; | |
39314 | }; | |
39315 | ||
39316 | // Pluggable, initialized in high-level API below. | |
39317 | var randombytes = function(/* x, n */) { throw new Error('no PRNG'); }; | |
39318 | ||
39319 | var _0 = new Uint8Array(16); | |
39320 | var _9 = new Uint8Array(32); _9[0] = 9; | |
39321 | ||
39322 | var gf0 = gf(), | |
39323 | gf1 = gf([1]), | |
39324 | _121665 = gf([0xdb41, 1]), | |
39325 | D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]), | |
39326 | D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]), | |
39327 | X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]), | |
39328 | Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]), | |
39329 | I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]); | |
39330 | ||
39331 | function ts64(x, i, h, l) { | |
39332 | x[i] = (h >> 24) & 0xff; | |
39333 | x[i+1] = (h >> 16) & 0xff; | |
39334 | x[i+2] = (h >> 8) & 0xff; | |
39335 | x[i+3] = h & 0xff; | |
39336 | x[i+4] = (l >> 24) & 0xff; | |
39337 | x[i+5] = (l >> 16) & 0xff; | |
39338 | x[i+6] = (l >> 8) & 0xff; | |
39339 | x[i+7] = l & 0xff; | |
39340 | } | |
39341 | ||
39342 | function vn(x, xi, y, yi, n) { | |
39343 | var i,d = 0; | |
39344 | for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i]; | |
39345 | return (1 & ((d - 1) >>> 8)) - 1; | |
39346 | } | |
39347 | ||
39348 | function crypto_verify_16(x, xi, y, yi) { | |
39349 | return vn(x,xi,y,yi,16); | |
39350 | } | |
39351 | ||
39352 | function crypto_verify_32(x, xi, y, yi) { | |
39353 | return vn(x,xi,y,yi,32); | |
39354 | } | |
39355 | ||
39356 | function core_salsa20(o, p, k, c) { | |
39357 | var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24, | |
39358 | j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24, | |
39359 | j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24, | |
39360 | j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24, | |
39361 | j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24, | |
39362 | j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24, | |
39363 | j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24, | |
39364 | j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24, | |
39365 | j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24, | |
39366 | j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24, | |
39367 | j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24, | |
39368 | j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24, | |
39369 | j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24, | |
39370 | j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24, | |
39371 | j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24, | |
39372 | j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24; | |
39373 | ||
39374 | var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, | |
39375 | x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, | |
39376 | x15 = j15, u; | |
39377 | ||
39378 | for (var i = 0; i < 20; i += 2) { | |
39379 | u = x0 + x12 | 0; | |
39380 | x4 ^= u<<7 | u>>>(32-7); | |
39381 | u = x4 + x0 | 0; | |
39382 | x8 ^= u<<9 | u>>>(32-9); | |
39383 | u = x8 + x4 | 0; | |
39384 | x12 ^= u<<13 | u>>>(32-13); | |
39385 | u = x12 + x8 | 0; | |
39386 | x0 ^= u<<18 | u>>>(32-18); | |
39387 | ||
39388 | u = x5 + x1 | 0; | |
39389 | x9 ^= u<<7 | u>>>(32-7); | |
39390 | u = x9 + x5 | 0; | |
39391 | x13 ^= u<<9 | u>>>(32-9); | |
39392 | u = x13 + x9 | 0; | |
39393 | x1 ^= u<<13 | u>>>(32-13); | |
39394 | u = x1 + x13 | 0; | |
39395 | x5 ^= u<<18 | u>>>(32-18); | |
39396 | ||
39397 | u = x10 + x6 | 0; | |
39398 | x14 ^= u<<7 | u>>>(32-7); | |
39399 | u = x14 + x10 | 0; | |
39400 | x2 ^= u<<9 | u>>>(32-9); | |
39401 | u = x2 + x14 | 0; | |
39402 | x6 ^= u<<13 | u>>>(32-13); | |
39403 | u = x6 + x2 | 0; | |
39404 | x10 ^= u<<18 | u>>>(32-18); | |
39405 | ||
39406 | u = x15 + x11 | 0; | |
39407 | x3 ^= u<<7 | u>>>(32-7); | |
39408 | u = x3 + x15 | 0; | |
39409 | x7 ^= u<<9 | u>>>(32-9); | |
39410 | u = x7 + x3 | 0; | |
39411 | x11 ^= u<<13 | u>>>(32-13); | |
39412 | u = x11 + x7 | 0; | |
39413 | x15 ^= u<<18 | u>>>(32-18); | |
39414 | ||
39415 | u = x0 + x3 | 0; | |
39416 | x1 ^= u<<7 | u>>>(32-7); | |
39417 | u = x1 + x0 | 0; | |
39418 | x2 ^= u<<9 | u>>>(32-9); | |
39419 | u = x2 + x1 | 0; | |
39420 | x3 ^= u<<13 | u>>>(32-13); | |
39421 | u = x3 + x2 | 0; | |
39422 | x0 ^= u<<18 | u>>>(32-18); | |
39423 | ||
39424 | u = x5 + x4 | 0; | |
39425 | x6 ^= u<<7 | u>>>(32-7); | |
39426 | u = x6 + x5 | 0; | |
39427 | x7 ^= u<<9 | u>>>(32-9); | |
39428 | u = x7 + x6 | 0; | |
39429 | x4 ^= u<<13 | u>>>(32-13); | |
39430 | u = x4 + x7 | 0; | |
39431 | x5 ^= u<<18 | u>>>(32-18); | |
39432 | ||
39433 | u = x10 + x9 | 0; | |
39434 | x11 ^= u<<7 | u>>>(32-7); | |
39435 | u = x11 + x10 | 0; | |
39436 | x8 ^= u<<9 | u>>>(32-9); | |
39437 | u = x8 + x11 | 0; | |
39438 | x9 ^= u<<13 | u>>>(32-13); | |
39439 | u = x9 + x8 | 0; | |
39440 | x10 ^= u<<18 | u>>>(32-18); | |
39441 | ||
39442 | u = x15 + x14 | 0; | |
39443 | x12 ^= u<<7 | u>>>(32-7); | |
39444 | u = x12 + x15 | 0; | |
39445 | x13 ^= u<<9 | u>>>(32-9); | |
39446 | u = x13 + x12 | 0; | |
39447 | x14 ^= u<<13 | u>>>(32-13); | |
39448 | u = x14 + x13 | 0; | |
39449 | x15 ^= u<<18 | u>>>(32-18); | |
39450 | } | |
39451 | x0 = x0 + j0 | 0; | |
39452 | x1 = x1 + j1 | 0; | |
39453 | x2 = x2 + j2 | 0; | |
39454 | x3 = x3 + j3 | 0; | |
39455 | x4 = x4 + j4 | 0; | |
39456 | x5 = x5 + j5 | 0; | |
39457 | x6 = x6 + j6 | 0; | |
39458 | x7 = x7 + j7 | 0; | |
39459 | x8 = x8 + j8 | 0; | |
39460 | x9 = x9 + j9 | 0; | |
39461 | x10 = x10 + j10 | 0; | |
39462 | x11 = x11 + j11 | 0; | |
39463 | x12 = x12 + j12 | 0; | |
39464 | x13 = x13 + j13 | 0; | |
39465 | x14 = x14 + j14 | 0; | |
39466 | x15 = x15 + j15 | 0; | |
39467 | ||
39468 | o[ 0] = x0 >>> 0 & 0xff; | |
39469 | o[ 1] = x0 >>> 8 & 0xff; | |
39470 | o[ 2] = x0 >>> 16 & 0xff; | |
39471 | o[ 3] = x0 >>> 24 & 0xff; | |
39472 | ||
39473 | o[ 4] = x1 >>> 0 & 0xff; | |
39474 | o[ 5] = x1 >>> 8 & 0xff; | |
39475 | o[ 6] = x1 >>> 16 & 0xff; | |
39476 | o[ 7] = x1 >>> 24 & 0xff; | |
39477 | ||
39478 | o[ 8] = x2 >>> 0 & 0xff; | |
39479 | o[ 9] = x2 >>> 8 & 0xff; | |
39480 | o[10] = x2 >>> 16 & 0xff; | |
39481 | o[11] = x2 >>> 24 & 0xff; | |
39482 | ||
39483 | o[12] = x3 >>> 0 & 0xff; | |
39484 | o[13] = x3 >>> 8 & 0xff; | |
39485 | o[14] = x3 >>> 16 & 0xff; | |
39486 | o[15] = x3 >>> 24 & 0xff; | |
39487 | ||
39488 | o[16] = x4 >>> 0 & 0xff; | |
39489 | o[17] = x4 >>> 8 & 0xff; | |
39490 | o[18] = x4 >>> 16 & 0xff; | |
39491 | o[19] = x4 >>> 24 & 0xff; | |
39492 | ||
39493 | o[20] = x5 >>> 0 & 0xff; | |
39494 | o[21] = x5 >>> 8 & 0xff; | |
39495 | o[22] = x5 >>> 16 & 0xff; | |
39496 | o[23] = x5 >>> 24 & 0xff; | |
39497 | ||
39498 | o[24] = x6 >>> 0 & 0xff; | |
39499 | o[25] = x6 >>> 8 & 0xff; | |
39500 | o[26] = x6 >>> 16 & 0xff; | |
39501 | o[27] = x6 >>> 24 & 0xff; | |
39502 | ||
39503 | o[28] = x7 >>> 0 & 0xff; | |
39504 | o[29] = x7 >>> 8 & 0xff; | |
39505 | o[30] = x7 >>> 16 & 0xff; | |
39506 | o[31] = x7 >>> 24 & 0xff; | |
39507 | ||
39508 | o[32] = x8 >>> 0 & 0xff; | |
39509 | o[33] = x8 >>> 8 & 0xff; | |
39510 | o[34] = x8 >>> 16 & 0xff; | |
39511 | o[35] = x8 >>> 24 & 0xff; | |
39512 | ||
39513 | o[36] = x9 >>> 0 & 0xff; | |
39514 | o[37] = x9 >>> 8 & 0xff; | |
39515 | o[38] = x9 >>> 16 & 0xff; | |
39516 | o[39] = x9 >>> 24 & 0xff; | |
39517 | ||
39518 | o[40] = x10 >>> 0 & 0xff; | |
39519 | o[41] = x10 >>> 8 & 0xff; | |
39520 | o[42] = x10 >>> 16 & 0xff; | |
39521 | o[43] = x10 >>> 24 & 0xff; | |
39522 | ||
39523 | o[44] = x11 >>> 0 & 0xff; | |
39524 | o[45] = x11 >>> 8 & 0xff; | |
39525 | o[46] = x11 >>> 16 & 0xff; | |
39526 | o[47] = x11 >>> 24 & 0xff; | |
39527 | ||
39528 | o[48] = x12 >>> 0 & 0xff; | |
39529 | o[49] = x12 >>> 8 & 0xff; | |
39530 | o[50] = x12 >>> 16 & 0xff; | |
39531 | o[51] = x12 >>> 24 & 0xff; | |
39532 | ||
39533 | o[52] = x13 >>> 0 & 0xff; | |
39534 | o[53] = x13 >>> 8 & 0xff; | |
39535 | o[54] = x13 >>> 16 & 0xff; | |
39536 | o[55] = x13 >>> 24 & 0xff; | |
39537 | ||
39538 | o[56] = x14 >>> 0 & 0xff; | |
39539 | o[57] = x14 >>> 8 & 0xff; | |
39540 | o[58] = x14 >>> 16 & 0xff; | |
39541 | o[59] = x14 >>> 24 & 0xff; | |
39542 | ||
39543 | o[60] = x15 >>> 0 & 0xff; | |
39544 | o[61] = x15 >>> 8 & 0xff; | |
39545 | o[62] = x15 >>> 16 & 0xff; | |
39546 | o[63] = x15 >>> 24 & 0xff; | |
39547 | } | |
39548 | ||
39549 | function core_hsalsa20(o,p,k,c) { | |
39550 | var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24, | |
39551 | j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24, | |
39552 | j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24, | |
39553 | j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24, | |
39554 | j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24, | |
39555 | j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24, | |
39556 | j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24, | |
39557 | j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24, | |
39558 | j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24, | |
39559 | j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24, | |
39560 | j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24, | |
39561 | j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24, | |
39562 | j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24, | |
39563 | j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24, | |
39564 | j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24, | |
39565 | j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24; | |
39566 | ||
39567 | var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, | |
39568 | x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, | |
39569 | x15 = j15, u; | |
39570 | ||
39571 | for (var i = 0; i < 20; i += 2) { | |
39572 | u = x0 + x12 | 0; | |
39573 | x4 ^= u<<7 | u>>>(32-7); | |
39574 | u = x4 + x0 | 0; | |
39575 | x8 ^= u<<9 | u>>>(32-9); | |
39576 | u = x8 + x4 | 0; | |
39577 | x12 ^= u<<13 | u>>>(32-13); | |
39578 | u = x12 + x8 | 0; | |
39579 | x0 ^= u<<18 | u>>>(32-18); | |
39580 | ||
39581 | u = x5 + x1 | 0; | |
39582 | x9 ^= u<<7 | u>>>(32-7); | |
39583 | u = x9 + x5 | 0; | |
39584 | x13 ^= u<<9 | u>>>(32-9); | |
39585 | u = x13 + x9 | 0; | |
39586 | x1 ^= u<<13 | u>>>(32-13); | |
39587 | u = x1 + x13 | 0; | |
39588 | x5 ^= u<<18 | u>>>(32-18); | |
39589 | ||
39590 | u = x10 + x6 | 0; | |
39591 | x14 ^= u<<7 | u>>>(32-7); | |
39592 | u = x14 + x10 | 0; | |
39593 | x2 ^= u<<9 | u>>>(32-9); | |
39594 | u = x2 + x14 | 0; | |
39595 | x6 ^= u<<13 | u>>>(32-13); | |
39596 | u = x6 + x2 | 0; | |
39597 | x10 ^= u<<18 | u>>>(32-18); | |
39598 | ||
39599 | u = x15 + x11 | 0; | |
39600 | x3 ^= u<<7 | u>>>(32-7); | |
39601 | u = x3 + x15 | 0; | |
39602 | x7 ^= u<<9 | u>>>(32-9); | |
39603 | u = x7 + x3 | 0; | |
39604 | x11 ^= u<<13 | u>>>(32-13); | |
39605 | u = x11 + x7 | 0; | |
39606 | x15 ^= u<<18 | u>>>(32-18); | |
39607 | ||
39608 | u = x0 + x3 | 0; | |
39609 | x1 ^= u<<7 | u>>>(32-7); | |
39610 | u = x1 + x0 | 0; | |
39611 | x2 ^= u<<9 | u>>>(32-9); | |
39612 | u = x2 + x1 | 0; | |
39613 | x3 ^= u<<13 | u>>>(32-13); | |
39614 | u = x3 + x2 | 0; | |
39615 | x0 ^= u<<18 | u>>>(32-18); | |
39616 | ||
39617 | u = x5 + x4 | 0; | |
39618 | x6 ^= u<<7 | u>>>(32-7); | |
39619 | u = x6 + x5 | 0; | |
39620 | x7 ^= u<<9 | u>>>(32-9); | |
39621 | u = x7 + x6 | 0; | |
39622 | x4 ^= u<<13 | u>>>(32-13); | |
39623 | u = x4 + x7 | 0; | |
39624 | x5 ^= u<<18 | u>>>(32-18); | |
39625 | ||
39626 | u = x10 + x9 | 0; | |
39627 | x11 ^= u<<7 | u>>>(32-7); | |
39628 | u = x11 + x10 | 0; | |
39629 | x8 ^= u<<9 | u>>>(32-9); | |
39630 | u = x8 + x11 | 0; | |
39631 | x9 ^= u<<13 | u>>>(32-13); | |
39632 | u = x9 + x8 | 0; | |
39633 | x10 ^= u<<18 | u>>>(32-18); | |
39634 | ||
39635 | u = x15 + x14 | 0; | |
39636 | x12 ^= u<<7 | u>>>(32-7); | |
39637 | u = x12 + x15 | 0; | |
39638 | x13 ^= u<<9 | u>>>(32-9); | |
39639 | u = x13 + x12 | 0; | |
39640 | x14 ^= u<<13 | u>>>(32-13); | |
39641 | u = x14 + x13 | 0; | |
39642 | x15 ^= u<<18 | u>>>(32-18); | |
39643 | } | |
39644 | ||
39645 | o[ 0] = x0 >>> 0 & 0xff; | |
39646 | o[ 1] = x0 >>> 8 & 0xff; | |
39647 | o[ 2] = x0 >>> 16 & 0xff; | |
39648 | o[ 3] = x0 >>> 24 & 0xff; | |
39649 | ||
39650 | o[ 4] = x5 >>> 0 & 0xff; | |
39651 | o[ 5] = x5 >>> 8 & 0xff; | |
39652 | o[ 6] = x5 >>> 16 & 0xff; | |
39653 | o[ 7] = x5 >>> 24 & 0xff; | |
39654 | ||
39655 | o[ 8] = x10 >>> 0 & 0xff; | |
39656 | o[ 9] = x10 >>> 8 & 0xff; | |
39657 | o[10] = x10 >>> 16 & 0xff; | |
39658 | o[11] = x10 >>> 24 & 0xff; | |
39659 | ||
39660 | o[12] = x15 >>> 0 & 0xff; | |
39661 | o[13] = x15 >>> 8 & 0xff; | |
39662 | o[14] = x15 >>> 16 & 0xff; | |
39663 | o[15] = x15 >>> 24 & 0xff; | |
39664 | ||
39665 | o[16] = x6 >>> 0 & 0xff; | |
39666 | o[17] = x6 >>> 8 & 0xff; | |
39667 | o[18] = x6 >>> 16 & 0xff; | |
39668 | o[19] = x6 >>> 24 & 0xff; | |
39669 | ||
39670 | o[20] = x7 >>> 0 & 0xff; | |
39671 | o[21] = x7 >>> 8 & 0xff; | |
39672 | o[22] = x7 >>> 16 & 0xff; | |
39673 | o[23] = x7 >>> 24 & 0xff; | |
39674 | ||
39675 | o[24] = x8 >>> 0 & 0xff; | |
39676 | o[25] = x8 >>> 8 & 0xff; | |
39677 | o[26] = x8 >>> 16 & 0xff; | |
39678 | o[27] = x8 >>> 24 & 0xff; | |
39679 | ||
39680 | o[28] = x9 >>> 0 & 0xff; | |
39681 | o[29] = x9 >>> 8 & 0xff; | |
39682 | o[30] = x9 >>> 16 & 0xff; | |
39683 | o[31] = x9 >>> 24 & 0xff; | |
39684 | } | |
39685 | ||
39686 | function crypto_core_salsa20(out,inp,k,c) { | |
39687 | core_salsa20(out,inp,k,c); | |
39688 | } | |
39689 | ||
39690 | function crypto_core_hsalsa20(out,inp,k,c) { | |
39691 | core_hsalsa20(out,inp,k,c); | |
39692 | } | |
39693 | ||
39694 | var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]); | |
39695 | // "expand 32-byte k" | |
39696 | ||
39697 | function crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) { | |
39698 | var z = new Uint8Array(16), x = new Uint8Array(64); | |
39699 | var u, i; | |
39700 | for (i = 0; i < 16; i++) z[i] = 0; | |
39701 | for (i = 0; i < 8; i++) z[i] = n[i]; | |
39702 | while (b >= 64) { | |
39703 | crypto_core_salsa20(x,z,k,sigma); | |
39704 | for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i]; | |
39705 | u = 1; | |
39706 | for (i = 8; i < 16; i++) { | |
39707 | u = u + (z[i] & 0xff) | 0; | |
39708 | z[i] = u & 0xff; | |
39709 | u >>>= 8; | |
39710 | } | |
39711 | b -= 64; | |
39712 | cpos += 64; | |
39713 | mpos += 64; | |
39714 | } | |
39715 | if (b > 0) { | |
39716 | crypto_core_salsa20(x,z,k,sigma); | |
39717 | for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i]; | |
39718 | } | |
39719 | return 0; | |
39720 | } | |
39721 | ||
39722 | function crypto_stream_salsa20(c,cpos,b,n,k) { | |
39723 | var z = new Uint8Array(16), x = new Uint8Array(64); | |
39724 | var u, i; | |
39725 | for (i = 0; i < 16; i++) z[i] = 0; | |
39726 | for (i = 0; i < 8; i++) z[i] = n[i]; | |
39727 | while (b >= 64) { | |
39728 | crypto_core_salsa20(x,z,k,sigma); | |
39729 | for (i = 0; i < 64; i++) c[cpos+i] = x[i]; | |
39730 | u = 1; | |
39731 | for (i = 8; i < 16; i++) { | |
39732 | u = u + (z[i] & 0xff) | 0; | |
39733 | z[i] = u & 0xff; | |
39734 | u >>>= 8; | |
39735 | } | |
39736 | b -= 64; | |
39737 | cpos += 64; | |
39738 | } | |
39739 | if (b > 0) { | |
39740 | crypto_core_salsa20(x,z,k,sigma); | |
39741 | for (i = 0; i < b; i++) c[cpos+i] = x[i]; | |
39742 | } | |
39743 | return 0; | |
39744 | } | |
39745 | ||
39746 | function crypto_stream(c,cpos,d,n,k) { | |
39747 | var s = new Uint8Array(32); | |
39748 | crypto_core_hsalsa20(s,n,k,sigma); | |
39749 | var sn = new Uint8Array(8); | |
39750 | for (var i = 0; i < 8; i++) sn[i] = n[i+16]; | |
39751 | return crypto_stream_salsa20(c,cpos,d,sn,s); | |
39752 | } | |
39753 | ||
39754 | function crypto_stream_xor(c,cpos,m,mpos,d,n,k) { | |
39755 | var s = new Uint8Array(32); | |
39756 | crypto_core_hsalsa20(s,n,k,sigma); | |
39757 | var sn = new Uint8Array(8); | |
39758 | for (var i = 0; i < 8; i++) sn[i] = n[i+16]; | |
39759 | return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s); | |
39760 | } | |
39761 | ||
39762 | /* | |
39763 | * Port of Andrew Moon's Poly1305-donna-16. Public domain. | |
39764 | * https://github.com/floodyberry/poly1305-donna | |
39765 | */ | |
39766 | ||
39767 | var poly1305 = function(key) { | |
39768 | this.buffer = new Uint8Array(16); | |
39769 | this.r = new Uint16Array(10); | |
39770 | this.h = new Uint16Array(10); | |
39771 | this.pad = new Uint16Array(8); | |
39772 | this.leftover = 0; | |
39773 | this.fin = 0; | |
39774 | ||
39775 | var t0, t1, t2, t3, t4, t5, t6, t7; | |
39776 | ||
39777 | t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0 ) & 0x1fff; | |
39778 | t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff; | |
39779 | t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03; | |
39780 | t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff; | |
39781 | t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff; | |
39782 | this.r[5] = ((t4 >>> 1)) & 0x1ffe; | |
39783 | t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff; | |
39784 | t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81; | |
39785 | t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff; | |
39786 | this.r[9] = ((t7 >>> 5)) & 0x007f; | |
39787 | ||
39788 | this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8; | |
39789 | this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8; | |
39790 | this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8; | |
39791 | this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8; | |
39792 | this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8; | |
39793 | this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8; | |
39794 | this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8; | |
39795 | this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8; | |
39796 | }; | |
39797 | ||
39798 | poly1305.prototype.blocks = function(m, mpos, bytes) { | |
39799 | var hibit = this.fin ? 0 : (1 << 11); | |
39800 | var t0, t1, t2, t3, t4, t5, t6, t7, c; | |
39801 | var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9; | |
39802 | ||
39803 | var h0 = this.h[0], | |
39804 | h1 = this.h[1], | |
39805 | h2 = this.h[2], | |
39806 | h3 = this.h[3], | |
39807 | h4 = this.h[4], | |
39808 | h5 = this.h[5], | |
39809 | h6 = this.h[6], | |
39810 | h7 = this.h[7], | |
39811 | h8 = this.h[8], | |
39812 | h9 = this.h[9]; | |
39813 | ||
39814 | var r0 = this.r[0], | |
39815 | r1 = this.r[1], | |
39816 | r2 = this.r[2], | |
39817 | r3 = this.r[3], | |
39818 | r4 = this.r[4], | |
39819 | r5 = this.r[5], | |
39820 | r6 = this.r[6], | |
39821 | r7 = this.r[7], | |
39822 | r8 = this.r[8], | |
39823 | r9 = this.r[9]; | |
39824 | ||
39825 | while (bytes >= 16) { | |
39826 | t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0 ) & 0x1fff; | |
39827 | t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 << 3)) & 0x1fff; | |
39828 | t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 << 6)) & 0x1fff; | |
39829 | t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>> 7) | (t3 << 9)) & 0x1fff; | |
39830 | t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>> 4) | (t4 << 12)) & 0x1fff; | |
39831 | h5 += ((t4 >>> 1)) & 0x1fff; | |
39832 | t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 << 2)) & 0x1fff; | |
39833 | t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 << 5)) & 0x1fff; | |
39834 | t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>> 8) | (t7 << 8)) & 0x1fff; | |
39835 | h9 += ((t7 >>> 5)) | hibit; | |
39836 | ||
39837 | c = 0; | |
39838 | ||
39839 | d0 = c; | |
39840 | d0 += h0 * r0; | |
39841 | d0 += h1 * (5 * r9); | |
39842 | d0 += h2 * (5 * r8); | |
39843 | d0 += h3 * (5 * r7); | |
39844 | d0 += h4 * (5 * r6); | |
39845 | c = (d0 >>> 13); d0 &= 0x1fff; | |
39846 | d0 += h5 * (5 * r5); | |
39847 | d0 += h6 * (5 * r4); | |
39848 | d0 += h7 * (5 * r3); | |
39849 | d0 += h8 * (5 * r2); | |
39850 | d0 += h9 * (5 * r1); | |
39851 | c += (d0 >>> 13); d0 &= 0x1fff; | |
39852 | ||
39853 | d1 = c; | |
39854 | d1 += h0 * r1; | |
39855 | d1 += h1 * r0; | |
39856 | d1 += h2 * (5 * r9); | |
39857 | d1 += h3 * (5 * r8); | |
39858 | d1 += h4 * (5 * r7); | |
39859 | c = (d1 >>> 13); d1 &= 0x1fff; | |
39860 | d1 += h5 * (5 * r6); | |
39861 | d1 += h6 * (5 * r5); | |
39862 | d1 += h7 * (5 * r4); | |
39863 | d1 += h8 * (5 * r3); | |
39864 | d1 += h9 * (5 * r2); | |
39865 | c += (d1 >>> 13); d1 &= 0x1fff; | |
39866 | ||
39867 | d2 = c; | |
39868 | d2 += h0 * r2; | |
39869 | d2 += h1 * r1; | |
39870 | d2 += h2 * r0; | |
39871 | d2 += h3 * (5 * r9); | |
39872 | d2 += h4 * (5 * r8); | |
39873 | c = (d2 >>> 13); d2 &= 0x1fff; | |
39874 | d2 += h5 * (5 * r7); | |
39875 | d2 += h6 * (5 * r6); | |
39876 | d2 += h7 * (5 * r5); | |
39877 | d2 += h8 * (5 * r4); | |
39878 | d2 += h9 * (5 * r3); | |
39879 | c += (d2 >>> 13); d2 &= 0x1fff; | |
39880 | ||
39881 | d3 = c; | |
39882 | d3 += h0 * r3; | |
39883 | d3 += h1 * r2; | |
39884 | d3 += h2 * r1; | |
39885 | d3 += h3 * r0; | |
39886 | d3 += h4 * (5 * r9); | |
39887 | c = (d3 >>> 13); d3 &= 0x1fff; | |
39888 | d3 += h5 * (5 * r8); | |
39889 | d3 += h6 * (5 * r7); | |
39890 | d3 += h7 * (5 * r6); | |
39891 | d3 += h8 * (5 * r5); | |
39892 | d3 += h9 * (5 * r4); | |
39893 | c += (d3 >>> 13); d3 &= 0x1fff; | |
39894 | ||
39895 | d4 = c; | |
39896 | d4 += h0 * r4; | |
39897 | d4 += h1 * r3; | |
39898 | d4 += h2 * r2; | |
39899 | d4 += h3 * r1; | |
39900 | d4 += h4 * r0; | |
39901 | c = (d4 >>> 13); d4 &= 0x1fff; | |
39902 | d4 += h5 * (5 * r9); | |
39903 | d4 += h6 * (5 * r8); | |
39904 | d4 += h7 * (5 * r7); | |
39905 | d4 += h8 * (5 * r6); | |
39906 | d4 += h9 * (5 * r5); | |
39907 | c += (d4 >>> 13); d4 &= 0x1fff; | |
39908 | ||
39909 | d5 = c; | |
39910 | d5 += h0 * r5; | |
39911 | d5 += h1 * r4; | |
39912 | d5 += h2 * r3; | |
39913 | d5 += h3 * r2; | |
39914 | d5 += h4 * r1; | |
39915 | c = (d5 >>> 13); d5 &= 0x1fff; | |
39916 | d5 += h5 * r0; | |
39917 | d5 += h6 * (5 * r9); | |
39918 | d5 += h7 * (5 * r8); | |
39919 | d5 += h8 * (5 * r7); | |
39920 | d5 += h9 * (5 * r6); | |
39921 | c += (d5 >>> 13); d5 &= 0x1fff; | |
39922 | ||
39923 | d6 = c; | |
39924 | d6 += h0 * r6; | |
39925 | d6 += h1 * r5; | |
39926 | d6 += h2 * r4; | |
39927 | d6 += h3 * r3; | |
39928 | d6 += h4 * r2; | |
39929 | c = (d6 >>> 13); d6 &= 0x1fff; | |
39930 | d6 += h5 * r1; | |
39931 | d6 += h6 * r0; | |
39932 | d6 += h7 * (5 * r9); | |
39933 | d6 += h8 * (5 * r8); | |
39934 | d6 += h9 * (5 * r7); | |
39935 | c += (d6 >>> 13); d6 &= 0x1fff; | |
39936 | ||
39937 | d7 = c; | |
39938 | d7 += h0 * r7; | |
39939 | d7 += h1 * r6; | |
39940 | d7 += h2 * r5; | |
39941 | d7 += h3 * r4; | |
39942 | d7 += h4 * r3; | |
39943 | c = (d7 >>> 13); d7 &= 0x1fff; | |
39944 | d7 += h5 * r2; | |
39945 | d7 += h6 * r1; | |
39946 | d7 += h7 * r0; | |
39947 | d7 += h8 * (5 * r9); | |
39948 | d7 += h9 * (5 * r8); | |
39949 | c += (d7 >>> 13); d7 &= 0x1fff; | |
39950 | ||
39951 | d8 = c; | |
39952 | d8 += h0 * r8; | |
39953 | d8 += h1 * r7; | |
39954 | d8 += h2 * r6; | |
39955 | d8 += h3 * r5; | |
39956 | d8 += h4 * r4; | |
39957 | c = (d8 >>> 13); d8 &= 0x1fff; | |
39958 | d8 += h5 * r3; | |
39959 | d8 += h6 * r2; | |
39960 | d8 += h7 * r1; | |
39961 | d8 += h8 * r0; | |
39962 | d8 += h9 * (5 * r9); | |
39963 | c += (d8 >>> 13); d8 &= 0x1fff; | |
39964 | ||
39965 | d9 = c; | |
39966 | d9 += h0 * r9; | |
39967 | d9 += h1 * r8; | |
39968 | d9 += h2 * r7; | |
39969 | d9 += h3 * r6; | |
39970 | d9 += h4 * r5; | |
39971 | c = (d9 >>> 13); d9 &= 0x1fff; | |
39972 | d9 += h5 * r4; | |
39973 | d9 += h6 * r3; | |
39974 | d9 += h7 * r2; | |
39975 | d9 += h8 * r1; | |
39976 | d9 += h9 * r0; | |
39977 | c += (d9 >>> 13); d9 &= 0x1fff; | |
39978 | ||
39979 | c = (((c << 2) + c)) | 0; | |
39980 | c = (c + d0) | 0; | |
39981 | d0 = c & 0x1fff; | |
39982 | c = (c >>> 13); | |
39983 | d1 += c; | |
39984 | ||
39985 | h0 = d0; | |
39986 | h1 = d1; | |
39987 | h2 = d2; | |
39988 | h3 = d3; | |
39989 | h4 = d4; | |
39990 | h5 = d5; | |
39991 | h6 = d6; | |
39992 | h7 = d7; | |
39993 | h8 = d8; | |
39994 | h9 = d9; | |
39995 | ||
39996 | mpos += 16; | |
39997 | bytes -= 16; | |
39998 | } | |
39999 | this.h[0] = h0; | |
40000 | this.h[1] = h1; | |
40001 | this.h[2] = h2; | |
40002 | this.h[3] = h3; | |
40003 | this.h[4] = h4; | |
40004 | this.h[5] = h5; | |
40005 | this.h[6] = h6; | |
40006 | this.h[7] = h7; | |
40007 | this.h[8] = h8; | |
40008 | this.h[9] = h9; | |
40009 | }; | |
40010 | ||
40011 | poly1305.prototype.finish = function(mac, macpos) { | |
40012 | var g = new Uint16Array(10); | |
40013 | var c, mask, f, i; | |
40014 | ||
40015 | if (this.leftover) { | |
40016 | i = this.leftover; | |
40017 | this.buffer[i++] = 1; | |
40018 | for (; i < 16; i++) this.buffer[i] = 0; | |
40019 | this.fin = 1; | |
40020 | this.blocks(this.buffer, 0, 16); | |
40021 | } | |
40022 | ||
40023 | c = this.h[1] >>> 13; | |
40024 | this.h[1] &= 0x1fff; | |
40025 | for (i = 2; i < 10; i++) { | |
40026 | this.h[i] += c; | |
40027 | c = this.h[i] >>> 13; | |
40028 | this.h[i] &= 0x1fff; | |
40029 | } | |
40030 | this.h[0] += (c * 5); | |
40031 | c = this.h[0] >>> 13; | |
40032 | this.h[0] &= 0x1fff; | |
40033 | this.h[1] += c; | |
40034 | c = this.h[1] >>> 13; | |
40035 | this.h[1] &= 0x1fff; | |
40036 | this.h[2] += c; | |
40037 | ||
40038 | g[0] = this.h[0] + 5; | |
40039 | c = g[0] >>> 13; | |
40040 | g[0] &= 0x1fff; | |
40041 | for (i = 1; i < 10; i++) { | |
40042 | g[i] = this.h[i] + c; | |
40043 | c = g[i] >>> 13; | |
40044 | g[i] &= 0x1fff; | |
40045 | } | |
40046 | g[9] -= (1 << 13); | |
40047 | ||
40048 | mask = (c ^ 1) - 1; | |
40049 | for (i = 0; i < 10; i++) g[i] &= mask; | |
40050 | mask = ~mask; | |
40051 | for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i]; | |
40052 | ||
40053 | this.h[0] = ((this.h[0] ) | (this.h[1] << 13) ) & 0xffff; | |
40054 | this.h[1] = ((this.h[1] >>> 3) | (this.h[2] << 10) ) & 0xffff; | |
40055 | this.h[2] = ((this.h[2] >>> 6) | (this.h[3] << 7) ) & 0xffff; | |
40056 | this.h[3] = ((this.h[3] >>> 9) | (this.h[4] << 4) ) & 0xffff; | |
40057 | this.h[4] = ((this.h[4] >>> 12) | (this.h[5] << 1) | (this.h[6] << 14)) & 0xffff; | |
40058 | this.h[5] = ((this.h[6] >>> 2) | (this.h[7] << 11) ) & 0xffff; | |
40059 | this.h[6] = ((this.h[7] >>> 5) | (this.h[8] << 8) ) & 0xffff; | |
40060 | this.h[7] = ((this.h[8] >>> 8) | (this.h[9] << 5) ) & 0xffff; | |
40061 | ||
40062 | f = this.h[0] + this.pad[0]; | |
40063 | this.h[0] = f & 0xffff; | |
40064 | for (i = 1; i < 8; i++) { | |
40065 | f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0; | |
40066 | this.h[i] = f & 0xffff; | |
40067 | } | |
40068 | ||
40069 | mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff; | |
40070 | mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff; | |
40071 | mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff; | |
40072 | mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff; | |
40073 | mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff; | |
40074 | mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff; | |
40075 | mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff; | |
40076 | mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff; | |
40077 | mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff; | |
40078 | mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff; | |
40079 | mac[macpos+10] = (this.h[5] >>> 0) & 0xff; | |
40080 | mac[macpos+11] = (this.h[5] >>> 8) & 0xff; | |
40081 | mac[macpos+12] = (this.h[6] >>> 0) & 0xff; | |
40082 | mac[macpos+13] = (this.h[6] >>> 8) & 0xff; | |
40083 | mac[macpos+14] = (this.h[7] >>> 0) & 0xff; | |
40084 | mac[macpos+15] = (this.h[7] >>> 8) & 0xff; | |
40085 | }; | |
40086 | ||
40087 | poly1305.prototype.update = function(m, mpos, bytes) { | |
40088 | var i, want; | |
40089 | ||
40090 | if (this.leftover) { | |
40091 | want = (16 - this.leftover); | |
40092 | if (want > bytes) | |
40093 | want = bytes; | |
40094 | for (i = 0; i < want; i++) | |
40095 | this.buffer[this.leftover + i] = m[mpos+i]; | |
40096 | bytes -= want; | |
40097 | mpos += want; | |
40098 | this.leftover += want; | |
40099 | if (this.leftover < 16) | |
40100 | return; | |
40101 | this.blocks(this.buffer, 0, 16); | |
40102 | this.leftover = 0; | |
40103 | } | |
40104 | ||
40105 | if (bytes >= 16) { | |
40106 | want = bytes - (bytes % 16); | |
40107 | this.blocks(m, mpos, want); | |
40108 | mpos += want; | |
40109 | bytes -= want; | |
40110 | } | |
40111 | ||
40112 | if (bytes) { | |
40113 | for (i = 0; i < bytes; i++) | |
40114 | this.buffer[this.leftover + i] = m[mpos+i]; | |
40115 | this.leftover += bytes; | |
40116 | } | |
40117 | }; | |
40118 | ||
40119 | function crypto_onetimeauth(out, outpos, m, mpos, n, k) { | |
40120 | var s = new poly1305(k); | |
40121 | s.update(m, mpos, n); | |
40122 | s.finish(out, outpos); | |
40123 | return 0; | |
40124 | } | |
40125 | ||
40126 | function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) { | |
40127 | var x = new Uint8Array(16); | |
40128 | crypto_onetimeauth(x,0,m,mpos,n,k); | |
40129 | return crypto_verify_16(h,hpos,x,0); | |
40130 | } | |
40131 | ||
40132 | function crypto_secretbox(c,m,d,n,k) { | |
40133 | var i; | |
40134 | if (d < 32) return -1; | |
40135 | crypto_stream_xor(c,0,m,0,d,n,k); | |
40136 | crypto_onetimeauth(c, 16, c, 32, d - 32, c); | |
40137 | for (i = 0; i < 16; i++) c[i] = 0; | |
40138 | return 0; | |
40139 | } | |
40140 | ||
40141 | function crypto_secretbox_open(m,c,d,n,k) { | |
40142 | var i; | |
40143 | var x = new Uint8Array(32); | |
40144 | if (d < 32) return -1; | |
40145 | crypto_stream(x,0,32,n,k); | |
40146 | if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1; | |
40147 | crypto_stream_xor(m,0,c,0,d,n,k); | |
40148 | for (i = 0; i < 32; i++) m[i] = 0; | |
40149 | return 0; | |
40150 | } | |
40151 | ||
40152 | function set25519(r, a) { | |
40153 | var i; | |
40154 | for (i = 0; i < 16; i++) r[i] = a[i]|0; | |
40155 | } | |
40156 | ||
40157 | function car25519(o) { | |
40158 | var i, v, c = 1; | |
40159 | for (i = 0; i < 16; i++) { | |
40160 | v = o[i] + c + 65535; | |
40161 | c = Math.floor(v / 65536); | |
40162 | o[i] = v - c * 65536; | |
40163 | } | |
40164 | o[0] += c-1 + 37 * (c-1); | |
40165 | } | |
40166 | ||
40167 | function sel25519(p, q, b) { | |
40168 | var t, c = ~(b-1); | |
40169 | for (var i = 0; i < 16; i++) { | |
40170 | t = c & (p[i] ^ q[i]); | |
40171 | p[i] ^= t; | |
40172 | q[i] ^= t; | |
40173 | } | |
40174 | } | |
40175 | ||
40176 | function pack25519(o, n) { | |
40177 | var i, j, b; | |
40178 | var m = gf(), t = gf(); | |
40179 | for (i = 0; i < 16; i++) t[i] = n[i]; | |
40180 | car25519(t); | |
40181 | car25519(t); | |
40182 | car25519(t); | |
40183 | for (j = 0; j < 2; j++) { | |
40184 | m[0] = t[0] - 0xffed; | |
40185 | for (i = 1; i < 15; i++) { | |
40186 | m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1); | |
40187 | m[i-1] &= 0xffff; | |
40188 | } | |
40189 | m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1); | |
40190 | b = (m[15]>>16) & 1; | |
40191 | m[14] &= 0xffff; | |
40192 | sel25519(t, m, 1-b); | |
40193 | } | |
40194 | for (i = 0; i < 16; i++) { | |
40195 | o[2*i] = t[i] & 0xff; | |
40196 | o[2*i+1] = t[i]>>8; | |
40197 | } | |
40198 | } | |
40199 | ||
40200 | function neq25519(a, b) { | |
40201 | var c = new Uint8Array(32), d = new Uint8Array(32); | |
40202 | pack25519(c, a); | |
40203 | pack25519(d, b); | |
40204 | return crypto_verify_32(c, 0, d, 0); | |
40205 | } | |
40206 | ||
40207 | function par25519(a) { | |
40208 | var d = new Uint8Array(32); | |
40209 | pack25519(d, a); | |
40210 | return d[0] & 1; | |
40211 | } | |
40212 | ||
40213 | function unpack25519(o, n) { | |
40214 | var i; | |
40215 | for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8); | |
40216 | o[15] &= 0x7fff; | |
40217 | } | |
40218 | ||
40219 | function A(o, a, b) { | |
40220 | for (var i = 0; i < 16; i++) o[i] = a[i] + b[i]; | |
40221 | } | |
40222 | ||
40223 | function Z(o, a, b) { | |
40224 | for (var i = 0; i < 16; i++) o[i] = a[i] - b[i]; | |
40225 | } | |
40226 | ||
40227 | function M(o, a, b) { | |
40228 | var v, c, | |
40229 | t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, | |
40230 | t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, | |
40231 | t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, | |
40232 | t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, | |
40233 | b0 = b[0], | |
40234 | b1 = b[1], | |
40235 | b2 = b[2], | |
40236 | b3 = b[3], | |
40237 | b4 = b[4], | |
40238 | b5 = b[5], | |
40239 | b6 = b[6], | |
40240 | b7 = b[7], | |
40241 | b8 = b[8], | |
40242 | b9 = b[9], | |
40243 | b10 = b[10], | |
40244 | b11 = b[11], | |
40245 | b12 = b[12], | |
40246 | b13 = b[13], | |
40247 | b14 = b[14], | |
40248 | b15 = b[15]; | |
40249 | ||
40250 | v = a[0]; | |
40251 | t0 += v * b0; | |
40252 | t1 += v * b1; | |
40253 | t2 += v * b2; | |
40254 | t3 += v * b3; | |
40255 | t4 += v * b4; | |
40256 | t5 += v * b5; | |
40257 | t6 += v * b6; | |
40258 | t7 += v * b7; | |
40259 | t8 += v * b8; | |
40260 | t9 += v * b9; | |
40261 | t10 += v * b10; | |
40262 | t11 += v * b11; | |
40263 | t12 += v * b12; | |
40264 | t13 += v * b13; | |
40265 | t14 += v * b14; | |
40266 | t15 += v * b15; | |
40267 | v = a[1]; | |
40268 | t1 += v * b0; | |
40269 | t2 += v * b1; | |
40270 | t3 += v * b2; | |
40271 | t4 += v * b3; | |
40272 | t5 += v * b4; | |
40273 | t6 += v * b5; | |
40274 | t7 += v * b6; | |
40275 | t8 += v * b7; | |
40276 | t9 += v * b8; | |
40277 | t10 += v * b9; | |
40278 | t11 += v * b10; | |
40279 | t12 += v * b11; | |
40280 | t13 += v * b12; | |
40281 | t14 += v * b13; | |
40282 | t15 += v * b14; | |
40283 | t16 += v * b15; | |
40284 | v = a[2]; | |
40285 | t2 += v * b0; | |
40286 | t3 += v * b1; | |
40287 | t4 += v * b2; | |
40288 | t5 += v * b3; | |
40289 | t6 += v * b4; | |
40290 | t7 += v * b5; | |
40291 | t8 += v * b6; | |
40292 | t9 += v * b7; | |
40293 | t10 += v * b8; | |
40294 | t11 += v * b9; | |
40295 | t12 += v * b10; | |
40296 | t13 += v * b11; | |
40297 | t14 += v * b12; | |
40298 | t15 += v * b13; | |
40299 | t16 += v * b14; | |
40300 | t17 += v * b15; | |
40301 | v = a[3]; | |
40302 | t3 += v * b0; | |
40303 | t4 += v * b1; | |
40304 | t5 += v * b2; | |
40305 | t6 += v * b3; | |
40306 | t7 += v * b4; | |
40307 | t8 += v * b5; | |
40308 | t9 += v * b6; | |
40309 | t10 += v * b7; | |
40310 | t11 += v * b8; | |
40311 | t12 += v * b9; | |
40312 | t13 += v * b10; | |
40313 | t14 += v * b11; | |
40314 | t15 += v * b12; | |
40315 | t16 += v * b13; | |
40316 | t17 += v * b14; | |
40317 | t18 += v * b15; | |
40318 | v = a[4]; | |
40319 | t4 += v * b0; | |
40320 | t5 += v * b1; | |
40321 | t6 += v * b2; | |
40322 | t7 += v * b3; | |
40323 | t8 += v * b4; | |
40324 | t9 += v * b5; | |
40325 | t10 += v * b6; | |
40326 | t11 += v * b7; | |
40327 | t12 += v * b8; | |
40328 | t13 += v * b9; | |
40329 | t14 += v * b10; | |
40330 | t15 += v * b11; | |
40331 | t16 += v * b12; | |
40332 | t17 += v * b13; | |
40333 | t18 += v * b14; | |
40334 | t19 += v * b15; | |
40335 | v = a[5]; | |
40336 | t5 += v * b0; | |
40337 | t6 += v * b1; | |
40338 | t7 += v * b2; | |
40339 | t8 += v * b3; | |
40340 | t9 += v * b4; | |
40341 | t10 += v * b5; | |
40342 | t11 += v * b6; | |
40343 | t12 += v * b7; | |
40344 | t13 += v * b8; | |
40345 | t14 += v * b9; | |
40346 | t15 += v * b10; | |
40347 | t16 += v * b11; | |
40348 | t17 += v * b12; | |
40349 | t18 += v * b13; | |
40350 | t19 += v * b14; | |
40351 | t20 += v * b15; | |
40352 | v = a[6]; | |
40353 | t6 += v * b0; | |
40354 | t7 += v * b1; | |
40355 | t8 += v * b2; | |
40356 | t9 += v * b3; | |
40357 | t10 += v * b4; | |
40358 | t11 += v * b5; | |
40359 | t12 += v * b6; | |
40360 | t13 += v * b7; | |
40361 | t14 += v * b8; | |
40362 | t15 += v * b9; | |
40363 | t16 += v * b10; | |
40364 | t17 += v * b11; | |
40365 | t18 += v * b12; | |
40366 | t19 += v * b13; | |
40367 | t20 += v * b14; | |
40368 | t21 += v * b15; | |
40369 | v = a[7]; | |
40370 | t7 += v * b0; | |
40371 | t8 += v * b1; | |
40372 | t9 += v * b2; | |
40373 | t10 += v * b3; | |
40374 | t11 += v * b4; | |
40375 | t12 += v * b5; | |
40376 | t13 += v * b6; | |
40377 | t14 += v * b7; | |
40378 | t15 += v * b8; | |
40379 | t16 += v * b9; | |
40380 | t17 += v * b10; | |
40381 | t18 += v * b11; | |
40382 | t19 += v * b12; | |
40383 | t20 += v * b13; | |
40384 | t21 += v * b14; | |
40385 | t22 += v * b15; | |
40386 | v = a[8]; | |
40387 | t8 += v * b0; | |
40388 | t9 += v * b1; | |
40389 | t10 += v * b2; | |
40390 | t11 += v * b3; | |
40391 | t12 += v * b4; | |
40392 | t13 += v * b5; | |
40393 | t14 += v * b6; | |
40394 | t15 += v * b7; | |
40395 | t16 += v * b8; | |
40396 | t17 += v * b9; | |
40397 | t18 += v * b10; | |
40398 | t19 += v * b11; | |
40399 | t20 += v * b12; | |
40400 | t21 += v * b13; | |
40401 | t22 += v * b14; | |
40402 | t23 += v * b15; | |
40403 | v = a[9]; | |
40404 | t9 += v * b0; | |
40405 | t10 += v * b1; | |
40406 | t11 += v * b2; | |
40407 | t12 += v * b3; | |
40408 | t13 += v * b4; | |
40409 | t14 += v * b5; | |
40410 | t15 += v * b6; | |
40411 | t16 += v * b7; | |
40412 | t17 += v * b8; | |
40413 | t18 += v * b9; | |
40414 | t19 += v * b10; | |
40415 | t20 += v * b11; | |
40416 | t21 += v * b12; | |
40417 | t22 += v * b13; | |
40418 | t23 += v * b14; | |
40419 | t24 += v * b15; | |
40420 | v = a[10]; | |
40421 | t10 += v * b0; | |
40422 | t11 += v * b1; | |
40423 | t12 += v * b2; | |
40424 | t13 += v * b3; | |
40425 | t14 += v * b4; | |
40426 | t15 += v * b5; | |
40427 | t16 += v * b6; | |
40428 | t17 += v * b7; | |
40429 | t18 += v * b8; | |
40430 | t19 += v * b9; | |
40431 | t20 += v * b10; | |
40432 | t21 += v * b11; | |
40433 | t22 += v * b12; | |
40434 | t23 += v * b13; | |
40435 | t24 += v * b14; | |
40436 | t25 += v * b15; | |
40437 | v = a[11]; | |
40438 | t11 += v * b0; | |
40439 | t12 += v * b1; | |
40440 | t13 += v * b2; | |
40441 | t14 += v * b3; | |
40442 | t15 += v * b4; | |
40443 | t16 += v * b5; | |
40444 | t17 += v * b6; | |
40445 | t18 += v * b7; | |
40446 | t19 += v * b8; | |
40447 | t20 += v * b9; | |
40448 | t21 += v * b10; | |
40449 | t22 += v * b11; | |
40450 | t23 += v * b12; | |
40451 | t24 += v * b13; | |
40452 | t25 += v * b14; | |
40453 | t26 += v * b15; | |
40454 | v = a[12]; | |
40455 | t12 += v * b0; | |
40456 | t13 += v * b1; | |
40457 | t14 += v * b2; | |
40458 | t15 += v * b3; | |
40459 | t16 += v * b4; | |
40460 | t17 += v * b5; | |
40461 | t18 += v * b6; | |
40462 | t19 += v * b7; | |
40463 | t20 += v * b8; | |
40464 | t21 += v * b9; | |
40465 | t22 += v * b10; | |
40466 | t23 += v * b11; | |
40467 | t24 += v * b12; | |
40468 | t25 += v * b13; | |
40469 | t26 += v * b14; | |
40470 | t27 += v * b15; | |
40471 | v = a[13]; | |
40472 | t13 += v * b0; | |
40473 | t14 += v * b1; | |
40474 | t15 += v * b2; | |
40475 | t16 += v * b3; | |
40476 | t17 += v * b4; | |
40477 | t18 += v * b5; | |
40478 | t19 += v * b6; | |
40479 | t20 += v * b7; | |
40480 | t21 += v * b8; | |
40481 | t22 += v * b9; | |
40482 | t23 += v * b10; | |
40483 | t24 += v * b11; | |
40484 | t25 += v * b12; | |
40485 | t26 += v * b13; | |
40486 | t27 += v * b14; | |
40487 | t28 += v * b15; | |
40488 | v = a[14]; | |
40489 | t14 += v * b0; | |
40490 | t15 += v * b1; | |
40491 | t16 += v * b2; | |
40492 | t17 += v * b3; | |
40493 | t18 += v * b4; | |
40494 | t19 += v * b5; | |
40495 | t20 += v * b6; | |
40496 | t21 += v * b7; | |
40497 | t22 += v * b8; | |
40498 | t23 += v * b9; | |
40499 | t24 += v * b10; | |
40500 | t25 += v * b11; | |
40501 | t26 += v * b12; | |
40502 | t27 += v * b13; | |
40503 | t28 += v * b14; | |
40504 | t29 += v * b15; | |
40505 | v = a[15]; | |
40506 | t15 += v * b0; | |
40507 | t16 += v * b1; | |
40508 | t17 += v * b2; | |
40509 | t18 += v * b3; | |
40510 | t19 += v * b4; | |
40511 | t20 += v * b5; | |
40512 | t21 += v * b6; | |
40513 | t22 += v * b7; | |
40514 | t23 += v * b8; | |
40515 | t24 += v * b9; | |
40516 | t25 += v * b10; | |
40517 | t26 += v * b11; | |
40518 | t27 += v * b12; | |
40519 | t28 += v * b13; | |
40520 | t29 += v * b14; | |
40521 | t30 += v * b15; | |
40522 | ||
40523 | t0 += 38 * t16; | |
40524 | t1 += 38 * t17; | |
40525 | t2 += 38 * t18; | |
40526 | t3 += 38 * t19; | |
40527 | t4 += 38 * t20; | |
40528 | t5 += 38 * t21; | |
40529 | t6 += 38 * t22; | |
40530 | t7 += 38 * t23; | |
40531 | t8 += 38 * t24; | |
40532 | t9 += 38 * t25; | |
40533 | t10 += 38 * t26; | |
40534 | t11 += 38 * t27; | |
40535 | t12 += 38 * t28; | |
40536 | t13 += 38 * t29; | |
40537 | t14 += 38 * t30; | |
40538 | // t15 left as is | |
40539 | ||
40540 | // first car | |
40541 | c = 1; | |
40542 | v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536; | |
40543 | v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536; | |
40544 | v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536; | |
40545 | v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536; | |
40546 | v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536; | |
40547 | v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536; | |
40548 | v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536; | |
40549 | v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536; | |
40550 | v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536; | |
40551 | v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536; | |
40552 | v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536; | |
40553 | v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536; | |
40554 | v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536; | |
40555 | v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536; | |
40556 | v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536; | |
40557 | v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536; | |
40558 | t0 += c-1 + 37 * (c-1); | |
40559 | ||
40560 | // second car | |
40561 | c = 1; | |
40562 | v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536; | |
40563 | v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536; | |
40564 | v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536; | |
40565 | v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536; | |
40566 | v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536; | |
40567 | v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536; | |
40568 | v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536; | |
40569 | v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536; | |
40570 | v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536; | |
40571 | v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536; | |
40572 | v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536; | |
40573 | v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536; | |
40574 | v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536; | |
40575 | v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536; | |
40576 | v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536; | |
40577 | v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536; | |
40578 | t0 += c-1 + 37 * (c-1); | |
40579 | ||
40580 | o[ 0] = t0; | |
40581 | o[ 1] = t1; | |
40582 | o[ 2] = t2; | |
40583 | o[ 3] = t3; | |
40584 | o[ 4] = t4; | |
40585 | o[ 5] = t5; | |
40586 | o[ 6] = t6; | |
40587 | o[ 7] = t7; | |
40588 | o[ 8] = t8; | |
40589 | o[ 9] = t9; | |
40590 | o[10] = t10; | |
40591 | o[11] = t11; | |
40592 | o[12] = t12; | |
40593 | o[13] = t13; | |
40594 | o[14] = t14; | |
40595 | o[15] = t15; | |
40596 | } | |
40597 | ||
40598 | function S(o, a) { | |
40599 | M(o, a, a); | |
40600 | } | |
40601 | ||
40602 | function inv25519(o, i) { | |
40603 | var c = gf(); | |
40604 | var a; | |
40605 | for (a = 0; a < 16; a++) c[a] = i[a]; | |
40606 | for (a = 253; a >= 0; a--) { | |
40607 | S(c, c); | |
40608 | if(a !== 2 && a !== 4) M(c, c, i); | |
40609 | } | |
40610 | for (a = 0; a < 16; a++) o[a] = c[a]; | |
40611 | } | |
40612 | ||
40613 | function pow2523(o, i) { | |
40614 | var c = gf(); | |
40615 | var a; | |
40616 | for (a = 0; a < 16; a++) c[a] = i[a]; | |
40617 | for (a = 250; a >= 0; a--) { | |
40618 | S(c, c); | |
40619 | if(a !== 1) M(c, c, i); | |
40620 | } | |
40621 | for (a = 0; a < 16; a++) o[a] = c[a]; | |
40622 | } | |
40623 | ||
40624 | function crypto_scalarmult(q, n, p) { | |
40625 | var z = new Uint8Array(32); | |
40626 | var x = new Float64Array(80), r, i; | |
40627 | var a = gf(), b = gf(), c = gf(), | |
40628 | d = gf(), e = gf(), f = gf(); | |
40629 | for (i = 0; i < 31; i++) z[i] = n[i]; | |
40630 | z[31]=(n[31]&127)|64; | |
40631 | z[0]&=248; | |
40632 | unpack25519(x,p); | |
40633 | for (i = 0; i < 16; i++) { | |
40634 | b[i]=x[i]; | |
40635 | d[i]=a[i]=c[i]=0; | |
40636 | } | |
40637 | a[0]=d[0]=1; | |
40638 | for (i=254; i>=0; --i) { | |
40639 | r=(z[i>>>3]>>>(i&7))&1; | |
40640 | sel25519(a,b,r); | |
40641 | sel25519(c,d,r); | |
40642 | A(e,a,c); | |
40643 | Z(a,a,c); | |
40644 | A(c,b,d); | |
40645 | Z(b,b,d); | |
40646 | S(d,e); | |
40647 | S(f,a); | |
40648 | M(a,c,a); | |
40649 | M(c,b,e); | |
40650 | A(e,a,c); | |
40651 | Z(a,a,c); | |
40652 | S(b,a); | |
40653 | Z(c,d,f); | |
40654 | M(a,c,_121665); | |
40655 | A(a,a,d); | |
40656 | M(c,c,a); | |
40657 | M(a,d,f); | |
40658 | M(d,b,x); | |
40659 | S(b,e); | |
40660 | sel25519(a,b,r); | |
40661 | sel25519(c,d,r); | |
40662 | } | |
40663 | for (i = 0; i < 16; i++) { | |
40664 | x[i+16]=a[i]; | |
40665 | x[i+32]=c[i]; | |
40666 | x[i+48]=b[i]; | |
40667 | x[i+64]=d[i]; | |
40668 | } | |
40669 | var x32 = x.subarray(32); | |
40670 | var x16 = x.subarray(16); | |
40671 | inv25519(x32,x32); | |
40672 | M(x16,x16,x32); | |
40673 | pack25519(q,x16); | |
40674 | return 0; | |
40675 | } | |
40676 | ||
40677 | function crypto_scalarmult_base(q, n) { | |
40678 | return crypto_scalarmult(q, n, _9); | |
40679 | } | |
40680 | ||
40681 | function crypto_box_keypair(y, x) { | |
40682 | randombytes(x, 32); | |
40683 | return crypto_scalarmult_base(y, x); | |
40684 | } | |
40685 | ||
40686 | function crypto_box_beforenm(k, y, x) { | |
40687 | var s = new Uint8Array(32); | |
40688 | crypto_scalarmult(s, x, y); | |
40689 | return crypto_core_hsalsa20(k, _0, s, sigma); | |
40690 | } | |
40691 | ||
40692 | var crypto_box_afternm = crypto_secretbox; | |
40693 | var crypto_box_open_afternm = crypto_secretbox_open; | |
40694 | ||
40695 | function crypto_box(c, m, d, n, y, x) { | |
40696 | var k = new Uint8Array(32); | |
40697 | crypto_box_beforenm(k, y, x); | |
40698 | return crypto_box_afternm(c, m, d, n, k); | |
40699 | } | |
40700 | ||
40701 | function crypto_box_open(m, c, d, n, y, x) { | |
40702 | var k = new Uint8Array(32); | |
40703 | crypto_box_beforenm(k, y, x); | |
40704 | return crypto_box_open_afternm(m, c, d, n, k); | |
40705 | } | |
40706 | ||
40707 | var K = [ | |
40708 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, | |
40709 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, | |
40710 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, | |
40711 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, | |
40712 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, | |
40713 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, | |
40714 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, | |
40715 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, | |
40716 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, | |
40717 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, | |
40718 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, | |
40719 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, | |
40720 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, | |
40721 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, | |
40722 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, | |
40723 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, | |
40724 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, | |
40725 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, | |
40726 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, | |
40727 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, | |
40728 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, | |
40729 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, | |
40730 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, | |
40731 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, | |
40732 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, | |
40733 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, | |
40734 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, | |
40735 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, | |
40736 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, | |
40737 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, | |
40738 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, | |
40739 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, | |
40740 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, | |
40741 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, | |
40742 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, | |
40743 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, | |
40744 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, | |
40745 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, | |
40746 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, | |
40747 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 | |
40748 | ]; | |
40749 | ||
40750 | function crypto_hashblocks_hl(hh, hl, m, n) { | |
40751 | var wh = new Int32Array(16), wl = new Int32Array(16), | |
40752 | bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, | |
40753 | bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, | |
40754 | th, tl, i, j, h, l, a, b, c, d; | |
40755 | ||
40756 | var ah0 = hh[0], | |
40757 | ah1 = hh[1], | |
40758 | ah2 = hh[2], | |
40759 | ah3 = hh[3], | |
40760 | ah4 = hh[4], | |
40761 | ah5 = hh[5], | |
40762 | ah6 = hh[6], | |
40763 | ah7 = hh[7], | |
40764 | ||
40765 | al0 = hl[0], | |
40766 | al1 = hl[1], | |
40767 | al2 = hl[2], | |
40768 | al3 = hl[3], | |
40769 | al4 = hl[4], | |
40770 | al5 = hl[5], | |
40771 | al6 = hl[6], | |
40772 | al7 = hl[7]; | |
40773 | ||
40774 | var pos = 0; | |
40775 | while (n >= 128) { | |
40776 | for (i = 0; i < 16; i++) { | |
40777 | j = 8 * i + pos; | |
40778 | wh[i] = (m[j+0] << 24) | (m[j+1] << 16) | (m[j+2] << 8) | m[j+3]; | |
40779 | wl[i] = (m[j+4] << 24) | (m[j+5] << 16) | (m[j+6] << 8) | m[j+7]; | |
40780 | } | |
40781 | for (i = 0; i < 80; i++) { | |
40782 | bh0 = ah0; | |
40783 | bh1 = ah1; | |
40784 | bh2 = ah2; | |
40785 | bh3 = ah3; | |
40786 | bh4 = ah4; | |
40787 | bh5 = ah5; | |
40788 | bh6 = ah6; | |
40789 | bh7 = ah7; | |
40790 | ||
40791 | bl0 = al0; | |
40792 | bl1 = al1; | |
40793 | bl2 = al2; | |
40794 | bl3 = al3; | |
40795 | bl4 = al4; | |
40796 | bl5 = al5; | |
40797 | bl6 = al6; | |
40798 | bl7 = al7; | |
40799 | ||
40800 | // add | |
40801 | h = ah7; | |
40802 | l = al7; | |
40803 | ||
40804 | a = l & 0xffff; b = l >>> 16; | |
40805 | c = h & 0xffff; d = h >>> 16; | |
40806 | ||
40807 | // Sigma1 | |
40808 | h = ((ah4 >>> 14) | (al4 << (32-14))) ^ ((ah4 >>> 18) | (al4 << (32-18))) ^ ((al4 >>> (41-32)) | (ah4 << (32-(41-32)))); | |
40809 | l = ((al4 >>> 14) | (ah4 << (32-14))) ^ ((al4 >>> 18) | (ah4 << (32-18))) ^ ((ah4 >>> (41-32)) | (al4 << (32-(41-32)))); | |
40810 | ||
40811 | a += l & 0xffff; b += l >>> 16; | |
40812 | c += h & 0xffff; d += h >>> 16; | |
40813 | ||
40814 | // Ch | |
40815 | h = (ah4 & ah5) ^ (~ah4 & ah6); | |
40816 | l = (al4 & al5) ^ (~al4 & al6); | |
40817 | ||
40818 | a += l & 0xffff; b += l >>> 16; | |
40819 | c += h & 0xffff; d += h >>> 16; | |
40820 | ||
40821 | // K | |
40822 | h = K[i*2]; | |
40823 | l = K[i*2+1]; | |
40824 | ||
40825 | a += l & 0xffff; b += l >>> 16; | |
40826 | c += h & 0xffff; d += h >>> 16; | |
40827 | ||
40828 | // w | |
40829 | h = wh[i%16]; | |
40830 | l = wl[i%16]; | |
40831 | ||
40832 | a += l & 0xffff; b += l >>> 16; | |
40833 | c += h & 0xffff; d += h >>> 16; | |
40834 | ||
40835 | b += a >>> 16; | |
40836 | c += b >>> 16; | |
40837 | d += c >>> 16; | |
40838 | ||
40839 | th = c & 0xffff | d << 16; | |
40840 | tl = a & 0xffff | b << 16; | |
40841 | ||
40842 | // add | |
40843 | h = th; | |
40844 | l = tl; | |
40845 | ||
40846 | a = l & 0xffff; b = l >>> 16; | |
40847 | c = h & 0xffff; d = h >>> 16; | |
40848 | ||
40849 | // Sigma0 | |
40850 | h = ((ah0 >>> 28) | (al0 << (32-28))) ^ ((al0 >>> (34-32)) | (ah0 << (32-(34-32)))) ^ ((al0 >>> (39-32)) | (ah0 << (32-(39-32)))); | |
40851 | l = ((al0 >>> 28) | (ah0 << (32-28))) ^ ((ah0 >>> (34-32)) | (al0 << (32-(34-32)))) ^ ((ah0 >>> (39-32)) | (al0 << (32-(39-32)))); | |
40852 | ||
40853 | a += l & 0xffff; b += l >>> 16; | |
40854 | c += h & 0xffff; d += h >>> 16; | |
40855 | ||
40856 | // Maj | |
40857 | h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2); | |
40858 | l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2); | |
40859 | ||
40860 | a += l & 0xffff; b += l >>> 16; | |
40861 | c += h & 0xffff; d += h >>> 16; | |
40862 | ||
40863 | b += a >>> 16; | |
40864 | c += b >>> 16; | |
40865 | d += c >>> 16; | |
40866 | ||
40867 | bh7 = (c & 0xffff) | (d << 16); | |
40868 | bl7 = (a & 0xffff) | (b << 16); | |
40869 | ||
40870 | // add | |
40871 | h = bh3; | |
40872 | l = bl3; | |
40873 | ||
40874 | a = l & 0xffff; b = l >>> 16; | |
40875 | c = h & 0xffff; d = h >>> 16; | |
40876 | ||
40877 | h = th; | |
40878 | l = tl; | |
40879 | ||
40880 | a += l & 0xffff; b += l >>> 16; | |
40881 | c += h & 0xffff; d += h >>> 16; | |
40882 | ||
40883 | b += a >>> 16; | |
40884 | c += b >>> 16; | |
40885 | d += c >>> 16; | |
40886 | ||
40887 | bh3 = (c & 0xffff) | (d << 16); | |
40888 | bl3 = (a & 0xffff) | (b << 16); | |
40889 | ||
40890 | ah1 = bh0; | |
40891 | ah2 = bh1; | |
40892 | ah3 = bh2; | |
40893 | ah4 = bh3; | |
40894 | ah5 = bh4; | |
40895 | ah6 = bh5; | |
40896 | ah7 = bh6; | |
40897 | ah0 = bh7; | |
40898 | ||
40899 | al1 = bl0; | |
40900 | al2 = bl1; | |
40901 | al3 = bl2; | |
40902 | al4 = bl3; | |
40903 | al5 = bl4; | |
40904 | al6 = bl5; | |
40905 | al7 = bl6; | |
40906 | al0 = bl7; | |
40907 | ||
40908 | if (i%16 === 15) { | |
40909 | for (j = 0; j < 16; j++) { | |
40910 | // add | |
40911 | h = wh[j]; | |
40912 | l = wl[j]; | |
40913 | ||
40914 | a = l & 0xffff; b = l >>> 16; | |
40915 | c = h & 0xffff; d = h >>> 16; | |
40916 | ||
40917 | h = wh[(j+9)%16]; | |
40918 | l = wl[(j+9)%16]; | |
40919 | ||
40920 | a += l & 0xffff; b += l >>> 16; | |
40921 | c += h & 0xffff; d += h >>> 16; | |
40922 | ||
40923 | // sigma0 | |
40924 | th = wh[(j+1)%16]; | |
40925 | tl = wl[(j+1)%16]; | |
40926 | h = ((th >>> 1) | (tl << (32-1))) ^ ((th >>> 8) | (tl << (32-8))) ^ (th >>> 7); | |
40927 | l = ((tl >>> 1) | (th << (32-1))) ^ ((tl >>> 8) | (th << (32-8))) ^ ((tl >>> 7) | (th << (32-7))); | |
40928 | ||
40929 | a += l & 0xffff; b += l >>> 16; | |
40930 | c += h & 0xffff; d += h >>> 16; | |
40931 | ||
40932 | // sigma1 | |
40933 | th = wh[(j+14)%16]; | |
40934 | tl = wl[(j+14)%16]; | |
40935 | h = ((th >>> 19) | (tl << (32-19))) ^ ((tl >>> (61-32)) | (th << (32-(61-32)))) ^ (th >>> 6); | |
40936 | l = ((tl >>> 19) | (th << (32-19))) ^ ((th >>> (61-32)) | (tl << (32-(61-32)))) ^ ((tl >>> 6) | (th << (32-6))); | |
40937 | ||
40938 | a += l & 0xffff; b += l >>> 16; | |
40939 | c += h & 0xffff; d += h >>> 16; | |
40940 | ||
40941 | b += a >>> 16; | |
40942 | c += b >>> 16; | |
40943 | d += c >>> 16; | |
40944 | ||
40945 | wh[j] = (c & 0xffff) | (d << 16); | |
40946 | wl[j] = (a & 0xffff) | (b << 16); | |
40947 | } | |
40948 | } | |
40949 | } | |
40950 | ||
40951 | // add | |
40952 | h = ah0; | |
40953 | l = al0; | |
40954 | ||
40955 | a = l & 0xffff; b = l >>> 16; | |
40956 | c = h & 0xffff; d = h >>> 16; | |
40957 | ||
40958 | h = hh[0]; | |
40959 | l = hl[0]; | |
40960 | ||
40961 | a += l & 0xffff; b += l >>> 16; | |
40962 | c += h & 0xffff; d += h >>> 16; | |
40963 | ||
40964 | b += a >>> 16; | |
40965 | c += b >>> 16; | |
40966 | d += c >>> 16; | |
40967 | ||
40968 | hh[0] = ah0 = (c & 0xffff) | (d << 16); | |
40969 | hl[0] = al0 = (a & 0xffff) | (b << 16); | |
40970 | ||
40971 | h = ah1; | |
40972 | l = al1; | |
40973 | ||
40974 | a = l & 0xffff; b = l >>> 16; | |
40975 | c = h & 0xffff; d = h >>> 16; | |
40976 | ||
40977 | h = hh[1]; | |
40978 | l = hl[1]; | |
40979 | ||
40980 | a += l & 0xffff; b += l >>> 16; | |
40981 | c += h & 0xffff; d += h >>> 16; | |
40982 | ||
40983 | b += a >>> 16; | |
40984 | c += b >>> 16; | |
40985 | d += c >>> 16; | |
40986 | ||
40987 | hh[1] = ah1 = (c & 0xffff) | (d << 16); | |
40988 | hl[1] = al1 = (a & 0xffff) | (b << 16); | |
40989 | ||
40990 | h = ah2; | |
40991 | l = al2; | |
40992 | ||
40993 | a = l & 0xffff; b = l >>> 16; | |
40994 | c = h & 0xffff; d = h >>> 16; | |
40995 | ||
40996 | h = hh[2]; | |
40997 | l = hl[2]; | |
40998 | ||
40999 | a += l & 0xffff; b += l >>> 16; | |
41000 | c += h & 0xffff; d += h >>> 16; | |
41001 | ||
41002 | b += a >>> 16; | |
41003 | c += b >>> 16; | |
41004 | d += c >>> 16; | |
41005 | ||
41006 | hh[2] = ah2 = (c & 0xffff) | (d << 16); | |
41007 | hl[2] = al2 = (a & 0xffff) | (b << 16); | |
41008 | ||
41009 | h = ah3; | |
41010 | l = al3; | |
41011 | ||
41012 | a = l & 0xffff; b = l >>> 16; | |
41013 | c = h & 0xffff; d = h >>> 16; | |
41014 | ||
41015 | h = hh[3]; | |
41016 | l = hl[3]; | |
41017 | ||
41018 | a += l & 0xffff; b += l >>> 16; | |
41019 | c += h & 0xffff; d += h >>> 16; | |
41020 | ||
41021 | b += a >>> 16; | |
41022 | c += b >>> 16; | |
41023 | d += c >>> 16; | |
41024 | ||
41025 | hh[3] = ah3 = (c & 0xffff) | (d << 16); | |
41026 | hl[3] = al3 = (a & 0xffff) | (b << 16); | |
41027 | ||
41028 | h = ah4; | |
41029 | l = al4; | |
41030 | ||
41031 | a = l & 0xffff; b = l >>> 16; | |
41032 | c = h & 0xffff; d = h >>> 16; | |
41033 | ||
41034 | h = hh[4]; | |
41035 | l = hl[4]; | |
41036 | ||
41037 | a += l & 0xffff; b += l >>> 16; | |
41038 | c += h & 0xffff; d += h >>> 16; | |
41039 | ||
41040 | b += a >>> 16; | |
41041 | c += b >>> 16; | |
41042 | d += c >>> 16; | |
41043 | ||
41044 | hh[4] = ah4 = (c & 0xffff) | (d << 16); | |
41045 | hl[4] = al4 = (a & 0xffff) | (b << 16); | |
41046 | ||
41047 | h = ah5; | |
41048 | l = al5; | |
41049 | ||
41050 | a = l & 0xffff; b = l >>> 16; | |
41051 | c = h & 0xffff; d = h >>> 16; | |
41052 | ||
41053 | h = hh[5]; | |
41054 | l = hl[5]; | |
41055 | ||
41056 | a += l & 0xffff; b += l >>> 16; | |
41057 | c += h & 0xffff; d += h >>> 16; | |
41058 | ||
41059 | b += a >>> 16; | |
41060 | c += b >>> 16; | |
41061 | d += c >>> 16; | |
41062 | ||
41063 | hh[5] = ah5 = (c & 0xffff) | (d << 16); | |
41064 | hl[5] = al5 = (a & 0xffff) | (b << 16); | |
41065 | ||
41066 | h = ah6; | |
41067 | l = al6; | |
41068 | ||
41069 | a = l & 0xffff; b = l >>> 16; | |
41070 | c = h & 0xffff; d = h >>> 16; | |
41071 | ||
41072 | h = hh[6]; | |
41073 | l = hl[6]; | |
41074 | ||
41075 | a += l & 0xffff; b += l >>> 16; | |
41076 | c += h & 0xffff; d += h >>> 16; | |
41077 | ||
41078 | b += a >>> 16; | |
41079 | c += b >>> 16; | |
41080 | d += c >>> 16; | |
41081 | ||
41082 | hh[6] = ah6 = (c & 0xffff) | (d << 16); | |
41083 | hl[6] = al6 = (a & 0xffff) | (b << 16); | |
41084 | ||
41085 | h = ah7; | |
41086 | l = al7; | |
41087 | ||
41088 | a = l & 0xffff; b = l >>> 16; | |
41089 | c = h & 0xffff; d = h >>> 16; | |
41090 | ||
41091 | h = hh[7]; | |
41092 | l = hl[7]; | |
41093 | ||
41094 | a += l & 0xffff; b += l >>> 16; | |
41095 | c += h & 0xffff; d += h >>> 16; | |
41096 | ||
41097 | b += a >>> 16; | |
41098 | c += b >>> 16; | |
41099 | d += c >>> 16; | |
41100 | ||
41101 | hh[7] = ah7 = (c & 0xffff) | (d << 16); | |
41102 | hl[7] = al7 = (a & 0xffff) | (b << 16); | |
41103 | ||
41104 | pos += 128; | |
41105 | n -= 128; | |
41106 | } | |
41107 | ||
41108 | return n; | |
41109 | } | |
41110 | ||
41111 | function crypto_hash(out, m, n) { | |
41112 | var hh = new Int32Array(8), | |
41113 | hl = new Int32Array(8), | |
41114 | x = new Uint8Array(256), | |
41115 | i, b = n; | |
41116 | ||
41117 | hh[0] = 0x6a09e667; | |
41118 | hh[1] = 0xbb67ae85; | |
41119 | hh[2] = 0x3c6ef372; | |
41120 | hh[3] = 0xa54ff53a; | |
41121 | hh[4] = 0x510e527f; | |
41122 | hh[5] = 0x9b05688c; | |
41123 | hh[6] = 0x1f83d9ab; | |
41124 | hh[7] = 0x5be0cd19; | |
41125 | ||
41126 | hl[0] = 0xf3bcc908; | |
41127 | hl[1] = 0x84caa73b; | |
41128 | hl[2] = 0xfe94f82b; | |
41129 | hl[3] = 0x5f1d36f1; | |
41130 | hl[4] = 0xade682d1; | |
41131 | hl[5] = 0x2b3e6c1f; | |
41132 | hl[6] = 0xfb41bd6b; | |
41133 | hl[7] = 0x137e2179; | |
41134 | ||
41135 | crypto_hashblocks_hl(hh, hl, m, n); | |
41136 | n %= 128; | |
41137 | ||
41138 | for (i = 0; i < n; i++) x[i] = m[b-n+i]; | |
41139 | x[n] = 128; | |
41140 | ||
41141 | n = 256-128*(n<112?1:0); | |
41142 | x[n-9] = 0; | |
41143 | ts64(x, n-8, (b / 0x20000000) | 0, b << 3); | |
41144 | crypto_hashblocks_hl(hh, hl, x, n); | |
41145 | ||
41146 | for (i = 0; i < 8; i++) ts64(out, 8*i, hh[i], hl[i]); | |
41147 | ||
41148 | return 0; | |
41149 | } | |
41150 | ||
41151 | function add(p, q) { | |
41152 | var a = gf(), b = gf(), c = gf(), | |
41153 | d = gf(), e = gf(), f = gf(), | |
41154 | g = gf(), h = gf(), t = gf(); | |
41155 | ||
41156 | Z(a, p[1], p[0]); | |
41157 | Z(t, q[1], q[0]); | |
41158 | M(a, a, t); | |
41159 | A(b, p[0], p[1]); | |
41160 | A(t, q[0], q[1]); | |
41161 | M(b, b, t); | |
41162 | M(c, p[3], q[3]); | |
41163 | M(c, c, D2); | |
41164 | M(d, p[2], q[2]); | |
41165 | A(d, d, d); | |
41166 | Z(e, b, a); | |
41167 | Z(f, d, c); | |
41168 | A(g, d, c); | |
41169 | A(h, b, a); | |
41170 | ||
41171 | M(p[0], e, f); | |
41172 | M(p[1], h, g); | |
41173 | M(p[2], g, f); | |
41174 | M(p[3], e, h); | |
41175 | } | |
41176 | ||
41177 | function cswap(p, q, b) { | |
41178 | var i; | |
41179 | for (i = 0; i < 4; i++) { | |
41180 | sel25519(p[i], q[i], b); | |
41181 | } | |
41182 | } | |
41183 | ||
41184 | function pack(r, p) { | |
41185 | var tx = gf(), ty = gf(), zi = gf(); | |
41186 | inv25519(zi, p[2]); | |
41187 | M(tx, p[0], zi); | |
41188 | M(ty, p[1], zi); | |
41189 | pack25519(r, ty); | |
41190 | r[31] ^= par25519(tx) << 7; | |
41191 | } | |
41192 | ||
41193 | function scalarmult(p, q, s) { | |
41194 | var b, i; | |
41195 | set25519(p[0], gf0); | |
41196 | set25519(p[1], gf1); | |
41197 | set25519(p[2], gf1); | |
41198 | set25519(p[3], gf0); | |
41199 | for (i = 255; i >= 0; --i) { | |
41200 | b = (s[(i/8)|0] >> (i&7)) & 1; | |
41201 | cswap(p, q, b); | |
41202 | add(q, p); | |
41203 | add(p, p); | |
41204 | cswap(p, q, b); | |
41205 | } | |
41206 | } | |
41207 | ||
41208 | function scalarbase(p, s) { | |
41209 | var q = [gf(), gf(), gf(), gf()]; | |
41210 | set25519(q[0], X); | |
41211 | set25519(q[1], Y); | |
41212 | set25519(q[2], gf1); | |
41213 | M(q[3], X, Y); | |
41214 | scalarmult(p, q, s); | |
41215 | } | |
41216 | ||
41217 | function crypto_sign_keypair(pk, sk, seeded) { | |
41218 | var d = new Uint8Array(64); | |
41219 | var p = [gf(), gf(), gf(), gf()]; | |
41220 | var i; | |
41221 | ||
41222 | if (!seeded) randombytes(sk, 32); | |
41223 | crypto_hash(d, sk, 32); | |
41224 | d[0] &= 248; | |
41225 | d[31] &= 127; | |
41226 | d[31] |= 64; | |
41227 | ||
41228 | scalarbase(p, d); | |
41229 | pack(pk, p); | |
41230 | ||
41231 | for (i = 0; i < 32; i++) sk[i+32] = pk[i]; | |
41232 | return 0; | |
41233 | } | |
41234 | ||
41235 | 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]); | |
41236 | ||
41237 | function modL(r, x) { | |
41238 | var carry, i, j, k; | |
41239 | for (i = 63; i >= 32; --i) { | |
41240 | carry = 0; | |
41241 | for (j = i - 32, k = i - 12; j < k; ++j) { | |
41242 | x[j] += carry - 16 * x[i] * L[j - (i - 32)]; | |
41243 | carry = (x[j] + 128) >> 8; | |
41244 | x[j] -= carry * 256; | |
41245 | } | |
41246 | x[j] += carry; | |
41247 | x[i] = 0; | |
41248 | } | |
41249 | carry = 0; | |
41250 | for (j = 0; j < 32; j++) { | |
41251 | x[j] += carry - (x[31] >> 4) * L[j]; | |
41252 | carry = x[j] >> 8; | |
41253 | x[j] &= 255; | |
41254 | } | |
41255 | for (j = 0; j < 32; j++) x[j] -= carry * L[j]; | |
41256 | for (i = 0; i < 32; i++) { | |
41257 | x[i+1] += x[i] >> 8; | |
41258 | r[i] = x[i] & 255; | |
41259 | } | |
41260 | } | |
41261 | ||
41262 | function reduce(r) { | |
41263 | var x = new Float64Array(64), i; | |
41264 | for (i = 0; i < 64; i++) x[i] = r[i]; | |
41265 | for (i = 0; i < 64; i++) r[i] = 0; | |
41266 | modL(r, x); | |
41267 | } | |
41268 | ||
41269 | // Note: difference from C - smlen returned, not passed as argument. | |
41270 | function crypto_sign(sm, m, n, sk) { | |
41271 | var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64); | |
41272 | var i, j, x = new Float64Array(64); | |
41273 | var p = [gf(), gf(), gf(), gf()]; | |
41274 | ||
41275 | crypto_hash(d, sk, 32); | |
41276 | d[0] &= 248; | |
41277 | d[31] &= 127; | |
41278 | d[31] |= 64; | |
41279 | ||
41280 | var smlen = n + 64; | |
41281 | for (i = 0; i < n; i++) sm[64 + i] = m[i]; | |
41282 | for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i]; | |
41283 | ||
41284 | crypto_hash(r, sm.subarray(32), n+32); | |
41285 | reduce(r); | |
41286 | scalarbase(p, r); | |
41287 | pack(sm, p); | |
41288 | ||
41289 | for (i = 32; i < 64; i++) sm[i] = sk[i]; | |
41290 | crypto_hash(h, sm, n + 64); | |
41291 | reduce(h); | |
41292 | ||
41293 | for (i = 0; i < 64; i++) x[i] = 0; | |
41294 | for (i = 0; i < 32; i++) x[i] = r[i]; | |
41295 | for (i = 0; i < 32; i++) { | |
41296 | for (j = 0; j < 32; j++) { | |
41297 | x[i+j] += h[i] * d[j]; | |
41298 | } | |
41299 | } | |
41300 | ||
41301 | modL(sm.subarray(32), x); | |
41302 | return smlen; | |
41303 | } | |
41304 | ||
41305 | function unpackneg(r, p) { | |
41306 | var t = gf(), chk = gf(), num = gf(), | |
41307 | den = gf(), den2 = gf(), den4 = gf(), | |
41308 | den6 = gf(); | |
41309 | ||
41310 | set25519(r[2], gf1); | |
41311 | unpack25519(r[1], p); | |
41312 | S(num, r[1]); | |
41313 | M(den, num, D); | |
41314 | Z(num, num, r[2]); | |
41315 | A(den, r[2], den); | |
41316 | ||
41317 | S(den2, den); | |
41318 | S(den4, den2); | |
41319 | M(den6, den4, den2); | |
41320 | M(t, den6, num); | |
41321 | M(t, t, den); | |
41322 | ||
41323 | pow2523(t, t); | |
41324 | M(t, t, num); | |
41325 | M(t, t, den); | |
41326 | M(t, t, den); | |
41327 | M(r[0], t, den); | |
41328 | ||
41329 | S(chk, r[0]); | |
41330 | M(chk, chk, den); | |
41331 | if (neq25519(chk, num)) M(r[0], r[0], I); | |
41332 | ||
41333 | S(chk, r[0]); | |
41334 | M(chk, chk, den); | |
41335 | if (neq25519(chk, num)) return -1; | |
41336 | ||
41337 | if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]); | |
41338 | ||
41339 | M(r[3], r[0], r[1]); | |
41340 | return 0; | |
41341 | } | |
41342 | ||
41343 | function crypto_sign_open(m, sm, n, pk) { | |
41344 | var i, mlen; | |
41345 | var t = new Uint8Array(32), h = new Uint8Array(64); | |
41346 | var p = [gf(), gf(), gf(), gf()], | |
41347 | q = [gf(), gf(), gf(), gf()]; | |
41348 | ||
41349 | mlen = -1; | |
41350 | if (n < 64) return -1; | |
41351 | ||
41352 | if (unpackneg(q, pk)) return -1; | |
41353 | ||
41354 | for (i = 0; i < n; i++) m[i] = sm[i]; | |
41355 | for (i = 0; i < 32; i++) m[i+32] = pk[i]; | |
41356 | crypto_hash(h, m, n); | |
41357 | reduce(h); | |
41358 | scalarmult(p, q, h); | |
41359 | ||
41360 | scalarbase(q, sm.subarray(32)); | |
41361 | add(p, q); | |
41362 | pack(t, p); | |
41363 | ||
41364 | n -= 64; | |
41365 | if (crypto_verify_32(sm, 0, t, 0)) { | |
41366 | for (i = 0; i < n; i++) m[i] = 0; | |
41367 | return -1; | |
41368 | } | |
41369 | ||
41370 | for (i = 0; i < n; i++) m[i] = sm[i + 64]; | |
41371 | mlen = n; | |
41372 | return mlen; | |
41373 | } | |
41374 | ||
41375 | var crypto_secretbox_KEYBYTES = 32, | |
41376 | crypto_secretbox_NONCEBYTES = 24, | |
41377 | crypto_secretbox_ZEROBYTES = 32, | |
41378 | crypto_secretbox_BOXZEROBYTES = 16, | |
41379 | crypto_scalarmult_BYTES = 32, | |
41380 | crypto_scalarmult_SCALARBYTES = 32, | |
41381 | crypto_box_PUBLICKEYBYTES = 32, | |
41382 | crypto_box_SECRETKEYBYTES = 32, | |
41383 | crypto_box_BEFORENMBYTES = 32, | |
41384 | crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES, | |
41385 | crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES, | |
41386 | crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES, | |
41387 | crypto_sign_BYTES = 64, | |
41388 | crypto_sign_PUBLICKEYBYTES = 32, | |
41389 | crypto_sign_SECRETKEYBYTES = 64, | |
41390 | crypto_sign_SEEDBYTES = 32, | |
41391 | crypto_hash_BYTES = 64; | |
41392 | ||
41393 | nacl.lowlevel = { | |
41394 | crypto_core_hsalsa20: crypto_core_hsalsa20, | |
41395 | crypto_stream_xor: crypto_stream_xor, | |
41396 | crypto_stream: crypto_stream, | |
41397 | crypto_stream_salsa20_xor: crypto_stream_salsa20_xor, | |
41398 | crypto_stream_salsa20: crypto_stream_salsa20, | |
41399 | crypto_onetimeauth: crypto_onetimeauth, | |
41400 | crypto_onetimeauth_verify: crypto_onetimeauth_verify, | |
41401 | crypto_verify_16: crypto_verify_16, | |
41402 | crypto_verify_32: crypto_verify_32, | |
41403 | crypto_secretbox: crypto_secretbox, | |
41404 | crypto_secretbox_open: crypto_secretbox_open, | |
41405 | crypto_scalarmult: crypto_scalarmult, | |
41406 | crypto_scalarmult_base: crypto_scalarmult_base, | |
41407 | crypto_box_beforenm: crypto_box_beforenm, | |
41408 | crypto_box_afternm: crypto_box_afternm, | |
41409 | crypto_box: crypto_box, | |
41410 | crypto_box_open: crypto_box_open, | |
41411 | crypto_box_keypair: crypto_box_keypair, | |
41412 | crypto_hash: crypto_hash, | |
41413 | crypto_sign: crypto_sign, | |
41414 | crypto_sign_keypair: crypto_sign_keypair, | |
41415 | crypto_sign_open: crypto_sign_open, | |
41416 | ||
41417 | crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES, | |
41418 | crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES, | |
41419 | crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES, | |
41420 | crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES, | |
41421 | crypto_scalarmult_BYTES: crypto_scalarmult_BYTES, | |
41422 | crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES, | |
41423 | crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES, | |
41424 | crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES, | |
41425 | crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES, | |
41426 | crypto_box_NONCEBYTES: crypto_box_NONCEBYTES, | |
41427 | crypto_box_ZEROBYTES: crypto_box_ZEROBYTES, | |
41428 | crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES, | |
41429 | crypto_sign_BYTES: crypto_sign_BYTES, | |
41430 | crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES, | |
41431 | crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES, | |
41432 | crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES, | |
41433 | crypto_hash_BYTES: crypto_hash_BYTES | |
41434 | }; | |
41435 | ||
41436 | /* High-level API */ | |
41437 | ||
41438 | function checkLengths(k, n) { | |
41439 | if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size'); | |
41440 | if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size'); | |
41441 | } | |
41442 | ||
41443 | function checkBoxLengths(pk, sk) { | |
41444 | if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size'); | |
41445 | if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size'); | |
41446 | } | |
41447 | ||
41448 | function checkArrayTypes() { | |
41449 | for (var i = 0; i < arguments.length; i++) { | |
41450 | if (!(arguments[i] instanceof Uint8Array)) | |
41451 | throw new TypeError('unexpected type, use Uint8Array'); | |
41452 | } | |
41453 | } | |
41454 | ||
41455 | function cleanup(arr) { | |
41456 | for (var i = 0; i < arr.length; i++) arr[i] = 0; | |
41457 | } | |
41458 | ||
41459 | nacl.randomBytes = function(n) { | |
41460 | var b = new Uint8Array(n); | |
41461 | randombytes(b, n); | |
41462 | return b; | |
41463 | }; | |
41464 | ||
41465 | nacl.secretbox = function(msg, nonce, key) { | |
41466 | checkArrayTypes(msg, nonce, key); | |
41467 | checkLengths(key, nonce); | |
41468 | var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length); | |
41469 | var c = new Uint8Array(m.length); | |
41470 | for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i]; | |
41471 | crypto_secretbox(c, m, m.length, nonce, key); | |
41472 | return c.subarray(crypto_secretbox_BOXZEROBYTES); | |
41473 | }; | |
41474 | ||
41475 | nacl.secretbox.open = function(box, nonce, key) { | |
41476 | checkArrayTypes(box, nonce, key); | |
41477 | checkLengths(key, nonce); | |
41478 | var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length); | |
41479 | var m = new Uint8Array(c.length); | |
41480 | for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i]; | |
41481 | if (c.length < 32) return null; | |
41482 | if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null; | |
41483 | return m.subarray(crypto_secretbox_ZEROBYTES); | |
41484 | }; | |
41485 | ||
41486 | nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES; | |
41487 | nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES; | |
41488 | nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES; | |
41489 | ||
41490 | nacl.scalarMult = function(n, p) { | |
41491 | checkArrayTypes(n, p); | |
41492 | if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size'); | |
41493 | if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size'); | |
41494 | var q = new Uint8Array(crypto_scalarmult_BYTES); | |
41495 | crypto_scalarmult(q, n, p); | |
41496 | return q; | |
41497 | }; | |
41498 | ||
41499 | nacl.scalarMult.base = function(n) { | |
41500 | checkArrayTypes(n); | |
41501 | if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size'); | |
41502 | var q = new Uint8Array(crypto_scalarmult_BYTES); | |
41503 | crypto_scalarmult_base(q, n); | |
41504 | return q; | |
41505 | }; | |
41506 | ||
41507 | nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES; | |
41508 | nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES; | |
41509 | ||
41510 | nacl.box = function(msg, nonce, publicKey, secretKey) { | |
41511 | var k = nacl.box.before(publicKey, secretKey); | |
41512 | return nacl.secretbox(msg, nonce, k); | |
41513 | }; | |
41514 | ||
41515 | nacl.box.before = function(publicKey, secretKey) { | |
41516 | checkArrayTypes(publicKey, secretKey); | |
41517 | checkBoxLengths(publicKey, secretKey); | |
41518 | var k = new Uint8Array(crypto_box_BEFORENMBYTES); | |
41519 | crypto_box_beforenm(k, publicKey, secretKey); | |
41520 | return k; | |
41521 | }; | |
41522 | ||
41523 | nacl.box.after = nacl.secretbox; | |
41524 | ||
41525 | nacl.box.open = function(msg, nonce, publicKey, secretKey) { | |
41526 | var k = nacl.box.before(publicKey, secretKey); | |
41527 | return nacl.secretbox.open(msg, nonce, k); | |
41528 | }; | |
41529 | ||
41530 | nacl.box.open.after = nacl.secretbox.open; | |
41531 | ||
41532 | nacl.box.keyPair = function() { | |
41533 | var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES); | |
41534 | var sk = new Uint8Array(crypto_box_SECRETKEYBYTES); | |
41535 | crypto_box_keypair(pk, sk); | |
41536 | return {publicKey: pk, secretKey: sk}; | |
41537 | }; | |
41538 | ||
41539 | nacl.box.keyPair.fromSecretKey = function(secretKey) { | |
41540 | checkArrayTypes(secretKey); | |
41541 | if (secretKey.length !== crypto_box_SECRETKEYBYTES) | |
41542 | throw new Error('bad secret key size'); | |
41543 | var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES); | |
41544 | crypto_scalarmult_base(pk, secretKey); | |
41545 | return {publicKey: pk, secretKey: new Uint8Array(secretKey)}; | |
41546 | }; | |
41547 | ||
41548 | nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES; | |
41549 | nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES; | |
41550 | nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES; | |
41551 | nacl.box.nonceLength = crypto_box_NONCEBYTES; | |
41552 | nacl.box.overheadLength = nacl.secretbox.overheadLength; | |
41553 | ||
41554 | nacl.sign = function(msg, secretKey) { | |
41555 | checkArrayTypes(msg, secretKey); | |
41556 | if (secretKey.length !== crypto_sign_SECRETKEYBYTES) | |
41557 | throw new Error('bad secret key size'); | |
41558 | var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length); | |
41559 | crypto_sign(signedMsg, msg, msg.length, secretKey); | |
41560 | return signedMsg; | |
41561 | }; | |
41562 | ||
41563 | nacl.sign.open = function(signedMsg, publicKey) { | |
41564 | checkArrayTypes(signedMsg, publicKey); | |
41565 | if (publicKey.length !== crypto_sign_PUBLICKEYBYTES) | |
41566 | throw new Error('bad public key size'); | |
41567 | var tmp = new Uint8Array(signedMsg.length); | |
41568 | var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey); | |
41569 | if (mlen < 0) return null; | |
41570 | var m = new Uint8Array(mlen); | |
41571 | for (var i = 0; i < m.length; i++) m[i] = tmp[i]; | |
41572 | return m; | |
41573 | }; | |
41574 | ||
41575 | nacl.sign.detached = function(msg, secretKey) { | |
41576 | var signedMsg = nacl.sign(msg, secretKey); | |
41577 | var sig = new Uint8Array(crypto_sign_BYTES); | |
41578 | for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i]; | |
41579 | return sig; | |
41580 | }; | |
41581 | ||
41582 | nacl.sign.detached.verify = function(msg, sig, publicKey) { | |
41583 | checkArrayTypes(msg, sig, publicKey); | |
41584 | if (sig.length !== crypto_sign_BYTES) | |
41585 | throw new Error('bad signature size'); | |
41586 | if (publicKey.length !== crypto_sign_PUBLICKEYBYTES) | |
41587 | throw new Error('bad public key size'); | |
41588 | var sm = new Uint8Array(crypto_sign_BYTES + msg.length); | |
41589 | var m = new Uint8Array(crypto_sign_BYTES + msg.length); | |
41590 | var i; | |
41591 | for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i]; | |
41592 | for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i]; | |
41593 | return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0); | |
41594 | }; | |
41595 | ||
41596 | nacl.sign.keyPair = function() { | |
41597 | var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES); | |
41598 | var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES); | |
41599 | crypto_sign_keypair(pk, sk); | |
41600 | return {publicKey: pk, secretKey: sk}; | |
41601 | }; | |
41602 | ||
41603 | nacl.sign.keyPair.fromSecretKey = function(secretKey) { | |
41604 | checkArrayTypes(secretKey); | |
41605 | if (secretKey.length !== crypto_sign_SECRETKEYBYTES) | |
41606 | throw new Error('bad secret key size'); | |
41607 | var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES); | |
41608 | for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i]; | |
41609 | return {publicKey: pk, secretKey: new Uint8Array(secretKey)}; | |
41610 | }; | |
41611 | ||
41612 | nacl.sign.keyPair.fromSeed = function(seed) { | |
41613 | checkArrayTypes(seed); | |
41614 | if (seed.length !== crypto_sign_SEEDBYTES) | |
41615 | throw new Error('bad seed size'); | |
41616 | var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES); | |
41617 | var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES); | |
41618 | for (var i = 0; i < 32; i++) sk[i] = seed[i]; | |
41619 | crypto_sign_keypair(pk, sk, true); | |
41620 | return {publicKey: pk, secretKey: sk}; | |
41621 | }; | |
41622 | ||
41623 | nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES; | |
41624 | nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES; | |
41625 | nacl.sign.seedLength = crypto_sign_SEEDBYTES; | |
41626 | nacl.sign.signatureLength = crypto_sign_BYTES; | |
41627 | ||
41628 | nacl.hash = function(msg) { | |
41629 | checkArrayTypes(msg); | |
41630 | var h = new Uint8Array(crypto_hash_BYTES); | |
41631 | crypto_hash(h, msg, msg.length); | |
41632 | return h; | |
41633 | }; | |
41634 | ||
41635 | nacl.hash.hashLength = crypto_hash_BYTES; | |
41636 | ||
41637 | nacl.verify = function(x, y) { | |
41638 | checkArrayTypes(x, y); | |
41639 | // Zero length arguments are considered not equal. | |
41640 | if (x.length === 0 || y.length === 0) return false; | |
41641 | if (x.length !== y.length) return false; | |
41642 | return (vn(x, 0, y, 0, x.length) === 0) ? true : false; | |
41643 | }; | |
41644 | ||
41645 | nacl.setPRNG = function(fn) { | |
41646 | randombytes = fn; | |
41647 | }; | |
41648 | ||
41649 | (function() { | |
41650 | // Initialize PRNG if environment provides CSPRNG. | |
41651 | // If not, methods calling randombytes will throw. | |
41652 | var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null; | |
41653 | if (crypto && crypto.getRandomValues) { | |
41654 | // Browsers. | |
41655 | var QUOTA = 65536; | |
41656 | nacl.setPRNG(function(x, n) { | |
41657 | var i, v = new Uint8Array(n); | |
41658 | for (i = 0; i < n; i += QUOTA) { | |
41659 | crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA))); | |
41660 | } | |
41661 | for (i = 0; i < n; i++) x[i] = v[i]; | |
41662 | cleanup(v); | |
41663 | }); | |
41664 | } else if (typeof require !== 'undefined') { | |
41665 | // Node.js. | |
41666 | crypto = require('crypto'); | |
41667 | if (crypto && crypto.randomBytes) { | |
41668 | nacl.setPRNG(function(x, n) { | |
41669 | var i, v = crypto.randomBytes(n); | |
41670 | for (i = 0; i < n; i++) x[i] = v[i]; | |
41671 | cleanup(v); | |
41672 | }); | |
41673 | } | |
41674 | } | |
41675 | })(); | |
41676 | ||
41677 | })(typeof module !== 'undefined' && module.exports ? module.exports : (self.nacl = self.nacl || {})); | |
41678 | ||
41679 | },{"crypto":20}],441:[function(require,module,exports){ | |
41680 | (function (global){ | |
41681 | ||
41682 | /** | |
41683 | * Module exports. | |
41684 | */ | |
41685 | ||
41686 | module.exports = deprecate; | |
41687 | ||
41688 | /** | |
41689 | * Mark that a method should not be used. | |
41690 | * Returns a modified function which warns once by default. | |
41691 | * | |
41692 | * If `localStorage.noDeprecation = true` is set, then it is a no-op. | |
41693 | * | |
41694 | * If `localStorage.throwDeprecation = true` is set, then deprecated functions | |
41695 | * will throw an Error when invoked. | |
41696 | * | |
41697 | * If `localStorage.traceDeprecation = true` is set, then deprecated functions | |
41698 | * will invoke `console.trace()` instead of `console.error()`. | |
41699 | * | |
41700 | * @param {Function} fn - the function to deprecate | |
41701 | * @param {String} msg - the string to print to the console when `fn` is invoked | |
41702 | * @returns {Function} a new "deprecated" version of `fn` | |
41703 | * @api public | |
41704 | */ | |
41705 | ||
41706 | function deprecate (fn, msg) { | |
41707 | if (config('noDeprecation')) { | |
41708 | return fn; | |
41709 | } | |
41710 | ||
41711 | var warned = false; | |
41712 | function deprecated() { | |
41713 | if (!warned) { | |
41714 | if (config('throwDeprecation')) { | |
41715 | throw new Error(msg); | |
41716 | } else if (config('traceDeprecation')) { | |
41717 | console.trace(msg); | |
41718 | } else { | |
41719 | console.warn(msg); | |
41720 | } | |
41721 | warned = true; | |
41722 | } | |
41723 | return fn.apply(this, arguments); | |
41724 | } | |
41725 | ||
41726 | return deprecated; | |
41727 | } | |
41728 | ||
41729 | /** | |
41730 | * Checks `localStorage` for boolean values for the given `name`. | |
41731 | * | |
41732 | * @param {String} name | |
41733 | * @returns {Boolean} | |
41734 | * @api private | |
41735 | */ | |
41736 | ||
41737 | function config (name) { | |
41738 | // accessing global.localStorage can trigger a DOMException in sandboxed iframes | |
41739 | try { | |
41740 | if (!global.localStorage) return false; | |
41741 | } catch (_) { | |
41742 | return false; | |
41743 | } | |
41744 | var val = global.localStorage[name]; | |
41745 | if (null == val) return false; | |
41746 | return String(val).toLowerCase() === 'true'; | |
41747 | } | |
41748 | ||
41749 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
41750 | },{}],442:[function(require,module,exports){ | |
41751 | module.exports = function isBuffer(arg) { | |
41752 | return arg && typeof arg === 'object' | |
41753 | && typeof arg.copy === 'function' | |
41754 | && typeof arg.fill === 'function' | |
41755 | && typeof arg.readUInt8 === 'function'; | |
41756 | } | |
41757 | },{}],443:[function(require,module,exports){ | |
41758 | (function (process,global){ | |
41759 | // Copyright Joyent, Inc. and other Node contributors. | |
41760 | // | |
41761 | // Permission is hereby granted, free of charge, to any person obtaining a | |
41762 | // copy of this software and associated documentation files (the | |
41763 | // "Software"), to deal in the Software without restriction, including | |
41764 | // without limitation the rights to use, copy, modify, merge, publish, | |
41765 | // distribute, sublicense, and/or sell copies of the Software, and to permit | |
41766 | // persons to whom the Software is furnished to do so, subject to the | |
41767 | // following conditions: | |
41768 | // | |
41769 | // The above copyright notice and this permission notice shall be included | |
41770 | // in all copies or substantial portions of the Software. | |
41771 | // | |
41772 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
41773 | // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
41774 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
41775 | // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
41776 | // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
41777 | // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
41778 | // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
41779 | ||
41780 | var formatRegExp = /%[sdj%]/g; | |
41781 | exports.format = function(f) { | |
41782 | if (!isString(f)) { | |
41783 | var objects = []; | |
41784 | for (var i = 0; i < arguments.length; i++) { | |
41785 | objects.push(inspect(arguments[i])); | |
41786 | } | |
41787 | return objects.join(' '); | |
41788 | } | |
41789 | ||
41790 | var i = 1; | |
41791 | var args = arguments; | |
41792 | var len = args.length; | |
41793 | var str = String(f).replace(formatRegExp, function(x) { | |
41794 | if (x === '%%') return '%'; | |
41795 | if (i >= len) return x; | |
41796 | switch (x) { | |
41797 | case '%s': return String(args[i++]); | |
41798 | case '%d': return Number(args[i++]); | |
41799 | case '%j': | |
41800 | try { | |
41801 | return JSON.stringify(args[i++]); | |
41802 | } catch (_) { | |
41803 | return '[Circular]'; | |
41804 | } | |
41805 | default: | |
41806 | return x; | |
41807 | } | |
41808 | }); | |
41809 | for (var x = args[i]; i < len; x = args[++i]) { | |
41810 | if (isNull(x) || !isObject(x)) { | |
41811 | str += ' ' + x; | |
41812 | } else { | |
41813 | str += ' ' + inspect(x); | |
41814 | } | |
41815 | } | |
41816 | return str; | |
41817 | }; | |
41818 | ||
41819 | ||
41820 | // Mark that a method should not be used. | |
41821 | // Returns a modified function which warns once by default. | |
41822 | // If --no-deprecation is set, then it is a no-op. | |
41823 | exports.deprecate = function(fn, msg) { | |
41824 | // Allow for deprecating things in the process of starting up. | |
41825 | if (isUndefined(global.process)) { | |
41826 | return function() { | |
41827 | return exports.deprecate(fn, msg).apply(this, arguments); | |
41828 | }; | |
41829 | } | |
41830 | ||
41831 | if (process.noDeprecation === true) { | |
41832 | return fn; | |
41833 | } | |
41834 | ||
41835 | var warned = false; | |
41836 | function deprecated() { | |
41837 | if (!warned) { | |
41838 | if (process.throwDeprecation) { | |
41839 | throw new Error(msg); | |
41840 | } else if (process.traceDeprecation) { | |
41841 | console.trace(msg); | |
41842 | } else { | |
41843 | console.error(msg); | |
41844 | } | |
41845 | warned = true; | |
41846 | } | |
41847 | return fn.apply(this, arguments); | |
41848 | } | |
41849 | ||
41850 | return deprecated; | |
41851 | }; | |
41852 | ||
41853 | ||
41854 | var debugs = {}; | |
41855 | var debugEnviron; | |
41856 | exports.debuglog = function(set) { | |
41857 | if (isUndefined(debugEnviron)) | |
41858 | debugEnviron = process.env.NODE_DEBUG || ''; | |
41859 | set = set.toUpperCase(); | |
41860 | if (!debugs[set]) { | |
41861 | if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { | |
41862 | var pid = process.pid; | |
41863 | debugs[set] = function() { | |
41864 | var msg = exports.format.apply(exports, arguments); | |
41865 | console.error('%s %d: %s', set, pid, msg); | |
41866 | }; | |
41867 | } else { | |
41868 | debugs[set] = function() {}; | |
41869 | } | |
41870 | } | |
41871 | return debugs[set]; | |
41872 | }; | |
41873 | ||
41874 | ||
41875 | /** | |
41876 | * Echos the value of a value. Trys to print the value out | |
41877 | * in the best way possible given the different types. | |
41878 | * | |
41879 | * @param {Object} obj The object to print out. | |
41880 | * @param {Object} opts Optional options object that alters the output. | |
41881 | */ | |
41882 | /* legacy: obj, showHidden, depth, colors*/ | |
41883 | function inspect(obj, opts) { | |
41884 | // default options | |
41885 | var ctx = { | |
41886 | seen: [], | |
41887 | stylize: stylizeNoColor | |
41888 | }; | |
41889 | // legacy... | |
41890 | if (arguments.length >= 3) ctx.depth = arguments[2]; | |
41891 | if (arguments.length >= 4) ctx.colors = arguments[3]; | |
41892 | if (isBoolean(opts)) { | |
41893 | // legacy... | |
41894 | ctx.showHidden = opts; | |
41895 | } else if (opts) { | |
41896 | // got an "options" object | |
41897 | exports._extend(ctx, opts); | |
41898 | } | |
41899 | // set default options | |
41900 | if (isUndefined(ctx.showHidden)) ctx.showHidden = false; | |
41901 | if (isUndefined(ctx.depth)) ctx.depth = 2; | |
41902 | if (isUndefined(ctx.colors)) ctx.colors = false; | |
41903 | if (isUndefined(ctx.customInspect)) ctx.customInspect = true; | |
41904 | if (ctx.colors) ctx.stylize = stylizeWithColor; | |
41905 | return formatValue(ctx, obj, ctx.depth); | |
41906 | } | |
41907 | exports.inspect = inspect; | |
41908 | ||
41909 | ||
41910 | // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics | |
41911 | inspect.colors = { | |
41912 | 'bold' : [1, 22], | |
41913 | 'italic' : [3, 23], | |
41914 | 'underline' : [4, 24], | |
41915 | 'inverse' : [7, 27], | |
41916 | 'white' : [37, 39], | |
41917 | 'grey' : [90, 39], | |
41918 | 'black' : [30, 39], | |
41919 | 'blue' : [34, 39], | |
41920 | 'cyan' : [36, 39], | |
41921 | 'green' : [32, 39], | |
41922 | 'magenta' : [35, 39], | |
41923 | 'red' : [31, 39], | |
41924 | 'yellow' : [33, 39] | |
41925 | }; | |
41926 | ||
41927 | // Don't use 'blue' not visible on cmd.exe | |
41928 | inspect.styles = { | |
41929 | 'special': 'cyan', | |
41930 | 'number': 'yellow', | |
41931 | 'boolean': 'yellow', | |
41932 | 'undefined': 'grey', | |
41933 | 'null': 'bold', | |
41934 | 'string': 'green', | |
41935 | 'date': 'magenta', | |
41936 | // "name": intentionally not styling | |
41937 | 'regexp': 'red' | |
41938 | }; | |
41939 | ||
41940 | ||
41941 | function stylizeWithColor(str, styleType) { | |
41942 | var style = inspect.styles[styleType]; | |
41943 | ||
41944 | if (style) { | |
41945 | return '\u001b[' + inspect.colors[style][0] + 'm' + str + | |
41946 | '\u001b[' + inspect.colors[style][1] + 'm'; | |
41947 | } else { | |
41948 | return str; | |
41949 | } | |
41950 | } | |
41951 | ||
41952 | ||
41953 | function stylizeNoColor(str, styleType) { | |
41954 | return str; | |
41955 | } | |
41956 | ||
41957 | ||
41958 | function arrayToHash(array) { | |
41959 | var hash = {}; | |
41960 | ||
41961 | array.forEach(function(val, idx) { | |
41962 | hash[val] = true; | |
41963 | }); | |
41964 | ||
41965 | return hash; | |
41966 | } | |
41967 | ||
41968 | ||
41969 | function formatValue(ctx, value, recurseTimes) { | |
41970 | // Provide a hook for user-specified inspect functions. | |
41971 | // Check that value is an object with an inspect function on it | |
41972 | if (ctx.customInspect && | |
41973 | value && | |
41974 | isFunction(value.inspect) && | |
41975 | // Filter out the util module, it's inspect function is special | |
41976 | value.inspect !== exports.inspect && | |
41977 | // Also filter out any prototype objects using the circular check. | |
41978 | !(value.constructor && value.constructor.prototype === value)) { | |
41979 | var ret = value.inspect(recurseTimes, ctx); | |
41980 | if (!isString(ret)) { | |
41981 | ret = formatValue(ctx, ret, recurseTimes); | |
41982 | } | |
41983 | return ret; | |
41984 | } | |
41985 | ||
41986 | // Primitive types cannot have properties | |
41987 | var primitive = formatPrimitive(ctx, value); | |
41988 | if (primitive) { | |
41989 | return primitive; | |
41990 | } | |
41991 | ||
41992 | // Look up the keys of the object. | |
41993 | var keys = Object.keys(value); | |
41994 | var visibleKeys = arrayToHash(keys); | |
41995 | ||
41996 | if (ctx.showHidden) { | |
41997 | keys = Object.getOwnPropertyNames(value); | |
41998 | } | |
41999 | ||
42000 | // IE doesn't make error fields non-enumerable | |
42001 | // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx | |
42002 | if (isError(value) | |
42003 | && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { | |
42004 | return formatError(value); | |
42005 | } | |
42006 | ||
42007 | // Some type of object without properties can be shortcutted. | |
42008 | if (keys.length === 0) { | |
42009 | if (isFunction(value)) { | |
42010 | var name = value.name ? ': ' + value.name : ''; | |
42011 | return ctx.stylize('[Function' + name + ']', 'special'); | |
42012 | } | |
42013 | if (isRegExp(value)) { | |
42014 | return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | |
42015 | } | |
42016 | if (isDate(value)) { | |
42017 | return ctx.stylize(Date.prototype.toString.call(value), 'date'); | |
42018 | } | |
42019 | if (isError(value)) { | |
42020 | return formatError(value); | |
42021 | } | |
42022 | } | |
42023 | ||
42024 | var base = '', array = false, braces = ['{', '}']; | |
42025 | ||
42026 | // Make Array say that they are Array | |
42027 | if (isArray(value)) { | |
42028 | array = true; | |
42029 | braces = ['[', ']']; | |
42030 | } | |
42031 | ||
42032 | // Make functions say that they are functions | |
42033 | if (isFunction(value)) { | |
42034 | var n = value.name ? ': ' + value.name : ''; | |
42035 | base = ' [Function' + n + ']'; | |
42036 | } | |
42037 | ||
42038 | // Make RegExps say that they are RegExps | |
42039 | if (isRegExp(value)) { | |
42040 | base = ' ' + RegExp.prototype.toString.call(value); | |
42041 | } | |
42042 | ||
42043 | // Make dates with properties first say the date | |
42044 | if (isDate(value)) { | |
42045 | base = ' ' + Date.prototype.toUTCString.call(value); | |
42046 | } | |
42047 | ||
42048 | // Make error with message first say the error | |
42049 | if (isError(value)) { | |
42050 | base = ' ' + formatError(value); | |
42051 | } | |
42052 | ||
42053 | if (keys.length === 0 && (!array || value.length == 0)) { | |
42054 | return braces[0] + base + braces[1]; | |
42055 | } | |
42056 | ||
42057 | if (recurseTimes < 0) { | |
42058 | if (isRegExp(value)) { | |
42059 | return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | |
42060 | } else { | |
42061 | return ctx.stylize('[Object]', 'special'); | |
42062 | } | |
42063 | } | |
42064 | ||
42065 | ctx.seen.push(value); | |
42066 | ||
42067 | var output; | |
42068 | if (array) { | |
42069 | output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); | |
42070 | } else { | |
42071 | output = keys.map(function(key) { | |
42072 | return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); | |
42073 | }); | |
42074 | } | |
42075 | ||
42076 | ctx.seen.pop(); | |
42077 | ||
42078 | return reduceToSingleString(output, base, braces); | |
42079 | } | |
42080 | ||
42081 | ||
42082 | function formatPrimitive(ctx, value) { | |
42083 | if (isUndefined(value)) | |
42084 | return ctx.stylize('undefined', 'undefined'); | |
42085 | if (isString(value)) { | |
42086 | var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') | |
42087 | .replace(/'/g, "\\'") | |
42088 | .replace(/\\"/g, '"') + '\''; | |
42089 | return ctx.stylize(simple, 'string'); | |
42090 | } | |
42091 | if (isNumber(value)) | |
42092 | return ctx.stylize('' + value, 'number'); | |
42093 | if (isBoolean(value)) | |
42094 | return ctx.stylize('' + value, 'boolean'); | |
42095 | // For some reason typeof null is "object", so special case here. | |
42096 | if (isNull(value)) | |
42097 | return ctx.stylize('null', 'null'); | |
42098 | } | |
42099 | ||
42100 | ||
42101 | function formatError(value) { | |
42102 | return '[' + Error.prototype.toString.call(value) + ']'; | |
42103 | } | |
42104 | ||
42105 | ||
42106 | function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { | |
42107 | var output = []; | |
42108 | for (var i = 0, l = value.length; i < l; ++i) { | |
42109 | if (hasOwnProperty(value, String(i))) { | |
42110 | output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | |
42111 | String(i), true)); | |
42112 | } else { | |
42113 | output.push(''); | |
42114 | } | |
42115 | } | |
42116 | keys.forEach(function(key) { | |
42117 | if (!key.match(/^\d+$/)) { | |
42118 | output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | |
42119 | key, true)); | |
42120 | } | |
42121 | }); | |
42122 | return output; | |
42123 | } | |
42124 | ||
42125 | ||
42126 | function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { | |
42127 | var name, str, desc; | |
42128 | desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; | |
42129 | if (desc.get) { | |
42130 | if (desc.set) { | |
42131 | str = ctx.stylize('[Getter/Setter]', 'special'); | |
42132 | } else { | |
42133 | str = ctx.stylize('[Getter]', 'special'); | |
42134 | } | |
42135 | } else { | |
42136 | if (desc.set) { | |
42137 | str = ctx.stylize('[Setter]', 'special'); | |
42138 | } | |
42139 | } | |
42140 | if (!hasOwnProperty(visibleKeys, key)) { | |
42141 | name = '[' + key + ']'; | |
42142 | } | |
42143 | if (!str) { | |
42144 | if (ctx.seen.indexOf(desc.value) < 0) { | |
42145 | if (isNull(recurseTimes)) { | |
42146 | str = formatValue(ctx, desc.value, null); | |
42147 | } else { | |
42148 | str = formatValue(ctx, desc.value, recurseTimes - 1); | |
42149 | } | |
42150 | if (str.indexOf('\n') > -1) { | |
42151 | if (array) { | |
42152 | str = str.split('\n').map(function(line) { | |
42153 | return ' ' + line; | |
42154 | }).join('\n').substr(2); | |
42155 | } else { | |
42156 | str = '\n' + str.split('\n').map(function(line) { | |
42157 | return ' ' + line; | |
42158 | }).join('\n'); | |
42159 | } | |
42160 | } | |
42161 | } else { | |
42162 | str = ctx.stylize('[Circular]', 'special'); | |
42163 | } | |
42164 | } | |
42165 | if (isUndefined(name)) { | |
42166 | if (array && key.match(/^\d+$/)) { | |
42167 | return str; | |
42168 | } | |
42169 | name = JSON.stringify('' + key); | |
42170 | if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { | |
42171 | name = name.substr(1, name.length - 2); | |
42172 | name = ctx.stylize(name, 'name'); | |
42173 | } else { | |
42174 | name = name.replace(/'/g, "\\'") | |
42175 | .replace(/\\"/g, '"') | |
42176 | .replace(/(^"|"$)/g, "'"); | |
42177 | name = ctx.stylize(name, 'string'); | |
42178 | } | |
42179 | } | |
42180 | ||
42181 | return name + ': ' + str; | |
42182 | } | |
42183 | ||
42184 | ||
42185 | function reduceToSingleString(output, base, braces) { | |
42186 | var numLinesEst = 0; | |
42187 | var length = output.reduce(function(prev, cur) { | |
42188 | numLinesEst++; | |
42189 | if (cur.indexOf('\n') >= 0) numLinesEst++; | |
42190 | return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; | |
42191 | }, 0); | |
42192 | ||
42193 | if (length > 60) { | |
42194 | return braces[0] + | |
42195 | (base === '' ? '' : base + '\n ') + | |
42196 | ' ' + | |
42197 | output.join(',\n ') + | |
42198 | ' ' + | |
42199 | braces[1]; | |
42200 | } | |
42201 | ||
42202 | return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; | |
42203 | } | |
42204 | ||
42205 | ||
42206 | // NOTE: These type checking functions intentionally don't use `instanceof` | |
42207 | // because it is fragile and can be easily faked with `Object.create()`. | |
42208 | function isArray(ar) { | |
42209 | return Array.isArray(ar); | |
42210 | } | |
42211 | exports.isArray = isArray; | |
42212 | ||
42213 | function isBoolean(arg) { | |
42214 | return typeof arg === 'boolean'; | |
42215 | } | |
42216 | exports.isBoolean = isBoolean; | |
42217 | ||
42218 | function isNull(arg) { | |
42219 | return arg === null; | |
42220 | } | |
42221 | exports.isNull = isNull; | |
42222 | ||
42223 | function isNullOrUndefined(arg) { | |
42224 | return arg == null; | |
42225 | } | |
42226 | exports.isNullOrUndefined = isNullOrUndefined; | |
42227 | ||
42228 | function isNumber(arg) { | |
42229 | return typeof arg === 'number'; | |
42230 | } | |
42231 | exports.isNumber = isNumber; | |
42232 | ||
42233 | function isString(arg) { | |
42234 | return typeof arg === 'string'; | |
42235 | } | |
42236 | exports.isString = isString; | |
42237 | ||
42238 | function isSymbol(arg) { | |
42239 | return typeof arg === 'symbol'; | |
42240 | } | |
42241 | exports.isSymbol = isSymbol; | |
42242 | ||
42243 | function isUndefined(arg) { | |
42244 | return arg === void 0; | |
42245 | } | |
42246 | exports.isUndefined = isUndefined; | |
42247 | ||
42248 | function isRegExp(re) { | |
42249 | return isObject(re) && objectToString(re) === '[object RegExp]'; | |
42250 | } | |
42251 | exports.isRegExp = isRegExp; | |
42252 | ||
42253 | function isObject(arg) { | |
42254 | return typeof arg === 'object' && arg !== null; | |
42255 | } | |
42256 | exports.isObject = isObject; | |
42257 | ||
42258 | function isDate(d) { | |
42259 | return isObject(d) && objectToString(d) === '[object Date]'; | |
42260 | } | |
42261 | exports.isDate = isDate; | |
42262 | ||
42263 | function isError(e) { | |
42264 | return isObject(e) && | |
42265 | (objectToString(e) === '[object Error]' || e instanceof Error); | |
42266 | } | |
42267 | exports.isError = isError; | |
42268 | ||
42269 | function isFunction(arg) { | |
42270 | return typeof arg === 'function'; | |
42271 | } | |
42272 | exports.isFunction = isFunction; | |
42273 | ||
42274 | function isPrimitive(arg) { | |
42275 | return arg === null || | |
42276 | typeof arg === 'boolean' || | |
42277 | typeof arg === 'number' || | |
42278 | typeof arg === 'string' || | |
42279 | typeof arg === 'symbol' || // ES6 symbol | |
42280 | typeof arg === 'undefined'; | |
42281 | } | |
42282 | exports.isPrimitive = isPrimitive; | |
42283 | ||
42284 | exports.isBuffer = require('./support/isBuffer'); | |
42285 | ||
42286 | function objectToString(o) { | |
42287 | return Object.prototype.toString.call(o); | |
42288 | } | |
42289 | ||
42290 | ||
42291 | function pad(n) { | |
42292 | return n < 10 ? '0' + n.toString(10) : n.toString(10); | |
42293 | } | |
42294 | ||
42295 | ||
42296 | var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', | |
42297 | 'Oct', 'Nov', 'Dec']; | |
42298 | ||
42299 | // 26 Feb 16:19:34 | |
42300 | function timestamp() { | |
42301 | var d = new Date(); | |
42302 | var time = [pad(d.getHours()), | |
42303 | pad(d.getMinutes()), | |
42304 | pad(d.getSeconds())].join(':'); | |
42305 | return [d.getDate(), months[d.getMonth()], time].join(' '); | |
42306 | } | |
42307 | ||
42308 | ||
42309 | // log is just a thin wrapper to console.log that prepends a timestamp | |
42310 | exports.log = function() { | |
42311 | console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); | |
42312 | }; | |
42313 | ||
42314 | ||
42315 | /** | |
42316 | * Inherit the prototype methods from one constructor into another. | |
42317 | * | |
42318 | * The Function.prototype.inherits from lang.js rewritten as a standalone | |
42319 | * function (not on Function.prototype). NOTE: If this file is to be loaded | |
42320 | * during bootstrapping this function needs to be rewritten using some native | |
42321 | * functions as prototype setup using normal JavaScript does not work as | |
42322 | * expected during bootstrapping (see mirror.js in r114903). | |
42323 | * | |
42324 | * @param {function} ctor Constructor function which needs to inherit the | |
42325 | * prototype. | |
42326 | * @param {function} superCtor Constructor function to inherit prototype from. | |
42327 | */ | |
42328 | exports.inherits = require('inherits'); | |
42329 | ||
42330 | exports._extend = function(origin, add) { | |
42331 | // Don't do anything if add isn't an object | |
42332 | if (!add || !isObject(add)) return origin; | |
42333 | ||
42334 | var keys = Object.keys(add); | |
42335 | var i = keys.length; | |
42336 | while (i--) { | |
42337 | origin[keys[i]] = add[keys[i]]; | |
42338 | } | |
42339 | return origin; | |
42340 | }; | |
42341 | ||
42342 | function hasOwnProperty(obj, prop) { | |
42343 | return Object.prototype.hasOwnProperty.call(obj, prop); | |
42344 | } | |
42345 | ||
42346 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
42347 | },{"./support/isBuffer":442,"_process":374,"inherits":119}],444:[function(require,module,exports){ | |
42348 | var indexOf = function (xs, item) { | |
42349 | if (xs.indexOf) return xs.indexOf(item); | |
42350 | else for (var i = 0; i < xs.length; i++) { | |
42351 | if (xs[i] === item) return i; | |
42352 | } | |
42353 | return -1; | |
42354 | }; | |
42355 | var Object_keys = function (obj) { | |
42356 | if (Object.keys) return Object.keys(obj) | |
42357 | else { | |
42358 | var res = []; | |
42359 | for (var key in obj) res.push(key) | |
42360 | return res; | |
42361 | } | |
42362 | }; | |
42363 | ||
42364 | var forEach = function (xs, fn) { | |
42365 | if (xs.forEach) return xs.forEach(fn) | |
42366 | else for (var i = 0; i < xs.length; i++) { | |
42367 | fn(xs[i], i, xs); | |
42368 | } | |
42369 | }; | |
42370 | ||
42371 | var defineProp = (function() { | |
42372 | try { | |
42373 | Object.defineProperty({}, '_', {}); | |
42374 | return function(obj, name, value) { | |
42375 | Object.defineProperty(obj, name, { | |
42376 | writable: true, | |
42377 | enumerable: false, | |
42378 | configurable: true, | |
42379 | value: value | |
42380 | }) | |
42381 | }; | |
42382 | } catch(e) { | |
42383 | return function(obj, name, value) { | |
42384 | obj[name] = value; | |
42385 | }; | |
42386 | } | |
42387 | }()); | |
42388 | ||
42389 | var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function', | |
42390 | 'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError', | |
42391 | 'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError', | |
42392 | 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', | |
42393 | 'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape']; | |
42394 | ||
42395 | function Context() {} | |
42396 | Context.prototype = {}; | |
42397 | ||
42398 | var Script = exports.Script = function NodeScript (code) { | |
42399 | if (!(this instanceof Script)) return new Script(code); | |
42400 | this.code = code; | |
42401 | }; | |
42402 | ||
42403 | Script.prototype.runInContext = function (context) { | |
42404 | if (!(context instanceof Context)) { | |
42405 | throw new TypeError("needs a 'context' argument."); | |
42406 | } | |
5b689bd6 | 42407 | |
8e3b890d SÖ |
42408 | var iframe = document.createElement('iframe'); |
42409 | if (!iframe.style) iframe.style = {}; | |
42410 | iframe.style.display = 'none'; | |
5b689bd6 | 42411 | |
8e3b890d | 42412 | document.body.appendChild(iframe); |
5b689bd6 | 42413 | |
8e3b890d SÖ |
42414 | var win = iframe.contentWindow; |
42415 | var wEval = win.eval, wExecScript = win.execScript; | |
42416 | ||
42417 | if (!wEval && wExecScript) { | |
42418 | // win.eval() magically appears when this is called in IE: | |
42419 | wExecScript.call(win, 'null'); | |
42420 | wEval = win.eval; | |
42421 | } | |
5b689bd6 | 42422 | |
8e3b890d SÖ |
42423 | forEach(Object_keys(context), function (key) { |
42424 | win[key] = context[key]; | |
42425 | }); | |
42426 | forEach(globals, function (key) { | |
42427 | if (context[key]) { | |
42428 | win[key] = context[key]; | |
42429 | } | |
42430 | }); | |
5b689bd6 | 42431 | |
8e3b890d SÖ |
42432 | var winKeys = Object_keys(win); |
42433 | ||
42434 | var res = wEval.call(win, this.code); | |
5b689bd6 | 42435 | |
8e3b890d SÖ |
42436 | forEach(Object_keys(win), function (key) { |
42437 | // Avoid copying circular objects like `top` and `window` by only | |
42438 | // updating existing context properties or new properties in the `win` | |
42439 | // that was only introduced after the eval. | |
42440 | if (key in context || indexOf(winKeys, key) === -1) { | |
42441 | context[key] = win[key]; | |
42442 | } | |
42443 | }); | |
42444 | ||
42445 | forEach(globals, function (key) { | |
42446 | if (!(key in context)) { | |
42447 | defineProp(context, key, win[key]); | |
42448 | } | |
42449 | }); | |
5b689bd6 | 42450 | |
8e3b890d | 42451 | document.body.removeChild(iframe); |
5b689bd6 | 42452 | |
8e3b890d SÖ |
42453 | return res; |
42454 | }; | |
42455 | ||
42456 | Script.prototype.runInThisContext = function () { | |
42457 | return eval(this.code); // maybe... | |
42458 | }; | |
42459 | ||
42460 | Script.prototype.runInNewContext = function (context) { | |
42461 | var ctx = Script.createContext(context); | |
42462 | var res = this.runInContext(ctx); | |
42463 | ||
42464 | if (context) { | |
42465 | forEach(Object_keys(ctx), function (key) { | |
42466 | context[key] = ctx[key]; | |
42467 | }); | |
42468 | } | |
42469 | ||
42470 | return res; | |
42471 | }; | |
42472 | ||
42473 | forEach(Object_keys(Script.prototype), function (name) { | |
42474 | exports[name] = Script[name] = function (code) { | |
42475 | var s = Script(code); | |
42476 | return s[name].apply(s, [].slice.call(arguments, 1)); | |
42477 | }; | |
42478 | }); | |
42479 | ||
42480 | exports.isContext = function (context) { | |
42481 | return context instanceof Context; | |
42482 | }; | |
42483 | ||
42484 | exports.createScript = function (code) { | |
42485 | return exports.Script(code); | |
42486 | }; | |
42487 | ||
42488 | exports.createContext = Script.createContext = function (context) { | |
42489 | var copy = new Context(); | |
42490 | if(typeof context === 'object') { | |
42491 | forEach(Object_keys(context), function (key) { | |
42492 | copy[key] = context[key]; | |
42493 | }); | |
42494 | } | |
42495 | return copy; | |
42496 | }; | |
42497 | ||
42498 | },{}],445:[function(require,module,exports){ | |
42499 | const StellarBase = require('stellar-base'); | |
42500 | const edHd = require('ed25519-hd-key'); | |
42501 | ||
42502 | window.stellarUtil = { | |
42503 | getKeypair: function (path, seed) { | |
42504 | const result = edHd.derivePath(path, seed); | |
42505 | return StellarBase.Keypair.fromRawEd25519Seed(result.key); | |
ad59508d SÖ |
42506 | }, |
42507 | dummyNetwork: { | |
42508 | bip32: {public: 0, private: 0}, | |
42509 | messagePrefix: '', | |
42510 | pubKeyHash: 0, | |
42511 | scriptHash: 0, | |
42512 | wif: 0, | |
42513 | }, | |
8e3b890d SÖ |
42514 | } |
42515 | ||
42516 | },{"ed25519-hd-key":84,"stellar-base":412}]},{},[445]); |