UNPKG

tape/tmp.html

Version:
1<!doctype html><html><head><meta charset="utf-8"></head><body><pre id="__testling_output"></pre><script>(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
2(function (process){
3'use strict';
4
5var defined = require('defined');
6var createDefaultStream = require('./lib/default_stream');
7var Test = require('./lib/test');
8var createResult = require('./lib/results');
9var through = require('through');
10
11var canEmitExit = typeof process !== 'undefined' && process
12    && typeof process.on === 'function' && process.browser !== true;
13var canExit = typeof process !== 'undefined' && process
14    && typeof process.exit === 'function';
15
16module.exports = (function () {
17	var wait = false;
18	var harness;
19
20	function getHarness(opts) {
21		if (!opts) { opts = {}; }
22		opts.autoclose = !canEmitExit;
23		// this override is here since tests fail via nyc if createHarness is moved upwards
24		// eslint-disable-next-line no-use-before-define
25		if (!harness) { harness = createExitHarness(opts, wait); }
26		return harness;
27	}
28
29	function lazyLoad() {
30		// eslint-disable-next-line no-invalid-this
31		return getHarness().apply(this, arguments);
32	}
33
34	lazyLoad.wait = function () {
35		wait = true;
36	};
37
38	lazyLoad.run = function () {
39		var run = getHarness().run;
40
41		if (run) { run(); }
42	};
43
44	lazyLoad.only = function () {
45		return getHarness().only.apply(this, arguments);
46	};
47
48	lazyLoad.createStream = function (opts) {
49		var options = opts || {};
50		if (!harness) {
51			var output = through();
52			getHarness({ stream: output, objectMode: options.objectMode });
53			return output;
54		}
55		return harness.createStream(options);
56	};
57
58	lazyLoad.onFinish = function () {
59		return getHarness().onFinish.apply(this, arguments);
60	};
61
62	lazyLoad.onFailure = function () {
63		return getHarness().onFailure.apply(this, arguments);
64	};
65
66	lazyLoad.getHarness = getHarness;
67
68	return lazyLoad;
69}());
70
71function createHarness(conf_) {
72	var results = createResult();
73	if (!conf_ || conf_.autoclose !== false) {
74		results.once('done', function () { results.close(); });
75	}
76
77	function test(name, conf, cb) {
78		var t = new Test(name, conf, cb);
79		test._tests.push(t);
80
81		(function inspectCode(st) {
82			st.on('test', function sub(st_) {
83				inspectCode(st_);
84			});
85			st.on('result', function (r) {
86				if (!r.todo && !r.ok && typeof r !== 'string') { test._exitCode = 1; }
87			});
88		}(t));
89
90		results.push(t);
91		return t;
92	}
93	test._results = results;
94
95	test._tests = [];
96
97	test.createStream = function (opts) {
98		return results.createStream(opts);
99	};
100
101	test.onFinish = function (cb) {
102		results.on('done', cb);
103	};
104
105	test.onFailure = function (cb) {
106		results.on('fail', cb);
107	};
108
109	var only = false;
110	test.only = function () {
111		if (only) { throw new Error('there can only be one only test'); }
112		if (conf_.noOnly) { throw new Error('`only` tests are prohibited'); }
113		only = true;
114		var t = test.apply(null, arguments);
115		results.only(t);
116		return t;
117	};
118	test._exitCode = 0;
119
120	test.close = function () { results.close(); };
121
122	return test;
123}
124
125function createExitHarness(conf, wait) {
126	var config = conf || {};
127	var harness = createHarness({
128		autoclose: defined(config.autoclose, false),
129		noOnly: defined(conf.noOnly, defined(process.env.NODE_TAPE_NO_ONLY_TEST, false))
130	});
131	var running = false;
132	var ended = false;
133
134	function run() {
135		if (running) { return; }
136		running = true;
137		var stream = harness.createStream({ objectMode: config.objectMode });
138		var es = stream.pipe(config.stream || createDefaultStream());
139		if (canEmitExit && es) { // in node v0.4, `es` is `undefined`
140			// TODO: use `err` arg?
141			// eslint-disable-next-line no-unused-vars
142			es.on('error', function (err) { harness._exitCode = 1; });
143		}
144		stream.on('end', function () { ended = true; });
145	}
146
147	if (wait) {
148		harness.run = run;
149	} else {
150		run();
151	}
152
153	if (config.exit === false) { return harness; }
154	if (!canEmitExit || !canExit) { return harness; }
155
156	process.on('exit', function (code) {
157		// let the process exit cleanly.
158		if (typeof code === 'number' && code !== 0) {
159			return;
160		}
161
162		if (!ended) {
163			var only = harness._results._only;
164			for (var i = 0; i < harness._tests.length; i++) {
165				var t = harness._tests[i];
166				if (!only || t === only) {
167					t._exit();
168				}
169			}
170		}
171		harness.close();
172
173		process.removeAllListeners('exit'); // necessary for node v0.6
174		process.exit(code || harness._exitCode); // eslint-disable-line no-process-exit
175	});
176
177	return harness;
178}
179
180module.exports.createHarness = createHarness;
181module.exports.Test = Test;
182module.exports.test = module.exports; // tap compat
183module.exports.test.skip = Test.skip;
184
185}).call(this,require("KliubH"))
186},{"./lib/default_stream":2,"./lib/results":3,"./lib/test":4,"KliubH":91,"defined":14,"through":79}],2:[function(require,module,exports){
187(function (process){
188'use strict';
189
190var through = require('through');
191var fs = require('fs');
192
193module.exports = function () {
194	var line = '';
195	var stream = through(write, flush);
196	return stream;
197
198	function write(buf) {
199		for (var i = 0; i < buf.length; i++) {
200			var c = typeof buf === 'string'
201				? buf.charAt(i)
202				: String.fromCharCode(buf[i]);
203			if (c === '\n') {
204				flush();
205			} else {
206				line += c;
207			}
208		}
209	}
210
211	function flush() {
212		if (fs.writeSync && (/^win/).test(process.platform)) {
213			try {
214				fs.writeSync(1, line + '\n');
215			} catch (e) {
216				stream.emit('error', e);
217			}
218		} else {
219			try {
220				console.log(line); // eslint-disable-line no-console
221			} catch (e) {
222				stream.emit('error', e);
223			}
224		}
225		line = '';
226	}
227};
228
229}).call(this,require("KliubH"))
230},{"KliubH":91,"fs":85,"through":79}],3:[function(require,module,exports){
231(function (process){
232'use strict';
233
234var defined = require('defined');
235var EventEmitter = require('events').EventEmitter;
236var inherits = require('inherits');
237var through = require('through');
238var resumer = require('resumer');
239var inspect = require('object-inspect');
240var callBound = require('call-bind/callBound');
241var has = require('has');
242var $exec = callBound('RegExp.prototype.exec');
243var $split = callBound('String.prototype.split');
244var $replace = callBound('String.prototype.replace');
245var $shift = callBound('Array.prototype.shift');
246var $push = callBound('Array.prototype.push');
247var yamlIndicators = /:|-|\?/;
248var nextTick = typeof setImmediate !== 'undefined'
249	? setImmediate
250	: process.nextTick;
251
252function coalesceWhiteSpaces(str) {
253	return $replace(String(str), /\s+/g, ' ');
254}
255
256function getNextTest(results) {
257	if (!results._only) {
258		return $shift(results.tests);
259	}
260
261	do {
262		var t = $shift(results.tests);
263		if (t && results._only === t) {
264			return t;
265		}
266	} while (results.tests.length !== 0);
267
268	return void undefined;
269}
270
271function invalidYaml(str) {
272	return $exec(yamlIndicators, str) !== null;
273}
274
275function encodeResult(res, count) {
276	var output = '';
277	output += (res.ok ? 'ok ' : 'not ok ') + count;
278	output += res.name ? ' ' + coalesceWhiteSpaces(res.name) : '';
279
280	if (res.skip) {
281		output += ' # SKIP' + (typeof res.skip === 'string' ? ' ' + coalesceWhiteSpaces(res.skip) : '');
282	} else if (res.todo) {
283		output += ' # TODO' + (typeof res.todo === 'string' ? ' ' + coalesceWhiteSpaces(res.todo) : '');
284	}
285
286	output += '\n';
287	if (res.ok) { return output; }
288
289	var outer = '  ';
290	var inner = outer + '  ';
291	output += outer + '---\n';
292	output += inner + 'operator: ' + res.operator + '\n';
293
294	if (has(res, 'expected') || has(res, 'actual')) {
295		var ex = inspect(res.expected, { depth: res.objectPrintDepth });
296		var ac = inspect(res.actual, { depth: res.objectPrintDepth });
297
298		if (Math.max(ex.length, ac.length) > 65 || invalidYaml(ex) || invalidYaml(ac)) {
299			output += inner + 'expected: |-\n' + inner + '  ' + ex + '\n';
300			output += inner + 'actual: |-\n' + inner + '  ' + ac + '\n';
301		} else {
302			output += inner + 'expected: ' + ex + '\n';
303			output += inner + 'actual:   ' + ac + '\n';
304		}
305	}
306	if (res.at) {
307		output += inner + 'at: ' + res.at + '\n';
308	}
309
310	var actualStack = res.actual && (typeof res.actual === 'object' || typeof res.actual === 'function') ? res.actual.stack : undefined;
311	var errorStack = res.error && res.error.stack;
312	var stack = defined(actualStack, errorStack);
313	if (stack) {
314		var lines = $split(String(stack), '\n');
315		output += inner + 'stack: |-\n';
316		for (var i = 0; i < lines.length; i++) {
317			output += inner + '  ' + lines[i] + '\n';
318		}
319	}
320
321	output += outer + '...\n';
322	return output;
323}
324
325function Results() {
326	if (!(this instanceof Results)) { return new Results(); }
327	this.count = 0;
328	this.fail = 0;
329	this.pass = 0;
330	this.todo = 0;
331	this._stream = through();
332	this.tests = [];
333	this._only = null;
334	this._isRunning = false;
335}
336
337inherits(Results, EventEmitter);
338
339Results.prototype.createStream = function (opts) {
340	if (!opts) { opts = {}; }
341	var self = this;
342	var output;
343	var testId = 0;
344	if (opts.objectMode) {
345		output = through();
346		self.on('_push', function ontest(t, extra) {
347			if (!extra) { extra = {}; }
348			var id = testId++;
349			t.once('prerun', function () {
350				var row = {
351					type: 'test',
352					name: t.name,
353					id: id,
354					skip: t._skip,
355					todo: t._todo
356				};
357				if (has(extra, 'parent')) {
358					row.parent = extra.parent;
359				}
360				output.queue(row);
361			});
362			t.on('test', function (st) {
363				ontest(st, { parent: id });
364			});
365			t.on('result', function (res) {
366				if (res && typeof res === 'object') {
367					res.test = id;
368					res.type = 'assert';
369				}
370				output.queue(res);
371			});
372			t.on('end', function () {
373				output.queue({ type: 'end', test: id });
374			});
375		});
376		self.on('done', function () { output.queue(null); });
377	} else {
378		output = resumer();
379		output.queue('TAP version 13\n');
380		self._stream.pipe(output);
381	}
382
383	if (!this._isRunning) {
384		this._isRunning = true;
385		nextTick(function next() {
386			var t;
387			while (t = getNextTest(self)) {
388				t.run();
389				if (!t.ended) {
390					t.once('end', function () { nextTick(next); });
391					return;
392				}
393			}
394			self.emit('done');
395		});
396	}
397
398	return output;
399};
400
401Results.prototype.push = function (t) {
402	var self = this;
403	$push(self.tests, t);
404	self._watch(t);
405	self.emit('_push', t);
406};
407
408Results.prototype.only = function (t) {
409	this._only = t;
410};
411
412Results.prototype._watch = function (t) {
413	var self = this;
414	function write(s) { self._stream.queue(s); }
415
416	t.once('prerun', function () {
417		var premsg = '';
418		if (t._skip) {
419			premsg = 'SKIP ';
420		} else if (t._todo) {
421			premsg = 'TODO ';
422		}
423		write('# ' + premsg + coalesceWhiteSpaces(t.name) + '\n');
424	});
425
426	t.on('result', function (res) {
427		if (typeof res === 'string') {
428			write('# ' + res + '\n');
429			return;
430		}
431		write(encodeResult(res, self.count + 1));
432		self.count++;
433
434		if (res.ok || res.todo) {
435			self.pass++;
436		} else {
437			self.fail++;
438			self.emit('fail');
439		}
440	});
441
442	t.on('test', function (st) { self._watch(st); });
443};
444
445Results.prototype.close = function () {
446	var self = this;
447	if (self.closed) { self._stream.emit('error', new Error('ALREADY CLOSED')); }
448	self.closed = true;
449
450	function write(s) { self._stream.queue(s); }
451
452	write('\n1..' + self.count + '\n');
453	write('# tests ' + self.count + '\n');
454	write('# pass  ' + (self.pass + self.todo) + '\n');
455	if (self.todo) { write('# todo  ' + self.todo + '\n'); }
456	if (self.fail) {
457		write('# fail  ' + self.fail + '\n');
458	} else {
459		write('\n# ok\n');
460	}
461
462	self._stream.queue(null);
463};
464
465module.exports = Results;
466
467}).call(this,require("KliubH"))
468},{"KliubH":91,"call-bind/callBound":10,"defined":14,"events":87,"has":39,"inherits":40,"object-inspect":56,"resumer":73,"through":79}],4:[function(require,module,exports){
469(function (process,__dirname){
470'use strict';
471
472var deepEqual = require('deep-equal');
473var defined = require('defined');
474var path = require('path');
475var inherits = require('inherits');
476var EventEmitter = require('events').EventEmitter;
477var has = require('has');
478var isRegExp = require('is-regex');
479var trim = require('string.prototype.trim');
480var callBound = require('call-bind/callBound');
481var forEach = require('for-each');
482var inspect = require('object-inspect');
483var is = require('object-is');
484var objectKeys = require('object-keys');
485var every = require('array.prototype.every');
486
487var isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
488var toLowerCase = callBound('String.prototype.toLowerCase');
489var isProto = callBound('Object.prototype.isPrototypeOf');
490var $exec = callBound('RegExp.prototype.exec');
491var objectToString = callBound('Object.prototype.toString');
492var $split = callBound('String.prototype.split');
493var $replace = callBound('String.prototype.replace');
494var $strSlice = callBound('String.prototype.slice');
495var $push = callBound('Array.prototype.push');
496var $shift = callBound('Array.prototype.shift');
497
498var nextTick = typeof setImmediate !== 'undefined'
499	? setImmediate
500	: process.nextTick;
501var safeSetTimeout = setTimeout;
502var safeClearTimeout = clearTimeout;
503
504// eslint-disable-next-line no-unused-vars
505function getTestArgs(name_, opts_, cb_) {
506	var name = '(anonymous)';
507	var opts = {};
508	var cb;
509
510	for (var i = 0; i < arguments.length; i++) {
511		var arg = arguments[i];
512		var t = typeof arg;
513		if (t === 'string') {
514			name = arg;
515		} else if (t === 'object') {
516			opts = arg || opts;
517		} else if (t === 'function') {
518			cb = arg;
519		}
520	}
521	return {
522		name: name,
523		opts: opts,
524		cb: cb
525	};
526}
527
528function Test(name_, opts_, cb_) {
529	if (!(this instanceof Test)) {
530		return new Test(name_, opts_, cb_);
531	}
532
533	var args = getTestArgs(name_, opts_, cb_);
534
535	this.readable = true;
536	this.name = args.name || '(anonymous)';
537	this.assertCount = 0;
538	this.pendingCount = 0;
539	this._skip = args.opts.skip || false;
540	this._todo = args.opts.todo || false;
541	this._timeout = args.opts.timeout;
542	this._plan = undefined;
543	this._cb = args.cb;
544	this._progeny = [];
545	this._teardown = [];
546	this._ok = true;
547	var depthEnvVar = process.env.NODE_TAPE_OBJECT_PRINT_DEPTH;
548	if (args.opts.objectPrintDepth) {
549		this._objectPrintDepth = args.opts.objectPrintDepth;
550	} else if (depthEnvVar) {
551		if (toLowerCase(depthEnvVar) === 'infinity') {
552			this._objectPrintDepth = Infinity;
553		} else {
554			this._objectPrintDepth = depthEnvVar;
555		}
556	} else {
557		this._objectPrintDepth = 5;
558	}
559
560	for (var prop in this) {
561		this[prop] = (function bind(self, val) {
562			if (typeof val === 'function') {
563				return function bound() {
564					return val.apply(self, arguments);
565				};
566			}
567			return val;
568		}(this, this[prop]));
569	}
570}
571
572inherits(Test, EventEmitter);
573
574Test.prototype.run = function run() {
575	this.emit('prerun');
576	if (!this._cb || this._skip) {
577		this._end();
578		return;
579	}
580	if (this._timeout != null) {
581		this.timeoutAfter(this._timeout);
582	}
583
584	var callbackReturn = this._cb(this);
585
586	if (
587		typeof Promise === 'function'
588        && callbackReturn
589        && typeof callbackReturn.then === 'function'
590	) {
591		var self = this;
592		Promise.resolve(callbackReturn).then(function onResolve() {
593			if (!self.calledEnd) {
594				self.end();
595			}
596		})['catch'](function onError(err) {
597			if (err instanceof Error || objectToString(err) === '[object Error]') {
598				self.ifError(err);
599			} else {
600				self.fail(err);
601			}
602			self.end();
603		});
604		return;
605	}
606
607	this.emit('run');
608};
609
610Test.prototype.test = function test(name, opts, cb) {
611	var self = this;
612	var t = new Test(name, opts, cb);
613	$push(this._progeny, t);
614	this.pendingCount++;
615	this.emit('test', t);
616	t.on('prerun', function () {
617		self.assertCount++;
618	});
619
620	if (!self._pendingAsserts()) {
621		nextTick(function () {
622			self._end();
623		});
624	}
625
626	nextTick(function () {
627		if (!self._plan && self.pendingCount == self._progeny.length) {
628			self._end();
629		}
630	});
631};
632
633Test.prototype.comment = function comment(msg) {
634	var that = this;
635	forEach($split(trim(msg), '\n'), function (aMsg) {
636		that.emit('result', $replace(trim(aMsg), /^#\s*/, ''));
637	});
638};
639
640Test.prototype.plan = function plan(n) {
641	this._plan = n;
642	this.emit('plan', n);
643};
644
645Test.prototype.timeoutAfter = function timeoutAfter(ms) {
646	if (!ms) { throw new Error('timeoutAfter requires a timespan'); }
647	var self = this;
648	var timeout = safeSetTimeout(function () {
649		self.fail(self.name + ' timed out after ' + ms + 'ms');
650		self.end();
651	}, ms);
652	this.once('end', function () {
653		safeClearTimeout(timeout);
654	});
655};
656
657Test.prototype.end = function end(err) {
658	if (arguments.length >= 1 && !!err) {
659		this.ifError(err);
660	}
661
662	if (this.calledEnd) {
663		this.fail('.end() already called');
664	}
665	this.calledEnd = true;
666	this._end();
667};
668
669Test.prototype.teardown = function teardown(fn) {
670	if (typeof fn !== 'function') {
671		this.fail('teardown: ' + inspect(fn) + ' is not a function');
672	} else {
673		this._teardown.push(fn);
674	}
675};
676
677Test.prototype._end = function _end(err) {
678	var self = this;
679
680	if (!this._cb && !this._todo && !this._skip) {
681		this.fail('# TODO ' + this.name);
682	}
683
684	if (this._progeny.length) {
685		var t = $shift(this._progeny);
686		t.on('end', function () { self._end(); });
687		t.run();
688		return;
689	}
690
691	function completeEnd() {
692		if (!self.ended) { self.emit('end'); }
693		var pendingAsserts = self._pendingAsserts();
694		if (!self._planError && self._plan !== undefined && pendingAsserts) {
695			self._planError = true;
696			self.fail('plan != count', {
697				expected: self._plan,
698				actual: self.assertCount
699			});
700		}
701		self.ended = true;
702	}
703
704	function next() {
705		if (self._teardown.length === 0) {
706			completeEnd();
707			return;
708		}
709		var fn = self._teardown.shift();
710		var res;
711		try {
712			res = fn();
713		} catch (e) {
714			self.fail(e);
715		}
716		if (res && typeof res.then === 'function') {
717			res.then(next, function (_err) {
718				// TODO: wth?
719				err = err || _err;
720			});
721		} else {
722			next();
723		}
724	}
725
726	next();
727};
728
729Test.prototype._exit = function _exit() {
730	if (this._plan !== undefined && !this._planError && this.assertCount !== this._plan) {
731		this._planError = true;
732		this.fail('plan != count', {
733			expected: this._plan,
734			actual: this.assertCount,
735			exiting: true
736		});
737	} else if (!this.ended) {
738		this.fail('test exited without ending: ' + this.name, {
739			exiting: true
740		});
741	}
742};
743
744Test.prototype._pendingAsserts = function _pendingAsserts() {
745	if (this._plan === undefined) {
746		return 1;
747	}
748	return this._plan - (this._progeny.length + this.assertCount);
749};
750
751Test.prototype._assert = function assert(ok, opts) {
752	var self = this;
753	var extra = opts.extra || {};
754
755	ok = !!ok || !!extra.skip;
756
757	var name = defined(extra.message, opts.message, '(unnamed assert)');
758	if (this.calledEnd && opts.operator !== 'fail') {
759		this.fail('.end() already called: ' + name);
760		return;
761	}
762
763	var res = {
764		id: self.assertCount++,
765		ok: ok,
766		skip: defined(extra.skip, opts.skip),
767		todo: defined(extra.todo, opts.todo, self._todo),
768		name: name,
769		operator: defined(extra.operator, opts.operator),
770		objectPrintDepth: self._objectPrintDepth
771	};
772	if (has(opts, 'actual') || has(extra, 'actual')) {
773		res.actual = defined(extra.actual, opts.actual);
774	}
775	if (has(opts, 'expected') || has(extra, 'expected')) {
776		res.expected = defined(extra.expected, opts.expected);
777	}
778	this._ok = !!(this._ok && ok);
779
780	if (!ok && !res.todo) {
781		res.error = defined(extra.error, opts.error, new Error(res.name));
782	}
783
784	if (!ok) {
785		var e = new Error('exception');
786		var err = $split(e.stack || '', '\n');
787		var dir = __dirname + path.sep;
788
789		for (var i = 0; i < err.length; i++) {
790			/*
791                Stack trace lines may resemble one of the following. We need
792                to correctly extract a function name (if any) and path / line
793                number for each line.
794
795                    at myFunction (/path/to/file.js:123:45)
796                    at myFunction (/path/to/file.other-ext:123:45)
797                    at myFunction (/path to/file.js:123:45)
798                    at myFunction (C:\path\to\file.js:123:45)
799                    at myFunction (/path/to/file.js:123)
800                    at Test.<anonymous> (/path/to/file.js:123:45)
801                    at Test.bound [as run] (/path/to/file.js:123:45)
802                    at /path/to/file.js:123:45
803
804                Regex has three parts. First is non-capturing group for 'at '
805                (plus anything preceding it).
806
807                    /^(?:[^\s]*\s*\bat\s+)/
808
809                Second captures function call description (optional). This is
810                not necessarily a valid JS function name, but just what the
811                stack trace is using to represent a function call. It may look
812                like `<anonymous>` or 'Test.bound [as run]'.
813
814                For our purposes, we assume that, if there is a function
815                name, it's everything leading up to the first open
816                parentheses (trimmed) before our pathname.
817
818                    /(?:(.*)\s+\()?/
819
820                Last part captures file path plus line no (and optional
821                column no).
822
823                    /((?:\/|[a-zA-Z]:\\)[^:\)]+:(\d+)(?::(\d+))?)\)?/
824            */
825			var re = /^(?:[^\s]*\s*\bat\s+)(?:(.*)\s+\()?((?:\/|[a-zA-Z]:\\)[^:)]+:(\d+)(?::(\d+))?)\)?$/;
826			var lineWithTokens = $replace($replace(err[i], process.cwd(), '/$CWD'), __dirname, '/$TEST');
827			var m = re.exec(lineWithTokens);
828
829			if (!m) {
830				continue;
831			}
832
833			var callDescription = m[1] || '<anonymous>';
834			var filePath = $replace($replace(m[2], '/$CWD', process.cwd()), '/$TEST', __dirname);
835
836			if ($strSlice(filePath, 0, dir.length) === dir) {
837				continue;
838			}
839
840			// Function call description may not (just) be a function name.
841			// Try to extract function name by looking at first "word" only.
842			res.functionName = $split(callDescription, /\s+/)[0];
843			res.file = filePath;
844			res.line = Number(m[3]);
845			if (m[4]) { res.column = Number(m[4]); }
846
847			res.at = callDescription + ' (' + filePath + ')';
848			break;
849		}
850	}
851
852	self.emit('result', res);
853
854	var pendingAsserts = self._pendingAsserts();
855	if (!pendingAsserts) {
856		if (extra.exiting) {
857			self._end();
858		} else {
859			nextTick(function () {
860				self._end();
861			});
862		}
863	}
864
865	if (!self._planError && pendingAsserts < 0) {
866		self._planError = true;
867		self.fail('plan != count', {
868			expected: self._plan,
869			actual: self._plan - pendingAsserts
870		});
871	}
872};
873
874Test.prototype.fail = function fail(msg, extra) {
875	this._assert(false, {
876		message: msg,
877		operator: 'fail',
878		extra: extra
879	});
880};
881
882Test.prototype.pass = function pass(msg, extra) {
883	this._assert(true, {
884		message: msg,
885		operator: 'pass',
886		extra: extra
887	});
888};
889
890Test.prototype.skip = function skip(msg, extra) {
891	this._assert(true, {
892		message: msg,
893		operator: 'skip',
894		skip: true,
895		extra: extra
896	});
897};
898
899var testAssert = function assert(value, msg, extra) { // eslint-disable-line func-style
900	this._assert(value, {
901		message: defined(msg, 'should be truthy'),
902		operator: 'ok',
903		expected: true,
904		actual: value,
905		extra: extra
906	});
907};
908Test.prototype.ok
909= Test.prototype['true']
910= Test.prototype.assert
911= testAssert;
912
913function notOK(value, msg, extra) {
914	this._assert(!value, {
915		message: defined(msg, 'should be falsy'),
916		operator: 'notOk',
917		expected: false,
918		actual: value,
919		extra: extra
920	});
921}
922Test.prototype.notOk
923= Test.prototype['false']
924= Test.prototype.notok
925= notOK;
926
927function error(err, msg, extra) {
928	this._assert(!err, {
929		message: defined(msg, String(err)),
930		operator: 'error',
931		error: err,
932		extra: extra
933	});
934}
935Test.prototype.error
936= Test.prototype.ifError
937= Test.prototype.ifErr
938= Test.prototype.iferror
939= error;
940
941function strictEqual(a, b, msg, extra) {
942	if (arguments.length < 2) {
943		throw new TypeError('two arguments must be provided to compare');
944	}
945	this._assert(is(a, b), {
946		message: defined(msg, 'should be strictly equal'),
947		operator: 'equal',
948		actual: a,
949		expected: b,
950		extra: extra
951	});
952}
953Test.prototype.equal
954= Test.prototype.equals
955= Test.prototype.isEqual
956= Test.prototype.strictEqual
957= Test.prototype.strictEquals
958= Test.prototype.is
959= strictEqual;
960
961function notStrictEqual(a, b, msg, extra) {
962	if (arguments.length < 2) {
963		throw new TypeError('two arguments must be provided to compare');
964	}
965	this._assert(!is(a, b), {
966		message: defined(msg, 'should not be strictly equal'),
967		operator: 'notEqual',
968		actual: a,
969		expected: b,
970		extra: extra
971	});
972}
973
974Test.prototype.notEqual
975= Test.prototype.notEquals
976= Test.prototype.isNotEqual
977= Test.prototype.doesNotEqual
978= Test.prototype.isInequal
979= Test.prototype.notStrictEqual
980= Test.prototype.notStrictEquals
981= Test.prototype.isNot
982= Test.prototype.not
983= notStrictEqual;
984
985function looseEqual(a, b, msg, extra) {
986	if (arguments.length < 2) {
987		throw new TypeError('two arguments must be provided to compare');
988	}
989	this._assert(a == b, {
990		message: defined(msg, 'should be loosely equal'),
991		operator: 'looseEqual',
992		actual: a,
993		expected: b,
994		extra: extra
995	});
996}
997
998Test.prototype.looseEqual
999= Test.prototype.looseEquals
1000= looseEqual;
1001
1002function notLooseEqual(a, b, msg, extra) {
1003	if (arguments.length < 2) {
1004		throw new TypeError('two arguments must be provided to compare');
1005	}
1006	this._assert(a != b, {
1007		message: defined(msg, 'should not be loosely equal'),
1008		operator: 'notLooseEqual',
1009		actual: a,
1010		expected: b,
1011		extra: extra
1012	});
1013}
1014Test.prototype.notLooseEqual
1015= Test.prototype.notLooseEquals
1016= notLooseEqual;
1017
1018function tapeDeepEqual(a, b, msg, extra) {
1019	if (arguments.length < 2) {
1020		throw new TypeError('two arguments must be provided to compare');
1021	}
1022	this._assert(deepEqual(a, b, { strict: true }), {
1023		message: defined(msg, 'should be deeply equivalent'),
1024		operator: 'deepEqual',
1025		actual: a,
1026		expected: b,
1027		extra: extra
1028	});
1029}
1030Test.prototype.deepEqual
1031= Test.prototype.deepEquals
1032= Test.prototype.isEquivalent
1033= Test.prototype.same
1034= tapeDeepEqual;
1035
1036function notDeepEqual(a, b, msg, extra) {
1037	if (arguments.length < 2) {
1038		throw new TypeError('two arguments must be provided to compare');
1039	}
1040	this._assert(!deepEqual(a, b, { strict: true }), {
1041		message: defined(msg, 'should not be deeply equivalent'),
1042		operator: 'notDeepEqual',
1043		actual: a,
1044		expected: b,
1045		extra: extra
1046	});
1047}
1048Test.prototype.notDeepEqual
1049= Test.prototype.notDeepEquals
1050= Test.prototype.notEquivalent
1051= Test.prototype.notDeeply
1052= Test.prototype.notSame
1053= Test.prototype.isNotDeepEqual
1054= Test.prototype.isNotDeeply
1055= Test.prototype.isNotEquivalent
1056= Test.prototype.isInequivalent
1057= notDeepEqual;
1058
1059function deepLooseEqual(a, b, msg, extra) {
1060	if (arguments.length < 2) {
1061		throw new TypeError('two arguments must be provided to compare');
1062	}
1063	this._assert(deepEqual(a, b), {
1064		message: defined(msg, 'should be loosely deeply equivalent'),
1065		operator: 'deepLooseEqual',
1066		actual: a,
1067		expected: b,
1068		extra: extra
1069	});
1070}
1071
1072Test.prototype.deepLooseEqual
1073= deepLooseEqual;
1074
1075function notDeepLooseEqual(a, b, msg, extra) {
1076	if (arguments.length < 2) {
1077		throw new TypeError('two arguments must be provided to compare');
1078	}
1079	this._assert(!deepEqual(a, b), {
1080		message: defined(msg, 'should not be loosely deeply equivalent'),
1081		operator: 'notDeepLooseEqual',
1082		actual: a,
1083		expected: b,
1084		extra: extra
1085	});
1086}
1087Test.prototype.notDeepLooseEqual
1088= notDeepLooseEqual;
1089
1090Test.prototype['throws'] = function (fn, expected, msg, extra) {
1091	if (typeof expected === 'string') {
1092		msg = expected;
1093		expected = undefined;
1094	}
1095
1096	var caught;
1097
1098	try {
1099		fn();
1100	} catch (err) {
1101		caught = { error: err };
1102		if (Object(err) === err && (!isEnumerable(err, 'message') || !has(err, 'message'))) {
1103			var message = err.message;
1104			delete err.message;
1105			err.message = message;
1106		}
1107	}
1108
1109	var passed = caught;
1110
1111	if (caught) {
1112		if (typeof expected === 'string' && caught.error && caught.error.message === expected) {
1113			throw new TypeError('The "error/message" argument is ambiguous. The error message ' + inspect(expected) + ' is identical to the message.');
1114		}
1115		if (typeof expected === 'function') {
1116			if (typeof expected.prototype !== 'undefined' && caught.error instanceof expected) {
1117				passed = true;
1118			} else if (isProto(Error, expected)) {
1119				passed = false;
1120			} else {
1121				passed = expected.call({}, caught.error) === true;
1122			}
1123		} else if (isRegExp(expected)) {
1124			passed = $exec(expected, caught.error) !== null;
1125			expected = inspect(expected);
1126		} else if (expected && typeof expected === 'object') { // Handle validation objects.
1127			var keys = objectKeys(expected);
1128			// Special handle errors to make sure the name and the message are compared as well.
1129			if (expected instanceof Error) {
1130				$push(keys, 'name', 'message');
1131			} else if (keys.length === 0) {
1132				throw new TypeError('`throws` validation object must not be empty');
1133			}
1134			passed = every(keys, function (key) {
1135				if (typeof caught.error[key] === 'string' && isRegExp(expected[key]) && $exec(expected[key], caught.error[key]) !== null) {
1136					return true;
1137				}
1138				if (key in caught.error && deepEqual(caught.error[key], expected[key], { strict: true })) {
1139					return true;
1140				}
1141				return false;
1142			});
1143		}
1144	}
1145
1146	this._assert(!!passed, {
1147		message: defined(msg, 'should throw'),
1148		operator: 'throws',
1149		actual: caught && caught.error,
1150		expected: expected,
1151		error: !passed && caught && caught.error,
1152		extra: extra
1153	});
1154};
1155
1156Test.prototype.doesNotThrow = function doesNotThrow(fn, expected, msg, extra) {
1157	if (typeof expected === 'string') {
1158		msg = expected;
1159		expected = undefined;
1160	}
1161	var caught;
1162	try {
1163		fn();
1164	} catch (err) {
1165		caught = { error: err };
1166	}
1167	this._assert(!caught, {
1168		message: defined(msg, 'should not throw'),
1169		operator: 'throws',
1170		actual: caught && caught.error,
1171		expected: expected,
1172		error: caught && caught.error,
1173		extra: extra
1174	});
1175};
1176
1177Test.prototype.match = function match(string, regexp, msg, extra) {
1178	if (!isRegExp(regexp)) {
1179		this._assert(false, {
1180			message: defined(msg, 'The "regexp" argument must be an instance of RegExp. Received type ' + typeof regexp + ' (' + inspect(regexp) + ')'),
1181			operator: 'match',
1182			actual: objectToString(regexp),
1183			expected: '[object RegExp]',
1184			extra: extra
1185		});
1186	} else if (typeof string !== 'string') {
1187		this._assert(false, {
1188			message: defined(msg, 'The "string" argument must be of type string. Received type ' + typeof string + ' (' + inspect(string) + ')'),
1189			operator: 'match',
1190			actual: string === null ? null : typeof string,
1191			expected: 'string',
1192			extra: extra
1193		});
1194	} else {
1195		var matches = $exec(regexp, string) !== null;
1196		var message = defined(
1197			msg,
1198			'The input ' + (matches ? 'matched' : 'did not match') + ' the regular expression ' + inspect(regexp) + '. Input: ' + inspect(string)
1199		);
1200		this._assert(matches, {
1201			message: message,
1202			operator: 'match',
1203			actual: string,
1204			expected: regexp,
1205			extra: extra
1206		});
1207	}
1208};
1209
1210Test.prototype.doesNotMatch = function doesNotMatch(string, regexp, msg, extra) {
1211	if (!isRegExp(regexp)) {
1212		this._assert(false, {
1213			message: defined(msg, 'The "regexp" argument must be an instance of RegExp. Received type ' + typeof regexp + ' (' + inspect(regexp) + ')'),
1214			operator: 'doesNotMatch',
1215			actual: objectToString(regexp),
1216			expected: '[object RegExp]',
1217			extra: extra
1218		});
1219	} else if (typeof string !== 'string') {
1220		this._assert(false, {
1221			message: defined(msg, 'The "string" argument must be of type string. Received type ' + typeof string + ' (' + inspect(string) + ')'),
1222			operator: 'doesNotMatch',
1223			actual: string === null ? null : typeof string,
1224			expected: 'string',
1225			extra: extra
1226		});
1227	} else {
1228		var matches = $exec(regexp, string) !== null;
1229		var message = defined(
1230			msg,
1231			'The input ' + (matches ? 'was expected to not match' : 'did not match') + ' the regular expression ' + inspect(regexp) + '. Input: ' + inspect(string)
1232		);
1233		this._assert(!matches, {
1234			message: message,
1235			operator: 'doesNotMatch',
1236			actual: string,
1237			expected: regexp,
1238			extra: extra
1239		});
1240	}
1241};
1242
1243// eslint-disable-next-line no-unused-vars
1244Test.skip = function skip(name_, _opts, _cb) {
1245	var args = getTestArgs.apply(null, arguments);
1246	args.opts.skip = true;
1247	return new Test(args.name, args.opts, args.cb);
1248};
1249
1250module.exports = Test;
1251
1252// vim: set softtabstop=4 shiftwidth=4:
1253
1254}).call(this,require("KliubH"),"/../../lib")
1255},{"KliubH":91,"array.prototype.every":6,"call-bind/callBound":10,"deep-equal":12,"defined":14,"events":87,"for-each":29,"has":39,"inherits":40,"is-regex":48,"object-inspect":56,"object-is":59,"object-keys":63,"path":90,"string.prototype.trim":76}],5:[function(require,module,exports){
1256'use strict';
1257
1258var IsCallable = require('es-abstract/2021/IsCallable');
1259var ToObject = require('es-abstract/2021/ToObject');
1260var ToUint32 = require('es-abstract/2021/ToUint32');
1261var callBound = require('call-bind/callBound');
1262var isString = require('is-string');
1263
1264// Check failure of by-index access of string characters (IE < 9) and failure of `0 in boxedString` (Rhino)
1265var boxedString = Object('a');
1266var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
1267
1268var $split = callBound('String.prototype.split');
1269
1270module.exports = function every(callbackfn) {
1271	var O = ToObject(this);
1272	var self = splitString && isString(O) ? $split(O, '') : O;
1273	var len = ToUint32(self.length);
1274	var T;
1275	if (arguments.length > 1) {
1276		T = arguments[1];
1277	}
1278
1279	// If no callback function or if callback is not a callable function
1280	if (!IsCallable(callbackfn)) {
1281		throw new TypeError('Array.prototype.every callback must be a function');
1282	}
1283
1284	for (var i = 0; i < len; i++) {
1285		if (i in self && !(typeof T === 'undefined' ? callbackfn(self[i], i, O) : callbackfn.call(T, self[i], i, O))) {
1286			return false;
1287		}
1288	}
1289	return true;
1290};
1291
1292},{"call-bind/callBound":10,"es-abstract/2021/IsCallable":15,"es-abstract/2021/ToObject":18,"es-abstract/2021/ToUint32":21,"is-string":50}],6:[function(require,module,exports){
1293'use strict';
1294
1295var define = require('define-properties');
1296var RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');
1297var callBound = require('call-bind/callBound');
1298
1299var implementation = require('./implementation');
1300var getPolyfill = require('./polyfill');
1301var polyfill = getPolyfill();
1302var shim = require('./shim');
1303
1304var $slice = callBound('Array.prototype.slice');
1305
1306// eslint-disable-next-line no-unused-vars
1307var boundEveryShim = function every(array, callbackfn) {
1308	RequireObjectCoercible(array);
1309	return polyfill.apply(array, $slice(arguments, 1));
1310};
1311define(boundEveryShim, {
1312	getPolyfill: getPolyfill,
1313	implementation: implementation,
1314	shim: shim
1315});
1316
1317module.exports = boundEveryShim;
1318
1319},{"./implementation":5,"./polyfill":7,"./shim":8,"call-bind/callBound":10,"define-properties":13,"es-abstract/2021/RequireObjectCoercible":16}],7:[function(require,module,exports){
1320var implementation = require('./implementation');
1321
1322module.exports = function getPolyfill() {
1323	if (typeof Array.prototype.every === 'function') {
1324		var hasPrimitiveContextInStrict = [1].every(function () {
1325			'use strict';
1326
1327			return typeof this === 'string' && this === 'x';
1328		}, 'x');
1329		if (hasPrimitiveContextInStrict) {
1330			return Array.prototype.every;
1331		}
1332	}
1333	return implementation;
1334};
1335
1336},{"./implementation":5}],8:[function(require,module,exports){
1337'use strict';
1338
1339var define = require('define-properties');
1340var getPolyfill = require('./polyfill');
1341
1342module.exports = function shimArrayPrototypeEvery() {
1343	var polyfill = getPolyfill();
1344	define(
1345		Array.prototype,
1346		{ every: polyfill },
1347		{ every: function () { return Array.prototype.every !== polyfill; } }
1348	);
1349	return polyfill;
1350};
1351
1352},{"./polyfill":7,"define-properties":13}],9:[function(require,module,exports){
1353(function (global){
1354'use strict';
1355
1356var possibleNames = [
1357	'BigInt64Array',
1358	'BigUint64Array',
1359	'Float32Array',
1360	'Float64Array',
1361	'Int16Array',
1362	'Int32Array',
1363	'Int8Array',
1364	'Uint16Array',
1365	'Uint32Array',
1366	'Uint8Array',
1367	'Uint8ClampedArray'
1368];
1369
1370var g = typeof globalThis === 'undefined' ? global : globalThis;
1371
1372module.exports = function availableTypedArrays() {
1373	var out = [];
1374	for (var i = 0; i < possibleNames.length; i++) {
1375		if (typeof g[possibleNames[i]] === 'function') {
1376			out[out.length] = possibleNames[i];
1377		}
1378	}
1379	return out;
1380};
1381
1382}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
1383},{}],10:[function(require,module,exports){
1384'use strict';
1385
1386var GetIntrinsic = require('get-intrinsic');
1387
1388var callBind = require('./');
1389
1390var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
1391
1392module.exports = function callBoundIntrinsic(name, allowMissing) {
1393	var intrinsic = GetIntrinsic(name, !!allowMissing);
1394	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
1395		return callBind(intrinsic);
1396	}
1397	return intrinsic;
1398};
1399
1400},{"./":11,"get-intrinsic":33}],11:[function(require,module,exports){
1401'use strict';
1402
1403var bind = require('function-bind');
1404var GetIntrinsic = require('get-intrinsic');
1405
1406var $apply = GetIntrinsic('%Function.prototype.apply%');
1407var $call = GetIntrinsic('%Function.prototype.call%');
1408var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
1409
1410var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
1411var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
1412var $max = GetIntrinsic('%Math.max%');
1413
1414if ($defineProperty) {
1415	try {
1416		$defineProperty({}, 'a', { value: 1 });
1417	} catch (e) {
1418		// IE 8 has a broken defineProperty
1419		$defineProperty = null;
1420	}
1421}
1422
1423module.exports = function callBind(originalFunction) {
1424	var func = $reflectApply(bind, $call, arguments);
1425	if ($gOPD && $defineProperty) {
1426		var desc = $gOPD(func, 'length');
1427		if (desc.configurable) {
1428			// original length, plus the receiver, minus any additional arguments (after the receiver)
1429			$defineProperty(
1430				func,
1431				'length',
1432				{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
1433			);
1434		}
1435	}
1436	return func;
1437};
1438
1439var applyBind = function applyBind() {
1440	return $reflectApply(bind, $apply, arguments);
1441};
1442
1443if ($defineProperty) {
1444	$defineProperty(module.exports, 'apply', { value: applyBind });
1445} else {
1446	module.exports.apply = applyBind;
1447}
1448
1449},{"function-bind":31,"get-intrinsic":33}],12:[function(require,module,exports){
1450'use strict';
1451
1452var objectKeys = require('object-keys');
1453var isArguments = require('is-arguments');
1454var is = require('object-is');
1455var isRegex = require('is-regex');
1456var flags = require('regexp.prototype.flags');
1457var isArray = require('isarray');
1458var isDate = require('is-date-object');
1459var whichBoxedPrimitive = require('which-boxed-primitive');
1460var GetIntrinsic = require('get-intrinsic');
1461var callBound = require('call-bind/callBound');
1462var whichCollection = require('which-collection');
1463var getIterator = require('es-get-iterator');
1464var getSideChannel = require('side-channel');
1465var whichTypedArray = require('which-typed-array');
1466var assign = require('object.assign');
1467
1468var $getTime = callBound('Date.prototype.getTime');
1469var gPO = Object.getPrototypeOf;
1470var $objToString = callBound('Object.prototype.toString');
1471
1472var $Set = GetIntrinsic('%Set%', true);
1473var $mapHas = callBound('Map.prototype.has', true);
1474var $mapGet = callBound('Map.prototype.get', true);
1475var $mapSize = callBound('Map.prototype.size', true);
1476var $setAdd = callBound('Set.prototype.add', true);
1477var $setDelete = callBound('Set.prototype.delete', true);
1478var $setHas = callBound('Set.prototype.has', true);
1479var $setSize = callBound('Set.prototype.size', true);
1480
1481// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L401-L414
1482function setHasEqualElement(set, val1, opts, channel) {
1483  var i = getIterator(set);
1484  var result;
1485  while ((result = i.next()) && !result.done) {
1486    if (internalDeepEqual(val1, result.value, opts, channel)) { // eslint-disable-line no-use-before-define
1487      // Remove the matching element to make sure we do not check that again.
1488      $setDelete(set, result.value);
1489      return true;
1490    }
1491  }
1492
1493  return false;
1494}
1495
1496// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L416-L439
1497function findLooseMatchingPrimitives(prim) {
1498  if (typeof prim === 'undefined') {
1499    return null;
1500  }
1501  if (typeof prim === 'object') { // Only pass in null as object!
1502    return void 0;
1503  }
1504  if (typeof prim === 'symbol') {
1505    return false;
1506  }
1507  if (typeof prim === 'string' || typeof prim === 'number') {
1508    // Loose equal entries exist only if the string is possible to convert to a regular number and not NaN.
1509    return +prim === +prim; // eslint-disable-line no-implicit-coercion
1510  }
1511  return true;
1512}
1513
1514// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L449-L460
1515function mapMightHaveLoosePrim(a, b, prim, item, opts, channel) {
1516  var altValue = findLooseMatchingPrimitives(prim);
1517  if (altValue != null) {
1518    return altValue;
1519  }
1520  var curB = $mapGet(b, altValue);
1521  var looseOpts = assign({}, opts, { strict: false });
1522  if (
1523    (typeof curB === 'undefined' && !$mapHas(b, altValue))
1524    // eslint-disable-next-line no-use-before-define
1525    || !internalDeepEqual(item, curB, looseOpts, channel)
1526  ) {
1527    return false;
1528  }
1529  // eslint-disable-next-line no-use-before-define
1530  return !$mapHas(a, altValue) && internalDeepEqual(item, curB, looseOpts, channel);
1531}
1532
1533// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L441-L447
1534function setMightHaveLoosePrim(a, b, prim) {
1535  var altValue = findLooseMatchingPrimitives(prim);
1536  if (altValue != null) {
1537    return altValue;
1538  }
1539
1540  return $setHas(b, altValue) && !$setHas(a, altValue);
1541}
1542
1543// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L518-L533
1544function mapHasEqualEntry(set, map, key1, item1, opts, channel) {
1545  var i = getIterator(set);
1546  var result;
1547  var key2;
1548  while ((result = i.next()) && !result.done) {
1549    key2 = result.value;
1550    if (
1551      // eslint-disable-next-line no-use-before-define
1552      internalDeepEqual(key1, key2, opts, channel)
1553      // eslint-disable-next-line no-use-before-define
1554      && internalDeepEqual(item1, $mapGet(map, key2), opts, channel)
1555    ) {
1556      $setDelete(set, key2);
1557      return true;
1558    }
1559  }
1560
1561  return false;
1562}
1563
1564function internalDeepEqual(actual, expected, options, channel) {
1565  var opts = options || {};
1566
1567  // 7.1. All identical values are equivalent, as determined by ===.
1568  if (opts.strict ? is(actual, expected) : actual === expected) {
1569    return true;
1570  }
1571
1572  var actualBoxed = whichBoxedPrimitive(actual);
1573  var expectedBoxed = whichBoxedPrimitive(expected);
1574  if (actualBoxed !== expectedBoxed) {
1575    return false;
1576  }
1577
1578  // 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==.
1579  if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {
1580    return opts.strict ? is(actual, expected) : actual == expected; // eslint-disable-line eqeqeq
1581  }
1582
1583  /*
1584   * 7.4. For all other Object pairs, including Array objects, equivalence is
1585   * determined by having the same number of owned properties (as verified
1586   * with Object.prototype.hasOwnProperty.call), the same set of keys
1587   * (although not necessarily the same order), equivalent values for every
1588   * corresponding key, and an identical 'prototype' property. Note: this
1589   * accounts for both named and indexed properties on Arrays.
1590   */
1591  // see https://github.com/nodejs/node/commit/d3aafd02efd3a403d646a3044adcf14e63a88d32 for memos/channel inspiration
1592
1593  var hasActual = channel.has(actual);
1594  var hasExpected = channel.has(expected);
1595  var sentinel;
1596  if (hasActual && hasExpected) {
1597    if (channel.get(actual) === channel.get(expected)) {
1598      return true;
1599    }
1600  } else {
1601    sentinel = {};
1602  }
1603  if (!hasActual) { channel.set(actual, sentinel); }
1604  if (!hasExpected) { channel.set(expected, sentinel); }
1605
1606  // eslint-disable-next-line no-use-before-define
1607  return objEquiv(actual, expected, opts, channel);
1608}
1609
1610function isBuffer(x) {
1611  if (!x || typeof x !== 'object' || typeof x.length !== 'number') {
1612    return false;
1613  }
1614  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
1615    return false;
1616  }
1617  if (x.length > 0 && typeof x[0] !== 'number') {
1618    return false;
1619  }
1620
1621  return !!(x.constructor && x.constructor.isBuffer && x.constructor.isBuffer(x));
1622}
1623
1624function setEquiv(a, b, opts, channel) {
1625  if ($setSize(a) !== $setSize(b)) {
1626    return false;
1627  }
1628  var iA = getIterator(a);
1629  var iB = getIterator(b);
1630  var resultA;
1631  var resultB;
1632  var set;
1633  while ((resultA = iA.next()) && !resultA.done) {
1634    if (resultA.value && typeof resultA.value === 'object') {
1635      if (!set) { set = new $Set(); }
1636      $setAdd(set, resultA.value);
1637    } else if (!$setHas(b, resultA.value)) {
1638      if (opts.strict) { return false; }
1639      if (!setMightHaveLoosePrim(a, b, resultA.value)) {
1640        return false;
1641      }
1642      if (!set) { set = new $Set(); }
1643      $setAdd(set, resultA.value);
1644    }
1645  }
1646  if (set) {
1647    while ((resultB = iB.next()) && !resultB.done) {
1648      // We have to check if a primitive value is already matching and only if it's not, go hunting for it.
1649      if (resultB.value && typeof resultB.value === 'object') {
1650        if (!setHasEqualElement(set, resultB.value, opts.strict, channel)) {
1651          return false;
1652        }
1653      } else if (
1654        !opts.strict
1655        && !$setHas(a, resultB.value)
1656        && !setHasEqualElement(set, resultB.value, opts.strict, channel)
1657      ) {
1658        return false;
1659      }
1660    }
1661    return $setSize(set) === 0;
1662  }
1663  return true;
1664}
1665
1666function mapEquiv(a, b, opts, channel) {
1667  if ($mapSize(a) !== $mapSize(b)) {
1668    return false;
1669  }
1670  var iA = getIterator(a);
1671  var iB = getIterator(b);
1672  var resultA;
1673  var resultB;
1674  var set;
1675  var key;
1676  var item1;
1677  var item2;
1678  while ((resultA = iA.next()) && !resultA.done) {
1679    key = resultA.value[0];
1680    item1 = resultA.value[1];
1681    if (key && typeof key === 'object') {
1682      if (!set) { set = new $Set(); }
1683      $setAdd(set, key);
1684    } else {
1685      item2 = $mapGet(b, key);
1686      if ((typeof item2 === 'undefined' && !$mapHas(b, key)) || !internalDeepEqual(item1, item2, opts, channel)) {
1687        if (opts.strict) {
1688          return false;
1689        }
1690        if (!mapMightHaveLoosePrim(a, b, key, item1, opts, channel)) {
1691          return false;
1692        }
1693        if (!set) { set = new $Set(); }
1694        $setAdd(set, key);
1695      }
1696    }
1697  }
1698
1699  if (set) {
1700    while ((resultB = iB.next()) && !resultB.done) {
1701      key = resultB.value[0];
1702      item2 = resultB.value[1];
1703      if (key && typeof key === 'object') {
1704        if (!mapHasEqualEntry(set, a, key, item2, opts, channel)) {
1705          return false;
1706        }
1707      } else if (
1708        !opts.strict
1709        && (!a.has(key) || !internalDeepEqual($mapGet(a, key), item2, opts, channel))
1710        && !mapHasEqualEntry(set, a, key, item2, assign({}, opts, { strict: false }), channel)
1711      ) {
1712        return false;
1713      }
1714    }
1715    return $setSize(set) === 0;
1716  }
1717  return true;
1718}
1719
1720function objEquiv(a, b, opts, channel) {
1721  /* eslint max-statements: [2, 100], max-lines-per-function: [2, 120], max-depth: [2, 5] */
1722  var i, key;
1723
1724  if (typeof a !== typeof b) { return false; }
1725  if (a == null || b == null) { return false; }
1726
1727  if ($objToString(a) !== $objToString(b)) { return false; }
1728
1729  if (isArguments(a) !== isArguments(b)) { return false; }
1730
1731  var aIsArray = isArray(a);
1732  var bIsArray = isArray(b);
1733  if (aIsArray !== bIsArray) { return false; }
1734
1735  // TODO: replace when a cross-realm brand check is available
1736  var aIsError = a instanceof Error;
1737  var bIsError = b instanceof Error;
1738  if (aIsError !== bIsError) { return false; }
1739  if (aIsError || bIsError) {
1740    if (a.name !== b.name || a.message !== b.message) { return false; }
1741  }
1742
1743  var aIsRegex = isRegex(a);
1744  var bIsRegex = isRegex(b);
1745  if (aIsRegex !== bIsRegex) { return false; }
1746  if ((aIsRegex || bIsRegex) && (a.source !== b.source || flags(a) !== flags(b))) {
1747    return false;
1748  }
1749
1750  var aIsDate = isDate(a);
1751  var bIsDate = isDate(b);
1752  if (aIsDate !== bIsDate) { return false; }
1753  if (aIsDate || bIsDate) { // && would work too, because both are true or both false here
1754    if ($getTime(a) !== $getTime(b)) { return false; }
1755  }
1756  if (opts.strict && gPO && gPO(a) !== gPO(b)) { return false; }
1757
1758  if (whichTypedArray(a) !== whichTypedArray(b)) {
1759    return false;
1760  }
1761
1762  var aIsBuffer = isBuffer(a);
1763  var bIsBuffer = isBuffer(b);
1764  if (aIsBuffer !== bIsBuffer) { return false; }
1765  if (aIsBuffer || bIsBuffer) { // && would work too, because both are true or both false here
1766    if (a.length !== b.length) { return false; }
1767    for (i = 0; i < a.length; i++) {
1768      if (a[i] !== b[i]) { return false; }
1769    }
1770    return true;
1771  }
1772
1773  if (typeof a !== typeof b) { return false; }
1774
1775  var ka = objectKeys(a);
1776  var kb = objectKeys(b);
1777  // having the same number of owned properties (keys incorporates hasOwnProperty)
1778  if (ka.length !== kb.length) { return false; }
1779
1780  // the same set of keys (although not necessarily the same order),
1781  ka.sort();
1782  kb.sort();
1783  // ~~~cheap key test
1784  for (i = ka.length - 1; i >= 0; i--) {
1785    if (ka[i] != kb[i]) { return false; } // eslint-disable-line eqeqeq
1786  }
1787
1788  // equivalent values for every corresponding key, and ~~~possibly expensive deep test
1789  for (i = ka.length - 1; i >= 0; i--) {
1790    key = ka[i];
1791    if (!internalDeepEqual(a[key], b[key], opts, channel)) { return false; }
1792  }
1793
1794  var aCollection = whichCollection(a);
1795  var bCollection = whichCollection(b);
1796  if (aCollection !== bCollection) {
1797    return false;
1798  }
1799  if (aCollection === 'Set' || bCollection === 'Set') { // aCollection === bCollection
1800    return setEquiv(a, b, opts, channel);
1801  }
1802  if (aCollection === 'Map') { // aCollection === bCollection
1803    return mapEquiv(a, b, opts, channel);
1804  }
1805
1806  return true;
1807}
1808
1809module.exports = function deepEqual(a, b, opts) {
1810  return internalDeepEqual(a, b, opts, getSideChannel());
1811};
1812
1813},{"call-bind/callBound":10,"es-get-iterator":26,"get-intrinsic":33,"is-arguments":41,"is-date-object":45,"is-regex":48,"isarray":55,"object-is":59,"object-keys":63,"object.assign":66,"regexp.prototype.flags":70,"side-channel":74,"which-boxed-primitive":80,"which-collection":81,"which-typed-array":82}],13:[function(require,module,exports){
1814'use strict';
1815
1816var keys = require('object-keys');
1817var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
1818
1819var toStr = Object.prototype.toString;
1820var concat = Array.prototype.concat;
1821var origDefineProperty = Object.defineProperty;
1822
1823var isFunction = function (fn) {
1824	return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
1825};
1826
1827var hasPropertyDescriptors = require('has-property-descriptors')();
1828
1829var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
1830
1831var defineProperty = function (object, name, value, predicate) {
1832	if (name in object && (!isFunction(predicate) || !predicate())) {
1833		return;
1834	}
1835	if (supportsDescriptors) {
1836		origDefineProperty(object, name, {
1837			configurable: true,
1838			enumerable: false,
1839			value: value,
1840			writable: true
1841		});
1842	} else {
1843		object[name] = value; // eslint-disable-line no-param-reassign
1844	}
1845};
1846
1847var defineProperties = function (object, map) {
1848	var predicates = arguments.length > 2 ? arguments[2] : {};
1849	var props = keys(map);
1850	if (hasSymbols) {
1851		props = concat.call(props, Object.getOwnPropertySymbols(map));
1852	}
1853	for (var i = 0; i < props.length; i += 1) {
1854		defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
1855	}
1856};
1857
1858defineProperties.supportsDescriptors = !!supportsDescriptors;
1859
1860module.exports = defineProperties;
1861
1862},{"has-property-descriptors":35,"object-keys":63}],14:[function(require,module,exports){
1863module.exports = function () {
1864    for (var i = 0; i < arguments.length; i++) {
1865        if (arguments[i] !== undefined) return arguments[i];
1866    }
1867};
1868
1869},{}],15:[function(require,module,exports){
1870'use strict';
1871
1872// http://262.ecma-international.org/5.1/#sec-9.11
1873
1874module.exports = require('is-callable');
1875
1876},{"is-callable":44}],16:[function(require,module,exports){
1877'use strict';
1878
1879module.exports = require('../5/CheckObjectCoercible');
1880
1881},{"../5/CheckObjectCoercible":22}],17:[function(require,module,exports){
1882'use strict';
1883
1884var GetIntrinsic = require('get-intrinsic');
1885
1886var $TypeError = GetIntrinsic('%TypeError%');
1887var $Number = GetIntrinsic('%Number%');
1888var $RegExp = GetIntrinsic('%RegExp%');
1889var $parseInteger = GetIntrinsic('%parseInt%');
1890
1891var callBound = require('call-bind/callBound');
1892var regexTester = require('../helpers/regexTester');
1893var isPrimitive = require('../helpers/isPrimitive');
1894
1895var $strSlice = callBound('String.prototype.slice');
1896var isBinary = regexTester(/^0b[01]+$/i);
1897var isOctal = regexTester(/^0o[0-7]+$/i);
1898var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
1899var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
1900var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
1901var hasNonWS = regexTester(nonWSregex);
1902
1903// whitespace from: https://es5.github.io/#x15.5.4.20
1904// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
1905var ws = [
1906	'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
1907	'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
1908	'\u2029\uFEFF'
1909].join('');
1910var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
1911var $replace = callBound('String.prototype.replace');
1912var $trim = function (value) {
1913	return $replace(value, trimRegex, '');
1914};
1915
1916var ToPrimitive = require('./ToPrimitive');
1917
1918// https://ecma-international.org/ecma-262/6.0/#sec-tonumber
1919
1920module.exports = function ToNumber(argument) {
1921	var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
1922	if (typeof value === 'symbol') {
1923		throw new $TypeError('Cannot convert a Symbol value to a number');
1924	}
1925	if (typeof value === 'bigint') {
1926		throw new $TypeError('Conversion from \'BigInt\' to \'number\' is not allowed.');
1927	}
1928	if (typeof value === 'string') {
1929		if (isBinary(value)) {
1930			return ToNumber($parseInteger($strSlice(value, 2), 2));
1931		} else if (isOctal(value)) {
1932			return ToNumber($parseInteger($strSlice(value, 2), 8));
1933		} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
1934			return NaN;
1935		}
1936		var trimmed = $trim(value);
1937		if (trimmed !== value) {
1938			return ToNumber(trimmed);
1939		}
1940
1941	}
1942	return $Number(value);
1943};
1944
1945},{"../helpers/isPrimitive":24,"../helpers/regexTester":25,"./ToPrimitive":19,"call-bind/callBound":10,"get-intrinsic":33}],18:[function(require,module,exports){
1946'use strict';
1947
1948var GetIntrinsic = require('get-intrinsic');
1949
1950var $Object = GetIntrinsic('%Object%');
1951
1952var RequireObjectCoercible = require('./RequireObjectCoercible');
1953
1954// https://ecma-international.org/ecma-262/6.0/#sec-toobject
1955
1956module.exports = function ToObject(value) {
1957	RequireObjectCoercible(value);
1958	return $Object(value);
1959};
1960
1961},{"./RequireObjectCoercible":16,"get-intrinsic":33}],19:[function(require,module,exports){
1962'use strict';
1963
1964var toPrimitive = require('es-to-primitive/es2015');
1965
1966// https://ecma-international.org/ecma-262/6.0/#sec-toprimitive
1967
1968module.exports = function ToPrimitive(input) {
1969	if (arguments.length > 1) {
1970		return toPrimitive(input, arguments[1]);
1971	}
1972	return toPrimitive(input);
1973};
1974
1975},{"es-to-primitive/es2015":27}],20:[function(require,module,exports){
1976'use strict';
1977
1978var GetIntrinsic = require('get-intrinsic');
1979
1980var $String = GetIntrinsic('%String%');
1981var $TypeError = GetIntrinsic('%TypeError%');
1982
1983// https://ecma-international.org/ecma-262/6.0/#sec-tostring
1984
1985module.exports = function ToString(argument) {
1986	if (typeof argument === 'symbol') {
1987		throw new $TypeError('Cannot convert a Symbol value to a string');
1988	}
1989	return $String(argument);
1990};
1991
1992},{"get-intrinsic":33}],21:[function(require,module,exports){
1993'use strict';
1994
1995var ToNumber = require('./ToNumber');
1996
1997// http://262.ecma-international.org/5.1/#sec-9.6
1998
1999module.exports = function ToUint32(x) {
2000	return ToNumber(x) >>> 0;
2001};
2002
2003},{"./ToNumber":17}],22:[function(require,module,exports){
2004'use strict';
2005
2006var GetIntrinsic = require('get-intrinsic');
2007
2008var $TypeError = GetIntrinsic('%TypeError%');
2009
2010// http://262.ecma-international.org/5.1/#sec-9.10
2011
2012module.exports = function CheckObjectCoercible(value, optMessage) {
2013	if (value == null) {
2014		throw new $TypeError(optMessage || ('Cannot call method on ' + value));
2015	}
2016	return value;
2017};
2018
2019},{"get-intrinsic":33}],23:[function(require,module,exports){
2020'use strict';
2021
2022var GetIntrinsic = require('get-intrinsic');
2023
2024var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
2025if ($gOPD) {
2026	try {
2027		$gOPD([], 'length');
2028	} catch (e) {
2029		// IE 8 has a broken gOPD
2030		$gOPD = null;
2031	}
2032}
2033
2034module.exports = $gOPD;
2035
2036},{"get-intrinsic":33}],24:[function(require,module,exports){
2037'use strict';
2038
2039module.exports = function isPrimitive(value) {
2040	return value === null || (typeof value !== 'function' && typeof value !== 'object');
2041};
2042
2043},{}],25:[function(require,module,exports){
2044'use strict';
2045
2046var callBound = require('call-bind/callBound');
2047
2048var $exec = callBound('RegExp.prototype.exec');
2049
2050module.exports = function regexTester(regex) {
2051	return function test(s) { return $exec(regex, s) !== null; };
2052};
2053
2054},{"call-bind/callBound":10}],26:[function(require,module,exports){
2055(function (process){
2056'use strict';
2057
2058/* eslint global-require: 0 */
2059// the code is structured this way so that bundlers can
2060// alias out `has-symbols` to `() => true` or `() => false` if your target
2061// environments' Symbol capabilities are known, and then use
2062// dead code elimination on the rest of this module.
2063//
2064// Similarly, `isarray` can be aliased to `Array.isArray` if
2065// available in all target environments.
2066
2067var isArguments = require('is-arguments');
2068
2069if (require('has-symbols')() || require('has-symbols/shams')()) {
2070	var $iterator = Symbol.iterator;
2071	// Symbol is available natively or shammed
2072	// natively:
2073	//  - Chrome >= 38
2074	//  - Edge 12-14?, Edge >= 15 for sure
2075	//  - FF >= 36
2076	//  - Safari >= 9
2077	//  - node >= 0.12
2078	module.exports = function getIterator(iterable) {
2079		// alternatively, `iterable[$iterator]?.()`
2080		if (iterable != null && typeof iterable[$iterator] !== 'undefined') {
2081			return iterable[$iterator]();
2082		}
2083		if (isArguments(iterable)) {
2084			// arguments objects lack Symbol.iterator
2085			// - node 0.12
2086			return Array.prototype[$iterator].call(iterable);
2087		}
2088	};
2089} else {
2090	// Symbol is not available, native or shammed
2091	var isArray = require('isarray');
2092	var isString = require('is-string');
2093	var GetIntrinsic = require('get-intrinsic');
2094	var $Map = GetIntrinsic('%Map%', true);
2095	var $Set = GetIntrinsic('%Set%', true);
2096	var callBound = require('call-bind/callBound');
2097	var $arrayPush = callBound('Array.prototype.push');
2098	var $charCodeAt = callBound('String.prototype.charCodeAt');
2099	var $stringSlice = callBound('String.prototype.slice');
2100
2101	var advanceStringIndex = function advanceStringIndex(S, index) {
2102		var length = S.length;
2103		if ((index + 1) >= length) {
2104			return index + 1;
2105		}
2106
2107		var first = $charCodeAt(S, index);
2108		if (first < 0xD800 || first > 0xDBFF) {
2109			return index + 1;
2110		}
2111
2112		var second = $charCodeAt(S, index + 1);
2113		if (second < 0xDC00 || second > 0xDFFF) {
2114			return index + 1;
2115		}
2116
2117		return index + 2;
2118	};
2119
2120	var getArrayIterator = function getArrayIterator(arraylike) {
2121		var i = 0;
2122		return {
2123			next: function next() {
2124				var done = i >= arraylike.length;
2125				var value;
2126				if (!done) {
2127					value = arraylike[i];
2128					i += 1;
2129				}
2130				return {
2131					done: done,
2132					value: value
2133				};
2134			}
2135		};
2136	};
2137
2138	var getNonCollectionIterator = function getNonCollectionIterator(iterable, noPrimordialCollections) {
2139		if (isArray(iterable) || isArguments(iterable)) {
2140			return getArrayIterator(iterable);
2141		}
2142		if (isString(iterable)) {
2143			var i = 0;
2144			return {
2145				next: function next() {
2146					var nextIndex = advanceStringIndex(iterable, i);
2147					var value = $stringSlice(iterable, i, nextIndex);
2148					i = nextIndex;
2149					return {
2150						done: nextIndex > iterable.length,
2151						value: value
2152					};
2153				}
2154			};
2155		}
2156
2157		// es6-shim and es-shims' es-map use a string "_es6-shim iterator_" property on different iterables, such as MapIterator.
2158		if (noPrimordialCollections && typeof iterable['_es6-shim iterator_'] !== 'undefined') {
2159			return iterable['_es6-shim iterator_']();
2160		}
2161	};
2162
2163	if (!$Map && !$Set) {
2164		// the only language iterables are Array, String, arguments
2165		// - Safari <= 6.0
2166		// - Chrome < 38
2167		// - node < 0.12
2168		// - FF < 13
2169		// - IE < 11
2170		// - Edge < 11
2171
2172		module.exports = function getIterator(iterable) {
2173			if (iterable != null) {
2174				return getNonCollectionIterator(iterable, true);
2175			}
2176		};
2177	} else {
2178		// either Map or Set are available, but Symbol is not
2179		// - es6-shim on an ES5 browser
2180		// - Safari 6.2 (maybe 6.1?)
2181		// - FF v[13, 36)
2182		// - IE 11
2183		// - Edge 11
2184		// - Safari v[6, 9)
2185
2186		var isMap = require('is-map');
2187		var isSet = require('is-set');
2188
2189		// Firefox >= 27, IE 11, Safari 6.2 - 9, Edge 11, es6-shim in older envs, all have forEach
2190		var $mapForEach = callBound('Map.prototype.forEach', true);
2191		var $setForEach = callBound('Set.prototype.forEach', true);
2192		if (typeof process === 'undefined' || !process.versions || !process.versions.node) { // "if is not node"
2193
2194			// Firefox 17 - 26 has `.iterator()`, whose iterator `.next()` either
2195			// returns a value, or throws a StopIteration object. These browsers
2196			// do not have any other mechanism for iteration.
2197			var $mapIterator = callBound('Map.prototype.iterator', true);
2198			var $setIterator = callBound('Set.prototype.iterator', true);
2199			var getStopIterationIterator = function (iterator) {
2200				var done = false;
2201				return {
2202					next: function next() {
2203						try {
2204							return {
2205								done: done,
2206								value: done ? undefined : iterator.next()
2207							};
2208						} catch (e) {
2209							done = true;
2210							return {
2211								done: true,
2212								value: undefined
2213							};
2214						}
2215					}
2216				};
2217			};
2218		}
2219		// Firefox 27-35, and some older es6-shim versions, use a string "@@iterator" property
2220		// this returns a proper iterator object, so we should use it instead of forEach.
2221		// newer es6-shim versions use a string "_es6-shim iterator_" property.
2222		var $mapAtAtIterator = callBound('Map.prototype.@@iterator', true) || callBound('Map.prototype._es6-shim iterator_', true);
2223		var $setAtAtIterator = callBound('Set.prototype.@@iterator', true) || callBound('Set.prototype._es6-shim iterator_', true);
2224
2225		var getCollectionIterator = function getCollectionIterator(iterable) {
2226			if (isMap(iterable)) {
2227				if ($mapIterator) {
2228					return getStopIterationIterator($mapIterator(iterable));
2229				}
2230				if ($mapAtAtIterator) {
2231					return $mapAtAtIterator(iterable);
2232				}
2233				if ($mapForEach) {
2234					var entries = [];
2235					$mapForEach(iterable, function (v, k) {
2236						$arrayPush(entries, [k, v]);
2237					});
2238					return getArrayIterator(entries);
2239				}
2240			}
2241			if (isSet(iterable)) {
2242				if ($setIterator) {
2243					return getStopIterationIterator($setIterator(iterable));
2244				}
2245				if ($setAtAtIterator) {
2246					return $setAtAtIterator(iterable);
2247				}
2248				if ($setForEach) {
2249					var values = [];
2250					$setForEach(iterable, function (v) {
2251						$arrayPush(values, v);
2252					});
2253					return getArrayIterator(values);
2254				}
2255			}
2256		};
2257
2258		module.exports = function getIterator(iterable) {
2259			return getCollectionIterator(iterable) || getNonCollectionIterator(iterable);
2260		};
2261	}
2262}
2263
2264}).call(this,require("KliubH"))
2265},{"KliubH":91,"call-bind/callBound":10,"get-intrinsic":33,"has-symbols":36,"has-symbols/shams":37,"is-arguments":41,"is-map":46,"is-set":49,"is-string":50,"isarray":55}],27:[function(require,module,exports){
2266'use strict';
2267
2268var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';
2269
2270var isPrimitive = require('./helpers/isPrimitive');
2271var isCallable = require('is-callable');
2272var isDate = require('is-date-object');
2273var isSymbol = require('is-symbol');
2274
2275var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
2276	if (typeof O === 'undefined' || O === null) {
2277		throw new TypeError('Cannot call method on ' + O);
2278	}
2279	if (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {
2280		throw new TypeError('hint must be "string" or "number"');
2281	}
2282	var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
2283	var method, result, i;
2284	for (i = 0; i < methodNames.length; ++i) {
2285		method = O[methodNames[i]];
2286		if (isCallable(method)) {
2287			result = method.call(O);
2288			if (isPrimitive(result)) {
2289				return result;
2290			}
2291		}
2292	}
2293	throw new TypeError('No default value');
2294};
2295
2296var GetMethod = function GetMethod(O, P) {
2297	var func = O[P];
2298	if (func !== null && typeof func !== 'undefined') {
2299		if (!isCallable(func)) {
2300			throw new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');
2301		}
2302		return func;
2303	}
2304	return void 0;
2305};
2306
2307// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive
2308module.exports = function ToPrimitive(input) {
2309	if (isPrimitive(input)) {
2310		return input;
2311	}
2312	var hint = 'default';
2313	if (arguments.length > 1) {
2314		if (arguments[1] === String) {
2315			hint = 'string';
2316		} else if (arguments[1] === Number) {
2317			hint = 'number';
2318		}
2319	}
2320
2321	var exoticToPrim;
2322	if (hasSymbols) {
2323		if (Symbol.toPrimitive) {
2324			exoticToPrim = GetMethod(input, Symbol.toPrimitive);
2325		} else if (isSymbol(input)) {
2326			exoticToPrim = Symbol.prototype.valueOf;
2327		}
2328	}
2329	if (typeof exoticToPrim !== 'undefined') {
2330		var result = exoticToPrim.call(input, hint);
2331		if (isPrimitive(result)) {
2332			return result;
2333		}
2334		throw new TypeError('unable to convert exotic object to primitive');
2335	}
2336	if (hint === 'default' && (isDate(input) || isSymbol(input))) {
2337		hint = 'string';
2338	}
2339	return ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);
2340};
2341
2342},{"./helpers/isPrimitive":28,"is-callable":44,"is-date-object":45,"is-symbol":51}],28:[function(require,module,exports){
2343module.exports=require(24)
2344},{}],29:[function(require,module,exports){
2345'use strict';
2346
2347var isCallable = require('is-callable');
2348
2349var toStr = Object.prototype.toString;
2350var hasOwnProperty = Object.prototype.hasOwnProperty;
2351
2352var forEachArray = function forEachArray(array, iterator, receiver) {
2353    for (var i = 0, len = array.length; i < len; i++) {
2354        if (hasOwnProperty.call(array, i)) {
2355            if (receiver == null) {
2356                iterator(array[i], i, array);
2357            } else {
2358                iterator.call(receiver, array[i], i, array);
2359            }
2360        }
2361    }
2362};
2363
2364var forEachString = function forEachString(string, iterator, receiver) {
2365    for (var i = 0, len = string.length; i < len; i++) {
2366        // no such thing as a sparse string.
2367        if (receiver == null) {
2368            iterator(string.charAt(i), i, string);
2369        } else {
2370            iterator.call(receiver, string.charAt(i), i, string);
2371        }
2372    }
2373};
2374
2375var forEachObject = function forEachObject(object, iterator, receiver) {
2376    for (var k in object) {
2377        if (hasOwnProperty.call(object, k)) {
2378            if (receiver == null) {
2379                iterator(object[k], k, object);
2380            } else {
2381                iterator.call(receiver, object[k], k, object);
2382            }
2383        }
2384    }
2385};
2386
2387var forEach = function forEach(list, iterator, thisArg) {
2388    if (!isCallable(iterator)) {
2389        throw new TypeError('iterator must be a function');
2390    }
2391
2392    var receiver;
2393    if (arguments.length >= 3) {
2394        receiver = thisArg;
2395    }
2396
2397    if (toStr.call(list) === '[object Array]') {
2398        forEachArray(list, iterator, receiver);
2399    } else if (typeof list === 'string') {
2400        forEachString(list, iterator, receiver);
2401    } else {
2402        forEachObject(list, iterator, receiver);
2403    }
2404};
2405
2406module.exports = forEach;
2407
2408},{"is-callable":44}],30:[function(require,module,exports){
2409'use strict';
2410
2411/* eslint no-invalid-this: 1 */
2412
2413var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
2414var slice = Array.prototype.slice;
2415var toStr = Object.prototype.toString;
2416var funcType = '[object Function]';
2417
2418module.exports = function bind(that) {
2419    var target = this;
2420    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
2421        throw new TypeError(ERROR_MESSAGE + target);
2422    }
2423    var args = slice.call(arguments, 1);
2424
2425    var bound;
2426    var binder = function () {
2427        if (this instanceof bound) {
2428            var result = target.apply(
2429                this,
2430                args.concat(slice.call(arguments))
2431            );
2432            if (Object(result) === result) {
2433                return result;
2434            }
2435            return this;
2436        } else {
2437            return target.apply(
2438                that,
2439                args.concat(slice.call(arguments))
2440            );
2441        }
2442    };
2443
2444    var boundLength = Math.max(0, target.length - args.length);
2445    var boundArgs = [];
2446    for (var i = 0; i < boundLength; i++) {
2447        boundArgs.push('$' + i);
2448    }
2449
2450    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
2451
2452    if (target.prototype) {
2453        var Empty = function Empty() {};
2454        Empty.prototype = target.prototype;
2455        bound.prototype = new Empty();
2456        Empty.prototype = null;
2457    }
2458
2459    return bound;
2460};
2461
2462},{}],31:[function(require,module,exports){
2463'use strict';
2464
2465var implementation = require('./implementation');
2466
2467module.exports = Function.prototype.bind || implementation;
2468
2469},{"./implementation":30}],32:[function(require,module,exports){
2470'use strict';
2471
2472var functionsHaveNames = function functionsHaveNames() {
2473	return typeof function f() {}.name === 'string';
2474};
2475
2476var gOPD = Object.getOwnPropertyDescriptor;
2477if (gOPD) {
2478	try {
2479		gOPD([], 'length');
2480	} catch (e) {
2481		// IE 8 has a broken gOPD
2482		gOPD = null;
2483	}
2484}
2485
2486functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {
2487	if (!functionsHaveNames() || !gOPD) {
2488		return false;
2489	}
2490	var desc = gOPD(function () {}, 'name');
2491	return !!desc && !!desc.configurable;
2492};
2493
2494var $bind = Function.prototype.bind;
2495
2496functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {
2497	return functionsHaveNames() && typeof $bind === 'function' && function f() {}.bind().name !== '';
2498};
2499
2500module.exports = functionsHaveNames;
2501
2502},{}],33:[function(require,module,exports){
2503'use strict';
2504
2505var undefined;
2506
2507var $SyntaxError = SyntaxError;
2508var $Function = Function;
2509var $TypeError = TypeError;
2510
2511// eslint-disable-next-line consistent-return
2512var getEvalledConstructor = function (expressionSyntax) {
2513	try {
2514		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
2515	} catch (e) {}
2516};
2517
2518var $gOPD = Object.getOwnPropertyDescriptor;
2519if ($gOPD) {
2520	try {
2521		$gOPD({}, '');
2522	} catch (e) {
2523		$gOPD = null; // this is IE 8, which has a broken gOPD
2524	}
2525}
2526
2527var throwTypeError = function () {
2528	throw new $TypeError();
2529};
2530var ThrowTypeError = $gOPD
2531	? (function () {
2532		try {
2533			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
2534			arguments.callee; // IE 8 does not throw here
2535			return throwTypeError;
2536		} catch (calleeThrows) {
2537			try {
2538				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
2539				return $gOPD(arguments, 'callee').get;
2540			} catch (gOPDthrows) {
2541				return throwTypeError;
2542			}
2543		}
2544	}())
2545	: throwTypeError;
2546
2547var hasSymbols = require('has-symbols')();
2548
2549var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
2550
2551var needsEval = {};
2552
2553var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
2554
2555var INTRINSICS = {
2556	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
2557	'%Array%': Array,
2558	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
2559	'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
2560	'%AsyncFromSyncIteratorPrototype%': undefined,
2561	'%AsyncFunction%': needsEval,
2562	'%AsyncGenerator%': needsEval,
2563	'%AsyncGeneratorFunction%': needsEval,
2564	'%AsyncIteratorPrototype%': needsEval,
2565	'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
2566	'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
2567	'%Boolean%': Boolean,
2568	'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
2569	'%Date%': Date,
2570	'%decodeURI%': decodeURI,
2571	'%decodeURIComponent%': decodeURIComponent,
2572	'%encodeURI%': encodeURI,
2573	'%encodeURIComponent%': encodeURIComponent,
2574	'%Error%': Error,
2575	'%eval%': eval, // eslint-disable-line no-eval
2576	'%EvalError%': EvalError,
2577	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
2578	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
2579	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
2580	'%Function%': $Function,
2581	'%GeneratorFunction%': needsEval,
2582	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
2583	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
2584	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
2585	'%isFinite%': isFinite,
2586	'%isNaN%': isNaN,
2587	'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
2588	'%JSON%': typeof JSON === 'object' ? JSON : undefined,
2589	'%Map%': typeof Map === 'undefined' ? undefined : Map,
2590	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
2591	'%Math%': Math,
2592	'%Number%': Number,
2593	'%Object%': Object,
2594	'%parseFloat%': parseFloat,
2595	'%parseInt%': parseInt,
2596	'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
2597	'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
2598	'%RangeError%': RangeError,
2599	'%ReferenceError%': ReferenceError,
2600	'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
2601	'%RegExp%': RegExp,
2602	'%Set%': typeof Set === 'undefined' ? undefined : Set,
2603	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
2604	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
2605	'%String%': String,
2606	'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
2607	'%Symbol%': hasSymbols ? Symbol : undefined,
2608	'%SyntaxError%': $SyntaxError,
2609	'%ThrowTypeError%': ThrowTypeError,
2610	'%TypedArray%': TypedArray,
2611	'%TypeError%': $TypeError,
2612	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
2613	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
2614	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
2615	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
2616	'%URIError%': URIError,
2617	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
2618	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
2619	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
2620};
2621
2622var doEval = function doEval(name) {
2623	var value;
2624	if (name === '%AsyncFunction%') {
2625		value = getEvalledConstructor('async function () {}');
2626	} else if (name === '%GeneratorFunction%') {
2627		value = getEvalledConstructor('function* () {}');
2628	} else if (name === '%AsyncGeneratorFunction%') {
2629		value = getEvalledConstructor('async function* () {}');
2630	} else if (name === '%AsyncGenerator%') {
2631		var fn = doEval('%AsyncGeneratorFunction%');
2632		if (fn) {
2633			value = fn.prototype;
2634		}
2635	} else if (name === '%AsyncIteratorPrototype%') {
2636		var gen = doEval('%AsyncGenerator%');
2637		if (gen) {
2638			value = getProto(gen.prototype);
2639		}
2640	}
2641
2642	INTRINSICS[name] = value;
2643
2644	return value;
2645};
2646
2647var LEGACY_ALIASES = {
2648	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
2649	'%ArrayPrototype%': ['Array', 'prototype'],
2650	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
2651	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
2652	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
2653	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
2654	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
2655	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
2656	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
2657	'%BooleanPrototype%': ['Boolean', 'prototype'],
2658	'%DataViewPrototype%': ['DataView', 'prototype'],
2659	'%DatePrototype%': ['Date', 'prototype'],
2660	'%ErrorPrototype%': ['Error', 'prototype'],
2661	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
2662	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
2663	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
2664	'%FunctionPrototype%': ['Function', 'prototype'],
2665	'%Generator%': ['GeneratorFunction', 'prototype'],
2666	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
2667	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
2668	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
2669	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
2670	'%JSONParse%': ['JSON', 'parse'],
2671	'%JSONStringify%': ['JSON', 'stringify'],
2672	'%MapPrototype%': ['Map', 'prototype'],
2673	'%NumberPrototype%': ['Number', 'prototype'],
2674	'%ObjectPrototype%': ['Object', 'prototype'],
2675	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
2676	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
2677	'%PromisePrototype%': ['Promise', 'prototype'],
2678	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
2679	'%Promise_all%': ['Promise', 'all'],
2680	'%Promise_reject%': ['Promise', 'reject'],
2681	'%Promise_resolve%': ['Promise', 'resolve'],
2682	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
2683	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
2684	'%RegExpPrototype%': ['RegExp', 'prototype'],
2685	'%SetPrototype%': ['Set', 'prototype'],
2686	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
2687	'%StringPrototype%': ['String', 'prototype'],
2688	'%SymbolPrototype%': ['Symbol', 'prototype'],
2689	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
2690	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
2691	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
2692	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
2693	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
2694	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
2695	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
2696	'%URIErrorPrototype%': ['URIError', 'prototype'],
2697	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
2698	'%WeakSetPrototype%': ['WeakSet', 'prototype']
2699};
2700
2701var bind = require('function-bind');
2702var hasOwn = require('has');
2703var $concat = bind.call(Function.call, Array.prototype.concat);
2704var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
2705var $replace = bind.call(Function.call, String.prototype.replace);
2706var $strSlice = bind.call(Function.call, String.prototype.slice);
2707
2708/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
2709var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
2710var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
2711var stringToPath = function stringToPath(string) {
2712	var first = $strSlice(string, 0, 1);
2713	var last = $strSlice(string, -1);
2714	if (first === '%' && last !== '%') {
2715		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
2716	} else if (last === '%' && first !== '%') {
2717		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
2718	}
2719	var result = [];
2720	$replace(string, rePropName, function (match, number, quote, subString) {
2721		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
2722	});
2723	return result;
2724};
2725/* end adaptation */
2726
2727var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
2728	var intrinsicName = name;
2729	var alias;
2730	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
2731		alias = LEGACY_ALIASES[intrinsicName];
2732		intrinsicName = '%' + alias[0] + '%';
2733	}
2734
2735	if (hasOwn(INTRINSICS, intrinsicName)) {
2736		var value = INTRINSICS[intrinsicName];
2737		if (value === needsEval) {
2738			value = doEval(intrinsicName);
2739		}
2740		if (typeof value === 'undefined' && !allowMissing) {
2741			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
2742		}
2743
2744		return {
2745			alias: alias,
2746			name: intrinsicName,
2747			value: value
2748		};
2749	}
2750
2751	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
2752};
2753
2754module.exports = function GetIntrinsic(name, allowMissing) {
2755	if (typeof name !== 'string' || name.length === 0) {
2756		throw new $TypeError('intrinsic name must be a non-empty string');
2757	}
2758	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
2759		throw new $TypeError('"allowMissing" argument must be a boolean');
2760	}
2761
2762	var parts = stringToPath(name);
2763	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
2764
2765	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
2766	var intrinsicRealName = intrinsic.name;
2767	var value = intrinsic.value;
2768	var skipFurtherCaching = false;
2769
2770	var alias = intrinsic.alias;
2771	if (alias) {
2772		intrinsicBaseName = alias[0];
2773		$spliceApply(parts, $concat([0, 1], alias));
2774	}
2775
2776	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
2777		var part = parts[i];
2778		var first = $strSlice(part, 0, 1);
2779		var last = $strSlice(part, -1);
2780		if (
2781			(
2782				(first === '"' || first === "'" || first === '`')
2783				|| (last === '"' || last === "'" || last === '`')
2784			)
2785			&& first !== last
2786		) {
2787			throw new $SyntaxError('property names with quotes must have matching quotes');
2788		}
2789		if (part === 'constructor' || !isOwn) {
2790			skipFurtherCaching = true;
2791		}
2792
2793		intrinsicBaseName += '.' + part;
2794		intrinsicRealName = '%' + intrinsicBaseName + '%';
2795
2796		if (hasOwn(INTRINSICS, intrinsicRealName)) {
2797			value = INTRINSICS[intrinsicRealName];
2798		} else if (value != null) {
2799			if (!(part in value)) {
2800				if (!allowMissing) {
2801					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
2802				}
2803				return void undefined;
2804			}
2805			if ($gOPD && (i + 1) >= parts.length) {
2806				var desc = $gOPD(value, part);
2807				isOwn = !!desc;
2808
2809				// By convention, when a data property is converted to an accessor
2810				// property to emulate a data property that does not suffer from
2811				// the override mistake, that accessor's getter is marked with
2812				// an `originalValue` property. Here, when we detect this, we
2813				// uphold the illusion by pretending to see that original data
2814				// property, i.e., returning the value rather than the getter
2815				// itself.
2816				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
2817					value = desc.get;
2818				} else {
2819					value = value[part];
2820				}
2821			} else {
2822				isOwn = hasOwn(value, part);
2823				value = value[part];
2824			}
2825
2826			if (isOwn && !skipFurtherCaching) {
2827				INTRINSICS[intrinsicRealName] = value;
2828			}
2829		}
2830	}
2831	return value;
2832};
2833
2834},{"function-bind":31,"has":39,"has-symbols":36}],34:[function(require,module,exports){
2835'use strict';
2836
2837var $BigInt = typeof BigInt !== 'undefined' && BigInt;
2838
2839module.exports = function hasNativeBigInts() {
2840	return typeof $BigInt === 'function'
2841		&& typeof BigInt === 'function'
2842		&& typeof $BigInt(42) === 'bigint' // eslint-disable-line no-magic-numbers
2843		&& typeof BigInt(42) === 'bigint'; // eslint-disable-line no-magic-numbers
2844};
2845
2846},{}],35:[function(require,module,exports){
2847'use strict';
2848
2849var GetIntrinsic = require('get-intrinsic');
2850
2851var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
2852
2853var hasPropertyDescriptors = function hasPropertyDescriptors() {
2854	if ($defineProperty) {
2855		try {
2856			$defineProperty({}, 'a', { value: 1 });
2857			return true;
2858		} catch (e) {
2859			// IE 8 has a broken defineProperty
2860			return false;
2861		}
2862	}
2863	return false;
2864};
2865
2866hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
2867	// node v0.6 has a bug where array lengths can be Set but not Defined
2868	if (!hasPropertyDescriptors()) {
2869		return null;
2870	}
2871	try {
2872		return $defineProperty([], 'length', { value: 1 }).length !== 1;
2873	} catch (e) {
2874		// In Firefox 4-22, defining length on an array throws an exception.
2875		return true;
2876	}
2877};
2878
2879module.exports = hasPropertyDescriptors;
2880
2881},{"get-intrinsic":33}],36:[function(require,module,exports){
2882'use strict';
2883
2884var origSymbol = typeof Symbol !== 'undefined' && Symbol;
2885var hasSymbolSham = require('./shams');
2886
2887module.exports = function hasNativeSymbols() {
2888	if (typeof origSymbol !== 'function') { return false; }
2889	if (typeof Symbol !== 'function') { return false; }
2890	if (typeof origSymbol('foo') !== 'symbol') { return false; }
2891	if (typeof Symbol('bar') !== 'symbol') { return false; }
2892
2893	return hasSymbolSham();
2894};
2895
2896},{"./shams":37}],37:[function(require,module,exports){
2897'use strict';
2898
2899/* eslint complexity: [2, 18], max-statements: [2, 33] */
2900module.exports = function hasSymbols() {
2901	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
2902	if (typeof Symbol.iterator === 'symbol') { return true; }
2903
2904	var obj = {};
2905	var sym = Symbol('test');
2906	var symObj = Object(sym);
2907	if (typeof sym === 'string') { return false; }
2908
2909	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
2910	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
2911
2912	// temp disabled per https://github.com/ljharb/object.assign/issues/17
2913	// if (sym instanceof Symbol) { return false; }
2914	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
2915	// if (!(symObj instanceof Symbol)) { return false; }
2916
2917	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
2918	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
2919
2920	var symVal = 42;
2921	obj[sym] = symVal;
2922	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
2923	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
2924
2925	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
2926
2927	var syms = Object.getOwnPropertySymbols(obj);
2928	if (syms.length !== 1 || syms[0] !== sym) { return false; }
2929
2930	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
2931
2932	if (typeof Object.getOwnPropertyDescriptor === 'function') {
2933		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
2934		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
2935	}
2936
2937	return true;
2938};
2939
2940},{}],38:[function(require,module,exports){
2941'use strict';
2942
2943var hasSymbols = require('has-symbols/shams');
2944
2945module.exports = function hasToStringTagShams() {
2946	return hasSymbols() && !!Symbol.toStringTag;
2947};
2948
2949},{"has-symbols/shams":37}],39:[function(require,module,exports){
2950'use strict';
2951
2952var bind = require('function-bind');
2953
2954module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
2955
2956},{"function-bind":31}],40:[function(require,module,exports){
2957if (typeof Object.create === 'function') {
2958  // implementation from standard node.js 'util' module
2959  module.exports = function inherits(ctor, superCtor) {
2960    if (superCtor) {
2961      ctor.super_ = superCtor
2962      ctor.prototype = Object.create(superCtor.prototype, {
2963        constructor: {
2964          value: ctor,
2965          enumerable: false,
2966          writable: true,
2967          configurable: true
2968        }
2969      })
2970    }
2971  };
2972} else {
2973  // old school shim for old browsers
2974  module.exports = function inherits(ctor, superCtor) {
2975    if (superCtor) {
2976      ctor.super_ = superCtor
2977      var TempCtor = function () {}
2978      TempCtor.prototype = superCtor.prototype
2979      ctor.prototype = new TempCtor()
2980      ctor.prototype.constructor = ctor
2981    }
2982  }
2983}
2984
2985},{}],41:[function(require,module,exports){
2986'use strict';
2987
2988var hasToStringTag = require('has-tostringtag/shams')();
2989var callBound = require('call-bind/callBound');
2990
2991var $toString = callBound('Object.prototype.toString');
2992
2993var isStandardArguments = function isArguments(value) {
2994	if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {
2995		return false;
2996	}
2997	return $toString(value) === '[object Arguments]';
2998};
2999
3000var isLegacyArguments = function isArguments(value) {
3001	if (isStandardArguments(value)) {
3002		return true;
3003	}
3004	return value !== null &&
3005		typeof value === 'object' &&
3006		typeof value.length === 'number' &&
3007		value.length >= 0 &&
3008		$toString(value) !== '[object Array]' &&
3009		$toString(value.callee) === '[object Function]';
3010};
3011
3012var supportsStandardArguments = (function () {
3013	return isStandardArguments(arguments);
3014}());
3015
3016isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
3017
3018module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
3019
3020},{"call-bind/callBound":10,"has-tostringtag/shams":38}],42:[function(require,module,exports){
3021'use strict';
3022
3023var hasBigInts = require('has-bigints')();
3024
3025if (hasBigInts) {
3026	var bigIntValueOf = BigInt.prototype.valueOf;
3027	var tryBigInt = function tryBigIntObject(value) {
3028		try {
3029			bigIntValueOf.call(value);
3030			return true;
3031		} catch (e) {
3032		}
3033		return false;
3034	};
3035
3036	module.exports = function isBigInt(value) {
3037		if (
3038			value === null
3039			|| typeof value === 'undefined'
3040			|| typeof value === 'boolean'
3041			|| typeof value === 'string'
3042			|| typeof value === 'number'
3043			|| typeof value === 'symbol'
3044			|| typeof value === 'function'
3045		) {
3046			return false;
3047		}
3048		if (typeof value === 'bigint') {
3049			return true;
3050		}
3051
3052		return tryBigInt(value);
3053	};
3054} else {
3055	module.exports = function isBigInt(value) {
3056		return false && value;
3057	};
3058}
3059
3060},{"has-bigints":34}],43:[function(require,module,exports){
3061'use strict';
3062
3063var callBound = require('call-bind/callBound');
3064var $boolToStr = callBound('Boolean.prototype.toString');
3065var $toString = callBound('Object.prototype.toString');
3066
3067var tryBooleanObject = function booleanBrandCheck(value) {
3068	try {
3069		$boolToStr(value);
3070		return true;
3071	} catch (e) {
3072		return false;
3073	}
3074};
3075var boolClass = '[object Boolean]';
3076var hasToStringTag = require('has-tostringtag/shams')();
3077
3078module.exports = function isBoolean(value) {
3079	if (typeof value === 'boolean') {
3080		return true;
3081	}
3082	if (value === null || typeof value !== 'object') {
3083		return false;
3084	}
3085	return hasToStringTag && Symbol.toStringTag in value ? tryBooleanObject(value) : $toString(value) === boolClass;
3086};
3087
3088},{"call-bind/callBound":10,"has-tostringtag/shams":38}],44:[function(require,module,exports){
3089'use strict';
3090
3091var fnToStr = Function.prototype.toString;
3092var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
3093var badArrayLike;
3094var isCallableMarker;
3095if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
3096	try {
3097		badArrayLike = Object.defineProperty({}, 'length', {
3098			get: function () {
3099				throw isCallableMarker;
3100			}
3101		});
3102		isCallableMarker = {};
3103		// eslint-disable-next-line no-throw-literal
3104		reflectApply(function () { throw 42; }, null, badArrayLike);
3105	} catch (_) {
3106		if (_ !== isCallableMarker) {
3107			reflectApply = null;
3108		}
3109	}
3110} else {
3111	reflectApply = null;
3112}
3113
3114var constructorRegex = /^\s*class\b/;
3115var isES6ClassFn = function isES6ClassFunction(value) {
3116	try {
3117		var fnStr = fnToStr.call(value);
3118		return constructorRegex.test(fnStr);
3119	} catch (e) {
3120		return false; // not a function
3121	}
3122};
3123
3124var tryFunctionObject = function tryFunctionToStr(value) {
3125	try {
3126		if (isES6ClassFn(value)) { return false; }
3127		fnToStr.call(value);
3128		return true;
3129	} catch (e) {
3130		return false;
3131	}
3132};
3133var toStr = Object.prototype.toString;
3134var fnClass = '[object Function]';
3135var genClass = '[object GeneratorFunction]';
3136var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
3137/* globals document: false */
3138var documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};
3139
3140module.exports = reflectApply
3141	? function isCallable(value) {
3142		if (value === documentDotAll) { return true; }
3143		if (!value) { return false; }
3144		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
3145		if (typeof value === 'function' && !value.prototype) { return true; }
3146		try {
3147			reflectApply(value, null, badArrayLike);
3148		} catch (e) {
3149			if (e !== isCallableMarker) { return false; }
3150		}
3151		return !isES6ClassFn(value);
3152	}
3153	: function isCallable(value) {
3154		if (value === documentDotAll) { return true; }
3155		if (!value) { return false; }
3156		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
3157		if (typeof value === 'function' && !value.prototype) { return true; }
3158		if (hasToStringTag) { return tryFunctionObject(value); }
3159		if (isES6ClassFn(value)) { return false; }
3160		var strClass = toStr.call(value);
3161		return strClass === fnClass || strClass === genClass;
3162	};
3163
3164},{}],45:[function(require,module,exports){
3165'use strict';
3166
3167var getDay = Date.prototype.getDay;
3168var tryDateObject = function tryDateGetDayCall(value) {
3169	try {
3170		getDay.call(value);
3171		return true;
3172	} catch (e) {
3173		return false;
3174	}
3175};
3176
3177var toStr = Object.prototype.toString;
3178var dateClass = '[object Date]';
3179var hasToStringTag = require('has-tostringtag/shams')();
3180
3181module.exports = function isDateObject(value) {
3182	if (typeof value !== 'object' || value === null) {
3183		return false;
3184	}
3185	return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;
3186};
3187
3188},{"has-tostringtag/shams":38}],46:[function(require,module,exports){
3189'use strict';
3190
3191var $Map = typeof Map === 'function' && Map.prototype ? Map : null;
3192var $Set = typeof Set === 'function' && Set.prototype ? Set : null;
3193
3194var exported;
3195
3196if (!$Map) {
3197	// eslint-disable-next-line no-unused-vars
3198	exported = function isMap(x) {
3199		// `Map` is not present in this environment.
3200		return false;
3201	};
3202}
3203
3204var $mapHas = $Map ? Map.prototype.has : null;
3205var $setHas = $Set ? Set.prototype.has : null;
3206if (!exported && !$mapHas) {
3207	// eslint-disable-next-line no-unused-vars
3208	exported = function isMap(x) {
3209		// `Map` does not have a `has` method
3210		return false;
3211	};
3212}
3213
3214module.exports = exported || function isMap(x) {
3215	if (!x || typeof x !== 'object') {
3216		return false;
3217	}
3218	try {
3219		$mapHas.call(x);
3220		if ($setHas) {
3221			try {
3222				$setHas.call(x);
3223			} catch (e) {
3224				return true;
3225			}
3226		}
3227		return x instanceof $Map; // core-js workaround, pre-v2.5.0
3228	} catch (e) {}
3229	return false;
3230};
3231
3232},{}],47:[function(require,module,exports){
3233'use strict';
3234
3235var numToStr = Number.prototype.toString;
3236var tryNumberObject = function tryNumberObject(value) {
3237	try {
3238		numToStr.call(value);
3239		return true;
3240	} catch (e) {
3241		return false;
3242	}
3243};
3244var toStr = Object.prototype.toString;
3245var numClass = '[object Number]';
3246var hasToStringTag = require('has-tostringtag/shams')();
3247
3248module.exports = function isNumberObject(value) {
3249	if (typeof value === 'number') {
3250		return true;
3251	}
3252	if (typeof value !== 'object') {
3253		return false;
3254	}
3255	return hasToStringTag ? tryNumberObject(value) : toStr.call(value) === numClass;
3256};
3257
3258},{"has-tostringtag/shams":38}],48:[function(require,module,exports){
3259'use strict';
3260
3261var callBound = require('call-bind/callBound');
3262var hasToStringTag = require('has-tostringtag/shams')();
3263var has;
3264var $exec;
3265var isRegexMarker;
3266var badStringifier;
3267
3268if (hasToStringTag) {
3269	has = callBound('Object.prototype.hasOwnProperty');
3270	$exec = callBound('RegExp.prototype.exec');
3271	isRegexMarker = {};
3272
3273	var throwRegexMarker = function () {
3274		throw isRegexMarker;
3275	};
3276	badStringifier = {
3277		toString: throwRegexMarker,
3278		valueOf: throwRegexMarker
3279	};
3280
3281	if (typeof Symbol.toPrimitive === 'symbol') {
3282		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
3283	}
3284}
3285
3286var $toString = callBound('Object.prototype.toString');
3287var gOPD = Object.getOwnPropertyDescriptor;
3288var regexClass = '[object RegExp]';
3289
3290module.exports = hasToStringTag
3291	// eslint-disable-next-line consistent-return
3292	? function isRegex(value) {
3293		if (!value || typeof value !== 'object') {
3294			return false;
3295		}
3296
3297		var descriptor = gOPD(value, 'lastIndex');
3298		var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
3299		if (!hasLastIndexDataProperty) {
3300			return false;
3301		}
3302
3303		try {
3304			$exec(value, badStringifier);
3305		} catch (e) {
3306			return e === isRegexMarker;
3307		}
3308	}
3309	: function isRegex(value) {
3310		// In older browsers, typeof regex incorrectly returns 'function'
3311		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
3312			return false;
3313		}
3314
3315		return $toString(value) === regexClass;
3316	};
3317
3318},{"call-bind/callBound":10,"has-tostringtag/shams":38}],49:[function(require,module,exports){
3319'use strict';
3320
3321var $Map = typeof Map === 'function' && Map.prototype ? Map : null;
3322var $Set = typeof Set === 'function' && Set.prototype ? Set : null;
3323
3324var exported;
3325
3326if (!$Set) {
3327	// eslint-disable-next-line no-unused-vars
3328	exported = function isSet(x) {
3329		// `Set` is not present in this environment.
3330		return false;
3331	};
3332}
3333
3334var $mapHas = $Map ? Map.prototype.has : null;
3335var $setHas = $Set ? Set.prototype.has : null;
3336if (!exported && !$setHas) {
3337	// eslint-disable-next-line no-unused-vars
3338	exported = function isSet(x) {
3339		// `Set` does not have a `has` method
3340		return false;
3341	};
3342}
3343
3344module.exports = exported || function isSet(x) {
3345	if (!x || typeof x !== 'object') {
3346		return false;
3347	}
3348	try {
3349		$setHas.call(x);
3350		if ($mapHas) {
3351			try {
3352				$mapHas.call(x);
3353			} catch (e) {
3354				return true;
3355			}
3356		}
3357		return x instanceof $Set; // core-js workaround, pre-v2.5.0
3358	} catch (e) {}
3359	return false;
3360};
3361
3362},{}],50:[function(require,module,exports){
3363'use strict';
3364
3365var strValue = String.prototype.valueOf;
3366var tryStringObject = function tryStringObject(value) {
3367	try {
3368		strValue.call(value);
3369		return true;
3370	} catch (e) {
3371		return false;
3372	}
3373};
3374var toStr = Object.prototype.toString;
3375var strClass = '[object String]';
3376var hasToStringTag = require('has-tostringtag/shams')();
3377
3378module.exports = function isString(value) {
3379	if (typeof value === 'string') {
3380		return true;
3381	}
3382	if (typeof value !== 'object') {
3383		return false;
3384	}
3385	return hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;
3386};
3387
3388},{"has-tostringtag/shams":38}],51:[function(require,module,exports){
3389'use strict';
3390
3391var toStr = Object.prototype.toString;
3392var hasSymbols = require('has-symbols')();
3393
3394if (hasSymbols) {
3395	var symToStr = Symbol.prototype.toString;
3396	var symStringRegex = /^Symbol\(.*\)$/;
3397	var isSymbolObject = function isRealSymbolObject(value) {
3398		if (typeof value.valueOf() !== 'symbol') {
3399			return false;
3400		}
3401		return symStringRegex.test(symToStr.call(value));
3402	};
3403
3404	module.exports = function isSymbol(value) {
3405		if (typeof value === 'symbol') {
3406			return true;
3407		}
3408		if (toStr.call(value) !== '[object Symbol]') {
3409			return false;
3410		}
3411		try {
3412			return isSymbolObject(value);
3413		} catch (e) {
3414			return false;
3415		}
3416	};
3417} else {
3418
3419	module.exports = function isSymbol(value) {
3420		// this environment does not support Symbols.
3421		return false && value;
3422	};
3423}
3424
3425},{"has-symbols":36}],52:[function(require,module,exports){
3426(function (global){
3427'use strict';
3428
3429var forEach = require('for-each');
3430var availableTypedArrays = require('available-typed-arrays');
3431var callBound = require('call-bind/callBound');
3432
3433var $toString = callBound('Object.prototype.toString');
3434var hasToStringTag = require('has-tostringtag/shams')();
3435
3436var g = typeof globalThis === 'undefined' ? global : globalThis;
3437var typedArrays = availableTypedArrays();
3438
3439var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {
3440	for (var i = 0; i < array.length; i += 1) {
3441		if (array[i] === value) {
3442			return i;
3443		}
3444	}
3445	return -1;
3446};
3447var $slice = callBound('String.prototype.slice');
3448var toStrTags = {};
3449var gOPD = require('es-abstract/helpers/getOwnPropertyDescriptor');
3450var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
3451if (hasToStringTag && gOPD && getPrototypeOf) {
3452	forEach(typedArrays, function (typedArray) {
3453		var arr = new g[typedArray]();
3454		if (Symbol.toStringTag in arr) {
3455			var proto = getPrototypeOf(arr);
3456			var descriptor = gOPD(proto, Symbol.toStringTag);
3457			if (!descriptor) {
3458				var superProto = getPrototypeOf(proto);
3459				descriptor = gOPD(superProto, Symbol.toStringTag);
3460			}
3461			toStrTags[typedArray] = descriptor.get;
3462		}
3463	});
3464}
3465
3466var tryTypedArrays = function tryAllTypedArrays(value) {
3467	var anyTrue = false;
3468	forEach(toStrTags, function (getter, typedArray) {
3469		if (!anyTrue) {
3470			try {
3471				anyTrue = getter.call(value) === typedArray;
3472			} catch (e) { /**/ }
3473		}
3474	});
3475	return anyTrue;
3476};
3477
3478module.exports = function isTypedArray(value) {
3479	if (!value || typeof value !== 'object') { return false; }
3480	if (!hasToStringTag || !(Symbol.toStringTag in value)) {
3481		var tag = $slice($toString(value), 8, -1);
3482		return $indexOf(typedArrays, tag) > -1;
3483	}
3484	if (!gOPD) { return false; }
3485	return tryTypedArrays(value);
3486};
3487
3488}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
3489},{"available-typed-arrays":9,"call-bind/callBound":10,"es-abstract/helpers/getOwnPropertyDescriptor":23,"for-each":29,"has-tostringtag/shams":38}],53:[function(require,module,exports){
3490'use strict';
3491
3492var $WeakMap = typeof WeakMap === 'function' && WeakMap.prototype ? WeakMap : null;
3493var $WeakSet = typeof WeakSet === 'function' && WeakSet.prototype ? WeakSet : null;
3494
3495var exported;
3496
3497if (!$WeakMap) {
3498	// eslint-disable-next-line no-unused-vars
3499	exported = function isWeakMap(x) {
3500		// `WeakMap` is not present in this environment.
3501		return false;
3502	};
3503}
3504
3505var $mapHas = $WeakMap ? $WeakMap.prototype.has : null;
3506var $setHas = $WeakSet ? $WeakSet.prototype.has : null;
3507if (!exported && !$mapHas) {
3508	// eslint-disable-next-line no-unused-vars
3509	exported = function isWeakMap(x) {
3510		// `WeakMap` does not have a `has` method
3511		return false;
3512	};
3513}
3514
3515module.exports = exported || function isWeakMap(x) {
3516	if (!x || typeof x !== 'object') {
3517		return false;
3518	}
3519	try {
3520		$mapHas.call(x, $mapHas);
3521		if ($setHas) {
3522			try {
3523				$setHas.call(x, $setHas);
3524			} catch (e) {
3525				return true;
3526			}
3527		}
3528		return x instanceof $WeakMap; // core-js workaround, pre-v3
3529	} catch (e) {}
3530	return false;
3531};
3532
3533},{}],54:[function(require,module,exports){
3534'use strict';
3535
3536var GetIntrinsic = require('get-intrinsic');
3537var callBound = require('call-bind/callBound');
3538
3539var $WeakSet = GetIntrinsic('%WeakSet%', true);
3540
3541var $setHas = callBound('WeakSet.prototype.has', true);
3542
3543if ($setHas) {
3544	var $mapHas = callBound('WeakMap.prototype.has', true);
3545
3546	module.exports = function isWeakSet(x) {
3547		if (!x || typeof x !== 'object') {
3548			return false;
3549		}
3550		try {
3551			$setHas(x, $setHas);
3552			if ($mapHas) {
3553				try {
3554					$mapHas(x, $mapHas);
3555				} catch (e) {
3556					return true;
3557				}
3558			}
3559			return x instanceof $WeakSet; // core-js workaround, pre-v3
3560		} catch (e) {}
3561		return false;
3562	};
3563} else {
3564	// eslint-disable-next-line no-unused-vars
3565	module.exports = function isWeakSet(x) {
3566		// `WeakSet` does not exist, or does not have a `has` method
3567		return false;
3568	};
3569}
3570
3571},{"call-bind/callBound":10,"get-intrinsic":33}],55:[function(require,module,exports){
3572var toString = {}.toString;
3573
3574module.exports = Array.isArray || function (arr) {
3575  return toString.call(arr) == '[object Array]';
3576};
3577
3578},{}],56:[function(require,module,exports){
3579var hasMap = typeof Map === 'function' && Map.prototype;
3580var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
3581var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
3582var mapForEach = hasMap && Map.prototype.forEach;
3583var hasSet = typeof Set === 'function' && Set.prototype;
3584var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
3585var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
3586var setForEach = hasSet && Set.prototype.forEach;
3587var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
3588var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
3589var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
3590var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
3591var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
3592var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
3593var booleanValueOf = Boolean.prototype.valueOf;
3594var objectToString = Object.prototype.toString;
3595var functionToString = Function.prototype.toString;
3596var $match = String.prototype.match;
3597var $slice = String.prototype.slice;
3598var $replace = String.prototype.replace;
3599var $toUpperCase = String.prototype.toUpperCase;
3600var $toLowerCase = String.prototype.toLowerCase;
3601var $test = RegExp.prototype.test;
3602var $concat = Array.prototype.concat;
3603var $join = Array.prototype.join;
3604var $arrSlice = Array.prototype.slice;
3605var $floor = Math.floor;
3606var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
3607var gOPS = Object.getOwnPropertySymbols;
3608var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
3609var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';
3610// ie, `has-tostringtag/shams
3611var toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')
3612    ? Symbol.toStringTag
3613    : null;
3614var isEnumerable = Object.prototype.propertyIsEnumerable;
3615
3616var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (
3617    [].__proto__ === Array.prototype // eslint-disable-line no-proto
3618        ? function (O) {
3619            return O.__proto__; // eslint-disable-line no-proto
3620        }
3621        : null
3622);
3623
3624function addNumericSeparator(num, str) {
3625    if (
3626        num === Infinity
3627        || num === -Infinity
3628        || num !== num
3629        || (num && num > -1000 && num < 1000)
3630        || $test.call(/e/, str)
3631    ) {
3632        return str;
3633    }
3634    var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
3635    if (typeof num === 'number') {
3636        var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
3637        if (int !== num) {
3638            var intStr = String(int);
3639            var dec = $slice.call(str, intStr.length + 1);
3640            return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');
3641        }
3642    }
3643    return $replace.call(str, sepRegex, '$&_');
3644}
3645
3646var utilInspect = require('./util.inspect');
3647var inspectCustom = utilInspect.custom;
3648var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
3649
3650module.exports = function inspect_(obj, options, depth, seen) {
3651    var opts = options || {};
3652
3653    if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
3654        throw new TypeError('option "quoteStyle" must be "single" or "double"');
3655    }
3656    if (
3657        has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
3658            ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
3659            : opts.maxStringLength !== null
3660        )
3661    ) {
3662        throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
3663    }
3664    var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;
3665    if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
3666        throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`');
3667    }
3668
3669    if (
3670        has(opts, 'indent')
3671        && opts.indent !== null
3672        && opts.indent !== '\t'
3673        && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
3674    ) {
3675        throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
3676    }
3677    if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {
3678        throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
3679    }
3680    var numericSeparator = opts.numericSeparator;
3681
3682    if (typeof obj === 'undefined') {
3683        return 'undefined';
3684    }
3685    if (obj === null) {
3686        return 'null';
3687    }
3688    if (typeof obj === 'boolean') {
3689        return obj ? 'true' : 'false';
3690    }
3691
3692    if (typeof obj === 'string') {
3693        return inspectString(obj, opts);
3694    }
3695    if (typeof obj === 'number') {
3696        if (obj === 0) {
3697            return Infinity / obj > 0 ? '0' : '-0';
3698        }
3699        var str = String(obj);
3700        return numericSeparator ? addNumericSeparator(obj, str) : str;
3701    }
3702    if (typeof obj === 'bigint') {
3703        var bigIntStr = String(obj) + 'n';
3704        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
3705    }
3706
3707    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
3708    if (typeof depth === 'undefined') { depth = 0; }
3709    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
3710        return isArray(obj) ? '[Array]' : '[Object]';
3711    }
3712
3713    var indent = getIndent(opts, depth);
3714
3715    if (typeof seen === 'undefined') {
3716        seen = [];
3717    } else if (indexOf(seen, obj) >= 0) {
3718        return '[Circular]';
3719    }
3720
3721    function inspect(value, from, noIndent) {
3722        if (from) {
3723            seen = $arrSlice.call(seen);
3724            seen.push(from);
3725        }
3726        if (noIndent) {
3727            var newOpts = {
3728                depth: opts.depth
3729            };
3730            if (has(opts, 'quoteStyle')) {
3731                newOpts.quoteStyle = opts.quoteStyle;
3732            }
3733            return inspect_(value, newOpts, depth + 1, seen);
3734        }
3735        return inspect_(value, opts, depth + 1, seen);
3736    }
3737
3738    if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable
3739        var name = nameOf(obj);
3740        var keys = arrObjKeys(obj, inspect);
3741        return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');
3742    }
3743    if (isSymbol(obj)) {
3744        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, '$1') : symToString.call(obj);
3745        return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;
3746    }
3747    if (isElement(obj)) {
3748        var s = '<' + $toLowerCase.call(String(obj.nodeName));
3749        var attrs = obj.attributes || [];
3750        for (var i = 0; i < attrs.length; i++) {
3751            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
3752        }
3753        s += '>';
3754        if (obj.childNodes && obj.childNodes.length) { s += '...'; }
3755        s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';
3756        return s;
3757    }
3758    if (isArray(obj)) {
3759        if (obj.length === 0) { return '[]'; }
3760        var xs = arrObjKeys(obj, inspect);
3761        if (indent && !singleLineValues(xs)) {
3762            return '[' + indentedJoin(xs, indent) + ']';
3763        }
3764        return '[ ' + $join.call(xs, ', ') + ' ]';
3765    }
3766    if (isError(obj)) {
3767        var parts = arrObjKeys(obj, inspect);
3768        if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) {
3769            return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';
3770        }
3771        if (parts.length === 0) { return '[' + String(obj) + ']'; }
3772        return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';
3773    }
3774    if (typeof obj === 'object' && customInspect) {
3775        if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) {
3776            return utilInspect(obj, { depth: maxDepth - depth });
3777        } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {
3778            return obj.inspect();
3779        }
3780    }
3781    if (isMap(obj)) {
3782        var mapParts = [];
3783        mapForEach.call(obj, function (value, key) {
3784            mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
3785        });
3786        return collectionOf('Map', mapSize.call(obj), mapParts, indent);
3787    }
3788    if (isSet(obj)) {
3789        var setParts = [];
3790        setForEach.call(obj, function (value) {
3791            setParts.push(inspect(value, obj));
3792        });
3793        return collectionOf('Set', setSize.call(obj), setParts, indent);
3794    }
3795    if (isWeakMap(obj)) {
3796        return weakCollectionOf('WeakMap');
3797    }
3798    if (isWeakSet(obj)) {
3799        return weakCollectionOf('WeakSet');
3800    }
3801    if (isWeakRef(obj)) {
3802        return weakCollectionOf('WeakRef');
3803    }
3804    if (isNumber(obj)) {
3805        return markBoxed(inspect(Number(obj)));
3806    }
3807    if (isBigInt(obj)) {
3808        return markBoxed(inspect(bigIntValueOf.call(obj)));
3809    }
3810    if (isBoolean(obj)) {
3811        return markBoxed(booleanValueOf.call(obj));
3812    }
3813    if (isString(obj)) {
3814        return markBoxed(inspect(String(obj)));
3815    }
3816    if (!isDate(obj) && !isRegExp(obj)) {
3817        var ys = arrObjKeys(obj, inspect);
3818        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
3819        var protoTag = obj instanceof Object ? '' : 'null prototype';
3820        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';
3821        var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
3822        var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');
3823        if (ys.length === 0) { return tag + '{}'; }
3824        if (indent) {
3825            return tag + '{' + indentedJoin(ys, indent) + '}';
3826        }
3827        return tag + '{ ' + $join.call(ys, ', ') + ' }';
3828    }
3829    return String(obj);
3830};
3831
3832function wrapQuotes(s, defaultStyle, opts) {
3833    var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
3834    return quoteChar + s + quoteChar;
3835}
3836
3837function quote(s) {
3838    return $replace.call(String(s), /"/g, '&quot;');
3839}
3840
3841function isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3842function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3843function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3844function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3845function isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3846function isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3847function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
3848
3849// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
3850function isSymbol(obj) {
3851    if (hasShammedSymbols) {
3852        return obj && typeof obj === 'object' && obj instanceof Symbol;
3853    }
3854    if (typeof obj === 'symbol') {
3855        return true;
3856    }
3857    if (!obj || typeof obj !== 'object' || !symToString) {
3858        return false;
3859    }
3860    try {
3861        symToString.call(obj);
3862        return true;
3863    } catch (e) {}
3864    return false;
3865}
3866
3867function isBigInt(obj) {
3868    if (!obj || typeof obj !== 'object' || !bigIntValueOf) {
3869        return false;
3870    }
3871    try {
3872        bigIntValueOf.call(obj);
3873        return true;
3874    } catch (e) {}
3875    return false;
3876}
3877
3878var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
3879function has(obj, key) {
3880    return hasOwn.call(obj, key);
3881}
3882
3883function toStr(obj) {
3884    return objectToString.call(obj);
3885}
3886
3887function nameOf(f) {
3888    if (f.name) { return f.name; }
3889    var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
3890    if (m) { return m[1]; }
3891    return null;
3892}
3893
3894function indexOf(xs, x) {
3895    if (xs.indexOf) { return xs.indexOf(x); }
3896    for (var i = 0, l = xs.length; i < l; i++) {
3897        if (xs[i] === x) { return i; }
3898    }
3899    return -1;
3900}
3901
3902function isMap(x) {
3903    if (!mapSize || !x || typeof x !== 'object') {
3904        return false;
3905    }
3906    try {
3907        mapSize.call(x);
3908        try {
3909            setSize.call(x);
3910        } catch (s) {
3911            return true;
3912        }
3913        return x instanceof Map; // core-js workaround, pre-v2.5.0
3914    } catch (e) {}
3915    return false;
3916}
3917
3918function isWeakMap(x) {
3919    if (!weakMapHas || !x || typeof x !== 'object') {
3920        return false;
3921    }
3922    try {
3923        weakMapHas.call(x, weakMapHas);
3924        try {
3925            weakSetHas.call(x, weakSetHas);
3926        } catch (s) {
3927            return true;
3928        }
3929        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
3930    } catch (e) {}
3931    return false;
3932}
3933
3934function isWeakRef(x) {
3935    if (!weakRefDeref || !x || typeof x !== 'object') {
3936        return false;
3937    }
3938    try {
3939        weakRefDeref.call(x);
3940        return true;
3941    } catch (e) {}
3942    return false;
3943}
3944
3945function isSet(x) {
3946    if (!setSize || !x || typeof x !== 'object') {
3947        return false;
3948    }
3949    try {
3950        setSize.call(x);
3951        try {
3952            mapSize.call(x);
3953        } catch (m) {
3954            return true;
3955        }
3956        return x instanceof Set; // core-js workaround, pre-v2.5.0
3957    } catch (e) {}
3958    return false;
3959}
3960
3961function isWeakSet(x) {
3962    if (!weakSetHas || !x || typeof x !== 'object') {
3963        return false;
3964    }
3965    try {
3966        weakSetHas.call(x, weakSetHas);
3967        try {
3968            weakMapHas.call(x, weakMapHas);
3969        } catch (s) {
3970            return true;
3971        }
3972        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
3973    } catch (e) {}
3974    return false;
3975}
3976
3977function isElement(x) {
3978    if (!x || typeof x !== 'object') { return false; }
3979    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
3980        return true;
3981    }
3982    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
3983}
3984
3985function inspectString(str, opts) {
3986    if (str.length > opts.maxStringLength) {
3987        var remaining = str.length - opts.maxStringLength;
3988        var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
3989        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
3990    }
3991    // eslint-disable-next-line no-control-regex
3992    var s = $replace.call($replace.call(str, /(['\\])/g, '\\$1'), /[\x00-\x1f]/g, lowbyte);
3993    return wrapQuotes(s, 'single', opts);
3994}
3995
3996function lowbyte(c) {
3997    var n = c.charCodeAt(0);
3998    var x = {
3999        8: 'b',
4000        9: 't',
4001        10: 'n',
4002        12: 'f',
4003        13: 'r'
4004    }[n];
4005    if (x) { return '\\' + x; }
4006    return '\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));
4007}
4008
4009function markBoxed(str) {
4010    return 'Object(' + str + ')';
4011}
4012
4013function weakCollectionOf(type) {
4014    return type + ' { ? }';
4015}
4016
4017function collectionOf(type, size, entries, indent) {
4018    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');
4019    return type + ' (' + size + ') {' + joinedEntries + '}';
4020}
4021
4022function singleLineValues(xs) {
4023    for (var i = 0; i < xs.length; i++) {
4024        if (indexOf(xs[i], '\n') >= 0) {
4025            return false;
4026        }
4027    }
4028    return true;
4029}
4030
4031function getIndent(opts, depth) {
4032    var baseIndent;
4033    if (opts.indent === '\t') {
4034        baseIndent = '\t';
4035    } else if (typeof opts.indent === 'number' && opts.indent > 0) {
4036        baseIndent = $join.call(Array(opts.indent + 1), ' ');
4037    } else {
4038        return null;
4039    }
4040    return {
4041        base: baseIndent,
4042        prev: $join.call(Array(depth + 1), baseIndent)
4043    };
4044}
4045
4046function indentedJoin(xs, indent) {
4047    if (xs.length === 0) { return ''; }
4048    var lineJoiner = '\n' + indent.prev + indent.base;
4049    return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev;
4050}
4051
4052function arrObjKeys(obj, inspect) {
4053    var isArr = isArray(obj);
4054    var xs = [];
4055    if (isArr) {
4056        xs.length = obj.length;
4057        for (var i = 0; i < obj.length; i++) {
4058            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
4059        }
4060    }
4061    var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
4062    var symMap;
4063    if (hasShammedSymbols) {
4064        symMap = {};
4065        for (var k = 0; k < syms.length; k++) {
4066            symMap['$' + syms[k]] = syms[k];
4067        }
4068    }
4069
4070    for (var key in obj) { // eslint-disable-line no-restricted-syntax
4071        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
4072        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
4073        if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
4074            // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
4075            continue; // eslint-disable-line no-restricted-syntax, no-continue
4076        } else if ($test.call(/[^\w$]/, key)) {
4077            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
4078        } else {
4079            xs.push(key + ': ' + inspect(obj[key], obj));
4080        }
4081    }
4082    if (typeof gOPS === 'function') {
4083        for (var j = 0; j < syms.length; j++) {
4084            if (isEnumerable.call(obj, syms[j])) {
4085                xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
4086            }
4087        }
4088    }
4089    return xs;
4090}
4091
4092},{"./util.inspect":57}],57:[function(require,module,exports){
4093module.exports = require('util').inspect;
4094
4095},{"util":102}],58:[function(require,module,exports){
4096'use strict';
4097
4098var numberIsNaN = function (value) {
4099	return value !== value;
4100};
4101
4102module.exports = function is(a, b) {
4103	if (a === 0 && b === 0) {
4104		return 1 / a === 1 / b;
4105	}
4106	if (a === b) {
4107		return true;
4108	}
4109	if (numberIsNaN(a) && numberIsNaN(b)) {
4110		return true;
4111	}
4112	return false;
4113};
4114
4115
4116},{}],59:[function(require,module,exports){
4117'use strict';
4118
4119var define = require('define-properties');
4120var callBind = require('call-bind');
4121
4122var implementation = require('./implementation');
4123var getPolyfill = require('./polyfill');
4124var shim = require('./shim');
4125
4126var polyfill = callBind(getPolyfill(), Object);
4127
4128define(polyfill, {
4129	getPolyfill: getPolyfill,
4130	implementation: implementation,
4131	shim: shim
4132});
4133
4134module.exports = polyfill;
4135
4136},{"./implementation":58,"./polyfill":60,"./shim":61,"call-bind":11,"define-properties":13}],60:[function(require,module,exports){
4137'use strict';
4138
4139var implementation = require('./implementation');
4140
4141module.exports = function getPolyfill() {
4142	return typeof Object.is === 'function' ? Object.is : implementation;
4143};
4144
4145},{"./implementation":58}],61:[function(require,module,exports){
4146'use strict';
4147
4148var getPolyfill = require('./polyfill');
4149var define = require('define-properties');
4150
4151module.exports = function shimObjectIs() {
4152	var polyfill = getPolyfill();
4153	define(Object, { is: polyfill }, {
4154		is: function testObjectIs() {
4155			return Object.is !== polyfill;
4156		}
4157	});
4158	return polyfill;
4159};
4160
4161},{"./polyfill":60,"define-properties":13}],62:[function(require,module,exports){
4162'use strict';
4163
4164var keysShim;
4165if (!Object.keys) {
4166	// modified from https://github.com/es-shims/es5-shim
4167	var has = Object.prototype.hasOwnProperty;
4168	var toStr = Object.prototype.toString;
4169	var isArgs = require('./isArguments'); // eslint-disable-line global-require
4170	var isEnumerable = Object.prototype.propertyIsEnumerable;
4171	var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
4172	var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
4173	var dontEnums = [
4174		'toString',
4175		'toLocaleString',
4176		'valueOf',
4177		'hasOwnProperty',
4178		'isPrototypeOf',
4179		'propertyIsEnumerable',
4180		'constructor'
4181	];
4182	var equalsConstructorPrototype = function (o) {
4183		var ctor = o.constructor;
4184		return ctor && ctor.prototype === o;
4185	};
4186	var excludedKeys = {
4187		$applicationCache: true,
4188		$console: true,
4189		$external: true,
4190		$frame: true,
4191		$frameElement: true,
4192		$frames: true,
4193		$innerHeight: true,
4194		$innerWidth: true,
4195		$onmozfullscreenchange: true,
4196		$onmozfullscreenerror: true,
4197		$outerHeight: true,
4198		$outerWidth: true,
4199		$pageXOffset: true,
4200		$pageYOffset: true,
4201		$parent: true,
4202		$scrollLeft: true,
4203		$scrollTop: true,
4204		$scrollX: true,
4205		$scrollY: true,
4206		$self: true,
4207		$webkitIndexedDB: true,
4208		$webkitStorageInfo: true,
4209		$window: true
4210	};
4211	var hasAutomationEqualityBug = (function () {
4212		/* global window */
4213		if (typeof window === 'undefined') { return false; }
4214		for (var k in window) {
4215			try {
4216				if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
4217					try {
4218						equalsConstructorPrototype(window[k]);
4219					} catch (e) {
4220						return true;
4221					}
4222				}
4223			} catch (e) {
4224				return true;
4225			}
4226		}
4227		return false;
4228	}());
4229	var equalsConstructorPrototypeIfNotBuggy = function (o) {
4230		/* global window */
4231		if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
4232			return equalsConstructorPrototype(o);
4233		}
4234		try {
4235			return equalsConstructorPrototype(o);
4236		} catch (e) {
4237			return false;
4238		}
4239	};
4240
4241	keysShim = function keys(object) {
4242		var isObject = object !== null && typeof object === 'object';
4243		var isFunction = toStr.call(object) === '[object Function]';
4244		var isArguments = isArgs(object);
4245		var isString = isObject && toStr.call(object) === '[object String]';
4246		var theKeys = [];
4247
4248		if (!isObject && !isFunction && !isArguments) {
4249			throw new TypeError('Object.keys called on a non-object');
4250		}
4251
4252		var skipProto = hasProtoEnumBug && isFunction;
4253		if (isString && object.length > 0 && !has.call(object, 0)) {
4254			for (var i = 0; i < object.length; ++i) {
4255				theKeys.push(String(i));
4256			}
4257		}
4258
4259		if (isArguments && object.length > 0) {
4260			for (var j = 0; j < object.length; ++j) {
4261				theKeys.push(String(j));
4262			}
4263		} else {
4264			for (var name in object) {
4265				if (!(skipProto && name === 'prototype') && has.call(object, name)) {
4266					theKeys.push(String(name));
4267				}
4268			}
4269		}
4270
4271		if (hasDontEnumBug) {
4272			var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
4273
4274			for (var k = 0; k < dontEnums.length; ++k) {
4275				if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
4276					theKeys.push(dontEnums[k]);
4277				}
4278			}
4279		}
4280		return theKeys;
4281	};
4282}
4283module.exports = keysShim;
4284
4285},{"./isArguments":64}],63:[function(require,module,exports){
4286'use strict';
4287
4288var slice = Array.prototype.slice;
4289var isArgs = require('./isArguments');
4290
4291var origKeys = Object.keys;
4292var keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');
4293
4294var originalKeys = Object.keys;
4295
4296keysShim.shim = function shimObjectKeys() {
4297	if (Object.keys) {
4298		var keysWorksWithArguments = (function () {
4299			// Safari 5.0 bug
4300			var args = Object.keys(arguments);
4301			return args && args.length === arguments.length;
4302		}(1, 2));
4303		if (!keysWorksWithArguments) {
4304			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
4305				if (isArgs(object)) {
4306					return originalKeys(slice.call(object));
4307				}
4308				return originalKeys(object);
4309			};
4310		}
4311	} else {
4312		Object.keys = keysShim;
4313	}
4314	return Object.keys || keysShim;
4315};
4316
4317module.exports = keysShim;
4318
4319},{"./implementation":62,"./isArguments":64}],64:[function(require,module,exports){
4320'use strict';
4321
4322var toStr = Object.prototype.toString;
4323
4324module.exports = function isArguments(value) {
4325	var str = toStr.call(value);
4326	var isArgs = str === '[object Arguments]';
4327	if (!isArgs) {
4328		isArgs = str !== '[object Array]' &&
4329			value !== null &&
4330			typeof value === 'object' &&
4331			typeof value.length === 'number' &&
4332			value.length >= 0 &&
4333			toStr.call(value.callee) === '[object Function]';
4334	}
4335	return isArgs;
4336};
4337
4338},{}],65:[function(require,module,exports){
4339'use strict';
4340
4341// modified from https://github.com/es-shims/es6-shim
4342var objectKeys = require('object-keys');
4343var hasSymbols = require('has-symbols/shams')();
4344var callBound = require('call-bind/callBound');
4345var toObject = Object;
4346var $push = callBound('Array.prototype.push');
4347var $propIsEnumerable = callBound('Object.prototype.propertyIsEnumerable');
4348var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;
4349
4350// eslint-disable-next-line no-unused-vars
4351module.exports = function assign(target, source1) {
4352	if (target == null) { throw new TypeError('target must be an object'); }
4353	var to = toObject(target); // step 1
4354	if (arguments.length === 1) {
4355		return to; // step 2
4356	}
4357	for (var s = 1; s < arguments.length; ++s) {
4358		var from = toObject(arguments[s]); // step 3.a.i
4359
4360		// step 3.a.ii:
4361		var keys = objectKeys(from);
4362		var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols);
4363		if (getSymbols) {
4364			var syms = getSymbols(from);
4365			for (var j = 0; j < syms.length; ++j) {
4366				var key = syms[j];
4367				if ($propIsEnumerable(from, key)) {
4368					$push(keys, key);
4369				}
4370			}
4371		}
4372
4373		// step 3.a.iii:
4374		for (var i = 0; i < keys.length; ++i) {
4375			var nextKey = keys[i];
4376			if ($propIsEnumerable(from, nextKey)) { // step 3.a.iii.2
4377				var propValue = from[nextKey]; // step 3.a.iii.2.a
4378				to[nextKey] = propValue; // step 3.a.iii.2.b
4379			}
4380		}
4381	}
4382
4383	return to; // step 4
4384};
4385
4386},{"call-bind/callBound":10,"has-symbols/shams":37,"object-keys":63}],66:[function(require,module,exports){
4387'use strict';
4388
4389var defineProperties = require('define-properties');
4390var callBind = require('call-bind');
4391
4392var implementation = require('./implementation');
4393var getPolyfill = require('./polyfill');
4394var shim = require('./shim');
4395
4396var polyfill = callBind.apply(getPolyfill());
4397// eslint-disable-next-line no-unused-vars
4398var bound = function assign(target, source1) {
4399	return polyfill(Object, arguments);
4400};
4401
4402defineProperties(bound, {
4403	getPolyfill: getPolyfill,
4404	implementation: implementation,
4405	shim: shim
4406});
4407
4408module.exports = bound;
4409
4410},{"./implementation":65,"./polyfill":67,"./shim":68,"call-bind":11,"define-properties":13}],67:[function(require,module,exports){
4411'use strict';
4412
4413var implementation = require('./implementation');
4414
4415var lacksProperEnumerationOrder = function () {
4416	if (!Object.assign) {
4417		return false;
4418	}
4419	/*
4420	 * v8, specifically in node 4.x, has a bug with incorrect property enumeration order
4421	 * note: this does not detect the bug unless there's 20 characters
4422	 */
4423	var str = 'abcdefghijklmnopqrst';
4424	var letters = str.split('');
4425	var map = {};
4426	for (var i = 0; i < letters.length; ++i) {
4427		map[letters[i]] = letters[i];
4428	}
4429	var obj = Object.assign({}, map);
4430	var actual = '';
4431	for (var k in obj) {
4432		actual += k;
4433	}
4434	return str !== actual;
4435};
4436
4437var assignHasPendingExceptions = function () {
4438	if (!Object.assign || !Object.preventExtensions) {
4439		return false;
4440	}
4441	/*
4442	 * Firefox 37 still has "pending exception" logic in its Object.assign implementation,
4443	 * which is 72% slower than our shim, and Firefox 40's native implementation.
4444	 */
4445	var thrower = Object.preventExtensions({ 1: 2 });
4446	try {
4447		Object.assign(thrower, 'xy');
4448	} catch (e) {
4449		return thrower[1] === 'y';
4450	}
4451	return false;
4452};
4453
4454module.exports = function getPolyfill() {
4455	if (!Object.assign) {
4456		return implementation;
4457	}
4458	if (lacksProperEnumerationOrder()) {
4459		return implementation;
4460	}
4461	if (assignHasPendingExceptions()) {
4462		return implementation;
4463	}
4464	return Object.assign;
4465};
4466
4467},{"./implementation":65}],68:[function(require,module,exports){
4468'use strict';
4469
4470var define = require('define-properties');
4471var getPolyfill = require('./polyfill');
4472
4473module.exports = function shimAssign() {
4474	var polyfill = getPolyfill();
4475	define(
4476		Object,
4477		{ assign: polyfill },
4478		{ assign: function () { return Object.assign !== polyfill; } }
4479	);
4480	return polyfill;
4481};
4482
4483},{"./polyfill":67,"define-properties":13}],69:[function(require,module,exports){
4484'use strict';
4485
4486var functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames();
4487
4488var $Object = Object;
4489var $TypeError = TypeError;
4490
4491module.exports = function flags() {
4492	if (this != null && this !== $Object(this)) {
4493		throw new $TypeError('RegExp.prototype.flags getter called on non-object');
4494	}
4495	var result = '';
4496	if (this.hasIndices) {
4497		result += 'd';
4498	}
4499	if (this.global) {
4500		result += 'g';
4501	}
4502	if (this.ignoreCase) {
4503		result += 'i';
4504	}
4505	if (this.multiline) {
4506		result += 'm';
4507	}
4508	if (this.dotAll) {
4509		result += 's';
4510	}
4511	if (this.unicode) {
4512		result += 'u';
4513	}
4514	if (this.sticky) {
4515		result += 'y';
4516	}
4517	return result;
4518};
4519
4520if (functionsHaveConfigurableNames && Object.defineProperty) {
4521	Object.defineProperty(module.exports, 'name', { value: 'get flags' });
4522}
4523
4524},{"functions-have-names":32}],70:[function(require,module,exports){
4525'use strict';
4526
4527var define = require('define-properties');
4528var callBind = require('call-bind');
4529
4530var implementation = require('./implementation');
4531var getPolyfill = require('./polyfill');
4532var shim = require('./shim');
4533
4534var flagsBound = callBind(getPolyfill());
4535
4536define(flagsBound, {
4537	getPolyfill: getPolyfill,
4538	implementation: implementation,
4539	shim: shim
4540});
4541
4542module.exports = flagsBound;
4543
4544},{"./implementation":69,"./polyfill":71,"./shim":72,"call-bind":11,"define-properties":13}],71:[function(require,module,exports){
4545'use strict';
4546
4547var implementation = require('./implementation');
4548
4549var supportsDescriptors = require('define-properties').supportsDescriptors;
4550var $gOPD = Object.getOwnPropertyDescriptor;
4551
4552module.exports = function getPolyfill() {
4553	if (supportsDescriptors && (/a/mig).flags === 'gim') {
4554		var descriptor = $gOPD(RegExp.prototype, 'flags');
4555		if (
4556			descriptor
4557			&& typeof descriptor.get === 'function'
4558			&& typeof RegExp.prototype.dotAll === 'boolean'
4559			&& typeof RegExp.prototype.hasIndices === 'boolean'
4560		) {
4561			/* eslint getter-return: 0 */
4562			var calls = '';
4563			var o = {};
4564			Object.defineProperty(o, 'hasIndices', {
4565				get: function () {
4566					calls += 'd';
4567				}
4568			});
4569			Object.defineProperty(o, 'sticky', {
4570				get: function () {
4571					calls += 'y';
4572				}
4573			});
4574			if (calls === 'dy') {
4575				return descriptor.get;
4576			}
4577		}
4578	}
4579	return implementation;
4580};
4581
4582},{"./implementation":69,"define-properties":13}],72:[function(require,module,exports){
4583'use strict';
4584
4585var supportsDescriptors = require('define-properties').supportsDescriptors;
4586var getPolyfill = require('./polyfill');
4587var gOPD = Object.getOwnPropertyDescriptor;
4588var defineProperty = Object.defineProperty;
4589var TypeErr = TypeError;
4590var getProto = Object.getPrototypeOf;
4591var regex = /a/;
4592
4593module.exports = function shimFlags() {
4594	if (!supportsDescriptors || !getProto) {
4595		throw new TypeErr('RegExp.prototype.flags requires a true ES5 environment that supports property descriptors');
4596	}
4597	var polyfill = getPolyfill();
4598	var proto = getProto(regex);
4599	var descriptor = gOPD(proto, 'flags');
4600	if (!descriptor || descriptor.get !== polyfill) {
4601		defineProperty(proto, 'flags', {
4602			configurable: true,
4603			enumerable: false,
4604			get: polyfill
4605		});
4606	}
4607	return polyfill;
4608};
4609
4610},{"./polyfill":71,"define-properties":13}],73:[function(require,module,exports){
4611(function (process){
4612var through = require('through');
4613var nextTick = typeof setImmediate !== 'undefined'
4614    ? setImmediate
4615    : process.nextTick
4616;
4617
4618module.exports = function (write, end) {
4619    var tr = through(write, end);
4620    tr.pause();
4621    var resume = tr.resume;
4622    var pause = tr.pause;
4623    var paused = false;
4624    
4625    tr.pause = function () {
4626        paused = true;
4627        return pause.apply(this, arguments);
4628    };
4629    
4630    tr.resume = function () {
4631        paused = false;
4632        return resume.apply(this, arguments);
4633    };
4634    
4635    nextTick(function () {
4636        if (!paused) tr.resume();
4637    });
4638    
4639    return tr;
4640};
4641
4642}).call(this,require("KliubH"))
4643},{"KliubH":91,"through":79}],74:[function(require,module,exports){
4644'use strict';
4645
4646var GetIntrinsic = require('get-intrinsic');
4647var callBound = require('call-bind/callBound');
4648var inspect = require('object-inspect');
4649
4650var $TypeError = GetIntrinsic('%TypeError%');
4651var $WeakMap = GetIntrinsic('%WeakMap%', true);
4652var $Map = GetIntrinsic('%Map%', true);
4653
4654var $weakMapGet = callBound('WeakMap.prototype.get', true);
4655var $weakMapSet = callBound('WeakMap.prototype.set', true);
4656var $weakMapHas = callBound('WeakMap.prototype.has', true);
4657var $mapGet = callBound('Map.prototype.get', true);
4658var $mapSet = callBound('Map.prototype.set', true);
4659var $mapHas = callBound('Map.prototype.has', true);
4660
4661/*
4662 * This function traverses the list returning the node corresponding to the
4663 * given key.
4664 *
4665 * That node is also moved to the head of the list, so that if it's accessed
4666 * again we don't need to traverse the whole list. By doing so, all the recently
4667 * used nodes can be accessed relatively quickly.
4668 */
4669var listGetNode = function (list, key) { // eslint-disable-line consistent-return
4670	for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
4671		if (curr.key === key) {
4672			prev.next = curr.next;
4673			curr.next = list.next;
4674			list.next = curr; // eslint-disable-line no-param-reassign
4675			return curr;
4676		}
4677	}
4678};
4679
4680var listGet = function (objects, key) {
4681	var node = listGetNode(objects, key);
4682	return node && node.value;
4683};
4684var listSet = function (objects, key, value) {
4685	var node = listGetNode(objects, key);
4686	if (node) {
4687		node.value = value;
4688	} else {
4689		// Prepend the new node to the beginning of the list
4690		objects.next = { // eslint-disable-line no-param-reassign
4691			key: key,
4692			next: objects.next,
4693			value: value
4694		};
4695	}
4696};
4697var listHas = function (objects, key) {
4698	return !!listGetNode(objects, key);
4699};
4700
4701module.exports = function getSideChannel() {
4702	var $wm;
4703	var $m;
4704	var $o;
4705	var channel = {
4706		assert: function (key) {
4707			if (!channel.has(key)) {
4708				throw new $TypeError('Side channel does not contain ' + inspect(key));
4709			}
4710		},
4711		get: function (key) { // eslint-disable-line consistent-return
4712			if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
4713				if ($wm) {
4714					return $weakMapGet($wm, key);
4715				}
4716			} else if ($Map) {
4717				if ($m) {
4718					return $mapGet($m, key);
4719				}
4720			} else {
4721				if ($o) { // eslint-disable-line no-lonely-if
4722					return listGet($o, key);
4723				}
4724			}
4725		},
4726		has: function (key) {
4727			if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
4728				if ($wm) {
4729					return $weakMapHas($wm, key);
4730				}
4731			} else if ($Map) {
4732				if ($m) {
4733					return $mapHas($m, key);
4734				}
4735			} else {
4736				if ($o) { // eslint-disable-line no-lonely-if
4737					return listHas($o, key);
4738				}
4739			}
4740			return false;
4741		},
4742		set: function (key, value) {
4743			if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
4744				if (!$wm) {
4745					$wm = new $WeakMap();
4746				}
4747				$weakMapSet($wm, key, value);
4748			} else if ($Map) {
4749				if (!$m) {
4750					$m = new $Map();
4751				}
4752				$mapSet($m, key, value);
4753			} else {
4754				if (!$o) {
4755					/*
4756					 * Initialize the linked list as an empty node, so that we don't have
4757					 * to special-case handling of the first node: we can always refer to
4758					 * it as (previous node).next, instead of something like (list).head
4759					 */
4760					$o = { key: {}, next: null };
4761				}
4762				listSet($o, key, value);
4763			}
4764		}
4765	};
4766	return channel;
4767};
4768
4769},{"call-bind/callBound":10,"get-intrinsic":33,"object-inspect":56}],75:[function(require,module,exports){
4770'use strict';
4771
4772var RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');
4773var ToString = require('es-abstract/2021/ToString');
4774var callBound = require('call-bind/callBound');
4775var $replace = callBound('String.prototype.replace');
4776
4777var mvsIsWS = (/^\s$/).test('\u180E');
4778/* eslint-disable no-control-regex */
4779var leftWhitespace = mvsIsWS
4780	? /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/
4781	: /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/;
4782var rightWhitespace = mvsIsWS
4783	? /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+$/
4784	: /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+$/;
4785/* eslint-enable no-control-regex */
4786
4787module.exports = function trim() {
4788	var S = ToString(RequireObjectCoercible(this));
4789	return $replace($replace(S, leftWhitespace, ''), rightWhitespace, '');
4790};
4791
4792},{"call-bind/callBound":10,"es-abstract/2021/RequireObjectCoercible":16,"es-abstract/2021/ToString":20}],76:[function(require,module,exports){
4793'use strict';
4794
4795var callBind = require('call-bind');
4796var define = require('define-properties');
4797var RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');
4798
4799var implementation = require('./implementation');
4800var getPolyfill = require('./polyfill');
4801var shim = require('./shim');
4802
4803var bound = callBind(getPolyfill());
4804var boundMethod = function trim(receiver) {
4805	RequireObjectCoercible(receiver);
4806	return bound(receiver);
4807};
4808
4809define(boundMethod, {
4810	getPolyfill: getPolyfill,
4811	implementation: implementation,
4812	shim: shim
4813});
4814
4815module.exports = boundMethod;
4816
4817},{"./implementation":75,"./polyfill":77,"./shim":78,"call-bind":11,"define-properties":13,"es-abstract/2021/RequireObjectCoercible":16}],77:[function(require,module,exports){
4818'use strict';
4819
4820var implementation = require('./implementation');
4821
4822var zeroWidthSpace = '\u200b';
4823var mongolianVowelSeparator = '\u180E';
4824
4825module.exports = function getPolyfill() {
4826	if (
4827		String.prototype.trim
4828		&& zeroWidthSpace.trim() === zeroWidthSpace
4829		&& mongolianVowelSeparator.trim() === mongolianVowelSeparator
4830		&& ('_' + mongolianVowelSeparator).trim() === ('_' + mongolianVowelSeparator)
4831		&& (mongolianVowelSeparator + '_').trim() === (mongolianVowelSeparator + '_')
4832	) {
4833		return String.prototype.trim;
4834	}
4835	return implementation;
4836};
4837
4838},{"./implementation":75}],78:[function(require,module,exports){
4839'use strict';
4840
4841var define = require('define-properties');
4842var getPolyfill = require('./polyfill');
4843
4844module.exports = function shimStringTrim() {
4845	var polyfill = getPolyfill();
4846	define(String.prototype, { trim: polyfill }, {
4847		trim: function testTrim() {
4848			return String.prototype.trim !== polyfill;
4849		}
4850	});
4851	return polyfill;
4852};
4853
4854},{"./polyfill":77,"define-properties":13}],79:[function(require,module,exports){
4855(function (process){
4856var Stream = require('stream')
4857
4858// through
4859//
4860// a stream that does nothing but re-emit the input.
4861// useful for aggregating a series of changing but not ending streams into one stream)
4862
4863exports = module.exports = through
4864through.through = through
4865
4866//create a readable writable stream.
4867
4868function through (write, end, opts) {
4869  write = write || function (data) { this.queue(data) }
4870  end = end || function () { this.queue(null) }
4871
4872  var ended = false, destroyed = false, buffer = [], _ended = false
4873  var stream = new Stream()
4874  stream.readable = stream.writable = true
4875  stream.paused = false
4876
4877//  stream.autoPause   = !(opts && opts.autoPause   === false)
4878  stream.autoDestroy = !(opts && opts.autoDestroy === false)
4879
4880  stream.write = function (data) {
4881    write.call(this, data)
4882    return !stream.paused
4883  }
4884
4885  function drain() {
4886    while(buffer.length && !stream.paused) {
4887      var data = buffer.shift()
4888      if(null === data)
4889        return stream.emit('end')
4890      else
4891        stream.emit('data', data)
4892    }
4893  }
4894
4895  stream.queue = stream.push = function (data) {
4896//    console.error(ended)
4897    if(_ended) return stream
4898    if(data === null) _ended = true
4899    buffer.push(data)
4900    drain()
4901    return stream
4902  }
4903
4904  //this will be registered as the first 'end' listener
4905  //must call destroy next tick, to make sure we're after any
4906  //stream piped from here.
4907  //this is only a problem if end is not emitted synchronously.
4908  //a nicer way to do this is to make sure this is the last listener for 'end'
4909
4910  stream.on('end', function () {
4911    stream.readable = false
4912    if(!stream.writable && stream.autoDestroy)
4913      process.nextTick(function () {
4914        stream.destroy()
4915      })
4916  })
4917
4918  function _end () {
4919    stream.writable = false
4920    end.call(stream)
4921    if(!stream.readable && stream.autoDestroy)
4922      stream.destroy()
4923  }
4924
4925  stream.end = function (data) {
4926    if(ended) return
4927    ended = true
4928    if(arguments.length) stream.write(data)
4929    _end() // will emit or queue
4930    return stream
4931  }
4932
4933  stream.destroy = function () {
4934    if(destroyed) return
4935    destroyed = true
4936    ended = true
4937    buffer.length = 0
4938    stream.writable = stream.readable = false
4939    stream.emit('close')
4940    return stream
4941  }
4942
4943  stream.pause = function () {
4944    if(stream.paused) return
4945    stream.paused = true
4946    return stream
4947  }
4948
4949  stream.resume = function () {
4950    if(stream.paused) {
4951      stream.paused = false
4952      stream.emit('resume')
4953    }
4954    drain()
4955    //may have become paused again,
4956    //as drain emits 'data'.
4957    if(!stream.paused)
4958      stream.emit('drain')
4959    return stream
4960  }
4961  return stream
4962}
4963
4964
4965}).call(this,require("KliubH"))
4966},{"KliubH":91,"stream":93}],80:[function(require,module,exports){
4967'use strict';
4968
4969var isString = require('is-string');
4970var isNumber = require('is-number-object');
4971var isBoolean = require('is-boolean-object');
4972var isSymbol = require('is-symbol');
4973var isBigInt = require('is-bigint');
4974
4975// eslint-disable-next-line consistent-return
4976module.exports = function whichBoxedPrimitive(value) {
4977	// eslint-disable-next-line eqeqeq
4978	if (value == null || (typeof value !== 'object' && typeof value !== 'function')) {
4979		return null;
4980	}
4981	if (isString(value)) {
4982		return 'String';
4983	}
4984	if (isNumber(value)) {
4985		return 'Number';
4986	}
4987	if (isBoolean(value)) {
4988		return 'Boolean';
4989	}
4990	if (isSymbol(value)) {
4991		return 'Symbol';
4992	}
4993	if (isBigInt(value)) {
4994		return 'BigInt';
4995	}
4996};
4997
4998},{"is-bigint":42,"is-boolean-object":43,"is-number-object":47,"is-string":50,"is-symbol":51}],81:[function(require,module,exports){
4999'use strict';
5000
5001var isMap = require('is-map');
5002var isSet = require('is-set');
5003var isWeakMap = require('is-weakmap');
5004var isWeakSet = require('is-weakset');
5005
5006module.exports = function whichCollection(value) {
5007	if (value && typeof value === 'object') {
5008		if (isMap(value)) {
5009			return 'Map';
5010		}
5011		if (isSet(value)) {
5012			return 'Set';
5013		}
5014		if (isWeakMap(value)) {
5015			return 'WeakMap';
5016		}
5017		if (isWeakSet(value)) {
5018			return 'WeakSet';
5019		}
5020	}
5021	return false;
5022};
5023
5024},{"is-map":46,"is-set":49,"is-weakmap":53,"is-weakset":54}],82:[function(require,module,exports){
5025(function (global){
5026'use strict';
5027
5028var forEach = require('for-each');
5029var availableTypedArrays = require('available-typed-arrays');
5030var callBound = require('call-bind/callBound');
5031
5032var $toString = callBound('Object.prototype.toString');
5033var hasToStringTag = require('has-tostringtag/shams')();
5034
5035var g = typeof globalThis === 'undefined' ? global : globalThis;
5036var typedArrays = availableTypedArrays();
5037
5038var $slice = callBound('String.prototype.slice');
5039var toStrTags = {};
5040var gOPD = require('es-abstract/helpers/getOwnPropertyDescriptor');
5041var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
5042if (hasToStringTag && gOPD && getPrototypeOf) {
5043	forEach(typedArrays, function (typedArray) {
5044		if (typeof g[typedArray] === 'function') {
5045			var arr = new g[typedArray]();
5046			if (Symbol.toStringTag in arr) {
5047				var proto = getPrototypeOf(arr);
5048				var descriptor = gOPD(proto, Symbol.toStringTag);
5049				if (!descriptor) {
5050					var superProto = getPrototypeOf(proto);
5051					descriptor = gOPD(superProto, Symbol.toStringTag);
5052				}
5053				toStrTags[typedArray] = descriptor.get;
5054			}
5055		}
5056	});
5057}
5058
5059var tryTypedArrays = function tryAllTypedArrays(value) {
5060	var foundName = false;
5061	forEach(toStrTags, function (getter, typedArray) {
5062		if (!foundName) {
5063			try {
5064				var name = getter.call(value);
5065				if (name === typedArray) {
5066					foundName = name;
5067				}
5068			} catch (e) {}
5069		}
5070	});
5071	return foundName;
5072};
5073
5074var isTypedArray = require('is-typed-array');
5075
5076module.exports = function whichTypedArray(value) {
5077	if (!isTypedArray(value)) { return false; }
5078	if (!hasToStringTag || !(Symbol.toStringTag in value)) { return $slice($toString(value), 8, -1); }
5079	return tryTypedArrays(value);
5080};
5081
5082}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
5083},{"available-typed-arrays":9,"call-bind/callBound":10,"es-abstract/helpers/getOwnPropertyDescriptor":23,"for-each":29,"has-tostringtag/shams":38,"is-typed-array":52}],83:[function(require,module,exports){
5084'use strict';
5085
5086var test = require('../../');
5087
5088test(function (t) {
5089	t.plan(4);
5090	t.ok(true);
5091	t.equal(3, 1 + 2);
5092	t.deepEqual([1, 2, [3, 4]], [1, 2, [3, 4]]);
5093	t.notDeepEqual([1, 2, [3, 4, 5]], [1, 2, [3, 4]]);
5094});
5095
5096},{"../../":1}],84:[function(require,module,exports){
5097var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
5098
5099;(function (exports) {
5100	'use strict';
5101
5102  var Arr = (typeof Uint8Array !== 'undefined')
5103    ? Uint8Array
5104    : Array
5105
5106	var PLUS   = '+'.charCodeAt(0)
5107	var SLASH  = '/'.charCodeAt(0)
5108	var NUMBER = '0'.charCodeAt(0)
5109	var LOWER  = 'a'.charCodeAt(0)
5110	var UPPER  = 'A'.charCodeAt(0)
5111	var PLUS_URL_SAFE = '-'.charCodeAt(0)
5112	var SLASH_URL_SAFE = '_'.charCodeAt(0)
5113
5114	function decode (elt) {
5115		var code = elt.charCodeAt(0)
5116		if (code === PLUS ||
5117		    code === PLUS_URL_SAFE)
5118			return 62 // '+'
5119		if (code === SLASH ||
5120		    code === SLASH_URL_SAFE)
5121			return 63 // '/'
5122		if (code < NUMBER)
5123			return -1 //no match
5124		if (code < NUMBER + 10)
5125			return code - NUMBER + 26 + 26
5126		if (code < UPPER + 26)
5127			return code - UPPER
5128		if (code < LOWER + 26)
5129			return code - LOWER + 26
5130	}
5131
5132	function b64ToByteArray (b64) {
5133		var i, j, l, tmp, placeHolders, arr
5134
5135		if (b64.length % 4 > 0) {
5136			throw new Error('Invalid string. Length must be a multiple of 4')
5137		}
5138
5139		// the number of equal signs (place holders)
5140		// if there are two placeholders, than the two characters before it
5141		// represent one byte
5142		// if there is only one, then the three characters before it represent 2 bytes
5143		// this is just a cheap hack to not do indexOf twice
5144		var len = b64.length
5145		placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
5146
5147		// base64 is 4/3 + up to two characters of the original data
5148		arr = new Arr(b64.length * 3 / 4 - placeHolders)
5149
5150		// if there are placeholders, only get up to the last complete 4 chars
5151		l = placeHolders > 0 ? b64.length - 4 : b64.length
5152
5153		var L = 0
5154
5155		function push (v) {
5156			arr[L++] = v
5157		}
5158
5159		for (i = 0, j = 0; i < l; i += 4, j += 3) {
5160			tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
5161			push((tmp & 0xFF0000) >> 16)
5162			push((tmp & 0xFF00) >> 8)
5163			push(tmp & 0xFF)
5164		}
5165
5166		if (placeHolders === 2) {
5167			tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
5168			push(tmp & 0xFF)
5169		} else if (placeHolders === 1) {
5170			tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
5171			push((tmp >> 8) & 0xFF)
5172			push(tmp & 0xFF)
5173		}
5174
5175		return arr
5176	}
5177
5178	function uint8ToBase64 (uint8) {
5179		var i,
5180			extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
5181			output = "",
5182			temp, length
5183
5184		function encode (num) {
5185			return lookup.charAt(num)
5186		}
5187
5188		function tripletToBase64 (num) {
5189			return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
5190		}
5191
5192		// go through the array every three bytes, we'll deal with trailing stuff later
5193		for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
5194			temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
5195			output += tripletToBase64(temp)
5196		}
5197
5198		// pad the end with zeros, but make sure to not forget the extra bytes
5199		switch (extraBytes) {
5200			case 1:
5201				temp = uint8[uint8.length - 1]
5202				output += encode(temp >> 2)
5203				output += encode((temp << 4) & 0x3F)
5204				output += '=='
5205				break
5206			case 2:
5207				temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
5208				output += encode(temp >> 10)
5209				output += encode((temp >> 4) & 0x3F)
5210				output += encode((temp << 2) & 0x3F)
5211				output += '='
5212				break
5213		}
5214
5215		return output
5216	}
5217
5218	exports.toByteArray = b64ToByteArray
5219	exports.fromByteArray = uint8ToBase64
5220}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
5221
5222},{}],85:[function(require,module,exports){
5223
5224},{}],86:[function(require,module,exports){
5225/*!
5226 * The buffer module from node.js, for the browser.
5227 *
5228 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
5229 * @license  MIT
5230 */
5231
5232var base64 = require('base64-js')
5233var ieee754 = require('ieee754')
5234
5235exports.Buffer = Buffer
5236exports.SlowBuffer = Buffer
5237exports.INSPECT_MAX_BYTES = 50
5238Buffer.poolSize = 8192
5239
5240/**
5241 * If `Buffer._useTypedArrays`:
5242 *   === true    Use Uint8Array implementation (fastest)
5243 *   === false   Use Object implementation (compatible down to IE6)
5244 */
5245Buffer._useTypedArrays = (function () {
5246  // Detect if browser supports Typed Arrays. Supported browsers are IE 10+, Firefox 4+,
5247  // Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+. If the browser does not support adding
5248  // properties to `Uint8Array` instances, then that's the same as no `Uint8Array` support
5249  // because we need to be able to add all the node Buffer API methods. This is an issue
5250  // in Firefox 4-29. Now fixed: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
5251  try {
5252    var buf = new ArrayBuffer(0)
5253    var arr = new Uint8Array(buf)
5254    arr.foo = function () { return 42 }
5255    return 42 === arr.foo() &&
5256        typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
5257  } catch (e) {
5258    return false
5259  }
5260})()
5261
5262/**
5263 * Class: Buffer
5264 * =============
5265 *
5266 * The Buffer constructor returns instances of `Uint8Array` that are augmented
5267 * with function properties for all the node `Buffer` API functions. We use
5268 * `Uint8Array` so that square bracket notation works as expected -- it returns
5269 * a single octet.
5270 *
5271 * By augmenting the instances, we can avoid modifying the `Uint8Array`
5272 * prototype.
5273 */
5274function Buffer (subject, encoding, noZero) {
5275  if (!(this instanceof Buffer))
5276    return new Buffer(subject, encoding, noZero)
5277
5278  var type = typeof subject
5279
5280  // Workaround: node's base64 implementation allows for non-padded strings
5281  // while base64-js does not.
5282  if (encoding === 'base64' && type === 'string') {
5283    subject = stringtrim(subject)
5284    while (subject.length % 4 !== 0) {
5285      subject = subject + '='
5286    }
5287  }
5288
5289  // Find the length
5290  var length
5291  if (type === 'number')
5292    length = coerce(subject)
5293  else if (type === 'string')
5294    length = Buffer.byteLength(subject, encoding)
5295  else if (type === 'object')
5296    length = coerce(subject.length) // assume that object is array-like
5297  else
5298    throw new Error('First argument needs to be a number, array or string.')
5299
5300  var buf
5301  if (Buffer._useTypedArrays) {
5302    // Preferred: Return an augmented `Uint8Array` instance for best performance
5303    buf = Buffer._augment(new Uint8Array(length))
5304  } else {
5305    // Fallback: Return THIS instance of Buffer (created by `new`)
5306    buf = this
5307    buf.length = length
5308    buf._isBuffer = true
5309  }
5310
5311  var i
5312  if (Buffer._useTypedArrays && typeof subject.byteLength === 'number') {
5313    // Speed optimization -- use set if we're copying from a typed array
5314    buf._set(subject)
5315  } else if (isArrayish(subject)) {
5316    // Treat array-ish objects as a byte array
5317    for (i = 0; i < length; i++) {
5318      if (Buffer.isBuffer(subject))
5319        buf[i] = subject.readUInt8(i)
5320      else
5321        buf[i] = subject[i]
5322    }
5323  } else if (type === 'string') {
5324    buf.write(subject, 0, encoding)
5325  } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
5326    for (i = 0; i < length; i++) {
5327      buf[i] = 0
5328    }
5329  }
5330
5331  return buf
5332}
5333
5334// STATIC METHODS
5335// ==============
5336
5337Buffer.isEncoding = function (encoding) {
5338  switch (String(encoding).toLowerCase()) {
5339    case 'hex':
5340    case 'utf8':
5341    case 'utf-8':
5342    case 'ascii':
5343    case 'binary':
5344    case 'base64':
5345    case 'raw':
5346    case 'ucs2':
5347    case 'ucs-2':
5348    case 'utf16le':
5349    case 'utf-16le':
5350      return true
5351    default:
5352      return false
5353  }
5354}
5355
5356Buffer.isBuffer = function (b) {
5357  return !!(b !== null && b !== undefined && b._isBuffer)
5358}
5359
5360Buffer.byteLength = function (str, encoding) {
5361  var ret
5362  str = str + ''
5363  switch (encoding || 'utf8') {
5364    case 'hex':
5365      ret = str.length / 2
5366      break
5367    case 'utf8':
5368    case 'utf-8':
5369      ret = utf8ToBytes(str).length
5370      break
5371    case 'ascii':
5372    case 'binary':
5373    case 'raw':
5374      ret = str.length
5375      break
5376    case 'base64':
5377      ret = base64ToBytes(str).length
5378      break
5379    case 'ucs2':
5380    case 'ucs-2':
5381    case 'utf16le':
5382    case 'utf-16le':
5383      ret = str.length * 2
5384      break
5385    default:
5386      throw new Error('Unknown encoding')
5387  }
5388  return ret
5389}
5390
5391Buffer.concat = function (list, totalLength) {
5392  assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
5393      'list should be an Array.')
5394
5395  if (list.length === 0) {
5396    return new Buffer(0)
5397  } else if (list.length === 1) {
5398    return list[0]
5399  }
5400
5401  var i
5402  if (typeof totalLength !== 'number') {
5403    totalLength = 0
5404    for (i = 0; i < list.length; i++) {
5405      totalLength += list[i].length
5406    }
5407  }
5408
5409  var buf = new Buffer(totalLength)
5410  var pos = 0
5411  for (i = 0; i < list.length; i++) {
5412    var item = list[i]
5413    item.copy(buf, pos)
5414    pos += item.length
5415  }
5416  return buf
5417}
5418
5419// BUFFER INSTANCE METHODS
5420// =======================
5421
5422function _hexWrite (buf, string, offset, length) {
5423  offset = Number(offset) || 0
5424  var remaining = buf.length - offset
5425  if (!length) {
5426    length = remaining
5427  } else {
5428    length = Number(length)
5429    if (length > remaining) {
5430      length = remaining
5431    }
5432  }
5433
5434  // must be an even number of digits
5435  var strLen = string.length
5436  assert(strLen % 2 === 0, 'Invalid hex string')
5437
5438  if (length > strLen / 2) {
5439    length = strLen / 2
5440  }
5441  for (var i = 0; i < length; i++) {
5442    var byte = parseInt(string.substr(i * 2, 2), 16)
5443    assert(!isNaN(byte), 'Invalid hex string')
5444    buf[offset + i] = byte
5445  }
5446  Buffer._charsWritten = i * 2
5447  return i
5448}
5449
5450function _utf8Write (buf, string, offset, length) {
5451  var charsWritten = Buffer._charsWritten =
5452    blitBuffer(utf8ToBytes(string), buf, offset, length)
5453  return charsWritten
5454}
5455
5456function _asciiWrite (buf, string, offset, length) {
5457  var charsWritten = Buffer._charsWritten =
5458    blitBuffer(asciiToBytes(string), buf, offset, length)
5459  return charsWritten
5460}
5461
5462function _binaryWrite (buf, string, offset, length) {
5463  return _asciiWrite(buf, string, offset, length)
5464}
5465
5466function _base64Write (buf, string, offset, length) {
5467  var charsWritten = Buffer._charsWritten =
5468    blitBuffer(base64ToBytes(string), buf, offset, length)
5469  return charsWritten
5470}
5471
5472function _utf16leWrite (buf, string, offset, length) {
5473  var charsWritten = Buffer._charsWritten =
5474    blitBuffer(utf16leToBytes(string), buf, offset, length)
5475  return charsWritten
5476}
5477
5478Buffer.prototype.write = function (string, offset, length, encoding) {
5479  // Support both (string, offset, length, encoding)
5480  // and the legacy (string, encoding, offset, length)
5481  if (isFinite(offset)) {
5482    if (!isFinite(length)) {
5483      encoding = length
5484      length = undefined
5485    }
5486  } else {  // legacy
5487    var swap = encoding
5488    encoding = offset
5489    offset = length
5490    length = swap
5491  }
5492
5493  offset = Number(offset) || 0
5494  var remaining = this.length - offset
5495  if (!length) {
5496    length = remaining
5497  } else {
5498    length = Number(length)
5499    if (length > remaining) {
5500      length = remaining
5501    }
5502  }
5503  encoding = String(encoding || 'utf8').toLowerCase()
5504
5505  var ret
5506  switch (encoding) {
5507    case 'hex':
5508      ret = _hexWrite(this, string, offset, length)
5509      break
5510    case 'utf8':
5511    case 'utf-8':
5512      ret = _utf8Write(this, string, offset, length)
5513      break
5514    case 'ascii':
5515      ret = _asciiWrite(this, string, offset, length)
5516      break
5517    case 'binary':
5518      ret = _binaryWrite(this, string, offset, length)
5519      break
5520    case 'base64':
5521      ret = _base64Write(this, string, offset, length)
5522      break
5523    case 'ucs2':
5524    case 'ucs-2':
5525    case 'utf16le':
5526    case 'utf-16le':
5527      ret = _utf16leWrite(this, string, offset, length)
5528      break
5529    default:
5530      throw new Error('Unknown encoding')
5531  }
5532  return ret
5533}
5534
5535Buffer.prototype.toString = function (encoding, start, end) {
5536  var self = this
5537
5538  encoding = String(encoding || 'utf8').toLowerCase()
5539  start = Number(start) || 0
5540  end = (end !== undefined)
5541    ? Number(end)
5542    : end = self.length
5543
5544  // Fastpath empty strings
5545  if (end === start)
5546    return ''
5547
5548  var ret
5549  switch (encoding) {
5550    case 'hex':
5551      ret = _hexSlice(self, start, end)
5552      break
5553    case 'utf8':
5554    case 'utf-8':
5555      ret = _utf8Slice(self, start, end)
5556      break
5557    case 'ascii':
5558      ret = _asciiSlice(self, start, end)
5559      break
5560    case 'binary':
5561      ret = _binarySlice(self, start, end)
5562      break
5563    case 'base64':
5564      ret = _base64Slice(self, start, end)
5565      break
5566    case 'ucs2':
5567    case 'ucs-2':
5568    case 'utf16le':
5569    case 'utf-16le':
5570      ret = _utf16leSlice(self, start, end)
5571      break
5572    default:
5573      throw new Error('Unknown encoding')
5574  }
5575  return ret
5576}
5577
5578Buffer.prototype.toJSON = function () {
5579  return {
5580    type: 'Buffer',
5581    data: Array.prototype.slice.call(this._arr || this, 0)
5582  }
5583}
5584
5585// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
5586Buffer.prototype.copy = function (target, target_start, start, end) {
5587  var source = this
5588
5589  if (!start) start = 0
5590  if (!end && end !== 0) end = this.length
5591  if (!target_start) target_start = 0
5592
5593  // Copy 0 bytes; we're done
5594  if (end === start) return
5595  if (target.length === 0 || source.length === 0) return
5596
5597  // Fatal error conditions
5598  assert(end >= start, 'sourceEnd < sourceStart')
5599  assert(target_start >= 0 && target_start < target.length,
5600      'targetStart out of bounds')
5601  assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
5602  assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')
5603
5604  // Are we oob?
5605  if (end > this.length)
5606    end = this.length
5607  if (target.length - target_start < end - start)
5608    end = target.length - target_start + start
5609
5610  var len = end - start
5611
5612  if (len < 100 || !Buffer._useTypedArrays) {
5613    for (var i = 0; i < len; i++)
5614      target[i + target_start] = this[i + start]
5615  } else {
5616    target._set(this.subarray(start, start + len), target_start)
5617  }
5618}
5619
5620function _base64Slice (buf, start, end) {
5621  if (start === 0 && end === buf.length) {
5622    return base64.fromByteArray(buf)
5623  } else {
5624    return base64.fromByteArray(buf.slice(start, end))
5625  }
5626}
5627
5628function _utf8Slice (buf, start, end) {
5629  var res = ''
5630  var tmp = ''
5631  end = Math.min(buf.length, end)
5632
5633  for (var i = start; i < end; i++) {
5634    if (buf[i] <= 0x7F) {
5635      res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
5636      tmp = ''
5637    } else {
5638      tmp += '%' + buf[i].toString(16)
5639    }
5640  }
5641
5642  return res + decodeUtf8Char(tmp)
5643}
5644
5645function _asciiSlice (buf, start, end) {
5646  var ret = ''
5647  end = Math.min(buf.length, end)
5648
5649  for (var i = start; i < end; i++)
5650    ret += String.fromCharCode(buf[i])
5651  return ret
5652}
5653
5654function _binarySlice (buf, start, end) {
5655  return _asciiSlice(buf, start, end)
5656}
5657
5658function _hexSlice (buf, start, end) {
5659  var len = buf.length
5660
5661  if (!start || start < 0) start = 0
5662  if (!end || end < 0 || end > len) end = len
5663
5664  var out = ''
5665  for (var i = start; i < end; i++) {
5666    out += toHex(buf[i])
5667  }
5668  return out
5669}
5670
5671function _utf16leSlice (buf, start, end) {
5672  var bytes = buf.slice(start, end)
5673  var res = ''
5674  for (var i = 0; i < bytes.length; i += 2) {
5675    res += String.fromCharCode(bytes[i] + bytes[i+1] * 256)
5676  }
5677  return res
5678}
5679
5680Buffer.prototype.slice = function (start, end) {
5681  var len = this.length
5682  start = clamp(start, len, 0)
5683  end = clamp(end, len, len)
5684
5685  if (Buffer._useTypedArrays) {
5686    return Buffer._augment(this.subarray(start, end))
5687  } else {
5688    var sliceLen = end - start
5689    var newBuf = new Buffer(sliceLen, undefined, true)
5690    for (var i = 0; i < sliceLen; i++) {
5691      newBuf[i] = this[i + start]
5692    }
5693    return newBuf
5694  }
5695}
5696
5697// `get` will be removed in Node 0.13+
5698Buffer.prototype.get = function (offset) {
5699  console.log('.get() is deprecated. Access using array indexes instead.')
5700  return this.readUInt8(offset)
5701}
5702
5703// `set` will be removed in Node 0.13+
5704Buffer.prototype.set = function (v, offset) {
5705  console.log('.set() is deprecated. Access using array indexes instead.')
5706  return this.writeUInt8(v, offset)
5707}
5708
5709Buffer.prototype.readUInt8 = function (offset, noAssert) {
5710  if (!noAssert) {
5711    assert(offset !== undefined && offset !== null, 'missing offset')
5712    assert(offset < this.length, 'Trying to read beyond buffer length')
5713  }
5714
5715  if (offset >= this.length)
5716    return
5717
5718  return this[offset]
5719}
5720
5721function _readUInt16 (buf, offset, littleEndian, noAssert) {
5722  if (!noAssert) {
5723    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5724    assert(offset !== undefined && offset !== null, 'missing offset')
5725    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
5726  }
5727
5728  var len = buf.length
5729  if (offset >= len)
5730    return
5731
5732  var val
5733  if (littleEndian) {
5734    val = buf[offset]
5735    if (offset + 1 < len)
5736      val |= buf[offset + 1] << 8
5737  } else {
5738    val = buf[offset] << 8
5739    if (offset + 1 < len)
5740      val |= buf[offset + 1]
5741  }
5742  return val
5743}
5744
5745Buffer.prototype.readUInt16LE = function (offset, noAssert) {
5746  return _readUInt16(this, offset, true, noAssert)
5747}
5748
5749Buffer.prototype.readUInt16BE = function (offset, noAssert) {
5750  return _readUInt16(this, offset, false, noAssert)
5751}
5752
5753function _readUInt32 (buf, offset, littleEndian, noAssert) {
5754  if (!noAssert) {
5755    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5756    assert(offset !== undefined && offset !== null, 'missing offset')
5757    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
5758  }
5759
5760  var len = buf.length
5761  if (offset >= len)
5762    return
5763
5764  var val
5765  if (littleEndian) {
5766    if (offset + 2 < len)
5767      val = buf[offset + 2] << 16
5768    if (offset + 1 < len)
5769      val |= buf[offset + 1] << 8
5770    val |= buf[offset]
5771    if (offset + 3 < len)
5772      val = val + (buf[offset + 3] << 24 >>> 0)
5773  } else {
5774    if (offset + 1 < len)
5775      val = buf[offset + 1] << 16
5776    if (offset + 2 < len)
5777      val |= buf[offset + 2] << 8
5778    if (offset + 3 < len)
5779      val |= buf[offset + 3]
5780    val = val + (buf[offset] << 24 >>> 0)
5781  }
5782  return val
5783}
5784
5785Buffer.prototype.readUInt32LE = function (offset, noAssert) {
5786  return _readUInt32(this, offset, true, noAssert)
5787}
5788
5789Buffer.prototype.readUInt32BE = function (offset, noAssert) {
5790  return _readUInt32(this, offset, false, noAssert)
5791}
5792
5793Buffer.prototype.readInt8 = function (offset, noAssert) {
5794  if (!noAssert) {
5795    assert(offset !== undefined && offset !== null,
5796        'missing offset')
5797    assert(offset < this.length, 'Trying to read beyond buffer length')
5798  }
5799
5800  if (offset >= this.length)
5801    return
5802
5803  var neg = this[offset] & 0x80
5804  if (neg)
5805    return (0xff - this[offset] + 1) * -1
5806  else
5807    return this[offset]
5808}
5809
5810function _readInt16 (buf, offset, littleEndian, noAssert) {
5811  if (!noAssert) {
5812    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5813    assert(offset !== undefined && offset !== null, 'missing offset')
5814    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
5815  }
5816
5817  var len = buf.length
5818  if (offset >= len)
5819    return
5820
5821  var val = _readUInt16(buf, offset, littleEndian, true)
5822  var neg = val & 0x8000
5823  if (neg)
5824    return (0xffff - val + 1) * -1
5825  else
5826    return val
5827}
5828
5829Buffer.prototype.readInt16LE = function (offset, noAssert) {
5830  return _readInt16(this, offset, true, noAssert)
5831}
5832
5833Buffer.prototype.readInt16BE = function (offset, noAssert) {
5834  return _readInt16(this, offset, false, noAssert)
5835}
5836
5837function _readInt32 (buf, offset, littleEndian, noAssert) {
5838  if (!noAssert) {
5839    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5840    assert(offset !== undefined && offset !== null, 'missing offset')
5841    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
5842  }
5843
5844  var len = buf.length
5845  if (offset >= len)
5846    return
5847
5848  var val = _readUInt32(buf, offset, littleEndian, true)
5849  var neg = val & 0x80000000
5850  if (neg)
5851    return (0xffffffff - val + 1) * -1
5852  else
5853    return val
5854}
5855
5856Buffer.prototype.readInt32LE = function (offset, noAssert) {
5857  return _readInt32(this, offset, true, noAssert)
5858}
5859
5860Buffer.prototype.readInt32BE = function (offset, noAssert) {
5861  return _readInt32(this, offset, false, noAssert)
5862}
5863
5864function _readFloat (buf, offset, littleEndian, noAssert) {
5865  if (!noAssert) {
5866    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5867    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
5868  }
5869
5870  return ieee754.read(buf, offset, littleEndian, 23, 4)
5871}
5872
5873Buffer.prototype.readFloatLE = function (offset, noAssert) {
5874  return _readFloat(this, offset, true, noAssert)
5875}
5876
5877Buffer.prototype.readFloatBE = function (offset, noAssert) {
5878  return _readFloat(this, offset, false, noAssert)
5879}
5880
5881function _readDouble (buf, offset, littleEndian, noAssert) {
5882  if (!noAssert) {
5883    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5884    assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
5885  }
5886
5887  return ieee754.read(buf, offset, littleEndian, 52, 8)
5888}
5889
5890Buffer.prototype.readDoubleLE = function (offset, noAssert) {
5891  return _readDouble(this, offset, true, noAssert)
5892}
5893
5894Buffer.prototype.readDoubleBE = function (offset, noAssert) {
5895  return _readDouble(this, offset, false, noAssert)
5896}
5897
5898Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
5899  if (!noAssert) {
5900    assert(value !== undefined && value !== null, 'missing value')
5901    assert(offset !== undefined && offset !== null, 'missing offset')
5902    assert(offset < this.length, 'trying to write beyond buffer length')
5903    verifuint(value, 0xff)
5904  }
5905
5906  if (offset >= this.length) return
5907
5908  this[offset] = value
5909}
5910
5911function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
5912  if (!noAssert) {
5913    assert(value !== undefined && value !== null, 'missing value')
5914    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5915    assert(offset !== undefined && offset !== null, 'missing offset')
5916    assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
5917    verifuint(value, 0xffff)
5918  }
5919
5920  var len = buf.length
5921  if (offset >= len)
5922    return
5923
5924  for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
5925    buf[offset + i] =
5926        (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
5927            (littleEndian ? i : 1 - i) * 8
5928  }
5929}
5930
5931Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
5932  _writeUInt16(this, value, offset, true, noAssert)
5933}
5934
5935Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
5936  _writeUInt16(this, value, offset, false, noAssert)
5937}
5938
5939function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
5940  if (!noAssert) {
5941    assert(value !== undefined && value !== null, 'missing value')
5942    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5943    assert(offset !== undefined && offset !== null, 'missing offset')
5944    assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
5945    verifuint(value, 0xffffffff)
5946  }
5947
5948  var len = buf.length
5949  if (offset >= len)
5950    return
5951
5952  for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
5953    buf[offset + i] =
5954        (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
5955  }
5956}
5957
5958Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
5959  _writeUInt32(this, value, offset, true, noAssert)
5960}
5961
5962Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
5963  _writeUInt32(this, value, offset, false, noAssert)
5964}
5965
5966Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
5967  if (!noAssert) {
5968    assert(value !== undefined && value !== null, 'missing value')
5969    assert(offset !== undefined && offset !== null, 'missing offset')
5970    assert(offset < this.length, 'Trying to write beyond buffer length')
5971    verifsint(value, 0x7f, -0x80)
5972  }
5973
5974  if (offset >= this.length)
5975    return
5976
5977  if (value >= 0)
5978    this.writeUInt8(value, offset, noAssert)
5979  else
5980    this.writeUInt8(0xff + value + 1, offset, noAssert)
5981}
5982
5983function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
5984  if (!noAssert) {
5985    assert(value !== undefined && value !== null, 'missing value')
5986    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
5987    assert(offset !== undefined && offset !== null, 'missing offset')
5988    assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
5989    verifsint(value, 0x7fff, -0x8000)
5990  }
5991
5992  var len = buf.length
5993  if (offset >= len)
5994    return
5995
5996  if (value >= 0)
5997    _writeUInt16(buf, value, offset, littleEndian, noAssert)
5998  else
5999    _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
6000}
6001
6002Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
6003  _writeInt16(this, value, offset, true, noAssert)
6004}
6005
6006Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
6007  _writeInt16(this, value, offset, false, noAssert)
6008}
6009
6010function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
6011  if (!noAssert) {
6012    assert(value !== undefined && value !== null, 'missing value')
6013    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
6014    assert(offset !== undefined && offset !== null, 'missing offset')
6015    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
6016    verifsint(value, 0x7fffffff, -0x80000000)
6017  }
6018
6019  var len = buf.length
6020  if (offset >= len)
6021    return
6022
6023  if (value >= 0)
6024    _writeUInt32(buf, value, offset, littleEndian, noAssert)
6025  else
6026    _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
6027}
6028
6029Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
6030  _writeInt32(this, value, offset, true, noAssert)
6031}
6032
6033Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
6034  _writeInt32(this, value, offset, false, noAssert)
6035}
6036
6037function _writeFloat (buf, value, offset, littleEndian, noAssert) {
6038  if (!noAssert) {
6039    assert(value !== undefined && value !== null, 'missing value')
6040    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
6041    assert(offset !== undefined && offset !== null, 'missing offset')
6042    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
6043    verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
6044  }
6045
6046  var len = buf.length
6047  if (offset >= len)
6048    return
6049
6050  ieee754.write(buf, value, offset, littleEndian, 23, 4)
6051}
6052
6053Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
6054  _writeFloat(this, value, offset, true, noAssert)
6055}
6056
6057Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
6058  _writeFloat(this, value, offset, false, noAssert)
6059}
6060
6061function _writeDouble (buf, value, offset, littleEndian, noAssert) {
6062  if (!noAssert) {
6063    assert(value !== undefined && value !== null, 'missing value')
6064    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
6065    assert(offset !== undefined && offset !== null, 'missing offset')
6066    assert(offset + 7 < buf.length,
6067        'Trying to write beyond buffer length')
6068    verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
6069  }
6070
6071  var len = buf.length
6072  if (offset >= len)
6073    return
6074
6075  ieee754.write(buf, value, offset, littleEndian, 52, 8)
6076}
6077
6078Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
6079  _writeDouble(this, value, offset, true, noAssert)
6080}
6081
6082Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
6083  _writeDouble(this, value, offset, false, noAssert)
6084}
6085
6086// fill(value, start=0, end=buffer.length)
6087Buffer.prototype.fill = function (value, start, end) {
6088  if (!value) value = 0
6089  if (!start) start = 0
6090  if (!end) end = this.length
6091
6092  if (typeof value === 'string') {
6093    value = value.charCodeAt(0)
6094  }
6095
6096  assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
6097  assert(end >= start, 'end < start')
6098
6099  // Fill 0 bytes; we're done
6100  if (end === start) return
6101  if (this.length === 0) return
6102
6103  assert(start >= 0 && start < this.length, 'start out of bounds')
6104  assert(end >= 0 && end <= this.length, 'end out of bounds')
6105
6106  for (var i = start; i < end; i++) {
6107    this[i] = value
6108  }
6109}
6110
6111Buffer.prototype.inspect = function () {
6112  var out = []
6113  var len = this.length
6114  for (var i = 0; i < len; i++) {
6115    out[i] = toHex(this[i])
6116    if (i === exports.INSPECT_MAX_BYTES) {
6117      out[i + 1] = '...'
6118      break
6119    }
6120  }
6121  return '<Buffer ' + out.join(' ') + '>'
6122}
6123
6124/**
6125 * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
6126 * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
6127 */
6128Buffer.prototype.toArrayBuffer = function () {
6129  if (typeof Uint8Array !== 'undefined') {
6130    if (Buffer._useTypedArrays) {
6131      return (new Buffer(this)).buffer
6132    } else {
6133      var buf = new Uint8Array(this.length)
6134      for (var i = 0, len = buf.length; i < len; i += 1)
6135        buf[i] = this[i]
6136      return buf.buffer
6137    }
6138  } else {
6139    throw new Error('Buffer.toArrayBuffer not supported in this browser')
6140  }
6141}
6142
6143// HELPER FUNCTIONS
6144// ================
6145
6146function stringtrim (str) {
6147  if (str.trim) return str.trim()
6148  return str.replace(/^\s+|\s+$/g, '')
6149}
6150
6151var BP = Buffer.prototype
6152
6153/**
6154 * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
6155 */
6156Buffer._augment = function (arr) {
6157  arr._isBuffer = true
6158
6159  // save reference to original Uint8Array get/set methods before overwriting
6160  arr._get = arr.get
6161  arr._set = arr.set
6162
6163  // deprecated, will be removed in node 0.13+
6164  arr.get = BP.get
6165  arr.set = BP.set
6166
6167  arr.write = BP.write
6168  arr.toString = BP.toString
6169  arr.toLocaleString = BP.toString
6170  arr.toJSON = BP.toJSON
6171  arr.copy = BP.copy
6172  arr.slice = BP.slice
6173  arr.readUInt8 = BP.readUInt8
6174  arr.readUInt16LE = BP.readUInt16LE
6175  arr.readUInt16BE = BP.readUInt16BE
6176  arr.readUInt32LE = BP.readUInt32LE
6177  arr.readUInt32BE = BP.readUInt32BE
6178  arr.readInt8 = BP.readInt8
6179  arr.readInt16LE = BP.readInt16LE
6180  arr.readInt16BE = BP.readInt16BE
6181  arr.readInt32LE = BP.readInt32LE
6182  arr.readInt32BE = BP.readInt32BE
6183  arr.readFloatLE = BP.readFloatLE
6184  arr.readFloatBE = BP.readFloatBE
6185  arr.readDoubleLE = BP.readDoubleLE
6186  arr.readDoubleBE = BP.readDoubleBE
6187  arr.writeUInt8 = BP.writeUInt8
6188  arr.writeUInt16LE = BP.writeUInt16LE
6189  arr.writeUInt16BE = BP.writeUInt16BE
6190  arr.writeUInt32LE = BP.writeUInt32LE
6191  arr.writeUInt32BE = BP.writeUInt32BE
6192  arr.writeInt8 = BP.writeInt8
6193  arr.writeInt16LE = BP.writeInt16LE
6194  arr.writeInt16BE = BP.writeInt16BE
6195  arr.writeInt32LE = BP.writeInt32LE
6196  arr.writeInt32BE = BP.writeInt32BE
6197  arr.writeFloatLE = BP.writeFloatLE
6198  arr.writeFloatBE = BP.writeFloatBE
6199  arr.writeDoubleLE = BP.writeDoubleLE
6200  arr.writeDoubleBE = BP.writeDoubleBE
6201  arr.fill = BP.fill
6202  arr.inspect = BP.inspect
6203  arr.toArrayBuffer = BP.toArrayBuffer
6204
6205  return arr
6206}
6207
6208// slice(start, end)
6209function clamp (index, len, defaultValue) {
6210  if (typeof index !== 'number') return defaultValue
6211  index = ~~index;  // Coerce to integer.
6212  if (index >= len) return len
6213  if (index >= 0) return index
6214  index += len
6215  if (index >= 0) return index
6216  return 0
6217}
6218
6219function coerce (length) {
6220  // Coerce length to a number (possibly NaN), round up
6221  // in case it's fractional (e.g. 123.456) then do a
6222  // double negate to coerce a NaN to 0. Easy, right?
6223  length = ~~Math.ceil(+length)
6224  return length < 0 ? 0 : length
6225}
6226
6227function isArray (subject) {
6228  return (Array.isArray || function (subject) {
6229    return Object.prototype.toString.call(subject) === '[object Array]'
6230  })(subject)
6231}
6232
6233function isArrayish (subject) {
6234  return isArray(subject) || Buffer.isBuffer(subject) ||
6235      subject && typeof subject === 'object' &&
6236      typeof subject.length === 'number'
6237}
6238
6239function toHex (n) {
6240  if (n < 16) return '0' + n.toString(16)
6241  return n.toString(16)
6242}
6243
6244function utf8ToBytes (str) {
6245  var byteArray = []
6246  for (var i = 0; i < str.length; i++) {
6247    var b = str.charCodeAt(i)
6248    if (b <= 0x7F)
6249      byteArray.push(str.charCodeAt(i))
6250    else {
6251      var start = i
6252      if (b >= 0xD800 && b <= 0xDFFF) i++
6253      var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
6254      for (var j = 0; j < h.length; j++)
6255        byteArray.push(parseInt(h[j], 16))
6256    }
6257  }
6258  return byteArray
6259}
6260
6261function asciiToBytes (str) {
6262  var byteArray = []
6263  for (var i = 0; i < str.length; i++) {
6264    // Node's code seems to be doing this and not & 0x7F..
6265    byteArray.push(str.charCodeAt(i) & 0xFF)
6266  }
6267  return byteArray
6268}
6269
6270function utf16leToBytes (str) {
6271  var c, hi, lo
6272  var byteArray = []
6273  for (var i = 0; i < str.length; i++) {
6274    c = str.charCodeAt(i)
6275    hi = c >> 8
6276    lo = c % 256
6277    byteArray.push(lo)
6278    byteArray.push(hi)
6279  }
6280
6281  return byteArray
6282}
6283
6284function base64ToBytes (str) {
6285  return base64.toByteArray(str)
6286}
6287
6288function blitBuffer (src, dst, offset, length) {
6289  var pos
6290  for (var i = 0; i < length; i++) {
6291    if ((i + offset >= dst.length) || (i >= src.length))
6292      break
6293    dst[i + offset] = src[i]
6294  }
6295  return i
6296}
6297
6298function decodeUtf8Char (str) {
6299  try {
6300    return decodeURIComponent(str)
6301  } catch (err) {
6302    return String.fromCharCode(0xFFFD) // UTF 8 invalid char
6303  }
6304}
6305
6306/*
6307 * We have to make sure that the value is a valid integer. This means that it
6308 * is non-negative. It has no fractional component and that it does not
6309 * exceed the maximum allowed value.
6310 */
6311function verifuint (value, max) {
6312  assert(typeof value === 'number', 'cannot write a non-number as a number')
6313  assert(value >= 0, 'specified a negative value for writing an unsigned value')
6314  assert(value <= max, 'value is larger than maximum value for type')
6315  assert(Math.floor(value) === value, 'value has a fractional component')
6316}
6317
6318function verifsint (value, max, min) {
6319  assert(typeof value === 'number', 'cannot write a non-number as a number')
6320  assert(value <= max, 'value larger than maximum allowed value')
6321  assert(value >= min, 'value smaller than minimum allowed value')
6322  assert(Math.floor(value) === value, 'value has a fractional component')
6323}
6324
6325function verifIEEE754 (value, max, min) {
6326  assert(typeof value === 'number', 'cannot write a non-number as a number')
6327  assert(value <= max, 'value larger than maximum allowed value')
6328  assert(value >= min, 'value smaller than minimum allowed value')
6329}
6330
6331function assert (test, message) {
6332  if (!test) throw new Error(message || 'Failed assertion')
6333}
6334
6335},{"base64-js":84,"ieee754":88}],87:[function(require,module,exports){
6336// Copyright Joyent, Inc. and other Node contributors.
6337//
6338// Permission is hereby granted, free of charge, to any person obtaining a
6339// copy of this software and associated documentation files (the
6340// "Software"), to deal in the Software without restriction, including
6341// without limitation the rights to use, copy, modify, merge, publish,
6342// distribute, sublicense, and/or sell copies of the Software, and to permit
6343// persons to whom the Software is furnished to do so, subject to the
6344// following conditions:
6345//
6346// The above copyright notice and this permission notice shall be included
6347// in all copies or substantial portions of the Software.
6348//
6349// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
6350// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
6351// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
6352// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
6353// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
6354// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
6355// USE OR OTHER DEALINGS IN THE SOFTWARE.
6356
6357function EventEmitter() {
6358  this._events = this._events || {};
6359  this._maxListeners = this._maxListeners || undefined;
6360}
6361module.exports = EventEmitter;
6362
6363// Backwards-compat with node 0.10.x
6364EventEmitter.EventEmitter = EventEmitter;
6365
6366EventEmitter.prototype._events = undefined;
6367EventEmitter.prototype._maxListeners = undefined;
6368
6369// By default EventEmitters will print a warning if more than 10 listeners are
6370// added to it. This is a useful default which helps finding memory leaks.
6371EventEmitter.defaultMaxListeners = 10;
6372
6373// Obviously not all Emitters should be limited to 10. This function allows
6374// that to be increased. Set to zero for unlimited.
6375EventEmitter.prototype.setMaxListeners = function(n) {
6376  if (!isNumber(n) || n < 0 || isNaN(n))
6377    throw TypeError('n must be a positive number');
6378  this._maxListeners = n;
6379  return this;
6380};
6381
6382EventEmitter.prototype.emit = function(type) {
6383  var er, handler, len, args, i, listeners;
6384
6385  if (!this._events)
6386    this._events = {};
6387
6388  // If there is no 'error' event listener then throw.
6389  if (type === 'error') {
6390    if (!this._events.error ||
6391        (isObject(this._events.error) && !this._events.error.length)) {
6392      er = arguments[1];
6393      if (er instanceof Error) {
6394        throw er; // Unhandled 'error' event
6395      }
6396      throw TypeError('Uncaught, unspecified "error" event.');
6397    }
6398  }
6399
6400  handler = this._events[type];
6401
6402  if (isUndefined(handler))
6403    return false;
6404
6405  if (isFunction(handler)) {
6406    switch (arguments.length) {
6407      // fast cases
6408      case 1:
6409        handler.call(this);
6410        break;
6411      case 2:
6412        handler.call(this, arguments[1]);
6413        break;
6414      case 3:
6415        handler.call(this, arguments[1], arguments[2]);
6416        break;
6417      // slower
6418      default:
6419        len = arguments.length;
6420        args = new Array(len - 1);
6421        for (i = 1; i < len; i++)
6422          args[i - 1] = arguments[i];
6423        handler.apply(this, args);
6424    }
6425  } else if (isObject(handler)) {
6426    len = arguments.length;
6427    args = new Array(len - 1);
6428    for (i = 1; i < len; i++)
6429      args[i - 1] = arguments[i];
6430
6431    listeners = handler.slice();
6432    len = listeners.length;
6433    for (i = 0; i < len; i++)
6434      listeners[i].apply(this, args);
6435  }
6436
6437  return true;
6438};
6439
6440EventEmitter.prototype.addListener = function(type, listener) {
6441  var m;
6442
6443  if (!isFunction(listener))
6444    throw TypeError('listener must be a function');
6445
6446  if (!this._events)
6447    this._events = {};
6448
6449  // To avoid recursion in the case that type === "newListener"! Before
6450  // adding it to the listeners, first emit "newListener".
6451  if (this._events.newListener)
6452    this.emit('newListener', type,
6453              isFunction(listener.listener) ?
6454              listener.listener : listener);
6455
6456  if (!this._events[type])
6457    // Optimize the case of one listener. Don't need the extra array object.
6458    this._events[type] = listener;
6459  else if (isObject(this._events[type]))
6460    // If we've already got an array, just append.
6461    this._events[type].push(listener);
6462  else
6463    // Adding the second element, need to change to array.
6464    this._events[type] = [this._events[type], listener];
6465
6466  // Check for listener leak
6467  if (isObject(this._events[type]) && !this._events[type].warned) {
6468    var m;
6469    if (!isUndefined(this._maxListeners)) {
6470      m = this._maxListeners;
6471    } else {
6472      m = EventEmitter.defaultMaxListeners;
6473    }
6474
6475    if (m && m > 0 && this._events[type].length > m) {
6476      this._events[type].warned = true;
6477      console.error('(node) warning: possible EventEmitter memory ' +
6478                    'leak detected. %d listeners added. ' +
6479                    'Use emitter.setMaxListeners() to increase limit.',
6480                    this._events[type].length);
6481      if (typeof console.trace === 'function') {
6482        // not supported in IE 10
6483        console.trace();
6484      }
6485    }
6486  }
6487
6488  return this;
6489};
6490
6491EventEmitter.prototype.on = EventEmitter.prototype.addListener;
6492
6493EventEmitter.prototype.once = function(type, listener) {
6494  if (!isFunction(listener))
6495    throw TypeError('listener must be a function');
6496
6497  var fired = false;
6498
6499  function g() {
6500    this.removeListener(type, g);
6501
6502    if (!fired) {
6503      fired = true;
6504      listener.apply(this, arguments);
6505    }
6506  }
6507
6508  g.listener = listener;
6509  this.on(type, g);
6510
6511  return this;
6512};
6513
6514// emits a 'removeListener' event iff the listener was removed
6515EventEmitter.prototype.removeListener = function(type, listener) {
6516  var list, position, length, i;
6517
6518  if (!isFunction(listener))
6519    throw TypeError('listener must be a function');
6520
6521  if (!this._events || !this._events[type])
6522    return this;
6523
6524  list = this._events[type];
6525  length = list.length;
6526  position = -1;
6527
6528  if (list === listener ||
6529      (isFunction(list.listener) && list.listener === listener)) {
6530    delete this._events[type];
6531    if (this._events.removeListener)
6532      this.emit('removeListener', type, listener);
6533
6534  } else if (isObject(list)) {
6535    for (i = length; i-- > 0;) {
6536      if (list[i] === listener ||
6537          (list[i].listener && list[i].listener === listener)) {
6538        position = i;
6539        break;
6540      }
6541    }
6542
6543    if (position < 0)
6544      return this;
6545
6546    if (list.length === 1) {
6547      list.length = 0;
6548      delete this._events[type];
6549    } else {
6550      list.splice(position, 1);
6551    }
6552
6553    if (this._events.removeListener)
6554      this.emit('removeListener', type, listener);
6555  }
6556
6557  return this;
6558};
6559
6560EventEmitter.prototype.removeAllListeners = function(type) {
6561  var key, listeners;
6562
6563  if (!this._events)
6564    return this;
6565
6566  // not listening for removeListener, no need to emit
6567  if (!this._events.removeListener) {
6568    if (arguments.length === 0)
6569      this._events = {};
6570    else if (this._events[type])
6571      delete this._events[type];
6572    return this;
6573  }
6574
6575  // emit removeListener for all listeners on all events
6576  if (arguments.length === 0) {
6577    for (key in this._events) {
6578      if (key === 'removeListener') continue;
6579      this.removeAllListeners(key);
6580    }
6581    this.removeAllListeners('removeListener');
6582    this._events = {};
6583    return this;
6584  }
6585
6586  listeners = this._events[type];
6587
6588  if (isFunction(listeners)) {
6589    this.removeListener(type, listeners);
6590  } else {
6591    // LIFO order
6592    while (listeners.length)
6593      this.removeListener(type, listeners[listeners.length - 1]);
6594  }
6595  delete this._events[type];
6596
6597  return this;
6598};
6599
6600EventEmitter.prototype.listeners = function(type) {
6601  var ret;
6602  if (!this._events || !this._events[type])
6603    ret = [];
6604  else if (isFunction(this._events[type]))
6605    ret = [this._events[type]];
6606  else
6607    ret = this._events[type].slice();
6608  return ret;
6609};
6610
6611EventEmitter.listenerCount = function(emitter, type) {
6612  var ret;
6613  if (!emitter._events || !emitter._events[type])
6614    ret = 0;
6615  else if (isFunction(emitter._events[type]))
6616    ret = 1;
6617  else
6618    ret = emitter._events[type].length;
6619  return ret;
6620};
6621
6622function isFunction(arg) {
6623  return typeof arg === 'function';
6624}
6625
6626function isNumber(arg) {
6627  return typeof arg === 'number';
6628}
6629
6630function isObject(arg) {
6631  return typeof arg === 'object' && arg !== null;
6632}
6633
6634function isUndefined(arg) {
6635  return arg === void 0;
6636}
6637
6638},{}],88:[function(require,module,exports){
6639exports.read = function (buffer, offset, isLE, mLen, nBytes) {
6640  var e, m
6641  var eLen = (nBytes * 8) - mLen - 1
6642  var eMax = (1 << eLen) - 1
6643  var eBias = eMax >> 1
6644  var nBits = -7
6645  var i = isLE ? (nBytes - 1) : 0
6646  var d = isLE ? -1 : 1
6647  var s = buffer[offset + i]
6648
6649  i += d
6650
6651  e = s & ((1 << (-nBits)) - 1)
6652  s >>= (-nBits)
6653  nBits += eLen
6654  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
6655
6656  m = e & ((1 << (-nBits)) - 1)
6657  e >>= (-nBits)
6658  nBits += mLen
6659  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
6660
6661  if (e === 0) {
6662    e = 1 - eBias
6663  } else if (e === eMax) {
6664    return m ? NaN : ((s ? -1 : 1) * Infinity)
6665  } else {
6666    m = m + Math.pow(2, mLen)
6667    e = e - eBias
6668  }
6669  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
6670}
6671
6672exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
6673  var e, m, c
6674  var eLen = (nBytes * 8) - mLen - 1
6675  var eMax = (1 << eLen) - 1
6676  var eBias = eMax >> 1
6677  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
6678  var i = isLE ? 0 : (nBytes - 1)
6679  var d = isLE ? 1 : -1
6680  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
6681
6682  value = Math.abs(value)
6683
6684  if (isNaN(value) || value === Infinity) {
6685    m = isNaN(value) ? 1 : 0
6686    e = eMax
6687  } else {
6688    e = Math.floor(Math.log(value) / Math.LN2)
6689    if (value * (c = Math.pow(2, -e)) < 1) {
6690      e--
6691      c *= 2
6692    }
6693    if (e + eBias >= 1) {
6694      value += rt / c
6695    } else {
6696      value += rt * Math.pow(2, 1 - eBias)
6697    }
6698    if (value * c >= 2) {
6699      e++
6700      c /= 2
6701    }
6702
6703    if (e + eBias >= eMax) {
6704      m = 0
6705      e = eMax
6706    } else if (e + eBias >= 1) {
6707      m = ((value * c) - 1) * Math.pow(2, mLen)
6708      e = e + eBias
6709    } else {
6710      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
6711      e = 0
6712    }
6713  }
6714
6715  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
6716
6717  e = (e << mLen) | m
6718  eLen += mLen
6719  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
6720
6721  buffer[offset + i - d] |= s * 128
6722}
6723
6724},{}],89:[function(require,module,exports){
6725module.exports=require(40)
6726},{}],90:[function(require,module,exports){
6727(function (process){
6728// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,
6729// backported and transplited with Babel, with backwards-compat fixes
6730
6731// Copyright Joyent, Inc. and other Node contributors.
6732//
6733// Permission is hereby granted, free of charge, to any person obtaining a
6734// copy of this software and associated documentation files (the
6735// "Software"), to deal in the Software without restriction, including
6736// without limitation the rights to use, copy, modify, merge, publish,
6737// distribute, sublicense, and/or sell copies of the Software, and to permit
6738// persons to whom the Software is furnished to do so, subject to the
6739// following conditions:
6740//
6741// The above copyright notice and this permission notice shall be included
6742// in all copies or substantial portions of the Software.
6743//
6744// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
6745// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
6746// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
6747// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
6748// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
6749// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
6750// USE OR OTHER DEALINGS IN THE SOFTWARE.
6751
6752// resolves . and .. elements in a path array with directory names there
6753// must be no slashes, empty elements, or device names (c:\) in the array
6754// (so also no leading and trailing slashes - it does not distinguish
6755// relative and absolute paths)
6756function normalizeArray(parts, allowAboveRoot) {
6757  // if the path tries to go above the root, `up` ends up > 0
6758  var up = 0;
6759  for (var i = parts.length - 1; i >= 0; i--) {
6760    var last = parts[i];
6761    if (last === '.') {
6762      parts.splice(i, 1);
6763    } else if (last === '..') {
6764      parts.splice(i, 1);
6765      up++;
6766    } else if (up) {
6767      parts.splice(i, 1);
6768      up--;
6769    }
6770  }
6771
6772  // if the path is allowed to go above the root, restore leading ..s
6773  if (allowAboveRoot) {
6774    for (; up--; up) {
6775      parts.unshift('..');
6776    }
6777  }
6778
6779  return parts;
6780}
6781
6782// path.resolve([from ...], to)
6783// posix version
6784exports.resolve = function() {
6785  var resolvedPath = '',
6786      resolvedAbsolute = false;
6787
6788  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
6789    var path = (i >= 0) ? arguments[i] : process.cwd();
6790
6791    // Skip empty and invalid entries
6792    if (typeof path !== 'string') {
6793      throw new TypeError('Arguments to path.resolve must be strings');
6794    } else if (!path) {
6795      continue;
6796    }
6797
6798    resolvedPath = path + '/' + resolvedPath;
6799    resolvedAbsolute = path.charAt(0) === '/';
6800  }
6801
6802  // At this point the path should be resolved to a full absolute path, but
6803  // handle relative paths to be safe (might happen when process.cwd() fails)
6804
6805  // Normalize the path
6806  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
6807    return !!p;
6808  }), !resolvedAbsolute).join('/');
6809
6810  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
6811};
6812
6813// path.normalize(path)
6814// posix version
6815exports.normalize = function(path) {
6816  var isAbsolute = exports.isAbsolute(path),
6817      trailingSlash = substr(path, -1) === '/';
6818
6819  // Normalize the path
6820  path = normalizeArray(filter(path.split('/'), function(p) {
6821    return !!p;
6822  }), !isAbsolute).join('/');
6823
6824  if (!path && !isAbsolute) {
6825    path = '.';
6826  }
6827  if (path && trailingSlash) {
6828    path += '/';
6829  }
6830
6831  return (isAbsolute ? '/' : '') + path;
6832};
6833
6834// posix version
6835exports.isAbsolute = function(path) {
6836  return path.charAt(0) === '/';
6837};
6838
6839// posix version
6840exports.join = function() {
6841  var paths = Array.prototype.slice.call(arguments, 0);
6842  return exports.normalize(filter(paths, function(p, index) {
6843    if (typeof p !== 'string') {
6844      throw new TypeError('Arguments to path.join must be strings');
6845    }
6846    return p;
6847  }).join('/'));
6848};
6849
6850
6851// path.relative(from, to)
6852// posix version
6853exports.relative = function(from, to) {
6854  from = exports.resolve(from).substr(1);
6855  to = exports.resolve(to).substr(1);
6856
6857  function trim(arr) {
6858    var start = 0;
6859    for (; start < arr.length; start++) {
6860      if (arr[start] !== '') break;
6861    }
6862
6863    var end = arr.length - 1;
6864    for (; end >= 0; end--) {
6865      if (arr[end] !== '') break;
6866    }
6867
6868    if (start > end) return [];
6869    return arr.slice(start, end - start + 1);
6870  }
6871
6872  var fromParts = trim(from.split('/'));
6873  var toParts = trim(to.split('/'));
6874
6875  var length = Math.min(fromParts.length, toParts.length);
6876  var samePartsLength = length;
6877  for (var i = 0; i < length; i++) {
6878    if (fromParts[i] !== toParts[i]) {
6879      samePartsLength = i;
6880      break;
6881    }
6882  }
6883
6884  var outputParts = [];
6885  for (var i = samePartsLength; i < fromParts.length; i++) {
6886    outputParts.push('..');
6887  }
6888
6889  outputParts = outputParts.concat(toParts.slice(samePartsLength));
6890
6891  return outputParts.join('/');
6892};
6893
6894exports.sep = '/';
6895exports.delimiter = ':';
6896
6897exports.dirname = function (path) {
6898  if (typeof path !== 'string') path = path + '';
6899  if (path.length === 0) return '.';
6900  var code = path.charCodeAt(0);
6901  var hasRoot = code === 47 /*/*/;
6902  var end = -1;
6903  var matchedSlash = true;
6904  for (var i = path.length - 1; i >= 1; --i) {
6905    code = path.charCodeAt(i);
6906    if (code === 47 /*/*/) {
6907        if (!matchedSlash) {
6908          end = i;
6909          break;
6910        }
6911      } else {
6912      // We saw the first non-path separator
6913      matchedSlash = false;
6914    }
6915  }
6916
6917  if (end === -1) return hasRoot ? '/' : '.';
6918  if (hasRoot && end === 1) {
6919    // return '//';
6920    // Backwards-compat fix:
6921    return '/';
6922  }
6923  return path.slice(0, end);
6924};
6925
6926function basename(path) {
6927  if (typeof path !== 'string') path = path + '';
6928
6929  var start = 0;
6930  var end = -1;
6931  var matchedSlash = true;
6932  var i;
6933
6934  for (i = path.length - 1; i >= 0; --i) {
6935    if (path.charCodeAt(i) === 47 /*/*/) {
6936        // If we reached a path separator that was not part of a set of path
6937        // separators at the end of the string, stop now
6938        if (!matchedSlash) {
6939          start = i + 1;
6940          break;
6941        }
6942      } else if (end === -1) {
6943      // We saw the first non-path separator, mark this as the end of our
6944      // path component
6945      matchedSlash = false;
6946      end = i + 1;
6947    }
6948  }
6949
6950  if (end === -1) return '';
6951  return path.slice(start, end);
6952}
6953
6954// Uses a mixed approach for backwards-compatibility, as ext behavior changed
6955// in new Node.js versions, so only basename() above is backported here
6956exports.basename = function (path, ext) {
6957  var f = basename(path);
6958  if (ext && f.substr(-1 * ext.length) === ext) {
6959    f = f.substr(0, f.length - ext.length);
6960  }
6961  return f;
6962};
6963
6964exports.extname = function (path) {
6965  if (typeof path !== 'string') path = path + '';
6966  var startDot = -1;
6967  var startPart = 0;
6968  var end = -1;
6969  var matchedSlash = true;
6970  // Track the state of characters (if any) we see before our first dot and
6971  // after any path separator we find
6972  var preDotState = 0;
6973  for (var i = path.length - 1; i >= 0; --i) {
6974    var code = path.charCodeAt(i);
6975    if (code === 47 /*/*/) {
6976        // If we reached a path separator that was not part of a set of path
6977        // separators at the end of the string, stop now
6978        if (!matchedSlash) {
6979          startPart = i + 1;
6980          break;
6981        }
6982        continue;
6983      }
6984    if (end === -1) {
6985      // We saw the first non-path separator, mark this as the end of our
6986      // extension
6987      matchedSlash = false;
6988      end = i + 1;
6989    }
6990    if (code === 46 /*.*/) {
6991        // If this is our first dot, mark it as the start of our extension
6992        if (startDot === -1)
6993          startDot = i;
6994        else if (preDotState !== 1)
6995          preDotState = 1;
6996    } else if (startDot !== -1) {
6997      // We saw a non-dot and non-path separator before our dot, so we should
6998      // have a good chance at having a non-empty extension
6999      preDotState = -1;
7000    }
7001  }
7002
7003  if (startDot === -1 || end === -1 ||
7004      // We saw a non-dot character immediately before the dot
7005      preDotState === 0 ||
7006      // The (right-most) trimmed path component is exactly '..'
7007      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
7008    return '';
7009  }
7010  return path.slice(startDot, end);
7011};
7012
7013function filter (xs, f) {
7014    if (xs.filter) return xs.filter(f);
7015    var res = [];
7016    for (var i = 0; i < xs.length; i++) {
7017        if (f(xs[i], i, xs)) res.push(xs[i]);
7018    }
7019    return res;
7020}
7021
7022// String.prototype.substr - negative index don't work in IE8
7023var substr = 'ab'.substr(-1) === 'b'
7024    ? function (str, start, len) { return str.substr(start, len) }
7025    : function (str, start, len) {
7026        if (start < 0) start = str.length + start;
7027        return str.substr(start, len);
7028    }
7029;
7030
7031}).call(this,require("KliubH"))
7032},{"KliubH":91}],91:[function(require,module,exports){
7033// shim for using process in browser
7034
7035var process = module.exports = {};
7036
7037process.nextTick = (function () {
7038    var canSetImmediate = typeof window !== 'undefined'
7039    && window.setImmediate;
7040    var canPost = typeof window !== 'undefined'
7041    && window.postMessage && window.addEventListener
7042    ;
7043
7044    if (canSetImmediate) {
7045        return function (f) { return window.setImmediate(f) };
7046    }
7047
7048    if (canPost) {
7049        var queue = [];
7050        window.addEventListener('message', function (ev) {
7051            var source = ev.source;
7052            if ((source === window || source === null) && ev.data === 'process-tick') {
7053                ev.stopPropagation();
7054                if (queue.length > 0) {
7055                    var fn = queue.shift();
7056                    fn();
7057                }
7058            }
7059        }, true);
7060
7061        return function nextTick(fn) {
7062            queue.push(fn);
7063            window.postMessage('process-tick', '*');
7064        };
7065    }
7066
7067    return function nextTick(fn) {
7068        setTimeout(fn, 0);
7069    };
7070})();
7071
7072process.title = 'browser';
7073process.browser = true;
7074process.env = {};
7075process.argv = [];
7076
7077function noop() {}
7078
7079process.on = noop;
7080process.addListener = noop;
7081process.once = noop;
7082process.off = noop;
7083process.removeListener = noop;
7084process.removeAllListeners = noop;
7085process.emit = noop;
7086
7087process.binding = function (name) {
7088    throw new Error('process.binding is not supported');
7089}
7090
7091// TODO(shtylman)
7092process.cwd = function () { return '/' };
7093process.chdir = function (dir) {
7094    throw new Error('process.chdir is not supported');
7095};
7096
7097},{}],92:[function(require,module,exports){
7098// Copyright Joyent, Inc. and other Node contributors.
7099//
7100// Permission is hereby granted, free of charge, to any person obtaining a
7101// copy of this software and associated documentation files (the
7102// "Software"), to deal in the Software without restriction, including
7103// without limitation the rights to use, copy, modify, merge, publish,
7104// distribute, sublicense, and/or sell copies of the Software, and to permit
7105// persons to whom the Software is furnished to do so, subject to the
7106// following conditions:
7107//
7108// The above copyright notice and this permission notice shall be included
7109// in all copies or substantial portions of the Software.
7110//
7111// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
7112// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
7113// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
7114// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
7115// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
7116// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
7117// USE OR OTHER DEALINGS IN THE SOFTWARE.
7118
7119// a duplex stream is just a stream that is both readable and writable.
7120// Since JS doesn't have multiple prototypal inheritance, this class
7121// prototypally inherits from Readable, and then parasitically from
7122// Writable.
7123
7124module.exports = Duplex;
7125var inherits = require('inherits');
7126var setImmediate = require('process/browser.js').nextTick;
7127var Readable = require('./readable.js');
7128var Writable = require('./writable.js');
7129
7130inherits(Duplex, Readable);
7131
7132Duplex.prototype.write = Writable.prototype.write;
7133Duplex.prototype.end = Writable.prototype.end;
7134Duplex.prototype._write = Writable.prototype._write;
7135
7136function Duplex(options) {
7137  if (!(this instanceof Duplex))
7138    return new Duplex(options);
7139
7140  Readable.call(this, options);
7141  Writable.call(this, options);
7142
7143  if (options && options.readable === false)
7144    this.readable = false;
7145
7146  if (options && options.writable === false)
7147    this.writable = false;
7148
7149  this.allowHalfOpen = true;
7150  if (options && options.allowHalfOpen === false)
7151    this.allowHalfOpen = false;
7152
7153  this.once('end', onend);
7154}
7155
7156// the no-half-open enforcer
7157function onend() {
7158  // if we allow half-open state, or if the writable side ended,
7159  // then we're ok.
7160  if (this.allowHalfOpen || this._writableState.ended)
7161    return;
7162
7163  // no more data can be written.
7164  // But allow more writes to happen in this tick.
7165  var self = this;
7166  setImmediate(function () {
7167    self.end();
7168  });
7169}
7170
7171},{"./readable.js":96,"./writable.js":98,"inherits":89,"process/browser.js":94}],93:[function(require,module,exports){
7172// Copyright Joyent, Inc. and other Node contributors.
7173//
7174// Permission is hereby granted, free of charge, to any person obtaining a
7175// copy of this software and associated documentation files (the
7176// "Software"), to deal in the Software without restriction, including
7177// without limitation the rights to use, copy, modify, merge, publish,
7178// distribute, sublicense, and/or sell copies of the Software, and to permit
7179// persons to whom the Software is furnished to do so, subject to the
7180// following conditions:
7181//
7182// The above copyright notice and this permission notice shall be included
7183// in all copies or substantial portions of the Software.
7184//
7185// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
7186// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
7187// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
7188// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
7189// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
7190// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
7191// USE OR OTHER DEALINGS IN THE SOFTWARE.
7192
7193module.exports = Stream;
7194
7195var EE = require('events').EventEmitter;
7196var inherits = require('inherits');
7197
7198inherits(Stream, EE);
7199Stream.Readable = require('./readable.js');
7200Stream.Writable = require('./writable.js');
7201Stream.Duplex = require('./duplex.js');
7202Stream.Transform = require('./transform.js');
7203Stream.PassThrough = require('./passthrough.js');
7204
7205// Backwards-compat with node 0.4.x
7206Stream.Stream = Stream;
7207
7208
7209
7210// old-style streams.  Note that the pipe method (the only relevant
7211// part of this class) is overridden in the Readable class.
7212
7213function Stream() {
7214  EE.call(this);
7215}
7216
7217Stream.prototype.pipe = function(dest, options) {
7218  var source = this;
7219
7220  function ondata(chunk) {
7221    if (dest.writable) {
7222      if (false === dest.write(chunk) && source.pause) {
7223        source.pause();
7224      }
7225    }
7226  }
7227
7228  source.on('data', ondata);
7229
7230  function ondrain() {
7231    if (source.readable && source.resume) {
7232      source.resume();
7233    }
7234  }
7235
7236  dest.on('drain', ondrain);
7237
7238  // If the 'end' option is not supplied, dest.end() will be called when
7239  // source gets the 'end' or 'close' events.  Only dest.end() once.
7240  if (!dest._isStdio && (!options || options.end !== false)) {
7241    source.on('end', onend);
7242    source.on('close', onclose);
7243  }
7244
7245  var didOnEnd = false;
7246  function onend() {
7247    if (didOnEnd) return;
7248    didOnEnd = true;
7249
7250    dest.end();
7251  }
7252
7253
7254  function onclose() {
7255    if (didOnEnd) return;
7256    didOnEnd = true;
7257
7258    if (typeof dest.destroy === 'function') dest.destroy();
7259  }
7260
7261  // don't leave dangling pipes when there are errors.
7262  function onerror(er) {
7263    cleanup();
7264    if (EE.listenerCount(this, 'error') === 0) {
7265      throw er; // Unhandled stream error in pipe.
7266    }
7267  }
7268
7269  source.on('error', onerror);
7270  dest.on('error', onerror);
7271
7272  // remove all the event listeners that were added.
7273  function cleanup() {
7274    source.removeListener('data', ondata);
7275    dest.removeListener('drain', ondrain);
7276
7277    source.removeListener('end', onend);
7278    source.removeListener('close', onclose);
7279
7280    source.removeListener('error', onerror);
7281    dest.removeListener('error', onerror);
7282
7283    source.removeListener('end', cleanup);
7284    source.removeListener('close', cleanup);
7285
7286    dest.removeListener('close', cleanup);
7287  }
7288
7289  source.on('end', cleanup);
7290  source.on('close', cleanup);
7291
7292  dest.on('close', cleanup);
7293
7294  dest.emit('pipe', source);
7295
7296  // Allow for unix-like usage: A.pipe(B).pipe(C)
7297  return dest;
7298};
7299
7300},{"./duplex.js":92,"./passthrough.js":95,"./readable.js":96,"./transform.js":97,"./writable.js":98,"events":87,"inherits":89}],94:[function(require,module,exports){
7301// shim for using process in browser
7302
7303var process = module.exports = {};
7304
7305process.nextTick = (function () {
7306    var canSetImmediate = typeof window !== 'undefined'
7307    && window.setImmediate;
7308    var canPost = typeof window !== 'undefined'
7309    && window.postMessage && window.addEventListener
7310    ;
7311
7312    if (canSetImmediate) {
7313        return function (f) { return window.setImmediate(f) };
7314    }
7315
7316    if (canPost) {
7317        var queue = [];
7318        window.addEventListener('message', function (ev) {
7319            var source = ev.source;
7320            if ((source === window || source === null) && ev.data === 'process-tick') {
7321                ev.stopPropagation();
7322                if (queue.length > 0) {
7323                    var fn = queue.shift();
7324                    fn();
7325                }
7326            }
7327        }, true);
7328
7329        return function nextTick(fn) {
7330            queue.push(fn);
7331            window.postMessage('process-tick', '*');
7332        };
7333    }
7334
7335    return function nextTick(fn) {
7336        setTimeout(fn, 0);
7337    };
7338})();
7339
7340process.title = 'browser';
7341process.browser = true;
7342process.env = {};
7343process.argv = [];
7344
7345process.binding = function (name) {
7346    throw new Error('process.binding is not supported');
7347}
7348
7349// TODO(shtylman)
7350process.cwd = function () { return '/' };
7351process.chdir = function (dir) {
7352    throw new Error('process.chdir is not supported');
7353};
7354
7355},{}],95:[function(require,module,exports){
7356// Copyright Joyent, Inc. and other Node contributors.
7357//
7358// Permission is hereby granted, free of charge, to any person obtaining a
7359// copy of this software and associated documentation files (the
7360// "Software"), to deal in the Software without restriction, including
7361// without limitation the rights to use, copy, modify, merge, publish,
7362// distribute, sublicense, and/or sell copies of the Software, and to permit
7363// persons to whom the Software is furnished to do so, subject to the
7364// following conditions:
7365//
7366// The above copyright notice and this permission notice shall be included
7367// in all copies or substantial portions of the Software.
7368//
7369// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
7370// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
7371// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
7372// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
7373// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
7374// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
7375// USE OR OTHER DEALINGS IN THE SOFTWARE.
7376
7377// a passthrough stream.
7378// basically just the most minimal sort of Transform stream.
7379// Every written chunk gets output as-is.
7380
7381module.exports = PassThrough;
7382
7383var Transform = require('./transform.js');
7384var inherits = require('inherits');
7385inherits(PassThrough, Transform);
7386
7387function PassThrough(options) {
7388  if (!(this instanceof PassThrough))
7389    return new PassThrough(options);
7390
7391  Transform.call(this, options);
7392}
7393
7394PassThrough.prototype._transform = function(chunk, encoding, cb) {
7395  cb(null, chunk);
7396};
7397
7398},{"./transform.js":97,"inherits":89}],96:[function(require,module,exports){
7399(function (process){
7400// Copyright Joyent, Inc. and other Node contributors.
7401//
7402// Permission is hereby granted, free of charge, to any person obtaining a
7403// copy of this software and associated documentation files (the
7404// "Software"), to deal in the Software without restriction, including
7405// without limitation the rights to use, copy, modify, merge, publish,
7406// distribute, sublicense, and/or sell copies of the Software, and to permit
7407// persons to whom the Software is furnished to do so, subject to the
7408// following conditions:
7409//
7410// The above copyright notice and this permission notice shall be included
7411// in all copies or substantial portions of the Software.
7412//
7413// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
7414// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
7415// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
7416// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
7417// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
7418// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
7419// USE OR OTHER DEALINGS IN THE SOFTWARE.
7420
7421module.exports = Readable;
7422Readable.ReadableState = ReadableState;
7423
7424var EE = require('events').EventEmitter;
7425var Stream = require('./index.js');
7426var Buffer = require('buffer').Buffer;
7427var setImmediate = require('process/browser.js').nextTick;
7428var StringDecoder;
7429
7430var inherits = require('inherits');
7431inherits(Readable, Stream);
7432
7433function ReadableState(options, stream) {
7434  options = options || {};
7435
7436  // the point at which it stops calling _read() to fill the buffer
7437  // Note: 0 is a valid value, means "don't call _read preemptively ever"
7438  var hwm = options.highWaterMark;
7439  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
7440
7441  // cast to ints.
7442  this.highWaterMark = ~~this.highWaterMark;
7443
7444  this.buffer = [];
7445  this.length = 0;
7446  this.pipes = null;
7447  this.pipesCount = 0;
7448  this.flowing = false;
7449  this.ended = false;
7450  this.endEmitted = false;
7451  this.reading = false;
7452
7453  // In streams that never have any data, and do push(null) right away,
7454  // the consumer can miss the 'end' event if they do some I/O before
7455  // consuming the stream.  So, we don't emit('end') until some reading
7456  // happens.
7457  this.calledRead = false;
7458
7459  // a flag to be able to tell if the onwrite cb is called immediately,
7460  // or on a later tick.  We set this to true at first, becuase any
7461  // actions that shouldn't happen until "later" should generally also
7462  // not happen before the first write call.
7463  this.sync = true;
7464
7465  // whenever we return null, then we set a flag to say
7466  // that we're awaiting a 'readable' event emission.
7467  this.needReadable = false;
7468  this.emittedReadable = false;
7469  this.readableListening = false;
7470
7471
7472  // object stream flag. Used to make read(n) ignore n and to
7473  // make all the buffer merging and length checks go away
7474  this.objectMode = !!options.objectMode;
7475
7476  // Crypto is kind of old and crusty.  Historically, its default string
7477  // encoding is 'binary' so we have to make this configurable.
7478  // Everything else in the universe uses 'utf8', though.
7479  this.defaultEncoding = options.defaultEncoding || 'utf8';
7480
7481  // when piping, we only care about 'readable' events that happen
7482  // after read()ing all the bytes and not getting any pushback.
7483  this.ranOut = false;
7484
7485  // the number of writers that are awaiting a drain event in .pipe()s
7486  this.awaitDrain = 0;
7487
7488  // if true, a maybeReadMore has been scheduled
7489  this.readingMore = false;
7490
7491  this.decoder = null;
7492  this.encoding = null;
7493  if (options.encoding) {
7494    if (!StringDecoder)
7495      StringDecoder = require('string_decoder').StringDecoder;
7496    this.decoder = new StringDecoder(options.encoding);
7497    this.encoding = options.encoding;
7498  }
7499}
7500
7501function Readable(options) {
7502  if (!(this instanceof Readable))
7503    return new Readable(options);
7504
7505  this._readableState = new ReadableState(options, this);
7506
7507  // legacy
7508  this.readable = true;
7509
7510  Stream.call(this);
7511}
7512
7513// Manually shove something into the read() buffer.
7514// This returns true if the highWaterMark has not been hit yet,
7515// similar to how Writable.write() returns true if you should
7516// write() some more.
7517Readable.prototype.push = function(chunk, encoding) {
7518  var state = this._readableState;
7519
7520  if (typeof chunk === 'string' && !state.objectMode) {
7521    encoding = encoding || state.defaultEncoding;
7522    if (encoding !== state.encoding) {
7523      chunk = new Buffer(chunk, encoding);
7524      encoding = '';
7525    }
7526  }
7527
7528  return readableAddChunk(this, state, chunk, encoding, false);
7529};
7530
7531// Unshift should *always* be something directly out of read()
7532Readable.prototype.unshift = function(chunk) {
7533  var state = this._readableState;
7534  return readableAddChunk(this, state, chunk, '', true);
7535};
7536
7537function readableAddChunk(stream, state, chunk, encoding, addToFront) {
7538  var er = chunkInvalid(state, chunk);
7539  if (er) {
7540    stream.emit('error', er);
7541  } else if (chunk === null || chunk === undefined) {
7542    state.reading = false;
7543    if (!state.ended)
7544      onEofChunk(stream, state);
7545  } else if (state.objectMode || chunk && chunk.length > 0) {
7546    if (state.ended && !addToFront) {
7547      var e = new Error('stream.push() after EOF');
7548      stream.emit('error', e);
7549    } else if (state.endEmitted && addToFront) {
7550      var e = new Error('stream.unshift() after end event');
7551      stream.emit('error', e);
7552    } else {
7553      if (state.decoder && !addToFront && !encoding)
7554        chunk = state.decoder.write(chunk);
7555
7556      // update the buffer info.
7557      state.length += state.objectMode ? 1 : chunk.length;
7558      if (addToFront) {
7559        state.buffer.unshift(chunk);
7560      } else {
7561        state.reading = false;
7562        state.buffer.push(chunk);
7563      }
7564
7565      if (state.needReadable)
7566        emitReadable(stream);
7567
7568      maybeReadMore(stream, state);
7569    }
7570  } else if (!addToFront) {
7571    state.reading = false;
7572  }
7573
7574  return needMoreData(state);
7575}
7576
7577
7578
7579// if it's past the high water mark, we can push in some more.
7580// Also, if we have no data yet, we can stand some
7581// more bytes.  This is to work around cases where hwm=0,
7582// such as the repl.  Also, if the push() triggered a
7583// readable event, and the user called read(largeNumber) such that
7584// needReadable was set, then we ought to push more, so that another
7585// 'readable' event will be triggered.
7586function needMoreData(state) {
7587  return !state.ended &&
7588         (state.needReadable ||
7589          state.length < state.highWaterMark ||
7590          state.length === 0);
7591}
7592
7593// backwards compatibility.
7594Readable.prototype.setEncoding = function(enc) {
7595  if (!StringDecoder)
7596    StringDecoder = require('string_decoder').StringDecoder;
7597  this._readableState.decoder = new StringDecoder(enc);
7598  this._readableState.encoding = enc;
7599};
7600
7601// Don't raise the hwm > 128MB
7602var MAX_HWM = 0x800000;
7603function roundUpToNextPowerOf2(n) {
7604  if (n >= MAX_HWM) {
7605    n = MAX_HWM;
7606  } else {
7607    // Get the next highest power of 2
7608    n--;
7609    for (var p = 1; p < 32; p <<= 1) n |= n >> p;
7610    n++;
7611  }
7612  return n;
7613}
7614
7615function howMuchToRead(n, state) {
7616  if (state.length === 0 && state.ended)
7617    return 0;
7618
7619  if (state.objectMode)
7620    return n === 0 ? 0 : 1;
7621
7622  if (isNaN(n) || n === null) {
7623    // only flow one buffer at a time
7624    if (state.flowing && state.buffer.length)
7625      return state.buffer[0].length;
7626    else
7627      return state.length;
7628  }
7629
7630  if (n <= 0)
7631    return 0;
7632
7633  // If we're asking for more than the target buffer level,
7634  // then raise the water mark.  Bump up to the next highest
7635  // power of 2, to prevent increasing it excessively in tiny
7636  // amounts.
7637  if (n > state.highWaterMark)
7638    state.highWaterMark = roundUpToNextPowerOf2(n);
7639
7640  // don't have that much.  return null, unless we've ended.
7641  if (n > state.length) {
7642    if (!state.ended) {
7643      state.needReadable = true;
7644      return 0;
7645    } else
7646      return state.length;
7647  }
7648
7649  return n;
7650}
7651
7652// you can override either this method, or the async _read(n) below.
7653Readable.prototype.read = function(n) {
7654  var state = this._readableState;
7655  state.calledRead = true;
7656  var nOrig = n;
7657
7658  if (typeof n !== 'number' || n > 0)
7659    state.emittedReadable = false;
7660
7661  // if we're doing read(0) to trigger a readable event, but we
7662  // already have a bunch of data in the buffer, then just trigger
7663  // the 'readable' event and move on.
7664  if (n === 0 &&
7665      state.needReadable &&
7666      (state.length >= state.highWaterMark || state.ended)) {
7667    emitReadable(this);
7668    return null;
7669  }
7670
7671  n = howMuchToRead(n, state);
7672
7673  // if we've ended, and we're now clear, then finish it up.
7674  if (n === 0 && state.ended) {
7675    if (state.length === 0)
7676      endReadable(this);
7677    return null;
7678  }
7679
7680  // All the actual chunk generation logic needs to be
7681  // *below* the call to _read.  The reason is that in certain
7682  // synthetic stream cases, such as passthrough streams, _read
7683  // may be a completely synchronous operation which may change
7684  // the state of the read buffer, providing enough data when
7685  // before there was *not* enough.
7686  //
7687  // So, the steps are:
7688  // 1. Figure out what the state of things will be after we do
7689  // a read from the buffer.
7690  //
7691  // 2. If that resulting state will trigger a _read, then call _read.
7692  // Note that this may be asynchronous, or synchronous.  Yes, it is
7693  // deeply ugly to write APIs this way, but that still doesn't mean
7694  // that the Readable class should behave improperly, as streams are
7695  // designed to be sync/async agnostic.
7696  // Take note if the _read call is sync or async (ie, if the read call
7697  // has returned yet), so that we know whether or not it's safe to emit
7698  // 'readable' etc.
7699  //
7700  // 3. Actually pull the requested chunks out of the buffer and return.
7701
7702  // if we need a readable event, then we need to do some reading.
7703  var doRead = state.needReadable;
7704
7705  // if we currently have less than the highWaterMark, then also read some
7706  if (state.length - n <= state.highWaterMark)
7707    doRead = true;
7708
7709  // however, if we've ended, then there's no point, and if we're already
7710  // reading, then it's unnecessary.
7711  if (state.ended || state.reading)
7712    doRead = false;
7713
7714  if (doRead) {
7715    state.reading = true;
7716    state.sync = true;
7717    // if the length is currently zero, then we *need* a readable event.
7718    if (state.length === 0)
7719      state.needReadable = true;
7720    // call internal read method
7721    this._read(state.highWaterMark);
7722    state.sync = false;
7723  }
7724
7725  // If _read called its callback synchronously, then `reading`
7726  // will be false, and we need to re-evaluate how much data we
7727  // can return to the user.
7728  if (doRead && !state.reading)
7729    n = howMuchToRead(nOrig, state);
7730
7731  var ret;
7732  if (n > 0)
7733    ret = fromList(n, state);
7734  else
7735    ret = null;
7736
7737  if (ret === null) {
7738    state.needReadable = true;
7739    n = 0;
7740  }
7741
7742  state.length -= n;
7743
7744  // If we have nothing in the buffer, then we want to know
7745  // as soon as we *do* get something into the buffer.
7746  if (state.length === 0 && !state.ended)
7747    state.needReadable = true;
7748
7749  // If we happened to read() exactly the remaining amount in the
7750  // buffer, and the EOF has been seen at this point, then make sure
7751  // that we emit 'end' on the very next tick.
7752  if (state.ended && !state.endEmitted && state.length === 0)
7753    endReadable(this);
7754
7755  return ret;
7756};
7757
7758function chunkInvalid(state, chunk) {
7759  var er = null;
7760  if (!Buffer.isBuffer(chunk) &&
7761      'string' !== typeof chunk &&
7762      chunk !== null &&
7763      chunk !== undefined &&
7764      !state.objectMode &&
7765      !er) {
7766    er = new TypeError('Invalid non-string/buffer chunk');
7767  }
7768  return er;
7769}
7770
7771
7772function onEofChunk(stream, state) {
7773  if (state.decoder && !state.ended) {
7774    var chunk = state.decoder.end();
7775    if (chunk && chunk.length) {
7776      state.buffer.push(chunk);
7777      state.length += state.objectMode ? 1 : chunk.length;
7778    }
7779  }
7780  state.ended = true;
7781
7782  // if we've ended and we have some data left, then emit
7783  // 'readable' now to make sure it gets picked up.
7784  if (state.length > 0)
7785    emitReadable(stream);
7786  else
7787    endReadable(stream);
7788}
7789
7790// Don't emit readable right away in sync mode, because this can trigger
7791// another read() call => stack overflow.  This way, it might trigger
7792// a nextTick recursion warning, but that's not so bad.
7793function emitReadable(stream) {
7794  var state = stream._readableState;
7795  state.needReadable = false;
7796  if (state.emittedReadable)
7797    return;
7798
7799  state.emittedReadable = true;
7800  if (state.sync)
7801    setImmediate(function() {
7802      emitReadable_(stream);
7803    });
7804  else
7805    emitReadable_(stream);
7806}
7807
7808function emitReadable_(stream) {
7809  stream.emit('readable');
7810}
7811
7812
7813// at this point, the user has presumably seen the 'readable' event,
7814// and called read() to consume some data.  that may have triggered
7815// in turn another _read(n) call, in which case reading = true if
7816// it's in progress.
7817// However, if we're not ended, or reading, and the length < hwm,
7818// then go ahead and try to read some more preemptively.
7819function maybeReadMore(stream, state) {
7820  if (!state.readingMore) {
7821    state.readingMore = true;
7822    setImmediate(function() {
7823      maybeReadMore_(stream, state);
7824    });
7825  }
7826}
7827
7828function maybeReadMore_(stream, state) {
7829  var len = state.length;
7830  while (!state.reading && !state.flowing && !state.ended &&
7831         state.length < state.highWaterMark) {
7832    stream.read(0);
7833    if (len === state.length)
7834      // didn't get any data, stop spinning.
7835      break;
7836    else
7837      len = state.length;
7838  }
7839  state.readingMore = false;
7840}
7841
7842// abstract method.  to be overridden in specific implementation classes.
7843// call cb(er, data) where data is <= n in length.
7844// for virtual (non-string, non-buffer) streams, "length" is somewhat
7845// arbitrary, and perhaps not very meaningful.
7846Readable.prototype._read = function(n) {
7847  this.emit('error', new Error('not implemented'));
7848};
7849
7850Readable.prototype.pipe = function(dest, pipeOpts) {
7851  var src = this;
7852  var state = this._readableState;
7853
7854  switch (state.pipesCount) {
7855    case 0:
7856      state.pipes = dest;
7857      break;
7858    case 1:
7859      state.pipes = [state.pipes, dest];
7860      break;
7861    default:
7862      state.pipes.push(dest);
7863      break;
7864  }
7865  state.pipesCount += 1;
7866
7867  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
7868              dest !== process.stdout &&
7869              dest !== process.stderr;
7870
7871  var endFn = doEnd ? onend : cleanup;
7872  if (state.endEmitted)
7873    setImmediate(endFn);
7874  else
7875    src.once('end', endFn);
7876
7877  dest.on('unpipe', onunpipe);
7878  function onunpipe(readable) {
7879    if (readable !== src) return;
7880    cleanup();
7881  }
7882
7883  function onend() {
7884    dest.end();
7885  }
7886
7887  // when the dest drains, it reduces the awaitDrain counter
7888  // on the source.  This would be more elegant with a .once()
7889  // handler in flow(), but adding and removing repeatedly is
7890  // too slow.
7891  var ondrain = pipeOnDrain(src);
7892  dest.on('drain', ondrain);
7893
7894  function cleanup() {
7895    // cleanup event handlers once the pipe is broken
7896    dest.removeListener('close', onclose);
7897    dest.removeListener('finish', onfinish);
7898    dest.removeListener('drain', ondrain);
7899    dest.removeListener('error', onerror);
7900    dest.removeListener('unpipe', onunpipe);
7901    src.removeListener('end', onend);
7902    src.removeListener('end', cleanup);
7903
7904    // if the reader is waiting for a drain event from this
7905    // specific writer, then it would cause it to never start
7906    // flowing again.
7907    // So, if this is awaiting a drain, then we just call it now.
7908    // If we don't know, then assume that we are waiting for one.
7909    if (!dest._writableState || dest._writableState.needDrain)
7910      ondrain();
7911  }
7912
7913  // if the dest has an error, then stop piping into it.
7914  // however, don't suppress the throwing behavior for this.
7915  // check for listeners before emit removes one-time listeners.
7916  var errListeners = EE.listenerCount(dest, 'error');
7917  function onerror(er) {
7918    unpipe();
7919    if (errListeners === 0 && EE.listenerCount(dest, 'error') === 0)
7920      dest.emit('error', er);
7921  }
7922  dest.once('error', onerror);
7923
7924  // Both close and finish should trigger unpipe, but only once.
7925  function onclose() {
7926    dest.removeListener('finish', onfinish);
7927    unpipe();
7928  }
7929  dest.once('close', onclose);
7930  function onfinish() {
7931    dest.removeListener('close', onclose);
7932    unpipe();
7933  }
7934  dest.once('finish', onfinish);
7935
7936  function unpipe() {
7937    src.unpipe(dest);
7938  }
7939
7940  // tell the dest that it's being piped to
7941  dest.emit('pipe', src);
7942
7943  // start the flow if it hasn't been started already.
7944  if (!state.flowing) {
7945    // the handler that waits for readable events after all
7946    // the data gets sucked out in flow.
7947    // This would be easier to follow with a .once() handler
7948    // in flow(), but that is too slow.
7949    this.on('readable', pipeOnReadable);
7950
7951    state.flowing = true;
7952    setImmediate(function() {
7953      flow(src);
7954    });
7955  }
7956
7957  return dest;
7958};
7959
7960function pipeOnDrain(src) {
7961  return function() {
7962    var dest = this;
7963    var state = src._readableState;
7964    state.awaitDrain--;
7965    if (state.awaitDrain === 0)
7966      flow(src);
7967  };
7968}
7969
7970function flow(src) {
7971  var state = src._readableState;
7972  var chunk;
7973  state.awaitDrain = 0;
7974
7975  function write(dest, i, list) {
7976    var written = dest.write(chunk);
7977    if (false === written) {
7978      state.awaitDrain++;
7979    }
7980  }
7981
7982  while (state.pipesCount && null !== (chunk = src.read())) {
7983
7984    if (state.pipesCount === 1)
7985      write(state.pipes, 0, null);
7986    else
7987      forEach(state.pipes, write);
7988
7989    src.emit('data', chunk);
7990
7991    // if anyone needs a drain, then we have to wait for that.
7992    if (state.awaitDrain > 0)
7993      return;
7994  }
7995
7996  // if every destination was unpiped, either before entering this
7997  // function, or in the while loop, then stop flowing.
7998  //
7999  // NB: This is a pretty rare edge case.
8000  if (state.pipesCount === 0) {
8001    state.flowing = false;
8002
8003    // if there were data event listeners added, then switch to old mode.
8004    if (EE.listenerCount(src, 'data') > 0)
8005      emitDataEvents(src);
8006    return;
8007  }
8008
8009  // at this point, no one needed a drain, so we just ran out of data
8010  // on the next readable event, start it over again.
8011  state.ranOut = true;
8012}
8013
8014function pipeOnReadable() {
8015  if (this._readableState.ranOut) {
8016    this._readableState.ranOut = false;
8017    flow(this);
8018  }
8019}
8020
8021
8022Readable.prototype.unpipe = function(dest) {
8023  var state = this._readableState;
8024
8025  // if we're not piping anywhere, then do nothing.
8026  if (state.pipesCount === 0)
8027    return this;
8028
8029  // just one destination.  most common case.
8030  if (state.pipesCount === 1) {
8031    // passed in one, but it's not the right one.
8032    if (dest && dest !== state.pipes)
8033      return this;
8034
8035    if (!dest)
8036      dest = state.pipes;
8037
8038    // got a match.
8039    state.pipes = null;
8040    state.pipesCount = 0;
8041    this.removeListener('readable', pipeOnReadable);
8042    state.flowing = false;
8043    if (dest)
8044      dest.emit('unpipe', this);
8045    return this;
8046  }
8047
8048  // slow case. multiple pipe destinations.
8049
8050  if (!dest) {
8051    // remove all.
8052    var dests = state.pipes;
8053    var len = state.pipesCount;
8054    state.pipes = null;
8055    state.pipesCount = 0;
8056    this.removeListener('readable', pipeOnReadable);
8057    state.flowing = false;
8058
8059    for (var i = 0; i < len; i++)
8060      dests[i].emit('unpipe', this);
8061    return this;
8062  }
8063
8064  // try to find the right one.
8065  var i = indexOf(state.pipes, dest);
8066  if (i === -1)
8067    return this;
8068
8069  state.pipes.splice(i, 1);
8070  state.pipesCount -= 1;
8071  if (state.pipesCount === 1)
8072    state.pipes = state.pipes[0];
8073
8074  dest.emit('unpipe', this);
8075
8076  return this;
8077};
8078
8079// set up data events if they are asked for
8080// Ensure readable listeners eventually get something
8081Readable.prototype.on = function(ev, fn) {
8082  var res = Stream.prototype.on.call(this, ev, fn);
8083
8084  if (ev === 'data' && !this._readableState.flowing)
8085    emitDataEvents(this);
8086
8087  if (ev === 'readable' && this.readable) {
8088    var state = this._readableState;
8089    if (!state.readableListening) {
8090      state.readableListening = true;
8091      state.emittedReadable = false;
8092      state.needReadable = true;
8093      if (!state.reading) {
8094        this.read(0);
8095      } else if (state.length) {
8096        emitReadable(this, state);
8097      }
8098    }
8099  }
8100
8101  return res;
8102};
8103Readable.prototype.addListener = Readable.prototype.on;
8104
8105// pause() and resume() are remnants of the legacy readable stream API
8106// If the user uses them, then switch into old mode.
8107Readable.prototype.resume = function() {
8108  emitDataEvents(this);
8109  this.read(0);
8110  this.emit('resume');
8111};
8112
8113Readable.prototype.pause = function() {
8114  emitDataEvents(this, true);
8115  this.emit('pause');
8116};
8117
8118function emitDataEvents(stream, startPaused) {
8119  var state = stream._readableState;
8120
8121  if (state.flowing) {
8122    // https://github.com/isaacs/readable-stream/issues/16
8123    throw new Error('Cannot switch to old mode now.');
8124  }
8125
8126  var paused = startPaused || false;
8127  var readable = false;
8128
8129  // convert to an old-style stream.
8130  stream.readable = true;
8131  stream.pipe = Stream.prototype.pipe;
8132  stream.on = stream.addListener = Stream.prototype.on;
8133
8134  stream.on('readable', function() {
8135    readable = true;
8136
8137    var c;
8138    while (!paused && (null !== (c = stream.read())))
8139      stream.emit('data', c);
8140
8141    if (c === null) {
8142      readable = false;
8143      stream._readableState.needReadable = true;
8144    }
8145  });
8146
8147  stream.pause = function() {
8148    paused = true;
8149    this.emit('pause');
8150  };
8151
8152  stream.resume = function() {
8153    paused = false;
8154    if (readable)
8155      setImmediate(function() {
8156        stream.emit('readable');
8157      });
8158    else
8159      this.read(0);
8160    this.emit('resume');
8161  };
8162
8163  // now make it start, just in case it hadn't already.
8164  stream.emit('readable');
8165}
8166
8167// wrap an old-style stream as the async data source.
8168// This is *not* part of the readable stream interface.
8169// It is an ugly unfortunate mess of history.
8170Readable.prototype.wrap = function(stream) {
8171  var state = this._readableState;
8172  var paused = false;
8173
8174  var self = this;
8175  stream.on('end', function() {
8176    if (state.decoder && !state.ended) {
8177      var chunk = state.decoder.end();
8178      if (chunk && chunk.length)
8179        self.push(chunk);
8180    }
8181
8182    self.push(null);
8183  });
8184
8185  stream.on('data', function(chunk) {
8186    if (state.decoder)
8187      chunk = state.decoder.write(chunk);
8188    if (!chunk || !state.objectMode && !chunk.length)
8189      return;
8190
8191    var ret = self.push(chunk);
8192    if (!ret) {
8193      paused = true;
8194      stream.pause();
8195    }
8196  });
8197
8198  // proxy all the other methods.
8199  // important when wrapping filters and duplexes.
8200  for (var i in stream) {
8201    if (typeof stream[i] === 'function' &&
8202        typeof this[i] === 'undefined') {
8203      this[i] = function(method) { return function() {
8204        return stream[method].apply(stream, arguments);
8205      }}(i);
8206    }
8207  }
8208
8209  // proxy certain important events.
8210  var events = ['error', 'close', 'destroy', 'pause', 'resume'];
8211  forEach(events, function(ev) {
8212    stream.on(ev, function (x) {
8213      return self.emit.apply(self, ev, x);
8214    });
8215  });
8216
8217  // when we try to consume some more bytes, simply unpause the
8218  // underlying stream.
8219  self._read = function(n) {
8220    if (paused) {
8221      paused = false;
8222      stream.resume();
8223    }
8224  };
8225
8226  return self;
8227};
8228
8229
8230
8231// exposed for testing purposes only.
8232Readable._fromList = fromList;
8233
8234// Pluck off n bytes from an array of buffers.
8235// Length is the combined lengths of all the buffers in the list.
8236function fromList(n, state) {
8237  var list = state.buffer;
8238  var length = state.length;
8239  var stringMode = !!state.decoder;
8240  var objectMode = !!state.objectMode;
8241  var ret;
8242
8243  // nothing in the list, definitely empty.
8244  if (list.length === 0)
8245    return null;
8246
8247  if (length === 0)
8248    ret = null;
8249  else if (objectMode)
8250    ret = list.shift();
8251  else if (!n || n >= length) {
8252    // read it all, truncate the array.
8253    if (stringMode)
8254      ret = list.join('');
8255    else
8256      ret = Buffer.concat(list, length);
8257    list.length = 0;
8258  } else {
8259    // read just some of it.
8260    if (n < list[0].length) {
8261      // just take a part of the first list item.
8262      // slice is the same for buffers and strings.
8263      var buf = list[0];
8264      ret = buf.slice(0, n);
8265      list[0] = buf.slice(n);
8266    } else if (n === list[0].length) {
8267      // first list is a perfect match
8268      ret = list.shift();
8269    } else {
8270      // complex case.
8271      // we have enough to cover it, but it spans past the first buffer.
8272      if (stringMode)
8273        ret = '';
8274      else
8275        ret = new Buffer(n);
8276
8277      var c = 0;
8278      for (var i = 0, l = list.length; i < l && c < n; i++) {
8279        var buf = list[0];
8280        var cpy = Math.min(n - c, buf.length);
8281
8282        if (stringMode)
8283          ret += buf.slice(0, cpy);
8284        else
8285          buf.copy(ret, c, 0, cpy);
8286
8287        if (cpy < buf.length)
8288          list[0] = buf.slice(cpy);
8289        else
8290          list.shift();
8291
8292        c += cpy;
8293      }
8294    }
8295  }
8296
8297  return ret;
8298}
8299
8300function endReadable(stream) {
8301  var state = stream._readableState;
8302
8303  // If we get here before consuming all the bytes, then that is a
8304  // bug in node.  Should never happen.
8305  if (state.length > 0)
8306    throw new Error('endReadable called on non-empty stream');
8307
8308  if (!state.endEmitted && state.calledRead) {
8309    state.ended = true;
8310    setImmediate(function() {
8311      // Check that we didn't get one last unshift.
8312      if (!state.endEmitted && state.length === 0) {
8313        state.endEmitted = true;
8314        stream.readable = false;
8315        stream.emit('end');
8316      }
8317    });
8318  }
8319}
8320
8321function forEach (xs, f) {
8322  for (var i = 0, l = xs.length; i < l; i++) {
8323    f(xs[i], i);
8324  }
8325}
8326
8327function indexOf (xs, x) {
8328  for (var i = 0, l = xs.length; i < l; i++) {
8329    if (xs[i] === x) return i;
8330  }
8331  return -1;
8332}
8333
8334}).call(this,require("KliubH"))
8335},{"./index.js":93,"KliubH":91,"buffer":86,"events":87,"inherits":89,"process/browser.js":94,"string_decoder":99}],97:[function(require,module,exports){
8336// Copyright Joyent, Inc. and other Node contributors.
8337//
8338// Permission is hereby granted, free of charge, to any person obtaining a
8339// copy of this software and associated documentation files (the
8340// "Software"), to deal in the Software without restriction, including
8341// without limitation the rights to use, copy, modify, merge, publish,
8342// distribute, sublicense, and/or sell copies of the Software, and to permit
8343// persons to whom the Software is furnished to do so, subject to the
8344// following conditions:
8345//
8346// The above copyright notice and this permission notice shall be included
8347// in all copies or substantial portions of the Software.
8348//
8349// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
8350// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
8351// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
8352// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
8353// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
8354// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
8355// USE OR OTHER DEALINGS IN THE SOFTWARE.
8356
8357// a transform stream is a readable/writable stream where you do
8358// something with the data.  Sometimes it's called a "filter",
8359// but that's not a great name for it, since that implies a thing where
8360// some bits pass through, and others are simply ignored.  (That would
8361// be a valid example of a transform, of course.)
8362//
8363// While the output is causally related to the input, it's not a
8364// necessarily symmetric or synchronous transformation.  For example,
8365// a zlib stream might take multiple plain-text writes(), and then
8366// emit a single compressed chunk some time in the future.
8367//
8368// Here's how this works:
8369//
8370// The Transform stream has all the aspects of the readable and writable
8371// stream classes.  When you write(chunk), that calls _write(chunk,cb)
8372// internally, and returns false if there's a lot of pending writes
8373// buffered up.  When you call read(), that calls _read(n) until
8374// there's enough pending readable data buffered up.
8375//
8376// In a transform stream, the written data is placed in a buffer.  When
8377// _read(n) is called, it transforms the queued up data, calling the
8378// buffered _write cb's as it consumes chunks.  If consuming a single
8379// written chunk would result in multiple output chunks, then the first
8380// outputted bit calls the readcb, and subsequent chunks just go into
8381// the read buffer, and will cause it to emit 'readable' if necessary.
8382//
8383// This way, back-pressure is actually determined by the reading side,
8384// since _read has to be called to start processing a new chunk.  However,
8385// a pathological inflate type of transform can cause excessive buffering
8386// here.  For example, imagine a stream where every byte of input is
8387// interpreted as an integer from 0-255, and then results in that many
8388// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
8389// 1kb of data being output.  In this case, you could write a very small
8390// amount of input, and end up with a very large amount of output.  In
8391// such a pathological inflating mechanism, there'd be no way to tell
8392// the system to stop doing the transform.  A single 4MB write could
8393// cause the system to run out of memory.
8394//
8395// However, even in such a pathological case, only a single written chunk
8396// would be consumed, and then the rest would wait (un-transformed) until
8397// the results of the previous transformed chunk were consumed.
8398
8399module.exports = Transform;
8400
8401var Duplex = require('./duplex.js');
8402var inherits = require('inherits');
8403inherits(Transform, Duplex);
8404
8405
8406function TransformState(options, stream) {
8407  this.afterTransform = function(er, data) {
8408    return afterTransform(stream, er, data);
8409  };
8410
8411  this.needTransform = false;
8412  this.transforming = false;
8413  this.writecb = null;
8414  this.writechunk = null;
8415}
8416
8417function afterTransform(stream, er, data) {
8418  var ts = stream._transformState;
8419  ts.transforming = false;
8420
8421  var cb = ts.writecb;
8422
8423  if (!cb)
8424    return stream.emit('error', new Error('no writecb in Transform class'));
8425
8426  ts.writechunk = null;
8427  ts.writecb = null;
8428
8429  if (data !== null && data !== undefined)
8430    stream.push(data);
8431
8432  if (cb)
8433    cb(er);
8434
8435  var rs = stream._readableState;
8436  rs.reading = false;
8437  if (rs.needReadable || rs.length < rs.highWaterMark) {
8438    stream._read(rs.highWaterMark);
8439  }
8440}
8441
8442
8443function Transform(options) {
8444  if (!(this instanceof Transform))
8445    return new Transform(options);
8446
8447  Duplex.call(this, options);
8448
8449  var ts = this._transformState = new TransformState(options, this);
8450
8451  // when the writable side finishes, then flush out anything remaining.
8452  var stream = this;
8453
8454  // start out asking for a readable event once data is transformed.
8455  this._readableState.needReadable = true;
8456
8457  // we have implemented the _read method, and done the other things
8458  // that Readable wants before the first _read call, so unset the
8459  // sync guard flag.
8460  this._readableState.sync = false;
8461
8462  this.once('finish', function() {
8463    if ('function' === typeof this._flush)
8464      this._flush(function(er) {
8465        done(stream, er);
8466      });
8467    else
8468      done(stream);
8469  });
8470}
8471
8472Transform.prototype.push = function(chunk, encoding) {
8473  this._transformState.needTransform = false;
8474  return Duplex.prototype.push.call(this, chunk, encoding);
8475};
8476
8477// This is the part where you do stuff!
8478// override this function in implementation classes.
8479// 'chunk' is an input chunk.
8480//
8481// Call `push(newChunk)` to pass along transformed output
8482// to the readable side.  You may call 'push' zero or more times.
8483//
8484// Call `cb(err)` when you are done with this chunk.  If you pass
8485// an error, then that'll put the hurt on the whole operation.  If you
8486// never call cb(), then you'll never get another chunk.
8487Transform.prototype._transform = function(chunk, encoding, cb) {
8488  throw new Error('not implemented');
8489};
8490
8491Transform.prototype._write = function(chunk, encoding, cb) {
8492  var ts = this._transformState;
8493  ts.writecb = cb;
8494  ts.writechunk = chunk;
8495  ts.writeencoding = encoding;
8496  if (!ts.transforming) {
8497    var rs = this._readableState;
8498    if (ts.needTransform ||
8499        rs.needReadable ||
8500        rs.length < rs.highWaterMark)
8501      this._read(rs.highWaterMark);
8502  }
8503};
8504
8505// Doesn't matter what the args are here.
8506// _transform does all the work.
8507// That we got here means that the readable side wants more data.
8508Transform.prototype._read = function(n) {
8509  var ts = this._transformState;
8510
8511  if (ts.writechunk && ts.writecb && !ts.transforming) {
8512    ts.transforming = true;
8513    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
8514  } else {
8515    // mark that we need a transform, so that any data that comes in
8516    // will get processed, now that we've asked for it.
8517    ts.needTransform = true;
8518  }
8519};
8520
8521
8522function done(stream, er) {
8523  if (er)
8524    return stream.emit('error', er);
8525
8526  // if there's nothing in the write buffer, then that means
8527  // that nothing more will ever be provided
8528  var ws = stream._writableState;
8529  var rs = stream._readableState;
8530  var ts = stream._transformState;
8531
8532  if (ws.length)
8533    throw new Error('calling transform done when ws.length != 0');
8534
8535  if (ts.transforming)
8536    throw new Error('calling transform done when still transforming');
8537
8538  return stream.push(null);
8539}
8540
8541},{"./duplex.js":92,"inherits":89}],98:[function(require,module,exports){
8542// Copyright Joyent, Inc. and other Node contributors.
8543//
8544// Permission is hereby granted, free of charge, to any person obtaining a
8545// copy of this software and associated documentation files (the
8546// "Software"), to deal in the Software without restriction, including
8547// without limitation the rights to use, copy, modify, merge, publish,
8548// distribute, sublicense, and/or sell copies of the Software, and to permit
8549// persons to whom the Software is furnished to do so, subject to the
8550// following conditions:
8551//
8552// The above copyright notice and this permission notice shall be included
8553// in all copies or substantial portions of the Software.
8554//
8555// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
8556// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
8557// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
8558// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
8559// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
8560// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
8561// USE OR OTHER DEALINGS IN THE SOFTWARE.
8562
8563// A bit simpler than readable streams.
8564// Implement an async ._write(chunk, cb), and it'll handle all
8565// the drain event emission and buffering.
8566
8567module.exports = Writable;
8568Writable.WritableState = WritableState;
8569
8570var isUint8Array = typeof Uint8Array !== 'undefined'
8571  ? function (x) { return x instanceof Uint8Array }
8572  : function (x) {
8573    return x && x.constructor && x.constructor.name === 'Uint8Array'
8574  }
8575;
8576var isArrayBuffer = typeof ArrayBuffer !== 'undefined'
8577  ? function (x) { return x instanceof ArrayBuffer }
8578  : function (x) {
8579    return x && x.constructor && x.constructor.name === 'ArrayBuffer'
8580  }
8581;
8582
8583var inherits = require('inherits');
8584var Stream = require('./index.js');
8585var setImmediate = require('process/browser.js').nextTick;
8586var Buffer = require('buffer').Buffer;
8587
8588inherits(Writable, Stream);
8589
8590function WriteReq(chunk, encoding, cb) {
8591  this.chunk = chunk;
8592  this.encoding = encoding;
8593  this.callback = cb;
8594}
8595
8596function WritableState(options, stream) {
8597  options = options || {};
8598
8599  // the point at which write() starts returning false
8600  // Note: 0 is a valid value, means that we always return false if
8601  // the entire buffer is not flushed immediately on write()
8602  var hwm = options.highWaterMark;
8603  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
8604
8605  // object stream flag to indicate whether or not this stream
8606  // contains buffers or objects.
8607  this.objectMode = !!options.objectMode;
8608
8609  // cast to ints.
8610  this.highWaterMark = ~~this.highWaterMark;
8611
8612  this.needDrain = false;
8613  // at the start of calling end()
8614  this.ending = false;
8615  // when end() has been called, and returned
8616  this.ended = false;
8617  // when 'finish' is emitted
8618  this.finished = false;
8619
8620  // should we decode strings into buffers before passing to _write?
8621  // this is here so that some node-core streams can optimize string
8622  // handling at a lower level.
8623  var noDecode = options.decodeStrings === false;
8624  this.decodeStrings = !noDecode;
8625
8626  // Crypto is kind of old and crusty.  Historically, its default string
8627  // encoding is 'binary' so we have to make this configurable.
8628  // Everything else in the universe uses 'utf8', though.
8629  this.defaultEncoding = options.defaultEncoding || 'utf8';
8630
8631  // not an actual buffer we keep track of, but a measurement
8632  // of how much we're waiting to get pushed to some underlying
8633  // socket or file.
8634  this.length = 0;
8635
8636  // a flag to see when we're in the middle of a write.
8637  this.writing = false;
8638
8639  // a flag to be able to tell if the onwrite cb is called immediately,
8640  // or on a later tick.  We set this to true at first, becuase any
8641  // actions that shouldn't happen until "later" should generally also
8642  // not happen before the first write call.
8643  this.sync = true;
8644
8645  // a flag to know if we're processing previously buffered items, which
8646  // may call the _write() callback in the same tick, so that we don't
8647  // end up in an overlapped onwrite situation.
8648  this.bufferProcessing = false;
8649
8650  // the callback that's passed to _write(chunk,cb)
8651  this.onwrite = function(er) {
8652    onwrite(stream, er);
8653  };
8654
8655  // the callback that the user supplies to write(chunk,encoding,cb)
8656  this.writecb = null;
8657
8658  // the amount that is being written when _write is called.
8659  this.writelen = 0;
8660
8661  this.buffer = [];
8662}
8663
8664function Writable(options) {
8665  // Writable ctor is applied to Duplexes, though they're not
8666  // instanceof Writable, they're instanceof Readable.
8667  if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
8668    return new Writable(options);
8669
8670  this._writableState = new WritableState(options, this);
8671
8672  // legacy.
8673  this.writable = true;
8674
8675  Stream.call(this);
8676}
8677
8678// Otherwise people can pipe Writable streams, which is just wrong.
8679Writable.prototype.pipe = function() {
8680  this.emit('error', new Error('Cannot pipe. Not readable.'));
8681};
8682
8683
8684function writeAfterEnd(stream, state, cb) {
8685  var er = new Error('write after end');
8686  // TODO: defer error events consistently everywhere, not just the cb
8687  stream.emit('error', er);
8688  setImmediate(function() {
8689    cb(er);
8690  });
8691}
8692
8693// If we get something that is not a buffer, string, null, or undefined,
8694// and we're not in objectMode, then that's an error.
8695// Otherwise stream chunks are all considered to be of length=1, and the
8696// watermarks determine how many objects to keep in the buffer, rather than
8697// how many bytes or characters.
8698function validChunk(stream, state, chunk, cb) {
8699  var valid = true;
8700  if (!Buffer.isBuffer(chunk) &&
8701      'string' !== typeof chunk &&
8702      chunk !== null &&
8703      chunk !== undefined &&
8704      !state.objectMode) {
8705    var er = new TypeError('Invalid non-string/buffer chunk');
8706    stream.emit('error', er);
8707    setImmediate(function() {
8708      cb(er);
8709    });
8710    valid = false;
8711  }
8712  return valid;
8713}
8714
8715Writable.prototype.write = function(chunk, encoding, cb) {
8716  var state = this._writableState;
8717  var ret = false;
8718
8719  if (typeof encoding === 'function') {
8720    cb = encoding;
8721    encoding = null;
8722  }
8723
8724  if (!Buffer.isBuffer(chunk) && isUint8Array(chunk))
8725    chunk = new Buffer(chunk);
8726  if (isArrayBuffer(chunk) && typeof Uint8Array !== 'undefined')
8727    chunk = new Buffer(new Uint8Array(chunk));
8728  
8729  if (Buffer.isBuffer(chunk))
8730    encoding = 'buffer';
8731  else if (!encoding)
8732    encoding = state.defaultEncoding;
8733
8734  if (typeof cb !== 'function')
8735    cb = function() {};
8736
8737  if (state.ended)
8738    writeAfterEnd(this, state, cb);
8739  else if (validChunk(this, state, chunk, cb))
8740    ret = writeOrBuffer(this, state, chunk, encoding, cb);
8741
8742  return ret;
8743};
8744
8745function decodeChunk(state, chunk, encoding) {
8746  if (!state.objectMode &&
8747      state.decodeStrings !== false &&
8748      typeof chunk === 'string') {
8749    chunk = new Buffer(chunk, encoding);
8750  }
8751  return chunk;
8752}
8753
8754// if we're already writing something, then just put this
8755// in the queue, and wait our turn.  Otherwise, call _write
8756// If we return false, then we need a drain event, so set that flag.
8757function writeOrBuffer(stream, state, chunk, encoding, cb) {
8758  chunk = decodeChunk(state, chunk, encoding);
8759  var len = state.objectMode ? 1 : chunk.length;
8760
8761  state.length += len;
8762
8763  var ret = state.length < state.highWaterMark;
8764  state.needDrain = !ret;
8765
8766  if (state.writing)
8767    state.buffer.push(new WriteReq(chunk, encoding, cb));
8768  else
8769    doWrite(stream, state, len, chunk, encoding, cb);
8770
8771  return ret;
8772}
8773
8774function doWrite(stream, state, len, chunk, encoding, cb) {
8775  state.writelen = len;
8776  state.writecb = cb;
8777  state.writing = true;
8778  state.sync = true;
8779  stream._write(chunk, encoding, state.onwrite);
8780  state.sync = false;
8781}
8782
8783function onwriteError(stream, state, sync, er, cb) {
8784  if (sync)
8785    setImmediate(function() {
8786      cb(er);
8787    });
8788  else
8789    cb(er);
8790
8791  stream.emit('error', er);
8792}
8793
8794function onwriteStateUpdate(state) {
8795  state.writing = false;
8796  state.writecb = null;
8797  state.length -= state.writelen;
8798  state.writelen = 0;
8799}
8800
8801function onwrite(stream, er) {
8802  var state = stream._writableState;
8803  var sync = state.sync;
8804  var cb = state.writecb;
8805
8806  onwriteStateUpdate(state);
8807
8808  if (er)
8809    onwriteError(stream, state, sync, er, cb);
8810  else {
8811    // Check if we're actually ready to finish, but don't emit yet
8812    var finished = needFinish(stream, state);
8813
8814    if (!finished && !state.bufferProcessing && state.buffer.length)
8815      clearBuffer(stream, state);
8816
8817    if (sync) {
8818      setImmediate(function() {
8819        afterWrite(stream, state, finished, cb);
8820      });
8821    } else {
8822      afterWrite(stream, state, finished, cb);
8823    }
8824  }
8825}
8826
8827function afterWrite(stream, state, finished, cb) {
8828  if (!finished)
8829    onwriteDrain(stream, state);
8830  cb();
8831  if (finished)
8832    finishMaybe(stream, state);
8833}
8834
8835// Must force callback to be called on nextTick, so that we don't
8836// emit 'drain' before the write() consumer gets the 'false' return
8837// value, and has a chance to attach a 'drain' listener.
8838function onwriteDrain(stream, state) {
8839  if (state.length === 0 && state.needDrain) {
8840    state.needDrain = false;
8841    stream.emit('drain');
8842  }
8843}
8844
8845
8846// if there's something in the buffer waiting, then process it
8847function clearBuffer(stream, state) {
8848  state.bufferProcessing = true;
8849
8850  for (var c = 0; c < state.buffer.length; c++) {
8851    var entry = state.buffer[c];
8852    var chunk = entry.chunk;
8853    var encoding = entry.encoding;
8854    var cb = entry.callback;
8855    var len = state.objectMode ? 1 : chunk.length;
8856
8857    doWrite(stream, state, len, chunk, encoding, cb);
8858
8859    // if we didn't call the onwrite immediately, then
8860    // it means that we need to wait until it does.
8861    // also, that means that the chunk and cb are currently
8862    // being processed, so move the buffer counter past them.
8863    if (state.writing) {
8864      c++;
8865      break;
8866    }
8867  }
8868
8869  state.bufferProcessing = false;
8870  if (c < state.buffer.length)
8871    state.buffer = state.buffer.slice(c);
8872  else
8873    state.buffer.length = 0;
8874}
8875
8876Writable.prototype._write = function(chunk, encoding, cb) {
8877  cb(new Error('not implemented'));
8878};
8879
8880Writable.prototype.end = function(chunk, encoding, cb) {
8881  var state = this._writableState;
8882
8883  if (typeof chunk === 'function') {
8884    cb = chunk;
8885    chunk = null;
8886    encoding = null;
8887  } else if (typeof encoding === 'function') {
8888    cb = encoding;
8889    encoding = null;
8890  }
8891
8892  if (typeof chunk !== 'undefined' && chunk !== null)
8893    this.write(chunk, encoding);
8894
8895  // ignore unnecessary end() calls.
8896  if (!state.ending && !state.finished)
8897    endWritable(this, state, cb);
8898};
8899
8900
8901function needFinish(stream, state) {
8902  return (state.ending &&
8903          state.length === 0 &&
8904          !state.finished &&
8905          !state.writing);
8906}
8907
8908function finishMaybe(stream, state) {
8909  var need = needFinish(stream, state);
8910  if (need) {
8911    state.finished = true;
8912    stream.emit('finish');
8913  }
8914  return need;
8915}
8916
8917function endWritable(stream, state, cb) {
8918  state.ending = true;
8919  finishMaybe(stream, state);
8920  if (cb) {
8921    if (state.finished)
8922      setImmediate(cb);
8923    else
8924      stream.once('finish', cb);
8925  }
8926  state.ended = true;
8927}
8928
8929},{"./index.js":93,"buffer":86,"inherits":89,"process/browser.js":94}],99:[function(require,module,exports){
8930// Copyright Joyent, Inc. and other Node contributors.
8931//
8932// Permission is hereby granted, free of charge, to any person obtaining a
8933// copy of this software and associated documentation files (the
8934// "Software"), to deal in the Software without restriction, including
8935// without limitation the rights to use, copy, modify, merge, publish,
8936// distribute, sublicense, and/or sell copies of the Software, and to permit
8937// persons to whom the Software is furnished to do so, subject to the
8938// following conditions:
8939//
8940// The above copyright notice and this permission notice shall be included
8941// in all copies or substantial portions of the Software.
8942//
8943// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
8944// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
8945// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
8946// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
8947// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
8948// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
8949// USE OR OTHER DEALINGS IN THE SOFTWARE.
8950
8951var Buffer = require('buffer').Buffer;
8952
8953function assertEncoding(encoding) {
8954  if (encoding && !Buffer.isEncoding(encoding)) {
8955    throw new Error('Unknown encoding: ' + encoding);
8956  }
8957}
8958
8959var StringDecoder = exports.StringDecoder = function(encoding) {
8960  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
8961  assertEncoding(encoding);
8962  switch (this.encoding) {
8963    case 'utf8':
8964      // CESU-8 represents each of Surrogate Pair by 3-bytes
8965      this.surrogateSize = 3;
8966      break;
8967    case 'ucs2':
8968    case 'utf16le':
8969      // UTF-16 represents each of Surrogate Pair by 2-bytes
8970      this.surrogateSize = 2;
8971      this.detectIncompleteChar = utf16DetectIncompleteChar;
8972      break;
8973    case 'base64':
8974      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
8975      this.surrogateSize = 3;
8976      this.detectIncompleteChar = base64DetectIncompleteChar;
8977      break;
8978    default:
8979      this.write = passThroughWrite;
8980      return;
8981  }
8982
8983  this.charBuffer = new Buffer(6);
8984  this.charReceived = 0;
8985  this.charLength = 0;
8986};
8987
8988
8989StringDecoder.prototype.write = function(buffer) {
8990  var charStr = '';
8991  var offset = 0;
8992
8993  // if our last write ended with an incomplete multibyte character
8994  while (this.charLength) {
8995    // determine how many remaining bytes this buffer has to offer for this char
8996    var i = (buffer.length >= this.charLength - this.charReceived) ?
8997                this.charLength - this.charReceived :
8998                buffer.length;
8999
9000    // add the new bytes to the char buffer
9001    buffer.copy(this.charBuffer, this.charReceived, offset, i);
9002    this.charReceived += (i - offset);
9003    offset = i;
9004
9005    if (this.charReceived < this.charLength) {
9006      // still not enough chars in this buffer? wait for more ...
9007      return '';
9008    }
9009
9010    // get the character that was split
9011    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
9012
9013    // lead surrogate (D800-DBFF) is also the incomplete character
9014    var charCode = charStr.charCodeAt(charStr.length - 1);
9015    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
9016      this.charLength += this.surrogateSize;
9017      charStr = '';
9018      continue;
9019    }
9020    this.charReceived = this.charLength = 0;
9021
9022    // if there are no more bytes in this buffer, just emit our char
9023    if (i == buffer.length) return charStr;
9024
9025    // otherwise cut off the characters end from the beginning of this buffer
9026    buffer = buffer.slice(i, buffer.length);
9027    break;
9028  }
9029
9030  var lenIncomplete = this.detectIncompleteChar(buffer);
9031
9032  var end = buffer.length;
9033  if (this.charLength) {
9034    // buffer the incomplete character bytes we got
9035    buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
9036    this.charReceived = lenIncomplete;
9037    end -= lenIncomplete;
9038  }
9039
9040  charStr += buffer.toString(this.encoding, 0, end);
9041
9042  var end = charStr.length - 1;
9043  var charCode = charStr.charCodeAt(end);
9044  // lead surrogate (D800-DBFF) is also the incomplete character
9045  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
9046    var size = this.surrogateSize;
9047    this.charLength += size;
9048    this.charReceived += size;
9049    this.charBuffer.copy(this.charBuffer, size, 0, size);
9050    this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
9051    return charStr.substring(0, end);
9052  }
9053
9054  // or just emit the charStr
9055  return charStr;
9056};
9057
9058StringDecoder.prototype.detectIncompleteChar = function(buffer) {
9059  // determine how many bytes we have to check at the end of this buffer
9060  var i = (buffer.length >= 3) ? 3 : buffer.length;
9061
9062  // Figure out if one of the last i bytes of our buffer announces an
9063  // incomplete char.
9064  for (; i > 0; i--) {
9065    var c = buffer[buffer.length - i];
9066
9067    // See http://en.wikipedia.org/wiki/UTF-8#Description
9068
9069    // 110XXXXX
9070    if (i == 1 && c >> 5 == 0x06) {
9071      this.charLength = 2;
9072      break;
9073    }
9074
9075    // 1110XXXX
9076    if (i <= 2 && c >> 4 == 0x0E) {
9077      this.charLength = 3;
9078      break;
9079    }
9080
9081    // 11110XXX
9082    if (i <= 3 && c >> 3 == 0x1E) {
9083      this.charLength = 4;
9084      break;
9085    }
9086  }
9087
9088  return i;
9089};
9090
9091StringDecoder.prototype.end = function(buffer) {
9092  var res = '';
9093  if (buffer && buffer.length)
9094    res = this.write(buffer);
9095
9096  if (this.charReceived) {
9097    var cr = this.charReceived;
9098    var buf = this.charBuffer;
9099    var enc = this.encoding;
9100    res += buf.slice(0, cr).toString(enc);
9101  }
9102
9103  return res;
9104};
9105
9106function passThroughWrite(buffer) {
9107  return buffer.toString(this.encoding);
9108}
9109
9110function utf16DetectIncompleteChar(buffer) {
9111  var incomplete = this.charReceived = buffer.length % 2;
9112  this.charLength = incomplete ? 2 : 0;
9113  return incomplete;
9114}
9115
9116function base64DetectIncompleteChar(buffer) {
9117  var incomplete = this.charReceived = buffer.length % 3;
9118  this.charLength = incomplete ? 3 : 0;
9119  return incomplete;
9120}
9121
9122},{"buffer":86}],100:[function(require,module,exports){
9123if (typeof Object.create === 'function') {
9124  // implementation from standard node.js 'util' module
9125  module.exports = function inherits(ctor, superCtor) {
9126    ctor.super_ = superCtor
9127    ctor.prototype = Object.create(superCtor.prototype, {
9128      constructor: {
9129        value: ctor,
9130        enumerable: false,
9131        writable: true,
9132        configurable: true
9133      }
9134    });
9135  };
9136} else {
9137  // old school shim for old browsers
9138  module.exports = function inherits(ctor, superCtor) {
9139    ctor.super_ = superCtor
9140    var TempCtor = function () {}
9141    TempCtor.prototype = superCtor.prototype
9142    ctor.prototype = new TempCtor()
9143    ctor.prototype.constructor = ctor
9144  }
9145}
9146
9147},{}],101:[function(require,module,exports){
9148module.exports = function isBuffer(arg) {
9149  return arg && typeof arg === 'object'
9150    && typeof arg.copy === 'function'
9151    && typeof arg.fill === 'function'
9152    && typeof arg.readUInt8 === 'function';
9153}
9154},{}],102:[function(require,module,exports){
9155(function (process,global){
9156// Copyright Joyent, Inc. and other Node contributors.
9157//
9158// Permission is hereby granted, free of charge, to any person obtaining a
9159// copy of this software and associated documentation files (the
9160// "Software"), to deal in the Software without restriction, including
9161// without limitation the rights to use, copy, modify, merge, publish,
9162// distribute, sublicense, and/or sell copies of the Software, and to permit
9163// persons to whom the Software is furnished to do so, subject to the
9164// following conditions:
9165//
9166// The above copyright notice and this permission notice shall be included
9167// in all copies or substantial portions of the Software.
9168//
9169// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
9170// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
9171// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
9172// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
9173// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
9174// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
9175// USE OR OTHER DEALINGS IN THE SOFTWARE.
9176
9177var formatRegExp = /%[sdj%]/g;
9178exports.format = function(f) {
9179  if (!isString(f)) {
9180    var objects = [];
9181    for (var i = 0; i < arguments.length; i++) {
9182      objects.push(inspect(arguments[i]));
9183    }
9184    return objects.join(' ');
9185  }
9186
9187  var i = 1;
9188  var args = arguments;
9189  var len = args.length;
9190  var str = String(f).replace(formatRegExp, function(x) {
9191    if (x === '%%') return '%';
9192    if (i >= len) return x;
9193    switch (x) {
9194      case '%s': return String(args[i++]);
9195      case '%d': return Number(args[i++]);
9196      case '%j':
9197        try {
9198          return JSON.stringify(args[i++]);
9199        } catch (_) {
9200          return '[Circular]';
9201        }
9202      default:
9203        return x;
9204    }
9205  });
9206  for (var x = args[i]; i < len; x = args[++i]) {
9207    if (isNull(x) || !isObject(x)) {
9208      str += ' ' + x;
9209    } else {
9210      str += ' ' + inspect(x);
9211    }
9212  }
9213  return str;
9214};
9215
9216
9217// Mark that a method should not be used.
9218// Returns a modified function which warns once by default.
9219// If --no-deprecation is set, then it is a no-op.
9220exports.deprecate = function(fn, msg) {
9221  // Allow for deprecating things in the process of starting up.
9222  if (isUndefined(global.process)) {
9223    return function() {
9224      return exports.deprecate(fn, msg).apply(this, arguments);
9225    };
9226  }
9227
9228  if (process.noDeprecation === true) {
9229    return fn;
9230  }
9231
9232  var warned = false;
9233  function deprecated() {
9234    if (!warned) {
9235      if (process.throwDeprecation) {
9236        throw new Error(msg);
9237      } else if (process.traceDeprecation) {
9238        console.trace(msg);
9239      } else {
9240        console.error(msg);
9241      }
9242      warned = true;
9243    }
9244    return fn.apply(this, arguments);
9245  }
9246
9247  return deprecated;
9248};
9249
9250
9251var debugs = {};
9252var debugEnviron;
9253exports.debuglog = function(set) {
9254  if (isUndefined(debugEnviron))
9255    debugEnviron = process.env.NODE_DEBUG || '';
9256  set = set.toUpperCase();
9257  if (!debugs[set]) {
9258    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
9259      var pid = process.pid;
9260      debugs[set] = function() {
9261        var msg = exports.format.apply(exports, arguments);
9262        console.error('%s %d: %s', set, pid, msg);
9263      };
9264    } else {
9265      debugs[set] = function() {};
9266    }
9267  }
9268  return debugs[set];
9269};
9270
9271
9272/**
9273 * Echos the value of a value. Trys to print the value out
9274 * in the best way possible given the different types.
9275 *
9276 * @param {Object} obj The object to print out.
9277 * @param {Object} opts Optional options object that alters the output.
9278 */
9279/* legacy: obj, showHidden, depth, colors*/
9280function inspect(obj, opts) {
9281  // default options
9282  var ctx = {
9283    seen: [],
9284    stylize: stylizeNoColor
9285  };
9286  // legacy...
9287  if (arguments.length >= 3) ctx.depth = arguments[2];
9288  if (arguments.length >= 4) ctx.colors = arguments[3];
9289  if (isBoolean(opts)) {
9290    // legacy...
9291    ctx.showHidden = opts;
9292  } else if (opts) {
9293    // got an "options" object
9294    exports._extend(ctx, opts);
9295  }
9296  // set default options
9297  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
9298  if (isUndefined(ctx.depth)) ctx.depth = 2;
9299  if (isUndefined(ctx.colors)) ctx.colors = false;
9300  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
9301  if (ctx.colors) ctx.stylize = stylizeWithColor;
9302  return formatValue(ctx, obj, ctx.depth);
9303}
9304exports.inspect = inspect;
9305
9306
9307// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
9308inspect.colors = {
9309  'bold' : [1, 22],
9310  'italic' : [3, 23],
9311  'underline' : [4, 24],
9312  'inverse' : [7, 27],
9313  'white' : [37, 39],
9314  'grey' : [90, 39],
9315  'black' : [30, 39],
9316  'blue' : [34, 39],
9317  'cyan' : [36, 39],
9318  'green' : [32, 39],
9319  'magenta' : [35, 39],
9320  'red' : [31, 39],
9321  'yellow' : [33, 39]
9322};
9323
9324// Don't use 'blue' not visible on cmd.exe
9325inspect.styles = {
9326  'special': 'cyan',
9327  'number': 'yellow',
9328  'boolean': 'yellow',
9329  'undefined': 'grey',
9330  'null': 'bold',
9331  'string': 'green',
9332  'date': 'magenta',
9333  // "name": intentionally not styling
9334  'regexp': 'red'
9335};
9336
9337
9338function stylizeWithColor(str, styleType) {
9339  var style = inspect.styles[styleType];
9340
9341  if (style) {
9342    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
9343           '\u001b[' + inspect.colors[style][1] + 'm';
9344  } else {
9345    return str;
9346  }
9347}
9348
9349
9350function stylizeNoColor(str, styleType) {
9351  return str;
9352}
9353
9354
9355function arrayToHash(array) {
9356  var hash = {};
9357
9358  array.forEach(function(val, idx) {
9359    hash[val] = true;
9360  });
9361
9362  return hash;
9363}
9364
9365
9366function formatValue(ctx, value, recurseTimes) {
9367  // Provide a hook for user-specified inspect functions.
9368  // Check that value is an object with an inspect function on it
9369  if (ctx.customInspect &&
9370      value &&
9371      isFunction(value.inspect) &&
9372      // Filter out the util module, it's inspect function is special
9373      value.inspect !== exports.inspect &&
9374      // Also filter out any prototype objects using the circular check.
9375      !(value.constructor && value.constructor.prototype === value)) {
9376    var ret = value.inspect(recurseTimes, ctx);
9377    if (!isString(ret)) {
9378      ret = formatValue(ctx, ret, recurseTimes);
9379    }
9380    return ret;
9381  }
9382
9383  // Primitive types cannot have properties
9384  var primitive = formatPrimitive(ctx, value);
9385  if (primitive) {
9386    return primitive;
9387  }
9388
9389  // Look up the keys of the object.
9390  var keys = Object.keys(value);
9391  var visibleKeys = arrayToHash(keys);
9392
9393  if (ctx.showHidden) {
9394    keys = Object.getOwnPropertyNames(value);
9395  }
9396
9397  // IE doesn't make error fields non-enumerable
9398  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
9399  if (isError(value)
9400      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
9401    return formatError(value);
9402  }
9403
9404  // Some type of object without properties can be shortcutted.
9405  if (keys.length === 0) {
9406    if (isFunction(value)) {
9407      var name = value.name ? ': ' + value.name : '';
9408      return ctx.stylize('[Function' + name + ']', 'special');
9409    }
9410    if (isRegExp(value)) {
9411      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
9412    }
9413    if (isDate(value)) {
9414      return ctx.stylize(Date.prototype.toString.call(value), 'date');
9415    }
9416    if (isError(value)) {
9417      return formatError(value);
9418    }
9419  }
9420
9421  var base = '', array = false, braces = ['{', '}'];
9422
9423  // Make Array say that they are Array
9424  if (isArray(value)) {
9425    array = true;
9426    braces = ['[', ']'];
9427  }
9428
9429  // Make functions say that they are functions
9430  if (isFunction(value)) {
9431    var n = value.name ? ': ' + value.name : '';
9432    base = ' [Function' + n + ']';
9433  }
9434
9435  // Make RegExps say that they are RegExps
9436  if (isRegExp(value)) {
9437    base = ' ' + RegExp.prototype.toString.call(value);
9438  }
9439
9440  // Make dates with properties first say the date
9441  if (isDate(value)) {
9442    base = ' ' + Date.prototype.toUTCString.call(value);
9443  }
9444
9445  // Make error with message first say the error
9446  if (isError(value)) {
9447    base = ' ' + formatError(value);
9448  }
9449
9450  if (keys.length === 0 && (!array || value.length == 0)) {
9451    return braces[0] + base + braces[1];
9452  }
9453
9454  if (recurseTimes < 0) {
9455    if (isRegExp(value)) {
9456      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
9457    } else {
9458      return ctx.stylize('[Object]', 'special');
9459    }
9460  }
9461
9462  ctx.seen.push(value);
9463
9464  var output;
9465  if (array) {
9466    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
9467  } else {
9468    output = keys.map(function(key) {
9469      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
9470    });
9471  }
9472
9473  ctx.seen.pop();
9474
9475  return reduceToSingleString(output, base, braces);
9476}
9477
9478
9479function formatPrimitive(ctx, value) {
9480  if (isUndefined(value))
9481    return ctx.stylize('undefined', 'undefined');
9482  if (isString(value)) {
9483    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
9484                                             .replace(/'/g, "\\'")
9485                                             .replace(/\\"/g, '"') + '\'';
9486    return ctx.stylize(simple, 'string');
9487  }
9488  if (isNumber(value))
9489    return ctx.stylize('' + value, 'number');
9490  if (isBoolean(value))
9491    return ctx.stylize('' + value, 'boolean');
9492  // For some reason typeof null is "object", so special case here.
9493  if (isNull(value))
9494    return ctx.stylize('null', 'null');
9495}
9496
9497
9498function formatError(value) {
9499  return '[' + Error.prototype.toString.call(value) + ']';
9500}
9501
9502
9503function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
9504  var output = [];
9505  for (var i = 0, l = value.length; i < l; ++i) {
9506    if (hasOwnProperty(value, String(i))) {
9507      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
9508          String(i), true));
9509    } else {
9510      output.push('');
9511    }
9512  }
9513  keys.forEach(function(key) {
9514    if (!key.match(/^\d+$/)) {
9515      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
9516          key, true));
9517    }
9518  });
9519  return output;
9520}
9521
9522
9523function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
9524  var name, str, desc;
9525  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
9526  if (desc.get) {
9527    if (desc.set) {
9528      str = ctx.stylize('[Getter/Setter]', 'special');
9529    } else {
9530      str = ctx.stylize('[Getter]', 'special');
9531    }
9532  } else {
9533    if (desc.set) {
9534      str = ctx.stylize('[Setter]', 'special');
9535    }
9536  }
9537  if (!hasOwnProperty(visibleKeys, key)) {
9538    name = '[' + key + ']';
9539  }
9540  if (!str) {
9541    if (ctx.seen.indexOf(desc.value) < 0) {
9542      if (isNull(recurseTimes)) {
9543        str = formatValue(ctx, desc.value, null);
9544      } else {
9545        str = formatValue(ctx, desc.value, recurseTimes - 1);
9546      }
9547      if (str.indexOf('\n') > -1) {
9548        if (array) {
9549          str = str.split('\n').map(function(line) {
9550            return '  ' + line;
9551          }).join('\n').substr(2);
9552        } else {
9553          str = '\n' + str.split('\n').map(function(line) {
9554            return '   ' + line;
9555          }).join('\n');
9556        }
9557      }
9558    } else {
9559      str = ctx.stylize('[Circular]', 'special');
9560    }
9561  }
9562  if (isUndefined(name)) {
9563    if (array && key.match(/^\d+$/)) {
9564      return str;
9565    }
9566    name = JSON.stringify('' + key);
9567    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
9568      name = name.substr(1, name.length - 2);
9569      name = ctx.stylize(name, 'name');
9570    } else {
9571      name = name.replace(/'/g, "\\'")
9572                 .replace(/\\"/g, '"')
9573                 .replace(/(^"|"$)/g, "'");
9574      name = ctx.stylize(name, 'string');
9575    }
9576  }
9577
9578  return name + ': ' + str;
9579}
9580
9581
9582function reduceToSingleString(output, base, braces) {
9583  var numLinesEst = 0;
9584  var length = output.reduce(function(prev, cur) {
9585    numLinesEst++;
9586    if (cur.indexOf('\n') >= 0) numLinesEst++;
9587    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
9588  }, 0);
9589
9590  if (length > 60) {
9591    return braces[0] +
9592           (base === '' ? '' : base + '\n ') +
9593           ' ' +
9594           output.join(',\n  ') +
9595           ' ' +
9596           braces[1];
9597  }
9598
9599  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
9600}
9601
9602
9603// NOTE: These type checking functions intentionally don't use `instanceof`
9604// because it is fragile and can be easily faked with `Object.create()`.
9605function isArray(ar) {
9606  return Array.isArray(ar);
9607}
9608exports.isArray = isArray;
9609
9610function isBoolean(arg) {
9611  return typeof arg === 'boolean';
9612}
9613exports.isBoolean = isBoolean;
9614
9615function isNull(arg) {
9616  return arg === null;
9617}
9618exports.isNull = isNull;
9619
9620function isNullOrUndefined(arg) {
9621  return arg == null;
9622}
9623exports.isNullOrUndefined = isNullOrUndefined;
9624
9625function isNumber(arg) {
9626  return typeof arg === 'number';
9627}
9628exports.isNumber = isNumber;
9629
9630function isString(arg) {
9631  return typeof arg === 'string';
9632}
9633exports.isString = isString;
9634
9635function isSymbol(arg) {
9636  return typeof arg === 'symbol';
9637}
9638exports.isSymbol = isSymbol;
9639
9640function isUndefined(arg) {
9641  return arg === void 0;
9642}
9643exports.isUndefined = isUndefined;
9644
9645function isRegExp(re) {
9646  return isObject(re) && objectToString(re) === '[object RegExp]';
9647}
9648exports.isRegExp = isRegExp;
9649
9650function isObject(arg) {
9651  return typeof arg === 'object' && arg !== null;
9652}
9653exports.isObject = isObject;
9654
9655function isDate(d) {
9656  return isObject(d) && objectToString(d) === '[object Date]';
9657}
9658exports.isDate = isDate;
9659
9660function isError(e) {
9661  return isObject(e) &&
9662      (objectToString(e) === '[object Error]' || e instanceof Error);
9663}
9664exports.isError = isError;
9665
9666function isFunction(arg) {
9667  return typeof arg === 'function';
9668}
9669exports.isFunction = isFunction;
9670
9671function isPrimitive(arg) {
9672  return arg === null ||
9673         typeof arg === 'boolean' ||
9674         typeof arg === 'number' ||
9675         typeof arg === 'string' ||
9676         typeof arg === 'symbol' ||  // ES6 symbol
9677         typeof arg === 'undefined';
9678}
9679exports.isPrimitive = isPrimitive;
9680
9681exports.isBuffer = require('./support/isBuffer');
9682
9683function objectToString(o) {
9684  return Object.prototype.toString.call(o);
9685}
9686
9687
9688function pad(n) {
9689  return n < 10 ? '0' + n.toString(10) : n.toString(10);
9690}
9691
9692
9693var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
9694              'Oct', 'Nov', 'Dec'];
9695
9696// 26 Feb 16:19:34
9697function timestamp() {
9698  var d = new Date();
9699  var time = [pad(d.getHours()),
9700              pad(d.getMinutes()),
9701              pad(d.getSeconds())].join(':');
9702  return [d.getDate(), months[d.getMonth()], time].join(' ');
9703}
9704
9705
9706// log is just a thin wrapper to console.log that prepends a timestamp
9707exports.log = function() {
9708  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
9709};
9710
9711
9712/**
9713 * Inherit the prototype methods from one constructor into another.
9714 *
9715 * The Function.prototype.inherits from lang.js rewritten as a standalone
9716 * function (not on Function.prototype). NOTE: If this file is to be loaded
9717 * during bootstrapping this function needs to be rewritten using some native
9718 * functions as prototype setup using normal JavaScript does not work as
9719 * expected during bootstrapping (see mirror.js in r114903).
9720 *
9721 * @param {function} ctor Constructor function which needs to inherit the
9722 *     prototype.
9723 * @param {function} superCtor Constructor function to inherit prototype from.
9724 */
9725exports.inherits = require('inherits');
9726
9727exports._extend = function(origin, add) {
9728  // Don't do anything if add isn't an object
9729  if (!add || !isObject(add)) return origin;
9730
9731  var keys = Object.keys(add);
9732  var i = keys.length;
9733  while (i--) {
9734    origin[keys[i]] = add[keys[i]];
9735  }
9736  return origin;
9737};
9738
9739function hasOwnProperty(obj, prop) {
9740  return Object.prototype.hasOwnProperty.call(obj, prop);
9741}
9742
9743}).call(this,require("KliubH"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
9744},{"./support/isBuffer":101,"KliubH":91,"inherits":100}]},{},[83])
9745//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/browser-pack/_prelude.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/lib/default_stream.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/lib/results.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/lib/test.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/array.prototype.every/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/array.prototype.every/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/array.prototype.every/polyfill.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/array.prototype.every/shim.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/available-typed-arrays/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/call-bind/callBound.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/call-bind/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/deep-equal/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/define-properties/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/defined/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/IsCallable.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/RequireObjectCoercible.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/ToNumber.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/ToObject.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/ToPrimitive.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/ToString.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/2021/ToUint32.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/5/CheckObjectCoercible.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/helpers/getOwnPropertyDescriptor.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/helpers/isPrimitive.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-abstract/helpers/regexTester.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-get-iterator/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/es-to-primitive/es2015.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/for-each/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/function-bind/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/function-bind/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/functions-have-names/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/get-intrinsic/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/has-bigints/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/has-property-descriptors/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/has-symbols/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/has-symbols/shams.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/has-tostringtag/shams.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/has/src/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/inherits/inherits_browser.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-arguments/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-bigint/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-boolean-object/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-callable/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-date-object/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-map/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-number-object/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-regex/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-set/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-string/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-symbol/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-typed-array/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-weakmap/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/is-weakset/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/isarray/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-inspect/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-inspect/util.inspect.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-is/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-is/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-is/polyfill.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-is/shim.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-keys/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-keys/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object-keys/isArguments.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object.assign/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object.assign/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object.assign/polyfill.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/object.assign/shim.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/regexp.prototype.flags/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/regexp.prototype.flags/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/regexp.prototype.flags/polyfill.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/regexp.prototype.flags/shim.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/resumer/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/side-channel/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/string.prototype.trim/implementation.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/string.prototype.trim/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/string.prototype.trim/polyfill.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/string.prototype.trim/shim.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/through/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/which-boxed-primitive/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/which-collection/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/node_modules/which-typed-array/index.js","/Users/ljharb/Dropbox/git/ljharb/tape.git/test/browser/asserts.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/base64-js/lib/b64.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/browser-resolve/empty.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/buffer/index.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/events/events.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/ieee754/index.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/path-browserify/index.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/process/browser.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/duplex.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/index.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/node_modules/process/browser.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/passthrough.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/readable.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/transform.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/stream-browserify/writable.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/string_decoder/index.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/util/node_modules/inherits/inherits_browser.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/util/support/isBufferBrowser.js","/Users/ljharb/Dropbox/git/ljharb/testling.git/node_modules/util/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1WA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACp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jCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChgBA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5HA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrlCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7SA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv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lYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv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file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","(function (process){\n'use strict';\n\nvar defined = require('defined');\nvar createDefaultStream = require('./lib/default_stream');\nvar Test = require('./lib/test');\nvar createResult = require('./lib/results');\nvar through = require('through');\n\nvar canEmitExit = typeof process !== 'undefined' && process\n    && typeof process.on === 'function' && process.browser !== true;\nvar canExit = typeof process !== 'undefined' && process\n    && typeof process.exit === 'function';\n\nmodule.exports = (function () {\n\tvar wait = false;\n\tvar harness;\n\n\tfunction getHarness(opts) {\n\t\tif (!opts) { opts = {}; }\n\t\topts.autoclose = !canEmitExit;\n\t\t// this override is here since tests fail via nyc if createHarness is moved upwards\n\t\t// eslint-disable-next-line no-use-before-define\n\t\tif (!harness) { harness = createExitHarness(opts, wait); }\n\t\treturn harness;\n\t}\n\n\tfunction lazyLoad() {\n\t\t// eslint-disable-next-line no-invalid-this\n\t\treturn getHarness().apply(this, arguments);\n\t}\n\n\tlazyLoad.wait = function () {\n\t\twait = true;\n\t};\n\n\tlazyLoad.run = function () {\n\t\tvar run = getHarness().run;\n\n\t\tif (run) { run(); }\n\t};\n\n\tlazyLoad.only = function () {\n\t\treturn getHarness().only.apply(this, arguments);\n\t};\n\n\tlazyLoad.createStream = function (opts) {\n\t\tvar options = opts || {};\n\t\tif (!harness) {\n\t\t\tvar output = through();\n\t\t\tgetHarness({ stream: output, objectMode: options.objectMode });\n\t\t\treturn output;\n\t\t}\n\t\treturn harness.createStream(options);\n\t};\n\n\tlazyLoad.onFinish = function () {\n\t\treturn getHarness().onFinish.apply(this, arguments);\n\t};\n\n\tlazyLoad.onFailure = function () {\n\t\treturn getHarness().onFailure.apply(this, arguments);\n\t};\n\n\tlazyLoad.getHarness = getHarness;\n\n\treturn lazyLoad;\n}());\n\nfunction createHarness(conf_) {\n\tvar results = createResult();\n\tif (!conf_ || conf_.autoclose !== false) {\n\t\tresults.once('done', function () { results.close(); });\n\t}\n\n\tfunction test(name, conf, cb) {\n\t\tvar t = new Test(name, conf, cb);\n\t\ttest._tests.push(t);\n\n\t\t(function inspectCode(st) {\n\t\t\tst.on('test', function sub(st_) {\n\t\t\t\tinspectCode(st_);\n\t\t\t});\n\t\t\tst.on('result', function (r) {\n\t\t\t\tif (!r.todo && !r.ok && typeof r !== 'string') { test._exitCode = 1; }\n\t\t\t});\n\t\t}(t));\n\n\t\tresults.push(t);\n\t\treturn t;\n\t}\n\ttest._results = results;\n\n\ttest._tests = [];\n\n\ttest.createStream = function (opts) {\n\t\treturn results.createStream(opts);\n\t};\n\n\ttest.onFinish = function (cb) {\n\t\tresults.on('done', cb);\n\t};\n\n\ttest.onFailure = function (cb) {\n\t\tresults.on('fail', cb);\n\t};\n\n\tvar only = false;\n\ttest.only = function () {\n\t\tif (only) { throw new Error('there can only be one only test'); }\n\t\tif (conf_.noOnly) { throw new Error('`only` tests are prohibited'); }\n\t\tonly = true;\n\t\tvar t = test.apply(null, arguments);\n\t\tresults.only(t);\n\t\treturn t;\n\t};\n\ttest._exitCode = 0;\n\n\ttest.close = function () { results.close(); };\n\n\treturn test;\n}\n\nfunction createExitHarness(conf, wait) {\n\tvar config = conf || {};\n\tvar harness = createHarness({\n\t\tautoclose: defined(config.autoclose, false),\n\t\tnoOnly: defined(conf.noOnly, defined(process.env.NODE_TAPE_NO_ONLY_TEST, false))\n\t});\n\tvar running = false;\n\tvar ended = false;\n\n\tfunction run() {\n\t\tif (running) { return; }\n\t\trunning = true;\n\t\tvar stream = harness.createStream({ objectMode: config.objectMode });\n\t\tvar es = stream.pipe(config.stream || createDefaultStream());\n\t\tif (canEmitExit && es) { // in node v0.4, `es` is `undefined`\n\t\t\t// TODO: use `err` arg?\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\tes.on('error', function (err) { harness._exitCode = 1; });\n\t\t}\n\t\tstream.on('end', function () { ended = true; });\n\t}\n\n\tif (wait) {\n\t\tharness.run = run;\n\t} else {\n\t\trun();\n\t}\n\n\tif (config.exit === false) { return harness; }\n\tif (!canEmitExit || !canExit) { return harness; }\n\n\tprocess.on('exit', function (code) {\n\t\t// let the process exit cleanly.\n\t\tif (typeof code === 'number' && code !== 0) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (!ended) {\n\t\t\tvar only = harness._results._only;\n\t\t\tfor (var i = 0; i < harness._tests.length; i++) {\n\t\t\t\tvar t = harness._tests[i];\n\t\t\t\tif (!only || t === only) {\n\t\t\t\t\tt._exit();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tharness.close();\n\n\t\tprocess.removeAllListeners('exit'); // necessary for node v0.6\n\t\tprocess.exit(code || harness._exitCode); // eslint-disable-line no-process-exit\n\t});\n\n\treturn harness;\n}\n\nmodule.exports.createHarness = createHarness;\nmodule.exports.Test = Test;\nmodule.exports.test = module.exports; // tap compat\nmodule.exports.test.skip = Test.skip;\n\n}).call(this,require(\"KliubH\"))","(function (process){\n'use strict';\n\nvar through = require('through');\nvar fs = require('fs');\n\nmodule.exports = function () {\n\tvar line = '';\n\tvar stream = through(write, flush);\n\treturn stream;\n\n\tfunction write(buf) {\n\t\tfor (var i = 0; i < buf.length; i++) {\n\t\t\tvar c = typeof buf === 'string'\n\t\t\t\t? buf.charAt(i)\n\t\t\t\t: String.fromCharCode(buf[i]);\n\t\t\tif (c === '\\n') {\n\t\t\t\tflush();\n\t\t\t} else {\n\t\t\t\tline += c;\n\t\t\t}\n\t\t}\n\t}\n\n\tfunction flush() {\n\t\tif (fs.writeSync && (/^win/).test(process.platform)) {\n\t\t\ttry {\n\t\t\t\tfs.writeSync(1, line + '\\n');\n\t\t\t} catch (e) {\n\t\t\t\tstream.emit('error', e);\n\t\t\t}\n\t\t} else {\n\t\t\ttry {\n\t\t\t\tconsole.log(line); // eslint-disable-line no-console\n\t\t\t} catch (e) {\n\t\t\t\tstream.emit('error', e);\n\t\t\t}\n\t\t}\n\t\tline = '';\n\t}\n};\n\n}).call(this,require(\"KliubH\"))","(function (process){\n'use strict';\n\nvar defined = require('defined');\nvar EventEmitter = require('events').EventEmitter;\nvar inherits = require('inherits');\nvar through = require('through');\nvar resumer = require('resumer');\nvar inspect = require('object-inspect');\nvar callBound = require('call-bind/callBound');\nvar has = require('has');\nvar $exec = callBound('RegExp.prototype.exec');\nvar $split = callBound('String.prototype.split');\nvar $replace = callBound('String.prototype.replace');\nvar $shift = callBound('Array.prototype.shift');\nvar $push = callBound('Array.prototype.push');\nvar yamlIndicators = /:|-|\\?/;\nvar nextTick = typeof setImmediate !== 'undefined'\n\t? setImmediate\n\t: process.nextTick;\n\nfunction coalesceWhiteSpaces(str) {\n\treturn $replace(String(str), /\\s+/g, ' ');\n}\n\nfunction getNextTest(results) {\n\tif (!results._only) {\n\t\treturn $shift(results.tests);\n\t}\n\n\tdo {\n\t\tvar t = $shift(results.tests);\n\t\tif (t && results._only === t) {\n\t\t\treturn t;\n\t\t}\n\t} while (results.tests.length !== 0);\n\n\treturn void undefined;\n}\n\nfunction invalidYaml(str) {\n\treturn $exec(yamlIndicators, str) !== null;\n}\n\nfunction encodeResult(res, count) {\n\tvar output = '';\n\toutput += (res.ok ? 'ok ' : 'not ok ') + count;\n\toutput += res.name ? ' ' + coalesceWhiteSpaces(res.name) : '';\n\n\tif (res.skip) {\n\t\toutput += ' # SKIP' + (typeof res.skip === 'string' ? ' ' + coalesceWhiteSpaces(res.skip) : '');\n\t} else if (res.todo) {\n\t\toutput += ' # TODO' + (typeof res.todo === 'string' ? ' ' + coalesceWhiteSpaces(res.todo) : '');\n\t}\n\n\toutput += '\\n';\n\tif (res.ok) { return output; }\n\n\tvar outer = '  ';\n\tvar inner = outer + '  ';\n\toutput += outer + '---\\n';\n\toutput += inner + 'operator: ' + res.operator + '\\n';\n\n\tif (has(res, 'expected') || has(res, 'actual')) {\n\t\tvar ex = inspect(res.expected, { depth: res.objectPrintDepth });\n\t\tvar ac = inspect(res.actual, { depth: res.objectPrintDepth });\n\n\t\tif (Math.max(ex.length, ac.length) > 65 || invalidYaml(ex) || invalidYaml(ac)) {\n\t\t\toutput += inner + 'expected: |-\\n' + inner + '  ' + ex + '\\n';\n\t\t\toutput += inner + 'actual: |-\\n' + inner + '  ' + ac + '\\n';\n\t\t} else {\n\t\t\toutput += inner + 'expected: ' + ex + '\\n';\n\t\t\toutput += inner + 'actual:   ' + ac + '\\n';\n\t\t}\n\t}\n\tif (res.at) {\n\t\toutput += inner + 'at: ' + res.at + '\\n';\n\t}\n\n\tvar actualStack = res.actual && (typeof res.actual === 'object' || typeof res.actual === 'function') ? res.actual.stack : undefined;\n\tvar errorStack = res.error && res.error.stack;\n\tvar stack = defined(actualStack, errorStack);\n\tif (stack) {\n\t\tvar lines = $split(String(stack), '\\n');\n\t\toutput += inner + 'stack: |-\\n';\n\t\tfor (var i = 0; i < lines.length; i++) {\n\t\t\toutput += inner + '  ' + lines[i] + '\\n';\n\t\t}\n\t}\n\n\toutput += outer + '...\\n';\n\treturn output;\n}\n\nfunction Results() {\n\tif (!(this instanceof Results)) { return new Results(); }\n\tthis.count = 0;\n\tthis.fail = 0;\n\tthis.pass = 0;\n\tthis.todo = 0;\n\tthis._stream = through();\n\tthis.tests = [];\n\tthis._only = null;\n\tthis._isRunning = false;\n}\n\ninherits(Results, EventEmitter);\n\nResults.prototype.createStream = function (opts) {\n\tif (!opts) { opts = {}; }\n\tvar self = this;\n\tvar output;\n\tvar testId = 0;\n\tif (opts.objectMode) {\n\t\toutput = through();\n\t\tself.on('_push', function ontest(t, extra) {\n\t\t\tif (!extra) { extra = {}; }\n\t\t\tvar id = testId++;\n\t\t\tt.once('prerun', function () {\n\t\t\t\tvar row = {\n\t\t\t\t\ttype: 'test',\n\t\t\t\t\tname: t.name,\n\t\t\t\t\tid: id,\n\t\t\t\t\tskip: t._skip,\n\t\t\t\t\ttodo: t._todo\n\t\t\t\t};\n\t\t\t\tif (has(extra, 'parent')) {\n\t\t\t\t\trow.parent = extra.parent;\n\t\t\t\t}\n\t\t\t\toutput.queue(row);\n\t\t\t});\n\t\t\tt.on('test', function (st) {\n\t\t\t\tontest(st, { parent: id });\n\t\t\t});\n\t\t\tt.on('result', function (res) {\n\t\t\t\tif (res && typeof res === 'object') {\n\t\t\t\t\tres.test = id;\n\t\t\t\t\tres.type = 'assert';\n\t\t\t\t}\n\t\t\t\toutput.queue(res);\n\t\t\t});\n\t\t\tt.on('end', function () {\n\t\t\t\toutput.queue({ type: 'end', test: id });\n\t\t\t});\n\t\t});\n\t\tself.on('done', function () { output.queue(null); });\n\t} else {\n\t\toutput = resumer();\n\t\toutput.queue('TAP version 13\\n');\n\t\tself._stream.pipe(output);\n\t}\n\n\tif (!this._isRunning) {\n\t\tthis._isRunning = true;\n\t\tnextTick(function next() {\n\t\t\tvar t;\n\t\t\twhile (t = getNextTest(self)) {\n\t\t\t\tt.run();\n\t\t\t\tif (!t.ended) {\n\t\t\t\t\tt.once('end', function () { nextTick(next); });\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tself.emit('done');\n\t\t});\n\t}\n\n\treturn output;\n};\n\nResults.prototype.push = function (t) {\n\tvar self = this;\n\t$push(self.tests, t);\n\tself._watch(t);\n\tself.emit('_push', t);\n};\n\nResults.prototype.only = function (t) {\n\tthis._only = t;\n};\n\nResults.prototype._watch = function (t) {\n\tvar self = this;\n\tfunction write(s) { self._stream.queue(s); }\n\n\tt.once('prerun', function () {\n\t\tvar premsg = '';\n\t\tif (t._skip) {\n\t\t\tpremsg = 'SKIP ';\n\t\t} else if (t._todo) {\n\t\t\tpremsg = 'TODO ';\n\t\t}\n\t\twrite('# ' + premsg + coalesceWhiteSpaces(t.name) + '\\n');\n\t});\n\n\tt.on('result', function (res) {\n\t\tif (typeof res === 'string') {\n\t\t\twrite('# ' + res + '\\n');\n\t\t\treturn;\n\t\t}\n\t\twrite(encodeResult(res, self.count + 1));\n\t\tself.count++;\n\n\t\tif (res.ok || res.todo) {\n\t\t\tself.pass++;\n\t\t} else {\n\t\t\tself.fail++;\n\t\t\tself.emit('fail');\n\t\t}\n\t});\n\n\tt.on('test', function (st) { self._watch(st); });\n};\n\nResults.prototype.close = function () {\n\tvar self = this;\n\tif (self.closed) { self._stream.emit('error', new Error('ALREADY CLOSED')); }\n\tself.closed = true;\n\n\tfunction write(s) { self._stream.queue(s); }\n\n\twrite('\\n1..' + self.count + '\\n');\n\twrite('# tests ' + self.count + '\\n');\n\twrite('# pass  ' + (self.pass + self.todo) + '\\n');\n\tif (self.todo) { write('# todo  ' + self.todo + '\\n'); }\n\tif (self.fail) {\n\t\twrite('# fail  ' + self.fail + '\\n');\n\t} else {\n\t\twrite('\\n# ok\\n');\n\t}\n\n\tself._stream.queue(null);\n};\n\nmodule.exports = Results;\n\n}).call(this,require(\"KliubH\"))","(function (process,__dirname){\n'use strict';\n\nvar deepEqual = require('deep-equal');\nvar defined = require('defined');\nvar path = require('path');\nvar inherits = require('inherits');\nvar EventEmitter = require('events').EventEmitter;\nvar has = require('has');\nvar isRegExp = require('is-regex');\nvar trim = require('string.prototype.trim');\nvar callBound = require('call-bind/callBound');\nvar forEach = require('for-each');\nvar inspect = require('object-inspect');\nvar is = require('object-is');\nvar objectKeys = require('object-keys');\nvar every = require('array.prototype.every');\n\nvar isEnumerable = callBound('Object.prototype.propertyIsEnumerable');\nvar toLowerCase = callBound('String.prototype.toLowerCase');\nvar isProto = callBound('Object.prototype.isPrototypeOf');\nvar $exec = callBound('RegExp.prototype.exec');\nvar objectToString = callBound('Object.prototype.toString');\nvar $split = callBound('String.prototype.split');\nvar $replace = callBound('String.prototype.replace');\nvar $strSlice = callBound('String.prototype.slice');\nvar $push = callBound('Array.prototype.push');\nvar $shift = callBound('Array.prototype.shift');\n\nvar nextTick = typeof setImmediate !== 'undefined'\n\t? setImmediate\n\t: process.nextTick;\nvar safeSetTimeout = setTimeout;\nvar safeClearTimeout = clearTimeout;\n\n// eslint-disable-next-line no-unused-vars\nfunction getTestArgs(name_, opts_, cb_) {\n\tvar name = '(anonymous)';\n\tvar opts = {};\n\tvar cb;\n\n\tfor (var i = 0; i < arguments.length; i++) {\n\t\tvar arg = arguments[i];\n\t\tvar t = typeof arg;\n\t\tif (t === 'string') {\n\t\t\tname = arg;\n\t\t} else if (t === 'object') {\n\t\t\topts = arg || opts;\n\t\t} else if (t === 'function') {\n\t\t\tcb = arg;\n\t\t}\n\t}\n\treturn {\n\t\tname: name,\n\t\topts: opts,\n\t\tcb: cb\n\t};\n}\n\nfunction Test(name_, opts_, cb_) {\n\tif (!(this instanceof Test)) {\n\t\treturn new Test(name_, opts_, cb_);\n\t}\n\n\tvar args = getTestArgs(name_, opts_, cb_);\n\n\tthis.readable = true;\n\tthis.name = args.name || '(anonymous)';\n\tthis.assertCount = 0;\n\tthis.pendingCount = 0;\n\tthis._skip = args.opts.skip || false;\n\tthis._todo = args.opts.todo || false;\n\tthis._timeout = args.opts.timeout;\n\tthis._plan = undefined;\n\tthis._cb = args.cb;\n\tthis._progeny = [];\n\tthis._teardown = [];\n\tthis._ok = true;\n\tvar depthEnvVar = process.env.NODE_TAPE_OBJECT_PRINT_DEPTH;\n\tif (args.opts.objectPrintDepth) {\n\t\tthis._objectPrintDepth = args.opts.objectPrintDepth;\n\t} else if (depthEnvVar) {\n\t\tif (toLowerCase(depthEnvVar) === 'infinity') {\n\t\t\tthis._objectPrintDepth = Infinity;\n\t\t} else {\n\t\t\tthis._objectPrintDepth = depthEnvVar;\n\t\t}\n\t} else {\n\t\tthis._objectPrintDepth = 5;\n\t}\n\n\tfor (var prop in this) {\n\t\tthis[prop] = (function bind(self, val) {\n\t\t\tif (typeof val === 'function') {\n\t\t\t\treturn function bound() {\n\t\t\t\t\treturn val.apply(self, arguments);\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn val;\n\t\t}(this, this[prop]));\n\t}\n}\n\ninherits(Test, EventEmitter);\n\nTest.prototype.run = function run() {\n\tthis.emit('prerun');\n\tif (!this._cb || this._skip) {\n\t\tthis._end();\n\t\treturn;\n\t}\n\tif (this._timeout != null) {\n\t\tthis.timeoutAfter(this._timeout);\n\t}\n\n\tvar callbackReturn = this._cb(this);\n\n\tif (\n\t\ttypeof Promise === 'function'\n        && callbackReturn\n        && typeof callbackReturn.then === 'function'\n\t) {\n\t\tvar self = this;\n\t\tPromise.resolve(callbackReturn).then(function onResolve() {\n\t\t\tif (!self.calledEnd) {\n\t\t\t\tself.end();\n\t\t\t}\n\t\t})['catch'](function onError(err) {\n\t\t\tif (err instanceof Error || objectToString(err) === '[object Error]') {\n\t\t\t\tself.ifError(err);\n\t\t\t} else {\n\t\t\t\tself.fail(err);\n\t\t\t}\n\t\t\tself.end();\n\t\t});\n\t\treturn;\n\t}\n\n\tthis.emit('run');\n};\n\nTest.prototype.test = function test(name, opts, cb) {\n\tvar self = this;\n\tvar t = new Test(name, opts, cb);\n\t$push(this._progeny, t);\n\tthis.pendingCount++;\n\tthis.emit('test', t);\n\tt.on('prerun', function () {\n\t\tself.assertCount++;\n\t});\n\n\tif (!self._pendingAsserts()) {\n\t\tnextTick(function () {\n\t\t\tself._end();\n\t\t});\n\t}\n\n\tnextTick(function () {\n\t\tif (!self._plan && self.pendingCount == self._progeny.length) {\n\t\t\tself._end();\n\t\t}\n\t});\n};\n\nTest.prototype.comment = function comment(msg) {\n\tvar that = this;\n\tforEach($split(trim(msg), '\\n'), function (aMsg) {\n\t\tthat.emit('result', $replace(trim(aMsg), /^#\\s*/, ''));\n\t});\n};\n\nTest.prototype.plan = function plan(n) {\n\tthis._plan = n;\n\tthis.emit('plan', n);\n};\n\nTest.prototype.timeoutAfter = function timeoutAfter(ms) {\n\tif (!ms) { throw new Error('timeoutAfter requires a timespan'); }\n\tvar self = this;\n\tvar timeout = safeSetTimeout(function () {\n\t\tself.fail(self.name + ' timed out after ' + ms + 'ms');\n\t\tself.end();\n\t}, ms);\n\tthis.once('end', function () {\n\t\tsafeClearTimeout(timeout);\n\t});\n};\n\nTest.prototype.end = function end(err) {\n\tif (arguments.length >= 1 && !!err) {\n\t\tthis.ifError(err);\n\t}\n\n\tif (this.calledEnd) {\n\t\tthis.fail('.end() already called');\n\t}\n\tthis.calledEnd = true;\n\tthis._end();\n};\n\nTest.prototype.teardown = function teardown(fn) {\n\tif (typeof fn !== 'function') {\n\t\tthis.fail('teardown: ' + inspect(fn) + ' is not a function');\n\t} else {\n\t\tthis._teardown.push(fn);\n\t}\n};\n\nTest.prototype._end = function _end(err) {\n\tvar self = this;\n\n\tif (!this._cb && !this._todo && !this._skip) {\n\t\tthis.fail('# TODO ' + this.name);\n\t}\n\n\tif (this._progeny.length) {\n\t\tvar t = $shift(this._progeny);\n\t\tt.on('end', function () { self._end(); });\n\t\tt.run();\n\t\treturn;\n\t}\n\n\tfunction completeEnd() {\n\t\tif (!self.ended) { self.emit('end'); }\n\t\tvar pendingAsserts = self._pendingAsserts();\n\t\tif (!self._planError && self._plan !== undefined && pendingAsserts) {\n\t\t\tself._planError = true;\n\t\t\tself.fail('plan != count', {\n\t\t\t\texpected: self._plan,\n\t\t\t\tactual: self.assertCount\n\t\t\t});\n\t\t}\n\t\tself.ended = true;\n\t}\n\n\tfunction next() {\n\t\tif (self._teardown.length === 0) {\n\t\t\tcompleteEnd();\n\t\t\treturn;\n\t\t}\n\t\tvar fn = self._teardown.shift();\n\t\tvar res;\n\t\ttry {\n\t\t\tres = fn();\n\t\t} catch (e) {\n\t\t\tself.fail(e);\n\t\t}\n\t\tif (res && typeof res.then === 'function') {\n\t\t\tres.then(next, function (_err) {\n\t\t\t\t// TODO: wth?\n\t\t\t\terr = err || _err;\n\t\t\t});\n\t\t} else {\n\t\t\tnext();\n\t\t}\n\t}\n\n\tnext();\n};\n\nTest.prototype._exit = function _exit() {\n\tif (this._plan !== undefined && !this._planError && this.assertCount !== this._plan) {\n\t\tthis._planError = true;\n\t\tthis.fail('plan != count', {\n\t\t\texpected: this._plan,\n\t\t\tactual: this.assertCount,\n\t\t\texiting: true\n\t\t});\n\t} else if (!this.ended) {\n\t\tthis.fail('test exited without ending: ' + this.name, {\n\t\t\texiting: true\n\t\t});\n\t}\n};\n\nTest.prototype._pendingAsserts = function _pendingAsserts() {\n\tif (this._plan === undefined) {\n\t\treturn 1;\n\t}\n\treturn this._plan - (this._progeny.length + this.assertCount);\n};\n\nTest.prototype._assert = function assert(ok, opts) {\n\tvar self = this;\n\tvar extra = opts.extra || {};\n\n\tok = !!ok || !!extra.skip;\n\n\tvar name = defined(extra.message, opts.message, '(unnamed assert)');\n\tif (this.calledEnd && opts.operator !== 'fail') {\n\t\tthis.fail('.end() already called: ' + name);\n\t\treturn;\n\t}\n\n\tvar res = {\n\t\tid: self.assertCount++,\n\t\tok: ok,\n\t\tskip: defined(extra.skip, opts.skip),\n\t\ttodo: defined(extra.todo, opts.todo, self._todo),\n\t\tname: name,\n\t\toperator: defined(extra.operator, opts.operator),\n\t\tobjectPrintDepth: self._objectPrintDepth\n\t};\n\tif (has(opts, 'actual') || has(extra, 'actual')) {\n\t\tres.actual = defined(extra.actual, opts.actual);\n\t}\n\tif (has(opts, 'expected') || has(extra, 'expected')) {\n\t\tres.expected = defined(extra.expected, opts.expected);\n\t}\n\tthis._ok = !!(this._ok && ok);\n\n\tif (!ok && !res.todo) {\n\t\tres.error = defined(extra.error, opts.error, new Error(res.name));\n\t}\n\n\tif (!ok) {\n\t\tvar e = new Error('exception');\n\t\tvar err = $split(e.stack || '', '\\n');\n\t\tvar dir = __dirname + path.sep;\n\n\t\tfor (var i = 0; i < err.length; i++) {\n\t\t\t/*\n                Stack trace lines may resemble one of the following. We need\n                to correctly extract a function name (if any) and path / line\n                number for each line.\n\n                    at myFunction (/path/to/file.js:123:45)\n                    at myFunction (/path/to/file.other-ext:123:45)\n                    at myFunction (/path to/file.js:123:45)\n                    at myFunction (C:\\path\\to\\file.js:123:45)\n                    at myFunction (/path/to/file.js:123)\n                    at Test.<anonymous> (/path/to/file.js:123:45)\n                    at Test.bound [as run] (/path/to/file.js:123:45)\n                    at /path/to/file.js:123:45\n\n                Regex has three parts. First is non-capturing group for 'at '\n                (plus anything preceding it).\n\n                    /^(?:[^\\s]*\\s*\\bat\\s+)/\n\n                Second captures function call description (optional). This is\n                not necessarily a valid JS function name, but just what the\n                stack trace is using to represent a function call. It may look\n                like `<anonymous>` or 'Test.bound [as run]'.\n\n                For our purposes, we assume that, if there is a function\n                name, it's everything leading up to the first open\n                parentheses (trimmed) before our pathname.\n\n                    /(?:(.*)\\s+\\()?/\n\n                Last part captures file path plus line no (and optional\n                column no).\n\n                    /((?:\\/|[a-zA-Z]:\\\\)[^:\\)]+:(\\d+)(?::(\\d+))?)\\)?/\n            */\n\t\t\tvar re = /^(?:[^\\s]*\\s*\\bat\\s+)(?:(.*)\\s+\\()?((?:\\/|[a-zA-Z]:\\\\)[^:)]+:(\\d+)(?::(\\d+))?)\\)?$/;\n\t\t\tvar lineWithTokens = $replace($replace(err[i], process.cwd(), '/$CWD'), __dirname, '/$TEST');\n\t\t\tvar m = re.exec(lineWithTokens);\n\n\t\t\tif (!m) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tvar callDescription = m[1] || '<anonymous>';\n\t\t\tvar filePath = $replace($replace(m[2], '/$CWD', process.cwd()), '/$TEST', __dirname);\n\n\t\t\tif ($strSlice(filePath, 0, dir.length) === dir) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Function call description may not (just) be a function name.\n\t\t\t// Try to extract function name by looking at first \"word\" only.\n\t\t\tres.functionName = $split(callDescription, /\\s+/)[0];\n\t\t\tres.file = filePath;\n\t\t\tres.line = Number(m[3]);\n\t\t\tif (m[4]) { res.column = Number(m[4]); }\n\n\t\t\tres.at = callDescription + ' (' + filePath + ')';\n\t\t\tbreak;\n\t\t}\n\t}\n\n\tself.emit('result', res);\n\n\tvar pendingAsserts = self._pendingAsserts();\n\tif (!pendingAsserts) {\n\t\tif (extra.exiting) {\n\t\t\tself._end();\n\t\t} else {\n\t\t\tnextTick(function () {\n\t\t\t\tself._end();\n\t\t\t});\n\t\t}\n\t}\n\n\tif (!self._planError && pendingAsserts < 0) {\n\t\tself._planError = true;\n\t\tself.fail('plan != count', {\n\t\t\texpected: self._plan,\n\t\t\tactual: self._plan - pendingAsserts\n\t\t});\n\t}\n};\n\nTest.prototype.fail = function fail(msg, extra) {\n\tthis._assert(false, {\n\t\tmessage: msg,\n\t\toperator: 'fail',\n\t\textra: extra\n\t});\n};\n\nTest.prototype.pass = function pass(msg, extra) {\n\tthis._assert(true, {\n\t\tmessage: msg,\n\t\toperator: 'pass',\n\t\textra: extra\n\t});\n};\n\nTest.prototype.skip = function skip(msg, extra) {\n\tthis._assert(true, {\n\t\tmessage: msg,\n\t\toperator: 'skip',\n\t\tskip: true,\n\t\textra: extra\n\t});\n};\n\nvar testAssert = function assert(value, msg, extra) { // eslint-disable-line func-style\n\tthis._assert(value, {\n\t\tmessage: defined(msg, 'should be truthy'),\n\t\toperator: 'ok',\n\t\texpected: true,\n\t\tactual: value,\n\t\textra: extra\n\t});\n};\nTest.prototype.ok\n= Test.prototype['true']\n= Test.prototype.assert\n= testAssert;\n\nfunction notOK(value, msg, extra) {\n\tthis._assert(!value, {\n\t\tmessage: defined(msg, 'should be falsy'),\n\t\toperator: 'notOk',\n\t\texpected: false,\n\t\tactual: value,\n\t\textra: extra\n\t});\n}\nTest.prototype.notOk\n= Test.prototype['false']\n= Test.prototype.notok\n= notOK;\n\nfunction error(err, msg, extra) {\n\tthis._assert(!err, {\n\t\tmessage: defined(msg, String(err)),\n\t\toperator: 'error',\n\t\terror: err,\n\t\textra: extra\n\t});\n}\nTest.prototype.error\n= Test.prototype.ifError\n= Test.prototype.ifErr\n= Test.prototype.iferror\n= error;\n\nfunction strictEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(is(a, b), {\n\t\tmessage: defined(msg, 'should be strictly equal'),\n\t\toperator: 'equal',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\nTest.prototype.equal\n= Test.prototype.equals\n= Test.prototype.isEqual\n= Test.prototype.strictEqual\n= Test.prototype.strictEquals\n= Test.prototype.is\n= strictEqual;\n\nfunction notStrictEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(!is(a, b), {\n\t\tmessage: defined(msg, 'should not be strictly equal'),\n\t\toperator: 'notEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\n\nTest.prototype.notEqual\n= Test.prototype.notEquals\n= Test.prototype.isNotEqual\n= Test.prototype.doesNotEqual\n= Test.prototype.isInequal\n= Test.prototype.notStrictEqual\n= Test.prototype.notStrictEquals\n= Test.prototype.isNot\n= Test.prototype.not\n= notStrictEqual;\n\nfunction looseEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(a == b, {\n\t\tmessage: defined(msg, 'should be loosely equal'),\n\t\toperator: 'looseEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\n\nTest.prototype.looseEqual\n= Test.prototype.looseEquals\n= looseEqual;\n\nfunction notLooseEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(a != b, {\n\t\tmessage: defined(msg, 'should not be loosely equal'),\n\t\toperator: 'notLooseEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\nTest.prototype.notLooseEqual\n= Test.prototype.notLooseEquals\n= notLooseEqual;\n\nfunction tapeDeepEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(deepEqual(a, b, { strict: true }), {\n\t\tmessage: defined(msg, 'should be deeply equivalent'),\n\t\toperator: 'deepEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\nTest.prototype.deepEqual\n= Test.prototype.deepEquals\n= Test.prototype.isEquivalent\n= Test.prototype.same\n= tapeDeepEqual;\n\nfunction notDeepEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(!deepEqual(a, b, { strict: true }), {\n\t\tmessage: defined(msg, 'should not be deeply equivalent'),\n\t\toperator: 'notDeepEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\nTest.prototype.notDeepEqual\n= Test.prototype.notDeepEquals\n= Test.prototype.notEquivalent\n= Test.prototype.notDeeply\n= Test.prototype.notSame\n= Test.prototype.isNotDeepEqual\n= Test.prototype.isNotDeeply\n= Test.prototype.isNotEquivalent\n= Test.prototype.isInequivalent\n= notDeepEqual;\n\nfunction deepLooseEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(deepEqual(a, b), {\n\t\tmessage: defined(msg, 'should be loosely deeply equivalent'),\n\t\toperator: 'deepLooseEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\n\nTest.prototype.deepLooseEqual\n= deepLooseEqual;\n\nfunction notDeepLooseEqual(a, b, msg, extra) {\n\tif (arguments.length < 2) {\n\t\tthrow new TypeError('two arguments must be provided to compare');\n\t}\n\tthis._assert(!deepEqual(a, b), {\n\t\tmessage: defined(msg, 'should not be loosely deeply equivalent'),\n\t\toperator: 'notDeepLooseEqual',\n\t\tactual: a,\n\t\texpected: b,\n\t\textra: extra\n\t});\n}\nTest.prototype.notDeepLooseEqual\n= notDeepLooseEqual;\n\nTest.prototype['throws'] = function (fn, expected, msg, extra) {\n\tif (typeof expected === 'string') {\n\t\tmsg = expected;\n\t\texpected = undefined;\n\t}\n\n\tvar caught;\n\n\ttry {\n\t\tfn();\n\t} catch (err) {\n\t\tcaught = { error: err };\n\t\tif (Object(err) === err && (!isEnumerable(err, 'message') || !has(err, 'message'))) {\n\t\t\tvar message = err.message;\n\t\t\tdelete err.message;\n\t\t\terr.message = message;\n\t\t}\n\t}\n\n\tvar passed = caught;\n\n\tif (caught) {\n\t\tif (typeof expected === 'string' && caught.error && caught.error.message === expected) {\n\t\t\tthrow new TypeError('The \"error/message\" argument is ambiguous. The error message ' + inspect(expected) + ' is identical to the message.');\n\t\t}\n\t\tif (typeof expected === 'function') {\n\t\t\tif (typeof expected.prototype !== 'undefined' && caught.error instanceof expected) {\n\t\t\t\tpassed = true;\n\t\t\t} else if (isProto(Error, expected)) {\n\t\t\t\tpassed = false;\n\t\t\t} else {\n\t\t\t\tpassed = expected.call({}, caught.error) === true;\n\t\t\t}\n\t\t} else if (isRegExp(expected)) {\n\t\t\tpassed = $exec(expected, caught.error) !== null;\n\t\t\texpected = inspect(expected);\n\t\t} else if (expected && typeof expected === 'object') { // Handle validation objects.\n\t\t\tvar keys = objectKeys(expected);\n\t\t\t// Special handle errors to make sure the name and the message are compared as well.\n\t\t\tif (expected instanceof Error) {\n\t\t\t\t$push(keys, 'name', 'message');\n\t\t\t} else if (keys.length === 0) {\n\t\t\t\tthrow new TypeError('`throws` validation object must not be empty');\n\t\t\t}\n\t\t\tpassed = every(keys, function (key) {\n\t\t\t\tif (typeof caught.error[key] === 'string' && isRegExp(expected[key]) && $exec(expected[key], caught.error[key]) !== null) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\tif (key in caught.error && deepEqual(caught.error[key], expected[key], { strict: true })) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t});\n\t\t}\n\t}\n\n\tthis._assert(!!passed, {\n\t\tmessage: defined(msg, 'should throw'),\n\t\toperator: 'throws',\n\t\tactual: caught && caught.error,\n\t\texpected: expected,\n\t\terror: !passed && caught && caught.error,\n\t\textra: extra\n\t});\n};\n\nTest.prototype.doesNotThrow = function doesNotThrow(fn, expected, msg, extra) {\n\tif (typeof expected === 'string') {\n\t\tmsg = expected;\n\t\texpected = undefined;\n\t}\n\tvar caught;\n\ttry {\n\t\tfn();\n\t} catch (err) {\n\t\tcaught = { error: err };\n\t}\n\tthis._assert(!caught, {\n\t\tmessage: defined(msg, 'should not throw'),\n\t\toperator: 'throws',\n\t\tactual: caught && caught.error,\n\t\texpected: expected,\n\t\terror: caught && caught.error,\n\t\textra: extra\n\t});\n};\n\nTest.prototype.match = function match(string, regexp, msg, extra) {\n\tif (!isRegExp(regexp)) {\n\t\tthis._assert(false, {\n\t\t\tmessage: defined(msg, 'The \"regexp\" argument must be an instance of RegExp. Received type ' + typeof regexp + ' (' + inspect(regexp) + ')'),\n\t\t\toperator: 'match',\n\t\t\tactual: objectToString(regexp),\n\t\t\texpected: '[object RegExp]',\n\t\t\textra: extra\n\t\t});\n\t} else if (typeof string !== 'string') {\n\t\tthis._assert(false, {\n\t\t\tmessage: defined(msg, 'The \"string\" argument must be of type string. Received type ' + typeof string + ' (' + inspect(string) + ')'),\n\t\t\toperator: 'match',\n\t\t\tactual: string === null ? null : typeof string,\n\t\t\texpected: 'string',\n\t\t\textra: extra\n\t\t});\n\t} else {\n\t\tvar matches = $exec(regexp, string) !== null;\n\t\tvar message = defined(\n\t\t\tmsg,\n\t\t\t'The input ' + (matches ? 'matched' : 'did not match') + ' the regular expression ' + inspect(regexp) + '. Input: ' + inspect(string)\n\t\t);\n\t\tthis._assert(matches, {\n\t\t\tmessage: message,\n\t\t\toperator: 'match',\n\t\t\tactual: string,\n\t\t\texpected: regexp,\n\t\t\textra: extra\n\t\t});\n\t}\n};\n\nTest.prototype.doesNotMatch = function doesNotMatch(string, regexp, msg, extra) {\n\tif (!isRegExp(regexp)) {\n\t\tthis._assert(false, {\n\t\t\tmessage: defined(msg, 'The \"regexp\" argument must be an instance of RegExp. Received type ' + typeof regexp + ' (' + inspect(regexp) + ')'),\n\t\t\toperator: 'doesNotMatch',\n\t\t\tactual: objectToString(regexp),\n\t\t\texpected: '[object RegExp]',\n\t\t\textra: extra\n\t\t});\n\t} else if (typeof string !== 'string') {\n\t\tthis._assert(false, {\n\t\t\tmessage: defined(msg, 'The \"string\" argument must be of type string. Received type ' + typeof string + ' (' + inspect(string) + ')'),\n\t\t\toperator: 'doesNotMatch',\n\t\t\tactual: string === null ? null : typeof string,\n\t\t\texpected: 'string',\n\t\t\textra: extra\n\t\t});\n\t} else {\n\t\tvar matches = $exec(regexp, string) !== null;\n\t\tvar message = defined(\n\t\t\tmsg,\n\t\t\t'The input ' + (matches ? 'was expected to not match' : 'did not match') + ' the regular expression ' + inspect(regexp) + '. Input: ' + inspect(string)\n\t\t);\n\t\tthis._assert(!matches, {\n\t\t\tmessage: message,\n\t\t\toperator: 'doesNotMatch',\n\t\t\tactual: string,\n\t\t\texpected: regexp,\n\t\t\textra: extra\n\t\t});\n\t}\n};\n\n// eslint-disable-next-line no-unused-vars\nTest.skip = function skip(name_, _opts, _cb) {\n\tvar args = getTestArgs.apply(null, arguments);\n\targs.opts.skip = true;\n\treturn new Test(args.name, args.opts, args.cb);\n};\n\nmodule.exports = Test;\n\n// vim: set softtabstop=4 shiftwidth=4:\n\n}).call(this,require(\"KliubH\"),\"/../../lib\")","'use strict';\n\nvar IsCallable = require('es-abstract/2021/IsCallable');\nvar ToObject = require('es-abstract/2021/ToObject');\nvar ToUint32 = require('es-abstract/2021/ToUint32');\nvar callBound = require('call-bind/callBound');\nvar isString = require('is-string');\n\n// Check failure of by-index access of string characters (IE < 9) and failure of `0 in boxedString` (Rhino)\nvar boxedString = Object('a');\nvar splitString = boxedString[0] !== 'a' || !(0 in boxedString);\n\nvar $split = callBound('String.prototype.split');\n\nmodule.exports = function every(callbackfn) {\n\tvar O = ToObject(this);\n\tvar self = splitString && isString(O) ? $split(O, '') : O;\n\tvar len = ToUint32(self.length);\n\tvar T;\n\tif (arguments.length > 1) {\n\t\tT = arguments[1];\n\t}\n\n\t// If no callback function or if callback is not a callable function\n\tif (!IsCallable(callbackfn)) {\n\t\tthrow new TypeError('Array.prototype.every callback must be a function');\n\t}\n\n\tfor (var i = 0; i < len; i++) {\n\t\tif (i in self && !(typeof T === 'undefined' ? callbackfn(self[i], i, O) : callbackfn.call(T, self[i], i, O))) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');\nvar callBound = require('call-bind/callBound');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar polyfill = getPolyfill();\nvar shim = require('./shim');\n\nvar $slice = callBound('Array.prototype.slice');\n\n// eslint-disable-next-line no-unused-vars\nvar boundEveryShim = function every(array, callbackfn) {\n\tRequireObjectCoercible(array);\n\treturn polyfill.apply(array, $slice(arguments, 1));\n};\ndefine(boundEveryShim, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundEveryShim;\n","var implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\tif (typeof Array.prototype.every === 'function') {\n\t\tvar hasPrimitiveContextInStrict = [1].every(function () {\n\t\t\t'use strict';\n\n\t\t\treturn typeof this === 'string' && this === 'x';\n\t\t}, 'x');\n\t\tif (hasPrimitiveContextInStrict) {\n\t\t\treturn Array.prototype.every;\n\t\t}\n\t}\n\treturn implementation;\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimArrayPrototypeEvery() {\n\tvar polyfill = getPolyfill();\n\tdefine(\n\t\tArray.prototype,\n\t\t{ every: polyfill },\n\t\t{ every: function () { return Array.prototype.every !== polyfill; } }\n\t);\n\treturn polyfill;\n};\n","(function (global){\n'use strict';\n\nvar possibleNames = [\n\t'BigInt64Array',\n\t'BigUint64Array',\n\t'Float32Array',\n\t'Float64Array',\n\t'Int16Array',\n\t'Int32Array',\n\t'Int8Array',\n\t'Uint16Array',\n\t'Uint32Array',\n\t'Uint8Array',\n\t'Uint8ClampedArray'\n];\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\n\nmodule.exports = function availableTypedArrays() {\n\tvar out = [];\n\tfor (var i = 0; i < possibleNames.length; i++) {\n\t\tif (typeof g[possibleNames[i]] === 'function') {\n\t\t\tout[out.length] = possibleNames[i];\n\t\t}\n\t}\n\treturn out;\n};\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar bind = require('function-bind');\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $apply = GetIntrinsic('%Function.prototype.apply%');\nvar $call = GetIntrinsic('%Function.prototype.call%');\nvar $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\nvar $max = GetIntrinsic('%Math.max%');\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = $reflectApply(bind, $call, arguments);\n\tif ($gOPD && $defineProperty) {\n\t\tvar desc = $gOPD(func, 'length');\n\t\tif (desc.configurable) {\n\t\t\t// original length, plus the receiver, minus any additional arguments (after the receiver)\n\t\t\t$defineProperty(\n\t\t\t\tfunc,\n\t\t\t\t'length',\n\t\t\t\t{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }\n\t\t\t);\n\t\t}\n\t}\n\treturn func;\n};\n\nvar applyBind = function applyBind() {\n\treturn $reflectApply(bind, $apply, arguments);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","'use strict';\n\nvar objectKeys = require('object-keys');\nvar isArguments = require('is-arguments');\nvar is = require('object-is');\nvar isRegex = require('is-regex');\nvar flags = require('regexp.prototype.flags');\nvar isArray = require('isarray');\nvar isDate = require('is-date-object');\nvar whichBoxedPrimitive = require('which-boxed-primitive');\nvar GetIntrinsic = require('get-intrinsic');\nvar callBound = require('call-bind/callBound');\nvar whichCollection = require('which-collection');\nvar getIterator = require('es-get-iterator');\nvar getSideChannel = require('side-channel');\nvar whichTypedArray = require('which-typed-array');\nvar assign = require('object.assign');\n\nvar $getTime = callBound('Date.prototype.getTime');\nvar gPO = Object.getPrototypeOf;\nvar $objToString = callBound('Object.prototype.toString');\n\nvar $Set = GetIntrinsic('%Set%', true);\nvar $mapHas = callBound('Map.prototype.has', true);\nvar $mapGet = callBound('Map.prototype.get', true);\nvar $mapSize = callBound('Map.prototype.size', true);\nvar $setAdd = callBound('Set.prototype.add', true);\nvar $setDelete = callBound('Set.prototype.delete', true);\nvar $setHas = callBound('Set.prototype.has', true);\nvar $setSize = callBound('Set.prototype.size', true);\n\n// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L401-L414\nfunction setHasEqualElement(set, val1, opts, channel) {\n  var i = getIterator(set);\n  var result;\n  while ((result = i.next()) && !result.done) {\n    if (internalDeepEqual(val1, result.value, opts, channel)) { // eslint-disable-line no-use-before-define\n      // Remove the matching element to make sure we do not check that again.\n      $setDelete(set, result.value);\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L416-L439\nfunction findLooseMatchingPrimitives(prim) {\n  if (typeof prim === 'undefined') {\n    return null;\n  }\n  if (typeof prim === 'object') { // Only pass in null as object!\n    return void 0;\n  }\n  if (typeof prim === 'symbol') {\n    return false;\n  }\n  if (typeof prim === 'string' || typeof prim === 'number') {\n    // Loose equal entries exist only if the string is possible to convert to a regular number and not NaN.\n    return +prim === +prim; // eslint-disable-line no-implicit-coercion\n  }\n  return true;\n}\n\n// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L449-L460\nfunction mapMightHaveLoosePrim(a, b, prim, item, opts, channel) {\n  var altValue = findLooseMatchingPrimitives(prim);\n  if (altValue != null) {\n    return altValue;\n  }\n  var curB = $mapGet(b, altValue);\n  var looseOpts = assign({}, opts, { strict: false });\n  if (\n    (typeof curB === 'undefined' && !$mapHas(b, altValue))\n    // eslint-disable-next-line no-use-before-define\n    || !internalDeepEqual(item, curB, looseOpts, channel)\n  ) {\n    return false;\n  }\n  // eslint-disable-next-line no-use-before-define\n  return !$mapHas(a, altValue) && internalDeepEqual(item, curB, looseOpts, channel);\n}\n\n// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L441-L447\nfunction setMightHaveLoosePrim(a, b, prim) {\n  var altValue = findLooseMatchingPrimitives(prim);\n  if (altValue != null) {\n    return altValue;\n  }\n\n  return $setHas(b, altValue) && !$setHas(a, altValue);\n}\n\n// taken from https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce6974624208502f6bc/internal/util/comparisons.js#L518-L533\nfunction mapHasEqualEntry(set, map, key1, item1, opts, channel) {\n  var i = getIterator(set);\n  var result;\n  var key2;\n  while ((result = i.next()) && !result.done) {\n    key2 = result.value;\n    if (\n      // eslint-disable-next-line no-use-before-define\n      internalDeepEqual(key1, key2, opts, channel)\n      // eslint-disable-next-line no-use-before-define\n      && internalDeepEqual(item1, $mapGet(map, key2), opts, channel)\n    ) {\n      $setDelete(set, key2);\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction internalDeepEqual(actual, expected, options, channel) {\n  var opts = options || {};\n\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (opts.strict ? is(actual, expected) : actual === expected) {\n    return true;\n  }\n\n  var actualBoxed = whichBoxedPrimitive(actual);\n  var expectedBoxed = whichBoxedPrimitive(expected);\n  if (actualBoxed !== expectedBoxed) {\n    return false;\n  }\n\n  // 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==.\n  if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {\n    return opts.strict ? is(actual, expected) : actual == expected; // eslint-disable-line eqeqeq\n  }\n\n  /*\n   * 7.4. For all other Object pairs, including Array objects, equivalence is\n   * determined by having the same number of owned properties (as verified\n   * with Object.prototype.hasOwnProperty.call), the same set of keys\n   * (although not necessarily the same order), equivalent values for every\n   * corresponding key, and an identical 'prototype' property. Note: this\n   * accounts for both named and indexed properties on Arrays.\n   */\n  // see https://github.com/nodejs/node/commit/d3aafd02efd3a403d646a3044adcf14e63a88d32 for memos/channel inspiration\n\n  var hasActual = channel.has(actual);\n  var hasExpected = channel.has(expected);\n  var sentinel;\n  if (hasActual && hasExpected) {\n    if (channel.get(actual) === channel.get(expected)) {\n      return true;\n    }\n  } else {\n    sentinel = {};\n  }\n  if (!hasActual) { channel.set(actual, sentinel); }\n  if (!hasExpected) { channel.set(expected, sentinel); }\n\n  // eslint-disable-next-line no-use-before-define\n  return objEquiv(actual, expected, opts, channel);\n}\n\nfunction isBuffer(x) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') {\n    return false;\n  }\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false;\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') {\n    return false;\n  }\n\n  return !!(x.constructor && x.constructor.isBuffer && x.constructor.isBuffer(x));\n}\n\nfunction setEquiv(a, b, opts, channel) {\n  if ($setSize(a) !== $setSize(b)) {\n    return false;\n  }\n  var iA = getIterator(a);\n  var iB = getIterator(b);\n  var resultA;\n  var resultB;\n  var set;\n  while ((resultA = iA.next()) && !resultA.done) {\n    if (resultA.value && typeof resultA.value === 'object') {\n      if (!set) { set = new $Set(); }\n      $setAdd(set, resultA.value);\n    } else if (!$setHas(b, resultA.value)) {\n      if (opts.strict) { return false; }\n      if (!setMightHaveLoosePrim(a, b, resultA.value)) {\n        return false;\n      }\n      if (!set) { set = new $Set(); }\n      $setAdd(set, resultA.value);\n    }\n  }\n  if (set) {\n    while ((resultB = iB.next()) && !resultB.done) {\n      // We have to check if a primitive value is already matching and only if it's not, go hunting for it.\n      if (resultB.value && typeof resultB.value === 'object') {\n        if (!setHasEqualElement(set, resultB.value, opts.strict, channel)) {\n          return false;\n        }\n      } else if (\n        !opts.strict\n        && !$setHas(a, resultB.value)\n        && !setHasEqualElement(set, resultB.value, opts.strict, channel)\n      ) {\n        return false;\n      }\n    }\n    return $setSize(set) === 0;\n  }\n  return true;\n}\n\nfunction mapEquiv(a, b, opts, channel) {\n  if ($mapSize(a) !== $mapSize(b)) {\n    return false;\n  }\n  var iA = getIterator(a);\n  var iB = getIterator(b);\n  var resultA;\n  var resultB;\n  var set;\n  var key;\n  var item1;\n  var item2;\n  while ((resultA = iA.next()) && !resultA.done) {\n    key = resultA.value[0];\n    item1 = resultA.value[1];\n    if (key && typeof key === 'object') {\n      if (!set) { set = new $Set(); }\n      $setAdd(set, key);\n    } else {\n      item2 = $mapGet(b, key);\n      if ((typeof item2 === 'undefined' && !$mapHas(b, key)) || !internalDeepEqual(item1, item2, opts, channel)) {\n        if (opts.strict) {\n          return false;\n        }\n        if (!mapMightHaveLoosePrim(a, b, key, item1, opts, channel)) {\n          return false;\n        }\n        if (!set) { set = new $Set(); }\n        $setAdd(set, key);\n      }\n    }\n  }\n\n  if (set) {\n    while ((resultB = iB.next()) && !resultB.done) {\n      key = resultB.value[0];\n      item2 = resultB.value[1];\n      if (key && typeof key === 'object') {\n        if (!mapHasEqualEntry(set, a, key, item2, opts, channel)) {\n          return false;\n        }\n      } else if (\n        !opts.strict\n        && (!a.has(key) || !internalDeepEqual($mapGet(a, key), item2, opts, channel))\n        && !mapHasEqualEntry(set, a, key, item2, assign({}, opts, { strict: false }), channel)\n      ) {\n        return false;\n      }\n    }\n    return $setSize(set) === 0;\n  }\n  return true;\n}\n\nfunction objEquiv(a, b, opts, channel) {\n  /* eslint max-statements: [2, 100], max-lines-per-function: [2, 120], max-depth: [2, 5] */\n  var i, key;\n\n  if (typeof a !== typeof b) { return false; }\n  if (a == null || b == null) { return false; }\n\n  if ($objToString(a) !== $objToString(b)) { return false; }\n\n  if (isArguments(a) !== isArguments(b)) { return false; }\n\n  var aIsArray = isArray(a);\n  var bIsArray = isArray(b);\n  if (aIsArray !== bIsArray) { return false; }\n\n  // TODO: replace when a cross-realm brand check is available\n  var aIsError = a instanceof Error;\n  var bIsError = b instanceof Error;\n  if (aIsError !== bIsError) { return false; }\n  if (aIsError || bIsError) {\n    if (a.name !== b.name || a.message !== b.message) { return false; }\n  }\n\n  var aIsRegex = isRegex(a);\n  var bIsRegex = isRegex(b);\n  if (aIsRegex !== bIsRegex) { return false; }\n  if ((aIsRegex || bIsRegex) && (a.source !== b.source || flags(a) !== flags(b))) {\n    return false;\n  }\n\n  var aIsDate = isDate(a);\n  var bIsDate = isDate(b);\n  if (aIsDate !== bIsDate) { return false; }\n  if (aIsDate || bIsDate) { // && would work too, because both are true or both false here\n    if ($getTime(a) !== $getTime(b)) { return false; }\n  }\n  if (opts.strict && gPO && gPO(a) !== gPO(b)) { return false; }\n\n  if (whichTypedArray(a) !== whichTypedArray(b)) {\n    return false;\n  }\n\n  var aIsBuffer = isBuffer(a);\n  var bIsBuffer = isBuffer(b);\n  if (aIsBuffer !== bIsBuffer) { return false; }\n  if (aIsBuffer || bIsBuffer) { // && would work too, because both are true or both false here\n    if (a.length !== b.length) { return false; }\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) { return false; }\n    }\n    return true;\n  }\n\n  if (typeof a !== typeof b) { return false; }\n\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  // having the same number of owned properties (keys incorporates hasOwnProperty)\n  if (ka.length !== kb.length) { return false; }\n\n  // the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  // ~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i]) { return false; } // eslint-disable-line eqeqeq\n  }\n\n  // equivalent values for every corresponding key, and ~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!internalDeepEqual(a[key], b[key], opts, channel)) { return false; }\n  }\n\n  var aCollection = whichCollection(a);\n  var bCollection = whichCollection(b);\n  if (aCollection !== bCollection) {\n    return false;\n  }\n  if (aCollection === 'Set' || bCollection === 'Set') { // aCollection === bCollection\n    return setEquiv(a, b, opts, channel);\n  }\n  if (aCollection === 'Map') { // aCollection === bCollection\n    return mapEquiv(a, b, opts, channel);\n  }\n\n  return true;\n}\n\nmodule.exports = function deepEqual(a, b, opts) {\n  return internalDeepEqual(a, b, opts, getSideChannel());\n};\n","'use strict';\n\nvar keys = require('object-keys');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar origDefineProperty = Object.defineProperty;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar hasPropertyDescriptors = require('has-property-descriptors')();\n\nvar supportsDescriptors = origDefineProperty && hasPropertyDescriptors;\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\torigDefineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value; // eslint-disable-line no-param-reassign\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n","module.exports = function () {\n    for (var i = 0; i < arguments.length; i++) {\n        if (arguments[i] !== undefined) return arguments[i];\n    }\n};\n","'use strict';\n\n// http://262.ecma-international.org/5.1/#sec-9.11\n\nmodule.exports = require('is-callable');\n","'use strict';\n\nmodule.exports = require('../5/CheckObjectCoercible');\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $Number = GetIntrinsic('%Number%');\nvar $RegExp = GetIntrinsic('%RegExp%');\nvar $parseInteger = GetIntrinsic('%parseInt%');\n\nvar callBound = require('call-bind/callBound');\nvar regexTester = require('../helpers/regexTester');\nvar isPrimitive = require('../helpers/isPrimitive');\n\nvar $strSlice = callBound('String.prototype.slice');\nvar isBinary = regexTester(/^0b[01]+$/i);\nvar isOctal = regexTester(/^0o[0-7]+$/i);\nvar isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);\nvar nonWS = ['\\u0085', '\\u200b', '\\ufffe'].join('');\nvar nonWSregex = new $RegExp('[' + nonWS + ']', 'g');\nvar hasNonWS = regexTester(nonWSregex);\n\n// whitespace from: https://es5.github.io/#x15.5.4.20\n// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324\nvar ws = [\n\t'\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003',\n\t'\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028',\n\t'\\u2029\\uFEFF'\n].join('');\nvar trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');\nvar $replace = callBound('String.prototype.replace');\nvar $trim = function (value) {\n\treturn $replace(value, trimRegex, '');\n};\n\nvar ToPrimitive = require('./ToPrimitive');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-tonumber\n\nmodule.exports = function ToNumber(argument) {\n\tvar value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);\n\tif (typeof value === 'symbol') {\n\t\tthrow new $TypeError('Cannot convert a Symbol value to a number');\n\t}\n\tif (typeof value === 'bigint') {\n\t\tthrow new $TypeError('Conversion from \\'BigInt\\' to \\'number\\' is not allowed.');\n\t}\n\tif (typeof value === 'string') {\n\t\tif (isBinary(value)) {\n\t\t\treturn ToNumber($parseInteger($strSlice(value, 2), 2));\n\t\t} else if (isOctal(value)) {\n\t\t\treturn ToNumber($parseInteger($strSlice(value, 2), 8));\n\t\t} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n\t\t\treturn NaN;\n\t\t}\n\t\tvar trimmed = $trim(value);\n\t\tif (trimmed !== value) {\n\t\t\treturn ToNumber(trimmed);\n\t\t}\n\n\t}\n\treturn $Number(value);\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $Object = GetIntrinsic('%Object%');\n\nvar RequireObjectCoercible = require('./RequireObjectCoercible');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-toobject\n\nmodule.exports = function ToObject(value) {\n\tRequireObjectCoercible(value);\n\treturn $Object(value);\n};\n","'use strict';\n\nvar toPrimitive = require('es-to-primitive/es2015');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-toprimitive\n\nmodule.exports = function ToPrimitive(input) {\n\tif (arguments.length > 1) {\n\t\treturn toPrimitive(input, arguments[1]);\n\t}\n\treturn toPrimitive(input);\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $String = GetIntrinsic('%String%');\nvar $TypeError = GetIntrinsic('%TypeError%');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-tostring\n\nmodule.exports = function ToString(argument) {\n\tif (typeof argument === 'symbol') {\n\t\tthrow new $TypeError('Cannot convert a Symbol value to a string');\n\t}\n\treturn $String(argument);\n};\n","'use strict';\n\nvar ToNumber = require('./ToNumber');\n\n// http://262.ecma-international.org/5.1/#sec-9.6\n\nmodule.exports = function ToUint32(x) {\n\treturn ToNumber(x) >>> 0;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\n// http://262.ecma-international.org/5.1/#sec-9.10\n\nmodule.exports = function CheckObjectCoercible(value, optMessage) {\n\tif (value == null) {\n\t\tthrow new $TypeError(optMessage || ('Cannot call method on ' + value));\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\nmodule.exports = function isPrimitive(value) {\n\treturn value === null || (typeof value !== 'function' && typeof value !== 'object');\n};\n","'use strict';\n\nvar callBound = require('call-bind/callBound');\n\nvar $exec = callBound('RegExp.prototype.exec');\n\nmodule.exports = function regexTester(regex) {\n\treturn function test(s) { return $exec(regex, s) !== null; };\n};\n","(function (process){\n'use strict';\n\n/* eslint global-require: 0 */\n// the code is structured this way so that bundlers can\n// alias out `has-symbols` to `() => true` or `() => false` if your target\n// environments' Symbol capabilities are known, and then use\n// dead code elimination on the rest of this module.\n//\n// Similarly, `isarray` can be aliased to `Array.isArray` if\n// available in all target environments.\n\nvar isArguments = require('is-arguments');\n\nif (require('has-symbols')() || require('has-symbols/shams')()) {\n\tvar $iterator = Symbol.iterator;\n\t// Symbol is available natively or shammed\n\t// natively:\n\t//  - Chrome >= 38\n\t//  - Edge 12-14?, Edge >= 15 for sure\n\t//  - FF >= 36\n\t//  - Safari >= 9\n\t//  - node >= 0.12\n\tmodule.exports = function getIterator(iterable) {\n\t\t// alternatively, `iterable[$iterator]?.()`\n\t\tif (iterable != null && typeof iterable[$iterator] !== 'undefined') {\n\t\t\treturn iterable[$iterator]();\n\t\t}\n\t\tif (isArguments(iterable)) {\n\t\t\t// arguments objects lack Symbol.iterator\n\t\t\t// - node 0.12\n\t\t\treturn Array.prototype[$iterator].call(iterable);\n\t\t}\n\t};\n} else {\n\t// Symbol is not available, native or shammed\n\tvar isArray = require('isarray');\n\tvar isString = require('is-string');\n\tvar GetIntrinsic = require('get-intrinsic');\n\tvar $Map = GetIntrinsic('%Map%', true);\n\tvar $Set = GetIntrinsic('%Set%', true);\n\tvar callBound = require('call-bind/callBound');\n\tvar $arrayPush = callBound('Array.prototype.push');\n\tvar $charCodeAt = callBound('String.prototype.charCodeAt');\n\tvar $stringSlice = callBound('String.prototype.slice');\n\n\tvar advanceStringIndex = function advanceStringIndex(S, index) {\n\t\tvar length = S.length;\n\t\tif ((index + 1) >= length) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\tvar first = $charCodeAt(S, index);\n\t\tif (first < 0xD800 || first > 0xDBFF) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\tvar second = $charCodeAt(S, index + 1);\n\t\tif (second < 0xDC00 || second > 0xDFFF) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\treturn index + 2;\n\t};\n\n\tvar getArrayIterator = function getArrayIterator(arraylike) {\n\t\tvar i = 0;\n\t\treturn {\n\t\t\tnext: function next() {\n\t\t\t\tvar done = i >= arraylike.length;\n\t\t\t\tvar value;\n\t\t\t\tif (!done) {\n\t\t\t\t\tvalue = arraylike[i];\n\t\t\t\t\ti += 1;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tdone: done,\n\t\t\t\t\tvalue: value\n\t\t\t\t};\n\t\t\t}\n\t\t};\n\t};\n\n\tvar getNonCollectionIterator = function getNonCollectionIterator(iterable, noPrimordialCollections) {\n\t\tif (isArray(iterable) || isArguments(iterable)) {\n\t\t\treturn getArrayIterator(iterable);\n\t\t}\n\t\tif (isString(iterable)) {\n\t\t\tvar i = 0;\n\t\t\treturn {\n\t\t\t\tnext: function next() {\n\t\t\t\t\tvar nextIndex = advanceStringIndex(iterable, i);\n\t\t\t\t\tvar value = $stringSlice(iterable, i, nextIndex);\n\t\t\t\t\ti = nextIndex;\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: nextIndex > iterable.length,\n\t\t\t\t\t\tvalue: value\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\t\t// es6-shim and es-shims' es-map use a string \"_es6-shim iterator_\" property on different iterables, such as MapIterator.\n\t\tif (noPrimordialCollections && typeof iterable['_es6-shim iterator_'] !== 'undefined') {\n\t\t\treturn iterable['_es6-shim iterator_']();\n\t\t}\n\t};\n\n\tif (!$Map && !$Set) {\n\t\t// the only language iterables are Array, String, arguments\n\t\t// - Safari <= 6.0\n\t\t// - Chrome < 38\n\t\t// - node < 0.12\n\t\t// - FF < 13\n\t\t// - IE < 11\n\t\t// - Edge < 11\n\n\t\tmodule.exports = function getIterator(iterable) {\n\t\t\tif (iterable != null) {\n\t\t\t\treturn getNonCollectionIterator(iterable, true);\n\t\t\t}\n\t\t};\n\t} else {\n\t\t// either Map or Set are available, but Symbol is not\n\t\t// - es6-shim on an ES5 browser\n\t\t// - Safari 6.2 (maybe 6.1?)\n\t\t// - FF v[13, 36)\n\t\t// - IE 11\n\t\t// - Edge 11\n\t\t// - Safari v[6, 9)\n\n\t\tvar isMap = require('is-map');\n\t\tvar isSet = require('is-set');\n\n\t\t// Firefox >= 27, IE 11, Safari 6.2 - 9, Edge 11, es6-shim in older envs, all have forEach\n\t\tvar $mapForEach = callBound('Map.prototype.forEach', true);\n\t\tvar $setForEach = callBound('Set.prototype.forEach', true);\n\t\tif (typeof process === 'undefined' || !process.versions || !process.versions.node) { // \"if is not node\"\n\n\t\t\t// Firefox 17 - 26 has `.iterator()`, whose iterator `.next()` either\n\t\t\t// returns a value, or throws a StopIteration object. These browsers\n\t\t\t// do not have any other mechanism for iteration.\n\t\t\tvar $mapIterator = callBound('Map.prototype.iterator', true);\n\t\t\tvar $setIterator = callBound('Set.prototype.iterator', true);\n\t\t\tvar getStopIterationIterator = function (iterator) {\n\t\t\t\tvar done = false;\n\t\t\t\treturn {\n\t\t\t\t\tnext: function next() {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tdone: done,\n\t\t\t\t\t\t\t\tvalue: done ? undefined : iterator.next()\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\t\tdone = true;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tdone: true,\n\t\t\t\t\t\t\t\tvalue: undefined\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t}\n\t\t// Firefox 27-35, and some older es6-shim versions, use a string \"@@iterator\" property\n\t\t// this returns a proper iterator object, so we should use it instead of forEach.\n\t\t// newer es6-shim versions use a string \"_es6-shim iterator_\" property.\n\t\tvar $mapAtAtIterator = callBound('Map.prototype.@@iterator', true) || callBound('Map.prototype._es6-shim iterator_', true);\n\t\tvar $setAtAtIterator = callBound('Set.prototype.@@iterator', true) || callBound('Set.prototype._es6-shim iterator_', true);\n\n\t\tvar getCollectionIterator = function getCollectionIterator(iterable) {\n\t\t\tif (isMap(iterable)) {\n\t\t\t\tif ($mapIterator) {\n\t\t\t\t\treturn getStopIterationIterator($mapIterator(iterable));\n\t\t\t\t}\n\t\t\t\tif ($mapAtAtIterator) {\n\t\t\t\t\treturn $mapAtAtIterator(iterable);\n\t\t\t\t}\n\t\t\t\tif ($mapForEach) {\n\t\t\t\t\tvar entries = [];\n\t\t\t\t\t$mapForEach(iterable, function (v, k) {\n\t\t\t\t\t\t$arrayPush(entries, [k, v]);\n\t\t\t\t\t});\n\t\t\t\t\treturn getArrayIterator(entries);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (isSet(iterable)) {\n\t\t\t\tif ($setIterator) {\n\t\t\t\t\treturn getStopIterationIterator($setIterator(iterable));\n\t\t\t\t}\n\t\t\t\tif ($setAtAtIterator) {\n\t\t\t\t\treturn $setAtAtIterator(iterable);\n\t\t\t\t}\n\t\t\t\tif ($setForEach) {\n\t\t\t\t\tvar values = [];\n\t\t\t\t\t$setForEach(iterable, function (v) {\n\t\t\t\t\t\t$arrayPush(values, v);\n\t\t\t\t\t});\n\t\t\t\t\treturn getArrayIterator(values);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tmodule.exports = function getIterator(iterable) {\n\t\t\treturn getCollectionIterator(iterable) || getNonCollectionIterator(iterable);\n\t\t};\n\t}\n}\n\n}).call(this,require(\"KliubH\"))","'use strict';\n\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';\n\nvar isPrimitive = require('./helpers/isPrimitive');\nvar isCallable = require('is-callable');\nvar isDate = require('is-date-object');\nvar isSymbol = require('is-symbol');\n\nvar ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {\n\tif (typeof O === 'undefined' || O === null) {\n\t\tthrow new TypeError('Cannot call method on ' + O);\n\t}\n\tif (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {\n\t\tthrow new TypeError('hint must be \"string\" or \"number\"');\n\t}\n\tvar methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];\n\tvar method, result, i;\n\tfor (i = 0; i < methodNames.length; ++i) {\n\t\tmethod = O[methodNames[i]];\n\t\tif (isCallable(method)) {\n\t\t\tresult = method.call(O);\n\t\t\tif (isPrimitive(result)) {\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t}\n\tthrow new TypeError('No default value');\n};\n\nvar GetMethod = function GetMethod(O, P) {\n\tvar func = O[P];\n\tif (func !== null && typeof func !== 'undefined') {\n\t\tif (!isCallable(func)) {\n\t\t\tthrow new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');\n\t\t}\n\t\treturn func;\n\t}\n\treturn void 0;\n};\n\n// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive\nmodule.exports = function ToPrimitive(input) {\n\tif (isPrimitive(input)) {\n\t\treturn input;\n\t}\n\tvar hint = 'default';\n\tif (arguments.length > 1) {\n\t\tif (arguments[1] === String) {\n\t\t\thint = 'string';\n\t\t} else if (arguments[1] === Number) {\n\t\t\thint = 'number';\n\t\t}\n\t}\n\n\tvar exoticToPrim;\n\tif (hasSymbols) {\n\t\tif (Symbol.toPrimitive) {\n\t\t\texoticToPrim = GetMethod(input, Symbol.toPrimitive);\n\t\t} else if (isSymbol(input)) {\n\t\t\texoticToPrim = Symbol.prototype.valueOf;\n\t\t}\n\t}\n\tif (typeof exoticToPrim !== 'undefined') {\n\t\tvar result = exoticToPrim.call(input, hint);\n\t\tif (isPrimitive(result)) {\n\t\t\treturn result;\n\t\t}\n\t\tthrow new TypeError('unable to convert exotic object to primitive');\n\t}\n\tif (hint === 'default' && (isDate(input) || isSymbol(input))) {\n\t\thint = 'string';\n\t}\n\treturn ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);\n};\n","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n    for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n            if (receiver == null) {\n                iterator(array[i], i, array);\n            } else {\n                iterator.call(receiver, array[i], i, array);\n            }\n        }\n    }\n};\n\nvar forEachString = function forEachString(string, iterator, receiver) {\n    for (var i = 0, len = string.length; i < len; i++) {\n        // no such thing as a sparse string.\n        if (receiver == null) {\n            iterator(string.charAt(i), i, string);\n        } else {\n            iterator.call(receiver, string.charAt(i), i, string);\n        }\n    }\n};\n\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n    for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n            if (receiver == null) {\n                iterator(object[k], k, object);\n            } else {\n                iterator.call(receiver, object[k], k, object);\n            }\n        }\n    }\n};\n\nvar forEach = function forEach(list, iterator, thisArg) {\n    if (!isCallable(iterator)) {\n        throw new TypeError('iterator must be a function');\n    }\n\n    var receiver;\n    if (arguments.length >= 3) {\n        receiver = thisArg;\n    }\n\n    if (toStr.call(list) === '[object Array]') {\n        forEachArray(list, iterator, receiver);\n    } else if (typeof list === 'string') {\n        forEachString(list, iterator, receiver);\n    } else {\n        forEachObject(list, iterator, receiver);\n    }\n};\n\nmodule.exports = forEach;\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slice.call(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                args.concat(slice.call(arguments))\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        } else {\n            return target.apply(\n                that,\n                args.concat(slice.call(arguments))\n            );\n        }\n    };\n\n    var boundLength = Math.max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs.push('$' + i);\n    }\n\n    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar functionsHaveNames = function functionsHaveNames() {\n\treturn typeof function f() {}.name === 'string';\n};\n\nvar gOPD = Object.getOwnPropertyDescriptor;\nif (gOPD) {\n\ttry {\n\t\tgOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\tgOPD = null;\n\t}\n}\n\nfunctionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {\n\tif (!functionsHaveNames() || !gOPD) {\n\t\treturn false;\n\t}\n\tvar desc = gOPD(function () {}, 'name');\n\treturn !!desc && !!desc.configurable;\n};\n\nvar $bind = Function.prototype.bind;\n\nfunctionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {\n\treturn functionsHaveNames() && typeof $bind === 'function' && function f() {}.bind().name !== '';\n};\n\nmodule.exports = functionsHaveNames;\n","'use strict';\n\nvar undefined;\n\nvar $SyntaxError = SyntaxError;\nvar $Function = Function;\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = Object.getOwnPropertyDescriptor;\nif ($gOPD) {\n\ttry {\n\t\t$gOPD({}, '');\n\t} catch (e) {\n\t\t$gOPD = null; // this is IE 8, which has a broken gOPD\n\t}\n}\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': Object,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': RangeError,\n\t'%ReferenceError%': ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet\n};\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('has');\nvar $concat = bind.call(Function.call, Array.prototype.concat);\nvar $spliceApply = bind.call(Function.apply, Array.prototype.splice);\nvar $replace = bind.call(Function.call, String.prototype.replace);\nvar $strSlice = bind.call(Function.call, String.prototype.slice);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar $BigInt = typeof BigInt !== 'undefined' && BigInt;\n\nmodule.exports = function hasNativeBigInts() {\n\treturn typeof $BigInt === 'function'\n\t\t&& typeof BigInt === 'function'\n\t\t&& typeof $BigInt(42) === 'bigint' // eslint-disable-line no-magic-numbers\n\t\t&& typeof BigInt(42) === 'bigint'; // eslint-disable-line no-magic-numbers\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\tif ($defineProperty) {\n\t\ttry {\n\t\t\t$defineProperty({}, 'a', { value: 1 });\n\t\t\treturn true;\n\t\t} catch (e) {\n\t\t\t// IE 8 has a broken defineProperty\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn false;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!hasPropertyDescriptors()) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\nvar bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar hasBigInts = require('has-bigints')();\n\nif (hasBigInts) {\n\tvar bigIntValueOf = BigInt.prototype.valueOf;\n\tvar tryBigInt = function tryBigIntObject(value) {\n\t\ttry {\n\t\t\tbigIntValueOf.call(value);\n\t\t\treturn true;\n\t\t} catch (e) {\n\t\t}\n\t\treturn false;\n\t};\n\n\tmodule.exports = function isBigInt(value) {\n\t\tif (\n\t\t\tvalue === null\n\t\t\t|| typeof value === 'undefined'\n\t\t\t|| typeof value === 'boolean'\n\t\t\t|| typeof value === 'string'\n\t\t\t|| typeof value === 'number'\n\t\t\t|| typeof value === 'symbol'\n\t\t\t|| typeof value === 'function'\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\t\tif (typeof value === 'bigint') {\n\t\t\treturn true;\n\t\t}\n\n\t\treturn tryBigInt(value);\n\t};\n} else {\n\tmodule.exports = function isBigInt(value) {\n\t\treturn false && value;\n\t};\n}\n","'use strict';\n\nvar callBound = require('call-bind/callBound');\nvar $boolToStr = callBound('Boolean.prototype.toString');\nvar $toString = callBound('Object.prototype.toString');\n\nvar tryBooleanObject = function booleanBrandCheck(value) {\n\ttry {\n\t\t$boolToStr(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar boolClass = '[object Boolean]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nmodule.exports = function isBoolean(value) {\n\tif (typeof value === 'boolean') {\n\t\treturn true;\n\t}\n\tif (value === null || typeof value !== 'object') {\n\t\treturn false;\n\t}\n\treturn hasToStringTag && Symbol.toStringTag in value ? tryBooleanObject(value) : $toString(value) === boolClass;\n};\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n/* globals document: false */\nvar documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (value === documentDotAll) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (typeof value === 'function' && !value.prototype) { return true; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (value === documentDotAll) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (typeof value === 'function' && !value.prototype) { return true; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\treturn strClass === fnClass || strClass === genClass;\n\t};\n","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateGetDayCall(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n","'use strict';\n\nvar $Map = typeof Map === 'function' && Map.prototype ? Map : null;\nvar $Set = typeof Set === 'function' && Set.prototype ? Set : null;\n\nvar exported;\n\nif (!$Map) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isMap(x) {\n\t\t// `Map` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $Map ? Map.prototype.has : null;\nvar $setHas = $Set ? Set.prototype.has : null;\nif (!exported && !$mapHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isMap(x) {\n\t\t// `Map` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isMap(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$mapHas.call(x);\n\t\tif ($setHas) {\n\t\t\ttry {\n\t\t\t\t$setHas.call(x);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $Map; // core-js workaround, pre-v2.5.0\n\t} catch (e) {}\n\treturn false;\n};\n","'use strict';\n\nvar numToStr = Number.prototype.toString;\nvar tryNumberObject = function tryNumberObject(value) {\n\ttry {\n\t\tnumToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar numClass = '[object Number]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nmodule.exports = function isNumberObject(value) {\n\tif (typeof value === 'number') {\n\t\treturn true;\n\t}\n\tif (typeof value !== 'object') {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryNumberObject(value) : toStr.call(value) === numClass;\n};\n","'use strict';\n\nvar callBound = require('call-bind/callBound');\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar has;\nvar $exec;\nvar isRegexMarker;\nvar badStringifier;\n\nif (hasToStringTag) {\n\thas = callBound('Object.prototype.hasOwnProperty');\n\t$exec = callBound('RegExp.prototype.exec');\n\tisRegexMarker = {};\n\n\tvar throwRegexMarker = function () {\n\t\tthrow isRegexMarker;\n\t};\n\tbadStringifier = {\n\t\ttoString: throwRegexMarker,\n\t\tvalueOf: throwRegexMarker\n\t};\n\n\tif (typeof Symbol.toPrimitive === 'symbol') {\n\t\tbadStringifier[Symbol.toPrimitive] = throwRegexMarker;\n\t}\n}\n\nvar $toString = callBound('Object.prototype.toString');\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar regexClass = '[object RegExp]';\n\nmodule.exports = hasToStringTag\n\t// eslint-disable-next-line consistent-return\n\t? function isRegex(value) {\n\t\tif (!value || typeof value !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar descriptor = gOPD(value, 'lastIndex');\n\t\tvar hasLastIndexDataProperty = descriptor && has(descriptor, 'value');\n\t\tif (!hasLastIndexDataProperty) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\t\t\t$exec(value, badStringifier);\n\t\t} catch (e) {\n\t\t\treturn e === isRegexMarker;\n\t\t}\n\t}\n\t: function isRegex(value) {\n\t\t// In older browsers, typeof regex incorrectly returns 'function'\n\t\tif (!value || (typeof value !== 'object' && typeof value !== 'function')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn $toString(value) === regexClass;\n\t};\n","'use strict';\n\nvar $Map = typeof Map === 'function' && Map.prototype ? Map : null;\nvar $Set = typeof Set === 'function' && Set.prototype ? Set : null;\n\nvar exported;\n\nif (!$Set) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isSet(x) {\n\t\t// `Set` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $Map ? Map.prototype.has : null;\nvar $setHas = $Set ? Set.prototype.has : null;\nif (!exported && !$setHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isSet(x) {\n\t\t// `Set` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isSet(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$setHas.call(x);\n\t\tif ($mapHas) {\n\t\t\ttry {\n\t\t\t\t$mapHas.call(x);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $Set; // core-js workaround, pre-v2.5.0\n\t} catch (e) {}\n\treturn false;\n};\n","'use strict';\n\nvar strValue = String.prototype.valueOf;\nvar tryStringObject = function tryStringObject(value) {\n\ttry {\n\t\tstrValue.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar strClass = '[object String]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nmodule.exports = function isString(value) {\n\tif (typeof value === 'string') {\n\t\treturn true;\n\t}\n\tif (typeof value !== 'object') {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;\n};\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = require('has-symbols')();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n","(function (global){\n'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\nvar $slice = callBound('String.prototype.slice');\nvar toStrTags = {};\nvar gOPD = require('es-abstract/helpers/getOwnPropertyDescriptor');\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr) {\n\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor) {\n\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\ttoStrTags[typedArray] = descriptor.get;\n\t\t}\n\t});\n}\n\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\tvar anyTrue = false;\n\tforEach(toStrTags, function (getter, typedArray) {\n\t\tif (!anyTrue) {\n\t\t\ttry {\n\t\t\t\tanyTrue = getter.call(value) === typedArray;\n\t\t\t} catch (e) { /**/ }\n\t\t}\n\t});\n\treturn anyTrue;\n};\n\nmodule.exports = function isTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag || !(Symbol.toStringTag in value)) {\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\treturn $indexOf(typedArrays, tag) > -1;\n\t}\n\tif (!gOPD) { return false; }\n\treturn tryTypedArrays(value);\n};\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","'use strict';\n\nvar $WeakMap = typeof WeakMap === 'function' && WeakMap.prototype ? WeakMap : null;\nvar $WeakSet = typeof WeakSet === 'function' && WeakSet.prototype ? WeakSet : null;\n\nvar exported;\n\nif (!$WeakMap) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isWeakMap(x) {\n\t\t// `WeakMap` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $WeakMap ? $WeakMap.prototype.has : null;\nvar $setHas = $WeakSet ? $WeakSet.prototype.has : null;\nif (!exported && !$mapHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isWeakMap(x) {\n\t\t// `WeakMap` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isWeakMap(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$mapHas.call(x, $mapHas);\n\t\tif ($setHas) {\n\t\t\ttry {\n\t\t\t\t$setHas.call(x, $setHas);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $WeakMap; // core-js workaround, pre-v3\n\t} catch (e) {}\n\treturn false;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar callBound = require('call-bind/callBound');\n\nvar $WeakSet = GetIntrinsic('%WeakSet%', true);\n\nvar $setHas = callBound('WeakSet.prototype.has', true);\n\nif ($setHas) {\n\tvar $mapHas = callBound('WeakMap.prototype.has', true);\n\n\tmodule.exports = function isWeakSet(x) {\n\t\tif (!x || typeof x !== 'object') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\t$setHas(x, $setHas);\n\t\t\tif ($mapHas) {\n\t\t\t\ttry {\n\t\t\t\t\t$mapHas(x, $mapHas);\n\t\t\t\t} catch (e) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn x instanceof $WeakSet; // core-js workaround, pre-v3\n\t\t} catch (e) {}\n\t\treturn false;\n\t};\n} else {\n\t// eslint-disable-next-line no-unused-vars\n\tmodule.exports = function isWeakSet(x) {\n\t\t// `WeakSet` does not exist, or does not have a `has` method\n\t\treturn false;\n\t};\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","var hasMap = typeof Map === 'function' && Map.prototype;\nvar mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;\nvar mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;\nvar mapForEach = hasMap && Map.prototype.forEach;\nvar hasSet = typeof Set === 'function' && Set.prototype;\nvar setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;\nvar setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;\nvar setForEach = hasSet && Set.prototype.forEach;\nvar hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;\nvar weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\nvar hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;\nvar weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\nvar hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;\nvar weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\nvar booleanValueOf = Boolean.prototype.valueOf;\nvar objectToString = Object.prototype.toString;\nvar functionToString = Function.prototype.toString;\nvar $match = String.prototype.match;\nvar $slice = String.prototype.slice;\nvar $replace = String.prototype.replace;\nvar $toUpperCase = String.prototype.toUpperCase;\nvar $toLowerCase = String.prototype.toLowerCase;\nvar $test = RegExp.prototype.test;\nvar $concat = Array.prototype.concat;\nvar $join = Array.prototype.join;\nvar $arrSlice = Array.prototype.slice;\nvar $floor = Math.floor;\nvar bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;\nvar gOPS = Object.getOwnPropertySymbols;\nvar symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;\nvar hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';\n// ie, `has-tostringtag/shams\nvar toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')\n    ? Symbol.toStringTag\n    : null;\nvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\nvar gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (\n    [].__proto__ === Array.prototype // eslint-disable-line no-proto\n        ? function (O) {\n            return O.__proto__; // eslint-disable-line no-proto\n        }\n        : null\n);\n\nfunction addNumericSeparator(num, str) {\n    if (\n        num === Infinity\n        || num === -Infinity\n        || num !== num\n        || (num && num > -1000 && num < 1000)\n        || $test.call(/e/, str)\n    ) {\n        return str;\n    }\n    var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n    if (typeof num === 'number') {\n        var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)\n        if (int !== num) {\n            var intStr = String(int);\n            var dec = $slice.call(str, intStr.length + 1);\n            return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');\n        }\n    }\n    return $replace.call(str, sepRegex, '$&_');\n}\n\nvar utilInspect = require('./util.inspect');\nvar inspectCustom = utilInspect.custom;\nvar inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;\n\nmodule.exports = function inspect_(obj, options, depth, seen) {\n    var opts = options || {};\n\n    if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n    }\n    if (\n        has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'\n            ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity\n            : opts.maxStringLength !== null\n        )\n    ) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n    }\n    var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;\n    if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {\n        throw new TypeError('option \"customInspect\", if provided, must be `true`, `false`, or `\\'symbol\\'`');\n    }\n\n    if (\n        has(opts, 'indent')\n        && opts.indent !== null\n        && opts.indent !== '\\t'\n        && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)\n    ) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n    }\n    if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n    }\n    var numericSeparator = opts.numericSeparator;\n\n    if (typeof obj === 'undefined') {\n        return 'undefined';\n    }\n    if (obj === null) {\n        return 'null';\n    }\n    if (typeof obj === 'boolean') {\n        return obj ? 'true' : 'false';\n    }\n\n    if (typeof obj === 'string') {\n        return inspectString(obj, opts);\n    }\n    if (typeof obj === 'number') {\n        if (obj === 0) {\n            return Infinity / obj > 0 ? '0' : '-0';\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n    }\n    if (typeof obj === 'bigint') {\n        var bigIntStr = String(obj) + 'n';\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n    }\n\n    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;\n    if (typeof depth === 'undefined') { depth = 0; }\n    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {\n        return isArray(obj) ? '[Array]' : '[Object]';\n    }\n\n    var indent = getIndent(opts, depth);\n\n    if (typeof seen === 'undefined') {\n        seen = [];\n    } else if (indexOf(seen, obj) >= 0) {\n        return '[Circular]';\n    }\n\n    function inspect(value, from, noIndent) {\n        if (from) {\n            seen = $arrSlice.call(seen);\n            seen.push(from);\n        }\n        if (noIndent) {\n            var newOpts = {\n                depth: opts.depth\n            };\n            if (has(opts, 'quoteStyle')) {\n                newOpts.quoteStyle = opts.quoteStyle;\n            }\n            return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n    }\n\n    if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect);\n        return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');\n    }\n    if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, '$1') : symToString.call(obj);\n        return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;\n    }\n    if (isElement(obj)) {\n        var s = '<' + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);\n        }\n        s += '>';\n        if (obj.childNodes && obj.childNodes.length) { s += '...'; }\n        s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';\n        return s;\n    }\n    if (isArray(obj)) {\n        if (obj.length === 0) { return '[]'; }\n        var xs = arrObjKeys(obj, inspect);\n        if (indent && !singleLineValues(xs)) {\n            return '[' + indentedJoin(xs, indent) + ']';\n        }\n        return '[ ' + $join.call(xs, ', ') + ' ]';\n    }\n    if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect);\n        if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) {\n            return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';\n        }\n        if (parts.length === 0) { return '[' + String(obj) + ']'; }\n        return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';\n    }\n    if (typeof obj === 'object' && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) {\n            return utilInspect(obj, { depth: maxDepth - depth });\n        } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {\n            return obj.inspect();\n        }\n    }\n    if (isMap(obj)) {\n        var mapParts = [];\n        mapForEach.call(obj, function (value, key) {\n            mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));\n        });\n        return collectionOf('Map', mapSize.call(obj), mapParts, indent);\n    }\n    if (isSet(obj)) {\n        var setParts = [];\n        setForEach.call(obj, function (value) {\n            setParts.push(inspect(value, obj));\n        });\n        return collectionOf('Set', setSize.call(obj), setParts, indent);\n    }\n    if (isWeakMap(obj)) {\n        return weakCollectionOf('WeakMap');\n    }\n    if (isWeakSet(obj)) {\n        return weakCollectionOf('WeakSet');\n    }\n    if (isWeakRef(obj)) {\n        return weakCollectionOf('WeakRef');\n    }\n    if (isNumber(obj)) {\n        return markBoxed(inspect(Number(obj)));\n    }\n    if (isBigInt(obj)) {\n        return markBoxed(inspect(bigIntValueOf.call(obj)));\n    }\n    if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n    }\n    if (isString(obj)) {\n        return markBoxed(inspect(String(obj)));\n    }\n    if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? '' : 'null prototype';\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';\n        var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';\n        var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');\n        if (ys.length === 0) { return tag + '{}'; }\n        if (indent) {\n            return tag + '{' + indentedJoin(ys, indent) + '}';\n        }\n        return tag + '{ ' + $join.call(ys, ', ') + ' }';\n    }\n    return String(obj);\n};\n\nfunction wrapQuotes(s, defaultStyle, opts) {\n    var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '\"' : \"'\";\n    return quoteChar + s + quoteChar;\n}\n\nfunction quote(s) {\n    return $replace.call(String(s), /\"/g, '&quot;');\n}\n\nfunction isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\n\n// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives\nfunction isSymbol(obj) {\n    if (hasShammedSymbols) {\n        return obj && typeof obj === 'object' && obj instanceof Symbol;\n    }\n    if (typeof obj === 'symbol') {\n        return true;\n    }\n    if (!obj || typeof obj !== 'object' || !symToString) {\n        return false;\n    }\n    try {\n        symToString.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isBigInt(obj) {\n    if (!obj || typeof obj !== 'object' || !bigIntValueOf) {\n        return false;\n    }\n    try {\n        bigIntValueOf.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };\nfunction has(obj, key) {\n    return hasOwn.call(obj, key);\n}\n\nfunction toStr(obj) {\n    return objectToString.call(obj);\n}\n\nfunction nameOf(f) {\n    if (f.name) { return f.name; }\n    var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n    if (m) { return m[1]; }\n    return null;\n}\n\nfunction indexOf(xs, x) {\n    if (xs.indexOf) { return xs.indexOf(x); }\n    for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) { return i; }\n    }\n    return -1;\n}\n\nfunction isMap(x) {\n    if (!mapSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        mapSize.call(x);\n        try {\n            setSize.call(x);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof Map; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakMap(x) {\n    if (!weakMapHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n            weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakRef(x) {\n    if (!weakRefDeref || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakRefDeref.call(x);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isSet(x) {\n    if (!setSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        setSize.call(x);\n        try {\n            mapSize.call(x);\n        } catch (m) {\n            return true;\n        }\n        return x instanceof Set; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakSet(x) {\n    if (!weakSetHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n            weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isElement(x) {\n    if (!x || typeof x !== 'object') { return false; }\n    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {\n        return true;\n    }\n    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';\n}\n\nfunction inspectString(str, opts) {\n    if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n    }\n    // eslint-disable-next-line no-control-regex\n    var s = $replace.call($replace.call(str, /(['\\\\])/g, '\\\\$1'), /[\\x00-\\x1f]/g, lowbyte);\n    return wrapQuotes(s, 'single', opts);\n}\n\nfunction lowbyte(c) {\n    var n = c.charCodeAt(0);\n    var x = {\n        8: 'b',\n        9: 't',\n        10: 'n',\n        12: 'f',\n        13: 'r'\n    }[n];\n    if (x) { return '\\\\' + x; }\n    return '\\\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));\n}\n\nfunction markBoxed(str) {\n    return 'Object(' + str + ')';\n}\n\nfunction weakCollectionOf(type) {\n    return type + ' { ? }';\n}\n\nfunction collectionOf(type, size, entries, indent) {\n    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');\n    return type + ' (' + size + ') {' + joinedEntries + '}';\n}\n\nfunction singleLineValues(xs) {\n    for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], '\\n') >= 0) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction getIndent(opts, depth) {\n    var baseIndent;\n    if (opts.indent === '\\t') {\n        baseIndent = '\\t';\n    } else if (typeof opts.indent === 'number' && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), ' ');\n    } else {\n        return null;\n    }\n    return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n    };\n}\n\nfunction indentedJoin(xs, indent) {\n    if (xs.length === 0) { return ''; }\n    var lineJoiner = '\\n' + indent.prev + indent.base;\n    return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\\n' + indent.prev;\n}\n\nfunction arrObjKeys(obj, inspect) {\n    var isArr = isArray(obj);\n    var xs = [];\n    if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';\n        }\n    }\n    var syms = typeof gOPS === 'function' ? gOPS(obj) : [];\n    var symMap;\n    if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n            symMap['$' + syms[k]] = syms[k];\n        }\n    }\n\n    for (var key in obj) { // eslint-disable-line no-restricted-syntax\n        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {\n            // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section\n            continue; // eslint-disable-line no-restricted-syntax, no-continue\n        } else if ($test.call(/[^\\w$]/, key)) {\n            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));\n        } else {\n            xs.push(key + ': ' + inspect(obj[key], obj));\n        }\n    }\n    if (typeof gOPS === 'function') {\n        for (var j = 0; j < syms.length; j++) {\n            if (isEnumerable.call(obj, syms[j])) {\n                xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));\n            }\n        }\n    }\n    return xs;\n}\n","module.exports = require('util').inspect;\n","'use strict';\n\nvar numberIsNaN = function (value) {\n\treturn value !== value;\n};\n\nmodule.exports = function is(a, b) {\n\tif (a === 0 && b === 0) {\n\t\treturn 1 / a === 1 / b;\n\t}\n\tif (a === b) {\n\t\treturn true;\n\t}\n\tif (numberIsNaN(a) && numberIsNaN(b)) {\n\t\treturn true;\n\t}\n\treturn false;\n};\n\n","'use strict';\n\nvar define = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind(getPolyfill(), Object);\n\ndefine(polyfill, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = polyfill;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\treturn typeof Object.is === 'function' ? Object.is : implementation;\n};\n","'use strict';\n\nvar getPolyfill = require('./polyfill');\nvar define = require('define-properties');\n\nmodule.exports = function shimObjectIs() {\n\tvar polyfill = getPolyfill();\n\tdefine(Object, { is: polyfill }, {\n\t\tis: function testObjectIs() {\n\t\t\treturn Object.is !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = require('./isArguments'); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n","'use strict';\n\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n","'use strict';\n\n// modified from https://github.com/es-shims/es6-shim\nvar objectKeys = require('object-keys');\nvar hasSymbols = require('has-symbols/shams')();\nvar callBound = require('call-bind/callBound');\nvar toObject = Object;\nvar $push = callBound('Array.prototype.push');\nvar $propIsEnumerable = callBound('Object.prototype.propertyIsEnumerable');\nvar originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;\n\n// eslint-disable-next-line no-unused-vars\nmodule.exports = function assign(target, source1) {\n\tif (target == null) { throw new TypeError('target must be an object'); }\n\tvar to = toObject(target); // step 1\n\tif (arguments.length === 1) {\n\t\treturn to; // step 2\n\t}\n\tfor (var s = 1; s < arguments.length; ++s) {\n\t\tvar from = toObject(arguments[s]); // step 3.a.i\n\n\t\t// step 3.a.ii:\n\t\tvar keys = objectKeys(from);\n\t\tvar getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols);\n\t\tif (getSymbols) {\n\t\t\tvar syms = getSymbols(from);\n\t\t\tfor (var j = 0; j < syms.length; ++j) {\n\t\t\t\tvar key = syms[j];\n\t\t\t\tif ($propIsEnumerable(from, key)) {\n\t\t\t\t\t$push(keys, key);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// step 3.a.iii:\n\t\tfor (var i = 0; i < keys.length; ++i) {\n\t\t\tvar nextKey = keys[i];\n\t\t\tif ($propIsEnumerable(from, nextKey)) { // step 3.a.iii.2\n\t\t\t\tvar propValue = from[nextKey]; // step 3.a.iii.2.a\n\t\t\t\tto[nextKey] = propValue; // step 3.a.iii.2.b\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to; // step 4\n};\n","'use strict';\n\nvar defineProperties = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind.apply(getPolyfill());\n// eslint-disable-next-line no-unused-vars\nvar bound = function assign(target, source1) {\n\treturn polyfill(Object, arguments);\n};\n\ndefineProperties(bound, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = bound;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nvar lacksProperEnumerationOrder = function () {\n\tif (!Object.assign) {\n\t\treturn false;\n\t}\n\t/*\n\t * v8, specifically in node 4.x, has a bug with incorrect property enumeration order\n\t * note: this does not detect the bug unless there's 20 characters\n\t */\n\tvar str = 'abcdefghijklmnopqrst';\n\tvar letters = str.split('');\n\tvar map = {};\n\tfor (var i = 0; i < letters.length; ++i) {\n\t\tmap[letters[i]] = letters[i];\n\t}\n\tvar obj = Object.assign({}, map);\n\tvar actual = '';\n\tfor (var k in obj) {\n\t\tactual += k;\n\t}\n\treturn str !== actual;\n};\n\nvar assignHasPendingExceptions = function () {\n\tif (!Object.assign || !Object.preventExtensions) {\n\t\treturn false;\n\t}\n\t/*\n\t * Firefox 37 still has \"pending exception\" logic in its Object.assign implementation,\n\t * which is 72% slower than our shim, and Firefox 40's native implementation.\n\t */\n\tvar thrower = Object.preventExtensions({ 1: 2 });\n\ttry {\n\t\tObject.assign(thrower, 'xy');\n\t} catch (e) {\n\t\treturn thrower[1] === 'y';\n\t}\n\treturn false;\n};\n\nmodule.exports = function getPolyfill() {\n\tif (!Object.assign) {\n\t\treturn implementation;\n\t}\n\tif (lacksProperEnumerationOrder()) {\n\t\treturn implementation;\n\t}\n\tif (assignHasPendingExceptions()) {\n\t\treturn implementation;\n\t}\n\treturn Object.assign;\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimAssign() {\n\tvar polyfill = getPolyfill();\n\tdefine(\n\t\tObject,\n\t\t{ assign: polyfill },\n\t\t{ assign: function () { return Object.assign !== polyfill; } }\n\t);\n\treturn polyfill;\n};\n","'use strict';\n\nvar functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames();\n\nvar $Object = Object;\nvar $TypeError = TypeError;\n\nmodule.exports = function flags() {\n\tif (this != null && this !== $Object(this)) {\n\t\tthrow new $TypeError('RegExp.prototype.flags getter called on non-object');\n\t}\n\tvar result = '';\n\tif (this.hasIndices) {\n\t\tresult += 'd';\n\t}\n\tif (this.global) {\n\t\tresult += 'g';\n\t}\n\tif (this.ignoreCase) {\n\t\tresult += 'i';\n\t}\n\tif (this.multiline) {\n\t\tresult += 'm';\n\t}\n\tif (this.dotAll) {\n\t\tresult += 's';\n\t}\n\tif (this.unicode) {\n\t\tresult += 'u';\n\t}\n\tif (this.sticky) {\n\t\tresult += 'y';\n\t}\n\treturn result;\n};\n\nif (functionsHaveConfigurableNames && Object.defineProperty) {\n\tObject.defineProperty(module.exports, 'name', { value: 'get flags' });\n}\n","'use strict';\n\nvar define = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar flagsBound = callBind(getPolyfill());\n\ndefine(flagsBound, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = flagsBound;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nvar supportsDescriptors = require('define-properties').supportsDescriptors;\nvar $gOPD = Object.getOwnPropertyDescriptor;\n\nmodule.exports = function getPolyfill() {\n\tif (supportsDescriptors && (/a/mig).flags === 'gim') {\n\t\tvar descriptor = $gOPD(RegExp.prototype, 'flags');\n\t\tif (\n\t\t\tdescriptor\n\t\t\t&& typeof descriptor.get === 'function'\n\t\t\t&& typeof RegExp.prototype.dotAll === 'boolean'\n\t\t\t&& typeof RegExp.prototype.hasIndices === 'boolean'\n\t\t) {\n\t\t\t/* eslint getter-return: 0 */\n\t\t\tvar calls = '';\n\t\t\tvar o = {};\n\t\t\tObject.defineProperty(o, 'hasIndices', {\n\t\t\t\tget: function () {\n\t\t\t\t\tcalls += 'd';\n\t\t\t\t}\n\t\t\t});\n\t\t\tObject.defineProperty(o, 'sticky', {\n\t\t\t\tget: function () {\n\t\t\t\t\tcalls += 'y';\n\t\t\t\t}\n\t\t\t});\n\t\t\tif (calls === 'dy') {\n\t\t\t\treturn descriptor.get;\n\t\t\t}\n\t\t}\n\t}\n\treturn implementation;\n};\n","'use strict';\n\nvar supportsDescriptors = require('define-properties').supportsDescriptors;\nvar getPolyfill = require('./polyfill');\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar defineProperty = Object.defineProperty;\nvar TypeErr = TypeError;\nvar getProto = Object.getPrototypeOf;\nvar regex = /a/;\n\nmodule.exports = function shimFlags() {\n\tif (!supportsDescriptors || !getProto) {\n\t\tthrow new TypeErr('RegExp.prototype.flags requires a true ES5 environment that supports property descriptors');\n\t}\n\tvar polyfill = getPolyfill();\n\tvar proto = getProto(regex);\n\tvar descriptor = gOPD(proto, 'flags');\n\tif (!descriptor || descriptor.get !== polyfill) {\n\t\tdefineProperty(proto, 'flags', {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tget: polyfill\n\t\t});\n\t}\n\treturn polyfill;\n};\n","(function (process){\nvar through = require('through');\nvar nextTick = typeof setImmediate !== 'undefined'\n    ? setImmediate\n    : process.nextTick\n;\n\nmodule.exports = function (write, end) {\n    var tr = through(write, end);\n    tr.pause();\n    var resume = tr.resume;\n    var pause = tr.pause;\n    var paused = false;\n    \n    tr.pause = function () {\n        paused = true;\n        return pause.apply(this, arguments);\n    };\n    \n    tr.resume = function () {\n        paused = false;\n        return resume.apply(this, arguments);\n    };\n    \n    nextTick(function () {\n        if (!paused) tr.resume();\n    });\n    \n    return tr;\n};\n\n}).call(this,require(\"KliubH\"))","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar callBound = require('call-bind/callBound');\nvar inspect = require('object-inspect');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $WeakMap = GetIntrinsic('%WeakMap%', true);\nvar $Map = GetIntrinsic('%Map%', true);\n\nvar $weakMapGet = callBound('WeakMap.prototype.get', true);\nvar $weakMapSet = callBound('WeakMap.prototype.set', true);\nvar $weakMapHas = callBound('WeakMap.prototype.has', true);\nvar $mapGet = callBound('Map.prototype.get', true);\nvar $mapSet = callBound('Map.prototype.set', true);\nvar $mapHas = callBound('Map.prototype.has', true);\n\n/*\n * This function traverses the list returning the node corresponding to the\n * given key.\n *\n * That node is also moved to the head of the list, so that if it's accessed\n * again we don't need to traverse the whole list. By doing so, all the recently\n * used nodes can be accessed relatively quickly.\n */\nvar listGetNode = function (list, key) { // eslint-disable-line consistent-return\n\tfor (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {\n\t\tif (curr.key === key) {\n\t\t\tprev.next = curr.next;\n\t\t\tcurr.next = list.next;\n\t\t\tlist.next = curr; // eslint-disable-line no-param-reassign\n\t\t\treturn curr;\n\t\t}\n\t}\n};\n\nvar listGet = function (objects, key) {\n\tvar node = listGetNode(objects, key);\n\treturn node && node.value;\n};\nvar listSet = function (objects, key, value) {\n\tvar node = listGetNode(objects, key);\n\tif (node) {\n\t\tnode.value = value;\n\t} else {\n\t\t// Prepend the new node to the beginning of the list\n\t\tobjects.next = { // eslint-disable-line no-param-reassign\n\t\t\tkey: key,\n\t\t\tnext: objects.next,\n\t\t\tvalue: value\n\t\t};\n\t}\n};\nvar listHas = function (objects, key) {\n\treturn !!listGetNode(objects, key);\n};\n\nmodule.exports = function getSideChannel() {\n\tvar $wm;\n\tvar $m;\n\tvar $o;\n\tvar channel = {\n\t\tassert: function (key) {\n\t\t\tif (!channel.has(key)) {\n\t\t\t\tthrow new $TypeError('Side channel does not contain ' + inspect(key));\n\t\t\t}\n\t\t},\n\t\tget: function (key) { // eslint-disable-line consistent-return\n\t\t\tif ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {\n\t\t\t\tif ($wm) {\n\t\t\t\t\treturn $weakMapGet($wm, key);\n\t\t\t\t}\n\t\t\t} else if ($Map) {\n\t\t\t\tif ($m) {\n\t\t\t\t\treturn $mapGet($m, key);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif ($o) { // eslint-disable-line no-lonely-if\n\t\t\t\t\treturn listGet($o, key);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\thas: function (key) {\n\t\t\tif ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {\n\t\t\t\tif ($wm) {\n\t\t\t\t\treturn $weakMapHas($wm, key);\n\t\t\t\t}\n\t\t\t} else if ($Map) {\n\t\t\t\tif ($m) {\n\t\t\t\t\treturn $mapHas($m, key);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif ($o) { // eslint-disable-line no-lonely-if\n\t\t\t\t\treturn listHas($o, key);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\t\tset: function (key, value) {\n\t\t\tif ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {\n\t\t\t\tif (!$wm) {\n\t\t\t\t\t$wm = new $WeakMap();\n\t\t\t\t}\n\t\t\t\t$weakMapSet($wm, key, value);\n\t\t\t} else if ($Map) {\n\t\t\t\tif (!$m) {\n\t\t\t\t\t$m = new $Map();\n\t\t\t\t}\n\t\t\t\t$mapSet($m, key, value);\n\t\t\t} else {\n\t\t\t\tif (!$o) {\n\t\t\t\t\t/*\n\t\t\t\t\t * Initialize the linked list as an empty node, so that we don't have\n\t\t\t\t\t * to special-case handling of the first node: we can always refer to\n\t\t\t\t\t * it as (previous node).next, instead of something like (list).head\n\t\t\t\t\t */\n\t\t\t\t\t$o = { key: {}, next: null };\n\t\t\t\t}\n\t\t\t\tlistSet($o, key, value);\n\t\t\t}\n\t\t}\n\t};\n\treturn channel;\n};\n","'use strict';\n\nvar RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');\nvar ToString = require('es-abstract/2021/ToString');\nvar callBound = require('call-bind/callBound');\nvar $replace = callBound('String.prototype.replace');\n\nvar mvsIsWS = (/^\\s$/).test('\\u180E');\n/* eslint-disable no-control-regex */\nvar leftWhitespace = mvsIsWS\n\t? /^[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]+/\n\t: /^[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]+/;\nvar rightWhitespace = mvsIsWS\n\t? /[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]+$/\n\t: /[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]+$/;\n/* eslint-enable no-control-regex */\n\nmodule.exports = function trim() {\n\tvar S = ToString(RequireObjectCoercible(this));\n\treturn $replace($replace(S, leftWhitespace, ''), rightWhitespace, '');\n};\n","'use strict';\n\nvar callBind = require('call-bind');\nvar define = require('define-properties');\nvar RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar bound = callBind(getPolyfill());\nvar boundMethod = function trim(receiver) {\n\tRequireObjectCoercible(receiver);\n\treturn bound(receiver);\n};\n\ndefine(boundMethod, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundMethod;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nvar zeroWidthSpace = '\\u200b';\nvar mongolianVowelSeparator = '\\u180E';\n\nmodule.exports = function getPolyfill() {\n\tif (\n\t\tString.prototype.trim\n\t\t&& zeroWidthSpace.trim() === zeroWidthSpace\n\t\t&& mongolianVowelSeparator.trim() === mongolianVowelSeparator\n\t\t&& ('_' + mongolianVowelSeparator).trim() === ('_' + mongolianVowelSeparator)\n\t\t&& (mongolianVowelSeparator + '_').trim() === (mongolianVowelSeparator + '_')\n\t) {\n\t\treturn String.prototype.trim;\n\t}\n\treturn implementation;\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimStringTrim() {\n\tvar polyfill = getPolyfill();\n\tdefine(String.prototype, { trim: polyfill }, {\n\t\ttrim: function testTrim() {\n\t\t\treturn String.prototype.trim !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","(function (process){\nvar Stream = require('stream')\n\n// through\n//\n// a stream that does nothing but re-emit the input.\n// useful for aggregating a series of changing but not ending streams into one stream)\n\nexports = module.exports = through\nthrough.through = through\n\n//create a readable writable stream.\n\nfunction through (write, end, opts) {\n  write = write || function (data) { this.queue(data) }\n  end = end || function () { this.queue(null) }\n\n  var ended = false, destroyed = false, buffer = [], _ended = false\n  var stream = new Stream()\n  stream.readable = stream.writable = true\n  stream.paused = false\n\n//  stream.autoPause   = !(opts && opts.autoPause   === false)\n  stream.autoDestroy = !(opts && opts.autoDestroy === false)\n\n  stream.write = function (data) {\n    write.call(this, data)\n    return !stream.paused\n  }\n\n  function drain() {\n    while(buffer.length && !stream.paused) {\n      var data = buffer.shift()\n      if(null === data)\n        return stream.emit('end')\n      else\n        stream.emit('data', data)\n    }\n  }\n\n  stream.queue = stream.push = function (data) {\n//    console.error(ended)\n    if(_ended) return stream\n    if(data === null) _ended = true\n    buffer.push(data)\n    drain()\n    return stream\n  }\n\n  //this will be registered as the first 'end' listener\n  //must call destroy next tick, to make sure we're after any\n  //stream piped from here.\n  //this is only a problem if end is not emitted synchronously.\n  //a nicer way to do this is to make sure this is the last listener for 'end'\n\n  stream.on('end', function () {\n    stream.readable = false\n    if(!stream.writable && stream.autoDestroy)\n      process.nextTick(function () {\n        stream.destroy()\n      })\n  })\n\n  function _end () {\n    stream.writable = false\n    end.call(stream)\n    if(!stream.readable && stream.autoDestroy)\n      stream.destroy()\n  }\n\n  stream.end = function (data) {\n    if(ended) return\n    ended = true\n    if(arguments.length) stream.write(data)\n    _end() // will emit or queue\n    return stream\n  }\n\n  stream.destroy = function () {\n    if(destroyed) return\n    destroyed = true\n    ended = true\n    buffer.length = 0\n    stream.writable = stream.readable = false\n    stream.emit('close')\n    return stream\n  }\n\n  stream.pause = function () {\n    if(stream.paused) return\n    stream.paused = true\n    return stream\n  }\n\n  stream.resume = function () {\n    if(stream.paused) {\n      stream.paused = false\n      stream.emit('resume')\n    }\n    drain()\n    //may have become paused again,\n    //as drain emits 'data'.\n    if(!stream.paused)\n      stream.emit('drain')\n    return stream\n  }\n  return stream\n}\n\n\n}).call(this,require(\"KliubH\"))","'use strict';\n\nvar isString = require('is-string');\nvar isNumber = require('is-number-object');\nvar isBoolean = require('is-boolean-object');\nvar isSymbol = require('is-symbol');\nvar isBigInt = require('is-bigint');\n\n// eslint-disable-next-line consistent-return\nmodule.exports = function whichBoxedPrimitive(value) {\n\t// eslint-disable-next-line eqeqeq\n\tif (value == null || (typeof value !== 'object' && typeof value !== 'function')) {\n\t\treturn null;\n\t}\n\tif (isString(value)) {\n\t\treturn 'String';\n\t}\n\tif (isNumber(value)) {\n\t\treturn 'Number';\n\t}\n\tif (isBoolean(value)) {\n\t\treturn 'Boolean';\n\t}\n\tif (isSymbol(value)) {\n\t\treturn 'Symbol';\n\t}\n\tif (isBigInt(value)) {\n\t\treturn 'BigInt';\n\t}\n};\n","'use strict';\n\nvar isMap = require('is-map');\nvar isSet = require('is-set');\nvar isWeakMap = require('is-weakmap');\nvar isWeakSet = require('is-weakset');\n\nmodule.exports = function whichCollection(value) {\n\tif (value && typeof value === 'object') {\n\t\tif (isMap(value)) {\n\t\t\treturn 'Map';\n\t\t}\n\t\tif (isSet(value)) {\n\t\t\treturn 'Set';\n\t\t}\n\t\tif (isWeakMap(value)) {\n\t\t\treturn 'WeakMap';\n\t\t}\n\t\tif (isWeakSet(value)) {\n\t\t\treturn 'WeakSet';\n\t\t}\n\t}\n\treturn false;\n};\n","(function (global){\n'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\nvar toStrTags = {};\nvar gOPD = require('es-abstract/helpers/getOwnPropertyDescriptor');\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tif (typeof g[typedArray] === 'function') {\n\t\t\tvar arr = new g[typedArray]();\n\t\t\tif (Symbol.toStringTag in arr) {\n\t\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\t\tif (!descriptor) {\n\t\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t\t}\n\t\t\t\ttoStrTags[typedArray] = descriptor.get;\n\t\t\t}\n\t\t}\n\t});\n}\n\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\tvar foundName = false;\n\tforEach(toStrTags, function (getter, typedArray) {\n\t\tif (!foundName) {\n\t\t\ttry {\n\t\t\t\tvar name = getter.call(value);\n\t\t\t\tif (name === typedArray) {\n\t\t\t\t\tfoundName = name;\n\t\t\t\t}\n\t\t\t} catch (e) {}\n\t\t}\n\t});\n\treturn foundName;\n};\n\nvar isTypedArray = require('is-typed-array');\n\nmodule.exports = function whichTypedArray(value) {\n\tif (!isTypedArray(value)) { return false; }\n\tif (!hasToStringTag || !(Symbol.toStringTag in value)) { return $slice($toString(value), 8, -1); }\n\treturn tryTypedArrays(value);\n};\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","'use strict';\n\nvar test = require('../../');\n\ntest(function (t) {\n\tt.plan(4);\n\tt.ok(true);\n\tt.equal(3, 1 + 2);\n\tt.deepEqual([1, 2, [3, 4]], [1, 2, [3, 4]]);\n\tt.notDeepEqual([1, 2, [3, 4, 5]], [1, 2, [3, 4]]);\n});\n","var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n;(function (exports) {\n\t'use strict';\n\n  var Arr = (typeof Uint8Array !== 'undefined')\n    ? Uint8Array\n    : Array\n\n\tvar PLUS   = '+'.charCodeAt(0)\n\tvar SLASH  = '/'.charCodeAt(0)\n\tvar NUMBER = '0'.charCodeAt(0)\n\tvar LOWER  = 'a'.charCodeAt(0)\n\tvar UPPER  = 'A'.charCodeAt(0)\n\tvar PLUS_URL_SAFE = '-'.charCodeAt(0)\n\tvar SLASH_URL_SAFE = '_'.charCodeAt(0)\n\n\tfunction decode (elt) {\n\t\tvar code = elt.charCodeAt(0)\n\t\tif (code === PLUS ||\n\t\t    code === PLUS_URL_SAFE)\n\t\t\treturn 62 // '+'\n\t\tif (code === SLASH ||\n\t\t    code === SLASH_URL_SAFE)\n\t\t\treturn 63 // '/'\n\t\tif (code < NUMBER)\n\t\t\treturn -1 //no match\n\t\tif (code < NUMBER + 10)\n\t\t\treturn code - NUMBER + 26 + 26\n\t\tif (code < UPPER + 26)\n\t\t\treturn code - UPPER\n\t\tif (code < LOWER + 26)\n\t\t\treturn code - LOWER + 26\n\t}\n\n\tfunction b64ToByteArray (b64) {\n\t\tvar i, j, l, tmp, placeHolders, arr\n\n\t\tif (b64.length % 4 > 0) {\n\t\t\tthrow new Error('Invalid string. Length must be a multiple of 4')\n\t\t}\n\n\t\t// the number of equal signs (place holders)\n\t\t// if there are two placeholders, than the two characters before it\n\t\t// represent one byte\n\t\t// if there is only one, then the three characters before it represent 2 bytes\n\t\t// this is just a cheap hack to not do indexOf twice\n\t\tvar len = b64.length\n\t\tplaceHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0\n\n\t\t// base64 is 4/3 + up to two characters of the original data\n\t\tarr = new Arr(b64.length * 3 / 4 - placeHolders)\n\n\t\t// if there are placeholders, only get up to the last complete 4 chars\n\t\tl = placeHolders > 0 ? b64.length - 4 : b64.length\n\n\t\tvar L = 0\n\n\t\tfunction push (v) {\n\t\t\tarr[L++] = v\n\t\t}\n\n\t\tfor (i = 0, j = 0; i < l; i += 4, j += 3) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))\n\t\t\tpush((tmp & 0xFF0000) >> 16)\n\t\t\tpush((tmp & 0xFF00) >> 8)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\tif (placeHolders === 2) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)\n\t\t\tpush(tmp & 0xFF)\n\t\t} else if (placeHolders === 1) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)\n\t\t\tpush((tmp >> 8) & 0xFF)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\treturn arr\n\t}\n\n\tfunction uint8ToBase64 (uint8) {\n\t\tvar i,\n\t\t\textraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes\n\t\t\toutput = \"\",\n\t\t\ttemp, length\n\n\t\tfunction encode (num) {\n\t\t\treturn lookup.charAt(num)\n\t\t}\n\n\t\tfunction tripletToBase64 (num) {\n\t\t\treturn encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)\n\t\t}\n\n\t\t// go through the array every three bytes, we'll deal with trailing stuff later\n\t\tfor (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {\n\t\t\ttemp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n\t\t\toutput += tripletToBase64(temp)\n\t\t}\n\n\t\t// pad the end with zeros, but make sure to not forget the extra bytes\n\t\tswitch (extraBytes) {\n\t\t\tcase 1:\n\t\t\t\ttemp = uint8[uint8.length - 1]\n\t\t\t\toutput += encode(temp >> 2)\n\t\t\t\toutput += encode((temp << 4) & 0x3F)\n\t\t\t\toutput += '=='\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\ttemp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])\n\t\t\t\toutput += encode(temp >> 10)\n\t\t\t\toutput += encode((temp >> 4) & 0x3F)\n\t\t\t\toutput += encode((temp << 2) & 0x3F)\n\t\t\t\toutput += '='\n\t\t\t\tbreak\n\t\t}\n\n\t\treturn output\n\t}\n\n\texports.toByteArray = b64ToByteArray\n\texports.fromByteArray = uint8ToBase64\n}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))\n",null,"/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = Buffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192\n\n/**\n * If `Buffer._useTypedArrays`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (compatible down to IE6)\n */\nBuffer._useTypedArrays = (function () {\n  // Detect if browser supports Typed Arrays. Supported browsers are IE 10+, Firefox 4+,\n  // Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+. If the browser does not support adding\n  // properties to `Uint8Array` instances, then that's the same as no `Uint8Array` support\n  // because we need to be able to add all the node Buffer API methods. This is an issue\n  // in Firefox 4-29. Now fixed: https://bugzilla.mozilla.org/show_bug.cgi?id=695438\n  try {\n    var buf = new ArrayBuffer(0)\n    var arr = new Uint8Array(buf)\n    arr.foo = function () { return 42 }\n    return 42 === arr.foo() &&\n        typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`\n  } catch (e) {\n    return false\n  }\n})()\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (subject, encoding, noZero) {\n  if (!(this instanceof Buffer))\n    return new Buffer(subject, encoding, noZero)\n\n  var type = typeof subject\n\n  // Workaround: node's base64 implementation allows for non-padded strings\n  // while base64-js does not.\n  if (encoding === 'base64' && type === 'string') {\n    subject = stringtrim(subject)\n    while (subject.length % 4 !== 0) {\n      subject = subject + '='\n    }\n  }\n\n  // Find the length\n  var length\n  if (type === 'number')\n    length = coerce(subject)\n  else if (type === 'string')\n    length = Buffer.byteLength(subject, encoding)\n  else if (type === 'object')\n    length = coerce(subject.length) // assume that object is array-like\n  else\n    throw new Error('First argument needs to be a number, array or string.')\n\n  var buf\n  if (Buffer._useTypedArrays) {\n    // Preferred: Return an augmented `Uint8Array` instance for best performance\n    buf = Buffer._augment(new Uint8Array(length))\n  } else {\n    // Fallback: Return THIS instance of Buffer (created by `new`)\n    buf = this\n    buf.length = length\n    buf._isBuffer = true\n  }\n\n  var i\n  if (Buffer._useTypedArrays && typeof subject.byteLength === 'number') {\n    // Speed optimization -- use set if we're copying from a typed array\n    buf._set(subject)\n  } else if (isArrayish(subject)) {\n    // Treat array-ish objects as a byte array\n    for (i = 0; i < length; i++) {\n      if (Buffer.isBuffer(subject))\n        buf[i] = subject.readUInt8(i)\n      else\n        buf[i] = subject[i]\n    }\n  } else if (type === 'string') {\n    buf.write(subject, 0, encoding)\n  } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {\n    for (i = 0; i < length; i++) {\n      buf[i] = 0\n    }\n  }\n\n  return buf\n}\n\n// STATIC METHODS\n// ==============\n\nBuffer.isEncoding = function (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.isBuffer = function (b) {\n  return !!(b !== null && b !== undefined && b._isBuffer)\n}\n\nBuffer.byteLength = function (str, encoding) {\n  var ret\n  str = str + ''\n  switch (encoding || 'utf8') {\n    case 'hex':\n      ret = str.length / 2\n      break\n    case 'utf8':\n    case 'utf-8':\n      ret = utf8ToBytes(str).length\n      break\n    case 'ascii':\n    case 'binary':\n    case 'raw':\n      ret = str.length\n      break\n    case 'base64':\n      ret = base64ToBytes(str).length\n      break\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      ret = str.length * 2\n      break\n    default:\n      throw new Error('Unknown encoding')\n  }\n  return ret\n}\n\nBuffer.concat = function (list, totalLength) {\n  assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\\n' +\n      'list should be an Array.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  } else if (list.length === 1) {\n    return list[0]\n  }\n\n  var i\n  if (typeof totalLength !== 'number') {\n    totalLength = 0\n    for (i = 0; i < list.length; i++) {\n      totalLength += list[i].length\n    }\n  }\n\n  var buf = new Buffer(totalLength)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\n// BUFFER INSTANCE METHODS\n// =======================\n\nfunction _hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  assert(strLen % 2 === 0, 'Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var byte = parseInt(string.substr(i * 2, 2), 16)\n    assert(!isNaN(byte), 'Invalid hex string')\n    buf[offset + i] = byte\n  }\n  Buffer._charsWritten = i * 2\n  return i\n}\n\nfunction _utf8Write (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(utf8ToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nfunction _asciiWrite (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(asciiToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nfunction _binaryWrite (buf, string, offset, length) {\n  return _asciiWrite(buf, string, offset, length)\n}\n\nfunction _base64Write (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(base64ToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nfunction _utf16leWrite (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(utf16leToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nBuffer.prototype.write = function (string, offset, length, encoding) {\n  // Support both (string, offset, length, encoding)\n  // and the legacy (string, encoding, offset, length)\n  if (isFinite(offset)) {\n    if (!isFinite(length)) {\n      encoding = length\n      length = undefined\n    }\n  } else {  // legacy\n    var swap = encoding\n    encoding = offset\n    offset = length\n    length = swap\n  }\n\n  offset = Number(offset) || 0\n  var remaining = this.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n  encoding = String(encoding || 'utf8').toLowerCase()\n\n  var ret\n  switch (encoding) {\n    case 'hex':\n      ret = _hexWrite(this, string, offset, length)\n      break\n    case 'utf8':\n    case 'utf-8':\n      ret = _utf8Write(this, string, offset, length)\n      break\n    case 'ascii':\n      ret = _asciiWrite(this, string, offset, length)\n      break\n    case 'binary':\n      ret = _binaryWrite(this, string, offset, length)\n      break\n    case 'base64':\n      ret = _base64Write(this, string, offset, length)\n      break\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      ret = _utf16leWrite(this, string, offset, length)\n      break\n    default:\n      throw new Error('Unknown encoding')\n  }\n  return ret\n}\n\nBuffer.prototype.toString = function (encoding, start, end) {\n  var self = this\n\n  encoding = String(encoding || 'utf8').toLowerCase()\n  start = Number(start) || 0\n  end = (end !== undefined)\n    ? Number(end)\n    : end = self.length\n\n  // Fastpath empty strings\n  if (end === start)\n    return ''\n\n  var ret\n  switch (encoding) {\n    case 'hex':\n      ret = _hexSlice(self, start, end)\n      break\n    case 'utf8':\n    case 'utf-8':\n      ret = _utf8Slice(self, start, end)\n      break\n    case 'ascii':\n      ret = _asciiSlice(self, start, end)\n      break\n    case 'binary':\n      ret = _binarySlice(self, start, end)\n      break\n    case 'base64':\n      ret = _base64Slice(self, start, end)\n      break\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      ret = _utf16leSlice(self, start, end)\n      break\n    default:\n      throw new Error('Unknown encoding')\n  }\n  return ret\n}\n\nBuffer.prototype.toJSON = function () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function (target, target_start, start, end) {\n  var source = this\n\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (!target_start) target_start = 0\n\n  // Copy 0 bytes; we're done\n  if (end === start) return\n  if (target.length === 0 || source.length === 0) return\n\n  // Fatal error conditions\n  assert(end >= start, 'sourceEnd < sourceStart')\n  assert(target_start >= 0 && target_start < target.length,\n      'targetStart out of bounds')\n  assert(start >= 0 && start < source.length, 'sourceStart out of bounds')\n  assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length)\n    end = this.length\n  if (target.length - target_start < end - start)\n    end = target.length - target_start + start\n\n  var len = end - start\n\n  if (len < 100 || !Buffer._useTypedArrays) {\n    for (var i = 0; i < len; i++)\n      target[i + target_start] = this[i + start]\n  } else {\n    target._set(this.subarray(start, start + len), target_start)\n  }\n}\n\nfunction _base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction _utf8Slice (buf, start, end) {\n  var res = ''\n  var tmp = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    if (buf[i] <= 0x7F) {\n      res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])\n      tmp = ''\n    } else {\n      tmp += '%' + buf[i].toString(16)\n    }\n  }\n\n  return res + decodeUtf8Char(tmp)\n}\n\nfunction _asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++)\n    ret += String.fromCharCode(buf[i])\n  return ret\n}\n\nfunction _binarySlice (buf, start, end) {\n  return _asciiSlice(buf, start, end)\n}\n\nfunction _hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction _utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i+1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function (start, end) {\n  var len = this.length\n  start = clamp(start, len, 0)\n  end = clamp(end, len, len)\n\n  if (Buffer._useTypedArrays) {\n    return Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    var newBuf = new Buffer(sliceLen, undefined, true)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n    return newBuf\n  }\n}\n\n// `get` will be removed in Node 0.13+\nBuffer.prototype.get = function (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` will be removed in Node 0.13+\nBuffer.prototype.set = function (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nBuffer.prototype.readUInt8 = function (offset, noAssert) {\n  if (!noAssert) {\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset < this.length, 'Trying to read beyond buffer length')\n  }\n\n  if (offset >= this.length)\n    return\n\n  return this[offset]\n}\n\nfunction _readUInt16 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val\n  if (littleEndian) {\n    val = buf[offset]\n    if (offset + 1 < len)\n      val |= buf[offset + 1] << 8\n  } else {\n    val = buf[offset] << 8\n    if (offset + 1 < len)\n      val |= buf[offset + 1]\n  }\n  return val\n}\n\nBuffer.prototype.readUInt16LE = function (offset, noAssert) {\n  return _readUInt16(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readUInt16BE = function (offset, noAssert) {\n  return _readUInt16(this, offset, false, noAssert)\n}\n\nfunction _readUInt32 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val\n  if (littleEndian) {\n    if (offset + 2 < len)\n      val = buf[offset + 2] << 16\n    if (offset + 1 < len)\n      val |= buf[offset + 1] << 8\n    val |= buf[offset]\n    if (offset + 3 < len)\n      val = val + (buf[offset + 3] << 24 >>> 0)\n  } else {\n    if (offset + 1 < len)\n      val = buf[offset + 1] << 16\n    if (offset + 2 < len)\n      val |= buf[offset + 2] << 8\n    if (offset + 3 < len)\n      val |= buf[offset + 3]\n    val = val + (buf[offset] << 24 >>> 0)\n  }\n  return val\n}\n\nBuffer.prototype.readUInt32LE = function (offset, noAssert) {\n  return _readUInt32(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readUInt32BE = function (offset, noAssert) {\n  return _readUInt32(this, offset, false, noAssert)\n}\n\nBuffer.prototype.readInt8 = function (offset, noAssert) {\n  if (!noAssert) {\n    assert(offset !== undefined && offset !== null,\n        'missing offset')\n    assert(offset < this.length, 'Trying to read beyond buffer length')\n  }\n\n  if (offset >= this.length)\n    return\n\n  var neg = this[offset] & 0x80\n  if (neg)\n    return (0xff - this[offset] + 1) * -1\n  else\n    return this[offset]\n}\n\nfunction _readInt16 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val = _readUInt16(buf, offset, littleEndian, true)\n  var neg = val & 0x8000\n  if (neg)\n    return (0xffff - val + 1) * -1\n  else\n    return val\n}\n\nBuffer.prototype.readInt16LE = function (offset, noAssert) {\n  return _readInt16(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readInt16BE = function (offset, noAssert) {\n  return _readInt16(this, offset, false, noAssert)\n}\n\nfunction _readInt32 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val = _readUInt32(buf, offset, littleEndian, true)\n  var neg = val & 0x80000000\n  if (neg)\n    return (0xffffffff - val + 1) * -1\n  else\n    return val\n}\n\nBuffer.prototype.readInt32LE = function (offset, noAssert) {\n  return _readInt32(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readInt32BE = function (offset, noAssert) {\n  return _readInt32(this, offset, false, noAssert)\n}\n\nfunction _readFloat (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  return ieee754.read(buf, offset, littleEndian, 23, 4)\n}\n\nBuffer.prototype.readFloatLE = function (offset, noAssert) {\n  return _readFloat(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readFloatBE = function (offset, noAssert) {\n  return _readFloat(this, offset, false, noAssert)\n}\n\nfunction _readDouble (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  return ieee754.read(buf, offset, littleEndian, 52, 8)\n}\n\nBuffer.prototype.readDoubleLE = function (offset, noAssert) {\n  return _readDouble(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readDoubleBE = function (offset, noAssert) {\n  return _readDouble(this, offset, false, noAssert)\n}\n\nBuffer.prototype.writeUInt8 = function (value, offset, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset < this.length, 'trying to write beyond buffer length')\n    verifuint(value, 0xff)\n  }\n\n  if (offset >= this.length) return\n\n  this[offset] = value\n}\n\nfunction _writeUInt16 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'trying to write beyond buffer length')\n    verifuint(value, 0xffff)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {\n    buf[offset + i] =\n        (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n            (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function (value, offset, noAssert) {\n  _writeUInt16(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeUInt16BE = function (value, offset, noAssert) {\n  _writeUInt16(this, value, offset, false, noAssert)\n}\n\nfunction _writeUInt32 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'trying to write beyond buffer length')\n    verifuint(value, 0xffffffff)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {\n    buf[offset + i] =\n        (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function (value, offset, noAssert) {\n  _writeUInt32(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeUInt32BE = function (value, offset, noAssert) {\n  _writeUInt32(this, value, offset, false, noAssert)\n}\n\nBuffer.prototype.writeInt8 = function (value, offset, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset < this.length, 'Trying to write beyond buffer length')\n    verifsint(value, 0x7f, -0x80)\n  }\n\n  if (offset >= this.length)\n    return\n\n  if (value >= 0)\n    this.writeUInt8(value, offset, noAssert)\n  else\n    this.writeUInt8(0xff + value + 1, offset, noAssert)\n}\n\nfunction _writeInt16 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')\n    verifsint(value, 0x7fff, -0x8000)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  if (value >= 0)\n    _writeUInt16(buf, value, offset, littleEndian, noAssert)\n  else\n    _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)\n}\n\nBuffer.prototype.writeInt16LE = function (value, offset, noAssert) {\n  _writeInt16(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeInt16BE = function (value, offset, noAssert) {\n  _writeInt16(this, value, offset, false, noAssert)\n}\n\nfunction _writeInt32 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')\n    verifsint(value, 0x7fffffff, -0x80000000)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  if (value >= 0)\n    _writeUInt32(buf, value, offset, littleEndian, noAssert)\n  else\n    _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)\n}\n\nBuffer.prototype.writeInt32LE = function (value, offset, noAssert) {\n  _writeInt32(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeInt32BE = function (value, offset, noAssert) {\n  _writeInt32(this, value, offset, false, noAssert)\n}\n\nfunction _writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')\n    verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n}\n\nBuffer.prototype.writeFloatLE = function (value, offset, noAssert) {\n  _writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function (value, offset, noAssert) {\n  _writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction _writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 7 < buf.length,\n        'Trying to write beyond buffer length')\n    verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n}\n\nBuffer.prototype.writeDoubleLE = function (value, offset, noAssert) {\n  _writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function (value, offset, noAssert) {\n  _writeDouble(this, value, offset, false, noAssert)\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (typeof value === 'string') {\n    value = value.charCodeAt(0)\n  }\n\n  assert(typeof value === 'number' && !isNaN(value), 'value is not a number')\n  assert(end >= start, 'end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  assert(start >= 0 && start < this.length, 'start out of bounds')\n  assert(end >= 0 && end <= this.length, 'end out of bounds')\n\n  for (var i = start; i < end; i++) {\n    this[i] = value\n  }\n}\n\nBuffer.prototype.inspect = function () {\n  var out = []\n  var len = this.length\n  for (var i = 0; i < len; i++) {\n    out[i] = toHex(this[i])\n    if (i === exports.INSPECT_MAX_BYTES) {\n      out[i + 1] = '...'\n      break\n    }\n  }\n  return '<Buffer ' + out.join(' ') + '>'\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer._useTypedArrays) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1)\n        buf[i] = this[i]\n      return buf.buffer\n    }\n  } else {\n    throw new Error('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function (arr) {\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array get/set methods before overwriting\n  arr._get = arr.get\n  arr._set = arr.set\n\n  // deprecated, will be removed in node 0.13+\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\n// slice(start, end)\nfunction clamp (index, len, defaultValue) {\n  if (typeof index !== 'number') return defaultValue\n  index = ~~index;  // Coerce to integer.\n  if (index >= len) return len\n  if (index >= 0) return index\n  index += len\n  if (index >= 0) return index\n  return 0\n}\n\nfunction coerce (length) {\n  // Coerce length to a number (possibly NaN), round up\n  // in case it's fractional (e.g. 123.456) then do a\n  // double negate to coerce a NaN to 0. Easy, right?\n  length = ~~Math.ceil(+length)\n  return length < 0 ? 0 : length\n}\n\nfunction isArray (subject) {\n  return (Array.isArray || function (subject) {\n    return Object.prototype.toString.call(subject) === '[object Array]'\n  })(subject)\n}\n\nfunction isArrayish (subject) {\n  return isArray(subject) || Buffer.isBuffer(subject) ||\n      subject && typeof subject === 'object' &&\n      typeof subject.length === 'number'\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    var b = str.charCodeAt(i)\n    if (b <= 0x7F)\n      byteArray.push(str.charCodeAt(i))\n    else {\n      var start = i\n      if (b >= 0xD800 && b <= 0xDFFF) i++\n      var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')\n      for (var j = 0; j < h.length; j++)\n        byteArray.push(parseInt(h[j], 16))\n    }\n  }\n  return byteArray\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(str)\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  var pos\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length))\n      break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction decodeUtf8Char (str) {\n  try {\n    return decodeURIComponent(str)\n  } catch (err) {\n    return String.fromCharCode(0xFFFD) // UTF 8 invalid char\n  }\n}\n\n/*\n * We have to make sure that the value is a valid integer. This means that it\n * is non-negative. It has no fractional component and that it does not\n * exceed the maximum allowed value.\n */\nfunction verifuint (value, max) {\n  assert(typeof value === 'number', 'cannot write a non-number as a number')\n  assert(value >= 0, 'specified a negative value for writing an unsigned value')\n  assert(value <= max, 'value is larger than maximum value for type')\n  assert(Math.floor(value) === value, 'value has a fractional component')\n}\n\nfunction verifsint (value, max, min) {\n  assert(typeof value === 'number', 'cannot write a non-number as a number')\n  assert(value <= max, 'value larger than maximum allowed value')\n  assert(value >= min, 'value smaller than minimum allowed value')\n  assert(Math.floor(value) === value, 'value has a fractional component')\n}\n\nfunction verifIEEE754 (value, max, min) {\n  assert(typeof value === 'number', 'cannot write a non-number as a number')\n  assert(value <= max, 'value larger than maximum allowed value')\n  assert(value >= min, 'value smaller than minimum allowed value')\n}\n\nfunction assert (test, message) {\n  if (!test) throw new Error(message || 'Failed assertion')\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      }\n      throw TypeError('Uncaught, unspecified \"error\" event.');\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        len = arguments.length;\n        args = new Array(len - 1);\n        for (i = 1; i < len; i++)\n          args[i - 1] = arguments[i];\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    len = arguments.length;\n    args = new Array(len - 1);\n    for (i = 1; i < len; i++)\n      args[i - 1] = arguments[i];\n\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    var m;\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  var ret;\n  if (!emitter._events || !emitter._events[type])\n    ret = 0;\n  else if (isFunction(emitter._events[type]))\n    ret = 1;\n  else\n    ret = emitter._events[type].length;\n  return ret;\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","(function (process){\n// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n\n}).call(this,require(\"KliubH\"))","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    if (canPost) {\n        var queue = [];\n        window.addEventListener('message', function (ev) {\n            var source = ev.source;\n            if ((source === window || source === null) && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n}\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\nmodule.exports = Duplex;\nvar inherits = require('inherits');\nvar setImmediate = require('process/browser.js').nextTick;\nvar Readable = require('./readable.js');\nvar Writable = require('./writable.js');\n\ninherits(Duplex, Readable);\n\nDuplex.prototype.write = Writable.prototype.write;\nDuplex.prototype.end = Writable.prototype.end;\nDuplex.prototype._write = Writable.prototype._write;\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex))\n    return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false)\n    this.readable = false;\n\n  if (options && options.writable === false)\n    this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false)\n    this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended)\n    return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  var self = this;\n  setImmediate(function () {\n    self.end();\n  });\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('./readable.js');\nStream.Writable = require('./writable.js');\nStream.Duplex = require('./duplex.js');\nStream.Transform = require('./transform.js');\nStream.PassThrough = require('./passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    if (canPost) {\n        var queue = [];\n        window.addEventListener('message', function (ev) {\n            var source = ev.source;\n            if ((source === window || source === null) && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n}\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./transform.js');\nvar inherits = require('inherits');\ninherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough))\n    return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function(chunk, encoding, cb) {\n  cb(null, chunk);\n};\n","(function (process){\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Readable;\nReadable.ReadableState = ReadableState;\n\nvar EE = require('events').EventEmitter;\nvar Stream = require('./index.js');\nvar Buffer = require('buffer').Buffer;\nvar setImmediate = require('process/browser.js').nextTick;\nvar StringDecoder;\n\nvar inherits = require('inherits');\ninherits(Readable, Stream);\n\nfunction ReadableState(options, stream) {\n  options = options || {};\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;\n\n  // cast to ints.\n  this.highWaterMark = ~~this.highWaterMark;\n\n  this.buffer = [];\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = false;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // In streams that never have any data, and do push(null) right away,\n  // the consumer can miss the 'end' event if they do some I/O before\n  // consuming the stream.  So, we don't emit('end') until some reading\n  // happens.\n  this.calledRead = false;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, becuase any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // when piping, we only care about 'readable' events that happen\n  // after read()ing all the bytes and not getting any pushback.\n  this.ranOut = false;\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder)\n      StringDecoder = require('string_decoder').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  if (!(this instanceof Readable))\n    return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  Stream.call(this);\n}\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function(chunk, encoding) {\n  var state = this._readableState;\n\n  if (typeof chunk === 'string' && !state.objectMode) {\n    encoding = encoding || state.defaultEncoding;\n    if (encoding !== state.encoding) {\n      chunk = new Buffer(chunk, encoding);\n      encoding = '';\n    }\n  }\n\n  return readableAddChunk(this, state, chunk, encoding, false);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function(chunk) {\n  var state = this._readableState;\n  return readableAddChunk(this, state, chunk, '', true);\n};\n\nfunction readableAddChunk(stream, state, chunk, encoding, addToFront) {\n  var er = chunkInvalid(state, chunk);\n  if (er) {\n    stream.emit('error', er);\n  } else if (chunk === null || chunk === undefined) {\n    state.reading = false;\n    if (!state.ended)\n      onEofChunk(stream, state);\n  } else if (state.objectMode || chunk && chunk.length > 0) {\n    if (state.ended && !addToFront) {\n      var e = new Error('stream.push() after EOF');\n      stream.emit('error', e);\n    } else if (state.endEmitted && addToFront) {\n      var e = new Error('stream.unshift() after end event');\n      stream.emit('error', e);\n    } else {\n      if (state.decoder && !addToFront && !encoding)\n        chunk = state.decoder.write(chunk);\n\n      // update the buffer info.\n      state.length += state.objectMode ? 1 : chunk.length;\n      if (addToFront) {\n        state.buffer.unshift(chunk);\n      } else {\n        state.reading = false;\n        state.buffer.push(chunk);\n      }\n\n      if (state.needReadable)\n        emitReadable(stream);\n\n      maybeReadMore(stream, state);\n    }\n  } else if (!addToFront) {\n    state.reading = false;\n  }\n\n  return needMoreData(state);\n}\n\n\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended &&\n         (state.needReadable ||\n          state.length < state.highWaterMark ||\n          state.length === 0);\n}\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function(enc) {\n  if (!StringDecoder)\n    StringDecoder = require('string_decoder').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n};\n\n// Don't raise the hwm > 128MB\nvar MAX_HWM = 0x800000;\nfunction roundUpToNextPowerOf2(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2\n    n--;\n    for (var p = 1; p < 32; p <<= 1) n |= n >> p;\n    n++;\n  }\n  return n;\n}\n\nfunction howMuchToRead(n, state) {\n  if (state.length === 0 && state.ended)\n    return 0;\n\n  if (state.objectMode)\n    return n === 0 ? 0 : 1;\n\n  if (isNaN(n) || n === null) {\n    // only flow one buffer at a time\n    if (state.flowing && state.buffer.length)\n      return state.buffer[0].length;\n    else\n      return state.length;\n  }\n\n  if (n <= 0)\n    return 0;\n\n  // If we're asking for more than the target buffer level,\n  // then raise the water mark.  Bump up to the next highest\n  // power of 2, to prevent increasing it excessively in tiny\n  // amounts.\n  if (n > state.highWaterMark)\n    state.highWaterMark = roundUpToNextPowerOf2(n);\n\n  // don't have that much.  return null, unless we've ended.\n  if (n > state.length) {\n    if (!state.ended) {\n      state.needReadable = true;\n      return 0;\n    } else\n      return state.length;\n  }\n\n  return n;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function(n) {\n  var state = this._readableState;\n  state.calledRead = true;\n  var nOrig = n;\n\n  if (typeof n !== 'number' || n > 0)\n    state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 &&\n      state.needReadable &&\n      (state.length >= state.highWaterMark || state.ended)) {\n    emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0)\n      endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length - n <= state.highWaterMark)\n    doRead = true;\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading)\n    doRead = false;\n\n  if (doRead) {\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0)\n      state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n  }\n\n  // If _read called its callback synchronously, then `reading`\n  // will be false, and we need to re-evaluate how much data we\n  // can return to the user.\n  if (doRead && !state.reading)\n    n = howMuchToRead(nOrig, state);\n\n  var ret;\n  if (n > 0)\n    ret = fromList(n, state);\n  else\n    ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  }\n\n  state.length -= n;\n\n  // If we have nothing in the buffer, then we want to know\n  // as soon as we *do* get something into the buffer.\n  if (state.length === 0 && !state.ended)\n    state.needReadable = true;\n\n  // If we happened to read() exactly the remaining amount in the\n  // buffer, and the EOF has been seen at this point, then make sure\n  // that we emit 'end' on the very next tick.\n  if (state.ended && !state.endEmitted && state.length === 0)\n    endReadable(this);\n\n  return ret;\n};\n\nfunction chunkInvalid(state, chunk) {\n  var er = null;\n  if (!Buffer.isBuffer(chunk) &&\n      'string' !== typeof chunk &&\n      chunk !== null &&\n      chunk !== undefined &&\n      !state.objectMode &&\n      !er) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n\nfunction onEofChunk(stream, state) {\n  if (state.decoder && !state.ended) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // if we've ended and we have some data left, then emit\n  // 'readable' now to make sure it gets picked up.\n  if (state.length > 0)\n    emitReadable(stream);\n  else\n    endReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (state.emittedReadable)\n    return;\n\n  state.emittedReadable = true;\n  if (state.sync)\n    setImmediate(function() {\n      emitReadable_(stream);\n    });\n  else\n    emitReadable_(stream);\n}\n\nfunction emitReadable_(stream) {\n  stream.emit('readable');\n}\n\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    setImmediate(function() {\n      maybeReadMore_(stream, state);\n    });\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended &&\n         state.length < state.highWaterMark) {\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\n    else\n      len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function(n) {\n  this.emit('error', new Error('not implemented'));\n};\n\nReadable.prototype.pipe = function(dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&\n              dest !== process.stdout &&\n              dest !== process.stderr;\n\n  var endFn = doEnd ? onend : cleanup;\n  if (state.endEmitted)\n    setImmediate(endFn);\n  else\n    src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable) {\n    if (readable !== src) return;\n    cleanup();\n  }\n\n  function onend() {\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  function cleanup() {\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', cleanup);\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (!dest._writableState || dest._writableState.needDrain)\n      ondrain();\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  // check for listeners before emit removes one-time listeners.\n  var errListeners = EE.listenerCount(dest, 'error');\n  function onerror(er) {\n    unpipe();\n    if (errListeners === 0 && EE.listenerCount(dest, 'error') === 0)\n      dest.emit('error', er);\n  }\n  dest.once('error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    // the handler that waits for readable events after all\n    // the data gets sucked out in flow.\n    // This would be easier to follow with a .once() handler\n    // in flow(), but that is too slow.\n    this.on('readable', pipeOnReadable);\n\n    state.flowing = true;\n    setImmediate(function() {\n      flow(src);\n    });\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function() {\n    var dest = this;\n    var state = src._readableState;\n    state.awaitDrain--;\n    if (state.awaitDrain === 0)\n      flow(src);\n  };\n}\n\nfunction flow(src) {\n  var state = src._readableState;\n  var chunk;\n  state.awaitDrain = 0;\n\n  function write(dest, i, list) {\n    var written = dest.write(chunk);\n    if (false === written) {\n      state.awaitDrain++;\n    }\n  }\n\n  while (state.pipesCount && null !== (chunk = src.read())) {\n\n    if (state.pipesCount === 1)\n      write(state.pipes, 0, null);\n    else\n      forEach(state.pipes, write);\n\n    src.emit('data', chunk);\n\n    // if anyone needs a drain, then we have to wait for that.\n    if (state.awaitDrain > 0)\n      return;\n  }\n\n  // if every destination was unpiped, either before entering this\n  // function, or in the while loop, then stop flowing.\n  //\n  // NB: This is a pretty rare edge case.\n  if (state.pipesCount === 0) {\n    state.flowing = false;\n\n    // if there were data event listeners added, then switch to old mode.\n    if (EE.listenerCount(src, 'data') > 0)\n      emitDataEvents(src);\n    return;\n  }\n\n  // at this point, no one needed a drain, so we just ran out of data\n  // on the next readable event, start it over again.\n  state.ranOut = true;\n}\n\nfunction pipeOnReadable() {\n  if (this._readableState.ranOut) {\n    this._readableState.ranOut = false;\n    flow(this);\n  }\n}\n\n\nReadable.prototype.unpipe = function(dest) {\n  var state = this._readableState;\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0)\n    return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes)\n      return this;\n\n    if (!dest)\n      dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    this.removeListener('readable', pipeOnReadable);\n    state.flowing = false;\n    if (dest)\n      dest.emit('unpipe', this);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    this.removeListener('readable', pipeOnReadable);\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++)\n      dests[i].emit('unpipe', this);\n    return this;\n  }\n\n  // try to find the right one.\n  var i = indexOf(state.pipes, dest);\n  if (i === -1)\n    return this;\n\n  state.pipes.splice(i, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1)\n    state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function(ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data' && !this._readableState.flowing)\n    emitDataEvents(this);\n\n  if (ev === 'readable' && this.readable) {\n    var state = this._readableState;\n    if (!state.readableListening) {\n      state.readableListening = true;\n      state.emittedReadable = false;\n      state.needReadable = true;\n      if (!state.reading) {\n        this.read(0);\n      } else if (state.length) {\n        emitReadable(this, state);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function() {\n  emitDataEvents(this);\n  this.read(0);\n  this.emit('resume');\n};\n\nReadable.prototype.pause = function() {\n  emitDataEvents(this, true);\n  this.emit('pause');\n};\n\nfunction emitDataEvents(stream, startPaused) {\n  var state = stream._readableState;\n\n  if (state.flowing) {\n    // https://github.com/isaacs/readable-stream/issues/16\n    throw new Error('Cannot switch to old mode now.');\n  }\n\n  var paused = startPaused || false;\n  var readable = false;\n\n  // convert to an old-style stream.\n  stream.readable = true;\n  stream.pipe = Stream.prototype.pipe;\n  stream.on = stream.addListener = Stream.prototype.on;\n\n  stream.on('readable', function() {\n    readable = true;\n\n    var c;\n    while (!paused && (null !== (c = stream.read())))\n      stream.emit('data', c);\n\n    if (c === null) {\n      readable = false;\n      stream._readableState.needReadable = true;\n    }\n  });\n\n  stream.pause = function() {\n    paused = true;\n    this.emit('pause');\n  };\n\n  stream.resume = function() {\n    paused = false;\n    if (readable)\n      setImmediate(function() {\n        stream.emit('readable');\n      });\n    else\n      this.read(0);\n    this.emit('resume');\n  };\n\n  // now make it start, just in case it hadn't already.\n  stream.emit('readable');\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function(stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function() {\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length)\n        self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function(chunk) {\n    if (state.decoder)\n      chunk = state.decoder.write(chunk);\n    if (!chunk || !state.objectMode && !chunk.length)\n      return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (typeof stream[i] === 'function' &&\n        typeof this[i] === 'undefined') {\n      this[i] = function(method) { return function() {\n        return stream[method].apply(stream, arguments);\n      }}(i);\n    }\n  }\n\n  // proxy certain important events.\n  var events = ['error', 'close', 'destroy', 'pause', 'resume'];\n  forEach(events, function(ev) {\n    stream.on(ev, function (x) {\n      return self.emit.apply(self, ev, x);\n    });\n  });\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function(n) {\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\nfunction fromList(n, state) {\n  var list = state.buffer;\n  var length = state.length;\n  var stringMode = !!state.decoder;\n  var objectMode = !!state.objectMode;\n  var ret;\n\n  // nothing in the list, definitely empty.\n  if (list.length === 0)\n    return null;\n\n  if (length === 0)\n    ret = null;\n  else if (objectMode)\n    ret = list.shift();\n  else if (!n || n >= length) {\n    // read it all, truncate the array.\n    if (stringMode)\n      ret = list.join('');\n    else\n      ret = Buffer.concat(list, length);\n    list.length = 0;\n  } else {\n    // read just some of it.\n    if (n < list[0].length) {\n      // just take a part of the first list item.\n      // slice is the same for buffers and strings.\n      var buf = list[0];\n      ret = buf.slice(0, n);\n      list[0] = buf.slice(n);\n    } else if (n === list[0].length) {\n      // first list is a perfect match\n      ret = list.shift();\n    } else {\n      // complex case.\n      // we have enough to cover it, but it spans past the first buffer.\n      if (stringMode)\n        ret = '';\n      else\n        ret = new Buffer(n);\n\n      var c = 0;\n      for (var i = 0, l = list.length; i < l && c < n; i++) {\n        var buf = list[0];\n        var cpy = Math.min(n - c, buf.length);\n\n        if (stringMode)\n          ret += buf.slice(0, cpy);\n        else\n          buf.copy(ret, c, 0, cpy);\n\n        if (cpy < buf.length)\n          list[0] = buf.slice(cpy);\n        else\n          list.shift();\n\n        c += cpy;\n      }\n    }\n  }\n\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0)\n    throw new Error('endReadable called on non-empty stream');\n\n  if (!state.endEmitted && state.calledRead) {\n    state.ended = true;\n    setImmediate(function() {\n      // Check that we didn't get one last unshift.\n      if (!state.endEmitted && state.length === 0) {\n        state.endEmitted = true;\n        stream.readable = false;\n        stream.emit('end');\n      }\n    });\n  }\n}\n\nfunction forEach (xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf (xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}\n\n}).call(this,require(\"KliubH\"))","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\nmodule.exports = Transform;\n\nvar Duplex = require('./duplex.js');\nvar inherits = require('inherits');\ninherits(Transform, Duplex);\n\n\nfunction TransformState(options, stream) {\n  this.afterTransform = function(er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb)\n    return stream.emit('error', new Error('no writecb in Transform class'));\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data !== null && data !== undefined)\n    stream.push(data);\n\n  if (cb)\n    cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\n\n\nfunction Transform(options) {\n  if (!(this instanceof Transform))\n    return new Transform(options);\n\n  Duplex.call(this, options);\n\n  var ts = this._transformState = new TransformState(options, this);\n\n  // when the writable side finishes, then flush out anything remaining.\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  this.once('finish', function() {\n    if ('function' === typeof this._flush)\n      this._flush(function(er) {\n        done(stream, er);\n      });\n    else\n      done(stream);\n  });\n}\n\nTransform.prototype.push = function(chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function(chunk, encoding, cb) {\n  throw new Error('not implemented');\n};\n\nTransform.prototype._write = function(chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform ||\n        rs.needReadable ||\n        rs.length < rs.highWaterMark)\n      this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function(n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\n\nfunction done(stream, er) {\n  if (er)\n    return stream.emit('error', er);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var rs = stream._readableState;\n  var ts = stream._transformState;\n\n  if (ws.length)\n    throw new Error('calling transform done when ws.length != 0');\n\n  if (ts.transforming)\n    throw new Error('calling transform done when still transforming');\n\n  return stream.push(null);\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, cb), and it'll handle all\n// the drain event emission and buffering.\n\nmodule.exports = Writable;\nWritable.WritableState = WritableState;\n\nvar isUint8Array = typeof Uint8Array !== 'undefined'\n  ? function (x) { return x instanceof Uint8Array }\n  : function (x) {\n    return x && x.constructor && x.constructor.name === 'Uint8Array'\n  }\n;\nvar isArrayBuffer = typeof ArrayBuffer !== 'undefined'\n  ? function (x) { return x instanceof ArrayBuffer }\n  : function (x) {\n    return x && x.constructor && x.constructor.name === 'ArrayBuffer'\n  }\n;\n\nvar inherits = require('inherits');\nvar Stream = require('./index.js');\nvar setImmediate = require('process/browser.js').nextTick;\nvar Buffer = require('buffer').Buffer;\n\ninherits(Writable, Stream);\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n}\n\nfunction WritableState(options, stream) {\n  options = options || {};\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  // cast to ints.\n  this.highWaterMark = ~~this.highWaterMark;\n\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, becuase any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function(er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.buffer = [];\n}\n\nfunction Writable(options) {\n  // Writable ctor is applied to Duplexes, though they're not\n  // instanceof Writable, they're instanceof Readable.\n  if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))\n    return new Writable(options);\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function() {\n  this.emit('error', new Error('Cannot pipe. Not readable.'));\n};\n\n\nfunction writeAfterEnd(stream, state, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  setImmediate(function() {\n    cb(er);\n  });\n}\n\n// If we get something that is not a buffer, string, null, or undefined,\n// and we're not in objectMode, then that's an error.\n// Otherwise stream chunks are all considered to be of length=1, and the\n// watermarks determine how many objects to keep in the buffer, rather than\n// how many bytes or characters.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  if (!Buffer.isBuffer(chunk) &&\n      'string' !== typeof chunk &&\n      chunk !== null &&\n      chunk !== undefined &&\n      !state.objectMode) {\n    var er = new TypeError('Invalid non-string/buffer chunk');\n    stream.emit('error', er);\n    setImmediate(function() {\n      cb(er);\n    });\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function(chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (!Buffer.isBuffer(chunk) && isUint8Array(chunk))\n    chunk = new Buffer(chunk);\n  if (isArrayBuffer(chunk) && typeof Uint8Array !== 'undefined')\n    chunk = new Buffer(new Uint8Array(chunk));\n  \n  if (Buffer.isBuffer(chunk))\n    encoding = 'buffer';\n  else if (!encoding)\n    encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function')\n    cb = function() {};\n\n  if (state.ended)\n    writeAfterEnd(this, state, cb);\n  else if (validChunk(this, state, chunk, cb))\n    ret = writeOrBuffer(this, state, chunk, encoding, cb);\n\n  return ret;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode &&\n      state.decodeStrings !== false &&\n      typeof chunk === 'string') {\n    chunk = new Buffer(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, chunk, encoding, cb) {\n  chunk = decodeChunk(state, chunk, encoding);\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  state.needDrain = !ret;\n\n  if (state.writing)\n    state.buffer.push(new WriteReq(chunk, encoding, cb));\n  else\n    doWrite(stream, state, len, chunk, encoding, cb);\n\n  return ret;\n}\n\nfunction doWrite(stream, state, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  if (sync)\n    setImmediate(function() {\n      cb(er);\n    });\n  else\n    cb(er);\n\n  stream.emit('error', er);\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er)\n    onwriteError(stream, state, sync, er, cb);\n  else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(stream, state);\n\n    if (!finished && !state.bufferProcessing && state.buffer.length)\n      clearBuffer(stream, state);\n\n    if (sync) {\n      setImmediate(function() {\n        afterWrite(stream, state, finished, cb);\n      });\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished)\n    onwriteDrain(stream, state);\n  cb();\n  if (finished)\n    finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n\n  for (var c = 0; c < state.buffer.length; c++) {\n    var entry = state.buffer[c];\n    var chunk = entry.chunk;\n    var encoding = entry.encoding;\n    var cb = entry.callback;\n    var len = state.objectMode ? 1 : chunk.length;\n\n    doWrite(stream, state, len, chunk, encoding, cb);\n\n    // if we didn't call the onwrite immediately, then\n    // it means that we need to wait until it does.\n    // also, that means that the chunk and cb are currently\n    // being processed, so move the buffer counter past them.\n    if (state.writing) {\n      c++;\n      break;\n    }\n  }\n\n  state.bufferProcessing = false;\n  if (c < state.buffer.length)\n    state.buffer = state.buffer.slice(c);\n  else\n    state.buffer.length = 0;\n}\n\nWritable.prototype._write = function(chunk, encoding, cb) {\n  cb(new Error('not implemented'));\n};\n\nWritable.prototype.end = function(chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (typeof chunk !== 'undefined' && chunk !== null)\n    this.write(chunk, encoding);\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished)\n    endWritable(this, state, cb);\n};\n\n\nfunction needFinish(stream, state) {\n  return (state.ending &&\n          state.length === 0 &&\n          !state.finished &&\n          !state.writing);\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(stream, state);\n  if (need) {\n    state.finished = true;\n    stream.emit('finish');\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished)\n      setImmediate(cb);\n    else\n      stream.once('finish', cb);\n  }\n  state.ended = true;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar Buffer = require('buffer').Buffer;\n\nfunction assertEncoding(encoding) {\n  if (encoding && !Buffer.isEncoding(encoding)) {\n    throw new Error('Unknown encoding: ' + encoding);\n  }\n}\n\nvar StringDecoder = exports.StringDecoder = function(encoding) {\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\n  assertEncoding(encoding);\n  switch (this.encoding) {\n    case 'utf8':\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\n      this.surrogateSize = 3;\n      break;\n    case 'ucs2':\n    case 'utf16le':\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\n      this.surrogateSize = 2;\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\n      break;\n    case 'base64':\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\n      this.surrogateSize = 3;\n      this.detectIncompleteChar = base64DetectIncompleteChar;\n      break;\n    default:\n      this.write = passThroughWrite;\n      return;\n  }\n\n  this.charBuffer = new Buffer(6);\n  this.charReceived = 0;\n  this.charLength = 0;\n};\n\n\nStringDecoder.prototype.write = function(buffer) {\n  var charStr = '';\n  var offset = 0;\n\n  // if our last write ended with an incomplete multibyte character\n  while (this.charLength) {\n    // determine how many remaining bytes this buffer has to offer for this char\n    var i = (buffer.length >= this.charLength - this.charReceived) ?\n                this.charLength - this.charReceived :\n                buffer.length;\n\n    // add the new bytes to the char buffer\n    buffer.copy(this.charBuffer, this.charReceived, offset, i);\n    this.charReceived += (i - offset);\n    offset = i;\n\n    if (this.charReceived < this.charLength) {\n      // still not enough chars in this buffer? wait for more ...\n      return '';\n    }\n\n    // get the character that was split\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\n\n    // lead surrogate (D800-DBFF) is also the incomplete character\n    var charCode = charStr.charCodeAt(charStr.length - 1);\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n      this.charLength += this.surrogateSize;\n      charStr = '';\n      continue;\n    }\n    this.charReceived = this.charLength = 0;\n\n    // if there are no more bytes in this buffer, just emit our char\n    if (i == buffer.length) return charStr;\n\n    // otherwise cut off the characters end from the beginning of this buffer\n    buffer = buffer.slice(i, buffer.length);\n    break;\n  }\n\n  var lenIncomplete = this.detectIncompleteChar(buffer);\n\n  var end = buffer.length;\n  if (this.charLength) {\n    // buffer the incomplete character bytes we got\n    buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);\n    this.charReceived = lenIncomplete;\n    end -= lenIncomplete;\n  }\n\n  charStr += buffer.toString(this.encoding, 0, end);\n\n  var end = charStr.length - 1;\n  var charCode = charStr.charCodeAt(end);\n  // lead surrogate (D800-DBFF) is also the incomplete character\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n    var size = this.surrogateSize;\n    this.charLength += size;\n    this.charReceived += size;\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\n    this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);\n    return charStr.substring(0, end);\n  }\n\n  // or just emit the charStr\n  return charStr;\n};\n\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\n  // determine how many bytes we have to check at the end of this buffer\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\n\n  // Figure out if one of the last i bytes of our buffer announces an\n  // incomplete char.\n  for (; i > 0; i--) {\n    var c = buffer[buffer.length - i];\n\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\n\n    // 110XXXXX\n    if (i == 1 && c >> 5 == 0x06) {\n      this.charLength = 2;\n      break;\n    }\n\n    // 1110XXXX\n    if (i <= 2 && c >> 4 == 0x0E) {\n      this.charLength = 3;\n      break;\n    }\n\n    // 11110XXX\n    if (i <= 3 && c >> 3 == 0x1E) {\n      this.charLength = 4;\n      break;\n    }\n  }\n\n  return i;\n};\n\nStringDecoder.prototype.end = function(buffer) {\n  var res = '';\n  if (buffer && buffer.length)\n    res = this.write(buffer);\n\n  if (this.charReceived) {\n    var cr = this.charReceived;\n    var buf = this.charBuffer;\n    var enc = this.encoding;\n    res += buf.slice(0, cr).toString(enc);\n  }\n\n  return res;\n};\n\nfunction passThroughWrite(buffer) {\n  return buffer.toString(this.encoding);\n}\n\nfunction utf16DetectIncompleteChar(buffer) {\n  var incomplete = this.charReceived = buffer.length % 2;\n  this.charLength = incomplete ? 2 : 0;\n  return incomplete;\n}\n\nfunction base64DetectIncompleteChar(buffer) {\n  var incomplete = this.charReceived = buffer.length % 3;\n  this.charLength = incomplete ? 3 : 0;\n  return incomplete;\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","(function (process,global){\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\n}).call(this,require(\"KliubH\"),typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})"]}
9746</script></body></html>