· 5 years ago · Sep 10, 2020, 06:56 PM
1work = (function() {
2 var flock = {};
3 flock.worker = function(e) {
4 /**
5 * @param {string} i
6 * @return {?}
7 */
8 function t(i) {
9 if (n[i]) {
10 return n[i].exports;
11 }
12 var module = n[i] = {
13 i : i,
14 l : false,
15 exports : {}
16 };
17 return e[i].call(module.exports, module, module.exports, t), module.l = true, module.exports;
18 }
19 var n = {};
20 return t.m = e, t.c = n, t.i = function(value) {
21 return value;
22 }, t.d = function(e, name, n) {
23 if (!t.o(e, name)) {
24 Object.defineProperty(e, name, {
25 configurable : false,
26 enumerable : true,
27 get : n
28 });
29 }
30 }, t.n = function(module) {
31 /** @type {function(): ?} */
32 var n = module && module.__esModule ? function() {
33 return module.default;
34 } : function() {
35 return module;
36 };
37 return t.d(n, "a", n), n;
38 }, t.o = function(e, input) {
39 return Object.prototype.hasOwnProperty.call(e, input);
40 }, t.p = "", Object.defineProperty(t, "p", {
41 get : function() {
42 try {
43 if ("function" != typeof __cdnJSPath) {
44 throw new Error("WebpackRequireFrom: '__cdnJSPath' is not a function or not available at runtime. See https://github.com/agoldis/webpack-require-from#troubleshooting");
45 }
46 return __cdnJSPath();
47 } catch (logValues) {
48 return console.error(logValues), "";
49 }
50 }
51 }), t(t.s = 49);
52 }({
53 0 : function(mixin, doPost) {
54 var g;
55 g = function() {
56 return this;
57 }();
58 try {
59 g = g || Function("return this")() || (0, eval)("this");
60 } catch (t) {
61 if ("object" == typeof window) {
62 /** @type {!Window} */
63 g = window;
64 }
65 }
66 mixin.exports = g;
67 },
68 1 : function(finalizers, self, tickWidth) {
69 /**
70 * @return {?}
71 */
72 function extend() {
73 /** @type {!Array} */
74 var newItems = [];
75 /** @type {number} */
76 var i = 0;
77 for (; i < arguments.length; i++) {
78 newItems[i] = arguments[i];
79 }
80 var clone = {};
81 return self.each(newItems, function(options) {
82 self.each(options, function(canCreateDiscussions, name) {
83 clone[name] = options[name];
84 });
85 }), clone;
86 }
87 /**
88 * @param {!Object} args
89 * @param {string} table
90 * @param {?} result
91 * @return {?}
92 */
93 function callback(args, table, result) {
94 var value = self.reduce(table.split("."), function(resourcePics, size) {
95 return resourcePics && resourcePics[size];
96 }, args);
97 return self.isUndefined(value) ? result : value;
98 }
99 /**
100 * @param {?} pattern
101 * @param {string} value
102 * @param {?} substitute
103 * @return {?}
104 */
105 function replace(pattern, value, substitute) {
106 return void 0 === pattern && (pattern = ""), pattern.split(value).join(substitute);
107 }
108 /**
109 * @param {?} t
110 * @return {?}
111 */
112 function value(t) {
113 /** @type {null} */
114 var todo = null;
115 try {
116 /** @type {(Element|null)} */
117 todo = document.querySelector(t);
118 } catch (e) {
119 console.error(t, "is not a valid css selector");
120 }
121 return todo;
122 }
123 /**
124 * @param {?} query
125 * @return {?}
126 */
127 function exports(query) {
128 return self.map(document.querySelectorAll(query), function(deferredImports) {
129 return deferredImports;
130 });
131 }
132 /**
133 * @param {!Object} i
134 * @param {?} b
135 * @return {?}
136 */
137 function inArray(i, b) {
138 return self.isArray(i) && -1 !== i.indexOf(b);
139 }
140 /**
141 * @param {!Object} val
142 * @return {?}
143 */
144 function isEmpty(val) {
145 return (self.isString(val) || self.isArray(val)) && 0 === val.length;
146 }
147 /**
148 * @param {!Array} value
149 * @return {?}
150 */
151 function validator(value) {
152 return null === value;
153 }
154 /**
155 * @return {?}
156 */
157 function merge() {
158 /** @type {!Array} */
159 var newItems = [];
160 /** @type {number} */
161 var i = 0;
162 for (; i < arguments.length; i++) {
163 newItems[i] = arguments[i];
164 }
165 var blankDocument = {};
166 return self.each(newItems.reverse(), function(t) {
167 self.each(t, function(value, key) {
168 blankDocument[key] = self.isUndefined(value) || validator(value) ? blankDocument[key] : value;
169 });
170 }), blankDocument;
171 }
172 /**
173 * @param {!Function} func
174 * @param {number} arity
175 * @param {!Array} fn
176 * @return {?}
177 */
178 function curry(func, arity, fn) {
179 return arity = arity || func.length, fn = fn || [], function() {
180 /** @type {!Array} */
181 var args = [];
182 /** @type {number} */
183 var i = 0;
184 for (; i < arguments.length; i++) {
185 args[i] = arguments[i];
186 }
187 return args = fn.concat(args), arity <= args.length ? func.apply(this, args) : curry(func, arity - args.length, args);
188 };
189 }
190 /**
191 * @param {?} emailValue
192 * @return {?}
193 */
194 function isEmail(emailValue) {
195 return /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(emailValue);
196 }
197 /**
198 * @param {string} n
199 * @param {!Array} r
200 * @param {number} a
201 * @return {?}
202 */
203 function range(n, r, a) {
204 if (self.isUndefined(r) && self.isUndefined(a)) {
205 /** @type {string} */
206 r = n;
207 /** @type {number} */
208 n = 0;
209 }
210 a = a || 1;
211 /** @type {!Array} */
212 var startToEnd = [];
213 /** @type {string} */
214 var i = n;
215 for (; i < r; i = i + a) {
216 startToEnd.push(i);
217 }
218 return startToEnd;
219 }
220 /**
221 * @param {!Function} callback
222 * @return {undefined}
223 */
224 function ready(callback) {
225 if (void 0 === callback) {
226 /** @type {function(): undefined} */
227 callback = self.noop;
228 }
229 if ("l" !== document.readyState[0]) {
230 self.nextTick(function() {
231 return callback(null);
232 });
233 } else {
234 document.addEventListener("DOMContentLoaded", callback);
235 }
236 }
237 /**
238 * @return {?}
239 */
240 function hpaDasUrl() {
241 return "https://api.pushpushgo.com/";
242 }
243 /**
244 * @return {undefined}
245 */
246 function Deferred() {
247 var callbackTwo = this;
248 /** @type {null} */
249 this.resolve = null;
250 /** @type {null} */
251 this.reject = null;
252 /** @type {!Promise} */
253 this.promise = new Promise(function(resolve, reject) {
254 callbackTwo.resolve = resolve;
255 callbackTwo.reject = reject;
256 });
257 Object.freeze(this);
258 }
259 /**
260 * @return {?}
261 */
262 function init() {
263 return "PushManager" in window || "safari" in window && "pushNotification" in window.safari;
264 }
265 /**
266 * @return {?}
267 */
268 function conf() {
269 return "safari" in window;
270 }
271 /**
272 * @param {?} item
273 * @return {?}
274 */
275 function updateSynchronously(item) {
276 /** @type {boolean} */
277 var e = !(!item || !item.websitePushId);
278 return e || console.warn('Safari supported but "websitePushId" is not configured', e), e;
279 }
280 /**
281 * @return {?}
282 */
283 function isMobile() {
284 try {
285 return document.createEvent("TouchEvent"), true;
286 } catch (t) {
287 return false;
288 }
289 }
290 /**
291 * @param {string} version
292 * @return {?}
293 */
294 function filter(version) {
295 return {
296 release : version,
297 whitelistUrls : [/^(.*)$/g],
298 fetchParameters : {
299 method : "POST",
300 credentials : "omit",
301 referrerPolicy : "origin"
302 },
303 ignoreErrors : [/The transaction was aborted, so the request cannot be fulfilled/, /Version change transaction was aborted in upgradeneeded event handler/, /A request was aborted, for example through a call to IDBTransaction\.abort/, /No available storage method found/, /window\.sessionStorage is null/, /location is null/],
304 shouldSendCallback : function() {
305 return init();
306 },
307 allowSecretKey : true
308 };
309 }
310 /**
311 * @param {?} styles
312 * @param {string} id
313 * @return {?}
314 */
315 function walk(styles, id) {
316 if (void 0 === id) {
317 /** @type {string} */
318 id = "default";
319 }
320 /** @type {!Array} */
321 var tags = [];
322 return [].concat(styles).reduce(function(match, type) {
323 if (!type) {
324 return match;
325 }
326 var data;
327 if ("string" == typeof type) {
328 /** @type {!Array<string>} */
329 var args = type.split(":").reverse();
330 /** @type {string} */
331 var tagName = args[0];
332 /** @type {string} */
333 var title = args[1];
334 title = title || id;
335 data = {
336 tag : tagName,
337 label : title
338 };
339 } else {
340 /** @type {string} */
341 data = type;
342 }
343 var HTML_INFO = (data.label || id) + ":" + (data.tag || null);
344 return "" === data.tag || "null" === data.tag || match[HTML_INFO] ? match : (match[HTML_INFO] = true, tags.push(data), match);
345 }, {}), {
346 tags : tags
347 };
348 }
349 /**
350 * @return {undefined}
351 */
352 function main() {
353 if (!String.prototype.endsWith) {
354 /**
355 * @param {string} str
356 * @param {number=} len
357 * @return {boolean}
358 * @this {!String}
359 */
360 String.prototype.endsWith = function(str, len) {
361 return (void 0 === len || len > this.length) && (len = this.length), this.substring(len - str.length, len) === str;
362 };
363 }
364 }
365 /**
366 * @param {!Arguments} v
367 * @param {!Object} o
368 * @return {?}
369 */
370 function translate(v, o) {
371 return self.reduce(v, function(global, getter, name) {
372 /** @type {string} */
373 var value = "" + getter;
374 return global[name] = -1 !== value.indexOf("$") ? o[value.replace(/\$/g, "")] : value, global;
375 }, {});
376 }
377 /**
378 * @param {number} id
379 * @param {number} nbLast
380 * @return {?}
381 */
382 function get_season(id, nbLast) {
383 return void 0 === nbLast && (nbLast = Date.now()), Math.floor(nbLast / 1e3 - id / 1e3);
384 }
385 /**
386 * @param {string} strObj
387 * @return {?}
388 */
389 function resolve(strObj) {
390 return strObj.trim().endsWith("/") ? strObj.trim().slice(0, -1) : strObj.trim();
391 }
392 /**
393 * @param {!Array} options
394 * @return {?}
395 */
396 function set(options) {
397 options = options || [];
398 var path = resolve(location.pathname);
399 if (0 === options.length) {
400 return true;
401 }
402 var n = options.some(function(mathjaxConfig) {
403 return true === mathjaxConfig.enable;
404 });
405 var h2 = options.sort(function(mathjaxConfig) {
406 return mathjaxConfig.enable ? 1 : -1;
407 });
408 /** @type {number} */
409 var i = 0;
410 var c = h2;
411 for (; i < c.length; i++) {
412 var test = c[i];
413 /** @type {!RegExp} */
414 var exclude = new RegExp(test.url);
415 if (test.re && 2 === Object.keys(test.re).length && (exclude = new RegExp(test.re.source, test.re.flags)), exclude.test(location.protocol + "//" + location.host + path)) {
416 return test.enable;
417 }
418 }
419 return !n;
420 }
421 /**
422 * @param {!Object} error
423 * @return {?}
424 */
425 function a(error) {
426 /** @type {!Array} */
427 var drilldownLevelLabels = [];
428 var p;
429 for (p in error) {
430 if (error[p]) {
431 drilldownLevelLabels.push(encodeURIComponent(p) + "=" + encodeURIComponent(error[p]));
432 }
433 }
434 return drilldownLevelLabels.join("&");
435 }
436 /**
437 * @param {?} data
438 * @return {?}
439 */
440 function toB64(data) {
441 /** @type {string} */
442 var tok = String.fromCharCode.apply(null, new Uint8Array(data));
443 return window.btoa(tok).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
444 }
445 /**
446 * @param {string} b
447 * @return {?}
448 */
449 function openBook(b) {
450 /** @type {string} */
451 var d = "=".repeat((4 - b.length % 4) % 4);
452 /** @type {string} */
453 var msg = (b + d).replace(/\-/g, "+").replace(/_/g, "/");
454 var p = window.atob(msg);
455 /** @type {!Uint8Array} */
456 var uiArr = new Uint8Array(p.length);
457 /** @type {number} */
458 var i = 0;
459 for (; i < p.length; ++i) {
460 uiArr[i] = p.charCodeAt(i);
461 }
462 return uiArr;
463 }
464 Object.defineProperty(self, "__esModule", {
465 value : true
466 });
467 var getSetting = tickWidth(7);
468 self.get = getSetting;
469 /**
470 * @param {!Object} data
471 * @return {?}
472 */
473 self.value = function(data) {
474 return function() {
475 return data;
476 };
477 };
478 /**
479 * @param {!Function} t
480 * @return {?}
481 */
482 self.toString = function(t) {
483 return Object.prototype.toString.call(t);
484 };
485 /**
486 * @param {!Function} fn
487 * @return {?}
488 */
489 self.isFunction = function(fn) {
490 return "function" == typeof fn;
491 };
492 /**
493 * @param {!Function} value
494 * @return {?}
495 */
496 self.isObject = function(value) {
497 return "[object Object]" === self.toString(value);
498 };
499 /**
500 * @param {!Object} value
501 * @return {?}
502 */
503 self.isArray = function(value) {
504 return "[object Array]" === self.toString(value);
505 };
506 /**
507 * @param {?} obj
508 * @return {?}
509 */
510 self.isUndefined = function(obj) {
511 return void 0 === obj;
512 };
513 /**
514 * @param {!Object} items
515 * @return {?}
516 */
517 self.first = function(items) {
518 return self.isArray(items) ? items[0] : void 0;
519 };
520 /**
521 * @param {!Object} event
522 * @return {?}
523 */
524 self.rest = function(event) {
525 return self.isArray(event) ? event.slice(1) : [];
526 };
527 /**
528 * @return {?}
529 */
530 self.isTestMode = function() {
531 /** @type {boolean} */
532 var value = false;
533 try {
534 /** @type {boolean} */
535 value = "true" === window.sessionStorage.getItem("ppg_test_mode");
536 } catch (data) {
537 console.error("Cannot check state of test mode, session storage is not available error", data.message);
538 }
539 return value;
540 };
541 /**
542 * @return {?}
543 */
544 self.isShowPopupMode = function() {
545 return -1 !== location.search.indexOf("ppg_show_popup=on");
546 };
547 /**
548 * @param {?} obj
549 * @param {!Function} f
550 * @return {undefined}
551 */
552 self.each = function(obj, f) {
553 if (obj) {
554 f = self.toFunction(f);
555 var i;
556 for (i in obj) {
557 if (obj.hasOwnProperty(i)) {
558 f(obj[i], i);
559 }
560 }
561 }
562 };
563 /**
564 * @param {(!Function|string)} object
565 * @param {string} fn
566 * @return {?}
567 */
568 self.map = function(object, fn) {
569 fn = self.toFunction(fn);
570 /** @type {!Array} */
571 var result = [];
572 return self.each(object, function(part, i) {
573 return result.push(fn(part, i));
574 }), result;
575 };
576 /**
577 * @param {(!Function|string)} value
578 * @param {!Function} fn
579 * @param {!Object} data
580 * @return {?}
581 */
582 self.reduce = function(value, fn, data) {
583 fn = self.toFunction(fn);
584 /** @type {!Object} */
585 var result = data;
586 return self.each(value, function(a, callback) {
587 if (self.isUndefined(result)) {
588 return result = a;
589 }
590 result = fn(result, a, callback, value);
591 }), result;
592 };
593 /**
594 * @param {!Array} array
595 * @return {?}
596 */
597 self.unique = function(array) {
598 return array.filter(function(sceneUid, canCreateDiscussions, scenes) {
599 return scenes.indexOf(sceneUid) === canCreateDiscussions;
600 });
601 };
602 /**
603 * @param {number} ms
604 * @param {!Object} f
605 * @return {?}
606 */
607 self.delay = function(ms, f) {
608 return setTimeout(self.toFunction(f), ms);
609 };
610 /**
611 * @param {string} f
612 * @return {?}
613 */
614 self.nextTick = function(f) {
615 return self.delay(0, f);
616 };
617 /**
618 * @return {?}
619 */
620 self.compose = function() {
621 /** @type {!Array} */
622 var labels = [];
623 /** @type {number} */
624 var i = 0;
625 for (; i < arguments.length; i++) {
626 labels[i] = arguments[i];
627 }
628 return function(menu) {
629 return self.reduce(labels, function(notifications, saveNotifs) {
630 return saveNotifs(notifications);
631 }, menu);
632 };
633 };
634 /**
635 * @return {?}
636 */
637 self.or = function() {
638 /** @type {!Array} */
639 var labels = [];
640 /** @type {number} */
641 var i = 0;
642 for (; i < arguments.length; i++) {
643 labels[i] = arguments[i];
644 }
645 return function() {
646 /** @type {!Array} */
647 var obj = [];
648 /** @type {number} */
649 var i = 0;
650 for (; i < arguments.length; i++) {
651 obj[i] = arguments[i];
652 }
653 return self.reduce(labels, function(lowlaId, e) {
654 return lowlaId || e.apply(void 0, obj);
655 }, false);
656 };
657 };
658 /**
659 * @return {?}
660 */
661 self.and = function() {
662 /** @type {!Array} */
663 var labels = [];
664 /** @type {number} */
665 var i = 0;
666 for (; i < arguments.length; i++) {
667 labels[i] = arguments[i];
668 }
669 return function() {
670 /** @type {!Array} */
671 var args = [];
672 /** @type {number} */
673 var i = 0;
674 for (; i < arguments.length; i++) {
675 args[i] = arguments[i];
676 }
677 return self.reduce(labels, function(callback, fToRetry) {
678 return callback && fToRetry.apply(void 0, args);
679 }, true);
680 };
681 };
682 /**
683 * @param {!Function} fn
684 * @return {?}
685 */
686 self.not = function(fn) {
687 return function() {
688 /** @type {!Array} */
689 var specialized = [];
690 /** @type {number} */
691 var i = 0;
692 for (; i < arguments.length; i++) {
693 specialized[i] = arguments[i];
694 }
695 return !fn.apply(void 0, specialized);
696 };
697 };
698 /**
699 * @return {undefined}
700 */
701 self.noop = function() {
702 };
703 /**
704 * @param {!Object} func
705 * @return {?}
706 */
707 self.toFunction = function(func) {
708 return self.isFunction(func) ? func : self.noop;
709 };
710 self.isIterable = self.or(self.isArray, self.isObject);
711 /**
712 * @param {!Object} data
713 * @param {string} fn
714 * @return {?}
715 */
716 self.invoke = function(data, fn) {
717 /** @type {!Array} */
718 var writes = [];
719 /** @type {number} */
720 var i = 2;
721 for (; i < arguments.length; i++) {
722 writes[i - 2] = arguments[i];
723 }
724 return self.reduce(fn.split("."), function(config, key) {
725 return config && config[key] || self.noop;
726 }, data).apply(void 0, writes);
727 };
728 /**
729 * @param {!Object} str
730 * @return {?}
731 */
732 self.isString = function(str) {
733 return "string" == typeof str;
734 };
735 /** @type {function(): ?} */
736 self.extend = extend;
737 /** @type {function(!Object, string, ?): ?} */
738 self.result = callback;
739 /** @type {function(?, string, ?): ?} */
740 self.replace = replace;
741 /** @type {function(?): ?} */
742 self.$ = value;
743 /** @type {function(?): ?} */
744 self.$$ = exports;
745 /** @type {function(!Object, ?): ?} */
746 self.inArray = inArray;
747 /** @type {function(!Object): ?} */
748 self.isEmpty = isEmpty;
749 /** @type {function(!Array): ?} */
750 self.isNull = validator;
751 /** @type {function(): ?} */
752 self.defaults = merge;
753 self.isDefined = self.not(self.isUndefined);
754 /** @type {function(!Function, number, !Array): ?} */
755 self.curry = curry;
756 /** @type {function(?): ?} */
757 self.isEmail = isEmail;
758 /** @type {function(string, !Array, number): ?} */
759 self.range = range;
760 /** @type {function(!Function): undefined} */
761 self.ready = ready;
762 /**
763 * @param {(!Function|string)} key
764 * @param {string} fn
765 * @return {?}
766 */
767 self.filter = function(key, fn) {
768 fn = self.toFunction(fn);
769 /** @type {!Array} */
770 var results = [];
771 return self.each(key, function(updatedObj, lastErrorObject) {
772 if (fn(updatedObj, lastErrorObject)) {
773 results.push(updatedObj);
774 }
775 }), results;
776 };
777 /** @type {function(): ?} */
778 self.getAPIUrl = hpaDasUrl;
779 /** @type {function(): undefined} */
780 self.Deferred = Deferred;
781 /** @type {function(): ?} */
782 self.isPushable = init;
783 /** @type {function(): ?} */
784 self.isSafari = conf;
785 /** @type {function(?): ?} */
786 self.isSafariConfigured = updateSynchronously;
787 /** @type {function(): ?} */
788 self.isMobile = isMobile;
789 /** @type {function(string): ?} */
790 self.getRavenOptions = filter;
791 /** @type {function(?, string): ?} */
792 self.unifyTags = walk;
793 /** @type {function(): undefined} */
794 self.endsWithPolyfill = main;
795 /** @type {function(!Arguments, !Object): ?} */
796 self.translate = translate;
797 /** @type {function(number, number): ?} */
798 self.diffDates = get_season;
799 /** @type {function(string): ?} */
800 self.trimSlash = resolve;
801 /** @type {function(!Array): ?} */
802 self.showPopup = set;
803 /** @type {function(!Object): ?} */
804 self.encodeQueryData = a;
805 /** @type {function(?): ?} */
806 self.fromUInt8ArrayToUrl = toB64;
807 /** @type {function(string): ?} */
808 self.urlBase64ToUint8Array = openBook;
809 },
810 10 : function(module, data) {
811 /**
812 * @param {string} message
813 * @return {undefined}
814 */
815 function RavenConfigError(message) {
816 /** @type {string} */
817 this.name = "RavenConfigError";
818 /** @type {string} */
819 this.message = message;
820 }
821 /** @type {!Error} */
822 RavenConfigError.prototype = new Error;
823 /** @type {function(string): undefined} */
824 RavenConfigError.prototype.constructor = RavenConfigError;
825 /** @type {function(string): undefined} */
826 module.exports = RavenConfigError;
827 },
828 11 : function(module, data, legToQuery) {
829 var query = legToQuery(3);
830 /**
831 * @param {?} property
832 * @param {string} key
833 * @param {!Function} callback
834 * @return {undefined}
835 */
836 var wrapMethod = function(property, key, callback) {
837 var descr = property[key];
838 var prop = property;
839 if (key in property) {
840 var index = "warn" === key ? "warning" : key;
841 /**
842 * @return {undefined}
843 */
844 property[key] = function() {
845 /** @type {!Array<?>} */
846 var params = [].slice.call(arguments);
847 var assertionError = query.safeJoin(params, " ");
848 var data = {
849 level : index,
850 logger : "console",
851 extra : {
852 arguments : params
853 }
854 };
855 if ("assert" === key) {
856 if (false === params[0]) {
857 assertionError = "Assertion failed: " + (query.safeJoin(params.slice(1), " ") || "console.assert");
858 /** @type {!Array<?>} */
859 data.extra.arguments = params.slice(1);
860 if (callback) {
861 callback(assertionError, data);
862 }
863 }
864 } else {
865 if (callback) {
866 callback(assertionError, data);
867 }
868 }
869 if (descr) {
870 Function.prototype.apply.call(descr, prop, params);
871 }
872 };
873 }
874 };
875 module.exports = {
876 wrapMethod : wrapMethod
877 };
878 },
879 12 : function(module, exports, _dereq_) {
880 (function(e) {
881 /**
882 * @return {?}
883 */
884 function now() {
885 return +new Date;
886 }
887 /**
888 * @param {?} obj
889 * @param {!Function} fn
890 * @return {?}
891 */
892 function hook(obj, fn) {
893 return isFunction(fn) ? function(bindOnce) {
894 return fn(bindOnce, obj);
895 } : fn;
896 }
897 /**
898 * @return {undefined}
899 */
900 function Raven() {
901 /** @type {boolean} */
902 this._hasJSON = !("object" != typeof JSON || !JSON.stringify);
903 /** @type {boolean} */
904 this._hasDocument = !isUndefined(_document);
905 /** @type {boolean} */
906 this._hasNavigator = !isUndefined(_navigator);
907 /** @type {null} */
908 this._lastCapturedException = null;
909 /** @type {null} */
910 this._lastData = null;
911 /** @type {null} */
912 this._lastEventId = null;
913 /** @type {null} */
914 this._globalServer = null;
915 /** @type {null} */
916 this._globalKey = null;
917 /** @type {null} */
918 this._globalProject = null;
919 this._globalContext = {};
920 this._globalOptions = {
921 release : global.SENTRY_RELEASE && global.SENTRY_RELEASE.id,
922 logger : "javascript",
923 ignoreErrors : [],
924 ignoreUrls : [],
925 whitelistUrls : [],
926 includePaths : [],
927 headers : null,
928 collectWindowErrors : true,
929 captureUnhandledRejections : true,
930 maxMessageLength : 0,
931 maxUrlLength : 250,
932 stackTraceLimit : 50,
933 autoBreadcrumbs : true,
934 instrument : true,
935 sampleRate : 1,
936 sanitizeKeys : []
937 };
938 this._fetchDefaults = {
939 method : "POST",
940 referrerPolicy : endsWith() ? "origin" : ""
941 };
942 /** @type {number} */
943 this._ignoreOnError = 0;
944 /** @type {boolean} */
945 this._isRavenInstalled = false;
946 /** @type {number} */
947 this._originalErrorStackTraceLimit = Error.stackTraceLimit;
948 this._originalConsole = global.console || {};
949 this._originalConsoleMethods = {};
950 /** @type {!Array} */
951 this._plugins = [];
952 this._startTime = now();
953 /** @type {!Array} */
954 this._wrappedBuiltIns = [];
955 /** @type {!Array} */
956 this._breadcrumbs = [];
957 /** @type {null} */
958 this._lastCapturedEvent = null;
959 this._keypressTimeout;
960 this._location = global.location;
961 this._lastHref = this._location && this._location.href;
962 this._resetBackoff();
963 var method;
964 for (method in this._originalConsole) {
965 this._originalConsoleMethods[method] = this._originalConsole[method];
966 }
967 }
968 var TraceKit = _dereq_(13);
969 var stringify = _dereq_(4);
970 var c = _dereq_(14);
971 var RavenConfigError = _dereq_(10);
972 var utils = _dereq_(3);
973 var parseBody = utils.isErrorEvent;
974 var callback = utils.isDOMError;
975 var def = utils.isDOMException;
976 var isError = utils.isError;
977 var isObject = utils.isObject;
978 var isPlainObject = utils.isPlainObject;
979 var isUndefined = utils.isUndefined;
980 var isFunction = utils.isFunction;
981 var isString = utils.isString;
982 var isArray = utils.isArray;
983 var isEmptyObject = utils.isEmptyObject;
984 var each = utils.each;
985 var objectMerge = utils.objectMerge;
986 var truncate = utils.truncate;
987 var dataURLToBlob = utils.objectFrozen;
988 var hasKey = utils.hasKey;
989 var joinRegExp = utils.joinRegExp;
990 var urlencode = utils.urlencode;
991 var decodeSafeOctets = utils.uuid4;
992 var htmlTreeAsString = utils.htmlTreeAsString;
993 var isSameException = utils.isSameException;
994 var isSameStacktrace = utils.isSameStacktrace;
995 var parseUrl = utils.parseUrl;
996 var fill = utils.fill;
997 var log = utils.supportsFetch;
998 var endsWith = utils.supportsReferrerPolicy;
999 var add_spaces = utils.serializeKeysForMessage;
1000 var binaryInsert = utils.serializeException;
1001 var clean = utils.sanitize;
1002 var wrapConsoleMethod = _dereq_(11).wrapMethod;
1003 /** @type {!Array<string>} */
1004 var dsnKeys = "source protocol user pass host port path".split(" ");
1005 /** @type {!RegExp} */
1006 var httpRegexp = /^(?:(\w+):)?\/\/(?:(\w+)(:\w+)?@)?([\w\.-]+)(?::(\d+))?(\/.*)/;
1007 var global = "undefined" != typeof window ? window : void 0 !== e ? e : "undefined" != typeof self ? self : {};
1008 var _document = global.document;
1009 var _navigator = global.navigator;
1010 Raven.prototype = {
1011 VERSION : "3.27.0",
1012 debug : true,
1013 TraceKit : TraceKit,
1014 config : function(dsn, options) {
1015 var self = this;
1016 if (false && self._globalServer) {
1017 console.log(self);
1018 return this._logDebug("error", "Error: Raven has already been configured"), self;
1019 }
1020 if (!dsn) {
1021 return self;
1022 }
1023 var globalOptions = self._globalOptions;
1024 if (options) {
1025 each(options, function(key, value) {
1026 if ("tags" === key || "extra" === key || "user" === key) {
1027 self._globalContext[key] = value;
1028 } else {
1029 globalOptions[key] = value;
1030 }
1031 });
1032 }
1033 self.setDSN(dsn);
1034 globalOptions.ignoreErrors.push(/^Script error\.?$/);
1035 globalOptions.ignoreErrors.push(/^Javascript error: Script error\.? on line 0$/);
1036 globalOptions.ignoreErrors = joinRegExp(globalOptions.ignoreErrors);
1037 globalOptions.ignoreUrls = !!globalOptions.ignoreUrls.length && joinRegExp(globalOptions.ignoreUrls);
1038 globalOptions.whitelistUrls = !!globalOptions.whitelistUrls.length && joinRegExp(globalOptions.whitelistUrls);
1039 globalOptions.includePaths = joinRegExp(globalOptions.includePaths);
1040 /** @type {number} */
1041 globalOptions.maxBreadcrumbs = Math.max(0, Math.min(globalOptions.maxBreadcrumbs || 100, 100));
1042 var autoBreadcrumbDefaults = {
1043 xhr : true,
1044 console : true,
1045 dom : true,
1046 location : true,
1047 sentry : true
1048 };
1049 var autoBreadcrumbs = globalOptions.autoBreadcrumbs;
1050 if ("[object Object]" === {}.toString.call(autoBreadcrumbs)) {
1051 autoBreadcrumbs = objectMerge(autoBreadcrumbDefaults, autoBreadcrumbs);
1052 } else {
1053 if (false !== autoBreadcrumbs) {
1054 autoBreadcrumbs = autoBreadcrumbDefaults;
1055 }
1056 }
1057 globalOptions.autoBreadcrumbs = autoBreadcrumbs;
1058 var instrumentDefaults = {
1059 tryCatch : true
1060 };
1061 var instrument = globalOptions.instrument;
1062 return "[object Object]" === {}.toString.call(instrument) ? instrument = objectMerge(instrumentDefaults, instrument) : false !== instrument && (instrument = instrumentDefaults), globalOptions.instrument = instrument, TraceKit.collectWindowErrors = !!globalOptions.collectWindowErrors, self;
1063 },
1064 install : function() {
1065 var self = this;
1066 return self.isSetup() && !self._isRavenInstalled && (TraceKit.report.subscribe(function() {
1067 self._handleOnErrorStackInfo.apply(self, arguments);
1068 }), self._globalOptions.captureUnhandledRejections && self._attachPromiseRejectionHandler(), self._patchFunctionToString(), self._globalOptions.instrument && self._globalOptions.instrument.tryCatch && self._instrumentTryCatch(), self._globalOptions.autoBreadcrumbs && self._instrumentBreadcrumbs(), self._drainPlugins(), self._isRavenInstalled = true), Error.stackTraceLimit = self._globalOptions.stackTraceLimit, this;
1069 },
1070 setDSN : function(dsn) {
1071 var self = this;
1072 var uri = self._parseDSN(dsn);
1073 var start = uri.path.lastIndexOf("/");
1074 var name = uri.path.substr(1, start);
1075 /** @type {!Function} */
1076 self._dsn = dsn;
1077 self._globalKey = uri.user;
1078 self._globalSecret = uri.pass && uri.pass.substr(1);
1079 console.log(self._globalSecret);
1080 self._globalProject = uri.path.substr(start + 1);
1081 self._globalServer = self._getGlobalServer(uri);
1082 /** @type {string} */
1083 self._globalEndpoint = self._globalServer + "/" + name + "api/" + self._globalProject + "/store/";
1084 console.log(self._globalEndpoint);
1085 this._resetBackoff();
1086 },
1087 context : function(name, fn, options) {
1088 return isFunction(name) && (options = fn || [], fn = name, name = {}), this.wrap(name, fn).apply(this, options);
1089 },
1090 wrap : function(options, func, _before) {
1091 /**
1092 * @return {?}
1093 */
1094 function wrapped() {
1095 /** @type {!Array} */
1096 var args = [];
1097 /** @type {number} */
1098 var i = arguments.length;
1099 var deep = !options || options && false !== options.deep;
1100 if (_before && isFunction(_before)) {
1101 _before.apply(this, arguments);
1102 }
1103 for (; i--;) {
1104 args[i] = deep ? self.wrap(options, arguments[i]) : arguments[i];
1105 }
1106 try {
1107 return func.apply(this, args);
1108 } catch (reason) {
1109 throw self._ignoreNextOnError(), self.captureException(reason, options), reason;
1110 }
1111 }
1112 var self = this;
1113 if (isUndefined(func) && !isFunction(options)) {
1114 return options;
1115 }
1116 if (isFunction(options) && (func = options, options = void 0), !isFunction(func)) {
1117 return func;
1118 }
1119 try {
1120 if (func.__raven__) {
1121 return func;
1122 }
1123 if (func.__raven_wrapper__) {
1124 return func.__raven_wrapper__;
1125 }
1126 } catch (t) {
1127 return func;
1128 }
1129 var i;
1130 for (i in func) {
1131 if (hasKey(func, i)) {
1132 wrapped[i] = func[i];
1133 }
1134 }
1135 return wrapped.prototype = func.prototype, func.__raven_wrapper__ = wrapped, wrapped.__raven__ = true, wrapped.__orig__ = func, wrapped;
1136 },
1137 uninstall : function() {
1138 return TraceKit.report.uninstall(), this._detachPromiseRejectionHandler(), this._unpatchFunctionToString(), this._restoreBuiltIns(), this._restoreConsole(), Error.stackTraceLimit = this._originalErrorStackTraceLimit, this._isRavenInstalled = false, this;
1139 },
1140 _promiseRejectionHandler : function(data) {
1141 this._logDebug("debug", "Raven caught unhandled promise rejection:", data);
1142 this.captureException(data.reason, {
1143 mechanism : {
1144 type : "onunhandledrejection",
1145 handled : false
1146 }
1147 });
1148 },
1149 _attachPromiseRejectionHandler : function() {
1150 return this._promiseRejectionHandler = this._promiseRejectionHandler.bind(this), global.addEventListener && global.addEventListener("unhandledrejection", this._promiseRejectionHandler), this;
1151 },
1152 _detachPromiseRejectionHandler : function() {
1153 return global.removeEventListener && global.removeEventListener("unhandledrejection", this._promiseRejectionHandler), this;
1154 },
1155 captureException : function(error, options) {
1156 if (options = objectMerge({
1157 trimHeadFrames : 0
1158 }, options || {}), parseBody(error) && error.error) {
1159 error = error.error;
1160 } else {
1161 if (callback(error) || def(error)) {
1162 var e = error.name || (callback(error) ? "DOMError" : "DOMException");
1163 var ex = error.message ? e + ": " + error.message : e;
1164 return this.captureMessage(ex, objectMerge(options, {
1165 stacktrace : true,
1166 trimHeadFrames : options.trimHeadFrames + 1
1167 }));
1168 }
1169 if (isError(error)) {
1170 /** @type {!Object} */
1171 error = error;
1172 } else {
1173 if (!isPlainObject(error)) {
1174 return this.captureMessage(error, objectMerge(options, {
1175 stacktrace : true,
1176 trimHeadFrames : options.trimHeadFrames + 1
1177 }));
1178 }
1179 options = this._getCaptureExceptionOptionsFromPlainObject(options, error);
1180 /** @type {!Error} */
1181 error = new Error(options.message);
1182 }
1183 }
1184 /** @type {!Object} */
1185 this._lastCapturedException = error;
1186 try {
1187 var stack = TraceKit.computeStackTrace(error);
1188 this._handleStackInfo(stack, options);
1189 } catch (busy) {
1190 if (error !== busy) {
1191 throw busy;
1192 }
1193 }
1194 return this;
1195 },
1196 _getCaptureExceptionOptionsFromPlainObject : function(options, value) {
1197 /** @type {!Array<string>} */
1198 var out = Object.keys(value).sort();
1199 var data = objectMerge(options, {
1200 message : "Non-Error exception captured with keys: " + add_spaces(out),
1201 fingerprint : [c(out)],
1202 extra : options.extra || {}
1203 });
1204 return data.extra.__serialized__ = binaryInsert(value), data;
1205 },
1206 captureMessage : function(message, options) {
1207 if (!this._globalOptions.ignoreErrors.test || !this._globalOptions.ignoreErrors.test(message)) {
1208 options = options || {};
1209 /** @type {string} */
1210 message = message + "";
1211 var ex;
1212 var data = objectMerge({
1213 message : message
1214 }, options);
1215 try {
1216 throw new Error(message);
1217 } catch (e) {
1218 ex = e;
1219 }
1220 /** @type {null} */
1221 ex.name = null;
1222 var stack = TraceKit.computeStackTrace(ex);
1223 var response = isArray(stack.stack) && stack.stack[1];
1224 if (response && "Raven.captureException" === response.func) {
1225 response = stack.stack[2];
1226 }
1227 var includeStr = response && response.url || "";
1228 if ((!this._globalOptions.ignoreUrls.test || !this._globalOptions.ignoreUrls.test(includeStr)) && (!this._globalOptions.whitelistUrls.test || this._globalOptions.whitelistUrls.test(includeStr))) {
1229 if (this._globalOptions.stacktrace || options.stacktrace || "" === data.message) {
1230 data.fingerprint = null == data.fingerprint ? message : data.fingerprint;
1231 options = objectMerge({
1232 trimHeadFrames : 0
1233 }, options);
1234 options.trimHeadFrames += 1;
1235 var frames = this._prepareFrames(stack, options);
1236 data.stacktrace = {
1237 frames : frames.reverse()
1238 };
1239 }
1240 return data.fingerprint && (data.fingerprint = isArray(data.fingerprint) ? data.fingerprint : [data.fingerprint]), this._send(data), this;
1241 }
1242 }
1243 },
1244 captureBreadcrumb : function(obj) {
1245 var crumb = objectMerge({
1246 timestamp : now() / 1e3
1247 }, obj);
1248 if (isFunction(this._globalOptions.breadcrumbCallback)) {
1249 var result = this._globalOptions.breadcrumbCallback(crumb);
1250 if (isObject(result) && !isEmptyObject(result)) {
1251 crumb = result;
1252 } else {
1253 if (false === result) {
1254 return this;
1255 }
1256 }
1257 }
1258 return this._breadcrumbs.push(crumb), this._breadcrumbs.length > this._globalOptions.maxBreadcrumbs && this._breadcrumbs.shift(), this;
1259 },
1260 addPlugin : function(plugin) {
1261 /** @type {!Array<?>} */
1262 var pluginArgs = [].slice.call(arguments, 1);
1263 return this._plugins.push([plugin, pluginArgs]), this._isRavenInstalled && this._drainPlugins(), this;
1264 },
1265 setUserContext : function(user) {
1266 return this._globalContext.user = user, this;
1267 },
1268 setExtraContext : function(extra) {
1269 return this._mergeContext("extra", extra), this;
1270 },
1271 setTagsContext : function(tags) {
1272 return this._mergeContext("tags", tags), this;
1273 },
1274 clearContext : function() {
1275 return this._globalContext = {}, this;
1276 },
1277 getContext : function() {
1278 return JSON.parse(stringify(this._globalContext));
1279 },
1280 setEnvironment : function(environment) {
1281 return this._globalOptions.environment = environment, this;
1282 },
1283 setRelease : function(release) {
1284 return this._globalOptions.release = release, this;
1285 },
1286 setDataCallback : function(callback) {
1287 var original = this._globalOptions.dataCallback;
1288 return this._globalOptions.dataCallback = hook(original, callback), this;
1289 },
1290 setBreadcrumbCallback : function(callback) {
1291 var original = this._globalOptions.breadcrumbCallback;
1292 return this._globalOptions.breadcrumbCallback = hook(original, callback), this;
1293 },
1294 setShouldSendCallback : function(callback) {
1295 var original = this._globalOptions.shouldSendCallback;
1296 return this._globalOptions.shouldSendCallback = hook(original, callback), this;
1297 },
1298 setTransport : function(transport) {
1299 return this._globalOptions.transport = transport, this;
1300 },
1301 lastException : function() {
1302 return this._lastCapturedException;
1303 },
1304 lastEventId : function() {
1305 return this._lastEventId;
1306 },
1307 isSetup : function() {
1308 return !!this._hasJSON && (!!this._globalServer || (this.ravenNotConfiguredError || (this.ravenNotConfiguredError = true, this._logDebug("error", "Error: Raven has not been configured.")), false));
1309 },
1310 afterLoad : function() {
1311 var globalConfig = global.RavenConfig;
1312 if (globalConfig) {
1313 this.config(globalConfig.dsn, globalConfig.config).install();
1314 }
1315 },
1316 showReportDialog : function(options) {
1317 if (_document) {
1318 if (options = objectMerge({
1319 eventId : this.lastEventId(),
1320 dsn : this._dsn,
1321 user : this._globalContext.user || {}
1322 }, options), !options.eventId) {
1323 throw new RavenConfigError("Missing eventId");
1324 }
1325 if (!options.dsn) {
1326 throw new RavenConfigError("Missing DSN");
1327 }
1328 /** @type {function(string): string} */
1329 var encode = encodeURIComponent;
1330 /** @type {!Array} */
1331 var drilldownLevelLabels = [];
1332 var item;
1333 for (item in options) {
1334 if ("user" === item) {
1335 var user = options.user;
1336 if (user.name) {
1337 drilldownLevelLabels.push("name=" + encode(user.name));
1338 }
1339 if (user.email) {
1340 drilldownLevelLabels.push("email=" + encode(user.email));
1341 }
1342 } else {
1343 drilldownLevelLabels.push(encode(item) + "=" + encode(options[item]));
1344 }
1345 }
1346 var globalServer = this._getGlobalServer(this._parseDSN(options.dsn));
1347 var a = _document.createElement("script");
1348 /** @type {boolean} */
1349 a.async = true;
1350 /** @type {string} */
1351 a.src = globalServer + "/api/embed/error-page/?" + drilldownLevelLabels.join("&");
1352 (_document.head || _document.body).appendChild(a);
1353 }
1354 },
1355 _ignoreNextOnError : function() {
1356 var self = this;
1357 this._ignoreOnError += 1;
1358 setTimeout(function() {
1359 self._ignoreOnError -= 1;
1360 });
1361 },
1362 _triggerEvent : function(eventType, data) {
1363 var evt;
1364 var i;
1365 if (this._hasDocument) {
1366 data = data || {};
1367 eventType = "raven" + eventType.substr(0, 1).toUpperCase() + eventType.substr(1);
1368 if (_document.createEvent) {
1369 evt = _document.createEvent("HTMLEvents");
1370 evt.initEvent(eventType, true, true);
1371 } else {
1372 evt = _document.createEventObject();
1373 /** @type {string} */
1374 evt.eventType = eventType;
1375 }
1376 for (i in data) {
1377 if (hasKey(data, i)) {
1378 evt[i] = data[i];
1379 }
1380 }
1381 if (_document.createEvent) {
1382 _document.dispatchEvent(evt);
1383 } else {
1384 try {
1385 _document.fireEvent("on" + evt.eventType.toLowerCase(), evt);
1386 } catch (t) {
1387 }
1388 }
1389 }
1390 },
1391 _breadcrumbEventHandler : function(evtName) {
1392 var self = this;
1393 return function(evt) {
1394 if (self._keypressTimeout = null, self._lastCapturedEvent !== evt) {
1395 /** @type {!Object} */
1396 self._lastCapturedEvent = evt;
1397 var target;
1398 try {
1399 target = htmlTreeAsString(evt.target);
1400 } catch (t) {
1401 /** @type {string} */
1402 target = "<unknown>";
1403 }
1404 self.captureBreadcrumb({
1405 category : "ui." + evtName,
1406 message : target
1407 });
1408 }
1409 };
1410 },
1411 _keypressEventHandler : function() {
1412 var self = this;
1413 return function(context) {
1414 var target;
1415 try {
1416 target = context.target;
1417 } catch (t) {
1418 return;
1419 }
1420 var htmlElementName = target && target.tagName;
1421 if (htmlElementName && ("INPUT" === htmlElementName || "TEXTAREA" === htmlElementName || target.isContentEditable)) {
1422 var timeout = self._keypressTimeout;
1423 if (!timeout) {
1424 self._breadcrumbEventHandler("input")(context);
1425 }
1426 clearTimeout(timeout);
1427 /** @type {number} */
1428 self._keypressTimeout = setTimeout(function() {
1429 /** @type {null} */
1430 self._keypressTimeout = null;
1431 }, 1e3);
1432 }
1433 };
1434 },
1435 _captureUrlChange : function(from, to) {
1436 var parsedLoc = parseUrl(this._location.href);
1437 var parsedTo = parseUrl(to);
1438 var parsedFrom = parseUrl(from);
1439 /** @type {string} */
1440 this._lastHref = to;
1441 if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {
1442 to = parsedTo.relative;
1443 }
1444 if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {
1445 from = parsedFrom.relative;
1446 }
1447 this.captureBreadcrumb({
1448 category : "navigation",
1449 data : {
1450 to : to,
1451 from : from
1452 }
1453 });
1454 },
1455 _patchFunctionToString : function() {
1456 var format = this;
1457 /** @type {function(this:!Function): string} */
1458 format._originalFunctionToString = Function.prototype.toString;
1459 /**
1460 * @return {string}
1461 */
1462 Function.prototype.toString = function() {
1463 return "function" == typeof this && this.__raven__ ? format._originalFunctionToString.apply(this.__orig__, arguments) : format._originalFunctionToString.apply(this, arguments);
1464 };
1465 },
1466 _unpatchFunctionToString : function() {
1467 if (this._originalFunctionToString) {
1468 Function.prototype.toString = this._originalFunctionToString;
1469 }
1470 },
1471 _instrumentTryCatch : function() {
1472 /**
1473 * @param {!Function} fn
1474 * @return {?}
1475 */
1476 function wrapTimeFn(fn) {
1477 return function(n, canCreateDiscussions) {
1478 /** @type {!Array} */
1479 var args = new Array(arguments.length);
1480 /** @type {number} */
1481 var i = 0;
1482 for (; i < args.length; ++i) {
1483 args[i] = arguments[i];
1484 }
1485 var callback = args[0];
1486 return isFunction(callback) && (args[0] = self.wrap({
1487 mechanism : {
1488 type : "instrument",
1489 data : {
1490 function : fn.name || "<anonymous>"
1491 }
1492 }
1493 }, callback)), fn.apply ? fn.apply(this, args) : fn(args[0], args[1]);
1494 };
1495 }
1496 var self = this;
1497 var wrappedBuiltIns = self._wrappedBuiltIns;
1498 var autoBreadcrumbs = this._globalOptions.autoBreadcrumbs;
1499 fill(global, "setTimeout", wrapTimeFn, wrappedBuiltIns);
1500 fill(global, "setInterval", wrapTimeFn, wrappedBuiltIns);
1501 if (global.requestAnimationFrame) {
1502 fill(global, "requestAnimationFrame", function(c) {
1503 return function(name) {
1504 return c(self.wrap({
1505 mechanism : {
1506 type : "instrument",
1507 data : {
1508 function : "requestAnimationFrame",
1509 handler : c && c.name || "<anonymous>"
1510 }
1511 }
1512 }, name));
1513 };
1514 }, wrappedBuiltIns);
1515 }
1516 /** @type {!Array} */
1517 var eventTargets = ["EventTarget", "Window", "Node", "ApplicationCache", "AudioTrackList", "ChannelMergerNode", "CryptoOperation", "EventSource", "FileReader", "HTMLUnknownElement", "IDBDatabase", "IDBRequest", "IDBTransaction", "KeyOperation", "MediaController", "MessagePort", "ModalWindow", "Notification", "SVGElementInstance", "Screen", "TextTrack", "TextTrackCue", "TextTrackList", "WebSocket", "WebSocketWorker", "Worker", "XMLHttpRequest", "XMLHttpRequestEventTarget", "XMLHttpRequestUpload"];
1518 /** @type {number} */
1519 var i = 0;
1520 for (; i < eventTargets.length; i++) {
1521 !function(key) {
1522 var proto = global[key] && global[key].prototype;
1523 if (proto && proto.hasOwnProperty && proto.hasOwnProperty("addEventListener")) {
1524 fill(proto, "addEventListener", function(parent) {
1525 return function(floatReference, options, params, message) {
1526 try {
1527 if (options && options.handleEvent) {
1528 options.handleEvent = self.wrap({
1529 mechanism : {
1530 type : "instrument",
1531 data : {
1532 target : key,
1533 function : "handleEvent",
1534 handler : options && options.name || "<anonymous>"
1535 }
1536 }
1537 }, options.handleEvent);
1538 }
1539 } catch (t) {
1540 }
1541 var before;
1542 var spy;
1543 var equal;
1544 return autoBreadcrumbs && autoBreadcrumbs.dom && ("EventTarget" === key || "Node" === key) && (spy = self._breadcrumbEventHandler("click"), equal = self._keypressEventHandler(), before = function(event) {
1545 if (event) {
1546 var eventType;
1547 try {
1548 eventType = event.type;
1549 } catch (t) {
1550 return;
1551 }
1552 return "click" === eventType ? spy(event) : "keypress" === eventType ? equal(event) : void 0;
1553 }
1554 }), parent.call(this, floatReference, self.wrap({
1555 mechanism : {
1556 type : "instrument",
1557 data : {
1558 target : key,
1559 function : "addEventListener",
1560 handler : options && options.name || "<anonymous>"
1561 }
1562 }
1563 }, options, before), params, message);
1564 };
1565 }, wrappedBuiltIns);
1566 fill(proto, "removeEventListener", function(t) {
1567 return function(e, fn, data, s) {
1568 try {
1569 fn = fn && (fn.__raven_wrapper__ ? fn.__raven_wrapper__ : fn);
1570 } catch (t) {
1571 }
1572 return t.call(this, e, fn, data, s);
1573 };
1574 }, wrappedBuiltIns);
1575 }
1576 }(eventTargets[i]);
1577 }
1578 },
1579 _instrumentBreadcrumbs : function() {
1580 /**
1581 * @param {string} prop
1582 * @param {!Object} xhr
1583 * @return {undefined}
1584 */
1585 function wrapProp(prop, xhr) {
1586 if (prop in xhr && isFunction(xhr[prop])) {
1587 fill(xhr, prop, function(name) {
1588 return self.wrap({
1589 mechanism : {
1590 type : "instrument",
1591 data : {
1592 function : prop,
1593 handler : name && name.name || "<anonymous>"
1594 }
1595 }
1596 }, name);
1597 });
1598 }
1599 }
1600 var self = this;
1601 var autoBreadcrumbs = this._globalOptions.autoBreadcrumbs;
1602 var wrappedBuiltIns = self._wrappedBuiltIns;
1603 if (autoBreadcrumbs.xhr && "XMLHttpRequest" in global) {
1604 var _window = global.XMLHttpRequest && global.XMLHttpRequest.prototype;
1605 fill(_window, "open", function(CropAreaRectangle) {
1606 return function(new_method, url) {
1607 return isString(url) && -1 === url.indexOf(self._globalKey) && (this.__raven_xhr = {
1608 method : new_method,
1609 url : url,
1610 status_code : null
1611 }), CropAreaRectangle.apply(this, arguments);
1612 };
1613 }, wrappedBuiltIns);
1614 fill(_window, "send", function(CropAreaRectangle) {
1615 return function() {
1616 /**
1617 * @return {undefined}
1618 */
1619 function onreadystatechangeHandler() {
1620 if (xhr.__raven_xhr && 4 === xhr.readyState) {
1621 try {
1622 xhr.__raven_xhr.status_code = xhr.status;
1623 } catch (t) {
1624 }
1625 self.captureBreadcrumb({
1626 type : "http",
1627 category : "xhr",
1628 data : xhr.__raven_xhr
1629 });
1630 }
1631 }
1632 var xhr = this;
1633 /** @type {!Array} */
1634 var props = ["onload", "onerror", "onprogress"];
1635 /** @type {number} */
1636 var j = 0;
1637 for (; j < props.length; j++) {
1638 wrapProp(props[j], xhr);
1639 }
1640 return "onreadystatechange" in xhr && isFunction(xhr.onreadystatechange) ? fill(xhr, "onreadystatechange", function(name) {
1641 return self.wrap({
1642 mechanism : {
1643 type : "instrument",
1644 data : {
1645 function : "onreadystatechange",
1646 handler : name && name.name || "<anonymous>"
1647 }
1648 }
1649 }, name, onreadystatechangeHandler);
1650 }) : xhr.onreadystatechange = onreadystatechangeHandler, CropAreaRectangle.apply(this, arguments);
1651 };
1652 }, wrappedBuiltIns);
1653 }
1654 if (autoBreadcrumbs.xhr && log()) {
1655 fill(global, "fetch", function(fToRetry) {
1656 return function() {
1657 /** @type {!Array} */
1658 var args = new Array(arguments.length);
1659 /** @type {number} */
1660 var i = 0;
1661 for (; i < args.length; ++i) {
1662 args[i] = arguments[i];
1663 }
1664 var url;
1665 var data = args[0];
1666 /** @type {string} */
1667 var method = "GET";
1668 if ("string" == typeof data ? url = data : "Request" in global && data instanceof global.Request ? (url = data.url, data.method && (method = data.method)) : url = "" + data, -1 !== url.indexOf(self._globalKey)) {
1669 return fToRetry.apply(this, args);
1670 }
1671 if (args[1] && args[1].method) {
1672 method = args[1].method;
1673 }
1674 var fetchData = {
1675 method : method,
1676 url : url,
1677 status_code : null
1678 };
1679 return fToRetry.apply(this, args).then(function(response) {
1680 return fetchData.status_code = response.status, self.captureBreadcrumb({
1681 type : "http",
1682 category : "fetch",
1683 data : fetchData
1684 }), response;
1685 }).catch(function(canCreateDiscussions) {
1686 throw self.captureBreadcrumb({
1687 type : "http",
1688 category : "fetch",
1689 data : fetchData,
1690 level : "error"
1691 }), canCreateDiscussions;
1692 });
1693 };
1694 }, wrappedBuiltIns);
1695 }
1696 if (autoBreadcrumbs.dom && this._hasDocument) {
1697 if (_document.addEventListener) {
1698 _document.addEventListener("click", self._breadcrumbEventHandler("click"), false);
1699 _document.addEventListener("keypress", self._keypressEventHandler(), false);
1700 } else {
1701 if (_document.attachEvent) {
1702 _document.attachEvent("onclick", self._breadcrumbEventHandler("click"));
1703 _document.attachEvent("onkeypress", self._keypressEventHandler());
1704 }
1705 }
1706 }
1707 var chrome = global.chrome;
1708 var err = chrome && chrome.app && chrome.app.runtime;
1709 var hasPushState = !err && global.history && global.history.pushState && global.history.replaceState;
1710 if (autoBreadcrumbs.location && hasPushState) {
1711 var matchMedia = global.onpopstate;
1712 /**
1713 * @return {?}
1714 */
1715 global.onpopstate = function() {
1716 var currentHref = self._location.href;
1717 if (self._captureUrlChange(self._lastHref, currentHref), matchMedia) {
1718 return matchMedia.apply(this, arguments);
1719 }
1720 };
1721 /**
1722 * @param {!Function} cb
1723 * @return {?}
1724 */
1725 var done = function(cb) {
1726 return function() {
1727 var url = arguments.length > 2 ? arguments[2] : void 0;
1728 return url && self._captureUrlChange(self._lastHref, url + ""), cb.apply(this, arguments);
1729 };
1730 };
1731 fill(global.history, "pushState", done, wrappedBuiltIns);
1732 fill(global.history, "replaceState", done, wrappedBuiltIns);
1733 }
1734 if (autoBreadcrumbs.console && "console" in global && console.log) {
1735 /**
1736 * @param {string} msg
1737 * @param {!Object} data
1738 * @return {undefined}
1739 */
1740 var consoleMethodCallback = function(msg, data) {
1741 self.captureBreadcrumb({
1742 message : msg,
1743 level : data.level,
1744 category : "console"
1745 });
1746 };
1747 each(["debug", "info", "warn", "error", "log"], function(canCreateDiscussions, level) {
1748 wrapConsoleMethod(console, level, consoleMethodCallback);
1749 });
1750 }
1751 },
1752 _restoreBuiltIns : function() {
1753 var tab;
1754 for (; this._wrappedBuiltIns.length;) {
1755 tab = this._wrappedBuiltIns.shift();
1756 var data = tab[0];
1757 var offset = tab[1];
1758 var r = tab[2];
1759 data[offset] = r;
1760 }
1761 },
1762 _restoreConsole : function() {
1763 var method;
1764 for (method in this._originalConsoleMethods) {
1765 this._originalConsole[method] = this._originalConsoleMethods[method];
1766 }
1767 },
1768 _drainPlugins : function() {
1769 var array = this;
1770 each(this._plugins, function(canCreateDiscussions, splices) {
1771 var splice = splices[0];
1772 var newNodeLists = splices[1];
1773 splice.apply(array, [array].concat(newNodeLists));
1774 });
1775 },
1776 _parseDSN : function(str) {
1777 /** @type {(Array<string>|null)} */
1778 var e = httpRegexp.exec(str);
1779 var dsn = {};
1780 /** @type {number} */
1781 var i = 7;
1782 try {
1783 for (; i--;) {
1784 /** @type {string} */
1785 dsn[dsnKeys[i]] = e[i] || "";
1786 }
1787 } catch (e) {
1788 throw new RavenConfigError("Invalid DSN: " + str);
1789 }
1790 if (dsn.pass && !this._globalOptions.allowSecretKey) {
1791 throw new RavenConfigError("Do not specify your secret key in the DSN. See: http://bit.ly/raven-secret-key");
1792 }
1793 return dsn;
1794 },
1795 _getGlobalServer : function(uri) {
1796 /** @type {string} */
1797 var s = "//" + uri.host + (uri.port ? ":" + uri.port : "");
1798 return uri.protocol && (s = uri.protocol + ":" + s), s;
1799 },
1800 _handleOnErrorStackInfo : function(stack, options) {
1801 options = options || {};
1802 options.mechanism = options.mechanism || {
1803 type : "onerror",
1804 handled : false
1805 };
1806 if (!this._ignoreOnError) {
1807 this._handleStackInfo(stack, options);
1808 }
1809 },
1810 _handleStackInfo : function(stackInfo, options) {
1811 var frames = this._prepareFrames(stackInfo, options);
1812 this._triggerEvent("handle", {
1813 stackInfo : stackInfo,
1814 options : options
1815 });
1816 this._processException(stackInfo.name, stackInfo.message, stackInfo.url, stackInfo.lineno, frames, options);
1817 },
1818 _prepareFrames : function(stackInfo, options) {
1819 var self = this;
1820 /** @type {!Array} */
1821 var frames = [];
1822 if (stackInfo.stack && stackInfo.stack.length && (each(stackInfo.stack, function(canCreateDiscussions, frame) {
1823 var item = self._normalizeFrame(frame, stackInfo.url);
1824 if (item) {
1825 frames.push(item);
1826 }
1827 }), options && options.trimHeadFrames)) {
1828 /** @type {number} */
1829 var j = 0;
1830 for (; j < options.trimHeadFrames && j < frames.length; j++) {
1831 /** @type {boolean} */
1832 frames[j].in_app = false;
1833 }
1834 }
1835 return frames = frames.slice(0, this._globalOptions.stackTraceLimit);
1836 },
1837 _normalizeFrame : function(frame, url) {
1838 var normalized = {
1839 filename : frame.url,
1840 lineno : frame.line,
1841 colno : frame.column,
1842 function : frame.func || "?"
1843 };
1844 return frame.url || (normalized.filename = url), normalized.in_app = !(this._globalOptions.includePaths.test && !this._globalOptions.includePaths.test(normalized.filename) || /(Raven|TraceKit)\./.test(normalized.function) || /raven\.(min\.)?js$/.test(normalized.filename)), normalized;
1845 },
1846 _processException : function(type, message, fileurl, lineno, frames, options) {
1847 /** @type {string} */
1848 var instanceFillValue = (type ? type + ": " : "") + (message || "");
1849 if (!this._globalOptions.ignoreErrors.test || !this._globalOptions.ignoreErrors.test(message) && !this._globalOptions.ignoreErrors.test(instanceFillValue)) {
1850 var stacktrace;
1851 if (frames && frames.length ? (fileurl = frames[0].filename || fileurl, frames.reverse(), stacktrace = {
1852 frames : frames
1853 }) : fileurl && (stacktrace = {
1854 frames : [{
1855 filename : fileurl,
1856 lineno : lineno,
1857 in_app : true
1858 }]
1859 }), (!this._globalOptions.ignoreUrls.test || !this._globalOptions.ignoreUrls.test(fileurl)) && (!this._globalOptions.whitelistUrls.test || this._globalOptions.whitelistUrls.test(fileurl))) {
1860 var data = objectMerge({
1861 exception : {
1862 values : [{
1863 type : type,
1864 value : message,
1865 stacktrace : stacktrace
1866 }]
1867 },
1868 transaction : fileurl
1869 }, options);
1870 var c = data.exception.values[0];
1871 if (null == c.type && "" === c.value) {
1872 /** @type {string} */
1873 c.value = "Unrecoverable error caught";
1874 }
1875 if (!data.exception.mechanism && data.mechanism) {
1876 data.exception.mechanism = data.mechanism;
1877 delete data.mechanism;
1878 }
1879 data.exception.mechanism = objectMerge({
1880 type : "generic",
1881 handled : true
1882 }, data.exception.mechanism || {});
1883 this._send(data);
1884 }
1885 }
1886 },
1887 _trimPacket : function(data) {
1888 var max = this._globalOptions.maxMessageLength;
1889 if (data.message && (data.message = truncate(data.message, max)), data.exception) {
1890 var exception = data.exception.values[0];
1891 exception.value = truncate(exception.value, max);
1892 }
1893 var request = data.request;
1894 return request && (request.url && (request.url = truncate(request.url, this._globalOptions.maxUrlLength)), request.Referer && (request.Referer = truncate(request.Referer, this._globalOptions.maxUrlLength))), data.breadcrumbs && data.breadcrumbs.values && this._trimBreadcrumbs(data.breadcrumbs), data;
1895 },
1896 _trimBreadcrumbs : function(breadcrumbs) {
1897 var urlProp;
1898 var crumb;
1899 var data;
1900 /** @type {!Array} */
1901 var urlProps = ["to", "from", "url"];
1902 /** @type {number} */
1903 var i = 0;
1904 for (; i < breadcrumbs.values.length; ++i) {
1905 if (crumb = breadcrumbs.values[i], crumb.hasOwnProperty("data") && isObject(crumb.data) && !dataURLToBlob(crumb.data)) {
1906 data = objectMerge({}, crumb.data);
1907 /** @type {number} */
1908 var j = 0;
1909 for (; j < urlProps.length; ++j) {
1910 urlProp = urlProps[j];
1911 if (data.hasOwnProperty(urlProp) && data[urlProp]) {
1912 data[urlProp] = truncate(data[urlProp], this._globalOptions.maxUrlLength);
1913 }
1914 }
1915 breadcrumbs.values[i].data = data;
1916 }
1917 }
1918 },
1919 _getHttpData : function() {
1920 if (this._hasNavigator || this._hasDocument) {
1921 var requestOptions = {};
1922 return this._hasNavigator && _navigator.userAgent && (requestOptions.headers = {
1923 "User-Agent" : _navigator.userAgent
1924 }), global.location && global.location.href && (requestOptions.url = global.location.href), this._hasDocument && _document.referrer && (requestOptions.headers || (requestOptions.headers = {}), requestOptions.headers.Referer = _document.referrer), requestOptions;
1925 }
1926 },
1927 _resetBackoff : function() {
1928 /** @type {number} */
1929 this._backoffDuration = 0;
1930 /** @type {null} */
1931 this._backoffStart = null;
1932 },
1933 _shouldBackoff : function() {
1934 return this._backoffDuration && now() - this._backoffStart < this._backoffDuration;
1935 },
1936 _isRepeatData : function(current) {
1937 var last = this._lastData;
1938 return !(!last || current.message !== last.message || current.transaction !== last.transaction) && (current.stacktrace || last.stacktrace ? isSameStacktrace(current.stacktrace, last.stacktrace) : !current.exception && !last.exception || isSameException(current.exception, last.exception));
1939 },
1940 _setBackoffState : function(request) {
1941 if (!this._shouldBackoff()) {
1942 var error = request.status;
1943 if (400 === error || 401 === error || 429 === error) {
1944 var total_pageviews_raw;
1945 try {
1946 total_pageviews_raw = log() ? request.headers.get("Retry-After") : request.getResponseHeader("Retry-After");
1947 /** @type {number} */
1948 total_pageviews_raw = 1e3 * parseInt(total_pageviews_raw, 10);
1949 } catch (t) {
1950 }
1951 /** @type {number} */
1952 this._backoffDuration = total_pageviews_raw || (2 * this._backoffDuration || 1e3);
1953 this._backoffStart = now();
1954 }
1955 }
1956 },
1957 _send : function(data) {
1958 var globalOptions = this._globalOptions;
1959 var baseData = {
1960 project : this._globalProject,
1961 logger : globalOptions.logger,
1962 platform : "javascript"
1963 };
1964 var httpData = this._getHttpData();
1965 if (httpData && (baseData.request = httpData), data.trimHeadFrames && delete data.trimHeadFrames, data = objectMerge(baseData, data), data.tags = objectMerge(objectMerge({}, this._globalContext.tags), data.tags), data.extra = objectMerge(objectMerge({}, this._globalContext.extra), data.extra), data.extra["session:duration"] = now() - this._startTime, this._breadcrumbs && this._breadcrumbs.length > 0 && (data.breadcrumbs = {
1966 values : [].slice.call(this._breadcrumbs, 0)
1967 }), this._globalContext.user && (data.user = this._globalContext.user), globalOptions.environment && (data.environment = globalOptions.environment), globalOptions.release && (data.release = globalOptions.release), globalOptions.serverName && (data.server_name = globalOptions.serverName), data = this._sanitizeData(data), Object.keys(data).forEach(function(i) {
1968 if (null == data[i] || "" === data[i] || isEmptyObject(data[i])) {
1969 delete data[i];
1970 }
1971 }), isFunction(globalOptions.dataCallback) && (data = globalOptions.dataCallback(data) || data), data && !isEmptyObject(data) && (!isFunction(globalOptions.shouldSendCallback) || globalOptions.shouldSendCallback(data))) {
1972 return this._shouldBackoff() ? void this._logDebug("warn", "Raven dropped error due to backoff: ", data) : void("number" == typeof globalOptions.sampleRate ? Math.random() < globalOptions.sampleRate && this._sendProcessedPayload(data) : this._sendProcessedPayload(data));
1973 }
1974 },
1975 _sanitizeData : function(data) {
1976 return clean(data, this._globalOptions.sanitizeKeys);
1977 },
1978 _getUuid : function() {
1979 return decodeSafeOctets();
1980 },
1981 _sendProcessedPayload : function(data, callback) {
1982 var self = this;
1983 var globalOptions = this._globalOptions;
1984 if (this.isSetup()) {
1985 if (data = this._trimPacket(data), !this._globalOptions.allowDuplicates && this._isRepeatData(data)) {
1986 return void this._logDebug("warn", "Raven dropped repeat event: ", data);
1987 }
1988 this._lastEventId = data.event_id || (data.event_id = this._getUuid());
1989 /** @type {!Object} */
1990 this._lastData = data;
1991 this._logDebug("debug", "Raven about to send:", data);
1992 var auth = {
1993 sentry_version : "7",
1994 sentry_client : "raven-js/" + this.VERSION,
1995 sentry_key : this._globalKey
1996 };
1997 if (this._globalSecret) {
1998 auth.sentry_secret = this._globalSecret;
1999 }
2000 var error = data.exception && data.exception.values[0];
2001 if (this._globalOptions.autoBreadcrumbs && this._globalOptions.autoBreadcrumbs.sentry) {
2002 this.captureBreadcrumb({
2003 category : "sentry",
2004 message : error ? (error.type ? error.type + ": " : "") + error.value : data.message,
2005 event_id : data.event_id,
2006 level : data.level || "error"
2007 });
2008 }
2009 var url = this._globalEndpoint;
2010 (globalOptions.transport || this._makeRequest).call(this, {
2011 url : url,
2012 auth : auth,
2013 data : data,
2014 options : globalOptions,
2015 onSuccess : function() {
2016 self._resetBackoff();
2017 self._triggerEvent("success", {
2018 data : data,
2019 src : url
2020 });
2021 if (callback) {
2022 callback();
2023 }
2024 },
2025 onError : function(error) {
2026 self._logDebug("error", "Raven transport failed to send: ", error);
2027 if (error.request) {
2028 self._setBackoffState(error.request);
2029 }
2030 self._triggerEvent("failure", {
2031 data : data,
2032 src : url
2033 });
2034 error = error || new Error("Raven send failed (no additional details provided)");
2035 if (callback) {
2036 callback(error);
2037 }
2038 }
2039 });
2040 }
2041 },
2042 _makeRequest : function(opts) {
2043 var request = opts.url + "?" + urlencode(opts.auth);
2044 /** @type {null} */
2045 var value = null;
2046 var options = {};
2047 if (opts.options.headers && (value = this._evaluateHash(opts.options.headers)), opts.options.fetchParameters && (options = this._evaluateHash(opts.options.fetchParameters)), log()) {
2048 options.body = stringify(opts.data);
2049 var baseData = objectMerge({}, this._fetchDefaults);
2050 var data = objectMerge(baseData, options);
2051 return value && (data.headers = value), global.fetch(request, data).then(function(options) {
2052 if (options.ok) {
2053 if (opts.onSuccess) {
2054 opts.onSuccess();
2055 }
2056 } else {
2057 /** @type {!Error} */
2058 var error = new Error("Sentry error code: " + options.status);
2059 /** @type {!Object} */
2060 error.request = options;
2061 if (opts.onError) {
2062 opts.onError(error);
2063 }
2064 }
2065 }).catch(function() {
2066 if (opts.onError) {
2067 opts.onError(new Error("Sentry error code: network unavailable"));
2068 }
2069 });
2070 }
2071 var req = global.XMLHttpRequest && new global.XMLHttpRequest;
2072 if (req) {
2073 if ("withCredentials" in req || "undefined" != typeof XDomainRequest) {
2074 if ("withCredentials" in req) {
2075 /**
2076 * @return {undefined}
2077 */
2078 req.onreadystatechange = function() {
2079 if (4 === req.readyState) {
2080 if (200 === req.status) {
2081 if (opts.onSuccess) {
2082 opts.onSuccess();
2083 }
2084 } else {
2085 if (opts.onError) {
2086 /** @type {!Error} */
2087 var error = new Error("Sentry error code: " + req.status);
2088 error.request = req;
2089 opts.onError(error);
2090 }
2091 }
2092 }
2093 };
2094 } else {
2095 /** @type {!XDomainRequest} */
2096 req = new XDomainRequest;
2097 request = request.replace(/^https?:/, "");
2098 if (opts.onSuccess) {
2099 req.onload = opts.onSuccess;
2100 }
2101 if (opts.onError) {
2102 /**
2103 * @return {undefined}
2104 */
2105 req.onerror = function() {
2106 /** @type {!Error} */
2107 var error = new Error("Sentry error code: XDomainRequest");
2108 error.request = req;
2109 opts.onError(error);
2110 };
2111 }
2112 }
2113 req.open("POST", request);
2114 if (value) {
2115 each(value, function(headerName, mime) {
2116 req.setRequestHeader(headerName, mime);
2117 });
2118 }
2119 req.send(stringify(opts.data));
2120 }
2121 }
2122 },
2123 _evaluateHash : function(states) {
2124 var a = {};
2125 var key;
2126 for (key in states) {
2127 if (states.hasOwnProperty(key)) {
2128 var state = states[key];
2129 a[key] = "function" == typeof state ? state() : state;
2130 }
2131 }
2132 return a;
2133 },
2134 _logDebug : function(level) {
2135 if (this._originalConsoleMethods[level] && (this.debug || this._globalOptions.debug)) {
2136 Function.prototype.apply.call(this._originalConsoleMethods[level], this._originalConsole, [].slice.call(arguments, 1));
2137 }
2138 },
2139 _mergeContext : function(key, context) {
2140 if (isUndefined(context)) {
2141 delete this._globalContext[key];
2142 } else {
2143 this._globalContext[key] = objectMerge(this._globalContext[key] || {}, context);
2144 }
2145 }
2146 };
2147 /** @type {function(string): ?} */
2148 Raven.prototype.setUser = Raven.prototype.setUserContext;
2149 /** @type {function(string): ?} */
2150 Raven.prototype.setReleaseContext = Raven.prototype.setRelease;
2151 /** @type {function(): undefined} */
2152 module.exports = Raven;
2153 }).call(exports, _dereq_(0));
2154 },
2155 13 : function(module, media, $) {
2156 (function(e) {
2157 /**
2158 * @return {?}
2159 */
2160 function getLocationHref() {
2161 return "undefined" == typeof document || null == document.location ? "" : document.location.href;
2162 }
2163 /**
2164 * @return {?}
2165 */
2166 function push() {
2167 return "undefined" == typeof document || null == document.location ? "" : document.location.origin ? document.location.origin : document.location.protocol + "//" + document.location.hostname + (document.location.port ? ":" + document.location.port : "");
2168 }
2169 var helper = $(3);
2170 var TraceKit = {
2171 collectWindowErrors : true,
2172 debug : false
2173 };
2174 var _window = "undefined" != typeof window ? window : void 0 !== e ? e : "undefined" != typeof self ? self : {};
2175 /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
2176 var slice = [].slice;
2177 /** @type {string} */
2178 var UNKNOWN_FUNCTION = "?";
2179 /** @type {!RegExp} */
2180 var item_pattern = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;
2181 TraceKit.report = function() {
2182 /**
2183 * @param {!Function} f
2184 * @return {undefined}
2185 */
2186 function subscribe(f) {
2187 installGlobalHandler();
2188 m.push(f);
2189 }
2190 /**
2191 * @param {?} error
2192 * @return {undefined}
2193 */
2194 function unsubscribe(error) {
2195 /** @type {number} */
2196 var i = m.length - 1;
2197 for (; i >= 0; --i) {
2198 if (m[i] === error) {
2199 m.splice(i, 1);
2200 }
2201 }
2202 }
2203 /**
2204 * @return {undefined}
2205 */
2206 function unsubscribeAll() {
2207 uninstallGlobalHandler();
2208 /** @type {!Array} */
2209 m = [];
2210 }
2211 /**
2212 * @param {!Object} stack
2213 * @param {boolean} isWindowError
2214 * @return {undefined}
2215 */
2216 function notifyHandlers(stack, isWindowError) {
2217 /** @type {null} */
2218 var n = null;
2219 if (!isWindowError || TraceKit.collectWindowErrors) {
2220 var origin;
2221 for (origin in m) {
2222 if (m.hasOwnProperty(origin)) {
2223 try {
2224 m[origin].apply(null, [stack].concat(slice.call(arguments, 2)));
2225 } catch (numInternals) {
2226 n = numInternals;
2227 }
2228 }
2229 }
2230 if (n) {
2231 throw n;
2232 }
2233 }
2234 }
2235 /**
2236 * @param {string} error
2237 * @param {string} url
2238 * @param {string} lineNo
2239 * @param {(number|string)} colNo
2240 * @param {!Object} err
2241 * @return {?}
2242 */
2243 function traceKitWindowOnError(error, url, lineNo, colNo, err) {
2244 /** @type {null} */
2245 var stack = null;
2246 var e = helper.isErrorEvent(err) ? err.error : err;
2247 var message = helper.isErrorEvent(error) ? error.message : error;
2248 if (lastExceptionStack) {
2249 TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
2250 processLastException();
2251 } else {
2252 if (e && helper.isError(e)) {
2253 stack = TraceKit.computeStackTrace(e);
2254 notifyHandlers(stack, true);
2255 } else {
2256 var node;
2257 var location = {
2258 url : url,
2259 line : lineNo,
2260 column : colNo
2261 };
2262 var node_name = void 0;
2263 if ("[object String]" === {}.toString.call(message)) {
2264 node = message.match(item_pattern);
2265 if (node) {
2266 node_name = node[1];
2267 message = node[2];
2268 }
2269 }
2270 /** @type {string} */
2271 location.func = UNKNOWN_FUNCTION;
2272 stack = {
2273 name : node_name,
2274 message : message,
2275 url : getLocationHref(),
2276 stack : [location]
2277 };
2278 notifyHandlers(stack, true);
2279 }
2280 }
2281 return !!_oldOnerrorHandler && _oldOnerrorHandler.apply(this, arguments);
2282 }
2283 /**
2284 * @return {undefined}
2285 */
2286 function installGlobalHandler() {
2287 if (!_) {
2288 _oldOnerrorHandler = _window.onerror;
2289 /** @type {function(string, string, string, (number|string), !Object): ?} */
2290 _window.onerror = traceKitWindowOnError;
2291 /** @type {boolean} */
2292 _ = true;
2293 }
2294 }
2295 /**
2296 * @return {undefined}
2297 */
2298 function uninstallGlobalHandler() {
2299 if (_) {
2300 _window.onerror = _oldOnerrorHandler;
2301 /** @type {boolean} */
2302 _ = false;
2303 _oldOnerrorHandler = void 0;
2304 }
2305 }
2306 /**
2307 * @return {undefined}
2308 */
2309 function processLastException() {
2310 var _lastExceptionStack = lastExceptionStack;
2311 var _lastArgs = lastArgs;
2312 /** @type {null} */
2313 lastArgs = null;
2314 /** @type {null} */
2315 lastExceptionStack = null;
2316 /** @type {null} */
2317 lastException = null;
2318 notifyHandlers.apply(null, [_lastExceptionStack, false].concat(_lastArgs));
2319 }
2320 /**
2321 * @param {?} ex
2322 * @param {!Object} options
2323 * @return {undefined}
2324 */
2325 function report(ex, options) {
2326 /** @type {!Array<?>} */
2327 var args = slice.call(arguments, 1);
2328 if (lastExceptionStack) {
2329 if (lastException === ex) {
2330 return;
2331 }
2332 processLastException();
2333 }
2334 var stack = TraceKit.computeStackTrace(ex);
2335 if (lastExceptionStack = stack, lastException = ex, lastArgs = args, setTimeout(function() {
2336 if (lastException === ex) {
2337 processLastException();
2338 }
2339 }, stack.incomplete ? 2e3 : 0), false !== options) {
2340 throw ex;
2341 }
2342 }
2343 var _oldOnerrorHandler;
2344 var _;
2345 /** @type {!Array} */
2346 var m = [];
2347 /** @type {null} */
2348 var lastArgs = null;
2349 /** @type {null} */
2350 var lastException = null;
2351 /** @type {null} */
2352 var lastExceptionStack = null;
2353 return report.subscribe = subscribe, report.unsubscribe = unsubscribe, report.uninstall = unsubscribeAll, report;
2354 }();
2355 TraceKit.computeStackTrace = function() {
2356 /**
2357 * @param {!Error} err
2358 * @return {?}
2359 */
2360 function get(err) {
2361 if (void 0 !== err.stack && err.stack) {
2362 var discussionList;
2363 var parts;
2364 var element;
2365 /** @type {!RegExp} */
2366 var f = /^\s*at (?:(.*?) ?\()?((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|[a-z]:|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
2367 /** @type {!RegExp} */
2368 var re = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx(?:-web)|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
2369 /** @type {!RegExp} */
2370 var regexp = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|moz-extension).*?:\/.*?|\[native code\]|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
2371 /** @type {!RegExp} */
2372 var geckoEval = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
2373 /** @type {!RegExp} */
2374 var chromeEval = /\((\S*)(?::(\d+))(?::(\d+))\)/;
2375 var argv = err.stack.split("\n");
2376 /** @type {!Array} */
2377 var stack = [];
2378 /** @type {number} */
2379 var i = (/^(.*) is undefined$/.exec(err.message), 0);
2380 var argc = argv.length;
2381 for (; i < argc; ++i) {
2382 if (parts = f.exec(argv[i])) {
2383 /** @type {(boolean|string)} */
2384 var isNative = parts[2] && 0 === parts[2].indexOf("native");
2385 /** @type {(boolean|string)} */
2386 var discussionExtractor = parts[2] && 0 === parts[2].indexOf("eval");
2387 if (discussionExtractor && (discussionList = chromeEval.exec(parts[2]))) {
2388 /** @type {string} */
2389 parts[2] = discussionList[1];
2390 /** @type {string} */
2391 parts[3] = discussionList[2];
2392 /** @type {string} */
2393 parts[4] = discussionList[3];
2394 }
2395 element = {
2396 url : isNative ? null : parts[2],
2397 func : parts[1] || UNKNOWN_FUNCTION,
2398 args : isNative ? [parts[2]] : [],
2399 line : parts[3] ? +parts[3] : null,
2400 column : parts[4] ? +parts[4] : null
2401 };
2402 } else {
2403 if (parts = re.exec(argv[i])) {
2404 element = {
2405 url : parts[2],
2406 func : parts[1] || UNKNOWN_FUNCTION,
2407 args : [],
2408 line : +parts[3],
2409 column : parts[4] ? +parts[4] : null
2410 };
2411 } else {
2412 if (!(parts = regexp.exec(argv[i]))) {
2413 continue;
2414 }
2415 /** @type {(boolean|string)} */
2416 discussionExtractor = parts[3] && parts[3].indexOf(" > eval") > -1;
2417 if (discussionExtractor && (discussionList = geckoEval.exec(parts[3]))) {
2418 /** @type {string} */
2419 parts[3] = discussionList[1];
2420 /** @type {string} */
2421 parts[4] = discussionList[2];
2422 /** @type {null} */
2423 parts[5] = null;
2424 } else {
2425 if (!(0 !== i || parts[5] || void 0 === err.columnNumber)) {
2426 stack[0].column = err.columnNumber + 1;
2427 }
2428 }
2429 element = {
2430 url : parts[3],
2431 func : parts[1] || UNKNOWN_FUNCTION,
2432 args : parts[2] ? parts[2].split(",") : [],
2433 line : parts[4] ? +parts[4] : null,
2434 column : parts[5] ? +parts[5] : null
2435 };
2436 }
2437 }
2438 if (!element.func && element.line && (element.func = UNKNOWN_FUNCTION), element.url && "blob:" === element.url.substr(0, 5)) {
2439 /** @type {!XMLHttpRequest} */
2440 var xhr = new XMLHttpRequest;
2441 if (xhr.open("GET", element.url, false), xhr.send(null), 200 === xhr.status) {
2442 /** @type {string} */
2443 var docstr = xhr.responseText || "";
2444 /** @type {string} */
2445 docstr = docstr.slice(-300);
2446 /** @type {(Array<string>|null)} */
2447 var y = docstr.match(/\/\/# sourceMappingURL=(.*)$/);
2448 if (y) {
2449 /** @type {string} */
2450 var ext = y[1];
2451 if ("~" === ext.charAt(0)) {
2452 /** @type {string} */
2453 ext = push() + ext.slice(1);
2454 }
2455 /** @type {string} */
2456 element.url = ext.slice(0, -4);
2457 }
2458 }
2459 }
2460 stack.push(element);
2461 }
2462 return stack.length ? {
2463 name : err.name,
2464 message : err.message,
2465 url : getLocationHref(),
2466 stack : stack
2467 } : null;
2468 }
2469 }
2470 /**
2471 * @param {!Object} stackInfo
2472 * @param {string} url
2473 * @param {string} lineNo
2474 * @param {?} message
2475 * @return {?}
2476 */
2477 function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {
2478 var initial = {
2479 url : url,
2480 line : lineNo
2481 };
2482 if (initial.url && initial.line) {
2483 if (stackInfo.incomplete = false, initial.func || (initial.func = UNKNOWN_FUNCTION), stackInfo.stack.length > 0 && stackInfo.stack[0].url === initial.url) {
2484 if (stackInfo.stack[0].line === initial.line) {
2485 return false;
2486 }
2487 if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {
2488 return stackInfo.stack[0].line = initial.line, false;
2489 }
2490 }
2491 return stackInfo.stack.unshift(initial), stackInfo.partial = true, true;
2492 }
2493 return stackInfo.incomplete = true, false;
2494 }
2495 /**
2496 * @param {!Error} ex
2497 * @param {number} depth
2498 * @return {?}
2499 */
2500 function computeStackTraceByWalkingCallerChain(ex, depth) {
2501 var parts;
2502 var item;
2503 /** @type {!RegExp} */
2504 var fullLinkRegex = /function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i;
2505 /** @type {!Array} */
2506 var stack = [];
2507 var funcs = {};
2508 /** @type {boolean} */
2509 var recursion = false;
2510 /** @type {(!Function|null)} */
2511 var curr = computeStackTraceByWalkingCallerChain.caller;
2512 for (; curr && !recursion; curr = curr.caller) {
2513 if (curr !== computeStackTrace && curr !== TraceKit.report) {
2514 if (item = {
2515 url : null,
2516 func : UNKNOWN_FUNCTION,
2517 line : null,
2518 column : null
2519 }, curr.name ? item.func = curr.name : (parts = fullLinkRegex.exec(curr.toString())) && (item.func = parts[1]), void 0 === item.func) {
2520 try {
2521 item.func = parts.input.substring(0, parts.input.indexOf("{"));
2522 } catch (t) {
2523 }
2524 }
2525 if (funcs["" + curr]) {
2526 /** @type {boolean} */
2527 recursion = true;
2528 } else {
2529 /** @type {boolean} */
2530 funcs["" + curr] = true;
2531 }
2532 stack.push(item);
2533 }
2534 }
2535 if (depth) {
2536 stack.splice(0, depth);
2537 }
2538 var result = {
2539 name : ex.name,
2540 message : ex.message,
2541 url : getLocationHref(),
2542 stack : stack
2543 };
2544 return augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description), result;
2545 }
2546 /**
2547 * @param {!Error} ex
2548 * @param {number} depth
2549 * @return {?}
2550 */
2551 function computeStackTrace(ex, depth) {
2552 /** @type {null} */
2553 var stack = null;
2554 /** @type {number} */
2555 depth = null == depth ? 0 : +depth;
2556 try {
2557 if (stack = get(ex)) {
2558 return stack;
2559 }
2560 } catch (t) {
2561 if (TraceKit.debug) {
2562 throw t;
2563 }
2564 }
2565 try {
2566 if (stack = computeStackTraceByWalkingCallerChain(ex, depth + 1)) {
2567 return stack;
2568 }
2569 } catch (t) {
2570 if (TraceKit.debug) {
2571 throw t;
2572 }
2573 }
2574 return {
2575 name : ex.name,
2576 message : ex.message,
2577 url : getLocationHref()
2578 };
2579 }
2580 return computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement, computeStackTrace.computeStackTraceFromStackProp = get, computeStackTrace;
2581 }();
2582 module.exports = TraceKit;
2583 }).call(media, $(0));
2584 },
2585 14 : function(data, defer_sort) {
2586 /**
2587 * @param {number} a
2588 * @param {number} b
2589 * @return {?}
2590 */
2591 function $(a, b) {
2592 /** @type {number} */
2593 var n = (65535 & a) + (65535 & b);
2594 return (a >> 16) + (b >> 16) + (n >> 16) << 16 | 65535 & n;
2595 }
2596 /**
2597 * @param {number} h
2598 * @param {number} l
2599 * @return {?}
2600 */
2601 function hslaToRgba(h, l) {
2602 return h << l | h >>> 32 - l;
2603 }
2604 /**
2605 * @param {number} t
2606 * @param {number} values
2607 * @param {number} obj
2608 * @param {number} target
2609 * @param {number} item
2610 * @param {number} props
2611 * @return {?}
2612 */
2613 function callback(t, values, obj, target, item, props) {
2614 return $(hslaToRgba($($(values, t), $(target, props)), item), obj);
2615 }
2616 /**
2617 * @param {number} m
2618 * @param {number} b
2619 * @param {number} c
2620 * @param {number} d
2621 * @param {undefined} row
2622 * @param {number} data
2623 * @param {number} i
2624 * @return {?}
2625 */
2626 function f(m, b, c, d, row, data, i) {
2627 return callback(b & c | ~b & d, m, b, row, data, i);
2628 }
2629 /**
2630 * @param {number} v
2631 * @param {number} d
2632 * @param {number} a
2633 * @param {number} b
2634 * @param {undefined} i
2635 * @param {number} data
2636 * @param {number} n
2637 * @return {?}
2638 */
2639 function d(v, d, a, b, i, data, n) {
2640 return callback(d & b | a & ~b, v, d, i, data, n);
2641 }
2642 /**
2643 * @param {number} v
2644 * @param {number} d
2645 * @param {number} a
2646 * @param {number} b
2647 * @param {undefined} i
2648 * @param {number} data
2649 * @param {number} n
2650 * @return {?}
2651 */
2652 function e(v, d, a, b, i, data, n) {
2653 return callback(d ^ a ^ b, v, d, i, data, n);
2654 }
2655 /**
2656 * @param {number} m
2657 * @param {number} d
2658 * @param {number} a
2659 * @param {number} b
2660 * @param {undefined} t
2661 * @param {number} i
2662 * @param {number} data
2663 * @return {?}
2664 */
2665 function g(m, d, a, b, t, i, data) {
2666 return callback(a ^ (d | ~b), m, d, t, i, data);
2667 }
2668 /**
2669 * @param {!Object} b
2670 * @param {number} a
2671 * @return {?}
2672 */
2673 function cb(b, a) {
2674 b[a >> 5] |= 128 << a % 32;
2675 /** @type {number} */
2676 b[14 + (a + 64 >>> 9 << 4)] = a;
2677 var i;
2678 var k;
2679 var res;
2680 var t;
2681 var c;
2682 /** @type {number} */
2683 var o = 1732584193;
2684 /** @type {number} */
2685 var p = -271733879;
2686 /** @type {number} */
2687 var m = -1732584194;
2688 /** @type {number} */
2689 var n = 271733878;
2690 /** @type {number} */
2691 i = 0;
2692 for (; i < b.length; i = i + 16) {
2693 k = o;
2694 res = p;
2695 t = m;
2696 c = n;
2697 o = f(o, p, m, n, b[i], 7, -680876936);
2698 n = f(n, o, p, m, b[i + 1], 12, -389564586);
2699 m = f(m, n, o, p, b[i + 2], 17, 606105819);
2700 p = f(p, m, n, o, b[i + 3], 22, -1044525330);
2701 o = f(o, p, m, n, b[i + 4], 7, -176418897);
2702 n = f(n, o, p, m, b[i + 5], 12, 1200080426);
2703 m = f(m, n, o, p, b[i + 6], 17, -1473231341);
2704 p = f(p, m, n, o, b[i + 7], 22, -45705983);
2705 o = f(o, p, m, n, b[i + 8], 7, 1770035416);
2706 n = f(n, o, p, m, b[i + 9], 12, -1958414417);
2707 m = f(m, n, o, p, b[i + 10], 17, -42063);
2708 p = f(p, m, n, o, b[i + 11], 22, -1990404162);
2709 o = f(o, p, m, n, b[i + 12], 7, 1804603682);
2710 n = f(n, o, p, m, b[i + 13], 12, -40341101);
2711 m = f(m, n, o, p, b[i + 14], 17, -1502002290);
2712 p = f(p, m, n, o, b[i + 15], 22, 1236535329);
2713 o = d(o, p, m, n, b[i + 1], 5, -165796510);
2714 n = d(n, o, p, m, b[i + 6], 9, -1069501632);
2715 m = d(m, n, o, p, b[i + 11], 14, 643717713);
2716 p = d(p, m, n, o, b[i], 20, -373897302);
2717 o = d(o, p, m, n, b[i + 5], 5, -701558691);
2718 n = d(n, o, p, m, b[i + 10], 9, 38016083);
2719 m = d(m, n, o, p, b[i + 15], 14, -660478335);
2720 p = d(p, m, n, o, b[i + 4], 20, -405537848);
2721 o = d(o, p, m, n, b[i + 9], 5, 568446438);
2722 n = d(n, o, p, m, b[i + 14], 9, -1019803690);
2723 m = d(m, n, o, p, b[i + 3], 14, -187363961);
2724 p = d(p, m, n, o, b[i + 8], 20, 1163531501);
2725 o = d(o, p, m, n, b[i + 13], 5, -1444681467);
2726 n = d(n, o, p, m, b[i + 2], 9, -51403784);
2727 m = d(m, n, o, p, b[i + 7], 14, 1735328473);
2728 p = d(p, m, n, o, b[i + 12], 20, -1926607734);
2729 o = e(o, p, m, n, b[i + 5], 4, -378558);
2730 n = e(n, o, p, m, b[i + 8], 11, -2022574463);
2731 m = e(m, n, o, p, b[i + 11], 16, 1839030562);
2732 p = e(p, m, n, o, b[i + 14], 23, -35309556);
2733 o = e(o, p, m, n, b[i + 1], 4, -1530992060);
2734 n = e(n, o, p, m, b[i + 4], 11, 1272893353);
2735 m = e(m, n, o, p, b[i + 7], 16, -155497632);
2736 p = e(p, m, n, o, b[i + 10], 23, -1094730640);
2737 o = e(o, p, m, n, b[i + 13], 4, 681279174);
2738 n = e(n, o, p, m, b[i], 11, -358537222);
2739 m = e(m, n, o, p, b[i + 3], 16, -722521979);
2740 p = e(p, m, n, o, b[i + 6], 23, 76029189);
2741 o = e(o, p, m, n, b[i + 9], 4, -640364487);
2742 n = e(n, o, p, m, b[i + 12], 11, -421815835);
2743 m = e(m, n, o, p, b[i + 15], 16, 530742520);
2744 p = e(p, m, n, o, b[i + 2], 23, -995338651);
2745 o = g(o, p, m, n, b[i], 6, -198630844);
2746 n = g(n, o, p, m, b[i + 7], 10, 1126891415);
2747 m = g(m, n, o, p, b[i + 14], 15, -1416354905);
2748 p = g(p, m, n, o, b[i + 5], 21, -57434055);
2749 o = g(o, p, m, n, b[i + 12], 6, 1700485571);
2750 n = g(n, o, p, m, b[i + 3], 10, -1894986606);
2751 m = g(m, n, o, p, b[i + 10], 15, -1051523);
2752 p = g(p, m, n, o, b[i + 1], 21, -2054922799);
2753 o = g(o, p, m, n, b[i + 8], 6, 1873313359);
2754 n = g(n, o, p, m, b[i + 15], 10, -30611744);
2755 m = g(m, n, o, p, b[i + 6], 15, -1560198380);
2756 p = g(p, m, n, o, b[i + 13], 21, 1309151649);
2757 o = g(o, p, m, n, b[i + 4], 6, -145523070);
2758 n = g(n, o, p, m, b[i + 11], 10, -1120210379);
2759 m = g(m, n, o, p, b[i + 2], 15, 718787259);
2760 p = g(p, m, n, o, b[i + 9], 21, -343485551);
2761 o = $(o, k);
2762 p = $(p, res);
2763 m = $(m, t);
2764 n = $(n, c);
2765 }
2766 return [o, p, m, n];
2767 }
2768 /**
2769 * @param {!Object} bin
2770 * @return {?}
2771 */
2772 function write(bin) {
2773 var i;
2774 /** @type {string} */
2775 var charStr = "";
2776 /** @type {number} */
2777 var inputsSize = 32 * bin.length;
2778 /** @type {number} */
2779 i = 0;
2780 for (; i < inputsSize; i = i + 8) {
2781 /** @type {string} */
2782 charStr = charStr + String.fromCharCode(bin[i >> 5] >>> i % 32 & 255);
2783 }
2784 return charStr;
2785 }
2786 /**
2787 * @param {string} t
2788 * @return {?}
2789 */
2790 function normalize(t) {
2791 var i;
2792 /** @type {!Array} */
2793 var array = [];
2794 array[(t.length >> 2) - 1] = void 0;
2795 /** @type {number} */
2796 i = 0;
2797 for (; i < array.length; i = i + 1) {
2798 /** @type {number} */
2799 array[i] = 0;
2800 }
2801 /** @type {number} */
2802 var cell_amount = 8 * t.length;
2803 /** @type {number} */
2804 i = 0;
2805 for (; i < cell_amount; i = i + 8) {
2806 array[i >> 5] |= (255 & t.charCodeAt(i / 8)) << i % 32;
2807 }
2808 return array;
2809 }
2810 /**
2811 * @param {string} x
2812 * @return {?}
2813 */
2814 function append(x) {
2815 return write(cb(normalize(x), 8 * x.length));
2816 }
2817 /**
2818 * @param {string} t
2819 * @param {string} e
2820 * @return {?}
2821 */
2822 function add(t, e) {
2823 var style;
2824 var result;
2825 var res = normalize(t);
2826 /** @type {!Array} */
2827 var $ = [];
2828 /** @type {!Array} */
2829 var types = [];
2830 $[15] = types[15] = void 0;
2831 if (res.length > 16) {
2832 res = cb(res, 8 * t.length);
2833 }
2834 /** @type {number} */
2835 style = 0;
2836 for (; style < 16; style = style + 1) {
2837 /** @type {number} */
2838 $[style] = 909522486 ^ res[style];
2839 /** @type {number} */
2840 types[style] = 1549556828 ^ res[style];
2841 }
2842 return result = cb($.concat(normalize(e)), 512 + 8 * e.length), write(cb(types.concat(result), 640));
2843 }
2844 /**
2845 * @param {string} param_hash
2846 * @return {?}
2847 */
2848 function resolve(param_hash) {
2849 var a;
2850 var i;
2851 /** @type {string} */
2852 var s = "0123456789abcdef";
2853 /** @type {string} */
2854 var value = "";
2855 /** @type {number} */
2856 i = 0;
2857 for (; i < param_hash.length; i = i + 1) {
2858 a = param_hash.charCodeAt(i);
2859 /** @type {string} */
2860 value = value + (s.charAt(a >>> 4 & 15) + s.charAt(15 & a));
2861 }
2862 return value;
2863 }
2864 /**
2865 * @param {?} name
2866 * @return {?}
2867 */
2868 function p(name) {
2869 return unescape(encodeURIComponent(name));
2870 }
2871 /**
2872 * @param {?} name
2873 * @return {?}
2874 */
2875 function raf(name) {
2876 return append(p(name));
2877 }
2878 /**
2879 * @param {?} func
2880 * @return {?}
2881 */
2882 function loop(func) {
2883 return resolve(raf(func));
2884 }
2885 /**
2886 * @param {?} s
2887 * @param {?} name
2888 * @return {?}
2889 */
2890 function isString(s, name) {
2891 return add(p(s), p(name));
2892 }
2893 /**
2894 * @param {?} url
2895 * @param {?} output
2896 * @return {?}
2897 */
2898 function find(url, output) {
2899 return resolve(isString(url, output));
2900 }
2901 /**
2902 * @param {?} callback
2903 * @param {?} selector
2904 * @param {?} context
2905 * @return {?}
2906 */
2907 function update(callback, selector, context) {
2908 return selector ? context ? isString(selector, callback) : find(selector, callback) : context ? raf(callback) : loop(callback);
2909 }
2910 /** @type {function(?, ?, ?): ?} */
2911 data.exports = update;
2912 },
2913 2 : function(clickRepeater, e, islongclick) {
2914 Object.defineProperty(e, "__esModule", {
2915 value : true
2916 });
2917 /** @type {string} */
2918 e.LOCAL_STORAGE_KEY = "pushpushgo";
2919 /** @type {string} */
2920 e.LOCAL_STORAGE_IDB_KEY = "pushpushgo-idb";
2921 /** @type {string} */
2922 e.LOGGER_LS_KEY = "logger_ppg";
2923 /** @type {number} */
2924 e.KEY_CODE_L = 76;
2925 /** @type {string} */
2926 e.RAVEN_DSN = "https://0a846115220444c9b7d6a2ef9e1589dc@sentry.io/270146";
2927 },
2928 3 : function(module, data, decode) {
2929 (function(e) {
2930 /**
2931 * @param {number} a
2932 * @return {?}
2933 */
2934 function isPlainObject(a) {
2935 return "object" == typeof a && null !== a;
2936 }
2937 /**
2938 * @param {!Object} obj
2939 * @return {?}
2940 */
2941 function isError(obj) {
2942 switch(Object.prototype.toString.call(obj)) {
2943 case "[object Error]":
2944 case "[object Exception]":
2945 case "[object DOMException]":
2946 return true;
2947 default:
2948 return obj instanceof Error;
2949 }
2950 }
2951 /**
2952 * @param {!Object} value
2953 * @return {?}
2954 */
2955 function validateBaseArgs(value) {
2956 return "[object ErrorEvent]" === Object.prototype.toString.call(value);
2957 }
2958 /**
2959 * @param {!Object} data
2960 * @return {?}
2961 */
2962 function recursiveStyle(data) {
2963 return "[object DOMError]" === Object.prototype.toString.call(data);
2964 }
2965 /**
2966 * @param {!Object} target
2967 * @return {?}
2968 */
2969 function isMutableObject(target) {
2970 return "[object DOMException]" === Object.prototype.toString.call(target);
2971 }
2972 /**
2973 * @param {?} obj
2974 * @return {?}
2975 */
2976 function isUndefined(obj) {
2977 return void 0 === obj;
2978 }
2979 /**
2980 * @param {!Function} fn
2981 * @return {?}
2982 */
2983 function isFunction(fn) {
2984 return "function" == typeof fn;
2985 }
2986 /**
2987 * @param {!Object} obj
2988 * @return {?}
2989 */
2990 function isObject(obj) {
2991 return "[object Object]" === Object.prototype.toString.call(obj);
2992 }
2993 /**
2994 * @param {!Object} str
2995 * @return {?}
2996 */
2997 function isString(str) {
2998 return "[object String]" === Object.prototype.toString.call(str);
2999 }
3000 /**
3001 * @param {!Object} value
3002 * @return {?}
3003 */
3004 function isArray(value) {
3005 return "[object Array]" === Object.prototype.toString.call(value);
3006 }
3007 /**
3008 * @param {!Object} obj
3009 * @return {?}
3010 */
3011 function isEmptyObject(obj) {
3012 if (!isObject(obj)) {
3013 return false;
3014 }
3015 var i;
3016 for (i in obj) {
3017 if (obj.hasOwnProperty(i)) {
3018 return false;
3019 }
3020 }
3021 return true;
3022 }
3023 /**
3024 * @return {?}
3025 */
3026 function factory() {
3027 try {
3028 return new ErrorEvent(""), true;
3029 } catch (t) {
3030 return false;
3031 }
3032 }
3033 /**
3034 * @return {?}
3035 */
3036 function jui_widget_exists() {
3037 try {
3038 return new DOMError(""), true;
3039 } catch (t) {
3040 return false;
3041 }
3042 }
3043 /**
3044 * @return {?}
3045 */
3046 function evaluate() {
3047 try {
3048 return new DOMException(""), true;
3049 } catch (t) {
3050 return false;
3051 }
3052 }
3053 /**
3054 * @return {?}
3055 */
3056 function get() {
3057 if (!("fetch" in _window)) {
3058 return false;
3059 }
3060 try {
3061 return new Headers, new Request(""), new Response, true;
3062 } catch (t) {
3063 return false;
3064 }
3065 }
3066 /**
3067 * @return {?}
3068 */
3069 function open() {
3070 if (!get()) {
3071 return false;
3072 }
3073 try {
3074 return new Request("pickleRick", {
3075 referrerPolicy : "origin"
3076 }), true;
3077 } catch (t) {
3078 return false;
3079 }
3080 }
3081 /**
3082 * @return {?}
3083 */
3084 function Function_define() {
3085 return "function" == typeof PromiseRejectionEvent;
3086 }
3087 /**
3088 * @param {?} label
3089 * @return {?}
3090 */
3091 function makeObject(label) {
3092 /**
3093 * @param {?} a
3094 * @param {?} v
3095 * @return {?}
3096 */
3097 function o(a, v) {
3098 var width = label(a) || a;
3099 return v ? v(width) || width : width;
3100 }
3101 return o;
3102 }
3103 /**
3104 * @param {?} obj
3105 * @param {!Function} fn
3106 * @return {undefined}
3107 */
3108 function each(obj, fn) {
3109 var i;
3110 var tableslen;
3111 if (isUndefined(obj.length)) {
3112 for (i in obj) {
3113 if (hasKey(obj, i)) {
3114 fn.call(null, i, obj[i]);
3115 }
3116 }
3117 } else {
3118 if (tableslen = obj.length) {
3119 /** @type {number} */
3120 i = 0;
3121 for (; i < tableslen; i++) {
3122 fn.call(null, i, obj[i]);
3123 }
3124 }
3125 }
3126 }
3127 /**
3128 * @param {?} obj1
3129 * @param {?} obj2
3130 * @return {?}
3131 */
3132 function objectMerge(obj1, obj2) {
3133 return obj2 ? (each(obj2, function(name, value) {
3134 obj1[name] = value;
3135 }), obj1) : obj1;
3136 }
3137 /**
3138 * @param {?} val
3139 * @return {?}
3140 */
3141 function isValid(val) {
3142 return !!Object.isFrozen && Object.isFrozen(val);
3143 }
3144 /**
3145 * @param {(Object|string)} str
3146 * @param {number} max
3147 * @return {?}
3148 */
3149 function truncate(str, max) {
3150 if ("number" != typeof max) {
3151 throw new Error("2nd argument to `truncate` function should be a number");
3152 }
3153 return "string" != typeof str || 0 === max ? str : str.length <= max ? str : str.substr(0, max) + "\u2026";
3154 }
3155 /**
3156 * @param {(!Function|string)} obj
3157 * @param {string} key
3158 * @return {?}
3159 */
3160 function hasKey(obj, key) {
3161 return Object.prototype.hasOwnProperty.call(obj, key);
3162 }
3163 /**
3164 * @param {!NodeList} value
3165 * @return {?}
3166 */
3167 function fn(value) {
3168 var p;
3169 /** @type {!Array} */
3170 var n = [];
3171 /** @type {number} */
3172 var k = 0;
3173 var i = value.length;
3174 for (; k < i; k++) {
3175 p = value[k];
3176 if (isString(p)) {
3177 n.push(p.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"));
3178 } else {
3179 if (p && p.source) {
3180 n.push(p.source);
3181 }
3182 }
3183 }
3184 return new RegExp(n.join("|"), "i");
3185 }
3186 /**
3187 * @param {?} value
3188 * @return {?}
3189 */
3190 function urlencode(value) {
3191 /** @type {!Array} */
3192 var drilldownLevelLabels = [];
3193 return each(value, function(qov, fileFullpath) {
3194 drilldownLevelLabels.push(encodeURIComponent(qov) + "=" + encodeURIComponent(fileFullpath));
3195 }), drilldownLevelLabels.join("&");
3196 }
3197 /**
3198 * @param {string} string
3199 * @return {?}
3200 */
3201 function parseUrl(string) {
3202 if ("string" != typeof string) {
3203 return {};
3204 }
3205 /** @type {(Array<string>|null)} */
3206 var match = string.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
3207 /** @type {string} */
3208 var query = match[6] || "";
3209 /** @type {string} */
3210 var fragment = match[8] || "";
3211 return {
3212 protocol : match[2],
3213 host : match[4],
3214 path : match[5],
3215 relative : match[5] + query + fragment
3216 };
3217 }
3218 /**
3219 * @return {?}
3220 */
3221 function uuid4() {
3222 var crypto = _window.crypto || _window.msCrypto;
3223 if (!isUndefined(crypto) && crypto.getRandomValues) {
3224 /** @type {!Uint16Array} */
3225 var array = new Uint16Array(8);
3226 crypto.getRandomValues(array);
3227 /** @type {number} */
3228 array[3] = 4095 & array[3] | 16384;
3229 /** @type {number} */
3230 array[4] = 16383 & array[4] | 32768;
3231 /**
3232 * @param {number} ch
3233 * @return {?}
3234 */
3235 var pad = function(ch) {
3236 var s = ch.toString(16);
3237 for (; s.length < 4;) {
3238 /** @type {string} */
3239 s = "0" + s;
3240 }
3241 return s;
3242 };
3243 return pad(array[0]) + pad(array[1]) + pad(array[2]) + pad(array[3]) + pad(array[4]) + pad(array[5]) + pad(array[6]) + pad(array[7]);
3244 }
3245 return "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(/[xy]/g, function(l) {
3246 /** @type {number} */
3247 var r = 16 * Math.random() | 0;
3248 return ("x" === l ? r : 3 & r | 8).toString(16);
3249 });
3250 }
3251 /**
3252 * @param {!Node} elem
3253 * @return {?}
3254 */
3255 function htmlTreeAsString(elem) {
3256 var nextStr;
3257 /** @type {!Array} */
3258 var out = [];
3259 /** @type {number} */
3260 var r = 0;
3261 /** @type {number} */
3262 var len = 0;
3263 /** @type {number} */
3264 var sepLength = " > ".length;
3265 for (; elem && r++ < 5 && !("html" === (nextStr = htmlElementAsString(elem)) || r > 1 && len + out.length * sepLength + nextStr.length >= 80);) {
3266 out.push(nextStr);
3267 len = len + nextStr.length;
3268 elem = elem.parentNode;
3269 }
3270 return out.reverse().join(" > ");
3271 }
3272 /**
3273 * @param {!Node} elem
3274 * @return {?}
3275 */
3276 function htmlElementAsString(elem) {
3277 var attr;
3278 var keywordResults;
3279 var key;
3280 var clearChatButton;
3281 var i;
3282 /** @type {!Array} */
3283 var a = [];
3284 if (!elem || !elem.tagName) {
3285 return "";
3286 }
3287 if (a.push(elem.tagName.toLowerCase()), elem.id && a.push("#" + elem.id), (attr = elem.className) && isString(attr)) {
3288 keywordResults = attr.split(/\s+/);
3289 /** @type {number} */
3290 i = 0;
3291 for (; i < keywordResults.length; i++) {
3292 a.push("." + keywordResults[i]);
3293 }
3294 }
3295 /** @type {!Array} */
3296 var attrWhitelist = ["type", "name", "title", "alt"];
3297 /** @type {number} */
3298 i = 0;
3299 for (; i < attrWhitelist.length; i++) {
3300 key = attrWhitelist[i];
3301 if (clearChatButton = elem.getAttribute(key)) {
3302 a.push("[" + key + '="' + clearChatButton + '"]');
3303 }
3304 }
3305 return a.join("");
3306 }
3307 /**
3308 * @param {!Object} e
3309 * @param {!Object} keys
3310 * @return {?}
3311 */
3312 function expect(e, keys) {
3313 return !!(!!e ^ !!keys);
3314 }
3315 /**
3316 * @param {?} value
3317 * @param {?} property
3318 * @return {?}
3319 */
3320 function handler(value, property) {
3321 return isUndefined(value) && isUndefined(property);
3322 }
3323 /**
3324 * @param {!Object} e
3325 * @param {!Object} data
3326 * @return {?}
3327 */
3328 function cb(e, data) {
3329 return !expect(e, data) && (e = e.values[0], data = data.values[0], e.type === data.type && e.value === data.value && (!handler(e.stacktrace, data.stacktrace) && run(e.stacktrace, data.stacktrace)));
3330 }
3331 /**
3332 * @param {!Object} context
3333 * @param {!Object} body
3334 * @return {?}
3335 */
3336 function run(context, body) {
3337 if (expect(context, body)) {
3338 return false;
3339 }
3340 var prev = context.frames;
3341 var next = body.frames;
3342 if (void 0 === prev || void 0 === next) {
3343 return false;
3344 }
3345 if (prev.length !== next.length) {
3346 return false;
3347 }
3348 var a;
3349 var b;
3350 /** @type {number} */
3351 var i = 0;
3352 for (; i < prev.length; i++) {
3353 if (a = prev[i], b = next[i], a.filename !== b.filename || a.lineno !== b.lineno || a.colno !== b.colno || a.function !== b.function) {
3354 return false;
3355 }
3356 }
3357 return true;
3358 }
3359 /**
3360 * @param {!Object} obj
3361 * @param {string} name
3362 * @param {!Function} replacement
3363 * @param {!Array} track
3364 * @return {undefined}
3365 */
3366 function fill(obj, name, replacement, track) {
3367 if (null != obj) {
3368 var orig = obj[name];
3369 obj[name] = replacement(orig);
3370 /** @type {boolean} */
3371 obj[name].__raven__ = true;
3372 obj[name].__orig__ = orig;
3373 if (track) {
3374 track.push([obj, name, orig]);
3375 }
3376 }
3377 }
3378 /**
3379 * @param {!Object} value
3380 * @param {string} arg
3381 * @return {?}
3382 */
3383 function compileSwitchStatement(value, arg) {
3384 if (!isArray(value)) {
3385 return "";
3386 }
3387 /** @type {!Array} */
3388 var argstrings = [];
3389 /** @type {number} */
3390 var i = 0;
3391 for (; i < value.length; i++) {
3392 try {
3393 argstrings.push(String(value[i]));
3394 } catch (t) {
3395 argstrings.push("[value cannot be serialized]");
3396 }
3397 }
3398 return argstrings.join(arg);
3399 }
3400 /**
3401 * @param {string} match
3402 * @return {?}
3403 */
3404 function fail(match) {
3405 return ~-encodeURI(match).split(/%..|./).length;
3406 }
3407 /**
3408 * @param {?} err
3409 * @return {?}
3410 */
3411 function next(err) {
3412 return fail(JSON.stringify(err));
3413 }
3414 /**
3415 * @param {?} value
3416 * @return {?}
3417 */
3418 function resolve(value) {
3419 if ("string" == typeof value) {
3420 return truncate(value, 40);
3421 }
3422 if ("number" == typeof value || "boolean" == typeof value || void 0 === value) {
3423 return value;
3424 }
3425 /** @type {string} */
3426 var number = Object.prototype.toString.call(value);
3427 return "[object Object]" === number ? "[Object]" : "[object Array]" === number ? "[Array]" : "[object Function]" === number ? value.name ? "[Function: " + value.name + "]" : "[Function]" : value;
3428 }
3429 /**
3430 * @param {!Object} tree
3431 * @param {number} a
3432 * @return {?}
3433 */
3434 function callback(tree, a) {
3435 return 0 === a ? resolve(tree) : isObject(tree) ? Object.keys(tree).reduce(function(results, i) {
3436 return results[i] = callback(tree[i], a - 1), results;
3437 }, {}) : Array.isArray(tree) ? tree.map(function(latestCommit) {
3438 return callback(latestCommit, a - 1);
3439 }) : resolve(tree);
3440 }
3441 /**
3442 * @param {!Object} value
3443 * @param {number} n
3444 * @param {number} a
3445 * @return {?}
3446 */
3447 function delay(value, n, a) {
3448 if (!isObject(value)) {
3449 return value;
3450 }
3451 /** @type {number} */
3452 n = "number" != typeof n ? max : n;
3453 a = "number" != typeof n ? previous : a;
3454 var element = callback(value, n);
3455 return next(getState(element)) > a ? delay(value, n - 1) : element;
3456 }
3457 /**
3458 * @param {!Object} data
3459 * @param {number} width
3460 * @return {?}
3461 */
3462 function apply(data, width) {
3463 if ("number" == typeof data || "string" == typeof data) {
3464 return data.toString();
3465 }
3466 if (!Array.isArray(data)) {
3467 return "";
3468 }
3469 if (data = data.filter(function(matchPart) {
3470 return "string" == typeof matchPart;
3471 }), 0 === data.length) {
3472 return "[object has no keys]";
3473 }
3474 if (width = "number" != typeof width ? opt_width : width, data[0].length >= width) {
3475 return data[0];
3476 }
3477 var count = data.length;
3478 for (; count > 0; count--) {
3479 var word = data.slice(0, count).join(", ");
3480 if (!(word.length > width)) {
3481 return count === data.length ? word : word + "\u2026";
3482 }
3483 }
3484 return "";
3485 }
3486 /**
3487 * @param {!Object} message
3488 * @param {!NodeList} value
3489 * @return {?}
3490 */
3491 function listener(message, value) {
3492 /**
3493 * @param {!Object} input
3494 * @return {?}
3495 */
3496 function callback(input) {
3497 return isArray(input) ? input.map(function(identifierPositions) {
3498 return callback(identifierPositions);
3499 }) : isObject(input) ? Object.keys(input).reduce(function(result, i) {
3500 return valid.test(i) ? result[i] = mergedElement : result[i] = callback(input[i]), result;
3501 }, {}) : input;
3502 }
3503 if (!isArray(value) || isArray(value) && 0 === value.length) {
3504 return message;
3505 }
3506 var credential_list;
3507 var valid = fn(value);
3508 /** @type {string} */
3509 var mergedElement = "********";
3510 try {
3511 /** @type {*} */
3512 credential_list = JSON.parse(getState(message));
3513 } catch (e) {
3514 return message;
3515 }
3516 return callback(credential_list);
3517 }
3518 var getState = decode(4);
3519 var _window = "undefined" != typeof window ? window : void 0 !== e ? e : "undefined" != typeof self ? self : {};
3520 /** @type {number} */
3521 var max = 3;
3522 /** @type {number} */
3523 var previous = 51200;
3524 /** @type {number} */
3525 var opt_width = 40;
3526 module.exports = {
3527 isObject : isPlainObject,
3528 isError : isError,
3529 isErrorEvent : validateBaseArgs,
3530 isDOMError : recursiveStyle,
3531 isDOMException : isMutableObject,
3532 isUndefined : isUndefined,
3533 isFunction : isFunction,
3534 isPlainObject : isObject,
3535 isString : isString,
3536 isArray : isArray,
3537 isEmptyObject : isEmptyObject,
3538 supportsErrorEvent : factory,
3539 supportsDOMError : jui_widget_exists,
3540 supportsDOMException : evaluate,
3541 supportsFetch : get,
3542 supportsReferrerPolicy : open,
3543 supportsPromiseRejectionEvent : Function_define,
3544 wrappedCallback : makeObject,
3545 each : each,
3546 objectMerge : objectMerge,
3547 truncate : truncate,
3548 objectFrozen : isValid,
3549 hasKey : hasKey,
3550 joinRegExp : fn,
3551 urlencode : urlencode,
3552 uuid4 : uuid4,
3553 htmlTreeAsString : htmlTreeAsString,
3554 htmlElementAsString : htmlElementAsString,
3555 isSameException : cb,
3556 isSameStacktrace : run,
3557 parseUrl : parseUrl,
3558 fill : fill,
3559 safeJoin : compileSwitchStatement,
3560 serializeException : delay,
3561 serializeKeysForMessage : apply,
3562 sanitize : listener
3563 };
3564 }).call(data, decode(0));
3565 },
3566 39 : function(clickRepeater, e, islongclick) {
3567 /**
3568 * @param {?} recB
3569 * @return {undefined}
3570 */
3571 function value(recB) {
3572 }
3573 Object.defineProperty(e, "__esModule", {
3574 value : true
3575 });
3576 /** @type {function(?): undefined} */
3577 e.errorHandler = value;
3578 },
3579 4 : function(module, exports) {
3580 /**
3581 * @param {!Array} b
3582 * @param {string} s
3583 * @return {?}
3584 */
3585 function indexOf(b, s) {
3586 /** @type {number} */
3587 var i = 0;
3588 for (; i < b.length; ++i) {
3589 if (b[i] === s) {
3590 return i;
3591 }
3592 }
3593 return -1;
3594 }
3595 /**
3596 * @param {?} value
3597 * @param {?} replacer
3598 * @param {?} spaces
3599 * @param {!Object} cycleReplacer
3600 * @return {?}
3601 */
3602 function stringify(value, replacer, spaces, cycleReplacer) {
3603 return JSON.stringify(value, serializer(replacer, cycleReplacer), spaces);
3604 }
3605 /**
3606 * @param {!Object} item
3607 * @return {?}
3608 */
3609 function serialize(item) {
3610 var msg = {
3611 stack : item.stack,
3612 message : item.message,
3613 name : item.name
3614 };
3615 var key;
3616 for (key in item) {
3617 if (Object.prototype.hasOwnProperty.call(item, key)) {
3618 msg[key] = item[key];
3619 }
3620 }
3621 return msg;
3622 }
3623 /**
3624 * @param {?} replacer
3625 * @param {!Object} cycleReplacer
3626 * @return {?}
3627 */
3628 function serializer(replacer, cycleReplacer) {
3629 /** @type {!Array} */
3630 var stack = [];
3631 /** @type {!Array} */
3632 var keys = [];
3633 return null == cycleReplacer && (cycleReplacer = function(key, value) {
3634 return stack[0] === value ? "[Circular ~]" : "[Circular ~." + keys.slice(0, indexOf(stack, value)).join(".") + "]";
3635 }), function(key, value) {
3636 if (stack.length > 0) {
3637 var index = indexOf(stack, this);
3638 if (~index) {
3639 stack.splice(index + 1);
3640 } else {
3641 stack.push(this);
3642 }
3643 if (~index) {
3644 keys.splice(index, 1 / 0, key);
3645 } else {
3646 keys.push(key);
3647 }
3648 if (~indexOf(stack, value)) {
3649 value = cycleReplacer.call(this, key, value);
3650 }
3651 } else {
3652 stack.push(value);
3653 }
3654 return null == replacer ? value instanceof Error ? serialize(value) : value : replacer.call(this, key, value);
3655 };
3656 }
3657 /** @type {function(?, ?, ?, !Object): ?} */
3658 exports = module.exports = stringify;
3659 /** @type {function(?, !Object): ?} */
3660 exports.getSerialize = serializer;
3661 },
3662 49 : function(depsLoaded, module, require) {
3663 /**
3664 * @param {!Object} data
3665 * @return {undefined}
3666 */
3667 function init(data) {
3668 /**
3669 * @param {!Object} options
3670 * @return {?}
3671 */
3672 function test(options) {
3673 return $.showNotification(options.title, {
3674 body : options.body,
3675 icon : options.icon,
3676 image : options.image,
3677 requireInteraction : options.requireInteraction,
3678 actions : options.actions,
3679 data : {
3680 actions : options.actions,
3681 redirectLink : options.redirectLink,
3682 id : options.id,
3683 sId : options.sId,
3684 channel : options.channel
3685 }
3686 });
3687 }
3688 /**
3689 * @param {!Object} options
3690 * @param {string} config
3691 * @return {?}
3692 */
3693 function create(options, config) {
3694 var requestToFetch = config && config.messageUrl || url + "/message";
3695 /** @type {!Object} */
3696 var setting = Object.assign({}, config, {
3697 version : data.version,
3698 campaign : config.campaign,
3699 endpoint : options.endpoint
3700 });
3701 return fetch(requestToFetch, {
3702 method : "post",
3703 headers : headers,
3704 body : JSON.stringify(setting)
3705 }).then(function(rawResp) {
3706 return rawResp.json();
3707 }).then(function(notifications) {
3708 return notifications = notifications.filter(function(canCreateDiscussions) {
3709 return canCreateDiscussions;
3710 }), notifications && 0 !== notifications.length || (notifications = [{
3711 title : post.title,
3712 body : post.content,
3713 redirectLink : post.redirectLink
3714 }]), Promise.all(notifications.map(test));
3715 }).catch(util.errorHandler);
3716 }
3717 console.log(config.RAVEN_DSN);
3718 Raven.config(config.RAVEN_DSN, _.getRavenOptions(data.version));
3719 console.log(Raven.config)
3720 var url = data.endpoint;
3721 var post = data.fallback;
3722 var headers = {
3723 Accept : "application/json",
3724 "Content-Type" : "application/json"
3725 };
3726 var clients = self.clients;
3727 console.log(self);
3728 console.log(clients);
3729 var $ = self.registration;
3730 try {
3731 self.addEventListener("install", function() {
3732 return self.skipWaiting();
3733 });
3734 self.addEventListener("push", function(event) {
3735 var methods = {};
3736 if (event.data) {
3737 try {
3738 methods = event.data.json();
3739 } catch (conv_reverse_sort) {
3740 methods = {};
3741 console.log(conv_reverse_sort);
3742 }
3743 }
3744 event.waitUntil(Promise.all([self.registration.pushManager.getSubscription().then(function(app) {
3745 return create(app, methods);
3746 })]));
3747 });
3748 self.addEventListener("notificationclick", function(e) {
3749 e.notification.close();
3750 var data = e.notification.data;
3751 var joiningClientId = data.id;
3752 var sId = data.sId;
3753 var chatId = data.channel;
3754 var imgUrl = data.redirectLink;
3755 var lines = data.actions;
3756 var action = e.action;
3757 var folder = _.first(_.filter(lines, function(defn) {
3758 return defn.action === action;
3759 }));
3760 if (joiningClientId) {
3761 fetch(url + "/message/click", {
3762 method : "post",
3763 headers : headers,
3764 body : JSON.stringify({
3765 id : joiningClientId,
3766 sId : sId,
3767 channel : chatId,
3768 aId : action
3769 })
3770 });
3771 }
3772 var url = folder && folder.link ? folder.link : imgUrl;
3773 e.waitUntil(clients.matchAll({
3774 type : "window"
3775 }).then(function(canCreateDiscussions) {
3776 /** @type {number} */
3777 var layer_i = 0;
3778 /** @type {!Object} */
3779 var crossfilterable_layers = canCreateDiscussions;
3780 for (; layer_i < crossfilterable_layers.length; layer_i++) {
3781 var client = crossfilterable_layers[layer_i];
3782 if (client.url === url && "focus" in client) {
3783 return client.focus();
3784 }
3785 }
3786 if (clients.openWindow) {
3787 return clients.openWindow(url);
3788 }
3789 }));
3790 });
3791 } catch (reason) {
3792 Raven.captureException(reason);
3793 }
3794 }
3795 Object.defineProperty(module, "__esModule", {
3796 value : true
3797 });
3798 var config = require(2);
3799 console.log(config);
3800 var util = require(39);
3801 console.log(util);
3802 var _ = require(1);
3803 var Raven = require(6);
3804 /** @type {function(!Object): undefined} */
3805 module.runWorker = init;
3806 },
3807 6 : function(module, level, n) {
3808 (function(e) {
3809 var end = n(12);
3810 var _window = "undefined" != typeof window ? window : void 0 !== e ? e : "undefined" != typeof self ? self : {};
3811 var _Raven = _window.Raven;
3812 var Raven = new end;
3813 /**
3814 * @return {?}
3815 */
3816 Raven.noConflict = function() {
3817 return _window.Raven = _Raven, Raven;
3818 };
3819 Raven.afterLoad();
3820 module.exports = Raven;
3821 module.exports.Client = end;
3822 }).call(level, n(0));
3823 },
3824 7 : function(module, level, generator) {
3825 (function(global) {
3826 /**
3827 * @param {string} object
3828 * @param {string} name
3829 * @return {?}
3830 */
3831 function getValue(object, name) {
3832 return null == object ? void 0 : object[name];
3833 }
3834 /**
3835 * @param {string} value
3836 * @return {?}
3837 */
3838 function isHostObject(value) {
3839 /** @type {boolean} */
3840 var result = false;
3841 if (null != value && "function" != typeof value.toString) {
3842 try {
3843 /** @type {boolean} */
3844 result = !!(value + "");
3845 } catch (t) {
3846 }
3847 }
3848 return result;
3849 }
3850 /**
3851 * @param {number} entries
3852 * @return {undefined}
3853 */
3854 function Hash(entries) {
3855 /** @type {number} */
3856 var i = -1;
3857 var length = entries ? entries.length : 0;
3858 this.clear();
3859 for (; ++i < length;) {
3860 var entry = entries[i];
3861 this.set(entry[0], entry[1]);
3862 }
3863 }
3864 /**
3865 * @return {undefined}
3866 */
3867 function hashClear() {
3868 this.__data__ = nativeCreate ? nativeCreate(null) : {};
3869 }
3870 /**
3871 * @param {!Object} key
3872 * @return {?}
3873 */
3874 function hashDelete$1(key) {
3875 return this.has(key) && delete this.__data__[key];
3876 }
3877 /**
3878 * @param {string} key
3879 * @return {?}
3880 */
3881 function hashGet(key) {
3882 var data = this.__data__;
3883 if (nativeCreate) {
3884 var type = data[key];
3885 return type === error ? void 0 : type;
3886 }
3887 return hasOwnProperty.call(data, key) ? data[key] : void 0;
3888 }
3889 /**
3890 * @param {!Object} key
3891 * @return {?}
3892 */
3893 function hashHas(key) {
3894 var data = this.__data__;
3895 return nativeCreate ? void 0 !== data[key] : hasOwnProperty.call(data, key);
3896 }
3897 /**
3898 * @param {?} name
3899 * @param {?} value
3900 * @return {?}
3901 */
3902 function mapSet(name, value) {
3903 return this.__data__[name] = nativeCreate && void 0 === value ? error : value, this;
3904 }
3905 /**
3906 * @param {number} entries
3907 * @return {undefined}
3908 */
3909 function ListCache(entries) {
3910 /** @type {number} */
3911 var i = -1;
3912 var length = entries ? entries.length : 0;
3913 this.clear();
3914 for (; ++i < length;) {
3915 var entry = entries[i];
3916 this.set(entry[0], entry[1]);
3917 }
3918 }
3919 /**
3920 * @return {undefined}
3921 */
3922 function stackClear() {
3923 /** @type {!Array} */
3924 this.__data__ = [];
3925 }
3926 /**
3927 * @param {boolean} key
3928 * @return {?}
3929 */
3930 function listCacheDelete(key) {
3931 var data = this.__data__;
3932 var index = assocIndexOf(data, key);
3933 return !(index < 0) && (index == data.length - 1 ? data.pop() : splice.call(data, index, 1), true);
3934 }
3935 /**
3936 * @param {string} key
3937 * @return {?}
3938 */
3939 function listCacheGet(key) {
3940 var data = this.__data__;
3941 var index = assocIndexOf(data, key);
3942 return index < 0 ? void 0 : data[index][1];
3943 }
3944 /**
3945 * @param {!Function} key
3946 * @return {?}
3947 */
3948 function listCacheHas(key) {
3949 return assocIndexOf(this.__data__, key) > -1;
3950 }
3951 /**
3952 * @param {?} key
3953 * @param {?} value
3954 * @return {?}
3955 */
3956 function listCacheSet(key, value) {
3957 var data = this.__data__;
3958 var index = assocIndexOf(data, key);
3959 return index < 0 ? data.push([key, value]) : data[index][1] = value, this;
3960 }
3961 /**
3962 * @param {number} entries
3963 * @return {undefined}
3964 */
3965 function MapCache(entries) {
3966 /** @type {number} */
3967 var i = -1;
3968 var length = entries ? entries.length : 0;
3969 this.clear();
3970 for (; ++i < length;) {
3971 var entry = entries[i];
3972 this.set(entry[0], entry[1]);
3973 }
3974 }
3975 /**
3976 * @return {undefined}
3977 */
3978 function mapCacheClear() {
3979 this.__data__ = {
3980 hash : new Hash,
3981 map : new (Map || ListCache),
3982 string : new Hash
3983 };
3984 }
3985 /**
3986 * @param {?} key
3987 * @return {?}
3988 */
3989 function del(key) {
3990 return getMapData(this, key).delete(key);
3991 }
3992 /**
3993 * @param {string} key
3994 * @return {?}
3995 */
3996 function mapCacheGet(key) {
3997 return getMapData(this, key).get(key);
3998 }
3999 /**
4000 * @param {!Object} key
4001 * @return {?}
4002 */
4003 function has(key) {
4004 return getMapData(this, key).has(key);
4005 }
4006 /**
4007 * @param {?} key
4008 * @param {?} value
4009 * @return {?}
4010 */
4011 function set(key, value) {
4012 return getMapData(this, key).set(key, value), this;
4013 }
4014 /**
4015 * @param {!Array} array
4016 * @param {string} key
4017 * @return {?}
4018 */
4019 function assocIndexOf(array, key) {
4020 var length = array.length;
4021 for (; length--;) {
4022 if (eq(array[length][0], key)) {
4023 return length;
4024 }
4025 }
4026 return -1;
4027 }
4028 /**
4029 * @param {!Object} object
4030 * @param {string} path
4031 * @return {?}
4032 */
4033 function get(object, path) {
4034 path = isKey(path, object) ? [path] : castPath(path);
4035 /** @type {number} */
4036 var i = 0;
4037 var l = path.length;
4038 for (; null != object && i < l;) {
4039 object = object[toKey(path[i++])];
4040 }
4041 return i && i == l ? object : void 0;
4042 }
4043 /**
4044 * @param {string} value
4045 * @return {?}
4046 */
4047 function isNative(value) {
4048 return !(!isObject(value) || isObjectLike(value)) && (isFunction(value) || isHostObject(value) ? reIsNative : regex).test(toSource(value));
4049 }
4050 /**
4051 * @param {number} value
4052 * @return {?}
4053 */
4054 function number(value) {
4055 if ("string" == typeof value) {
4056 return value;
4057 }
4058 if (test(value)) {
4059 return symbolToString ? symbolToString.call(value) : "";
4060 }
4061 /** @type {string} */
4062 var port = value + "";
4063 return "0" == port && 1 / value == -Infinity ? "-0" : port;
4064 }
4065 /**
4066 * @param {string} value
4067 * @return {?}
4068 */
4069 function castPath(value) {
4070 return isArray(value) ? value : stringToPath(value);
4071 }
4072 /**
4073 * @param {!Object} value
4074 * @param {!Object} key
4075 * @return {?}
4076 */
4077 function getMapData(value, key) {
4078 var data = value.__data__;
4079 return isKeyable(key) ? data["string" == typeof key ? "string" : "hash"] : data.map;
4080 }
4081 /**
4082 * @param {!Function} object
4083 * @param {string} key
4084 * @return {?}
4085 */
4086 function getNative(object, key) {
4087 var value = getValue(object, key);
4088 return isNative(value) ? value : void 0;
4089 }
4090 /**
4091 * @param {?} value
4092 * @param {!Object} object
4093 * @return {?}
4094 */
4095 function isKey(value, object) {
4096 if (isArray(value)) {
4097 return false;
4098 }
4099 /** @type {string} */
4100 var t = typeof value;
4101 return !("number" != t && "symbol" != t && "boolean" != t && null != value && !test(value)) || (contribRegex.test(value) || !trueRE.test(value) || null != object && value in Object(object));
4102 }
4103 /**
4104 * @param {!Object} value
4105 * @return {?}
4106 */
4107 function isKeyable(value) {
4108 /** @type {string} */
4109 var type = typeof value;
4110 return "string" == type || "number" == type || "symbol" == type || "boolean" == type ? "__proto__" !== value : null === value;
4111 }
4112 /**
4113 * @param {string} value
4114 * @return {?}
4115 */
4116 function isObjectLike(value) {
4117 return !!metadataPropertyName && metadataPropertyName in value;
4118 }
4119 /**
4120 * @param {number} key
4121 * @return {?}
4122 */
4123 function toKey(key) {
4124 if ("string" == typeof key || test(key)) {
4125 return key;
4126 }
4127 /** @type {string} */
4128 var keyString = key + "";
4129 return "0" == keyString && 1 / key == -Infinity ? "-0" : keyString;
4130 }
4131 /**
4132 * @param {string} func
4133 * @return {?}
4134 */
4135 function toSource(func) {
4136 if (null != func) {
4137 try {
4138 return funcToString.call(func);
4139 } catch (t) {
4140 }
4141 try {
4142 return func + "";
4143 } catch (t) {
4144 }
4145 }
4146 return "";
4147 }
4148 /**
4149 * @param {!Function} callback
4150 * @param {!Function} fn
4151 * @return {?}
4152 */
4153 function memoize(callback, fn) {
4154 if ("function" != typeof callback || fn && "function" != typeof fn) {
4155 throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
4156 }
4157 /**
4158 * @return {?}
4159 */
4160 var memoized = function() {
4161 /** @type {!Arguments} */
4162 var value = arguments;
4163 var key = fn ? fn.apply(this, value) : value[0];
4164 var cache = memoized.cache;
4165 if (cache.has(key)) {
4166 return cache.get(key);
4167 }
4168 var result = callback.apply(this, value);
4169 return memoized.cache = cache.set(key, result), result;
4170 };
4171 return memoized.cache = new (memoize.Cache || MapCache), memoized;
4172 }
4173 /**
4174 * @param {string} value
4175 * @param {string} other
4176 * @return {?}
4177 */
4178 function eq(value, other) {
4179 return value === other || value !== value && other !== other;
4180 }
4181 /**
4182 * @param {string} obj
4183 * @return {?}
4184 */
4185 function isFunction(obj) {
4186 var scale = isObject(obj) ? toString.call(obj) : "";
4187 return scale == box || scale == K;
4188 }
4189 /**
4190 * @param {string} o
4191 * @return {?}
4192 */
4193 function isObject(o) {
4194 /** @type {string} */
4195 var tp = typeof o;
4196 return !!o && ("object" == tp || "function" == tp);
4197 }
4198 /**
4199 * @param {?} val
4200 * @return {?}
4201 */
4202 function isNumber(val) {
4203 return !!val && "object" == typeof val;
4204 }
4205 /**
4206 * @param {?} x
4207 * @return {?}
4208 */
4209 function test(x) {
4210 return "symbol" == typeof x || isNumber(x) && toString.call(x) == o;
4211 }
4212 /**
4213 * @param {?} value
4214 * @return {?}
4215 */
4216 function dropVowels(value) {
4217 return null == value ? "" : number(value);
4218 }
4219 /**
4220 * @param {!Object} val
4221 * @param {string} name
4222 * @param {number} a
4223 * @return {?}
4224 */
4225 function obj(val, name, a) {
4226 var b = null == val ? void 0 : get(val, name);
4227 return void 0 === b ? a : b;
4228 }
4229 /** @type {string} */
4230 var ERR_ACCESSORS_NOT_SUPPORTED = "Expected a function";
4231 /** @type {string} */
4232 var error = "__lodash_hash_undefined__";
4233 /** @type {number} */
4234 var Infinity = 1 / 0;
4235 /** @type {string} */
4236 var box = "[object Function]";
4237 /** @type {string} */
4238 var K = "[object GeneratorFunction]";
4239 /** @type {string} */
4240 var o = "[object Symbol]";
4241 /** @type {!RegExp} */
4242 var trueRE = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
4243 /** @type {!RegExp} */
4244 var contribRegex = /^\w*$/;
4245 /** @type {!RegExp} */
4246 var r_hasNonAlphanumericCharacter = /^\./;
4247 /** @type {!RegExp} */
4248 var reTrimSpaces = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
4249 /** @type {!RegExp} */
4250 var savedRegExp = /[\\^$.*+?()[\]{}|]/g;
4251 /** @type {!RegExp} */
4252 var reEscapeChar = /\\(\\)?/g;
4253 /** @type {!RegExp} */
4254 var regex = /^\[object .+?Constructor\]$/;
4255 var freeGlobal = "object" == typeof global && global && global.Object === Object && global;
4256 /** @type {(Window|boolean)} */
4257 var freeSelf = "object" == typeof self && self && self.Object === Object && self;
4258 var root = freeGlobal || freeSelf || Function("return this")();
4259 var array = Array.prototype;
4260 var funcProto = Function.prototype;
4261 var ObjProto = Object.prototype;
4262 var coreJsData = root["__core-js_shared__"];
4263 var metadataPropertyName = function() {
4264 /** @type {(Array<string>|null)} */
4265 var mixElem = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
4266 return mixElem ? "Symbol(src)_1." + mixElem : "";
4267 }();
4268 /** @type {function(this:!Function): string} */
4269 var funcToString = funcProto.toString;
4270 var hasOwnProperty = ObjProto.hasOwnProperty;
4271 var toString = ObjProto.toString;
4272 /** @type {!RegExp} */
4273 var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(savedRegExp, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
4274 var Symbol = root.Symbol;
4275 /** @type {function(this:IArrayLike<T>, *=, *=, ...T): !Array<T>} */
4276 var splice = array.splice;
4277 var Map = getNative(root, "Map");
4278 var nativeCreate = getNative(Object, "create");
4279 var symbolProto = Symbol ? Symbol.prototype : void 0;
4280 var symbolToString = symbolProto ? symbolProto.toString : void 0;
4281 /** @type {function(): undefined} */
4282 Hash.prototype.clear = hashClear;
4283 /** @type {function(!Object): ?} */
4284 Hash.prototype.delete = hashDelete$1;
4285 /** @type {function(string): ?} */
4286 Hash.prototype.get = hashGet;
4287 /** @type {function(!Object): ?} */
4288 Hash.prototype.has = hashHas;
4289 /** @type {function(?, ?): ?} */
4290 Hash.prototype.set = mapSet;
4291 /** @type {function(): undefined} */
4292 ListCache.prototype.clear = stackClear;
4293 /** @type {function(boolean): ?} */
4294 ListCache.prototype.delete = listCacheDelete;
4295 /** @type {function(string): ?} */
4296 ListCache.prototype.get = listCacheGet;
4297 /** @type {function(!Function): ?} */
4298 ListCache.prototype.has = listCacheHas;
4299 /** @type {function(?, ?): ?} */
4300 ListCache.prototype.set = listCacheSet;
4301 /** @type {function(): undefined} */
4302 MapCache.prototype.clear = mapCacheClear;
4303 /** @type {function(?): ?} */
4304 MapCache.prototype.delete = del;
4305 /** @type {function(string): ?} */
4306 MapCache.prototype.get = mapCacheGet;
4307 /** @type {function(!Object): ?} */
4308 MapCache.prototype.has = has;
4309 /** @type {function(?, ?): ?} */
4310 MapCache.prototype.set = set;
4311 var stringToPath = memoize(function(token) {
4312 token = dropVowels(token);
4313 /** @type {!Array} */
4314 var pathArray = [];
4315 return r_hasNonAlphanumericCharacter.test(token) && pathArray.push(""), token.replace(reTrimSpaces, function(match, number, quote, string) {
4316 pathArray.push(quote ? string.replace(reEscapeChar, "$1") : number || match);
4317 }), pathArray;
4318 });
4319 /** @type {function(number): undefined} */
4320 memoize.Cache = MapCache;
4321 /** @type {function(*): boolean} */
4322 var isArray = Array.isArray;
4323 /** @type {function(!Object, string, number): ?} */
4324 module.exports = obj;
4325 }).call(level, generator(0));
4326 }
4327 });
4328 /*
4329 flock.worker.runWorker({
4330 "endpoint" : "https://api.pushpushgo.com",
4331 "version" : "5ce3b69196128f000bf99c07",
4332 "fallback" : {
4333 "title" : "",
4334 "content" : "",
4335 "redirectLink" : "https://mcdonalds.pl"
4336 }
4337 });
4338 */
4339
4340 flock.worker.runWorker({
4341 "endpoint" : "https://127.0.0.1",
4342 "version" : "5ce3b69196128f000bf99c07",
4343 "fallback" : {
4344 "title" : "",
4345 "content" : "",
4346 "redirectLink" : "https://mcdonalds.pl"
4347 }
4348 });
4349 return flock.worker;
4350 //console.log(flock.worker.runWorker({})); //przy uruchamianiu z nodejs
4351 //work.runWorker(config); - przy uruchamianiu z konsoli przegladarki + configu powyzej w zmiennej config
4352})();