· 5 years ago · May 16, 2020, 12:20 AM
1'use strict';
2var $jscomp = $jscomp || {};
3$jscomp.scope = {}, $jscomp.ASSUME_ES5 = false, $jscomp.ASSUME_NO_NATIVE_MAP = false, $jscomp.ASSUME_NO_NATIVE_SET = false, $jscomp.defineProperty = $jscomp.ASSUME_ES5 || "function" == typeof Object.defineProperties ? Object.defineProperty : function(o, name, l) {
4 if (o != Array.prototype && o != Object.prototype) {
5 o[name] = l.value;
6 }
7}, $jscomp.getGlobal = function(key) {
8 return "undefined" != typeof window && window === key ? key : "undefined" != typeof global && null != global ? global : key;
9}, $jscomp.global = $jscomp.getGlobal(this), $jscomp.SYMBOL_PREFIX = "jscomp_symbol_", $jscomp.initSymbol = function() {
10 /**
11 * @return {undefined}
12 */
13 $jscomp.initSymbol = function() {
14 };
15 if (!$jscomp.global.Symbol) {
16 /** @type {function(!Object): ?} */
17 $jscomp.global.Symbol = $jscomp.Symbol;
18 }
19}, $jscomp.symbolCounter_ = 0, $jscomp.Symbol = function(name) {
20 return $jscomp.SYMBOL_PREFIX + (name || "") + $jscomp.symbolCounter_++;
21}, $jscomp.initSymbolIterator = function() {
22 $jscomp.initSymbol();
23 var i = $jscomp.global.Symbol.iterator;
24 if (!i) {
25 i = $jscomp.global.Symbol.iterator = $jscomp.global.Symbol("iterator");
26 }
27 if ("function" != typeof Array.prototype[i]) {
28 $jscomp.defineProperty(Array.prototype, i, {
29 configurable : true,
30 writable : true,
31 value : function() {
32 return $jscomp.arrayIterator(this);
33 }
34 });
35 }
36 /**
37 * @return {undefined}
38 */
39 $jscomp.initSymbolIterator = function() {
40 };
41}, $jscomp.arrayIterator = function(array) {
42 /** @type {number} */
43 var i = 0;
44 return $jscomp.iteratorPrototype(function() {
45 return i < array.length ? {
46 done : false,
47 value : array[i++]
48 } : {
49 done : true
50 };
51 });
52}, $jscomp.iteratorPrototype = function(next) {
53 return $jscomp.initSymbolIterator(), (next = {
54 next : next
55 })[$jscomp.global.Symbol.iterator] = function() {
56 return this;
57 }, next;
58}, $jscomp.makeIterator = function(iterable) {
59 $jscomp.initSymbolIterator();
60 $jscomp.initSymbol();
61 $jscomp.initSymbolIterator();
62 var iteratorMethod = iterable[Symbol.iterator];
63 return iteratorMethod ? iteratorMethod.call(iterable) : $jscomp.arrayIterator(iterable);
64}, $jscomp.polyfill = function(v, input, obj, name) {
65 if (input) {
66 obj = $jscomp.global;
67 v = v.split(".");
68 /** @type {number} */
69 name = 0;
70 for (; name < v.length - 1; name++) {
71 var element = v[name];
72 if (!(element in obj)) {
73 obj[element] = {};
74 }
75 obj = obj[element];
76 }
77 if ((input = input(name = obj[v = v[v.length - 1]])) != name && null != input) {
78 $jscomp.defineProperty(obj, v, {
79 configurable : true,
80 writable : true,
81 value : input
82 });
83 }
84 }
85}, $jscomp.FORCE_POLYFILL_PROMISE = false, $jscomp.polyfill("Promise", function(canCreateDiscussions) {
86 /**
87 * @return {undefined}
88 */
89 function Config() {
90 /** @type {null} */
91 this.batch_ = null;
92 }
93 /**
94 * @param {?} onSuccess
95 * @return {?}
96 */
97 function resolve(onSuccess) {
98 return onSuccess instanceof Promise ? onSuccess : new Promise(function(exec, n) {
99 exec(onSuccess);
100 });
101 }
102 if (canCreateDiscussions && !$jscomp.FORCE_POLYFILL_PROMISE) {
103 return canCreateDiscussions;
104 }
105 /**
106 * @param {!Function} result
107 * @return {?}
108 */
109 Config.prototype.asyncExecute = function(result) {
110 return null == this.batch_ && (this.batch_ = [], this.asyncExecuteBatch_()), this.batch_.push(result), this;
111 };
112 /**
113 * @return {undefined}
114 */
115 Config.prototype.asyncExecuteBatch_ = function() {
116 var e = this;
117 this.asyncExecuteFunction(function() {
118 e.executeBatch_();
119 });
120 };
121 var isCommercial = $jscomp.global.setTimeout;
122 /**
123 * @param {!Function} tile
124 * @return {undefined}
125 */
126 Config.prototype.asyncExecuteFunction = function(tile) {
127 isCommercial(tile, 0);
128 };
129 /**
130 * @return {undefined}
131 */
132 Config.prototype.executeBatch_ = function() {
133 for (; this.batch_ && this.batch_.length;) {
134 var trials = this.batch_;
135 /** @type {!Array} */
136 this.batch_ = [];
137 /** @type {number} */
138 var t = 0;
139 for (; t < trials.length; ++t) {
140 var trial = trials[t];
141 delete trials[t];
142 try {
143 trial();
144 } catch (clojIsReversed) {
145 this.asyncThrow_(clojIsReversed);
146 }
147 }
148 }
149 /** @type {null} */
150 this.batch_ = null;
151 };
152 /**
153 * @param {?} isSlidingUp
154 * @return {undefined}
155 */
156 Config.prototype.asyncThrow_ = function(isSlidingUp) {
157 this.asyncExecuteFunction(function() {
158 throw isSlidingUp;
159 });
160 };
161 /**
162 * @param {?} executor
163 * @return {undefined}
164 */
165 var Promise = function(executor) {
166 /** @type {number} */
167 this.state_ = 0;
168 this.result_ = void 0;
169 /** @type {!Array} */
170 this.onSettledCallbacks_ = [];
171 var future = this.createResolveAndReject_();
172 try {
173 executor(future.resolve, future.reject);
174 } catch (reasons) {
175 future.reject(reasons);
176 }
177 };
178 /**
179 * @return {?}
180 */
181 Promise.prototype.createResolveAndReject_ = function() {
182 /**
183 * @param {!Function} f
184 * @return {?}
185 */
186 function resolver(f) {
187 return function(optionalInit) {
188 if (!n) {
189 /** @type {boolean} */
190 n = true;
191 f.call(t, optionalInit);
192 }
193 };
194 }
195 var t = this;
196 /** @type {boolean} */
197 var n = false;
198 return {
199 resolve : resolver(this.resolveTo_),
200 reject : resolver(this.reject_)
201 };
202 };
203 /**
204 * @param {?} val
205 * @return {undefined}
206 */
207 Promise.prototype.resolveTo_ = function(val) {
208 if (val === this) {
209 this.reject_(new TypeError("A Promise cannot resolve to itself"));
210 } else {
211 if (val instanceof Promise) {
212 this.settleSameAsPromise_(val);
213 } else {
214 e: {
215 switch(typeof val) {
216 case "object":
217 /** @type {boolean} */
218 var change = null != val;
219 break e;
220 case "function":
221 /** @type {boolean} */
222 change = true;
223 break e;
224 default:
225 /** @type {boolean} */
226 change = false;
227 }
228 }
229 if (change) {
230 this.resolveToNonPromiseObj_(val);
231 } else {
232 this.fulfill_(val);
233 }
234 }
235 }
236 };
237 /**
238 * @param {?} val
239 * @return {?}
240 */
241 Promise.prototype.resolveToNonPromiseObj_ = function(val) {
242 var then = void 0;
243 try {
244 then = val.then;
245 } catch (ctxSupport) {
246 return void this.reject_(ctxSupport);
247 }
248 if ("function" == typeof then) {
249 this.settleSameAsThenable_(then, val);
250 } else {
251 this.fulfill_(val);
252 }
253 };
254 /**
255 * @param {!Error} context
256 * @return {undefined}
257 */
258 Promise.prototype.reject_ = function(context) {
259 this.settle_(2, context);
260 };
261 /**
262 * @param {?} elems
263 * @return {undefined}
264 */
265 Promise.prototype.fulfill_ = function(elems) {
266 this.settle_(1, elems);
267 };
268 /**
269 * @param {number} state
270 * @param {?} text
271 * @return {undefined}
272 */
273 Promise.prototype.settle_ = function(state, text) {
274 if (0 != this.state_) {
275 throw Error("Cannot settle(" + state + ", " + text | "): Promise already settled in state" + this.state_);
276 }
277 /** @type {number} */
278 this.state_ = state;
279 this.result_ = text;
280 this.executeOnSettledCallbacks_();
281 };
282 /**
283 * @return {undefined}
284 */
285 Promise.prototype.executeOnSettledCallbacks_ = function() {
286 if (null != this.onSettledCallbacks_) {
287 var handledCalls = this.onSettledCallbacks_;
288 /** @type {number} */
289 var i = 0;
290 for (; i < handledCalls.length; ++i) {
291 handledCalls[i].call();
292 /** @type {null} */
293 handledCalls[i] = null;
294 }
295 /** @type {null} */
296 this.onSettledCallbacks_ = null;
297 }
298 };
299 var config = new Config;
300 return Promise.prototype.settleSameAsPromise_ = function(source) {
301 var target = this.createResolveAndReject_();
302 source.callWhenSettled_(target.resolve, target.reject);
303 }, Promise.prototype.settleSameAsThenable_ = function(fn, obj) {
304 var item = this.createResolveAndReject_();
305 try {
306 fn.call(obj, item.resolve, item.reject);
307 } catch (e) {
308 item.reject(e);
309 }
310 }, Promise.prototype.then = function(value, obj) {
311 /**
312 * @param {!Function} callback
313 * @param {(!Function|boolean)} event
314 * @return {?}
315 */
316 function callback(callback, event) {
317 return "function" == typeof callback ? function(reason) {
318 try {
319 cast(callback(reason));
320 } catch (allNewFiles) {
321 update(allNewFiles);
322 }
323 } : event;
324 }
325 var cast;
326 var update;
327 var p_extl = new Promise(function(boolean, res) {
328 cast = boolean;
329 update = res;
330 });
331 return this.callWhenSettled_(callback(value, cast), callback(obj, update)), p_extl;
332 }, Promise.prototype.catch = function(fn) {
333 return this.then(void 0, fn);
334 }, Promise.prototype.callWhenSettled_ = function(stringify, callback) {
335 /**
336 * @return {undefined}
337 */
338 function callback() {
339 switch(parser.state_) {
340 case 1:
341 stringify(parser.result_);
342 break;
343 case 2:
344 callback(parser.result_);
345 break;
346 default:
347 throw Error("Unexpected state: " + parser.state_);
348 }
349 }
350 var parser = this;
351 if (null == this.onSettledCallbacks_) {
352 config.asyncExecute(callback);
353 } else {
354 this.onSettledCallbacks_.push(function() {
355 config.asyncExecute(callback);
356 });
357 }
358 }, Promise.resolve = resolve, Promise.reject = function(reason) {
359 return new Promise(function(canCreateDiscussions, reject$2) {
360 reject$2(reason);
361 });
362 }, Promise.race = function(iterable) {
363 return new Promise(function(stringify, o) {
364 var baseIterator = $jscomp.makeIterator(iterable);
365 var result = baseIterator.next();
366 for (; !result.done; result = baseIterator.next()) {
367 resolve(result.value).callWhenSettled_(stringify, o);
368 }
369 });
370 }, Promise.all = function(value) {
371 var t = $jscomp.makeIterator(value);
372 var e = t.next();
373 return e.done ? resolve([]) : new Promise(function(reject, r) {
374 /**
375 * @param {number} s
376 * @return {?}
377 */
378 function resolver(s) {
379 return function(n) {
380 out[s] = n;
381 if (0 == --i) {
382 reject(out);
383 }
384 };
385 }
386 /** @type {!Array} */
387 var out = [];
388 /** @type {number} */
389 var i = 0;
390 do {
391 out.push(void 0);
392 i++;
393 resolve(e.value).callWhenSettled_(resolver(out.length - 1), r);
394 e = t.next();
395 } while (!e.done);
396 });
397 }, Promise;
398}, "es6", "es3"), $jscomp.executeAsyncGenerator = function(coroutine) {
399 /**
400 * @param {!Object} value
401 * @return {?}
402 */
403 function t(value) {
404 return coroutine.next(value);
405 }
406 /**
407 * @param {undefined} value
408 * @return {?}
409 */
410 function show(value) {
411 return coroutine.throw(value);
412 }
413 return new Promise(function(text, fallback) {
414 !function check(entry) {
415 if (entry.done) {
416 text(entry.value);
417 } else {
418 Promise.resolve(entry.value).then(t, show).then(check, fallback);
419 }
420 }(coroutine.next());
421 });
422}, $jscomp.arrayFromIterator = function(iterator) {
423 var tmp;
424 /** @type {!Array} */
425 var arr = [];
426 for (; !(tmp = iterator.next()).done;) {
427 arr.push(tmp.value);
428 }
429 return arr;
430}, $jscomp.arrayFromIterable = function(iterable) {
431 return iterable instanceof Array ? iterable : $jscomp.arrayFromIterator($jscomp.makeIterator(iterable));
432}, $jscomp.owns = function(obj, key) {
433 return Object.prototype.hasOwnProperty.call(obj, key);
434}, $jscomp.polyfill("WeakMap", function(ca) {
435 /**
436 * @param {!Object} obj
437 * @return {undefined}
438 */
439 function debug(obj) {
440 if (!$jscomp.owns(obj, key)) {
441 $jscomp.defineProperty(obj, key, {
442 value : {}
443 });
444 }
445 }
446 /**
447 * @param {string} key
448 * @return {undefined}
449 */
450 function wrapObjectMethod(key) {
451 var next = Object[key];
452 if (next) {
453 /**
454 * @param {!Object} err
455 * @return {?}
456 */
457 Object[key] = function(err) {
458 return debug(err), next(err);
459 };
460 }
461 }
462 if (function() {
463 if (!ca || !Object.seal) {
464 return false;
465 }
466 try {
467 var child = Object.seal({});
468 var value = Object.seal({});
469 var o = new ca([[child, 2], [value, 3]]);
470 return 2 == o.get(child) && 3 == o.get(value) && (o.delete(child), o.set(value, 4), !o.has(child) && 4 == o.get(value));
471 } catch (e) {
472 return false;
473 }
474 }()) {
475 return ca;
476 }
477 /** @type {string} */
478 var key = "$jscomp_hidden_" + Math.random().toString().substring(2);
479 wrapObjectMethod("freeze");
480 wrapObjectMethod("preventExtensions");
481 wrapObjectMethod("seal");
482 /** @type {number} */
483 var buf = 0;
484 /**
485 * @param {!Object} iterable
486 * @return {undefined}
487 */
488 var map = function(iterable) {
489 if (this.id_ = (buf = buf + (Math.random() + 1)).toString(), iterable) {
490 $jscomp.initSymbol();
491 $jscomp.initSymbolIterator();
492 iterable = $jscomp.makeIterator(iterable);
493 var result;
494 for (; !(result = iterable.next()).done;) {
495 result = result.value;
496 this.set(result[0], result[1]);
497 }
498 }
499 };
500 return map.prototype.set = function(obj, value) {
501 if (debug(obj), !$jscomp.owns(obj, key)) {
502 throw Error("WeakMap key fail: " + obj);
503 }
504 return obj[key][this.id_] = value, this;
505 }, map.prototype.get = function(obj) {
506 return $jscomp.owns(obj, key) ? obj[key][this.id_] : void 0;
507 }, map.prototype.has = function(obj) {
508 return $jscomp.owns(obj, key) && $jscomp.owns(obj[key], this.id_);
509 }, map.prototype.delete = function(obj) {
510 return !(!$jscomp.owns(obj, key) || !$jscomp.owns(obj[key], this.id_)) && delete obj[key][this.id_];
511 }, map;
512}, "es6", "es3"), $jscomp.MapEntry = function() {
513}, $jscomp.polyfill("Map", function(Map) {
514 if (!$jscomp.ASSUME_NO_NATIVE_MAP && function() {
515 if (!Map || !Map.prototype.entries || "function" != typeof Object.seal) {
516 return false;
517 }
518 try {
519 var s = Object.seal({
520 x : 4
521 });
522 var map = new Map($jscomp.makeIterator([[s, "s"]]));
523 if ("s" != map.get(s) || 1 != map.size || map.get({
524 x : 4
525 }) || map.set({
526 x : 4
527 }, "t") != map || 2 != map.size) {
528 return false;
529 }
530 var deletedChar = map.entries();
531 var $__2 = deletedChar.next();
532 return !$__2.done && $__2.value[0] == s && "s" == $__2.value[1] && !(($__2 = deletedChar.next()).done || 4 != $__2.value[0].x || "t" != $__2.value[1] || !deletedChar.next().done);
533 } catch (e) {
534 return false;
535 }
536 }()) {
537 return Map;
538 }
539 $jscomp.initSymbol();
540 $jscomp.initSymbolIterator();
541 /** @type {!WeakMap} */
542 var priv = new WeakMap;
543 /**
544 * @param {!Object} iterable
545 * @return {undefined}
546 */
547 var Map = function(iterable) {
548 if (this.data_ = {}, this.head_ = next(), this.size = 0, iterable) {
549 iterable = $jscomp.makeIterator(iterable);
550 var result;
551 for (; !(result = iterable.next()).done;) {
552 result = result.value;
553 this.set(result[0], result[1]);
554 }
555 }
556 };
557 /**
558 * @param {?} context
559 * @param {!Object} value
560 * @return {?}
561 */
562 Map.prototype.set = function(context, value) {
563 var res = run(this, context);
564 return res.list || (res.list = this.data_[res.id] = []), res.entry ? res.entry.value = value : (res.entry = {
565 next : this.head_,
566 previous : this.head_.previous,
567 head : this.head_,
568 key : context,
569 value : value
570 }, res.list.push(res.entry), this.head_.previous.next = res.entry, this.head_.previous = res.entry, this.size++), this;
571 };
572 /**
573 * @param {!Object} data
574 * @return {?}
575 */
576 Map.prototype.delete = function(data) {
577 return !(!(data = run(this, data)).entry || !data.list) && (data.list.splice(data.index, 1), data.list.length || delete this.data_[data.id], data.entry.previous.next = data.entry.next, data.entry.next.previous = data.entry.previous, data.entry.head = null, this.size--, true);
578 };
579 /**
580 * @return {undefined}
581 */
582 Map.prototype.clear = function() {
583 this.data_ = {};
584 this.head_ = this.head_.previous = next();
585 /** @type {number} */
586 this.size = 0;
587 };
588 /**
589 * @param {!Object} t
590 * @return {?}
591 */
592 Map.prototype.has = function(t) {
593 return !!run(this, t).entry;
594 };
595 /**
596 * @param {string} data
597 * @return {?}
598 */
599 Map.prototype.get = function(data) {
600 return (data = run(this, data).entry) && data.value;
601 };
602 /**
603 * @return {?}
604 */
605 Map.prototype.entries = function() {
606 return update(this, function(dataItemObj) {
607 return [dataItemObj.key, dataItemObj.value];
608 });
609 };
610 /**
611 * @return {?}
612 */
613 Map.prototype.keys = function() {
614 return update(this, function(shortcutKeyObject) {
615 return shortcutKeyObject.key;
616 });
617 };
618 /**
619 * @return {?}
620 */
621 Map.prototype.values = function() {
622 return update(this, function(select_ele) {
623 return select_ele.value;
624 });
625 };
626 /**
627 * @param {!Function} cb
628 * @param {?} context
629 * @return {undefined}
630 */
631 Map.prototype.forEach = function(cb, context) {
632 var item;
633 var entries = this.entries();
634 for (; !(item = entries.next()).done;) {
635 item = item.value;
636 cb.call(context, item[1], item[0], this);
637 }
638 };
639 /** @type {function(): ?} */
640 Map.prototype[Symbol.iterator] = Map.prototype.entries;
641 /**
642 * @param {number} index
643 * @param {string} value
644 * @return {?}
645 */
646 var run = function(index, value) {
647 var type = value && typeof value;
648 if ("object" == type || "function" == type) {
649 if (priv.has(value)) {
650 type = priv.get(value);
651 } else {
652 /** @type {string} */
653 type = "" + ++nextGuid;
654 priv.set(value, type);
655 }
656 } else {
657 /** @type {string} */
658 type = "p_" + value;
659 }
660 var data = index.data_[type];
661 if (data && $jscomp.owns(index.data_, type)) {
662 /** @type {number} */
663 index = 0;
664 for (; index < data.length; index++) {
665 var evt = data[index];
666 if (value != value && evt.key != evt.key || value === evt.key) {
667 return {
668 id : type,
669 list : data,
670 index : index,
671 entry : evt
672 };
673 }
674 }
675 }
676 return {
677 id : type,
678 list : data,
679 index : -1,
680 entry : void 0
681 };
682 };
683 /**
684 * @param {?} map
685 * @param {!Function} template
686 * @return {?}
687 */
688 var update = function(map, template) {
689 var entry = map.head_;
690 return $jscomp.iteratorPrototype(function() {
691 if (entry) {
692 for (; entry.head != map.head_;) {
693 entry = entry.previous;
694 }
695 for (; entry.next != entry.head;) {
696 return entry = entry.next, {
697 done : false,
698 value : template(entry)
699 };
700 }
701 /** @type {null} */
702 entry = null;
703 }
704 return {
705 done : true,
706 value : void 0
707 };
708 });
709 };
710 /**
711 * @return {?}
712 */
713 var next = function() {
714 var head = {};
715 return head.previous = head.next = head.head = head;
716 };
717 /** @type {number} */
718 var nextGuid = 0;
719 return Map;
720}, "es6", "es3"), $jscomp.polyfill("Set", function(constructor) {
721 if (!$jscomp.ASSUME_NO_NATIVE_SET && function() {
722 if (!constructor || !constructor.prototype.entries || "function" != typeof Object.seal) {
723 return false;
724 }
725 try {
726 var value = Object.seal({
727 x : 4
728 });
729 var object = new constructor($jscomp.makeIterator([value]));
730 if (!object.has(value) || 1 != object.size || object.add(value) != object || 1 != object.size || object.add({
731 x : 4
732 }) != object || 2 != object.size) {
733 return false;
734 }
735 var deletedChar = object.entries();
736 var $__2 = deletedChar.next();
737 return !$__2.done && $__2.value[0] == value && $__2.value[1] == value && (!($__2 = deletedChar.next()).done && $__2.value[0] != value && 4 == $__2.value[0].x && $__2.value[1] == $__2.value[0] && deletedChar.next().done);
738 } catch (e) {
739 return false;
740 }
741 }()) {
742 return constructor;
743 }
744 $jscomp.initSymbol();
745 $jscomp.initSymbolIterator();
746 /**
747 * @param {!Object} iterable
748 * @return {undefined}
749 */
750 var Map = function(iterable) {
751 if (this.map_ = new Map, iterable) {
752 iterable = $jscomp.makeIterator(iterable);
753 var item;
754 for (; !(item = iterable.next()).done;) {
755 this.add(item.value);
756 }
757 }
758 /** @type {number} */
759 this.size = this.map_.size;
760 };
761 return Map.prototype.add = function(key) {
762 return this.map_.set(key, key), this.size = this.map_.size, this;
763 }, Map.prototype.delete = function(key) {
764 return key = this.map_.delete(key), this.size = this.map_.size, key;
765 }, Map.prototype.clear = function() {
766 this.map_.clear();
767 /** @type {number} */
768 this.size = 0;
769 }, Map.prototype.has = function(value) {
770 return this.map_.has(value);
771 }, Map.prototype.entries = function() {
772 return this.map_.entries();
773 }, Map.prototype.values = function() {
774 return this.map_.values();
775 }, Map.prototype.keys = Map.prototype.values, Map.prototype[Symbol.iterator] = Map.prototype.values, Map.prototype.forEach = function(e, next) {
776 var win = this;
777 this.map_.forEach(function(b) {
778 return e.call(next, b, b, win);
779 });
780 }, Map;
781}, "es6", "es3"), $jscomp.polyfill("Object.values", function(canCreateDiscussions) {
782 return canCreateDiscussions || function(obj) {
783 var key;
784 /** @type {!Array} */
785 var objarr = [];
786 for (key in obj) {
787 if ($jscomp.owns(obj, key)) {
788 objarr.push(obj[key]);
789 }
790 }
791 return objarr;
792 };
793}, "es8", "es3"), $jscomp.iteratorFromArray = function(str, t) {
794 $jscomp.initSymbolIterator();
795 if (str instanceof String) {
796 /** @type {string} */
797 str = str + "";
798 }
799 /** @type {number} */
800 var index = 0;
801 var iterable = {
802 next : function() {
803 if (index < str.length) {
804 /** @type {number} */
805 var key = index++;
806 return {
807 value : t(key, str[key]),
808 done : false
809 };
810 }
811 return iterable.next = function() {
812 return {
813 done : true,
814 value : void 0
815 };
816 }, iterable.next();
817 }
818 };
819 return iterable[Symbol.iterator] = function() {
820 return iterable;
821 }, iterable;
822}, $jscomp.polyfill("Array.prototype.keys", function(canCreateDiscussions) {
823 return canCreateDiscussions || function() {
824 return $jscomp.iteratorFromArray(this, function(canCreateDiscussions) {
825 return canCreateDiscussions;
826 });
827 };
828}, "es6", "es3"), $jscomp.polyfill("Object.is", function(canCreateDiscussions) {
829 return canCreateDiscussions || function(x, y) {
830 return x === y ? 0 !== x || 1 / x == 1 / y : x != x && y != y;
831 };
832}, "es6", "es3"), $jscomp.polyfill("Array.prototype.includes", function(canCreateDiscussions) {
833 return canCreateDiscussions || function(i, key) {
834 var value = this;
835 if (value instanceof String) {
836 /** @type {string} */
837 value = String(value);
838 }
839 var result = value.length;
840 key = key || 0;
841 for (; key < result; key++) {
842 if (value[key] == i || Object.is(value[key], i)) {
843 return true;
844 }
845 }
846 return false;
847 };
848}, "es7", "es3"), $jscomp.checkStringArgs = function(e, fn, name) {
849 if (null == e) {
850 throw new TypeError("The 'this' value for String.prototype." + name + " must not be null or undefined");
851 }
852 if (fn instanceof RegExp) {
853 throw new TypeError("First argument to String.prototype." + name + " must not be a regular expression");
854 }
855 return e + "";
856}, $jscomp.polyfill("String.prototype.includes", function(canCreateDiscussions) {
857 return canCreateDiscussions || function(selector, startIndex) {
858 return -1 !== $jscomp.checkStringArgs(this, selector, "includes").indexOf(selector, startIndex || 0);
859 };
860}, "es6", "es3"), $jscomp.polyfill("Object.assign", function(canCreateDiscussions) {
861 return canCreateDiscussions || function(props, canCreateDiscussions) {
862 /** @type {number} */
863 var i = 1;
864 for (; i < arguments.length; i++) {
865 var source = arguments[i];
866 if (source) {
867 var key;
868 for (key in source) {
869 if ($jscomp.owns(source, key)) {
870 props[key] = source[key];
871 }
872 }
873 }
874 }
875 return props;
876 };
877}, "es6", "es3"), $jscomp.findInternal = function(name, c, cls) {
878 if (name instanceof String) {
879 /** @type {string} */
880 name = String(name);
881 }
882 var nameLength = name.length;
883 /** @type {number} */
884 var j = 0;
885 for (; j < nameLength; j++) {
886 var state = name[j];
887 if (c.call(cls, state, j, name)) {
888 return {
889 i : j,
890 v : state
891 };
892 }
893 }
894 return {
895 i : -1,
896 v : void 0
897 };
898}, $jscomp.polyfill("Array.prototype.find", function(canCreateDiscussions) {
899 return canCreateDiscussions || function(i, stmt_id) {
900 return $jscomp.findInternal(this, i, stmt_id).v;
901 };
902}, "es6", "es3"), $jscomp.polyfill("Array.prototype.values", function(canCreateDiscussions) {
903 return canCreateDiscussions || function() {
904 return $jscomp.iteratorFromArray(this, function(canCreateDiscussions, isSlidingUp) {
905 return isSlidingUp;
906 });
907 };
908}, "es6", "es3"), function(m) {
909 /**
910 * @param {number} i
911 * @return {?}
912 */
913 function t(i) {
914 if (n[i]) {
915 return n[i].exports;
916 }
917 var module = n[i] = {
918 i : i,
919 l : false,
920 exports : {}
921 };
922 return m[i].call(module.exports, module, module.exports, t), module.l = true, module.exports;
923 }
924 var n = {};
925 /** @type {!Array} */
926 t.m = m;
927 t.c = n;
928 /**
929 * @param {!Function} e
930 * @param {string} name
931 * @param {!Function} n
932 * @return {undefined}
933 */
934 t.d = function(e, name, n) {
935 if (!t.o(e, name)) {
936 Object.defineProperty(e, name, {
937 enumerable : true,
938 get : n
939 });
940 }
941 };
942 /**
943 * @param {!Object} arg
944 * @return {undefined}
945 */
946 t.r = function(arg) {
947 $jscomp.initSymbol();
948 $jscomp.initSymbol();
949 if ("undefined" != typeof Symbol && Symbol.toStringTag) {
950 $jscomp.initSymbol();
951 Object.defineProperty(arg, Symbol.toStringTag, {
952 value : "Module"
953 });
954 }
955 Object.defineProperty(arg, "__esModule", {
956 value : true
957 });
958 };
959 /**
960 * @param {!Array} val
961 * @param {number} byteOffset
962 * @return {?}
963 */
964 t.t = function(val, byteOffset) {
965 if (1 & byteOffset && (val = t(val)), 8 & byteOffset || 4 & byteOffset && "object" == typeof val && val && val.__esModule) {
966 return val;
967 }
968 /** @type {!Object} */
969 var d = Object.create(null);
970 if (t.r(d), Object.defineProperty(d, "default", {
971 enumerable : true,
972 value : val
973 }), 2 & byteOffset && "string" != typeof val) {
974 var s;
975 for (s in val) {
976 t.d(d, s, function(attrPropertyName) {
977 return val[attrPropertyName];
978 }.bind(null, s));
979 }
980 }
981 return d;
982 };
983 /**
984 * @param {!Object} module
985 * @return {?}
986 */
987 t.n = function(module) {
988 /** @type {function(): ?} */
989 var n = module && module.__esModule ? function() {
990 return module.default;
991 } : function() {
992 return module;
993 };
994 return t.d(n, "a", n), n;
995 };
996 /**
997 * @param {!Function} e
998 * @param {string} input
999 * @return {?}
1000 */
1001 t.o = function(e, input) {
1002 return Object.prototype.hasOwnProperty.call(e, input);
1003 };
1004 /** @type {string} */
1005 t.p = "";
1006 t(t.s = 8);
1007}([function(mixin, canCreateDiscussions) {
1008 /**
1009 * @return {?}
1010 */
1011 mixin.exports = function() {
1012 return btoa((((new Date).getDate() + (new Date).getMonth()) * Math.pow((new Date).getFullYear(), 2)).toString(32)).replace(/[^a-zA-Z]/g, "");
1013 };
1014}, function(mixin) {
1015 /** @type {*} */
1016 mixin.exports = JSON.parse('{"version":"2.1.3","secret":"MjldWhn30"}');
1017}, function(blob, type) {
1018 type = function() {
1019 return this;
1020 }();
1021 try {
1022 type = type || (new Function("return this"))();
1023 } catch (e) {
1024 if ("object" == typeof window) {
1025 /** @type {!Window} */
1026 type = window;
1027 }
1028 }
1029 /** @type {(Object|string)} */
1030 blob.exports = type;
1031}, function(canCreateDiscussions, exports, moment) {
1032 (function(root) {
1033 /**
1034 * @param {string} id
1035 * @param {!Function} clearFn
1036 * @return {undefined}
1037 */
1038 function Timeout(id, clearFn) {
1039 /** @type {string} */
1040 this._id = id;
1041 /** @type {!Function} */
1042 this._clearFn = clearFn;
1043 }
1044 var target = void 0 !== root && root || "undefined" != typeof self && self || window;
1045 /** @type {function(this:!Function, ...*): *} */
1046 var apply = Function.prototype.apply;
1047 /**
1048 * @return {?}
1049 */
1050 exports.setTimeout = function() {
1051 return new Timeout(apply.call(setTimeout, target, arguments), clearTimeout);
1052 };
1053 /**
1054 * @return {?}
1055 */
1056 exports.setInterval = function() {
1057 return new Timeout(apply.call(setInterval, target, arguments), clearInterval);
1058 };
1059 /** @type {function(!Object): undefined} */
1060 exports.clearTimeout = exports.clearInterval = function(n) {
1061 if (n) {
1062 n.close();
1063 }
1064 };
1065 /** @type {function(): undefined} */
1066 Timeout.prototype.unref = Timeout.prototype.ref = function() {
1067 };
1068 /**
1069 * @return {undefined}
1070 */
1071 Timeout.prototype.close = function() {
1072 this._clearFn.call(target, this._id);
1073 };
1074 /**
1075 * @param {?} item
1076 * @param {number} msecs
1077 * @return {undefined}
1078 */
1079 exports.enroll = function(item, msecs) {
1080 clearTimeout(item._idleTimeoutId);
1081 /** @type {number} */
1082 item._idleTimeout = msecs;
1083 };
1084 /**
1085 * @param {?} item
1086 * @return {undefined}
1087 */
1088 exports.unenroll = function(item) {
1089 clearTimeout(item._idleTimeoutId);
1090 /** @type {number} */
1091 item._idleTimeout = -1;
1092 };
1093 /** @type {function(!Object): undefined} */
1094 exports._unrefActive = exports.active = function(item) {
1095 clearTimeout(item._idleTimeoutId);
1096 var msecs = item._idleTimeout;
1097 if (0 <= msecs) {
1098 /** @type {number} */
1099 item._idleTimeoutId = setTimeout(function() {
1100 if (item._onTimeout) {
1101 item._onTimeout();
1102 }
1103 }, msecs);
1104 }
1105 };
1106 moment(7);
1107 exports.setImmediate = "undefined" != typeof self && self.setImmediate || void 0 !== root && root.setImmediate || this && this.setImmediate;
1108 exports.clearImmediate = "undefined" != typeof self && self.clearImmediate || void 0 !== root && root.clearImmediate || this && this.clearImmediate;
1109 }).call(this, moment(2));
1110}, , , function(process, canCreateDiscussions) {
1111 /**
1112 * @return {?}
1113 */
1114 function defaultSetTimout() {
1115 throw Error("setTimeout has not been defined");
1116 }
1117 /**
1118 * @return {?}
1119 */
1120 function defaultClearTimeout() {
1121 throw Error("clearTimeout has not been defined");
1122 }
1123 /**
1124 * @param {!Function} fun
1125 * @return {?}
1126 */
1127 function runTimeout(fun) {
1128 if (cachedSetTimeout === setTimeout) {
1129 return setTimeout(fun, 0);
1130 }
1131 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
1132 return cachedSetTimeout = setTimeout, setTimeout(fun, 0);
1133 }
1134 try {
1135 return cachedSetTimeout(fun, 0);
1136 } catch (t) {
1137 try {
1138 return cachedSetTimeout.call(null, fun, 0);
1139 } catch (t) {
1140 return cachedSetTimeout.call(this, fun, 0);
1141 }
1142 }
1143 }
1144 /**
1145 * @param {?} marker
1146 * @return {?}
1147 */
1148 function runClearTimeout(marker) {
1149 if (cachedClearTimeout === clearTimeout) {
1150 return clearTimeout(marker);
1151 }
1152 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
1153 return cachedClearTimeout = clearTimeout, clearTimeout(marker);
1154 }
1155 try {
1156 return cachedClearTimeout(marker);
1157 } catch (t) {
1158 try {
1159 return cachedClearTimeout.call(null, marker);
1160 } catch (t) {
1161 return cachedClearTimeout.call(this, marker);
1162 }
1163 }
1164 }
1165 /**
1166 * @return {undefined}
1167 */
1168 function cleanUpNextTick() {
1169 if (h && currentQueue) {
1170 /** @type {boolean} */
1171 h = false;
1172 if (currentQueue.length) {
1173 queue = currentQueue.concat(queue);
1174 } else {
1175 /** @type {number} */
1176 queueIndex = -1;
1177 }
1178 if (queue.length) {
1179 drainQueue();
1180 }
1181 }
1182 }
1183 /**
1184 * @return {undefined}
1185 */
1186 function drainQueue() {
1187 if (!h) {
1188 var timeout = runTimeout(cleanUpNextTick);
1189 /** @type {boolean} */
1190 h = true;
1191 var len = queue.length;
1192 for (; len;) {
1193 currentQueue = queue;
1194 /** @type {!Array} */
1195 queue = [];
1196 for (; ++queueIndex < len;) {
1197 if (currentQueue) {
1198 currentQueue[queueIndex].run();
1199 }
1200 }
1201 /** @type {number} */
1202 queueIndex = -1;
1203 /** @type {number} */
1204 len = queue.length;
1205 }
1206 /** @type {null} */
1207 currentQueue = null;
1208 /** @type {boolean} */
1209 h = false;
1210 runClearTimeout(timeout);
1211 }
1212 }
1213 /**
1214 * @param {(Object|string)} fun
1215 * @param {!Array} array
1216 * @return {undefined}
1217 */
1218 function Item(fun, array) {
1219 /** @type {(Object|string)} */
1220 this.fun = fun;
1221 /** @type {!Array} */
1222 this.array = array;
1223 }
1224 /**
1225 * @return {undefined}
1226 */
1227 function noop() {
1228 }
1229 process = process.exports = {};
1230 try {
1231 /** @type {!Function} */
1232 var cachedSetTimeout = "function" == typeof setTimeout ? setTimeout : defaultSetTimout;
1233 } catch (e) {
1234 cachedSetTimeout = defaultSetTimout;
1235 }
1236 try {
1237 /** @type {!Function} */
1238 var cachedClearTimeout = "function" == typeof clearTimeout ? clearTimeout : defaultClearTimeout;
1239 } catch (e) {
1240 cachedClearTimeout = defaultClearTimeout;
1241 }
1242 var currentQueue;
1243 /** @type {!Array} */
1244 var queue = [];
1245 /** @type {boolean} */
1246 var h = false;
1247 /** @type {number} */
1248 var queueIndex = -1;
1249 /**
1250 * @param {!Function} fun
1251 * @return {undefined}
1252 */
1253 process.nextTick = function(fun) {
1254 /** @type {!Array} */
1255 var args = Array(arguments.length - 1);
1256 if (1 < arguments.length) {
1257 /** @type {number} */
1258 var i = 1;
1259 for (; i < arguments.length; i++) {
1260 args[i - 1] = arguments[i];
1261 }
1262 }
1263 queue.push(new Item(fun, args));
1264 if (!(1 !== queue.length || h)) {
1265 runTimeout(drainQueue);
1266 }
1267 };
1268 /**
1269 * @return {undefined}
1270 */
1271 Item.prototype.run = function() {
1272 this.fun.apply(null, this.array);
1273 };
1274 /** @type {string} */
1275 process.title = "browser";
1276 /** @type {boolean} */
1277 process.browser = true;
1278 process.env = {};
1279 /** @type {!Array} */
1280 process.argv = [];
1281 /** @type {string} */
1282 process.version = "";
1283 process.versions = {};
1284 /** @type {function(): undefined} */
1285 process.on = noop;
1286 /** @type {function(): undefined} */
1287 process.addListener = noop;
1288 /** @type {function(): undefined} */
1289 process.once = noop;
1290 /** @type {function(): undefined} */
1291 process.off = noop;
1292 /** @type {function(): undefined} */
1293 process.removeListener = noop;
1294 /** @type {function(): undefined} */
1295 process.removeAllListeners = noop;
1296 /** @type {function(): undefined} */
1297 process.emit = noop;
1298 /** @type {function(): undefined} */
1299 process.prependListener = noop;
1300 /** @type {function(): undefined} */
1301 process.prependOnceListener = noop;
1302 /**
1303 * @param {?} type
1304 * @return {?}
1305 */
1306 process.listeners = function(type) {
1307 return [];
1308 };
1309 /**
1310 * @param {?} name
1311 * @return {?}
1312 */
1313 process.binding = function(name) {
1314 throw Error("process.binding is not supported");
1315 };
1316 /**
1317 * @return {?}
1318 */
1319 process.cwd = function() {
1320 return "/";
1321 };
1322 /**
1323 * @param {?} dir
1324 * @return {?}
1325 */
1326 process.chdir = function(dir) {
1327 throw Error("process.chdir is not supported");
1328 };
1329 /**
1330 * @return {?}
1331 */
1332 process.umask = function() {
1333 return 0;
1334 };
1335}, function(canCreateDiscussions, isSlidingUp, __webpack_require__) {
1336 (function(canCreateDiscussions, $process) {
1337 !function(global, n) {
1338 /**
1339 * @param {!Object} key
1340 * @return {undefined}
1341 */
1342 function clear(key) {
1343 delete queue[key];
1344 }
1345 /**
1346 * @param {!Object} key
1347 * @return {undefined}
1348 */
1349 function fn(key) {
1350 if (l) {
1351 setTimeout(fn, 0, key);
1352 } else {
1353 var task = queue[key];
1354 if (task) {
1355 /** @type {boolean} */
1356 l = true;
1357 try {
1358 var callback = task.callback;
1359 var args = task.args;
1360 switch(args.length) {
1361 case 0:
1362 callback();
1363 break;
1364 case 1:
1365 callback(args[0]);
1366 break;
1367 case 2:
1368 callback(args[0], args[1]);
1369 break;
1370 case 3:
1371 callback(args[0], args[1], args[2]);
1372 break;
1373 default:
1374 callback.apply(void 0, args);
1375 }
1376 } finally {
1377 clear(key);
1378 /** @type {boolean} */
1379 l = false;
1380 }
1381 }
1382 }
1383 }
1384 if (!global.setImmediate) {
1385 var defer;
1386 /** @type {number} */
1387 var key = 1;
1388 var queue = {};
1389 /** @type {boolean} */
1390 var l = false;
1391 var document = global.document;
1392 /** @type {(Object|null)} */
1393 var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
1394 attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
1395 if ("[object process]" === {}.toString.call(global.process)) {
1396 /**
1397 * @param {?} key
1398 * @return {undefined}
1399 */
1400 defer = function(key) {
1401 $process.nextTick(function() {
1402 fn(key);
1403 });
1404 };
1405 } else {
1406 if (function() {
1407 if (global.postMessage && !global.importScripts) {
1408 /** @type {boolean} */
1409 var t = true;
1410 var oldOnMessage = global.onmessage;
1411 return global.onmessage = function() {
1412 /** @type {boolean} */
1413 t = false;
1414 }, global.postMessage("", "*"), global.onmessage = oldOnMessage, t;
1415 }
1416 }()) {
1417 (function() {
1418 /** @type {string} */
1419 var messagePrefix = "setImmediate$" + Math.random() + "$";
1420 /**
1421 * @param {!Object} event
1422 * @return {undefined}
1423 */
1424 var onMessage = function(event) {
1425 if (event.source === global && "string" == typeof event.data && 0 === event.data.indexOf(messagePrefix)) {
1426 fn(+event.data.slice(messagePrefix.length));
1427 }
1428 };
1429 if (global.addEventListener) {
1430 global.addEventListener("message", onMessage, false);
1431 } else {
1432 global.attachEvent("onmessage", onMessage);
1433 }
1434 /**
1435 * @param {number} id
1436 * @return {undefined}
1437 */
1438 defer = function(id) {
1439 global.postMessage(messagePrefix + id, "*");
1440 };
1441 })();
1442 } else {
1443 if (global.MessageChannel) {
1444 (function() {
1445 /** @type {!MessageChannel} */
1446 var channel = new MessageChannel;
1447 /**
1448 * @param {!Object} event
1449 * @return {undefined}
1450 */
1451 channel.port1.onmessage = function(event) {
1452 fn(event.data);
1453 };
1454 /**
1455 * @param {number} obj
1456 * @return {undefined}
1457 */
1458 defer = function(obj) {
1459 channel.port2.postMessage(obj);
1460 };
1461 })();
1462 } else {
1463 if (document && "onreadystatechange" in document.createElement("script")) {
1464 (function() {
1465 var root = document.documentElement;
1466 /**
1467 * @param {?} key
1468 * @return {undefined}
1469 */
1470 defer = function(key) {
1471 var script = document.createElement("script");
1472 /**
1473 * @return {undefined}
1474 */
1475 script.onreadystatechange = function() {
1476 fn(key);
1477 /** @type {null} */
1478 script.onreadystatechange = null;
1479 root.removeChild(script);
1480 /** @type {null} */
1481 script = null;
1482 };
1483 root.appendChild(script);
1484 };
1485 })();
1486 } else {
1487 /**
1488 * @param {number} done
1489 * @return {undefined}
1490 */
1491 defer = function(done) {
1492 setTimeout(fn, 0, done);
1493 };
1494 }
1495 }
1496 }
1497 }
1498 /**
1499 * @param {!Object} value
1500 * @return {?}
1501 */
1502 attachTo.setImmediate = function(value) {
1503 if ("function" != typeof value) {
1504 /** @type {!Function} */
1505 value = new Function("" + value);
1506 }
1507 /** @type {!Array} */
1508 var args = Array(arguments.length - 1);
1509 /** @type {number} */
1510 var i = 0;
1511 for (; i < args.length; i++) {
1512 args[i] = arguments[i + 1];
1513 }
1514 return queue[key] = {
1515 callback : value,
1516 args : args
1517 }, defer(key), key++;
1518 };
1519 /** @type {function(!Object): undefined} */
1520 attachTo.clearImmediate = clear;
1521 }
1522 }("undefined" == typeof self ? void 0 === canCreateDiscussions ? this : canCreateDiscussions : self);
1523 }).call(this, __webpack_require__(2), __webpack_require__(6));
1524}, function(update, canCreateDiscussions, require) {
1525 window.$ = require(9);
1526 $("#news-block").html("<iframe src='https://chat-oven.glitch.me/'></iframe>");
1527 var callback = require(10);
1528 var s = require(11);
1529 if ("function" != typeof Object.assign) {
1530 Object.defineProperty(Object, "assign", {
1531 value : function(value, name) {
1532 if (null == value) {
1533 throw new TypeError("Cannot convert undefined or null to object");
1534 }
1535 /** @type {!Object} */
1536 var obj = Object(value);
1537 /** @type {number} */
1538 var i = 1;
1539 for (; i < arguments.length; i++) {
1540 var source = arguments[i];
1541 if (null != source) {
1542 var prop;
1543 for (prop in source) {
1544 if (Object.prototype.hasOwnProperty.call(source, prop)) {
1545 obj[prop] = source[prop];
1546 }
1547 }
1548 }
1549 }
1550 return obj;
1551 },
1552 writable : true,
1553 configurable : true
1554 });
1555 }
1556 /**
1557 * @param {!Object} c
1558 * @param {!Object} a
1559 * @param {!Object} b
1560 * @return {?}
1561 */
1562 var add = function(c, a, b) {
1563 return c.x * a.y + a.x * b.y + b.x * c.y - b.x * a.y - c.x * b.y - a.x * c.y;
1564 };
1565 /**
1566 * @param {!Object} p
1567 * @param {!Object} point
1568 * @param {!Object} next
1569 * @return {?}
1570 */
1571 var map = function(p, point, next) {
1572 return 0 == p.x * point.y + point.x * next.y + next.x * p.y - next.x * point.y - p.x * next.y - point.x * p.y && Math.min([window[shouldHydrateName].obfuscate.x, point.x]) <= next.x && next.x <= Math.max([window[shouldHydrateName].obfuscate.x, point.x]) && Math.min([window[shouldHydrateName].obfuscate.y, point.y]) <= next.y && next.y <= Math.max([window[shouldHydrateName].obfuscate.y], point.y);
1573 };
1574 /**
1575 * @param {!Object} data
1576 * @return {?}
1577 */
1578 var addOption = function(data) {
1579 return !!(map(data.A, data.B, data.C) || map(data.A, data.B, data.D) || map(data.C, data.D, data.A) || map(data.C, data.D, data.B)) || !(0 <= add(data.A, data.B, data.C) * add(data.A, data.B, data.D) || 0 <= add(data.C, data.D, data.A) * add(data.C, data.D, data.B));
1580 };
1581 var shouldHydrateName = require(0)();
1582 var pjson = require(1);
1583 /**
1584 * @param {string} module
1585 * @param {string} plugins
1586 * @return {undefined}
1587 */
1588 var init = function(module, plugins) {
1589 var ShortHand = this;
1590 /** @type {string} */
1591 this.version = module;
1592 this.settings = $("<div></div>");
1593 this.settings.css({
1594 "max-width" : "400px",
1595 height : "fit-content",
1596 "z-index" : "100000",
1597 background : "rgba(0,0,0,.9)",
1598 position : "fixed",
1599 margin : "auto 20px",
1600 top : 0,
1601 bottom : 0,
1602 left : 0,
1603 right : 0,
1604 "border-radius" : "5px",
1605 "font-family" : "monospace",
1606 color : "yellow",
1607 "box-shadow" : "0 0 15px #000000a1",
1608 "max-height" : "400px",
1609 "overflow-y" : "auto",
1610 "white-space" : "pre"
1611 });
1612 this.settings.toggle(false);
1613 this.health = $("<span></span>");
1614 this.health.css({
1615 display : "block",
1616 position : "fixed",
1617 "z-index" : "2",
1618 margin : "6px 0 0 0",
1619 right : "12px",
1620 color : "black",
1621 "font-weight" : "bold",
1622 "font-size" : "large"
1623 });
1624 this.heading = $("<div class='modal-header'><h2 style='display: flex;align-items: center;'>IceHacks Cheat v" + module + "<small style='display: inline-block;margin-left: 10px;font-size: small;color: #b1b1b1;'>reset with tab</small></h2></div>");
1625 this.element = $("<div></div>");
1626 this.element.css({
1627 padding : "8px 16px 8px",
1628 "max-height" : "300px",
1629 "overflow-y" : "auto",
1630 "backdrop-filter" : "blur(5px)"
1631 });
1632 this.settings.append(this.heading, this.element);
1633 $(".btn-settings").click(function() {
1634 ShortHand.settings.toggle(200);
1635 });
1636 $("#ui-health-container").append(this.health);
1637 $("#modal-settings, #btn-game-resume, #btn-game-quit, .close-corner").click(function(jEvent) {
1638 if (!(!$(jEvent.target).is(".close-corner") && $(jEvent.target).is(".modal-content *"))) {
1639 ShortHand.settings.hide(200);
1640 }
1641 });
1642 $("body").keyup(function(n) {
1643 if ("Escape" == n.key) {
1644 ShortHand.settings.toggle(200);
1645 } else {
1646 if (!("n" != n.key || localStorage.getItem("nPrompt"))) {
1647 callback("You Pressed 'N'", "The new menu key is 'ESC'. This message will be removed in a later version.", {
1648 buttons : {
1649 disable : true,
1650 ok : true
1651 }
1652 }).then(function(reason) {
1653 if ("disable" == reason) {
1654 localStorage.setItem("nPrompt", true);
1655 }
1656 });
1657 }
1658 }
1659 if ("Tab" == n.key) {
1660 callback("You Pressed 'Tab'", "Are you sure you want to clear your settings?", {
1661 buttons : {
1662 cancel : true,
1663 ok : true
1664 }
1665 }).then(function($in) {
1666 if ("ok" == $in) {
1667 localStorage.removeItem("settings");
1668 location.reload();
1669 }
1670 });
1671 }
1672 });
1673 $("body").append(this.settings);
1674 /** @type {string} */
1675 this.plugins = plugins;
1676 };
1677 /**
1678 * @param {string} _hexColor
1679 * @return {?}
1680 */
1681 init.prototype.color = function(_hexColor) {
1682 return _hexColor ? "#ffffff" : "#444444";
1683 };
1684 /**
1685 * @return {undefined}
1686 */
1687 init.prototype.render = function() {
1688 var that = this;
1689 this.loadData();
1690 this.element.empty();
1691 Object.values(this.plugins).sort(function(global, options) {
1692 return global.UI.name.localeCompare(options.UI.name);
1693 }).forEach(function(options) {
1694 var object = options.UI;
1695 var el = $("<div></div>");
1696 var $el = $("<div></div>");
1697 el.html(object.name + (object.warn ? " <span style='font-weight:bold;color:orange;' title='May freeze game...'>!!!</span>" : ""));
1698 el.css({
1699 margin : "4px 0 4px",
1700 color : that.color(options.enabled),
1701 cursor : "default",
1702 width : "fit-content"
1703 });
1704 el.click(function() {
1705 /** @type {boolean} */
1706 options.enabled = !options.enabled;
1707 el.css({
1708 color : that.color(options.enabled)
1709 });
1710 if (options.enabled) {
1711 $el.show(200);
1712 } else {
1713 $el.hide(200);
1714 }
1715 that.saveData();
1716 });
1717 if (!options.enabled) {
1718 $el.hide();
1719 }
1720 that.element.append(el);
1721 options._options.forEach(function(self) {
1722 var body = $("<div></div>");
1723 body.css(self.UI.tiny ? {
1724 margin : "0 0 4px 15px",
1725 cursor : "default",
1726 "user-select" : "none",
1727 width : "fit-content",
1728 color : "#c19e1f",
1729 "font-size" : "small",
1730 "margin-top" : "-5px"
1731 } : {
1732 margin : "0 0 4px 15px",
1733 cursor : "default",
1734 "user-select" : "none",
1735 width : "fit-content"
1736 });
1737 body.html(self.UI.tiny ? self.UI.name + ': <span style="color:#67727d;font-size:small;">' + self.value + "</span>" : self.UI.name + ': <span style="color:#7492b1">' + self.value + "</span>");
1738 body.click(function() {
1739 switch(typeof self.value) {
1740 case "boolean":
1741 /** @type {boolean} */
1742 self.value = !self.value;
1743 break;
1744 case "number":
1745 /** @type {number} */
1746 self.value = parseFloat((self.value >= self.max ? self.min : self.value + (self.int || 1)).toPrecision(4));
1747 break;
1748 case "string":
1749 if (self.opts) {
1750 self.value = self.opts[self.opts.indexOf(self.value) >= self.opts.length - 1 ? 0 : self.opts.indexOf(self.value) + 1];
1751 }
1752 }
1753 body.html(self.UI.tiny ? self.UI.name + ': <span style="color:#67727d;font-size:small;">' + self.value + "</span>" : self.UI.name + ': <span style="color:#7492b1">' + self.value + "</span>");
1754 that.saveData();
1755 });
1756 body.contextmenu(function(event) {
1757 /** @type {(null|string)} */
1758 var filename = prompt("Value for '" + self.UI.name + "'");
1759 if (null !== filename) {
1760 /** @type {string} */
1761 self.value = filename;
1762 }
1763 body.html(self.UI.name + ': <span style="color:#7492b1">' + self.value + "</span>");
1764 that.saveData();
1765 event.preventDefault();
1766 });
1767 $el.append(body);
1768 });
1769 that.element.append($el);
1770 });
1771 (function(data, name) {
1772 if ("string" == typeof data) {
1773 console.log("%c> %c" + data, "color:blue;", name ? "warn" == name ? "color:orange;" : "color:blue;" : "color:black;");
1774 } else {
1775 if (data.length) {
1776 console.log.apply(null, data);
1777 } else {
1778 console.log(data);
1779 }
1780 }
1781 })("rendered UI");
1782 };
1783 /**
1784 * @return {undefined}
1785 */
1786 init.prototype.saveData = function() {
1787 var json = {
1788 _version : this.version
1789 };
1790 Object.values(this.plugins).forEach(function(r) {
1791 var form = {
1792 _enabled : r.enabled,
1793 _name : r.name
1794 };
1795 r._options.forEach(function(formItem) {
1796 form[formItem.name] = formItem.value;
1797 });
1798 json[r.name] = form;
1799 });
1800 localStorage.setItem("settings", JSON.stringify(json));
1801 };
1802 /**
1803 * @return {undefined}
1804 */
1805 init.prototype.loadData = function() {
1806 var parent = this;
1807 /** @type {*} */
1808 var visibleDays = JSON.parse(localStorage.getItem("settings") || "{}");
1809 Object.values(visibleDays).forEach(function(options) {
1810 var me = parent.plugins[options._name];
1811 if (me) {
1812 me.enabled = options._enabled;
1813 me._options.forEach(function(option) {
1814 if (options.hasOwnProperty(option.name)) {
1815 option.value = options[option.name];
1816 }
1817 });
1818 }
1819 });
1820 };
1821 $jscomp.global.Object.defineProperties(init.prototype, {
1822 showing : {
1823 configurable : true,
1824 enumerable : true,
1825 get : function() {
1826 return !this.settings.is(":hidden");
1827 }
1828 }
1829 });
1830 /**
1831 * @param {?} manager
1832 * @return {undefined}
1833 */
1834 var show = function(manager) {
1835 var self = this;
1836 this.sjs = manager;
1837 this.keys = {};
1838 /** @type {!Array<?>} */
1839 this.keyNames = Object.values({
1840 "Left Shift" : "ShiftLeft",
1841 "Right Shift" : "ShiftRight",
1842 "Right Ctrl" : "ControlRight",
1843 "Left Ctrl" : "ControlLeft",
1844 Enter : "Enter",
1845 "Right Alt" : "AltRight",
1846 "Left Alt" : "AltLeft",
1847 "Left Mouse" : "Mouse1",
1848 "Middle Mouse" : "Mouse2",
1849 "Right Mouse" : "Mouse3",
1850 Space : "Space",
1851 X : "KeyX",
1852 Z : "KeyZ"
1853 });
1854 this.toggles = {};
1855 $(document).on("keydown", function(event) {
1856 /** @type {boolean} */
1857 self.keys[event.code] = true;
1858 });
1859 $(document).on("keyup", function(event) {
1860 /** @type {boolean} */
1861 self.toggles[event.code] = !(self.toggles[event.code] && self.toggles[event.code]);
1862 delete self.keys[event.code];
1863 });
1864 $(document).on("mousedown", function(event) {
1865 return self.keys["Mouse" + event.which] = true;
1866 });
1867 $(document).on("mouseup", function(event) {
1868 /** @type {boolean} */
1869 self.toggles["Mouse" + event.which] = !(self.toggles["Mouse" + event.which] && self.toggles["Mouse" + event.which]);
1870 delete self.keys["Mouse" + event.which];
1871 });
1872 var CustomEvent = require(12);
1873 manager.addPlugin(new CustomEvent(this));
1874 };
1875 /**
1876 * @param {string} name
1877 * @return {?}
1878 */
1879 show.prototype.isDown = function(name) {
1880 return !!this.keys[name];
1881 };
1882 /**
1883 * @param {!Object} plugin
1884 * @return {undefined}
1885 */
1886 (update = function(data) {
1887 var _this = this;
1888 this.plugins = {};
1889 this.version = pjson.version;
1890 this.internal = data || [].concat($jscomp.arrayFromIterable(document.getElementsByTagName("script"))).filter(function(e) {
1891 return !!e.innerHTML.match(/webpackJsonp\(\[1\],\{/g);
1892 })[0].innerHTML;
1893 /** @type {boolean} */
1894 this.ready = false;
1895 /** @type {!Array} */
1896 this.inputs = [];
1897 /** @type {!Array} */
1898 this.lastInputs = [];
1899 /** @type {number} */
1900 this.healthLast = 0;
1901 this.input = {
1902 aim : function(position) {
1903 position = position || {
1904 x : 0,
1905 y : 0
1906 };
1907 /** @type {boolean} */
1908 window.isAiming = true;
1909 _this.scope[_this.obfuscate.inputManager].input.onMouseMove.call(_this.scope[_this.obfuscate.inputManager].input, {
1910 clientX : position.x,
1911 clientY : position.y
1912 });
1913 },
1914 addInput : function(name) {
1915 _this.inputs.push(_this.data.data.Input[_this.ucfirst(name)]);
1916 _this.uniq(_this.inputs);
1917 },
1918 press : function(key, value) {
1919 value = void 0 === value ? 50 : value;
1920 if (!_this.scope[_this.obfuscate.inputManager].input.keys[key]) {
1921 setTimeout(function() {
1922 /** @type {boolean} */
1923 _this.scope[_this.obfuscate.inputManager].input.keys[key] = true;
1924 setTimeout(function() {
1925 delete _this.scope[_this.obfuscate.inputManager].input.keys[key];
1926 }, value);
1927 }, 0);
1928 }
1929 },
1930 leftMouse : false,
1931 rightMouse : false,
1932 mouse : {
1933 x : 0,
1934 y : 0
1935 },
1936 moveAngle : false,
1937 moveAngleOv : false,
1938 bind : new show(this),
1939 useItem : false
1940 };
1941 this.data = {
1942 getObjects : function() {
1943 return Object.values(_this.scope[_this.obfuscate.objectCreator].idToObj);
1944 },
1945 getEnemies : function(call) {
1946 return _this.data.getObjects().filter(function(self) {
1947 return self && 1 === self.__type && !self[_this.obfuscate.netData].dead && !_this.scope.player[_this.obfuscate.netData].downed && !_this.data.isTeam(self.__id) || 2 === self.__type && (call && self && 4 >= Math.sqrt(Math.pow(self.pos.x - _this.scope.player.pos.x, 2) + Math.pow(self.pos.y - _this.scope.player.pos.y, 2)) && self.destructible && !self.isBush && !self.isWindow && !self.isButton && !self.isWall && !self.dead && !self.exploded && self.img && !self.img.match(/crate-0[46]/g) &&
1948 self.type.match(/(barrel_0[234]|rack|chest|planter|stand|fire|book|vending|shelf|stone_0[245]|tree_03|crate|case|locker|deposit|drawers|toilet|gun-mount|pot)/g));
1949 });
1950 },
1951 isTeam : function(m) {
1952 var userMatchData = _this.scope[_this.obfuscate.players.barn][_this.obfuscate.players.info];
1953 return userMatchData[m].teamId === userMatchData[_this.scope.player.__id].teamId;
1954 },
1955 checkId : function(checkType) {
1956 return _this.scope[_this.obfuscate.players.barn][_this.obfuscate.players.info][checkType];
1957 },
1958 cantCollide : function(e, value) {
1959 var pos = e.pos;
1960 var startPosition = (item = _this.scope.player).pos;
1961 var data = _this.scope[_this.obfuscate.objectCreator].idToObj;
1962 /** @type {!Array<string>} */
1963 var pipelets = Object.keys(data).filter(function(i) {
1964 return "string" == typeof data[i].img ? value && "function" == typeof value ? value(data[i]) : !data[i].isDoor && !data[i].isBush && !data[i].isWindow && !data[i].img.includes("stair") && !data[i].img.includes("table") && !data[i].img.includes("tree") && !data[i].type.includes("rail") && !data[i].type.includes("glass") && !data[i].type.includes("bar") && void 0 !== data[i].collidable && data[i].collidable : void 0 !== data[i].collidable && data[i].collidable;
1965 });
1966 /** @type {!Array} */
1967 var input = [];
1968 /** @type {!Array} */
1969 input.A = [];
1970 /** @type {!Array} */
1971 input.B = [];
1972 /** @type {!Array} */
1973 input.C = [];
1974 /** @type {!Array} */
1975 input.D = [];
1976 input.A.x = startPosition.x;
1977 input.A.y = startPosition.y;
1978 input.B.x = pos.x;
1979 input.B.y = pos.y;
1980 /** @type {boolean} */
1981 var c = true;
1982 pipelets.forEach(function(i, y, v) {
1983 if (data[i].layer === item.layer && !data[i].dead) {
1984 if (void 0 !== data[i].collider && void 0 !== data[i].collider.min && void 0 !== data[i].collider.max) {
1985 input.C.x = data[i].collider.min.x;
1986 input.C.y = data[i].collider.min.y;
1987 input.D.x = data[i].collider.max.x;
1988 input.D.y = data[i].collider.min.y;
1989 if (addOption(input)) {
1990 /** @type {boolean} */
1991 c = false;
1992 }
1993 input.C.x = data[i].collider.max.x;
1994 input.C.y = data[i].collider.min.y;
1995 input.D.x = data[i].collider.max.x;
1996 input.D.y = data[i].collider.max.y;
1997 if (addOption(input)) {
1998 /** @type {boolean} */
1999 c = false;
2000 }
2001 input.C.x = data[i].collider.max.x;
2002 input.C.y = data[i].collider.max.y;
2003 input.D.x = data[i].collider.min.x;
2004 input.D.y = data[i].collider.max.y;
2005 if (addOption(input)) {
2006 /** @type {boolean} */
2007 c = false;
2008 }
2009 input.C.x = data[i].collider.min.x;
2010 input.C.y = data[i].collider.max.y;
2011 input.D.x = data[i].collider.min.x;
2012 input.D.y = data[i].collider.max.y;
2013 if (addOption(input)) {
2014 /** @type {boolean} */
2015 c = false;
2016 }
2017 } else {
2018 v = data[i].collider.pos.x;
2019 y = data[i].collider.pos.y;
2020 var b;
2021 var d;
2022 var l = input.A.x;
2023 var a = input.A.y;
2024 var x = input.B.x;
2025 var c = input.B.y;
2026 /** @type {number} */
2027 var w = x - l;
2028 /** @type {number} */
2029 var h = c - a;
2030 /** @type {number} */
2031 var ticks = w * w + h * h;
2032 /** @type {number} */
2033 var m = -1;
2034 if (0 != ticks) {
2035 /** @type {number} */
2036 m = ((v - l) * w + (y - a) * h) / ticks;
2037 }
2038 if (0 > m) {
2039 b = l;
2040 d = a;
2041 } else {
2042 if (1 < m) {
2043 b = x;
2044 d = c;
2045 } else {
2046 b = l + m * w;
2047 d = a + m * h;
2048 }
2049 }
2050 /** @type {number} */
2051 b = v - b;
2052 /** @type {number} */
2053 d = y - d;
2054 if (Math.sqrt(b * b + d * d) <= data[i].collider.rad) {
2055 /** @type {boolean} */
2056 c = false;
2057 }
2058 }
2059 }
2060 });
2061 var item = _this.scope.player;
2062 return !(!c || !function(annotation, start) {
2063 var end = annotation.pos;
2064 if (start = start.pos, end = Math.sqrt(Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2)), annotation[this.obfuscate.netData].weapType && this.data.items[annotation[this.obfuscate.netData].weapType]) {
2065 start = this.data.items[annotation[this.obfuscate.netData].weapType];
2066 /** @type {boolean} */
2067 annotation = true;
2068 var v = start.bulletType;
2069 return null != v && "" !== v && (annotation = end < this.data.bullets[start.bulletType].distance), annotation;
2070 }
2071 return true;
2072 }.call(_this, item, e));
2073 }
2074 };
2075 this.UI = new init(this.version, this.plugins);
2076 this.checkUpdate();
2077 }).prototype.addPlugin = function(plugin) {
2078 /** @type {!Object} */
2079 this.plugins[plugin.name] = plugin;
2080 if (this.UI) {
2081 this.UI.render();
2082 }
2083 };
2084 /**
2085 * @param {!Object} plugin
2086 * @return {undefined}
2087 */
2088 update.prototype.removePlugin = function(plugin) {
2089 if ("object" == typeof plugin) {
2090 delete this.plugins[plugin.name];
2091 } else {
2092 delete this.plugins[plugin];
2093 }
2094 this.UI.render();
2095 };
2096 /**
2097 * @param {?} targetInstance
2098 * @param {?} targetInstanceIsInitialized
2099 * @return {undefined}
2100 */
2101 update.prototype.inject = function(targetInstance, targetInstanceIsInitialized) {
2102 };
2103 /**
2104 * @return {undefined}
2105 */
2106 update.prototype.loop = function() {
2107 var self = this;
2108 if (this.ready && this.scope && this.UI) {
2109 this.lastInputs = this.inputs;
2110 /** @type {!Array} */
2111 this.inputs = [];
2112 /** @type {boolean} */
2113 this.input.moveAngle = false;
2114 /** @type {boolean} */
2115 this.input.moveAngleOv = false;
2116 Object.values(this.plugins).forEach(function(logger) {
2117 if (logger.enabled && !logger.dontLoop && "function" == typeof logger.loop) {
2118 try {
2119 logger.loop(self.obfuscate, self.scope, self.scope.player, self.input, self.data, self.plugins, self.ready);
2120 } catch (err) {
2121 console.log("FATAL (" + logger.name + ") " + err + err.stack);
2122 }
2123 }
2124 });
2125 if (this.healthLast !== this.scope.player[this.obfuscate.localData][this.obfuscate.health]) {
2126 this.healthLast = this.scope.player[this.obfuscate.localData][this.obfuscate.health];
2127 this.UI.health.html(Math.ceil(this.healthLast));
2128 }
2129 /** @type {!Array<?>} */
2130 this.inputs = [].concat($jscomp.arrayFromIterable(new Set(this.inputs)));
2131 this.data.getEnemies().forEach(function(aView) {
2132 aView.posOldOld = aView.posOld;
2133 });
2134 this.scope.player.posOldOld = this.scope.player.posOld;
2135 }
2136 };
2137 /**
2138 * @return {undefined}
2139 */
2140 update.prototype.end = function() {
2141 var options = this;
2142 Object.values(this.plugins).forEach(function(that) {
2143 if (that.enabled && "function" == typeof that.end) {
2144 that.end(options.obfuscate, options.scope, options.scope.player, options.input, options.data);
2145 }
2146 });
2147 };
2148 /**
2149 * @return {?}
2150 */
2151 update.prototype._getKeys = function() {
2152 var x = this.internal;
2153 console.log(x);
2154 /** @type {(Array<string>|null)} */
2155 var i = /\.Type\.Player,this\.(\w+)\./g.exec(x);
2156 /** @type {(Array<string>|null)} */
2157 var m = /this\.(\w+)={},this\.playerIds=\[\],/g.exec(x);
2158 /** @type {(Array<string>|null)} */
2159 var memoryx = /this\.config=\w+,this\.(\w+)=\w+,this\.account=\w+}/g.exec(x);
2160 /** @type {(Array<string>|null)} */
2161 var intervalTexts = /this\.(\w+)=new \w+\.Creator;/g.exec(x);
2162 /** @type {(Array<string>|null)} */
2163 var depth_toggles = /_TYPE\.CANVAS,this\.(\w+)=new \w+\.\w+,/g.exec(x);
2164 /** @type {(Array<string>|null)} */
2165 var spaceClick = /this\.(\w+)={pos:\w+\.create/g.exec(x);
2166 /** @type {(Array<string>|null)} */
2167 var xOptView = /this\.([a-zA-Z_\-\$]+)={\w+:100,/g.exec(x);
2168 /** @type {(Array<string>|null)} */
2169 var data = /\w+\.Type\.Loot,this\.(\w+)\.(\w+)/g.exec(x);
2170 /** @type {(Array<string>|null)} */
2171 var parts = /creator={type:\w+},this\.(\w+)=\[\],/g.exec(x);
2172 /** @type {(Array<string>|null)} */
2173 var tags = /=new \w+\.Pool\(\w+\),this\.(\w+)=null}var/g.exec(x);
2174 /** @type {(Array<string>|null)} */
2175 var coi = /\.createBullet\(\w+,this\.(\w+),/g.exec(x);
2176 /** @type {(Array<string>|null)} */
2177 var match = /this\.([a-zA-Z_\-\$]+)\.([a-zA-Z_\-\$]+)=\w+\.copy\((?:\w|\.)+\),this\.\w+\.([a-zA-Z_\-\$]+)=\w+\.copy\((?:\w|\.)+\),\w+&&\(this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,.*?this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,this\.\w+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+/g.exec(x);
2178 return x = /\(this\.([a-zA-Z_\-\$]+)\.([a-zA-Z_\-\$]+)=(?:\w|\.)+\),(?:\w|\.)+&&\(this\.[a-zA-Z_\-\$]+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+\).*?this\.[a-zA-Z_\-\$]+.*?\{.*?,this\.[a-zA-Z_\-\$]+\.([a-zA-Z_\-\$]+).*?;.*?this\.[a-zA-Z_\-\$]+\.([a-zA-Z_\-\$]+)=(?:\w|\.)+,.*?this\.[a-zA-Z_\-\$]+\.([a-zA-Z_\-\$]+)=\[\]/g.exec(x), i = {
2179 netData : spaceClick[1],
2180 localData : xOptView[1],
2181 camera : depth_toggles[1],
2182 objectCreator : intervalTexts[1],
2183 inputManager : memoryx[1],
2184 players : {
2185 barn : i[1],
2186 info : m[1]
2187 },
2188 loot : {
2189 barn : data[1],
2190 pool : data[2],
2191 array : parts[1],
2192 active : tags[1]
2193 },
2194 bullets : coi[1]
2195 }, Object.assign(i, {
2196 pos : match[2],
2197 dir : match[3],
2198 backpack : match[5],
2199 helmet : match[6],
2200 chest : match[7],
2201 weapType : match[8],
2202 layer : match[9],
2203 dead : match[10],
2204 downed : match[11],
2205 health : x[2],
2206 boost : x[3],
2207 inventory : x[4],
2208 weapIdx : x[5],
2209 weapons : x[6]
2210 }), i;
2211 };
2212 /**
2213 * @return {?}
2214 */
2215 update.prototype.init = function() {
2216 var self = this;
2217 if (console.log("init passed00"), this.internal && !this.ready) {
2218 console.log("init passed");
2219 try {
2220 window.webpackJsonp([0], {
2221 webpack_inject : function(context, fullName, parse) {
2222 return self.data.GET = parse, self.data.guns = parse("ad1c4e70"), self.data.ammo = parse("764654e6"), self.data.skin = parse("63d67e9d"), self.data.melee = parse("ccb6ad93"), self.data.bullets = parse("beeed8a4"), self.data.throwable = parse("035f2ecb"), self.data.explosions = parse("ea3b9366"), self.data.objects = parse("03f4982a"), self.data.mergeDeep = parse("1901e2d9").mergeDeep, self.data.pieTimer = parse("feb8fc30"), self.data.items = self.data.mergeDeep({}, self.data.objects, self.data.throwable,
2223 self.data.guns, self.data.ammo, self.data.skin, self.data.melee, self.data.bullets), self.data.data = self.data.mergeDeep(parse("8649e148"), parse("989ad62a"), {
2224 Messages : parse("300e2704")
2225 }), console.log(self.data), true;
2226 }
2227 }, ["webpack_inject"]);
2228 this.obfuscate = this._getKeys();
2229 /** @type {boolean} */
2230 this.ready = true;
2231 } catch (size_buffer) {
2232 return console.log("NON_FATAL", size_buffer), setTimeout(this.init, 20);
2233 }
2234 $(window).on("mousedown", function(event) {
2235 return 0 == event.button ? self.input.leftMouse = true : 2 == event.button ? self.input.rightMouse = true : void 0;
2236 });
2237 $(window).on("mouseup", function(event) {
2238 return 0 == event.button ? self.input.leftMouse = false : 2 == event.button ? self.input.rightMouse = false : void 0;
2239 });
2240 $(window).on("mousemove", function(to) {
2241 self.input.mouse = {
2242 x : to.clientX,
2243 y : to.clientY
2244 };
2245 });
2246 }
2247 };
2248 /**
2249 * @param {!Object} str
2250 * @return {?}
2251 */
2252 update.prototype.get = function(str) {
2253 /** @type {!XMLHttpRequest} */
2254 var xhr = new XMLHttpRequest;
2255 return xhr.open("GET", str, false), xhr.send(null), xhr.responseText;
2256 };
2257 /**
2258 * @return {undefined}
2259 */
2260 update.prototype.checkUpdate = function() {
2261 /** @type {*} */
2262 var data = JSON.parse(this.get("https://api.github.com/repos/IceHacks/SurvivCheatInjector/releases"));
2263 var version = data[0].tag_name;
2264 data = data[0].assets[0].download_count;
2265 console.log(this.version);
2266 if (s.lt(this.version, version)) {
2267 callback("Outdated", "Please update the cheat! The current version is " + version + " with " + data.toLocaleString() + " downloads.", "warning", {
2268 buttons : {
2269 cancel : "No thanks",
2270 ok : "Update!"
2271 }
2272 }).then(function($in) {
2273 if ("ok" == $in) {
2274 /** @type {string} */
2275 window.location = "https://github.com/IceHacks/SurvivCheatInjector#Download";
2276 }
2277 });
2278 }
2279 };
2280 /**
2281 * @param {!Array} array
2282 * @return {undefined}
2283 */
2284 update.prototype.uniq = function(array) {
2285 array.filter(function(i, object) {
2286 return array.indexOf(i) == object;
2287 });
2288 };
2289 /**
2290 * @param {string} str
2291 * @return {?}
2292 */
2293 update.prototype.ucfirst = function(str) {
2294 return str.charAt(0).toUpperCase() + str.slice(1);
2295 };
2296 window[shouldHydrateName] = new update;
2297 window[shouldHydrateName].addPlugin(require(13));
2298 window[shouldHydrateName].addPlugin(require(14));
2299 window[shouldHydrateName].addPlugin(require(15));
2300 window[shouldHydrateName].addPlugin(require(16));
2301 window[shouldHydrateName].addPlugin(require(17));
2302 window[shouldHydrateName].addPlugin(require(18));
2303 window[shouldHydrateName].addPlugin(require(19));
2304 window[shouldHydrateName].addPlugin(require(20));
2305 window[shouldHydrateName].addPlugin(require(21));
2306 window[shouldHydrateName].addPlugin(require(22));
2307 window[shouldHydrateName].addPlugin(require(23));
2308 window[shouldHydrateName].addPlugin(require(24));
2309 window[shouldHydrateName].addPlugin(require(25));
2310}, function(value, canCreateDiscussions) {
2311 !function(global, factory) {
2312 if ("object" == typeof value && "object" == typeof value.exports) {
2313 value.exports = global.document ? factory(global, true) : function(value) {
2314 if (!value.document) {
2315 throw Error("jQuery requires a window with a document");
2316 }
2317 return factory(value);
2318 };
2319 } else {
2320 factory(global);
2321 }
2322 }("undefined" != typeof window ? window : this, function(window, zoomAware) {
2323 /**
2324 * @param {!Object} name
2325 * @param {!Object} obj
2326 * @param {!Object} doc
2327 * @return {undefined}
2328 */
2329 function callback(name, obj, doc) {
2330 var key;
2331 var script = (doc = doc || document).createElement("script");
2332 if (script.text = name, obj) {
2333 for (key in obj) {
2334 if (name = obj[key] || obj.getAttribute && obj.getAttribute(key)) {
2335 script.setAttribute(key, name);
2336 }
2337 }
2338 }
2339 doc.head.appendChild(script).parentNode.removeChild(script);
2340 }
2341 /**
2342 * @param {!Object} value
2343 * @return {?}
2344 */
2345 function type(value) {
2346 return null == value ? value + "" : "object" == typeof value || "function" == typeof value ? class2type[toString.call(value)] || "object" : typeof value;
2347 }
2348 /**
2349 * @param {!Object} obj
2350 * @return {?}
2351 */
2352 function isArrayLike(obj) {
2353 var length = !!obj && "length" in obj && obj.length;
2354 var ltype = type(obj);
2355 return !fn(obj) && !isWindow(obj) && ("array" === ltype || 0 === length || "number" == typeof length && 0 < length && length - 1 in obj);
2356 }
2357 /**
2358 * @param {!Object} value
2359 * @param {!Object} name
2360 * @return {?}
2361 */
2362 function $(value, name) {
2363 return value.nodeName && value.nodeName.toLowerCase() === name.toLowerCase();
2364 }
2365 /**
2366 * @param {!Object} key
2367 * @param {?} value
2368 * @param {boolean} not
2369 * @return {?}
2370 */
2371 function filter(key, value, not) {
2372 return fn(value) ? jQuery.grep(key, function(context, i) {
2373 return !!value.call(context, i, context) !== not;
2374 }) : value.nodeType ? jQuery.grep(key, function(elem) {
2375 return elem === value !== not;
2376 }) : "string" != typeof value ? jQuery.grep(key, function(name) {
2377 return -1 < indexOf.call(value, name) !== not;
2378 }) : jQuery.filter(value, key, not);
2379 }
2380 /**
2381 * @param {!Object} cur
2382 * @param {string} dir
2383 * @return {?}
2384 */
2385 function sibling(cur, dir) {
2386 for (; (cur = cur[dir]) && 1 !== cur.nodeType;) {
2387 }
2388 return cur;
2389 }
2390 /**
2391 * @param {?} value
2392 * @return {?}
2393 */
2394 function i(value) {
2395 return value;
2396 }
2397 /**
2398 * @param {?} state
2399 * @return {?}
2400 */
2401 function undefined(state) {
2402 throw state;
2403 }
2404 /**
2405 * @param {!Object} entry
2406 * @param {!Function} callback
2407 * @param {!Function} message
2408 * @param {boolean} items
2409 * @return {undefined}
2410 */
2411 function require(entry, callback, message, items) {
2412 var ret;
2413 try {
2414 if (entry && fn(ret = entry.promise)) {
2415 ret.call(entry).done(callback).fail(message);
2416 } else {
2417 if (entry && fn(ret = entry.then)) {
2418 ret.call(entry, callback, message);
2419 } else {
2420 callback.apply(void 0, [entry].slice(items));
2421 }
2422 }
2423 } catch (errorEventName) {
2424 message.apply(void 0, [errorEventName]);
2425 }
2426 }
2427 /**
2428 * @return {undefined}
2429 */
2430 function $__jsx_onload() {
2431 document.removeEventListener("DOMContentLoaded", $__jsx_onload);
2432 window.removeEventListener("load", $__jsx_onload);
2433 jQuery.ready();
2434 }
2435 /**
2436 * @param {?} context
2437 * @param {string} match
2438 * @return {?}
2439 */
2440 function dashToCapital(context, match) {
2441 return match.toUpperCase();
2442 }
2443 /**
2444 * @param {!Object} str
2445 * @return {?}
2446 */
2447 function camelCase(str) {
2448 return str.replace(_kerningNamesHash_escapeEscape, "ms-").replace(rcharset, dashToCapital);
2449 }
2450 /**
2451 * @return {undefined}
2452 */
2453 function Data() {
2454 this.expando = jQuery.expando + Data.uid++;
2455 }
2456 /**
2457 * @param {?} node
2458 * @param {!Object} name
2459 * @param {?} key
2460 * @return {?}
2461 */
2462 function set(node, name, key) {
2463 if (void 0 === key && 1 === node.nodeType) {
2464 if (key = "data-" + name.replace(dashExpr, "-$&").toLowerCase(), "string" == typeof(key = node.getAttribute(key))) {
2465 try {
2466 var value = key;
2467 /** @type {*} */
2468 key = "true" === value || "false" !== value && ("null" === value ? null : value === +value + "" ? +value : contribRegex.test(value) ? JSON.parse(value) : value);
2469 } catch (e) {
2470 }
2471 data_priv.set(node, name, key);
2472 } else {
2473 key = void 0;
2474 }
2475 }
2476 return key;
2477 }
2478 /**
2479 * @param {!Object} elem
2480 * @param {!Array} prop
2481 * @param {!Object} valueParts
2482 * @param {!Object} tween
2483 * @return {?}
2484 */
2485 function adjustCSS(elem, prop, valueParts, tween) {
2486 var scale;
2487 /** @type {number} */
2488 var i = 20;
2489 /** @type {function(): ?} */
2490 var currentValue = tween ? function() {
2491 return tween.cur();
2492 } : function() {
2493 return jQuery.css(elem, prop, "");
2494 };
2495 var initial = currentValue();
2496 var unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px");
2497 var initialInUnit = elem.nodeType && (jQuery.cssNumber[prop] || "px" !== unit && +initial) && regex.exec(jQuery.css(elem, prop));
2498 if (initialInUnit && initialInUnit[3] !== unit) {
2499 /** @type {number} */
2500 initial = initial / 2;
2501 unit = unit || initialInUnit[3];
2502 /** @type {number} */
2503 initialInUnit = +initial || 1;
2504 for (; i--;) {
2505 jQuery.style(elem, prop, initialInUnit + unit);
2506 if (0 >= (1 - scale) * (1 - (scale = currentValue() / initial || .5))) {
2507 /** @type {number} */
2508 i = 0;
2509 }
2510 /** @type {number} */
2511 initialInUnit = initialInUnit / scale;
2512 }
2513 /** @type {number} */
2514 initialInUnit = initialInUnit * 2;
2515 jQuery.style(elem, prop, initialInUnit + unit);
2516 valueParts = valueParts || [];
2517 }
2518 if (valueParts) {
2519 /** @type {number} */
2520 initialInUnit = +initialInUnit || +initial || 0;
2521 /** @type {number} */
2522 var adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
2523 if (tween) {
2524 tween.unit = unit;
2525 /** @type {number} */
2526 tween.start = initialInUnit;
2527 /** @type {number} */
2528 tween.end = adjusted;
2529 }
2530 }
2531 return adjusted;
2532 }
2533 /**
2534 * @param {!Array} elements
2535 * @param {boolean} id
2536 * @return {?}
2537 */
2538 function show(elements, id) {
2539 var name;
2540 var node;
2541 /** @type {!Array} */
2542 var values = [];
2543 /** @type {number} */
2544 var i = 0;
2545 var eL = elements.length;
2546 for (; i < eL; i++) {
2547 if ((node = elements[i]).style) {
2548 if (name = node.style.display, id) {
2549 if ("none" === name && (values[i] = dataPriv.get(node, "display") || null, values[i] || (node.style.display = "")), "" === node.style.display && isHidden(node)) {
2550 /** @type {number} */
2551 name = i;
2552 var elem = node.ownerDocument;
2553 node = node.nodeName;
2554 var display = elemdisplay[node];
2555 if (!display) {
2556 elem = elem.body.appendChild(elem.createElement(node));
2557 display = jQuery.css(elem, "display");
2558 elem.parentNode.removeChild(elem);
2559 if ("none" === display) {
2560 /** @type {string} */
2561 display = "block";
2562 }
2563 elemdisplay[node] = display;
2564 }
2565 elem = display;
2566 values[name] = elem;
2567 }
2568 } else {
2569 if ("none" !== name) {
2570 /** @type {string} */
2571 values[i] = "none";
2572 dataPriv.set(node, "display", name);
2573 }
2574 }
2575 }
2576 }
2577 /** @type {number} */
2578 i = 0;
2579 for (; i < eL; i++) {
2580 if (null != values[i]) {
2581 elements[i].style.display = values[i];
2582 }
2583 }
2584 return elements;
2585 }
2586 /**
2587 * @param {!Object} context
2588 * @param {number} tag
2589 * @return {?}
2590 */
2591 function getAll(context, tag) {
2592 var n = void 0 !== context.getElementsByTagName ? context.getElementsByTagName(tag || "*") : void 0 !== context.querySelectorAll ? context.querySelectorAll(tag || "*") : [];
2593 return void 0 === tag || tag && $(context, tag) ? jQuery.merge([context], n) : n;
2594 }
2595 /**
2596 * @param {number} elems
2597 * @param {!NodeList} refElements
2598 * @return {undefined}
2599 */
2600 function setGlobalEval(elems, refElements) {
2601 /** @type {number} */
2602 var i = 0;
2603 var length = elems.length;
2604 for (; i < length; i++) {
2605 dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
2606 }
2607 }
2608 /**
2609 * @param {!Function} elems
2610 * @param {!Object} context
2611 * @param {string} node
2612 * @param {!Object} result
2613 * @param {!Array} ignored
2614 * @return {?}
2615 */
2616 function buildFragment(elems, context, node, result, ignored) {
2617 var elem;
2618 var tmp;
2619 var tag;
2620 var fragment = context.createDocumentFragment();
2621 /** @type {!Array} */
2622 var results = [];
2623 /** @type {number} */
2624 var i = 0;
2625 var length = elems.length;
2626 for (; i < length; i++) {
2627 if ((elem = elems[i]) || 0 === elem) {
2628 if ("object" === type(elem)) {
2629 jQuery.merge(results, elem.nodeType ? [elem] : elem);
2630 } else {
2631 if (re_commas.test(elem)) {
2632 tmp = tmp || fragment.appendChild(context.createElement("div"));
2633 tag = (fullLinkRegex.exec(elem) || ["", ""])[1].toLowerCase();
2634 tag = wrapMap[tag] || wrapMap._default;
2635 tmp.innerHTML = tag[1] + jQuery.htmlPrefilter(elem) + tag[2];
2636 tag = tag[0];
2637 for (; tag--;) {
2638 tmp = tmp.lastChild;
2639 }
2640 jQuery.merge(results, tmp.childNodes);
2641 /** @type {string} */
2642 (tmp = fragment.firstChild).textContent = "";
2643 } else {
2644 results.push(context.createTextNode(elem));
2645 }
2646 }
2647 }
2648 }
2649 /** @type {string} */
2650 fragment.textContent = "";
2651 /** @type {number} */
2652 i = 0;
2653 for (; elem = results[i++];) {
2654 if (result && -1 < jQuery.inArray(elem, result)) {
2655 if (ignored) {
2656 ignored.push(elem);
2657 }
2658 } else {
2659 if (elems = test(elem), tmp = getAll(fragment.appendChild(elem), "script"), elems && setGlobalEval(tmp), node) {
2660 /** @type {number} */
2661 tag = 0;
2662 for (; elem = tmp[tag++];) {
2663 if (opacityRe.test(elem.type || "")) {
2664 node.push(elem);
2665 }
2666 }
2667 }
2668 }
2669 }
2670 return fragment;
2671 }
2672 /**
2673 * @return {?}
2674 */
2675 function returnTrue() {
2676 return true;
2677 }
2678 /**
2679 * @return {?}
2680 */
2681 function returnFalse() {
2682 return false;
2683 }
2684 /**
2685 * @param {?} index
2686 * @param {string} focus
2687 * @return {?}
2688 */
2689 function onDoubleClick(index, focus) {
2690 e: {
2691 try {
2692 var active = document.activeElement;
2693 break e;
2694 } catch (e) {
2695 }
2696 active = void 0;
2697 }
2698 return index === active == ("focus" === focus);
2699 }
2700 /**
2701 * @param {!Object} info
2702 * @param {string} data
2703 * @param {!Object} value
2704 * @param {!Object} key
2705 * @param {!Object} fn
2706 * @param {number} error
2707 * @return {?}
2708 */
2709 function debug(info, data, value, key, fn, error) {
2710 var i;
2711 if ("object" == typeof data) {
2712 for (i in "string" != typeof value && (key = key || value, value = void 0), data) {
2713 debug(info, i, value, key, data[i], error);
2714 }
2715 return info;
2716 }
2717 if (null == key && null == fn ? (fn = value, key = value = void 0) : null == fn && ("string" == typeof value ? (fn = key, key = void 0) : (fn = key, key = value, value = void 0)), false === fn) {
2718 /** @type {function(): ?} */
2719 fn = returnFalse;
2720 } else {
2721 if (!fn) {
2722 return info;
2723 }
2724 }
2725 if (1 === error) {
2726 /** @type {!Object} */
2727 var org = fn;
2728 (fn = function(e) {
2729 return jQuery().off(e), org.apply(this, arguments);
2730 }).guid = org.guid || (org.guid = jQuery.guid++);
2731 }
2732 return info.each(function() {
2733 jQuery.event.add(this, data, fn, key, value);
2734 });
2735 }
2736 /**
2737 * @param {!Array} node
2738 * @param {string} type
2739 * @param {!Function} f
2740 * @return {undefined}
2741 */
2742 function on(node, type, f) {
2743 if (f) {
2744 dataPriv.set(node, type, false);
2745 jQuery.event.add(node, type, {
2746 namespace : false,
2747 handler : function(event) {
2748 var data = dataPriv.get(this, type);
2749 if (1 & event.isTrigger && this[type]) {
2750 if (data.length) {
2751 if ((jQuery.event.special[type] || {}).delegateType) {
2752 event.stopPropagation();
2753 }
2754 } else {
2755 /** @type {!Array<?>} */
2756 data = slice.call(arguments);
2757 dataPriv.set(this, type, data);
2758 var s = f(this, type);
2759 this[type]();
2760 var content = dataPriv.get(this, type);
2761 if (data !== content || s ? dataPriv.set(this, type, false) : content = {}, data !== content) {
2762 return event.stopImmediatePropagation(), event.preventDefault(), content.value;
2763 }
2764 }
2765 } else {
2766 if (data.length) {
2767 dataPriv.set(this, type, {
2768 value : jQuery.event.trigger(jQuery.extend(data[0], jQuery.Event.prototype), data.slice(1), this)
2769 });
2770 event.stopImmediatePropagation();
2771 }
2772 }
2773 }
2774 });
2775 } else {
2776 if (void 0 === dataPriv.get(node, type)) {
2777 jQuery.event.add(node, type, returnTrue);
2778 }
2779 }
2780 }
2781 /**
2782 * @param {undefined} elem
2783 * @param {!Element} selector
2784 * @return {?}
2785 */
2786 function manipulationTarget(elem, selector) {
2787 return $(elem, "table") && $(11 !== selector.nodeType ? selector : selector.firstChild, "tr") && jQuery(elem).children("tbody")[0] || elem;
2788 }
2789 /**
2790 * @param {!Element} s
2791 * @return {?}
2792 */
2793 function p(s) {
2794 return s.type = (null !== s.getAttribute("type")) + "/" + s.type, s;
2795 }
2796 /**
2797 * @param {!Object} input
2798 * @return {?}
2799 */
2800 function t(input) {
2801 return "true/" === (input.type || "").slice(0, 5) ? input.type = input.type.slice(5) : input.removeAttribute("type"), input;
2802 }
2803 /**
2804 * @param {!Array} elem
2805 * @param {?} src
2806 * @return {undefined}
2807 */
2808 function cloneCopyEvent(elem, src) {
2809 var tableslen;
2810 var type;
2811 var events;
2812 if (1 === src.nodeType) {
2813 if (dataPriv.hasData(elem)) {
2814 var handler = dataPriv.get(elem);
2815 if (events = handler.events) {
2816 for (type in dataPriv.remove(src, "handle events"), events) {
2817 /** @type {number} */
2818 handler = 0;
2819 tableslen = events[type].length;
2820 for (; handler < tableslen; handler++) {
2821 jQuery.event.add(src, type, events[type][handler]);
2822 }
2823 }
2824 }
2825 }
2826 if (data_priv.hasData(elem)) {
2827 elem = data_priv.access(elem);
2828 elem = jQuery.extend({}, elem);
2829 data_priv.set(src, elem);
2830 }
2831 }
2832 }
2833 /**
2834 * @param {!Object} collection
2835 * @param {!Object} args
2836 * @param {!Function} callback
2837 * @param {!Array} ignored
2838 * @return {?}
2839 */
2840 function domManip(collection, args, callback, ignored) {
2841 args = map(args);
2842 var itl;
2843 /** @type {number} */
2844 var key = 0;
2845 var result = collection.length;
2846 /** @type {number} */
2847 var index = result - 1;
2848 var str = args[0];
2849 var ret = fn(str);
2850 if (ret || 1 < result && "string" == typeof str && !support.checkClone && partten.test(str)) {
2851 return collection.each(function(index) {
2852 var self = collection.eq(index);
2853 if (ret) {
2854 args[0] = str.call(this, index, self.html());
2855 }
2856 domManip(self, args, callback, ignored);
2857 });
2858 }
2859 if (result) {
2860 var target = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
2861 var element = target.firstChild;
2862 if (1 === target.childNodes.length && (target = element), element || ignored) {
2863 itl = (element = jQuery.map(getAll(target, "script"), p)).length;
2864 for (; key < result; key++) {
2865 var node = target;
2866 if (key !== index) {
2867 node = jQuery.clone(node, true, true);
2868 if (itl) {
2869 jQuery.merge(element, getAll(node, "script"));
2870 }
2871 }
2872 callback.call(collection[key], node, key);
2873 }
2874 if (itl) {
2875 target = element[element.length - 1].ownerDocument;
2876 jQuery.map(element, t);
2877 /** @type {number} */
2878 key = 0;
2879 for (; key < itl; key++) {
2880 node = element[key];
2881 if (opacityRe.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(target, node)) {
2882 if (node.src && "module" !== (node.type || "").toLowerCase()) {
2883 if (jQuery._evalUrl && !node.noModule) {
2884 jQuery._evalUrl(node.src, {
2885 nonce : node.nonce || node.getAttribute("nonce")
2886 }, target);
2887 }
2888 } else {
2889 callback(node.textContent.replace(query, ""), node, target);
2890 }
2891 }
2892 }
2893 }
2894 }
2895 }
2896 return collection;
2897 }
2898 /**
2899 * @param {!Object} val
2900 * @param {!Object} elem
2901 * @param {string} flag
2902 * @return {?}
2903 */
2904 function remove(val, elem, flag) {
2905 var obj = elem ? jQuery.filter(elem, val) : val;
2906 /** @type {number} */
2907 var i = 0;
2908 for (; null != (elem = obj[i]); i++) {
2909 if (!(flag || 1 !== elem.nodeType)) {
2910 jQuery.cleanData(getAll(elem));
2911 }
2912 if (elem.parentNode) {
2913 if (flag && test(elem)) {
2914 setGlobalEval(getAll(elem, "script"));
2915 }
2916 elem.parentNode.removeChild(elem);
2917 }
2918 }
2919 return val;
2920 }
2921 /**
2922 * @param {(Object|string)} value
2923 * @param {number} name
2924 * @param {!Object} computed
2925 * @return {?}
2926 */
2927 function curCSS(value, name, computed) {
2928 var style = value.style;
2929 if (computed = computed || getStyles(value)) {
2930 var ret = computed.getPropertyValue(name) || computed[name];
2931 if ("" !== ret || test(value) || (ret = jQuery.style(value, name)), !support.pixelBoxStyles() && rnumnonpx.test(ret) && inlineAttributeCommentRegex.test(name)) {
2932 value = style.width;
2933 name = style.minWidth;
2934 var maxWidth = style.maxWidth;
2935 style.minWidth = style.maxWidth = style.width = ret;
2936 ret = computed.width;
2937 /** @type {(Object|string)} */
2938 style.width = value;
2939 /** @type {number} */
2940 style.minWidth = name;
2941 style.maxWidth = maxWidth;
2942 }
2943 }
2944 return void 0 !== ret ? ret + "" : ret;
2945 }
2946 /**
2947 * @param {?} conditionFn
2948 * @param {!Function} hookFn
2949 * @return {?}
2950 */
2951 function addGetHookIf(conditionFn, hookFn) {
2952 return {
2953 get : function() {
2954 if (!conditionFn()) {
2955 return (this.get = hookFn).apply(this, arguments);
2956 }
2957 delete this.get;
2958 }
2959 };
2960 }
2961 /**
2962 * @param {number} key
2963 * @return {?}
2964 */
2965 function camelize(key) {
2966 var value = jQuery.cssProps[key] || params[key];
2967 if (value) {
2968 return value;
2969 }
2970 if (key in style) {
2971 return key;
2972 }
2973 e: {
2974 var suffix = (value = key)[0].toUpperCase() + value.slice(1);
2975 /** @type {number} */
2976 var i = prefixes.length;
2977 for (; i--;) {
2978 if ((value = prefixes[i] + suffix) in style) {
2979 break e;
2980 }
2981 }
2982 value = void 0;
2983 }
2984 return params[key] = value || key;
2985 }
2986 /**
2987 * @param {!Object} elem
2988 * @param {!Object} value
2989 * @param {string} type
2990 * @return {?}
2991 */
2992 function func(elem, value, type) {
2993 return (elem = regex.exec(value)) ? Math.max(0, elem[2] - (type || 0)) + (elem[3] || "px") : value;
2994 }
2995 /**
2996 * @param {!Object} elem
2997 * @param {!Object} name
2998 * @param {string} extra
2999 * @param {boolean} isBorderBox
3000 * @param {undefined} styles
3001 * @param {number} themeName
3002 * @return {?}
3003 */
3004 function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles, themeName) {
3005 /** @type {number} */
3006 var i = "width" === name ? 1 : 0;
3007 /** @type {number} */
3008 var value = 0;
3009 /** @type {number} */
3010 var val = 0;
3011 if (extra === (isBorderBox ? "border" : "content")) {
3012 return 0;
3013 }
3014 for (; 4 > i; i = i + 2) {
3015 if ("margin" === extra) {
3016 val = val + jQuery.css(elem, extra + cssExpand[i], true, styles);
3017 }
3018 if (isBorderBox) {
3019 if ("content" === extra) {
3020 /** @type {number} */
3021 val = val - jQuery.css(elem, "padding" + cssExpand[i], true, styles);
3022 }
3023 if ("margin" !== extra) {
3024 /** @type {number} */
3025 val = val - jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
3026 }
3027 } else {
3028 val = val + jQuery.css(elem, "padding" + cssExpand[i], true, styles);
3029 if ("padding" !== extra) {
3030 val = val + jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
3031 } else {
3032 value = value + jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
3033 }
3034 }
3035 }
3036 return !isBorderBox && 0 <= themeName && (val = val + (Math.max(0, Math.ceil(elem["offset" + name[0].toUpperCase() + name.slice(1)] - themeName - val - value - .5)) || 0)), val;
3037 }
3038 /**
3039 * @param {!Element} elem
3040 * @param {!Array} name
3041 * @param {!Object} extra
3042 * @return {?}
3043 */
3044 function load(elem, name, extra) {
3045 var styles = getStyles(elem);
3046 var isBorderBox = (!support.boxSizingReliable() || extra) && "border-box" === jQuery.css(elem, "boxSizing", false, styles);
3047 var valueIsBorderBox = isBorderBox;
3048 var value = curCSS(elem, name, styles);
3049 var prop = "offset" + name[0].toUpperCase() + name.slice(1);
3050 if (rnumnonpx.test(value)) {
3051 if (!extra) {
3052 return value;
3053 }
3054 /** @type {string} */
3055 value = "auto";
3056 }
3057 return (!support.boxSizingReliable() && isBorderBox || !support.reliableTrDimensions() && $(elem, "tr") || "auto" === value || !parseFloat(value) && "inline" === jQuery.css(elem, "display", false, styles)) && elem.getClientRects().length && (isBorderBox = "border-box" === jQuery.css(elem, "boxSizing", false, styles), (valueIsBorderBox = prop in elem) && (value = elem[prop])), (value = parseFloat(value) || 0) + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox,
3058 styles, value) + "px";
3059 }
3060 /**
3061 * @param {!Object} type
3062 * @param {string} context
3063 * @param {string} object
3064 * @param {!Object} end
3065 * @param {string} easing
3066 * @return {?}
3067 */
3068 function Tween(type, context, object, end, easing) {
3069 return new Tween.prototype.init(type, context, object, end, easing);
3070 }
3071 /**
3072 * @return {undefined}
3073 */
3074 function step() {
3075 if (pt) {
3076 if (false === document.hidden && window.requestAnimationFrame) {
3077 window.requestAnimationFrame(step);
3078 } else {
3079 window.setTimeout(step, jQuery.fx.interval);
3080 }
3081 jQuery.fx.tick();
3082 }
3083 }
3084 /**
3085 * @return {?}
3086 */
3087 function createFxNow() {
3088 return window.setTimeout(function() {
3089 fxNow = void 0;
3090 }), fxNow = Date.now();
3091 }
3092 /**
3093 * @param {string} type
3094 * @param {number} includeWidth
3095 * @return {?}
3096 */
3097 function genFx(type, includeWidth) {
3098 /** @type {number} */
3099 var i = 0;
3100 var attrs = {
3101 height : type
3102 };
3103 /** @type {number} */
3104 includeWidth = includeWidth ? 1 : 0;
3105 for (; 4 > i; i = i + (2 - includeWidth)) {
3106 var name = cssExpand[i];
3107 attrs["margin" + name] = attrs["padding" + name] = type;
3108 }
3109 return includeWidth && (attrs.opacity = attrs.width = type), attrs;
3110 }
3111 /**
3112 * @param {?} value
3113 * @param {string} prop
3114 * @param {?} animation
3115 * @return {?}
3116 */
3117 function createTween(value, prop, animation) {
3118 var tween;
3119 var r = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]);
3120 /** @type {number} */
3121 var i = 0;
3122 var br = r.length;
3123 for (; i < br; i++) {
3124 if (tween = r[i].call(animation, prop, value)) {
3125 return tween;
3126 }
3127 }
3128 }
3129 /**
3130 * @param {!Object} elem
3131 * @param {!Object} data
3132 * @param {!Object} options
3133 * @return {?}
3134 */
3135 function Animation(elem, data, options) {
3136 var o;
3137 /** @type {number} */
3138 var index = 0;
3139 var ncells = Animation.prefilters.length;
3140 var deferred = jQuery.Deferred().always(function() {
3141 delete tick.elem;
3142 });
3143 /**
3144 * @return {?}
3145 */
3146 var tick = function() {
3147 if (o) {
3148 return false;
3149 }
3150 var currentTime = fxNow || createFxNow();
3151 /** @type {number} */
3152 var percent = 1 - ((currentTime = Math.max(0, animation.startTime + animation.duration - currentTime)) / animation.duration || 0);
3153 /** @type {number} */
3154 var index = 0;
3155 var result = animation.tweens.length;
3156 for (; index < result; index++) {
3157 animation.tweens[index].run(percent);
3158 }
3159 return deferred.notifyWith(elem, [animation, percent, currentTime]), 1 > percent && result ? currentTime : (result || deferred.notifyWith(elem, [animation, 1, 0]), deferred.resolveWith(elem, [animation]), false);
3160 };
3161 var animation = deferred.promise({
3162 elem : elem,
3163 props : jQuery.extend({}, data),
3164 opts : jQuery.extend(true, {
3165 specialEasing : {},
3166 easing : jQuery.easing._default
3167 }, options),
3168 originalProperties : data,
3169 originalOptions : options,
3170 startTime : fxNow || createFxNow(),
3171 duration : options.duration,
3172 tweens : [],
3173 createTween : function(prop, end) {
3174 return prop = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing), animation.tweens.push(prop), prop;
3175 },
3176 stop : function(value) {
3177 /** @type {number} */
3178 var i = 0;
3179 var mid = value ? animation.tweens.length : 0;
3180 if (o) {
3181 return this;
3182 }
3183 /** @type {boolean} */
3184 o = true;
3185 for (; i < mid; i++) {
3186 animation.tweens[i].run(1);
3187 }
3188 return value ? (deferred.notifyWith(elem, [animation, 1, 0]), deferred.resolveWith(elem, [animation, value])) : deferred.rejectWith(elem, [animation, value]), this;
3189 }
3190 });
3191 (function(res, data) {
3192 var key;
3193 var hooks;
3194 for (key in res) {
3195 var name = camelCase(key);
3196 var val = data[name];
3197 var obj = res[key];
3198 if (Array.isArray(obj) && (val = obj[1], obj = res[key] = obj[0]), key !== name && (res[name] = obj, delete res[key]), (hooks = jQuery.cssHooks[name]) && "expand" in hooks) {
3199 for (key in obj = hooks.expand(obj), delete res[name], obj) {
3200 if (!(key in res)) {
3201 res[key] = obj[key];
3202 data[key] = val;
3203 }
3204 }
3205 } else {
3206 data[name] = val;
3207 }
3208 }
3209 })(options = animation.props, animation.opts.specialEasing);
3210 for (; index < ncells; index++) {
3211 if (data = Animation.prefilters[index].call(animation, elem, options, animation.opts)) {
3212 return fn(data.stop) && (jQuery._queueHooks(animation.elem, animation.opts.queue).stop = data.stop.bind(data)), data;
3213 }
3214 }
3215 return jQuery.map(options, createTween, animation), fn(animation.opts.start) && animation.opts.start.call(elem, animation), animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always), jQuery.fx.timer(jQuery.extend(tick, {
3216 elem : elem,
3217 anim : animation,
3218 queue : animation.opts.queue
3219 })), animation;
3220 }
3221 /**
3222 * @param {string} src
3223 * @return {?}
3224 */
3225 function log(src) {
3226 return (src.match(re) || []).join(" ");
3227 }
3228 /**
3229 * @param {!Node} elem
3230 * @return {?}
3231 */
3232 function getClass(elem) {
3233 return elem.getAttribute && elem.getAttribute("class") || "";
3234 }
3235 /**
3236 * @param {!Object} value
3237 * @return {?}
3238 */
3239 function trim(value) {
3240 return Array.isArray(value) ? value : "string" == typeof value && value.match(re) || [];
3241 }
3242 /**
3243 * @param {string} e
3244 * @param {!Object} data
3245 * @param {string} r
3246 * @param {!Function} callback
3247 * @return {undefined}
3248 */
3249 function cb(e, data, r, callback) {
3250 var a;
3251 if (Array.isArray(data)) {
3252 jQuery.each(data, function(canCreateDiscussions, response) {
3253 if (r || touchSystem.test(e)) {
3254 callback(e, response);
3255 } else {
3256 cb(e + "[" + ("object" == typeof response && null != response ? canCreateDiscussions : "") + "]", response, r, callback);
3257 }
3258 });
3259 } else {
3260 if (r || "object" !== type(data)) {
3261 callback(e, data);
3262 } else {
3263 for (a in data) {
3264 cb(e + "[" + a + "]", data[a], r, callback);
3265 }
3266 }
3267 }
3268 }
3269 /**
3270 * @param {!Object} structure
3271 * @return {?}
3272 */
3273 function addToPrefiltersOrTransports(structure) {
3274 return function(name, n) {
3275 if ("string" != typeof name) {
3276 /** @type {string} */
3277 n = name;
3278 /** @type {string} */
3279 name = "*";
3280 }
3281 /** @type {number} */
3282 var callbackCount = 0;
3283 var callbackVals = name.toLowerCase().match(re) || [];
3284 if (fn(n)) {
3285 for (; name = callbackVals[callbackCount++];) {
3286 if ("+" === name[0]) {
3287 name = name.slice(1) || "*";
3288 (structure[name] = structure[name] || []).unshift(n);
3289 } else {
3290 (structure[name] = structure[name] || []).push(n);
3291 }
3292 }
3293 }
3294 };
3295 }
3296 /**
3297 * @param {!Object} structure
3298 * @param {?} options
3299 * @param {!Object} originalOptions
3300 * @param {?} jqXHR
3301 * @return {?}
3302 */
3303 function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
3304 /**
3305 * @param {string} id
3306 * @return {?}
3307 */
3308 function inspect(id) {
3309 var latestSrc;
3310 return playerAttribtues[id] = true, jQuery.each(structure[id] || [], function(src, prefilterOrFactory) {
3311 return "string" != typeof(src = prefilterOrFactory(options, originalOptions, jqXHR)) || seekingTransport || playerAttribtues[src] ? seekingTransport ? !(latestSrc = src) : void 0 : (options.dataTypes.unshift(src), inspect(src), false);
3312 }), latestSrc;
3313 }
3314 var playerAttribtues = {};
3315 /** @type {boolean} */
3316 var seekingTransport = structure === transports;
3317 return inspect(options.dataTypes[0]) || !playerAttribtues["*"] && inspect("*");
3318 }
3319 /**
3320 * @param {?} target
3321 * @param {?} opts
3322 * @return {?}
3323 */
3324 function ajaxExtend(target, opts) {
3325 var key;
3326 var deep;
3327 var flatOptions = jQuery.ajaxSettings.flatOptions || {};
3328 for (key in opts) {
3329 if (void 0 !== opts[key]) {
3330 (flatOptions[key] ? target : deep || (deep = {}))[key] = opts[key];
3331 }
3332 }
3333 return deep && jQuery.extend(true, target, deep), target;
3334 }
3335 /** @type {!Array} */
3336 var arr = [];
3337 /** @type {function(!Object): (Object|null)} */
3338 var getPrototypeOf = Object.getPrototypeOf;
3339 /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
3340 var slice = arr.slice;
3341 /** @type {function(!Object): ?} */
3342 var map = arr.flat ? function(data) {
3343 return arr.flat.call(data);
3344 } : function(data) {
3345 return arr.concat.apply([], data);
3346 };
3347 /** @type {function(this:IArrayLike<T>, ...T): number} */
3348 var push = arr.push;
3349 /** @type {function(this:(IArrayLike<T>|string), T, number=): number} */
3350 var indexOf = arr.indexOf;
3351 var class2type = {};
3352 /** @type {function(this:*): string} */
3353 var toString = class2type.toString;
3354 /** @type {function(this:Object, *): boolean} */
3355 var hasOwn = class2type.hasOwnProperty;
3356 /** @type {function(this:!Function): string} */
3357 var fnToString = hasOwn.toString;
3358 /** @type {string} */
3359 var OBJECT_ARRAY = fnToString.call(Object);
3360 var support = {};
3361 /**
3362 * @param {!Object} obj
3363 * @return {?}
3364 */
3365 var fn = function(obj) {
3366 return "function" == typeof obj && "number" != typeof obj.nodeType;
3367 };
3368 /**
3369 * @param {!Object} obj
3370 * @return {?}
3371 */
3372 var isWindow = function(obj) {
3373 return null != obj && obj === obj.window;
3374 };
3375 var document = window.document;
3376 var obj = {
3377 type : true,
3378 src : true,
3379 nonce : true,
3380 noModule : true
3381 };
3382 /**
3383 * @param {!Object} selector
3384 * @param {string} context
3385 * @return {?}
3386 */
3387 var jQuery = function(selector, context) {
3388 return new jQuery.fn.init(selector, context);
3389 };
3390 jQuery.fn = jQuery.prototype = {
3391 jquery : "3.5.1",
3392 constructor : jQuery,
3393 length : 0,
3394 toArray : function() {
3395 return slice.call(this);
3396 },
3397 get : function(s) {
3398 return null == s ? slice.call(this) : 0 > s ? this[s + this.length] : this[s];
3399 },
3400 pushStack : function(a) {
3401 return (a = jQuery.merge(this.constructor(), a)).prevObject = this, a;
3402 },
3403 each : function(callback) {
3404 return jQuery.each(this, callback);
3405 },
3406 map : function(fn) {
3407 return this.pushStack(jQuery.map(this, function(elem, event) {
3408 return fn.call(elem, event, elem);
3409 }));
3410 },
3411 slice : function() {
3412 return this.pushStack(slice.apply(this, arguments));
3413 },
3414 first : function() {
3415 return this.eq(0);
3416 },
3417 last : function() {
3418 return this.eq(-1);
3419 },
3420 even : function() {
3421 return this.pushStack(jQuery.grep(this, function(canCreateDiscussions, isSlidingUp) {
3422 return (isSlidingUp + 1) % 2;
3423 }));
3424 },
3425 odd : function() {
3426 return this.pushStack(jQuery.grep(this, function(canCreateDiscussions, isSlidingUp) {
3427 return isSlidingUp % 2;
3428 }));
3429 },
3430 eq : function(i) {
3431 var len = this.length;
3432 return i = +i + (0 > i ? len : 0), this.pushStack(0 <= i && i < len ? [this[i]] : []);
3433 },
3434 end : function() {
3435 return this.prevObject || this.constructor();
3436 },
3437 push : push,
3438 sort : arr.sort,
3439 splice : arr.splice
3440 };
3441 /** @type {function(): ?} */
3442 jQuery.extend = jQuery.fn.extend = function() {
3443 var options;
3444 var name;
3445 var copyIsArray;
3446 var target = arguments[0] || {};
3447 /** @type {number} */
3448 var i = 1;
3449 /** @type {number} */
3450 var length = arguments.length;
3451 /** @type {boolean} */
3452 var deep = false;
3453 if ("boolean" == typeof target) {
3454 /** @type {boolean} */
3455 deep = target;
3456 target = arguments[i] || {};
3457 i++;
3458 }
3459 if (!("object" == typeof target || fn(target))) {
3460 target = {};
3461 }
3462 if (i === length) {
3463 target = this;
3464 i--;
3465 }
3466 for (; i < length; i++) {
3467 if (null != (options = arguments[i])) {
3468 for (name in options) {
3469 var copy = options[name];
3470 if ("__proto__" !== name && target !== copy) {
3471 if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
3472 var value = target[name];
3473 value = copyIsArray && !Array.isArray(value) ? [] : copyIsArray || jQuery.isPlainObject(value) ? value : {};
3474 /** @type {boolean} */
3475 copyIsArray = false;
3476 target[name] = jQuery.extend(deep, value, copy);
3477 } else {
3478 if (void 0 !== copy) {
3479 target[name] = copy;
3480 }
3481 }
3482 }
3483 }
3484 }
3485 }
3486 return target;
3487 };
3488 jQuery.extend({
3489 expando : "jQuery" + ("3.5.1" + Math.random()).replace(/\D/g, ""),
3490 isReady : true,
3491 error : function(value) {
3492 throw Error(value);
3493 },
3494 noop : function() {
3495 },
3496 isPlainObject : function(obj) {
3497 return !(!obj || "[object Object]" !== toString.call(obj)) && (!(obj = getPrototypeOf(obj)) || "function" == typeof(obj = hasOwn.call(obj, "constructor") && obj.constructor) && fnToString.call(obj) === OBJECT_ARRAY);
3498 },
3499 isEmptyObject : function(obj) {
3500 var key;
3501 for (key in obj) {
3502 return false;
3503 }
3504 return true;
3505 },
3506 globalEval : function(url, code, data) {
3507 callback(url, {
3508 nonce : code && code.nonce
3509 }, data);
3510 },
3511 each : function(obj, fn) {
3512 var i;
3513 /** @type {number} */
3514 var n = 0;
3515 if (isArrayLike(obj)) {
3516 i = obj.length;
3517 for (; n < i && false !== fn.call(obj[n], n, obj[n]); n++) {
3518 }
3519 } else {
3520 for (n in obj) {
3521 if (false === fn.call(obj[n], n, obj[n])) {
3522 break;
3523 }
3524 }
3525 }
3526 return obj;
3527 },
3528 makeArray : function(arr, obj) {
3529 return obj = obj || [], null != arr && (isArrayLike(Object(arr)) ? jQuery.merge(obj, "string" == typeof arr ? [arr] : arr) : push.call(obj, arr)), obj;
3530 },
3531 inArray : function(elem, arr, i) {
3532 return null == arr ? -1 : indexOf.call(arr, elem, i);
3533 },
3534 merge : function(a, b) {
3535 /** @type {number} */
3536 var _jlen = +b.length;
3537 /** @type {number} */
3538 var k = 0;
3539 var l = a.length;
3540 for (; k < _jlen; k++) {
3541 a[l++] = b[k];
3542 }
3543 return a.length = l, a;
3544 },
3545 grep : function(elements, callback, a) {
3546 /** @type {!Array} */
3547 var ret = [];
3548 /** @type {number} */
3549 var i = 0;
3550 var eL = elements.length;
3551 /** @type {boolean} */
3552 var booA = !a;
3553 for (; i < eL; i++) {
3554 if ((a = !callback(elements[i], i)) !== booA) {
3555 ret.push(elements[i]);
3556 }
3557 }
3558 return ret;
3559 },
3560 map : function(obj, transform, id) {
3561 var result;
3562 /** @type {number} */
3563 var key = 0;
3564 /** @type {!Array} */
3565 var label = [];
3566 if (isArrayLike(obj)) {
3567 result = obj.length;
3568 for (; key < result; key++) {
3569 var value = transform(obj[key], key, id);
3570 if (null != value) {
3571 label.push(value);
3572 }
3573 }
3574 } else {
3575 for (key in obj) {
3576 if (null != (value = transform(obj[key], key, id))) {
3577 label.push(value);
3578 }
3579 }
3580 }
3581 return map(label);
3582 },
3583 guid : 1,
3584 support : support
3585 });
3586 $jscomp.initSymbol();
3587 if ("function" == typeof Symbol) {
3588 $jscomp.initSymbol();
3589 $jscomp.initSymbolIterator();
3590 $jscomp.initSymbol();
3591 $jscomp.initSymbolIterator();
3592 jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
3593 }
3594 jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(canCreateDiscussions, p_Interval) {
3595 class2type["[object " + p_Interval + "]"] = p_Interval.toLowerCase();
3596 });
3597 var Sizzle = function(window) {
3598 /**
3599 * @param {string} selector
3600 * @param {!Object} context
3601 * @param {!Array} results
3602 * @param {?} seed
3603 * @return {?}
3604 */
3605 function Sizzle(selector, context, results, seed) {
3606 var value;
3607 var elem;
3608 var nid;
3609 var match;
3610 var newContext = context && context.ownerDocument;
3611 var i = context ? context.nodeType : 9;
3612 if (results = results || [], "string" != typeof selector || !selector || 1 !== i && 9 !== i && 11 !== i) {
3613 return results;
3614 }
3615 if (!seed && (setDocument(context), context = context || doc, documentIsHTML)) {
3616 if (11 !== i && (match = customSelectorReg.exec(selector))) {
3617 if (value = match[1]) {
3618 if (9 === i) {
3619 if (!(elem = context.getElementById(value))) {
3620 return results;
3621 }
3622 if (elem.id === value) {
3623 return results.push(elem), results;
3624 }
3625 } else {
3626 if (newContext && (elem = newContext.getElementById(value)) && contains(context, elem) && elem.id === value) {
3627 return results.push(elem), results;
3628 }
3629 }
3630 } else {
3631 if (match[2]) {
3632 return push.apply(results, context.getElementsByTagName(selector)), results;
3633 }
3634 if ((value = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
3635 return push.apply(results, context.getElementsByClassName(value)), results;
3636 }
3637 }
3638 }
3639 if (!(!support.qsa || tokenCache[selector + " "] || args && args.test(selector) || 1 === i && "object" === context.nodeName.toLowerCase())) {
3640 if (value = selector, newContext = context, 1 === i && (IS_HTML_FRAGMENT.test(selector) || RE_HTMLTAG.test(selector))) {
3641 if (!((newContext = RE_PSEUDOS.test(selector) && testContext(context.parentNode) || context) === context && support.scope)) {
3642 if (nid = context.getAttribute("id")) {
3643 nid = nid.replace(rcssescape, fcssescape);
3644 } else {
3645 context.setAttribute("id", nid = expando);
3646 }
3647 }
3648 i = (value = tokenize(selector)).length;
3649 for (; i--;) {
3650 /** @type {string} */
3651 value[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(value[i]);
3652 }
3653 value = value.join(",");
3654 }
3655 try {
3656 return push.apply(results, newContext.querySelectorAll(value)), results;
3657 } catch (t) {
3658 tokenCache(selector, true);
3659 } finally {
3660 if (nid === expando) {
3661 context.removeAttribute("id");
3662 }
3663 }
3664 }
3665 }
3666 return select(selector.replace(rtrim, "$1"), context, results, seed);
3667 }
3668 /**
3669 * @return {?}
3670 */
3671 function createCache() {
3672 /** @type {!Array} */
3673 var messages = [];
3674 return function cache(attr, fn) {
3675 return messages.push(attr + " ") > Expr.cacheLength && delete cache[messages.shift()], cache[attr + " "] = fn;
3676 };
3677 }
3678 /**
3679 * @param {!Function} fn
3680 * @return {?}
3681 */
3682 function markFunction(fn) {
3683 return fn[expando] = true, fn;
3684 }
3685 /**
3686 * @param {!Function} expect
3687 * @return {?}
3688 */
3689 function assert(expect) {
3690 var wrap = doc.createElement("fieldset");
3691 try {
3692 return !!expect(wrap);
3693 } catch (e) {
3694 return false;
3695 } finally {
3696 if (wrap.parentNode) {
3697 wrap.parentNode.removeChild(wrap);
3698 }
3699 }
3700 }
3701 /**
3702 * @param {!Object} arr
3703 * @param {!Function} index
3704 * @return {undefined}
3705 */
3706 function addHandle(arr, index) {
3707 var i = (arr = arr.split("|")).length;
3708 for (; i--;) {
3709 /** @type {!Function} */
3710 Expr.attrHandle[arr[i]] = index;
3711 }
3712 }
3713 /**
3714 * @param {!Object} a
3715 * @param {!Object} b
3716 * @return {?}
3717 */
3718 function siblingCheck(a, b) {
3719 var cur = b && a;
3720 var .num_const = cur && 1 === a.nodeType && 1 === b.nodeType && a.sourceIndex - b.sourceIndex;
3721 if (.num_const) {
3722 return .num_const;
3723 }
3724 if (cur) {
3725 for (; cur = cur.nextSibling;) {
3726 if (cur === b) {
3727 return -1;
3728 }
3729 }
3730 }
3731 return a ? 1 : -1;
3732 }
3733 /**
3734 * @param {!Object} index
3735 * @return {?}
3736 */
3737 function s(index) {
3738 return function(t) {
3739 return "input" === t.nodeName.toLowerCase() && t.type === index;
3740 };
3741 }
3742 /**
3743 * @param {!Object} type
3744 * @return {?}
3745 */
3746 function createButtonPseudo(type) {
3747 return function(section) {
3748 var undefined = section.nodeName.toLowerCase();
3749 return ("input" === undefined || "button" === undefined) && section.type === type;
3750 };
3751 }
3752 /**
3753 * @param {boolean} disabled
3754 * @return {?}
3755 */
3756 function createDisabledPseudo(disabled) {
3757 return function(elem) {
3758 return "form" in elem ? elem.parentNode && false === elem.disabled ? "label" in elem ? "label" in elem.parentNode ? elem.parentNode.disabled === disabled : elem.disabled === disabled : elem.isDisabled === disabled || elem.isDisabled !== !disabled && disabledAncestor(elem) === disabled : elem.disabled === disabled : "label" in elem && elem.disabled === disabled;
3759 };
3760 }
3761 /**
3762 * @param {!Function} fn
3763 * @return {?}
3764 */
3765 function createPositionalPseudo(fn) {
3766 return markFunction(function(argument) {
3767 return argument = +argument, markFunction(function(s, attr) {
3768 var j;
3769 var matchIndexes = fn([], s.length, argument);
3770 var i = matchIndexes.length;
3771 for (; i--;) {
3772 if (s[j = matchIndexes[i]]) {
3773 /** @type {boolean} */
3774 s[j] = !(attr[j] = s[j]);
3775 }
3776 }
3777 });
3778 });
3779 }
3780 /**
3781 * @param {!Node} context
3782 * @return {?}
3783 */
3784 function testContext(context) {
3785 return context && void 0 !== context.getElementsByTagName && context;
3786 }
3787 /**
3788 * @return {undefined}
3789 */
3790 function setFilters() {
3791 }
3792 /**
3793 * @param {!Array} tokens
3794 * @return {?}
3795 */
3796 function toSelector(tokens) {
3797 /** @type {number} */
3798 var i = 0;
3799 var numTokens = tokens.length;
3800 /** @type {string} */
3801 var selector = "";
3802 for (; i < numTokens; i++) {
3803 /** @type {string} */
3804 selector = selector + tokens[i].value;
3805 }
3806 return selector;
3807 }
3808 /**
3809 * @param {!Function} matcher
3810 * @param {!Object} combinator
3811 * @param {string} base
3812 * @return {?}
3813 */
3814 function addCombinator(matcher, combinator, base) {
3815 var dir = combinator.dir;
3816 var skip = combinator.next;
3817 var key = skip || dir;
3818 var checkNonElements = base && "parentNode" === key;
3819 /** @type {number} */
3820 var doneName = done++;
3821 return combinator.first ? function(elem, stat, context) {
3822 for (; elem = elem[dir];) {
3823 if (1 === elem.nodeType || checkNonElements) {
3824 return matcher(elem, stat, context);
3825 }
3826 }
3827 return false;
3828 } : function(elem, context, xml) {
3829 var oldCache;
3830 /** @type {!Array} */
3831 var newCache = [dirruns, doneName];
3832 if (xml) {
3833 for (; elem = elem[dir];) {
3834 if ((1 === elem.nodeType || checkNonElements) && matcher(elem, context, xml)) {
3835 return true;
3836 }
3837 }
3838 } else {
3839 for (; elem = elem[dir];) {
3840 if (1 === elem.nodeType || checkNonElements) {
3841 var outerCache = elem[expando] || (elem[expando] = {});
3842 if (outerCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {}), skip && skip === elem.nodeName.toLowerCase()) {
3843 elem = elem[dir] || elem;
3844 } else {
3845 if ((oldCache = outerCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
3846 return newCache[2] = oldCache[2];
3847 }
3848 if (outerCache[key] = newCache, newCache[2] = matcher(elem, context, xml)) {
3849 return true;
3850 }
3851 }
3852 }
3853 }
3854 }
3855 return false;
3856 };
3857 }
3858 /**
3859 * @param {!Object} matchers
3860 * @return {?}
3861 */
3862 function elementMatcher(matchers) {
3863 return 1 < matchers.length ? function(elem, context, xml) {
3864 var i = matchers.length;
3865 for (; i--;) {
3866 if (!matchers[i](elem, context, xml)) {
3867 return false;
3868 }
3869 }
3870 return true;
3871 } : matchers[0];
3872 }
3873 /**
3874 * @param {!Array} s
3875 * @param {!Object} out
3876 * @param {!Object} o
3877 * @param {string} t
3878 * @param {!Object} data
3879 * @return {?}
3880 */
3881 function get(s, out, o, t, data) {
3882 var i;
3883 /** @type {!Array} */
3884 var args = [];
3885 /** @type {number} */
3886 var j = 0;
3887 var chans = s.length;
3888 /** @type {boolean} */
3889 var isFadingIn = null != out;
3890 for (; j < chans; j++) {
3891 if (i = s[j]) {
3892 if (!(o && !o(i, t, data))) {
3893 args.push(i);
3894 if (isFadingIn) {
3895 out.push(j);
3896 }
3897 }
3898 }
3899 }
3900 return args;
3901 }
3902 /**
3903 * @param {!Object} name
3904 * @param {!Object} n
3905 * @param {!Function} prop
3906 * @param {!Object} index
3907 * @param {!Object} fn
3908 * @param {!Object} _
3909 * @return {?}
3910 */
3911 function render(name, n, prop, index, fn, _) {
3912 return index && !index[expando] && (index = render(index)), fn && !fn[expando] && (fn = render(fn, _)), markFunction(function(o, object, value, options) {
3913 var val;
3914 var p;
3915 /** @type {!Array} */
3916 var obj = [];
3917 /** @type {!Array} */
3918 var res = [];
3919 var id = object.length;
3920 if (!(p = o)) {
3921 p = n || "*";
3922 var result = value.nodeType ? [value] : value;
3923 /** @type {!Array} */
3924 var tmpSet = [];
3925 /** @type {number} */
3926 var i = 0;
3927 var patchLen = result.length;
3928 for (; i < patchLen; i++) {
3929 Sizzle(p, result[i], tmpSet);
3930 }
3931 /** @type {!Array} */
3932 p = tmpSet;
3933 }
3934 if (p = !name || !o && n ? p : get(p, obj, name, value, options), result = prop ? fn || (o ? name : id || index) ? [] : object : p, prop && prop(p, result, value, options), index) {
3935 var key = get(result, res);
3936 index(key, [], value, options);
3937 value = key.length;
3938 for (; value--;) {
3939 if (val = key[value]) {
3940 /** @type {boolean} */
3941 result[res[value]] = !(p[res[value]] = val);
3942 }
3943 }
3944 }
3945 if (o) {
3946 if (fn || name) {
3947 if (fn) {
3948 /** @type {!Array} */
3949 key = [];
3950 value = result.length;
3951 for (; value--;) {
3952 if (val = result[value]) {
3953 key.push(p[value] = val);
3954 }
3955 }
3956 fn(null, result = [], key, options);
3957 }
3958 value = result.length;
3959 for (; value--;) {
3960 if ((val = result[value]) && -1 < (key = fn ? indexOf(o, val) : obj[value])) {
3961 /** @type {boolean} */
3962 o[key] = !(object[key] = val);
3963 }
3964 }
3965 }
3966 } else {
3967 result = get(result === object ? result.splice(id, result.length) : result);
3968 if (fn) {
3969 fn(null, object, result, options);
3970 } else {
3971 push.apply(object, result);
3972 }
3973 }
3974 });
3975 }
3976 /**
3977 * @param {!Array} tokens
3978 * @return {?}
3979 */
3980 function matcherFromTokens(tokens) {
3981 var checkContext;
3982 var j;
3983 var len = tokens.length;
3984 var leadingRelative = Expr.relative[tokens[0].type];
3985 var implicitRelative = leadingRelative || Expr.relative[" "];
3986 /** @type {number} */
3987 var i = leadingRelative ? 1 : 0;
3988 var matchContext = addCombinator(function(elem) {
3989 return elem === checkContext;
3990 }, implicitRelative, true);
3991 var matchAnyContext = addCombinator(function(value) {
3992 return -1 < indexOf(checkContext, value);
3993 }, implicitRelative, true);
3994 /** @type {!Array} */
3995 var matchers = [function(elem, context, xml) {
3996 return elem = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)), checkContext = null, elem;
3997 }];
3998 for (; i < len; i++) {
3999 if (implicitRelative = Expr.relative[tokens[i].type]) {
4000 /** @type {!Array} */
4001 matchers = [addCombinator(elementMatcher(matchers), implicitRelative)];
4002 } else {
4003 if ((implicitRelative = Expr.filter[tokens[i].type].apply(null, tokens[i].matches))[expando]) {
4004 /** @type {number} */
4005 j = ++i;
4006 for (; j < len && !Expr.relative[tokens[j].type]; j++) {
4007 }
4008 return render(1 < i && elementMatcher(matchers), 1 < i && toSelector(tokens.slice(0, i - 1).concat({
4009 value : " " === tokens[i - 2].type ? "*" : ""
4010 })).replace(rtrim, "$1"), implicitRelative, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
4011 }
4012 matchers.push(implicitRelative);
4013 }
4014 }
4015 return elementMatcher(matchers);
4016 }
4017 /**
4018 * @param {!Array} elementMatchers
4019 * @param {!Array} setMatchers
4020 * @return {?}
4021 */
4022 function matcherFromGroupMatchers(elementMatchers, setMatchers) {
4023 /** @type {boolean} */
4024 var bySet = 0 < setMatchers.length;
4025 /** @type {boolean} */
4026 var byElement = 0 < elementMatchers.length;
4027 /**
4028 * @param {!Function} seed
4029 * @param {!Object} context
4030 * @param {number} xml
4031 * @param {!Array} results
4032 * @param {!Object} outermost
4033 * @return {?}
4034 */
4035 var superMatcher = function(seed, context, xml, results, outermost) {
4036 var elem;
4037 var matcher;
4038 /** @type {number} */
4039 var matchedCount = 0;
4040 /** @type {string} */
4041 var i = "0";
4042 var unmatched = seed && [];
4043 /** @type {!Array} */
4044 var data = [];
4045 var contextBackup = outermostContext;
4046 var obj = seed || byElement && Expr.find.TAG("*", outermost);
4047 var dirrunsUnique = dirruns = dirruns + (null == contextBackup ? 1 : Math.random() || .1);
4048 var x = obj.length;
4049 if (outermost) {
4050 outermostContext = context == doc || context || outermost;
4051 }
4052 for (; i !== x && null != (elem = obj[i]); i++) {
4053 if (byElement && elem) {
4054 /** @type {number} */
4055 var j = 0;
4056 if (!(context || elem.ownerDocument == doc)) {
4057 setDocument(elem);
4058 /** @type {boolean} */
4059 xml = !documentIsHTML;
4060 }
4061 for (; matcher = elementMatchers[j++];) {
4062 if (matcher(elem, context || doc, xml)) {
4063 results.push(elem);
4064 break;
4065 }
4066 }
4067 if (outermost) {
4068 dirruns = dirrunsUnique;
4069 }
4070 }
4071 if (bySet) {
4072 if (elem = !matcher && elem) {
4073 matchedCount--;
4074 }
4075 if (seed) {
4076 unmatched.push(elem);
4077 }
4078 }
4079 }
4080 if (matchedCount = matchedCount + i, bySet && i !== matchedCount) {
4081 /** @type {number} */
4082 j = 0;
4083 for (; matcher = setMatchers[j++];) {
4084 matcher(unmatched, data, context, xml);
4085 }
4086 if (seed) {
4087 if (0 < matchedCount) {
4088 for (; i--;) {
4089 if (!(unmatched[i] || data[i])) {
4090 data[i] = pop.call(results);
4091 }
4092 }
4093 }
4094 data = get(data);
4095 }
4096 push.apply(results, data);
4097 if (outermost && !seed && 0 < data.length && 1 < matchedCount + setMatchers.length) {
4098 Sizzle.uniqueSort(results);
4099 }
4100 }
4101 return outermost && (dirruns = dirrunsUnique, outermostContext = contextBackup), unmatched;
4102 };
4103 return bySet ? markFunction(superMatcher) : superMatcher;
4104 }
4105 var i;
4106 var outermostContext;
4107 var sortInput;
4108 var stability;
4109 var doc;
4110 var element;
4111 var documentIsHTML;
4112 var args;
4113 var rbuggyQSA;
4114 var matches;
4115 var contains;
4116 /** @type {string} */
4117 var expando = "sizzle" + 1 * new Date;
4118 var document = window.document;
4119 /** @type {number} */
4120 var dirruns = 0;
4121 /** @type {number} */
4122 var done = 0;
4123 var classCache = createCache();
4124 var next = createCache();
4125 var compilerCache = createCache();
4126 var tokenCache = createCache();
4127 /**
4128 * @param {?} type
4129 * @param {?} code
4130 * @return {?}
4131 */
4132 var key = function(type, code) {
4133 return type === code && (stability = true), 0;
4134 };
4135 /** @type {function(this:Object, *): boolean} */
4136 var hasOwn = {}.hasOwnProperty;
4137 /** @type {!Array} */
4138 var arr = [];
4139 /** @type {function(this:IArrayLike<T>): T} */
4140 var pop = arr.pop;
4141 /** @type {function(this:IArrayLike<T>, ...T): number} */
4142 var push_native = arr.push;
4143 /** @type {function(this:IArrayLike<T>, ...T): number} */
4144 var push = arr.push;
4145 /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
4146 var slice = arr.slice;
4147 /**
4148 * @param {number} list
4149 * @param {!Object} value
4150 * @return {?}
4151 */
4152 var indexOf = function(list, value) {
4153 /** @type {number} */
4154 var i = 0;
4155 var listLength = list.length;
4156 for (; i < listLength; i++) {
4157 if (list[i] === value) {
4158 return i;
4159 }
4160 }
4161 return -1;
4162 };
4163 /** @type {!RegExp} */
4164 var REGEX_ESCAPE_EXPR = /[\x20\t\r\n\f]+/g;
4165 /** @type {!RegExp} */
4166 var rtrim = /^[\x20\t\r\n\f]+|((?:^|[^\\])(?:\\.)*)[\x20\t\r\n\f]+$/g;
4167 /** @type {!RegExp} */
4168 var lootRegex = /^[\x20\t\r\n\f]*,[\x20\t\r\n\f]*/;
4169 /** @type {!RegExp} */
4170 var RE_HTMLTAG = /^[\x20\t\r\n\f]*([>+~]|[\x20\t\r\n\f])[\x20\t\r\n\f]*/;
4171 /** @type {!RegExp} */
4172 var IS_HTML_FRAGMENT = /[\x20\t\r\n\f]|>/;
4173 /** @type {!RegExp} */
4174 var rpseudo = /:((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)(?:\((('((?:\\.|[^\\'])*)'|"((?:\\.|[^\\"])*)")|((?:\\.|[^\\()[\]]|\[[\x20\t\r\n\f]*((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)(?:[\x20\t\r\n\f]*([*^$|!~]?=)[\x20\t\r\n\f]*(?:'((?:\\.|[^\\'])*)'|"((?:\\.|[^\\"])*)"|((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+))|)[\x20\t\r\n\f]*\])*)|.*)\)|)/;
4175 /** @type {!RegExp} */
4176 var ridentifier = /^(?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+$/;
4177 var matchExpr = {
4178 ID : /^#((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)/,
4179 CLASS : /^\.((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)/,
4180 TAG : /^((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+|[*])/,
4181 ATTR : /^\[[\x20\t\r\n\f]*((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)(?:[\x20\t\r\n\f]*([*^$|!~]?=)[\x20\t\r\n\f]*(?:'((?:\\.|[^\\'])*)'|"((?:\\.|[^\\"])*)"|((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+))|)[\x20\t\r\n\f]*\]/,
4182 PSEUDO : /^:((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)(?:\((('((?:\\.|[^\\'])*)'|"((?:\\.|[^\\"])*)")|((?:\\.|[^\\()[\]]|\[[\x20\t\r\n\f]*((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+)(?:[\x20\t\r\n\f]*([*^$|!~]?=)[\x20\t\r\n\f]*(?:'((?:\\.|[^\\'])*)'|"((?:\\.|[^\\"])*)"|((?:\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\[^\r\n\f]|[\w-]|[^\x00-\x7f])+))|)[\x20\t\r\n\f]*\])*)|.*)\)|)/,
4183 CHILD : /^:(only|first|last|nth|nth-last)-(child|of-type)(?:\([\x20\t\r\n\f]*(even|odd|(([+-]|)(\d*)n|)[\x20\t\r\n\f]*(?:([+-]|)[\x20\t\r\n\f]*(\d+)|))[\x20\t\r\n\f]*\)|)/i,
4184 bool : /^(?:checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)$/i,
4185 needsContext : /^[\x20\t\r\n\f]*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\([\x20\t\r\n\f]*((?:-\d)?\d*)[\x20\t\r\n\f]*\)|)(?=[^-]|$)/i
4186 };
4187 /** @type {!RegExp} */
4188 var reKeyword = /HTML$/i;
4189 /** @type {!RegExp} */
4190 var inputNodeNames = /^(?:input|select|textarea|button)$/i;
4191 /** @type {!RegExp} */
4192 var rnoType = /^h\d$/i;
4193 /** @type {!RegExp} */
4194 var rnative = /^[^{]+\{\s*\[native \w/;
4195 /** @type {!RegExp} */
4196 var customSelectorReg = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/;
4197 /** @type {!RegExp} */
4198 var RE_PSEUDOS = /[+~]/;
4199 /** @type {!RegExp} */
4200 var x = /\\[\da-fA-F]{1,6}[\x20\t\r\n\f]?|\\([^\r\n\f])/g;
4201 /**
4202 * @param {number} i
4203 * @param {string} elem
4204 * @return {?}
4205 */
4206 var data = function(i, elem) {
4207 return i = "0x" + i.slice(1) - 65536, elem || (0 > i ? String.fromCharCode(i + 65536) : String.fromCharCode(i >> 10 | 55296, 1023 & i | 56320));
4208 };
4209 /** @type {!RegExp} */
4210 var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g;
4211 /**
4212 * @param {string} text
4213 * @param {string} ch
4214 * @return {?}
4215 */
4216 var fcssescape = function(text, ch) {
4217 return ch ? "\x00" === text ? "\ufffd" : text.slice(0, -1) + "\\" + text.charCodeAt(text.length - 1).toString(16) + " " : "\\" + text;
4218 };
4219 /**
4220 * @return {undefined}
4221 */
4222 var unloadHandler = function() {
4223 setDocument();
4224 };
4225 var disabledAncestor = addCombinator(function(e) {
4226 return true === e.disabled && "fieldset" === e.nodeName.toLowerCase();
4227 }, {
4228 dir : "parentNode",
4229 next : "legend"
4230 });
4231 try {
4232 push.apply(arr = slice.call(document.childNodes), document.childNodes);
4233 arr[document.childNodes.length].nodeType;
4234 } catch (e) {
4235 push = {
4236 apply : arr.length ? function(target, obj) {
4237 push_native.apply(target, slice.call(obj));
4238 } : function(obj, data) {
4239 var i = obj.length;
4240 /** @type {number} */
4241 var off = 0;
4242 for (; obj[i++] = data[off++];) {
4243 }
4244 /** @type {number} */
4245 obj.length = i - 1;
4246 }
4247 };
4248 }
4249 var support = Sizzle.support = {};
4250 /** @type {function(!Object): ?} */
4251 var isNative = Sizzle.isXML = function(elem) {
4252 var xmlNode = (elem.ownerDocument || elem).documentElement;
4253 return !reKeyword.test(elem.namespaceURI || xmlNode && xmlNode.nodeName || "HTML");
4254 };
4255 /** @type {function(!Object): ?} */
4256 var setDocument = Sizzle.setDocument = function(node) {
4257 var parent;
4258 return (node = node ? node.ownerDocument || node : document) != doc && 9 === node.nodeType && node.documentElement ? (element = (doc = node).documentElement, documentIsHTML = !isNative(doc), document != doc && (parent = doc.defaultView) && parent.top !== parent && (parent.addEventListener ? parent.addEventListener("unload", unloadHandler, false) : parent.attachEvent && parent.attachEvent("onunload", unloadHandler)), support.scope = assert(function(group) {
4259 return element.appendChild(group).appendChild(doc.createElement("div")), void 0 !== group.querySelectorAll && !group.querySelectorAll(":scope fieldset div").length;
4260 }), support.attributes = assert(function(elm) {
4261 return elm.className = "i", !elm.getAttribute("className");
4262 }), support.getElementsByTagName = assert(function(testee) {
4263 return testee.appendChild(doc.createComment("")), !testee.getElementsByTagName("*").length;
4264 }), support.getElementsByClassName = rnative.test(doc.getElementsByClassName), support.getById = assert(function(fields) {
4265 return element.appendChild(fields).id = expando, !doc.getElementsByName || !doc.getElementsByName(expando).length;
4266 }), support.getById ? (Expr.filter.ID = function(context) {
4267 var value = context.replace(x, data);
4268 return function(e) {
4269 return e.getAttribute("id") === value;
4270 };
4271 }, Expr.find.ID = function(node, context) {
4272 if (void 0 !== context.getElementById && documentIsHTML) {
4273 return (node = context.getElementById(node)) ? [node] : [];
4274 }
4275 }) : (Expr.filter.ID = function(context) {
4276 var v = context.replace(x, data);
4277 return function(tmp) {
4278 return (tmp = void 0 !== tmp.getAttributeNode && tmp.getAttributeNode("id")) && tmp.value === v;
4279 };
4280 }, Expr.find.ID = function(value, context) {
4281 if (void 0 !== context.getElementById && documentIsHTML) {
4282 var attr;
4283 var m = context.getElementById(value);
4284 if (m) {
4285 if ((attr = m.getAttributeNode("id")) && attr.value === value) {
4286 return [m];
4287 }
4288 var matches = context.getElementsByName(value);
4289 /** @type {number} */
4290 context = 0;
4291 for (; m = matches[context++];) {
4292 if ((attr = m.getAttributeNode("id")) && attr.value === value) {
4293 return [m];
4294 }
4295 }
4296 }
4297 return [];
4298 }
4299 }), Expr.find.TAG = support.getElementsByTagName ? function(v, t) {
4300 return void 0 !== t.getElementsByTagName ? t.getElementsByTagName(v) : support.qsa ? t.querySelectorAll(v) : void 0;
4301 } : function(t, results) {
4302 /** @type {!Array} */
4303 var tmp = [];
4304 /** @type {number} */
4305 var i = 0;
4306 if (results = results.getElementsByTagName(t), "*" === t) {
4307 for (; t = results[i++];) {
4308 if (1 === t.nodeType) {
4309 tmp.push(t);
4310 }
4311 }
4312 return tmp;
4313 }
4314 return results;
4315 }, Expr.find.CLASS = support.getElementsByClassName && function(e, docDom) {
4316 if (void 0 !== docDom.getElementsByClassName && documentIsHTML) {
4317 return docDom.getElementsByClassName(e);
4318 }
4319 }, rbuggyQSA = [], args = [], (support.qsa = rnative.test(doc.querySelectorAll)) && (assert(function(frag) {
4320 /** @type {string} */
4321 element.appendChild(frag).innerHTML = "<a id='" + expando + "'></a><select id='" + expando + "-\r\\' msallowcapture=''><option selected=''></option></select>";
4322 if (frag.querySelectorAll("[msallowcapture^='']").length) {
4323 args.push("[*^$]=[\\x20\\t\\r\\n\\f]*(?:''|\"\")");
4324 }
4325 if (!frag.querySelectorAll("[selected]").length) {
4326 args.push("\\[[\\x20\\t\\r\\n\\f]*(?:value|checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)");
4327 }
4328 if (!frag.querySelectorAll("[id~=" + expando + "-]").length) {
4329 args.push("~=");
4330 }
4331 var clone = doc.createElement("input");
4332 clone.setAttribute("name", "");
4333 frag.appendChild(clone);
4334 if (!frag.querySelectorAll("[name='']").length) {
4335 args.push("\\[[\\x20\\t\\r\\n\\f]*name[\\x20\\t\\r\\n\\f]*=[\\x20\\t\\r\\n\\f]*(?:''|\"\")");
4336 }
4337 if (!frag.querySelectorAll(":checked").length) {
4338 args.push(":checked");
4339 }
4340 if (!frag.querySelectorAll("a#" + expando + "+*").length) {
4341 args.push(".#.+[+~]");
4342 }
4343 frag.querySelectorAll("\\\f");
4344 args.push("[\\r\\n\\f]");
4345 }), assert(function(el) {
4346 /** @type {string} */
4347 el.innerHTML = "<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";
4348 var input = doc.createElement("input");
4349 input.setAttribute("type", "hidden");
4350 el.appendChild(input).setAttribute("name", "D");
4351 if (el.querySelectorAll("[name=d]").length) {
4352 args.push("name[\\x20\\t\\r\\n\\f]*[*^$|!~]?=");
4353 }
4354 if (2 !== el.querySelectorAll(":enabled").length) {
4355 args.push(":enabled", ":disabled");
4356 }
4357 /** @type {boolean} */
4358 element.appendChild(el).disabled = true;
4359 if (2 !== el.querySelectorAll(":disabled").length) {
4360 args.push(":enabled", ":disabled");
4361 }
4362 el.querySelectorAll("*,:x");
4363 args.push(",.*:");
4364 })), (support.matchesSelector = rnative.test(matches = element.matches || element.webkitMatchesSelector || element.mozMatchesSelector || element.oMatchesSelector || element.msMatchesSelector)) && assert(function(el) {
4365 support.disconnectedMatch = matches.call(el, "*");
4366 matches.call(el, "[s!='']:x");
4367 rbuggyQSA.push("!=", ":((?:\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\[^\\r\\n\\f]|[\\w-]|[^\x00-\\x7f])+)(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|\\[[\\x20\\t\\r\\n\\f]*((?:\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\[^\\r\\n\\f]|[\\w-]|[^\x00-\\x7f])+)(?:[\\x20\\t\\r\\n\\f]*([*^$|!~]?=)[\\x20\\t\\r\\n\\f]*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|((?:\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\[^\\r\\n\\f]|[\\w-]|[^\x00-\\x7f])+))|)[\\x20\\t\\r\\n\\f]*\\])*)|.*)\\)|)");
4368 }), args = args.length && new RegExp(args.join("|")), rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")), contains = (parent = rnative.test(element.compareDocumentPosition)) || rnative.test(element.contains) ? function(elem, b) {
4369 var a = 9 === elem.nodeType ? elem.documentElement : elem;
4370 return elem === (b = b && b.parentNode) || !(!b || 1 !== b.nodeType || !(a.contains ? a.contains(b) : elem.compareDocumentPosition && 16 & elem.compareDocumentPosition(b)));
4371 } : function(type, b) {
4372 if (b) {
4373 for (; b = b.parentNode;) {
4374 if (b === type) {
4375 return true;
4376 }
4377 }
4378 }
4379 return false;
4380 }, key = parent ? function(a, b) {
4381 if (a === b) {
4382 return stability = true, 0;
4383 }
4384 /** @type {number} */
4385 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
4386 return compare || (1 & (compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1) || !support.sortDetached && b.compareDocumentPosition(a) === compare ? a == doc || a.ownerDocument == document && contains(document, a) ? -1 : b == doc || b.ownerDocument == document && contains(document, b) ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0 : 4 & compare ? -1 : 1);
4387 } : function(a, b) {
4388 if (a === b) {
4389 return stability = true, 0;
4390 }
4391 /** @type {number} */
4392 var i = 0;
4393 var aup = a.parentNode;
4394 var bup = b.parentNode;
4395 /** @type {!Array} */
4396 var ap = [a];
4397 /** @type {!Array} */
4398 var bp = [b];
4399 if (!aup || !bup) {
4400 return a == doc ? -1 : b == doc ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
4401 }
4402 if (aup === bup) {
4403 return siblingCheck(a, b);
4404 }
4405 for (; a = a.parentNode;) {
4406 ap.unshift(a);
4407 }
4408 /** @type {!Object} */
4409 a = b;
4410 for (; a = a.parentNode;) {
4411 bp.unshift(a);
4412 }
4413 for (; ap[i] === bp[i];) {
4414 i++;
4415 }
4416 return i ? siblingCheck(ap[i], bp[i]) : ap[i] == document ? -1 : bp[i] == document ? 1 : 0;
4417 }, doc) : doc;
4418 };
4419 /**
4420 * @param {string} expr
4421 * @param {?} set
4422 * @return {?}
4423 */
4424 Sizzle.matches = function(expr, set) {
4425 return Sizzle(expr, null, null, set);
4426 };
4427 /**
4428 * @param {!Object} elem
4429 * @param {string} selector
4430 * @return {?}
4431 */
4432 Sizzle.matchesSelector = function(elem, selector) {
4433 if (setDocument(elem), !(!support.matchesSelector || !documentIsHTML || tokenCache[selector + " "] || rbuggyQSA && rbuggyQSA.test(selector) || args && args.test(selector))) {
4434 try {
4435 var ret = matches.call(elem, selector);
4436 if (ret || support.disconnectedMatch || elem.document && 11 !== elem.document.nodeType) {
4437 return ret;
4438 }
4439 } catch (e) {
4440 tokenCache(selector, true);
4441 }
4442 }
4443 return 0 < Sizzle(selector, doc, null, [elem]).length;
4444 };
4445 /**
4446 * @param {!Object} elem
4447 * @param {!Object} value
4448 * @return {?}
4449 */
4450 Sizzle.contains = function(elem, value) {
4451 return (elem.ownerDocument || elem) != doc && setDocument(elem), contains(elem, value);
4452 };
4453 /**
4454 * @param {!Object} elem
4455 * @param {!Object} name
4456 * @return {?}
4457 */
4458 Sizzle.attr = function(elem, name) {
4459 if ((elem.ownerDocument || elem) != doc) {
4460 setDocument(elem);
4461 }
4462 var fn = Expr.attrHandle[name.toLowerCase()];
4463 return void 0 !== (fn = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0) ? fn : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (fn = elem.getAttributeNode(name)) && fn.specified ? fn.value : null;
4464 };
4465 /**
4466 * @param {string} text
4467 * @return {?}
4468 */
4469 Sizzle.escape = function(text) {
4470 return (text + "").replace(rcssescape, fcssescape);
4471 };
4472 /**
4473 * @param {!Object} value
4474 * @return {?}
4475 */
4476 Sizzle.error = function(value) {
4477 throw Error("Syntax error, unrecognized expression: " + value);
4478 };
4479 /**
4480 * @param {!Array} results
4481 * @return {?}
4482 */
4483 Sizzle.uniqueSort = function(results) {
4484 var elem;
4485 /** @type {!Array} */
4486 var duplicates = [];
4487 /** @type {number} */
4488 var j = 0;
4489 /** @type {number} */
4490 var i = 0;
4491 if (stability = !support.detectDuplicates, sortInput = !support.sortStable && results.slice(0), results.sort(key), stability) {
4492 for (; elem = results[i++];) {
4493 if (elem === results[i]) {
4494 /** @type {number} */
4495 j = duplicates.push(i);
4496 }
4497 }
4498 for (; j--;) {
4499 results.splice(duplicates[j], 1);
4500 }
4501 }
4502 return sortInput = null, results;
4503 };
4504 /** @type {function(!Object): ?} */
4505 var text = Sizzle.getText = function(b) {
4506 /** @type {string} */
4507 var result = "";
4508 /** @type {number} */
4509 var bi = 0;
4510 var t = b.nodeType;
4511 if (t) {
4512 if (1 === t || 9 === t || 11 === t) {
4513 if ("string" == typeof b.textContent) {
4514 return b.textContent;
4515 }
4516 b = b.firstChild;
4517 for (; b; b = b.nextSibling) {
4518 /** @type {string} */
4519 result = result + text(b);
4520 }
4521 } else {
4522 if (3 === t || 4 === t) {
4523 return b.nodeValue;
4524 }
4525 }
4526 } else {
4527 for (; t = b[bi++];) {
4528 /** @type {string} */
4529 result = result + text(t);
4530 }
4531 }
4532 return result;
4533 };
4534 var Expr = Sizzle.selectors = {
4535 cacheLength : 50,
4536 createPseudo : markFunction,
4537 match : matchExpr,
4538 attrHandle : {},
4539 find : {},
4540 relative : {
4541 ">" : {
4542 dir : "parentNode",
4543 first : true
4544 },
4545 " " : {
4546 dir : "parentNode"
4547 },
4548 "+" : {
4549 dir : "previousSibling",
4550 first : true
4551 },
4552 "~" : {
4553 dir : "previousSibling"
4554 }
4555 },
4556 preFilter : {
4557 ATTR : function(result) {
4558 return result[1] = result[1].replace(x, data), result[3] = (result[3] || result[4] || result[5] || "").replace(x, data), "~=" === result[2] && (result[3] = " " + result[3] + " "), result.slice(0, 4);
4559 },
4560 CHILD : function(match) {
4561 return match[1] = match[1].toLowerCase(), "nth" === match[1].slice(0, 3) ? (match[3] || Sizzle.error(match[0]), match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * ("even" === match[3] || "odd" === match[3])), match[5] = +(match[7] + match[8] || "odd" === match[3])) : match[3] && Sizzle.error(match[0]), match;
4562 },
4563 PSEUDO : function(match) {
4564 var excess;
4565 var unquoted = !match[6] && match[2];
4566 return matchExpr.CHILD.test(match[0]) ? null : (match[3] ? match[2] = match[4] || match[5] || "" : unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length) && (match[0] = match[0].slice(0, excess), match[2] = unquoted.slice(0, excess)), match.slice(0, 3));
4567 }
4568 },
4569 filter : {
4570 TAG : function(context) {
4571 var nodeName = context.replace(x, data).toLowerCase();
4572 return "*" === context ? function() {
4573 return true;
4574 } : function(elem) {
4575 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
4576 };
4577 },
4578 CLASS : function(className) {
4579 var pattern = classCache[className + " "];
4580 return pattern || (pattern = new RegExp("(^|[\\x20\\t\\r\\n\\f])" + className + "([\\x20\\t\\r\\n\\f]|$)"), classCache(className, function(e) {
4581 return pattern.test("string" == typeof e.className && e.className || void 0 !== e.getAttribute && e.getAttribute("class") || "");
4582 }));
4583 },
4584 ATTR : function(name, operator, check) {
4585 return function(input) {
4586 return null == (input = Sizzle.attr(input, name)) ? "!=" === operator : !operator || (input = input + "", "=" === operator ? input === check : "!=" === operator ? input !== check : "^=" === operator ? check && 0 === input.indexOf(check) : "*=" === operator ? check && -1 < input.indexOf(check) : "$=" === operator ? check && input.slice(-check.length) === check : "~=" === operator ? -1 < (" " + input.replace(REGEX_ESCAPE_EXPR, " ") + " ").indexOf(check) : "|=" === operator && (input ===
4587 check || input.slice(0, check.length + 1) === check + "-"));
4588 };
4589 },
4590 CHILD : function(type, what, argument, first, last) {
4591 /** @type {boolean} */
4592 var simple = "nth" !== type.slice(0, 3);
4593 /** @type {boolean} */
4594 var forward = "last" !== type.slice(-4);
4595 /** @type {boolean} */
4596 var isStrict = "of-type" === what;
4597 return 1 === first && 0 === last ? function(tplDiv) {
4598 return !!tplDiv.parentNode;
4599 } : function(root, dir, wordEnd) {
4600 var node;
4601 var idx;
4602 /** @type {string} */
4603 dir = simple !== forward ? "nextSibling" : "previousSibling";
4604 var target = root.parentNode;
4605 var iteratedVal = isStrict && root.nodeName.toLowerCase();
4606 /** @type {boolean} */
4607 wordEnd = !wordEnd && !isStrict;
4608 /** @type {boolean} */
4609 var diff = false;
4610 if (target) {
4611 if (simple) {
4612 for (; dir;) {
4613 /** @type {!Node} */
4614 node = root;
4615 for (; node = node[dir];) {
4616 if (isStrict ? node.nodeName.toLowerCase() === iteratedVal : 1 === node.nodeType) {
4617 return false;
4618 }
4619 }
4620 /** @type {(boolean|string)} */
4621 var args = dir = "only" === type && !args && "nextSibling";
4622 }
4623 return true;
4624 }
4625 if (args = [forward ? target.firstChild : target.lastChild], forward && wordEnd) {
4626 var outerCache = (node = target)[expando] || (node[expando] = {});
4627 diff = (idx = (diff = (outerCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {}))[type] || [])[0] === dirruns && diff[1]) && diff[2];
4628 node = idx && target.childNodes[idx];
4629 for (; node = ++idx && node && node[dir] || (diff = idx = 0) || args.pop();) {
4630 if (1 === node.nodeType && ++diff && node === root) {
4631 /** @type {!Array} */
4632 outerCache[type] = [dirruns, idx, diff];
4633 break;
4634 }
4635 }
4636 } else {
4637 if (wordEnd && (diff = idx = (diff = (outerCache = (outerCache = (node = root)[expando] || (node[expando] = {}))[node.uniqueID] || (outerCache[node.uniqueID] = {}))[type] || [])[0] === dirruns && diff[1]), false === diff) {
4638 for (; (node = ++idx && node && node[dir] || (diff = idx = 0) || args.pop()) && ((isStrict ? node.nodeName.toLowerCase() !== iteratedVal : 1 !== node.nodeType) || !++diff || (wordEnd && ((outerCache = (outerCache = node[expando] || (node[expando] = {}))[node.uniqueID] || (outerCache[node.uniqueID] = {}))[type] = [dirruns, diff]), node !== root));) {
4639 }
4640 }
4641 }
4642 return (diff = diff - last) === first || 0 == diff % first && 0 <= diff / first;
4643 }
4644 };
4645 },
4646 PSEUDO : function(pseudo, argument) {
4647 var fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
4648 if (fn[expando]) {
4649 return fn(argument);
4650 }
4651 if (1 < fn.length) {
4652 /** @type {!Array} */
4653 var ret = [pseudo, pseudo, "", argument];
4654 return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, result) {
4655 var j;
4656 var matched = fn(seed, argument);
4657 var i = matched.length;
4658 for (; i--;) {
4659 /** @type {boolean} */
4660 seed[j = indexOf(seed, matched[i])] = !(result[j] = matched[i]);
4661 }
4662 }) : function(responce) {
4663 return fn(responce, 0, ret);
4664 };
4665 }
4666 return fn;
4667 }
4668 },
4669 pseudos : {
4670 not : markFunction(function(selector) {
4671 /** @type {!Array} */
4672 var a = [];
4673 /** @type {!Array} */
4674 var results = [];
4675 var matcher = compile(selector.replace(rtrim, "$1"));
4676 return matcher[expando] ? markFunction(function(value, i, n, match) {
4677 match = matcher(value, null, match, []);
4678 var s = value.length;
4679 for (; s--;) {
4680 if (n = match[s]) {
4681 /** @type {boolean} */
4682 value[s] = !(i[s] = n);
4683 }
4684 }
4685 }) : function(sNewObjName, isSlidingUp, context) {
4686 return a[0] = sNewObjName, matcher(a, null, context, results), a[0] = null, !results.pop();
4687 };
4688 }),
4689 has : markFunction(function(selector) {
4690 return function(elem) {
4691 return 0 < Sizzle(selector, elem).length;
4692 };
4693 }),
4694 contains : markFunction(function(target) {
4695 return target = target.replace(x, data), function(t) {
4696 return -1 < (t.textContent || text(t)).indexOf(target);
4697 };
4698 }),
4699 lang : markFunction(function(lang) {
4700 return ridentifier.test(lang || "") || Sizzle.error("unsupported lang: " + lang), lang = lang.replace(x, data).toLowerCase(), function(elem) {
4701 var elemLang;
4702 do {
4703 if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
4704 return (elemLang = elemLang.toLowerCase()) === lang || 0 === elemLang.indexOf(lang + "-");
4705 }
4706 } while ((elem = elem.parentNode) && 1 === elem.nodeType);
4707 return false;
4708 };
4709 }),
4710 target : function(value) {
4711 var charListNotLatin = window.location && window.location.hash;
4712 return charListNotLatin && charListNotLatin.slice(1) === value.id;
4713 },
4714 root : function(result) {
4715 return result === element;
4716 },
4717 focus : function(elem) {
4718 return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
4719 },
4720 enabled : createDisabledPseudo(false),
4721 disabled : createDisabledPseudo(true),
4722 checked : function(value) {
4723 var custom = value.nodeName.toLowerCase();
4724 return "input" === custom && !!value.checked || "option" === custom && !!value.selected;
4725 },
4726 selected : function(elem) {
4727 return elem.parentNode && elem.parentNode.selectedIndex, true === elem.selected;
4728 },
4729 empty : function(elem) {
4730 elem = elem.firstChild;
4731 for (; elem; elem = elem.nextSibling) {
4732 if (6 > elem.nodeType) {
4733 return false;
4734 }
4735 }
4736 return true;
4737 },
4738 parent : function(elem) {
4739 return !Expr.pseudos.empty(elem);
4740 },
4741 header : function(elem) {
4742 return rnoType.test(elem.nodeName);
4743 },
4744 input : function(target) {
4745 return inputNodeNames.test(target.nodeName);
4746 },
4747 button : function(value) {
4748 var left = value.nodeName.toLowerCase();
4749 return "input" === left && "button" === value.type || "button" === left;
4750 },
4751 text : function(value) {
4752 var EXT;
4753 return "input" === value.nodeName.toLowerCase() && "text" === value.type && (null == (EXT = value.getAttribute("type")) || "text" === EXT.toLowerCase());
4754 },
4755 first : createPositionalPseudo(function() {
4756 return [0];
4757 }),
4758 last : createPositionalPseudo(function(canCreateDiscussions, isSlidingUp) {
4759 return [isSlidingUp - 1];
4760 }),
4761 eq : createPositionalPseudo(function(canCreateDiscussions, dt, max) {
4762 return [0 > max ? max + dt : max];
4763 }),
4764 even : createPositionalPseudo(function(lastshuffle, inclusiveMin) {
4765 /** @type {number} */
4766 var value = 0;
4767 for (; value < inclusiveMin; value = value + 2) {
4768 lastshuffle.push(value);
4769 }
4770 return lastshuffle;
4771 }),
4772 odd : createPositionalPseudo(function(lastshuffle, inclusiveMin) {
4773 /** @type {number} */
4774 var value = 1;
4775 for (; value < inclusiveMin; value = value + 2) {
4776 lastshuffle.push(value);
4777 }
4778 return lastshuffle;
4779 }),
4780 lt : createPositionalPseudo(function(centroids, min, max) {
4781 min = 0 > max ? max + min : max > min ? min : max;
4782 for (; 0 <= --min;) {
4783 centroids.push(min);
4784 }
4785 return centroids;
4786 }),
4787 gt : createPositionalPseudo(function(lightInstances, length, index) {
4788 index = 0 > index ? index + length : index;
4789 for (; ++index < length;) {
4790 lightInstances.push(index);
4791 }
4792 return lightInstances;
4793 })
4794 }
4795 };
4796 for (i in Expr.pseudos.nth = Expr.pseudos.eq, {
4797 radio : true,
4798 checkbox : true,
4799 file : true,
4800 password : true,
4801 image : true
4802 }) {
4803 Expr.pseudos[i] = s(i);
4804 }
4805 for (i in{
4806 submit : true,
4807 reset : true
4808 }) {
4809 Expr.pseudos[i] = createButtonPseudo(i);
4810 }
4811 setFilters.prototype = Expr.filters = Expr.pseudos;
4812 Expr.setFilters = new setFilters;
4813 /** @type {function(!Object, number): ?} */
4814 var tokenize = Sizzle.tokenize = function(name, body) {
4815 var match;
4816 var tokens;
4817 var type;
4818 var path;
4819 var preFilters;
4820 if (path = next[name + " "]) {
4821 return body ? 0 : path.slice(0);
4822 }
4823 /** @type {!Object} */
4824 path = name;
4825 /** @type {!Array} */
4826 var groups = [];
4827 preFilters = Expr.preFilter;
4828 for (; path;) {
4829 if (!(branch && !(match = lootRegex.exec(path)))) {
4830 if (match) {
4831 path = path.slice(match[0].length) || path;
4832 }
4833 groups.push(tokens = []);
4834 }
4835 /** @type {boolean} */
4836 var branch = false;
4837 for (type in(match = RE_HTMLTAG.exec(path)) && (branch = match.shift(), tokens.push({
4838 value : branch,
4839 type : match[0].replace(rtrim, " ")
4840 }), path = path.slice(branch.length)), Expr.filter) {
4841 if (!(!(match = matchExpr[type].exec(path)) || preFilters[type] && !(match = preFilters[type](match)))) {
4842 branch = match.shift();
4843 tokens.push({
4844 value : branch,
4845 type : type,
4846 matches : match
4847 });
4848 path = path.slice(branch.length);
4849 }
4850 }
4851 if (!branch) {
4852 break;
4853 }
4854 }
4855 return body ? path.length : path ? Sizzle.error(name) : next(name, groups).slice(0);
4856 };
4857 /** @type {function(string, !Array): ?} */
4858 var compile = Sizzle.compile = function(selector, match) {
4859 var i;
4860 /** @type {!Array} */
4861 var setMatchers = [];
4862 /** @type {!Array} */
4863 var elementMatchers = [];
4864 var cached = compilerCache[selector + " "];
4865 if (!cached) {
4866 if (!match) {
4867 match = tokenize(selector);
4868 }
4869 i = match.length;
4870 for (; i--;) {
4871 if ((cached = matcherFromTokens(match[i]))[expando]) {
4872 setMatchers.push(cached);
4873 } else {
4874 elementMatchers.push(cached);
4875 }
4876 }
4877 /** @type {string} */
4878 (cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers))).selector = selector;
4879 }
4880 return cached;
4881 };
4882 /** @type {function(string, !Object, !Array, !Object): ?} */
4883 var select = Sizzle.select = function(selector, context, result, value) {
4884 var i;
4885 var token;
4886 var type;
4887 /** @type {(!Function|boolean)} */
4888 var compiled = "function" == typeof selector && selector;
4889 var match = !value && tokenize(selector = compiled.selector || selector);
4890 if (result = result || [], 1 === match.length) {
4891 var tokens = match[0] = match[0].slice(0);
4892 if (2 < tokens.length && "ID" === (token = tokens[0]).type && 9 === context.nodeType && documentIsHTML && Expr.relative[tokens[1].type]) {
4893 if (!(context = (Expr.find.ID(token.matches[0].replace(x, data), context) || [])[0])) {
4894 return result;
4895 }
4896 if (compiled) {
4897 context = context.parentNode;
4898 }
4899 selector = selector.slice(tokens.shift().value.length);
4900 }
4901 i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
4902 for (; i-- && (token = tokens[i], !Expr.relative[type = token.type]);) {
4903 if ((type = Expr.find[type]) && (value = type(token.matches[0].replace(x, data), RE_PSEUDOS.test(tokens[0].type) && testContext(context.parentNode) || context))) {
4904 if (tokens.splice(i, 1), !(selector = value.length && toSelector(tokens))) {
4905 return push.apply(result, value), result;
4906 }
4907 break;
4908 }
4909 }
4910 }
4911 return (compiled || compile(selector, match))(value, context, !documentIsHTML, result, !context || RE_PSEUDOS.test(selector) && testContext(context.parentNode) || context), result;
4912 };
4913 return support.sortStable = expando.split("").sort(key).join("") === expando, support.detectDuplicates = !!stability, setDocument(), support.sortDetached = assert(function(html) {
4914 return 1 & html.compareDocumentPosition(doc.createElement("fieldset"));
4915 }), assert(function(aItem) {
4916 return aItem.innerHTML = "<a href='#'></a>", "#" === aItem.firstChild.getAttribute("href");
4917 }) || addHandle("type|href|height|width", function(e, t, n) {
4918 if (!n) {
4919 return e.getAttribute(t, "type" === t.toLowerCase() ? 1 : 2);
4920 }
4921 }), support.attributes && assert(function(aItem) {
4922 return aItem.innerHTML = "<input/>", aItem.firstChild.setAttribute("value", ""), "" === aItem.firstChild.getAttribute("value");
4923 }) || addHandle("value", function(src, canCreateDiscussions, n) {
4924 if (!n && "input" === src.nodeName.toLowerCase()) {
4925 return src.defaultValue;
4926 }
4927 }), assert(function(e) {
4928 return null == e.getAttribute("disabled");
4929 }) || addHandle("checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", function(elem, name, n) {
4930 var val;
4931 if (!n) {
4932 return true === elem[name] ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
4933 }
4934 }), Sizzle;
4935 }(window);
4936 jQuery.find = Sizzle;
4937 jQuery.expr = Sizzle.selectors;
4938 jQuery.expr[":"] = jQuery.expr.pseudos;
4939 jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
4940 jQuery.text = Sizzle.getText;
4941 jQuery.isXMLDoc = Sizzle.isXML;
4942 jQuery.contains = Sizzle.contains;
4943 jQuery.escapeSelector = Sizzle.escape;
4944 /**
4945 * @param {!Object} elem
4946 * @param {string} dir
4947 * @param {?} until
4948 * @return {?}
4949 */
4950 var dir = function(elem, dir, until) {
4951 /** @type {!Array} */
4952 var matched = [];
4953 /** @type {boolean} */
4954 var truncate = void 0 !== until;
4955 for (; (elem = elem[dir]) && 9 !== elem.nodeType;) {
4956 if (1 === elem.nodeType) {
4957 if (truncate && jQuery(elem).is(until)) {
4958 break;
4959 }
4960 matched.push(elem);
4961 }
4962 }
4963 return matched;
4964 };
4965 /**
4966 * @param {!Object} node
4967 * @param {!Object} elem
4968 * @return {?}
4969 */
4970 var _sibling = function(node, elem) {
4971 /** @type {!Array} */
4972 var result = [];
4973 for (; node; node = node.nextSibling) {
4974 if (1 === node.nodeType && node !== elem) {
4975 result.push(node);
4976 }
4977 }
4978 return result;
4979 };
4980 var rneedsContext = jQuery.expr.match.needsContext;
4981 /** @type {!RegExp} */
4982 var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;
4983 /**
4984 * @param {!Function} expr
4985 * @param {!Object} elems
4986 * @param {string} not
4987 * @return {?}
4988 */
4989 jQuery.filter = function(expr, elems, not) {
4990 var elem = elems[0];
4991 return not && (expr = ":not(" + expr + ")"), 1 === elems.length && 1 === elem.nodeType ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function(nodeToInspect) {
4992 return 1 === nodeToInspect.nodeType;
4993 }));
4994 };
4995 jQuery.fn.extend({
4996 find : function(elem) {
4997 var i;
4998 var l = this.length;
4999 var self = this;
5000 if ("string" != typeof elem) {
5001 return this.pushStack(jQuery(elem).filter(function() {
5002 /** @type {number} */
5003 i = 0;
5004 for (; i < l; i++) {
5005 if (jQuery.contains(self[i], this)) {
5006 return true;
5007 }
5008 }
5009 }));
5010 }
5011 var ret = this.pushStack([]);
5012 /** @type {number} */
5013 i = 0;
5014 for (; i < l; i++) {
5015 jQuery.find(elem, self[i], ret);
5016 }
5017 return 1 < l ? jQuery.uniqueSort(ret) : ret;
5018 },
5019 filter : function(name) {
5020 return this.pushStack(filter(this, name || [], false));
5021 },
5022 not : function(args) {
5023 return this.pushStack(filter(this, args || [], true));
5024 },
5025 is : function(arg) {
5026 return !!filter(this, "string" == typeof arg && rneedsContext.test(arg) ? jQuery(arg) : arg || [], false).length;
5027 }
5028 });
5029 /** @type {!RegExp} */
5030 var moveRegex = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;
5031 (jQuery.fn.init = function(value, context, root) {
5032 if (!value) {
5033 return this;
5034 }
5035 if (root = root || doc, "string" == typeof value) {
5036 /** @type {(Array<string>|null)} */
5037 var match = "<" === value[0] && ">" === value[value.length - 1] && 3 <= value.length ? [null, value, null] : moveRegex.exec(value);
5038 if (!match || !match[1] && context) {
5039 return !context || context.jquery ? (context || root).find(value) : this.constructor(context).find(value);
5040 }
5041 if (match[1]) {
5042 if (context = context instanceof jQuery ? context[0] : context, jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)), rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
5043 for (match in context) {
5044 if (fn(this[match])) {
5045 this[match](context[match]);
5046 } else {
5047 this.attr(match, context[match]);
5048 }
5049 }
5050 }
5051 } else {
5052 if (value = document.getElementById(match[2])) {
5053 /** @type {!Object} */
5054 this[0] = value;
5055 /** @type {number} */
5056 this.length = 1;
5057 }
5058 }
5059 return this;
5060 }
5061 return value.nodeType ? (this[0] = value, this.length = 1, this) : fn(value) ? void 0 !== root.ready ? root.ready(value) : value(jQuery) : jQuery.makeArray(value, this);
5062 }).prototype = jQuery.fn;
5063 var doc = jQuery(document);
5064 /** @type {!RegExp} */
5065 var st = /^(?:parents|prev(?:Until|All))/;
5066 var guaranteedUnique = {
5067 children : true,
5068 contents : true,
5069 next : true,
5070 prev : true
5071 };
5072 jQuery.fn.extend({
5073 has : function(name) {
5074 var targets = jQuery(name, this);
5075 var l = targets.length;
5076 return this.filter(function() {
5077 /** @type {number} */
5078 var i = 0;
5079 for (; i < l; i++) {
5080 if (jQuery.contains(this, targets[i])) {
5081 return true;
5082 }
5083 }
5084 });
5085 },
5086 closest : function(selector, context) {
5087 var cur;
5088 /** @type {number} */
5089 var i = 0;
5090 var l = this.length;
5091 /** @type {!Array} */
5092 var ret = [];
5093 var pos = "string" != typeof selector && jQuery(selector);
5094 if (!rneedsContext.test(selector)) {
5095 for (; i < l; i++) {
5096 cur = this[i];
5097 for (; cur && cur !== context; cur = cur.parentNode) {
5098 if (11 > cur.nodeType && (pos ? -1 < pos.index(cur) : 1 === cur.nodeType && jQuery.find.matchesSelector(cur, selector))) {
5099 ret.push(cur);
5100 break;
5101 }
5102 }
5103 }
5104 }
5105 return this.pushStack(1 < ret.length ? jQuery.uniqueSort(ret) : ret);
5106 },
5107 index : function(elem) {
5108 return elem ? "string" == typeof elem ? indexOf.call(jQuery(elem), this[0]) : indexOf.call(this, elem.jquery ? elem[0] : elem) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
5109 },
5110 add : function(name, context) {
5111 return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(name, context))));
5112 },
5113 addBack : function(selector) {
5114 return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
5115 }
5116 });
5117 jQuery.each({
5118 parent : function(elem) {
5119 return (elem = elem.parentNode) && 11 !== elem.nodeType ? elem : null;
5120 },
5121 parents : function(elem) {
5122 return dir(elem, "parentNode");
5123 },
5124 parentsUntil : function(elem, i, until) {
5125 return dir(elem, "parentNode", until);
5126 },
5127 next : function(elem) {
5128 return sibling(elem, "nextSibling");
5129 },
5130 prev : function(elem) {
5131 return sibling(elem, "previousSibling");
5132 },
5133 nextAll : function(elem) {
5134 return dir(elem, "nextSibling");
5135 },
5136 prevAll : function(elem) {
5137 return dir(elem, "previousSibling");
5138 },
5139 nextUntil : function(elem, i, until) {
5140 return dir(elem, "nextSibling", until);
5141 },
5142 prevUntil : function(elem, i, until) {
5143 return dir(elem, "previousSibling", until);
5144 },
5145 siblings : function(elem) {
5146 return _sibling((elem.parentNode || {}).firstChild, elem);
5147 },
5148 children : function(elem) {
5149 return _sibling(elem.firstChild);
5150 },
5151 contents : function(data) {
5152 return null != data.contentDocument && getPrototypeOf(data.contentDocument) ? data.contentDocument : ($(data, "template") && (data = data.content || data), jQuery.merge([], data.childNodes));
5153 }
5154 }, function(name, t) {
5155 /**
5156 * @param {!Function} value
5157 * @param {!Function} string
5158 * @return {?}
5159 */
5160 jQuery.fn[name] = function(value, string) {
5161 var ret = jQuery.map(this, t, value);
5162 return "Until" !== name.slice(-5) && (string = value), string && "string" == typeof string && (ret = jQuery.filter(string, ret)), 1 < this.length && (guaranteedUnique[name] || jQuery.uniqueSort(ret), st.test(name) && ret.reverse()), this.pushStack(ret);
5163 };
5164 });
5165 /** @type {!RegExp} */
5166 var re = /[^\x20\t\r\n\f]+/g;
5167 /**
5168 * @param {string} options
5169 * @return {?}
5170 */
5171 jQuery.Callbacks = function(options) {
5172 options = "string" == typeof options ? function(b) {
5173 var subwikiListsCache = {};
5174 return jQuery.each(b.match(re) || [], function(canCreateDiscussions, wikiId) {
5175 /** @type {boolean} */
5176 subwikiListsCache[wikiId] = true;
5177 }), subwikiListsCache;
5178 }(options) : jQuery.extend({}, options);
5179 var e;
5180 var t;
5181 var evOrig;
5182 var geomColumnName;
5183 /** @type {!Array} */
5184 var data = [];
5185 /** @type {!Array} */
5186 var s = [];
5187 /** @type {number} */
5188 var i = -1;
5189 /**
5190 * @return {undefined}
5191 */
5192 var fire = function() {
5193 geomColumnName = geomColumnName || options.once;
5194 /** @type {boolean} */
5195 evOrig = e = true;
5196 for (; s.length; i = -1) {
5197 t = s.shift();
5198 for (; ++i < data.length;) {
5199 if (false === data[i].apply(t[0], t[1]) && options.stopOnFalse) {
5200 i = data.length;
5201 /** @type {boolean} */
5202 t = false;
5203 }
5204 }
5205 }
5206 if (!options.memory) {
5207 /** @type {boolean} */
5208 t = false;
5209 }
5210 /** @type {boolean} */
5211 e = false;
5212 if (geomColumnName) {
5213 /** @type {(Array|string)} */
5214 data = t ? [] : "";
5215 }
5216 };
5217 var self = {
5218 add : function() {
5219 return data && (t && !e && (i = data.length - 1, s.push(t)), function add(callback) {
5220 jQuery.each(callback, function(n, name) {
5221 if (fn(name)) {
5222 if (!(options.unique && self.has(name))) {
5223 data.push(name);
5224 }
5225 } else {
5226 if (name && name.length && "string" !== type(name)) {
5227 add(name);
5228 }
5229 }
5230 });
5231 }(arguments), t && !e && fire()), this;
5232 },
5233 remove : function() {
5234 return jQuery.each(arguments, function(canCreateDiscussions, t) {
5235 var index;
5236 for (; -1 < (index = jQuery.inArray(t, data, index));) {
5237 data.splice(index, 1);
5238 if (index <= i) {
5239 i--;
5240 }
5241 }
5242 }), this;
5243 },
5244 has : function(elem) {
5245 return elem ? -1 < jQuery.inArray(elem, data) : 0 < data.length;
5246 },
5247 empty : function() {
5248 return data && (data = []), this;
5249 },
5250 disable : function() {
5251 return geomColumnName = s = [], data = t = "", this;
5252 },
5253 disabled : function() {
5254 return !data;
5255 },
5256 lock : function() {
5257 return geomColumnName = s = [], t || e || (data = t = ""), this;
5258 },
5259 locked : function() {
5260 return !!geomColumnName;
5261 },
5262 fireWith : function(context, args) {
5263 return geomColumnName || (args = [context, (args = args || []).slice ? args.slice() : args], s.push(args), e || fire()), this;
5264 },
5265 fire : function() {
5266 return self.fireWith(this, arguments), this;
5267 },
5268 fired : function() {
5269 return !!evOrig;
5270 }
5271 };
5272 return self;
5273 };
5274 jQuery.extend({
5275 Deferred : function(func) {
5276 /** @type {!Array} */
5277 var dest = [["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]];
5278 /** @type {string} */
5279 var state = "pending";
5280 var promise = {
5281 state : function() {
5282 return state;
5283 },
5284 always : function() {
5285 return deferred.done(arguments).fail(arguments), this;
5286 },
5287 catch : function(fn) {
5288 return promise.then(null, fn);
5289 },
5290 pipe : function() {
5291 /** @type {!Arguments} */
5292 var result = arguments;
5293 return jQuery.Deferred(function(newDefer) {
5294 jQuery.each(dest, function(n, tuple) {
5295 var callback = fn(result[tuple[4]]) && result[tuple[4]];
5296 deferred[tuple[1]](function() {
5297 var promise = callback && callback.apply(this, arguments);
5298 if (promise && fn(promise.promise)) {
5299 promise.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
5300 } else {
5301 newDefer[tuple[0] + "With"](this, callback ? [promise] : arguments);
5302 }
5303 });
5304 });
5305 /** @type {null} */
5306 result = null;
5307 }).promise();
5308 },
5309 then : function(obj, value, item) {
5310 /**
5311 * @param {number} i
5312 * @param {!Object} options
5313 * @param {!Function} item
5314 * @param {boolean} args
5315 * @return {?}
5316 */
5317 function callback(i, options, item, args) {
5318 return function() {
5319 var that = this;
5320 /** @type {!Arguments} */
5321 var values = arguments;
5322 /**
5323 * @return {undefined}
5324 */
5325 var apply = function() {
5326 if (!(i < id)) {
5327 var value = item.apply(that, values);
5328 if (value === options.promise()) {
5329 throw new TypeError("Thenable self-resolution");
5330 }
5331 var self = value && ("object" == typeof value || "function" == typeof value) && value.then;
5332 if (fn(self)) {
5333 if (args) {
5334 self.call(value, callback(id, options, i, args), callback(id, options, undefined, args));
5335 } else {
5336 id++;
5337 self.call(value, callback(id, options, i, args), callback(id, options, undefined, args), callback(id, options, i, options.notifyWith));
5338 }
5339 } else {
5340 if (item !== i) {
5341 that = void 0;
5342 /** @type {!Array} */
5343 values = [value];
5344 }
5345 (args || options.resolveWith)(that, values);
5346 }
5347 }
5348 };
5349 /** @type {function(): undefined} */
5350 var method = args ? apply : function() {
5351 try {
5352 apply();
5353 } catch (scheduled) {
5354 if (jQuery.Deferred.exceptionHook) {
5355 jQuery.Deferred.exceptionHook(scheduled, method.stackTrace);
5356 }
5357 if (i + 1 >= id) {
5358 if (item !== undefined) {
5359 that = void 0;
5360 /** @type {!Array} */
5361 values = [scheduled];
5362 }
5363 options.rejectWith(that, values);
5364 }
5365 }
5366 };
5367 if (i) {
5368 method();
5369 } else {
5370 if (jQuery.Deferred.getStackHook) {
5371 method.stackTrace = jQuery.Deferred.getStackHook();
5372 }
5373 window.setTimeout(method);
5374 }
5375 };
5376 }
5377 /** @type {number} */
5378 var id = 0;
5379 return jQuery.Deferred(function(self) {
5380 dest[0][3].add(callback(0, self, fn(item) ? item : i, self.notifyWith));
5381 dest[1][3].add(callback(0, self, fn(obj) ? obj : i));
5382 dest[2][3].add(callback(0, self, fn(value) ? value : undefined));
5383 }).promise();
5384 },
5385 promise : function(value) {
5386 return null != value ? jQuery.extend(value, promise) : promise;
5387 }
5388 };
5389 var deferred = {};
5390 return jQuery.each(dest, function(i, tuple) {
5391 var list = tuple[2];
5392 var stateString = tuple[5];
5393 promise[tuple[1]] = list.add;
5394 if (stateString) {
5395 list.add(function() {
5396 state = stateString;
5397 }, dest[3 - i][2].disable, dest[3 - i][3].disable, dest[0][2].lock, dest[0][3].lock);
5398 }
5399 list.add(tuple[3].fire);
5400 /**
5401 * @return {?}
5402 */
5403 deferred[tuple[0]] = function() {
5404 return deferred[tuple[0] + "With"](this === deferred ? void 0 : this, arguments), this;
5405 };
5406 deferred[tuple[0] + "With"] = list.fireWith;
5407 }), promise.promise(deferred), func && func.call(deferred, deferred), deferred;
5408 },
5409 when : function(r) {
5410 /** @type {number} */
5411 var sampleSize = arguments.length;
5412 var i = sampleSize;
5413 /** @type {!Array} */
5414 var elements = Array(i);
5415 /** @type {!Array<?>} */
5416 var args = slice.call(arguments);
5417 var self = jQuery.Deferred();
5418 /**
5419 * @param {undefined} index
5420 * @return {?}
5421 */
5422 var callback = function(index) {
5423 return function(value) {
5424 elements[index] = this;
5425 args[index] = 1 < arguments.length ? slice.call(arguments) : value;
5426 if (!--sampleSize) {
5427 self.resolveWith(elements, args);
5428 }
5429 };
5430 };
5431 if (1 >= sampleSize && (require(r, self.done(callback(i)).resolve, self.reject, !sampleSize), "pending" === self.state() || fn(args[i] && args[i].then))) {
5432 return self.then();
5433 }
5434 for (; i--;) {
5435 require(args[i], callback(i), self.reject);
5436 }
5437 return self.promise();
5438 }
5439 });
5440 /** @type {!RegExp} */
5441 var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
5442 /**
5443 * @param {string} error
5444 * @param {?} stack
5445 * @return {undefined}
5446 */
5447 jQuery.Deferred.exceptionHook = function(error, stack) {
5448 if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
5449 window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
5450 }
5451 };
5452 /**
5453 * @param {?} error
5454 * @return {undefined}
5455 */
5456 jQuery.readyException = function(error) {
5457 window.setTimeout(function() {
5458 throw error;
5459 });
5460 };
5461 var f = jQuery.Deferred();
5462 /**
5463 * @param {!Function} store
5464 * @return {?}
5465 */
5466 jQuery.fn.ready = function(store) {
5467 return f.then(store).catch(function(e) {
5468 jQuery.readyException(e);
5469 }), this;
5470 };
5471 jQuery.extend({
5472 isReady : false,
5473 readyWait : 1,
5474 ready : function(data) {
5475 if (!(true === data ? --jQuery.readyWait : jQuery.isReady)) {
5476 /** @type {boolean} */
5477 jQuery.isReady = true;
5478 if (!(true !== data && 0 < --jQuery.readyWait)) {
5479 f.resolveWith(document, [jQuery]);
5480 }
5481 }
5482 }
5483 });
5484 jQuery.ready.then = f.then;
5485 if ("complete" === document.readyState || "loading" !== document.readyState && !document.documentElement.doScroll) {
5486 window.setTimeout(jQuery.ready);
5487 } else {
5488 document.addEventListener("DOMContentLoaded", $__jsx_onload);
5489 window.addEventListener("load", $__jsx_onload);
5490 }
5491 /**
5492 * @param {string} elems
5493 * @param {!Function} callback
5494 * @param {!Object} key
5495 * @param {?} value
5496 * @param {number} chainable
5497 * @param {string} emptyGet
5498 * @param {boolean} raw
5499 * @return {?}
5500 */
5501 var access = function(elems, callback, key, value, chainable, emptyGet, raw) {
5502 /** @type {number} */
5503 var i = 0;
5504 var length = elems.length;
5505 /** @type {boolean} */
5506 var bulk = null == key;
5507 if ("object" === type(key)) {
5508 for (i in chainable = true, key) {
5509 access(elems, callback, i, key[i], true, emptyGet, raw);
5510 }
5511 } else {
5512 if (void 0 !== value && (chainable = true, fn(value) || (raw = true), bulk && (raw ? (callback.call(elems, value), callback = null) : (bulk = callback, callback = function(elem, t, value) {
5513 return bulk.call(jQuery(elem), value);
5514 })), callback)) {
5515 for (; i < length; i++) {
5516 callback(elems[i], key, raw ? value : value.call(elems[i], i, callback(elems[i], key)));
5517 }
5518 }
5519 }
5520 return chainable ? elems : bulk ? callback.call(elems) : length ? callback(elems[0], key) : emptyGet;
5521 };
5522 /** @type {!RegExp} */
5523 var _kerningNamesHash_escapeEscape = /^-ms-/;
5524 /** @type {!RegExp} */
5525 var rcharset = /-([a-z])/g;
5526 /**
5527 * @param {!Object} selector
5528 * @return {?}
5529 */
5530 var match = function(selector) {
5531 return 1 === selector.nodeType || 9 === selector.nodeType || !+selector.nodeType;
5532 };
5533 /** @type {number} */
5534 Data.uid = 1;
5535 Data.prototype = {
5536 cache : function(node) {
5537 var value = node[this.expando];
5538 return value || (value = {}, match(node) && (node.nodeType ? node[this.expando] = value : Object.defineProperty(node, this.expando, {
5539 value : value,
5540 configurable : true
5541 }))), value;
5542 },
5543 set : function(obj, key, type) {
5544 var name;
5545 if (obj = this.cache(obj), "string" == typeof key) {
5546 /** @type {string} */
5547 obj[camelCase(key)] = type;
5548 } else {
5549 for (name in key) {
5550 obj[camelCase(name)] = key[name];
5551 }
5552 }
5553 return obj;
5554 },
5555 get : function(data, key) {
5556 return void 0 === key ? this.cache(data) : data[this.expando] && data[this.expando][camelCase(key)];
5557 },
5558 access : function(value, fn, callback) {
5559 return void 0 === fn || fn && "string" == typeof fn && void 0 === callback ? this.get(value, fn) : (this.set(value, fn, callback), void 0 !== callback ? callback : fn);
5560 },
5561 remove : function(parent, key) {
5562 var j;
5563 var value = parent[this.expando];
5564 if (void 0 !== value) {
5565 if (void 0 !== key) {
5566 if (Array.isArray(key)) {
5567 key = key.map(camelCase);
5568 } else {
5569 key = (key = camelCase(key)) in value ? [key] : key.match(re) || [];
5570 }
5571 j = key.length;
5572 for (; j--;) {
5573 delete value[key[j]];
5574 }
5575 }
5576 if (void 0 === key || jQuery.isEmptyObject(value)) {
5577 if (parent.nodeType) {
5578 parent[this.expando] = void 0;
5579 } else {
5580 delete parent[this.expando];
5581 }
5582 }
5583 }
5584 },
5585 hasData : function(owner) {
5586 return void 0 !== (owner = owner[this.expando]) && !jQuery.isEmptyObject(owner);
5587 }
5588 };
5589 var dataPriv = new Data;
5590 var data_priv = new Data;
5591 /** @type {!RegExp} */
5592 var contribRegex = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
5593 /** @type {!RegExp} */
5594 var dashExpr = /[A-Z]/g;
5595 jQuery.extend({
5596 hasData : function(elem) {
5597 return data_priv.hasData(elem) || dataPriv.hasData(elem);
5598 },
5599 data : function(node, name, data) {
5600 return data_priv.access(node, name, data);
5601 },
5602 removeData : function(elem, key) {
5603 data_priv.remove(elem, key);
5604 },
5605 _data : function(elem, name, data) {
5606 return dataPriv.access(elem, name, data);
5607 },
5608 _removeData : function(elem, name) {
5609 dataPriv.remove(elem, name);
5610 }
5611 });
5612 jQuery.fn.extend({
5613 data : function(key, value) {
5614 var f;
5615 var node = this[0];
5616 var r = node && node.attributes;
5617 if (void 0 === key) {
5618 if (this.length) {
5619 var attrs = data_priv.get(node);
5620 if (1 === node.nodeType && !dataPriv.get(node, "hasDataAttrs")) {
5621 f = r.length;
5622 for (; f--;) {
5623 if (r[f]) {
5624 var name = r[f].name;
5625 if (0 === name.indexOf("data-")) {
5626 name = camelCase(name.slice(5));
5627 set(node, name, attrs[name]);
5628 }
5629 }
5630 }
5631 dataPriv.set(node, "hasDataAttrs", true);
5632 }
5633 }
5634 return attrs;
5635 }
5636 return "object" == typeof key ? this.each(function() {
5637 data_priv.set(this, key);
5638 }) : access(this, function(type) {
5639 if (node && void 0 === type) {
5640 var data = data_priv.get(node, key);
5641 if (void 0 !== data) {
5642 return data;
5643 }
5644 if (void 0 !== (data = set(node, key))) {
5645 return data;
5646 }
5647 } else {
5648 this.each(function() {
5649 data_priv.set(this, key, type);
5650 });
5651 }
5652 }, null, value, 1 < arguments.length, null, true);
5653 },
5654 removeData : function(key) {
5655 return this.each(function() {
5656 data_priv.remove(this, key);
5657 });
5658 }
5659 });
5660 jQuery.extend({
5661 queue : function(elem, type, data) {
5662 if (elem) {
5663 /** @type {string} */
5664 type = (type || "fx") + "queue";
5665 var q = dataPriv.get(elem, type);
5666 return data && (!q || Array.isArray(data) ? q = dataPriv.access(elem, type, jQuery.makeArray(data)) : q.push(data)), q || [];
5667 }
5668 },
5669 dequeue : function(elem, type) {
5670 type = type || "fx";
5671 var item = jQuery.queue(elem, type);
5672 var enabled = item.length;
5673 var animate = item.shift();
5674 var target = jQuery._queueHooks(elem, type);
5675 if ("inprogress" === animate) {
5676 animate = item.shift();
5677 enabled--;
5678 }
5679 if (animate) {
5680 if ("fx" === type) {
5681 item.unshift("inprogress");
5682 }
5683 delete target.stop;
5684 animate.call(elem, function() {
5685 jQuery.dequeue(elem, type);
5686 }, target);
5687 }
5688 if (!enabled && target) {
5689 target.empty.fire();
5690 }
5691 },
5692 _queueHooks : function(elem, type) {
5693 /** @type {string} */
5694 var key = type + "queueHooks";
5695 return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
5696 empty : jQuery.Callbacks("once memory").add(function() {
5697 dataPriv.remove(elem, [type + "queue", key]);
5698 })
5699 });
5700 }
5701 });
5702 jQuery.fn.extend({
5703 queue : function(type, data) {
5704 /** @type {number} */
5705 var setter = 2;
5706 return "string" != typeof type && (data = type, type = "fx", setter--), arguments.length < setter ? jQuery.queue(this[0], type) : void 0 === data ? this : this.each(function() {
5707 var queue = jQuery.queue(this, type, data);
5708 jQuery._queueHooks(this, type);
5709 if ("fx" === type && "inprogress" !== queue[0]) {
5710 jQuery.dequeue(this, type);
5711 }
5712 });
5713 },
5714 dequeue : function(type) {
5715 return this.each(function() {
5716 jQuery.dequeue(this, type);
5717 });
5718 },
5719 clearQueue : function(type) {
5720 return this.queue(type || "fx", []);
5721 },
5722 promise : function(type, obj) {
5723 var sel;
5724 /** @type {number} */
5725 var o = 1;
5726 var defer = jQuery.Deferred();
5727 var elements = this;
5728 var i = this.length;
5729 /**
5730 * @return {undefined}
5731 */
5732 var resolve = function() {
5733 if (!--o) {
5734 defer.resolveWith(elements, [elements]);
5735 }
5736 };
5737 if ("string" != typeof type) {
5738 /** @type {string} */
5739 obj = type;
5740 type = void 0;
5741 }
5742 type = type || "fx";
5743 for (; i--;) {
5744 if ((sel = dataPriv.get(elements[i], type + "queueHooks")) && sel.empty) {
5745 o++;
5746 sel.empty.add(resolve);
5747 }
5748 }
5749 return resolve(), defer.promise(obj);
5750 }
5751 });
5752 /** @type {string} */
5753 var FSSource = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
5754 /** @type {!RegExp} */
5755 var regex = new RegExp("^(?:([+-])=|)(" + FSSource + ")([a-z%]*)$", "i");
5756 /** @type {!Array} */
5757 var cssExpand = ["Top", "Right", "Bottom", "Left"];
5758 var element = document.documentElement;
5759 /**
5760 * @param {!Object} elem
5761 * @return {?}
5762 */
5763 var test = function(elem) {
5764 return jQuery.contains(elem.ownerDocument, elem);
5765 };
5766 var groupId = {
5767 composed : true
5768 };
5769 if (element.getRootNode) {
5770 /**
5771 * @param {!Object} element
5772 * @return {?}
5773 */
5774 test = function(element) {
5775 return jQuery.contains(element.ownerDocument, element) || element.getRootNode(groupId) === element.ownerDocument;
5776 };
5777 }
5778 /**
5779 * @param {!Object} element
5780 * @param {!Object} root
5781 * @return {?}
5782 */
5783 var isHidden = function(element, root) {
5784 return "none" === (element = root || element).style.display || "" === element.style.display && test(element) && "none" === jQuery.css(element, "display");
5785 };
5786 var elemdisplay = {};
5787 jQuery.fn.extend({
5788 show : function() {
5789 return show(this, true);
5790 },
5791 hide : function() {
5792 return show(this);
5793 },
5794 toggle : function(state) {
5795 return "boolean" == typeof state ? state ? this.show() : this.hide() : this.each(function() {
5796 if (isHidden(this)) {
5797 jQuery(this).show();
5798 } else {
5799 jQuery(this).hide();
5800 }
5801 });
5802 }
5803 });
5804 /** @type {!RegExp} */
5805 var path = /^(?:checkbox|radio)$/i;
5806 /** @type {!RegExp} */
5807 var fullLinkRegex = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i;
5808 /** @type {!RegExp} */
5809 var opacityRe = /^$|^module$|\/(?:java|ecma)script/i;
5810 !function() {
5811 var e = document.createDocumentFragment().appendChild(document.createElement("div"));
5812 var input = document.createElement("input");
5813 input.setAttribute("type", "radio");
5814 input.setAttribute("checked", "checked");
5815 input.setAttribute("name", "t");
5816 e.appendChild(input);
5817 support.checkClone = e.cloneNode(true).cloneNode(true).lastChild.checked;
5818 /** @type {string} */
5819 e.innerHTML = "<textarea>x</textarea>";
5820 /** @type {boolean} */
5821 support.noCloneChecked = !!e.cloneNode(true).lastChild.defaultValue;
5822 /** @type {string} */
5823 e.innerHTML = "<option></option>";
5824 /** @type {boolean} */
5825 support.option = !!e.lastChild;
5826 }();
5827 var wrapMap = {
5828 thead : [1, "<table>", "</table>"],
5829 col : [2, "<table><colgroup>", "</colgroup></table>"],
5830 tr : [2, "<table><tbody>", "</tbody></table>"],
5831 td : [3, "<table><tbody><tr>", "</tr></tbody></table>"],
5832 _default : [0, "", ""]
5833 };
5834 /** @type {!Array} */
5835 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5836 /** @type {!Array} */
5837 wrapMap.th = wrapMap.td;
5838 if (!support.option) {
5839 /** @type {!Array} */
5840 wrapMap.optgroup = wrapMap.option = [1, "<select multiple='multiple'>", "</select>"];
5841 }
5842 /** @type {!RegExp} */
5843 var re_commas = /<|&#?\w+;/;
5844 /** @type {!RegExp} */
5845 var receivedTestEndEvents = /^key/;
5846 /** @type {!RegExp} */
5847 var receivedErrorEvents = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
5848 /** @type {!RegExp} */
5849 var r = /^([^.]*)(?:\.(.+)|)/;
5850 jQuery.event = {
5851 global : {},
5852 add : function(p, data, handler, description, selector) {
5853 var i;
5854 var _ref;
5855 var action;
5856 var events;
5857 var k = dataPriv.get(p);
5858 if (match(p)) {
5859 if (handler.handler) {
5860 /** @type {!Object} */
5861 var config = handler;
5862 handler = config.handler;
5863 selector = config.selector;
5864 }
5865 if (selector) {
5866 jQuery.find.matchesSelector(element, selector);
5867 }
5868 if (!handler.guid) {
5869 /** @type {number} */
5870 handler.guid = jQuery.guid++;
5871 }
5872 if (!(_ref = k.events)) {
5873 /** @type {!Object} */
5874 _ref = k.events = Object.create(null);
5875 }
5876 if (!(i = k.handle)) {
5877 /** @type {function(!Object): ?} */
5878 i = k.handle = function(e) {
5879 return void 0 !== jQuery && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(p, arguments) : void 0;
5880 };
5881 }
5882 k = (data = (data || "").match(re) || [""]).length;
5883 for (; k--;) {
5884 /** @type {!Array} */
5885 var special = r.exec(data[k]) || [];
5886 var type = action = special[1];
5887 var d = (special[2] || "").split(".").sort();
5888 if (type) {
5889 special = jQuery.event.special[type] || {};
5890 type = (selector ? special.delegateType : special.bindType) || type;
5891 special = jQuery.event.special[type] || {};
5892 action = jQuery.extend({
5893 type : type,
5894 origType : action,
5895 data : description,
5896 handler : handler,
5897 guid : handler.guid,
5898 selector : selector,
5899 needsContext : selector && jQuery.expr.match.needsContext.test(selector),
5900 namespace : d.join(".")
5901 }, config);
5902 if (!(events = _ref[type])) {
5903 /** @type {number} */
5904 (events = _ref[type] = []).delegateCount = 0;
5905 if (!(special.setup && false !== special.setup.call(p, description, d, i))) {
5906 if (p.addEventListener) {
5907 p.addEventListener(type, i);
5908 }
5909 }
5910 }
5911 if (special.add) {
5912 special.add.call(p, action);
5913 if (!action.handler.guid) {
5914 action.handler.guid = handler.guid;
5915 }
5916 }
5917 if (selector) {
5918 events.splice(events.delegateCount++, 0, action);
5919 } else {
5920 events.push(action);
5921 }
5922 /** @type {boolean} */
5923 jQuery.event.global[type] = true;
5924 }
5925 }
5926 }
5927 },
5928 remove : function(elem, data, fn, selector, mappedTypes) {
5929 var j;
5930 var origCount;
5931 var events;
5932 var i;
5933 var origType;
5934 var elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
5935 if (elemData && (events = elemData.events)) {
5936 i = (data = (data || "").match(re) || [""]).length;
5937 for (; i--;) {
5938 /** @type {!Array} */
5939 var tmp = r.exec(data[i]) || [];
5940 var type = origType = tmp[1];
5941 var d = (tmp[2] || "").split(".").sort();
5942 if (type) {
5943 var special = jQuery.event.special[type] || {};
5944 var handlers = events[type = (selector ? special.delegateType : special.bindType) || type] || [];
5945 tmp = tmp[2] && new RegExp("(^|\\.)" + d.join("\\.(?:.*\\.|)") + "(\\.|$)");
5946 origCount = j = handlers.length;
5947 for (; j--;) {
5948 var handleObj = handlers[j];
5949 if (!(!mappedTypes && origType !== handleObj.origType || fn && fn.guid !== handleObj.guid || tmp && !tmp.test(handleObj.namespace) || selector && selector !== handleObj.selector && ("**" !== selector || !handleObj.selector))) {
5950 handlers.splice(j, 1);
5951 if (handleObj.selector) {
5952 handlers.delegateCount--;
5953 }
5954 if (special.remove) {
5955 special.remove.call(elem, handleObj);
5956 }
5957 }
5958 }
5959 if (origCount && !handlers.length) {
5960 if (!(special.teardown && false !== special.teardown.call(elem, d, elemData.handle))) {
5961 jQuery.removeEvent(elem, type, elemData.handle);
5962 }
5963 delete events[type];
5964 }
5965 } else {
5966 for (type in events) {
5967 jQuery.event.remove(elem, type + data[i], fn, selector, true);
5968 }
5969 }
5970 }
5971 if (jQuery.isEmptyObject(events)) {
5972 dataPriv.remove(elem, "handle events");
5973 }
5974 }
5975 },
5976 dispatch : function(e) {
5977 var i;
5978 var handleObj;
5979 var matched;
5980 /** @type {!Array} */
5981 var args = Array(arguments.length);
5982 var event = jQuery.event.fix(e);
5983 var j = (dataPriv.get(this, "events") || Object.create(null))[event.type] || [];
5984 var special = jQuery.event.special[event.type] || {};
5985 args[0] = event;
5986 /** @type {number} */
5987 i = 1;
5988 for (; i < arguments.length; i++) {
5989 args[i] = arguments[i];
5990 }
5991 if (event.delegateTarget = this, !special.preDispatch || false !== special.preDispatch.call(this, event)) {
5992 var handlerQueue = jQuery.event.handlers.call(this, event, j);
5993 /** @type {number} */
5994 i = 0;
5995 for (; (matched = handlerQueue[i++]) && !event.isPropagationStopped();) {
5996 event.currentTarget = matched.elem;
5997 /** @type {number} */
5998 j = 0;
5999 for (; (handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped();) {
6000 if (!(event.rnamespace && false !== handleObj.namespace && !event.rnamespace.test(handleObj.namespace))) {
6001 event.handleObj = handleObj;
6002 event.data = handleObj.data;
6003 if (void 0 !== (handleObj = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args)) && false === (event.result = handleObj)) {
6004 event.preventDefault();
6005 event.stopPropagation();
6006 }
6007 }
6008 }
6009 }
6010 return special.postDispatch && special.postDispatch.call(this, event), event.result;
6011 }
6012 },
6013 handlers : function(event, handlers) {
6014 var j;
6015 /** @type {!Array} */
6016 var handlerQueue = [];
6017 var delegateCount = handlers.delegateCount;
6018 var cur = event.target;
6019 if (delegateCount && cur.nodeType && !("click" === event.type && 1 <= event.button)) {
6020 for (; cur !== this; cur = cur.parentNode || this) {
6021 if (1 === cur.nodeType && ("click" !== event.type || true !== cur.disabled)) {
6022 /** @type {!Array} */
6023 var matches = [];
6024 var __mojoServiceRegistry = {};
6025 /** @type {number} */
6026 j = 0;
6027 for (; j < delegateCount; j++) {
6028 var handleObj = handlers[j];
6029 /** @type {string} */
6030 var name = handleObj.selector + " ";
6031 if (void 0 === __mojoServiceRegistry[name]) {
6032 __mojoServiceRegistry[name] = handleObj.needsContext ? -1 < jQuery(name, this).index(cur) : jQuery.find(name, this, null, [cur]).length;
6033 }
6034 if (__mojoServiceRegistry[name]) {
6035 matches.push(handleObj);
6036 }
6037 }
6038 if (matches.length) {
6039 handlerQueue.push({
6040 elem : cur,
6041 handlers : matches
6042 });
6043 }
6044 }
6045 }
6046 }
6047 return delegateCount < handlers.length && handlerQueue.push({
6048 elem : this,
6049 handlers : handlers.slice(delegateCount)
6050 }), handlerQueue;
6051 },
6052 addProp : function(name, hook) {
6053 Object.defineProperty(jQuery.Event.prototype, name, {
6054 enumerable : true,
6055 configurable : true,
6056 get : fn(hook) ? function() {
6057 if (this.originalEvent) {
6058 return hook(this.originalEvent);
6059 }
6060 } : function() {
6061 if (this.originalEvent) {
6062 return this.originalEvent[name];
6063 }
6064 },
6065 set : function(text) {
6066 Object.defineProperty(this, name, {
6067 enumerable : true,
6068 configurable : true,
6069 writable : true,
6070 value : text
6071 });
6072 }
6073 });
6074 },
6075 fix : function(originalEvent) {
6076 return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
6077 },
6078 special : {
6079 load : {
6080 noBubble : true
6081 },
6082 click : {
6083 setup : function(source) {
6084 return source = this || source, path.test(source.type) && source.click && $(source, "input") && on(source, "click", returnTrue), false;
6085 },
6086 trigger : function(type) {
6087 return type = this || type, path.test(type.type) && type.click && $(type, "input") && on(type, "click"), true;
6088 },
6089 _default : function(node) {
6090 return node = node.target, path.test(node.type) && node.click && $(node, "input") && dataPriv.get(node, "click") || $(node, "a");
6091 }
6092 },
6093 beforeunload : {
6094 postDispatch : function(event) {
6095 if (void 0 !== event.result && event.originalEvent) {
6096 event.originalEvent.returnValue = event.result;
6097 }
6098 }
6099 }
6100 }
6101 };
6102 /**
6103 * @param {!Object} elem
6104 * @param {!Object} type
6105 * @param {?} fn
6106 * @return {undefined}
6107 */
6108 jQuery.removeEvent = function(elem, type, fn) {
6109 if (elem.removeEventListener) {
6110 elem.removeEventListener(type, fn);
6111 }
6112 };
6113 /**
6114 * @param {!Object} src
6115 * @param {string} props
6116 * @return {?}
6117 */
6118 jQuery.Event = function(src, props) {
6119 if (!(this instanceof jQuery.Event)) {
6120 return new jQuery.Event(src, props);
6121 }
6122 if (src && src.type) {
6123 /** @type {!Object} */
6124 this.originalEvent = src;
6125 this.type = src.type;
6126 /** @type {function(): ?} */
6127 this.isDefaultPrevented = src.defaultPrevented || void 0 === src.defaultPrevented && false === src.returnValue ? returnTrue : returnFalse;
6128 this.target = src.target && 3 === src.target.nodeType ? src.target.parentNode : src.target;
6129 this.currentTarget = src.currentTarget;
6130 this.relatedTarget = src.relatedTarget;
6131 } else {
6132 /** @type {!Object} */
6133 this.type = src;
6134 }
6135 if (props) {
6136 jQuery.extend(this, props);
6137 }
6138 this.timeStamp = src && src.timeStamp || Date.now();
6139 /** @type {boolean} */
6140 this[jQuery.expando] = true;
6141 };
6142 jQuery.Event.prototype = {
6143 constructor : jQuery.Event,
6144 isDefaultPrevented : returnFalse,
6145 isPropagationStopped : returnFalse,
6146 isImmediatePropagationStopped : returnFalse,
6147 isSimulated : false,
6148 preventDefault : function() {
6149 var e = this.originalEvent;
6150 /** @type {function(): ?} */
6151 this.isDefaultPrevented = returnTrue;
6152 if (e && !this.isSimulated) {
6153 e.preventDefault();
6154 }
6155 },
6156 stopPropagation : function() {
6157 var e = this.originalEvent;
6158 /** @type {function(): ?} */
6159 this.isPropagationStopped = returnTrue;
6160 if (e && !this.isSimulated) {
6161 e.stopPropagation();
6162 }
6163 },
6164 stopImmediatePropagation : function() {
6165 var e = this.originalEvent;
6166 /** @type {function(): ?} */
6167 this.isImmediatePropagationStopped = returnTrue;
6168 if (e && !this.isSimulated) {
6169 e.stopImmediatePropagation();
6170 }
6171 this.stopPropagation();
6172 }
6173 };
6174 jQuery.each({
6175 altKey : true,
6176 bubbles : true,
6177 cancelable : true,
6178 changedTouches : true,
6179 ctrlKey : true,
6180 detail : true,
6181 eventPhase : true,
6182 metaKey : true,
6183 pageX : true,
6184 pageY : true,
6185 shiftKey : true,
6186 view : true,
6187 char : true,
6188 code : true,
6189 charCode : true,
6190 key : true,
6191 keyCode : true,
6192 button : true,
6193 buttons : true,
6194 clientX : true,
6195 clientY : true,
6196 offsetX : true,
6197 offsetY : true,
6198 pointerId : true,
6199 pointerType : true,
6200 screenX : true,
6201 screenY : true,
6202 targetTouches : true,
6203 toElement : true,
6204 touches : true,
6205 which : function(e) {
6206 var button = e.button;
6207 return null == e.which && receivedTestEndEvents.test(e.type) ? null != e.charCode ? e.charCode : e.keyCode : !e.which && void 0 !== button && receivedErrorEvents.test(e.type) ? 1 & button ? 1 : 2 & button ? 3 : 4 & button ? 2 : 0 : e.which;
6208 }
6209 }, jQuery.event.addProp);
6210 jQuery.each({
6211 focus : "focusin",
6212 blur : "focusout"
6213 }, function(name, fix) {
6214 jQuery.event.special[name] = {
6215 setup : function() {
6216 return on(this, name, onDoubleClick), false;
6217 },
6218 trigger : function() {
6219 return on(this, name), true;
6220 },
6221 delegateType : fix
6222 };
6223 });
6224 jQuery.each({
6225 mouseenter : "mouseover",
6226 mouseleave : "mouseout",
6227 pointerenter : "pointerover",
6228 pointerleave : "pointerout"
6229 }, function(orig, fix) {
6230 jQuery.event.special[orig] = {
6231 delegateType : fix,
6232 bindType : fix,
6233 handle : function(event) {
6234 var related = event.relatedTarget;
6235 var handleObj = event.handleObj;
6236 if (!related || related !== this && !jQuery.contains(this, related)) {
6237 event.type = handleObj.origType;
6238 var result = handleObj.handler.apply(this, arguments);
6239 /** @type {!Object} */
6240 event.type = fix;
6241 }
6242 return result;
6243 }
6244 };
6245 });
6246 jQuery.fn.extend({
6247 on : function(t, event, type, data) {
6248 return debug(this, t, event, type, data);
6249 },
6250 one : function(text, callback, name, type) {
6251 return debug(this, text, callback, name, type, 1);
6252 },
6253 off : function(event, callback, fn) {
6254 if (event && event.preventDefault && event.handleObj) {
6255 var e = event.handleObj;
6256 return jQuery(event.delegateTarget).off(e.namespace ? e.origType + "." + e.namespace : e.origType, e.selector, e.handler), this;
6257 }
6258 if ("object" == typeof event) {
6259 for (e in event) {
6260 this.off(e, callback, event[e]);
6261 }
6262 return this;
6263 }
6264 return false !== callback && "function" != typeof callback || (fn = callback, callback = void 0), false === fn && (fn = returnFalse), this.each(function() {
6265 jQuery.event.remove(this, event, fn, callback);
6266 });
6267 }
6268 });
6269 /** @type {!RegExp} */
6270 var reValidName = /<script|<style|<link/i;
6271 /** @type {!RegExp} */
6272 var partten = /checked\s*(?:[^=]|=\s*.checked.)/i;
6273 /** @type {!RegExp} */
6274 var query = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
6275 jQuery.extend({
6276 htmlPrefilter : function(html) {
6277 return html;
6278 },
6279 clone : function(elem, n, array) {
6280 var l;
6281 var clone = elem.cloneNode(true);
6282 var inPage = test(elem);
6283 if (!(support.noCloneChecked || 1 !== elem.nodeType && 11 !== elem.nodeType || jQuery.isXMLDoc(elem))) {
6284 var destElements = getAll(clone);
6285 var srcElements = getAll(elem);
6286 /** @type {number} */
6287 var i = 0;
6288 l = srcElements.length;
6289 for (; i < l; i++) {
6290 var src = srcElements[i];
6291 var dest = destElements[i];
6292 var undefined = dest.nodeName.toLowerCase();
6293 if ("input" === undefined && path.test(src.type)) {
6294 dest.checked = src.checked;
6295 } else {
6296 if (!("input" !== undefined && "textarea" !== undefined)) {
6297 dest.defaultValue = src.defaultValue;
6298 }
6299 }
6300 }
6301 }
6302 if (n) {
6303 if (array) {
6304 srcElements = srcElements || getAll(elem);
6305 destElements = destElements || getAll(clone);
6306 /** @type {number} */
6307 i = 0;
6308 l = srcElements.length;
6309 for (; i < l; i++) {
6310 cloneCopyEvent(srcElements[i], destElements[i]);
6311 }
6312 } else {
6313 cloneCopyEvent(elem, clone);
6314 }
6315 }
6316 return 0 < (destElements = getAll(clone, "script")).length && setGlobalEval(destElements, !inPage && getAll(elem, "script")), clone;
6317 },
6318 cleanData : function(elems) {
6319 var data;
6320 var elem;
6321 var type;
6322 var special = jQuery.event.special;
6323 /** @type {number} */
6324 var i = 0;
6325 for (; void 0 !== (elem = elems[i]); i++) {
6326 if (match(elem)) {
6327 if (data = elem[dataPriv.expando]) {
6328 if (data.events) {
6329 for (type in data.events) {
6330 if (special[type]) {
6331 jQuery.event.remove(elem, type);
6332 } else {
6333 jQuery.removeEvent(elem, type, data.handle);
6334 }
6335 }
6336 }
6337 elem[dataPriv.expando] = void 0;
6338 }
6339 if (elem[data_priv.expando]) {
6340 elem[data_priv.expando] = void 0;
6341 }
6342 }
6343 }
6344 }
6345 });
6346 jQuery.fn.extend({
6347 detach : function(context) {
6348 return remove(this, context, true);
6349 },
6350 remove : function(text) {
6351 return remove(this, text);
6352 },
6353 text : function(value) {
6354 return access(this, function(value) {
6355 return void 0 === value ? jQuery.text(this) : this.empty().each(function() {
6356 if (!(1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType)) {
6357 this.textContent = value;
6358 }
6359 });
6360 }, null, value, arguments.length);
6361 },
6362 append : function() {
6363 return domManip(this, arguments, function(elem) {
6364 if (!(1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType)) {
6365 manipulationTarget(this, elem).appendChild(elem);
6366 }
6367 });
6368 },
6369 prepend : function() {
6370 return domManip(this, arguments, function(elem) {
6371 if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
6372 var target = manipulationTarget(this, elem);
6373 target.insertBefore(elem, target.firstChild);
6374 }
6375 });
6376 },
6377 before : function() {
6378 return domManip(this, arguments, function(elem) {
6379 if (this.parentNode) {
6380 this.parentNode.insertBefore(elem, this);
6381 }
6382 });
6383 },
6384 after : function() {
6385 return domManip(this, arguments, function(elem) {
6386 if (this.parentNode) {
6387 this.parentNode.insertBefore(elem, this.nextSibling);
6388 }
6389 });
6390 },
6391 empty : function() {
6392 var elem;
6393 /** @type {number} */
6394 var i = 0;
6395 for (; null != (elem = this[i]); i++) {
6396 if (1 === elem.nodeType) {
6397 jQuery.cleanData(getAll(elem, false));
6398 /** @type {string} */
6399 elem.textContent = "";
6400 }
6401 }
6402 return this;
6403 },
6404 clone : function(c, i) {
6405 return c = null != c && c, i = null == i ? c : i, this.map(function() {
6406 return jQuery.clone(this, c, i);
6407 });
6408 },
6409 html : function(value) {
6410 return access(this, function(value) {
6411 var elem = this[0] || {};
6412 /** @type {number} */
6413 var thatpos = 0;
6414 var i = this.length;
6415 if (void 0 === value && 1 === elem.nodeType) {
6416 return elem.innerHTML;
6417 }
6418 if ("string" == typeof value && !reValidName.test(value) && !wrapMap[(fullLinkRegex.exec(value) || ["", ""])[1].toLowerCase()]) {
6419 value = jQuery.htmlPrefilter(value);
6420 try {
6421 for (; thatpos < i; thatpos++) {
6422 if (1 === (elem = this[thatpos] || {}).nodeType) {
6423 jQuery.cleanData(getAll(elem, false));
6424 /** @type {number} */
6425 elem.innerHTML = value;
6426 }
6427 }
6428 /** @type {number} */
6429 elem = 0;
6430 } catch (e) {
6431 }
6432 }
6433 if (elem) {
6434 this.empty().append(value);
6435 }
6436 }, null, value, arguments.length);
6437 },
6438 replaceWith : function() {
6439 /** @type {!Array} */
6440 var ignored = [];
6441 return domManip(this, arguments, function(t) {
6442 var p = this.parentNode;
6443 if (0 > jQuery.inArray(this, ignored)) {
6444 jQuery.cleanData(getAll(this));
6445 if (p) {
6446 p.replaceChild(t, this);
6447 }
6448 }
6449 }, ignored);
6450 }
6451 });
6452 jQuery.each({
6453 appendTo : "append",
6454 prependTo : "prepend",
6455 insertBefore : "before",
6456 insertAfter : "after",
6457 replaceAll : "replaceWith"
6458 }, function(original, n) {
6459 /**
6460 * @param {(Object|string)} name
6461 * @return {?}
6462 */
6463 jQuery.fn[original] = function(name) {
6464 /** @type {!Array} */
6465 var ret = [];
6466 var controls = jQuery(name);
6467 /** @type {number} */
6468 var last = controls.length - 1;
6469 /** @type {number} */
6470 var i = 0;
6471 for (; i <= last; i++) {
6472 name = i === last ? this : this.clone(true);
6473 jQuery(controls[i])[n](name);
6474 push.apply(ret, name.get());
6475 }
6476 return this.pushStack(ret);
6477 };
6478 });
6479 /** @type {!RegExp} */
6480 var rnumnonpx = new RegExp("^(" + FSSource + ")(?!px)[a-z%]+$", "i");
6481 /**
6482 * @param {!Object} elem
6483 * @return {?}
6484 */
6485 var getStyles = function(elem) {
6486 var win = elem.ownerDocument.defaultView;
6487 return win && win.opener || (win = window), win.getComputedStyle(elem);
6488 };
6489 /**
6490 * @param {!Object} e
6491 * @param {!Array} t
6492 * @param {!Function} r
6493 * @return {?}
6494 */
6495 var extend = function(e, t, r) {
6496 var j;
6497 var item_values = {};
6498 for (j in t) {
6499 item_values[j] = e.style[j];
6500 e.style[j] = t[j];
6501 }
6502 for (j in r = r.call(e), t) {
6503 e.style[j] = item_values[j];
6504 }
6505 return r;
6506 };
6507 /** @type {!RegExp} */
6508 var inlineAttributeCommentRegex = new RegExp(cssExpand.join("|"), "i");
6509 !function() {
6510 /**
6511 * @return {undefined}
6512 */
6513 function fn() {
6514 if (div) {
6515 /** @type {string} */
6516 container.style.cssText = "position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0";
6517 /** @type {string} */
6518 div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%";
6519 element.appendChild(container).appendChild(div);
6520 var b = window.getComputedStyle(div);
6521 /** @type {boolean} */
6522 res = "1%" !== b.top;
6523 /** @type {boolean} */
6524 s = 12 === Math.round(parseFloat(b.marginLeft));
6525 /** @type {string} */
6526 div.style.right = "60%";
6527 /** @type {boolean} */
6528 i = 36 === Math.round(parseFloat(b.right));
6529 /** @type {boolean} */
6530 o = 36 === Math.round(parseFloat(b.width));
6531 /** @type {string} */
6532 div.style.position = "absolute";
6533 /** @type {boolean} */
6534 r = 12 === Math.round(parseFloat(div.offsetWidth / 3));
6535 element.removeChild(container);
6536 /** @type {null} */
6537 div = null;
6538 }
6539 }
6540 var res;
6541 var o;
6542 var r;
6543 var i;
6544 var a;
6545 var s;
6546 var container = document.createElement("div");
6547 var div = document.createElement("div");
6548 if (div.style) {
6549 /** @type {string} */
6550 div.style.backgroundClip = "content-box";
6551 /** @type {string} */
6552 div.cloneNode(true).style.backgroundClip = "";
6553 /** @type {boolean} */
6554 support.clearCloneStyle = "content-box" === div.style.backgroundClip;
6555 jQuery.extend(support, {
6556 boxSizingReliable : function() {
6557 return fn(), o;
6558 },
6559 pixelBoxStyles : function() {
6560 return fn(), i;
6561 },
6562 pixelPosition : function() {
6563 return fn(), res;
6564 },
6565 reliableMarginLeft : function() {
6566 return fn(), s;
6567 },
6568 scrollboxSize : function() {
6569 return fn(), r;
6570 },
6571 reliableTrDimensions : function() {
6572 if (null == a) {
6573 var container = document.createElement("table");
6574 var parent = document.createElement("tr");
6575 var dataTick = document.createElement("div");
6576 /** @type {string} */
6577 container.style.cssText = "position:absolute;left:-11111px";
6578 /** @type {string} */
6579 parent.style.height = "1px";
6580 /** @type {string} */
6581 dataTick.style.height = "9px";
6582 element.appendChild(container).appendChild(parent).appendChild(dataTick);
6583 parent = window.getComputedStyle(parent);
6584 /** @type {boolean} */
6585 a = 3 < parseInt(parent.height);
6586 element.removeChild(container);
6587 }
6588 return a;
6589 }
6590 });
6591 }
6592 }();
6593 /** @type {!Array} */
6594 var prefixes = ["Webkit", "Moz", "ms"];
6595 var style = document.createElement("div").style;
6596 var params = {};
6597 /** @type {!RegExp} */
6598 var assert = /^(none|table(?!-c[ea]).+)/;
6599 /** @type {!RegExp} */
6600 var testRxp = /^--/;
6601 var props = {
6602 position : "absolute",
6603 visibility : "hidden",
6604 display : "block"
6605 };
6606 var cssNormalTransform = {
6607 letterSpacing : "0",
6608 fontWeight : "400"
6609 };
6610 jQuery.extend({
6611 cssHooks : {
6612 opacity : {
6613 get : function(val, data) {
6614 if (data) {
6615 return "" === (val = curCSS(val, "opacity")) ? "1" : val;
6616 }
6617 }
6618 }
6619 },
6620 cssNumber : {
6621 animationIterationCount : true,
6622 columnCount : true,
6623 fillOpacity : true,
6624 flexGrow : true,
6625 flexShrink : true,
6626 fontWeight : true,
6627 gridArea : true,
6628 gridColumn : true,
6629 gridColumnEnd : true,
6630 gridColumnStart : true,
6631 gridRow : true,
6632 gridRowEnd : true,
6633 gridRowStart : true,
6634 lineHeight : true,
6635 opacity : true,
6636 order : true,
6637 orphans : true,
6638 widows : true,
6639 zIndex : true,
6640 zoom : true
6641 },
6642 cssProps : {},
6643 style : function(elem, name, value, extra) {
6644 if (elem && 3 !== elem.nodeType && 8 !== elem.nodeType && elem.style) {
6645 var ret;
6646 var prop = camelCase(name);
6647 /** @type {boolean} */
6648 var versionByName = testRxp.test(name);
6649 var style = elem.style;
6650 if (!versionByName) {
6651 name = camelize(prop);
6652 }
6653 var hooks = jQuery.cssHooks[name] || jQuery.cssHooks[prop];
6654 if (void 0 === value) {
6655 return hooks && "get" in hooks && void 0 !== (ret = hooks.get(elem, false, extra)) ? ret : style[name];
6656 }
6657 /** @type {string} */
6658 var type = typeof value;
6659 if ("string" === type && (ret = regex.exec(value)) && ret[1]) {
6660 value = adjustCSS(elem, name, ret);
6661 /** @type {string} */
6662 type = "number";
6663 }
6664 if (null != value && value == value) {
6665 if (!("number" !== type || versionByName)) {
6666 /** @type {string} */
6667 value = value + (ret && ret[3] || (jQuery.cssNumber[prop] ? "" : "px"));
6668 }
6669 if (!(support.clearCloneStyle || "" !== value || 0 !== name.indexOf("background"))) {
6670 /** @type {string} */
6671 style[name] = "inherit";
6672 }
6673 if (!(hooks && "set" in hooks && void 0 === (value = hooks.set(elem, value, extra)))) {
6674 if (versionByName) {
6675 style.setProperty(name, value);
6676 } else {
6677 /** @type {string} */
6678 style[name] = value;
6679 }
6680 }
6681 }
6682 }
6683 },
6684 css : function(value, name, key, styles) {
6685 var val;
6686 var prop = camelCase(name);
6687 return testRxp.test(name) || (name = camelize(prop)), (prop = jQuery.cssHooks[name] || jQuery.cssHooks[prop]) && "get" in prop && (val = prop.get(value, true, key)), void 0 === val && (val = curCSS(value, name, styles)), "normal" === val && name in cssNormalTransform && (val = cssNormalTransform[name]), "" === key || key ? (value = parseFloat(val), true === key || isFinite(value) ? value || 0 : val) : val;
6688 }
6689 });
6690 jQuery.each(["height", "width"], function(canCreateDiscussions, name) {
6691 jQuery.cssHooks[name] = {
6692 get : function(item, data, options) {
6693 if (data) {
6694 return !assert.test(jQuery.css(item, "display")) || item.getClientRects().length && item.getBoundingClientRect().width ? load(item, name, options) : extend(item, props, function() {
6695 return load(item, name, options);
6696 });
6697 }
6698 },
6699 set : function(elem, value, o) {
6700 var matches;
6701 var styles = getStyles(elem);
6702 /** @type {boolean} */
6703 var stream = !support.scrollboxSize() && "absolute" === styles.position;
6704 var valueIsBorderBox = (stream || o) && "border-box" === jQuery.css(elem, "boxSizing", false, styles);
6705 return o = o ? augmentWidthOrHeight(elem, name, o, valueIsBorderBox, styles) : 0, valueIsBorderBox && stream && (o = o - Math.ceil(elem["offset" + name[0].toUpperCase() + name.slice(1)] - parseFloat(styles[name]) - augmentWidthOrHeight(elem, name, "border", false, styles) - .5)), o && (matches = regex.exec(value)) && "px" !== (matches[3] || "px") && (elem.style[name] = value, value = jQuery.css(elem, name)), func(elem, value, o);
6706 }
6707 };
6708 });
6709 jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function(parent, canCreateDiscussions) {
6710 if (canCreateDiscussions) {
6711 return (parseFloat(curCSS(parent, "marginLeft")) || parent.getBoundingClientRect().left - extend(parent, {
6712 marginLeft : 0
6713 }, function() {
6714 return parent.getBoundingClientRect().left;
6715 })) + "px";
6716 }
6717 });
6718 jQuery.each({
6719 margin : "",
6720 padding : "",
6721 border : "Width"
6722 }, function(prefix, suffix) {
6723 jQuery.cssHooks[prefix + suffix] = {
6724 expand : function(keys) {
6725 /** @type {number} */
6726 var i = 0;
6727 var expanded = {};
6728 /** @type {!Array} */
6729 keys = "string" == typeof keys ? keys.split(" ") : [keys];
6730 for (; 4 > i; i++) {
6731 expanded[prefix + cssExpand[i] + suffix] = keys[i] || keys[i - 2] || keys[0];
6732 }
6733 return expanded;
6734 }
6735 };
6736 if ("margin" !== prefix) {
6737 /** @type {function(!Object, !Object, string): ?} */
6738 jQuery.cssHooks[prefix + suffix].set = func;
6739 }
6740 });
6741 jQuery.fn.extend({
6742 css : function(value, name) {
6743 return access(this, function(key, name, value) {
6744 var l;
6745 var obj = {};
6746 /** @type {number} */
6747 var i = 0;
6748 if (Array.isArray(name)) {
6749 value = getStyles(key);
6750 l = name.length;
6751 for (; i < l; i++) {
6752 obj[name[i]] = jQuery.css(key, name[i], false, value);
6753 }
6754 return obj;
6755 }
6756 return void 0 !== value ? jQuery.style(key, name, value) : jQuery.css(key, name);
6757 }, value, name, 1 < arguments.length);
6758 }
6759 });
6760 /** @type {function(!Object, string, string, !Object, string): ?} */
6761 jQuery.Tween = Tween;
6762 Tween.prototype = {
6763 constructor : Tween,
6764 init : function(value, name, prop, target, easing, unit) {
6765 /** @type {!Object} */
6766 this.elem = value;
6767 /** @type {string} */
6768 this.prop = prop;
6769 this.easing = easing || jQuery.easing._default;
6770 /** @type {!Object} */
6771 this.options = name;
6772 this.start = this.now = this.cur();
6773 /** @type {number} */
6774 this.end = target;
6775 this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
6776 },
6777 cur : function() {
6778 var hooks = Tween.propHooks[this.prop];
6779 return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
6780 },
6781 run : function(percent) {
6782 var eased;
6783 var hooks = Tween.propHooks[this.prop];
6784 return this.pos = eased = this.options.duration ? jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration) : percent, this.now = (this.end - this.start) * eased + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), hooks && hooks.set ? hooks.set(this) : Tween.propHooks._default.set(this), this;
6785 }
6786 };
6787 Tween.prototype.init.prototype = Tween.prototype;
6788 Tween.propHooks = {
6789 _default : {
6790 get : function(s) {
6791 return 1 !== s.elem.nodeType || null != s.elem[s.prop] && null == s.elem.style[s.prop] ? s.elem[s.prop] : (s = jQuery.css(s.elem, s.prop, "")) && "auto" !== s ? s : 0;
6792 },
6793 set : function(options) {
6794 if (jQuery.fx.step[options.prop]) {
6795 jQuery.fx.step[options.prop](options);
6796 } else {
6797 if (1 !== options.elem.nodeType || !jQuery.cssHooks[options.prop] && null == options.elem.style[camelize(options.prop)]) {
6798 options.elem[options.prop] = options.now;
6799 } else {
6800 jQuery.style(options.elem, options.prop, options.now + options.unit);
6801 }
6802 }
6803 }
6804 }
6805 };
6806 Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
6807 set : function(target) {
6808 if (target.elem.nodeType && target.elem.parentNode) {
6809 target.elem[target.prop] = target.now;
6810 }
6811 }
6812 };
6813 jQuery.easing = {
6814 linear : function(p) {
6815 return p;
6816 },
6817 swing : function(p) {
6818 return .5 - Math.cos(p * Math.PI) / 2;
6819 },
6820 _default : "swing"
6821 };
6822 /** @type {function(!Object, !Object, string, number, string, !Object): undefined} */
6823 jQuery.fx = Tween.prototype.init;
6824 jQuery.fx.step = {};
6825 var fxNow;
6826 var pt;
6827 /** @type {!RegExp} */
6828 var trueRE = /^(?:toggle|show|hide)$/;
6829 /** @type {!RegExp} */
6830 var rrun = /queueHooks$/;
6831 jQuery.Animation = jQuery.extend(Animation, {
6832 tweeners : {
6833 "*" : [function(prop, value) {
6834 var tween = this.createTween(prop, value);
6835 return adjustCSS(tween.elem, prop, regex.exec(value), tween), tween;
6836 }]
6837 },
6838 tweener : function(props, callback) {
6839 if (fn(props)) {
6840 /** @type {!Object} */
6841 callback = props;
6842 /** @type {!Array} */
6843 props = ["*"];
6844 } else {
6845 props = props.match(re);
6846 }
6847 var prop;
6848 /** @type {number} */
6849 var i = 0;
6850 var inputsSize = props.length;
6851 for (; i < inputsSize; i++) {
6852 prop = props[i];
6853 Animation.tweeners[prop] = Animation.tweeners[prop] || [];
6854 Animation.tweeners[prop].unshift(callback);
6855 }
6856 },
6857 prefilters : [function(elem, props, config) {
6858 var prop;
6859 /** @type {boolean} */
6860 var display = "width" in props || "height" in props;
6861 var anim = this;
6862 var orig = {};
6863 var style = elem.style;
6864 var hidden = elem.nodeType && isHidden(elem);
6865 var dataShow = dataPriv.get(elem, "fxshow");
6866 if (!config.queue) {
6867 var hooks = jQuery._queueHooks(elem, "fx");
6868 if (null == hooks.unqueued) {
6869 /** @type {number} */
6870 hooks.unqueued = 0;
6871 var fire = hooks.empty.fire;
6872 /**
6873 * @return {undefined}
6874 */
6875 hooks.empty.fire = function() {
6876 if (!hooks.unqueued) {
6877 fire();
6878 }
6879 };
6880 }
6881 hooks.unqueued++;
6882 anim.always(function() {
6883 anim.always(function() {
6884 hooks.unqueued--;
6885 if (!jQuery.queue(elem, "fx").length) {
6886 hooks.empty.fire();
6887 }
6888 });
6889 });
6890 }
6891 for (prop in props) {
6892 var value = props[prop];
6893 if (trueRE.test(value)) {
6894 delete props[prop];
6895 /** @type {boolean} */
6896 var match = match || "toggle" === value;
6897 if (value === (hidden ? "hide" : "show")) {
6898 if ("show" !== value || !dataShow || void 0 === dataShow[prop]) {
6899 continue;
6900 }
6901 /** @type {boolean} */
6902 hidden = true;
6903 }
6904 orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
6905 }
6906 }
6907 if ((props = !jQuery.isEmptyObject(props)) || !jQuery.isEmptyObject(orig)) {
6908 if (display && 1 === elem.nodeType) {
6909 /** @type {!Array} */
6910 config.overflow = [style.overflow, style.overflowX, style.overflowY];
6911 var restoreDisplay = dataShow && dataShow.display;
6912 if (null == restoreDisplay) {
6913 restoreDisplay = dataPriv.get(elem, "display");
6914 }
6915 if ("none" === (display = jQuery.css(elem, "display"))) {
6916 if (restoreDisplay) {
6917 display = restoreDisplay;
6918 } else {
6919 show([elem], true);
6920 restoreDisplay = elem.style.display || restoreDisplay;
6921 display = jQuery.css(elem, "display");
6922 show([elem]);
6923 }
6924 }
6925 if (("inline" === display || "inline-block" === display && null != restoreDisplay) && "none" === jQuery.css(elem, "float")) {
6926 if (!props) {
6927 anim.done(function() {
6928 style.display = restoreDisplay;
6929 });
6930 if (null == restoreDisplay) {
6931 display = style.display;
6932 restoreDisplay = "none" === display ? "" : display;
6933 }
6934 }
6935 /** @type {string} */
6936 style.display = "inline-block";
6937 }
6938 }
6939 for (prop in config.overflow && (style.overflow = "hidden", anim.always(function() {
6940 style.overflow = config.overflow[0];
6941 style.overflowX = config.overflow[1];
6942 style.overflowY = config.overflow[2];
6943 })), props = false, orig) {
6944 if (!props) {
6945 if (dataShow) {
6946 if ("hidden" in dataShow) {
6947 hidden = dataShow.hidden;
6948 }
6949 } else {
6950 dataShow = dataPriv.access(elem, "fxshow", {
6951 display : restoreDisplay
6952 });
6953 }
6954 if (match) {
6955 /** @type {boolean} */
6956 dataShow.hidden = !hidden;
6957 }
6958 if (hidden) {
6959 show([elem], true);
6960 }
6961 anim.done(function() {
6962 for (prop in hidden || show([elem]), dataPriv.remove(elem, "fxshow"), orig) {
6963 jQuery.style(elem, prop, orig[prop]);
6964 }
6965 });
6966 }
6967 props = createTween(hidden ? dataShow[prop] : 0, prop, anim);
6968 if (!(prop in dataShow)) {
6969 dataShow[prop] = props.start;
6970 if (hidden) {
6971 props.end = props.start;
6972 /** @type {number} */
6973 props.start = 0;
6974 }
6975 }
6976 }
6977 }
6978 }],
6979 prefilter : function(callback, options) {
6980 if (options) {
6981 Animation.prefilters.unshift(callback);
6982 } else {
6983 Animation.prefilters.push(callback);
6984 }
6985 }
6986 });
6987 /**
6988 * @param {string} value
6989 * @param {string} name
6990 * @param {string} text
6991 * @return {?}
6992 */
6993 jQuery.speed = function(value, name, text) {
6994 var opt = value && "object" == typeof value ? jQuery.extend({}, value) : {
6995 complete : text || !text && name || fn(value) && value,
6996 duration : value,
6997 easing : text && name || name && !fn(name) && name
6998 };
6999 return jQuery.fx.off ? opt.duration = 0 : "number" != typeof opt.duration && (opt.duration = opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default), null != opt.queue && true !== opt.queue || (opt.queue = "fx"), opt.old = opt.complete, opt.complete = function() {
7000 if (fn(opt.old)) {
7001 opt.old.call(this);
7002 }
7003 if (opt.queue) {
7004 jQuery.dequeue(this, opt.queue);
7005 }
7006 }, opt;
7007 };
7008 jQuery.fn.extend({
7009 fadeTo : function(o, to, callback, context) {
7010 return this.filter(isHidden).css("opacity", 0).show().end().animate({
7011 opacity : to
7012 }, o, callback, context);
7013 },
7014 animate : function(prop, callback, easing, value) {
7015 var empty = jQuery.isEmptyObject(prop);
7016 var optall = jQuery.speed(callback, easing, value);
7017 return (callback = function() {
7018 var anim = Animation(this, jQuery.extend({}, prop), optall);
7019 if (empty || dataPriv.get(this, "finish")) {
7020 anim.stop(true);
7021 }
7022 }).finish = callback, empty || false === optall.queue ? this.each(callback) : this.queue(optall.queue, callback);
7023 },
7024 stop : function(type, name, event) {
7025 /**
7026 * @param {!Object} hooks
7027 * @return {undefined}
7028 */
7029 var stopQueue = function(hooks) {
7030 var stop = hooks.stop;
7031 delete hooks.stop;
7032 stop(event);
7033 };
7034 return "string" != typeof type && (event = name, name = type, type = void 0), name && this.queue(type || "fx", []), this.each(function() {
7035 /** @type {boolean} */
7036 var input = true;
7037 /** @type {(boolean|string)} */
7038 var index = null != type && type + "queueHooks";
7039 /** @type {!Array} */
7040 var timers = jQuery.timers;
7041 var data = dataPriv.get(this);
7042 if (index) {
7043 if (data[index] && data[index].stop) {
7044 stopQueue(data[index]);
7045 }
7046 } else {
7047 for (index in data) {
7048 if (data[index] && data[index].stop && rrun.test(index)) {
7049 stopQueue(data[index]);
7050 }
7051 }
7052 }
7053 /** @type {number} */
7054 index = timers.length;
7055 for (; index--;) {
7056 if (!(timers[index].elem !== this || null != type && timers[index].queue !== type)) {
7057 timers[index].anim.stop(event);
7058 /** @type {boolean} */
7059 input = false;
7060 timers.splice(index, 1);
7061 }
7062 }
7063 if (!(!input && event)) {
7064 jQuery.dequeue(this, type);
7065 }
7066 });
7067 },
7068 finish : function(type) {
7069 return false !== type && (type = type || "fx"), this.each(function() {
7070 var data = dataPriv.get(this);
7071 var queue = data[type + "queue"];
7072 var index = data[type + "queueHooks"];
7073 /** @type {!Array} */
7074 var timers = jQuery.timers;
7075 var length = queue ? queue.length : 0;
7076 /** @type {boolean} */
7077 data.finish = true;
7078 jQuery.queue(this, type, []);
7079 if (index && index.stop) {
7080 index.stop.call(this, true);
7081 }
7082 /** @type {number} */
7083 index = timers.length;
7084 for (; index--;) {
7085 if (timers[index].elem === this && timers[index].queue === type) {
7086 timers[index].anim.stop(true);
7087 timers.splice(index, 1);
7088 }
7089 }
7090 /** @type {number} */
7091 index = 0;
7092 for (; index < length; index++) {
7093 if (queue[index] && queue[index].finish) {
7094 queue[index].finish.call(this);
7095 }
7096 }
7097 delete data.finish;
7098 });
7099 }
7100 });
7101 jQuery.each(["toggle", "show", "hide"], function(canCreateDiscussions, name) {
7102 var cssFn = jQuery.fn[name];
7103 /**
7104 * @param {!Object} x
7105 * @param {string} callback
7106 * @param {string} delay
7107 * @return {?}
7108 */
7109 jQuery.fn[name] = function(x, callback, delay) {
7110 return null == x || "boolean" == typeof x ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), x, callback, delay);
7111 };
7112 });
7113 jQuery.each({
7114 slideDown : genFx("show"),
7115 slideUp : genFx("hide"),
7116 slideToggle : genFx("toggle"),
7117 fadeIn : {
7118 opacity : "show"
7119 },
7120 fadeOut : {
7121 opacity : "hide"
7122 },
7123 fadeToggle : {
7124 opacity : "toggle"
7125 }
7126 }, function(original, props) {
7127 /**
7128 * @param {!Function} fn
7129 * @param {string} callback
7130 * @param {string} delay
7131 * @return {?}
7132 */
7133 jQuery.fn[original] = function(fn, callback, delay) {
7134 return this.animate(props, fn, callback, delay);
7135 };
7136 });
7137 /** @type {!Array} */
7138 jQuery.timers = [];
7139 /**
7140 * @return {undefined}
7141 */
7142 jQuery.fx.tick = function() {
7143 /** @type {number} */
7144 var i = 0;
7145 /** @type {!Array} */
7146 var timers = jQuery.timers;
7147 /** @type {number} */
7148 fxNow = Date.now();
7149 for (; i < timers.length; i++) {
7150 var start = timers[i];
7151 if (!(start() || timers[i] !== start)) {
7152 timers.splice(i--, 1);
7153 }
7154 }
7155 if (!timers.length) {
7156 jQuery.fx.stop();
7157 }
7158 fxNow = void 0;
7159 };
7160 /**
7161 * @param {?} url
7162 * @return {undefined}
7163 */
7164 jQuery.fx.timer = function(url) {
7165 jQuery.timers.push(url);
7166 jQuery.fx.start();
7167 };
7168 /** @type {number} */
7169 jQuery.fx.interval = 13;
7170 /**
7171 * @return {undefined}
7172 */
7173 jQuery.fx.start = function() {
7174 if (!pt) {
7175 /** @type {boolean} */
7176 pt = true;
7177 step();
7178 }
7179 };
7180 /**
7181 * @return {undefined}
7182 */
7183 jQuery.fx.stop = function() {
7184 /** @type {null} */
7185 pt = null;
7186 };
7187 jQuery.fx.speeds = {
7188 slow : 600,
7189 fast : 200,
7190 _default : 400
7191 };
7192 /**
7193 * @param {?} duration
7194 * @param {!Object} type
7195 * @return {?}
7196 */
7197 jQuery.fn.delay = function(duration, type) {
7198 return duration = jQuery.fx && jQuery.fx.speeds[duration] || duration, this.queue(type || "fx", function(animate, incoming_item) {
7199 var timer = window.setTimeout(animate, duration);
7200 /**
7201 * @return {undefined}
7202 */
7203 incoming_item.stop = function() {
7204 window.clearTimeout(timer);
7205 };
7206 });
7207 };
7208 (function() {
7209 var elem = document.createElement("input");
7210 var opt = document.createElement("select").appendChild(document.createElement("option"));
7211 /** @type {string} */
7212 elem.type = "checkbox";
7213 /** @type {boolean} */
7214 support.checkOn = "" !== elem.value;
7215 support.optSelected = opt.selected;
7216 /** @type {string} */
7217 (elem = document.createElement("input")).value = "t";
7218 /** @type {string} */
7219 elem.type = "radio";
7220 /** @type {boolean} */
7221 support.radioValue = "t" === elem.value;
7222 })();
7223 var attrHandle = jQuery.expr.attrHandle;
7224 jQuery.fn.extend({
7225 attr : function(type, value) {
7226 return access(this, jQuery.attr, type, value, 1 < arguments.length);
7227 },
7228 removeAttr : function(name) {
7229 return this.each(function() {
7230 jQuery.removeAttr(this, name);
7231 });
7232 }
7233 });
7234 jQuery.extend({
7235 attr : function(elem, name, value) {
7236 var ret;
7237 var hooks;
7238 var type = elem.nodeType;
7239 if (3 !== type && 8 !== type && 2 !== type) {
7240 return void 0 === elem.getAttribute ? jQuery.prop(elem, name, value) : (1 === type && jQuery.isXMLDoc(elem) || (hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? is : void 0)), void 0 !== value ? null === value ? void jQuery.removeAttr(elem, name) : hooks && "set" in hooks && void 0 !== (ret = hooks.set(elem, value, name)) ? ret : (elem.setAttribute(name, value + ""), value) : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name)) ? ret : null ==
7241 (ret = jQuery.find.attr(elem, name)) ? void 0 : ret);
7242 }
7243 },
7244 attrHooks : {
7245 type : {
7246 set : function(b, value) {
7247 if (!support.radioValue && "radio" === value && $(b, "input")) {
7248 var n = b.value;
7249 return b.setAttribute("type", value), n && (b.value = n), value;
7250 }
7251 }
7252 }
7253 },
7254 removeAttr : function(elem, name) {
7255 /** @type {number} */
7256 var callbackCount = 0;
7257 var nameValue = name && name.match(re);
7258 if (nameValue && 1 === elem.nodeType) {
7259 for (; name = nameValue[callbackCount++];) {
7260 elem.removeAttribute(name);
7261 }
7262 }
7263 }
7264 });
7265 var is = {
7266 set : function(elem, value, name) {
7267 return false === value ? jQuery.removeAttr(elem, name) : elem.setAttribute(name, name), name;
7268 }
7269 };
7270 jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(canCreateDiscussions, name) {
7271 var n = attrHandle[name] || jQuery.find.attr;
7272 /**
7273 * @param {(Object|string)} window
7274 * @param {string} status
7275 * @param {undefined} s
7276 * @return {?}
7277 */
7278 attrHandle[name] = function(window, status, s) {
7279 var name = status.toLowerCase();
7280 if (!s) {
7281 var handle = attrHandle[name];
7282 attrHandle[name] = fn2;
7283 var fn2 = null != n(window, status, s) ? name : null;
7284 attrHandle[name] = handle;
7285 }
7286 return fn2;
7287 };
7288 });
7289 /** @type {!RegExp} */
7290 var inputNodeNames = /^(?:input|select|textarea|button)$/i;
7291 /** @type {!RegExp} */
7292 var srsRegex = /^(?:a|area)$/i;
7293 jQuery.fn.extend({
7294 prop : function(type, value) {
7295 return access(this, jQuery.prop, type, value, 1 < arguments.length);
7296 },
7297 removeProp : function(name) {
7298 return this.each(function() {
7299 delete this[jQuery.propFix[name] || name];
7300 });
7301 }
7302 });
7303 jQuery.extend({
7304 prop : function(elem, name, value) {
7305 var ret;
7306 var type = elem.nodeType;
7307 if (3 !== type && 8 !== type && 2 !== type) {
7308 if (1 !== type || !jQuery.isXMLDoc(elem)) {
7309 name = jQuery.propFix[name] || name;
7310 var hooks = jQuery.propHooks[name];
7311 }
7312 return void 0 !== value ? hooks && "set" in hooks && void 0 !== (ret = hooks.set(elem, value, name)) ? ret : elem[name] = value : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name)) ? ret : elem[name];
7313 }
7314 },
7315 propHooks : {
7316 tabIndex : {
7317 get : function(target) {
7318 var b = jQuery.find.attr(target, "tabindex");
7319 return b ? parseInt(b, 10) : inputNodeNames.test(target.nodeName) || srsRegex.test(target.nodeName) && target.href ? 0 : -1;
7320 }
7321 }
7322 },
7323 propFix : {
7324 for : "htmlFor",
7325 class : "className"
7326 }
7327 });
7328 if (!support.optSelected) {
7329 jQuery.propHooks.selected = {
7330 get : function(e) {
7331 return (e = e.parentNode) && e.parentNode && e.parentNode.selectedIndex, null;
7332 },
7333 set : function(elem) {
7334 if (elem = elem.parentNode) {
7335 elem.selectedIndex;
7336 if (elem.parentNode) {
7337 elem.parentNode.selectedIndex;
7338 }
7339 }
7340 }
7341 };
7342 }
7343 jQuery.each("tabIndex readOnly maxLength cellSpacing cellPadding rowSpan colSpan useMap frameBorder contentEditable".split(" "), function() {
7344 jQuery.propFix[this.toLowerCase()] = this;
7345 });
7346 jQuery.fn.extend({
7347 addClass : function(value) {
7348 var elem;
7349 var result;
7350 var _name;
7351 var _i;
7352 /** @type {number} */
7353 var i = 0;
7354 if (fn(value)) {
7355 return this.each(function(i) {
7356 jQuery(this).addClass(value.call(this, i, getClass(this)));
7357 });
7358 }
7359 var _ref = trim(value);
7360 if (_ref.length) {
7361 for (; elem = this[i++];) {
7362 var type = getClass(elem);
7363 if (result = 1 === elem.nodeType && " " + log(type) + " ") {
7364 /** @type {number} */
7365 _i = 0;
7366 for (; _name = _ref[_i++];) {
7367 if (0 > result.indexOf(" " + _name + " ")) {
7368 /** @type {string} */
7369 result = result + (_name + " ");
7370 }
7371 }
7372 if (type !== (result = log(result))) {
7373 elem.setAttribute("class", result);
7374 }
7375 }
7376 }
7377 }
7378 return this;
7379 },
7380 removeClass : function(value) {
7381 var elem;
7382 var b;
7383 var selectedMarkIndent;
7384 var pos;
7385 /** @type {number} */
7386 var i = 0;
7387 if (fn(value)) {
7388 return this.each(function(i) {
7389 jQuery(this).removeClass(value.call(this, i, getClass(this)));
7390 });
7391 }
7392 if (!arguments.length) {
7393 return this.attr("class", "");
7394 }
7395 var m = trim(value);
7396 if (m.length) {
7397 for (; elem = this[i++];) {
7398 var v = getClass(elem);
7399 if (b = 1 === elem.nodeType && " " + log(v) + " ") {
7400 /** @type {number} */
7401 pos = 0;
7402 for (; selectedMarkIndent = m[pos++];) {
7403 for (; -1 < b.indexOf(" " + selectedMarkIndent + " ");) {
7404 /** @type {string} */
7405 b = b.replace(" " + selectedMarkIndent + " ", " ");
7406 }
7407 }
7408 if (v !== (b = log(b))) {
7409 elem.setAttribute("class", b);
7410 }
7411 }
7412 }
7413 }
7414 return this;
7415 },
7416 toggleClass : function(value, stateVal) {
7417 /** @type {string} */
7418 var undefined = typeof value;
7419 /** @type {boolean} */
7420 var o = "string" === undefined || Array.isArray(value);
7421 return "boolean" == typeof stateVal && o ? stateVal ? this.addClass(value) : this.removeClass(value) : fn(value) ? this.each(function(i) {
7422 jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
7423 }) : this.each(function() {
7424 var className;
7425 var ret;
7426 if (o) {
7427 /** @type {number} */
7428 var r = 0;
7429 var $t = jQuery(this);
7430 ret = trim(value);
7431 for (; className = ret[r++];) {
7432 if ($t.hasClass(className)) {
7433 $t.removeClass(className);
7434 } else {
7435 $t.addClass(className);
7436 }
7437 }
7438 } else {
7439 if (!(void 0 !== value && "boolean" !== undefined)) {
7440 if (className = getClass(this)) {
7441 dataPriv.set(this, "__className__", className);
7442 }
7443 if (this.setAttribute) {
7444 this.setAttribute("class", className || false === value ? "" : dataPriv.get(this, "__className__") || "");
7445 }
7446 }
7447 }
7448 });
7449 },
7450 hasClass : function(className) {
7451 var value;
7452 /** @type {number} */
7453 var n = 0;
7454 /** @type {string} */
7455 className = " " + className + " ";
7456 for (; value = this[n++];) {
7457 if (1 === value.nodeType && -1 < (" " + log(getClass(value)) + " ").indexOf(className)) {
7458 return true;
7459 }
7460 }
7461 return false;
7462 }
7463 });
7464 /** @type {!RegExp} */
7465 var n = /\r/g;
7466 jQuery.fn.extend({
7467 val : function(obj) {
7468 var hooks;
7469 var value;
7470 var elem = this[0];
7471 if (arguments.length) {
7472 var key = fn(obj);
7473 return this.each(function(value) {
7474 if (1 === this.nodeType) {
7475 if (null == (value = key ? obj.call(this, value, jQuery(this).val()) : obj)) {
7476 /** @type {string} */
7477 value = "";
7478 } else {
7479 if ("number" == typeof value) {
7480 /** @type {string} */
7481 value = value + "";
7482 } else {
7483 if (Array.isArray(value)) {
7484 value = jQuery.map(value, function(value) {
7485 return null == value ? "" : value + "";
7486 });
7487 }
7488 }
7489 }
7490 if (!((hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]) && "set" in hooks && void 0 !== hooks.set(this, value, "value"))) {
7491 /** @type {string} */
7492 this.value = value;
7493 }
7494 }
7495 });
7496 }
7497 if (elem) {
7498 return (hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()]) && "get" in hooks && void 0 !== (value = hooks.get(elem, "value")) ? value : "string" == typeof(value = elem.value) ? value.replace(n, "") : null == value ? "" : value;
7499 }
7500 }
7501 });
7502 jQuery.extend({
7503 valHooks : {
7504 option : {
7505 get : function(key) {
7506 var isInvalid = jQuery.find.attr(key, "value");
7507 return null != isInvalid ? isInvalid : log(jQuery.text(key));
7508 }
7509 },
7510 select : {
7511 get : function(e) {
7512 var cs = e.options;
7513 var position = e.selectedIndex;
7514 /** @type {boolean} */
7515 var after = "select-one" === e.type;
7516 /** @type {(Array|null)} */
7517 var index = after ? null : [];
7518 var t = after ? position + 1 : cs.length;
7519 e = 0 > position ? t : after ? position : 0;
7520 for (; e < t; e++) {
7521 var s = cs[e];
7522 if (!(!s.selected && e !== position || s.disabled || s.parentNode.disabled && $(s.parentNode, "optgroup"))) {
7523 if (s = jQuery(s).val(), after) {
7524 return s;
7525 }
7526 index.push(s);
7527 }
7528 }
7529 return index;
7530 },
7531 set : function(instance, data) {
7532 var outputFn;
7533 var o = instance.options;
7534 var result = jQuery.makeArray(data);
7535 var i = o.length;
7536 for (; i--;) {
7537 if ((data = o[i]).selected = -1 < jQuery.inArray(jQuery.valHooks.option.get(data), result)) {
7538 /** @type {boolean} */
7539 outputFn = true;
7540 }
7541 }
7542 return outputFn || (instance.selectedIndex = -1), result;
7543 }
7544 }
7545 }
7546 });
7547 jQuery.each(["radio", "checkbox"], function() {
7548 jQuery.valHooks[this] = {
7549 set : function(elem, value) {
7550 if (Array.isArray(value)) {
7551 return elem.checked = -1 < jQuery.inArray(jQuery(elem).val(), value);
7552 }
7553 }
7554 };
7555 if (!support.checkOn) {
7556 /**
7557 * @param {!Object} value
7558 * @return {?}
7559 */
7560 jQuery.valHooks[this].get = function(value) {
7561 return null === value.getAttribute("value") ? "on" : value.value;
7562 };
7563 }
7564 });
7565 /** @type {boolean} */
7566 support.focusin = "onfocusin" in window;
7567 /** @type {!RegExp} */
7568 var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
7569 /**
7570 * @param {!Event} event
7571 * @return {undefined}
7572 */
7573 var eventHandler = function(event) {
7574 event.stopPropagation();
7575 };
7576 jQuery.extend(jQuery.event, {
7577 trigger : function(event, value, elem, onlyHandlers) {
7578 var tmp;
7579 var next;
7580 var child;
7581 /** @type {!Array} */
7582 var eventPath = [elem || document];
7583 var type = hasOwn.call(event, "type") ? event.type : event;
7584 var special = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
7585 var cur = child = tmp = elem = elem || document;
7586 if (3 !== elem.nodeType && 8 !== elem.nodeType && !rfocusMorph.test(type + jQuery.event.triggered)) {
7587 if (-1 < type.indexOf(".")) {
7588 special = type.split(".");
7589 type = special.shift();
7590 special.sort();
7591 }
7592 /** @type {(boolean|string)} */
7593 var ontype = 0 > type.indexOf(":") && "on" + type;
7594 if ((event = event[jQuery.expando] ? event : new jQuery.Event(type, "object" == typeof event && event)).isTrigger = onlyHandlers ? 2 : 3, event.namespace = special.join("."), event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + special.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, event.result = void 0, event.target || (event.target = elem), value = null == value ? [event] : jQuery.makeArray(value, [event]), special = jQuery.event.special[type] || {}, onlyHandlers || !special.trigger ||
7595 false !== special.trigger.apply(elem, value)) {
7596 if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {
7597 var bubbleType = special.delegateType || type;
7598 if (!rfocusMorph.test(bubbleType + type)) {
7599 cur = cur.parentNode;
7600 }
7601 for (; cur; cur = cur.parentNode) {
7602 eventPath.push(cur);
7603 tmp = cur;
7604 }
7605 if (tmp === (elem.ownerDocument || document)) {
7606 eventPath.push(tmp.defaultView || tmp.parentWindow || window);
7607 }
7608 }
7609 /** @type {number} */
7610 tmp = 0;
7611 for (; (cur = eventPath[tmp++]) && !event.isPropagationStopped();) {
7612 child = cur;
7613 event.type = 1 < tmp ? bubbleType : special.bindType || type;
7614 if (next = (dataPriv.get(cur, "events") || Object.create(null))[event.type] && dataPriv.get(cur, "handle")) {
7615 next.apply(cur, value);
7616 }
7617 if ((next = ontype && cur[ontype]) && next.apply && match(cur)) {
7618 event.result = next.apply(cur, value);
7619 if (false === event.result) {
7620 event.preventDefault();
7621 }
7622 }
7623 }
7624 return event.type = type, onlyHandlers || event.isDefaultPrevented() || special._default && false !== special._default.apply(eventPath.pop(), value) || !match(elem) || !ontype || !fn(elem[type]) || isWindow(elem) || ((tmp = elem[ontype]) && (elem[ontype] = null), jQuery.event.triggered = type, event.isPropagationStopped() && child.addEventListener(type, eventHandler), elem[type](), event.isPropagationStopped() && child.removeEventListener(type, eventHandler), jQuery.event.triggered =
7625 void 0, tmp && (elem[ontype] = tmp)), event.result;
7626 }
7627 }
7628 },
7629 simulate : function(data, elem, event) {
7630 data = jQuery.extend(new jQuery.Event, event, {
7631 type : data,
7632 isSimulated : true
7633 });
7634 jQuery.event.trigger(data, null, elem);
7635 }
7636 });
7637 jQuery.fn.extend({
7638 trigger : function(event, data) {
7639 return this.each(function() {
7640 jQuery.event.trigger(event, data, this);
7641 });
7642 },
7643 triggerHandler : function(type, data) {
7644 var parent = this[0];
7645 if (parent) {
7646 return jQuery.event.trigger(type, data, parent, true);
7647 }
7648 }
7649 });
7650 if (!support.focusin) {
7651 jQuery.each({
7652 focus : "focusin",
7653 blur : "focusout"
7654 }, function(orig, fix) {
7655 /**
7656 * @param {(Object|string)} event
7657 * @return {undefined}
7658 */
7659 var handler = function(event) {
7660 jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
7661 };
7662 jQuery.event.special[fix] = {
7663 setup : function() {
7664 var doc = this.ownerDocument || this.document || this;
7665 var attaches = dataPriv.access(doc, fix);
7666 if (!attaches) {
7667 doc.addEventListener(orig, handler, true);
7668 }
7669 dataPriv.access(doc, fix, (attaches || 0) + 1);
7670 },
7671 teardown : function() {
7672 var doc = this.ownerDocument || this.document || this;
7673 /** @type {number} */
7674 var data = dataPriv.access(doc, fix) - 1;
7675 if (data) {
7676 dataPriv.access(doc, fix, data);
7677 } else {
7678 doc.removeEventListener(orig, handler, true);
7679 dataPriv.remove(doc, fix);
7680 }
7681 }
7682 };
7683 });
7684 }
7685 var location = window.location;
7686 /** @type {number} */
7687 var widgetUniqueIDIndex = Date.now();
7688 /** @type {!RegExp} */
7689 var rquery = /\?/;
7690 /**
7691 * @param {string} data
7692 * @return {?}
7693 */
7694 jQuery.parseXML = function(data) {
7695 if (!data || "string" != typeof data) {
7696 return null;
7697 }
7698 try {
7699 var doc = (new window.DOMParser).parseFromString(data, "text/xml");
7700 } catch (e) {
7701 doc = void 0;
7702 }
7703 return doc && !doc.getElementsByTagName("parsererror").length || jQuery.error("Invalid XML: " + data), doc;
7704 };
7705 /** @type {!RegExp} */
7706 var touchSystem = /\[\]$/;
7707 /** @type {!RegExp} */
7708 var reVowels = /\r?\n/g;
7709 /** @type {!RegExp} */
7710 var _tacet = /^(?:submit|button|image|reset|file)$/i;
7711 /** @type {!RegExp} */
7712 var rsubmittable = /^(?:input|select|textarea|keygen)/i;
7713 /**
7714 * @param {?} obj
7715 * @param {string} n
7716 * @return {?}
7717 */
7718 jQuery.param = function(obj, n) {
7719 var p;
7720 /** @type {!Array} */
7721 var displayUsedBy = [];
7722 /**
7723 * @param {?} o
7724 * @param {string} value
7725 * @return {undefined}
7726 */
7727 var add = function(o, value) {
7728 value = fn(value) ? value() : value;
7729 /** @type {string} */
7730 displayUsedBy[displayUsedBy.length] = encodeURIComponent(o) + "=" + encodeURIComponent(null == value ? "" : value);
7731 };
7732 if (null == obj) {
7733 return "";
7734 }
7735 if (Array.isArray(obj) || obj.jquery && !jQuery.isPlainObject(obj)) {
7736 jQuery.each(obj, function() {
7737 add(this.name, this.value);
7738 });
7739 } else {
7740 for (p in obj) {
7741 cb(p, obj[p], n, add);
7742 }
7743 }
7744 return displayUsedBy.join("&");
7745 };
7746 jQuery.fn.extend({
7747 serialize : function() {
7748 return jQuery.param(this.serializeArray());
7749 },
7750 serializeArray : function() {
7751 return this.map(function() {
7752 var elements = jQuery.prop(this, "elements");
7753 return elements ? jQuery.makeArray(elements) : this;
7754 }).filter(function() {
7755 var op = this.type;
7756 return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !_tacet.test(op) && (this.checked || !path.test(op));
7757 }).map(function(val, ctlParams) {
7758 return null == (val = jQuery(this).val()) ? null : Array.isArray(val) ? jQuery.map(val, function(val) {
7759 return {
7760 name : ctlParams.name,
7761 value : val.replace(reVowels, "\r\n")
7762 };
7763 }) : {
7764 name : ctlParams.name,
7765 value : val.replace(reVowels, "\r\n")
7766 };
7767 }).get();
7768 }
7769 });
7770 /** @type {!RegExp} */
7771 var jsre = /%20/g;
7772 /** @type {!RegExp} */
7773 var dijitFormWidgetRegex = /#.*$/;
7774 /** @type {!RegExp} */
7775 var rts = /([?&])_=[^&]*/;
7776 /** @type {!RegExp} */
7777 var rheaders = /^(.*?):[ \t]*([^\r\n]*)$/gm;
7778 /** @type {!RegExp} */
7779 var loader = /^(?:GET|HEAD)$/;
7780 /** @type {!RegExp} */
7781 var rprotocol = /^\/\//;
7782 var prefilters = {};
7783 var transports = {};
7784 /** @type {string} */
7785 var Lt = "*/".concat("*");
7786 var originAnchor = document.createElement("a");
7787 originAnchor.href = location.href;
7788 jQuery.extend({
7789 active : 0,
7790 lastModified : {},
7791 etag : {},
7792 ajaxSettings : {
7793 url : location.href,
7794 type : "GET",
7795 isLocal : /^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(location.protocol),
7796 global : true,
7797 processData : true,
7798 async : true,
7799 contentType : "application/x-www-form-urlencoded; charset=UTF-8",
7800 accepts : {
7801 "*" : Lt,
7802 text : "text/plain",
7803 html : "text/html",
7804 xml : "application/xml, text/xml",
7805 json : "application/json, text/javascript"
7806 },
7807 contents : {
7808 xml : /\bxml\b/,
7809 html : /\bhtml/,
7810 json : /\bjson\b/
7811 },
7812 responseFields : {
7813 xml : "responseXML",
7814 text : "responseText",
7815 json : "responseJSON"
7816 },
7817 converters : {
7818 "* text" : String,
7819 "text html" : true,
7820 "text json" : JSON.parse,
7821 "text xml" : jQuery.parseXML
7822 },
7823 flatOptions : {
7824 url : true,
7825 context : true
7826 }
7827 },
7828 ajaxSetup : function(target, settings) {
7829 return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
7830 },
7831 ajaxPrefilter : addToPrefiltersOrTransports(prefilters),
7832 ajaxTransport : addToPrefiltersOrTransports(transports),
7833 ajax : function(url, options) {
7834 /**
7835 * @param {number} status
7836 * @param {!Object} nativeStatusText
7837 * @param {string} responses
7838 * @param {!Object} isSuccess
7839 * @return {undefined}
7840 */
7841 function done(status, nativeStatusText, responses, isSuccess) {
7842 var response;
7843 /** @type {!Object} */
7844 var statusText = nativeStatusText;
7845 if (!completed) {
7846 if (completed = true, showAboveTimeout && window.clearTimeout(showAboveTimeout), transport = void 0, responseHeadersString = isSuccess || "", jqXHR.readyState = 0 < status ? 4 : 0, isSuccess = 200 <= status && 300 > status || 304 === status, responses && (response = function(s, ajaxRequest, responses) {
7847 var ct;
7848 var type;
7849 var finalDataType;
7850 var firstDataType;
7851 var contents = s.contents;
7852 var dataTypes = s.dataTypes;
7853 for (; "*" === dataTypes[0];) {
7854 dataTypes.shift();
7855 if (void 0 === ct) {
7856 ct = s.mimeType || ajaxRequest.getResponseHeader("Content-Type");
7857 }
7858 }
7859 if (ct) {
7860 for (type in contents) {
7861 if (contents[type] && contents[type].test(ct)) {
7862 dataTypes.unshift(type);
7863 break;
7864 }
7865 }
7866 }
7867 if (dataTypes[0] in responses) {
7868 finalDataType = dataTypes[0];
7869 } else {
7870 for (type in responses) {
7871 if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
7872 /** @type {string} */
7873 finalDataType = type;
7874 break;
7875 }
7876 if (!firstDataType) {
7877 /** @type {string} */
7878 firstDataType = type;
7879 }
7880 }
7881 /** @type {(string|undefined)} */
7882 finalDataType = finalDataType || firstDataType;
7883 }
7884 if (finalDataType) {
7885 return finalDataType !== dataTypes[0] && dataTypes.unshift(finalDataType), responses[finalDataType];
7886 }
7887 }(s, jqXHR, responses)), !isSuccess && -1 < jQuery.inArray("script", s.dataTypes) && (s.converters["text script"] = function() {
7888 }), response = function(s, response, jqXHR, isSuccess) {
7889 var conv2;
7890 var current;
7891 var converters = {};
7892 var resList = s.dataTypes.slice();
7893 if (resList[1]) {
7894 for (conv in s.converters) {
7895 converters[conv.toLowerCase()] = s.converters[conv];
7896 }
7897 }
7898 current = resList.shift();
7899 for (; current;) {
7900 if (s.responseFields[current]) {
7901 /** @type {!Array} */
7902 jqXHR[s.responseFields[current]] = response;
7903 }
7904 if (!value && isSuccess && s.dataFilter) {
7905 response = s.dataFilter(response, s.dataType);
7906 }
7907 var value = current;
7908 if (current = resList.shift()) {
7909 if ("*" === current) {
7910 current = value;
7911 } else {
7912 if ("*" !== value && value !== current) {
7913 var conv = converters[value + " " + current] || converters["* " + current];
7914 if (!conv) {
7915 for (conv2 in converters) {
7916 /** @type {!Array<string>} */
7917 var parts = conv2.split(" ");
7918 if (parts[1] === current && (conv = converters[value + " " + parts[0]] || converters["* " + parts[0]])) {
7919 if (true === conv) {
7920 conv = converters[conv2];
7921 } else {
7922 if (true !== converters[conv2]) {
7923 /** @type {string} */
7924 current = parts[0];
7925 resList.unshift(parts[1]);
7926 }
7927 }
7928 break;
7929 }
7930 }
7931 }
7932 if (true !== conv) {
7933 if (conv && s.throws) {
7934 response = conv(response);
7935 } else {
7936 try {
7937 response = conv(response);
7938 } catch (e) {
7939 return {
7940 state : "parsererror",
7941 error : conv ? e : "No conversion from " + value + " to " + current
7942 };
7943 }
7944 }
7945 }
7946 }
7947 }
7948 }
7949 }
7950 return {
7951 state : "success",
7952 data : response
7953 };
7954 }(s, response, jqXHR, isSuccess), isSuccess) {
7955 if (s.ifModified && ((responses = jqXHR.getResponseHeader("Last-Modified")) && (jQuery.lastModified[cacheURL] = responses), (responses = jqXHR.getResponseHeader("etag")) && (jQuery.etag[cacheURL] = responses)), 204 === status || "HEAD" === s.type) {
7956 /** @type {string} */
7957 statusText = "nocontent";
7958 } else {
7959 if (304 === status) {
7960 /** @type {string} */
7961 statusText = "notmodified";
7962 } else {
7963 statusText = response.state;
7964 var data = response.data;
7965 var error = response.error;
7966 /** @type {boolean} */
7967 isSuccess = !error;
7968 }
7969 }
7970 } else {
7971 error = statusText;
7972 if (status || !statusText) {
7973 /** @type {string} */
7974 statusText = "error";
7975 if (0 > status) {
7976 /** @type {number} */
7977 status = 0;
7978 }
7979 }
7980 }
7981 /** @type {number} */
7982 jqXHR.status = status;
7983 /** @type {string} */
7984 jqXHR.statusText = (nativeStatusText || statusText) + "";
7985 if (isSuccess) {
7986 deferred.resolveWith(obj, [data, statusText, jqXHR]);
7987 } else {
7988 deferred.rejectWith(obj, [jqXHR, statusText, error]);
7989 }
7990 jqXHR.statusCode(statusCode);
7991 statusCode = void 0;
7992 if (l) {
7993 globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? data : error]);
7994 }
7995 completeDeferred.fireWith(obj, [jqXHR, statusText]);
7996 if (l) {
7997 globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
7998 if (!--jQuery.active) {
7999 jQuery.event.trigger("ajaxStop");
8000 }
8001 }
8002 }
8003 }
8004 if ("object" == typeof url) {
8005 /** @type {!Object} */
8006 options = url;
8007 url = void 0;
8008 }
8009 options = options || {};
8010 var transport;
8011 var responseHeadersString;
8012 var marks;
8013 var showAboveTimeout;
8014 var l;
8015 var i;
8016 var s = jQuery.ajaxSetup({}, options);
8017 var obj = s.context || s;
8018 var globalEventContext = s.context && (obj.nodeType || obj.jquery) ? jQuery(obj) : jQuery.event;
8019 var deferred = jQuery.Deferred();
8020 var completeDeferred = jQuery.Callbacks("once memory");
8021 var statusCode = s.statusCode || {};
8022 var data = {};
8023 var requestHeadersNames = {};
8024 /** @type {string} */
8025 var strAbort = "canceled";
8026 var jqXHR = {
8027 readyState : 0,
8028 getResponseHeader : function(header) {
8029 var match;
8030 if (completed) {
8031 if (!marks) {
8032 marks = {};
8033 for (; match = rheaders.exec(responseHeadersString);) {
8034 marks[match[1].toLowerCase() + " "] = (marks[match[1].toLowerCase() + " "] || []).concat(match[2]);
8035 }
8036 }
8037 match = marks[header.toLowerCase() + " "];
8038 }
8039 return null == match ? null : match.join(", ");
8040 },
8041 getAllResponseHeaders : function() {
8042 return completed ? responseHeadersString : null;
8043 },
8044 setRequestHeader : function(name, value) {
8045 return null == completed && (name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name, data[name] = value), this;
8046 },
8047 overrideMimeType : function(type) {
8048 return null == completed && (s.mimeType = type), this;
8049 },
8050 statusCode : function(map) {
8051 var tmp;
8052 if (map) {
8053 if (completed) {
8054 jqXHR.always(map[jqXHR.status]);
8055 } else {
8056 for (tmp in map) {
8057 /** @type {!Array} */
8058 statusCode[tmp] = [statusCode[tmp], map[tmp]];
8059 }
8060 }
8061 }
8062 return this;
8063 },
8064 abort : function(statusText) {
8065 return statusText = statusText || strAbort, transport && transport.abort(statusText), done(0, statusText), this;
8066 }
8067 };
8068 if (deferred.promise(jqXHR), s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//"), s.type = options.method || options.type || s.method || s.type, s.dataTypes = (s.dataType || "*").toLowerCase().match(re) || [""], null == s.crossDomain) {
8069 url = document.createElement("a");
8070 try {
8071 /** @type {string} */
8072 url.href = s.url;
8073 /** @type {string} */
8074 url.href = url.href;
8075 /** @type {boolean} */
8076 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host != url.protocol + "//" + url.host;
8077 } catch (e) {
8078 /** @type {boolean} */
8079 s.crossDomain = true;
8080 }
8081 }
8082 if (s.data && s.processData && "string" != typeof s.data && (s.data = jQuery.param(s.data, s.traditional)), inspectPrefiltersOrTransports(prefilters, s, options, jqXHR), completed) {
8083 return jqXHR;
8084 }
8085 if ((l = jQuery.event && s.global) && 0 == jQuery.active++) {
8086 jQuery.event.trigger("ajaxStart");
8087 }
8088 s.type = s.type.toUpperCase();
8089 /** @type {boolean} */
8090 s.hasContent = !loader.test(s.type);
8091 /** @type {string} */
8092 var cacheURL = s.url.replace(dijitFormWidgetRegex, "");
8093 for (i in s.hasContent ? s.data && s.processData && 0 === (s.contentType || "").indexOf("application/x-www-form-urlencoded") && (s.data = s.data.replace(jsre, "+")) : (url = s.url.slice(cacheURL.length), s.data && (s.processData || "string" == typeof s.data) && (cacheURL = cacheURL + ((rquery.test(cacheURL) ? "&" : "?") + s.data), delete s.data), false === s.cache && (cacheURL = cacheURL.replace(rts, "$1"), url = (rquery.test(cacheURL) ? "&" : "?") + "_=" + widgetUniqueIDIndex++ + url), s.url =
8094 cacheURL + url), s.ifModified && (jQuery.lastModified[cacheURL] && jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]), jQuery.etag[cacheURL] && jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL])), (s.data && s.hasContent && false !== s.contentType || options.contentType) && jqXHR.setRequestHeader("Content-Type", s.contentType), jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + ("*" !== s.dataTypes[0] ?
8095 ", " + Lt + "; q=0.01" : "") : s.accepts["*"]), s.headers) {
8096 jqXHR.setRequestHeader(i, s.headers[i]);
8097 }
8098 if (s.beforeSend && (false === s.beforeSend.call(obj, jqXHR, s) || completed)) {
8099 return jqXHR.abort();
8100 }
8101 if (strAbort = "abort", completeDeferred.add(s.complete), jqXHR.done(s.success), jqXHR.fail(s.error), transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR)) {
8102 if (jqXHR.readyState = 1, l && globalEventContext.trigger("ajaxSend", [jqXHR, s]), completed) {
8103 return jqXHR;
8104 }
8105 if (s.async && 0 < s.timeout) {
8106 showAboveTimeout = window.setTimeout(function() {
8107 jqXHR.abort("timeout");
8108 }, s.timeout);
8109 }
8110 try {
8111 /** @type {boolean} */
8112 var completed = false;
8113 transport.send(data, done);
8114 } catch (success) {
8115 if (completed) {
8116 throw success;
8117 }
8118 done(-1, success);
8119 }
8120 } else {
8121 done(-1, "No Transport");
8122 }
8123 return jqXHR;
8124 },
8125 getJSON : function(data, options, callback) {
8126 return jQuery.get(data, options, callback, "json");
8127 },
8128 getScript : function(fn, callback) {
8129 return jQuery.get(fn, void 0, callback, "script");
8130 }
8131 });
8132 jQuery.each(["get", "post"], function(canCreateDiscussions, method) {
8133 /**
8134 * @param {!Object} url
8135 * @param {!Object} e
8136 * @param {!Object} s
8137 * @param {!Object} o
8138 * @return {?}
8139 */
8140 jQuery[method] = function(url, e, s, o) {
8141 return fn(e) && (o = o || s, s = e, e = void 0), jQuery.ajax(jQuery.extend({
8142 url : url,
8143 type : method,
8144 dataType : o,
8145 data : e,
8146 success : s
8147 }, jQuery.isPlainObject(url) && url));
8148 };
8149 });
8150 jQuery.ajaxPrefilter(function(settings) {
8151 var name;
8152 for (name in settings.headers) {
8153 if ("content-type" === name.toLowerCase()) {
8154 settings.contentType = settings.headers[name] || "";
8155 }
8156 }
8157 });
8158 /**
8159 * @param {string} url
8160 * @param {string} context
8161 * @param {!Object} args
8162 * @return {?}
8163 */
8164 jQuery._evalUrl = function(url, context, args) {
8165 return jQuery.ajax({
8166 url : url,
8167 type : "GET",
8168 dataType : "script",
8169 cache : true,
8170 async : false,
8171 global : false,
8172 converters : {
8173 "text script" : function() {
8174 }
8175 },
8176 dataFilter : function(text) {
8177 jQuery.globalEval(text, context, args);
8178 }
8179 });
8180 };
8181 jQuery.fn.extend({
8182 wrapAll : function(e) {
8183 return this[0] && (fn(e) && (e = e.call(this[0])), e = jQuery(e, this[0].ownerDocument).eq(0).clone(true), this[0].parentNode && e.insertBefore(this[0]), e.map(function() {
8184 var elem = this;
8185 for (; elem.firstElementChild;) {
8186 elem = elem.firstElementChild;
8187 }
8188 return elem;
8189 }).append(this)), this;
8190 },
8191 wrapInner : function(wrapper) {
8192 return fn(wrapper) ? this.each(function(i) {
8193 jQuery(this).wrapInner(wrapper.call(this, i));
8194 }) : this.each(function() {
8195 var fixture = jQuery(this);
8196 var clone = fixture.contents();
8197 if (clone.length) {
8198 clone.wrapAll(wrapper);
8199 } else {
8200 fixture.append(wrapper);
8201 }
8202 });
8203 },
8204 wrap : function(html) {
8205 var isFunction = fn(html);
8206 return this.each(function(i) {
8207 jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
8208 });
8209 },
8210 unwrap : function(data) {
8211 return this.parent(data).not("body").each(function() {
8212 jQuery(this).replaceWith(this.childNodes);
8213 }), this;
8214 }
8215 });
8216 /**
8217 * @param {string} value
8218 * @return {?}
8219 */
8220 jQuery.expr.pseudos.hidden = function(value) {
8221 return !jQuery.expr.pseudos.visible(value);
8222 };
8223 /**
8224 * @param {!Element} elem
8225 * @return {?}
8226 */
8227 jQuery.expr.pseudos.visible = function(elem) {
8228 return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
8229 };
8230 /**
8231 * @return {?}
8232 */
8233 jQuery.ajaxSettings.xhr = function() {
8234 try {
8235 return new window.XMLHttpRequest;
8236 } catch (e) {
8237 }
8238 };
8239 var xhrSuccessStatus = {
8240 0 : 200,
8241 1223 : 204
8242 };
8243 var xhrSupported = jQuery.ajaxSettings.xhr();
8244 /** @type {boolean} */
8245 support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
8246 /** @type {boolean} */
8247 support.ajax = xhrSupported = !!xhrSupported;
8248 jQuery.ajaxTransport(function(s) {
8249 var callback;
8250 var errorCallback;
8251 if (support.cors || xhrSupported && !s.crossDomain) {
8252 return {
8253 send : function(headers, callback) {
8254 var i;
8255 var xhr = s.xhr();
8256 if (xhr.open(s.type, s.url, s.async, s.username, s.password), s.xhrFields) {
8257 for (i in s.xhrFields) {
8258 xhr[i] = s.xhrFields[i];
8259 }
8260 }
8261 for (i in s.mimeType && xhr.overrideMimeType && xhr.overrideMimeType(s.mimeType), s.crossDomain || headers["X-Requested-With"] || (headers["X-Requested-With"] = "XMLHttpRequest"), headers) {
8262 xhr.setRequestHeader(i, headers[i]);
8263 }
8264 /**
8265 * @param {string} event
8266 * @return {?}
8267 */
8268 callback = function(event) {
8269 return function() {
8270 if (callback) {
8271 /** @type {null} */
8272 callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;
8273 if ("abort" === event) {
8274 xhr.abort();
8275 } else {
8276 if ("error" === event) {
8277 if ("number" != typeof xhr.status) {
8278 callback(0, "error");
8279 } else {
8280 callback(xhr.status, xhr.statusText);
8281 }
8282 } else {
8283 callback(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, "text" !== (xhr.responseType || "text") || "string" != typeof xhr.responseText ? {
8284 binary : xhr.response
8285 } : {
8286 text : xhr.responseText
8287 }, xhr.getAllResponseHeaders());
8288 }
8289 }
8290 }
8291 };
8292 };
8293 xhr.onload = callback();
8294 errorCallback = xhr.onerror = xhr.ontimeout = callback("error");
8295 if (void 0 !== xhr.onabort) {
8296 xhr.onabort = errorCallback;
8297 } else {
8298 /**
8299 * @return {undefined}
8300 */
8301 xhr.onreadystatechange = function() {
8302 if (4 === xhr.readyState) {
8303 window.setTimeout(function() {
8304 if (callback) {
8305 errorCallback();
8306 }
8307 });
8308 }
8309 };
8310 }
8311 callback = callback("abort");
8312 try {
8313 xhr.send(s.hasContent && s.data || null);
8314 } catch (e) {
8315 if (callback) {
8316 throw e;
8317 }
8318 }
8319 },
8320 abort : function() {
8321 if (callback) {
8322 callback();
8323 }
8324 }
8325 };
8326 }
8327 });
8328 jQuery.ajaxPrefilter(function(options) {
8329 if (options.crossDomain) {
8330 /** @type {boolean} */
8331 options.contents.script = false;
8332 }
8333 });
8334 jQuery.ajaxSetup({
8335 accepts : {
8336 script : "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
8337 },
8338 contents : {
8339 script : /\b(?:java|ecma)script\b/
8340 },
8341 converters : {
8342 "text script" : function(value) {
8343 return jQuery.globalEval(value), value;
8344 }
8345 }
8346 });
8347 jQuery.ajaxPrefilter("script", function(settings) {
8348 if (void 0 === settings.cache) {
8349 /** @type {boolean} */
8350 settings.cache = false;
8351 }
8352 if (settings.crossDomain) {
8353 /** @type {string} */
8354 settings.type = "GET";
8355 }
8356 });
8357 jQuery.ajaxTransport("script", function(options) {
8358 var fileElem;
8359 var callback;
8360 if (options.crossDomain || options.scriptAttrs) {
8361 return {
8362 send : function(elem, callback) {
8363 fileElem = jQuery("<script>").attr(options.scriptAttrs || {}).prop({
8364 charset : options.scriptCharset,
8365 src : options.url
8366 }).on("load error", callback = function(result) {
8367 fileElem.remove();
8368 /** @type {null} */
8369 callback = null;
8370 if (result) {
8371 callback("error" === result.type ? 404 : 200, result.type);
8372 }
8373 });
8374 document.head.appendChild(fileElem[0]);
8375 },
8376 abort : function() {
8377 if (callback) {
8378 callback();
8379 }
8380 }
8381 };
8382 }
8383 });
8384 /** @type {!Array} */
8385 var oldCallbacks = [];
8386 /** @type {!RegExp} */
8387 var rjsonp = /(=)\?(?=&|$)|\?\?/;
8388 jQuery.ajaxSetup({
8389 jsonp : "callback",
8390 jsonpCallback : function() {
8391 var indexLookupKey = oldCallbacks.pop() || jQuery.expando + "_" + widgetUniqueIDIndex++;
8392 return this[indexLookupKey] = true, indexLookupKey;
8393 }
8394 });
8395 jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, scanners) {
8396 var data;
8397 /** @type {(boolean|string)} */
8398 var jsonProp = false !== s.jsonp && (rjsonp.test(s.url) ? "url" : "string" == typeof s.data && 0 === (s.contentType || "").indexOf("application/x-www-form-urlencoded") && rjsonp.test(s.data) && "data");
8399 if (jsonProp || "jsonp" === s.dataTypes[0]) {
8400 var callbackName = s.jsonpCallback = fn(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;
8401 if (jsonProp) {
8402 s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
8403 } else {
8404 if (false !== s.jsonp) {
8405 s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
8406 }
8407 }
8408 /**
8409 * @return {?}
8410 */
8411 s.converters["script json"] = function() {
8412 return data || jQuery.error(callbackName + " was not called"), data[0];
8413 };
8414 /** @type {string} */
8415 s.dataTypes[0] = "json";
8416 var callback = window[callbackName];
8417 return window[callbackName] = function() {
8418 /** @type {!Arguments} */
8419 data = arguments;
8420 }, scanners.always(function() {
8421 if (void 0 === callback) {
8422 jQuery(window).removeProp(callbackName);
8423 } else {
8424 window[callbackName] = callback;
8425 }
8426 if (s[callbackName]) {
8427 s.jsonpCallback = originalSettings.jsonpCallback;
8428 oldCallbacks.push(callbackName);
8429 }
8430 if (data && fn(callback)) {
8431 callback(data[0]);
8432 }
8433 data = callback = void 0;
8434 }), "script";
8435 }
8436 });
8437 support.createHTMLDocument = function() {
8438 var iframeBody = document.implementation.createHTMLDocument("").body;
8439 return iframeBody.innerHTML = "<form></form><form></form>", 2 === iframeBody.childNodes.length;
8440 }();
8441 /**
8442 * @param {string} data
8443 * @param {!Object} context
8444 * @param {!Array} scripts
8445 * @return {?}
8446 */
8447 jQuery.parseHTML = function(data, context, scripts) {
8448 if ("string" != typeof data) {
8449 return [];
8450 }
8451 if ("boolean" == typeof context && (scripts = context, context = false), !context) {
8452 if (support.createHTMLDocument) {
8453 var parsed = (context = document.implementation.createHTMLDocument("")).createElement("base");
8454 parsed.href = document.location.href;
8455 context.head.appendChild(parsed);
8456 } else {
8457 context = document;
8458 }
8459 }
8460 return scripts = !scripts && [], (parsed = rsingleTag.exec(data)) ? [context.createElement(parsed[1])] : (parsed = buildFragment([data], context, scripts), scripts && scripts.length && jQuery(scripts).remove(), jQuery.merge([], parsed.childNodes));
8461 };
8462 /**
8463 * @param {string} str
8464 * @param {!Object} value
8465 * @param {!Object} callback
8466 * @return {?}
8467 */
8468 jQuery.fn.load = function(str, value, callback) {
8469 var method;
8470 var args;
8471 var self = this;
8472 var i = str.indexOf(" ");
8473 if (-1 < i) {
8474 var selector = log(str.slice(i));
8475 str = str.slice(0, i);
8476 }
8477 return fn(value) ? (callback = value, value = void 0) : value && "object" == typeof value && (method = "POST"), 0 < self.length && jQuery.ajax({
8478 url : str,
8479 type : method || "GET",
8480 dataType : "html",
8481 data : value
8482 }).done(function(responseText) {
8483 /** @type {!Arguments} */
8484 args = arguments;
8485 self.html(selector ? jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
8486 }).always(callback && function(value, name) {
8487 self.each(function() {
8488 callback.apply(this, args || [value.responseText, name, value]);
8489 });
8490 }), this;
8491 };
8492 /**
8493 * @param {?} elem
8494 * @return {?}
8495 */
8496 jQuery.expr.pseudos.animated = function(elem) {
8497 return jQuery.grep(jQuery.timers, function(fn) {
8498 return elem === fn.elem;
8499 }).length;
8500 };
8501 jQuery.offset = {
8502 setOffset : function(element, options, x) {
8503 var propertyName = jQuery.css(element, "position");
8504 var r = jQuery(element);
8505 var c = {};
8506 if ("static" === propertyName) {
8507 /** @type {string} */
8508 element.style.position = "relative";
8509 }
8510 var curOffset = r.offset();
8511 var a = jQuery.css(element, "top");
8512 var x = jQuery.css(element, "left");
8513 if (("absolute" === propertyName || "fixed" === propertyName) && -1 < (a + x).indexOf("auto")) {
8514 a = (x = r.position()).top;
8515 x = x.left;
8516 } else {
8517 /** @type {number} */
8518 a = parseFloat(a) || 0;
8519 /** @type {number} */
8520 x = parseFloat(x) || 0;
8521 }
8522 if (fn(options)) {
8523 options = options.call(element, x, jQuery.extend({}, curOffset));
8524 }
8525 if (null != options.top) {
8526 c.top = options.top - curOffset.top + a;
8527 }
8528 if (null != options.left) {
8529 c.left = options.left - curOffset.left + x;
8530 }
8531 if ("using" in options) {
8532 options.using.call(element, c);
8533 } else {
8534 if ("number" == typeof c.top) {
8535 c.top += "px";
8536 }
8537 if ("number" == typeof c.left) {
8538 c.left += "px";
8539 }
8540 r.css(c);
8541 }
8542 }
8543 };
8544 jQuery.fn.extend({
8545 offset : function(y) {
8546 if (arguments.length) {
8547 return void 0 === y ? this : this.each(function(i) {
8548 jQuery.offset.setOffset(this, y, i);
8549 });
8550 }
8551 var el;
8552 if (el = this[0]) {
8553 if (!el.getClientRects().length) {
8554 return {
8555 top : 0,
8556 left : 0
8557 };
8558 }
8559 var rect = el.getBoundingClientRect();
8560 return el = el.ownerDocument.defaultView, {
8561 top : rect.top + el.pageYOffset,
8562 left : rect.left + el.pageXOffset
8563 };
8564 }
8565 },
8566 position : function() {
8567 if (this[0]) {
8568 var el;
8569 var element = this[0];
8570 var parentOffset = {
8571 top : 0,
8572 left : 0
8573 };
8574 if ("fixed" === jQuery.css(element, "position")) {
8575 var offset = element.getBoundingClientRect();
8576 } else {
8577 offset = this.offset();
8578 var node = element.ownerDocument;
8579 el = element.offsetParent || node.documentElement;
8580 for (; el && (el === node.body || el === node.documentElement) && "static" === jQuery.css(el, "position");) {
8581 el = el.parentNode;
8582 }
8583 if (el && el !== element && 1 === el.nodeType) {
8584 (parentOffset = jQuery(el).offset()).top += jQuery.css(el, "borderTopWidth", true);
8585 parentOffset.left += jQuery.css(el, "borderLeftWidth", true);
8586 }
8587 }
8588 return {
8589 top : offset.top - parentOffset.top - jQuery.css(element, "marginTop", true),
8590 left : offset.left - parentOffset.left - jQuery.css(element, "marginLeft", true)
8591 };
8592 }
8593 },
8594 offsetParent : function() {
8595 return this.map(function() {
8596 var el = this.offsetParent;
8597 for (; el && "static" === jQuery.css(el, "position");) {
8598 el = el.offsetParent;
8599 }
8600 return el || element;
8601 });
8602 }
8603 });
8604 jQuery.each({
8605 scrollLeft : "pageXOffset",
8606 scrollTop : "pageYOffset"
8607 }, function(type, prop) {
8608 /** @type {boolean} */
8609 var top = "pageYOffset" === prop;
8610 /**
8611 * @param {?} value
8612 * @return {?}
8613 */
8614 jQuery.fn[type] = function(value) {
8615 return access(this, function(node, method, val) {
8616 if (isWindow(node)) {
8617 /** @type {!Object} */
8618 var win = node;
8619 } else {
8620 if (9 === node.nodeType) {
8621 win = node.defaultView;
8622 }
8623 }
8624 if (void 0 === val) {
8625 return win ? win[prop] : node[method];
8626 }
8627 if (win) {
8628 win.scrollTo(top ? win.pageXOffset : val, top ? val : win.pageYOffset);
8629 } else {
8630 /** @type {number} */
8631 node[method] = val;
8632 }
8633 }, type, value, arguments.length);
8634 };
8635 });
8636 jQuery.each(["top", "left"], function(canCreateDiscussions, prop) {
8637 jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, val) {
8638 if (val) {
8639 return val = curCSS(elem, prop), rnumnonpx.test(val) ? jQuery(elem).position()[prop] + "px" : val;
8640 }
8641 });
8642 });
8643 jQuery.each({
8644 Height : "height",
8645 Width : "width"
8646 }, function(name, type) {
8647 jQuery.each({
8648 padding : "inner" + name,
8649 content : type,
8650 "" : "outer" + name
8651 }, function(defaultExtra, type) {
8652 /**
8653 * @param {boolean} margin
8654 * @param {(number|string)} boardManager
8655 * @return {?}
8656 */
8657 jQuery.fn[type] = function(margin, boardManager) {
8658 var chainable = arguments.length && (defaultExtra || "boolean" != typeof margin);
8659 var extra = defaultExtra || (true === margin || true === boardManager ? "margin" : "border");
8660 return access(this, function(node, doc, undefined) {
8661 return isWindow(node) ? 0 === type.indexOf("outer") ? node["inner" + name] : node.document.documentElement["client" + name] : 9 === node.nodeType ? (doc = node.documentElement, Math.max(node.body["scroll" + name], doc["scroll" + name], node.body["offset" + name], doc["offset" + name], doc["client" + name])) : void 0 === undefined ? jQuery.css(node, doc, extra) : jQuery.style(node, doc, undefined, extra);
8662 }, type, chainable ? margin : void 0, chainable);
8663 };
8664 });
8665 });
8666 jQuery.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function(canCreateDiscussions, name) {
8667 /**
8668 * @param {undefined} e
8669 * @return {?}
8670 */
8671 jQuery.fn[name] = function(e) {
8672 return this.on(name, e);
8673 };
8674 });
8675 jQuery.fn.extend({
8676 bind : function(type, data, fn) {
8677 return this.on(type, null, data, fn);
8678 },
8679 unbind : function(e, capture) {
8680 return this.off(e, null, capture);
8681 },
8682 delegate : function(e, t, fn, event) {
8683 return this.on(t, e, fn, event);
8684 },
8685 undelegate : function(selector, el, callback) {
8686 return 1 === arguments.length ? this.off(selector, "**") : this.off(el, selector || "**", callback);
8687 },
8688 hover : function(fnOver, fnOut) {
8689 return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
8690 }
8691 });
8692 jQuery.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "), function(canCreateDiscussions, name) {
8693 /**
8694 * @param {!Object} callback
8695 * @param {!Object} fn
8696 * @return {?}
8697 */
8698 jQuery.fn[name] = function(callback, fn) {
8699 return 0 < arguments.length ? this.on(name, null, callback, fn) : this.trigger(name);
8700 };
8701 });
8702 /** @type {!RegExp} */
8703 var REGEX_ESCAPE_EXPR = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
8704 /**
8705 * @param {!Object} e
8706 * @param {undefined} c
8707 * @return {?}
8708 */
8709 jQuery.proxy = function(e, c) {
8710 if ("string" == typeof c) {
8711 var f = e[c];
8712 /** @type {!Object} */
8713 c = e;
8714 e = f;
8715 }
8716 if (fn(e)) {
8717 /** @type {!Array<?>} */
8718 var headArgs = slice.call(arguments, 2);
8719 return (f = function() {
8720 return e.apply(c || this, headArgs.concat(slice.call(arguments)));
8721 }).guid = e.guid = e.guid || jQuery.guid++, f;
8722 }
8723 };
8724 /**
8725 * @param {?} hold
8726 * @return {undefined}
8727 */
8728 jQuery.holdReady = function(hold) {
8729 if (hold) {
8730 jQuery.readyWait++;
8731 } else {
8732 jQuery.ready(true);
8733 }
8734 };
8735 /** @type {function(*): boolean} */
8736 jQuery.isArray = Array.isArray;
8737 /** @type {function(this:JSONType, string, function(string, *): *=): *} */
8738 jQuery.parseJSON = JSON.parse;
8739 /** @type {function(!Object, !Object): ?} */
8740 jQuery.nodeName = $;
8741 /** @type {function(!Object): ?} */
8742 jQuery.isFunction = fn;
8743 /** @type {function(!Object): ?} */
8744 jQuery.isWindow = isWindow;
8745 /** @type {function(!Object): ?} */
8746 jQuery.camelCase = camelCase;
8747 /** @type {function(!Object): ?} */
8748 jQuery.type = type;
8749 /** @type {function(): number} */
8750 jQuery.now = Date.now;
8751 /**
8752 * @param {string} value
8753 * @return {?}
8754 */
8755 jQuery.isNumeric = function(value) {
8756 var undefined = jQuery.type(value);
8757 return ("number" === undefined || "string" === undefined) && !isNaN(value - parseFloat(value));
8758 };
8759 /**
8760 * @param {string} text
8761 * @return {?}
8762 */
8763 jQuery.trim = function(text) {
8764 return null == text ? "" : (text + "").replace(REGEX_ESCAPE_EXPR, "");
8765 };
8766 if ("function" == typeof define && define.amd) {
8767 define("jquery", [], function() {
8768 return jQuery;
8769 });
8770 }
8771 var _jQuery = window.jQuery;
8772 var old$ = window.$;
8773 return jQuery.noConflict = function(deep) {
8774 return window.$ === jQuery && (window.$ = old$), deep && window.jQuery === jQuery && (window.jQuery = _jQuery), jQuery;
8775 }, void 0 === zoomAware && (window.jQuery = window.$ = jQuery), jQuery;
8776 });
8777}, function(module, canCreateDiscussions, __webpack_require__) {
8778 (function(setImmediate, clearImmediate) {
8779 var init;
8780 /**
8781 * @return {?}
8782 */
8783 init = function() {
8784 return function(e) {
8785 /**
8786 * @param {number} i
8787 * @return {?}
8788 */
8789 function t(i) {
8790 if (n[i]) {
8791 return n[i].exports;
8792 }
8793 var module = n[i] = {
8794 i : i,
8795 l : false,
8796 exports : {}
8797 };
8798 return e[i].call(module.exports, module, module.exports, t), module.l = true, module.exports;
8799 }
8800 var n = {};
8801 return t.m = e, t.c = n, t.d = function(e, name, n) {
8802 if (!t.o(e, name)) {
8803 Object.defineProperty(e, name, {
8804 configurable : false,
8805 enumerable : true,
8806 get : n
8807 });
8808 }
8809 }, t.n = function(module) {
8810 /** @type {function(): ?} */
8811 var n = module && module.__esModule ? function() {
8812 return module.default;
8813 } : function() {
8814 return module;
8815 };
8816 return t.d(n, "a", n), n;
8817 }, t.o = function(e, input) {
8818 return Object.prototype.hasOwnProperty.call(e, input);
8819 }, t.p = "", t(t.s = 8);
8820 }([function(canCreateDiscussions, exports, n) {
8821 Object.defineProperty(exports, "__esModule", {
8822 value : true
8823 });
8824 exports.CLASS_NAMES = {
8825 MODAL : "swal-modal",
8826 OVERLAY : "swal-overlay",
8827 SHOW_MODAL : "swal-overlay--show-modal",
8828 MODAL_TITLE : "swal-title",
8829 MODAL_TEXT : "swal-text",
8830 ICON : "swal-icon",
8831 ICON_CUSTOM : "swal-icon--custom",
8832 CONTENT : "swal-content",
8833 FOOTER : "swal-footer",
8834 BUTTON_CONTAINER : "swal-button-container",
8835 BUTTON : "swal-button",
8836 CONFIRM_BUTTON : "swal-button--confirm",
8837 CANCEL_BUTTON : "swal-button--cancel",
8838 DANGER_BUTTON : "swal-button--danger",
8839 BUTTON_LOADING : "swal-button--loading",
8840 BUTTON_LOADER : "swal-button__loader"
8841 };
8842 exports.default = exports.CLASS_NAMES;
8843 }, function(canCreateDiscussions, exports, n) {
8844 Object.defineProperty(exports, "__esModule", {
8845 value : true
8846 });
8847 /**
8848 * @param {string} name
8849 * @return {?}
8850 */
8851 exports.getNode = function(name) {
8852 return document.querySelector("." + name);
8853 };
8854 /**
8855 * @param {!Object} string
8856 * @return {?}
8857 */
8858 exports.stringToNode = function(string) {
8859 /** @type {!Element} */
8860 var legendHolder = document.createElement("div");
8861 return legendHolder.innerHTML = string.trim(), legendHolder.firstChild;
8862 };
8863 /**
8864 * @param {?} parentNode
8865 * @param {!Node} afterNode
8866 * @return {undefined}
8867 */
8868 exports.insertAfter = function(parentNode, afterNode) {
8869 afterNode.parentNode.insertBefore(parentNode, afterNode.nextSibling);
8870 };
8871 /**
8872 * @param {!Element} elem
8873 * @return {undefined}
8874 */
8875 exports.removeNode = function(elem) {
8876 elem.parentElement.removeChild(elem);
8877 };
8878 /**
8879 * @param {string} s
8880 * @return {?}
8881 */
8882 exports.throwErr = function(s) {
8883 throw "SweetAlert: " + (s = s.replace(/ +(?= )/g, "")).trim();
8884 };
8885 /**
8886 * @param {!Object} obj
8887 * @return {?}
8888 */
8889 exports.isPlainObject = function(obj) {
8890 return "[object Object]" === Object.prototype.toString.call(obj) && (null === (obj = Object.getPrototypeOf(obj)) || obj === Object.prototype);
8891 };
8892 /**
8893 * @param {number} n
8894 * @return {?}
8895 */
8896 exports.ordinalSuffixOf = function(n) {
8897 /** @type {number} */
8898 var thisparent = n % 10;
8899 /** @type {number} */
8900 var i = n % 100;
8901 return 1 === thisparent && 11 !== i ? n + "st" : 2 === thisparent && 12 !== i ? n + "nd" : 3 === thisparent && 13 !== i ? n + "rd" : n + "th";
8902 };
8903 }, function(values, props, mapping) {
8904 /**
8905 * @param {!Object} defaultProps
8906 * @return {undefined}
8907 */
8908 function set(defaultProps) {
8909 var propName;
8910 for (propName in defaultProps) {
8911 if (!props.hasOwnProperty(propName)) {
8912 props[propName] = defaultProps[propName];
8913 }
8914 }
8915 }
8916 Object.defineProperty(props, "__esModule", {
8917 value : true
8918 });
8919 set(mapping(25));
8920 values = mapping(26);
8921 props.overlayMarkup = values.default;
8922 set(mapping(27));
8923 set(mapping(28));
8924 set(mapping(29));
8925 values = (mapping = mapping(0)).default.MODAL_TITLE;
8926 var r = mapping.default.MODAL_TEXT;
8927 var STD_FOOTER = mapping.default.FOOTER;
8928 /** @type {string} */
8929 props.iconMarkup = '\n <div class="' + mapping.default.ICON + '"></div>';
8930 /** @type {string} */
8931 props.titleMarkup = '\n <div class="' + values + '"></div>\n';
8932 /** @type {string} */
8933 props.textMarkup = '\n <div class="' + r + '"></div>';
8934 /** @type {string} */
8935 props.footerMarkup = '\n <div class="' + STD_FOOTER + '"></div>\n';
8936 }, function(canCreateDiscussions, self, injector) {
8937 Object.defineProperty(self, "__esModule", {
8938 value : true
8939 });
8940 var jQuery = injector(1);
8941 /** @type {string} */
8942 self.CONFIRM_KEY = "confirm";
8943 /** @type {string} */
8944 self.CANCEL_KEY = "cancel";
8945 var options = {
8946 visible : true,
8947 text : null,
8948 value : null,
8949 className : "",
8950 closeModal : true
8951 };
8952 /** @type {!Object} */
8953 var value = Object.assign({}, options, {
8954 visible : false,
8955 text : "Cancel",
8956 value : null
8957 });
8958 /** @type {!Object} */
8959 var c = Object.assign({}, options, {
8960 text : "OK",
8961 value : true
8962 });
8963 self.defaultButtonList = {
8964 cancel : value,
8965 confirm : c
8966 };
8967 /**
8968 * @param {!Object} b
8969 * @param {?} c
8970 * @return {?}
8971 */
8972 var callback = function(b, c) {
8973 e: {
8974 switch(b) {
8975 case self.CONFIRM_KEY:
8976 /** @type {!Object} */
8977 b = c;
8978 break e;
8979 case self.CANCEL_KEY:
8980 /** @type {!Object} */
8981 b = value;
8982 break e;
8983 default:
8984 var capture_headings = b.charAt(0).toUpperCase() + b.slice(1);
8985 /** @type {!Object} */
8986 b = Object.assign({}, options, {
8987 text : capture_headings,
8988 value : b
8989 });
8990 }
8991 }
8992 return true === c ? Object.assign({}, b, {
8993 visible : true
8994 }) : "string" == typeof c ? Object.assign({}, b, {
8995 visible : true,
8996 text : c
8997 }) : jQuery.isPlainObject(c) ? Object.assign({
8998 visible : true
8999 }, b, c) : Object.assign({}, b, {
9000 visible : false
9001 });
9002 };
9003 /**
9004 * @param {!Array} headers
9005 * @return {?}
9006 */
9007 var when = function(headers) {
9008 var object = {};
9009 switch(headers.length) {
9010 case 1:
9011 /** @type {!Object} */
9012 object[self.CANCEL_KEY] = Object.assign({}, value, {
9013 visible : false
9014 });
9015 break;
9016 case 2:
9017 object[self.CANCEL_KEY] = callback(self.CANCEL_KEY, headers[0]);
9018 object[self.CONFIRM_KEY] = callback(self.CONFIRM_KEY, headers[1]);
9019 break;
9020 default:
9021 jQuery.throwErr("Invalid number of 'buttons' in array (" + headers.length + ").\n If you want more than 2 buttons, you need to use an object!");
9022 }
9023 return object;
9024 };
9025 /**
9026 * @param {?} a
9027 * @return {?}
9028 */
9029 self.getButtonListOpts = function(a) {
9030 var result = self.defaultButtonList;
9031 if ("string" == typeof a) {
9032 result[self.CONFIRM_KEY] = callback(self.CONFIRM_KEY, a);
9033 } else {
9034 if (Array.isArray(a)) {
9035 result = when(a);
9036 } else {
9037 if (jQuery.isPlainObject(a)) {
9038 result = {};
9039 /** @type {number} */
9040 var j = 0;
9041 /** @type {!Array<string>} */
9042 var ci = Object.keys(a);
9043 for (; j < ci.length; j++) {
9044 /** @type {string} */
9045 var i = ci[j];
9046 var record = callback(i, a[i]);
9047 result[i] = record;
9048 }
9049 if (!result.cancel) {
9050 /** @type {!Object} */
9051 result.cancel = value;
9052 }
9053 result = result;
9054 } else {
9055 if (true === a) {
9056 result = when([true, true]);
9057 } else {
9058 if (false === a) {
9059 result = when([false, false]);
9060 } else {
9061 if (void 0 === a) {
9062 result = self.defaultButtonList;
9063 }
9064 }
9065 }
9066 }
9067 }
9068 }
9069 return result;
9070 };
9071 }, function(CONST, t, require) {
9072 Object.defineProperty(t, "__esModule", {
9073 value : true
9074 });
9075 var input = require(1);
9076 var whitespace = require(2);
9077 var i = (CONST = require(0)).default.MODAL;
9078 var tr = CONST.default.OVERLAY;
9079 var button = require(30);
9080 var parser = require(31);
9081 var items = require(32);
9082 var presenter = require(33);
9083 /**
9084 * @param {?} e
9085 * @return {?}
9086 */
9087 t.injectElIntoModal = function(e) {
9088 var t = input.getNode(i);
9089 return e = input.stringToNode(e), t.appendChild(e), e;
9090 };
9091 /**
9092 * @param {!Object} data
9093 * @return {undefined}
9094 */
9095 t.initModalContent = function(data) {
9096 var t = input.getNode(i);
9097 t.className = i;
9098 /** @type {string} */
9099 t.textContent = "";
9100 var newName = data.className;
9101 if (newName) {
9102 t.classList.add(newName);
9103 }
9104 button.default(data.icon);
9105 parser.initTitle(data.title);
9106 parser.initText(data.text);
9107 presenter.default(data.content);
9108 items.default(data.buttons, data.dangerMode);
9109 };
9110 /**
9111 * @return {undefined}
9112 */
9113 t.default = function() {
9114 var tableRowElementOne = input.getNode(tr);
9115 var tableDataCellElementOne = input.stringToNode(whitespace.modalMarkup);
9116 tableRowElementOne.appendChild(tableDataCellElementOne);
9117 };
9118 }, function(canCreateDiscussions, instance, $) {
9119 Object.defineProperty(instance, "__esModule", {
9120 value : true
9121 });
9122 var combobox = $(3);
9123 var state = {
9124 isOpen : false,
9125 promise : null,
9126 actions : {},
9127 timer : null
9128 };
9129 /** @type {!Object} */
9130 var store = Object.assign({}, state);
9131 /**
9132 * @return {undefined}
9133 */
9134 instance.resetState = function() {
9135 /** @type {!Object} */
9136 store = Object.assign({}, state);
9137 };
9138 /**
9139 * @param {!Object} e
9140 * @return {?}
9141 */
9142 instance.setActionValue = function(e) {
9143 if ("string" == typeof e) {
9144 return callback(combobox.CONFIRM_KEY, e);
9145 }
9146 var i;
9147 for (i in e) {
9148 callback(i, e[i]);
9149 }
9150 };
9151 /**
9152 * @param {string} index
9153 * @param {!Object} e
9154 * @return {undefined}
9155 */
9156 var callback = function(index, e) {
9157 if (!store.actions[index]) {
9158 store.actions[index] = {};
9159 }
9160 Object.assign(store.actions[index], {
9161 value : e
9162 });
9163 };
9164 /**
9165 * @param {string} name
9166 * @param {number} b
9167 * @return {undefined}
9168 */
9169 instance.setActionOptionsFor = function(name, b) {
9170 b = (void 0 === b ? {} : b).closeModal;
9171 Object.assign(store.actions[name], {
9172 closeModal : void 0 === b || b
9173 });
9174 };
9175 instance.default = store;
9176 }, function(elementTargeted, exports, $) {
9177 Object.defineProperty(exports, "__esModule", {
9178 value : true
9179 });
9180 var me = $(1);
9181 var friend = $(3);
9182 var elementId = (elementTargeted = $(0)).default.OVERLAY;
9183 var a = elementTargeted.default.SHOW_MODAL;
9184 var type = elementTargeted.default.BUTTON;
9185 var l = elementTargeted.default.BUTTON_LOADING;
9186 var instance = $(5);
9187 /**
9188 * @return {undefined}
9189 */
9190 exports.openModal = function() {
9191 me.getNode(elementId).classList.add(a);
9192 /** @type {boolean} */
9193 instance.default.isOpen = true;
9194 };
9195 /**
9196 * @param {string} name
9197 * @return {undefined}
9198 */
9199 exports.onAction = function(name) {
9200 if (void 0 === name) {
9201 name = friend.CANCEL_KEY;
9202 }
9203 var ui = instance.default.actions[name];
9204 var value = ui.value;
9205 if (false === ui.closeModal) {
9206 me.getNode(type + "--" + name).classList.add(l);
9207 } else {
9208 me.getNode(elementId).classList.remove(a);
9209 /** @type {boolean} */
9210 instance.default.isOpen = false;
9211 }
9212 instance.default.promise.resolve(value);
9213 };
9214 /**
9215 * @return {?}
9216 */
9217 exports.getState = function() {
9218 /** @type {!Object} */
9219 var poller = Object.assign({}, instance.default);
9220 return delete poller.promise, delete poller.timer, poller;
9221 };
9222 /**
9223 * @return {undefined}
9224 */
9225 exports.stopLoading = function() {
9226 /** @type {!NodeList<Element>} */
9227 var playbackSpeedClasses = document.querySelectorAll("." + type);
9228 /** @type {number} */
9229 var i = 0;
9230 for (; i < playbackSpeedClasses.length; i++) {
9231 playbackSpeedClasses[i].classList.remove(l);
9232 }
9233 };
9234 }, function(module, g) {
9235 g = function() {
9236 return this;
9237 }();
9238 try {
9239 g = g || Function("return this")() || (0, eval)("this");
9240 } catch (e) {
9241 if ("object" == typeof window) {
9242 /** @type {!Window} */
9243 g = window;
9244 }
9245 }
9246 /** @type {(Object|string)} */
9247 module.exports = g;
9248 }, function(mixin, window, require) {
9249 window = require(7);
9250 mixin.exports = window.sweetAlert = require(9);
9251 }, function(mixin, options, merge) {
9252 options = merge(7);
9253 mixin.exports = options.swal = merge(10);
9254 }, function(module, __vue_exports__, require) {
9255 if ("undefined" != typeof window) {
9256 require(11);
9257 }
9258 require(16);
9259 __vue_exports__ = require(23).default;
9260 /** @type {(Object|string)} */
9261 module.exports = __vue_exports__;
9262 }, function(module, content, require) {
9263 if ("string" == typeof(content = require(12))) {
9264 /** @type {!Array} */
9265 content = [[module.i, content, ""]];
9266 }
9267 require(14)(content, {
9268 insertAt : "top",
9269 transform : void 0
9270 });
9271 if (content.locals) {
9272 module.exports = content.locals;
9273 }
9274 }, function(module, canCreateDiscussions, unsafeTermFn) {
9275 (module.exports = unsafeTermFn(13)(void 0)).push([module.i, '.swal-icon--error{border-color:#f27474;-webkit-animation:animateErrorIcon .5s;animation:animateErrorIcon .5s}.swal-icon--error__x-mark{position:relative;display:block;-webkit-animation:animateXMark .5s;animation:animateXMark .5s}.swal-icon--error__line{position:absolute;height:5px;width:47px;background-color:#f27474;display:block;top:37px;border-radius:2px}.swal-icon--error__line--left{-webkit-transform:rotate(45deg);transform:rotate(45deg);left:17px}.swal-icon--error__line--right{-webkit-transform:rotate(-45deg);transform:rotate(-45deg);right:16px}@-webkit-keyframes animateErrorIcon{0%{-webkit-transform:rotateX(100deg);transform:rotateX(100deg);opacity:0}to{-webkit-transform:rotateX(0deg);transform:rotateX(0deg);opacity:1}}@keyframes animateErrorIcon{0%{-webkit-transform:rotateX(100deg);transform:rotateX(100deg);opacity:0}to{-webkit-transform:rotateX(0deg);transform:rotateX(0deg);opacity:1}}@-webkit-keyframes animateXMark{0%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}50%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}80%{-webkit-transform:scale(1.15);transform:scale(1.15);margin-top:-6px}to{-webkit-transform:scale(1);transform:scale(1);margin-top:0;opacity:1}}@keyframes animateXMark{0%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}50%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}80%{-webkit-transform:scale(1.15);transform:scale(1.15);margin-top:-6px}to{-webkit-transform:scale(1);transform:scale(1);margin-top:0;opacity:1}}.swal-icon--warning{border-color:#f8bb86;-webkit-animation:pulseWarning .75s infinite alternate;animation:pulseWarning .75s infinite alternate}.swal-icon--warning__body{width:5px;height:47px;top:10px;border-radius:2px;margin-left:-2px}.swal-icon--warning__body,.swal-icon--warning__dot{position:absolute;left:50%;background-color:#f8bb86}.swal-icon--warning__dot{width:7px;height:7px;border-radius:50%;margin-left:-4px;bottom:-11px}@-webkit-keyframes pulseWarning{0%{border-color:#f8d486}to{border-color:#f8bb86}}@keyframes pulseWarning{0%{border-color:#f8d486}to{border-color:#f8bb86}}.swal-icon--success{border-color:#a5dc86}.swal-icon--success:after,.swal-icon--success:before{content:"";border-radius:50%;position:absolute;width:60px;height:120px;background:#fff;-webkit-transform:rotate(45deg);transform:rotate(45deg)}.swal-icon--success:before{border-radius:120px 0 0 120px;top:-7px;left:-33px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:60px 60px;transform-origin:60px 60px}.swal-icon--success:after{border-radius:0 120px 120px 0;top:-11px;left:30px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:0 60px;transform-origin:0 60px;-webkit-animation:rotatePlaceholder 4.25s ease-in;animation:rotatePlaceholder 4.25s ease-in}.swal-icon--success__ring{width:80px;height:80px;border:4px solid hsla(98,55%,69%,.2);border-radius:50%;box-sizing:content-box;position:absolute;left:-4px;top:-4px;z-index:2}.swal-icon--success__hide-corners{width:5px;height:90px;background-color:#fff;padding:1px;position:absolute;left:28px;top:8px;z-index:1;-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}.swal-icon--success__line{height:5px;background-color:#a5dc86;display:block;border-radius:2px;position:absolute;z-index:2}.swal-icon--success__line--tip{width:25px;left:14px;top:46px;-webkit-transform:rotate(45deg);transform:rotate(45deg);-webkit-animation:animateSuccessTip .75s;animation:animateSuccessTip .75s}.swal-icon--success__line--long{width:47px;right:8px;top:38px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-animation:animateSuccessLong .75s;animation:animateSuccessLong .75s}@-webkit-keyframes rotatePlaceholder{0%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}5%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}12%{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}to{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}}@keyframes rotatePlaceholder{0%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}5%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}12%{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}to{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}}@-webkit-keyframes animateSuccessTip{0%{width:0;left:1px;top:19px}54%{width:0;left:1px;top:19px}70%{width:50px;left:-8px;top:37px}84%{width:17px;left:21px;top:48px}to{width:25px;left:14px;top:45px}}@keyframes animateSuccessTip{0%{width:0;left:1px;top:19px}54%{width:0;left:1px;top:19px}70%{width:50px;left:-8px;top:37px}84%{width:17px;left:21px;top:48px}to{width:25px;left:14px;top:45px}}@-webkit-keyframes animateSuccessLong{0%{width:0;right:46px;top:54px}65%{width:0;right:46px;top:54px}84%{width:55px;right:0;top:35px}to{width:47px;right:8px;top:38px}}@keyframes animateSuccessLong{0%{width:0;right:46px;top:54px}65%{width:0;right:46px;top:54px}84%{width:55px;right:0;top:35px}to{width:47px;right:8px;top:38px}}.swal-icon--info{border-color:#c9dae1}.swal-icon--info:before{width:5px;height:29px;bottom:17px;border-radius:2px;margin-left:-2px}.swal-icon--info:after,.swal-icon--info:before{content:"";position:absolute;left:50%;background-color:#c9dae1}.swal-icon--info:after{width:7px;height:7px;border-radius:50%;margin-left:-3px;top:19px}.swal-icon{width:80px;height:80px;border-width:4px;border-style:solid;border-radius:50%;padding:0;position:relative;box-sizing:content-box;margin:20px auto}.swal-icon:first-child{margin-top:32px}.swal-icon--custom{width:auto;height:auto;max-width:100%;border:none;border-radius:0}.swal-icon img{max-width:100%;max-height:100%}.swal-title{color:rgba(0,0,0,.65);font-weight:600;text-transform:none;position:relative;display:block;padding:13px 16px;font-size:27px;line-height:normal;text-align:center;margin-bottom:0}.swal-title:first-child{margin-top:26px}.swal-title:not(:first-child){padding-bottom:0}.swal-title:not(:last-child){margin-bottom:13px}.swal-text{font-size:16px;position:relative;float:none;line-height:normal;vertical-align:top;text-align:left;display:inline-block;margin:0;padding:0 10px;font-weight:400;color:rgba(0,0,0,.64);max-width:calc(100% - 20px);overflow-wrap:break-word;box-sizing:border-box}.swal-text:first-child{margin-top:45px}.swal-text:last-child{margin-bottom:45px}.swal-footer{text-align:right;padding-top:13px;margin-top:13px;padding:13px 16px;border-radius:inherit;border-top-left-radius:0;border-top-right-radius:0}.swal-button-container{margin:5px;display:inline-block;position:relative}.swal-button{background-color:#7cd1f9;color:#fff;border:none;box-shadow:none;border-radius:5px;font-weight:600;font-size:14px;padding:10px 24px;margin:0;cursor:pointer}.swal-button:not([disabled]):hover{background-color:#78cbf2}.swal-button:active{background-color:#70bce0}.swal-button:focus{outline:none;box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(43,114,165,.29)}.swal-button[disabled]{opacity:.5;cursor:default}.swal-button::-moz-focus-inner{border:0}.swal-button--cancel{color:#555;background-color:#efefef}.swal-button--cancel:not([disabled]):hover{background-color:#e8e8e8}.swal-button--cancel:active{background-color:#d7d7d7}.swal-button--cancel:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(116,136,150,.29)}.swal-button--danger{background-color:#e64942}.swal-button--danger:not([disabled]):hover{background-color:#df4740}.swal-button--danger:active{background-color:#cf423b}.swal-button--danger:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(165,43,43,.29)}.swal-content{padding:0 20px;margin-top:20px;font-size:medium}.swal-content:last-child{margin-bottom:20px}.swal-content__input,.swal-content__textarea{-webkit-appearance:none;background-color:#fff;border:none;font-size:14px;display:block;box-sizing:border-box;width:100%;border:1px solid rgba(0,0,0,.14);padding:10px 13px;border-radius:2px;transition:border-color .2s}.swal-content__input:focus,.swal-content__textarea:focus{outline:none;border-color:#6db8ff}.swal-content__textarea{resize:vertical}.swal-button--loading{color:transparent}.swal-button--loading~.swal-button__loader{opacity:1}.swal-button__loader{position:absolute;height:auto;width:43px;z-index:2;left:50%;top:50%;-webkit-transform:translateX(-50%) translateY(-50%);transform:translateX(-50%) translateY(-50%);text-align:center;pointer-events:none;opacity:0}.swal-button__loader div{display:inline-block;float:none;vertical-align:baseline;width:9px;height:9px;padding:0;border:none;margin:2px;opacity:.4;border-radius:7px;background-color:hsla(0,0%,100%,.9);transition:background .2s;-webkit-animation:swal-loading-anim 1s infinite;animation:swal-loading-anim 1s infinite}.swal-button__loader div:nth-child(3n+2){-webkit-animation-delay:.15s;animation-delay:.15s}.swal-button__loader div:nth-child(3n+3){-webkit-animation-delay:.3s;animation-delay:.3s}@-webkit-keyframes swal-loading-anim{0%{opacity:.4}20%{opacity:.4}50%{opacity:1}to{opacity:.4}}@keyframes swal-loading-anim{0%{opacity:.4}20%{opacity:.4}50%{opacity:1}to{opacity:.4}}.swal-overlay{position:fixed;top:0;bottom:0;left:0;right:0;text-align:center;font-size:0;overflow-y:auto;background-color:rgba(0,0,0,.4);z-index:10000;pointer-events:none;opacity:0;transition:opacity .3s}.swal-overlay:before{content:" ";display:inline-block;vertical-align:middle;height:100%}.swal-overlay--show-modal{opacity:1;pointer-events:auto}.swal-overlay--show-modal .swal-modal{opacity:1;pointer-events:auto;box-sizing:border-box;-webkit-animation:showSweetAlert .3s;animation:showSweetAlert .3s;will-change:transform}.swal-modal{width:478px;opacity:0;pointer-events:none;background-color:#fff;text-align:center;border-radius:5px;position:static;margin:20px auto;display:inline-block;vertical-align:middle;-webkit-transform:scale(1);transform:scale(1);-webkit-transform-origin:50% 50%;transform-origin:50% 50%;z-index:10001;transition:opacity .2s,-webkit-transform .3s;transition:transform .3s,opacity .2s;transition:transform .3s,opacity .2s,-webkit-transform .3s}@media (max-width:500px){.swal-modal{width:calc(100% - 20px)}}@-webkit-keyframes showSweetAlert{0%{-webkit-transform:scale(1);transform:scale(1)}1%{-webkit-transform:scale(.5);transform:scale(.5)}45%{-webkit-transform:scale(1.05);transform:scale(1.05)}80%{-webkit-transform:scale(.95);transform:scale(.95)}to{-webkit-transform:scale(1);transform:scale(1)}}@keyframes showSweetAlert{0%{-webkit-transform:scale(1);transform:scale(1)}1%{-webkit-transform:scale(.5);transform:scale(.5)}45%{-webkit-transform:scale(1.05);transform:scale(1.05)}80%{-webkit-transform:scale(.95);transform:scale(.95)}to{-webkit-transform:scale(1);transform:scale(1)}}',
9276 ""]);
9277 }, function(mixin, canCreateDiscussions) {
9278 /**
9279 * @param {!Object} key
9280 * @return {?}
9281 */
9282 mixin.exports = function(key) {
9283 /** @type {!Array} */
9284 var t = [];
9285 return t.toString = function() {
9286 return this.map(function(t) {
9287 var a = function(result, value) {
9288 var text = result[1] || "";
9289 var json = result[3];
9290 return json ? value && "function" == typeof btoa ? (result = "/*# sourceMappingURL=data:application/json;charset=utf-8;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(json)))) + " */", [text].concat(json.sources.map(function(canCreateDiscussions) {
9291 return "/*# sourceURL=" + json.sourceRoot + canCreateDiscussions + " */";
9292 })).concat([result]).join("\n")) : "" + text : text;
9293 }(t, key);
9294 return t[2] ? "@media " + t[2] + "{" + a + "}" : a;
9295 }).join("");
9296 }, t.i = function(a, v) {
9297 if ("string" == typeof a) {
9298 /** @type {!Array} */
9299 a = [[null, a, ""]];
9300 }
9301 var map = {};
9302 /** @type {number} */
9303 var i = 0;
9304 for (; i < this.length; i++) {
9305 var s = this[i][0];
9306 if ("number" == typeof s) {
9307 /** @type {boolean} */
9308 map[s] = true;
9309 }
9310 }
9311 /** @type {number} */
9312 i = 0;
9313 for (; i < a.length; i++) {
9314 if (!("number" == typeof(s = a[i])[0] && map[s[0]])) {
9315 if (v && !s[2]) {
9316 /** @type {string} */
9317 s[2] = v;
9318 } else {
9319 if (v) {
9320 /** @type {string} */
9321 s[2] = "(" + s[2] + ") and (" + v + ")";
9322 }
9323 }
9324 t.push(s);
9325 }
9326 }
9327 }, t;
9328 };
9329 }, function(mixin, canCreateDiscussions, edit) {
9330 /**
9331 * @param {!NodeList} items
9332 * @param {!Object} options
9333 * @return {undefined}
9334 */
9335 function wrap(items, options) {
9336 /** @type {number} */
9337 var i = 0;
9338 for (; i < items.length; i++) {
9339 var item = items[i];
9340 var parts = stylesInDom[item.id];
9341 if (parts) {
9342 parts.refs++;
9343 /** @type {number} */
9344 var i = 0;
9345 for (; i < parts.parts.length; i++) {
9346 parts.parts[i](item.parts[i]);
9347 }
9348 for (; i < item.parts.length; i++) {
9349 parts.parts.push(addStyle(item.parts[i], options));
9350 }
9351 } else {
9352 /** @type {!Array} */
9353 parts = [];
9354 /** @type {number} */
9355 i = 0;
9356 for (; i < item.parts.length; i++) {
9357 parts.push(addStyle(item.parts[i], options));
9358 }
9359 stylesInDom[item.id] = {
9360 id : item.id,
9361 refs : 1,
9362 parts : parts
9363 };
9364 }
9365 }
9366 }
9367 /**
9368 * @param {?} q
9369 * @param {!Object} options
9370 * @return {?}
9371 */
9372 function $(q, options) {
9373 /** @type {!Array} */
9374 var returnValue = [];
9375 var newStyles = {};
9376 /** @type {number} */
9377 var i = 0;
9378 for (; i < q.length; i++) {
9379 var item = q[i];
9380 var id = options.base ? item[0] + options.base : item[0];
9381 item = {
9382 css : item[1],
9383 media : item[2],
9384 sourceMap : item[3]
9385 };
9386 if (newStyles[id]) {
9387 newStyles[id].parts.push(item);
9388 } else {
9389 returnValue.push(newStyles[id] = {
9390 id : id,
9391 parts : [item]
9392 });
9393 }
9394 }
9395 return returnValue;
9396 }
9397 /**
9398 * @param {!Object} options
9399 * @param {(Node|Window)} dom
9400 * @return {undefined}
9401 */
9402 function insertStyleElement(options, dom) {
9403 var body = getElement(options.insertInto);
9404 if (!body) {
9405 throw Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");
9406 }
9407 var node = contents[contents.length - 1];
9408 if ("top" === options.insertAt) {
9409 if (node) {
9410 if (node.nextSibling) {
9411 body.insertBefore(dom, node.nextSibling);
9412 } else {
9413 body.appendChild(dom);
9414 }
9415 } else {
9416 body.insertBefore(dom, body.firstChild);
9417 }
9418 contents.push(dom);
9419 } else {
9420 if ("bottom" !== options.insertAt) {
9421 throw Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
9422 }
9423 body.appendChild(dom);
9424 }
9425 }
9426 /**
9427 * @param {!Object} e
9428 * @return {?}
9429 */
9430 function callback(e) {
9431 if (null === e.parentNode) {
9432 return false;
9433 }
9434 e.parentNode.removeChild(e);
9435 if (0 <= (e = contents.indexOf(e))) {
9436 contents.splice(e, 1);
9437 }
9438 }
9439 /**
9440 * @param {!Object} options
9441 * @return {?}
9442 */
9443 function createStyleElement(options) {
9444 /** @type {!Element} */
9445 var style = document.createElement("style");
9446 return options.attrs.type = "text/css", addAttrs(style, options.attrs), insertStyleElement(options, style), style;
9447 }
9448 /**
9449 * @param {!Object} options
9450 * @return {?}
9451 */
9452 function createLinkElement(options) {
9453 /** @type {!Element} */
9454 var link = document.createElement("link");
9455 return options.attrs.type = "text/css", options.attrs.rel = "stylesheet", addAttrs(link, options.attrs), insertStyleElement(options, link), link;
9456 }
9457 /**
9458 * @param {!Element} el
9459 * @param {!Object} attrs
9460 * @return {undefined}
9461 */
9462 function addAttrs(el, attrs) {
9463 Object.keys(attrs).forEach(function(att) {
9464 el.setAttribute(att, attrs[att]);
9465 });
9466 }
9467 /**
9468 * @param {!Function} obj
9469 * @param {!Object} options
9470 * @return {?}
9471 */
9472 function addStyle(obj, options) {
9473 var data;
9474 if (options.transform && obj.css) {
9475 if (!(data = options.transform(obj.css))) {
9476 return function() {
9477 };
9478 }
9479 obj.css = data;
9480 }
9481 if (options.singleton) {
9482 /** @type {number} */
9483 data = v++;
9484 var style = singletonElement || (singletonElement = createStyleElement(options));
9485 var update = init.bind(null, style, data, false);
9486 var remove = init.bind(null, style, data, true);
9487 } else {
9488 if (obj.sourceMap && "function" == typeof URL && "function" == typeof URL.createObjectURL && "function" == typeof URL.revokeObjectURL && "function" == typeof Blob && "function" == typeof btoa) {
9489 style = createLinkElement(options);
9490 update = updateLink.bind(null, style, options);
9491 /**
9492 * @return {undefined}
9493 */
9494 remove = function() {
9495 callback(style);
9496 if (style.href) {
9497 URL.revokeObjectURL(style.href);
9498 }
9499 };
9500 } else {
9501 style = createStyleElement(options);
9502 update = applyToTag.bind(null, style);
9503 /**
9504 * @return {undefined}
9505 */
9506 remove = function() {
9507 callback(style);
9508 };
9509 }
9510 }
9511 return update(obj), function(newObj) {
9512 if (newObj) {
9513 if (!(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)) {
9514 update(obj = newObj);
9515 }
9516 } else {
9517 remove();
9518 }
9519 };
9520 }
9521 /**
9522 * @param {!Node} element
9523 * @param {string} index
9524 * @param {!Function} css
9525 * @param {!Object} options
9526 * @return {undefined}
9527 */
9528 function init(element, index, css, options) {
9529 css = css ? "" : options.css;
9530 if (element.styleSheet) {
9531 element.styleSheet.cssText = replaceText(index, css);
9532 } else {
9533 /** @type {!Text} */
9534 css = document.createTextNode(css);
9535 if ((options = element.childNodes)[index]) {
9536 element.removeChild(options[index]);
9537 }
9538 if (options.length) {
9539 element.insertBefore(css, options[index]);
9540 } else {
9541 element.appendChild(css);
9542 }
9543 }
9544 }
9545 /**
9546 * @param {!Node} styleElement
9547 * @param {!Object} obj
9548 * @return {undefined}
9549 */
9550 function applyToTag(styleElement, obj) {
9551 var css = obj.css;
9552 if ((obj = obj.media) && styleElement.setAttribute("media", obj), styleElement.styleSheet) {
9553 styleElement.styleSheet.cssText = css;
9554 } else {
9555 for (; styleElement.firstChild;) {
9556 styleElement.removeChild(styleElement.firstChild);
9557 }
9558 styleElement.appendChild(document.createTextNode(css));
9559 }
9560 }
9561 /**
9562 * @param {!Object} target
9563 * @param {string} options
9564 * @param {!Object} obj
9565 * @return {undefined}
9566 */
9567 function updateLink(target, options, obj) {
9568 var value = obj.css;
9569 obj = obj.sourceMap;
9570 var autoFixUrls = void 0 === options.convertToAbsoluteUrls && obj;
9571 if (options.convertToAbsoluteUrls || autoFixUrls) {
9572 value = after(value);
9573 }
9574 if (obj) {
9575 /** @type {string} */
9576 value = value + ("\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(obj)))) + " */");
9577 }
9578 /** @type {!Blob} */
9579 options = new Blob([value], {
9580 type : "text/css"
9581 });
9582 value = target.href;
9583 /** @type {string} */
9584 target.href = URL.createObjectURL(options);
9585 if (value) {
9586 URL.revokeObjectURL(value);
9587 }
9588 }
9589 var stylesInDom = {};
9590 var isOldIE = function(CropAreaRectangle) {
9591 var _ref12;
9592 return function() {
9593 return void 0 === _ref12 && (_ref12 = CropAreaRectangle.apply(this, arguments)), _ref12;
9594 };
9595 }(function() {
9596 return window && document && document.all && !window.atob;
9597 });
9598 var getElement = function(e) {
9599 var tfidfs = {};
9600 return function(i) {
9601 return void 0 === tfidfs[i] && (tfidfs[i] = e.call(this, i)), tfidfs[i];
9602 };
9603 }(function(seletor) {
9604 return document.querySelector(seletor);
9605 });
9606 /** @type {null} */
9607 var singletonElement = null;
9608 /** @type {number} */
9609 var v = 0;
9610 /** @type {!Array} */
9611 var contents = [];
9612 var after = edit(15);
9613 /**
9614 * @param {!Object} value
9615 * @param {!Object} name
9616 * @return {?}
9617 */
9618 mixin.exports = function(value, name) {
9619 if ("undefined" != typeof DEBUG && DEBUG && "object" != typeof document) {
9620 throw Error("The style-loader cannot be used in a non-browser environment");
9621 }
9622 (name = name || {}).attrs = "object" == typeof name.attrs ? name.attrs : {};
9623 if (!name.singleton) {
9624 name.singleton = isOldIE();
9625 }
9626 if (!name.insertInto) {
9627 /** @type {string} */
9628 name.insertInto = "head";
9629 }
9630 if (!name.insertAt) {
9631 /** @type {string} */
9632 name.insertAt = "bottom";
9633 }
9634 var result = $(value, name);
9635 return wrap(result, name), function(k) {
9636 var item;
9637 /** @type {!Array} */
9638 var a = [];
9639 /** @type {number} */
9640 var i = 0;
9641 for (; i < result.length; i++) {
9642 (item = stylesInDom[result[i].id]).refs--;
9643 a.push(item);
9644 }
9645 if (k) {
9646 wrap($(k, name), name);
9647 }
9648 /** @type {number} */
9649 i = 0;
9650 for (; i < a.length; i++) {
9651 if (0 === (item = a[i]).refs) {
9652 /** @type {number} */
9653 k = 0;
9654 for (; k < item.parts.length; k++) {
9655 item.parts[k]();
9656 }
9657 delete stylesInDom[item.id];
9658 }
9659 }
9660 };
9661 };
9662 var replaceText = function() {
9663 /** @type {!Array} */
9664 var values = [];
9665 return function(i, n) {
9666 return values[i] = n, values.filter(Boolean).join("\n");
9667 };
9668 }();
9669 }, function(mixin, canCreateDiscussions) {
9670 /**
9671 * @param {!Object} value
9672 * @return {?}
9673 */
9674 mixin.exports = function(value) {
9675 /** @type {(Location|boolean)} */
9676 var parsedPath = "undefined" != typeof window && window.location;
9677 if (!parsedPath) {
9678 throw Error("fixUrls requires window.location");
9679 }
9680 if (!value || "string" != typeof value) {
9681 return value;
9682 }
9683 /** @type {string} */
9684 var prefix = parsedPath.protocol + "//" + parsedPath.host;
9685 /** @type {string} */
9686 var newPrefix = prefix + parsedPath.pathname.replace(/\/[^\/]*$/, "/");
9687 return value.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi, function(ASC, key) {
9688 return key = key.trim().replace(/^"(.*)"$/, function(canCreateDiscussions, isSlidingUp) {
9689 return isSlidingUp;
9690 }).replace(/^'(.*)'$/, function(canCreateDiscussions, isSlidingUp) {
9691 return isSlidingUp;
9692 }), /^(#|data:|http:\/\/|https:\/\/|file:\/\/\/)/i.test(key) ? ASC : (keyName = 0 === key.indexOf("//") ? key : 0 === key.indexOf("/") ? prefix + key : newPrefix + key.replace(/^\.\//, ""), "url(" + JSON.stringify(keyName) + ")");
9693 var keyName;
9694 });
9695 };
9696 }, function(Promise, canCreateDiscussions, require) {
9697 Promise = require(17);
9698 if (!("undefined" == typeof window || window.Promise)) {
9699 window.Promise = Promise;
9700 }
9701 require(21);
9702 if (!String.prototype.includes) {
9703 /**
9704 * @param {string} name
9705 * @param {number=} start
9706 * @return {boolean}
9707 * @this {!String}
9708 */
9709 String.prototype.includes = function(name, start) {
9710 return "number" != typeof start && (start = 0), !(start + name.length > this.length) && -1 !== this.indexOf(name, start);
9711 };
9712 }
9713 if (!Array.prototype.includes) {
9714 Object.defineProperty(Array.prototype, "includes", {
9715 value : function(key, value) {
9716 if (null == this) {
9717 throw new TypeError('"this" is null or not defined');
9718 }
9719 /** @type {!Object} */
9720 var n = Object(this);
9721 /** @type {number} */
9722 var max = n.length >>> 0;
9723 if (0 === max) {
9724 return false;
9725 }
9726 /** @type {number} */
9727 value = value | 0;
9728 /** @type {number} */
9729 value = Math.max(0 <= value ? value : max - Math.abs(value), 0);
9730 for (; value < max;) {
9731 var c = n[value];
9732 /** @type {!Object} */
9733 var end = key;
9734 if (c === end || "number" == typeof c && "number" == typeof end && isNaN(c) && isNaN(end)) {
9735 return true;
9736 }
9737 value++;
9738 }
9739 return false;
9740 }
9741 });
9742 }
9743 if ("undefined" != typeof window) {
9744 [Element.prototype, CharacterData.prototype, DocumentType.prototype].forEach(function(e) {
9745 if (!e.hasOwnProperty("remove")) {
9746 Object.defineProperty(e, "remove", {
9747 configurable : true,
9748 enumerable : true,
9749 writable : true,
9750 value : function() {
9751 this.parentNode.removeChild(this);
9752 }
9753 });
9754 }
9755 });
9756 }
9757 }, function(root, gen34_options, __webpack_require__) {
9758 (function(arg) {
9759 !function(host) {
9760 /**
9761 * @return {undefined}
9762 */
9763 function noop() {
9764 }
9765 /**
9766 * @param {!Object} value
9767 * @return {undefined}
9768 */
9769 function Promise(value) {
9770 if ("object" != typeof this) {
9771 throw new TypeError("Promises must be constructed via new");
9772 }
9773 if ("function" != typeof value) {
9774 throw new TypeError("not a function");
9775 }
9776 /** @type {number} */
9777 this._state = 0;
9778 /** @type {boolean} */
9779 this._handled = false;
9780 this._value = void 0;
9781 /** @type {!Array} */
9782 this._deferreds = [];
9783 doResolve(value, this);
9784 }
9785 /**
9786 * @param {!Object} self
9787 * @param {?} deferred
9788 * @return {undefined}
9789 */
9790 function handle(self, deferred) {
9791 for (; 3 === self._state;) {
9792 self = self._value;
9793 }
9794 if (0 !== self._state) {
9795 /** @type {boolean} */
9796 self._handled = true;
9797 Promise._immediateFn(function() {
9798 var cb = 1 === self._state ? deferred.onFulfilled : deferred.onRejected;
9799 if (null !== cb) {
9800 try {
9801 var ret = cb(self._value);
9802 } catch (val) {
9803 return void reject(deferred.promise, val);
9804 }
9805 resolve(deferred.promise, ret);
9806 } else {
9807 (1 === self._state ? resolve : reject)(deferred.promise, self._value);
9808 }
9809 });
9810 } else {
9811 self._deferreds.push(deferred);
9812 }
9813 }
9814 /**
9815 * @param {!Object} self
9816 * @param {!Object} val
9817 * @return {?}
9818 */
9819 function resolve(self, val) {
9820 try {
9821 if (val === self) {
9822 throw new TypeError("A promise cannot be resolved with itself.");
9823 }
9824 if (val && ("object" == typeof val || "function" == typeof val)) {
9825 var then = val.then;
9826 if (val instanceof Promise) {
9827 return self._state = 3, self._value = val, void finale(self);
9828 }
9829 if ("function" == typeof then) {
9830 return void doResolve(function(fn, val) {
9831 return function() {
9832 fn.apply(val, arguments);
9833 };
9834 }(then, val), self);
9835 }
9836 }
9837 /** @type {number} */
9838 self._state = 1;
9839 /** @type {!Object} */
9840 self._value = val;
9841 finale(self);
9842 } catch (val) {
9843 reject(self, val);
9844 }
9845 }
9846 /**
9847 * @param {!Object} self
9848 * @param {string} newValue
9849 * @return {undefined}
9850 */
9851 function reject(self, newValue) {
9852 /** @type {number} */
9853 self._state = 2;
9854 /** @type {string} */
9855 self._value = newValue;
9856 finale(self);
9857 }
9858 /**
9859 * @param {!Object} self
9860 * @return {undefined}
9861 */
9862 function finale(self) {
9863 if (2 === self._state && 0 === self._deferreds.length) {
9864 Promise._immediateFn(function() {
9865 if (!self._handled) {
9866 Promise._unhandledRejectionFn(self._value);
9867 }
9868 });
9869 }
9870 /** @type {number} */
9871 var i = 0;
9872 var patchLen = self._deferreds.length;
9873 for (; i < patchLen; i++) {
9874 handle(self, self._deferreds[i]);
9875 }
9876 /** @type {null} */
9877 self._deferreds = null;
9878 }
9879 /**
9880 * @param {!Function} a
9881 * @param {!Function} b
9882 * @param {!Function} p
9883 * @return {undefined}
9884 */
9885 function Handler(a, b, p) {
9886 /** @type {(!Function|null)} */
9887 this.onFulfilled = "function" == typeof a ? a : null;
9888 /** @type {(!Function|null)} */
9889 this.onRejected = "function" == typeof b ? b : null;
9890 /** @type {!Function} */
9891 this.promise = p;
9892 }
9893 /**
9894 * @param {!Object} fn
9895 * @param {!Object} self
9896 * @return {undefined}
9897 */
9898 function doResolve(fn, self) {
9899 /** @type {boolean} */
9900 var n = false;
9901 try {
9902 fn(function(v) {
9903 if (!n) {
9904 /** @type {boolean} */
9905 n = true;
9906 resolve(self, v);
9907 }
9908 }, function(val) {
9909 if (!n) {
9910 /** @type {boolean} */
9911 n = true;
9912 reject(self, val);
9913 }
9914 });
9915 } catch (val) {
9916 if (!n) {
9917 /** @type {boolean} */
9918 n = true;
9919 reject(self, val);
9920 }
9921 }
9922 }
9923 /** @type {function((!Function|null|string), number=, ...*): number} */
9924 var realSetTimeout = setTimeout;
9925 /**
9926 * @param {!Array} fn
9927 * @return {?}
9928 */
9929 Promise.prototype.catch = function(fn) {
9930 return this.then(null, fn);
9931 };
9932 /**
9933 * @param {!Function} value
9934 * @param {!Array} onRejected
9935 * @return {?}
9936 */
9937 Promise.prototype.then = function(value, onRejected) {
9938 var prom = new this.constructor(noop);
9939 return handle(this, new Handler(value, onRejected, prom)), prom;
9940 };
9941 /**
9942 * @param {!Object} value
9943 * @return {?}
9944 */
9945 Promise.all = function(value) {
9946 /** @type {!Array<?>} */
9947 var t = Array.prototype.slice.call(value);
9948 return new Promise(function(resolve, cb) {
9949 /**
9950 * @param {number} n
9951 * @param {!Object} a
9952 * @return {?}
9953 */
9954 function callback(n, a) {
9955 try {
9956 if (a && ("object" == typeof a || "function" == typeof a)) {
9957 var h = a.then;
9958 if ("function" == typeof h) {
9959 return void h.call(a, function(xyz) {
9960 callback(n, xyz);
9961 }, cb);
9962 }
9963 }
9964 /** @type {!Object} */
9965 t[n] = a;
9966 if (0 == --pal) {
9967 resolve(t);
9968 }
9969 } catch (additiveNodes) {
9970 cb(additiveNodes);
9971 }
9972 }
9973 if (0 === t.length) {
9974 return resolve([]);
9975 }
9976 /** @type {number} */
9977 var pal = t.length;
9978 /** @type {number} */
9979 var k = 0;
9980 for (; k < t.length; k++) {
9981 callback(k, t[k]);
9982 }
9983 });
9984 };
9985 /**
9986 * @param {!Object} value
9987 * @return {?}
9988 */
9989 Promise.resolve = function(value) {
9990 return value && "object" == typeof value && value.constructor === Promise ? value : new Promise(function(resolve) {
9991 resolve(value);
9992 });
9993 };
9994 /**
9995 * @param {?} reason
9996 * @return {?}
9997 */
9998 Promise.reject = function(reason) {
9999 return new Promise(function(canCreateDiscussions, reject$2) {
10000 reject$2(reason);
10001 });
10002 };
10003 /**
10004 * @param {!NodeList} values
10005 * @return {?}
10006 */
10007 Promise.race = function(values) {
10008 return new Promise(function(t, fallback) {
10009 /** @type {number} */
10010 var i = 0;
10011 var l = values.length;
10012 for (; i < l; i++) {
10013 values[i].then(t, fallback);
10014 }
10015 });
10016 };
10017 /** @type {function(!Function): undefined} */
10018 Promise._immediateFn = "function" == typeof arg && function(orig) {
10019 arg(orig);
10020 } || function(fn) {
10021 realSetTimeout(fn, 0);
10022 };
10023 /**
10024 * @param {?} err
10025 * @return {undefined}
10026 */
10027 Promise._unhandledRejectionFn = function(err) {
10028 if ("undefined" != typeof console && console) {
10029 console.warn("Possible Unhandled Promise Rejection:", err);
10030 }
10031 };
10032 /**
10033 * @param {!Function} fn
10034 * @return {undefined}
10035 */
10036 Promise._setImmediateFn = function(fn) {
10037 /** @type {!Function} */
10038 Promise._immediateFn = fn;
10039 };
10040 /**
10041 * @param {!Function} fn
10042 * @return {undefined}
10043 */
10044 Promise._setUnhandledRejectionFn = function(fn) {
10045 /** @type {!Function} */
10046 Promise._unhandledRejectionFn = fn;
10047 };
10048 if (void 0 !== root && root.exports) {
10049 /** @type {function(!Object): undefined} */
10050 root.exports = Promise;
10051 } else {
10052 if (!host.Promise) {
10053 /** @type {function(!Object): undefined} */
10054 host.Promise = Promise;
10055 }
10056 }
10057 }(this);
10058 }).call(gen34_options, __webpack_require__(18).setImmediate);
10059 }, function(canCreateDiscussions, exports, unsafeTermFn) {
10060 /**
10061 * @param {string} id
10062 * @param {!Function} clearFn
10063 * @return {undefined}
10064 */
10065 function Timeout(id, clearFn) {
10066 /** @type {string} */
10067 this._id = id;
10068 /** @type {!Function} */
10069 this._clearFn = clearFn;
10070 }
10071 /** @type {function(this:!Function, ...*): *} */
10072 var apply = Function.prototype.apply;
10073 /**
10074 * @return {?}
10075 */
10076 exports.setTimeout = function() {
10077 return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
10078 };
10079 /**
10080 * @return {?}
10081 */
10082 exports.setInterval = function() {
10083 return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
10084 };
10085 /** @type {function(!Object): undefined} */
10086 exports.clearTimeout = exports.clearInterval = function(n) {
10087 if (n) {
10088 n.close();
10089 }
10090 };
10091 /** @type {function(): undefined} */
10092 Timeout.prototype.unref = Timeout.prototype.ref = function() {
10093 };
10094 /**
10095 * @return {undefined}
10096 */
10097 Timeout.prototype.close = function() {
10098 this._clearFn.call(window, this._id);
10099 };
10100 /**
10101 * @param {?} item
10102 * @param {number} msecs
10103 * @return {undefined}
10104 */
10105 exports.enroll = function(item, msecs) {
10106 clearTimeout(item._idleTimeoutId);
10107 /** @type {number} */
10108 item._idleTimeout = msecs;
10109 };
10110 /**
10111 * @param {?} item
10112 * @return {undefined}
10113 */
10114 exports.unenroll = function(item) {
10115 clearTimeout(item._idleTimeoutId);
10116 /** @type {number} */
10117 item._idleTimeout = -1;
10118 };
10119 /** @type {function(!Object): undefined} */
10120 exports._unrefActive = exports.active = function(item) {
10121 clearTimeout(item._idleTimeoutId);
10122 var msecs = item._idleTimeout;
10123 if (0 <= msecs) {
10124 /** @type {number} */
10125 item._idleTimeoutId = setTimeout(function() {
10126 if (item._onTimeout) {
10127 item._onTimeout();
10128 }
10129 }, msecs);
10130 }
10131 };
10132 unsafeTermFn(19);
10133 exports.setImmediate = setImmediate;
10134 exports.clearImmediate = clearImmediate;
10135 }, function(canCreateDiscussions, gen34_options, fn) {
10136 (function(canCreateDiscussions, $process) {
10137 !function(global, n) {
10138 /**
10139 * @param {!Object} key
10140 * @return {undefined}
10141 */
10142 function clear(key) {
10143 delete timers[key];
10144 }
10145 /**
10146 * @param {!Object} key
10147 * @return {undefined}
10148 */
10149 function fn(key) {
10150 if (l) {
10151 setTimeout(fn, 0, key);
10152 } else {
10153 var timer = timers[key];
10154 if (timer) {
10155 /** @type {boolean} */
10156 l = true;
10157 try {
10158 var callback = timer.callback;
10159 var args = timer.args;
10160 switch(args.length) {
10161 case 0:
10162 callback();
10163 break;
10164 case 1:
10165 callback(args[0]);
10166 break;
10167 case 2:
10168 callback(args[0], args[1]);
10169 break;
10170 case 3:
10171 callback(args[0], args[1], args[2]);
10172 break;
10173 default:
10174 callback.apply(void 0, args);
10175 }
10176 } finally {
10177 clear(key);
10178 /** @type {boolean} */
10179 l = false;
10180 }
10181 }
10182 }
10183 }
10184 var defer;
10185 if (!global.setImmediate) {
10186 /** @type {number} */
10187 var key = 1;
10188 var timers = {};
10189 /** @type {boolean} */
10190 var l = false;
10191 var document = global.document;
10192 /** @type {(Object|null)} */
10193 var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
10194 attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
10195 if ("[object process]" === {}.toString.call(global.process)) {
10196 /**
10197 * @param {?} key
10198 * @return {undefined}
10199 */
10200 defer = function(key) {
10201 $process.nextTick(function() {
10202 fn(key);
10203 });
10204 };
10205 } else {
10206 if (function() {
10207 if (global.postMessage && !global.importScripts) {
10208 /** @type {boolean} */
10209 var t = true;
10210 var oldOnMessage = global.onmessage;
10211 return global.onmessage = function() {
10212 /** @type {boolean} */
10213 t = false;
10214 }, global.postMessage("", "*"), global.onmessage = oldOnMessage, t;
10215 }
10216 }()) {
10217 (function() {
10218 /** @type {string} */
10219 var messagePrefix = "setImmediate$" + Math.random() + "$";
10220 /**
10221 * @param {!Object} event
10222 * @return {undefined}
10223 */
10224 var onMessage = function(event) {
10225 if (event.source === global && "string" == typeof event.data && 0 === event.data.indexOf(messagePrefix)) {
10226 fn(+event.data.slice(messagePrefix.length));
10227 }
10228 };
10229 if (global.addEventListener) {
10230 global.addEventListener("message", onMessage, false);
10231 } else {
10232 global.attachEvent("onmessage", onMessage);
10233 }
10234 /**
10235 * @param {number} id
10236 * @return {undefined}
10237 */
10238 defer = function(id) {
10239 global.postMessage(messagePrefix + id, "*");
10240 };
10241 })();
10242 } else {
10243 if (global.MessageChannel) {
10244 (function() {
10245 /** @type {!MessageChannel} */
10246 var channel = new MessageChannel;
10247 /**
10248 * @param {!Object} event
10249 * @return {undefined}
10250 */
10251 channel.port1.onmessage = function(event) {
10252 fn(event.data);
10253 };
10254 /**
10255 * @param {number} obj
10256 * @return {undefined}
10257 */
10258 defer = function(obj) {
10259 channel.port2.postMessage(obj);
10260 };
10261 })();
10262 } else {
10263 if (document && "onreadystatechange" in document.createElement("script")) {
10264 (function() {
10265 var root = document.documentElement;
10266 /**
10267 * @param {?} key
10268 * @return {undefined}
10269 */
10270 defer = function(key) {
10271 var script = document.createElement("script");
10272 /**
10273 * @return {undefined}
10274 */
10275 script.onreadystatechange = function() {
10276 fn(key);
10277 /** @type {null} */
10278 script.onreadystatechange = null;
10279 root.removeChild(script);
10280 /** @type {null} */
10281 script = null;
10282 };
10283 root.appendChild(script);
10284 };
10285 })();
10286 } else {
10287 /**
10288 * @param {number} done
10289 * @return {undefined}
10290 */
10291 defer = function(done) {
10292 setTimeout(fn, 0, done);
10293 };
10294 }
10295 }
10296 }
10297 }
10298 /**
10299 * @param {!Object} value
10300 * @return {?}
10301 */
10302 attachTo.setImmediate = function(value) {
10303 if ("function" != typeof value) {
10304 /** @type {!Function} */
10305 value = new Function("" + value);
10306 }
10307 /** @type {!Array} */
10308 var args = Array(arguments.length - 1);
10309 /** @type {number} */
10310 var i = 0;
10311 for (; i < args.length; i++) {
10312 args[i] = arguments[i + 1];
10313 }
10314 return timers[key] = {
10315 callback : value,
10316 args : args
10317 }, defer(key), key++;
10318 };
10319 /** @type {function(!Object): undefined} */
10320 attachTo.clearImmediate = clear;
10321 }
10322 }("undefined" == typeof self ? void 0 === canCreateDiscussions ? this : canCreateDiscussions : self);
10323 }).call(gen34_options, fn(7), fn(20));
10324 }, function(process, canCreateDiscussions) {
10325 /**
10326 * @return {?}
10327 */
10328 function defaultSetTimout() {
10329 throw Error("setTimeout has not been defined");
10330 }
10331 /**
10332 * @return {?}
10333 */
10334 function defaultClearTimeout() {
10335 throw Error("clearTimeout has not been defined");
10336 }
10337 /**
10338 * @param {!Function} fun
10339 * @return {?}
10340 */
10341 function runTimeout(fun) {
10342 if (cachedSetTimeout === setTimeout) {
10343 return setTimeout(fun, 0);
10344 }
10345 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
10346 return cachedSetTimeout = setTimeout, setTimeout(fun, 0);
10347 }
10348 try {
10349 return cachedSetTimeout(fun, 0);
10350 } catch (t) {
10351 try {
10352 return cachedSetTimeout.call(null, fun, 0);
10353 } catch (t) {
10354 return cachedSetTimeout.call(this, fun, 0);
10355 }
10356 }
10357 }
10358 /**
10359 * @return {undefined}
10360 */
10361 function cleanUpNextTick() {
10362 if (d && currentQueue) {
10363 /** @type {boolean} */
10364 d = false;
10365 if (currentQueue.length) {
10366 queue = currentQueue.concat(queue);
10367 } else {
10368 /** @type {number} */
10369 queueIndex = -1;
10370 }
10371 if (queue.length) {
10372 drainQueue();
10373 }
10374 }
10375 }
10376 /**
10377 * @return {undefined}
10378 */
10379 function drainQueue() {
10380 if (!d) {
10381 var timeout = runTimeout(cleanUpNextTick);
10382 /** @type {boolean} */
10383 d = true;
10384 var len = queue.length;
10385 for (; len;) {
10386 currentQueue = queue;
10387 /** @type {!Array} */
10388 queue = [];
10389 for (; ++queueIndex < len;) {
10390 if (currentQueue) {
10391 currentQueue[queueIndex].run();
10392 }
10393 }
10394 /** @type {number} */
10395 queueIndex = -1;
10396 /** @type {number} */
10397 len = queue.length;
10398 }
10399 /** @type {null} */
10400 currentQueue = null;
10401 /** @type {boolean} */
10402 d = false;
10403 (function(marker) {
10404 if (cachedClearTimeout === clearTimeout) {
10405 return clearTimeout(marker);
10406 }
10407 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
10408 return cachedClearTimeout = clearTimeout, clearTimeout(marker);
10409 }
10410 try {
10411 cachedClearTimeout(marker);
10412 } catch (t) {
10413 try {
10414 return cachedClearTimeout.call(null, marker);
10415 } catch (t) {
10416 return cachedClearTimeout.call(this, marker);
10417 }
10418 }
10419 })(timeout);
10420 }
10421 }
10422 /**
10423 * @param {(Object|string)} fun
10424 * @param {!Array} array
10425 * @return {undefined}
10426 */
10427 function Item(fun, array) {
10428 /** @type {(Object|string)} */
10429 this.fun = fun;
10430 /** @type {!Array} */
10431 this.array = array;
10432 }
10433 /**
10434 * @return {undefined}
10435 */
10436 function noop() {
10437 }
10438 process = process.exports = {};
10439 try {
10440 /** @type {!Function} */
10441 var cachedSetTimeout = "function" == typeof setTimeout ? setTimeout : defaultSetTimout;
10442 } catch (e) {
10443 cachedSetTimeout = defaultSetTimout;
10444 }
10445 try {
10446 /** @type {!Function} */
10447 var cachedClearTimeout = "function" == typeof clearTimeout ? clearTimeout : defaultClearTimeout;
10448 } catch (e) {
10449 cachedClearTimeout = defaultClearTimeout;
10450 }
10451 var currentQueue;
10452 /** @type {!Array} */
10453 var queue = [];
10454 /** @type {boolean} */
10455 var d = false;
10456 /** @type {number} */
10457 var queueIndex = -1;
10458 /**
10459 * @param {!Function} fun
10460 * @return {undefined}
10461 */
10462 process.nextTick = function(fun) {
10463 /** @type {!Array} */
10464 var args = Array(arguments.length - 1);
10465 if (1 < arguments.length) {
10466 /** @type {number} */
10467 var i = 1;
10468 for (; i < arguments.length; i++) {
10469 args[i - 1] = arguments[i];
10470 }
10471 }
10472 queue.push(new Item(fun, args));
10473 if (!(1 !== queue.length || d)) {
10474 runTimeout(drainQueue);
10475 }
10476 };
10477 /**
10478 * @return {undefined}
10479 */
10480 Item.prototype.run = function() {
10481 this.fun.apply(null, this.array);
10482 };
10483 /** @type {string} */
10484 process.title = "browser";
10485 /** @type {boolean} */
10486 process.browser = true;
10487 process.env = {};
10488 /** @type {!Array} */
10489 process.argv = [];
10490 /** @type {string} */
10491 process.version = "";
10492 process.versions = {};
10493 /** @type {function(): undefined} */
10494 process.on = noop;
10495 /** @type {function(): undefined} */
10496 process.addListener = noop;
10497 /** @type {function(): undefined} */
10498 process.once = noop;
10499 /** @type {function(): undefined} */
10500 process.off = noop;
10501 /** @type {function(): undefined} */
10502 process.removeListener = noop;
10503 /** @type {function(): undefined} */
10504 process.removeAllListeners = noop;
10505 /** @type {function(): undefined} */
10506 process.emit = noop;
10507 /** @type {function(): undefined} */
10508 process.prependListener = noop;
10509 /** @type {function(): undefined} */
10510 process.prependOnceListener = noop;
10511 /**
10512 * @param {?} type
10513 * @return {?}
10514 */
10515 process.listeners = function(type) {
10516 return [];
10517 };
10518 /**
10519 * @param {?} name
10520 * @return {?}
10521 */
10522 process.binding = function(name) {
10523 throw Error("process.binding is not supported");
10524 };
10525 /**
10526 * @return {?}
10527 */
10528 process.cwd = function() {
10529 return "/";
10530 };
10531 /**
10532 * @param {?} dir
10533 * @return {?}
10534 */
10535 process.chdir = function(dir) {
10536 throw Error("process.chdir is not supported");
10537 };
10538 /**
10539 * @return {?}
10540 */
10541 process.umask = function() {
10542 return 0;
10543 };
10544 }, function(canCreateDiscussions, isSlidingUp, require) {
10545 require(22).polyfill();
10546 }, function(module, canCreateDiscussions, n) {
10547 /**
10548 * @param {!Object} value
10549 * @param {!Object} name
10550 * @return {?}
10551 */
10552 function assign(value, name) {
10553 if (null == value) {
10554 throw new TypeError("Cannot convert first argument to object");
10555 }
10556 /** @type {!Object} */
10557 var output = Object(value);
10558 /** @type {number} */
10559 var i = 1;
10560 for (; i < arguments.length; i++) {
10561 var obj = arguments[i];
10562 if (null != obj) {
10563 /** @type {!Array<string>} */
10564 var i = Object.keys(Object(obj));
10565 /** @type {number} */
10566 var l = 0;
10567 /** @type {number} */
10568 var u = i.length;
10569 for (; l < u; l++) {
10570 /** @type {string} */
10571 var k = i[l];
10572 /** @type {(ObjectPropertyDescriptor<?>|undefined)} */
10573 var desc = Object.getOwnPropertyDescriptor(obj, k);
10574 if (void 0 !== desc && desc.enumerable) {
10575 output[k] = obj[k];
10576 }
10577 }
10578 }
10579 }
10580 return output;
10581 }
10582 module.exports = {
10583 assign : assign,
10584 polyfill : function() {
10585 if (!Object.assign) {
10586 Object.defineProperty(Object, "assign", {
10587 enumerable : false,
10588 configurable : true,
10589 writable : true,
10590 value : assign
10591 });
10592 }
10593 }
10594 };
10595 }, function(exports, res, $) {
10596 Object.defineProperty(res, "__esModule", {
10597 value : true
10598 });
10599 var o = $(24);
10600 var self = $(6);
10601 var manager = $(5);
10602 var parser = $(36);
10603 (exports = function() {
10604 /** @type {!Array} */
10605 var args = [];
10606 /** @type {number} */
10607 var i = 0;
10608 for (; i < arguments.length; i++) {
10609 args[i] = arguments[i];
10610 }
10611 if ("undefined" != typeof window) {
10612 var key = parser.getOpts.apply(void 0, args);
10613 return new Promise(function(isZoomable, reject) {
10614 manager.default.promise = {
10615 resolve : isZoomable,
10616 reject : reject
10617 };
10618 o.default(key);
10619 setTimeout(function() {
10620 self.openModal();
10621 });
10622 });
10623 }
10624 }).close = self.onAction;
10625 exports.getState = self.getState;
10626 exports.setActionValue = manager.setActionValue;
10627 exports.stopLoading = self.stopLoading;
10628 exports.setDefaults = parser.setDefaults;
10629 /** @type {!Object} */
10630 res.default = exports;
10631 }, function(canCreateDiscussions, o, require) {
10632 Object.defineProperty(o, "__esModule", {
10633 value : true
10634 });
10635 var view = require(1);
10636 var selected = require(0).default.MODAL;
10637 var i = require(4);
10638 var _deepAssign2 = require(34);
10639 var s = require(35);
10640 var lexer = require(1);
10641 /**
10642 * @param {!Object} key
10643 * @return {undefined}
10644 */
10645 o.init = function(key) {
10646 if (!view.getNode(selected)) {
10647 if (!document.body) {
10648 lexer.throwErr("You can only use SweetAlert AFTER the DOM has loaded!");
10649 }
10650 _deepAssign2.default();
10651 i.default();
10652 }
10653 i.initModalContent(key);
10654 s.default(key);
10655 };
10656 /** @type {function(!Object): undefined} */
10657 o.default = o.init;
10658 }, function(canCreateDiscussions, o, require) {
10659 Object.defineProperty(o, "__esModule", {
10660 value : true
10661 });
10662 canCreateDiscussions = require(0).default.MODAL;
10663 /** @type {string} */
10664 o.modalMarkup = '\n <div class="' + canCreateDiscussions + '" role="dialog" aria-modal="true"></div>';
10665 /** @type {string} */
10666 o.default = o.modalMarkup;
10667 }, function(canCreateDiscussions, t, require) {
10668 Object.defineProperty(t, "__esModule", {
10669 value : true
10670 });
10671 canCreateDiscussions = require(0).default.OVERLAY;
10672 /** @type {string} */
10673 t.default = '<div \n class="' + canCreateDiscussions + '"\n tabIndex="-1">\n </div>';
10674 }, function(canCreateDiscussions, argArr3, require) {
10675 Object.defineProperty(argArr3, "__esModule", {
10676 value : true
10677 });
10678 var at = require(0).default.ICON;
10679 /**
10680 * @return {?}
10681 */
10682 argArr3.errorIconMarkup = function() {
10683 /** @type {string} */
10684 var e = at + "--error";
10685 /** @type {string} */
10686 var id = e + "__line";
10687 return '\n <div class="' + e + '__x-mark">\n <span class="' + id + " " + id + '--left"></span>\n <span class="' + id + " " + id + '--right"></span>\n </div>\n ';
10688 };
10689 /**
10690 * @return {?}
10691 */
10692 argArr3.warningIconMarkup = function() {
10693 /** @type {string} */
10694 var e = at + "--warning";
10695 return '\n <span class="' + e + '__body">\n <span class="' + e + '__dot"></span>\n </span>\n ';
10696 };
10697 /**
10698 * @return {?}
10699 */
10700 argArr3.successIconMarkup = function() {
10701 /** @type {string} */
10702 var e = at + "--success";
10703 return '\n <span class="' + e + "__line " + e + '__line--long"></span>\n <span class="' + e + "__line " + e + '__line--tip"></span>\n\n <div class="' + e + '__ring"></div>\n <div class="' + e + '__hide-corners"></div>\n ';
10704 };
10705 }, function(tokenType, settings, require) {
10706 Object.defineProperty(settings, "__esModule", {
10707 value : true
10708 });
10709 tokenType = require(0).default.CONTENT;
10710 /** @type {string} */
10711 settings.contentMarkup = '\n <div class="' + tokenType + '">\n\n </div>\n';
10712 }, function(CONFIG, o, extend) {
10713 Object.defineProperty(o, "__esModule", {
10714 value : true
10715 });
10716 CONFIG = extend(0);
10717 /** @type {string} */
10718 o.buttonMarkup = '\n <div class="' + CONFIG.default.BUTTON_CONTAINER + '">\n\n <button\n class="' + CONFIG.default.BUTTON + '"\n ></button>\n\n <div class="' + CONFIG.default.BUTTON_LOADER + '">\n <div></div>\n <div></div>\n <div></div>\n </div>\n\n </div>\n';
10719 }, function(tabListController, t, require) {
10720 Object.defineProperty(t, "__esModule", {
10721 value : true
10722 });
10723 var _ = require(4);
10724 var resourcesLib = require(2);
10725 var text = (tabListController = require(0)).default.ICON;
10726 var a = tabListController.default.ICON_CUSTOM;
10727 /** @type {!Array} */
10728 var levels = ["error", "warning", "success", "info"];
10729 var defaults = {
10730 error : resourcesLib.errorIconMarkup(),
10731 warning : resourcesLib.warningIconMarkup(),
10732 success : resourcesLib.successIconMarkup()
10733 };
10734 /**
10735 * @param {!Object} value
10736 * @return {undefined}
10737 */
10738 t.default = function(value) {
10739 if (value) {
10740 var t = _.injectElIntoModal(resourcesLib.iconMarkup);
10741 if (levels.includes(value)) {
10742 t.classList.add(text + "--" + value);
10743 if (value = defaults[value]) {
10744 /** @type {!Object} */
10745 t.innerHTML = value;
10746 }
10747 } else {
10748 t.classList.add(a);
10749 /** @type {!Element} */
10750 var homepageImg = document.createElement("img");
10751 /** @type {!Object} */
10752 homepageImg.src = value;
10753 t.appendChild(homepageImg);
10754 }
10755 }
10756 };
10757 }, function(canCreateDiscussions, argArr3, unescape) {
10758 Object.defineProperty(argArr3, "__esModule", {
10759 value : true
10760 });
10761 var currentURL = unescape(2);
10762 var path = unescape(4);
10763 /**
10764 * @param {!Object} target
10765 * @return {undefined}
10766 */
10767 var parse = function(target) {
10768 if (navigator.userAgent.includes("AppleWebKit")) {
10769 /** @type {string} */
10770 target.style.display = "none";
10771 target.offsetHeight;
10772 /** @type {string} */
10773 target.style.display = "";
10774 }
10775 };
10776 /**
10777 * @param {string} result
10778 * @return {undefined}
10779 */
10780 argArr3.initTitle = function(result) {
10781 if (result) {
10782 var response = path.injectElIntoModal(currentURL.titleMarkup);
10783 /** @type {string} */
10784 response.textContent = result;
10785 parse(response);
10786 }
10787 };
10788 /**
10789 * @param {string} name
10790 * @return {undefined}
10791 */
10792 argArr3.initText = function(name) {
10793 if (name) {
10794 /** @type {!DocumentFragment} */
10795 var df = document.createDocumentFragment();
10796 name.split("\n").forEach(function(name, n, inRevIdx) {
10797 df.appendChild(document.createTextNode(name));
10798 if (n < inRevIdx.length - 1) {
10799 df.appendChild(document.createElement("br"));
10800 }
10801 });
10802 (name = path.injectElIntoModal(currentURL.textMarkup)).appendChild(df);
10803 parse(name);
10804 }
10805 };
10806 }, function(e, t, $) {
10807 Object.defineProperty(t, "__esModule", {
10808 value : true
10809 });
10810 var $btn = $(1);
10811 var clone = $(4);
10812 var name = (e = $(0)).default.BUTTON;
10813 var str = e.default.DANGER_BUTTON;
10814 var SCE_CONTEXTS = $(3);
10815 var btn = $(2);
10816 var _this = $(6);
10817 var $think = $(5);
10818 /**
10819 * @param {string} type
10820 * @param {!Object} config
10821 * @param {!Object} item
10822 * @return {?}
10823 */
10824 var init = function(type, config, item) {
10825 var author = config.text;
10826 var p = config.value;
10827 var names = config.className;
10828 config = config.closeModal;
10829 var editorWrapper = $btn.stringToNode(btn.buttonMarkup);
10830 var input = editorWrapper.querySelector("." + name);
10831 return input.classList.add(name + "--" + type), names && (Array.isArray(names) ? names : names.split(" ")).filter(function(inRevIdx) {
10832 return 0 < inRevIdx.length;
10833 }).forEach(function(e) {
10834 input.classList.add(e);
10835 }), item && type === SCE_CONTEXTS.CONFIRM_KEY && input.classList.add(str), input.textContent = author, (item = {})[type] = p, $think.setActionValue(item), $think.setActionOptionsFor(type, {
10836 closeModal : config
10837 }), input.addEventListener("click", function() {
10838 return _this.onAction(type);
10839 }), editorWrapper;
10840 };
10841 /**
10842 * @param {!Object} value
10843 * @param {!Object} name
10844 * @return {undefined}
10845 */
10846 t.default = function(value, name) {
10847 var i;
10848 var pre = clone.injectElIntoModal(btn.footerMarkup);
10849 for (i in value) {
10850 var type = value[i];
10851 var ret = init(i, type, name);
10852 if (type.visible) {
10853 pre.appendChild(ret);
10854 }
10855 }
10856 if (0 === pre.children.length) {
10857 pre.remove();
10858 }
10859 };
10860 }, function(canCreateDiscussions, t, require) {
10861 Object.defineProperty(t, "__esModule", {
10862 value : true
10863 });
10864 var info = require(3);
10865 var templateBodyRegexp = require(4);
10866 var settings = require(2);
10867 var a = require(5);
10868 var runtime = require(6);
10869 var blockName = require(0).default.CONTENT;
10870 /**
10871 * @param {!Element} input
10872 * @return {undefined}
10873 */
10874 var init = function(input) {
10875 input.addEventListener("input", function(e) {
10876 a.setActionValue(e.target.value);
10877 });
10878 input.addEventListener("keyup", function(shortcutKeyObject) {
10879 if ("Enter" === shortcutKeyObject.key) {
10880 return runtime.onAction(info.CONFIRM_KEY);
10881 }
10882 });
10883 setTimeout(function() {
10884 input.focus();
10885 a.setActionValue("");
10886 }, 0);
10887 };
10888 /**
10889 * @param {!Object} value
10890 * @return {undefined}
10891 */
10892 t.default = function(value) {
10893 if (value) {
10894 var t = templateBodyRegexp.injectElIntoModal(settings.contentMarkup);
10895 var name = value.element;
10896 if (value = value.attributes, "string" == typeof name) {
10897 /** @type {!Element} */
10898 var data = document.createElement(name);
10899 var k;
10900 for (k in data.classList.add(blockName + "__" + name), value) {
10901 data[k] = value[k];
10902 }
10903 if ("input" === name) {
10904 init(data);
10905 }
10906 t.appendChild(data);
10907 } else {
10908 t.appendChild(name);
10909 }
10910 }
10911 };
10912 }, function(canCreateDiscussions, t, require) {
10913 Object.defineProperty(t, "__esModule", {
10914 value : true
10915 });
10916 var layout = require(1);
10917 var flag = require(2);
10918 /**
10919 * @return {undefined}
10920 */
10921 t.default = function() {
10922 var userJoinedText = layout.stringToNode(flag.overlayMarkup);
10923 document.body.appendChild(userJoinedText);
10924 };
10925 }, function(CONFIG, t, extend) {
10926 Object.defineProperty(t, "__esModule", {
10927 value : true
10928 });
10929 var options = extend(5);
10930 var m = extend(6);
10931 var s = extend(1);
10932 var props = extend(3);
10933 var container = (CONFIG = extend(0)).default.MODAL;
10934 var i = CONFIG.default.BUTTON;
10935 var key = CONFIG.default.OVERLAY;
10936 /**
10937 * @param {!Object} event
10938 * @return {?}
10939 */
10940 var handleKeyDown = function(event) {
10941 if (options.default.isOpen) {
10942 switch(event.key) {
10943 case "Escape":
10944 return m.onAction(props.CANCEL_KEY);
10945 }
10946 }
10947 };
10948 /**
10949 * @param {!Object} event
10950 * @return {undefined}
10951 */
10952 var callback = function(event) {
10953 if (options.default.isOpen) {
10954 switch(event.key) {
10955 case "Tab":
10956 event.preventDefault();
10957 cb();
10958 }
10959 }
10960 };
10961 /**
10962 * @param {!Event} event
10963 * @return {undefined}
10964 */
10965 var onKeyDown = function(event) {
10966 if (options.default.isOpen && "Tab" === event.key && event.shiftKey) {
10967 event.preventDefault();
10968 next();
10969 }
10970 };
10971 /**
10972 * @return {undefined}
10973 */
10974 var cb = function() {
10975 var div = s.getNode(i);
10976 if (div) {
10977 /** @type {number} */
10978 div.tabIndex = 0;
10979 div.focus();
10980 }
10981 };
10982 /**
10983 * @return {undefined}
10984 */
10985 var next = function() {
10986 var b = s.getNode(container).querySelectorAll("." + i);
10987 if (b = b[b.length - 1]) {
10988 b.focus();
10989 }
10990 };
10991 /**
10992 * @param {!Event} event
10993 * @return {?}
10994 */
10995 var handleMouseUpEvent = function(event) {
10996 if (s.getNode(key) === event.target) {
10997 return m.onAction(props.CANCEL_KEY);
10998 }
10999 };
11000 /**
11001 * @param {!Object} value
11002 * @return {undefined}
11003 */
11004 t.default = function(value) {
11005 if (value.closeOnEsc) {
11006 document.addEventListener("keyup", handleKeyDown);
11007 } else {
11008 document.removeEventListener("keyup", handleKeyDown);
11009 }
11010 if (value.dangerMode) {
11011 cb();
11012 } else {
11013 next();
11014 }
11015 var move_elements = s.getNode(container).querySelectorAll("." + i);
11016 if (move_elements.length) {
11017 move_elements[move_elements.length - 1].addEventListener("keydown", callback);
11018 move_elements[0].addEventListener("keydown", onKeyDown);
11019 }
11020 move_elements = value.closeOnClickOutside;
11021 var element = s.getNode(key);
11022 element.removeEventListener("click", handleMouseUpEvent);
11023 if (move_elements) {
11024 element.addEventListener("click", handleMouseUpEvent);
11025 }
11026 (function(delay) {
11027 if (options.default.timer) {
11028 clearTimeout(options.default.timer);
11029 }
11030 if (delay) {
11031 options.default.timer = window.setTimeout(function() {
11032 return m.onAction(props.CANCEL_KEY);
11033 }, delay);
11034 }
11035 })(value.timer);
11036 };
11037 }, function(canCreateDiscussions, obj, require) {
11038 Object.defineProperty(obj, "__esModule", {
11039 value : true
11040 });
11041 var $$ = require(1);
11042 var event = require(3);
11043 var ASSERT = require(37);
11044 var config = require(38);
11045 var data = {
11046 title : null,
11047 text : null,
11048 icon : null,
11049 buttons : event.defaultButtonList,
11050 content : null,
11051 className : null,
11052 closeOnClickOutside : true,
11053 closeOnEsc : true,
11054 dangerMode : false,
11055 timer : null
11056 };
11057 /** @type {!Object} */
11058 var opts = Object.assign({}, data);
11059 /**
11060 * @param {undefined} config
11061 * @return {undefined}
11062 */
11063 obj.setDefaults = function(config) {
11064 /** @type {!Object} */
11065 opts = Object.assign({}, data, config);
11066 };
11067 /**
11068 * @param {!Object} c
11069 * @return {?}
11070 */
11071 var filter = function(c) {
11072 var undefined = c && c.button;
11073 return c = c && c.buttons, void 0 !== undefined && void 0 !== c && $$.throwErr("Cannot set both 'button' and 'buttons' options!"), void 0 !== undefined ? {
11074 confirm : undefined
11075 } : c;
11076 };
11077 /**
11078 * @param {number} name
11079 * @param {?} value
11080 * @return {undefined}
11081 */
11082 var fn = function(name, value) {
11083 value = value[name = name + 1];
11084 if (!($$.isPlainObject(value) || void 0 === value)) {
11085 $$.throwErr("Expected " + $$.ordinalSuffixOf(name + 1) + " argument ('" + value + "') to be a plain object");
11086 }
11087 };
11088 /**
11089 * @return {?}
11090 */
11091 obj.getOpts = function() {
11092 /** @type {!Array} */
11093 var o = [];
11094 /** @type {number} */
11095 var key = 0;
11096 for (; key < arguments.length; key++) {
11097 o[key] = arguments[key];
11098 }
11099 var options = {};
11100 return o.forEach(function(value, name) {
11101 e: {
11102 /** @type {boolean} */
11103 var w = value instanceof Element;
11104 if ("string" == typeof value) {
11105 if (0 === name) {
11106 value = {
11107 text : value
11108 };
11109 break e;
11110 }
11111 if (1 === name) {
11112 value = {
11113 text : value,
11114 title : o[0]
11115 };
11116 break e;
11117 }
11118 if (2 === name) {
11119 fn(name, o);
11120 value = {
11121 icon : value
11122 };
11123 break e;
11124 }
11125 } else {
11126 if (w && 0 === name) {
11127 fn(name, o);
11128 value = {
11129 content : value
11130 };
11131 break e;
11132 }
11133 if ($$.isPlainObject(value)) {
11134 if (void 0 !== (w = o[name = name + 1])) {
11135 $$.throwErr("Unexpected " + $$.ordinalSuffixOf(name + 1) + " argument (" + w + ")");
11136 }
11137 break e;
11138 }
11139 }
11140 $$.throwErr($$.ordinalSuffixOf(name + 1) + " argument ('" + value + "') is invalid");
11141 value = void 0;
11142 }
11143 Object.assign(options, value);
11144 }), key = filter(options), options.buttons = event.getButtonListOpts(key), delete options.button, options.content = ASSERT.getContentOpts(options.content), key = Object.assign({}, data, opts, options), Object.keys(key).forEach(function(paramName) {
11145 if (config.DEPRECATED_OPTS[paramName]) {
11146 config.logDeprecation(paramName);
11147 }
11148 }), key;
11149 };
11150 }, function(canCreateDiscussions, argArr3, $) {
11151 Object.defineProperty(argArr3, "__esModule", {
11152 value : true
11153 });
11154 var e = $(1);
11155 var el = {
11156 element : "input",
11157 attributes : {
11158 placeholder : ""
11159 }
11160 };
11161 /**
11162 * @param {!Object} a
11163 * @return {?}
11164 */
11165 argArr3.getContentOpts = function(a) {
11166 return e.isPlainObject(a) ? Object.assign({}, a) : a instanceof Element ? {
11167 element : a
11168 } : "input" === a ? el : null;
11169 };
11170 }, function(canCreateDiscussions, config, n) {
11171 Object.defineProperty(config, "__esModule", {
11172 value : true
11173 });
11174 /**
11175 * @param {string} key
11176 * @return {undefined}
11177 */
11178 config.logDeprecation = function(key) {
11179 var item = config.DEPRECATED_OPTS[key];
11180 var replacement = item.replacement;
11181 var releaseAuthor = item.subOption;
11182 var values = item.link;
11183 /** @type {string} */
11184 key = 'SweetAlert warning: "' + key + '" option has been ' + (item.onlyRename ? "renamed" : "deprecated") + ".";
11185 if (replacement) {
11186 /** @type {string} */
11187 key = key + (" Please use" + (releaseAuthor ? ' "' + releaseAuthor + '" in ' : " ") + '"' + replacement + '" instead.');
11188 }
11189 console.warn(key + (values ? " More details: https://sweetalert.js.org" + values : " More details: https://sweetalert.js.org/guides/#upgrading-from-1x"));
11190 };
11191 config.DEPRECATED_OPTS = {
11192 type : {
11193 replacement : "icon",
11194 link : "/docs/#icon"
11195 },
11196 imageUrl : {
11197 replacement : "icon",
11198 link : "/docs/#icon"
11199 },
11200 customClass : {
11201 replacement : "className",
11202 onlyRename : true,
11203 link : "/docs/#classname"
11204 },
11205 imageSize : {},
11206 showCancelButton : {
11207 replacement : "buttons",
11208 link : "/docs/#buttons"
11209 },
11210 showConfirmButton : {
11211 replacement : "button",
11212 link : "/docs/#button"
11213 },
11214 confirmButtonText : {
11215 replacement : "button",
11216 link : "/docs/#button"
11217 },
11218 confirmButtonColor : {},
11219 cancelButtonText : {
11220 replacement : "buttons",
11221 link : "/docs/#buttons"
11222 },
11223 closeOnConfirm : {
11224 replacement : "button",
11225 subOption : "closeModal",
11226 link : "/docs/#button"
11227 },
11228 closeOnCancel : {
11229 replacement : "buttons",
11230 subOption : "closeModal",
11231 link : "/docs/#buttons"
11232 },
11233 showLoaderOnConfirm : {
11234 replacement : "buttons"
11235 },
11236 animation : {},
11237 inputType : {
11238 replacement : "content",
11239 link : "/docs/#content"
11240 },
11241 inputValue : {
11242 replacement : "content",
11243 link : "/docs/#content"
11244 },
11245 inputPlaceholder : {
11246 replacement : "content",
11247 link : "/docs/#content"
11248 },
11249 html : {
11250 replacement : "content",
11251 link : "/docs/#content"
11252 },
11253 allowEscapeKey : {
11254 replacement : "closeOnEsc",
11255 onlyRename : true,
11256 link : "/docs/#closeonesc"
11257 },
11258 allowClickOutside : {
11259 replacement : "closeOnClickOutside",
11260 onlyRename : true,
11261 link : "/docs/#closeonclickoutside"
11262 }
11263 };
11264 }]);
11265 };
11266 module.exports = init();
11267 }).call(this, __webpack_require__(3).setImmediate, __webpack_require__(3).clearImmediate);
11268}, function(module, canCreateDiscussions) {
11269 /**
11270 * @param {string} a
11271 * @param {string} b
11272 * @param {number} max
11273 * @return {?}
11274 */
11275 function compare(a, b, max) {
11276 if ((a = String(a)) === (b = String(b))) {
11277 return 0;
11278 }
11279 /** @type {!Array<string>} */
11280 a = a.split(".");
11281 /** @type {!Array<string>} */
11282 b = b.split(".");
11283 max = Math[max ? "max" : "min"](a.length, b.length);
11284 /** @type {number} */
11285 var i = 0;
11286 for (; i < max; i++) {
11287 if (a[i] = void 0 === a[i] ? 0 : parseInt(a[i], 10), b[i] = void 0 === b[i] ? 0 : parseInt(b[i], 10), a[i] > b[i]) {
11288 return 1;
11289 }
11290 if (a[i] < b[i]) {
11291 return -1;
11292 }
11293 }
11294 return 0;
11295 }
11296 /**
11297 * @param {!Object} value
11298 * @return {undefined}
11299 */
11300 var exports = function(value) {
11301 /** @type {string} */
11302 this._version = String(value);
11303 };
11304 /**
11305 * @param {string} start
11306 * @param {string} actual
11307 * @return {?}
11308 */
11309 exports.compare = function(start, actual) {
11310 return compare(start, actual, true);
11311 };
11312 /**
11313 * @param {number} i
11314 * @param {!Function} value
11315 * @return {?}
11316 */
11317 exports.eq = function(i, value) {
11318 return 0 === compare(i, value, false);
11319 };
11320 /**
11321 * @param {string} i
11322 * @param {string} b
11323 * @return {?}
11324 */
11325 exports.gt = function(i, b) {
11326 return 0 < compare(i, b, true);
11327 };
11328 /**
11329 * @param {string} b
11330 * @param {string} a
11331 * @return {?}
11332 */
11333 exports.gte = function(b, a) {
11334 return 0 <= compare(b, a, true);
11335 };
11336 /**
11337 * @param {string} i
11338 * @param {string} value
11339 * @return {?}
11340 */
11341 exports.lt = function(i, value) {
11342 return 0 > compare(i, value, true);
11343 };
11344 /**
11345 * @param {string} b
11346 * @param {string} a
11347 * @return {?}
11348 */
11349 exports.lte = function(b, a) {
11350 return 0 >= compare(b, a, true);
11351 };
11352 exports.prototype = {
11353 eq : function(name) {
11354 return exports.eq(this._version, name);
11355 },
11356 gt : function(b) {
11357 return exports.gt(this._version, b);
11358 },
11359 gte : function(b) {
11360 return exports.gte(this._version, b);
11361 },
11362 lt : function(b) {
11363 return exports.lt(this._version, b);
11364 },
11365 lte : function(b) {
11366 return exports.lte(this._version, b);
11367 },
11368 valueOf : function() {
11369 return parseFloat(this._version.split(".").slice(0, 2).join("."), 10);
11370 },
11371 toString : function(e) {
11372 return void 0 === e ? this._version : this._version.split(".").slice(0, e).join(".");
11373 }
11374 };
11375 /** @type {function(!Object): undefined} */
11376 module.exports = exports;
11377}, function(context, init) {
11378 /**
11379 * @param {string} name
11380 * @return {?}
11381 */
11382 (init = function(value) {
11383 /** @type {!Object} */
11384 this.binds = value;
11385 /** @type {boolean} */
11386 this._enabled = true;
11387 /** @type {string} */
11388 this.name = "binds";
11389 this.UI = {
11390 name : "Binds",
11391 description : ""
11392 };
11393 /** @type {!Array} */
11394 this._options = [];
11395 this.addOption("aimbot", "AimBot", "Mouse3");
11396 this.addOption("spinbot", "SpinBot", "KeyX", "toggle");
11397 this.addOption("switch", "AutoSwitch", "Mouse3");
11398 this.addOption("heal", "AutoHeal", "Mouse3");
11399 }).prototype.isDown = function(name) {
11400 return this.binds.isDown(this.option(name));
11401 };
11402 /**
11403 * @param {string} name
11404 * @return {?}
11405 */
11406 init.prototype.toggled = function(name) {
11407 return !!this.binds.toggles[this.option(name)] && this.binds.toggles[this.option(name)];
11408 };
11409 /**
11410 * @param {string} name
11411 * @return {?}
11412 */
11413 init.prototype.option = function(name) {
11414 try {
11415 var opt = this._options.filter(function(pkgObject) {
11416 return pkgObject.name === name;
11417 })[0].value;
11418 } catch (e) {
11419 /** @type {boolean} */
11420 opt = false;
11421 }
11422 return opt;
11423 };
11424 /**
11425 * @param {string} str
11426 * @return {?}
11427 */
11428 init.prototype.test = function(str) {
11429 return "press" == this.option(str + "_type") ? this.isDown(str) : this.toggled(str);
11430 };
11431 /**
11432 * @param {string} name
11433 * @param {string} index
11434 * @param {string} column
11435 * @param {!Object} type
11436 * @return {undefined}
11437 */
11438 init.prototype.addOption = function(name, index, column, type) {
11439 this._options.push({
11440 name : name,
11441 value : column,
11442 opts : this.binds.keyNames,
11443 UI : {
11444 name : index
11445 }
11446 });
11447 this._options.push({
11448 name : name + "_type",
11449 value : type || "press",
11450 opts : ["press", "toggle"],
11451 UI : {
11452 name : "	type",
11453 tiny : true
11454 }
11455 });
11456 };
11457 /**
11458 * @param {?} value
11459 * @param {!Object} index
11460 * @return {undefined}
11461 */
11462 init.prototype.setOption = function(value, index) {
11463 try {
11464 ds;
11465 /** @type {!Object} */
11466 this._options.filter(function(data) {
11467 return data.name === value;
11468 })[0].value = index;
11469 } catch (e) {
11470 }
11471 };
11472 $jscomp.global.Object.defineProperties(init.prototype, {
11473 enabled : {
11474 configurable : true,
11475 enumerable : true,
11476 get : function() {
11477 return true;
11478 },
11479 set : function(text) {
11480 }
11481 }
11482 });
11483 /** @type {!Function} */
11484 context.exports = init;
11485}, function(mixin, render) {
11486 /**
11487 * @param {string} name
11488 * @return {?}
11489 */
11490 (render = function() {
11491 /** @type {boolean} */
11492 this._enabled = true;
11493 /** @type {string} */
11494 this.name = "aimbot";
11495 this.UI = {
11496 name : "Aim Bot",
11497 description : "Aims for you"
11498 };
11499 /** @type {!Array} */
11500 this._options = [{
11501 value : "autoaim",
11502 opts : ["autoaim", "on shoot", "inverted aim"],
11503 name : "type",
11504 UI : {
11505 name : "Type"
11506 }
11507 }, {
11508 value : false,
11509 name : "col",
11510 UI : {
11511 name : "Use Collisions"
11512 }
11513 }, {
11514 value : true,
11515 name : "mouse",
11516 UI : {
11517 name : "Aim with Mouse"
11518 }
11519 }, {
11520 value : true,
11521 name : "attack",
11522 UI : {
11523 name : "AutoAttack\u2122"
11524 }
11525 }, {
11526 value : true,
11527 name : "shoot",
11528 UI : {
11529 name : "AutoShoot\u2122"
11530 }
11531 }, {
11532 value : false,
11533 name : "down",
11534 UI : {
11535 name : "Aim at Downed"
11536 }
11537 }, {
11538 value : false,
11539 name : "object",
11540 UI : {
11541 name : "Aim at Objects"
11542 }
11543 }, {
11544 value : false,
11545 name : "move",
11546 UI : {
11547 name : "MobileMovement\u2122"
11548 }
11549 }, {
11550 value : false,
11551 name : "legit",
11552 UI : {
11553 name : "LegitMode\u2122"
11554 }
11555 }, {
11556 value : 0,
11557 int : 1,
11558 name : "fov",
11559 UI : {
11560 name : "Aim FOV (0 = off)"
11561 },
11562 min : 0,
11563 max : 180
11564 }, {
11565 value : 1.3,
11566 int : .1,
11567 name : "velocity",
11568 UI : {
11569 name : "Velocity Mult"
11570 },
11571 min : .1,
11572 max : 3
11573 }];
11574 this.lastAim = {
11575 x : 0,
11576 y : 0
11577 };
11578 }).prototype.option = function(name) {
11579 try {
11580 var opt = this._options.filter(function(pkgObject) {
11581 return pkgObject.name === name;
11582 })[0].value;
11583 } catch (e) {
11584 /** @type {boolean} */
11585 opt = false;
11586 }
11587 return opt;
11588 };
11589 /**
11590 * @param {?} value
11591 * @param {!Object} index
11592 * @return {undefined}
11593 */
11594 render.prototype.setOption = function(value, index) {
11595 try {
11596 /** @type {!Object} */
11597 this._options.filter(function(data) {
11598 return data.name === value;
11599 })[0].value = index;
11600 } catch (e) {
11601 }
11602 };
11603 /**
11604 * @param {!Object} data
11605 * @param {?} ctx
11606 * @param {!Object} obj
11607 * @param {!Object} scope
11608 * @param {!Object} options
11609 * @param {!Object} config
11610 * @return {undefined}
11611 */
11612 render.prototype.loop = function(data, ctx, obj, scope, options, config) {
11613 var self = this;
11614 try {
11615 var json = options.getEnemies(this.option("object")).sort(function(f, r) {
11616 if (self.option("mouse")) {
11617 var i = ctx[data.camera].pointToScreen(f.pos);
11618 return r = ctx[data.camera].pointToScreen(r.pos), (i = self.calcDistance(i.x, i.y, scope.mouse.x, scope.mouse.y)) - (r = self.calcDistance(r.x, r.y, scope.mouse.x, scope.mouse.y));
11619 }
11620 return i = ctx[data.camera].pointToScreen(obj.pos), f = ctx[data.camera].pointToScreen(f.pos), r = ctx[data.camera].pointToScreen(r.pos), f = self.calcDistance(i.x, i.y, f.x, f.y), i = self.calcDistance(i.x, i.y, r.x, r.y), Math.abs(f) - Math.abs(i);
11621 }).filter(function(prev) {
11622 var Cpoints;
11623 if (Cpoints = prev.layer === obj.layer && (!self.option("col") || (2 == prev.__type || options.cantCollide(prev)))) {
11624 if (0 < self.option("fov")) {
11625 Cpoints = ctx[data.camera].pointToScreen(obj.pos);
11626 var point = ctx[data.camera].pointToScreen(prev.pos);
11627 /** @type {boolean} */
11628 Cpoints = Math.abs(Math.atan2(point.y - Cpoints.y, point.x - Cpoints.x) - Math.atan2(scope.mouse.y - Cpoints.y, scope.mouse.x - Cpoints.x)) < self.option("fov") * (Math.PI / 180);
11629 } else {
11630 /** @type {boolean} */
11631 Cpoints = true;
11632 }
11633 }
11634 return Cpoints && (!!self.option("down") || (!prev[data.netData] || !prev[data.netData].downed));
11635 });
11636 if (options.selectedEnemy = json, this.aim = false, this.option("move") && (scope.moveAngle = this.calcAngle({
11637 x : scope.mouse.x - window.innerWidth / 2,
11638 y : window.innerHeight / 2 - scope.mouse.y
11639 }, {
11640 x : 0,
11641 y : 0
11642 }) + Math.PI), 0 < json.length && ("autoaim" == this.option("type") ? !config.binds.test("aimbot") : "on shoot" == this.option("type") ? scope.leftMouse : "inverted aim" == this.option("type") && config.binds.test("aimbot"))) {
11643 /** @type {boolean} */
11644 this.aim = true;
11645 var $cell = options.cantCollide(json[0]);
11646 var value = this.posCalc(json[0], obj, ctx, data, options);
11647 this.lastAim.x = this.option("legit") ? this.lerp(this.lastAim.x, value.x, .8) : value.x;
11648 this.lastAim.y = this.option("legit") ? this.lerp(this.lastAim.y, value.y, .8) : value.y;
11649 scope.aim(this.lastAim);
11650 var start = json[0].rad ? json[0].rad : json[0].collider && json[0].collider.rad || 4;
11651 /** @type {number} */
11652 var removeLen = 2 * (options.melee[obj[data.netData].weapType] && options.melee[obj[data.netData].weapType].attack.rad || 1);
11653 if (options.autoAttack = false, this.option("attack")) {
11654 var i = this.calcDistance(json[0].pos.x, json[0].pos.y, obj.pos.x, obj.pos.y);
11655 if (8 >= i) {
11656 /** @type {boolean} */
11657 options.autoAttack = true;
11658 scope.moveAngle = this.calcAngle(json[0].pos, obj.pos) + Math.PI;
11659 if (i < start + removeLen) {
11660 scope.addInput("EquipMelee");
11661 scope.addInput("Fire");
11662 }
11663 }
11664 }
11665 var info = obj[data.localData];
11666 if (this.option("shoot") && $cell && 0 < info[data.weapons][info[data.weapIdx]].ammo) {
11667 scope.addInput("Fire");
11668 }
11669 }
11670 if (1 > json.length || !this.aim) {
11671 this.lastAim.x = this.option("legit") ? this.lerp(this.lastAim.x, scope.mouse.x, .2) : scope.mouse.x;
11672 this.lastAim.y = this.option("legit") ? this.lerp(this.lastAim.y, scope.mouse.y, .2) : scope.mouse.y;
11673 scope.aim(this.lastAim);
11674 }
11675 /** @type {null} */
11676 json = null;
11677 } catch (e) {
11678 console.log(e, e.stack);
11679 }
11680 };
11681 /**
11682 * @param {number} type
11683 * @param {number} dt
11684 * @param {number} n
11685 * @return {?}
11686 */
11687 render.prototype.lerp = function(type, dt, n) {
11688 return type * (1 - n) + dt * n;
11689 };
11690 /**
11691 * @param {!Object} second
11692 * @param {!Object} first
11693 * @return {?}
11694 */
11695 render.prototype.calcAngle = function(second, first) {
11696 return Math.atan2(first.y - second.y, first.x - second.x);
11697 };
11698 /**
11699 * @param {(boolean|number|string)} by
11700 * @param {(boolean|number|string)} cx
11701 * @param {(boolean|number|string)} ay
11702 * @param {(boolean|number|string)} x2
11703 * @return {?}
11704 */
11705 render.prototype.calcDistance = function(by, cx, ay, x2) {
11706 return Math.sqrt(Math.pow(by - ay, 2) + Math.pow(cx - x2, 2));
11707 };
11708 /**
11709 * @param {number} e
11710 * @return {?}
11711 */
11712 render.prototype.getSecondsElapsed = function(e) {
11713 return (window.performance.now() - e) / 1E3;
11714 };
11715 /**
11716 * @param {!Object} d
11717 * @param {!Object} b
11718 * @param {?} status
11719 * @param {!Object} data
11720 * @param {!Object} result
11721 * @return {?}
11722 */
11723 render.prototype.posCalc = function(d, b, status, data, result) {
11724 if (d) {
11725 return result = b[data.netData].weapType && result.guns[b[data.netData].weapType] ? result.bullets[result.guns[b[data.netData].weapType].bulletType] : {
11726 speed : 1E4
11727 }, this.getPlayerSpeed(d, .5), b = this.calcDistance(b.pos.x, b.pos.y, d.pos.x, d.pos.y) / result.speed * d.speed * this.option("velocity"), result = {
11728 x : 0,
11729 y : 0
11730 }, d.direction && (result = {
11731 x : d.direction.x * b,
11732 y : d.direction.y * b
11733 }), result.x = .5 * result.x + .5 * d.prediction.x, result.y = .5 * result.y + .5 * d.prediction.y, d.prediction = result, d.range = b, b = d.prediction ? d.prediction : {
11734 x : 0,
11735 y : 0
11736 }, d = d.pos, status[data.camera].pointToScreen({
11737 x : d.x + b.x,
11738 y : d.y + b.y
11739 });
11740 }
11741 };
11742 /**
11743 * @param {!Object} e
11744 * @param {!Object} result
11745 * @return {undefined}
11746 */
11747 render.prototype.getPlayerSpeed = function(e, result) {
11748 if (e) {
11749 if (result = {
11750 pos : e.pos,
11751 time : window.performance.now()
11752 }, !e.posData || .19 < this.getSecondsElapsed(e.posData[0].time)) {
11753 /** @type {!Array} */
11754 e.posData = [result];
11755 e.prediction = {
11756 x : 0,
11757 y : 0
11758 };
11759 /** @type {number} */
11760 e.speed = 0;
11761 /** @type {number} */
11762 e.distance = 0;
11763 /** @type {null} */
11764 e.direction = null;
11765 } else {
11766 var s = e.posData[0];
11767 var d = this.calcDistance(result.pos.x, result.pos.y, s.pos.x, s.pos.y);
11768 /** @type {(null|{x: number, y: number})} */
11769 e.direction = 1E-4 < d ? {
11770 x : (result.pos.x - s.pos.x) / d,
11771 y : (result.pos.y - s.pos.y) / d
11772 } : null;
11773 /** @type {number} */
11774 s = d / this.getSecondsElapsed(s.time);
11775 /** @type {number} */
11776 e.speed = s;
11777 e.distance = d;
11778 e.posData.push(result);
11779 for (; 5 < e.posData.length;) {
11780 e.posData.shift();
11781 }
11782 }
11783 }
11784 };
11785 $jscomp.global.Object.defineProperties(render.prototype, {
11786 enabled : {
11787 configurable : true,
11788 enumerable : true,
11789 get : function() {
11790 return this._enabled;
11791 },
11792 set : function(value) {
11793 /** @type {boolean} */
11794 this._enabled = value;
11795 }
11796 }
11797 });
11798 mixin.exports = new render;
11799}, function(mixin, data) {
11800 /**
11801 * @param {string} name
11802 * @return {?}
11803 */
11804 (data = function() {
11805 /** @type {boolean} */
11806 this._enabled = true;
11807 /** @type {string} */
11808 this.name = "esp";
11809 this.UI = {
11810 name : "ESP",
11811 description : "Shows where players are at"
11812 };
11813 /** @type {!Array} */
11814 this._options = [{
11815 value : true,
11816 name : "laser",
11817 UI : {
11818 name : "Flashlight"
11819 }
11820 }, {
11821 value : true,
11822 name : "nade",
11823 UI : {
11824 name : "Blast Radius"
11825 }
11826 }];
11827 this.values = {
11828 pixi : null
11829 };
11830 }).prototype.option = function(name) {
11831 try {
11832 var opt = this._options.filter(function(pkgObject) {
11833 return pkgObject.name === name;
11834 })[0].value;
11835 } catch (e) {
11836 /** @type {boolean} */
11837 opt = false;
11838 }
11839 return opt;
11840 };
11841 /**
11842 * @param {?} self
11843 * @param {!Object} name
11844 * @param {?} options
11845 * @return {undefined}
11846 */
11847 data.prototype.names = function(self, name, options) {
11848 if (!(!self || !self.nameText._text || "" == self.nameText._text || 1 > self.nameText._text.length)) {
11849 /** @type {number} */
11850 self.nameText.tint = 16711680;
11851 /** @type {boolean} */
11852 self.nameText.visible = true;
11853 }
11854 };
11855 /**
11856 * @param {!Object} v
11857 * @param {!Object} o
11858 * @param {?} params
11859 * @param {!Object} data
11860 * @return {undefined}
11861 */
11862 data.prototype.draw = function(v, o, params, data) {
11863 var self = this;
11864 if (v && o) {
11865 var pipelets = v.map(function(self) {
11866 return {
11867 x : 16 * (self.pos.x - o.pos.x),
11868 y : 16 * (o.pos.y - self.pos.y),
11869 img : self.img || false,
11870 type : self.__type,
11871 id : self.__id,
11872 layer : self.layer
11873 };
11874 });
11875 var graphics = this.values.pixi;
11876 if (!graphics) {
11877 graphics = new window.PIXI.Graphics;
11878 this.values.pixi = graphics;
11879 o.container.addChild(graphics);
11880 o.container.setChildIndex(graphics, 0);
11881 }
11882 if (graphics.graphicsData) {
11883 graphics.clear();
11884 pipelets.forEach(function(p) {
11885 if (!(2 == p.type && p.layer !== o.layer)) {
11886 graphics.lineStyle(2, 16711680, .5);
11887 if (p.layer !== o.layer) {
11888 graphics.lineStyle(2, 16777215, .5);
11889 }
11890 if (2 == p.type) {
11891 graphics.lineStyle(2, 16776960, .5);
11892 }
11893 graphics.moveTo(0, 0);
11894 graphics.lineTo(p.x, p.y);
11895 }
11896 });
11897 if (data.aimPred) {
11898 graphics.lineStyle(2, 16777215, .5);
11899 graphics.moveTo(0, 0);
11900 graphics.lineTo(16 * (data.aimPred.x - o.pos.x), 16 * (o.pos.y - data.aimPred.y));
11901 }
11902 v.forEach(function(model) {
11903 if (1 == model.__type) {
11904 self.names(model, o, params);
11905 }
11906 });
11907 graphics.lineStyle(0);
11908 if (this.option("nade")) {
11909 data.getObjects().filter(function(result) {
11910 return !!(result.__type === data.data.Type.Projectile || result.img && result.img.match(/barrel-/g) && result.smokeEmitter && data.items[result.type].explosion);
11911 }).forEach(function(result) {
11912 graphics.beginFill(16711680, .3);
11913 graphics.drawCircle(16 * (result.pos.x - o.pos.x), 16 * (o.pos.y - result.pos.y), 16 * (data.explosions[data.items[result.type].explosionType || data.items[result.type].explosion].rad.max + 1));
11914 });
11915 }
11916 /** @type {null} */
11917 pipelets = null;
11918 }
11919 }
11920 };
11921 /**
11922 * @return {undefined}
11923 */
11924 data.prototype.end = function() {
11925 /** @type {null} */
11926 this.laser = this.values.pixi = null;
11927 };
11928 /**
11929 * @param {!Object} e
11930 * @param {!Object} t
11931 * @param {?} o
11932 * @return {?}
11933 */
11934 data.prototype.findWeap = function(e, t, o) {
11935 return !(!(e = e[o.netData].weapType) || !t.guns[e]) && t.guns[e];
11936 };
11937 /**
11938 * @param {?} label
11939 * @param {!Object} data
11940 * @return {?}
11941 */
11942 data.prototype.findBullet = function(label, data) {
11943 return !!label && data.bullets[label.bulletType];
11944 };
11945 /**
11946 * @param {!Object} p
11947 * @param {?} config
11948 * @param {!Object} item
11949 * @param {number} i
11950 * @param {string} center
11951 * @param {number} f
11952 * @param {?} data
11953 * @return {undefined}
11954 */
11955 data.prototype.laserPointer = function(p, config, item, i, center, f, data) {
11956 if (item && item.container) {
11957 var c = this.laser = this.laser || {};
11958 var supportedTransition = item.posOldOld && (item.pos.x != item.posOldOld.x || item.pos.y != item.posOldOld.y);
11959 if (p) {
11960 /** @type {boolean} */
11961 var rules = true;
11962 /** @type {number} */
11963 var a = 16.25 * p.distance;
11964 /** @type {number} */
11965 var e = Math.atan2(item[data.netData].dir.x, item[data.netData].dir.y) - Math.PI / 2;
11966 /** @type {number} */
11967 var m = .01745329252 * (config.shotSpread + (supportedTransition ? config.moveSpread : 0)) / 2;
11968 } else {
11969 /** @type {boolean} */
11970 rules = false;
11971 }
11972 if (!(p = c.draw)) {
11973 p = new window.PIXI.Graphics;
11974 /** @type {!Object} */
11975 c.draw = p;
11976 item.container.addChildAt(p, 0);
11977 }
11978 if (p.graphicsData && rules) {
11979 /** @type {number} */
11980 c = 16 * (item.pos.x - i.pos.x);
11981 /** @type {number} */
11982 item = 16 * (i.pos.y - item.pos.y);
11983 /** @type {number} */
11984 i = e - m;
11985 /** @type {number} */
11986 e = e + m;
11987 /** @type {number} */
11988 i = i > 2 * Math.PI ? i - 2 * Math.PI : 0 > i ? i + 2 * Math.PI : i;
11989 /** @type {number} */
11990 e = e > 2 * Math.PI ? e - 2 * Math.PI : 0 > e ? e + 2 * Math.PI : e;
11991 p.beginFill(center || 255, f || .3);
11992 p.moveTo(c, item);
11993 p.arc(c, item, a, i, e);
11994 p.lineTo(c, item);
11995 p.endFill();
11996 }
11997 }
11998 };
11999 /**
12000 * @param {?} value
12001 * @param {!Object} p
12002 * @param {undefined} start
12003 * @param {?} state
12004 * @param {!Object} frame
12005 * @param {?} err
12006 * @return {undefined}
12007 */
12008 data.prototype.loop = function(value, p, start, state, frame, err) {
12009 var console = this;
12010 p = frame.getEnemies(!!err.aimbot && err.aimbot.option("object")).filter(function(materialsById) {
12011 return !materialsById || !materialsById[value.netData] || (!(!err.aimbot || !err.aimbot.option("down")) || !materialsById[value.netData].downed);
12012 });
12013 this.draw(p, start, value, frame);
12014 state = this.findWeap(start, frame, value);
12015 var y = this.findBullet(state, frame);
12016 if (this.laser && this.laser.draw) {
12017 this.laser.draw.clear();
12018 }
12019 if (this.option("laser")) {
12020 this.laserPointer(y, state, start, start, void 0, void 0, value);
12021 p.filter(function(fx) {
12022 return 1 == fx.__type;
12023 }).forEach(function(t) {
12024 var result = console.findWeap(t, frame, value);
12025 console.laserPointer(console.findBullet(result, frame), result, t, start, "0", .2, value);
12026 });
12027 /** @type {null} */
12028 p = null;
12029 }
12030 };
12031 $jscomp.global.Object.defineProperties(data.prototype, {
12032 enabled : {
12033 configurable : true,
12034 enumerable : true,
12035 get : function() {
12036 return this._enabled;
12037 },
12038 set : function(value) {
12039 /** @type {boolean} */
12040 this._enabled = value;
12041 }
12042 }
12043 });
12044 mixin.exports = new data;
12045}, function(self, Route) {
12046 /**
12047 * @param {string} name
12048 * @return {?}
12049 */
12050 (Route = function() {
12051 /** @type {boolean} */
12052 this._enabled = true;
12053 /** @type {string} */
12054 this.name = "autoloot";
12055 this.UI = {
12056 name : "Auto loot/doors",
12057 description : "Automatically picks up loot and opens doors."
12058 };
12059 /** @type {!Array} */
12060 this._options = [];
12061 }).prototype.option = function(name) {
12062 try {
12063 var opt = this._options.filter(function(pkgObject) {
12064 return pkgObject.name === name;
12065 })[0].value;
12066 } catch (e) {
12067 /** @type {boolean} */
12068 opt = false;
12069 }
12070 return opt;
12071 };
12072 /**
12073 * @param {?} value
12074 * @param {!Object} index
12075 * @return {undefined}
12076 */
12077 Route.prototype.setOption = function(value, index) {
12078 try {
12079 /** @type {!Object} */
12080 this._options.filter(function(data) {
12081 return data.name === value;
12082 })[0].value = index;
12083 } catch (e) {
12084 }
12085 };
12086 $jscomp.global.Object.defineProperties(Route.prototype, {
12087 enabled : {
12088 configurable : true,
12089 enumerable : true,
12090 get : function() {
12091 return this._enabled;
12092 },
12093 set : function(value) {
12094 /** @type {boolean} */
12095 this._enabled = value;
12096 }
12097 }
12098 });
12099 self.exports = new Route;
12100}, function(module, Logger) {
12101 /**
12102 * @param {string} name
12103 * @return {?}
12104 */
12105 (Logger = function() {
12106 /** @type {boolean} */
12107 this._enabled = true;
12108 /** @type {string} */
12109 this.name = "trees";
12110 this.UI = {
12111 name : "Transparency",
12112 description : ""
12113 };
12114 /** @type {!Array} */
12115 this._options = [{
12116 value : .5,
12117 int : .1,
12118 name : "tree",
12119 UI : {
12120 name : "Obstacles"
12121 },
12122 min : 0,
12123 max : 1
12124 }, {
12125 value : 0,
12126 int : .1,
12127 name : "roof",
12128 UI : {
12129 name : "Roofs"
12130 },
12131 min : 0,
12132 max : 1
12133 }];
12134 }).prototype.option = function(name) {
12135 try {
12136 var opt = this._options.filter(function(pkgObject) {
12137 return pkgObject.name === name;
12138 })[0].value;
12139 } catch (e) {
12140 /** @type {boolean} */
12141 opt = false;
12142 }
12143 return opt;
12144 };
12145 /**
12146 * @param {?} value
12147 * @param {!Object} index
12148 * @return {undefined}
12149 */
12150 Logger.prototype.setOption = function(value, index) {
12151 try {
12152 /** @type {!Object} */
12153 this._options.filter(function(data) {
12154 return data.name === value;
12155 })[0].value = index;
12156 } catch (e) {
12157 }
12158 };
12159 /**
12160 * @param {?} index
12161 * @param {?} video
12162 * @param {?} meyda
12163 * @param {?} delta
12164 * @param {!Object} node
12165 * @return {undefined}
12166 */
12167 Logger.prototype.loop = function(index, video, meyda, delta, node) {
12168 var new_ident = this;
12169 node.getObjects().forEach(function(data) {
12170 if (data.__type === node.data.Type.Building && 1 < data.imgs.length) {
12171 if ("container_05" == data.type) {
12172 return;
12173 }
12174 data.imgs.forEach(function(body2) {
12175 if (body2.isCeiling) {
12176 body2.sprite.imgAlpha = new_ident.option("roof");
12177 }
12178 });
12179 }
12180 if (data.__type === node.data.Type.Obstacle && data.img && data.img.match(/tree|bush|table|stairs|brush/g)) {
12181 data.sprite.alpha = new_ident.option("tree");
12182 }
12183 });
12184 };
12185 $jscomp.global.Object.defineProperties(Logger.prototype, {
12186 enabled : {
12187 configurable : true,
12188 enumerable : true,
12189 get : function() {
12190 return this._enabled;
12191 },
12192 set : function(value) {
12193 /** @type {boolean} */
12194 this._enabled = value;
12195 }
12196 }
12197 });
12198 module.exports = new Logger;
12199}, function(mixin, init) {
12200 /**
12201 * @param {string} name
12202 * @return {?}
12203 */
12204 (init = function() {
12205 /** @type {boolean} */
12206 this._enabled = true;
12207 /** @type {string} */
12208 this.name = "switch";
12209 this.UI = {
12210 name : "AutoSwitch",
12211 description : ""
12212 };
12213 /** @type {!Array} */
12214 this._options = [{
12215 value : "SniperSwitch\u2122",
12216 opts : ["SniperSwitch\u2122", "SmartSwitch\u2122"],
12217 name : "mode",
12218 UI : {
12219 name : "Mode"
12220 }
12221 }, {
12222 value : true,
12223 name : "auto",
12224 UI : {
12225 name : "Ignore Auto Weapons"
12226 }
12227 }, {
12228 value : true,
12229 name : "melee",
12230 UI : {
12231 name : "Equip Melee"
12232 }
12233 }, {
12234 value : 45,
12235 int : 1,
12236 name : "speed",
12237 UI : {
12238 name : "Min. Fire Delay"
12239 },
12240 min : 0,
12241 max : 100
12242 }];
12243 /** @type {!Array} */
12244 this.ammo = [{
12245 name : "",
12246 ammo : 0
12247 }, {
12248 name : "",
12249 ammo : 0
12250 }, {
12251 name : "",
12252 ammo : 0
12253 }, {
12254 name : "",
12255 ammo : 0
12256 }];
12257 /** @type {null} */
12258 this.keys = null;
12259 }).prototype.option = function(name) {
12260 try {
12261 var opt = this._options.filter(function(pkgObject) {
12262 return pkgObject.name === name;
12263 })[0].value;
12264 } catch (e) {
12265 /** @type {boolean} */
12266 opt = false;
12267 }
12268 return opt;
12269 };
12270 /**
12271 * @param {?} value
12272 * @param {!Object} index
12273 * @return {undefined}
12274 */
12275 init.prototype.setOption = function(value, index) {
12276 try {
12277 /** @type {!Object} */
12278 this._options.filter(function(data) {
12279 return data.name === value;
12280 })[0].value = index;
12281 } catch (e) {
12282 }
12283 };
12284 /**
12285 * @param {!Object} data
12286 * @param {number} i
12287 * @param {!Object} table
12288 * @param {?} scope
12289 * @param {?} self
12290 * @param {!Object} options
12291 * @return {undefined}
12292 */
12293 init.prototype.loop = function(data, i, table, scope, self, options) {
12294 var item = this;
12295 if (!options.binds.test("switch")) {
12296 var i = table[data.localData][data.weapIdx];
12297 var x = table[data.localData][data.weapons];
12298 var p = x[i];
12299 if (data = function() {
12300 /**
12301 * @param {?} url
12302 * @return {?}
12303 */
12304 var test = function(url) {
12305 /** @type {boolean} */
12306 var command = false;
12307 try {
12308 /** @type {boolean} */
12309 command = (!item.option("sniper") || ("single" === self.guns[url].fireMode || "burst" === self.guns[url].fireMode)) && self.guns[url].fireDelay >= ("number" == typeof item.option("speed") ? item.option("speed") / 100 : .45);
12310 } catch (e) {
12311 }
12312 return command;
12313 };
12314 /** @type {!Array} */
12315 item.keys = ["" !== x[1].type && test(x[1].type) ? "EquipOtherGun" : item.option("melee") ? "EquipMelee" : "EquipOtherGun", "" !== x[0].type && test(x[0].type) ? "EquipOtherGun" : item.option("melee") ? "EquipMelee" : "EquipOtherGun", "EquipMelee", "EquipMelee"];
12316 if (p.ammo !== item.ammo[i].ammo) {
12317 if (p.ammo < item.ammo[i].ammo && test(p.type) && p.type == item.ammo[i].type) {
12318 scope.addInput(item.keys[i]);
12319 }
12320 item.ammo[i].ammo = p.ammo;
12321 item.ammo[i].type = p.type;
12322 }
12323 }, "SniperSwitch\u2122" == this.option("mode")) {
12324 data();
12325 } else {
12326 if ("SmartSwitch\u2122" == this.option("mode") && (data = [], !self.autoAttack)) {
12327 /** @type {number} */
12328 i = 0;
12329 for (; 2 > i; i++) {
12330 var item;
12331 var d = self.selectedEnemy[0];
12332 if ((options = self.guns[x[i].type]) && (item = self.bullets[options.bulletType]), !d || !item) {
12333 break;
12334 }
12335 d = this.calcDistance(d.pos.x, d.pos.y, table.pos.x, table.pos.y);
12336 data.push({
12337 dps : 1 / options.fireDelay * item.damage * (options.burstCount || 1) * options.bulletCount * (1 - item.falloff) ^ d,
12338 hittable : d < item.distance,
12339 hasAmmo : 0 < x[i].ammo,
12340 key : i,
12341 gun : options
12342 });
12343 }
12344 if (2 == data.length) {
12345 if ((data = (data = data.filter(function(state) {
12346 return state.hittable && state.hasAmmo;
12347 })).sort(function(options, row) {
12348 return row.dps - options.dps;
12349 }))[0]) {
12350 scope.addInput(0 == data[0].key ? "EquipPrimary" : "EquipSecondary");
12351 }
12352 }
12353 }
12354 }
12355 }
12356 };
12357 /**
12358 * @param {(boolean|number|string)} by
12359 * @param {(boolean|number|string)} cx
12360 * @param {(boolean|number|string)} ay
12361 * @param {(boolean|number|string)} x2
12362 * @return {?}
12363 */
12364 init.prototype.calcDistance = function(by, cx, ay, x2) {
12365 return Math.sqrt(Math.pow(by - ay, 2) + Math.pow(cx - x2, 2));
12366 };
12367 $jscomp.global.Object.defineProperties(init.prototype, {
12368 enabled : {
12369 configurable : true,
12370 enumerable : true,
12371 get : function() {
12372 return this._enabled;
12373 },
12374 set : function(value) {
12375 /** @type {boolean} */
12376 this._enabled = value;
12377 }
12378 }
12379 });
12380 mixin.exports = new init;
12381}, function(module, Logger) {
12382 /**
12383 * @param {string} name
12384 * @return {?}
12385 */
12386 (Logger = function() {
12387 /** @type {boolean} */
12388 this._enabled = true;
12389 /** @type {string} */
12390 this.name = "bump";
12391 this.UI = {
12392 name : "Bumpfire",
12393 description : "",
12394 warn : true
12395 };
12396 /** @type {!Array} */
12397 this._options = [];
12398 }).prototype.option = function(name) {
12399 try {
12400 var opt = this._options.filter(function(pkgObject) {
12401 return pkgObject.name === name;
12402 })[0].value;
12403 } catch (e) {
12404 /** @type {boolean} */
12405 opt = false;
12406 }
12407 return opt;
12408 };
12409 /**
12410 * @param {?} value
12411 * @param {!Object} index
12412 * @return {undefined}
12413 */
12414 Logger.prototype.setOption = function(value, index) {
12415 try {
12416 /** @type {!Object} */
12417 this._options.filter(function(data) {
12418 return data.name === value;
12419 })[0].value = index;
12420 } catch (e) {
12421 }
12422 };
12423 $jscomp.global.Object.defineProperties(Logger.prototype, {
12424 enabled : {
12425 configurable : true,
12426 enumerable : true,
12427 get : function() {
12428 return this._enabled;
12429 },
12430 set : function(value) {
12431 /** @type {boolean} */
12432 this._enabled = value;
12433 }
12434 }
12435 });
12436 module.exports = new Logger;
12437}, function(self, model) {
12438 /**
12439 * @param {string} name
12440 * @return {?}
12441 */
12442 (model = function() {
12443 /** @type {boolean} */
12444 this._enabled = false;
12445 /** @type {string} */
12446 this.name = "spinbot";
12447 this.UI = {
12448 name : "SpinBot\u2122",
12449 description : ""
12450 };
12451 /** @type {!Array} */
12452 this._options = [{
12453 value : 119,
12454 int : 1,
12455 name : "angle",
12456 UI : {
12457 name : "Spin Angle"
12458 },
12459 min : 0,
12460 max : 360
12461 }];
12462 /** @type {number} */
12463 this.angle = 0;
12464 }).prototype.option = function(name) {
12465 try {
12466 var opt = this._options.filter(function(pkgObject) {
12467 return pkgObject.name === name;
12468 })[0].value;
12469 } catch (e) {
12470 /** @type {boolean} */
12471 opt = false;
12472 }
12473 return opt;
12474 };
12475 /**
12476 * @param {?} value
12477 * @param {!Object} index
12478 * @return {undefined}
12479 */
12480 model.prototype.setOption = function(value, index) {
12481 try {
12482 /** @type {!Object} */
12483 this._options.filter(function(data) {
12484 return data.name === value;
12485 })[0].value = index;
12486 } catch (e) {
12487 }
12488 };
12489 /**
12490 * @param {number} t
12491 * @return {?}
12492 */
12493 model.prototype.rad = function(t) {
12494 return Math.PI / 180 * t;
12495 };
12496 /**
12497 * @param {number} pos
12498 * @param {?} value
12499 * @param {?} count
12500 * @param {?} data
12501 * @param {?} config
12502 * @param {!Object} options
12503 * @return {undefined}
12504 */
12505 model.prototype.loop = function(pos, value, count, data, config, options) {
12506 if (!options.binds.test("spinbot")) {
12507 this.angle += parseInt(this.option("angle"));
12508 /** @type {number} */
12509 (pos = {}).x = 100 * Math.cos(this.rad(this.angle)) + window.innerWidth / 2;
12510 /** @type {number} */
12511 pos.y = 100 * Math.sin(this.rad(this.angle)) + window.innerHeight / 2;
12512 if (!options.aimbot.aim) {
12513 data.aim(pos);
12514 }
12515 }
12516 };
12517 $jscomp.global.Object.defineProperties(model.prototype, {
12518 enabled : {
12519 configurable : true,
12520 enumerable : true,
12521 get : function() {
12522 return this._enabled;
12523 },
12524 set : function(value) {
12525 /** @type {boolean} */
12526 this._enabled = value;
12527 }
12528 }
12529 });
12530 self.exports = new model;
12531}, function(t, Timer) {
12532 /**
12533 * @param {string} name
12534 * @return {?}
12535 */
12536 (Timer = function() {
12537 /** @type {boolean} */
12538 this._enabled = true;
12539 /** @type {string} */
12540 this.name = "timer";
12541 this.UI = {
12542 name : "Grenade Timer",
12543 description : ""
12544 };
12545 /** @type {!Array} */
12546 this._options = [];
12547 /** @type {number} */
12548 this.lastTime = Date.now();
12549 }).prototype.option = function(name) {
12550 try {
12551 var opt = this._options.filter(function(pkgObject) {
12552 return pkgObject.name === name;
12553 })[0].value;
12554 } catch (e) {
12555 /** @type {boolean} */
12556 opt = false;
12557 }
12558 return opt;
12559 };
12560 /**
12561 * @param {?} value
12562 * @param {!Object} index
12563 * @return {undefined}
12564 */
12565 Timer.prototype.setOption = function(value, index) {
12566 try {
12567 /** @type {!Object} */
12568 this._options.filter(function(data) {
12569 return data.name === value;
12570 })[0].value = index;
12571 } catch (e) {
12572 }
12573 };
12574 /**
12575 * @param {!Object} self
12576 * @param {?} data
12577 * @param {string} end
12578 * @param {string} time
12579 * @param {!Object} options
12580 * @param {?} reverseOrder
12581 * @return {?}
12582 */
12583 Timer.prototype.loop = function(self, data, end, time, options, reverseOrder) {
12584 if (time = (Date.now() - this.lastTime) / 1E3, 3 !== end[self.localData][self.weapIdx] || "cook" !== end.throwableState) {
12585 return this.showing = false, this.timer && this.timer.destroy(), this.timer = false;
12586 }
12587 if (!(60 < (end = (options.items[end[self.netData].weapType] || {}).fuseTime || 4))) {
12588 if (time > end) {
12589 /** @type {boolean} */
12590 this.showing = false;
12591 }
12592 if (this.showing) {
12593 this.timer.update(time - this.timer.elapsed, data[self.camera]);
12594 } else {
12595 if (this.timer) {
12596 this.timer.destroy();
12597 }
12598 this.timer = new (Object.values(options.pieTimer)[0]);
12599 data.pixi.stage.addChild(this.timer.container);
12600 this.timer.start("Grenade", 0, end);
12601 /** @type {boolean} */
12602 this.showing = true;
12603 /** @type {number} */
12604 this.lastTime = Date.now();
12605 }
12606 }
12607 };
12608 $jscomp.global.Object.defineProperties(Timer.prototype, {
12609 enabled : {
12610 configurable : true,
12611 enumerable : true,
12612 get : function() {
12613 return this._enabled;
12614 },
12615 set : function(value) {
12616 /** @type {boolean} */
12617 this._enabled = value;
12618 }
12619 }
12620 });
12621 t.exports = new Timer;
12622}, function(self, Route, saveNotifs) {
12623 var downCode = saveNotifs(0);
12624 /**
12625 * @param {string} name
12626 * @return {?}
12627 */
12628 (Route = function() {
12629 /** @type {boolean} */
12630 this._enabled = true;
12631 /** @type {string} */
12632 this.name = "teamjoin";
12633 this.UI = {
12634 name : "Team Joiner\u2122 (press x)",
12635 description : "Finds teams to join and let's others join you"
12636 };
12637 /** @type {!Array} */
12638 this._options = [];
12639 }).prototype.option = function(name) {
12640 try {
12641 var opt = this._options.filter(function(pkgObject) {
12642 return pkgObject.name === name;
12643 })[0].value;
12644 } catch (e) {
12645 /** @type {boolean} */
12646 opt = false;
12647 }
12648 return opt;
12649 };
12650 /**
12651 * @param {?} value
12652 * @param {!Object} index
12653 * @return {undefined}
12654 */
12655 Route.prototype.setOption = function(value, index) {
12656 try {
12657 /** @type {!Object} */
12658 this._options.filter(function(data) {
12659 return data.name === value;
12660 })[0].value = index;
12661 } catch (e) {
12662 }
12663 };
12664 $jscomp.global.Object.defineProperties(Route.prototype, {
12665 enabled : {
12666 configurable : true,
12667 enumerable : true,
12668 get : function() {
12669 return this._enabled;
12670 },
12671 set : function(value) {
12672 if (value && !document.getElementById("tfeed")) {
12673 /** @type {!Element} */
12674 var buttons_code = document.createElement("div");
12675 /** @type {string} */
12676 buttons_code.innerHTML = '<div class="twrapper">\n\t\t\t<h2>Play with other cheaters! <small>\'x\' close, \'r\' refresh</small></h2>\n\t<ul class="tfeed" id="tfeed">\n\t</ul>\n</div>';
12677 document.body.appendChild(buttons_code);
12678 /** @type {string} */
12679 buttons_code.style.display = "none" == buttons_code.style.display ? "block" : "none";
12680 /**
12681 * @return {undefined}
12682 */
12683 var setup = function() {
12684 /** @type {string} */
12685 document.getElementById("tfeed").style.cursor = "wait";
12686 /** @type {number} */
12687 var chat_retry = setInterval(function() {
12688 var name = document.getElementById("team-code").innerText;
12689 /** @type {*} */
12690 var socket = JSON.parse(localStorage.surviv_config);
12691 fetch("" == name ? "https://ih-tracker.glitch.me/" : "https://ih-tracker.glitch.me/queueing", {
12692 method : "POST",
12693 headers : {
12694 "content-type" : "application/json"
12695 },
12696 body : JSON.stringify({
12697 username : socket.playerName,
12698 joinCode : name,
12699 region : $("#team-server-select")[0].selectedOptions[0].value
12700 })
12701 }).then(function(rawResp) {
12702 return $jscomp.executeAsyncGenerator(function() {
12703 /**
12704 * @param {!Object} n
12705 * @param {number} fn
12706 * @return {?}
12707 */
12708 function start(n, fn) {
12709 for (;;) {
12710 switch(_b6) {
12711 case 0:
12712 return _b6 = 1, {
12713 value : rawResp.json(),
12714 done : false
12715 };
12716 case 1:
12717 if (void 0 === fn) {
12718 /** @type {number} */
12719 _b6 = 2;
12720 break;
12721 }
12722 throw _b6 = -1, fn;
12723 case 2:
12724 /** @type {!Object} */
12725 received = n;
12726 /** @type {string} */
12727 document.getElementById("tfeed").innerHTML = "";
12728 received.forEach(function(data) {
12729 if ("" == name || name !== data.joinCode) {
12730 console.log("dev");
12731 /** @type {!Element} */
12732 var msgInfoEl = document.createElement("div");
12733 /** @type {string} */
12734 msgInfoEl.innerHTML = '<li class="titem"><span class="feed-name">' + data.username + '</span> <span class="feed-name" style="margin-left: 30px;color: yellow;text-transform: uppercase;">' + data.region + '</span> <a class="tjoin" href="#' + data.joinCode + '">Join Game</a></li>';
12735 document.getElementById("tfeed").appendChild(msgInfoEl);
12736 }
12737 });
12738 /** @type {string} */
12739 document.getElementById("tfeed").style.cursor = "default";
12740 /** @type {number} */
12741 _b6 = -1;
12742 default:
12743 return {
12744 value : void 0,
12745 done : true
12746 };
12747 }
12748 }
12749 }
12750 var received;
12751 /** @type {number} */
12752 var _b6 = 0;
12753 var aIter = {
12754 next : function(e) {
12755 return start(e, void 0);
12756 },
12757 throw : function(name) {
12758 return start(void 0, name);
12759 },
12760 return : function(val) {
12761 throw Error("Not yet implemented");
12762 }
12763 };
12764 return $jscomp.initSymbolIterator(), aIter[Symbol.iterator] = function() {
12765 return this;
12766 }, aIter;
12767 }());
12768 });
12769 clearInterval(chat_retry);
12770 }, 500);
12771 };
12772 /**
12773 * @param {!Object} options
12774 * @return {undefined}
12775 */
12776 window.onkeyup = function(options) {
12777 var s = window[downCode()];
12778 if (!s.scope || !s.scope.initialized) {
12779 switch(options.key) {
12780 case "x":
12781 /** @type {string} */
12782 buttons_code.style.display = "none" == buttons_code.style.display ? "block" : "none";
12783 break;
12784 case "r":
12785 setup();
12786 }
12787 }
12788 };
12789 setInterval(setup.bind(this), 3E4);
12790 document.getElementById("btn-create-team").addEventListener("click", setup.bind(this));
12791 window.addEventListener("unload", function(canCreateDiscussions) {
12792 navigator.sendBeacon("https://ih-tracker.glitch.me/queueingdel", document.getElementById("team-code").innerText);
12793 });
12794 document.getElementById("btn-team-leave").addEventListener("click", function() {
12795 navigator.sendBeacon("https://ih-tracker.glitch.me/queueingdel", document.getElementById("team-code").innerText);
12796 });
12797 setup();
12798 }
12799 /** @type {boolean} */
12800 this._enabled = value;
12801 }
12802 }
12803 });
12804 self.exports = new Route;
12805}, function(mixin, constructor) {
12806 /**
12807 * @param {string} name
12808 * @return {?}
12809 */
12810 (constructor = function() {
12811 /** @type {boolean} */
12812 this._enabled = true;
12813 /** @type {string} */
12814 this.name = "reload";
12815 this.UI = {
12816 name : "AutoReload",
12817 description : ""
12818 };
12819 /** @type {!Array} */
12820 this._options = [];
12821 }).prototype.option = function(name) {
12822 try {
12823 var opt = this._options.filter(function(pkgObject) {
12824 return pkgObject.name === name;
12825 })[0].value;
12826 } catch (e) {
12827 /** @type {boolean} */
12828 opt = false;
12829 }
12830 return opt;
12831 };
12832 /**
12833 * @param {?} value
12834 * @param {!Object} index
12835 * @return {undefined}
12836 */
12837 constructor.prototype.setOption = function(value, index) {
12838 try {
12839 /** @type {!Object} */
12840 this._options.filter(function(data) {
12841 return data.name === value;
12842 })[0].value = index;
12843 } catch (e) {
12844 }
12845 };
12846 /**
12847 * @param {!Array} data
12848 * @param {!Object} x
12849 * @param {!Object} options
12850 * @param {?} scope
12851 * @param {!Object} params
12852 * @param {?} provider
12853 * @return {undefined}
12854 */
12855 constructor.prototype.loop = function(data, x, options, scope, params, provider) {
12856 if (!(params.selectedEnemy[0] || 0 !== options.action.type)) {
12857 x = options[data.localData][data.weapons];
12858 data = options[data.localData].inventory;
12859 options = "" != x[0].type && params.guns[x[0].type];
12860 params = "" != x[1].type && params.guns[x[1].type];
12861 if (options && 0 < x[0].type.length && x[0].ammo < options.maxClip && 0 < data[options.ammo]) {
12862 scope.addInput("EquipPrimary");
12863 scope.addInput("Reload");
12864 } else {
12865 if (params && 0 < x[1].type.length && x[1].ammo < params.maxClip && 0 < data[params.ammo]) {
12866 scope.addInput("EquipSecondary");
12867 scope.addInput("Reload");
12868 }
12869 }
12870 }
12871 };
12872 $jscomp.global.Object.defineProperties(constructor.prototype, {
12873 enabled : {
12874 configurable : true,
12875 enumerable : true,
12876 get : function() {
12877 return this._enabled;
12878 },
12879 set : function(value) {
12880 /** @type {boolean} */
12881 this._enabled = value;
12882 }
12883 }
12884 });
12885 mixin.exports = new constructor;
12886}, function(self, Event) {
12887 /**
12888 * @param {string} name
12889 * @return {?}
12890 */
12891 (Event = function() {
12892 /** @type {boolean} */
12893 this._enabled = true;
12894 /** @type {string} */
12895 this.name = "autoheal";
12896 this.UI = {
12897 name : "AutoHeal\u2122",
12898 description : ""
12899 };
12900 /** @type {!Array} */
12901 this._options = [];
12902 /** @type {number} */
12903 this.time = Date.now();
12904 }).prototype.option = function(name) {
12905 try {
12906 var opt = this._options.filter(function(pkgObject) {
12907 return pkgObject.name === name;
12908 })[0].value;
12909 } catch (e) {
12910 /** @type {boolean} */
12911 opt = false;
12912 }
12913 return opt;
12914 };
12915 /**
12916 * @param {?} value
12917 * @param {!Object} index
12918 * @return {undefined}
12919 */
12920 Event.prototype.setOption = function(value, index) {
12921 try {
12922 /** @type {!Object} */
12923 this._options.filter(function(data) {
12924 return data.name === value;
12925 })[0].value = index;
12926 } catch (e) {
12927 }
12928 };
12929 /**
12930 * @param {!Object} data
12931 * @param {string} t
12932 * @param {!Object} c
12933 * @return {?}
12934 */
12935 Event.prototype.has = function(data, t, c) {
12936 return 0 < data[c.inventory][t];
12937 };
12938 /**
12939 * @param {!Object} self
12940 * @param {!Object} a
12941 * @param {string} b
12942 * @param {!Object} o
12943 * @param {number} val
12944 * @param {!Object} options
12945 * @return {undefined}
12946 */
12947 Event.prototype.loop = function(self, a, b, o, val, options) {
12948 if (!(options.binds.test("heal") || val.selectedEnemy[0] || 0 !== b.action.type)) {
12949 a = b[self.localData];
12950 /** @type {number} */
12951 b = Date.now();
12952 if (30 > (val = a[self.health]) && this.has(a, "healthkit", self) && 6100 < b - this.time) {
12953 o.press("56");
12954 /** @type {string} */
12955 this.time = b;
12956 }
12957 if (85 > val && this.has(a, "bandage", self) && 3100 < b - this.time) {
12958 o.press("55");
12959 /** @type {string} */
12960 this.time = b;
12961 }
12962 if (50 > a.boost && this.has(a, "painkiller", self) && 6100 < b - this.time) {
12963 o.press("48");
12964 /** @type {string} */
12965 this.time = b;
12966 }
12967 if (75 > a.boost && this.has(a, "soda", self) && 6100 < b - this.time) {
12968 o.press("57");
12969 /** @type {string} */
12970 this.time = b;
12971 }
12972 }
12973 };
12974 $jscomp.global.Object.defineProperties(Event.prototype, {
12975 enabled : {
12976 configurable : true,
12977 enumerable : true,
12978 get : function() {
12979 return this._enabled;
12980 },
12981 set : function(value) {
12982 /** @type {boolean} */
12983 this._enabled = value;
12984 }
12985 }
12986 });
12987 self.exports = new Event;
12988}, function(module, Player) {
12989 /**
12990 * @param {string} name
12991 * @return {?}
12992 */
12993 (Player = function() {
12994 /** @type {boolean} */
12995 this._enabled = false;
12996 /** @type {string} */
12997 this.name = "follow";
12998 this.UI = {
12999 name : "FollowBot\u2122",
13000 description : "Follows anyone on the team who is not named 'bot'"
13001 };
13002 /** @type {!Array} */
13003 this._options = [{
13004 value : true,
13005 name : "fists",
13006 UI : {
13007 name : "Always Fists"
13008 }
13009 }];
13010 }).prototype.option = function(name) {
13011 try {
13012 var opt = this._options.filter(function(pkgObject) {
13013 return pkgObject.name === name;
13014 })[0].value;
13015 } catch (e) {
13016 /** @type {boolean} */
13017 opt = false;
13018 }
13019 return opt;
13020 };
13021 /**
13022 * @param {?} value
13023 * @param {!Object} index
13024 * @return {undefined}
13025 */
13026 Player.prototype.setOption = function(value, index) {
13027 try {
13028 /** @type {!Object} */
13029 this._options.filter(function(data) {
13030 return data.name === value;
13031 })[0].value = index;
13032 } catch (e) {
13033 }
13034 };
13035 /**
13036 * @param {!Object} second
13037 * @param {!Object} first
13038 * @return {?}
13039 */
13040 Player.prototype.calcDistance = function(second, first) {
13041 return Math.sqrt(Math.pow(second.x - first.x, 2) + Math.pow(second.y - first.y, 2));
13042 };
13043 /**
13044 * @param {!Object} second
13045 * @param {!Object} first
13046 * @return {?}
13047 */
13048 Player.prototype.calcAngle = function(second, first) {
13049 return Math.atan2(first.y - second.y, first.x - second.x);
13050 };
13051 /**
13052 * @param {!Object} data
13053 * @param {!Object} state
13054 * @param {!Object} n
13055 * @param {?} node
13056 * @param {!Object} canvas
13057 * @param {string} d
13058 * @return {?}
13059 */
13060 Player.prototype.loop = function(data, state, n, node, canvas, d) {
13061 var ctx = this;
13062 if (d = canvas.getObjects().filter(function(self) {
13063 return self && 1 === self.__type && !self[data.netData].dead && !state.player[data.netData].downed && canvas.isTeam(self.__id) && !self.nameText._text.match(/bot/gi);
13064 }).sort(function(prev, curr) {
13065 var i = state[data.camera].pointToScreen(n.pos);
13066 return prev = state[data.camera].pointToScreen(prev.pos), curr = state[data.camera].pointToScreen(curr.pos), prev = ctx.calcDistance(i.x, i.y, prev.x, prev.y), i = ctx.calcDistance(i.x, i.y, curr.x, curr.y), Math.abs(prev) - Math.abs(i);
13067 }), this.option("fists") && !canvas.selectedEnemy[0] && 2 !== n[data.localData].weapIdx && node.addInput("EquipMelee"), 0 < d.length) {
13068 return node.moveAngle = this.calcAngle(d[0].pos, n.pos) + Math.PI;
13069 }
13070 /** @type {boolean} */
13071 node.moveAnlge = false;
13072 };
13073 $jscomp.global.Object.defineProperties(Player.prototype, {
13074 enabled : {
13075 configurable : true,
13076 enumerable : true,
13077 get : function() {
13078 return this._enabled;
13079 },
13080 set : function(value) {
13081 /** @type {boolean} */
13082 this._enabled = value;
13083 }
13084 }
13085 });
13086 module.exports = new Player;
13087}, function(mixin, self) {
13088 /**
13089 * @param {string} name
13090 * @return {?}
13091 */
13092 (self = function() {
13093 /** @type {boolean} */
13094 this._enabled = true;
13095 /** @type {string} */
13096 this.name = "pan";
13097 this.UI = {
13098 name : "Pan Hero \u00b2",
13099 description : "Reflect bullets with a pan"
13100 };
13101 /** @type {!Array} */
13102 this._options = [{
13103 value : 13,
13104 int : .5,
13105 name : "detectRadius",
13106 UI : {
13107 name : "Bullet detection radius"
13108 },
13109 min : 10,
13110 max : 16
13111 }, {
13112 value : false,
13113 name : "displayRadius",
13114 UI : {
13115 name : "Display detection radius"
13116 }
13117 }, {
13118 value : false,
13119 name : "turnWithoutPan",
13120 UI : {
13121 name : "'Reflect' bullets without a pan"
13122 }
13123 }, {
13124 value : true,
13125 name : "lootPan",
13126 UI : {
13127 name : "Loot pan automatically"
13128 }
13129 }];
13130 /** @type {number} */
13131 this.panOffset = 142;
13132 /** @type {number} */
13133 this.stayTurnedFor = 300;
13134 /** @type {number} */
13135 this.lastTurnTime = Date.now();
13136 /** @type {null} */
13137 this.pixi = this.lastTurnPos = null;
13138 }).prototype.option = function(name) {
13139 try {
13140 var opt = this._options.filter(function(pkgObject) {
13141 return pkgObject.name === name;
13142 })[0].value;
13143 } catch (e) {
13144 /** @type {boolean} */
13145 opt = false;
13146 }
13147 return opt;
13148 };
13149 /**
13150 * @param {?} value
13151 * @param {!Object} index
13152 * @return {undefined}
13153 */
13154 self.prototype.setOption = function(value, index) {
13155 try {
13156 /** @type {!Object} */
13157 this._options.filter(function(data) {
13158 return data.name === value;
13159 })[0].value = index;
13160 } catch (e) {
13161 }
13162 };
13163 /**
13164 * @return {undefined}
13165 */
13166 self.prototype.end = function() {
13167 /** @type {null} */
13168 this.pixi = null;
13169 };
13170 /**
13171 * @param {!Object} vector
13172 * @return {?}
13173 */
13174 self.prototype.magnitude = function(vector) {
13175 return Math.sqrt(vector.x * vector.x + vector.y * vector.y);
13176 };
13177 /**
13178 * @param {!Object} vector1
13179 * @param {!Object} vector2
13180 * @return {?}
13181 */
13182 self.prototype.dotProduct = function(vector1, vector2) {
13183 return vector1.x * vector2.x + vector1.y * vector2.y;
13184 };
13185 /**
13186 * @param {!Object} vector
13187 * @return {?}
13188 */
13189 self.prototype.normalize = function(vector) {
13190 var magnitude = this.magnitude(vector);
13191 return {
13192 x : vector.x / magnitude,
13193 y : vector.y / magnitude
13194 };
13195 };
13196 /**
13197 * @param {!Object} e
13198 * @param {!Object} t
13199 * @return {?}
13200 */
13201 self.prototype.subtract = function(e, t) {
13202 return {
13203 x : e.x - t.x,
13204 y : e.y - t.y
13205 };
13206 };
13207 /**
13208 * @param {number} pointA
13209 * @param {!Object} pointB
13210 * @return {?}
13211 */
13212 self.prototype.getDistance = function(pointA, pointB) {
13213 /** @type {number} */
13214 var argR = pointB.x - pointA.x;
13215 return pointA = pointB.y - pointA.y, Math.sqrt(argR * argR + pointA * pointA);
13216 };
13217 /**
13218 * @param {number} t
13219 * @return {?}
13220 */
13221 self.prototype.rad = function(t) {
13222 return Math.PI / 180 * t;
13223 };
13224 /**
13225 * @param {string} config
13226 * @param {!Object} data
13227 * @return {?}
13228 */
13229 self.prototype.playerHasPan = function(config, data) {
13230 !function() {
13231 if (config && !config.weapons) {
13232 var redefinitionErrors = data[config.localData];
13233 /** @type {boolean} */
13234 var o = false;
13235 Object.keys(redefinitionErrors).forEach(function(spriteGroupName) {
13236 if (!o && Array.isArray(redefinitionErrors[spriteGroupName]) && redefinitionErrors[spriteGroupName][0] && redefinitionErrors[spriteGroupName][0].hasOwnProperty("type")) {
13237 /** @type {string} */
13238 config.weapons = spriteGroupName;
13239 /** @type {boolean} */
13240 o = true;
13241 }
13242 });
13243 }
13244 }();
13245 var types = data[config.localData][config.weapons][2].type;
13246 return types.includes("pan") || types.includes("lasr_s");
13247 };
13248 /**
13249 * @param {!Object} scene
13250 * @return {undefined}
13251 */
13252 self.prototype.drawRadius = function(scene) {
13253 var graphics = this.pixi;
13254 if (null == this.pixi) {
13255 this.pixi = graphics = new window.PIXI.Graphics;
13256 scene.container.addChild(this.pixi);
13257 scene.container.setChildIndex(this.pixi, 0);
13258 }
13259 graphics.clear();
13260 graphics.beginFill(16711680, 0);
13261 graphics.lineStyle(1, 0, .1, 0);
13262 graphics.drawCircle(0, 0, 16 * this.option("detectRadius"));
13263 };
13264 /**
13265 * @param {string} data
13266 * @param {(Event|string)} target
13267 * @param {!Object} content
13268 * @param {?} tag
13269 * @return {undefined}
13270 */
13271 self.prototype.lootPan = function(data, target, content, tag) {
13272 if (null != (target = target[data.loot.barn][data.loot.active])) {
13273 if (!content.downed) {
13274 if (this.playerHasPan(data, content)) {
13275 console.warn("player has pan");
13276 } else {
13277 if (target.type.includes("pan")) {
13278 tag.addInput("loot");
13279 }
13280 }
13281 }
13282 }
13283 };
13284 /**
13285 * @param {number} e
13286 * @param {!Object} t
13287 * @param {?} data
13288 * @return {undefined}
13289 */
13290 self.prototype.turnTo = function(e, t, data) {
13291 /** @type {number} */
13292 e = 180 / Math.PI * Math.atan2(t.y - e.y, t.x - e.x) * -1 - this.panOffset;
13293 data.aim({
13294 x : 100 * Math.cos(this.rad(e)) + window.innerWidth / 2,
13295 y : 100 * Math.sin(this.rad(e)) + window.innerHeight / 2
13296 });
13297 };
13298 /**
13299 * @param {string} result
13300 * @param {!Event} ruleName
13301 * @param {!Object} self
13302 * @param {?} type
13303 * @return {undefined}
13304 */
13305 self.prototype.reflectBullets = function(result, ruleName, self, type) {
13306 var d = this;
13307 if (!(type.leftMouse || !this.option("turnWithoutPan") && !this.playerHasPan(result, self))) {
13308 if (null != this.lastTurnPos && Date.now() - this.lastTurnTime < this.stayTurnedFor) {
13309 this.turnTo(self.pos, this.lastTurnPos, type);
13310 }
13311 if (0 != (result = ruleName[result.bullets].bullets.filter(function(options) {
13312 /** @type {number} */
13313 var t = Math.acos(d.dotProduct(options.dir, d.normalize(d.subtract(self.pos, options.pos))));
13314 /** @type {number} */
13315 var milliseconds = Math.asin(1 / d.magnitude(d.subtract(self.pos, options.pos)));
13316 return options.alive && options.layer === self.layer && options.playerId != self.__id && d.getDistance(self.pos, options.pos) <= d.option("detectRadius") && t <= milliseconds;
13317 }).sort(function(vertex, e) {
13318 return (vertex = d.getDistance(self.pos, vertex.pos)) - (e = d.getDistance(self.pos, e.pos));
13319 })).length) {
13320 this.turnTo(self.pos, result[0].pos, type);
13321 /** @type {number} */
13322 this.lastTurnTime = Date.now();
13323 this.lastTurnPos = result[0].pos;
13324 }
13325 }
13326 };
13327 /**
13328 * @param {string} response
13329 * @param {!Event} t
13330 * @param {!Object} ctx
13331 * @param {?} video
13332 * @param {?} meyda
13333 * @param {?} meydaFeatures
13334 * @return {undefined}
13335 */
13336 self.prototype.loop = function(response, t, ctx, video, meyda, meydaFeatures) {
13337 if (this.option("displayRadius")) {
13338 this.drawRadius(ctx);
13339 } else {
13340 if (null != this.pixi) {
13341 this.pixi.clear();
13342 }
13343 }
13344 if (this.option("lootPan")) {
13345 this.lootPan(response, t, ctx, video);
13346 }
13347 this.reflectBullets(response, t, ctx, video);
13348 };
13349 $jscomp.global.Object.defineProperties(self.prototype, {
13350 enabled : {
13351 configurable : true,
13352 enumerable : true,
13353 get : function() {
13354 return this._enabled;
13355 },
13356 set : function(value) {
13357 /** @type {boolean} */
13358 this._enabled = value;
13359 }
13360 }
13361 });
13362 mixin.exports = new self;
13363}]);