API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 29th, 2018
1,674
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 258.19 KB | None | 0 0
raw download clone embed print report
  1. 'use strict';
  2. !function() {
  3. /**
  4. * @param {!Object} t
  5. * @param {!Object} n
  6. * @param {!NodeList} r
  7. * @return {?}
  8. */
  9. function e(t, n, r) {
  10. /**
  11. * @param {string} o
  12. * @param {?} s
  13. * @return {?}
  14. */
  15. function s(o, s) {
  16. if (!n[o]) {
  17. if (!t[o]) {
  18. var i = "function" == typeof require && require;
  19. if (!s && i) {
  20. return i(o, true);
  21. }
  22. if (a) {
  23. return a(o, true);
  24. }
  25. /** @type {!Error} */
  26. var f = new Error("Cannot find module '" + o + "'");
  27. throw f.code = "MODULE_NOT_FOUND", f;
  28. }
  29. var u = n[o] = {
  30. exports : {}
  31. };
  32. t[o][0].call(u.exports, function(e) {
  33. var n = t[o][1][e];
  34. return s(n ? n : e);
  35. }, u, u.exports, e, t, n, r);
  36. }
  37. return n[o].exports;
  38. }
  39. var a = "function" == typeof require && require;
  40. /** @type {number} */
  41. var o = 0;
  42. for (; o < r.length; o++) {
  43. s(r[o]);
  44. }
  45. return s;
  46. }
  47. return e;
  48. }()({
  49. 1 : [function(canCreateDiscussions, value, n) {
  50. !function(global, factory) {
  51. if ("object" == typeof value && "object" == typeof value.exports) {
  52. value.exports = global.document ? factory(global, true) : function(global) {
  53. if (!global.document) {
  54. throw new Error("jQuery requires a window with a document");
  55. }
  56. return factory(global);
  57. };
  58. } else {
  59. factory(global);
  60. }
  61. }("undefined" != typeof window ? window : this, function(window, zoomAware) {
  62. /**
  63. * @param {string} item
  64. * @param {!Object} doc
  65. * @return {undefined}
  66. */
  67. function test(item, doc) {
  68. doc = doc || document;
  69. var e = doc.createElement("script");
  70. /** @type {string} */
  71. e.text = item;
  72. doc.head.appendChild(e).parentNode.removeChild(e);
  73. }
  74. /**
  75. * @param {!Object} obj
  76. * @return {?}
  77. */
  78. function isArrayLike(obj) {
  79. var length = !!obj && "length" in obj && obj.length;
  80. var ltype = jQuery.type(obj);
  81. return "function" !== ltype && !jQuery.isWindow(obj) && ("array" === ltype || 0 === length || "number" == typeof length && length > 0 && length - 1 in obj);
  82. }
  83. /**
  84. * @param {!Object} elements
  85. * @param {!Object} qualifier
  86. * @param {boolean} not
  87. * @return {?}
  88. */
  89. function winnow(elements, qualifier, not) {
  90. if (jQuery.isFunction(qualifier)) {
  91. return jQuery.grep(elements, function(elem, i) {
  92. return !!qualifier.call(elem, i, elem) !== not;
  93. });
  94. }
  95. if (qualifier.nodeType) {
  96. return jQuery.grep(elements, function(elem) {
  97. return elem === qualifier !== not;
  98. });
  99. }
  100. if ("string" == typeof qualifier) {
  101. if (risSimple.test(qualifier)) {
  102. return jQuery.filter(qualifier, elements, not);
  103. }
  104. qualifier = jQuery.filter(qualifier, elements);
  105. }
  106. return jQuery.grep(elements, function(selector) {
  107. return indexOf.call(qualifier, selector) > -1 !== not && 1 === selector.nodeType;
  108. });
  109. }
  110. /**
  111. * @param {(Array|Element)} cur
  112. * @param {number} dir
  113. * @return {?}
  114. */
  115. function sibling(cur, dir) {
  116. for (; (cur = cur[dir]) && 1 !== cur.nodeType;) {
  117. }
  118. return cur;
  119. }
  120. /**
  121. * @param {string} options
  122. * @return {?}
  123. */
  124. function createOptions(options) {
  125. var subwikiListsCache = {};
  126. return jQuery.each(options.match(rnotwhite) || [], function(canCreateDiscussions, wikiId) {
  127. /** @type {boolean} */
  128. subwikiListsCache[wikiId] = true;
  129. }), subwikiListsCache;
  130. }
  131. /**
  132. * @param {?} b
  133. * @return {?}
  134. */
  135. function x(b) {
  136. return b;
  137. }
  138. /**
  139. * @param {?} state
  140. * @return {?}
  141. */
  142. function undefined(state) {
  143. throw state;
  144. }
  145. /**
  146. * @param {!Object} response
  147. * @param {!Function} handler
  148. * @param {!Function} method
  149. * @return {undefined}
  150. */
  151. function when(response, handler, method) {
  152. var value;
  153. try {
  154. if (response && jQuery.isFunction(value = response.promise)) {
  155. value.call(response).done(handler).fail(method);
  156. } else {
  157. if (response && jQuery.isFunction(value = response.then)) {
  158. value.call(response, handler, method);
  159. } else {
  160. handler.call(void 0, response);
  161. }
  162. }
  163. } catch (mockInnerStates) {
  164. method.call(void 0, mockInnerStates);
  165. }
  166. }
  167. /**
  168. * @return {undefined}
  169. */
  170. function $__jsx_onload() {
  171. document.removeEventListener("DOMContentLoaded", $__jsx_onload);
  172. window.removeEventListener("load", $__jsx_onload);
  173. jQuery.ready();
  174. }
  175. /**
  176. * @return {undefined}
  177. */
  178. function Data() {
  179. this.expando = jQuery.expando + Data.uid++;
  180. }
  181. /**
  182. * @param {!Object} value
  183. * @param {!Object} target
  184. * @param {?} data
  185. * @return {?}
  186. */
  187. function set(value, target, data) {
  188. var key;
  189. if (void 0 === data && 1 === value.nodeType) {
  190. if (key = "data-" + target.replace(rhyphen, "-$&").toLowerCase(), data = value.getAttribute(key), "string" == typeof data) {
  191. try {
  192. /** @type {*} */
  193. data = "true" === data || "false" !== data && ("null" === data ? null : +data + "" === data ? +data : JSON_START.test(data) ? JSON.parse(data) : data);
  194. } catch (e) {
  195. }
  196. $.set(value, target, data);
  197. } else {
  198. data = void 0;
  199. }
  200. }
  201. return data;
  202. }
  203. /**
  204. * @param {string} elem
  205. * @param {string} prop
  206. * @param {string} valueParts
  207. * @param {!Object} tween
  208. * @return {?}
  209. */
  210. function adjustCSS(elem, prop, valueParts, tween) {
  211. var adjusted;
  212. /** @type {number} */
  213. var scale = 1;
  214. /** @type {number} */
  215. var a = 20;
  216. /** @type {function(): ?} */
  217. var currentValue = tween ? function() {
  218. return tween.cur();
  219. } : function() {
  220. return jQuery.css(elem, prop, "");
  221. };
  222. var initial = currentValue();
  223. var unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px");
  224. var initialInUnit = (jQuery.cssNumber[prop] || "px" !== unit && +initial) && regex.exec(jQuery.css(elem, prop));
  225. if (initialInUnit && initialInUnit[3] !== unit) {
  226. unit = unit || initialInUnit[3];
  227. valueParts = valueParts || [];
  228. /** @type {number} */
  229. initialInUnit = +initial || 1;
  230. do {
  231. /** @type {(number|string)} */
  232. scale = scale || ".5";
  233. /** @type {number} */
  234. initialInUnit = initialInUnit / scale;
  235. jQuery.style(elem, prop, initialInUnit + unit);
  236. } while (scale !== (scale = currentValue() / initial) && 1 !== scale && --a);
  237. }
  238. return valueParts && (initialInUnit = +initialInUnit || +initial || 0, adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2], tween && (tween.unit = unit, tween.start = initialInUnit, tween.end = adjusted)), adjusted;
  239. }
  240. /**
  241. * @param {!Node} elem
  242. * @return {?}
  243. */
  244. function getDefaultDisplay(elem) {
  245. var div;
  246. var doc = elem.ownerDocument;
  247. var nodeName = elem.nodeName;
  248. var display = defaultDisplayMap[nodeName];
  249. return display ? display : (div = doc.body.appendChild(doc.createElement(nodeName)), display = jQuery.css(div, "display"), div.parentNode.removeChild(div), "none" === display && (display = "block"), defaultDisplayMap[nodeName] = display, display);
  250. }
  251. /**
  252. * @param {!Array} elements
  253. * @param {boolean} options
  254. * @return {?}
  255. */
  256. function showHide(elements, options) {
  257. var display;
  258. var elem;
  259. /** @type {!Array} */
  260. var values = [];
  261. /** @type {number} */
  262. var index = 0;
  263. var length = elements.length;
  264. for (; index < length; index++) {
  265. elem = elements[index];
  266. if (elem.style) {
  267. display = elem.style.display;
  268. if (options) {
  269. if ("none" === display) {
  270. values[index] = dataPriv.get(elem, "display") || null;
  271. if (!values[index]) {
  272. /** @type {string} */
  273. elem.style.display = "";
  274. }
  275. }
  276. if ("" === elem.style.display && isHidden(elem)) {
  277. values[index] = getDefaultDisplay(elem);
  278. }
  279. } else {
  280. if ("none" !== display) {
  281. /** @type {string} */
  282. values[index] = "none";
  283. dataPriv.set(elem, "display", display);
  284. }
  285. }
  286. }
  287. }
  288. /** @type {number} */
  289. index = 0;
  290. for (; index < length; index++) {
  291. if (null != values[index]) {
  292. elements[index].style.display = values[index];
  293. }
  294. }
  295. return elements;
  296. }
  297. /**
  298. * @param {!Object} context
  299. * @param {number} tag
  300. * @return {?}
  301. */
  302. function getAll(context, tag) {
  303. var n = "undefined" != typeof context.getElementsByTagName ? context.getElementsByTagName(tag || "*") : "undefined" != typeof context.querySelectorAll ? context.querySelectorAll(tag || "*") : [];
  304. return void 0 === tag || tag && jQuery.nodeName(context, tag) ? jQuery.merge([context], n) : n;
  305. }
  306. /**
  307. * @param {number} elems
  308. * @param {!NodeList} refElements
  309. * @return {undefined}
  310. */
  311. function setGlobalEval(elems, refElements) {
  312. /** @type {number} */
  313. var i = 0;
  314. var length = elems.length;
  315. for (; i < length; i++) {
  316. dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
  317. }
  318. }
  319. /**
  320. * @param {!Array} elems
  321. * @param {!Object} context
  322. * @param {string} result
  323. * @param {!Object} element
  324. * @param {!Object} ignored
  325. * @return {?}
  326. */
  327. function buildFragment(elems, context, result, element, ignored) {
  328. var elem;
  329. var tmp;
  330. var tag;
  331. var wrap;
  332. var ret;
  333. var j;
  334. var fragment = context.createDocumentFragment();
  335. /** @type {!Array} */
  336. var results = [];
  337. /** @type {number} */
  338. var i = 0;
  339. var length = elems.length;
  340. for (; i < length; i++) {
  341. if (elem = elems[i], elem || 0 === elem) {
  342. if ("object" === jQuery.type(elem)) {
  343. jQuery.merge(results, elem.nodeType ? [elem] : elem);
  344. } else {
  345. if (re_commas.test(elem)) {
  346. tmp = tmp || fragment.appendChild(context.createElement("div"));
  347. tag = (fullLinkRegex.exec(elem) || ["", ""])[1].toLowerCase();
  348. wrap = wrapMap[tag] || wrapMap._default;
  349. tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];
  350. j = wrap[0];
  351. for (; j--;) {
  352. tmp = tmp.lastChild;
  353. }
  354. jQuery.merge(results, tmp.childNodes);
  355. tmp = fragment.firstChild;
  356. /** @type {string} */
  357. tmp.textContent = "";
  358. } else {
  359. results.push(context.createTextNode(elem));
  360. }
  361. }
  362. }
  363. }
  364. /** @type {string} */
  365. fragment.textContent = "";
  366. /** @type {number} */
  367. i = 0;
  368. for (; elem = results[i++];) {
  369. if (element && jQuery.inArray(elem, element) > -1) {
  370. if (ignored) {
  371. ignored.push(elem);
  372. }
  373. } else {
  374. if (ret = jQuery.contains(elem.ownerDocument, elem), tmp = getAll(fragment.appendChild(elem), "script"), ret && setGlobalEval(tmp), result) {
  375. /** @type {number} */
  376. j = 0;
  377. for (; elem = tmp[j++];) {
  378. if (opacityRe.test(elem.type || "")) {
  379. result.push(elem);
  380. }
  381. }
  382. }
  383. }
  384. }
  385. return fragment;
  386. }
  387. /**
  388. * @return {?}
  389. */
  390. function returnTrue() {
  391. return true;
  392. }
  393. /**
  394. * @return {?}
  395. */
  396. function returnFalse() {
  397. return false;
  398. }
  399. /**
  400. * @return {?}
  401. */
  402. function safeActiveElement() {
  403. try {
  404. return document.activeElement;
  405. } catch (e) {
  406. }
  407. }
  408. /**
  409. * @param {!Object} el
  410. * @param {string} t
  411. * @param {!Object} value
  412. * @param {!Node} name
  413. * @param {!Node} callback
  414. * @param {number} download
  415. * @return {?}
  416. */
  417. function attach(el, t, value, name, callback, download) {
  418. var handler;
  419. var tb;
  420. if ("object" == typeof t) {
  421. if ("string" != typeof value) {
  422. name = name || value;
  423. value = void 0;
  424. }
  425. for (tb in t) {
  426. attach(el, tb, value, name, t[tb], download);
  427. }
  428. return el;
  429. }
  430. if (null == name && null == callback ? (callback = value, name = value = void 0) : null == callback && ("string" == typeof value ? (callback = name, name = void 0) : (callback = name, name = value, value = void 0)), callback === false) {
  431. /** @type {function(): ?} */
  432. callback = returnFalse;
  433. } else {
  434. if (!callback) {
  435. return el;
  436. }
  437. }
  438. return 1 === download && (handler = callback, callback = function(type) {
  439. return jQuery().off(type), handler.apply(this, arguments);
  440. }, callback.guid = handler.guid || (handler.guid = jQuery.guid++)), el.each(function() {
  441. jQuery.event.add(this, t, callback, name, value);
  442. });
  443. }
  444. /**
  445. * @param {!Object} elem
  446. * @param {!Element} content
  447. * @return {?}
  448. */
  449. function manipulationTarget(elem, content) {
  450. return jQuery.nodeName(elem, "table") && jQuery.nodeName(11 !== content.nodeType ? content : content.firstChild, "tr") ? elem.getElementsByTagName("tbody")[0] || elem : elem;
  451. }
  452. /**
  453. * @param {!Element} elem
  454. * @return {?}
  455. */
  456. function text(elem) {
  457. return elem.type = (null !== elem.getAttribute("type")) + "/" + elem.type, elem;
  458. }
  459. /**
  460. * @param {!Object} e
  461. * @return {?}
  462. */
  463. function createGeneNameGenomicState(e) {
  464. /** @type {(Array<string>|null)} */
  465. var params = receivedOpenEvents.exec(e.type);
  466. return params ? e.type = params[1] : e.removeAttribute("type"), e;
  467. }
  468. /**
  469. * @param {boolean} node
  470. * @param {!Object} elem
  471. * @return {undefined}
  472. */
  473. function cloneCopyEvent(node, elem) {
  474. var i;
  475. var tableslen;
  476. var host;
  477. var handle;
  478. var elemData;
  479. var p;
  480. var token;
  481. var data;
  482. if (1 === elem.nodeType) {
  483. if (dataPriv.hasData(node) && (handle = dataPriv.access(node), elemData = dataPriv.set(elem, handle), data = handle.events)) {
  484. delete elemData.handle;
  485. elemData.events = {};
  486. for (host in data) {
  487. /** @type {number} */
  488. i = 0;
  489. tableslen = data[host].length;
  490. for (; i < tableslen; i++) {
  491. jQuery.event.add(elem, host, data[host][i]);
  492. }
  493. }
  494. }
  495. if ($.hasData(node)) {
  496. p = $.access(node);
  497. token = jQuery.extend({}, p);
  498. $.set(elem, token);
  499. }
  500. }
  501. }
  502. /**
  503. * @param {!Object} src
  504. * @param {!Object} dest
  505. * @return {undefined}
  506. */
  507. function fixInput(src, dest) {
  508. var undefined = dest.nodeName.toLowerCase();
  509. if ("input" === undefined && reg.test(src.type)) {
  510. dest.checked = src.checked;
  511. } else {
  512. if (!("input" !== undefined && "textarea" !== undefined)) {
  513. dest.defaultValue = src.defaultValue;
  514. }
  515. }
  516. }
  517. /**
  518. * @param {!Object} collection
  519. * @param {!Array} args
  520. * @param {!Function} callback
  521. * @param {!Object} ignored
  522. * @return {?}
  523. */
  524. function domManip(collection, args, callback, ignored) {
  525. /** @type {!Array<?>} */
  526. args = c.apply([], args);
  527. var fragment;
  528. var first;
  529. var e;
  530. var position;
  531. var node;
  532. var doc;
  533. /** @type {number} */
  534. var key = 0;
  535. var result = collection.length;
  536. /** @type {number} */
  537. var index = result - 1;
  538. var fn = args[0];
  539. var rewriteFn = jQuery.isFunction(fn);
  540. if (rewriteFn || result > 1 && "string" == typeof fn && !support.checkClone && reValidName.test(fn)) {
  541. return collection.each(function(index) {
  542. var self = collection.eq(index);
  543. if (rewriteFn) {
  544. args[0] = fn.call(this, index, self.html());
  545. }
  546. domManip(self, args, callback, ignored);
  547. });
  548. }
  549. if (result && (fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored), first = fragment.firstChild, 1 === fragment.childNodes.length && (fragment = first), first || ignored)) {
  550. e = jQuery.map(getAll(fragment, "script"), text);
  551. position = e.length;
  552. for (; key < result; key++) {
  553. node = fragment;
  554. if (key !== index) {
  555. node = jQuery.clone(node, true, true);
  556. if (position) {
  557. jQuery.merge(e, getAll(node, "script"));
  558. }
  559. }
  560. callback.call(collection[key], node, key);
  561. }
  562. if (position) {
  563. doc = e[e.length - 1].ownerDocument;
  564. jQuery.map(e, createGeneNameGenomicState);
  565. /** @type {number} */
  566. key = 0;
  567. for (; key < position; key++) {
  568. node = e[key];
  569. if (opacityRe.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) {
  570. if (node.src) {
  571. if (jQuery._evalUrl) {
  572. jQuery._evalUrl(node.src);
  573. }
  574. } else {
  575. test(node.textContent.replace(codePoint, ""), doc);
  576. }
  577. }
  578. }
  579. }
  580. }
  581. return collection;
  582. }
  583. /**
  584. * @param {!Object} val
  585. * @param {!Function} fn
  586. * @param {string} keepData
  587. * @return {?}
  588. */
  589. function remove(val, fn, keepData) {
  590. var elem;
  591. var value = fn ? jQuery.filter(fn, val) : val;
  592. /** @type {number} */
  593. var name = 0;
  594. for (; null != (elem = value[name]); name++) {
  595. if (!(keepData || 1 !== elem.nodeType)) {
  596. jQuery.cleanData(getAll(elem));
  597. }
  598. if (elem.parentNode) {
  599. if (keepData && jQuery.contains(elem.ownerDocument, elem)) {
  600. setGlobalEval(getAll(elem, "script"));
  601. }
  602. elem.parentNode.removeChild(elem);
  603. }
  604. }
  605. return val;
  606. }
  607. /**
  608. * @param {!Object} elem
  609. * @param {string} name
  610. * @param {!Object} computed
  611. * @return {?}
  612. */
  613. function curCSS(elem, name, computed) {
  614. var minWidth;
  615. var width;
  616. var maxWidth;
  617. var ret;
  618. var style = elem.style;
  619. return computed = computed || getStyles(elem), computed && (ret = computed.getPropertyValue(name) || computed[name], "" !== ret || jQuery.contains(elem.ownerDocument, elem) || (ret = jQuery.style(elem, name)), !support.pixelMarginRight() && rnumnonpx.test(ret) && namespaces.test(name) && (minWidth = style.width, width = style.minWidth, maxWidth = style.maxWidth, style.minWidth = style.maxWidth = style.width = ret, ret = computed.width, style.width = minWidth, style.minWidth = width, style.maxWidth =
  620. maxWidth)), void 0 !== ret ? ret + "" : ret;
  621. }
  622. /**
  623. * @param {?} conditionFn
  624. * @param {!Function} hookFn
  625. * @return {?}
  626. */
  627. function addGetHookIf(conditionFn, hookFn) {
  628. return {
  629. get : function() {
  630. return conditionFn() ? void delete this.get : (this.get = hookFn).apply(this, arguments);
  631. }
  632. };
  633. }
  634. /**
  635. * @param {string} name
  636. * @return {?}
  637. */
  638. function vendorPropName(name) {
  639. if (name in style) {
  640. return name;
  641. }
  642. var UserSelect = name[0].toUpperCase() + name.slice(1);
  643. /** @type {number} */
  644. var i = prefixes.length;
  645. for (; i--;) {
  646. if (name = prefixes[i] + UserSelect, name in style) {
  647. return name;
  648. }
  649. }
  650. }
  651. /**
  652. * @param {!Object} type
  653. * @param {!Object} value
  654. * @param {string} prop
  655. * @return {?}
  656. */
  657. function _set(type, value, prop) {
  658. /** @type {(Array<string>|null)} */
  659. var matches = regex.exec(value);
  660. return matches ? Math.max(0, matches[2] - (prop || 0)) + (matches[3] || "px") : value;
  661. }
  662. /**
  663. * @param {!Object} elem
  664. * @param {string} name
  665. * @param {?} extra
  666. * @param {boolean} isBorderBox
  667. * @param {!Object} styles
  668. * @return {?}
  669. */
  670. function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
  671. /** @type {number} */
  672. var i = extra === (isBorderBox ? "border" : "content") ? 4 : "width" === name ? 1 : 0;
  673. /** @type {number} */
  674. var val = 0;
  675. for (; i < 4; i = i + 2) {
  676. if ("margin" === extra) {
  677. val = val + jQuery.css(elem, extra + cssExpand[i], true, styles);
  678. }
  679. if (isBorderBox) {
  680. if ("content" === extra) {
  681. /** @type {number} */
  682. val = val - jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  683. }
  684. if ("margin" !== extra) {
  685. /** @type {number} */
  686. val = val - jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  687. }
  688. } else {
  689. val = val + jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  690. if ("padding" !== extra) {
  691. val = val + jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  692. }
  693. }
  694. }
  695. return val;
  696. }
  697. /**
  698. * @param {!Element} elem
  699. * @param {string} name
  700. * @param {!Object} extra
  701. * @return {?}
  702. */
  703. function getWidthOrHeight(elem, name, extra) {
  704. var val;
  705. /** @type {boolean} */
  706. var valueIsBorderBox = true;
  707. var styles = getStyles(elem);
  708. /** @type {boolean} */
  709. var isBorderBox = "border-box" === jQuery.css(elem, "boxSizing", false, styles);
  710. if (elem.getClientRects().length && (val = elem.getBoundingClientRect()[name]), val <= 0 || null == val) {
  711. if (val = curCSS(elem, name, styles), (val < 0 || null == val) && (val = elem.style[name]), rnumnonpx.test(val)) {
  712. return val;
  713. }
  714. valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]);
  715. /** @type {number} */
  716. val = parseFloat(val) || 0;
  717. }
  718. return val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles) + "px";
  719. }
  720. /**
  721. * @param {!Object} type
  722. * @param {string} context
  723. * @param {string} object
  724. * @param {!Object} end
  725. * @param {string} easing
  726. * @return {?}
  727. */
  728. function Tween(type, context, object, end, easing) {
  729. return new Tween.prototype.init(type, context, object, end, easing);
  730. }
  731. /**
  732. * @return {undefined}
  733. */
  734. function raf() {
  735. if (id) {
  736. window.requestAnimationFrame(raf);
  737. jQuery.fx.tick();
  738. }
  739. }
  740. /**
  741. * @return {?}
  742. */
  743. function createFxNow() {
  744. return window.setTimeout(function() {
  745. fxNow = void 0;
  746. }), fxNow = jQuery.now();
  747. }
  748. /**
  749. * @param {string} type
  750. * @param {number} includeWidth
  751. * @return {?}
  752. */
  753. function genFx(type, includeWidth) {
  754. var which;
  755. /** @type {number} */
  756. var i = 0;
  757. var attrs = {
  758. height : type
  759. };
  760. /** @type {number} */
  761. includeWidth = includeWidth ? 1 : 0;
  762. for (; i < 4; i = i + (2 - includeWidth)) {
  763. which = cssExpand[i];
  764. attrs["margin" + which] = attrs["padding" + which] = type;
  765. }
  766. return includeWidth && (attrs.opacity = attrs.width = type), attrs;
  767. }
  768. /**
  769. * @param {?} value
  770. * @param {string} prop
  771. * @param {?} animation
  772. * @return {?}
  773. */
  774. function createTween(value, prop, animation) {
  775. var tween;
  776. var args = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]);
  777. /** @type {number} */
  778. var i = 0;
  779. var az = args.length;
  780. for (; i < az; i++) {
  781. if (tween = args[i].call(animation, prop, value)) {
  782. return tween;
  783. }
  784. }
  785. }
  786. /**
  787. * @param {!Element} elem
  788. * @param {!Object} props
  789. * @param {!Object} opts
  790. * @return {undefined}
  791. */
  792. function defaultPrefilter(elem, props, opts) {
  793. var prop;
  794. var value;
  795. var matched;
  796. var hooks;
  797. var oldfire;
  798. var tween;
  799. var restoreDisplay;
  800. var display;
  801. /** @type {boolean} */
  802. var f = "width" in props || "height" in props;
  803. var anim = this;
  804. var orig = {};
  805. var style = elem.style;
  806. var hidden = elem.nodeType && isHidden(elem);
  807. var dataShow = dataPriv.get(elem, "fxshow");
  808. if (!opts.queue) {
  809. hooks = jQuery._queueHooks(elem, "fx");
  810. if (null == hooks.unqueued) {
  811. /** @type {number} */
  812. hooks.unqueued = 0;
  813. /** @type {function(): undefined} */
  814. oldfire = hooks.empty.fire;
  815. /**
  816. * @return {undefined}
  817. */
  818. hooks.empty.fire = function() {
  819. if (!hooks.unqueued) {
  820. oldfire();
  821. }
  822. };
  823. }
  824. hooks.unqueued++;
  825. anim.always(function() {
  826. anim.always(function() {
  827. hooks.unqueued--;
  828. if (!jQuery.queue(elem, "fx").length) {
  829. hooks.empty.fire();
  830. }
  831. });
  832. });
  833. }
  834. for (prop in props) {
  835. if (value = props[prop], trueRE.test(value)) {
  836. if (delete props[prop], matched = matched || "toggle" === value, value === (hidden ? "hide" : "show")) {
  837. if ("show" !== value || !dataShow || void 0 === dataShow[prop]) {
  838. continue;
  839. }
  840. /** @type {boolean} */
  841. hidden = true;
  842. }
  843. orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
  844. }
  845. }
  846. if (tween = !jQuery.isEmptyObject(props), tween || !jQuery.isEmptyObject(orig)) {
  847. if (f && 1 === elem.nodeType) {
  848. /** @type {!Array} */
  849. opts.overflow = [style.overflow, style.overflowX, style.overflowY];
  850. restoreDisplay = dataShow && dataShow.display;
  851. if (null == restoreDisplay) {
  852. restoreDisplay = dataPriv.get(elem, "display");
  853. }
  854. display = jQuery.css(elem, "display");
  855. if ("none" === display) {
  856. if (restoreDisplay) {
  857. display = restoreDisplay;
  858. } else {
  859. showHide([elem], true);
  860. restoreDisplay = elem.style.display || restoreDisplay;
  861. display = jQuery.css(elem, "display");
  862. showHide([elem]);
  863. }
  864. }
  865. if (("inline" === display || "inline-block" === display && null != restoreDisplay) && "none" === jQuery.css(elem, "float")) {
  866. if (!tween) {
  867. anim.done(function() {
  868. style.display = restoreDisplay;
  869. });
  870. if (null == restoreDisplay) {
  871. display = style.display;
  872. restoreDisplay = "none" === display ? "" : display;
  873. }
  874. }
  875. /** @type {string} */
  876. style.display = "inline-block";
  877. }
  878. }
  879. if (opts.overflow) {
  880. /** @type {string} */
  881. style.overflow = "hidden";
  882. anim.always(function() {
  883. style.overflow = opts.overflow[0];
  884. style.overflowX = opts.overflow[1];
  885. style.overflowY = opts.overflow[2];
  886. });
  887. }
  888. /** @type {boolean} */
  889. tween = false;
  890. for (prop in orig) {
  891. if (!tween) {
  892. if (dataShow) {
  893. if ("hidden" in dataShow) {
  894. hidden = dataShow.hidden;
  895. }
  896. } else {
  897. dataShow = dataPriv.access(elem, "fxshow", {
  898. display : restoreDisplay
  899. });
  900. }
  901. if (matched) {
  902. /** @type {boolean} */
  903. dataShow.hidden = !hidden;
  904. }
  905. if (hidden) {
  906. showHide([elem], true);
  907. }
  908. anim.done(function() {
  909. if (!hidden) {
  910. showHide([elem]);
  911. }
  912. dataPriv.remove(elem, "fxshow");
  913. for (prop in orig) {
  914. jQuery.style(elem, prop, orig[prop]);
  915. }
  916. });
  917. }
  918. tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
  919. if (!(prop in dataShow)) {
  920. dataShow[prop] = tween.start;
  921. if (hidden) {
  922. tween.end = tween.start;
  923. /** @type {number} */
  924. tween.start = 0;
  925. }
  926. }
  927. }
  928. }
  929. }
  930. /**
  931. * @param {!Array} obj
  932. * @param {!Array} props
  933. * @return {undefined}
  934. */
  935. function propFilter(obj, props) {
  936. var key;
  937. var name;
  938. var value;
  939. var data;
  940. var hooks;
  941. for (key in obj) {
  942. if (name = jQuery.camelCase(key), value = props[name], data = obj[key], jQuery.isArray(data) && (value = data[1], data = obj[key] = data[0]), key !== name && (obj[name] = data, delete obj[key]), hooks = jQuery.cssHooks[name], hooks && "expand" in hooks) {
  943. data = hooks.expand(data);
  944. delete obj[name];
  945. for (key in data) {
  946. if (!(key in obj)) {
  947. obj[key] = data[key];
  948. props[key] = value;
  949. }
  950. }
  951. } else {
  952. props[name] = value;
  953. }
  954. }
  955. }
  956. /**
  957. * @param {!Object} elem
  958. * @param {?} properties
  959. * @param {!Object} options
  960. * @return {?}
  961. */
  962. function Animation(elem, properties, options) {
  963. var result;
  964. var i;
  965. /** @type {number} */
  966. var index = 0;
  967. var ncells = Animation.prefilters.length;
  968. var deferred = jQuery.Deferred().always(function() {
  969. delete tick.elem;
  970. });
  971. /**
  972. * @return {?}
  973. */
  974. var tick = function() {
  975. if (i) {
  976. return false;
  977. }
  978. var currentTime = fxNow || createFxNow();
  979. /** @type {number} */
  980. var remaining = Math.max(0, animation.startTime + animation.duration - currentTime);
  981. /** @type {number} */
  982. var temp = remaining / animation.duration || 0;
  983. /** @type {number} */
  984. var percent = 1 - temp;
  985. /** @type {number} */
  986. var index = 0;
  987. var length = animation.tweens.length;
  988. for (; index < length; index++) {
  989. animation.tweens[index].run(percent);
  990. }
  991. return deferred.notifyWith(elem, [animation, percent, remaining]), percent < 1 && length ? remaining : (deferred.resolveWith(elem, [animation]), false);
  992. };
  993. var animation = deferred.promise({
  994. elem : elem,
  995. props : jQuery.extend({}, properties),
  996. opts : jQuery.extend(true, {
  997. specialEasing : {},
  998. easing : jQuery.easing._default
  999. }, options),
  1000. originalProperties : properties,
  1001. originalOptions : options,
  1002. startTime : fxNow || createFxNow(),
  1003. duration : options.duration,
  1004. tweens : [],
  1005. createTween : function(prop, end) {
  1006. var result = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
  1007. return animation.tweens.push(result), result;
  1008. },
  1009. stop : function(value) {
  1010. /** @type {number} */
  1011. var index = 0;
  1012. var mid = value ? animation.tweens.length : 0;
  1013. if (i) {
  1014. return this;
  1015. }
  1016. /** @type {boolean} */
  1017. i = true;
  1018. for (; index < mid; index++) {
  1019. animation.tweens[index].run(1);
  1020. }
  1021. return value ? (deferred.notifyWith(elem, [animation, 1, 0]), deferred.resolveWith(elem, [animation, value])) : deferred.rejectWith(elem, [animation, value]), this;
  1022. }
  1023. });
  1024. var props = animation.props;
  1025. propFilter(props, animation.opts.specialEasing);
  1026. for (; index < ncells; index++) {
  1027. if (result = Animation.prefilters[index].call(animation, elem, props, animation.opts)) {
  1028. return jQuery.isFunction(result.stop) && (jQuery._queueHooks(animation.elem, animation.opts.queue).stop = jQuery.proxy(result.stop, result)), result;
  1029. }
  1030. }
  1031. return jQuery.map(props, createTween, animation), jQuery.isFunction(animation.opts.start) && animation.opts.start.call(elem, animation), jQuery.fx.timer(jQuery.extend(tick, {
  1032. elem : elem,
  1033. anim : animation,
  1034. queue : animation.opts.queue
  1035. })), animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
  1036. }
  1037. /**
  1038. * @param {!Node} el
  1039. * @return {?}
  1040. */
  1041. function fn(el) {
  1042. return el.getAttribute && el.getAttribute("class") || "";
  1043. }
  1044. /**
  1045. * @param {string} val
  1046. * @param {!Array} data
  1047. * @param {string} instance
  1048. * @param {!Function} next
  1049. * @return {undefined}
  1050. */
  1051. function callback(val, data, instance, next) {
  1052. var i;
  1053. if (jQuery.isArray(data)) {
  1054. jQuery.each(data, function(s, response) {
  1055. if (instance || rNum.test(val)) {
  1056. next(val, response);
  1057. } else {
  1058. callback(val + "[" + ("object" == typeof response && null != response ? s : "") + "]", response, instance, next);
  1059. }
  1060. });
  1061. } else {
  1062. if (instance || "object" !== jQuery.type(data)) {
  1063. next(val, data);
  1064. } else {
  1065. for (i in data) {
  1066. callback(val + "[" + i + "]", data[i], instance, next);
  1067. }
  1068. }
  1069. }
  1070. }
  1071. /**
  1072. * @param {!Object} structure
  1073. * @return {?}
  1074. */
  1075. function addToPrefiltersOrTransports(structure) {
  1076. return function(name, n) {
  1077. if ("string" != typeof name) {
  1078. /** @type {string} */
  1079. n = name;
  1080. /** @type {string} */
  1081. name = "*";
  1082. }
  1083. var type;
  1084. /** @type {number} */
  1085. var ol = 0;
  1086. var o = name.toLowerCase().match(rnotwhite) || [];
  1087. if (jQuery.isFunction(n)) {
  1088. for (; type = o[ol++];) {
  1089. if ("+" === type[0]) {
  1090. type = type.slice(1) || "*";
  1091. (structure[type] = structure[type] || []).unshift(n);
  1092. } else {
  1093. (structure[type] = structure[type] || []).push(n);
  1094. }
  1095. }
  1096. }
  1097. };
  1098. }
  1099. /**
  1100. * @param {!Object} structure
  1101. * @param {?} options
  1102. * @param {!Object} originalOptions
  1103. * @param {?} jqXHR
  1104. * @return {?}
  1105. */
  1106. function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
  1107. /**
  1108. * @param {string} type
  1109. * @return {?}
  1110. */
  1111. function inspect(type) {
  1112. var expectedProperty;
  1113. return staffBadges[type] = true, jQuery.each(structure[type] || [], function(canCreateDiscussions, prefilterOrFactory) {
  1114. var name = prefilterOrFactory(options, originalOptions, jqXHR);
  1115. return "string" != typeof name || seekingTransport || staffBadges[name] ? seekingTransport ? !(expectedProperty = name) : void 0 : (options.dataTypes.unshift(name), inspect(name), false);
  1116. }), expectedProperty;
  1117. }
  1118. var staffBadges = {};
  1119. /** @type {boolean} */
  1120. var seekingTransport = structure === transports;
  1121. return inspect(options.dataTypes[0]) || !staffBadges["*"] && inspect("*");
  1122. }
  1123. /**
  1124. * @param {?} target
  1125. * @param {?} opts
  1126. * @return {?}
  1127. */
  1128. function ajaxExtend(target, opts) {
  1129. var key;
  1130. var deep;
  1131. var flatOptions = jQuery.ajaxSettings.flatOptions || {};
  1132. for (key in opts) {
  1133. if (void 0 !== opts[key]) {
  1134. (flatOptions[key] ? target : deep || (deep = {}))[key] = opts[key];
  1135. }
  1136. }
  1137. return deep && jQuery.extend(true, target, deep), target;
  1138. }
  1139. /**
  1140. * @param {!Object} s
  1141. * @param {!XMLHttpRequest} jqXHR
  1142. * @param {!Array} responses
  1143. * @return {?}
  1144. */
  1145. function ajaxHandleResponses(s, jqXHR, responses) {
  1146. var ct;
  1147. var type;
  1148. var finalDataType;
  1149. var firstDataType;
  1150. var contents = s.contents;
  1151. var dataTypes = s.dataTypes;
  1152. for (; "*" === dataTypes[0];) {
  1153. dataTypes.shift();
  1154. if (void 0 === ct) {
  1155. ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
  1156. }
  1157. }
  1158. if (ct) {
  1159. for (type in contents) {
  1160. if (contents[type] && contents[type].test(ct)) {
  1161. dataTypes.unshift(type);
  1162. break;
  1163. }
  1164. }
  1165. }
  1166. if (dataTypes[0] in responses) {
  1167. finalDataType = dataTypes[0];
  1168. } else {
  1169. for (type in responses) {
  1170. if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
  1171. /** @type {string} */
  1172. finalDataType = type;
  1173. break;
  1174. }
  1175. if (!firstDataType) {
  1176. /** @type {string} */
  1177. firstDataType = type;
  1178. }
  1179. }
  1180. /** @type {(string|undefined)} */
  1181. finalDataType = finalDataType || firstDataType;
  1182. }
  1183. if (finalDataType) {
  1184. return finalDataType !== dataTypes[0] && dataTypes.unshift(finalDataType), responses[finalDataType];
  1185. }
  1186. }
  1187. /**
  1188. * @param {!Object} s
  1189. * @param {string} response
  1190. * @param {?} jqXHR
  1191. * @param {number} isSuccess
  1192. * @return {?}
  1193. */
  1194. function ajaxConvert(s, response, jqXHR, isSuccess) {
  1195. var conv2;
  1196. var current;
  1197. var conv;
  1198. var parts;
  1199. var value;
  1200. var converters = {};
  1201. var resList = s.dataTypes.slice();
  1202. if (resList[1]) {
  1203. for (conv in s.converters) {
  1204. converters[conv.toLowerCase()] = s.converters[conv];
  1205. }
  1206. }
  1207. current = resList.shift();
  1208. for (; current;) {
  1209. if (s.responseFields[current] && (jqXHR[s.responseFields[current]] = response), !value && isSuccess && s.dataFilter && (response = s.dataFilter(response, s.dataType)), value = current, current = resList.shift()) {
  1210. if ("*" === current) {
  1211. current = value;
  1212. } else {
  1213. if ("*" !== value && value !== current) {
  1214. if (conv = converters[value + " " + current] || converters["* " + current], !conv) {
  1215. for (conv2 in converters) {
  1216. if (parts = conv2.split(" "), parts[1] === current && (conv = converters[value + " " + parts[0]] || converters["* " + parts[0]])) {
  1217. if (conv === true) {
  1218. conv = converters[conv2];
  1219. } else {
  1220. if (converters[conv2] !== true) {
  1221. /** @type {string} */
  1222. current = parts[0];
  1223. resList.unshift(parts[1]);
  1224. }
  1225. }
  1226. break;
  1227. }
  1228. }
  1229. }
  1230. if (conv !== true) {
  1231. if (conv && s.throws) {
  1232. response = conv(response);
  1233. } else {
  1234. try {
  1235. response = conv(response);
  1236. } catch (e) {
  1237. return {
  1238. state : "parsererror",
  1239. error : conv ? e : "No conversion from " + value + " to " + current
  1240. };
  1241. }
  1242. }
  1243. }
  1244. }
  1245. }
  1246. }
  1247. }
  1248. return {
  1249. state : "success",
  1250. data : response
  1251. };
  1252. }
  1253. /**
  1254. * @param {!Object} obj
  1255. * @return {?}
  1256. */
  1257. function getWindow(obj) {
  1258. return jQuery.isWindow(obj) ? obj : 9 === obj.nodeType && obj.defaultView;
  1259. }
  1260. /** @type {!Array} */
  1261. var arr = [];
  1262. var document = window.document;
  1263. /** @type {function(!Object): (Object|null)} */
  1264. var getProto = Object.getPrototypeOf;
  1265. /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
  1266. var slice = arr.slice;
  1267. /** @type {function(this:*, ...*): !Array<?>} */
  1268. var c = arr.concat;
  1269. /** @type {function(this:IArrayLike<T>, ...T): number} */
  1270. var push = arr.push;
  1271. /** @type {function(this:(IArrayLike<T>|string), T, number=): number} */
  1272. var indexOf = arr.indexOf;
  1273. var class2type = {};
  1274. /** @type {function(this:*): string} */
  1275. var toString = class2type.toString;
  1276. /** @type {function(this:Object, *): boolean} */
  1277. var hasOwn = class2type.hasOwnProperty;
  1278. /** @type {function(this:!Function): string} */
  1279. var fnToString = hasOwn.toString;
  1280. /** @type {string} */
  1281. var type = fnToString.call(Object);
  1282. var support = {};
  1283. /** @type {string} */
  1284. var core_version = "3.1.0";
  1285. /**
  1286. * @param {!Object} selector
  1287. * @param {string} context
  1288. * @return {?}
  1289. */
  1290. var jQuery = function(selector, context) {
  1291. return new jQuery.fn.init(selector, context);
  1292. };
  1293. /** @type {!RegExp} */
  1294. var regNewline = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
  1295. /** @type {!RegExp} */
  1296. var _kerningNamesHash_escapeEscape = /^-ms-/;
  1297. /** @type {!RegExp} */
  1298. var rcharset = /-([a-z])/g;
  1299. /**
  1300. * @param {?} context
  1301. * @param {string} match
  1302. * @return {?}
  1303. */
  1304. var dashToCapital = function(context, match) {
  1305. return match.toUpperCase();
  1306. };
  1307. jQuery.fn = jQuery.prototype = {
  1308. jquery : core_version,
  1309. constructor : jQuery,
  1310. length : 0,
  1311. toArray : function() {
  1312. return slice.call(this);
  1313. },
  1314. get : function(num) {
  1315. return null != num ? num < 0 ? this[num + this.length] : this[num] : slice.call(this);
  1316. },
  1317. pushStack : function(name) {
  1318. var ret = jQuery.merge(this.constructor(), name);
  1319. return ret.prevObject = this, ret;
  1320. },
  1321. each : function(callback) {
  1322. return jQuery.each(this, callback);
  1323. },
  1324. map : function(a) {
  1325. return this.pushStack(jQuery.map(this, function(val, n) {
  1326. return a.call(val, n, val);
  1327. }));
  1328. },
  1329. slice : function() {
  1330. return this.pushStack(slice.apply(this, arguments));
  1331. },
  1332. first : function() {
  1333. return this.eq(0);
  1334. },
  1335. last : function() {
  1336. return this.eq(-1);
  1337. },
  1338. eq : function(idx) {
  1339. var l = this.length;
  1340. var i = +idx + (idx < 0 ? l : 0);
  1341. return this.pushStack(i >= 0 && i < l ? [this[i]] : []);
  1342. },
  1343. end : function() {
  1344. return this.prevObject || this.constructor();
  1345. },
  1346. push : push,
  1347. sort : arr.sort,
  1348. splice : arr.splice
  1349. };
  1350. /** @type {function(): ?} */
  1351. jQuery.extend = jQuery.fn.extend = function() {
  1352. var options;
  1353. var name;
  1354. var src;
  1355. var copy;
  1356. var copyIsArray;
  1357. var clone;
  1358. var target = arguments[0] || {};
  1359. /** @type {number} */
  1360. var i__7286__auto___11343 = 1;
  1361. /** @type {number} */
  1362. var len__7285__auto___11342 = arguments.length;
  1363. /** @type {boolean} */
  1364. var deep = false;
  1365. if ("boolean" == typeof target) {
  1366. /** @type {boolean} */
  1367. deep = target;
  1368. target = arguments[i__7286__auto___11343] || {};
  1369. i__7286__auto___11343++;
  1370. }
  1371. if (!("object" == typeof target || jQuery.isFunction(target))) {
  1372. target = {};
  1373. }
  1374. if (i__7286__auto___11343 === len__7285__auto___11342) {
  1375. target = this;
  1376. i__7286__auto___11343--;
  1377. }
  1378. for (; i__7286__auto___11343 < len__7285__auto___11342; i__7286__auto___11343++) {
  1379. if (null != (options = arguments[i__7286__auto___11343])) {
  1380. for (name in options) {
  1381. src = target[name];
  1382. copy = options[name];
  1383. if (target !== copy) {
  1384. if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
  1385. if (copyIsArray) {
  1386. /** @type {boolean} */
  1387. copyIsArray = false;
  1388. clone = src && jQuery.isArray(src) ? src : [];
  1389. } else {
  1390. clone = src && jQuery.isPlainObject(src) ? src : {};
  1391. }
  1392. target[name] = jQuery.extend(deep, clone, copy);
  1393. } else {
  1394. if (void 0 !== copy) {
  1395. target[name] = copy;
  1396. }
  1397. }
  1398. }
  1399. }
  1400. }
  1401. }
  1402. return target;
  1403. };
  1404. jQuery.extend({
  1405. expando : "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
  1406. isReady : true,
  1407. error : function(value) {
  1408. throw new Error(value);
  1409. },
  1410. noop : function() {
  1411. },
  1412. isFunction : function(obj) {
  1413. return "function" === jQuery.type(obj);
  1414. },
  1415. isArray : Array.isArray,
  1416. isWindow : function(obj) {
  1417. return null != obj && obj === obj.window;
  1418. },
  1419. isNumeric : function(value) {
  1420. var undefined = jQuery.type(value);
  1421. return ("number" === undefined || "string" === undefined) && !isNaN(value - parseFloat(value));
  1422. },
  1423. isPlainObject : function(obj) {
  1424. var proto;
  1425. var value;
  1426. return !(!obj || "[object Object]" !== toString.call(obj)) && (!(proto = getProto(obj)) || (value = hasOwn.call(proto, "constructor") && proto.constructor, "function" == typeof value && fnToString.call(value) === type));
  1427. },
  1428. isEmptyObject : function(obj) {
  1429. var key;
  1430. for (key in obj) {
  1431. return false;
  1432. }
  1433. return true;
  1434. },
  1435. type : function(obj) {
  1436. return null == obj ? obj + "" : "object" == typeof obj || "function" == typeof obj ? class2type[toString.call(obj)] || "object" : typeof obj;
  1437. },
  1438. globalEval : function(data) {
  1439. test(data);
  1440. },
  1441. camelCase : function(str) {
  1442. return str.replace(_kerningNamesHash_escapeEscape, "ms-").replace(rcharset, dashToCapital);
  1443. },
  1444. nodeName : function(elem, name) {
  1445. return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
  1446. },
  1447. each : function(obj, fn) {
  1448. var i;
  1449. /** @type {number} */
  1450. var n = 0;
  1451. if (isArrayLike(obj)) {
  1452. i = obj.length;
  1453. for (; n < i && fn.call(obj[n], n, obj[n]) !== false; n++) {
  1454. }
  1455. } else {
  1456. for (n in obj) {
  1457. if (fn.call(obj[n], n, obj[n]) === false) {
  1458. break;
  1459. }
  1460. }
  1461. }
  1462. return obj;
  1463. },
  1464. trim : function(text) {
  1465. return null == text ? "" : (text + "").replace(regNewline, "");
  1466. },
  1467. makeArray : function(arr, o) {
  1468. var obj = o || [];
  1469. return null != arr && (isArrayLike(Object(arr)) ? jQuery.merge(obj, "string" == typeof arr ? [arr] : arr) : push.call(obj, arr)), obj;
  1470. },
  1471. inArray : function(elem, arr, i) {
  1472. return null == arr ? -1 : indexOf.call(arr, elem, i);
  1473. },
  1474. merge : function(result, value) {
  1475. /** @type {number} */
  1476. var _jlen = +value.length;
  1477. /** @type {number} */
  1478. var k = 0;
  1479. var index = result.length;
  1480. for (; k < _jlen; k++) {
  1481. result[index++] = value[k];
  1482. }
  1483. return result.length = index, result;
  1484. },
  1485. grep : function(elems, callback, a) {
  1486. var editItemKey;
  1487. /** @type {!Array} */
  1488. var ret = [];
  1489. /** @type {number} */
  1490. var i = 0;
  1491. var length = elems.length;
  1492. /** @type {boolean} */
  1493. var booA = !a;
  1494. for (; i < length; i++) {
  1495. /** @type {boolean} */
  1496. editItemKey = !callback(elems[i], i);
  1497. if (editItemKey !== booA) {
  1498. ret.push(elems[i]);
  1499. }
  1500. }
  1501. return ret;
  1502. },
  1503. map : function(array, cb, type) {
  1504. var l;
  1505. var result;
  1506. /** @type {number} */
  1507. var i = 0;
  1508. /** @type {!Array} */
  1509. var o = [];
  1510. if (isArrayLike(array)) {
  1511. l = array.length;
  1512. for (; i < l; i++) {
  1513. result = cb(array[i], i, type);
  1514. if (null != result) {
  1515. o.push(result);
  1516. }
  1517. }
  1518. } else {
  1519. for (i in array) {
  1520. result = cb(array[i], i, type);
  1521. if (null != result) {
  1522. o.push(result);
  1523. }
  1524. }
  1525. }
  1526. return c.apply([], o);
  1527. },
  1528. guid : 1,
  1529. proxy : function(d, e) {
  1530. var i;
  1531. var headArgs;
  1532. var proxy;
  1533. if ("string" == typeof e && (i = d[e], e = d, d = i), jQuery.isFunction(d)) {
  1534. return headArgs = slice.call(arguments, 2), proxy = function() {
  1535. return d.apply(e || this, headArgs.concat(slice.call(arguments)));
  1536. }, proxy.guid = d.guid = d.guid || jQuery.guid++, proxy;
  1537. }
  1538. },
  1539. now : Date.now,
  1540. support : support
  1541. });
  1542. if ("function" == typeof Symbol) {
  1543. jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
  1544. }
  1545. jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(canCreateDiscussions, p_Interval) {
  1546. class2type["[object " + p_Interval + "]"] = p_Interval.toLowerCase();
  1547. });
  1548. var Sizzle = function(window) {
  1549. /**
  1550. * @param {string} selector
  1551. * @param {!Object} context
  1552. * @param {!Object} results
  1553. * @param {!Array} seed
  1554. * @return {?}
  1555. */
  1556. function Sizzle(selector, context, results, seed) {
  1557. var m;
  1558. var i;
  1559. var elem;
  1560. var nid;
  1561. var match;
  1562. var groups;
  1563. var newSelector;
  1564. var newContext = context && context.ownerDocument;
  1565. var undefined = context ? context.nodeType : 9;
  1566. if (results = results || [], "string" != typeof selector || !selector || 1 !== undefined && 9 !== undefined && 11 !== undefined) {
  1567. return results;
  1568. }
  1569. if (!seed && ((context ? context.ownerDocument || context : preferredDoc) !== document && setDocument(context), context = context || document, documentIsHTML)) {
  1570. if (11 !== undefined && (match = customSelectorReg.exec(selector))) {
  1571. if (m = match[1]) {
  1572. if (9 === undefined) {
  1573. if (!(elem = context.getElementById(m))) {
  1574. return results;
  1575. }
  1576. if (elem.id === m) {
  1577. return results.push(elem), results;
  1578. }
  1579. } else {
  1580. if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
  1581. return results.push(elem), results;
  1582. }
  1583. }
  1584. } else {
  1585. if (match[2]) {
  1586. return push.apply(results, context.getElementsByTagName(selector)), results;
  1587. }
  1588. if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
  1589. return push.apply(results, context.getElementsByClassName(m)), results;
  1590. }
  1591. }
  1592. }
  1593. if (support.qsa && !compilerCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
  1594. if (1 !== undefined) {
  1595. /** @type {!Object} */
  1596. newContext = context;
  1597. /** @type {string} */
  1598. newSelector = selector;
  1599. } else {
  1600. if ("object" !== context.nodeName.toLowerCase()) {
  1601. if (nid = context.getAttribute("id")) {
  1602. nid = nid.replace(rcssescape, fcssescape);
  1603. } else {
  1604. context.setAttribute("id", nid = expando);
  1605. }
  1606. groups = tokenize(selector);
  1607. i = groups.length;
  1608. for (; i--;) {
  1609. /** @type {string} */
  1610. groups[i] = "#" + nid + " " + toSelector(groups[i]);
  1611. }
  1612. newSelector = groups.join(",");
  1613. newContext = RE_PSEUDOS.test(selector) && testContext(context.parentNode) || context;
  1614. }
  1615. }
  1616. if (newSelector) {
  1617. try {
  1618. return push.apply(results, newContext.querySelectorAll(newSelector)), results;
  1619. } catch (e) {
  1620. } finally {
  1621. if (nid === expando) {
  1622. context.removeAttribute("id");
  1623. }
  1624. }
  1625. }
  1626. }
  1627. }
  1628. return select(selector.replace(rtrim, "$1"), context, results, seed);
  1629. }
  1630. /**
  1631. * @return {?}
  1632. */
  1633. function createCache() {
  1634. /**
  1635. * @param {string} duration
  1636. * @param {?} url
  1637. * @return {?}
  1638. */
  1639. function cache(duration, url) {
  1640. return lengths.push(duration + " ") > Expr.cacheLength && delete cache[lengths.shift()], cache[duration + " "] = url;
  1641. }
  1642. /** @type {!Array} */
  1643. var lengths = [];
  1644. return cache;
  1645. }
  1646. /**
  1647. * @param {!Function} fn
  1648. * @return {?}
  1649. */
  1650. function markFunction(fn) {
  1651. return fn[expando] = true, fn;
  1652. }
  1653. /**
  1654. * @param {!Function} expect
  1655. * @return {?}
  1656. */
  1657. function assert(expect) {
  1658. var wrap = document.createElement("fieldset");
  1659. try {
  1660. return !!expect(wrap);
  1661. } catch (e) {
  1662. return false;
  1663. } finally {
  1664. if (wrap.parentNode) {
  1665. wrap.parentNode.removeChild(wrap);
  1666. }
  1667. /** @type {null} */
  1668. wrap = null;
  1669. }
  1670. }
  1671. /**
  1672. * @param {string} attrs
  1673. * @param {!Function} handler
  1674. * @return {undefined}
  1675. */
  1676. function addHandle(attrs, handler) {
  1677. var arr = attrs.split("|");
  1678. var i = arr.length;
  1679. for (; i--;) {
  1680. /** @type {!Function} */
  1681. Expr.attrHandle[arr[i]] = handler;
  1682. }
  1683. }
  1684. /**
  1685. * @param {!Object} a
  1686. * @param {!Object} b
  1687. * @return {?}
  1688. */
  1689. function siblingCheck(a, b) {
  1690. var cur = b && a;
  1691. var .num_const = cur && 1 === a.nodeType && 1 === b.nodeType && a.sourceIndex - b.sourceIndex;
  1692. if (.num_const) {
  1693. return .num_const;
  1694. }
  1695. if (cur) {
  1696. for (; cur = cur.nextSibling;) {
  1697. if (cur === b) {
  1698. return -1;
  1699. }
  1700. }
  1701. }
  1702. return a ? 1 : -1;
  1703. }
  1704. /**
  1705. * @param {!Object} selector
  1706. * @return {?}
  1707. */
  1708. function s(selector) {
  1709. return function(item) {
  1710. var type = item.nodeName.toLowerCase();
  1711. return "input" === type && item.type === selector;
  1712. };
  1713. }
  1714. /**
  1715. * @param {!Object} type
  1716. * @return {?}
  1717. */
  1718. function createButtonPseudo(type) {
  1719. return function(section) {
  1720. var undefined = section.nodeName.toLowerCase();
  1721. return ("input" === undefined || "button" === undefined) && section.type === type;
  1722. };
  1723. }
  1724. /**
  1725. * @param {boolean} disabled
  1726. * @return {?}
  1727. */
  1728. function createDisabledPseudo(disabled) {
  1729. return function(elem) {
  1730. return "label" in elem && elem.disabled === disabled || "form" in elem && elem.disabled === disabled || "form" in elem && elem.disabled === false && (elem.isDisabled === disabled || elem.isDisabled !== !disabled && ("label" in elem || !disabledAncestor(elem)) !== disabled);
  1731. };
  1732. }
  1733. /**
  1734. * @param {!Function} fn
  1735. * @return {?}
  1736. */
  1737. function createPositionalPseudo(fn) {
  1738. return markFunction(function(key) {
  1739. return key = +key, markFunction(function(a, b) {
  1740. var i;
  1741. var k = fn([], a.length, key);
  1742. var l = k.length;
  1743. for (; l--;) {
  1744. if (a[i = k[l]]) {
  1745. /** @type {boolean} */
  1746. a[i] = !(b[i] = a[i]);
  1747. }
  1748. }
  1749. });
  1750. });
  1751. }
  1752. /**
  1753. * @param {!Node} context
  1754. * @return {?}
  1755. */
  1756. function testContext(context) {
  1757. return context && "undefined" != typeof context.getElementsByTagName && context;
  1758. }
  1759. /**
  1760. * @return {undefined}
  1761. */
  1762. function setFilters() {
  1763. }
  1764. /**
  1765. * @param {!Array} tokens
  1766. * @return {?}
  1767. */
  1768. function toSelector(tokens) {
  1769. /** @type {number} */
  1770. var i = 0;
  1771. var numTokens = tokens.length;
  1772. /** @type {string} */
  1773. var selector = "";
  1774. for (; i < numTokens; i++) {
  1775. /** @type {string} */
  1776. selector = selector + tokens[i].value;
  1777. }
  1778. return selector;
  1779. }
  1780. /**
  1781. * @param {!Function} matcher
  1782. * @param {!Object} combinator
  1783. * @param {string} base
  1784. * @return {?}
  1785. */
  1786. function addCombinator(matcher, combinator, base) {
  1787. var dir = combinator.dir;
  1788. var skip = combinator.next;
  1789. var key = skip || dir;
  1790. var checkNonElements = base && "parentNode" === key;
  1791. /** @type {number} */
  1792. var doneName = done++;
  1793. return combinator.first ? function(elem, stat, context) {
  1794. for (; elem = elem[dir];) {
  1795. if (1 === elem.nodeType || checkNonElements) {
  1796. return matcher(elem, stat, context);
  1797. }
  1798. }
  1799. } : function(elem, context, xml) {
  1800. var oldCache;
  1801. var uniqueCache;
  1802. var outerCache;
  1803. /** @type {!Array} */
  1804. var newCache = [dirruns, doneName];
  1805. if (xml) {
  1806. for (; elem = elem[dir];) {
  1807. if ((1 === elem.nodeType || checkNonElements) && matcher(elem, context, xml)) {
  1808. return true;
  1809. }
  1810. }
  1811. } else {
  1812. for (; elem = elem[dir];) {
  1813. if (1 === elem.nodeType || checkNonElements) {
  1814. if (outerCache = elem[expando] || (elem[expando] = {}), uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {}), skip && skip === elem.nodeName.toLowerCase()) {
  1815. elem = elem[dir] || elem;
  1816. } else {
  1817. if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
  1818. return newCache[2] = oldCache[2];
  1819. }
  1820. if (uniqueCache[key] = newCache, newCache[2] = matcher(elem, context, xml)) {
  1821. return true;
  1822. }
  1823. }
  1824. }
  1825. }
  1826. }
  1827. };
  1828. }
  1829. /**
  1830. * @param {!Object} matchers
  1831. * @return {?}
  1832. */
  1833. function elementMatcher(matchers) {
  1834. return matchers.length > 1 ? function(elem, context, xml) {
  1835. var i = matchers.length;
  1836. for (; i--;) {
  1837. if (!matchers[i](elem, context, xml)) {
  1838. return false;
  1839. }
  1840. }
  1841. return true;
  1842. } : matchers[0];
  1843. }
  1844. /**
  1845. * @param {string} selector
  1846. * @param {!NodeList} contexts
  1847. * @param {!Object} results
  1848. * @return {?}
  1849. */
  1850. function multipleContexts(selector, contexts, results) {
  1851. /** @type {number} */
  1852. var i = 0;
  1853. var count = contexts.length;
  1854. for (; i < count; i++) {
  1855. Sizzle(selector, contexts[i], results);
  1856. }
  1857. return results;
  1858. }
  1859. /**
  1860. * @param {!Array} t
  1861. * @param {!Object} token
  1862. * @param {!Object} fn
  1863. * @param {string} str
  1864. * @param {?} context
  1865. * @return {?}
  1866. */
  1867. function $(t, token, fn, str, context) {
  1868. var label;
  1869. /** @type {!Array} */
  1870. var el = [];
  1871. /** @type {number} */
  1872. var i = 0;
  1873. var pal = t.length;
  1874. /** @type {boolean} */
  1875. var changedToken = null != token;
  1876. for (; i < pal; i++) {
  1877. if (label = t[i]) {
  1878. if (!(fn && !fn(label, str, context))) {
  1879. el.push(label);
  1880. if (changedToken) {
  1881. token.push(i);
  1882. }
  1883. }
  1884. }
  1885. }
  1886. return el;
  1887. }
  1888. /**
  1889. * @param {!Object} object
  1890. * @param {string} selector
  1891. * @param {string} callback
  1892. * @param {!Object} fn
  1893. * @param {!Object} result
  1894. * @param {string} context
  1895. * @return {?}
  1896. */
  1897. function exec(object, selector, callback, fn, result, context) {
  1898. return fn && !fn[expando] && (fn = exec(fn)), result && !result[expando] && (result = exec(result, context)), markFunction(function(value, a, context, type) {
  1899. var c;
  1900. var index;
  1901. var b;
  1902. /** @type {!Array} */
  1903. var arrays = [];
  1904. /** @type {!Array} */
  1905. var d = [];
  1906. var key = a.length;
  1907. var t = value || multipleContexts(selector || "*", context.nodeType ? [context] : context, []);
  1908. var e = !object || !value && selector ? t : $(t, arrays, object, context, type);
  1909. var data = callback ? result || (value ? object : key || fn) ? [] : a : e;
  1910. if (callback && callback(e, data, context, type), fn) {
  1911. c = $(data, d);
  1912. fn(c, [], context, type);
  1913. index = c.length;
  1914. for (; index--;) {
  1915. if (b = c[index]) {
  1916. /** @type {boolean} */
  1917. data[d[index]] = !(e[d[index]] = b);
  1918. }
  1919. }
  1920. }
  1921. if (value) {
  1922. if (result || object) {
  1923. if (result) {
  1924. /** @type {!Array} */
  1925. c = [];
  1926. index = data.length;
  1927. for (; index--;) {
  1928. if (b = data[index]) {
  1929. c.push(e[index] = b);
  1930. }
  1931. }
  1932. result(null, data = [], c, type);
  1933. }
  1934. index = data.length;
  1935. for (; index--;) {
  1936. if ((b = data[index]) && (c = result ? indexOf(value, b) : arrays[index]) > -1) {
  1937. /** @type {boolean} */
  1938. value[c] = !(a[c] = b);
  1939. }
  1940. }
  1941. }
  1942. } else {
  1943. data = $(data === a ? data.splice(key, data.length) : data);
  1944. if (result) {
  1945. result(null, a, data, type);
  1946. } else {
  1947. push.apply(a, data);
  1948. }
  1949. }
  1950. });
  1951. }
  1952. /**
  1953. * @param {!Array} tokens
  1954. * @return {?}
  1955. */
  1956. function matcherFromTokens(tokens) {
  1957. var checkContext;
  1958. var matcher;
  1959. var j;
  1960. var len = tokens.length;
  1961. var leadingRelative = Expr.relative[tokens[0].type];
  1962. var implicitRelative = leadingRelative || Expr.relative[" "];
  1963. /** @type {number} */
  1964. var i = leadingRelative ? 1 : 0;
  1965. var matchContext = addCombinator(function(elem) {
  1966. return elem === checkContext;
  1967. }, implicitRelative, true);
  1968. var matchAnyContext = addCombinator(function(value) {
  1969. return indexOf(checkContext, value) > -1;
  1970. }, implicitRelative, true);
  1971. /** @type {!Array} */
  1972. var matchers = [function(elem, context, xml) {
  1973. var i = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
  1974. return checkContext = null, i;
  1975. }];
  1976. for (; i < len; i++) {
  1977. if (matcher = Expr.relative[tokens[i].type]) {
  1978. /** @type {!Array} */
  1979. matchers = [addCombinator(elementMatcher(matchers), matcher)];
  1980. } else {
  1981. if (matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches), matcher[expando]) {
  1982. /** @type {number} */
  1983. j = ++i;
  1984. for (; j < len && !Expr.relative[tokens[j].type]; j++) {
  1985. }
  1986. return exec(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1).concat({
  1987. value : " " === tokens[i - 2].type ? "*" : ""
  1988. })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
  1989. }
  1990. matchers.push(matcher);
  1991. }
  1992. }
  1993. return elementMatcher(matchers);
  1994. }
  1995. /**
  1996. * @param {!Array} elementMatchers
  1997. * @param {!Array} setMatchers
  1998. * @return {?}
  1999. */
  2000. function matcherFromGroupMatchers(elementMatchers, setMatchers) {
  2001. /** @type {boolean} */
  2002. var bySet = setMatchers.length > 0;
  2003. /** @type {boolean} */
  2004. var byElement = elementMatchers.length > 0;
  2005. /**
  2006. * @param {!Function} seed
  2007. * @param {!Object} context
  2008. * @param {number} xml
  2009. * @param {!Array} results
  2010. * @param {!Object} outermost
  2011. * @return {?}
  2012. */
  2013. var superMatcher = function(seed, context, xml, results, outermost) {
  2014. var elem;
  2015. var j;
  2016. var matcher;
  2017. /** @type {number} */
  2018. var matchedCount = 0;
  2019. /** @type {string} */
  2020. var i = "0";
  2021. var unmatched = seed && [];
  2022. /** @type {!Array} */
  2023. var data = [];
  2024. var contextBackup = outermostContext;
  2025. var elems = seed || byElement && Expr.find.TAG("*", outermost);
  2026. var dirrunsUnique = dirruns = dirruns + (null == contextBackup ? 1 : Math.random() || .1);
  2027. var length = elems.length;
  2028. if (outermost) {
  2029. outermostContext = context === document || context || outermost;
  2030. }
  2031. for (; i !== length && null != (elem = elems[i]); i++) {
  2032. if (byElement && elem) {
  2033. /** @type {number} */
  2034. j = 0;
  2035. if (!(context || elem.ownerDocument === document)) {
  2036. setDocument(elem);
  2037. /** @type {boolean} */
  2038. xml = !documentIsHTML;
  2039. }
  2040. for (; matcher = elementMatchers[j++];) {
  2041. if (matcher(elem, context || document, xml)) {
  2042. results.push(elem);
  2043. break;
  2044. }
  2045. }
  2046. if (outermost) {
  2047. dirruns = dirrunsUnique;
  2048. }
  2049. }
  2050. if (bySet) {
  2051. if (elem = !matcher && elem) {
  2052. matchedCount--;
  2053. }
  2054. if (seed) {
  2055. unmatched.push(elem);
  2056. }
  2057. }
  2058. }
  2059. if (matchedCount = matchedCount + i, bySet && i !== matchedCount) {
  2060. /** @type {number} */
  2061. j = 0;
  2062. for (; matcher = setMatchers[j++];) {
  2063. matcher(unmatched, data, context, xml);
  2064. }
  2065. if (seed) {
  2066. if (matchedCount > 0) {
  2067. for (; i--;) {
  2068. if (!(unmatched[i] || data[i])) {
  2069. data[i] = pop.call(results);
  2070. }
  2071. }
  2072. }
  2073. data = $(data);
  2074. }
  2075. push.apply(results, data);
  2076. if (outermost && !seed && data.length > 0 && matchedCount + setMatchers.length > 1) {
  2077. Sizzle.uniqueSort(results);
  2078. }
  2079. }
  2080. return outermost && (dirruns = dirrunsUnique, outermostContext = contextBackup), unmatched;
  2081. };
  2082. return bySet ? markFunction(superMatcher) : superMatcher;
  2083. }
  2084. var i;
  2085. var support;
  2086. var Expr;
  2087. var isUndefined;
  2088. var isXML;
  2089. var tokenize;
  2090. var compile;
  2091. var select;
  2092. var outermostContext;
  2093. var sortInput;
  2094. var ret;
  2095. var setDocument;
  2096. var document;
  2097. var docElem;
  2098. var documentIsHTML;
  2099. var rbuggyQSA;
  2100. var rbuggyMatches;
  2101. var matches;
  2102. var contains;
  2103. /** @type {string} */
  2104. var expando = "sizzle" + 1 * new Date;
  2105. var preferredDoc = window.document;
  2106. /** @type {number} */
  2107. var dirruns = 0;
  2108. /** @type {number} */
  2109. var done = 0;
  2110. var classCache = createCache();
  2111. var tokenCache = createCache();
  2112. var compilerCache = createCache();
  2113. /**
  2114. * @param {?} type
  2115. * @param {?} string
  2116. * @return {?}
  2117. */
  2118. var time = function(type, string) {
  2119. return type === string && (ret = true), 0;
  2120. };
  2121. /** @type {function(this:Object, *): boolean} */
  2122. var hasOwn = {}.hasOwnProperty;
  2123. /** @type {!Array} */
  2124. var arr = [];
  2125. /** @type {function(this:IArrayLike<T>): T} */
  2126. var pop = arr.pop;
  2127. /** @type {function(this:IArrayLike<T>, ...T): number} */
  2128. var push_native = arr.push;
  2129. /** @type {function(this:IArrayLike<T>, ...T): number} */
  2130. var push = arr.push;
  2131. /** @type {function(this:(IArrayLike<T>|string), *=, *=): !Array<T>} */
  2132. var slice = arr.slice;
  2133. /**
  2134. * @param {string} list
  2135. * @param {!Object} value
  2136. * @return {?}
  2137. */
  2138. var indexOf = function(list, value) {
  2139. /** @type {number} */
  2140. var i = 0;
  2141. var listLength = list.length;
  2142. for (; i < listLength; i++) {
  2143. if (list[i] === value) {
  2144. return i;
  2145. }
  2146. }
  2147. return -1;
  2148. };
  2149. /** @type {string} */
  2150. var value = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped";
  2151. /** @type {string} */
  2152. var _test = "[\\x20\\t\\r\\n\\f]";
  2153. /** @type {string} */
  2154. var escRightBracket = "(?:\\\\.|[\\w-]|[^\x00-\\xa0])+";
  2155. /** @type {string} */
  2156. var _end2 = "\\[" + _test + "*(" + escRightBracket + ")(?:" + _test + "*([*^$|!~]?=)" + _test + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + escRightBracket + "))|)" + _test + "*\\]";
  2157. /** @type {string} */
  2158. var pseudos = ":(" + escRightBracket + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + _end2 + ")*)|.*)\\)|)";
  2159. /** @type {!RegExp} */
  2160. var entityEscapeRegExp = new RegExp(_test + "+", "g");
  2161. /** @type {!RegExp} */
  2162. var rtrim = new RegExp("^" + _test + "+|((?:^|[^\\\\])(?:\\\\.)*)" + _test + "+$", "g");
  2163. /** @type {!RegExp} */
  2164. var chunker = new RegExp("^" + _test + "*," + _test + "*");
  2165. /** @type {!RegExp} */
  2166. var rcomma = new RegExp("^" + _test + "*([>+~]|" + _test + ")" + _test + "*");
  2167. /** @type {!RegExp} */
  2168. var rattributeQuotes = new RegExp("=" + _test + "*([^\\]'\"]*?)" + _test + "*\\]", "g");
  2169. /** @type {!RegExp} */
  2170. var rpseudo = new RegExp(pseudos);
  2171. /** @type {!RegExp} */
  2172. var ridentifier = new RegExp("^" + escRightBracket + "$");
  2173. var matchExpr = {
  2174. ID : new RegExp("^#(" + escRightBracket + ")"),
  2175. CLASS : new RegExp("^\\.(" + escRightBracket + ")"),
  2176. TAG : new RegExp("^(" + escRightBracket + "|[*])"),
  2177. ATTR : new RegExp("^" + _end2),
  2178. PSEUDO : new RegExp("^" + pseudos),
  2179. CHILD : new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + _test + "*(even|odd|(([+-]|)(\\d*)n|)" + _test + "*(?:([+-]|)" + _test + "*(\\d+)|))" + _test + "*\\)|)", "i"),
  2180. bool : new RegExp("^(?:" + value + ")$", "i"),
  2181. needsContext : new RegExp("^" + _test + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + _test + "*((?:-\\d)?\\d*)" + _test + "*\\)|)(?=[^-]|$)", "i")
  2182. };
  2183. /** @type {!RegExp} */
  2184. var inputNodeNames = /^(?:input|select|textarea|button)$/i;
  2185. /** @type {!RegExp} */
  2186. var rnoType = /^h\d$/i;
  2187. /** @type {!RegExp} */
  2188. var rnative = /^[^{]+\{\s*\[native \w/;
  2189. /** @type {!RegExp} */
  2190. var customSelectorReg = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/;
  2191. /** @type {!RegExp} */
  2192. var RE_PSEUDOS = /[+~]/;
  2193. /** @type {!RegExp} */
  2194. var start = new RegExp("\\\\([\\da-f]{1,6}" + _test + "?|(" + _test + ")|.)", "ig");
  2195. /**
  2196. * @param {?} _
  2197. * @param {string} escaped
  2198. * @param {boolean} escapedWhitespace
  2199. * @return {?}
  2200. */
  2201. var name = function(_, escaped, escapedWhitespace) {
  2202. /** @type {number} */
  2203. var high = "0x" + escaped - 65536;
  2204. return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, 1023 & high | 56320);
  2205. };
  2206. /** @type {!RegExp} */
  2207. var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
  2208. /**
  2209. * @param {string} text
  2210. * @param {string} ch
  2211. * @return {?}
  2212. */
  2213. var fcssescape = function(text, ch) {
  2214. return ch ? "\x00" === text ? "\ufffd" : text.slice(0, -1) + "\\" + text.charCodeAt(text.length - 1).toString(16) + " " : "\\" + text;
  2215. };
  2216. /**
  2217. * @return {undefined}
  2218. */
  2219. var unloadHandler = function() {
  2220. setDocument();
  2221. };
  2222. var disabledAncestor = addCombinator(function(showCalloutAnimation) {
  2223. return showCalloutAnimation.disabled === true;
  2224. }, {
  2225. dir : "parentNode",
  2226. next : "legend"
  2227. });
  2228. try {
  2229. push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
  2230. arr[preferredDoc.childNodes.length].nodeType;
  2231. } catch (e) {
  2232. push = {
  2233. apply : arr.length ? function(target, data) {
  2234. push_native.apply(target, slice.call(data));
  2235. } : function(obj, data) {
  2236. var i = obj.length;
  2237. /** @type {number} */
  2238. var off = 0;
  2239. for (; obj[i++] = data[off++];) {
  2240. }
  2241. /** @type {number} */
  2242. obj.length = i - 1;
  2243. }
  2244. };
  2245. }
  2246. support = Sizzle.support = {};
  2247. /** @type {function(!Object): ?} */
  2248. isXML = Sizzle.isXML = function(elem) {
  2249. var documentElement = elem && (elem.ownerDocument || elem).documentElement;
  2250. return !!documentElement && "HTML" !== documentElement.nodeName;
  2251. };
  2252. /** @type {function(!Object): ?} */
  2253. setDocument = Sizzle.setDocument = function(node) {
  2254. var init;
  2255. var subWindow;
  2256. var doc = node ? node.ownerDocument || node : preferredDoc;
  2257. return doc !== document && 9 === doc.nodeType && doc.documentElement ? (document = doc, docElem = document.documentElement, documentIsHTML = !isXML(document), preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow && (subWindow.addEventListener ? subWindow.addEventListener("unload", unloadHandler, false) : subWindow.attachEvent && subWindow.attachEvent("onunload", unloadHandler)), support.attributes = assert(function(elm) {
  2258. return elm.className = "i", !elm.getAttribute("className");
  2259. }), support.getElementsByTagName = assert(function(testee) {
  2260. return testee.appendChild(document.createComment("")), !testee.getElementsByTagName("*").length;
  2261. }), support.getElementsByClassName = rnative.test(document.getElementsByClassName), support.getById = assert(function(body) {
  2262. return docElem.appendChild(body).id = expando, !document.getElementsByName || !document.getElementsByName(expando).length;
  2263. }), support.getById ? (Expr.find.ID = function(elem, context) {
  2264. if ("undefined" != typeof context.getElementById && documentIsHTML) {
  2265. var c_style = context.getElementById(elem);
  2266. return c_style ? [c_style] : [];
  2267. }
  2268. }, Expr.filter.ID = function(elem) {
  2269. var i = elem.replace(start, name);
  2270. return function(e) {
  2271. return e.getAttribute("id") === i;
  2272. };
  2273. }) : (delete Expr.find.ID, Expr.filter.ID = function(elem) {
  2274. var state = elem.replace(start, name);
  2275. return function(elem) {
  2276. var obj = "undefined" != typeof elem.getAttributeNode && elem.getAttributeNode("id");
  2277. return obj && obj.value === state;
  2278. };
  2279. }), Expr.find.TAG = support.getElementsByTagName ? function(v, t) {
  2280. return "undefined" != typeof t.getElementsByTagName ? t.getElementsByTagName(v) : support.qsa ? t.querySelectorAll(v) : void 0;
  2281. } : function(selector, document) {
  2282. var first;
  2283. /** @type {!Array} */
  2284. var tmp = [];
  2285. /** @type {number} */
  2286. var i = 0;
  2287. var results = document.getElementsByTagName(selector);
  2288. if ("*" === selector) {
  2289. for (; first = results[i++];) {
  2290. if (1 === first.nodeType) {
  2291. tmp.push(first);
  2292. }
  2293. }
  2294. return tmp;
  2295. }
  2296. return results;
  2297. }, Expr.find.CLASS = support.getElementsByClassName && function(l, docDom) {
  2298. if ("undefined" != typeof docDom.getElementsByClassName && documentIsHTML) {
  2299. return docDom.getElementsByClassName(l);
  2300. }
  2301. }, rbuggyMatches = [], rbuggyQSA = [], (support.qsa = rnative.test(document.querySelectorAll)) && (assert(function(container) {
  2302. /** @type {string} */
  2303. docElem.appendChild(container).innerHTML = "<a id='" + expando + "'></a><select id='" + expando + "-\r\\' msallowcapture=''><option selected=''></option></select>";
  2304. if (container.querySelectorAll("[msallowcapture^='']").length) {
  2305. rbuggyQSA.push("[*^$]=" + _test + "*(?:''|\"\")");
  2306. }
  2307. if (!container.querySelectorAll("[selected]").length) {
  2308. rbuggyQSA.push("\\[" + _test + "*(?:value|" + value + ")");
  2309. }
  2310. if (!container.querySelectorAll("[id~=" + expando + "-]").length) {
  2311. rbuggyQSA.push("~=");
  2312. }
  2313. if (!container.querySelectorAll(":checked").length) {
  2314. rbuggyQSA.push(":checked");
  2315. }
  2316. if (!container.querySelectorAll("a#" + expando + "+*").length) {
  2317. rbuggyQSA.push(".#.+[+~]");
  2318. }
  2319. }), assert(function(el) {
  2320. /** @type {string} */
  2321. el.innerHTML = "<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";
  2322. var input = document.createElement("input");
  2323. input.setAttribute("type", "hidden");
  2324. el.appendChild(input).setAttribute("name", "D");
  2325. if (el.querySelectorAll("[name=d]").length) {
  2326. rbuggyQSA.push("name" + _test + "*[*^$|!~]?=");
  2327. }
  2328. if (2 !== el.querySelectorAll(":enabled").length) {
  2329. rbuggyQSA.push(":enabled", ":disabled");
  2330. }
  2331. /** @type {boolean} */
  2332. docElem.appendChild(el).disabled = true;
  2333. if (2 !== el.querySelectorAll(":disabled").length) {
  2334. rbuggyQSA.push(":enabled", ":disabled");
  2335. }
  2336. el.querySelectorAll("*,:x");
  2337. rbuggyQSA.push(",.*:");
  2338. })), (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) && assert(function(el) {
  2339. support.disconnectedMatch = matches.call(el, "*");
  2340. matches.call(el, "[s!='']:x");
  2341. rbuggyMatches.push("!=", pseudos);
  2342. }), rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")), rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|")), init = rnative.test(docElem.compareDocumentPosition), contains = init || rnative.test(docElem.contains) ? function(a, b) {
  2343. var adown = 9 === a.nodeType ? a.documentElement : a;
  2344. var bup = b && b.parentNode;
  2345. return a === bup || !(!bup || 1 !== bup.nodeType || !(adown.contains ? adown.contains(bup) : a.compareDocumentPosition && 16 & a.compareDocumentPosition(bup)));
  2346. } : function(a, b) {
  2347. if (b) {
  2348. for (; b = b.parentNode;) {
  2349. if (b === a) {
  2350. return true;
  2351. }
  2352. }
  2353. }
  2354. return false;
  2355. }, time = init ? function(a, b) {
  2356. if (a === b) {
  2357. return ret = true, 0;
  2358. }
  2359. /** @type {number} */
  2360. var idx = !a.compareDocumentPosition - !b.compareDocumentPosition;
  2361. return idx ? idx : (idx = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1, 1 & idx || !support.sortDetached && b.compareDocumentPosition(a) === idx ? a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ? -1 : b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0 : 4 & idx ? -1 : 1);
  2362. } : function(a, b) {
  2363. if (a === b) {
  2364. return ret = true, 0;
  2365. }
  2366. var cur;
  2367. /** @type {number} */
  2368. var i = 0;
  2369. var aup = a.parentNode;
  2370. var bup = b.parentNode;
  2371. /** @type {!Array} */
  2372. var ap = [a];
  2373. /** @type {!Array} */
  2374. var bp = [b];
  2375. if (!aup || !bup) {
  2376. return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
  2377. }
  2378. if (aup === bup) {
  2379. return siblingCheck(a, b);
  2380. }
  2381. /** @type {!Object} */
  2382. cur = a;
  2383. for (; cur = cur.parentNode;) {
  2384. ap.unshift(cur);
  2385. }
  2386. /** @type {!Object} */
  2387. cur = b;
  2388. for (; cur = cur.parentNode;) {
  2389. bp.unshift(cur);
  2390. }
  2391. for (; ap[i] === bp[i];) {
  2392. i++;
  2393. }
  2394. return i ? siblingCheck(ap[i], bp[i]) : ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
  2395. }, document) : document;
  2396. };
  2397. /**
  2398. * @param {string} expr
  2399. * @param {!Array} set
  2400. * @return {?}
  2401. */
  2402. Sizzle.matches = function(expr, set) {
  2403. return Sizzle(expr, null, null, set);
  2404. };
  2405. /**
  2406. * @param {!Object} elem
  2407. * @param {string} expr
  2408. * @return {?}
  2409. */
  2410. Sizzle.matchesSelector = function(elem, expr) {
  2411. if ((elem.ownerDocument || elem) !== document && setDocument(elem), expr = expr.replace(rattributeQuotes, "='$1']"), support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
  2412. try {
  2413. var ret = matches.call(elem, expr);
  2414. if (ret || support.disconnectedMatch || elem.document && 11 !== elem.document.nodeType) {
  2415. return ret;
  2416. }
  2417. } catch (e) {
  2418. }
  2419. }
  2420. return Sizzle(expr, document, null, [elem]).length > 0;
  2421. };
  2422. /**
  2423. * @param {!Object} context
  2424. * @param {!Object} selector
  2425. * @return {?}
  2426. */
  2427. Sizzle.contains = function(context, selector) {
  2428. return (context.ownerDocument || context) !== document && setDocument(context), contains(context, selector);
  2429. };
  2430. /**
  2431. * @param {!Object} elem
  2432. * @param {string} name
  2433. * @return {?}
  2434. */
  2435. Sizzle.attr = function(elem, name) {
  2436. if ((elem.ownerDocument || elem) !== document) {
  2437. setDocument(elem);
  2438. }
  2439. var fn = Expr.attrHandle[name.toLowerCase()];
  2440. var val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0;
  2441. return void 0 !== val ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  2442. };
  2443. /**
  2444. * @param {string} text
  2445. * @return {?}
  2446. */
  2447. Sizzle.escape = function(text) {
  2448. return (text + "").replace(rcssescape, fcssescape);
  2449. };
  2450. /**
  2451. * @param {string} elem
  2452. * @return {?}
  2453. */
  2454. Sizzle.error = function(elem) {
  2455. throw new Error("Syntax error, unrecognized expression: " + elem);
  2456. };
  2457. /**
  2458. * @param {!Array} results
  2459. * @return {?}
  2460. */
  2461. Sizzle.uniqueSort = function(results) {
  2462. var elem;
  2463. /** @type {!Array} */
  2464. var duplicates = [];
  2465. /** @type {number} */
  2466. var j = 0;
  2467. /** @type {number} */
  2468. var i = 0;
  2469. if (ret = !support.detectDuplicates, sortInput = !support.sortStable && results.slice(0), results.sort(time), ret) {
  2470. for (; elem = results[i++];) {
  2471. if (elem === results[i]) {
  2472. /** @type {number} */
  2473. j = duplicates.push(i);
  2474. }
  2475. }
  2476. for (; j--;) {
  2477. results.splice(duplicates[j], 1);
  2478. }
  2479. }
  2480. return sortInput = null, results;
  2481. };
  2482. /** @type {function(!Object): ?} */
  2483. isUndefined = Sizzle.getText = function(e) {
  2484. var p;
  2485. /** @type {string} */
  2486. var value = "";
  2487. /** @type {number} */
  2488. var r = 0;
  2489. var type = e.nodeType;
  2490. if (type) {
  2491. if (1 === type || 9 === type || 11 === type) {
  2492. if ("string" == typeof e.textContent) {
  2493. return e.textContent;
  2494. }
  2495. e = e.firstChild;
  2496. for (; e; e = e.nextSibling) {
  2497. value = value + isUndefined(e);
  2498. }
  2499. } else {
  2500. if (3 === type || 4 === type) {
  2501. return e.nodeValue;
  2502. }
  2503. }
  2504. } else {
  2505. for (; p = e[r++];) {
  2506. value = value + isUndefined(p);
  2507. }
  2508. }
  2509. return value;
  2510. };
  2511. Expr = Sizzle.selectors = {
  2512. cacheLength : 50,
  2513. createPseudo : markFunction,
  2514. match : matchExpr,
  2515. attrHandle : {},
  2516. find : {},
  2517. relative : {
  2518. ">" : {
  2519. dir : "parentNode",
  2520. first : true
  2521. },
  2522. " " : {
  2523. dir : "parentNode"
  2524. },
  2525. "+" : {
  2526. dir : "previousSibling",
  2527. first : true
  2528. },
  2529. "~" : {
  2530. dir : "previousSibling"
  2531. }
  2532. },
  2533. preFilter : {
  2534. ATTR : function(attr) {
  2535. return attr[1] = attr[1].replace(start, name), attr[3] = (attr[3] || attr[4] || attr[5] || "").replace(start, name), "~=" === attr[2] && (attr[3] = " " + attr[3] + " "), attr.slice(0, 4);
  2536. },
  2537. CHILD : function(match) {
  2538. return match[1] = match[1].toLowerCase(), "nth" === match[1].slice(0, 3) ? (match[3] || Sizzle.error(match[0]), match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * ("even" === match[3] || "odd" === match[3])), match[5] = +(match[7] + match[8] || "odd" === match[3])) : match[3] && Sizzle.error(match[0]), match;
  2539. },
  2540. PSEUDO : function(match) {
  2541. var excess;
  2542. var unquoted = !match[6] && match[2];
  2543. return matchExpr.CHILD.test(match[0]) ? null : (match[3] ? match[2] = match[4] || match[5] || "" : unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length) && (match[0] = match[0].slice(0, excess), match[2] = unquoted.slice(0, excess)), match.slice(0, 3));
  2544. }
  2545. },
  2546. filter : {
  2547. TAG : function(elem) {
  2548. var nodeName = elem.replace(start, name).toLowerCase();
  2549. return "*" === elem ? function() {
  2550. return true;
  2551. } : function(elem) {
  2552. return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  2553. };
  2554. },
  2555. CLASS : function(className) {
  2556. var pattern = classCache[className + " "];
  2557. return pattern || (pattern = new RegExp("(^|" + _test + ")" + className + "(" + _test + "|$)")) && classCache(className, function(e) {
  2558. return pattern.test("string" == typeof e.className && e.className || "undefined" != typeof e.getAttribute && e.getAttribute("class") || "");
  2559. });
  2560. },
  2561. ATTR : function(name, string, value) {
  2562. return function(elem) {
  2563. var key = Sizzle.attr(elem, name);
  2564. return null == key ? "!=" === string : !string || (key = key + "", "=" === string ? key === value : "!=" === string ? key !== value : "^=" === string ? value && 0 === key.indexOf(value) : "*=" === string ? value && key.indexOf(value) > -1 : "$=" === string ? value && key.slice(-value.length) === value : "~=" === string ? (" " + key.replace(entityEscapeRegExp, " ") + " ").indexOf(value) > -1 : "|=" === string && (key === value || key.slice(0, value.length + 1) === value + "-"));
  2565. };
  2566. },
  2567. CHILD : function(type, what, argument, first, last) {
  2568. /** @type {boolean} */
  2569. var simple = "nth" !== type.slice(0, 3);
  2570. /** @type {boolean} */
  2571. var forward = "last" !== type.slice(-4);
  2572. /** @type {boolean} */
  2573. var isStrict = "of-type" === what;
  2574. return 1 === first && 0 === last ? function(tplDiv) {
  2575. return !!tplDiv.parentNode;
  2576. } : function(elem, n, b) {
  2577. var cache;
  2578. var uniqueCache;
  2579. var outerCache;
  2580. var node;
  2581. var nodeIndex;
  2582. var start;
  2583. /** @type {string} */
  2584. var dir = simple !== forward ? "nextSibling" : "previousSibling";
  2585. var parent = elem.parentNode;
  2586. var iteratedVal = isStrict && elem.nodeName.toLowerCase();
  2587. /** @type {boolean} */
  2588. var useCache = !b && !isStrict;
  2589. /** @type {boolean} */
  2590. var diff = false;
  2591. if (parent) {
  2592. if (simple) {
  2593. for (; dir;) {
  2594. /** @type {!Node} */
  2595. node = elem;
  2596. for (; node = node[dir];) {
  2597. if (isStrict ? node.nodeName.toLowerCase() === iteratedVal : 1 === node.nodeType) {
  2598. return false;
  2599. }
  2600. }
  2601. /** @type {(boolean|string)} */
  2602. start = dir = "only" === type && !start && "nextSibling";
  2603. }
  2604. return true;
  2605. }
  2606. if (start = [forward ? parent.firstChild : parent.lastChild], forward && useCache) {
  2607. node = parent;
  2608. outerCache = node[expando] || (node[expando] = {});
  2609. uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
  2610. cache = uniqueCache[type] || [];
  2611. nodeIndex = cache[0] === dirruns && cache[1];
  2612. diff = nodeIndex && cache[2];
  2613. node = nodeIndex && parent.childNodes[nodeIndex];
  2614. for (; node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop();) {
  2615. if (1 === node.nodeType && ++diff && node === elem) {
  2616. /** @type {!Array} */
  2617. uniqueCache[type] = [dirruns, nodeIndex, diff];
  2618. break;
  2619. }
  2620. }
  2621. } else {
  2622. if (useCache && (node = elem, outerCache = node[expando] || (node[expando] = {}), uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {}), cache = uniqueCache[type] || [], nodeIndex = cache[0] === dirruns && cache[1], diff = nodeIndex), diff === false) {
  2623. for (; (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) && ((isStrict ? node.nodeName.toLowerCase() !== iteratedVal : 1 !== node.nodeType) || !++diff || (useCache && (outerCache = node[expando] || (node[expando] = {}), uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {}), uniqueCache[type] = [dirruns, diff]), node !== elem));) {
  2624. }
  2625. }
  2626. }
  2627. return diff = diff - last, diff === first || diff % first === 0 && diff / first >= 0;
  2628. }
  2629. };
  2630. },
  2631. PSEUDO : function(pseudo, argument) {
  2632. var args;
  2633. var fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
  2634. return fn[expando] ? fn(argument) : fn.length > 1 ? (args = [pseudo, pseudo, "", argument], Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches) {
  2635. var idx;
  2636. var matched = fn(seed, argument);
  2637. var i = matched.length;
  2638. for (; i--;) {
  2639. idx = indexOf(seed, matched[i]);
  2640. /** @type {boolean} */
  2641. seed[idx] = !(matches[idx] = matched[i]);
  2642. }
  2643. }) : function(responce) {
  2644. return fn(responce, 0, args);
  2645. }) : fn;
  2646. }
  2647. },
  2648. pseudos : {
  2649. not : markFunction(function(selector) {
  2650. /** @type {!Array} */
  2651. var a = [];
  2652. /** @type {!Array} */
  2653. var results = [];
  2654. var matcher = compile(selector.replace(rtrim, "$1"));
  2655. return matcher[expando] ? markFunction(function(a, resolvedDeps, n, context) {
  2656. var name;
  2657. var result = matcher(a, null, context, []);
  2658. var i = a.length;
  2659. for (; i--;) {
  2660. if (name = result[i]) {
  2661. /** @type {boolean} */
  2662. a[i] = !(resolvedDeps[i] = name);
  2663. }
  2664. }
  2665. }) : function(sNewObjName, isSlidingUp, context) {
  2666. return a[0] = sNewObjName, matcher(a, null, context, results), a[0] = null, !results.pop();
  2667. };
  2668. }),
  2669. has : markFunction(function(selector) {
  2670. return function(elem) {
  2671. return Sizzle(selector, elem).length > 0;
  2672. };
  2673. }),
  2674. contains : markFunction(function(e) {
  2675. return e = e.replace(start, name), function(elem) {
  2676. return (elem.textContent || elem.innerText || isUndefined(elem)).indexOf(e) > -1;
  2677. };
  2678. }),
  2679. lang : markFunction(function(lang) {
  2680. return ridentifier.test(lang || "") || Sizzle.error("unsupported lang: " + lang), lang = lang.replace(start, name).toLowerCase(), function(elem) {
  2681. var elemLang;
  2682. do {
  2683. if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
  2684. return elemLang = elemLang.toLowerCase(), elemLang === lang || 0 === elemLang.indexOf(lang + "-");
  2685. }
  2686. } while ((elem = elem.parentNode) && 1 === elem.nodeType);
  2687. return false;
  2688. };
  2689. }),
  2690. target : function(key) {
  2691. var charListNotLatin = window.location && window.location.hash;
  2692. return charListNotLatin && charListNotLatin.slice(1) === key.id;
  2693. },
  2694. root : function(elem) {
  2695. return elem === docElem;
  2696. },
  2697. focus : function(elem) {
  2698. return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
  2699. },
  2700. enabled : createDisabledPseudo(false),
  2701. disabled : createDisabledPseudo(true),
  2702. checked : function(elem) {
  2703. var custom = elem.nodeName.toLowerCase();
  2704. return "input" === custom && !!elem.checked || "option" === custom && !!elem.selected;
  2705. },
  2706. selected : function(elem) {
  2707. return elem.parentNode && elem.parentNode.selectedIndex, elem.selected === true;
  2708. },
  2709. empty : function(elem) {
  2710. elem = elem.firstChild;
  2711. for (; elem; elem = elem.nextSibling) {
  2712. if (elem.nodeType < 6) {
  2713. return false;
  2714. }
  2715. }
  2716. return true;
  2717. },
  2718. parent : function(elem) {
  2719. return !Expr.pseudos.empty(elem);
  2720. },
  2721. header : function(elem) {
  2722. return rnoType.test(elem.nodeName);
  2723. },
  2724. input : function(target) {
  2725. return inputNodeNames.test(target.nodeName);
  2726. },
  2727. button : function(elem) {
  2728. var left = elem.nodeName.toLowerCase();
  2729. return "input" === left && "button" === elem.type || "button" === left;
  2730. },
  2731. text : function(elem) {
  2732. var EXT;
  2733. return "input" === elem.nodeName.toLowerCase() && "text" === elem.type && (null == (EXT = elem.getAttribute("type")) || "text" === EXT.toLowerCase());
  2734. },
  2735. first : createPositionalPseudo(function() {
  2736. return [0];
  2737. }),
  2738. last : createPositionalPseudo(function(canCreateDiscussions, isSlidingUp) {
  2739. return [isSlidingUp - 1];
  2740. }),
  2741. eq : createPositionalPseudo(function(canCreateDiscussions, pageHeight, srcY) {
  2742. return [srcY < 0 ? srcY + pageHeight : srcY];
  2743. }),
  2744. even : createPositionalPseudo(function(lastshuffle, inclusiveMin) {
  2745. /** @type {number} */
  2746. var value = 0;
  2747. for (; value < inclusiveMin; value = value + 2) {
  2748. lastshuffle.push(value);
  2749. }
  2750. return lastshuffle;
  2751. }),
  2752. odd : createPositionalPseudo(function(lastshuffle, inclusiveMin) {
  2753. /** @type {number} */
  2754. var value = 1;
  2755. for (; value < inclusiveMin; value = value + 2) {
  2756. lastshuffle.push(value);
  2757. }
  2758. return lastshuffle;
  2759. }),
  2760. lt : createPositionalPseudo(function(newNodeLists, pageHeight, srcY) {
  2761. var itemNodeList = srcY < 0 ? srcY + pageHeight : srcY;
  2762. for (; --itemNodeList >= 0;) {
  2763. newNodeLists.push(itemNodeList);
  2764. }
  2765. return newNodeLists;
  2766. }),
  2767. gt : createPositionalPseudo(function(newNodeLists, pageHeight, srcY) {
  2768. var itemNodeList = srcY < 0 ? srcY + pageHeight : srcY;
  2769. for (; ++itemNodeList < pageHeight;) {
  2770. newNodeLists.push(itemNodeList);
  2771. }
  2772. return newNodeLists;
  2773. })
  2774. }
  2775. };
  2776. Expr.pseudos.nth = Expr.pseudos.eq;
  2777. for (i in{
  2778. radio : true,
  2779. checkbox : true,
  2780. file : true,
  2781. password : true,
  2782. image : true
  2783. }) {
  2784. Expr.pseudos[i] = s(i);
  2785. }
  2786. for (i in{
  2787. submit : true,
  2788. reset : true
  2789. }) {
  2790. Expr.pseudos[i] = createButtonPseudo(i);
  2791. }
  2792. return setFilters.prototype = Expr.filters = Expr.pseudos, Expr.setFilters = new setFilters, tokenize = Sizzle.tokenize = function(selector, parseOnly) {
  2793. var matched;
  2794. var match;
  2795. var tokens;
  2796. var type;
  2797. var soFar;
  2798. var groups;
  2799. var preFilters;
  2800. var cached = tokenCache[selector + " "];
  2801. if (cached) {
  2802. return parseOnly ? 0 : cached.slice(0);
  2803. }
  2804. /** @type {string} */
  2805. soFar = selector;
  2806. /** @type {!Array} */
  2807. groups = [];
  2808. preFilters = Expr.preFilter;
  2809. for (; soFar;) {
  2810. if (!(matched && !(match = chunker.exec(soFar)))) {
  2811. if (match) {
  2812. soFar = soFar.slice(match[0].length) || soFar;
  2813. }
  2814. groups.push(tokens = []);
  2815. }
  2816. /** @type {boolean} */
  2817. matched = false;
  2818. if (match = rcomma.exec(soFar)) {
  2819. /** @type {string} */
  2820. matched = match.shift();
  2821. tokens.push({
  2822. value : matched,
  2823. type : match[0].replace(rtrim, " ")
  2824. });
  2825. soFar = soFar.slice(matched.length);
  2826. }
  2827. for (type in Expr.filter) {
  2828. if (!(!(match = matchExpr[type].exec(soFar)) || preFilters[type] && !(match = preFilters[type](match)))) {
  2829. matched = match.shift();
  2830. tokens.push({
  2831. value : matched,
  2832. type : type,
  2833. matches : match
  2834. });
  2835. soFar = soFar.slice(matched.length);
  2836. }
  2837. }
  2838. if (!matched) {
  2839. break;
  2840. }
  2841. }
  2842. return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector, groups).slice(0);
  2843. }, compile = Sizzle.compile = function(selector, group) {
  2844. var i;
  2845. /** @type {!Array} */
  2846. var setMatchers = [];
  2847. /** @type {!Array} */
  2848. var elementMatchers = [];
  2849. var cached = compilerCache[selector + " "];
  2850. if (!cached) {
  2851. if (!group) {
  2852. group = tokenize(selector);
  2853. }
  2854. i = group.length;
  2855. for (; i--;) {
  2856. cached = matcherFromTokens(group[i]);
  2857. if (cached[expando]) {
  2858. setMatchers.push(cached);
  2859. } else {
  2860. elementMatchers.push(cached);
  2861. }
  2862. }
  2863. cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
  2864. /** @type {string} */
  2865. cached.selector = selector;
  2866. }
  2867. return cached;
  2868. }, select = Sizzle.select = function(selector, context, results, seed) {
  2869. var i;
  2870. var tokens;
  2871. var token;
  2872. var type;
  2873. var find;
  2874. /** @type {(!Function|boolean)} */
  2875. var compiled = "function" == typeof selector && selector;
  2876. var match = !seed && tokenize(selector = compiled.selector || selector);
  2877. if (results = results || [], 1 === match.length) {
  2878. if (tokens = match[0] = match[0].slice(0), tokens.length > 2 && "ID" === (token = tokens[0]).type && support.getById && 9 === context.nodeType && documentIsHTML && Expr.relative[tokens[1].type]) {
  2879. if (context = (Expr.find.ID(token.matches[0].replace(start, name), context) || [])[0], !context) {
  2880. return results;
  2881. }
  2882. if (compiled) {
  2883. context = context.parentNode;
  2884. }
  2885. selector = selector.slice(tokens.shift().value.length);
  2886. }
  2887. i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
  2888. for (; i-- && (token = tokens[i], !Expr.relative[type = token.type]);) {
  2889. if ((find = Expr.find[type]) && (seed = find(token.matches[0].replace(start, name), RE_PSEUDOS.test(tokens[0].type) && testContext(context.parentNode) || context))) {
  2890. if (tokens.splice(i, 1), selector = seed.length && toSelector(tokens), !selector) {
  2891. return push.apply(results, seed), results;
  2892. }
  2893. break;
  2894. }
  2895. }
  2896. }
  2897. return (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || RE_PSEUDOS.test(selector) && testContext(context.parentNode) || context), results;
  2898. }, support.sortStable = expando.split("").sort(time).join("") === expando, support.detectDuplicates = !!ret, setDocument(), support.sortDetached = assert(function(html) {
  2899. return 1 & html.compareDocumentPosition(document.createElement("fieldset"));
  2900. }), assert(function(aItem) {
  2901. return aItem.innerHTML = "<a href='#'></a>", "#" === aItem.firstChild.getAttribute("href");
  2902. }) || addHandle("type|href|height|width", function(e, t, n) {
  2903. if (!n) {
  2904. return e.getAttribute(t, "type" === t.toLowerCase() ? 1 : 2);
  2905. }
  2906. }), support.attributes && assert(function(aItem) {
  2907. return aItem.innerHTML = "<input/>", aItem.firstChild.setAttribute("value", ""), "" === aItem.firstChild.getAttribute("value");
  2908. }) || addHandle("value", function(src, canCreateDiscussions, n) {
  2909. if (!n && "input" === src.nodeName.toLowerCase()) {
  2910. return src.defaultValue;
  2911. }
  2912. }), assert(function(e) {
  2913. return null == e.getAttribute("disabled");
  2914. }) || addHandle(value, function(elem, name, n) {
  2915. var val;
  2916. if (!n) {
  2917. return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  2918. }
  2919. }), Sizzle;
  2920. }(window);
  2921. jQuery.find = Sizzle;
  2922. jQuery.expr = Sizzle.selectors;
  2923. jQuery.expr[":"] = jQuery.expr.pseudos;
  2924. jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
  2925. jQuery.text = Sizzle.getText;
  2926. jQuery.isXMLDoc = Sizzle.isXML;
  2927. jQuery.contains = Sizzle.contains;
  2928. jQuery.escapeSelector = Sizzle.escape;
  2929. /**
  2930. * @param {!Object} elem
  2931. * @param {string} dir
  2932. * @param {?} until
  2933. * @return {?}
  2934. */
  2935. var dir = function(elem, dir, until) {
  2936. /** @type {!Array} */
  2937. var matched = [];
  2938. /** @type {boolean} */
  2939. var truncate = void 0 !== until;
  2940. for (; (elem = elem[dir]) && 9 !== elem.nodeType;) {
  2941. if (1 === elem.nodeType) {
  2942. if (truncate && jQuery(elem).is(until)) {
  2943. break;
  2944. }
  2945. matched.push(elem);
  2946. }
  2947. }
  2948. return matched;
  2949. };
  2950. /**
  2951. * @param {!Object} node
  2952. * @param {!Object} elem
  2953. * @return {?}
  2954. */
  2955. var _sibling = function(node, elem) {
  2956. /** @type {!Array} */
  2957. var result = [];
  2958. for (; node; node = node.nextSibling) {
  2959. if (1 === node.nodeType && node !== elem) {
  2960. result.push(node);
  2961. }
  2962. }
  2963. return result;
  2964. };
  2965. var rneedsContext = jQuery.expr.match.needsContext;
  2966. /** @type {!RegExp} */
  2967. var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;
  2968. /** @type {!RegExp} */
  2969. var risSimple = /^.[^:#\[\.,]*$/;
  2970. /**
  2971. * @param {string} expr
  2972. * @param {!Object} elems
  2973. * @param {string} not
  2974. * @return {?}
  2975. */
  2976. jQuery.filter = function(expr, elems, not) {
  2977. var elem = elems[0];
  2978. return not && (expr = ":not(" + expr + ")"), 1 === elems.length && 1 === elem.nodeType ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function(nodeToInspect) {
  2979. return 1 === nodeToInspect.nodeType;
  2980. }));
  2981. };
  2982. jQuery.fn.extend({
  2983. find : function(elem) {
  2984. var i;
  2985. var ret;
  2986. var len = this.length;
  2987. var self = this;
  2988. if ("string" != typeof elem) {
  2989. return this.pushStack(jQuery(elem).filter(function() {
  2990. /** @type {number} */
  2991. i = 0;
  2992. for (; i < len; i++) {
  2993. if (jQuery.contains(self[i], this)) {
  2994. return true;
  2995. }
  2996. }
  2997. }));
  2998. }
  2999. ret = this.pushStack([]);
  3000. /** @type {number} */
  3001. i = 0;
  3002. for (; i < len; i++) {
  3003. jQuery.find(elem, self[i], ret);
  3004. }
  3005. return len > 1 ? jQuery.uniqueSort(ret) : ret;
  3006. },
  3007. filter : function(selector) {
  3008. return this.pushStack(winnow(this, selector || [], false));
  3009. },
  3010. not : function(selector) {
  3011. return this.pushStack(winnow(this, selector || [], true));
  3012. },
  3013. is : function(arg) {
  3014. return !!winnow(this, "string" == typeof arg && rneedsContext.test(arg) ? jQuery(arg) : arg || [], false).length;
  3015. }
  3016. });
  3017. var rootjQuery;
  3018. /** @type {!RegExp} */
  3019. var customSelectorReg = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;
  3020. /** @type {function(!Object, !Object, !Object): ?} */
  3021. var init = jQuery.fn.init = function(selector, context, root) {
  3022. var match;
  3023. var i;
  3024. if (!selector) {
  3025. return this;
  3026. }
  3027. if (root = root || rootjQuery, "string" == typeof selector) {
  3028. if (match = "<" === selector[0] && ">" === selector[selector.length - 1] && selector.length >= 3 ? [null, selector, null] : customSelectorReg.exec(selector), !match || !match[1] && context) {
  3029. return !context || context.jquery ? (context || root).find(selector) : this.constructor(context).find(selector);
  3030. }
  3031. if (match[1]) {
  3032. if (context = context instanceof jQuery ? context[0] : context, jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)), rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
  3033. for (match in context) {
  3034. if (jQuery.isFunction(this[match])) {
  3035. this[match](context[match]);
  3036. } else {
  3037. this.attr(match, context[match]);
  3038. }
  3039. }
  3040. }
  3041. return this;
  3042. }
  3043. return i = document.getElementById(match[2]), i && (this[0] = i, this.length = 1), this;
  3044. }
  3045. return selector.nodeType ? (this[0] = selector, this.length = 1, this) : jQuery.isFunction(selector) ? void 0 !== root.ready ? root.ready(selector) : selector(jQuery) : jQuery.makeArray(selector, this);
  3046. };
  3047. init.prototype = jQuery.fn;
  3048. rootjQuery = jQuery(document);
  3049. /** @type {!RegExp} */
  3050. var testRxp = /^(?:parents|prev(?:Until|All))/;
  3051. var guaranteedUnique = {
  3052. children : true,
  3053. contents : true,
  3054. next : true,
  3055. prev : true
  3056. };
  3057. jQuery.fn.extend({
  3058. has : function(name) {
  3059. var targets = jQuery(name, this);
  3060. var l = targets.length;
  3061. return this.filter(function() {
  3062. /** @type {number} */
  3063. var i = 0;
  3064. for (; i < l; i++) {
  3065. if (jQuery.contains(this, targets[i])) {
  3066. return true;
  3067. }
  3068. }
  3069. });
  3070. },
  3071. closest : function(selector, context) {
  3072. var cur;
  3073. /** @type {number} */
  3074. var i = 0;
  3075. var j = this.length;
  3076. /** @type {!Array} */
  3077. var ret = [];
  3078. var pos = "string" != typeof selector && jQuery(selector);
  3079. if (!rneedsContext.test(selector)) {
  3080. for (; i < j; i++) {
  3081. cur = this[i];
  3082. for (; cur && cur !== context; cur = cur.parentNode) {
  3083. if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 : 1 === cur.nodeType && jQuery.find.matchesSelector(cur, selector))) {
  3084. ret.push(cur);
  3085. break;
  3086. }
  3087. }
  3088. }
  3089. }
  3090. return this.pushStack(ret.length > 1 ? jQuery.uniqueSort(ret) : ret);
  3091. },
  3092. index : function(elem) {
  3093. return elem ? "string" == typeof elem ? indexOf.call(jQuery(elem), this[0]) : indexOf.call(this, elem.jquery ? elem[0] : elem) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
  3094. },
  3095. add : function(name, context) {
  3096. return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(name, context))));
  3097. },
  3098. addBack : function(selector) {
  3099. return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
  3100. }
  3101. });
  3102. jQuery.each({
  3103. parent : function(object) {
  3104. var n = object.parentNode;
  3105. return n && 11 !== n.nodeType ? n : null;
  3106. },
  3107. parents : function(elem) {
  3108. return dir(elem, "parentNode");
  3109. },
  3110. parentsUntil : function(elem, i, until) {
  3111. return dir(elem, "parentNode", until);
  3112. },
  3113. next : function(elem) {
  3114. return sibling(elem, "nextSibling");
  3115. },
  3116. prev : function(elem) {
  3117. return sibling(elem, "previousSibling");
  3118. },
  3119. nextAll : function(elem) {
  3120. return dir(elem, "nextSibling");
  3121. },
  3122. prevAll : function(elem) {
  3123. return dir(elem, "previousSibling");
  3124. },
  3125. nextUntil : function(elem, i, until) {
  3126. return dir(elem, "nextSibling", until);
  3127. },
  3128. prevUntil : function(elem, i, until) {
  3129. return dir(elem, "previousSibling", until);
  3130. },
  3131. siblings : function(elem) {
  3132. return _sibling((elem.parentNode || {}).firstChild, elem);
  3133. },
  3134. children : function(elem) {
  3135. return _sibling(elem.firstChild);
  3136. },
  3137. contents : function(elem) {
  3138. return elem.contentDocument || jQuery.merge([], elem.childNodes);
  3139. }
  3140. }, function(name, t) {
  3141. /**
  3142. * @param {boolean} s
  3143. * @param {boolean} string
  3144. * @return {?}
  3145. */
  3146. jQuery.fn[name] = function(s, string) {
  3147. var ret = jQuery.map(this, t, s);
  3148. return "Until" !== name.slice(-5) && (string = s), string && "string" == typeof string && (ret = jQuery.filter(string, ret)), this.length > 1 && (guaranteedUnique[name] || jQuery.uniqueSort(ret), testRxp.test(name) && ret.reverse()), this.pushStack(ret);
  3149. };
  3150. });
  3151. /** @type {!RegExp} */
  3152. var rnotwhite = /\S+/g;
  3153. /**
  3154. * @param {string} options
  3155. * @return {?}
  3156. */
  3157. jQuery.Callbacks = function(options) {
  3158. options = "string" == typeof options ? createOptions(options) : jQuery.extend({}, options);
  3159. var costSum;
  3160. var t;
  3161. var gasSum;
  3162. var a;
  3163. /** @type {!Array} */
  3164. var b = [];
  3165. /** @type {!Array} */
  3166. var d = [];
  3167. /** @type {number} */
  3168. var i = -1;
  3169. /**
  3170. * @return {undefined}
  3171. */
  3172. var fire = function() {
  3173. a = options.once;
  3174. /** @type {boolean} */
  3175. gasSum = costSum = true;
  3176. for (; d.length; i = -1) {
  3177. t = d.shift();
  3178. for (; ++i < b.length;) {
  3179. if (b[i].apply(t[0], t[1]) === false && options.stopOnFalse) {
  3180. i = b.length;
  3181. /** @type {boolean} */
  3182. t = false;
  3183. }
  3184. }
  3185. }
  3186. if (!options.memory) {
  3187. /** @type {boolean} */
  3188. t = false;
  3189. }
  3190. /** @type {boolean} */
  3191. costSum = false;
  3192. if (a) {
  3193. /** @type {(Array|string)} */
  3194. b = t ? [] : "";
  3195. }
  3196. };
  3197. var self = {
  3198. add : function() {
  3199. return b && (t && !costSum && (i = b.length - 1, d.push(t)), function add(callback) {
  3200. jQuery.each(callback, function(n, name) {
  3201. if (jQuery.isFunction(name)) {
  3202. if (!(options.unique && self.has(name))) {
  3203. b.push(name);
  3204. }
  3205. } else {
  3206. if (name && name.length && "string" !== jQuery.type(name)) {
  3207. add(name);
  3208. }
  3209. }
  3210. });
  3211. }(arguments), t && !costSum && fire()), this;
  3212. },
  3213. remove : function() {
  3214. return jQuery.each(arguments, function(canCreateDiscussions, t) {
  3215. var index;
  3216. for (; (index = jQuery.inArray(t, b, index)) > -1;) {
  3217. b.splice(index, 1);
  3218. if (index <= i) {
  3219. i--;
  3220. }
  3221. }
  3222. }), this;
  3223. },
  3224. has : function(className) {
  3225. return className ? jQuery.inArray(className, b) > -1 : b.length > 0;
  3226. },
  3227. empty : function() {
  3228. return b && (b = []), this;
  3229. },
  3230. disable : function() {
  3231. return a = d = [], b = t = "", this;
  3232. },
  3233. disabled : function() {
  3234. return !b;
  3235. },
  3236. lock : function() {
  3237. return a = d = [], t || costSum || (b = t = ""), this;
  3238. },
  3239. locked : function() {
  3240. return !!a;
  3241. },
  3242. fireWith : function(context, args) {
  3243. return a || (args = args || [], args = [context, args.slice ? args.slice() : args], d.push(args), costSum || fire()), this;
  3244. },
  3245. fire : function() {
  3246. return self.fireWith(this, arguments), this;
  3247. },
  3248. fired : function() {
  3249. return !!gasSum;
  3250. }
  3251. };
  3252. return self;
  3253. };
  3254. jQuery.extend({
  3255. Deferred : function(func) {
  3256. /** @type {!Array} */
  3257. var dest = [["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]];
  3258. /** @type {string} */
  3259. var state = "pending";
  3260. var promise = {
  3261. state : function() {
  3262. return state;
  3263. },
  3264. always : function() {
  3265. return deferred.done(arguments).fail(arguments), this;
  3266. },
  3267. catch : function(fn) {
  3268. return promise.then(null, fn);
  3269. },
  3270. pipe : function() {
  3271. /** @type {!Arguments} */
  3272. var values = arguments;
  3273. return jQuery.Deferred(function(newDefer) {
  3274. jQuery.each(dest, function(n, tuple) {
  3275. var fn = jQuery.isFunction(values[tuple[4]]) && values[tuple[4]];
  3276. deferred[tuple[1]](function() {
  3277. var returned = fn && fn.apply(this, arguments);
  3278. if (returned && jQuery.isFunction(returned.promise)) {
  3279. returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
  3280. } else {
  3281. newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments);
  3282. }
  3283. });
  3284. });
  3285. /** @type {null} */
  3286. values = null;
  3287. }).promise();
  3288. },
  3289. then : function(value, fn, d) {
  3290. /**
  3291. * @param {number} offset
  3292. * @param {!Object} options
  3293. * @param {!Function} item
  3294. * @param {boolean} args
  3295. * @return {?}
  3296. */
  3297. function callback(offset, options, item, args) {
  3298. return function() {
  3299. var context = this;
  3300. /** @type {!Arguments} */
  3301. var values = arguments;
  3302. /**
  3303. * @return {undefined}
  3304. */
  3305. var apply = function() {
  3306. var value;
  3307. var self;
  3308. if (!(offset < i)) {
  3309. if (value = item.apply(context, values), value === options.promise()) {
  3310. throw new TypeError("Thenable self-resolution");
  3311. }
  3312. self = value && ("object" == typeof value || "function" == typeof value) && value.then;
  3313. if (jQuery.isFunction(self)) {
  3314. if (args) {
  3315. self.call(value, callback(i, options, x, args), callback(i, options, undefined, args));
  3316. } else {
  3317. i++;
  3318. self.call(value, callback(i, options, x, args), callback(i, options, undefined, args), callback(i, options, x, options.notifyWith));
  3319. }
  3320. } else {
  3321. if (item !== x) {
  3322. context = void 0;
  3323. /** @type {!Array} */
  3324. values = [value];
  3325. }
  3326. (args || options.resolveWith)(context, values);
  3327. }
  3328. }
  3329. };
  3330. /** @type {function(): undefined} */
  3331. var method = args ? apply : function() {
  3332. try {
  3333. apply();
  3334. } catch (scheduled) {
  3335. if (jQuery.Deferred.exceptionHook) {
  3336. jQuery.Deferred.exceptionHook(scheduled, method.stackTrace);
  3337. }
  3338. if (offset + 1 >= i) {
  3339. if (item !== undefined) {
  3340. context = void 0;
  3341. /** @type {!Array} */
  3342. values = [scheduled];
  3343. }
  3344. options.rejectWith(context, values);
  3345. }
  3346. }
  3347. };
  3348. if (offset) {
  3349. method();
  3350. } else {
  3351. if (jQuery.Deferred.getStackHook) {
  3352. method.stackTrace = jQuery.Deferred.getStackHook();
  3353. }
  3354. window.setTimeout(method);
  3355. }
  3356. };
  3357. }
  3358. /** @type {number} */
  3359. var i = 0;
  3360. return jQuery.Deferred(function(self) {
  3361. dest[0][3].add(callback(0, self, jQuery.isFunction(d) ? d : x, self.notifyWith));
  3362. dest[1][3].add(callback(0, self, jQuery.isFunction(value) ? value : x));
  3363. dest[2][3].add(callback(0, self, jQuery.isFunction(fn) ? fn : undefined));
  3364. }).promise();
  3365. },
  3366. promise : function(context) {
  3367. return null != context ? jQuery.extend(context, promise) : promise;
  3368. }
  3369. };
  3370. var deferred = {};
  3371. return jQuery.each(dest, function(i, tuple) {
  3372. var list = tuple[2];
  3373. var stateString = tuple[5];
  3374. promise[tuple[1]] = list.add;
  3375. if (stateString) {
  3376. list.add(function() {
  3377. state = stateString;
  3378. }, dest[3 - i][2].disable, dest[0][2].lock);
  3379. }
  3380. list.add(tuple[3].fire);
  3381. /**
  3382. * @return {?}
  3383. */
  3384. deferred[tuple[0]] = function() {
  3385. return deferred[tuple[0] + "With"](this === deferred ? void 0 : this, arguments), this;
  3386. };
  3387. deferred[tuple[0] + "With"] = list.fireWith;
  3388. }), promise.promise(deferred), func && func.call(deferred, deferred), deferred;
  3389. },
  3390. when : function(data) {
  3391. /** @type {number} */
  3392. var sampleSize = arguments.length;
  3393. var i = sampleSize;
  3394. /** @type {!Array} */
  3395. var elements = Array(i);
  3396. /** @type {!Array<?>} */
  3397. var args = slice.call(arguments);
  3398. var d = jQuery.Deferred();
  3399. /**
  3400. * @param {undefined} i
  3401. * @return {?}
  3402. */
  3403. var updateFn = function(i) {
  3404. return function(value) {
  3405. elements[i] = this;
  3406. args[i] = arguments.length > 1 ? slice.call(arguments) : value;
  3407. if (!--sampleSize) {
  3408. d.resolveWith(elements, args);
  3409. }
  3410. };
  3411. };
  3412. if (sampleSize <= 1 && (when(data, d.done(updateFn(i)).resolve, d.reject), "pending" === d.state() || jQuery.isFunction(args[i] && args[i].then))) {
  3413. return d.then();
  3414. }
  3415. for (; i--;) {
  3416. when(args[i], updateFn(i), d.reject);
  3417. }
  3418. return d.promise();
  3419. }
  3420. });
  3421. /** @type {!RegExp} */
  3422. var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
  3423. /**
  3424. * @param {?} error
  3425. * @param {?} stack
  3426. * @return {undefined}
  3427. */
  3428. jQuery.Deferred.exceptionHook = function(error, stack) {
  3429. if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
  3430. window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
  3431. }
  3432. };
  3433. /**
  3434. * @param {?} error
  3435. * @return {undefined}
  3436. */
  3437. jQuery.readyException = function(error) {
  3438. window.setTimeout(function() {
  3439. throw error;
  3440. });
  3441. };
  3442. var context = jQuery.Deferred();
  3443. /**
  3444. * @param {boolean} selector
  3445. * @return {?}
  3446. */
  3447. jQuery.fn.ready = function(selector) {
  3448. return context.then(selector).catch(function(e) {
  3449. jQuery.readyException(e);
  3450. }), this;
  3451. };
  3452. jQuery.extend({
  3453. isReady : false,
  3454. readyWait : 1,
  3455. holdReady : function(hold) {
  3456. if (hold) {
  3457. jQuery.readyWait++;
  3458. } else {
  3459. jQuery.ready(true);
  3460. }
  3461. },
  3462. ready : function(wait) {
  3463. if (!(wait === true ? --jQuery.readyWait : jQuery.isReady)) {
  3464. /** @type {boolean} */
  3465. jQuery.isReady = true;
  3466. if (!(wait !== true && --jQuery.readyWait > 0)) {
  3467. context.resolveWith(document, [jQuery]);
  3468. }
  3469. }
  3470. }
  3471. });
  3472. jQuery.ready.then = context.then;
  3473. if ("complete" === document.readyState || "loading" !== document.readyState && !document.documentElement.doScroll) {
  3474. window.setTimeout(jQuery.ready);
  3475. } else {
  3476. document.addEventListener("DOMContentLoaded", $__jsx_onload);
  3477. window.addEventListener("load", $__jsx_onload);
  3478. }
  3479. /**
  3480. * @param {string} elems
  3481. * @param {!Function} fn
  3482. * @param {string} key
  3483. * @param {?} value
  3484. * @param {number} chainable
  3485. * @param {string} emptyGet
  3486. * @param {boolean} raw
  3487. * @return {?}
  3488. */
  3489. var access = function(elems, fn, key, value, chainable, emptyGet, raw) {
  3490. /** @type {number} */
  3491. var name = 0;
  3492. var len = elems.length;
  3493. /** @type {boolean} */
  3494. var bulk = null == key;
  3495. if ("object" === jQuery.type(key)) {
  3496. /** @type {boolean} */
  3497. chainable = true;
  3498. for (name in key) {
  3499. access(elems, fn, name, key[name], true, emptyGet, raw);
  3500. }
  3501. } else {
  3502. if (void 0 !== value && (chainable = true, jQuery.isFunction(value) || (raw = true), bulk && (raw ? (fn.call(elems, value), fn = null) : (bulk = fn, fn = function(elem, value, arg1) {
  3503. return bulk.call(jQuery(elem), arg1);
  3504. })), fn)) {
  3505. for (; name < len; name++) {
  3506. fn(elems[name], key, raw ? value : value.call(elems[name], name, fn(elems[name], key)));
  3507. }
  3508. }
  3509. }
  3510. return chainable ? elems : bulk ? fn.call(elems) : len ? fn(elems[0], key) : emptyGet;
  3511. };
  3512. /**
  3513. * @param {!Object} elem
  3514. * @return {?}
  3515. */
  3516. var acceptData = function(elem) {
  3517. return 1 === elem.nodeType || 9 === elem.nodeType || !+elem.nodeType;
  3518. };
  3519. /** @type {number} */
  3520. Data.uid = 1;
  3521. Data.prototype = {
  3522. cache : function(elem) {
  3523. var value = elem[this.expando];
  3524. return value || (value = {}, acceptData(elem) && (elem.nodeType ? elem[this.expando] = value : Object.defineProperty(elem, this.expando, {
  3525. value : value,
  3526. configurable : true
  3527. }))), value;
  3528. },
  3529. set : function(data, key, prop) {
  3530. var p;
  3531. var result = this.cache(data);
  3532. if ("string" == typeof key) {
  3533. result[jQuery.camelCase(key)] = prop;
  3534. } else {
  3535. for (p in key) {
  3536. result[jQuery.camelCase(p)] = key[p];
  3537. }
  3538. }
  3539. return result;
  3540. },
  3541. get : function(data, key) {
  3542. return void 0 === key ? this.cache(data) : data[this.expando] && data[this.expando][jQuery.camelCase(key)];
  3543. },
  3544. access : function(value, fn, o) {
  3545. return void 0 === fn || fn && "string" == typeof fn && void 0 === o ? this.get(value, fn) : (this.set(value, fn, o), void 0 !== o ? o : fn);
  3546. },
  3547. remove : function(owner, key) {
  3548. var j;
  3549. var value = owner[this.expando];
  3550. if (void 0 !== value) {
  3551. if (void 0 !== key) {
  3552. if (jQuery.isArray(key)) {
  3553. key = key.map(jQuery.camelCase);
  3554. } else {
  3555. key = jQuery.camelCase(key);
  3556. key = key in value ? [key] : key.match(rnotwhite) || [];
  3557. }
  3558. j = key.length;
  3559. for (; j--;) {
  3560. delete value[key[j]];
  3561. }
  3562. }
  3563. if (void 0 === key || jQuery.isEmptyObject(value)) {
  3564. if (owner.nodeType) {
  3565. owner[this.expando] = void 0;
  3566. } else {
  3567. delete owner[this.expando];
  3568. }
  3569. }
  3570. }
  3571. },
  3572. hasData : function(owner) {
  3573. var cache = owner[this.expando];
  3574. return void 0 !== cache && !jQuery.isEmptyObject(cache);
  3575. }
  3576. };
  3577. var dataPriv = new Data;
  3578. var $ = new Data;
  3579. /** @type {!RegExp} */
  3580. var JSON_START = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
  3581. /** @type {!RegExp} */
  3582. var rhyphen = /[A-Z]/g;
  3583. jQuery.extend({
  3584. hasData : function(elem) {
  3585. return $.hasData(elem) || dataPriv.hasData(elem);
  3586. },
  3587. data : function(elem, name, value) {
  3588. return $.access(elem, name, value);
  3589. },
  3590. removeData : function(elem, key) {
  3591. $.remove(elem, key);
  3592. },
  3593. _data : function(elem, name, data) {
  3594. return dataPriv.access(elem, name, data);
  3595. },
  3596. _removeData : function(elem, name) {
  3597. dataPriv.remove(elem, name);
  3598. }
  3599. });
  3600. jQuery.fn.extend({
  3601. data : function(value, args) {
  3602. var w;
  3603. var name;
  3604. var data;
  3605. var elem = this[0];
  3606. var root = elem && elem.attributes;
  3607. if (void 0 === value) {
  3608. if (this.length && (data = $.get(elem), 1 === elem.nodeType && !dataPriv.get(elem, "hasDataAttrs"))) {
  3609. w = root.length;
  3610. for (; w--;) {
  3611. if (root[w]) {
  3612. name = root[w].name;
  3613. if (0 === name.indexOf("data-")) {
  3614. name = jQuery.camelCase(name.slice(5));
  3615. set(elem, name, data[name]);
  3616. }
  3617. }
  3618. }
  3619. dataPriv.set(elem, "hasDataAttrs", true);
  3620. }
  3621. return data;
  3622. }
  3623. return "object" == typeof value ? this.each(function() {
  3624. $.set(this, value);
  3625. }) : access(this, function(name) {
  3626. var data;
  3627. if (elem && void 0 === name) {
  3628. if (data = $.get(elem, value), void 0 !== data) {
  3629. return data;
  3630. }
  3631. if (data = set(elem, value), void 0 !== data) {
  3632. return data;
  3633. }
  3634. } else {
  3635. this.each(function() {
  3636. $.set(this, value, name);
  3637. });
  3638. }
  3639. }, null, args, arguments.length > 1, null, true);
  3640. },
  3641. removeData : function(key) {
  3642. return this.each(function() {
  3643. $.remove(this, key);
  3644. });
  3645. }
  3646. });
  3647. jQuery.extend({
  3648. queue : function(elem, type, data) {
  3649. var q;
  3650. if (elem) {
  3651. return type = (type || "fx") + "queue", q = dataPriv.get(elem, type), data && (!q || jQuery.isArray(data) ? q = dataPriv.access(elem, type, jQuery.makeArray(data)) : q.push(data)), q || [];
  3652. }
  3653. },
  3654. dequeue : function(elem, type) {
  3655. type = type || "fx";
  3656. var queue = jQuery.queue(elem, type);
  3657. var i = queue.length;
  3658. var listener = queue.shift();
  3659. var handle = jQuery._queueHooks(elem, type);
  3660. /**
  3661. * @return {undefined}
  3662. */
  3663. var next = function() {
  3664. jQuery.dequeue(elem, type);
  3665. };
  3666. if ("inprogress" === listener) {
  3667. listener = queue.shift();
  3668. i--;
  3669. }
  3670. if (listener) {
  3671. if ("fx" === type) {
  3672. queue.unshift("inprogress");
  3673. }
  3674. delete handle.stop;
  3675. listener.call(elem, next, handle);
  3676. }
  3677. if (!i && handle) {
  3678. handle.empty.fire();
  3679. }
  3680. },
  3681. _queueHooks : function(elem, type) {
  3682. /** @type {string} */
  3683. var key = type + "queueHooks";
  3684. return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
  3685. empty : jQuery.Callbacks("once memory").add(function() {
  3686. dataPriv.remove(elem, [type + "queue", key]);
  3687. })
  3688. });
  3689. }
  3690. });
  3691. jQuery.fn.extend({
  3692. queue : function(type, data) {
  3693. /** @type {number} */
  3694. var setter = 2;
  3695. return "string" != typeof type && (data = type, type = "fx", setter--), arguments.length < setter ? jQuery.queue(this[0], type) : void 0 === data ? this : this.each(function() {
  3696. var queue = jQuery.queue(this, type, data);
  3697. jQuery._queueHooks(this, type);
  3698. if ("fx" === type && "inprogress" !== queue[0]) {
  3699. jQuery.dequeue(this, type);
  3700. }
  3701. });
  3702. },
  3703. dequeue : function(type) {
  3704. return this.each(function() {
  3705. jQuery.dequeue(this, type);
  3706. });
  3707. },
  3708. clearQueue : function(type) {
  3709. return this.queue(type || "fx", []);
  3710. },
  3711. promise : function(type, obj) {
  3712. var tmp;
  3713. /** @type {number} */
  3714. var r = 1;
  3715. var defer = jQuery.Deferred();
  3716. var elements = this;
  3717. var i = this.length;
  3718. /**
  3719. * @return {undefined}
  3720. */
  3721. var resolve = function() {
  3722. if (!--r) {
  3723. defer.resolveWith(elements, [elements]);
  3724. }
  3725. };
  3726. if ("string" != typeof type) {
  3727. /** @type {string} */
  3728. obj = type;
  3729. type = void 0;
  3730. }
  3731. type = type || "fx";
  3732. for (; i--;) {
  3733. tmp = dataPriv.get(elements[i], type + "queueHooks");
  3734. if (tmp && tmp.empty) {
  3735. r++;
  3736. tmp.empty.add(resolve);
  3737. }
  3738. }
  3739. return resolve(), defer.promise(obj);
  3740. }
  3741. });
  3742. /** @type {string} */
  3743. var FSSource = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
  3744. /** @type {!RegExp} */
  3745. var regex = new RegExp("^(?:([+-])=|)(" + FSSource + ")([a-z%]*)$", "i");
  3746. /** @type {!Array} */
  3747. var cssExpand = ["Top", "Right", "Bottom", "Left"];
  3748. /**
  3749. * @param {!Element} element
  3750. * @param {!Element} root
  3751. * @return {?}
  3752. */
  3753. var isHidden = function(element, root) {
  3754. return element = root || element, "none" === element.style.display || "" === element.style.display && jQuery.contains(element.ownerDocument, element) && "none" === jQuery.css(element, "display");
  3755. };
  3756. /**
  3757. * @param {!Object} elem
  3758. * @param {!Array} options
  3759. * @param {!Function} callback
  3760. * @param {number} args
  3761. * @return {?}
  3762. */
  3763. var swap = function(elem, options, callback, args) {
  3764. var ret;
  3765. var prop;
  3766. var originObject = {};
  3767. for (prop in options) {
  3768. originObject[prop] = elem.style[prop];
  3769. elem.style[prop] = options[prop];
  3770. }
  3771. ret = callback.apply(elem, args || []);
  3772. for (prop in options) {
  3773. elem.style[prop] = originObject[prop];
  3774. }
  3775. return ret;
  3776. };
  3777. var defaultDisplayMap = {};
  3778. jQuery.fn.extend({
  3779. show : function() {
  3780. return showHide(this, true);
  3781. },
  3782. hide : function() {
  3783. return showHide(this);
  3784. },
  3785. toggle : function(state) {
  3786. return "boolean" == typeof state ? state ? this.show() : this.hide() : this.each(function() {
  3787. if (isHidden(this)) {
  3788. jQuery(this).show();
  3789. } else {
  3790. jQuery(this).hide();
  3791. }
  3792. });
  3793. }
  3794. });
  3795. /** @type {!RegExp} */
  3796. var reg = /^(?:checkbox|radio)$/i;
  3797. /** @type {!RegExp} */
  3798. var fullLinkRegex = /<([a-z][^\/\0>\x20\t\r\n\f]+)/i;
  3799. /** @type {!RegExp} */
  3800. var opacityRe = /^$|\/(?:java|ecma)script/i;
  3801. var wrapMap = {
  3802. option : [1, "<select multiple='multiple'>", "</select>"],
  3803. thead : [1, "<table>", "</table>"],
  3804. col : [2, "<table><colgroup>", "</colgroup></table>"],
  3805. tr : [2, "<table><tbody>", "</tbody></table>"],
  3806. td : [3, "<table><tbody><tr>", "</tr></tbody></table>"],
  3807. _default : [0, "", ""]
  3808. };
  3809. /** @type {!Array} */
  3810. wrapMap.optgroup = wrapMap.option;
  3811. /** @type {!Array} */
  3812. wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  3813. /** @type {!Array} */
  3814. wrapMap.th = wrapMap.td;
  3815. /** @type {!RegExp} */
  3816. var re_commas = /<|&#?\w+;/;
  3817. !function() {
  3818. var text_screen = document.createDocumentFragment();
  3819. var t = text_screen.appendChild(document.createElement("div"));
  3820. var input = document.createElement("input");
  3821. input.setAttribute("type", "radio");
  3822. input.setAttribute("checked", "checked");
  3823. input.setAttribute("name", "t");
  3824. t.appendChild(input);
  3825. support.checkClone = t.cloneNode(true).cloneNode(true).lastChild.checked;
  3826. /** @type {string} */
  3827. t.innerHTML = "<textarea>x</textarea>";
  3828. /** @type {boolean} */
  3829. support.noCloneChecked = !!t.cloneNode(true).lastChild.defaultValue;
  3830. }();
  3831. var docElem = document.documentElement;
  3832. /** @type {!RegExp} */
  3833. var receivedTestEndEvents = /^key/;
  3834. /** @type {!RegExp} */
  3835. var receivedErrorEvents = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
  3836. /** @type {!RegExp} */
  3837. var result = /^([^.]*)(?:\.(.+)|)/;
  3838. jQuery.event = {
  3839. global : {},
  3840. add : function(elem, path, handler, data, selector) {
  3841. var handleObjIn;
  3842. var eventHandle;
  3843. var tmp;
  3844. var events;
  3845. var i;
  3846. var handleObj;
  3847. var special;
  3848. var handlers;
  3849. var type;
  3850. var h;
  3851. var origType;
  3852. var elemData = dataPriv.get(elem);
  3853. if (elemData) {
  3854. if (handler.handler) {
  3855. /** @type {!Object} */
  3856. handleObjIn = handler;
  3857. handler = handleObjIn.handler;
  3858. selector = handleObjIn.selector;
  3859. }
  3860. if (selector) {
  3861. jQuery.find.matchesSelector(docElem, selector);
  3862. }
  3863. if (!handler.guid) {
  3864. /** @type {number} */
  3865. handler.guid = jQuery.guid++;
  3866. }
  3867. if (!(events = elemData.events)) {
  3868. events = elemData.events = {};
  3869. }
  3870. if (!(eventHandle = elemData.handle)) {
  3871. /** @type {function(!Object): ?} */
  3872. eventHandle = elemData.handle = function(e) {
  3873. return "undefined" != typeof jQuery && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : void 0;
  3874. };
  3875. }
  3876. path = (path || "").match(rnotwhite) || [""];
  3877. i = path.length;
  3878. for (; i--;) {
  3879. /** @type {!Array} */
  3880. tmp = result.exec(path[i]) || [];
  3881. type = origType = tmp[1];
  3882. h = (tmp[2] || "").split(".").sort();
  3883. if (type) {
  3884. special = jQuery.event.special[type] || {};
  3885. type = (selector ? special.delegateType : special.bindType) || type;
  3886. special = jQuery.event.special[type] || {};
  3887. handleObj = jQuery.extend({
  3888. type : type,
  3889. origType : origType,
  3890. data : data,
  3891. handler : handler,
  3892. guid : handler.guid,
  3893. selector : selector,
  3894. needsContext : selector && jQuery.expr.match.needsContext.test(selector),
  3895. namespace : h.join(".")
  3896. }, handleObjIn);
  3897. if (!(handlers = events[type])) {
  3898. /** @type {!Array} */
  3899. handlers = events[type] = [];
  3900. /** @type {number} */
  3901. handlers.delegateCount = 0;
  3902. if (!(special.setup && special.setup.call(elem, data, h, eventHandle) !== false)) {
  3903. if (elem.addEventListener) {
  3904. elem.addEventListener(type, eventHandle);
  3905. }
  3906. }
  3907. }
  3908. if (special.add) {
  3909. special.add.call(elem, handleObj);
  3910. if (!handleObj.handler.guid) {
  3911. handleObj.handler.guid = handler.guid;
  3912. }
  3913. }
  3914. if (selector) {
  3915. handlers.splice(handlers.delegateCount++, 0, handleObj);
  3916. } else {
  3917. handlers.push(handleObj);
  3918. }
  3919. /** @type {boolean} */
  3920. jQuery.event.global[type] = true;
  3921. }
  3922. }
  3923. }
  3924. },
  3925. remove : function(elem, types, handler, selector, mappedTypes) {
  3926. var j;
  3927. var origCount;
  3928. var tmp;
  3929. var events;
  3930. var t;
  3931. var handleObj;
  3932. var special;
  3933. var handlers;
  3934. var type;
  3935. var h;
  3936. var origType;
  3937. var elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
  3938. if (elemData && (events = elemData.events)) {
  3939. types = (types || "").match(rnotwhite) || [""];
  3940. t = types.length;
  3941. for (; t--;) {
  3942. if (tmp = result.exec(types[t]) || [], type = origType = tmp[1], h = (tmp[2] || "").split(".").sort(), type) {
  3943. special = jQuery.event.special[type] || {};
  3944. type = (selector ? special.delegateType : special.bindType) || type;
  3945. handlers = events[type] || [];
  3946. tmp = tmp[2] && new RegExp("(^|\\.)" + h.join("\\.(?:.*\\.|)") + "(\\.|$)");
  3947. origCount = j = handlers.length;
  3948. for (; j--;) {
  3949. handleObj = handlers[j];
  3950. if (!(!mappedTypes && origType !== handleObj.origType || handler && handler.guid !== handleObj.guid || tmp && !tmp.test(handleObj.namespace) || selector && selector !== handleObj.selector && ("**" !== selector || !handleObj.selector))) {
  3951. handlers.splice(j, 1);
  3952. if (handleObj.selector) {
  3953. handlers.delegateCount--;
  3954. }
  3955. if (special.remove) {
  3956. special.remove.call(elem, handleObj);
  3957. }
  3958. }
  3959. }
  3960. if (origCount && !handlers.length) {
  3961. if (!(special.teardown && special.teardown.call(elem, h, elemData.handle) !== false)) {
  3962. jQuery.removeEvent(elem, type, elemData.handle);
  3963. }
  3964. delete events[type];
  3965. }
  3966. } else {
  3967. for (type in events) {
  3968. jQuery.event.remove(elem, type + types[t], handler, selector, true);
  3969. }
  3970. }
  3971. }
  3972. if (jQuery.isEmptyObject(events)) {
  3973. dataPriv.remove(elem, "handle events");
  3974. }
  3975. }
  3976. },
  3977. dispatch : function(e) {
  3978. var i;
  3979. var j;
  3980. var ret;
  3981. var matched;
  3982. var handleObj;
  3983. var handlerQueue;
  3984. var event = jQuery.event.fix(e);
  3985. /** @type {!Array} */
  3986. var args = new Array(arguments.length);
  3987. var handlers = (dataPriv.get(this, "events") || {})[event.type] || [];
  3988. var special = jQuery.event.special[event.type] || {};
  3989. args[0] = event;
  3990. /** @type {number} */
  3991. i = 1;
  3992. for (; i < arguments.length; i++) {
  3993. args[i] = arguments[i];
  3994. }
  3995. if (event.delegateTarget = this, !special.preDispatch || special.preDispatch.call(this, event) !== false) {
  3996. handlerQueue = jQuery.event.handlers.call(this, event, handlers);
  3997. /** @type {number} */
  3998. i = 0;
  3999. for (; (matched = handlerQueue[i++]) && !event.isPropagationStopped();) {
  4000. event.currentTarget = matched.elem;
  4001. /** @type {number} */
  4002. j = 0;
  4003. for (; (handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped();) {
  4004. if (!(event.rnamespace && !event.rnamespace.test(handleObj.namespace))) {
  4005. event.handleObj = handleObj;
  4006. event.data = handleObj.data;
  4007. ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
  4008. if (void 0 !== ret && (event.result = ret) === false) {
  4009. event.preventDefault();
  4010. event.stopPropagation();
  4011. }
  4012. }
  4013. }
  4014. }
  4015. return special.postDispatch && special.postDispatch.call(this, event), event.result;
  4016. }
  4017. },
  4018. handlers : function(event, handlers) {
  4019. var i;
  4020. var matches;
  4021. var a;
  4022. var handleObj;
  4023. /** @type {!Array} */
  4024. var handlerQueue = [];
  4025. var delegateCount = handlers.delegateCount;
  4026. var cur = event.target;
  4027. if (delegateCount && cur.nodeType && ("click" !== event.type || isNaN(event.button) || event.button < 1)) {
  4028. for (; cur !== this; cur = cur.parentNode || this) {
  4029. if (1 === cur.nodeType && (cur.disabled !== true || "click" !== event.type)) {
  4030. /** @type {!Array} */
  4031. matches = [];
  4032. /** @type {number} */
  4033. i = 0;
  4034. for (; i < delegateCount; i++) {
  4035. handleObj = handlers[i];
  4036. /** @type {string} */
  4037. a = handleObj.selector + " ";
  4038. if (void 0 === matches[a]) {
  4039. matches[a] = handleObj.needsContext ? jQuery(a, this).index(cur) > -1 : jQuery.find(a, this, null, [cur]).length;
  4040. }
  4041. if (matches[a]) {
  4042. matches.push(handleObj);
  4043. }
  4044. }
  4045. if (matches.length) {
  4046. handlerQueue.push({
  4047. elem : cur,
  4048. handlers : matches
  4049. });
  4050. }
  4051. }
  4052. }
  4053. }
  4054. return delegateCount < handlers.length && handlerQueue.push({
  4055. elem : this,
  4056. handlers : handlers.slice(delegateCount)
  4057. }), handlerQueue;
  4058. },
  4059. addProp : function(name, hook) {
  4060. Object.defineProperty(jQuery.Event.prototype, name, {
  4061. enumerable : true,
  4062. configurable : true,
  4063. get : jQuery.isFunction(hook) ? function() {
  4064. if (this.originalEvent) {
  4065. return hook(this.originalEvent);
  4066. }
  4067. } : function() {
  4068. if (this.originalEvent) {
  4069. return this.originalEvent[name];
  4070. }
  4071. },
  4072. set : function(type) {
  4073. Object.defineProperty(this, name, {
  4074. enumerable : true,
  4075. configurable : true,
  4076. writable : true,
  4077. value : type
  4078. });
  4079. }
  4080. });
  4081. },
  4082. fix : function(originalEvent) {
  4083. return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
  4084. },
  4085. special : {
  4086. load : {
  4087. noBubble : true
  4088. },
  4089. focus : {
  4090. trigger : function() {
  4091. if (this !== safeActiveElement() && this.focus) {
  4092. return this.focus(), false;
  4093. }
  4094. },
  4095. delegateType : "focusin"
  4096. },
  4097. blur : {
  4098. trigger : function() {
  4099. if (this === safeActiveElement() && this.blur) {
  4100. return this.blur(), false;
  4101. }
  4102. },
  4103. delegateType : "focusout"
  4104. },
  4105. click : {
  4106. trigger : function() {
  4107. if ("checkbox" === this.type && this.click && jQuery.nodeName(this, "input")) {
  4108. return this.click(), false;
  4109. }
  4110. },
  4111. _default : function(e) {
  4112. return jQuery.nodeName(e.target, "a");
  4113. }
  4114. },
  4115. beforeunload : {
  4116. postDispatch : function(event) {
  4117. if (void 0 !== event.result && event.originalEvent) {
  4118. event.originalEvent.returnValue = event.result;
  4119. }
  4120. }
  4121. }
  4122. }
  4123. };
  4124. /**
  4125. * @param {!Object} elem
  4126. * @param {!Object} type
  4127. * @param {?} fn
  4128. * @return {undefined}
  4129. */
  4130. jQuery.removeEvent = function(elem, type, fn) {
  4131. if (elem.removeEventListener) {
  4132. elem.removeEventListener(type, fn);
  4133. }
  4134. };
  4135. /**
  4136. * @param {!Object} src
  4137. * @param {string} options
  4138. * @return {?}
  4139. */
  4140. jQuery.Event = function(src, options) {
  4141. return this instanceof jQuery.Event ? (src && src.type ? (this.originalEvent = src, this.type = src.type, this.isDefaultPrevented = src.defaultPrevented || void 0 === src.defaultPrevented && src.returnValue === false ? returnTrue : returnFalse, this.target = src.target && 3 === src.target.nodeType ? src.target.parentNode : src.target, this.currentTarget = src.currentTarget, this.relatedTarget = src.relatedTarget) : this.type = src, options && jQuery.extend(this, options), this.timeStamp =
  4142. src && src.timeStamp || jQuery.now(), void(this[jQuery.expando] = true)) : new jQuery.Event(src, options);
  4143. };
  4144. jQuery.Event.prototype = {
  4145. constructor : jQuery.Event,
  4146. isDefaultPrevented : returnFalse,
  4147. isPropagationStopped : returnFalse,
  4148. isImmediatePropagationStopped : returnFalse,
  4149. isSimulated : false,
  4150. preventDefault : function() {
  4151. var e = this.originalEvent;
  4152. /** @type {function(): ?} */
  4153. this.isDefaultPrevented = returnTrue;
  4154. if (e && !this.isSimulated) {
  4155. e.preventDefault();
  4156. }
  4157. },
  4158. stopPropagation : function() {
  4159. var e = this.originalEvent;
  4160. /** @type {function(): ?} */
  4161. this.isPropagationStopped = returnTrue;
  4162. if (e && !this.isSimulated) {
  4163. e.stopPropagation();
  4164. }
  4165. },
  4166. stopImmediatePropagation : function() {
  4167. var e = this.originalEvent;
  4168. /** @type {function(): ?} */
  4169. this.isImmediatePropagationStopped = returnTrue;
  4170. if (e && !this.isSimulated) {
  4171. e.stopImmediatePropagation();
  4172. }
  4173. this.stopPropagation();
  4174. }
  4175. };
  4176. jQuery.each({
  4177. altKey : true,
  4178. bubbles : true,
  4179. cancelable : true,
  4180. changedTouches : true,
  4181. ctrlKey : true,
  4182. detail : true,
  4183. eventPhase : true,
  4184. metaKey : true,
  4185. pageX : true,
  4186. pageY : true,
  4187. shiftKey : true,
  4188. view : true,
  4189. char : true,
  4190. charCode : true,
  4191. key : true,
  4192. keyCode : true,
  4193. button : true,
  4194. buttons : true,
  4195. clientX : true,
  4196. clientY : true,
  4197. offsetX : true,
  4198. offsetY : true,
  4199. pointerId : true,
  4200. pointerType : true,
  4201. screenX : true,
  4202. screenY : true,
  4203. targetTouches : true,
  4204. toElement : true,
  4205. touches : true,
  4206. which : function(e) {
  4207. var button = e.button;
  4208. return null == e.which && receivedTestEndEvents.test(e.type) ? null != e.charCode ? e.charCode : e.keyCode : !e.which && void 0 !== button && receivedErrorEvents.test(e.type) ? 1 & button ? 1 : 2 & button ? 3 : 4 & button ? 2 : 0 : e.which;
  4209. }
  4210. }, jQuery.event.addProp);
  4211. jQuery.each({
  4212. mouseenter : "mouseover",
  4213. mouseleave : "mouseout",
  4214. pointerenter : "pointerover",
  4215. pointerleave : "pointerout"
  4216. }, function(orig, fix) {
  4217. jQuery.event.special[orig] = {
  4218. delegateType : fix,
  4219. bindType : fix,
  4220. handle : function(event) {
  4221. var _ref12;
  4222. var target = this;
  4223. var body = event.relatedTarget;
  4224. var handleObj = event.handleObj;
  4225. return body && (body === target || jQuery.contains(target, body)) || (event.type = handleObj.origType, _ref12 = handleObj.handler.apply(this, arguments), event.type = fix), _ref12;
  4226. }
  4227. };
  4228. });
  4229. jQuery.fn.extend({
  4230. on : function(el, name, str, fn) {
  4231. return attach(this, el, name, str, fn);
  4232. },
  4233. one : function(name, s, cb, type) {
  4234. return attach(this, name, s, cb, type, 1);
  4235. },
  4236. off : function(types, callback, handler) {
  4237. var handleObj;
  4238. var type;
  4239. if (types && types.preventDefault && types.handleObj) {
  4240. return handleObj = types.handleObj, jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler), this;
  4241. }
  4242. if ("object" == typeof types) {
  4243. for (type in types) {
  4244. this.off(type, callback, types[type]);
  4245. }
  4246. return this;
  4247. }
  4248. return callback !== false && "function" != typeof callback || (handler = callback, callback = void 0), handler === false && (handler = returnFalse), this.each(function() {
  4249. jQuery.event.remove(this, types, handler, callback);
  4250. });
  4251. }
  4252. });
  4253. /** @type {!RegExp} */
  4254. var regPlaceholder = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi;
  4255. /** @type {!RegExp} */
  4256. var _tacet = /<script|<style|<link/i;
  4257. /** @type {!RegExp} */
  4258. var reValidName = /checked\s*(?:[^=]|=\s*.checked.)/i;
  4259. /** @type {!RegExp} */
  4260. var receivedOpenEvents = /^true\/(.*)/;
  4261. /** @type {!RegExp} */
  4262. var codePoint = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  4263. jQuery.extend({
  4264. htmlPrefilter : function(src) {
  4265. return src.replace(regPlaceholder, "<$1></$2>");
  4266. },
  4267. clone : function(elem, n, array) {
  4268. var i;
  4269. var l;
  4270. var srcElements;
  4271. var destElements;
  4272. var clone = elem.cloneNode(true);
  4273. var inPage = jQuery.contains(elem.ownerDocument, elem);
  4274. if (!(support.noCloneChecked || 1 !== elem.nodeType && 11 !== elem.nodeType || jQuery.isXMLDoc(elem))) {
  4275. destElements = getAll(clone);
  4276. srcElements = getAll(elem);
  4277. /** @type {number} */
  4278. i = 0;
  4279. l = srcElements.length;
  4280. for (; i < l; i++) {
  4281. fixInput(srcElements[i], destElements[i]);
  4282. }
  4283. }
  4284. if (n) {
  4285. if (array) {
  4286. srcElements = srcElements || getAll(elem);
  4287. destElements = destElements || getAll(clone);
  4288. /** @type {number} */
  4289. i = 0;
  4290. l = srcElements.length;
  4291. for (; i < l; i++) {
  4292. cloneCopyEvent(srcElements[i], destElements[i]);
  4293. }
  4294. } else {
  4295. cloneCopyEvent(elem, clone);
  4296. }
  4297. }
  4298. return destElements = getAll(clone, "script"), destElements.length > 0 && setGlobalEval(destElements, !inPage && getAll(elem, "script")), clone;
  4299. },
  4300. cleanData : function(elems) {
  4301. var data;
  4302. var elem;
  4303. var type;
  4304. var special = jQuery.event.special;
  4305. /** @type {number} */
  4306. var i = 0;
  4307. for (; void 0 !== (elem = elems[i]); i++) {
  4308. if (acceptData(elem)) {
  4309. if (data = elem[dataPriv.expando]) {
  4310. if (data.events) {
  4311. for (type in data.events) {
  4312. if (special[type]) {
  4313. jQuery.event.remove(elem, type);
  4314. } else {
  4315. jQuery.removeEvent(elem, type, data.handle);
  4316. }
  4317. }
  4318. }
  4319. elem[dataPriv.expando] = void 0;
  4320. }
  4321. if (elem[$.expando]) {
  4322. elem[$.expando] = void 0;
  4323. }
  4324. }
  4325. }
  4326. }
  4327. });
  4328. jQuery.fn.extend({
  4329. detach : function(selector) {
  4330. return remove(this, selector, true);
  4331. },
  4332. remove : function(selector) {
  4333. return remove(this, selector);
  4334. },
  4335. text : function(value) {
  4336. return access(this, function(value) {
  4337. return void 0 === value ? jQuery.text(this) : this.empty().each(function() {
  4338. if (!(1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType)) {
  4339. this.textContent = value;
  4340. }
  4341. });
  4342. }, null, value, arguments.length);
  4343. },
  4344. append : function() {
  4345. return domManip(this, arguments, function(elem) {
  4346. if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
  4347. var target = manipulationTarget(this, elem);
  4348. target.appendChild(elem);
  4349. }
  4350. });
  4351. },
  4352. prepend : function() {
  4353. return domManip(this, arguments, function(elem) {
  4354. if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
  4355. var target = manipulationTarget(this, elem);
  4356. target.insertBefore(elem, target.firstChild);
  4357. }
  4358. });
  4359. },
  4360. before : function() {
  4361. return domManip(this, arguments, function(elem) {
  4362. if (this.parentNode) {
  4363. this.parentNode.insertBefore(elem, this);
  4364. }
  4365. });
  4366. },
  4367. after : function() {
  4368. return domManip(this, arguments, function(elem) {
  4369. if (this.parentNode) {
  4370. this.parentNode.insertBefore(elem, this.nextSibling);
  4371. }
  4372. });
  4373. },
  4374. empty : function() {
  4375. var elem;
  4376. /** @type {number} */
  4377. var i = 0;
  4378. for (; null != (elem = this[i]); i++) {
  4379. if (1 === elem.nodeType) {
  4380. jQuery.cleanData(getAll(elem, false));
  4381. /** @type {string} */
  4382. elem.textContent = "";
  4383. }
  4384. }
  4385. return this;
  4386. },
  4387. clone : function(c, i) {
  4388. return c = null != c && c, i = null == i ? c : i, this.map(function() {
  4389. return jQuery.clone(this, c, i);
  4390. });
  4391. },
  4392. html : function(value) {
  4393. return access(this, function(value) {
  4394. var elem = this[0] || {};
  4395. /** @type {number} */
  4396. var thatpos = 0;
  4397. var i = this.length;
  4398. if (void 0 === value && 1 === elem.nodeType) {
  4399. return elem.innerHTML;
  4400. }
  4401. if ("string" == typeof value && !_tacet.test(value) && !wrapMap[(fullLinkRegex.exec(value) || ["", ""])[1].toLowerCase()]) {
  4402. value = jQuery.htmlPrefilter(value);
  4403. try {
  4404. for (; thatpos < i; thatpos++) {
  4405. elem = this[thatpos] || {};
  4406. if (1 === elem.nodeType) {
  4407. jQuery.cleanData(getAll(elem, false));
  4408. /** @type {number} */
  4409. elem.innerHTML = value;
  4410. }
  4411. }
  4412. /** @type {number} */
  4413. elem = 0;
  4414. } catch (e) {
  4415. }
  4416. }
  4417. if (elem) {
  4418. this.empty().append(value);
  4419. }
  4420. }, null, value, arguments.length);
  4421. },
  4422. replaceWith : function() {
  4423. /** @type {!Array} */
  4424. var ignored = [];
  4425. return domManip(this, arguments, function(t) {
  4426. var p = this.parentNode;
  4427. if (jQuery.inArray(this, ignored) < 0) {
  4428. jQuery.cleanData(getAll(this));
  4429. if (p) {
  4430. p.replaceChild(t, this);
  4431. }
  4432. }
  4433. }, ignored);
  4434. }
  4435. });
  4436. jQuery.each({
  4437. appendTo : "append",
  4438. prependTo : "prepend",
  4439. insertBefore : "before",
  4440. insertAfter : "after",
  4441. replaceAll : "replaceWith"
  4442. }, function(original, n) {
  4443. /**
  4444. * @param {!Object} body
  4445. * @return {?}
  4446. */
  4447. jQuery.fn[original] = function(body) {
  4448. var what;
  4449. /** @type {!Array} */
  4450. var nodes = [];
  4451. var rows = jQuery(body);
  4452. /** @type {number} */
  4453. var last = rows.length - 1;
  4454. /** @type {number} */
  4455. var i = 0;
  4456. for (; i <= last; i++) {
  4457. what = i === last ? this : this.clone(true);
  4458. jQuery(rows[i])[n](what);
  4459. push.apply(nodes, what.get());
  4460. }
  4461. return this.pushStack(nodes);
  4462. };
  4463. });
  4464. /** @type {!RegExp} */
  4465. var namespaces = /^margin/;
  4466. /** @type {!RegExp} */
  4467. var rnumnonpx = new RegExp("^(" + FSSource + ")(?!px)[a-z%]+$", "i");
  4468. /**
  4469. * @param {!Object} elem
  4470. * @return {?}
  4471. */
  4472. var getStyles = function(elem) {
  4473. var win = elem.ownerDocument.defaultView;
  4474. return win && win.opener || (win = window), win.getComputedStyle(elem);
  4475. };
  4476. !function() {
  4477. /**
  4478. * @return {undefined}
  4479. */
  4480. function computeStyleTests() {
  4481. if (div) {
  4482. /** @type {string} */
  4483. div.style.cssText = "box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%";
  4484. /** @type {string} */
  4485. div.innerHTML = "";
  4486. docElem.appendChild(container);
  4487. var cs = window.getComputedStyle(div);
  4488. /** @type {boolean} */
  4489. n = "1%" !== cs.top;
  4490. /** @type {boolean} */
  4491. o = "2px" === cs.marginLeft;
  4492. /** @type {boolean} */
  4493. r = "4px" === cs.width;
  4494. /** @type {string} */
  4495. div.style.marginRight = "50%";
  4496. /** @type {boolean} */
  4497. i = "4px" === cs.marginRight;
  4498. docElem.removeChild(container);
  4499. /** @type {null} */
  4500. div = null;
  4501. }
  4502. }
  4503. var n;
  4504. var r;
  4505. var i;
  4506. var o;
  4507. var container = document.createElement("div");
  4508. var div = document.createElement("div");
  4509. if (div.style) {
  4510. /** @type {string} */
  4511. div.style.backgroundClip = "content-box";
  4512. /** @type {string} */
  4513. div.cloneNode(true).style.backgroundClip = "";
  4514. /** @type {boolean} */
  4515. support.clearCloneStyle = "content-box" === div.style.backgroundClip;
  4516. /** @type {string} */
  4517. container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute";
  4518. container.appendChild(div);
  4519. jQuery.extend(support, {
  4520. pixelPosition : function() {
  4521. return computeStyleTests(), n;
  4522. },
  4523. boxSizingReliable : function() {
  4524. return computeStyleTests(), r;
  4525. },
  4526. pixelMarginRight : function() {
  4527. return computeStyleTests(), i;
  4528. },
  4529. reliableMarginLeft : function() {
  4530. return computeStyleTests(), o;
  4531. }
  4532. });
  4533. }
  4534. }();
  4535. /** @type {!RegExp} */
  4536. var rdisplayswap = /^(none|table(?!-c[ea]).+)/;
  4537. var cssShow = {
  4538. position : "absolute",
  4539. visibility : "hidden",
  4540. display : "block"
  4541. };
  4542. var cssNormalTransform = {
  4543. letterSpacing : "0",
  4544. fontWeight : "400"
  4545. };
  4546. /** @type {!Array} */
  4547. var prefixes = ["Webkit", "Moz", "ms"];
  4548. var style = document.createElement("div").style;
  4549. jQuery.extend({
  4550. cssHooks : {
  4551. opacity : {
  4552. get : function(elem, value) {
  4553. if (value) {
  4554. var to = curCSS(elem, "opacity");
  4555. return "" === to ? "1" : to;
  4556. }
  4557. }
  4558. }
  4559. },
  4560. cssNumber : {
  4561. animationIterationCount : true,
  4562. columnCount : true,
  4563. fillOpacity : true,
  4564. flexGrow : true,
  4565. flexShrink : true,
  4566. fontWeight : true,
  4567. lineHeight : true,
  4568. opacity : true,
  4569. order : true,
  4570. orphans : true,
  4571. widows : true,
  4572. zIndex : true,
  4573. zoom : true
  4574. },
  4575. cssProps : {
  4576. float : "cssFloat"
  4577. },
  4578. style : function(elem, name, value, extra) {
  4579. if (elem && 3 !== elem.nodeType && 8 !== elem.nodeType && elem.style) {
  4580. var ret;
  4581. var type;
  4582. var hooks;
  4583. var origName = jQuery.camelCase(name);
  4584. var style = elem.style;
  4585. return name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(origName) || origName), hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName], void 0 === value ? hooks && "get" in hooks && void 0 !== (ret = hooks.get(elem, false, extra)) ? ret : style[name] : (type = typeof value, "string" === type && (ret = regex.exec(value)) && ret[1] && (value = adjustCSS(elem, name, ret), type = "number"), null != value && value === value && ("number" === type && (value =
  4586. value + (ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px"))), support.clearCloneStyle || "" !== value || 0 !== name.indexOf("background") || (style[name] = "inherit"), hooks && "set" in hooks && void 0 === (value = hooks.set(elem, value, extra)) || (style[name] = value)), void 0);
  4587. }
  4588. },
  4589. css : function(elem, name, extra, styles) {
  4590. var val;
  4591. var num;
  4592. var hooks;
  4593. var origName = jQuery.camelCase(name);
  4594. return name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(origName) || origName), hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName], hooks && "get" in hooks && (val = hooks.get(elem, true, extra)), void 0 === val && (val = curCSS(elem, name, styles)), "normal" === val && name in cssNormalTransform && (val = cssNormalTransform[name]), "" === extra || extra ? (num = parseFloat(val), extra === true || isFinite(num) ? num || 0 : val) : val;
  4595. }
  4596. });
  4597. jQuery.each(["height", "width"], function(canCreateDiscussions, name) {
  4598. jQuery.cssHooks[name] = {
  4599. get : function(elem, value, extra) {
  4600. if (value) {
  4601. return !rdisplayswap.test(jQuery.css(elem, "display")) || elem.getClientRects().length && elem.getBoundingClientRect().width ? getWidthOrHeight(elem, name, extra) : swap(elem, cssShow, function() {
  4602. return getWidthOrHeight(elem, name, extra);
  4603. });
  4604. }
  4605. },
  4606. set : function(elem, value, extra) {
  4607. var s;
  4608. var styles = extra && getStyles(elem);
  4609. var url = extra && augmentWidthOrHeight(elem, name, extra, "border-box" === jQuery.css(elem, "boxSizing", false, styles), styles);
  4610. return url && (s = regex.exec(value)) && "px" !== (s[3] || "px") && (elem.style[name] = value, value = jQuery.css(elem, name)), _set(elem, value, url);
  4611. }
  4612. };
  4613. });
  4614. jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function(elem, canCreateDiscussions) {
  4615. if (canCreateDiscussions) {
  4616. return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, {
  4617. marginLeft : 0
  4618. }, function() {
  4619. return elem.getBoundingClientRect().left;
  4620. })) + "px";
  4621. }
  4622. });
  4623. jQuery.each({
  4624. margin : "",
  4625. padding : "",
  4626. border : "Width"
  4627. }, function(prefix, suffix) {
  4628. jQuery.cssHooks[prefix + suffix] = {
  4629. expand : function(data) {
  4630. /** @type {number} */
  4631. var i = 0;
  4632. var expanded = {};
  4633. /** @type {!Array} */
  4634. var stops = "string" == typeof data ? data.split(" ") : [data];
  4635. for (; i < 4; i++) {
  4636. expanded[prefix + cssExpand[i] + suffix] = stops[i] || stops[i - 2] || stops[0];
  4637. }
  4638. return expanded;
  4639. }
  4640. };
  4641. if (!namespaces.test(prefix)) {
  4642. /** @type {function(!Object, !Object, string): ?} */
  4643. jQuery.cssHooks[prefix + suffix].set = _set;
  4644. }
  4645. });
  4646. jQuery.fn.extend({
  4647. css : function(name, value) {
  4648. return access(this, function(elem, name, undefined) {
  4649. var styles;
  4650. var l;
  4651. var map = {};
  4652. /** @type {number} */
  4653. var i = 0;
  4654. if (jQuery.isArray(name)) {
  4655. styles = getStyles(elem);
  4656. l = name.length;
  4657. for (; i < l; i++) {
  4658. map[name[i]] = jQuery.css(elem, name[i], false, styles);
  4659. }
  4660. return map;
  4661. }
  4662. return void 0 !== undefined ? jQuery.style(elem, name, undefined) : jQuery.css(elem, name);
  4663. }, name, value, arguments.length > 1);
  4664. }
  4665. });
  4666. /** @type {function(!Object, string, string, !Object, string): ?} */
  4667. jQuery.Tween = Tween;
  4668. Tween.prototype = {
  4669. constructor : Tween,
  4670. init : function(domElem, options, prop, end, easing, unit) {
  4671. /** @type {!Element} */
  4672. this.elem = domElem;
  4673. /** @type {!Object} */
  4674. this.prop = prop;
  4675. this.easing = easing || jQuery.easing._default;
  4676. /** @type {!Object} */
  4677. this.options = options;
  4678. this.start = this.now = this.cur();
  4679. /** @type {number} */
  4680. this.end = end;
  4681. this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
  4682. },
  4683. cur : function() {
  4684. var hooks = Tween.propHooks[this.prop];
  4685. return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
  4686. },
  4687. run : function(percent) {
  4688. var eased;
  4689. var hooks = Tween.propHooks[this.prop];
  4690. return this.options.duration ? this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration) : this.pos = eased = percent, this.now = (this.end - this.start) * eased + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), hooks && hooks.set ? hooks.set(this) : Tween.propHooks._default.set(this), this;
  4691. }
  4692. };
  4693. Tween.prototype.init.prototype = Tween.prototype;
  4694. Tween.propHooks = {
  4695. _default : {
  4696. get : function(s) {
  4697. var charset;
  4698. return 1 !== s.elem.nodeType || null != s.elem[s.prop] && null == s.elem.style[s.prop] ? s.elem[s.prop] : (charset = jQuery.css(s.elem, s.prop, ""), charset && "auto" !== charset ? charset : 0);
  4699. },
  4700. set : function(tween) {
  4701. if (jQuery.fx.step[tween.prop]) {
  4702. jQuery.fx.step[tween.prop](tween);
  4703. } else {
  4704. if (1 !== tween.elem.nodeType || null == tween.elem.style[jQuery.cssProps[tween.prop]] && !jQuery.cssHooks[tween.prop]) {
  4705. tween.elem[tween.prop] = tween.now;
  4706. } else {
  4707. jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
  4708. }
  4709. }
  4710. }
  4711. }
  4712. };
  4713. Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
  4714. set : function(tween) {
  4715. if (tween.elem.nodeType && tween.elem.parentNode) {
  4716. tween.elem[tween.prop] = tween.now;
  4717. }
  4718. }
  4719. };
  4720. jQuery.easing = {
  4721. linear : function(p) {
  4722. return p;
  4723. },
  4724. swing : function(p) {
  4725. return .5 - Math.cos(p * Math.PI) / 2;
  4726. },
  4727. _default : "swing"
  4728. };
  4729. /** @type {function(!Element, !Object, !Object, number, string, string): undefined} */
  4730. jQuery.fx = Tween.prototype.init;
  4731. jQuery.fx.step = {};
  4732. var fxNow;
  4733. var id;
  4734. /** @type {!RegExp} */
  4735. var trueRE = /^(?:toggle|show|hide)$/;
  4736. /** @type {!RegExp} */
  4737. var rrun = /queueHooks$/;
  4738. jQuery.Animation = jQuery.extend(Animation, {
  4739. tweeners : {
  4740. "*" : [function(prop, value) {
  4741. var tween = this.createTween(prop, value);
  4742. return adjustCSS(tween.elem, prop, regex.exec(value), tween), tween;
  4743. }]
  4744. },
  4745. tweener : function(props, callback) {
  4746. if (jQuery.isFunction(props)) {
  4747. /** @type {!Object} */
  4748. callback = props;
  4749. /** @type {!Array} */
  4750. props = ["*"];
  4751. } else {
  4752. props = props.match(rnotwhite);
  4753. }
  4754. var prop;
  4755. /** @type {number} */
  4756. var i = 0;
  4757. var inputsSize = props.length;
  4758. for (; i < inputsSize; i++) {
  4759. prop = props[i];
  4760. Animation.tweeners[prop] = Animation.tweeners[prop] || [];
  4761. Animation.tweeners[prop].unshift(callback);
  4762. }
  4763. },
  4764. prefilters : [defaultPrefilter],
  4765. prefilter : function(callback, options) {
  4766. if (options) {
  4767. Animation.prefilters.unshift(callback);
  4768. } else {
  4769. Animation.prefilters.push(callback);
  4770. }
  4771. }
  4772. });
  4773. /**
  4774. * @param {string} speed
  4775. * @param {string} easing
  4776. * @param {string} fn
  4777. * @return {?}
  4778. */
  4779. jQuery.speed = function(speed, easing, fn) {
  4780. var opt = speed && "object" == typeof speed ? jQuery.extend({}, speed) : {
  4781. complete : fn || !fn && easing || jQuery.isFunction(speed) && speed,
  4782. duration : speed,
  4783. easing : fn && easing || easing && !jQuery.isFunction(easing) && easing
  4784. };
  4785. return jQuery.fx.off || document.hidden ? opt.duration = 0 : opt.duration = "number" == typeof opt.duration ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default, null != opt.queue && opt.queue !== true || (opt.queue = "fx"), opt.old = opt.complete, opt.complete = function() {
  4786. if (jQuery.isFunction(opt.old)) {
  4787. opt.old.call(this);
  4788. }
  4789. if (opt.queue) {
  4790. jQuery.dequeue(this, opt.queue);
  4791. }
  4792. }, opt;
  4793. };
  4794. jQuery.fn.extend({
  4795. fadeTo : function(speed, to, callback, context) {
  4796. return this.filter(isHidden).css("opacity", 0).show().end().animate({
  4797. opacity : to
  4798. }, speed, callback, context);
  4799. },
  4800. animate : function(prop, speed, easing, callback) {
  4801. var empty = jQuery.isEmptyObject(prop);
  4802. var optall = jQuery.speed(speed, easing, callback);
  4803. /**
  4804. * @return {undefined}
  4805. */
  4806. var doAnimation = function() {
  4807. var anim = Animation(this, jQuery.extend({}, prop), optall);
  4808. if (empty || dataPriv.get(this, "finish")) {
  4809. anim.stop(true);
  4810. }
  4811. };
  4812. return doAnimation.finish = doAnimation, empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
  4813. },
  4814. stop : function(type, value, options) {
  4815. /**
  4816. * @param {!Object} hooks
  4817. * @return {undefined}
  4818. */
  4819. var stopQueue = function(hooks) {
  4820. var stop = hooks.stop;
  4821. delete hooks.stop;
  4822. stop(options);
  4823. };
  4824. return "string" != typeof type && (options = value, value = type, type = void 0), value && type !== false && this.queue(type || "fx", []), this.each(function() {
  4825. /** @type {boolean} */
  4826. var out = true;
  4827. /** @type {(boolean|string)} */
  4828. var index = null != type && type + "queueHooks";
  4829. /** @type {!Array} */
  4830. var timers = jQuery.timers;
  4831. var data = dataPriv.get(this);
  4832. if (index) {
  4833. if (data[index] && data[index].stop) {
  4834. stopQueue(data[index]);
  4835. }
  4836. } else {
  4837. for (index in data) {
  4838. if (data[index] && data[index].stop && rrun.test(index)) {
  4839. stopQueue(data[index]);
  4840. }
  4841. }
  4842. }
  4843. /** @type {number} */
  4844. index = timers.length;
  4845. for (; index--;) {
  4846. if (!(timers[index].elem !== this || null != type && timers[index].queue !== type)) {
  4847. timers[index].anim.stop(options);
  4848. /** @type {boolean} */
  4849. out = false;
  4850. timers.splice(index, 1);
  4851. }
  4852. }
  4853. if (!(!out && options)) {
  4854. jQuery.dequeue(this, type);
  4855. }
  4856. });
  4857. },
  4858. finish : function(type) {
  4859. return type !== false && (type = type || "fx"), this.each(function() {
  4860. var index;
  4861. var data = dataPriv.get(this);
  4862. var queue = data[type + "queue"];
  4863. var hooks = data[type + "queueHooks"];
  4864. /** @type {!Array} */
  4865. var timers = jQuery.timers;
  4866. var length = queue ? queue.length : 0;
  4867. /** @type {boolean} */
  4868. data.finish = true;
  4869. jQuery.queue(this, type, []);
  4870. if (hooks && hooks.stop) {
  4871. hooks.stop.call(this, true);
  4872. }
  4873. /** @type {number} */
  4874. index = timers.length;
  4875. for (; index--;) {
  4876. if (timers[index].elem === this && timers[index].queue === type) {
  4877. timers[index].anim.stop(true);
  4878. timers.splice(index, 1);
  4879. }
  4880. }
  4881. /** @type {number} */
  4882. index = 0;
  4883. for (; index < length; index++) {
  4884. if (queue[index] && queue[index].finish) {
  4885. queue[index].finish.call(this);
  4886. }
  4887. }
  4888. delete data.finish;
  4889. });
  4890. }
  4891. });
  4892. jQuery.each(["toggle", "show", "hide"], function(canCreateDiscussions, name) {
  4893. var cssFn = jQuery.fn[name];
  4894. /**
  4895. * @param {string} x
  4896. * @param {string} callback
  4897. * @param {string} options
  4898. * @return {?}
  4899. */
  4900. jQuery.fn[name] = function(x, callback, options) {
  4901. return null == x || "boolean" == typeof x ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), x, callback, options);
  4902. };
  4903. });
  4904. jQuery.each({
  4905. slideDown : genFx("show"),
  4906. slideUp : genFx("hide"),
  4907. slideToggle : genFx("toggle"),
  4908. fadeIn : {
  4909. opacity : "show"
  4910. },
  4911. fadeOut : {
  4912. opacity : "hide"
  4913. },
  4914. fadeToggle : {
  4915. opacity : "toggle"
  4916. }
  4917. }, function(original, props) {
  4918. /**
  4919. * @param {string} speed
  4920. * @param {string} callback
  4921. * @param {string} options
  4922. * @return {?}
  4923. */
  4924. jQuery.fn[original] = function(speed, callback, options) {
  4925. return this.animate(props, speed, callback, options);
  4926. };
  4927. });
  4928. /** @type {!Array} */
  4929. jQuery.timers = [];
  4930. /**
  4931. * @return {undefined}
  4932. */
  4933. jQuery.fx.tick = function() {
  4934. var timer;
  4935. /** @type {number} */
  4936. var i = 0;
  4937. /** @type {!Array} */
  4938. var timers = jQuery.timers;
  4939. fxNow = jQuery.now();
  4940. for (; i < timers.length; i++) {
  4941. timer = timers[i];
  4942. if (!(timer() || timers[i] !== timer)) {
  4943. timers.splice(i--, 1);
  4944. }
  4945. }
  4946. if (!timers.length) {
  4947. jQuery.fx.stop();
  4948. }
  4949. fxNow = void 0;
  4950. };
  4951. /**
  4952. * @param {?} timer
  4953. * @return {undefined}
  4954. */
  4955. jQuery.fx.timer = function(timer) {
  4956. jQuery.timers.push(timer);
  4957. if (timer()) {
  4958. jQuery.fx.start();
  4959. } else {
  4960. jQuery.timers.pop();
  4961. }
  4962. };
  4963. /** @type {number} */
  4964. jQuery.fx.interval = 13;
  4965. /**
  4966. * @return {undefined}
  4967. */
  4968. jQuery.fx.start = function() {
  4969. if (!id) {
  4970. id = window.requestAnimationFrame ? window.requestAnimationFrame(raf) : window.setInterval(jQuery.fx.tick, jQuery.fx.interval);
  4971. }
  4972. };
  4973. /**
  4974. * @return {undefined}
  4975. */
  4976. jQuery.fx.stop = function() {
  4977. if (window.cancelAnimationFrame) {
  4978. window.cancelAnimationFrame(id);
  4979. } else {
  4980. window.clearInterval(id);
  4981. }
  4982. /** @type {null} */
  4983. id = null;
  4984. };
  4985. jQuery.fx.speeds = {
  4986. slow : 600,
  4987. fast : 200,
  4988. _default : 400
  4989. };
  4990. /**
  4991. * @param {string} time
  4992. * @param {string} type
  4993. * @return {?}
  4994. */
  4995. jQuery.fn.delay = function(time, type) {
  4996. return time = jQuery.fx ? jQuery.fx.speeds[time] || time : time, type = type || "fx", this.queue(type, function(n, incoming_item) {
  4997. var id = window.setTimeout(n, time);
  4998. /**
  4999. * @return {undefined}
  5000. */
  5001. incoming_item.stop = function() {
  5002. window.clearTimeout(id);
  5003. };
  5004. });
  5005. };
  5006. (function() {
  5007. var input = document.createElement("input");
  5008. var select = document.createElement("select");
  5009. var opt = select.appendChild(document.createElement("option"));
  5010. /** @type {string} */
  5011. input.type = "checkbox";
  5012. /** @type {boolean} */
  5013. support.checkOn = "" !== input.value;
  5014. support.optSelected = opt.selected;
  5015. input = document.createElement("input");
  5016. /** @type {string} */
  5017. input.value = "t";
  5018. /** @type {string} */
  5019. input.type = "radio";
  5020. /** @type {boolean} */
  5021. support.radioValue = "t" === input.value;
  5022. })();
  5023. var boolHook;
  5024. var attrHandle = jQuery.expr.attrHandle;
  5025. jQuery.fn.extend({
  5026. attr : function(type, value) {
  5027. return access(this, jQuery.attr, type, value, arguments.length > 1);
  5028. },
  5029. removeAttr : function(name) {
  5030. return this.each(function() {
  5031. jQuery.removeAttr(this, name);
  5032. });
  5033. }
  5034. });
  5035. jQuery.extend({
  5036. attr : function(elem, name, value) {
  5037. var message;
  5038. var hooks;
  5039. var type = elem.nodeType;
  5040. if (3 !== type && 8 !== type && 2 !== type) {
  5041. return "undefined" == typeof elem.getAttribute ? jQuery.prop(elem, name, value) : (1 === type && jQuery.isXMLDoc(elem) || (hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : void 0)), void 0 !== value ? null === value ? void jQuery.removeAttr(elem, name) : hooks && "set" in hooks && void 0 !== (message = hooks.set(elem, value, name)) ? message : (elem.setAttribute(name, value + ""), value) : hooks && "get" in hooks && null !== (message = hooks.get(elem,
  5042. name)) ? message : (message = jQuery.find.attr(elem, name), null == message ? void 0 : message));
  5043. }
  5044. },
  5045. attrHooks : {
  5046. type : {
  5047. set : function(element, value) {
  5048. if (!support.radioValue && "radio" === value && jQuery.nodeName(element, "input")) {
  5049. var n = element.value;
  5050. return element.setAttribute("type", value), n && (element.value = n), value;
  5051. }
  5052. }
  5053. }
  5054. },
  5055. removeAttr : function(elem, value) {
  5056. var ATTR_MAXLENGTH;
  5057. /** @type {number} */
  5058. var callbackCount = 0;
  5059. var callbackVals = value && value.match(rnotwhite);
  5060. if (callbackVals && 1 === elem.nodeType) {
  5061. for (; ATTR_MAXLENGTH = callbackVals[callbackCount++];) {
  5062. elem.removeAttribute(ATTR_MAXLENGTH);
  5063. }
  5064. }
  5065. }
  5066. });
  5067. boolHook = {
  5068. set : function(elem, value, name) {
  5069. return value === false ? jQuery.removeAttr(elem, name) : elem.setAttribute(name, name), name;
  5070. }
  5071. };
  5072. jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(canCreateDiscussions, name) {
  5073. var n = attrHandle[name] || jQuery.find.attr;
  5074. /**
  5075. * @param {undefined} window
  5076. * @param {string} status
  5077. * @param {number} s
  5078. * @return {?}
  5079. */
  5080. attrHandle[name] = function(window, status, s) {
  5081. var ret;
  5082. var handle;
  5083. var lowercaseName = status.toLowerCase();
  5084. return s || (handle = attrHandle[lowercaseName], attrHandle[lowercaseName] = ret, ret = null != n(window, status, s) ? lowercaseName : null, attrHandle[lowercaseName] = handle), ret;
  5085. };
  5086. });
  5087. /** @type {!RegExp} */
  5088. var inputNodeNames = /^(?:input|select|textarea|button)$/i;
  5089. /** @type {!RegExp} */
  5090. var srsRegex = /^(?:a|area)$/i;
  5091. jQuery.fn.extend({
  5092. prop : function(type, value) {
  5093. return access(this, jQuery.prop, type, value, arguments.length > 1);
  5094. },
  5095. removeProp : function(name) {
  5096. return this.each(function() {
  5097. delete this[jQuery.propFix[name] || name];
  5098. });
  5099. }
  5100. });
  5101. jQuery.extend({
  5102. prop : function(elem, name, value) {
  5103. var ret;
  5104. var hooks;
  5105. var type = elem.nodeType;
  5106. if (3 !== type && 8 !== type && 2 !== type) {
  5107. return 1 === type && jQuery.isXMLDoc(elem) || (name = jQuery.propFix[name] || name, hooks = jQuery.propHooks[name]), void 0 !== value ? hooks && "set" in hooks && void 0 !== (ret = hooks.set(elem, value, name)) ? ret : elem[name] = value : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name)) ? ret : elem[name];
  5108. }
  5109. },
  5110. propHooks : {
  5111. tabIndex : {
  5112. get : function(target) {
  5113. var b = jQuery.find.attr(target, "tabindex");
  5114. return b ? parseInt(b, 10) : inputNodeNames.test(target.nodeName) || srsRegex.test(target.nodeName) && target.href ? 0 : -1;
  5115. }
  5116. }
  5117. },
  5118. propFix : {
  5119. for : "htmlFor",
  5120. class : "className"
  5121. }
  5122. });
  5123. if (!support.optSelected) {
  5124. jQuery.propHooks.selected = {
  5125. get : function(elem) {
  5126. var parent = elem.parentNode;
  5127. return parent && parent.parentNode && parent.parentNode.selectedIndex, null;
  5128. },
  5129. set : function(text) {
  5130. var f = text.parentNode;
  5131. if (f) {
  5132. f.selectedIndex;
  5133. if (f.parentNode) {
  5134. f.parentNode.selectedIndex;
  5135. }
  5136. }
  5137. }
  5138. };
  5139. }
  5140. jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() {
  5141. jQuery.propFix[this.toLowerCase()] = this;
  5142. });
  5143. /** @type {!RegExp} */
  5144. var reSpace = /[\t\r\n\f]/g;
  5145. jQuery.fn.extend({
  5146. addClass : function(value) {
  5147. var zeroSizeMaxes;
  5148. var n;
  5149. var e;
  5150. var d;
  5151. var zeroSizeMax;
  5152. var callbackCount;
  5153. var s;
  5154. /** @type {number} */
  5155. var u = 0;
  5156. if (jQuery.isFunction(value)) {
  5157. return this.each(function(i) {
  5158. jQuery(this).addClass(value.call(this, i, fn(this)));
  5159. });
  5160. }
  5161. if ("string" == typeof value && value) {
  5162. /** @type {!Array} */
  5163. zeroSizeMaxes = value.match(rnotwhite) || [];
  5164. for (; n = this[u++];) {
  5165. if (d = fn(n), e = 1 === n.nodeType && (" " + d + " ").replace(reSpace, " ")) {
  5166. /** @type {number} */
  5167. callbackCount = 0;
  5168. for (; zeroSizeMax = zeroSizeMaxes[callbackCount++];) {
  5169. if (e.indexOf(" " + zeroSizeMax + " ") < 0) {
  5170. /** @type {string} */
  5171. e = e + (zeroSizeMax + " ");
  5172. }
  5173. }
  5174. s = jQuery.trim(e);
  5175. if (d !== s) {
  5176. n.setAttribute("class", s);
  5177. }
  5178. }
  5179. }
  5180. }
  5181. return this;
  5182. },
  5183. removeClass : function(value) {
  5184. var zeroSizeMaxes;
  5185. var n;
  5186. var e;
  5187. var d;
  5188. var zeroSizeMax;
  5189. var callbackCount;
  5190. var s;
  5191. /** @type {number} */
  5192. var u = 0;
  5193. if (jQuery.isFunction(value)) {
  5194. return this.each(function(i) {
  5195. jQuery(this).removeClass(value.call(this, i, fn(this)));
  5196. });
  5197. }
  5198. if (!arguments.length) {
  5199. return this.attr("class", "");
  5200. }
  5201. if ("string" == typeof value && value) {
  5202. /** @type {!Array} */
  5203. zeroSizeMaxes = value.match(rnotwhite) || [];
  5204. for (; n = this[u++];) {
  5205. if (d = fn(n), e = 1 === n.nodeType && (" " + d + " ").replace(reSpace, " ")) {
  5206. /** @type {number} */
  5207. callbackCount = 0;
  5208. for (; zeroSizeMax = zeroSizeMaxes[callbackCount++];) {
  5209. for (; e.indexOf(" " + zeroSizeMax + " ") > -1;) {
  5210. /** @type {string} */
  5211. e = e.replace(" " + zeroSizeMax + " ", " ");
  5212. }
  5213. }
  5214. s = jQuery.trim(e);
  5215. if (d !== s) {
  5216. n.setAttribute("class", s);
  5217. }
  5218. }
  5219. }
  5220. }
  5221. return this;
  5222. },
  5223. toggleClass : function(value, stateVal) {
  5224. /** @type {string} */
  5225. var undefined = typeof value;
  5226. return "boolean" == typeof stateVal && "string" === undefined ? stateVal ? this.addClass(value) : this.removeClass(value) : jQuery.isFunction(value) ? this.each(function(i) {
  5227. jQuery(this).toggleClass(value.call(this, i, fn(this), stateVal), stateVal);
  5228. }) : this.each(function() {
  5229. var className;
  5230. var i;
  5231. var $body;
  5232. var classNames;
  5233. if ("string" === undefined) {
  5234. /** @type {number} */
  5235. i = 0;
  5236. $body = jQuery(this);
  5237. classNames = value.match(rnotwhite) || [];
  5238. for (; className = classNames[i++];) {
  5239. if ($body.hasClass(className)) {
  5240. $body.removeClass(className);
  5241. } else {
  5242. $body.addClass(className);
  5243. }
  5244. }
  5245. } else {
  5246. if (!(void 0 !== value && "boolean" !== undefined)) {
  5247. className = fn(this);
  5248. if (className) {
  5249. dataPriv.set(this, "__className__", className);
  5250. }
  5251. if (this.setAttribute) {
  5252. this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
  5253. }
  5254. }
  5255. }
  5256. });
  5257. },
  5258. hasClass : function(elem) {
  5259. var exactLanguageCode;
  5260. var n;
  5261. /** @type {number} */
  5262. var r = 0;
  5263. /** @type {string} */
  5264. exactLanguageCode = " " + elem + " ";
  5265. for (; n = this[r++];) {
  5266. if (1 === n.nodeType && (" " + fn(n) + " ").replace(reSpace, " ").indexOf(exactLanguageCode) > -1) {
  5267. return true;
  5268. }
  5269. }
  5270. return false;
  5271. }
  5272. });
  5273. /** @type {!RegExp} */
  5274. var n = /\r/g;
  5275. /** @type {!RegExp} */
  5276. var tokensRegExp = /[\x20\t\r\n\f]+/g;
  5277. jQuery.fn.extend({
  5278. val : function(val) {
  5279. var hooks;
  5280. var value;
  5281. var m;
  5282. var elem = this[0];
  5283. {
  5284. if (arguments.length) {
  5285. return m = jQuery.isFunction(val), this.each(function(error2) {
  5286. var value;
  5287. if (1 === this.nodeType) {
  5288. value = m ? val.call(this, error2, jQuery(this).val()) : val;
  5289. if (null == value) {
  5290. /** @type {string} */
  5291. value = "";
  5292. } else {
  5293. if ("number" == typeof value) {
  5294. /** @type {string} */
  5295. value = value + "";
  5296. } else {
  5297. if (jQuery.isArray(value)) {
  5298. value = jQuery.map(value, function(value) {
  5299. return null == value ? "" : value + "";
  5300. });
  5301. }
  5302. }
  5303. }
  5304. hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
  5305. if (!(hooks && "set" in hooks && void 0 !== hooks.set(this, value, "value"))) {
  5306. this.value = value;
  5307. }
  5308. }
  5309. });
  5310. }
  5311. if (elem) {
  5312. return hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()], hooks && "get" in hooks && void 0 !== (value = hooks.get(elem, "value")) ? value : (value = elem.value, "string" == typeof value ? value.replace(n, "") : null == value ? "" : value);
  5313. }
  5314. }
  5315. }
  5316. });
  5317. jQuery.extend({
  5318. valHooks : {
  5319. option : {
  5320. get : function(elem) {
  5321. var tween = jQuery.find.attr(elem, "value");
  5322. return null != tween ? tween : jQuery.trim(jQuery.text(elem)).replace(tokensRegExp, " ");
  5323. }
  5324. },
  5325. select : {
  5326. get : function(elem) {
  5327. var value;
  5328. var option;
  5329. var options = elem.options;
  5330. var index = elem.selectedIndex;
  5331. /** @type {boolean} */
  5332. var one = "select-one" === elem.type;
  5333. /** @type {(Array|null)} */
  5334. var values = one ? null : [];
  5335. var max = one ? index + 1 : options.length;
  5336. var i = index < 0 ? max : one ? index : 0;
  5337. for (; i < max; i++) {
  5338. if (option = options[i], (option.selected || i === index) && !option.disabled && (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup"))) {
  5339. if (value = jQuery(option).val(), one) {
  5340. return value;
  5341. }
  5342. values.push(value);
  5343. }
  5344. }
  5345. return values;
  5346. },
  5347. set : function(elem, value) {
  5348. var outputFn;
  5349. var val;
  5350. var options = elem.options;
  5351. var result = jQuery.makeArray(value);
  5352. var i = options.length;
  5353. for (; i--;) {
  5354. val = options[i];
  5355. if (val.selected = jQuery.inArray(jQuery.valHooks.option.get(val), result) > -1) {
  5356. /** @type {boolean} */
  5357. outputFn = true;
  5358. }
  5359. }
  5360. return outputFn || (elem.selectedIndex = -1), result;
  5361. }
  5362. }
  5363. }
  5364. });
  5365. jQuery.each(["radio", "checkbox"], function() {
  5366. jQuery.valHooks[this] = {
  5367. set : function(elem, value) {
  5368. if (jQuery.isArray(value)) {
  5369. return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;
  5370. }
  5371. }
  5372. };
  5373. if (!support.checkOn) {
  5374. /**
  5375. * @param {!Object} elem
  5376. * @return {?}
  5377. */
  5378. jQuery.valHooks[this].get = function(elem) {
  5379. return null === elem.getAttribute("value") ? "on" : elem.value;
  5380. };
  5381. }
  5382. });
  5383. /** @type {!RegExp} */
  5384. var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
  5385. jQuery.extend(jQuery.event, {
  5386. trigger : function(event, value, elem, onlyHandlers) {
  5387. var i;
  5388. var cur;
  5389. var tmp;
  5390. var bubbleType;
  5391. var ontype;
  5392. var handle;
  5393. var special;
  5394. /** @type {!Array} */
  5395. var eventPath = [elem || document];
  5396. var type = hasOwn.call(event, "type") ? event.type : event;
  5397. var h = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
  5398. if (cur = tmp = elem = elem || document, 3 !== elem.nodeType && 8 !== elem.nodeType && !rfocusMorph.test(type + jQuery.event.triggered) && (type.indexOf(".") > -1 && (h = type.split("."), type = h.shift(), h.sort()), ontype = type.indexOf(":") < 0 && "on" + type, event = event[jQuery.expando] ? event : new jQuery.Event(type, "object" == typeof event && event), event.isTrigger = onlyHandlers ? 2 : 3, event.namespace = h.join("."), event.rnamespace = event.namespace ? new RegExp("(^|\\.)" +
  5399. h.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, event.result = void 0, event.target || (event.target = elem), value = null == value ? [event] : jQuery.makeArray(value, [event]), special = jQuery.event.special[type] || {}, onlyHandlers || !special.trigger || special.trigger.apply(elem, value) !== false)) {
  5400. if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
  5401. bubbleType = special.delegateType || type;
  5402. if (!rfocusMorph.test(bubbleType + type)) {
  5403. cur = cur.parentNode;
  5404. }
  5405. for (; cur; cur = cur.parentNode) {
  5406. eventPath.push(cur);
  5407. tmp = cur;
  5408. }
  5409. if (tmp === (elem.ownerDocument || document)) {
  5410. eventPath.push(tmp.defaultView || tmp.parentWindow || window);
  5411. }
  5412. }
  5413. /** @type {number} */
  5414. i = 0;
  5415. for (; (cur = eventPath[i++]) && !event.isPropagationStopped();) {
  5416. event.type = i > 1 ? bubbleType : special.bindType || type;
  5417. handle = (dataPriv.get(cur, "events") || {})[event.type] && dataPriv.get(cur, "handle");
  5418. if (handle) {
  5419. handle.apply(cur, value);
  5420. }
  5421. handle = ontype && cur[ontype];
  5422. if (handle && handle.apply && acceptData(cur)) {
  5423. event.result = handle.apply(cur, value);
  5424. if (event.result === false) {
  5425. event.preventDefault();
  5426. }
  5427. }
  5428. }
  5429. return event.type = type, onlyHandlers || event.isDefaultPrevented() || special._default && special._default.apply(eventPath.pop(), value) !== false || !acceptData(elem) || ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem) && (tmp = elem[ontype], tmp && (elem[ontype] = null), jQuery.event.triggered = type, elem[type](), jQuery.event.triggered = void 0, tmp && (elem[ontype] = tmp)), event.result;
  5430. }
  5431. },
  5432. simulate : function(type, elem, options) {
  5433. var r = jQuery.extend(new jQuery.Event, options, {
  5434. type : type,
  5435. isSimulated : true
  5436. });
  5437. jQuery.event.trigger(r, null, elem);
  5438. }
  5439. });
  5440. jQuery.fn.extend({
  5441. trigger : function(event, data) {
  5442. return this.each(function() {
  5443. jQuery.event.trigger(event, data, this);
  5444. });
  5445. },
  5446. triggerHandler : function(type, data) {
  5447. var parent = this[0];
  5448. if (parent) {
  5449. return jQuery.event.trigger(type, data, parent, true);
  5450. }
  5451. }
  5452. });
  5453. jQuery.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "), function(canCreateDiscussions, name) {
  5454. /**
  5455. * @param {!Node} data
  5456. * @param {!Node} callback
  5457. * @return {?}
  5458. */
  5459. jQuery.fn[name] = function(data, callback) {
  5460. return arguments.length > 0 ? this.on(name, null, data, callback) : this.trigger(name);
  5461. };
  5462. });
  5463. jQuery.fn.extend({
  5464. hover : function(fnOver, fnOut) {
  5465. return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
  5466. }
  5467. });
  5468. /** @type {boolean} */
  5469. support.focusin = "onfocusin" in window;
  5470. if (!support.focusin) {
  5471. jQuery.each({
  5472. focus : "focusin",
  5473. blur : "focusout"
  5474. }, function(orig, fix) {
  5475. /**
  5476. * @param {(Object|string)} event
  5477. * @return {undefined}
  5478. */
  5479. var handler = function(event) {
  5480. jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
  5481. };
  5482. jQuery.event.special[fix] = {
  5483. setup : function() {
  5484. var doc = this.ownerDocument || this;
  5485. var attaches = dataPriv.access(doc, fix);
  5486. if (!attaches) {
  5487. doc.addEventListener(orig, handler, true);
  5488. }
  5489. dataPriv.access(doc, fix, (attaches || 0) + 1);
  5490. },
  5491. teardown : function() {
  5492. var doc = this.ownerDocument || this;
  5493. /** @type {number} */
  5494. var data = dataPriv.access(doc, fix) - 1;
  5495. if (data) {
  5496. dataPriv.access(doc, fix, data);
  5497. } else {
  5498. doc.removeEventListener(orig, handler, true);
  5499. dataPriv.remove(doc, fix);
  5500. }
  5501. }
  5502. };
  5503. });
  5504. }
  5505. var location = window.location;
  5506. var widgetUniqueIDIndex = jQuery.now();
  5507. /** @type {!RegExp} */
  5508. var rquery = /\?/;
  5509. /**
  5510. * @param {string} data
  5511. * @return {?}
  5512. */
  5513. jQuery.parseXML = function(data) {
  5514. var xml;
  5515. if (!data || "string" != typeof data) {
  5516. return null;
  5517. }
  5518. try {
  5519. xml = (new window.DOMParser).parseFromString(data, "text/xml");
  5520. } catch (e) {
  5521. xml = void 0;
  5522. }
  5523. return xml && !xml.getElementsByTagName("parsererror").length || jQuery.error("Invalid XML: " + data), xml;
  5524. };
  5525. /** @type {!RegExp} */
  5526. var rNum = /\[\]$/;
  5527. /** @type {!RegExp} */
  5528. var reVowels = /\r?\n/g;
  5529. /** @type {!RegExp} */
  5530. var reHasHexPrefix = /^(?:submit|button|image|reset|file)$/i;
  5531. /** @type {!RegExp} */
  5532. var rsubmittable = /^(?:input|select|textarea|keygen)/i;
  5533. /**
  5534. * @param {?} a
  5535. * @param {string} obj
  5536. * @return {?}
  5537. */
  5538. jQuery.param = function(a, obj) {
  5539. var j;
  5540. /** @type {!Array} */
  5541. var displayUsedBy = [];
  5542. /**
  5543. * @param {?} example
  5544. * @param {!Object} value
  5545. * @return {undefined}
  5546. */
  5547. var add = function(example, value) {
  5548. var val = jQuery.isFunction(value) ? value() : value;
  5549. /** @type {string} */
  5550. displayUsedBy[displayUsedBy.length] = encodeURIComponent(example) + "=" + encodeURIComponent(null == val ? "" : val);
  5551. };
  5552. if (jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
  5553. jQuery.each(a, function() {
  5554. add(this.name, this.value);
  5555. });
  5556. } else {
  5557. for (j in a) {
  5558. callback(j, a[j], obj, add);
  5559. }
  5560. }
  5561. return displayUsedBy.join("&");
  5562. };
  5563. jQuery.fn.extend({
  5564. serialize : function() {
  5565. return jQuery.param(this.serializeArray());
  5566. },
  5567. serializeArray : function() {
  5568. return this.map(function() {
  5569. var elements = jQuery.prop(this, "elements");
  5570. return elements ? jQuery.makeArray(elements) : this;
  5571. }).filter(function() {
  5572. var string = this.type;
  5573. return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !reHasHexPrefix.test(string) && (this.checked || !reg.test(string));
  5574. }).map(function(canCreateDiscussions, ctlParams) {
  5575. var val = jQuery(this).val();
  5576. return null == val ? null : jQuery.isArray(val) ? jQuery.map(val, function(val) {
  5577. return {
  5578. name : ctlParams.name,
  5579. value : val.replace(reVowels, "\r\n")
  5580. };
  5581. }) : {
  5582. name : ctlParams.name,
  5583. value : val.replace(reVowels, "\r\n")
  5584. };
  5585. }).get();
  5586. }
  5587. });
  5588. /** @type {!RegExp} */
  5589. var jsre = /%20/g;
  5590. /** @type {!RegExp} */
  5591. var rhash = /#.*$/;
  5592. /** @type {!RegExp} */
  5593. var rts = /([?&])_=[^&]*/;
  5594. /** @type {!RegExp} */
  5595. var rheaders = /^(.*?):[ \t]*([^\r\n]*)$/gm;
  5596. /** @type {!RegExp} */
  5597. var rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/;
  5598. /** @type {!RegExp} */
  5599. var re = /^(?:GET|HEAD)$/;
  5600. /** @type {!RegExp} */
  5601. var rprotocol = /^\/\//;
  5602. var prefilters = {};
  5603. var transports = {};
  5604. /** @type {string} */
  5605. var Mt = "*/".concat("*");
  5606. var originAnchor = document.createElement("a");
  5607. originAnchor.href = location.href;
  5608. jQuery.extend({
  5609. active : 0,
  5610. lastModified : {},
  5611. etag : {},
  5612. ajaxSettings : {
  5613. url : location.href,
  5614. type : "GET",
  5615. isLocal : rlocalProtocol.test(location.protocol),
  5616. global : true,
  5617. processData : true,
  5618. async : true,
  5619. contentType : "application/x-www-form-urlencoded; charset=UTF-8",
  5620. accepts : {
  5621. "*" : Mt,
  5622. text : "text/plain",
  5623. html : "text/html",
  5624. xml : "application/xml, text/xml",
  5625. json : "application/json, text/javascript"
  5626. },
  5627. contents : {
  5628. xml : /\bxml\b/,
  5629. html : /\bhtml/,
  5630. json : /\bjson\b/
  5631. },
  5632. responseFields : {
  5633. xml : "responseXML",
  5634. text : "responseText",
  5635. json : "responseJSON"
  5636. },
  5637. converters : {
  5638. "* text" : String,
  5639. "text html" : true,
  5640. "text json" : JSON.parse,
  5641. "text xml" : jQuery.parseXML
  5642. },
  5643. flatOptions : {
  5644. url : true,
  5645. context : true
  5646. }
  5647. },
  5648. ajaxSetup : function(target, settings) {
  5649. return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
  5650. },
  5651. ajaxPrefilter : addToPrefiltersOrTransports(prefilters),
  5652. ajaxTransport : addToPrefiltersOrTransports(transports),
  5653. ajax : function(url, options) {
  5654. /**
  5655. * @param {number} status
  5656. * @param {string} nativeStatusText
  5657. * @param {!Array} responses
  5658. * @param {string} headers
  5659. * @return {undefined}
  5660. */
  5661. function done(status, nativeStatusText, responses, headers) {
  5662. var isSuccess;
  5663. var success;
  5664. var error;
  5665. var response;
  5666. var modified;
  5667. /** @type {string} */
  5668. var statusText = nativeStatusText;
  5669. if (!completed) {
  5670. /** @type {boolean} */
  5671. completed = true;
  5672. if (showAboveTimeout) {
  5673. window.clearTimeout(showAboveTimeout);
  5674. }
  5675. transport = void 0;
  5676. responseHeadersString = headers || "";
  5677. /** @type {number} */
  5678. jqXHR.readyState = status > 0 ? 4 : 0;
  5679. /** @type {boolean} */
  5680. isSuccess = status >= 200 && status < 300 || 304 === status;
  5681. if (responses) {
  5682. response = ajaxHandleResponses(s, jqXHR, responses);
  5683. }
  5684. response = ajaxConvert(s, response, jqXHR, isSuccess);
  5685. if (isSuccess) {
  5686. if (s.ifModified) {
  5687. modified = jqXHR.getResponseHeader("Last-Modified");
  5688. if (modified) {
  5689. jQuery.lastModified[cacheURL] = modified;
  5690. }
  5691. modified = jqXHR.getResponseHeader("etag");
  5692. if (modified) {
  5693. jQuery.etag[cacheURL] = modified;
  5694. }
  5695. }
  5696. if (204 === status || "HEAD" === s.type) {
  5697. /** @type {string} */
  5698. statusText = "nocontent";
  5699. } else {
  5700. if (304 === status) {
  5701. /** @type {string} */
  5702. statusText = "notmodified";
  5703. } else {
  5704. statusText = response.state;
  5705. success = response.data;
  5706. error = response.error;
  5707. /** @type {boolean} */
  5708. isSuccess = !error;
  5709. }
  5710. }
  5711. } else {
  5712. error = statusText;
  5713. if (!(!status && statusText)) {
  5714. /** @type {string} */
  5715. statusText = "error";
  5716. if (status < 0) {
  5717. /** @type {number} */
  5718. status = 0;
  5719. }
  5720. }
  5721. }
  5722. /** @type {number} */
  5723. jqXHR.status = status;
  5724. /** @type {string} */
  5725. jqXHR.statusText = (nativeStatusText || statusText) + "";
  5726. if (isSuccess) {
  5727. deferred.resolveWith(obj, [success, statusText, jqXHR]);
  5728. } else {
  5729. deferred.rejectWith(obj, [jqXHR, statusText, error]);
  5730. }
  5731. jqXHR.statusCode(statusCode);
  5732. statusCode = void 0;
  5733. if (f) {
  5734. globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
  5735. }
  5736. completeDeferred.fireWith(obj, [jqXHR, statusText]);
  5737. if (f) {
  5738. globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
  5739. if (!--jQuery.active) {
  5740. jQuery.event.trigger("ajaxStop");
  5741. }
  5742. }
  5743. }
  5744. }
  5745. if ("object" == typeof url) {
  5746. /** @type {string} */
  5747. options = url;
  5748. url = void 0;
  5749. }
  5750. options = options || {};
  5751. var transport;
  5752. var cacheURL;
  5753. var responseHeadersString;
  5754. var n;
  5755. var showAboveTimeout;
  5756. var urlAnchor;
  5757. var completed;
  5758. var f;
  5759. var i;
  5760. var uncached;
  5761. var s = jQuery.ajaxSetup({}, options);
  5762. var obj = s.context || s;
  5763. var globalEventContext = s.context && (obj.nodeType || obj.jquery) ? jQuery(obj) : jQuery.event;
  5764. var deferred = jQuery.Deferred();
  5765. var completeDeferred = jQuery.Callbacks("once memory");
  5766. var statusCode = s.statusCode || {};
  5767. var data = {};
  5768. var requestHeadersNames = {};
  5769. /** @type {string} */
  5770. var status = "canceled";
  5771. var jqXHR = {
  5772. readyState : 0,
  5773. getResponseHeader : function(header) {
  5774. var i;
  5775. if (completed) {
  5776. if (!n) {
  5777. n = {};
  5778. for (; i = rheaders.exec(responseHeadersString);) {
  5779. /** @type {string} */
  5780. n[i[1].toLowerCase()] = i[2];
  5781. }
  5782. }
  5783. i = n[header.toLowerCase()];
  5784. }
  5785. return null == i ? null : i;
  5786. },
  5787. getAllResponseHeaders : function() {
  5788. return completed ? responseHeadersString : null;
  5789. },
  5790. setRequestHeader : function(name, value) {
  5791. return null == completed && (name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name, data[name] = value), this;
  5792. },
  5793. overrideMimeType : function(type) {
  5794. return null == completed && (s.mimeType = type), this;
  5795. },
  5796. statusCode : function(map) {
  5797. var tmp;
  5798. if (map) {
  5799. if (completed) {
  5800. jqXHR.always(map[jqXHR.status]);
  5801. } else {
  5802. for (tmp in map) {
  5803. /** @type {!Array} */
  5804. statusCode[tmp] = [statusCode[tmp], map[tmp]];
  5805. }
  5806. }
  5807. }
  5808. return this;
  5809. },
  5810. abort : function(type) {
  5811. var statusText = type || status;
  5812. return transport && transport.abort(statusText), done(0, statusText), this;
  5813. }
  5814. };
  5815. if (deferred.promise(jqXHR), s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//"), s.type = options.method || options.type || s.method || s.type, s.dataTypes = (s.dataType || "*").toLowerCase().match(rnotwhite) || [""], null == s.crossDomain) {
  5816. urlAnchor = document.createElement("a");
  5817. try {
  5818. /** @type {string} */
  5819. urlAnchor.href = s.url;
  5820. /** @type {string} */
  5821. urlAnchor.href = urlAnchor.href;
  5822. /** @type {boolean} */
  5823. s.crossDomain = originAnchor.protocol + "//" + originAnchor.host != urlAnchor.protocol + "//" + urlAnchor.host;
  5824. } catch (e) {
  5825. /** @type {boolean} */
  5826. s.crossDomain = true;
  5827. }
  5828. }
  5829. if (s.data && s.processData && "string" != typeof s.data && (s.data = jQuery.param(s.data, s.traditional)), inspectPrefiltersOrTransports(prefilters, s, options, jqXHR), completed) {
  5830. return jqXHR;
  5831. }
  5832. f = jQuery.event && s.global;
  5833. if (f && 0 === jQuery.active++) {
  5834. jQuery.event.trigger("ajaxStart");
  5835. }
  5836. s.type = s.type.toUpperCase();
  5837. /** @type {boolean} */
  5838. s.hasContent = !re.test(s.type);
  5839. /** @type {string} */
  5840. cacheURL = s.url.replace(rhash, "");
  5841. if (s.hasContent) {
  5842. if (s.data && s.processData && 0 === (s.contentType || "").indexOf("application/x-www-form-urlencoded")) {
  5843. s.data = s.data.replace(jsre, "+");
  5844. }
  5845. } else {
  5846. /** @type {string} */
  5847. uncached = s.url.slice(cacheURL.length);
  5848. if (s.data) {
  5849. /** @type {string} */
  5850. cacheURL = cacheURL + ((rquery.test(cacheURL) ? "&" : "?") + s.data);
  5851. delete s.data;
  5852. }
  5853. if (s.cache === false) {
  5854. /** @type {string} */
  5855. cacheURL = cacheURL.replace(rts, "");
  5856. /** @type {string} */
  5857. uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + widgetUniqueIDIndex++ + uncached;
  5858. }
  5859. /** @type {string} */
  5860. s.url = cacheURL + uncached;
  5861. }
  5862. if (s.ifModified) {
  5863. if (jQuery.lastModified[cacheURL]) {
  5864. jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
  5865. }
  5866. if (jQuery.etag[cacheURL]) {
  5867. jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
  5868. }
  5869. }
  5870. if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
  5871. jqXHR.setRequestHeader("Content-Type", s.contentType);
  5872. }
  5873. jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + ("*" !== s.dataTypes[0] ? ", " + Mt + "; q=0.01" : "") : s.accepts["*"]);
  5874. for (i in s.headers) {
  5875. jqXHR.setRequestHeader(i, s.headers[i]);
  5876. }
  5877. if (s.beforeSend && (s.beforeSend.call(obj, jqXHR, s) === false || completed)) {
  5878. return jqXHR.abort();
  5879. }
  5880. if (status = "abort", completeDeferred.add(s.complete), jqXHR.done(s.success), jqXHR.fail(s.error), transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR)) {
  5881. if (jqXHR.readyState = 1, f && globalEventContext.trigger("ajaxSend", [jqXHR, s]), completed) {
  5882. return jqXHR;
  5883. }
  5884. if (s.async && s.timeout > 0) {
  5885. showAboveTimeout = window.setTimeout(function() {
  5886. jqXHR.abort("timeout");
  5887. }, s.timeout);
  5888. }
  5889. try {
  5890. /** @type {boolean} */
  5891. completed = false;
  5892. transport.send(data, done);
  5893. } catch (success) {
  5894. if (completed) {
  5895. throw success;
  5896. }
  5897. done(-1, success);
  5898. }
  5899. } else {
  5900. done(-1, "No Transport");
  5901. }
  5902. return jqXHR;
  5903. },
  5904. getJSON : function(data, callback, options) {
  5905. return jQuery.get(data, callback, options, "json");
  5906. },
  5907. getScript : function(data, options) {
  5908. return jQuery.get(data, void 0, options, "script");
  5909. }
  5910. });
  5911. jQuery.each(["get", "post"], function(canCreateDiscussions, method) {
  5912. /**
  5913. * @param {string} url
  5914. * @param {!Object} p
  5915. * @param {!Function} color
  5916. * @param {string} type
  5917. * @return {?}
  5918. */
  5919. jQuery[method] = function(url, p, color, type) {
  5920. return jQuery.isFunction(p) && (type = type || color, color = p, p = void 0), jQuery.ajax(jQuery.extend({
  5921. url : url,
  5922. type : method,
  5923. dataType : type,
  5924. data : p,
  5925. success : color
  5926. }, jQuery.isPlainObject(url) && url));
  5927. };
  5928. });
  5929. /**
  5930. * @param {string} url
  5931. * @return {?}
  5932. */
  5933. jQuery._evalUrl = function(url) {
  5934. return jQuery.ajax({
  5935. url : url,
  5936. type : "GET",
  5937. dataType : "script",
  5938. cache : true,
  5939. async : false,
  5940. global : false,
  5941. throws : true
  5942. });
  5943. };
  5944. jQuery.fn.extend({
  5945. wrapAll : function(html) {
  5946. var t;
  5947. return this[0] && (jQuery.isFunction(html) && (html = html.call(this[0])), t = jQuery(html, this[0].ownerDocument).eq(0).clone(true), this[0].parentNode && t.insertBefore(this[0]), t.map(function() {
  5948. var elem = this;
  5949. for (; elem.firstElementChild;) {
  5950. elem = elem.firstElementChild;
  5951. }
  5952. return elem;
  5953. }).append(this)), this;
  5954. },
  5955. wrapInner : function(html) {
  5956. return jQuery.isFunction(html) ? this.each(function(i) {
  5957. jQuery(this).wrapInner(html.call(this, i));
  5958. }) : this.each(function() {
  5959. var t = jQuery(this);
  5960. var contents = t.contents();
  5961. if (contents.length) {
  5962. contents.wrapAll(html);
  5963. } else {
  5964. t.append(html);
  5965. }
  5966. });
  5967. },
  5968. wrap : function(html) {
  5969. var isFunction = jQuery.isFunction(html);
  5970. return this.each(function(i) {
  5971. jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
  5972. });
  5973. },
  5974. unwrap : function(fn) {
  5975. return this.parent(fn).not("body").each(function() {
  5976. jQuery(this).replaceWith(this.childNodes);
  5977. }), this;
  5978. }
  5979. });
  5980. /**
  5981. * @param {string} a
  5982. * @return {?}
  5983. */
  5984. jQuery.expr.pseudos.hidden = function(a) {
  5985. return !jQuery.expr.pseudos.visible(a);
  5986. };
  5987. /**
  5988. * @param {!Element} elem
  5989. * @return {?}
  5990. */
  5991. jQuery.expr.pseudos.visible = function(elem) {
  5992. return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
  5993. };
  5994. /**
  5995. * @return {?}
  5996. */
  5997. jQuery.ajaxSettings.xhr = function() {
  5998. try {
  5999. return new window.XMLHttpRequest;
  6000. } catch (e) {
  6001. }
  6002. };
  6003. var xhrSuccessStatus = {
  6004. 0 : 200,
  6005. 1223 : 204
  6006. };
  6007. var xhrSupported = jQuery.ajaxSettings.xhr();
  6008. /** @type {boolean} */
  6009. support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
  6010. /** @type {boolean} */
  6011. support.ajax = xhrSupported = !!xhrSupported;
  6012. jQuery.ajaxTransport(function(s) {
  6013. var callback;
  6014. var errorCallback;
  6015. if (support.cors || xhrSupported && !s.crossDomain) {
  6016. return {
  6017. send : function(headers, callback) {
  6018. var i;
  6019. var xhr = s.xhr();
  6020. if (xhr.open(s.type, s.url, s.async, s.username, s.password), s.xhrFields) {
  6021. for (i in s.xhrFields) {
  6022. xhr[i] = s.xhrFields[i];
  6023. }
  6024. }
  6025. if (s.mimeType && xhr.overrideMimeType) {
  6026. xhr.overrideMimeType(s.mimeType);
  6027. }
  6028. if (!(s.crossDomain || headers["X-Requested-With"])) {
  6029. /** @type {string} */
  6030. headers["X-Requested-With"] = "XMLHttpRequest";
  6031. }
  6032. for (i in headers) {
  6033. xhr.setRequestHeader(i, headers[i]);
  6034. }
  6035. /**
  6036. * @param {string} event
  6037. * @return {?}
  6038. */
  6039. callback = function(event) {
  6040. return function() {
  6041. if (callback) {
  6042. /** @type {null} */
  6043. callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
  6044. if ("abort" === event) {
  6045. xhr.abort();
  6046. } else {
  6047. if ("error" === event) {
  6048. if ("number" != typeof xhr.status) {
  6049. callback(0, "error");
  6050. } else {
  6051. callback(xhr.status, xhr.statusText);
  6052. }
  6053. } else {
  6054. callback(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, "text" !== (xhr.responseType || "text") || "string" != typeof xhr.responseText ? {
  6055. binary : xhr.response
  6056. } : {
  6057. text : xhr.responseText
  6058. }, xhr.getAllResponseHeaders());
  6059. }
  6060. }
  6061. }
  6062. };
  6063. };
  6064. xhr.onload = callback();
  6065. errorCallback = xhr.onerror = callback("error");
  6066. if (void 0 !== xhr.onabort) {
  6067. xhr.onabort = errorCallback;
  6068. } else {
  6069. /**
  6070. * @return {undefined}
  6071. */
  6072. xhr.onreadystatechange = function() {
  6073. if (4 === xhr.readyState) {
  6074. window.setTimeout(function() {
  6075. if (callback) {
  6076. errorCallback();
  6077. }
  6078. });
  6079. }
  6080. };
  6081. }
  6082. callback = callback("abort");
  6083. try {
  6084. xhr.send(s.hasContent && s.data || null);
  6085. } catch (e) {
  6086. if (callback) {
  6087. throw e;
  6088. }
  6089. }
  6090. },
  6091. abort : function() {
  6092. if (callback) {
  6093. callback();
  6094. }
  6095. }
  6096. };
  6097. }
  6098. });
  6099. jQuery.ajaxPrefilter(function(options) {
  6100. if (options.crossDomain) {
  6101. /** @type {boolean} */
  6102. options.contents.script = false;
  6103. }
  6104. });
  6105. jQuery.ajaxSetup({
  6106. accepts : {
  6107. script : "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  6108. },
  6109. contents : {
  6110. script : /\b(?:java|ecma)script\b/
  6111. },
  6112. converters : {
  6113. "text script" : function(value) {
  6114. return jQuery.globalEval(value), value;
  6115. }
  6116. }
  6117. });
  6118. jQuery.ajaxPrefilter("script", function(settings) {
  6119. if (void 0 === settings.cache) {
  6120. /** @type {boolean} */
  6121. settings.cache = false;
  6122. }
  6123. if (settings.crossDomain) {
  6124. /** @type {string} */
  6125. settings.type = "GET";
  6126. }
  6127. });
  6128. jQuery.ajaxTransport("script", function(s) {
  6129. if (s.crossDomain) {
  6130. var fileElem;
  6131. var callback;
  6132. return {
  6133. send : function(packets, callback) {
  6134. fileElem = jQuery("<script>").prop({
  6135. charset : s.scriptCharset,
  6136. src : s.url
  6137. }).on("load error", callback = function(result) {
  6138. fileElem.remove();
  6139. /** @type {null} */
  6140. callback = null;
  6141. if (result) {
  6142. callback("error" === result.type ? 404 : 200, result.type);
  6143. }
  6144. });
  6145. document.head.appendChild(fileElem[0]);
  6146. },
  6147. abort : function() {
  6148. if (callback) {
  6149. callback();
  6150. }
  6151. }
  6152. };
  6153. }
  6154. });
  6155. /** @type {!Array} */
  6156. var oldCallbacks = [];
  6157. /** @type {!RegExp} */
  6158. var t = /(=)\?(?=&|$)|\?\?/;
  6159. jQuery.ajaxSetup({
  6160. jsonp : "callback",
  6161. jsonpCallback : function() {
  6162. var indexLookupKey = oldCallbacks.pop() || jQuery.expando + "_" + widgetUniqueIDIndex++;
  6163. return this[indexLookupKey] = true, indexLookupKey;
  6164. }
  6165. });
  6166. jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, scanners) {
  6167. var callbackName;
  6168. var overwritten;
  6169. var responseContainer;
  6170. /** @type {(boolean|string)} */
  6171. var i = s.jsonp !== false && (t.test(s.url) ? "url" : "string" == typeof s.data && 0 === (s.contentType || "").indexOf("application/x-www-form-urlencoded") && t.test(s.data) && "data");
  6172. if (i || "jsonp" === s.dataTypes[0]) {
  6173. return callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback, i ? s[i] = s[i].replace(t, "$1" + callbackName) : s.jsonp !== false && (s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName), s.converters["script json"] = function() {
  6174. return responseContainer || jQuery.error(callbackName + " was not called"), responseContainer[0];
  6175. }, s.dataTypes[0] = "json", overwritten = window[callbackName], window[callbackName] = function() {
  6176. /** @type {!Arguments} */
  6177. responseContainer = arguments;
  6178. }, scanners.always(function() {
  6179. if (void 0 === overwritten) {
  6180. jQuery(window).removeProp(callbackName);
  6181. } else {
  6182. window[callbackName] = overwritten;
  6183. }
  6184. if (s[callbackName]) {
  6185. s.jsonpCallback = originalSettings.jsonpCallback;
  6186. oldCallbacks.push(callbackName);
  6187. }
  6188. if (responseContainer && jQuery.isFunction(overwritten)) {
  6189. overwritten(responseContainer[0]);
  6190. }
  6191. responseContainer = overwritten = void 0;
  6192. }), "script";
  6193. }
  6194. });
  6195. support.createHTMLDocument = function() {
  6196. var iframeBody = document.implementation.createHTMLDocument("").body;
  6197. return iframeBody.innerHTML = "<form></form><form></form>", 2 === iframeBody.childNodes.length;
  6198. }();
  6199. /**
  6200. * @param {string} data
  6201. * @param {!Object} context
  6202. * @param {!Function} keepScripts
  6203. * @return {?}
  6204. */
  6205. jQuery.parseHTML = function(data, context, keepScripts) {
  6206. if ("string" != typeof data) {
  6207. return [];
  6208. }
  6209. if ("boolean" == typeof context) {
  6210. /** @type {!Object} */
  6211. keepScripts = context;
  6212. /** @type {boolean} */
  6213. context = false;
  6214. }
  6215. var base;
  6216. var parsed;
  6217. var scripts;
  6218. return context || (support.createHTMLDocument ? (context = document.implementation.createHTMLDocument(""), base = context.createElement("base"), base.href = document.location.href, context.head.appendChild(base)) : context = document), parsed = rsingleTag.exec(data), scripts = !keepScripts && [], parsed ? [context.createElement(parsed[1])] : (parsed = buildFragment([data], context, scripts), scripts && scripts.length && jQuery(scripts).remove(), jQuery.merge([], parsed.childNodes));
  6219. };
  6220. /**
  6221. * @param {string} result
  6222. * @param {!Object} value
  6223. * @param {!Array} callback
  6224. * @return {?}
  6225. */
  6226. jQuery.fn.load = function(result, value, callback) {
  6227. var name;
  6228. var method;
  6229. var args;
  6230. var $ = this;
  6231. var val = result.indexOf(" ");
  6232. return val > -1 && (name = jQuery.trim(result.slice(val)), result = result.slice(0, val)), jQuery.isFunction(value) ? (callback = value, value = void 0) : value && "object" == typeof value && (method = "POST"), $.length > 0 && jQuery.ajax({
  6233. url : result,
  6234. type : method || "GET",
  6235. dataType : "html",
  6236. data : value
  6237. }).done(function(data) {
  6238. /** @type {!Arguments} */
  6239. args = arguments;
  6240. $.html(name ? jQuery("<div>").append(jQuery.parseHTML(data)).find(name) : data);
  6241. }).always(callback && function(elem, document) {
  6242. $.each(function() {
  6243. callback.apply(this, args || [elem.responseText, document, elem]);
  6244. });
  6245. }), this;
  6246. };
  6247. jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(canCreateDiscussions, name) {
  6248. /**
  6249. * @param {string} e
  6250. * @return {?}
  6251. */
  6252. jQuery.fn[name] = function(e) {
  6253. return this.on(name, e);
  6254. };
  6255. });
  6256. /**
  6257. * @param {?} elem
  6258. * @return {?}
  6259. */
  6260. jQuery.expr.pseudos.animated = function(elem) {
  6261. return jQuery.grep(jQuery.timers, function(fn) {
  6262. return elem === fn.elem;
  6263. }).length;
  6264. };
  6265. jQuery.offset = {
  6266. setOffset : function(element, options, x) {
  6267. var opt_boundsOrLeft;
  6268. var width;
  6269. var curCSSTop;
  6270. var height;
  6271. var curOffset;
  6272. var curCSSLeft;
  6273. var div;
  6274. var propertyName = jQuery.css(element, "position");
  6275. var f = jQuery(element);
  6276. var c = {};
  6277. if ("static" === propertyName) {
  6278. /** @type {string} */
  6279. element.style.position = "relative";
  6280. }
  6281. curOffset = f.offset();
  6282. curCSSTop = jQuery.css(element, "top");
  6283. curCSSLeft = jQuery.css(element, "left");
  6284. /** @type {boolean} */
  6285. div = ("absolute" === propertyName || "fixed" === propertyName) && (curCSSTop + curCSSLeft).indexOf("auto") > -1;
  6286. if (div) {
  6287. opt_boundsOrLeft = f.position();
  6288. height = opt_boundsOrLeft.top;
  6289. width = opt_boundsOrLeft.left;
  6290. } else {
  6291. /** @type {number} */
  6292. height = parseFloat(curCSSTop) || 0;
  6293. /** @type {number} */
  6294. width = parseFloat(curCSSLeft) || 0;
  6295. }
  6296. if (jQuery.isFunction(options)) {
  6297. options = options.call(element, x, jQuery.extend({}, curOffset));
  6298. }
  6299. if (null != options.top) {
  6300. /** @type {number} */
  6301. c.top = options.top - curOffset.top + height;
  6302. }
  6303. if (null != options.left) {
  6304. /** @type {number} */
  6305. c.left = options.left - curOffset.left + width;
  6306. }
  6307. if ("using" in options) {
  6308. options.using.call(element, c);
  6309. } else {
  6310. f.css(c);
  6311. }
  6312. }
  6313. };
  6314. jQuery.fn.extend({
  6315. offset : function(y) {
  6316. if (arguments.length) {
  6317. return void 0 === y ? this : this.each(function(i) {
  6318. jQuery.offset.setOffset(this, y, i);
  6319. });
  6320. }
  6321. var doc;
  6322. var win;
  6323. var rect;
  6324. var elem;
  6325. var range = this[0];
  6326. if (range) {
  6327. return range.getClientRects().length ? (rect = range.getBoundingClientRect(), rect.width || rect.height ? (elem = range.ownerDocument, win = getWindow(elem), doc = elem.documentElement, {
  6328. top : rect.top + win.pageYOffset - doc.clientTop,
  6329. left : rect.left + win.pageXOffset - doc.clientLeft
  6330. }) : rect) : {
  6331. top : 0,
  6332. left : 0
  6333. };
  6334. }
  6335. },
  6336. position : function() {
  6337. if (this[0]) {
  6338. var offsetParent;
  6339. var toOffset;
  6340. var n = this[0];
  6341. var offset = {
  6342. top : 0,
  6343. left : 0
  6344. };
  6345. return "fixed" === jQuery.css(n, "position") ? toOffset = n.getBoundingClientRect() : (offsetParent = this.offsetParent(), toOffset = this.offset(), jQuery.nodeName(offsetParent[0], "html") || (offset = offsetParent.offset()), offset = {
  6346. top : offset.top + jQuery.css(offsetParent[0], "borderTopWidth", true),
  6347. left : offset.left + jQuery.css(offsetParent[0], "borderLeftWidth", true)
  6348. }), {
  6349. top : toOffset.top - offset.top - jQuery.css(n, "marginTop", true),
  6350. left : toOffset.left - offset.left - jQuery.css(n, "marginLeft", true)
  6351. };
  6352. }
  6353. },
  6354. offsetParent : function() {
  6355. return this.map(function() {
  6356. var offsetParent = this.offsetParent;
  6357. for (; offsetParent && "static" === jQuery.css(offsetParent, "position");) {
  6358. offsetParent = offsetParent.offsetParent;
  6359. }
  6360. return offsetParent || docElem;
  6361. });
  6362. }
  6363. });
  6364. jQuery.each({
  6365. scrollLeft : "pageXOffset",
  6366. scrollTop : "pageYOffset"
  6367. }, function(type, prop) {
  6368. /** @type {boolean} */
  6369. var top = "pageYOffset" === prop;
  6370. /**
  6371. * @param {?} value
  6372. * @return {?}
  6373. */
  6374. jQuery.fn[type] = function(value) {
  6375. return access(this, function(el, method, val) {
  6376. var win = getWindow(el);
  6377. return void 0 === val ? win ? win[prop] : el[method] : void(win ? win.scrollTo(top ? win.pageXOffset : val, top ? val : win.pageYOffset) : el[method] = val);
  6378. }, type, value, arguments.length);
  6379. };
  6380. });
  6381. jQuery.each(["top", "left"], function(canCreateDiscussions, prop) {
  6382. jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, val) {
  6383. if (val) {
  6384. return val = curCSS(elem, prop), rnumnonpx.test(val) ? jQuery(elem).position()[prop] + "px" : val;
  6385. }
  6386. });
  6387. });
  6388. jQuery.each({
  6389. Height : "height",
  6390. Width : "width"
  6391. }, function(name, type) {
  6392. jQuery.each({
  6393. padding : "inner" + name,
  6394. content : type,
  6395. "" : "outer" + name
  6396. }, function(defaultExtra, type) {
  6397. /**
  6398. * @param {!Object} margin
  6399. * @param {boolean} value
  6400. * @return {?}
  6401. */
  6402. jQuery.fn[type] = function(margin, value) {
  6403. var chainable = arguments.length && (defaultExtra || "boolean" != typeof margin);
  6404. var extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
  6405. return access(this, function(el, offset, undefined) {
  6406. var doc;
  6407. return jQuery.isWindow(el) ? 0 === type.indexOf("outer") ? el["inner" + name] : el.document.documentElement["client" + name] : 9 === el.nodeType ? (doc = el.documentElement, Math.max(el.body["scroll" + name], doc["scroll" + name], el.body["offset" + name], doc["offset" + name], doc["client" + name])) : void 0 === undefined ? jQuery.css(el, offset, extra) : jQuery.style(el, offset, undefined, extra);
  6408. }, type, chainable ? margin : void 0, chainable);
  6409. };
  6410. });
  6411. });
  6412. jQuery.fn.extend({
  6413. bind : function(name, data, fn) {
  6414. return this.on(name, null, data, fn);
  6415. },
  6416. unbind : function(type, fn) {
  6417. return this.off(type, null, fn);
  6418. },
  6419. delegate : function(event, selector, data, callback) {
  6420. return this.on(selector, event, data, callback);
  6421. },
  6422. undelegate : function(selector, types, fn) {
  6423. return 1 === arguments.length ? this.off(selector, "**") : this.off(types, selector || "**", fn);
  6424. }
  6425. });
  6426. /** @type {function(this:JSONType, string, function(string, *): *=): *} */
  6427. jQuery.parseJSON = JSON.parse;
  6428. if ("function" == typeof define && define.amd) {
  6429. define("jquery", [], function() {
  6430. return jQuery;
  6431. });
  6432. }
  6433. var _jQuery = window.jQuery;
  6434. var old$ = window.$;
  6435. return jQuery.noConflict = function(deep) {
  6436. return window.$ === jQuery && (window.$ = old$), deep && window.jQuery === jQuery && (window.jQuery = _jQuery), jQuery;
  6437. }, zoomAware || (window.jQuery = window.$ = jQuery), jQuery;
  6438. });
  6439. }, {}],
  6440. 2 : [function(require, mixin, n) {
  6441. /**
  6442. * @return {undefined}
  6443. */
  6444. function displayTourItem() {
  6445. clearTimeout(_takingTooLongTimeout);
  6446. var el = $("#toperror");
  6447. el.removeClass("hide");
  6448. el.addClass("show");
  6449. /** @type {number} */
  6450. _takingTooLongTimeout = setTimeout(function() {
  6451. el.addClass("hide");
  6452. setTimeout(function() {
  6453. if ("hide" === el.attr("class")) {
  6454. el.removeClass("hide");
  6455. }
  6456. }, 1E3);
  6457. }, 3E3);
  6458. }
  6459. /**
  6460. * @param {!Event} event
  6461. * @return {undefined}
  6462. */
  6463. function start(event) {
  6464. var messageKind = d.val();
  6465. event.preventDefault();
  6466. d.val("");
  6467. (new Promise(function(saveNotifs) {
  6468. setTimeout(function() {
  6469. var error = (messageKind || "").toLowerCase();
  6470. saveNotifs(error === same.l().toLowerCase() ? {
  6471. redirect : same.r()
  6472. } : {
  6473. error : true
  6474. });
  6475. }, 500);
  6476. })).then(function(res) {
  6477. if (res.redirect) {
  6478. window.location.href = res.redirect;
  6479. } else {
  6480. displayTourItem();
  6481. }
  6482. });
  6483. }
  6484. /**
  6485. * @return {undefined}
  6486. */
  6487. function o() {
  6488. p.hide();
  6489. d.show();
  6490. d.css("width", "148px");
  6491. d.focus();
  6492. }
  6493. /**
  6494. * @return {undefined}
  6495. */
  6496. function load() {
  6497. d.hide();
  6498. p.show();
  6499. d.css("width", "47px");
  6500. }
  6501. /**
  6502. * @return {undefined}
  6503. */
  6504. function factory() {
  6505. d.hide();
  6506. el.find("form").submit(start);
  6507. /** @type {boolean} */
  6508. var e = false;
  6509. el.on("click", function() {
  6510. if (!e) {
  6511. /** @type {boolean} */
  6512. e = true;
  6513. o();
  6514. }
  6515. });
  6516. d.on("blur", function() {
  6517. /** @type {boolean} */
  6518. e = false;
  6519. load();
  6520. });
  6521. }
  6522. var $ = require("jquery");
  6523. var same = require("./obfuscated");
  6524. /** @type {null} */
  6525. var _takingTooLongTimeout = null;
  6526. var el = $("#login-box");
  6527. var p = el.find("p");
  6528. var d = el.find("input");
  6529. mixin.exports = {
  6530. setupLogin : factory
  6531. };
  6532. }, {
  6533. "./obfuscated" : 4,
  6534. jquery : 1
  6535. }],
  6536. 3 : [function(require, canCreateDiscussions, n) {
  6537. /**
  6538. * @param {number} a
  6539. * @return {?}
  6540. */
  6541. function dispatch(a) {
  6542. return --a * a * a + 1;
  6543. }
  6544. /**
  6545. * @param {number} c
  6546. * @param {number} g
  6547. * @param {number} b
  6548. * @return {?}
  6549. */
  6550. function fn(c, g, b) {
  6551. return b > c ? 1 : (b - g) / c;
  6552. }
  6553. /**
  6554. * @return {undefined}
  6555. */
  6556. function init() {
  6557. /**
  6558. * @return {undefined}
  6559. */
  6560. function createElement() {
  6561. /** @type {boolean} */
  6562. u = false;
  6563. /** @type {number} */
  6564. disElement.style.opacity = 1;
  6565. /** @type {number} */
  6566. animatedDiv.style.opacity = 0;
  6567. /** @type {string} */
  6568. animatedDiv.style.height = "0px";
  6569. }
  6570. /** @type {(Element|null)} */
  6571. var disElement = document.getElementById("text-group2");
  6572. /** @type {(Element|null)} */
  6573. var animatedDiv = document.getElementById("continue-wrap");
  6574. /** @type {number} */
  6575. var y = window.scrollY;
  6576. /** @type {number} */
  6577. var selected = 100;
  6578. /** @type {number} */
  6579. var name = 200;
  6580. /** @type {number} */
  6581. var avgItemHeight = 100;
  6582. document.getElementById("continuebtn-wrap").addEventListener("click", function() {
  6583. createElement();
  6584. });
  6585. window.addEventListener("scroll", function() {
  6586. if (u) {
  6587. /** @type {number} */
  6588. var e = window.scrollY;
  6589. var val = fn(selected, y, e);
  6590. var startAddingFrom = dispatch(fn(name, y, e));
  6591. if (startAddingFrom >= 1) {
  6592. createElement();
  6593. }
  6594. disElement.style.opacity = val;
  6595. /** @type {number} */
  6596. animatedDiv.style.opacity = 1 - val;
  6597. /** @type {string} */
  6598. animatedDiv.style.height = avgItemHeight * (1 - startAddingFrom) + "px";
  6599. }
  6600. });
  6601. }
  6602. /**
  6603. * @return {undefined}
  6604. */
  6605. function setup() {
  6606. /** @type {(Element|null)} */
  6607. var currentAlertElem = document.querySelector(".cookie-footer");
  6608. /** @type {string} */
  6609. var key = "_cookieFooterShown";
  6610. if (!(window.localStorage && window.localStorage.getItem(key))) {
  6611. /** @type {string} */
  6612. currentAlertElem.style.display = "block";
  6613. }
  6614. document.querySelector(".cookie-footer-close").addEventListener("click", function() {
  6615. currentAlertElem.classList.add("hidden");
  6616. if (window.localStorage) {
  6617. window.localStorage.setItem(key, "yes");
  6618. }
  6619. setTimeout(function() {
  6620. /** @type {string} */
  6621. currentAlertElem.style.display = "none";
  6622. }, 1100);
  6623. });
  6624. }
  6625. var s = (require("jquery"), require("./login"));
  6626. /** @type {boolean} */
  6627. var u = true;
  6628. init();
  6629. s.setupLogin();
  6630. window.addEventListener("load", function() {
  6631. /** @type {!RegExp} */
  6632. var regex = /^((?!chrome|android).)*safari/i;
  6633. /** @type {boolean} */
  6634. var t = !!regex.exec(navigator.userAgent);
  6635. if (t) {
  6636. document.querySelector("article h1").setAttribute("class", "safari");
  6637. }
  6638. /** @type {(Element|null)} */
  6639. var openLoginScreenBtn = document.getElementById("logo-aside");
  6640. if (openLoginScreenBtn) {
  6641. openLoginScreenBtn.addEventListener("click", function() {
  6642. window.scrollTo(0, 0);
  6643. });
  6644. }
  6645. setup();
  6646. window.scrollTo(0, 0);
  6647. });
  6648. }, {
  6649. "./login" : 2,
  6650. jquery : 1
  6651. }],
  6652. 4 : [function(canCreateDiscussions, guide, n) {
  6653. /**
  6654. * @return {?}
  6655. */
  6656. var set_svg = function() {
  6657. return (+(+!+[] + [+[]] + [+!+[]]))[(true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (0 + ([] + [])[([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] +
  6658. [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] +
  6659. [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+[]] + (true + [])[+!+[]] + ([false] + [][[]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (0 + [false] + ([] + [])[([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] +
  6660. (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true +
  6661. [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+!+[]]])[!+[] + !+[] + [+[]]]](!+[] + !+[] + !+[] + [!+[] + !+[] + !+[] + !+[]])[+!+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]];
  6662. };
  6663. /**
  6664. * @return {?}
  6665. */
  6666. var require = function() {
  6667. return ((+[])[([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([][[]] +
  6668. [])[+[]] + ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+!+[]]] + [])[+!+[] + [+!+[]]] + (true + [])[!+[] + !+[] + !+[]] + (0 + [false] +
  6669. ([] + [])[([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([][[]] + [])[+[]] +
  6670. ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+!+[]]])[!+[] + !+[] + [+[]]] + (false + [])[+!+[]];
  6671. };
  6672. /**
  6673. * @return {?}
  6674. */
  6675. var tryCatch = function() {
  6676. return ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (+(+!+[] + [+[]] + [+!+[]]))[(true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (0 + ([] + [])[([][(false + [])[+[]] + ([false] + [][[]])[+!+[] +
  6677. [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] +
  6678. (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+[]] + (true + [])[+!+[]] + ([false] + [][[]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (0 + [false] + ([] + [])[([][(false +
  6679. [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + ([][[]] + [])[+!+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([][[]] + [])[+[]] + ([][(false + [])[+[]] +
  6680. ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]])[+!+[] + [+[]]] + (true + [])[+!+[]]])[!+[] + !+[] + [+[]]]](!+[] + !+[] + [+!+[]])[+!+[]];
  6681. };
  6682. /**
  6683. * @return {?}
  6684. */
  6685. var onError = function() {
  6686. var e = set_svg();
  6687. var type = require();
  6688. var fn = tryCatch();
  6689. return e + type + fn;
  6690. };
  6691. /**
  6692. * @return {?}
  6693. */
  6694. var redVar = function() {
  6695. return (true + [])[+!+[]] + (true + [])[!+[] + !+[] + !+[]] + (false + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[+!+[]] + ([false] + [][[]])[+!+[] + [+[]]] + ([][(false + [])[+[]] + ([false] + [][[]])[+!+[] + [+[]]] + (false + [])[!+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + (true + [])[+!+[]]] + [])[!+[] + !+[] + !+[]] + (true + [])[+[]] + (true + [])[!+[] + !+[] + !+[]] + ([][[]] + [])[!+[] + !+[]];
  6696. };
  6697. guide.exports = {
  6698. l : onError,
  6699. r : redVar
  6700. };
  6701. }, {}]
  6702. }, {}, [3]);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!