Created
June 14, 2019 01:06
-
-
Save nicoandmee/90952ecfcf1025a37d549b1c82158663 to your computer and use it in GitHub Desktop.
[jokerstash] js ciontent
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| function isArray(e) { | |
| try { | |
| return toString.apply(e) == "[object Array]" | |
| } catch (t) {} | |
| } | |
| function random(e) { | |
| return Math.floor(Math.random() * (e + 1)) | |
| } | |
| function csrf(e) { | |
| var t = document.cookie.match(/(^|;)\s*csrf=([^;]+)/); | |
| if (t) | |
| return e ? t[2] : decodeURIComponent(t[2]); | |
| throw "No CSRF cookie." | |
| } | |
| function fetchRedirJSON(e, t, n) { | |
| e += "&csrf=" + csrf("e"), | |
| $.ajax({ | |
| url: e + "&json=1", | |
| dataType: "json", | |
| success: function(e) { | |
| t.apply(this, isArray(e) ? e : [e]) | |
| }, | |
| error: function() { | |
| n || setTimeout(function() { | |
| location.href = e | |
| }, 1e3) | |
| } | |
| }) | |
| } | |
| function loginFocused(e) { | |
| e.onfocus = null; | |
| var t = 10; | |
| setTimeout(function() { | |
| $ && $("#login").val() != "" && $("#password").val() != "" ? $("#captcha").val("").focus() : --t > 0 && setTimeout(arguments.callee, 100) | |
| }, 100) | |
| } | |
| function escapeRE(e) { | |
| return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&") | |
| } | |
| !function(e, t) { | |
| "object" == typeof module && "object" == typeof module.exports ? module.exports = e.document ? t(e, !0) : function(e) { | |
| if (!e.document) | |
| throw new Error("jQuery requires a window with a document"); | |
| return t(e) | |
| } | |
| : t(e) | |
| }("undefined" != typeof window ? window : this, function(a, b) { | |
| function s(e) { | |
| var t = e.length | |
| , r = n.type(e); | |
| return "function" === r || n.isWindow(e) ? !1 : 1 === e.nodeType && t ? !0 : "array" === r || 0 === t || "number" == typeof t && t > 0 && t - 1 in e | |
| } | |
| function x(e, t, r) { | |
| if (n.isFunction(t)) | |
| return n.grep(e, function(e, n) { | |
| return !!t.call(e, n, e) !== r | |
| }); | |
| if (t.nodeType) | |
| return n.grep(e, function(e) { | |
| return e === t !== r | |
| }); | |
| if ("string" == typeof t) { | |
| if (w.test(t)) | |
| return n.filter(t, e, r); | |
| t = n.filter(t, e) | |
| } | |
| return n.grep(e, function(e) { | |
| return g.call(t, e) >= 0 !== r | |
| }) | |
| } | |
| function D(e, t) { | |
| while ((e = e[t]) && 1 !== e.nodeType) | |
| ; | |
| return e | |
| } | |
| function G(e) { | |
| var t = F[e] = {}; | |
| return n.each(e.match(E) || [], function(e, n) { | |
| t[n] = !0 | |
| }), | |
| t | |
| } | |
| function I() { | |
| l.removeEventListener("DOMContentLoaded", I, !1), | |
| a.removeEventListener("load", I, !1), | |
| n.ready() | |
| } | |
| function K() { | |
| Object.defineProperty(this.cache = {}, 0, { | |
| get: function() { | |
| return {} | |
| } | |
| }), | |
| this.expando = n.expando + Math.random() | |
| } | |
| function P(e, t, r) { | |
| var i; | |
| if (void 0 === r && 1 === e.nodeType) | |
| if (i = "data-" + t.replace(O, "-$1").toLowerCase(), | |
| r = e.getAttribute(i), | |
| "string" == typeof r) { | |
| try { | |
| r = "true" === r ? !0 : "false" === r ? !1 : "null" === r ? null : +r + "" === r ? +r : N.test(r) ? n.parseJSON(r) : r | |
| } catch (s) {} | |
| M.set(e, t, r) | |
| } else | |
| r = void 0; | |
| return r | |
| } | |
| function Z() { | |
| return !0 | |
| } | |
| function $() { | |
| return !1 | |
| } | |
| function _() { | |
| try { | |
| return l.activeElement | |
| } catch (e) {} | |
| } | |
| function jb(e, t) { | |
| return n.nodeName(e, "table") && n.nodeName(11 !== t.nodeType ? t : t.firstChild, "tr") ? e.getElementsByTagName("tbody")[0] || e.appendChild(e.ownerDocument.createElement("tbody")) : e | |
| } | |
| function kb(e) { | |
| return e.type = (null !== e.getAttribute("type")) + "/" + e.type, | |
| e | |
| } | |
| function lb(e) { | |
| var t = gb.exec(e.type); | |
| return t ? e.type = t[1] : e.removeAttribute("type"), | |
| e | |
| } | |
| function mb(e, t) { | |
| for (var n = 0, r = e.length; r > n; n++) | |
| L.set(e[n], "globalEval", !t || L.get(t[n], "globalEval")) | |
| } | |
| function nb(e, t) { | |
| var r, i, s, o, u, a, f, l; | |
| if (1 === t.nodeType) { | |
| if (L.hasData(e) && (o = L.access(e), | |
| u = L.set(t, o), | |
| l = o.events)) { | |
| delete u.handle, | |
| u.events = {}; | |
| for (s in l) | |
| for (r = 0, | |
| i = l[s].length; i > r; r++) | |
| n.event.add(t, s, l[s][r]) | |
| } | |
| M.hasData(e) && (a = M.access(e), | |
| f = n.extend({}, a), | |
| M.set(t, f)) | |
| } | |
| } | |
| function ob(e, t) { | |
| var r = e.getElementsByTagName ? e.getElementsByTagName(t || "*") : e.querySelectorAll ? e.querySelectorAll(t || "*") : []; | |
| return void 0 === t || t && n.nodeName(e, t) ? n.merge([e], r) : r | |
| } | |
| function pb(e, t) { | |
| var n = t.nodeName.toLowerCase(); | |
| "input" === n && T.test(e.type) ? t.checked = e.checked : ("input" === n || "textarea" === n) && (t.defaultValue = e.defaultValue) | |
| } | |
| function sb(e, t) { | |
| var r, i = n(t.createElement(e)).appendTo(t.body), s = a.getDefaultComputedStyle && (r = a.getDefaultComputedStyle(i[0])) ? r.display : n.css(i[0], "display"); | |
| return i.detach(), | |
| s | |
| } | |
| function tb(e) { | |
| var t = l | |
| , r = rb[e]; | |
| return r || (r = sb(e, t), | |
| "none" !== r && r || (qb = (qb || n("<iframe frameborder='0' width='0' height='0'/>")).appendTo(t.documentElement), | |
| t = qb[0].contentDocument, | |
| t.write(), | |
| t.close(), | |
| r = sb(e, t), | |
| qb.detach()), | |
| rb[e] = r), | |
| r | |
| } | |
| function xb(e, t, r) { | |
| var i, s, o, u, a = e.style; | |
| return r = r || wb(e), | |
| r && (u = r.getPropertyValue(t) || r[t]), | |
| r && ("" !== u || n.contains(e.ownerDocument, e) || (u = n.style(e, t)), | |
| vb.test(u) && ub.test(t) && (i = a.width, | |
| s = a.minWidth, | |
| o = a.maxWidth, | |
| a.minWidth = a.maxWidth = a.width = u, | |
| u = r.width, | |
| a.width = i, | |
| a.minWidth = s, | |
| a.maxWidth = o)), | |
| void 0 !== u ? u + "" : u | |
| } | |
| function yb(e, t) { | |
| return { | |
| get: function() { | |
| return e() ? void delete this.get : (this.get = t).apply(this, arguments) | |
| } | |
| } | |
| } | |
| function Fb(e, t) { | |
| if (t in e) | |
| return t; | |
| var n = t[0].toUpperCase() + t.slice(1) | |
| , r = t | |
| , i = Eb.length; | |
| while (i--) | |
| if (t = Eb[i] + n, | |
| t in e) | |
| return t; | |
| return r | |
| } | |
| function Gb(e, t, n) { | |
| var r = Ab.exec(t); | |
| return r ? Math.max(0, r[1] - (n || 0)) + (r[2] || "px") : t | |
| } | |
| function Hb(e, t, r, i, s) { | |
| for (var o = r === (i ? "border" : "content") ? 4 : "width" === t ? 1 : 0, u = 0; 4 > o; o += 2) | |
| "margin" === r && (u += n.css(e, r + R[o], !0, s)), | |
| i ? ("content" === r && (u -= n.css(e, "padding" + R[o], !0, s)), | |
| "margin" !== r && (u -= n.css(e, "border" + R[o] + "Width", !0, s))) : (u += n.css(e, "padding" + R[o], !0, s), | |
| "padding" !== r && (u += n.css(e, "border" + R[o] + "Width", !0, s))); | |
| return u | |
| } | |
| function Ib(e, t, r) { | |
| var i = !0 | |
| , s = "width" === t ? e.offsetWidth : e.offsetHeight | |
| , o = wb(e) | |
| , u = "border-box" === n.css(e, "boxSizing", !1, o); | |
| if (0 >= s || null == s) { | |
| if (s = xb(e, t, o), | |
| (0 > s || null == s) && (s = e.style[t]), | |
| vb.test(s)) | |
| return s; | |
| i = u && (k.boxSizingReliable() || s === e.style[t]), | |
| s = parseFloat(s) || 0 | |
| } | |
| return s + Hb(e, t, r || (u ? "border" : "content"), i, o) + "px" | |
| } | |
| function Jb(e, t) { | |
| for (var r, i, s, o = [], u = 0, a = e.length; a > u; u++) | |
| i = e[u], | |
| i.style && (o[u] = L.get(i, "olddisplay"), | |
| r = i.style.display, | |
| t ? (o[u] || "none" !== r || (i.style.display = ""), | |
| "" === i.style.display && S(i) && (o[u] = L.access(i, "olddisplay", tb(i.nodeName)))) : (s = S(i), | |
| "none" === r && s || L.set(i, "olddisplay", s ? r : n.css(i, "display")))); | |
| for (u = 0; a > u; u++) | |
| i = e[u], | |
| i.style && (t && "none" !== i.style.display && "" !== i.style.display || (i.style.display = t ? o[u] || "" : "none")); | |
| return e | |
| } | |
| function Kb(e, t, n, r, i) { | |
| return new Kb.prototype.init(e,t,n,r,i) | |
| } | |
| function Sb() { | |
| return setTimeout(function() { | |
| Lb = void 0 | |
| }), | |
| Lb = n.now() | |
| } | |
| function Tb(e, t) { | |
| var n, r = 0, i = { | |
| height: e | |
| }; | |
| for (t = t ? 1 : 0; 4 > r; r += 2 - t) | |
| n = R[r], | |
| i["margin" + n] = i["padding" + n] = e; | |
| return t && (i.opacity = i.width = e), | |
| i | |
| } | |
| function Ub(e, t, n) { | |
| for (var r, i = (Rb[t] || []).concat(Rb["*"]), s = 0, o = i.length; o > s; s++) | |
| if (r = i[s].call(n, t, e)) | |
| return r | |
| } | |
| function Vb(e, t, r) { | |
| var i, s, o, u, a, f, l, c, h = this, p = {}, d = e.style, v = e.nodeType && S(e), m = L.get(e, "fxshow"); | |
| r.queue || (a = n._queueHooks(e, "fx"), | |
| null == a.unqueued && (a.unqueued = 0, | |
| f = a.empty.fire, | |
| a.empty.fire = function() { | |
| a.unqueued || f() | |
| } | |
| ), | |
| a.unqueued++, | |
| h.always(function() { | |
| h.always(function() { | |
| a.unqueued--, | |
| n.queue(e, "fx").length || a.empty.fire() | |
| }) | |
| })), | |
| 1 === e.nodeType && ("height"in t || "width"in t) && (r.overflow = [d.overflow, d.overflowX, d.overflowY], | |
| l = n.css(e, "display"), | |
| c = "none" === l ? L.get(e, "olddisplay") || tb(e.nodeName) : l, | |
| "inline" === c && "none" === n.css(e, "float") && (d.display = "inline-block")), | |
| r.overflow && (d.overflow = "hidden", | |
| h.always(function() { | |
| d.overflow = r.overflow[0], | |
| d.overflowX = r.overflow[1], | |
| d.overflowY = r.overflow[2] | |
| })); | |
| for (i in t) | |
| if (s = t[i], | |
| Nb.exec(s)) { | |
| if (delete t[i], | |
| o = o || "toggle" === s, | |
| s === (v ? "hide" : "show")) { | |
| if ("show" !== s || !m || void 0 === m[i]) | |
| continue; | |
| v = !0 | |
| } | |
| p[i] = m && m[i] || n.style(e, i) | |
| } else | |
| l = void 0; | |
| if (n.isEmptyObject(p)) | |
| "inline" === ("none" === l ? tb(e.nodeName) : l) && (d.display = l); | |
| else { | |
| m ? "hidden"in m && (v = m.hidden) : m = L.access(e, "fxshow", {}), | |
| o && (m.hidden = !v), | |
| v ? n(e).show() : h.done(function() { | |
| n(e).hide() | |
| }), | |
| h.done(function() { | |
| var t; | |
| L.remove(e, "fxshow"); | |
| for (t in p) | |
| n.style(e, t, p[t]) | |
| }); | |
| for (i in p) | |
| u = Ub(v ? m[i] : 0, i, h), | |
| i in m || (m[i] = u.start, | |
| v && (u.end = u.start, | |
| u.start = "width" === i || "height" === i ? 1 : 0)) | |
| } | |
| } | |
| function Wb(e, t) { | |
| var r, i, s, o, u; | |
| for (r in e) | |
| if (i = n.camelCase(r), | |
| s = t[i], | |
| o = e[r], | |
| n.isArray(o) && (s = o[1], | |
| o = e[r] = o[0]), | |
| r !== i && (e[i] = o, | |
| delete e[r]), | |
| u = n.cssHooks[i], | |
| u && "expand"in u) { | |
| o = u.expand(o), | |
| delete e[i]; | |
| for (r in o) | |
| r in e || (e[r] = o[r], | |
| t[r] = s) | |
| } else | |
| t[i] = s | |
| } | |
| function Xb(e, t, r) { | |
| var i, s, o = 0, u = Qb.length, a = n.Deferred().always(function() { | |
| delete f.elem | |
| }), f = function() { | |
| if (s) | |
| return !1; | |
| for (var t = Lb || Sb(), n = Math.max(0, l.startTime + l.duration - t), r = n / l.duration || 0, i = 1 - r, o = 0, u = l.tweens.length; u > o; o++) | |
| l.tweens[o].run(i); | |
| return a.notifyWith(e, [l, i, n]), | |
| 1 > i && u ? n : (a.resolveWith(e, [l]), | |
| !1) | |
| }, l = a.promise({ | |
| elem: e, | |
| props: n.extend({}, t), | |
| opts: n.extend(!0, { | |
| specialEasing: {} | |
| }, r), | |
| originalProperties: t, | |
| originalOptions: r, | |
| startTime: Lb || Sb(), | |
| duration: r.duration, | |
| tweens: [], | |
| createTween: function(t, r) { | |
| var i = n.Tween(e, l.opts, t, r, l.opts.specialEasing[t] || l.opts.easing); | |
| return l.tweens.push(i), | |
| i | |
| }, | |
| stop: function(t) { | |
| var n = 0 | |
| , r = t ? l.tweens.length : 0; | |
| if (s) | |
| return this; | |
| for (s = !0; r > n; n++) | |
| l.tweens[n].run(1); | |
| return t ? a.resolveWith(e, [l, t]) : a.rejectWith(e, [l, t]), | |
| this | |
| } | |
| }), c = l.props; | |
| for (Wb(c, l.opts.specialEasing); u > o; o++) | |
| if (i = Qb[o].call(l, e, c, l.opts)) | |
| return i; | |
| return n.map(c, Ub, l), | |
| n.isFunction(l.opts.start) && l.opts.start.call(e, l), | |
| n.fx.timer(n.extend(f, { | |
| elem: e, | |
| anim: l, | |
| queue: l.opts.queue | |
| })), | |
| l.progress(l.opts.progress).done(l.opts.done, l.opts.complete).fail(l.opts.fail).always(l.opts.always) | |
| } | |
| function rc(e) { | |
| return function(t, r) { | |
| "string" != typeof t && (r = t, | |
| t = "*"); | |
| var i, s = 0, o = t.toLowerCase().match(E) || []; | |
| if (n.isFunction(r)) | |
| while (i = o[s++]) | |
| "+" === i[0] ? (i = i.slice(1) || "*", | |
| (e[i] = e[i] || []).unshift(r)) : (e[i] = e[i] || []).push(r) | |
| } | |
| } | |
| function sc(e, t, r, i) { | |
| function u(l) { | |
| var h; | |
| return s[l] = !0, | |
| n.each(e[l] || [], function(e, n) { | |
| var a = n(t, r, i); | |
| return "string" != typeof a || o || s[a] ? o ? !(h = a) : void 0 : (t.dataTypes.unshift(a), | |
| u(a), | |
| !1) | |
| }), | |
| h | |
| } | |
| var s = {} | |
| , o = e === oc; | |
| return u(t.dataTypes[0]) || !s["*"] && u("*") | |
| } | |
| function tc(e, t) { | |
| var r, i, s = n.ajaxSettings.flatOptions || {}; | |
| for (r in t) | |
| void 0 !== t[r] && ((s[r] ? e : i || (i = {}))[r] = t[r]); | |
| return i && n.extend(!0, e, i), | |
| e | |
| } | |
| function uc(e, t, n) { | |
| var r, i, s, o, u = e.contents, a = e.dataTypes; | |
| while ("*" === a[0]) | |
| a.shift(), | |
| void 0 === r && (r = e.mimeType || t.getResponseHeader("Content-Type")); | |
| if (r) | |
| for (i in u) | |
| if (u[i] && u[i].test(r)) { | |
| a.unshift(i); | |
| break | |
| } | |
| if (a[0]in n) | |
| s = a[0]; | |
| else { | |
| for (i in n) { | |
| if (!a[0] || e.converters[i + " " + a[0]]) { | |
| s = i; | |
| break | |
| } | |
| o || (o = i) | |
| } | |
| s = s || o | |
| } | |
| return s ? (s !== a[0] && a.unshift(s), | |
| n[s]) : void 0 | |
| } | |
| function vc(e, t, n, r) { | |
| var i, s, o, u, a, f = {}, l = e.dataTypes.slice(); | |
| if (l[1]) | |
| for (o in e.converters) | |
| f[o.toLowerCase()] = e.converters[o]; | |
| s = l.shift(); | |
| while (s) | |
| if (e.responseFields[s] && (n[e.responseFields[s]] = t), | |
| !a && r && e.dataFilter && (t = e.dataFilter(t, e.dataType)), | |
| a = s, | |
| s = l.shift()) | |
| if ("*" === s) | |
| s = a; | |
| else if ("*" !== a && a !== s) { | |
| if (o = f[a + " " + s] || f["* " + s], | |
| !o) | |
| for (i in f) | |
| if (u = i.split(" "), | |
| u[1] === s && (o = f[a + " " + u[0]] || f["* " + u[0]])) { | |
| o === !0 ? o = f[i] : f[i] !== !0 && (s = u[0], | |
| l.unshift(u[1])); | |
| break | |
| } | |
| if (o !== !0) | |
| if (o && e["throws"]) | |
| t = o(t); | |
| else | |
| try { | |
| t = o(t) | |
| } catch (c) { | |
| return { | |
| state: "parsererror", | |
| error: o ? c : "No conversion from " + a + " to " + s | |
| } | |
| } | |
| } | |
| return { | |
| state: "success", | |
| data: t | |
| } | |
| } | |
| function Bc(e, t, r, i) { | |
| var s; | |
| if (n.isArray(t)) | |
| n.each(t, function(t, n) { | |
| r || xc.test(e) ? i(e, n) : Bc(e + "[" + ("object" == typeof n ? t : "") + "]", n, r, i) | |
| }); | |
| else if (r || "object" !== n.type(t)) | |
| i(e, t); | |
| else | |
| for (s in t) | |
| Bc(e + "[" + s + "]", t[s], r, i) | |
| } | |
| function Kc(e) { | |
| return n.isWindow(e) ? e : 9 === e.nodeType && e.defaultView | |
| } | |
| var c = [] | |
| , d = c.slice | |
| , e = c.concat | |
| , f = c.push | |
| , g = c.indexOf | |
| , h = {} | |
| , i = h.toString | |
| , j = h.hasOwnProperty | |
| , k = {} | |
| , l = a.document | |
| , m = "2.1.1" | |
| , n = function(e, t) { | |
| return new n.fn.init(e,t) | |
| } | |
| , o = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g | |
| , p = /^-ms-/ | |
| , q = /-([\da-z])/gi | |
| , r = function(e, t) { | |
| return t.toUpperCase() | |
| }; | |
| n.fn = n.prototype = { | |
| jquery: m, | |
| constructor: n, | |
| selector: "", | |
| length: 0, | |
| toArray: function() { | |
| return d.call(this) | |
| }, | |
| get: function(e) { | |
| return null != e ? 0 > e ? this[e + this.length] : this[e] : d.call(this) | |
| }, | |
| pushStack: function(e) { | |
| var t = n.merge(this.constructor(), e); | |
| return t.prevObject = this, | |
| t.context = this.context, | |
| t | |
| }, | |
| each: function(e, t) { | |
| return n.each(this, e, t) | |
| }, | |
| map: function(e) { | |
| return this.pushStack(n.map(this, function(t, n) { | |
| return e.call(t, n, t) | |
| })) | |
| }, | |
| slice: function() { | |
| return this.pushStack(d.apply(this, arguments)) | |
| }, | |
| first: function() { | |
| return this.eq(0) | |
| }, | |
| last: function() { | |
| return this.eq(-1) | |
| }, | |
| eq: function(e) { | |
| var t = this.length | |
| , n = +e + (0 > e ? t : 0); | |
| return this.pushStack(n >= 0 && t > n ? [this[n]] : []) | |
| }, | |
| end: function() { | |
| return this.prevObject || this.constructor(null) | |
| }, | |
| push: f, | |
| sort: c.sort, | |
| splice: c.splice | |
| }, | |
| n.extend = n.fn.extend = function() { | |
| var e, t, r, i, s, o, u = arguments[0] || {}, a = 1, f = arguments.length, l = !1; | |
| for ("boolean" == typeof u && (l = u, | |
| u = arguments[a] || {}, | |
| a++), | |
| "object" == typeof u || n.isFunction(u) || (u = {}), | |
| a === f && (u = this, | |
| a--); f > a; a++) | |
| if (null != (e = arguments[a])) | |
| for (t in e) | |
| r = u[t], | |
| i = e[t], | |
| u !== i && (l && i && (n.isPlainObject(i) || (s = n.isArray(i))) ? (s ? (s = !1, | |
| o = r && n.isArray(r) ? r : []) : o = r && n.isPlainObject(r) ? r : {}, | |
| u[t] = n.extend(l, o, i)) : void 0 !== i && (u[t] = i)); | |
| return u | |
| } | |
| , | |
| n.extend({ | |
| expando: "jQuery" + (m + Math.random()).replace(/\D/g, ""), | |
| isReady: !0, | |
| error: function(e) { | |
| throw new Error(e) | |
| }, | |
| noop: function() {}, | |
| isFunction: function(e) { | |
| return "function" === n.type(e) | |
| }, | |
| isArray: Array.isArray, | |
| isWindow: function(e) { | |
| return null != e && e === e.window | |
| }, | |
| isNumeric: function(e) { | |
| return !n.isArray(e) && e - parseFloat(e) >= 0 | |
| }, | |
| isPlainObject: function(e) { | |
| return "object" !== n.type(e) || e.nodeType || n.isWindow(e) ? !1 : e.constructor && !j.call(e.constructor.prototype, "isPrototypeOf") ? !1 : !0 | |
| }, | |
| isEmptyObject: function(e) { | |
| var t; | |
| for (t in e) | |
| return !1; | |
| return !0 | |
| }, | |
| type: function(e) { | |
| return null == e ? e + "" : "object" == typeof e || "function" == typeof e ? h[i.call(e)] || "object" : typeof e | |
| }, | |
| globalEval: function(a) { | |
| var b, c = eval; | |
| a = n.trim(a), | |
| a && (1 === a.indexOf("use strict") ? (b = l.createElement("script"), | |
| b.text = a, | |
| l.head.appendChild(b).parentNode.removeChild(b)) : c(a)) | |
| }, | |
| camelCase: function(e) { | |
| return e.replace(p, "ms-").replace(q, r) | |
| }, | |
| nodeName: function(e, t) { | |
| return e.nodeName && e.nodeName.toLowerCase() === t.toLowerCase() | |
| }, | |
| each: function(e, t, n) { | |
| var r, i = 0, o = e.length, u = s(e); | |
| if (n) { | |
| if (u) { | |
| for (; o > i; i++) | |
| if (r = t.apply(e[i], n), | |
| r === !1) | |
| break | |
| } else | |
| for (i in e) | |
| if (r = t.apply(e[i], n), | |
| r === !1) | |
| break | |
| } else if (u) { | |
| for (; o > i; i++) | |
| if (r = t.call(e[i], i, e[i]), | |
| r === !1) | |
| break | |
| } else | |
| for (i in e) | |
| if (r = t.call(e[i], i, e[i]), | |
| r === !1) | |
| break; | |
| return e | |
| }, | |
| trim: function(e) { | |
| return null == e ? "" : (e + "").replace(o, "") | |
| }, | |
| makeArray: function(e, t) { | |
| var r = t || []; | |
| return null != e && (s(Object(e)) ? n.merge(r, "string" == typeof e ? [e] : e) : f.call(r, e)), | |
| r | |
| }, | |
| inArray: function(e, t, n) { | |
| return null == t ? -1 : g.call(t, e, n) | |
| }, | |
| merge: function(e, t) { | |
| for (var n = +t.length, r = 0, i = e.length; n > r; r++) | |
| e[i++] = t[r]; | |
| return e.length = i, | |
| e | |
| }, | |
| grep: function(e, t, n) { | |
| for (var r, i = [], s = 0, o = e.length, u = !n; o > s; s++) | |
| r = !t(e[s], s), | |
| r !== u && i.push(e[s]); | |
| return i | |
| }, | |
| map: function(t, n, r) { | |
| var i, o = 0, u = t.length, a = s(t), f = []; | |
| if (a) | |
| for (; u > o; o++) | |
| i = n(t[o], o, r), | |
| null != i && f.push(i); | |
| else | |
| for (o in t) | |
| i = n(t[o], o, r), | |
| null != i && f.push(i); | |
| return e.apply([], f) | |
| }, | |
| guid: 1, | |
| proxy: function(e, t) { | |
| var r, i, s; | |
| return "string" == typeof t && (r = e[t], | |
| t = e, | |
| e = r), | |
| n.isFunction(e) ? (i = d.call(arguments, 2), | |
| s = function() { | |
| return e.apply(t || this, i.concat(d.call(arguments))) | |
| } | |
| , | |
| s.guid = e.guid = e.guid || n.guid++, | |
| s) : void 0 | |
| }, | |
| now: Date.now, | |
| support: k | |
| }), | |
| n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(e, t) { | |
| h["[object " + t + "]"] = t.toLowerCase() | |
| }); | |
| var t = function(e) { | |
| function st(e, t, r, i) { | |
| var s, u, f, l, c, d, g, y, S, x; | |
| if ((t ? t.ownerDocument || t : E) !== p && h(t), | |
| t = t || p, | |
| r = r || [], | |
| !e || "string" != typeof e) | |
| return r; | |
| if (1 !== (l = t.nodeType) && 9 !== l) | |
| return []; | |
| if (v && !i) { | |
| if (s = Z.exec(e)) | |
| if (f = s[1]) { | |
| if (9 === l) { | |
| if (u = t.getElementById(f), | |
| !u || !u.parentNode) | |
| return r; | |
| if (u.id === f) | |
| return r.push(u), | |
| r | |
| } else if (t.ownerDocument && (u = t.ownerDocument.getElementById(f)) && b(t, u) && u.id === f) | |
| return r.push(u), | |
| r | |
| } else { | |
| if (s[2]) | |
| return P.apply(r, t.getElementsByTagName(e)), | |
| r; | |
| if ((f = s[3]) && n.getElementsByClassName && t.getElementsByClassName) | |
| return P.apply(r, t.getElementsByClassName(f)), | |
| r | |
| } | |
| if (n.qsa && (!m || !m.test(e))) { | |
| if (y = g = w, | |
| S = t, | |
| x = 9 === l && e, | |
| 1 === l && "object" !== t.nodeName.toLowerCase()) { | |
| d = o(e), | |
| (g = t.getAttribute("id")) ? y = g.replace(tt, "\\$&") : t.setAttribute("id", y), | |
| y = "[id='" + y + "'] ", | |
| c = d.length; | |
| while (c--) | |
| d[c] = y + mt(d[c]); | |
| S = et.test(e) && dt(t.parentNode) || t, | |
| x = d.join(",") | |
| } | |
| if (x) | |
| try { | |
| return P.apply(r, S.querySelectorAll(x)), | |
| r | |
| } catch (T) {} finally { | |
| g || t.removeAttribute("id") | |
| } | |
| } | |
| } | |
| return a(e.replace(z, "$1"), t, r, i) | |
| } | |
| function ot() { | |
| function t(n, i) { | |
| return e.push(n + " ") > r.cacheLength && delete t[e.shift()], | |
| t[n + " "] = i | |
| } | |
| var e = []; | |
| return t | |
| } | |
| function ut(e) { | |
| return e[w] = !0, | |
| e | |
| } | |
| function at(e) { | |
| var t = p.createElement("div"); | |
| try { | |
| return !!e(t) | |
| } catch (n) { | |
| return !1 | |
| } finally { | |
| t.parentNode && t.parentNode.removeChild(t), | |
| t = null | |
| } | |
| } | |
| function ft(e, t) { | |
| var n = e.split("|") | |
| , i = e.length; | |
| while (i--) | |
| r.attrHandle[n[i]] = t | |
| } | |
| function lt(e, t) { | |
| var n = t && e | |
| , r = n && 1 === e.nodeType && 1 === t.nodeType && (~t.sourceIndex || A) - (~e.sourceIndex || A); | |
| if (r) | |
| return r; | |
| if (n) | |
| while (n = n.nextSibling) | |
| if (n === t) | |
| return -1; | |
| return e ? 1 : -1 | |
| } | |
| function ct(e) { | |
| return function(t) { | |
| var n = t.nodeName.toLowerCase(); | |
| return "input" === n && t.type === e | |
| } | |
| } | |
| function ht(e) { | |
| return function(t) { | |
| var n = t.nodeName.toLowerCase(); | |
| return ("input" === n || "button" === n) && t.type === e | |
| } | |
| } | |
| function pt(e) { | |
| return ut(function(t) { | |
| return t = +t, | |
| ut(function(n, r) { | |
| var i, s = e([], n.length, t), o = s.length; | |
| while (o--) | |
| n[i = s[o]] && (n[i] = !(r[i] = n[i])) | |
| }) | |
| }) | |
| } | |
| function dt(e) { | |
| return e && typeof e.getElementsByTagName !== L && e | |
| } | |
| function vt() {} | |
| function mt(e) { | |
| for (var t = 0, n = e.length, r = ""; n > t; t++) | |
| r += e[t].value; | |
| return r | |
| } | |
| function gt(e, t, n) { | |
| var r = t.dir | |
| , i = n && "parentNode" === r | |
| , s = x++; | |
| return t.first ? function(t, n, s) { | |
| while (t = t[r]) | |
| if (1 === t.nodeType || i) | |
| return e(t, n, s) | |
| } | |
| : function(t, n, o) { | |
| var u, a, f = [S, s]; | |
| if (o) { | |
| while (t = t[r]) | |
| if ((1 === t.nodeType || i) && e(t, n, o)) | |
| return !0 | |
| } else | |
| while (t = t[r]) | |
| if (1 === t.nodeType || i) { | |
| if (a = t[w] || (t[w] = {}), | |
| (u = a[r]) && u[0] === S && u[1] === s) | |
| return f[2] = u[2]; | |
| if (a[r] = f, | |
| f[2] = e(t, n, o)) | |
| return !0 | |
| } | |
| } | |
| } | |
| function yt(e) { | |
| return e.length > 1 ? function(t, n, r) { | |
| var i = e.length; | |
| while (i--) | |
| if (!e[i](t, n, r)) | |
| return !1; | |
| return !0 | |
| } | |
| : e[0] | |
| } | |
| function bt(e, t, n) { | |
| for (var r = 0, i = t.length; i > r; r++) | |
| st(e, t[r], n); | |
| return n | |
| } | |
| function wt(e, t, n, r, i) { | |
| for (var s, o = [], u = 0, a = e.length, f = null != t; a > u; u++) | |
| (s = e[u]) && (!n || n(s, r, i)) && (o.push(s), | |
| f && t.push(u)); | |
| return o | |
| } | |
| function Et(e, t, n, r, i, s) { | |
| return r && !r[w] && (r = Et(r)), | |
| i && !i[w] && (i = Et(i, s)), | |
| ut(function(s, o, u, a) { | |
| var f, l, c, h = [], p = [], d = o.length, v = s || bt(t || "*", u.nodeType ? [u] : u, []), m = !e || !s && t ? v : wt(v, h, e, u, a), g = n ? i || (s ? e : d || r) ? [] : o : m; | |
| if (n && n(m, g, u, a), | |
| r) { | |
| f = wt(g, p), | |
| r(f, [], u, a), | |
| l = f.length; | |
| while (l--) | |
| (c = f[l]) && (g[p[l]] = !(m[p[l]] = c)) | |
| } | |
| if (s) { | |
| if (i || e) { | |
| if (i) { | |
| f = [], | |
| l = g.length; | |
| while (l--) | |
| (c = g[l]) && f.push(m[l] = c); | |
| i(null, g = [], f, a) | |
| } | |
| l = g.length; | |
| while (l--) | |
| (c = g[l]) && (f = i ? B.call(s, c) : h[l]) > -1 && (s[f] = !(o[f] = c)) | |
| } | |
| } else | |
| g = wt(g === o ? g.splice(d, g.length) : g), | |
| i ? i(null, o, g, a) : P.apply(o, g) | |
| }) | |
| } | |
| function St(e) { | |
| for (var t, n, i, s = e.length, o = r.relative[e[0].type], u = o || r.relative[" "], a = o ? 1 : 0, l = gt(function(e) { | |
| return e === t | |
| }, u, !0), c = gt(function(e) { | |
| return B.call(t, e) > -1 | |
| }, u, !0), h = [function(e, n, r) { | |
| return !o && (r || n !== f) || ((t = n).nodeType ? l(e, n, r) : c(e, n, r)) | |
| } | |
| ]; s > a; a++) | |
| if (n = r.relative[e[a].type]) | |
| h = [gt(yt(h), n)]; | |
| else { | |
| if (n = r.filter[e[a].type].apply(null, e[a].matches), | |
| n[w]) { | |
| for (i = ++a; s > i; i++) | |
| if (r.relative[e[i].type]) | |
| break; | |
| return Et(a > 1 && yt(h), a > 1 && mt(e.slice(0, a - 1).concat({ | |
| value: " " === e[a - 2].type ? "*" : "" | |
| })).replace(z, "$1"), n, i > a && St(e.slice(a, i)), s > i && St(e = e.slice(i)), s > i && mt(e)) | |
| } | |
| h.push(n) | |
| } | |
| return yt(h) | |
| } | |
| function xt(e, t) { | |
| var n = t.length > 0 | |
| , i = e.length > 0 | |
| , s = function(s, o, u, a, l) { | |
| var c, h, d, v = 0, m = "0", g = s && [], y = [], b = f, w = s || i && r.find.TAG("*", l), E = S += null == b ? 1 : Math.random() || .1, x = w.length; | |
| for (l && (f = o !== p && o); m !== x && null != (c = w[m]); m++) { | |
| if (i && c) { | |
| h = 0; | |
| while (d = e[h++]) | |
| if (d(c, o, u)) { | |
| a.push(c); | |
| break | |
| } | |
| l && (S = E) | |
| } | |
| n && ((c = !d && c) && v--, | |
| s && g.push(c)) | |
| } | |
| if (v += m, | |
| n && m !== v) { | |
| h = 0; | |
| while (d = t[h++]) | |
| d(g, y, o, u); | |
| if (s) { | |
| if (v > 0) | |
| while (m--) | |
| g[m] || y[m] || (y[m] = _.call(a)); | |
| y = wt(y) | |
| } | |
| P.apply(a, y), | |
| l && !s && y.length > 0 && v + t.length > 1 && st.uniqueSort(a) | |
| } | |
| return l && (S = E, | |
| f = b), | |
| g | |
| }; | |
| return n ? ut(s) : s | |
| } | |
| var t, n, r, i, s, o, u, a, f, l, c, h, p, d, v, m, g, y, b, w = "sizzle" + -(new Date), E = e.document, S = 0, x = 0, T = ot(), N = ot(), C = ot(), k = function(e, t) { | |
| return e === t && (c = !0), | |
| 0 | |
| }, L = "undefined", A = 1 << 31, O = {}.hasOwnProperty, M = [], _ = M.pop, D = M.push, P = M.push, H = M.slice, B = M.indexOf || function(e) { | |
| for (var t = 0, n = this.length; n > t; t++) | |
| if (this[t] === e) | |
| return t; | |
| return -1 | |
| } | |
| , j = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", F = "[\\x20\\t\\r\\n\\f]", I = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", q = I.replace("w", "w#"), R = "\\[" + F + "*(" + I + ")(?:" + F + "*([*^$|!~]?=)" + F + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + q + "))|)" + F + "*\\]", U = ":(" + I + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + R + ")*)|.*)\\)|)", z = new RegExp("^" + F + "+|((?:^|[^\\\\])(?:\\\\.)*)" + F + "+$","g"), W = new RegExp("^" + F + "*," + F + "*"), X = new RegExp("^" + F + "*([>+~]|" + F + ")" + F + "*"), V = new RegExp("=" + F + "*([^\\]'\"]*?)" + F + "*\\]","g"), $ = new RegExp(U), J = new RegExp("^" + q + "$"), K = { | |
| ID: new RegExp("^#(" + I + ")"), | |
| CLASS: new RegExp("^\\.(" + I + ")"), | |
| TAG: new RegExp("^(" + I.replace("w", "w*") + ")"), | |
| ATTR: new RegExp("^" + R), | |
| PSEUDO: new RegExp("^" + U), | |
| CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + F + "*(even|odd|(([+-]|)(\\d*)n|)" + F + "*(?:([+-]|)" + F + "*(\\d+)|))" + F + "*\\)|)","i"), | |
| bool: new RegExp("^(?:" + j + ")$","i"), | |
| needsContext: new RegExp("^" + F + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + F + "*((?:-\\d)?\\d*)" + F + "*\\)|)(?=[^-]|$)","i") | |
| }, Q = /^(?:input|select|textarea|button)$/i, G = /^h\d$/i, Y = /^[^{]+\{\s*\[native \w/, Z = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, et = /[+~]/, tt = /'|\\/g, nt = new RegExp("\\\\([\\da-f]{1,6}" + F + "?|(" + F + ")|.)","ig"), rt = function(e, t, n) { | |
| var r = "0x" + t - 65536; | |
| return r !== r || n ? t : 0 > r ? String.fromCharCode(r + 65536) : String.fromCharCode(r >> 10 | 55296, 1023 & r | 56320) | |
| }; | |
| try { | |
| P.apply(M = H.call(E.childNodes), E.childNodes), | |
| M[E.childNodes.length].nodeType | |
| } catch (it) { | |
| P = { | |
| apply: M.length ? function(e, t) { | |
| D.apply(e, H.call(t)) | |
| } | |
| : function(e, t) { | |
| var n = e.length | |
| , r = 0; | |
| while (e[n++] = t[r++]) | |
| ; | |
| e.length = n - 1 | |
| } | |
| } | |
| } | |
| n = st.support = {}, | |
| s = st.isXML = function(e) { | |
| var t = e && (e.ownerDocument || e).documentElement; | |
| return t ? "HTML" !== t.nodeName : !1 | |
| } | |
| , | |
| h = st.setDocument = function(e) { | |
| var t, i = e ? e.ownerDocument || e : E, o = i.defaultView; | |
| return i !== p && 9 === i.nodeType && i.documentElement ? (p = i, | |
| d = i.documentElement, | |
| v = !s(i), | |
| o && o !== o.top && (o.addEventListener ? o.addEventListener("unload", function() { | |
| h() | |
| }, !1) : o.attachEvent && o.attachEvent("onunload", function() { | |
| h() | |
| })), | |
| n.attributes = at(function(e) { | |
| return e.className = "i", | |
| !e.getAttribute("className") | |
| }), | |
| n.getElementsByTagName = at(function(e) { | |
| return e.appendChild(i.createComment("")), | |
| !e.getElementsByTagName("*").length | |
| }), | |
| n.getElementsByClassName = Y.test(i.getElementsByClassName) && at(function(e) { | |
| return e.innerHTML = "<div class='a'></div><div class='a i'></div>", | |
| e.firstChild.className = "i", | |
| 2 === e.getElementsByClassName("i").length | |
| }), | |
| n.getById = at(function(e) { | |
| return d.appendChild(e).id = w, | |
| !i.getElementsByName || !i.getElementsByName(w).length | |
| }), | |
| n.getById ? (r.find.ID = function(e, t) { | |
| if (typeof t.getElementById !== L && v) { | |
| var n = t.getElementById(e); | |
| return n && n.parentNode ? [n] : [] | |
| } | |
| } | |
| , | |
| r.filter.ID = function(e) { | |
| var t = e.replace(nt, rt); | |
| return function(e) { | |
| return e.getAttribute("id") === t | |
| } | |
| } | |
| ) : (delete r.find.ID, | |
| r.filter.ID = function(e) { | |
| var t = e.replace(nt, rt); | |
| return function(e) { | |
| var n = typeof e.getAttributeNode !== L && e.getAttributeNode("id"); | |
| return n && n.value === t | |
| } | |
| } | |
| ), | |
| r.find.TAG = n.getElementsByTagName ? function(e, t) { | |
| return typeof t.getElementsByTagName !== L ? t.getElementsByTagName(e) : void 0 | |
| } | |
| : function(e, t) { | |
| var n, r = [], i = 0, s = t.getElementsByTagName(e); | |
| if ("*" === e) { | |
| while (n = s[i++]) | |
| 1 === n.nodeType && r.push(n); | |
| return r | |
| } | |
| return s | |
| } | |
| , | |
| r.find.CLASS = n.getElementsByClassName && function(e, t) { | |
| return typeof t.getElementsByClassName !== L && v ? t.getElementsByClassName(e) : void 0 | |
| } | |
| , | |
| g = [], | |
| m = [], | |
| (n.qsa = Y.test(i.querySelectorAll)) && (at(function(e) { | |
| e.innerHTML = "<select msallowclip=''><option selected=''></option></select>", | |
| e.querySelectorAll("[msallowclip^='']").length && m.push("[*^$]=" + F + "*(?:''|\"\")"), | |
| e.querySelectorAll("[selected]").length || m.push("\\[" + F + "*(?:value|" + j + ")"), | |
| e.querySelectorAll(":checked").length || m.push(":checked") | |
| }), | |
| at(function(e) { | |
| var t = i.createElement("input"); | |
| t.setAttribute("type", "hidden"), | |
| e.appendChild(t).setAttribute("name", "D"), | |
| e.querySelectorAll("[name=d]").length && m.push("name" + F + "*[*^$|!~]?="), | |
| e.querySelectorAll(":enabled").length || m.push(":enabled", ":disabled"), | |
| e.querySelectorAll("*,:x"), | |
| m.push(",.*:") | |
| })), | |
| (n.matchesSelector = Y.test(y = d.matches || d.webkitMatchesSelector || d.mozMatchesSelector || d.oMatchesSelector || d.msMatchesSelector)) && at(function(e) { | |
| n.disconnectedMatch = y.call(e, "div"), | |
| y.call(e, "[s!='']:x"), | |
| g.push("!=", U) | |
| }), | |
| m = m.length && new RegExp(m.join("|")), | |
| g = g.length && new RegExp(g.join("|")), | |
| t = Y.test(d.compareDocumentPosition), | |
| b = t || Y.test(d.contains) ? function(e, t) { | |
| var n = 9 === e.nodeType ? e.documentElement : e | |
| , r = t && t.parentNode; | |
| return e === r || !!r && 1 === r.nodeType && !!(n.contains ? n.contains(r) : e.compareDocumentPosition && 16 & e.compareDocumentPosition(r)) | |
| } | |
| : function(e, t) { | |
| if (t) | |
| while (t = t.parentNode) | |
| if (t === e) | |
| return !0; | |
| return !1 | |
| } | |
| , | |
| k = t ? function(e, t) { | |
| if (e === t) | |
| return c = !0, | |
| 0; | |
| var r = !e.compareDocumentPosition - !t.compareDocumentPosition; | |
| return r ? r : (r = (e.ownerDocument || e) === (t.ownerDocument || t) ? e.compareDocumentPosition(t) : 1, | |
| 1 & r || !n.sortDetached && t.compareDocumentPosition(e) === r ? e === i || e.ownerDocument === E && b(E, e) ? -1 : t === i || t.ownerDocument === E && b(E, t) ? 1 : l ? B.call(l, e) - B.call(l, t) : 0 : 4 & r ? -1 : 1) | |
| } | |
| : function(e, t) { | |
| if (e === t) | |
| return c = !0, | |
| 0; | |
| var n, r = 0, s = e.parentNode, o = t.parentNode, u = [e], a = [t]; | |
| if (!s || !o) | |
| return e === i ? -1 : t === i ? 1 : s ? -1 : o ? 1 : l ? B.call(l, e) - B.call(l, t) : 0; | |
| if (s === o) | |
| return lt(e, t); | |
| n = e; | |
| while (n = n.parentNode) | |
| u.unshift(n); | |
| n = t; | |
| while (n = n.parentNode) | |
| a.unshift(n); | |
| while (u[r] === a[r]) | |
| r++; | |
| return r ? lt(u[r], a[r]) : u[r] === E ? -1 : a[r] === E ? 1 : 0 | |
| } | |
| , | |
| i) : p | |
| } | |
| , | |
| st.matches = function(e, t) { | |
| return st(e, null, null, t) | |
| } | |
| , | |
| st.matchesSelector = function(e, t) { | |
| if ((e.ownerDocument || e) !== p && h(e), | |
| t = t.replace(V, "='$1']"), | |
| !(!n.matchesSelector || !v || g && g.test(t) || m && m.test(t))) | |
| try { | |
| var r = y.call(e, t); | |
| if (r || n.disconnectedMatch || e.document && 11 !== e.document.nodeType) | |
| return r | |
| } catch (i) {} | |
| return st(t, p, null, [e]).length > 0 | |
| } | |
| , | |
| st.contains = function(e, t) { | |
| return (e.ownerDocument || e) !== p && h(e), | |
| b(e, t) | |
| } | |
| , | |
| st.attr = function(e, t) { | |
| (e.ownerDocument || e) !== p && h(e); | |
| var i = r.attrHandle[t.toLowerCase()] | |
| , s = i && O.call(r.attrHandle, t.toLowerCase()) ? i(e, t, !v) : void 0; | |
| return void 0 !== s ? s : n.attributes || !v ? e.getAttribute(t) : (s = e.getAttributeNode(t)) && s.specified ? s.value : null | |
| } | |
| , | |
| st.error = function(e) { | |
| throw new Error("Syntax error, unrecognized expression: " + e) | |
| } | |
| , | |
| st.uniqueSort = function(e) { | |
| var t, r = [], i = 0, s = 0; | |
| if (c = !n.detectDuplicates, | |
| l = !n.sortStable && e.slice(0), | |
| e.sort(k), | |
| c) { | |
| while (t = e[s++]) | |
| t === e[s] && (i = r.push(s)); | |
| while (i--) | |
| e.splice(r[i], 1) | |
| } | |
| return l = null, | |
| e | |
| } | |
| , | |
| i = st.getText = function(e) { | |
| var t, n = "", r = 0, s = e.nodeType; | |
| if (s) { | |
| if (1 === s || 9 === s || 11 === s) { | |
| if ("string" == typeof e.textContent) | |
| return e.textContent; | |
| for (e = e.firstChild; e; e = e.nextSibling) | |
| n += i(e) | |
| } else if (3 === s || 4 === s) | |
| return e.nodeValue | |
| } else | |
| while (t = e[r++]) | |
| n += i(t); | |
| return n | |
| } | |
| , | |
| r = st.selectors = { | |
| cacheLength: 50, | |
| createPseudo: ut, | |
| match: K, | |
| attrHandle: {}, | |
| find: {}, | |
| relative: { | |
| ">": { | |
| dir: "parentNode", | |
| first: !0 | |
| }, | |
| " ": { | |
| dir: "parentNode" | |
| }, | |
| "+": { | |
| dir: "previousSibling", | |
| first: !0 | |
| }, | |
| "~": { | |
| dir: "previousSibling" | |
| } | |
| }, | |
| preFilter: { | |
| ATTR: function(e) { | |
| return e[1] = e[1].replace(nt, rt), | |
| e[3] = (e[3] || e[4] || e[5] || "").replace(nt, rt), | |
| "~=" === e[2] && (e[3] = " " + e[3] + " "), | |
| e.slice(0, 4) | |
| }, | |
| CHILD: function(e) { | |
| return e[1] = e[1].toLowerCase(), | |
| "nth" === e[1].slice(0, 3) ? (e[3] || st.error(e[0]), | |
| e[4] = +(e[4] ? e[5] + (e[6] || 1) : 2 * ("even" === e[3] || "odd" === e[3])), | |
| e[5] = +(e[7] + e[8] || "odd" === e[3])) : e[3] && st.error(e[0]), | |
| e | |
| }, | |
| PSEUDO: function(e) { | |
| var t, n = !e[6] && e[2]; | |
| return K.CHILD.test(e[0]) ? null : (e[3] ? e[2] = e[4] || e[5] || "" : n && $.test(n) && (t = o(n, !0)) && (t = n.indexOf(")", n.length - t) - n.length) && (e[0] = e[0].slice(0, t), | |
| e[2] = n.slice(0, t)), | |
| e.slice(0, 3)) | |
| } | |
| }, | |
| filter: { | |
| TAG: function(e) { | |
| var t = e.replace(nt, rt).toLowerCase(); | |
| return "*" === e ? function() { | |
| return !0 | |
| } | |
| : function(e) { | |
| return e.nodeName && e.nodeName.toLowerCase() === t | |
| } | |
| }, | |
| CLASS: function(e) { | |
| var t = T[e + " "]; | |
| return t || (t = new RegExp("(^|" + F + ")" + e + "(" + F + "|$)")) && T(e, function(e) { | |
| return t.test("string" == typeof e.className && e.className || typeof e.getAttribute !== L && e.getAttribute("class") || "") | |
| }) | |
| }, | |
| ATTR: function(e, t, n) { | |
| return function(r) { | |
| var i = st.attr(r, e); | |
| return null == i ? "!=" === t : t ? (i += "", | |
| "=" === t ? i === n : "!=" === t ? i !== n : "^=" === t ? n && 0 === i.indexOf(n) : "*=" === t ? n && i.indexOf(n) > -1 : "$=" === t ? n && i.slice(-n.length) === n : "~=" === t ? (" " + i + " ").indexOf(n) > -1 : "|=" === t ? i === n || i.slice(0, n.length + 1) === n + "-" : !1) : !0 | |
| } | |
| }, | |
| CHILD: function(e, t, n, r, i) { | |
| var s = "nth" !== e.slice(0, 3) | |
| , o = "last" !== e.slice(-4) | |
| , u = "of-type" === t; | |
| return 1 === r && 0 === i ? function(e) { | |
| return !!e.parentNode | |
| } | |
| : function(t, n, a) { | |
| var f, l, c, h, p, d, v = s !== o ? "nextSibling" : "previousSibling", m = t.parentNode, g = u && t.nodeName.toLowerCase(), y = !a && !u; | |
| if (m) { | |
| if (s) { | |
| while (v) { | |
| c = t; | |
| while (c = c[v]) | |
| if (u ? c.nodeName.toLowerCase() === g : 1 === c.nodeType) | |
| return !1; | |
| d = v = "only" === e && !d && "nextSibling" | |
| } | |
| return !0 | |
| } | |
| if (d = [o ? m.firstChild : m.lastChild], | |
| o && y) { | |
| l = m[w] || (m[w] = {}), | |
| f = l[e] || [], | |
| p = f[0] === S && f[1], | |
| h = f[0] === S && f[2], | |
| c = p && m.childNodes[p]; | |
| while (c = ++p && c && c[v] || (h = p = 0) || d.pop()) | |
| if (1 === c.nodeType && ++h && c === t) { | |
| l[e] = [S, p, h]; | |
| break | |
| } | |
| } else if (y && (f = (t[w] || (t[w] = {}))[e]) && f[0] === S) | |
| h = f[1]; | |
| else | |
| while (c = ++p && c && c[v] || (h = p = 0) || d.pop()) | |
| if ((u ? c.nodeName.toLowerCase() === g : 1 === c.nodeType) && ++h && (y && ((c[w] || (c[w] = {}))[e] = [S, h]), | |
| c === t)) | |
| break; | |
| return h -= i, | |
| h === r || h % r === 0 && h / r >= 0 | |
| } | |
| } | |
| }, | |
| PSEUDO: function(e, t) { | |
| var n, i = r.pseudos[e] || r.setFilters[e.toLowerCase()] || st.error("unsupported pseudo: " + e); | |
| return i[w] ? i(t) : i.length > 1 ? (n = [e, e, "", t], | |
| r.setFilters.hasOwnProperty(e.toLowerCase()) ? ut(function(e, n) { | |
| var r, s = i(e, t), o = s.length; | |
| while (o--) | |
| r = B.call(e, s[o]), | |
| e[r] = !(n[r] = s[o]) | |
| }) : function(e) { | |
| return i(e, 0, n) | |
| } | |
| ) : i | |
| } | |
| }, | |
| pseudos: { | |
| not: ut(function(e) { | |
| var t = [] | |
| , n = [] | |
| , r = u(e.replace(z, "$1")); | |
| return r[w] ? ut(function(e, t, n, i) { | |
| var s, o = r(e, null, i, []), u = e.length; | |
| while (u--) | |
| (s = o[u]) && (e[u] = !(t[u] = s)) | |
| }) : function(e, i, s) { | |
| return t[0] = e, | |
| r(t, null, s, n), | |
| !n.pop() | |
| } | |
| }), | |
| has: ut(function(e) { | |
| return function(t) { | |
| return st(e, t).length > 0 | |
| } | |
| }), | |
| contains: ut(function(e) { | |
| return function(t) { | |
| return (t.textContent || t.innerText || i(t)).indexOf(e) > -1 | |
| } | |
| }), | |
| lang: ut(function(e) { | |
| return J.test(e || "") || st.error("unsupported lang: " + e), | |
| e = e.replace(nt, rt).toLowerCase(), | |
| function(t) { | |
| var n; | |
| do | |
| if (n = v ? t.lang : t.getAttribute("xml:lang") || t.getAttribute("lang")) | |
| return n = n.toLowerCase(), | |
| n === e || 0 === n.indexOf(e + "-"); | |
| while ((t = t.parentNode) && 1 === t.nodeType);return !1 | |
| } | |
| }), | |
| target: function(t) { | |
| var n = e.location && e.location.hash; | |
| return n && n.slice(1) === t.id | |
| }, | |
| root: function(e) { | |
| return e === d | |
| }, | |
| focus: function(e) { | |
| return e === p.activeElement && (!p.hasFocus || p.hasFocus()) && !!(e.type || e.href || ~e.tabIndex) | |
| }, | |
| enabled: function(e) { | |
| return e.disabled === !1 | |
| }, | |
| disabled: function(e) { | |
| return e.disabled === !0 | |
| }, | |
| checked: function(e) { | |
| var t = e.nodeName.toLowerCase(); | |
| return "input" === t && !!e.checked || "option" === t && !!e.selected | |
| }, | |
| selected: function(e) { | |
| return e.parentNode && e.parentNode.selectedIndex, | |
| e.selected === !0 | |
| }, | |
| empty: function(e) { | |
| for (e = e.firstChild; e; e = e.nextSibling) | |
| if (e.nodeType < 6) | |
| return !1; | |
| return !0 | |
| }, | |
| parent: function(e) { | |
| return !r.pseudos.empty(e) | |
| }, | |
| header: function(e) { | |
| return G.test(e.nodeName) | |
| }, | |
| input: function(e) { | |
| return Q.test(e.nodeName) | |
| }, | |
| button: function(e) { | |
| var t = e.nodeName.toLowerCase(); | |
| return "input" === t && "button" === e.type || "button" === t | |
| }, | |
| text: function(e) { | |
| var t; | |
| return "input" === e.nodeName.toLowerCase() && "text" === e.type && (null == (t = e.getAttribute("type")) || "text" === t.toLowerCase()) | |
| }, | |
| first: pt(function() { | |
| return [0] | |
| }), | |
| last: pt(function(e, t) { | |
| return [t - 1] | |
| }), | |
| eq: pt(function(e, t, n) { | |
| return [0 > n ? n + t : n] | |
| }), | |
| even: pt(function(e, t) { | |
| for (var n = 0; t > n; n += 2) | |
| e.push(n); | |
| return e | |
| }), | |
| odd: pt(function(e, t) { | |
| for (var n = 1; t > n; n += 2) | |
| e.push(n); | |
| return e | |
| }), | |
| lt: pt(function(e, t, n) { | |
| for (var r = 0 > n ? n + t : n; --r >= 0; ) | |
| e.push(r); | |
| return e | |
| }), | |
| gt: pt(function(e, t, n) { | |
| for (var r = 0 > n ? n + t : n; ++r < t; ) | |
| e.push(r); | |
| return e | |
| }) | |
| } | |
| }, | |
| r.pseudos.nth = r.pseudos.eq; | |
| for (t in { | |
| radio: !0, | |
| checkbox: !0, | |
| file: !0, | |
| password: !0, | |
| image: !0 | |
| }) | |
| r.pseudos[t] = ct(t); | |
| for (t in { | |
| submit: !0, | |
| reset: !0 | |
| }) | |
| r.pseudos[t] = ht(t); | |
| return vt.prototype = r.filters = r.pseudos, | |
| r.setFilters = new vt, | |
| o = st.tokenize = function(e, t) { | |
| var n, i, s, o, u, a, f, l = N[e + " "]; | |
| if (l) | |
| return t ? 0 : l.slice(0); | |
| u = e, | |
| a = [], | |
| f = r.preFilter; | |
| while (u) { | |
| (!n || (i = W.exec(u))) && (i && (u = u.slice(i[0].length) || u), | |
| a.push(s = [])), | |
| n = !1, | |
| (i = X.exec(u)) && (n = i.shift(), | |
| s.push({ | |
| value: n, | |
| type: i[0].replace(z, " ") | |
| }), | |
| u = u.slice(n.length)); | |
| for (o in r.filter) | |
| !(i = K[o].exec(u)) || f[o] && !(i = f[o](i)) || (n = i.shift(), | |
| s.push({ | |
| value: n, | |
| type: o, | |
| matches: i | |
| }), | |
| u = u.slice(n.length)); | |
| if (!n) | |
| break | |
| } | |
| return t ? u.length : u ? st.error(e) : N(e, a).slice(0) | |
| } | |
| , | |
| u = st.compile = function(e, t) { | |
| var n, r = [], i = [], s = C[e + " "]; | |
| if (!s) { | |
| t || (t = o(e)), | |
| n = t.length; | |
| while (n--) | |
| s = St(t[n]), | |
| s[w] ? r.push(s) : i.push(s); | |
| s = C(e, xt(i, r)), | |
| s.selector = e | |
| } | |
| return s | |
| } | |
| , | |
| a = st.select = function(e, t, i, s) { | |
| var a, f, l, c, h, p = "function" == typeof e && e, d = !s && o(e = p.selector || e); | |
| if (i = i || [], | |
| 1 === d.length) { | |
| if (f = d[0] = d[0].slice(0), | |
| f.length > 2 && "ID" === (l = f[0]).type && n.getById && 9 === t.nodeType && v && r.relative[f[1].type]) { | |
| if (t = (r.find.ID(l.matches[0].replace(nt, rt), t) || [])[0], | |
| !t) | |
| return i; | |
| p && (t = t.parentNode), | |
| e = e.slice(f.shift().value.length) | |
| } | |
| a = K.needsContext.test(e) ? 0 : f.length; | |
| while (a--) { | |
| if (l = f[a], | |
| r.relative[c = l.type]) | |
| break; | |
| if ((h = r.find[c]) && (s = h(l.matches[0].replace(nt, rt), et.test(f[0].type) && dt(t.parentNode) || t))) { | |
| if (f.splice(a, 1), | |
| e = s.length && mt(f), | |
| !e) | |
| return P.apply(i, s), | |
| i; | |
| break | |
| } | |
| } | |
| } | |
| return (p || u(e, d))(s, t, !v, i, et.test(e) && dt(t.parentNode) || t), | |
| i | |
| } | |
| , | |
| n.sortStable = w.split("").sort(k).join("") === w, | |
| n.detectDuplicates = !!c, | |
| h(), | |
| n.sortDetached = at(function(e) { | |
| return 1 & e.compareDocumentPosition(p.createElement("div")) | |
| }), | |
| at(function(e) { | |
| return e.innerHTML = "<a href='#'></a>", | |
| "#" === e.firstChild.getAttribute("href") | |
| }) || ft("type|href|height|width", function(e, t, n) { | |
| return n ? void 0 : e.getAttribute(t, "type" === t.toLowerCase() ? 1 : 2) | |
| }), | |
| n.attributes && at(function(e) { | |
| return e.innerHTML = "<input/>", | |
| e.firstChild.setAttribute("value", ""), | |
| "" === e.firstChild.getAttribute("value") | |
| }) || ft("value", function(e, t, n) { | |
| return n || "input" !== e.nodeName.toLowerCase() ? void 0 : e.defaultValue | |
| }), | |
| at(function(e) { | |
| return null == e.getAttribute("disabled") | |
| }) || ft(j, function(e, t, n) { | |
| var r; | |
| return n ? void 0 : e[t] === !0 ? t.toLowerCase() : (r = e.getAttributeNode(t)) && r.specified ? r.value : null | |
| }), | |
| st | |
| }(a); | |
| n.find = t, | |
| n.expr = t.selectors, | |
| n.expr[":"] = n.expr.pseudos, | |
| n.unique = t.uniqueSort, | |
| n.text = t.getText, | |
| n.isXMLDoc = t.isXML, | |
| n.contains = t.contains; | |
| var u = n.expr.match.needsContext | |
| , v = /^<(\w+)\s*\/?>(?:<\/\1>|)$/ | |
| , w = /^.[^:#\[\.,]*$/; | |
| n.filter = function(e, t, r) { | |
| var i = t[0]; | |
| return r && (e = ":not(" + e + ")"), | |
| 1 === t.length && 1 === i.nodeType ? n.find.matchesSelector(i, e) ? [i] : [] : n.find.matches(e, n.grep(t, function(e) { | |
| return 1 === e.nodeType | |
| })) | |
| } | |
| , | |
| n.fn.extend({ | |
| find: function(e) { | |
| var t, r = this.length, i = [], s = this; | |
| if ("string" != typeof e) | |
| return this.pushStack(n(e).filter(function() { | |
| for (t = 0; r > t; t++) | |
| if (n.contains(s[t], this)) | |
| return !0 | |
| })); | |
| for (t = 0; r > t; t++) | |
| n.find(e, s[t], i); | |
| return i = this.pushStack(r > 1 ? n.unique(i) : i), | |
| i.selector = this.selector ? this.selector + " " + e : e, | |
| i | |
| }, | |
| filter: function(e) { | |
| return this.pushStack(x(this, e || [], !1)) | |
| }, | |
| not: function(e) { | |
| return this.pushStack(x(this, e || [], !0)) | |
| }, | |
| is: function(e) { | |
| return !!x(this, "string" == typeof e && u.test(e) ? n(e) : e || [], !1).length | |
| } | |
| }); | |
| var y, z = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, A = n.fn.init = function(e, t) { | |
| var r, i; | |
| if (!e) | |
| return this; | |
| if ("string" == typeof e) { | |
| if (r = "<" === e[0] && ">" === e[e.length - 1] && e.length >= 3 ? [null, e, null] : z.exec(e), | |
| !r || !r[1] && t) | |
| return !t || t.jquery ? (t || y).find(e) : this.constructor(t).find(e); | |
| if (r[1]) { | |
| if (t = t instanceof n ? t[0] : t, | |
| n.merge(this, n.parseHTML(r[1], t && t.nodeType ? t.ownerDocument || t : l, !0)), | |
| v.test(r[1]) && n.isPlainObject(t)) | |
| for (r in t) | |
| n.isFunction(this[r]) ? this[r](t[r]) : this.attr(r, t[r]); | |
| return this | |
| } | |
| return i = l.getElementById(r[2]), | |
| i && i.parentNode && (this.length = 1, | |
| this[0] = i), | |
| this.context = l, | |
| this.selector = e, | |
| this | |
| } | |
| return e.nodeType ? (this.context = this[0] = e, | |
| this.length = 1, | |
| this) : n.isFunction(e) ? "undefined" != typeof y.ready ? y.ready(e) : e(n) : (void 0 !== e.selector && (this.selector = e.selector, | |
| this.context = e.context), | |
| n.makeArray(e, this)) | |
| } | |
| ; | |
| A.prototype = n.fn, | |
| y = n(l); | |
| var B = /^(?:parents|prev(?:Until|All))/ | |
| , C = { | |
| children: !0, | |
| contents: !0, | |
| next: !0, | |
| prev: !0 | |
| }; | |
| n.extend({ | |
| dir: function(e, t, r) { | |
| var i = [] | |
| , s = void 0 !== r; | |
| while ((e = e[t]) && 9 !== e.nodeType) | |
| if (1 === e.nodeType) { | |
| if (s && n(e).is(r)) | |
| break; | |
| i.push(e) | |
| } | |
| return i | |
| }, | |
| sibling: function(e, t) { | |
| for (var n = []; e; e = e.nextSibling) | |
| 1 === e.nodeType && e !== t && n.push(e); | |
| return n | |
| } | |
| }), | |
| n.fn.extend({ | |
| has: function(e) { | |
| var t = n(e, this) | |
| , r = t.length; | |
| return this.filter(function() { | |
| for (var e = 0; r > e; e++) | |
| if (n.contains(this, t[e])) | |
| return !0 | |
| }) | |
| }, | |
| closest: function(e, t) { | |
| for (var r, i = 0, s = this.length, o = [], a = u.test(e) || "string" != typeof e ? n(e, t || this.context) : 0; s > i; i++) | |
| for (r = this[i]; r && r !== t; r = r.parentNode) | |
| if (r.nodeType < 11 && (a ? a.index(r) > -1 : 1 === r.nodeType && n.find.matchesSelector(r, e))) { | |
| o.push(r); | |
| break | |
| } | |
| return this.pushStack(o.length > 1 ? n.unique(o) : o) | |
| }, | |
| index: function(e) { | |
| return e ? "string" == typeof e ? g.call(n(e), this[0]) : g.call(this, e.jquery ? e[0] : e) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1 | |
| }, | |
| add: function(e, t) { | |
| return this.pushStack(n.unique(n.merge(this.get(), n(e, t)))) | |
| }, | |
| addBack: function(e) { | |
| return this.add(null == e ? this.prevObject : this.prevObject.filter(e)) | |
| } | |
| }), | |
| n.each({ | |
| parent: function(e) { | |
| var t = e.parentNode; | |
| return t && 11 !== t.nodeType ? t : null | |
| }, | |
| parents: function(e) { | |
| return n.dir(e, "parentNode") | |
| }, | |
| parentsUntil: function(e, t, r) { | |
| return n.dir(e, "parentNode", r) | |
| }, | |
| next: function(e) { | |
| return D(e, "nextSibling") | |
| }, | |
| prev: function(e) { | |
| return D(e, "previousSibling") | |
| }, | |
| nextAll: function(e) { | |
| return n.dir(e, "nextSibling") | |
| }, | |
| prevAll: function(e) { | |
| return n.dir(e, "previousSibling") | |
| }, | |
| nextUntil: function(e, t, r) { | |
| return n.dir(e, "nextSibling", r) | |
| }, | |
| prevUntil: function(e, t, r) { | |
| return n.dir(e, "previousSibling", r) | |
| }, | |
| siblings: function(e) { | |
| return n.sibling((e.parentNode || {}).firstChild, e) | |
| }, | |
| children: function(e) { | |
| return n.sibling(e.firstChild) | |
| }, | |
| contents: function(e) { | |
| return e.contentDocument || n.merge([], e.childNodes) | |
| } | |
| }, function(e, t) { | |
| n.fn[e] = function(r, i) { | |
| var s = n.map(this, t, r); | |
| return "Until" !== e.slice(-5) && (i = r), | |
| i && "string" == typeof i && (s = n.filter(i, s)), | |
| this.length > 1 && (C[e] || n.unique(s), | |
| B.test(e) && s.reverse()), | |
| this.pushStack(s) | |
| } | |
| }); | |
| var E = /\S+/g | |
| , F = {}; | |
| n.Callbacks = function(e) { | |
| e = "string" == typeof e ? F[e] || G(e) : n.extend({}, e); | |
| var t, r, i, s, o, u, a = [], f = !e.once && [], l = function(n) { | |
| for (t = e.memory && n, | |
| r = !0, | |
| u = s || 0, | |
| s = 0, | |
| o = a.length, | |
| i = !0; a && o > u; u++) | |
| if (a[u].apply(n[0], n[1]) === !1 && e.stopOnFalse) { | |
| t = !1; | |
| break | |
| } | |
| i = !1, | |
| a && (f ? f.length && l(f.shift()) : t ? a = [] : c.disable()) | |
| }, c = { | |
| add: function() { | |
| if (a) { | |
| var r = a.length; | |
| !function u(t) { | |
| n.each(t, function(t, r) { | |
| var i = n.type(r); | |
| "function" === i ? e.unique && c.has(r) || a.push(r) : r && r.length && "string" !== i && u(r) | |
| }) | |
| }(arguments), | |
| i ? o = a.length : t && (s = r, | |
| l(t)) | |
| } | |
| return this | |
| }, | |
| remove: function() { | |
| return a && n.each(arguments, function(e, t) { | |
| var r; | |
| while ((r = n.inArray(t, a, r)) > -1) | |
| a.splice(r, 1), | |
| i && (o >= r && o--, | |
| u >= r && u--) | |
| }), | |
| this | |
| }, | |
| has: function(e) { | |
| return e ? n.inArray(e, a) > -1 : !!a && !!a.length | |
| }, | |
| empty: function() { | |
| return a = [], | |
| o = 0, | |
| this | |
| }, | |
| disable: function() { | |
| return a = f = t = void 0, | |
| this | |
| }, | |
| disabled: function() { | |
| return !a | |
| }, | |
| lock: function() { | |
| return f = void 0, | |
| t || c.disable(), | |
| this | |
| }, | |
| locked: function() { | |
| return !f | |
| }, | |
| fireWith: function(e, t) { | |
| return !a || r && !f || (t = t || [], | |
| t = [e, t.slice ? t.slice() : t], | |
| i ? f.push(t) : l(t)), | |
| this | |
| }, | |
| fire: function() { | |
| return c.fireWith(this, arguments), | |
| this | |
| }, | |
| fired: function() { | |
| return !!r | |
| } | |
| }; | |
| return c | |
| } | |
| , | |
| n.extend({ | |
| Deferred: function(e) { | |
| var t = [["resolve", "done", n.Callbacks("once memory"), "resolved"], ["reject", "fail", n.Callbacks("once memory"), "rejected"], ["notify", "progress", n.Callbacks("memory")]] | |
| , r = "pending" | |
| , i = { | |
| state: function() { | |
| return r | |
| }, | |
| always: function() { | |
| return s.done(arguments).fail(arguments), | |
| this | |
| }, | |
| then: function() { | |
| var e = arguments; | |
| return n.Deferred(function(r) { | |
| n.each(t, function(t, o) { | |
| var u = n.isFunction(e[t]) && e[t]; | |
| s[o[1]](function() { | |
| var e = u && u.apply(this, arguments); | |
| e && n.isFunction(e.promise) ? e.promise().done(r.resolve).fail(r.reject).progress(r.notify) : r[o[0] + "With"](this === i ? r.promise() : this, u ? [e] : arguments) | |
| }) | |
| }), | |
| e = null | |
| }).promise() | |
| }, | |
| promise: function(e) { | |
| return null != e ? n.extend(e, i) : i | |
| } | |
| } | |
| , s = {}; | |
| return i.pipe = i.then, | |
| n.each(t, function(e, n) { | |
| var o = n[2] | |
| , u = n[3]; | |
| i[n[1]] = o.add, | |
| u && o.add(function() { | |
| r = u | |
| }, t[1 ^ e][2].disable, t[2][2].lock), | |
| s[n[0]] = function() { | |
| return s[n[0] + "With"](this === s ? i : this, arguments), | |
| this | |
| } | |
| , | |
| s[n[0] + "With"] = o.fireWith | |
| }), | |
| i.promise(s), | |
| e && e.call(s, s), | |
| s | |
| }, | |
| when: function(e) { | |
| var t = 0, r = d.call(arguments), i = r.length, s = 1 !== i || e && n.isFunction(e.promise) ? i : 0, o = 1 === s ? e : n.Deferred(), u = function(e, t, n) { | |
| return function(r) { | |
| t[e] = this, | |
| n[e] = arguments.length > 1 ? d.call(arguments) : r, | |
| n === a ? o.notifyWith(t, n) : --s || o.resolveWith(t, n) | |
| } | |
| }, a, f, l; | |
| if (i > 1) | |
| for (a = new Array(i), | |
| f = new Array(i), | |
| l = new Array(i); i > t; t++) | |
| r[t] && n.isFunction(r[t].promise) ? r[t].promise().done(u(t, l, r)).fail(o.reject).progress(u(t, f, a)) : --s; | |
| return s || o.resolveWith(l, r), | |
| o.promise() | |
| } | |
| }); | |
| var H; | |
| n.fn.ready = function(e) { | |
| return n.ready.promise().done(e), | |
| this | |
| } | |
| , | |
| n.extend({ | |
| isReady: !1, | |
| readyWait: 1, | |
| holdReady: function(e) { | |
| e ? n.readyWait++ : n.ready(!0) | |
| }, | |
| ready: function(e) { | |
| (e === !0 ? --n.readyWait : n.isReady) || (n.isReady = !0, | |
| e !== !0 && --n.readyWait > 0 || (H.resolveWith(l, [n]), | |
| n.fn.triggerHandler && (n(l).triggerHandler("ready"), | |
| n(l).off("ready")))) | |
| } | |
| }), | |
| n.ready.promise = function(e) { | |
| return H || (H = n.Deferred(), | |
| "complete" === l.readyState ? setTimeout(n.ready) : (l.addEventListener("DOMContentLoaded", I, !1), | |
| a.addEventListener("load", I, !1))), | |
| H.promise(e) | |
| } | |
| , | |
| n.ready.promise(); | |
| var J = n.access = function(e, t, r, i, s, o, u) { | |
| var a = 0 | |
| , f = e.length | |
| , l = null == r; | |
| if ("object" === n.type(r)) { | |
| s = !0; | |
| for (a in r) | |
| n.access(e, t, a, r[a], !0, o, u) | |
| } else if (void 0 !== i && (s = !0, | |
| n.isFunction(i) || (u = !0), | |
| l && (u ? (t.call(e, i), | |
| t = null) : (l = t, | |
| t = function(e, t, r) { | |
| return l.call(n(e), r) | |
| } | |
| )), | |
| t)) | |
| for (; f > a; a++) | |
| t(e[a], r, u ? i : i.call(e[a], a, t(e[a], r))); | |
| return s ? e : l ? t.call(e) : f ? t(e[0], r) : o | |
| } | |
| ; | |
| n.acceptData = function(e) { | |
| return 1 === e.nodeType || 9 === e.nodeType || !+e.nodeType | |
| } | |
| , | |
| K.uid = 1, | |
| K.accepts = n.acceptData, | |
| K.prototype = { | |
| key: function(e) { | |
| if (!K.accepts(e)) | |
| return 0; | |
| var t = {} | |
| , r = e[this.expando]; | |
| if (!r) { | |
| r = K.uid++; | |
| try { | |
| t[this.expando] = { | |
| value: r | |
| }, | |
| Object.defineProperties(e, t) | |
| } catch (i) { | |
| t[this.expando] = r, | |
| n.extend(e, t) | |
| } | |
| } | |
| return this.cache[r] || (this.cache[r] = {}), | |
| r | |
| }, | |
| set: function(e, t, r) { | |
| var i, s = this.key(e), o = this.cache[s]; | |
| if ("string" == typeof t) | |
| o[t] = r; | |
| else if (n.isEmptyObject(o)) | |
| n.extend(this.cache[s], t); | |
| else | |
| for (i in t) | |
| o[i] = t[i]; | |
| return o | |
| }, | |
| get: function(e, t) { | |
| var n = this.cache[this.key(e)]; | |
| return void 0 === t ? n : n[t] | |
| }, | |
| access: function(e, t, r) { | |
| var i; | |
| return void 0 === t || t && "string" == typeof t && void 0 === r ? (i = this.get(e, t), | |
| void 0 !== i ? i : this.get(e, n.camelCase(t))) : (this.set(e, t, r), | |
| void 0 !== r ? r : t) | |
| }, | |
| remove: function(e, t) { | |
| var r, i, s, o = this.key(e), u = this.cache[o]; | |
| if (void 0 === t) | |
| this.cache[o] = {}; | |
| else { | |
| n.isArray(t) ? i = t.concat(t.map(n.camelCase)) : (s = n.camelCase(t), | |
| t in u ? i = [t, s] : (i = s, | |
| i = i in u ? [i] : i.match(E) || [])), | |
| r = i.length; | |
| while (r--) | |
| delete u[i[r]] | |
| } | |
| }, | |
| hasData: function(e) { | |
| return !n.isEmptyObject(this.cache[e[this.expando]] || {}) | |
| }, | |
| discard: function(e) { | |
| e[this.expando] && delete this.cache[e[this.expando]] | |
| } | |
| }; | |
| var L = new K | |
| , M = new K | |
| , N = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/ | |
| , O = /([A-Z])/g; | |
| n.extend({ | |
| hasData: function(e) { | |
| return M.hasData(e) || L.hasData(e) | |
| }, | |
| data: function(e, t, n) { | |
| return M.access(e, t, n) | |
| }, | |
| removeData: function(e, t) { | |
| M.remove(e, t) | |
| }, | |
| _data: function(e, t, n) { | |
| return L.access(e, t, n) | |
| }, | |
| _removeData: function(e, t) { | |
| L.remove(e, t) | |
| } | |
| }), | |
| n.fn.extend({ | |
| data: function(e, t) { | |
| var r, i, s, o = this[0], u = o && o.attributes; | |
| if (void 0 === e) { | |
| if (this.length && (s = M.get(o), | |
| 1 === o.nodeType && !L.get(o, "hasDataAttrs"))) { | |
| r = u.length; | |
| while (r--) | |
| u[r] && (i = u[r].name, | |
| 0 === i.indexOf("data-") && (i = n.camelCase(i.slice(5)), | |
| P(o, i, s[i]))); | |
| L.set(o, "hasDataAttrs", !0) | |
| } | |
| return s | |
| } | |
| return "object" == typeof e ? this.each(function() { | |
| M.set(this, e) | |
| }) : J(this, function(t) { | |
| var r, i = n.camelCase(e); | |
| if (o && void 0 === t) { | |
| if (r = M.get(o, e), | |
| void 0 !== r) | |
| return r; | |
| if (r = M.get(o, i), | |
| void 0 !== r) | |
| return r; | |
| if (r = P(o, i, void 0), | |
| void 0 !== r) | |
| return r | |
| } else | |
| this.each(function() { | |
| var n = M.get(this, i); | |
| M.set(this, i, t), | |
| -1 !== e.indexOf("-") && void 0 !== n && M.set(this, e, t) | |
| }) | |
| }, null, t, arguments.length > 1, null, !0) | |
| }, | |
| removeData: function(e) { | |
| return this.each(function() { | |
| M.remove(this, e) | |
| }) | |
| } | |
| }), | |
| n.extend({ | |
| queue: function(e, t, r) { | |
| var i; | |
| return e ? (t = (t || "fx") + "queue", | |
| i = L.get(e, t), | |
| r && (!i || n.isArray(r) ? i = L.access(e, t, n.makeArray(r)) : i.push(r)), | |
| i || []) : void 0 | |
| }, | |
| dequeue: function(e, t) { | |
| t = t || "fx"; | |
| var r = n.queue(e, t) | |
| , i = r.length | |
| , s = r.shift() | |
| , o = n._queueHooks(e, t) | |
| , u = function() { | |
| n.dequeue(e, t) | |
| }; | |
| "inprogress" === s && (s = r.shift(), | |
| i--), | |
| s && ("fx" === t && r.unshift("inprogress"), | |
| delete o.stop, | |
| s.call(e, u, o)), | |
| !i && o && o.empty.fire() | |
| }, | |
| _queueHooks: function(e, t) { | |
| var r = t + "queueHooks"; | |
| return L.get(e, r) || L.access(e, r, { | |
| empty: n.Callbacks("once memory").add(function() { | |
| L.remove(e, [t + "queue", r]) | |
| }) | |
| }) | |
| } | |
| }), | |
| n.fn.extend({ | |
| queue: function(e, t) { | |
| var r = 2; | |
| return "string" != typeof e && (t = e, | |
| e = "fx", | |
| r--), | |
| arguments.length < r ? n.queue(this[0], e) : void 0 === t ? this : this.each(function() { | |
| var r = n.queue(this, e, t); | |
| n._queueHooks(this, e), | |
| "fx" === e && "inprogress" !== r[0] && n.dequeue(this, e) | |
| }) | |
| }, | |
| dequeue: function(e) { | |
| return this.each(function() { | |
| n.dequeue(this, e) | |
| }) | |
| }, | |
| clearQueue: function(e) { | |
| return this.queue(e || "fx", []) | |
| }, | |
| promise: function(e, t) { | |
| var r, i = 1, s = n.Deferred(), o = this, u = this.length, a = function() { | |
| --i || s.resolveWith(o, [o]) | |
| }; | |
| "string" != typeof e && (t = e, | |
| e = void 0), | |
| e = e || "fx"; | |
| while (u--) | |
| r = L.get(o[u], e + "queueHooks"), | |
| r && r.empty && (i++, | |
| r.empty.add(a)); | |
| return a(), | |
| s.promise(t) | |
| } | |
| }); | |
| var Q = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source | |
| , R = ["Top", "Right", "Bottom", "Left"] | |
| , S = function(e, t) { | |
| return e = t || e, | |
| "none" === n.css(e, "display") || !n.contains(e.ownerDocument, e) | |
| } | |
| , T = /^(?:checkbox|radio)$/i; | |
| !function() { | |
| var e = l.createDocumentFragment() | |
| , t = e.appendChild(l.createElement("div")) | |
| , n = l.createElement("input"); | |
| n.setAttribute("type", "radio"), | |
| n.setAttribute("checked", "checked"), | |
| n.setAttribute("name", "t"), | |
| t.appendChild(n), | |
| k.checkClone = t.cloneNode(!0).cloneNode(!0).lastChild.checked, | |
| t.innerHTML = "<textarea>x</textarea>", | |
| k.noCloneChecked = !!t.cloneNode(!0).lastChild.defaultValue | |
| }(); | |
| var U = "undefined"; | |
| k.focusinBubbles = "onfocusin"in a; | |
| var V = /^key/ | |
| , W = /^(?:mouse|pointer|contextmenu)|click/ | |
| , X = /^(?:focusinfocus|focusoutblur)$/ | |
| , Y = /^([^.]*)(?:\.(.+)|)$/; | |
| n.event = { | |
| global: {}, | |
| add: function(e, t, r, i, s) { | |
| var o, u, a, f, l, c, h, p, d, v, m, g = L.get(e); | |
| if (g) { | |
| r.handler && (o = r, | |
| r = o.handler, | |
| s = o.selector), | |
| r.guid || (r.guid = n.guid++), | |
| (f = g.events) || (f = g.events = {}), | |
| (u = g.handle) || (u = g.handle = function(t) { | |
| return typeof n !== U && n.event.triggered !== t.type ? n.event.dispatch.apply(e, arguments) : void 0 | |
| } | |
| ), | |
| t = (t || "").match(E) || [""], | |
| l = t.length; | |
| while (l--) | |
| a = Y.exec(t[l]) || [], | |
| d = m = a[1], | |
| v = (a[2] || "").split(".").sort(), | |
| d && (h = n.event.special[d] || {}, | |
| d = (s ? h.delegateType : h.bindType) || d, | |
| h = n.event.special[d] || {}, | |
| c = n.extend({ | |
| type: d, | |
| origType: m, | |
| data: i, | |
| handler: r, | |
| guid: r.guid, | |
| selector: s, | |
| needsContext: s && n.expr.match.needsContext.test(s), | |
| namespace: v.join(".") | |
| }, o), | |
| (p = f[d]) || (p = f[d] = [], | |
| p.delegateCount = 0, | |
| h.setup && h.setup.call(e, i, v, u) !== !1 || e.addEventListener && e.addEventListener(d, u, !1)), | |
| h.add && (h.add.call(e, c), | |
| c.handler.guid || (c.handler.guid = r.guid)), | |
| s ? p.splice(p.delegateCount++, 0, c) : p.push(c), | |
| n.event.global[d] = !0) | |
| } | |
| }, | |
| remove: function(e, t, r, i, s) { | |
| var o, u, a, f, l, c, h, p, d, v, m, g = L.hasData(e) && L.get(e); | |
| if (g && (f = g.events)) { | |
| t = (t || "").match(E) || [""], | |
| l = t.length; | |
| while (l--) | |
| if (a = Y.exec(t[l]) || [], | |
| d = m = a[1], | |
| v = (a[2] || "").split(".").sort(), | |
| d) { | |
| h = n.event.special[d] || {}, | |
| d = (i ? h.delegateType : h.bindType) || d, | |
| p = f[d] || [], | |
| a = a[2] && new RegExp("(^|\\.)" + v.join("\\.(?:.*\\.|)") + "(\\.|$)"), | |
| u = o = p.length; | |
| while (o--) | |
| c = p[o], | |
| !s && m !== c.origType || r && r.guid !== c.guid || a && !a.test(c.namespace) || i && i !== c.selector && ("**" !== i || !c.selector) || (p.splice(o, 1), | |
| c.selector && p.delegateCount--, | |
| h.remove && h.remove.call(e, c)); | |
| u && !p.length && (h.teardown && h.teardown.call(e, v, g.handle) !== !1 || n.removeEvent(e, d, g.handle), | |
| delete f[d]) | |
| } else | |
| for (d in f) | |
| n.event.remove(e, d + t[l], r, i, !0); | |
| n.isEmptyObject(f) && (delete g.handle, | |
| L.remove(e, "events")) | |
| } | |
| }, | |
| trigger: function(e, t, r, i) { | |
| var s, o, u, f, c, h, p, d = [r || l], v = j.call(e, "type") ? e.type : e, m = j.call(e, "namespace") ? e.namespace.split(".") : []; | |
| if (o = u = r = r || l, | |
| 3 !== r.nodeType && 8 !== r.nodeType && !X.test(v + n.event.triggered) && (v.indexOf(".") >= 0 && (m = v.split("."), | |
| v = m.shift(), | |
| m.sort()), | |
| c = v.indexOf(":") < 0 && "on" + v, | |
| e = e[n.expando] ? e : new n.Event(v,"object" == typeof e && e), | |
| e.isTrigger = i ? 2 : 3, | |
| e.namespace = m.join("."), | |
| e.namespace_re = e.namespace ? new RegExp("(^|\\.)" + m.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, | |
| e.result = void 0, | |
| e.target || (e.target = r), | |
| t = null == t ? [e] : n.makeArray(t, [e]), | |
| p = n.event.special[v] || {}, | |
| i || !p.trigger || p.trigger.apply(r, t) !== !1)) { | |
| if (!i && !p.noBubble && !n.isWindow(r)) { | |
| for (f = p.delegateType || v, | |
| X.test(f + v) || (o = o.parentNode); o; o = o.parentNode) | |
| d.push(o), | |
| u = o; | |
| u === (r.ownerDocument || l) && d.push(u.defaultView || u.parentWindow || a) | |
| } | |
| s = 0; | |
| while ((o = d[s++]) && !e.isPropagationStopped()) | |
| e.type = s > 1 ? f : p.bindType || v, | |
| h = (L.get(o, "events") || {})[e.type] && L.get(o, "handle"), | |
| h && h.apply(o, t), | |
| h = c && o[c], | |
| h && h.apply && n.acceptData(o) && (e.result = h.apply(o, t), | |
| e.result === !1 && e.preventDefault()); | |
| return e.type = v, | |
| i || e.isDefaultPrevented() || p._default && p._default.apply(d.pop(), t) !== !1 || !n.acceptData(r) || c && n.isFunction(r[v]) && !n.isWindow(r) && (u = r[c], | |
| u && (r[c] = null), | |
| n.event.triggered = v, | |
| r[v](), | |
| n.event.triggered = void 0, | |
| u && (r[c] = u)), | |
| e.result | |
| } | |
| }, | |
| dispatch: function(e) { | |
| e = n.event.fix(e); | |
| var t, r, i, s, o, u = [], a = d.call(arguments), f = (L.get(this, "events") || {})[e.type] || [], l = n.event.special[e.type] || {}; | |
| if (a[0] = e, | |
| e.delegateTarget = this, | |
| !l.preDispatch || l.preDispatch.call(this, e) !== !1) { | |
| u = n.event.handlers.call(this, e, f), | |
| t = 0; | |
| while ((s = u[t++]) && !e.isPropagationStopped()) { | |
| e.currentTarget = s.elem, | |
| r = 0; | |
| while ((o = s.handlers[r++]) && !e.isImmediatePropagationStopped()) | |
| (!e.namespace_re || e.namespace_re.test(o.namespace)) && (e.handleObj = o, | |
| e.data = o.data, | |
| i = ((n.event.special[o.origType] || {}).handle || o.handler).apply(s.elem, a), | |
| void 0 !== i && (e.result = i) === !1 && (e.preventDefault(), | |
| e.stopPropagation())) | |
| } | |
| return l.postDispatch && l.postDispatch.call(this, e), | |
| e.result | |
| } | |
| }, | |
| handlers: function(e, t) { | |
| var r, i, s, o, u = [], a = t.delegateCount, f = e.target; | |
| if (a && f.nodeType && (!e.button || "click" !== e.type)) | |
| for (; f !== this; f = f.parentNode || this) | |
| if (f.disabled !== !0 || "click" !== e.type) { | |
| for (i = [], | |
| r = 0; a > r; r++) | |
| o = t[r], | |
| s = o.selector + " ", | |
| void 0 === i[s] && (i[s] = o.needsContext ? n(s, this).index(f) >= 0 : n.find(s, this, null, [f]).length), | |
| i[s] && i.push(o); | |
| i.length && u.push({ | |
| elem: f, | |
| handlers: i | |
| }) | |
| } | |
| return a < t.length && u.push({ | |
| elem: this, | |
| handlers: t.slice(a) | |
| }), | |
| u | |
| }, | |
| props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), | |
| fixHooks: {}, | |
| keyHooks: { | |
| props: "char charCode key keyCode".split(" "), | |
| filter: function(e, t) { | |
| return null == e.which && (e.which = null != t.charCode ? t.charCode : t.keyCode), | |
| e | |
| } | |
| }, | |
| mouseHooks: { | |
| props: "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "), | |
| filter: function(e, t) { | |
| var n, r, i, s = t.button; | |
| return null == e.pageX && null != t.clientX && (n = e.target.ownerDocument || l, | |
| r = n.documentElement, | |
| i = n.body, | |
| e.pageX = t.clientX + (r && r.scrollLeft || i && i.scrollLeft || 0) - (r && r.clientLeft || i && i.clientLeft || 0), | |
| e.pageY = t.clientY + (r && r.scrollTop || i && i.scrollTop || 0) - (r && r.clientTop || i && i.clientTop || 0)), | |
| e.which || void 0 === s || (e.which = 1 & s ? 1 : 2 & s ? 3 : 4 & s ? 2 : 0), | |
| e | |
| } | |
| }, | |
| fix: function(e) { | |
| if (e[n.expando]) | |
| return e; | |
| var t, r, i, s = e.type, o = e, u = this.fixHooks[s]; | |
| u || (this.fixHooks[s] = u = W.test(s) ? this.mouseHooks : V.test(s) ? this.keyHooks : {}), | |
| i = u.props ? this.props.concat(u.props) : this.props, | |
| e = new n.Event(o), | |
| t = i.length; | |
| while (t--) | |
| r = i[t], | |
| e[r] = o[r]; | |
| return e.target || (e.target = l), | |
| 3 === e.target.nodeType && (e.target = e.target.parentNode), | |
| u.filter ? u.filter(e, o) : e | |
| }, | |
| special: { | |
| load: { | |
| noBubble: !0 | |
| }, | |
| focus: { | |
| trigger: function() { | |
| return this !== _() && this.focus ? (this.focus(), | |
| !1) : void 0 | |
| }, | |
| delegateType: "focusin" | |
| }, | |
| blur: { | |
| trigger: function() { | |
| return this === _() && this.blur ? (this.blur(), | |
| !1) : void 0 | |
| }, | |
| delegateType: "focusout" | |
| }, | |
| click: { | |
| trigger: function() { | |
| return "checkbox" === this.type && this.click && n.nodeName(this, "input") ? (this.click(), | |
| !1) : void 0 | |
| }, | |
| _default: function(e) { | |
| return n.nodeName(e.target, "a") | |
| } | |
| }, | |
| beforeunload: { | |
| postDispatch: function(e) { | |
| void 0 !== e.result && e.originalEvent && (e.originalEvent.returnValue = e.result) | |
| } | |
| } | |
| }, | |
| simulate: function(e, t, r, i) { | |
| var s = n.extend(new n.Event, r, { | |
| type: e, | |
| isSimulated: !0, | |
| originalEvent: {} | |
| }); | |
| i ? n.event.trigger(s, null, t) : n.event.dispatch.call(t, s), | |
| s.isDefaultPrevented() && r.preventDefault() | |
| } | |
| }, | |
| n.removeEvent = function(e, t, n) { | |
| e.removeEventListener && e.removeEventListener(t, n, !1) | |
| } | |
| , | |
| n.Event = function(e, t) { | |
| return this instanceof n.Event ? (e && e.type ? (this.originalEvent = e, | |
| this.type = e.type, | |
| this.isDefaultPrevented = e.defaultPrevented || void 0 === e.defaultPrevented && e.returnValue === !1 ? Z : $) : this.type = e, | |
| t && n.extend(this, t), | |
| this.timeStamp = e && e.timeStamp || n.now(), | |
| void (this[n.expando] = !0)) : new n.Event(e,t) | |
| } | |
| , | |
| n.Event.prototype = { | |
| isDefaultPrevented: $, | |
| isPropagationStopped: $, | |
| isImmediatePropagationStopped: $, | |
| preventDefault: function() { | |
| var e = this.originalEvent; | |
| this.isDefaultPrevented = Z, | |
| e && e.preventDefault && e.preventDefault() | |
| }, | |
| stopPropagation: function() { | |
| var e = this.originalEvent; | |
| this.isPropagationStopped = Z, | |
| e && e.stopPropagation && e.stopPropagation() | |
| }, | |
| stopImmediatePropagation: function() { | |
| var e = this.originalEvent; | |
| this.isImmediatePropagationStopped = Z, | |
| e && e.stopImmediatePropagation && e.stopImmediatePropagation(), | |
| this.stopPropagation() | |
| } | |
| }, | |
| n.each({ | |
| mouseenter: "mouseover", | |
| mouseleave: "mouseout", | |
| pointerenter: "pointerover", | |
| pointerleave: "pointerout" | |
| }, function(e, t) { | |
| n.event.special[e] = { | |
| delegateType: t, | |
| bindType: t, | |
| handle: function(e) { | |
| var r, i = this, s = e.relatedTarget, o = e.handleObj; | |
| return (!s || s !== i && !n.contains(i, s)) && (e.type = o.origType, | |
| r = o.handler.apply(this, arguments), | |
| e.type = t), | |
| r | |
| } | |
| } | |
| }), | |
| k.focusinBubbles || n.each({ | |
| focus: "focusin", | |
| blur: "focusout" | |
| }, function(e, t) { | |
| var r = function(e) { | |
| n.event.simulate(t, e.target, n.event.fix(e), !0) | |
| }; | |
| n.event.special[t] = { | |
| setup: function() { | |
| var n = this.ownerDocument || this | |
| , i = L.access(n, t); | |
| i || n.addEventListener(e, r, !0), | |
| L.access(n, t, (i || 0) + 1) | |
| }, | |
| teardown: function() { | |
| var n = this.ownerDocument || this | |
| , i = L.access(n, t) - 1; | |
| i ? L.access(n, t, i) : (n.removeEventListener(e, r, !0), | |
| L.remove(n, t)) | |
| } | |
| } | |
| }), | |
| n.fn.extend({ | |
| on: function(e, t, r, i, s) { | |
| var o, u; | |
| if ("object" == typeof e) { | |
| "string" != typeof t && (r = r || t, | |
| t = void 0); | |
| for (u in e) | |
| this.on(u, t, r, e[u], s); | |
| return this | |
| } | |
| if (null == r && null == i ? (i = t, | |
| r = t = void 0) : null == i && ("string" == typeof t ? (i = r, | |
| r = void 0) : (i = r, | |
| r = t, | |
| t = void 0)), | |
| i === !1) | |
| i = $; | |
| else if (!i) | |
| return this; | |
| return 1 === s && (o = i, | |
| i = function(e) { | |
| return n().off(e), | |
| o.apply(this, arguments) | |
| } | |
| , | |
| i.guid = o.guid || (o.guid = n.guid++)), | |
| this.each(function() { | |
| n.event.add(this, e, i, r, t) | |
| }) | |
| }, | |
| one: function(e, t, n, r) { | |
| return this.on(e, t, n, r, 1) | |
| }, | |
| off: function(e, t, r) { | |
| var i, s; | |
| if (e && e.preventDefault && e.handleObj) | |
| return i = e.handleObj, | |
| n(e.delegateTarget).off(i.namespace ? i.origType + "." + i.namespace : i.origType, i.selector, i.handler), | |
| this; | |
| if ("object" == typeof e) { | |
| for (s in e) | |
| this.off(s, t, e[s]); | |
| return this | |
| } | |
| return (t === !1 || "function" == typeof t) && (r = t, | |
| t = void 0), | |
| r === !1 && (r = $), | |
| this.each(function() { | |
| n.event.remove(this, e, r, t) | |
| }) | |
| }, | |
| trigger: function(e, t) { | |
| return this.each(function() { | |
| n.event.trigger(e, t, this) | |
| }) | |
| }, | |
| triggerHandler: function(e, t) { | |
| var r = this[0]; | |
| return r ? n.event.trigger(e, t, r, !0) : void 0 | |
| } | |
| }); | |
| var ab = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi | |
| , bb = /<([\w:]+)/ | |
| , cb = /<|&#?\w+;/ | |
| , db = /<(?:script|style|link)/i | |
| , eb = /checked\s*(?:[^=]|=\s*.checked.)/i | |
| , fb = /^$|\/(?:java|ecma)script/i | |
| , gb = /^true\/(.*)/ | |
| , hb = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g | |
| , ib = { | |
| option: [1, "<select multiple='multiple'>", "</select>"], | |
| thead: [1, "<table>", "</table>"], | |
| col: [2, "<table><colgroup>", "</colgroup></table>"], | |
| tr: [2, "<table><tbody>", "</tbody></table>"], | |
| td: [3, "<table><tbody><tr>", "</tr></tbody></table>"], | |
| _default: [0, "", ""] | |
| }; | |
| ib.optgroup = ib.option, | |
| ib.tbody = ib.tfoot = ib.colgroup = ib.caption = ib.thead, | |
| ib.th = ib.td, | |
| n.extend({ | |
| clone: function(e, t, r) { | |
| var i, s, o, u, a = e.cloneNode(!0), f = n.contains(e.ownerDocument, e); | |
| if (!(k.noCloneChecked || 1 !== e.nodeType && 11 !== e.nodeType || n.isXMLDoc(e))) | |
| for (u = ob(a), | |
| o = ob(e), | |
| i = 0, | |
| s = o.length; s > i; i++) | |
| pb(o[i], u[i]); | |
| if (t) | |
| if (r) | |
| for (o = o || ob(e), | |
| u = u || ob(a), | |
| i = 0, | |
| s = o.length; s > i; i++) | |
| nb(o[i], u[i]); | |
| else | |
| nb(e, a); | |
| return u = ob(a, "script"), | |
| u.length > 0 && mb(u, !f && ob(e, "script")), | |
| a | |
| }, | |
| buildFragment: function(e, t, r, i) { | |
| for (var s, o, u, a, f, l, c = t.createDocumentFragment(), h = [], p = 0, d = e.length; d > p; p++) | |
| if (s = e[p], | |
| s || 0 === s) | |
| if ("object" === n.type(s)) | |
| n.merge(h, s.nodeType ? [s] : s); | |
| else if (cb.test(s)) { | |
| o = o || c.appendChild(t.createElement("div")), | |
| u = (bb.exec(s) || ["", ""])[1].toLowerCase(), | |
| a = ib[u] || ib._default, | |
| o.innerHTML = a[1] + s.replace(ab, "<$1></$2>") + a[2], | |
| l = a[0]; | |
| while (l--) | |
| o = o.lastChild; | |
| n.merge(h, o.childNodes), | |
| o = c.firstChild, | |
| o.textContent = "" | |
| } else | |
| h.push(t.createTextNode(s)); | |
| c.textContent = "", | |
| p = 0; | |
| while (s = h[p++]) | |
| if ((!i || -1 === n.inArray(s, i)) && (f = n.contains(s.ownerDocument, s), | |
| o = ob(c.appendChild(s), "script"), | |
| f && mb(o), | |
| r)) { | |
| l = 0; | |
| while (s = o[l++]) | |
| fb.test(s.type || "") && r.push(s) | |
| } | |
| return c | |
| }, | |
| cleanData: function(e) { | |
| for (var t, r, i, s, o = n.event.special, u = 0; void 0 !== (r = e[u]); u++) { | |
| if (n.acceptData(r) && (s = r[L.expando], | |
| s && (t = L.cache[s]))) { | |
| if (t.events) | |
| for (i in t.events) | |
| o[i] ? n.event.remove(r, i) : n.removeEvent(r, i, t.handle); | |
| L.cache[s] && delete L.cache[s] | |
| } | |
| delete M.cache[r[M.expando]] | |
| } | |
| } | |
| }), | |
| n.fn.extend({ | |
| text: function(e) { | |
| return J(this, function(e) { | |
| return void 0 === e ? n.text(this) : this.empty().each(function() { | |
| (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) && (this.textContent = e) | |
| }) | |
| }, null, e, arguments.length) | |
| }, | |
| append: function() { | |
| return this.domManip(arguments, function(e) { | |
| if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) { | |
| var t = jb(this, e); | |
| t.appendChild(e) | |
| } | |
| }) | |
| }, | |
| prepend: function() { | |
| return this.domManip(arguments, function(e) { | |
| if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) { | |
| var t = jb(this, e); | |
| t.insertBefore(e, t.firstChild) | |
| } | |
| }) | |
| }, | |
| before: function() { | |
| return this.domManip(arguments, function(e) { | |
| this.parentNode && this.parentNode.insertBefore(e, this) | |
| }) | |
| }, | |
| after: function() { | |
| return this.domManip(arguments, function(e) { | |
| this.parentNode && this.parentNode.insertBefore(e, this.nextSibling) | |
| }) | |
| }, | |
| remove: function(e, t) { | |
| for (var r, i = e ? n.filter(e, this) : this, s = 0; null != (r = i[s]); s++) | |
| t || 1 !== r.nodeType || n.cleanData(ob(r)), | |
| r.parentNode && (t && n.contains(r.ownerDocument, r) && mb(ob(r, "script")), | |
| r.parentNode.removeChild(r)); | |
| return this | |
| }, | |
| empty: function() { | |
| for (var e, t = 0; null != (e = this[t]); t++) | |
| 1 === e.nodeType && (n.cleanData(ob(e, !1)), | |
| e.textContent = ""); | |
| return this | |
| }, | |
| clone: function(e, t) { | |
| return e = null == e ? !1 : e, | |
| t = null == t ? e : t, | |
| this.map(function() { | |
| return n.clone(this, e, t) | |
| }) | |
| }, | |
| html: function(e) { | |
| return J(this, function(e) { | |
| var t = this[0] || {} | |
| , r = 0 | |
| , i = this.length; | |
| if (void 0 === e && 1 === t.nodeType) | |
| return t.innerHTML; | |
| if ("string" == typeof e && !db.test(e) && !ib[(bb.exec(e) || ["", ""])[1].toLowerCase()]) { | |
| e = e.replace(ab, "<$1></$2>"); | |
| try { | |
| for (; i > r; r++) | |
| t = this[r] || {}, | |
| 1 === t.nodeType && (n.cleanData(ob(t, !1)), | |
| t.innerHTML = e); | |
| t = 0 | |
| } catch (s) {} | |
| } | |
| t && this.empty().append(e) | |
| }, null, e, arguments.length) | |
| }, | |
| replaceWith: function() { | |
| var e = arguments[0]; | |
| return this.domManip(arguments, function(t) { | |
| e = this.parentNode, | |
| n.cleanData(ob(this)), | |
| e && e.replaceChild(t, this) | |
| }), | |
| e && (e.length || e.nodeType) ? this : this.remove() | |
| }, | |
| detach: function(e) { | |
| return this.remove(e, !0) | |
| }, | |
| domManip: function(t, r) { | |
| t = e.apply([], t); | |
| var i, s, o, u, a, f, l = 0, c = this.length, h = this, p = c - 1, d = t[0], v = n.isFunction(d); | |
| if (v || c > 1 && "string" == typeof d && !k.checkClone && eb.test(d)) | |
| return this.each(function(e) { | |
| var n = h.eq(e); | |
| v && (t[0] = d.call(this, e, n.html())), | |
| n.domManip(t, r) | |
| }); | |
| if (c && (i = n.buildFragment(t, this[0].ownerDocument, !1, this), | |
| s = i.firstChild, | |
| 1 === i.childNodes.length && (i = s), | |
| s)) { | |
| for (o = n.map(ob(i, "script"), kb), | |
| u = o.length; c > l; l++) | |
| a = i, | |
| l !== p && (a = n.clone(a, !0, !0), | |
| u && n.merge(o, ob(a, "script"))), | |
| r.call(this[l], a, l); | |
| if (u) | |
| for (f = o[o.length - 1].ownerDocument, | |
| n.map(o, lb), | |
| l = 0; u > l; l++) | |
| a = o[l], | |
| fb.test(a.type || "") && !L.access(a, "globalEval") && n.contains(f, a) && (a.src ? n._evalUrl && n._evalUrl(a.src) : n.globalEval(a.textContent.replace(hb, ""))) | |
| } | |
| return this | |
| } | |
| }), | |
| n.each({ | |
| appendTo: "append", | |
| prependTo: "prepend", | |
| insertBefore: "before", | |
| insertAfter: "after", | |
| replaceAll: "replaceWith" | |
| }, function(e, t) { | |
| n.fn[e] = function(e) { | |
| for (var r, i = [], s = n(e), o = s.length - 1, u = 0; o >= u; u++) | |
| r = u === o ? this : this.clone(!0), | |
| n(s[u])[t](r), | |
| f.apply(i, r.get()); | |
| return this.pushStack(i) | |
| } | |
| }); | |
| var qb, rb = {}, ub = /^margin/, vb = new RegExp("^(" + Q + ")(?!px)[a-z%]+$","i"), wb = function(e) { | |
| return e.ownerDocument.defaultView.getComputedStyle(e, null) | |
| }; | |
| !function() { | |
| var e, t, r = l.documentElement, i = l.createElement("div"), s = l.createElement("div"); | |
| if (s.style) { | |
| s.style.backgroundClip = "content-box", | |
| s.cloneNode(!0).style.backgroundClip = "", | |
| k.clearCloneStyle = "content-box" === s.style.backgroundClip, | |
| i.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;position:absolute", | |
| i.appendChild(s); | |
| function o() { | |
| s.style.cssText = "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;margin-top:1%;top:1%;border:1px;padding:1px;width:4px;position:absolute", | |
| s.innerHTML = "", | |
| r.appendChild(i); | |
| var n = a.getComputedStyle(s, null); | |
| e = "1%" !== n.top, | |
| t = "4px" === n.width, | |
| r.removeChild(i) | |
| } | |
| a.getComputedStyle && n.extend(k, { | |
| pixelPosition: function() { | |
| return o(), | |
| e | |
| }, | |
| boxSizingReliable: function() { | |
| return null == t && o(), | |
| t | |
| }, | |
| reliableMarginRight: function() { | |
| var e, t = s.appendChild(l.createElement("div")); | |
| return t.style.cssText = s.style.cssText = "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:0", | |
| t.style.marginRight = t.style.width = "0", | |
| s.style.width = "1px", | |
| r.appendChild(i), | |
| e = !parseFloat(a.getComputedStyle(t, null).marginRight), | |
| r.removeChild(i), | |
| e | |
| } | |
| }) | |
| } | |
| }(), | |
| n.swap = function(e, t, n, r) { | |
| var i, s, o = {}; | |
| for (s in t) | |
| o[s] = e.style[s], | |
| e.style[s] = t[s]; | |
| i = n.apply(e, r || []); | |
| for (s in t) | |
| e.style[s] = o[s]; | |
| return i | |
| } | |
| ; | |
| var zb = /^(none|table(?!-c[ea]).+)/ | |
| , Ab = new RegExp("^(" + Q + ")(.*)$","i") | |
| , Bb = new RegExp("^([+-])=(" + Q + ")","i") | |
| , Cb = { | |
| position: "absolute", | |
| visibility: "hidden", | |
| display: "block" | |
| } | |
| , Db = { | |
| letterSpacing: "0", | |
| fontWeight: "400" | |
| } | |
| , Eb = ["Webkit", "O", "Moz", "ms"]; | |
| n.extend({ | |
| cssHooks: { | |
| opacity: { | |
| get: function(e, t) { | |
| if (t) { | |
| var n = xb(e, "opacity"); | |
| return "" === n ? "1" : n | |
| } | |
| } | |
| } | |
| }, | |
| cssNumber: { | |
| columnCount: !0, | |
| fillOpacity: !0, | |
| flexGrow: !0, | |
| flexShrink: !0, | |
| fontWeight: !0, | |
| lineHeight: !0, | |
| opacity: !0, | |
| order: !0, | |
| orphans: !0, | |
| widows: !0, | |
| zIndex: !0, | |
| zoom: !0 | |
| }, | |
| cssProps: { | |
| "float": "cssFloat" | |
| }, | |
| style: function(e, t, r, i) { | |
| if (e && 3 !== e.nodeType && 8 !== e.nodeType && e.style) { | |
| var s, o, u, a = n.camelCase(t), f = e.style; | |
| return t = n.cssProps[a] || (n.cssProps[a] = Fb(f, a)), | |
| u = n.cssHooks[t] || n.cssHooks[a], | |
| void 0 === r ? u && "get"in u && void 0 !== (s = u.get(e, !1, i)) ? s : f[t] : (o = typeof r, | |
| "string" === o && (s = Bb.exec(r)) && (r = (s[1] + 1) * s[2] + parseFloat(n.css(e, t)), | |
| o = "number"), | |
| null != r && r === r && ("number" !== o || n.cssNumber[a] || (r += "px"), | |
| k.clearCloneStyle || "" !== r || 0 !== t.indexOf("background") || (f[t] = "inherit"), | |
| u && "set"in u && void 0 === (r = u.set(e, r, i)) || (f[t] = r)), | |
| void 0) | |
| } | |
| }, | |
| css: function(e, t, r, i) { | |
| var s, o, u, a = n.camelCase(t); | |
| return t = n.cssProps[a] || (n.cssProps[a] = Fb(e.style, a)), | |
| u = n.cssHooks[t] || n.cssHooks[a], | |
| u && "get"in u && (s = u.get(e, !0, r)), | |
| void 0 === s && (s = xb(e, t, i)), | |
| "normal" === s && t in Db && (s = Db[t]), | |
| "" === r || r ? (o = parseFloat(s), | |
| r === !0 || n.isNumeric(o) ? o || 0 : s) : s | |
| } | |
| }), | |
| n.each(["height", "width"], function(e, t) { | |
| n.cssHooks[t] = { | |
| get: function(e, r, i) { | |
| return r ? zb.test(n.css(e, "display")) && 0 === e.offsetWidth ? n.swap(e, Cb, function() { | |
| return Ib(e, t, i) | |
| }) : Ib(e, t, i) : void 0 | |
| }, | |
| set: function(e, r, i) { | |
| var s = i && wb(e); | |
| return Gb(e, r, i ? Hb(e, t, i, "border-box" === n.css(e, "boxSizing", !1, s), s) : 0) | |
| } | |
| } | |
| }), | |
| n.cssHooks.marginRight = yb(k.reliableMarginRight, function(e, t) { | |
| return t ? n.swap(e, { | |
| display: "inline-block" | |
| }, xb, [e, "marginRight"]) : void 0 | |
| }), | |
| n.each({ | |
| margin: "", | |
| padding: "", | |
| border: "Width" | |
| }, function(e, t) { | |
| n.cssHooks[e + t] = { | |
| expand: function(n) { | |
| for (var r = 0, i = {}, s = "string" == typeof n ? n.split(" ") : [n]; 4 > r; r++) | |
| i[e + R[r] + t] = s[r] || s[r - 2] || s[0]; | |
| return i | |
| } | |
| }, | |
| ub.test(e) || (n.cssHooks[e + t].set = Gb) | |
| }), | |
| n.fn.extend({ | |
| css: function(e, t) { | |
| return J(this, function(e, t, r) { | |
| var i, s, o = {}, u = 0; | |
| if (n.isArray(t)) { | |
| for (i = wb(e), | |
| s = t.length; s > u; u++) | |
| o[t[u]] = n.css(e, t[u], !1, i); | |
| return o | |
| } | |
| return void 0 !== r ? n.style(e, t, r) : n.css(e, t) | |
| }, e, t, arguments.length > 1) | |
| }, | |
| show: function() { | |
| return Jb(this, !0) | |
| }, | |
| hide: function() { | |
| return Jb(this) | |
| }, | |
| toggle: function(e) { | |
| return "boolean" == typeof e ? e ? this.show() : this.hide() : this.each(function() { | |
| S(this) ? n(this).show() : n(this).hide() | |
| }) | |
| } | |
| }), | |
| n.Tween = Kb, | |
| Kb.prototype = { | |
| constructor: Kb, | |
| init: function(e, t, r, i, s, o) { | |
| this.elem = e, | |
| this.prop = r, | |
| this.easing = s || "swing", | |
| this.options = t, | |
| this.start = this.now = this.cur(), | |
| this.end = i, | |
| this.unit = o || (n.cssNumber[r] ? "" : "px") | |
| }, | |
| cur: function() { | |
| var e = Kb.propHooks[this.prop]; | |
| return e && e.get ? e.get(this) : Kb.propHooks._default.get(this) | |
| }, | |
| run: function(e) { | |
| var t, r = Kb.propHooks[this.prop]; | |
| return this.pos = t = this.options.duration ? n.easing[this.easing](e, this.options.duration * e, 0, 1, this.options.duration) : e, | |
| this.now = (this.end - this.start) * t + this.start, | |
| this.options.step && this.options.step.call(this.elem, this.now, this), | |
| r && r.set ? r.set(this) : Kb.propHooks._default.set(this), | |
| this | |
| } | |
| }, | |
| Kb.prototype.init.prototype = Kb.prototype, | |
| Kb.propHooks = { | |
| _default: { | |
| get: function(e) { | |
| var t; | |
| return null == e.elem[e.prop] || e.elem.style && null != e.elem.style[e.prop] ? (t = n.css(e.elem, e.prop, ""), | |
| t && "auto" !== t ? t : 0) : e.elem[e.prop] | |
| }, | |
| set: function(e) { | |
| n.fx.step[e.prop] ? n.fx.step[e.prop](e) : e.elem.style && (null != e.elem.style[n.cssProps[e.prop]] || n.cssHooks[e.prop]) ? n.style(e.elem, e.prop, e.now + e.unit) : e.elem[e.prop] = e.now | |
| } | |
| } | |
| }, | |
| Kb.propHooks.scrollTop = Kb.propHooks.scrollLeft = { | |
| set: function(e) { | |
| e.elem.nodeType && e.elem.parentNode && (e.elem[e.prop] = e.now) | |
| } | |
| }, | |
| n.easing = { | |
| linear: function(e) { | |
| return e | |
| }, | |
| swing: function(e) { | |
| return .5 - Math.cos(e * Math.PI) / 2 | |
| } | |
| }, | |
| n.fx = Kb.prototype.init, | |
| n.fx.step = {}; | |
| var Lb, Mb, Nb = /^(?:toggle|show|hide)$/, Ob = new RegExp("^(?:([+-])=|)(" + Q + ")([a-z%]*)$","i"), Pb = /queueHooks$/, Qb = [Vb], Rb = { | |
| "*": [function(e, t) { | |
| var r = this.createTween(e, t) | |
| , i = r.cur() | |
| , s = Ob.exec(t) | |
| , o = s && s[3] || (n.cssNumber[e] ? "" : "px") | |
| , u = (n.cssNumber[e] || "px" !== o && +i) && Ob.exec(n.css(r.elem, e)) | |
| , a = 1 | |
| , f = 20; | |
| if (u && u[3] !== o) { | |
| o = o || u[3], | |
| s = s || [], | |
| u = +i || 1; | |
| do | |
| a = a || ".5", | |
| u /= a, | |
| n.style(r.elem, e, u + o); | |
| while (a !== (a = r.cur() / i) && 1 !== a && --f) | |
| } | |
| return s && (u = r.start = +u || +i || 0, | |
| r.unit = o, | |
| r.end = s[1] ? u + (s[1] + 1) * s[2] : +s[2]), | |
| r | |
| } | |
| ] | |
| }; | |
| n.Animation = n.extend(Xb, { | |
| tweener: function(e, t) { | |
| n.isFunction(e) ? (t = e, | |
| e = ["*"]) : e = e.split(" "); | |
| for (var r, i = 0, s = e.length; s > i; i++) | |
| r = e[i], | |
| Rb[r] = Rb[r] || [], | |
| Rb[r].unshift(t) | |
| }, | |
| prefilter: function(e, t) { | |
| t ? Qb.unshift(e) : Qb.push(e) | |
| } | |
| }), | |
| n.speed = function(e, t, r) { | |
| var i = e && "object" == typeof e ? n.extend({}, e) : { | |
| complete: r || !r && t || n.isFunction(e) && e, | |
| duration: e, | |
| easing: r && t || t && !n.isFunction(t) && t | |
| }; | |
| return i.duration = n.fx.off ? 0 : "number" == typeof i.duration ? i.duration : i.duration in n.fx.speeds ? n.fx.speeds[i.duration] : n.fx.speeds._default, | |
| (null == i.queue || i.queue === !0) && (i.queue = "fx"), | |
| i.old = i.complete, | |
| i.complete = function() { | |
| n.isFunction(i.old) && i.old.call(this), | |
| i.queue && n.dequeue(this, i.queue) | |
| } | |
| , | |
| i | |
| } | |
| , | |
| n.fn.extend({ | |
| fadeTo: function(e, t, n, r) { | |
| return this.filter(S).css("opacity", 0).show().end().animate({ | |
| opacity: t | |
| }, e, n, r) | |
| }, | |
| animate: function(e, t, r, i) { | |
| var s = n.isEmptyObject(e) | |
| , o = n.speed(t, r, i) | |
| , u = function() { | |
| var t = Xb(this, n.extend({}, e), o); | |
| (s || L.get(this, "finish")) && t.stop(!0) | |
| }; | |
| return u.finish = u, | |
| s || o.queue === !1 ? this.each(u) : this.queue(o.queue, u) | |
| }, | |
| stop: function(e, t, r) { | |
| var i = function(e) { | |
| var t = e.stop; | |
| delete e.stop, | |
| t(r) | |
| }; | |
| return "string" != typeof e && (r = t, | |
| t = e, | |
| e = void 0), | |
| t && e !== !1 && this.queue(e || "fx", []), | |
| this.each(function() { | |
| var t = !0 | |
| , s = null != e && e + "queueHooks" | |
| , o = n.timers | |
| , u = L.get(this); | |
| if (s) | |
| u[s] && u[s].stop && i(u[s]); | |
| else | |
| for (s in u) | |
| u[s] && u[s].stop && Pb.test(s) && i(u[s]); | |
| for (s = o.length; s--; ) | |
| o[s].elem !== this || null != e && o[s].queue !== e || (o[s].anim.stop(r), | |
| t = !1, | |
| o.splice(s, 1)); | |
| (t || !r) && n.dequeue(this, e) | |
| }) | |
| }, | |
| finish: function(e) { | |
| return e !== !1 && (e = e || "fx"), | |
| this.each(function() { | |
| var t, r = L.get(this), i = r[e + "queue"], s = r[e + "queueHooks"], o = n.timers, u = i ? i.length : 0; | |
| for (r.finish = !0, | |
| n.queue(this, e, []), | |
| s && s.stop && s.stop.call(this, !0), | |
| t = o.length; t--; ) | |
| o[t].elem === this && o[t].queue === e && (o[t].anim.stop(!0), | |
| o.splice(t, 1)); | |
| for (t = 0; u > t; t++) | |
| i[t] && i[t].finish && i[t].finish.call(this); | |
| delete r.finish | |
| }) | |
| } | |
| }), | |
| n.each(["toggle", "show", "hide"], function(e, t) { | |
| var r = n.fn[t]; | |
| n.fn[t] = function(e, n, i) { | |
| return null == e || "boolean" == typeof e ? r.apply(this, arguments) : this.animate(Tb(t, !0), e, n, i) | |
| } | |
| }), | |
| n.each({ | |
| slideDown: Tb("show"), | |
| slideUp: Tb("hide"), | |
| slideToggle: Tb("toggle"), | |
| fadeIn: { | |
| opacity: "show" | |
| }, | |
| fadeOut: { | |
| opacity: "hide" | |
| }, | |
| fadeToggle: { | |
| opacity: "toggle" | |
| } | |
| }, function(e, t) { | |
| n.fn[e] = function(e, n, r) { | |
| return this.animate(t, e, n, r) | |
| } | |
| }), | |
| n.timers = [], | |
| n.fx.tick = function() { | |
| var e, t = 0, r = n.timers; | |
| for (Lb = n.now(); t < r.length; t++) | |
| e = r[t], | |
| e() || r[t] !== e || r.splice(t--, 1); | |
| r.length || n.fx.stop(), | |
| Lb = void 0 | |
| } | |
| , | |
| n.fx.timer = function(e) { | |
| n.timers.push(e), | |
| e() ? n.fx.start() : n.timers.pop() | |
| } | |
| , | |
| n.fx.interval = 13, | |
| n.fx.start = function() { | |
| Mb || (Mb = setInterval(n.fx.tick, n.fx.interval)) | |
| } | |
| , | |
| n.fx.stop = function() { | |
| clearInterval(Mb), | |
| Mb = null | |
| } | |
| , | |
| n.fx.speeds = { | |
| slow: 600, | |
| fast: 200, | |
| _default: 400 | |
| }, | |
| n.fn.delay = function(e, t) { | |
| return e = n.fx ? n.fx.speeds[e] || e : e, | |
| t = t || "fx", | |
| this.queue(t, function(t, n) { | |
| var r = setTimeout(t, e); | |
| n.stop = function() { | |
| clearTimeout(r) | |
| } | |
| }) | |
| } | |
| , | |
| function() { | |
| var e = l.createElement("input") | |
| , t = l.createElement("select") | |
| , n = t.appendChild(l.createElement("option")); | |
| e.type = "checkbox", | |
| k.checkOn = "" !== e.value, | |
| k.optSelected = n.selected, | |
| t.disabled = !0, | |
| k.optDisabled = !n.disabled, | |
| e = l.createElement("input"), | |
| e.value = "t", | |
| e.type = "radio", | |
| k.radioValue = "t" === e.value | |
| }(); | |
| var Yb, Zb, $b = n.expr.attrHandle; | |
| n.fn.extend({ | |
| attr: function(e, t) { | |
| return J(this, n.attr, e, t, arguments.length > 1) | |
| }, | |
| removeAttr: function(e) { | |
| return this.each(function() { | |
| n.removeAttr(this, e) | |
| }) | |
| } | |
| }), | |
| n.extend({ | |
| attr: function(e, t, r) { | |
| var i, s, o = e.nodeType; | |
| if (e && 3 !== o && 8 !== o && 2 !== o) | |
| return typeof e.getAttribute === U ? n.prop(e, t, r) : (1 === o && n.isXMLDoc(e) || (t = t.toLowerCase(), | |
| i = n.attrHooks[t] || (n.expr.match.bool.test(t) ? Zb : Yb)), | |
| void 0 === r ? i && "get"in i && null !== (s = i.get(e, t)) ? s : (s = n.find.attr(e, t), | |
| null == s ? void 0 : s) : null !== r ? i && "set"in i && void 0 !== (s = i.set(e, r, t)) ? s : (e.setAttribute(t, r + ""), | |
| r) : void n.removeAttr(e, t)) | |
| }, | |
| removeAttr: function(e, t) { | |
| var r, i, s = 0, o = t && t.match(E); | |
| if (o && 1 === e.nodeType) | |
| while (r = o[s++]) | |
| i = n.propFix[r] || r, | |
| n.expr.match.bool.test(r) && (e[i] = !1), | |
| e.removeAttribute(r) | |
| }, | |
| attrHooks: { | |
| type: { | |
| set: function(e, t) { | |
| if (!k.radioValue && "radio" === t && n.nodeName(e, "input")) { | |
| var r = e.value; | |
| return e.setAttribute("type", t), | |
| r && (e.value = r), | |
| t | |
| } | |
| } | |
| } | |
| } | |
| }), | |
| Zb = { | |
| set: function(e, t, r) { | |
| return t === !1 ? n.removeAttr(e, r) : e.setAttribute(r, r), | |
| r | |
| } | |
| }, | |
| n.each(n.expr.match.bool.source.match(/\w+/g), function(e, t) { | |
| var r = $b[t] || n.find.attr; | |
| $b[t] = function(e, t, n) { | |
| var i, s; | |
| return n || (s = $b[t], | |
| $b[t] = i, | |
| i = null != r(e, t, n) ? t.toLowerCase() : null, | |
| $b[t] = s), | |
| i | |
| } | |
| }); | |
| var _b = /^(?:input|select|textarea|button)$/i; | |
| n.fn.extend({ | |
| prop: function(e, t) { | |
| return J(this, n.prop, e, t, arguments.length > 1) | |
| }, | |
| removeProp: function(e) { | |
| return this.each(function() { | |
| delete this[n.propFix[e] || e] | |
| }) | |
| } | |
| }), | |
| n.extend({ | |
| propFix: { | |
| "for": "htmlFor", | |
| "class": "className" | |
| }, | |
| prop: function(e, t, r) { | |
| var i, s, o, u = e.nodeType; | |
| if (e && 3 !== u && 8 !== u && 2 !== u) | |
| return o = 1 !== u || !n.isXMLDoc(e), | |
| o && (t = n.propFix[t] || t, | |
| s = n.propHooks[t]), | |
| void 0 !== r ? s && "set"in s && void 0 !== (i = s.set(e, r, t)) ? i : e[t] = r : s && "get"in s && null !== (i = s.get(e, t)) ? i : e[t] | |
| }, | |
| propHooks: { | |
| tabIndex: { | |
| get: function(e) { | |
| return e.hasAttribute("tabindex") || _b.test(e.nodeName) || e.href ? e.tabIndex : -1 | |
| } | |
| } | |
| } | |
| }), | |
| k.optSelected || (n.propHooks.selected = { | |
| get: function(e) { | |
| var t = e.parentNode; | |
| return t && t.parentNode && t.parentNode.selectedIndex, | |
| null | |
| } | |
| }), | |
| n.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() { | |
| n.propFix[this.toLowerCase()] = this | |
| }); | |
| var ac = /[\t\r\n\f]/g; | |
| n.fn.extend({ | |
| addClass: function(e) { | |
| var t, r, i, s, o, u, a = "string" == typeof e && e, f = 0, l = this.length; | |
| if (n.isFunction(e)) | |
| return this.each(function(t) { | |
| n(this).addClass(e.call(this, t, this.className)) | |
| }); | |
| if (a) | |
| for (t = (e || "").match(E) || []; l > f; f++) | |
| if (r = this[f], | |
| i = 1 === r.nodeType && (r.className ? (" " + r.className + " ").replace(ac, " ") : " ")) { | |
| o = 0; | |
| while (s = t[o++]) | |
| i.indexOf(" " + s + " ") < 0 && (i += s + " "); | |
| u = n.trim(i), | |
| r.className !== u && (r.className = u) | |
| } | |
| return this | |
| }, | |
| removeClass: function(e) { | |
| var t, r, i, s, o, u, a = 0 === arguments.length || "string" == typeof e && e, f = 0, l = this.length; | |
| if (n.isFunction(e)) | |
| return this.each(function(t) { | |
| n(this).removeClass(e.call(this, t, this.className)) | |
| }); | |
| if (a) | |
| for (t = (e || "").match(E) || []; l > f; f++) | |
| if (r = this[f], | |
| i = 1 === r.nodeType && (r.className ? (" " + r.className + " ").replace(ac, " ") : "")) { | |
| o = 0; | |
| while (s = t[o++]) | |
| while (i.indexOf(" " + s + " ") >= 0) | |
| i = i.replace(" " + s + " ", " "); | |
| u = e ? n.trim(i) : "", | |
| r.className !== u && (r.className = u) | |
| } | |
| return this | |
| }, | |
| toggleClass: function(e, t) { | |
| var r = typeof e; | |
| return "boolean" == typeof t && "string" === r ? t ? this.addClass(e) : this.removeClass(e) : this.each(n.isFunction(e) ? function(r) { | |
| n(this).toggleClass(e.call(this, r, this.className, t), t) | |
| } | |
| : function() { | |
| if ("string" === r) { | |
| var t, i = 0, s = n(this), o = e.match(E) || []; | |
| while (t = o[i++]) | |
| s.hasClass(t) ? s.removeClass(t) : s.addClass(t) | |
| } else | |
| (r === U || "boolean" === r) && (this.className && L.set(this, "__className__", this.className), | |
| this.className = this.className || e === !1 ? "" : L.get(this, "__className__") || "") | |
| } | |
| ) | |
| }, | |
| hasClass: function(e) { | |
| for (var t = " " + e + " ", n = 0, r = this.length; r > n; n++) | |
| if (1 === this[n].nodeType && (" " + this[n].className + " ").replace(ac, " ").indexOf(t) >= 0) | |
| return !0; | |
| return !1 | |
| } | |
| }); | |
| var bc = /\r/g; | |
| n.fn.extend({ | |
| val: function(e) { | |
| var t, r, i, s = this[0]; | |
| if (arguments.length) | |
| return i = n.isFunction(e), | |
| this.each(function(r) { | |
| var s; | |
| 1 === this.nodeType && (s = i ? e.call(this, r, n(this).val()) : e, | |
| null == s ? s = "" : "number" == typeof s ? s += "" : n.isArray(s) && (s = n.map(s, function(e) { | |
| return null == e ? "" : e + "" | |
| })), | |
| t = n.valHooks[this.type] || n.valHooks[this.nodeName.toLowerCase()], | |
| t && "set"in t && void 0 !== t.set(this, s, "value") || (this.value = s)) | |
| }); | |
| if (s) | |
| return t = n.valHooks[s.type] || n.valHooks[s.nodeName.toLowerCase()], | |
| t && "get"in t && void 0 !== (r = t.get(s, "value")) ? r : (r = s.value, | |
| "string" == typeof r ? r.replace(bc, "") : null == r ? "" : r) | |
| } | |
| }), | |
| n.extend({ | |
| valHooks: { | |
| option: { | |
| get: function(e) { | |
| var t = n.find.attr(e, "value"); | |
| return null != t ? t : n.trim(n.text(e)) | |
| } | |
| }, | |
| select: { | |
| get: function(e) { | |
| for (var t, r, i = e.options, s = e.selectedIndex, o = "select-one" === e.type || 0 > s, u = o ? null : [], a = o ? s + 1 : i.length, f = 0 > s ? a : o ? s : 0; a > f; f++) | |
| if (r = i[f], | |
| !(!r.selected && f !== s || (k.optDisabled ? r.disabled : null !== r.getAttribute("disabled")) || r.parentNode.disabled && n.nodeName(r.parentNode, "optgroup"))) { | |
| if (t = n(r).val(), | |
| o) | |
| return t; | |
| u.push(t) | |
| } | |
| return u | |
| }, | |
| set: function(e, t) { | |
| var r, i, s = e.options, o = n.makeArray(t), u = s.length; | |
| while (u--) | |
| i = s[u], | |
| (i.selected = n.inArray(i.value, o) >= 0) && (r = !0); | |
| return r || (e.selectedIndex = -1), | |
| o | |
| } | |
| } | |
| } | |
| }), | |
| n.each(["radio", "checkbox"], function() { | |
| n.valHooks[this] = { | |
| set: function(e, t) { | |
| return n.isArray(t) ? e.checked = n.inArray(n(e).val(), t) >= 0 : void 0 | |
| } | |
| }, | |
| k.checkOn || (n.valHooks[this].get = function(e) { | |
| return null === e.getAttribute("value") ? "on" : e.value | |
| } | |
| ) | |
| }), | |
| n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "), function(e, t) { | |
| n.fn[t] = function(e, n) { | |
| return arguments.length > 0 ? this.on(t, null, e, n) : this.trigger(t) | |
| } | |
| }), | |
| n.fn.extend({ | |
| hover: function(e, t) { | |
| return this.mouseenter(e).mouseleave(t || e) | |
| }, | |
| bind: function(e, t, n) { | |
| return this.on(e, null, t, n) | |
| }, | |
| unbind: function(e, t) { | |
| return this.off(e, null, t) | |
| }, | |
| delegate: function(e, t, n, r) { | |
| return this.on(t, e, n, r) | |
| }, | |
| undelegate: function(e, t, n) { | |
| return 1 === arguments.length ? this.off(e, "**") : this.off(t, e || "**", n) | |
| } | |
| }); | |
| var cc = n.now() | |
| , dc = /\?/; | |
| n.parseJSON = function(e) { | |
| return JSON.parse(e + "") | |
| } | |
| , | |
| n.parseXML = function(e) { | |
| var t, r; | |
| if (!e || "string" != typeof e) | |
| return null; | |
| try { | |
| r = new DOMParser, | |
| t = r.parseFromString(e, "text/xml") | |
| } catch (i) { | |
| t = void 0 | |
| } | |
| return (!t || t.getElementsByTagName("parsererror").length) && n.error("Invalid XML: " + e), | |
| t | |
| } | |
| ; | |
| var ec, fc, gc = /#.*$/, hc = /([?&])_=[^&]*/, ic = /^(.*?):[ \t]*([^\r\n]*)$/gm, jc = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, kc = /^(?:GET|HEAD)$/, lc = /^\/\//, mc = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, nc = {}, oc = {}, pc = "*/".concat("*"); | |
| try { | |
| fc = location.href | |
| } catch (qc) { | |
| fc = l.createElement("a"), | |
| fc.href = "", | |
| fc = fc.href | |
| } | |
| ec = mc.exec(fc.toLowerCase()) || [], | |
| n.extend({ | |
| active: 0, | |
| lastModified: {}, | |
| etag: {}, | |
| ajaxSettings: { | |
| url: fc, | |
| type: "GET", | |
| isLocal: jc.test(ec[1]), | |
| global: !0, | |
| processData: !0, | |
| async: !0, | |
| contentType: "application/x-www-form-urlencoded; charset=UTF-8", | |
| accepts: { | |
| "*": pc, | |
| text: "text/plain", | |
| html: "text/html", | |
| xml: "application/xml, text/xml", | |
| json: "application/json, text/javascript" | |
| }, | |
| contents: { | |
| xml: /xml/, | |
| html: /html/, | |
| json: /json/ | |
| }, | |
| responseFields: { | |
| xml: "responseXML", | |
| text: "responseText", | |
| json: "responseJSON" | |
| }, | |
| converters: { | |
| "* text": String, | |
| "text html": !0, | |
| "text json": n.parseJSON, | |
| "text xml": n.parseXML | |
| }, | |
| flatOptions: { | |
| url: !0, | |
| context: !0 | |
| } | |
| }, | |
| ajaxSetup: function(e, t) { | |
| return t ? tc(tc(e, n.ajaxSettings), t) : tc(n.ajaxSettings, e) | |
| }, | |
| ajaxPrefilter: rc(nc), | |
| ajaxTransport: rc(oc), | |
| ajax: function(e, t) { | |
| function T(e, t, o, a) { | |
| var l, g, y, w, E, x = t; | |
| 2 !== b && (b = 2, | |
| u && clearTimeout(u), | |
| r = void 0, | |
| s = a || "", | |
| S.readyState = e > 0 ? 4 : 0, | |
| l = e >= 200 && 300 > e || 304 === e, | |
| o && (w = uc(c, S, o)), | |
| w = vc(c, w, S, l), | |
| l ? (c.ifModified && (E = S.getResponseHeader("Last-Modified"), | |
| E && (n.lastModified[i] = E), | |
| E = S.getResponseHeader("etag"), | |
| E && (n.etag[i] = E)), | |
| 204 === e || "HEAD" === c.type ? x = "nocontent" : 304 === e ? x = "notmodified" : (x = w.state, | |
| g = w.data, | |
| y = w.error, | |
| l = !y)) : (y = x, | |
| (e || !x) && (x = "error", | |
| 0 > e && (e = 0))), | |
| S.status = e, | |
| S.statusText = (t || x) + "", | |
| l ? d.resolveWith(h, [g, x, S]) : d.rejectWith(h, [S, x, y]), | |
| S.statusCode(m), | |
| m = void 0, | |
| f && p.trigger(l ? "ajaxSuccess" : "ajaxError", [S, c, l ? g : y]), | |
| v.fireWith(h, [S, x]), | |
| f && (p.trigger("ajaxComplete", [S, c]), | |
| --n.active || n.event.trigger("ajaxStop"))) | |
| } | |
| "object" == typeof e && (t = e, | |
| e = void 0), | |
| t = t || {}; | |
| var r, i, s, o, u, a, f, l, c = n.ajaxSetup({}, t), h = c.context || c, p = c.context && (h.nodeType || h.jquery) ? n(h) : n.event, d = n.Deferred(), v = n.Callbacks("once memory"), m = c.statusCode || {}, g = {}, y = {}, b = 0, w = "canceled", S = { | |
| readyState: 0, | |
| getResponseHeader: function(e) { | |
| var t; | |
| if (2 === b) { | |
| if (!o) { | |
| o = {}; | |
| while (t = ic.exec(s)) | |
| o[t[1].toLowerCase()] = t[2] | |
| } | |
| t = o[e.toLowerCase()] | |
| } | |
| return null == t ? null : t | |
| }, | |
| getAllResponseHeaders: function() { | |
| return 2 === b ? s : null | |
| }, | |
| setRequestHeader: function(e, t) { | |
| var n = e.toLowerCase(); | |
| return b || (e = y[n] = y[n] || e, | |
| g[e] = t), | |
| this | |
| }, | |
| overrideMimeType: function(e) { | |
| return b || (c.mimeType = e), | |
| this | |
| }, | |
| statusCode: function(e) { | |
| var t; | |
| if (e) | |
| if (2 > b) | |
| for (t in e) | |
| m[t] = [m[t], e[t]]; | |
| else | |
| S.always(e[S.status]); | |
| return this | |
| }, | |
| abort: function(e) { | |
| var t = e || w; | |
| return r && r.abort(t), | |
| T(0, t), | |
| this | |
| } | |
| }; | |
| if (d.promise(S).complete = v.add, | |
| S.success = S.done, | |
| S.error = S.fail, | |
| c.url = ((e || c.url || fc) + "").replace(gc, "").replace(lc, ec[1] + "//"), | |
| c.type = t.method || t.type || c.method || c.type, | |
| c.dataTypes = n.trim(c.dataType || "*").toLowerCase().match(E) || [""], | |
| null == c.crossDomain && (a = mc.exec(c.url.toLowerCase()), | |
| c.crossDomain = !(!a || a[1] === ec[1] && a[2] === ec[2] && (a[3] || ("http:" === a[1] ? "80" : "443")) === (ec[3] || ("http:" === ec[1] ? "80" : "443")))), | |
| c.data && c.processData && "string" != typeof c.data && (c.data = n.param(c.data, c.traditional)), | |
| sc(nc, c, t, S), | |
| 2 === b) | |
| return S; | |
| f = c.global, | |
| f && 0 === n.active++ && n.event.trigger("ajaxStart"), | |
| c.type = c.type.toUpperCase(), | |
| c.hasContent = !kc.test(c.type), | |
| i = c.url, | |
| c.hasContent || (c.data && (i = c.url += (dc.test(i) ? "&" : "?") + c.data, | |
| delete c.data), | |
| c.cache === !1 && (c.url = hc.test(i) ? i.replace(hc, "$1_=" + cc++) : i + (dc.test(i) ? "&" : "?") + "_=" + cc++)), | |
| c.ifModified && (n.lastModified[i] && S.setRequestHeader("If-Modified-Since", n.lastModified[i]), | |
| n.etag[i] && S.setRequestHeader("If-None-Match", n.etag[i])), | |
| (c.data && c.hasContent && c.contentType !== !1 || t.contentType) && S.setRequestHeader("Content-Type", c.contentType), | |
| S.setRequestHeader("Accept", c.dataTypes[0] && c.accepts[c.dataTypes[0]] ? c.accepts[c.dataTypes[0]] + ("*" !== c.dataTypes[0] ? ", " + pc + "; q=0.01" : "") : c.accepts["*"]); | |
| for (l in c.headers) | |
| S.setRequestHeader(l, c.headers[l]); | |
| if (!c.beforeSend || c.beforeSend.call(h, S, c) !== !1 && 2 !== b) { | |
| w = "abort"; | |
| for (l in { | |
| success: 1, | |
| error: 1, | |
| complete: 1 | |
| }) | |
| S[l](c[l]); | |
| if (r = sc(oc, c, t, S)) { | |
| S.readyState = 1, | |
| f && p.trigger("ajaxSend", [S, c]), | |
| c.async && c.timeout > 0 && (u = setTimeout(function() { | |
| S.abort("timeout") | |
| }, c.timeout)); | |
| try { | |
| b = 1, | |
| r.send(g, T) | |
| } catch (x) { | |
| if (!(2 > b)) | |
| throw x; | |
| T(-1, x) | |
| } | |
| } else | |
| T(-1, "No Transport"); | |
| return S | |
| } | |
| return S.abort() | |
| }, | |
| getJSON: function(e, t, r) { | |
| return n.get(e, t, r, "json") | |
| }, | |
| getScript: function(e, t) { | |
| return n.get(e, void 0, t, "script") | |
| } | |
| }), | |
| n.each(["get", "post"], function(e, t) { | |
| n[t] = function(e, r, i, s) { | |
| return n.isFunction(r) && (s = s || i, | |
| i = r, | |
| r = void 0), | |
| n.ajax({ | |
| url: e, | |
| type: t, | |
| dataType: s, | |
| data: r, | |
| success: i | |
| }) | |
| } | |
| }), | |
| n.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(e, t) { | |
| n.fn[t] = function(e) { | |
| return this.on(t, e) | |
| } | |
| }), | |
| n._evalUrl = function(e) { | |
| return n.ajax({ | |
| url: e, | |
| type: "GET", | |
| dataType: "script", | |
| async: !1, | |
| global: !1, | |
| "throws": !0 | |
| }) | |
| } | |
| , | |
| n.fn.extend({ | |
| wrapAll: function(e) { | |
| var t; | |
| return n.isFunction(e) ? this.each(function(t) { | |
| n(this).wrapAll(e.call(this, t)) | |
| }) : (this[0] && (t = n(e, this[0].ownerDocument).eq(0).clone(!0), | |
| this[0].parentNode && t.insertBefore(this[0]), | |
| t.map(function() { | |
| var e = this; | |
| while (e.firstElementChild) | |
| e = e.firstElementChild; | |
| return e | |
| }).append(this)), | |
| this) | |
| }, | |
| wrapInner: function(e) { | |
| return this.each(n.isFunction(e) ? function(t) { | |
| n(this).wrapInner(e.call(this, t)) | |
| } | |
| : function() { | |
| var t = n(this) | |
| , r = t.contents(); | |
| r.length ? r.wrapAll(e) : t.append(e) | |
| } | |
| ) | |
| }, | |
| wrap: function(e) { | |
| var t = n.isFunction(e); | |
| return this.each(function(r) { | |
| n(this).wrapAll(t ? e.call(this, r) : e) | |
| }) | |
| }, | |
| unwrap: function() { | |
| return this.parent().each(function() { | |
| n.nodeName(this, "body") || n(this).replaceWith(this.childNodes) | |
| }).end() | |
| } | |
| }), | |
| n.expr.filters.hidden = function(e) { | |
| return e.offsetWidth <= 0 && e.offsetHeight <= 0 | |
| } | |
| , | |
| n.expr.filters.visible = function(e) { | |
| return !n.expr.filters.hidden(e) | |
| } | |
| ; | |
| var wc = /%20/g | |
| , xc = /\[\]$/ | |
| , yc = /\r?\n/g | |
| , zc = /^(?:submit|button|image|reset|file)$/i | |
| , Ac = /^(?:input|select|textarea|keygen)/i; | |
| n.param = function(e, t) { | |
| var r, i = [], s = function(e, t) { | |
| t = n.isFunction(t) ? t() : null == t ? "" : t, | |
| i[i.length] = encodeURIComponent(e) + "=" + encodeURIComponent(t) | |
| }; | |
| if (void 0 === t && (t = n.ajaxSettings && n.ajaxSettings.traditional), | |
| n.isArray(e) || e.jquery && !n.isPlainObject(e)) | |
| n.each(e, function() { | |
| s(this.name, this.value) | |
| }); | |
| else | |
| for (r in e) | |
| Bc(r, e[r], t, s); | |
| return i.join("&").replace(wc, "+") | |
| } | |
| , | |
| n.fn.extend({ | |
| serialize: function() { | |
| return n.param(this.serializeArray()) | |
| }, | |
| serializeArray: function() { | |
| return this.map(function() { | |
| var e = n.prop(this, "elements"); | |
| return e ? n.makeArray(e) : this | |
| }).filter(function() { | |
| var e = this.type; | |
| return this.name && !n(this).is(":disabled") && Ac.test(this.nodeName) && !zc.test(e) && (this.checked || !T.test(e)) | |
| }).map(function(e, t) { | |
| var r = n(this).val(); | |
| return null == r ? null : n.isArray(r) ? n.map(r, function(e) { | |
| return { | |
| name: t.name, | |
| value: e.replace(yc, "\r\n") | |
| } | |
| }) : { | |
| name: t.name, | |
| value: r.replace(yc, "\r\n") | |
| } | |
| }).get() | |
| } | |
| }), | |
| n.ajaxSettings.xhr = function() { | |
| try { | |
| return new XMLHttpRequest | |
| } catch (e) {} | |
| } | |
| ; | |
| var Cc = 0 | |
| , Dc = {} | |
| , Ec = { | |
| 0: 200, | |
| 1223: 204 | |
| } | |
| , Fc = n.ajaxSettings.xhr(); | |
| a.ActiveXObject && n(a).on("unload", function() { | |
| for (var e in Dc) | |
| Dc[e]() | |
| }), | |
| k.cors = !!Fc && "withCredentials"in Fc, | |
| k.ajax = Fc = !!Fc, | |
| n.ajaxTransport(function(e) { | |
| var t; | |
| return k.cors || Fc && !e.crossDomain ? { | |
| send: function(n, r) { | |
| var i, s = e.xhr(), o = ++Cc; | |
| if (s.open(e.type, e.url, e.async, e.username, e.password), | |
| e.xhrFields) | |
| for (i in e.xhrFields) | |
| s[i] = e.xhrFields[i]; | |
| e.mimeType && s.overrideMimeType && s.overrideMimeType(e.mimeType), | |
| e.crossDomain || n["X-Requested-With"] || (n["X-Requested-With"] = "XMLHttpRequest"); | |
| for (i in n) | |
| s.setRequestHeader(i, n[i]); | |
| t = function(e) { | |
| return function() { | |
| t && (delete Dc[o], | |
| t = s.onload = s.onerror = null, | |
| "abort" === e ? s.abort() : "error" === e ? r(s.status, s.statusText) : r(Ec[s.status] || s.status, s.statusText, "string" == typeof s.responseText ? { | |
| text: s.responseText | |
| } : void 0, s.getAllResponseHeaders())) | |
| } | |
| } | |
| , | |
| s.onload = t(), | |
| s.onerror = t("error"), | |
| t = Dc[o] = t("abort"); | |
| try { | |
| s.send(e.hasContent && e.data || null) | |
| } catch (u) { | |
| if (t) | |
| throw u | |
| } | |
| }, | |
| abort: function() { | |
| t && t() | |
| } | |
| } : void 0 | |
| }), | |
| n.ajaxSetup({ | |
| accepts: { | |
| script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript" | |
| }, | |
| contents: { | |
| script: /(?:java|ecma)script/ | |
| }, | |
| converters: { | |
| "text script": function(e) { | |
| return n.globalEval(e), | |
| e | |
| } | |
| } | |
| }), | |
| n.ajaxPrefilter("script", function(e) { | |
| void 0 === e.cache && (e.cache = !1), | |
| e.crossDomain && (e.type = "GET") | |
| }), | |
| n.ajaxTransport("script", function(e) { | |
| if (e.crossDomain) { | |
| var t, r; | |
| return { | |
| send: function(i, s) { | |
| t = n("<script>").prop({ | |
| async: !0, | |
| charset: e.scriptCharset, | |
| src: e.url | |
| }).on("load error", r = function(e) { | |
| t.remove(), | |
| r = null, | |
| e && s("error" === e.type ? 404 : 200, e.type) | |
| } | |
| ), | |
| l.head.appendChild(t[0]) | |
| }, | |
| abort: function() { | |
| r && r() | |
| } | |
| } | |
| } | |
| }); | |
| var Gc = [] | |
| , Hc = /(=)\?(?=&|$)|\?\?/; | |
| n.ajaxSetup({ | |
| jsonp: "callback", | |
| jsonpCallback: function() { | |
| var e = Gc.pop() || n.expando + "_" + cc++; | |
| return this[e] = !0, | |
| e | |
| } | |
| }), | |
| n.ajaxPrefilter("json jsonp", function(e, t, r) { | |
| var i, s, o, u = e.jsonp !== !1 && (Hc.test(e.url) ? "url" : "string" == typeof e.data && !(e.contentType || "").indexOf("application/x-www-form-urlencoded") && Hc.test(e.data) && "data"); | |
| return u || "jsonp" === e.dataTypes[0] ? (i = e.jsonpCallback = n.isFunction(e.jsonpCallback) ? e.jsonpCallback() : e.jsonpCallback, | |
| u ? e[u] = e[u].replace(Hc, "$1" + i) : e.jsonp !== !1 && (e.url += (dc.test(e.url) ? "&" : "?") + e.jsonp + "=" + i), | |
| e.converters["script json"] = function() { | |
| return o || n.error(i + " was not called"), | |
| o[0] | |
| } | |
| , | |
| e.dataTypes[0] = "json", | |
| s = a[i], | |
| a[i] = function() { | |
| o = arguments | |
| } | |
| , | |
| r.always(function() { | |
| a[i] = s, | |
| e[i] && (e.jsonpCallback = t.jsonpCallback, | |
| Gc.push(i)), | |
| o && n.isFunction(s) && s(o[0]), | |
| o = s = void 0 | |
| }), | |
| "script") : void 0 | |
| }), | |
| n.parseHTML = function(e, t, r) { | |
| if (!e || "string" != typeof e) | |
| return null; | |
| "boolean" == typeof t && (r = t, | |
| t = !1), | |
| t = t || l; | |
| var i = v.exec(e) | |
| , s = !r && []; | |
| return i ? [t.createElement(i[1])] : (i = n.buildFragment([e], t, s), | |
| s && s.length && n(s).remove(), | |
| n.merge([], i.childNodes)) | |
| } | |
| ; | |
| var Ic = n.fn.load; | |
| n.fn.load = function(e, t, r) { | |
| if ("string" != typeof e && Ic) | |
| return Ic.apply(this, arguments); | |
| var i, s, o, u = this, a = e.indexOf(" "); | |
| return a >= 0 && (i = n.trim(e.slice(a)), | |
| e = e.slice(0, a)), | |
| n.isFunction(t) ? (r = t, | |
| t = void 0) : t && "object" == typeof t && (s = "POST"), | |
| u.length > 0 && n.ajax({ | |
| url: e, | |
| type: s, | |
| dataType: "html", | |
| data: t | |
| }).done(function(e) { | |
| o = arguments, | |
| u.html(i ? n("<div>").append(n.parseHTML(e)).find(i) : e) | |
| }).complete(r && function(e, t) { | |
| u.each(r, o || [e.responseText, t, e]) | |
| } | |
| ), | |
| this | |
| } | |
| , | |
| n.expr.filters.animated = function(e) { | |
| return n.grep(n.timers, function(t) { | |
| return e === t.elem | |
| }).length | |
| } | |
| ; | |
| var Jc = a.document.documentElement; | |
| n.offset = { | |
| setOffset: function(e, t, r) { | |
| var i, s, o, u, a, f, l, c = n.css(e, "position"), h = n(e), p = {}; | |
| "static" === c && (e.style.position = "relative"), | |
| a = h.offset(), | |
| o = n.css(e, "top"), | |
| f = n.css(e, "left"), | |
| l = ("absolute" === c || "fixed" === c) && (o + f).indexOf("auto") > -1, | |
| l ? (i = h.position(), | |
| u = i.top, | |
| s = i.left) : (u = parseFloat(o) || 0, | |
| s = parseFloat(f) || 0), | |
| n.isFunction(t) && (t = t.call(e, r, a)), | |
| null != t.top && (p.top = t.top - a.top + u), | |
| null != t.left && (p.left = t.left - a.left + s), | |
| "using"in t ? t.using.call(e, p) : h.css(p) | |
| } | |
| }, | |
| n.fn.extend({ | |
| offset: function(e) { | |
| if (arguments.length) | |
| return void 0 === e ? this : this.each(function(t) { | |
| n.offset.setOffset(this, e, t) | |
| }); | |
| var t, r, i = this[0], s = { | |
| top: 0, | |
| left: 0 | |
| }, o = i && i.ownerDocument; | |
| if (o) | |
| return t = o.documentElement, | |
| n.contains(t, i) ? (typeof i.getBoundingClientRect !== U && (s = i.getBoundingClientRect()), | |
| r = Kc(o), | |
| { | |
| top: s.top + r.pageYOffset - t.clientTop, | |
| left: s.left + r.pageXOffset - t.clientLeft | |
| }) : s | |
| }, | |
| position: function() { | |
| if (this[0]) { | |
| var e, t, r = this[0], i = { | |
| top: 0, | |
| left: 0 | |
| }; | |
| return "fixed" === n.css(r, "position") ? t = r.getBoundingClientRect() : (e = this.offsetParent(), | |
| t = this.offset(), | |
| n.nodeName(e[0], "html") || (i = e.offset()), | |
| i.top += n.css(e[0], "borderTopWidth", !0), | |
| i.left += n.css(e[0], "borderLeftWidth", !0)), | |
| { | |
| top: t.top - i.top - n.css(r, "marginTop", !0), | |
| left: t.left - i.left - n.css(r, "marginLeft", !0) | |
| } | |
| } | |
| }, | |
| offsetParent: function() { | |
| return this.map(function() { | |
| var e = this.offsetParent || Jc; | |
| while (e && !n.nodeName(e, "html") && "static" === n.css(e, "position")) | |
| e = e.offsetParent; | |
| return e || Jc | |
| }) | |
| } | |
| }), | |
| n.each({ | |
| scrollLeft: "pageXOffset", | |
| scrollTop: "pageYOffset" | |
| }, function(e, t) { | |
| var r = "pageYOffset" === t; | |
| n.fn[e] = function(n) { | |
| return J(this, function(e, n, i) { | |
| var s = Kc(e); | |
| return void 0 === i ? s ? s[t] : e[n] : void (s ? s.scrollTo(r ? a.pageXOffset : i, r ? i : a.pageYOffset) : e[n] = i) | |
| }, e, n, arguments.length, null) | |
| } | |
| }), | |
| n.each(["top", "left"], function(e, t) { | |
| n.cssHooks[t] = yb(k.pixelPosition, function(e, r) { | |
| return r ? (r = xb(e, t), | |
| vb.test(r) ? n(e).position()[t] + "px" : r) : void 0 | |
| }) | |
| }), | |
| n.each({ | |
| Height: "height", | |
| Width: "width" | |
| }, function(e, t) { | |
| n.each({ | |
| padding: "inner" + e, | |
| content: t, | |
| "": "outer" + e | |
| }, function(r, i) { | |
| n.fn[i] = function(i, s) { | |
| var o = arguments.length && (r || "boolean" != typeof i) | |
| , u = r || (i === !0 || s === !0 ? "margin" : "border"); | |
| return J(this, function(t, r, i) { | |
| var s; | |
| return n.isWindow(t) ? t.document.documentElement["client" + e] : 9 === t.nodeType ? (s = t.documentElement, | |
| Math.max(t.body["scroll" + e], s["scroll" + e], t.body["offset" + e], s["offset" + e], s["client" + e])) : void 0 === i ? n.css(t, r, u) : n.style(t, r, i, u) | |
| }, t, o ? i : void 0, o, null) | |
| } | |
| }) | |
| }), | |
| n.fn.size = function() { | |
| return this.length | |
| } | |
| , | |
| n.fn.andSelf = n.fn.addBack, | |
| "function" == typeof define && define.amd && define("jquery", [], function() { | |
| return n | |
| }); | |
| var Lc = a.jQuery | |
| , Mc = a.$; | |
| return n.noConflict = function(e) { | |
| return a.$ === n && (a.$ = Mc), | |
| e && a.jQuery === n && (a.jQuery = Lc), | |
| n | |
| } | |
| , | |
| typeof b === U && (a.jQuery = a.$ = n), | |
| n | |
| }), | |
| function() { | |
| var e = this | |
| , t = e._ | |
| , n = Array.prototype | |
| , r = Object.prototype | |
| , i = Function.prototype | |
| , s = n.push | |
| , o = n.slice | |
| , u = n.concat | |
| , a = r.toString | |
| , f = r.hasOwnProperty | |
| , l = Array.isArray | |
| , c = Object.keys | |
| , h = i.bind | |
| , p = function(e) { | |
| return e instanceof p ? e : this instanceof p ? void (this._wrapped = e) : new p(e) | |
| }; | |
| "undefined" != typeof exports ? ("undefined" != typeof module && module.exports && (exports = module.exports = p), | |
| exports._ = p) : e._ = p, | |
| p.VERSION = "1.7.0"; | |
| var d = function(e, t, n) { | |
| if (t === void 0) | |
| return e; | |
| switch (null == n ? 3 : n) { | |
| case 1: | |
| return function(n) { | |
| return e.call(t, n) | |
| } | |
| ; | |
| case 2: | |
| return function(n, r) { | |
| return e.call(t, n, r) | |
| } | |
| ; | |
| case 3: | |
| return function(n, r, i) { | |
| return e.call(t, n, r, i) | |
| } | |
| ; | |
| case 4: | |
| return function(n, r, i, s) { | |
| return e.call(t, n, r, i, s) | |
| } | |
| } | |
| return function() { | |
| return e.apply(t, arguments) | |
| } | |
| }; | |
| p.iteratee = function(e, t, n) { | |
| return null == e ? p.identity : p.isFunction(e) ? d(e, t, n) : p.isObject(e) ? p.matches(e) : p.property(e) | |
| } | |
| , | |
| p.each = p.forEach = function(e, t, n) { | |
| if (null == e) | |
| return e; | |
| t = d(t, n); | |
| var r, i = e.length; | |
| if (i === +i) | |
| for (r = 0; i > r; r++) | |
| t(e[r], r, e); | |
| else { | |
| var s = p.keys(e); | |
| for (r = 0, | |
| i = s.length; i > r; r++) | |
| t(e[s[r]], s[r], e) | |
| } | |
| return e | |
| } | |
| , | |
| p.map = p.collect = function(e, t, n) { | |
| if (null == e) | |
| return []; | |
| t = p.iteratee(t, n); | |
| for (var r, i = e.length !== +e.length && p.keys(e), s = (i || e).length, o = Array(s), u = 0; s > u; u++) | |
| r = i ? i[u] : u, | |
| o[u] = t(e[r], r, e); | |
| return o | |
| } | |
| ; | |
| var v = "Reduce of empty array with no initial value"; | |
| p.reduce = p.foldl = p.inject = function(e, t, n, r) { | |
| null == e && (e = []), | |
| t = d(t, r, 4); | |
| var i, s = e.length !== +e.length && p.keys(e), o = (s || e).length, u = 0; | |
| if (arguments.length < 3) { | |
| if (!o) | |
| throw new TypeError(v); | |
| n = e[s ? s[u++] : u++] | |
| } | |
| for (; o > u; u++) | |
| i = s ? s[u] : u, | |
| n = t(n, e[i], i, e); | |
| return n | |
| } | |
| , | |
| p.reduceRight = p.foldr = function(e, t, n, r) { | |
| null == e && (e = []), | |
| t = d(t, r, 4); | |
| var i, s = e.length !== +e.length && p.keys(e), o = (s || e).length; | |
| if (arguments.length < 3) { | |
| if (!o) | |
| throw new TypeError(v); | |
| n = e[s ? s[--o] : --o] | |
| } | |
| for (; o--; ) | |
| i = s ? s[o] : o, | |
| n = t(n, e[i], i, e); | |
| return n | |
| } | |
| , | |
| p.find = p.detect = function(e, t, n) { | |
| var r; | |
| return t = p.iteratee(t, n), | |
| p.some(e, function(e, n, i) { | |
| return t(e, n, i) ? (r = e, | |
| !0) : void 0 | |
| }), | |
| r | |
| } | |
| , | |
| p.filter = p.select = function(e, t, n) { | |
| var r = []; | |
| return null == e ? r : (t = p.iteratee(t, n), | |
| p.each(e, function(e, n, i) { | |
| t(e, n, i) && r.push(e) | |
| }), | |
| r) | |
| } | |
| , | |
| p.reject = function(e, t, n) { | |
| return p.filter(e, p.negate(p.iteratee(t)), n) | |
| } | |
| , | |
| p.every = p.all = function(e, t, n) { | |
| if (null == e) | |
| return !0; | |
| t = p.iteratee(t, n); | |
| var r, i, s = e.length !== +e.length && p.keys(e), o = (s || e).length; | |
| for (r = 0; o > r; r++) | |
| if (i = s ? s[r] : r, | |
| !t(e[i], i, e)) | |
| return !1; | |
| return !0 | |
| } | |
| , | |
| p.some = p.any = function(e, t, n) { | |
| if (null == e) | |
| return !1; | |
| t = p.iteratee(t, n); | |
| var r, i, s = e.length !== +e.length && p.keys(e), o = (s || e).length; | |
| for (r = 0; o > r; r++) | |
| if (i = s ? s[r] : r, | |
| t(e[i], i, e)) | |
| return !0; | |
| return !1 | |
| } | |
| , | |
| p.contains = p.include = function(e, t) { | |
| return null == e ? !1 : (e.length !== +e.length && (e = p.values(e)), | |
| p.indexOf(e, t) >= 0) | |
| } | |
| , | |
| p.invoke = function(e, t) { | |
| var n = o.call(arguments, 2) | |
| , r = p.isFunction(t); | |
| return p.map(e, function(e) { | |
| return (r ? t : e[t]).apply(e, n) | |
| }) | |
| } | |
| , | |
| p.pluck = function(e, t) { | |
| return p.map(e, p.property(t)) | |
| } | |
| , | |
| p.where = function(e, t) { | |
| return p.filter(e, p.matches(t)) | |
| } | |
| , | |
| p.findWhere = function(e, t) { | |
| return p.find(e, p.matches(t)) | |
| } | |
| , | |
| p.max = function(e, t, n) { | |
| var r, i, s = -1 / 0, o = -1 / 0; | |
| if (null == t && null != e) { | |
| e = e.length === +e.length ? e : p.values(e); | |
| for (var u = 0, a = e.length; a > u; u++) | |
| r = e[u], | |
| r > s && (s = r) | |
| } else | |
| t = p.iteratee(t, n), | |
| p.each(e, function(e, n, r) { | |
| i = t(e, n, r), | |
| (i > o || i === -1 / 0 && s === -1 / 0) && (s = e, | |
| o = i) | |
| }); | |
| return s | |
| } | |
| , | |
| p.min = function(e, t, n) { | |
| var r, i, s = 1 / 0, o = 1 / 0; | |
| if (null == t && null != e) { | |
| e = e.length === +e.length ? e : p.values(e); | |
| for (var u = 0, a = e.length; a > u; u++) | |
| r = e[u], | |
| s > r && (s = r) | |
| } else | |
| t = p.iteratee(t, n), | |
| p.each(e, function(e, n, r) { | |
| i = t(e, n, r), | |
| (o > i || 1 / 0 === i && 1 / 0 === s) && (s = e, | |
| o = i) | |
| }); | |
| return s | |
| } | |
| , | |
| p.shuffle = function(e) { | |
| for (var t, n = e && e.length === +e.length ? e : p.values(e), r = n.length, i = Array(r), s = 0; r > s; s++) | |
| t = p.random(0, s), | |
| t !== s && (i[s] = i[t]), | |
| i[t] = n[s]; | |
| return i | |
| } | |
| , | |
| p.sample = function(e, t, n) { | |
| return null == t || n ? (e.length !== +e.length && (e = p.values(e)), | |
| e[p.random(e.length - 1)]) : p.shuffle(e).slice(0, Math.max(0, t)) | |
| } | |
| , | |
| p.sortBy = function(e, t, n) { | |
| return t = p.iteratee(t, n), | |
| p.pluck(p.map(e, function(e, n, r) { | |
| return { | |
| value: e, | |
| index: n, | |
| criteria: t(e, n, r) | |
| } | |
| }).sort(function(e, t) { | |
| var n = e.criteria | |
| , r = t.criteria; | |
| if (n !== r) { | |
| if (n > r || n === void 0) | |
| return 1; | |
| if (r > n || r === void 0) | |
| return -1 | |
| } | |
| return e.index - t.index | |
| }), "value") | |
| } | |
| ; | |
| var m = function(e) { | |
| return function(t, n, r) { | |
| var i = {}; | |
| return n = p.iteratee(n, r), | |
| p.each(t, function(r, s) { | |
| var o = n(r, s, t); | |
| e(i, r, o) | |
| }), | |
| i | |
| } | |
| }; | |
| p.groupBy = m(function(e, t, n) { | |
| p.has(e, n) ? e[n].push(t) : e[n] = [t] | |
| }), | |
| p.indexBy = m(function(e, t, n) { | |
| e[n] = t | |
| }), | |
| p.countBy = m(function(e, t, n) { | |
| p.has(e, n) ? e[n]++ : e[n] = 1 | |
| }), | |
| p.sortedIndex = function(e, t, n, r) { | |
| n = p.iteratee(n, r, 1); | |
| for (var i = n(t), s = 0, o = e.length; o > s; ) { | |
| var u = s + o >>> 1; | |
| n(e[u]) < i ? s = u + 1 : o = u | |
| } | |
| return s | |
| } | |
| , | |
| p.toArray = function(e) { | |
| return e ? p.isArray(e) ? o.call(e) : e.length === +e.length ? p.map(e, p.identity) : p.values(e) : [] | |
| } | |
| , | |
| p.size = function(e) { | |
| return null == e ? 0 : e.length === +e.length ? e.length : p.keys(e).length | |
| } | |
| , | |
| p.partition = function(e, t, n) { | |
| t = p.iteratee(t, n); | |
| var r = [] | |
| , i = []; | |
| return p.each(e, function(e, n, s) { | |
| (t(e, n, s) ? r : i).push(e) | |
| }), | |
| [r, i] | |
| } | |
| , | |
| p.first = p.head = p.take = function(e, t, n) { | |
| return null == e ? void 0 : null == t || n ? e[0] : 0 > t ? [] : o.call(e, 0, t) | |
| } | |
| , | |
| p.initial = function(e, t, n) { | |
| return o.call(e, 0, Math.max(0, e.length - (null == t || n ? 1 : t))) | |
| } | |
| , | |
| p.last = function(e, t, n) { | |
| return null == e ? void 0 : null == t || n ? e[e.length - 1] : o.call(e, Math.max(e.length - t, 0)) | |
| } | |
| , | |
| p.rest = p.tail = p.drop = function(e, t, n) { | |
| return o.call(e, null == t || n ? 1 : t) | |
| } | |
| , | |
| p.compact = function(e) { | |
| return p.filter(e, p.identity) | |
| } | |
| ; | |
| var g = function(e, t, n, r) { | |
| if (t && p.every(e, p.isArray)) | |
| return u.apply(r, e); | |
| for (var i = 0, o = e.length; o > i; i++) { | |
| var a = e[i]; | |
| p.isArray(a) || p.isArguments(a) ? t ? s.apply(r, a) : g(a, t, n, r) : n || r.push(a) | |
| } | |
| return r | |
| }; | |
| p.flatten = function(e, t) { | |
| return g(e, t, !1, []) | |
| } | |
| , | |
| p.without = function(e) { | |
| return p.difference(e, o.call(arguments, 1)) | |
| } | |
| , | |
| p.uniq = p.unique = function(e, t, n, r) { | |
| if (null == e) | |
| return []; | |
| p.isBoolean(t) || (r = n, | |
| n = t, | |
| t = !1), | |
| null != n && (n = p.iteratee(n, r)); | |
| for (var i = [], s = [], o = 0, u = e.length; u > o; o++) { | |
| var a = e[o]; | |
| if (t) | |
| o && s === a || i.push(a), | |
| s = a; | |
| else if (n) { | |
| var f = n(a, o, e); | |
| p.indexOf(s, f) < 0 && (s.push(f), | |
| i.push(a)) | |
| } else | |
| p.indexOf(i, a) < 0 && i.push(a) | |
| } | |
| return i | |
| } | |
| , | |
| p.union = function() { | |
| return p.uniq(g(arguments, !0, !0, [])) | |
| } | |
| , | |
| p.intersection = function(e) { | |
| if (null == e) | |
| return []; | |
| for (var t = [], n = arguments.length, r = 0, i = e.length; i > r; r++) { | |
| var s = e[r]; | |
| if (!p.contains(t, s)) { | |
| for (var o = 1; n > o && p.contains(arguments[o], s); o++) | |
| ; | |
| o === n && t.push(s) | |
| } | |
| } | |
| return t | |
| } | |
| , | |
| p.difference = function(e) { | |
| var t = g(o.call(arguments, 1), !0, !0, []); | |
| return p.filter(e, function(e) { | |
| return !p.contains(t, e) | |
| }) | |
| } | |
| , | |
| p.zip = function(e) { | |
| if (null == e) | |
| return []; | |
| for (var t = p.max(arguments, "length").length, n = Array(t), r = 0; t > r; r++) | |
| n[r] = p.pluck(arguments, r); | |
| return n | |
| } | |
| , | |
| p.object = function(e, t) { | |
| if (null == e) | |
| return {}; | |
| for (var n = {}, r = 0, i = e.length; i > r; r++) | |
| t ? n[e[r]] = t[r] : n[e[r][0]] = e[r][1]; | |
| return n | |
| } | |
| , | |
| p.indexOf = function(e, t, n) { | |
| if (null == e) | |
| return -1; | |
| var r = 0 | |
| , i = e.length; | |
| if (n) { | |
| if ("number" != typeof n) | |
| return r = p.sortedIndex(e, t), | |
| e[r] === t ? r : -1; | |
| r = 0 > n ? Math.max(0, i + n) : n | |
| } | |
| for (; i > r; r++) | |
| if (e[r] === t) | |
| return r; | |
| return -1 | |
| } | |
| , | |
| p.lastIndexOf = function(e, t, n) { | |
| if (null == e) | |
| return -1; | |
| var r = e.length; | |
| for ("number" == typeof n && (r = 0 > n ? r + n + 1 : Math.min(r, n + 1)); --r >= 0; ) | |
| if (e[r] === t) | |
| return r; | |
| return -1 | |
| } | |
| , | |
| p.range = function(e, t, n) { | |
| arguments.length <= 1 && (t = e || 0, | |
| e = 0), | |
| n = n || 1; | |
| for (var r = Math.max(Math.ceil((t - e) / n), 0), i = Array(r), s = 0; r > s; s++, | |
| e += n) | |
| i[s] = e; | |
| return i | |
| } | |
| ; | |
| var y = function() {}; | |
| p.bind = function(e, t) { | |
| var n, r; | |
| if (h && e.bind === h) | |
| return h.apply(e, o.call(arguments, 1)); | |
| if (!p.isFunction(e)) | |
| throw new TypeError("Bind must be called on a function"); | |
| return n = o.call(arguments, 2), | |
| r = function() { | |
| if (this instanceof r) { | |
| y.prototype = e.prototype; | |
| var i = new y; | |
| y.prototype = null; | |
| var s = e.apply(i, n.concat(o.call(arguments))); | |
| return p.isObject(s) ? s : i | |
| } | |
| return e.apply(t, n.concat(o.call(arguments))) | |
| } | |
| } | |
| , | |
| p.partial = function(e) { | |
| var t = o.call(arguments, 1); | |
| return function() { | |
| for (var n = 0, r = t.slice(), i = 0, s = r.length; s > i; i++) | |
| r[i] === p && (r[i] = arguments[n++]); | |
| for (; n < arguments.length; ) | |
| r.push(arguments[n++]); | |
| return e.apply(this, r) | |
| } | |
| } | |
| , | |
| p.bindAll = function(e) { | |
| var t, n, r = arguments.length; | |
| if (1 >= r) | |
| throw new Error("bindAll must be passed function names"); | |
| for (t = 1; r > t; t++) | |
| n = arguments[t], | |
| e[n] = p.bind(e[n], e); | |
| return e | |
| } | |
| , | |
| p.memoize = function(e, t) { | |
| var n = function(r) { | |
| var i = n.cache | |
| , s = t ? t.apply(this, arguments) : r; | |
| return p.has(i, s) || (i[s] = e.apply(this, arguments)), | |
| i[s] | |
| }; | |
| return n.cache = {}, | |
| n | |
| } | |
| , | |
| p.delay = function(e, t) { | |
| var n = o.call(arguments, 2); | |
| return setTimeout(function() { | |
| return e.apply(null, n) | |
| }, t) | |
| } | |
| , | |
| p.defer = function(e) { | |
| return p.delay.apply(p, [e, 1].concat(o.call(arguments, 1))) | |
| } | |
| , | |
| p.throttle = function(e, t, n) { | |
| var r, i, s, o = null, u = 0; | |
| n || (n = {}); | |
| var a = function() { | |
| u = n.leading === !1 ? 0 : p.now(), | |
| o = null, | |
| s = e.apply(r, i), | |
| o || (r = i = null) | |
| }; | |
| return function() { | |
| var f = p.now(); | |
| u || n.leading !== !1 || (u = f); | |
| var l = t - (f - u); | |
| return r = this, | |
| i = arguments, | |
| 0 >= l || l > t ? (clearTimeout(o), | |
| o = null, | |
| u = f, | |
| s = e.apply(r, i), | |
| o || (r = i = null)) : o || n.trailing === !1 || (o = setTimeout(a, l)), | |
| s | |
| } | |
| } | |
| , | |
| p.debounce = function(e, t, n) { | |
| var r, i, s, o, u, a = function() { | |
| var f = p.now() - o; | |
| t > f && f > 0 ? r = setTimeout(a, t - f) : (r = null, | |
| n || (u = e.apply(s, i), | |
| r || (s = i = null))) | |
| }; | |
| return function() { | |
| s = this, | |
| i = arguments, | |
| o = p.now(); | |
| var f = n && !r; | |
| return r || (r = setTimeout(a, t)), | |
| f && (u = e.apply(s, i), | |
| s = i = null), | |
| u | |
| } | |
| } | |
| , | |
| p.wrap = function(e, t) { | |
| return p.partial(t, e) | |
| } | |
| , | |
| p.negate = function(e) { | |
| return function() { | |
| return !e.apply(this, arguments) | |
| } | |
| } | |
| , | |
| p.compose = function() { | |
| var e = arguments | |
| , t = e.length - 1; | |
| return function() { | |
| for (var n = t, r = e[t].apply(this, arguments); n--; ) | |
| r = e[n].call(this, r); | |
| return r | |
| } | |
| } | |
| , | |
| p.after = function(e, t) { | |
| return function() { | |
| return --e < 1 ? t.apply(this, arguments) : void 0 | |
| } | |
| } | |
| , | |
| p.before = function(e, t) { | |
| var n; | |
| return function() { | |
| return --e > 0 ? n = t.apply(this, arguments) : t = null, | |
| n | |
| } | |
| } | |
| , | |
| p.once = p.partial(p.before, 2), | |
| p.keys = function(e) { | |
| if (!p.isObject(e)) | |
| return []; | |
| if (c) | |
| return c(e); | |
| var t = []; | |
| for (var n in e) | |
| p.has(e, n) && t.push(n); | |
| return t | |
| } | |
| , | |
| p.values = function(e) { | |
| for (var t = p.keys(e), n = t.length, r = Array(n), i = 0; n > i; i++) | |
| r[i] = e[t[i]]; | |
| return r | |
| } | |
| , | |
| p.pairs = function(e) { | |
| for (var t = p.keys(e), n = t.length, r = Array(n), i = 0; n > i; i++) | |
| r[i] = [t[i], e[t[i]]]; | |
| return r | |
| } | |
| , | |
| p.invert = function(e) { | |
| for (var t = {}, n = p.keys(e), r = 0, i = n.length; i > r; r++) | |
| t[e[n[r]]] = n[r]; | |
| return t | |
| } | |
| , | |
| p.functions = p.methods = function(e) { | |
| var t = []; | |
| for (var n in e) | |
| p.isFunction(e[n]) && t.push(n); | |
| return t.sort() | |
| } | |
| , | |
| p.extend = function(e) { | |
| if (!p.isObject(e)) | |
| return e; | |
| for (var t, n, r = 1, i = arguments.length; i > r; r++) { | |
| t = arguments[r]; | |
| for (n in t) | |
| f.call(t, n) && (e[n] = t[n]) | |
| } | |
| return e | |
| } | |
| , | |
| p.pick = function(e, t, n) { | |
| var r, i = {}; | |
| if (null == e) | |
| return i; | |
| if (p.isFunction(t)) { | |
| t = d(t, n); | |
| for (r in e) { | |
| var s = e[r]; | |
| t(s, r, e) && (i[r] = s) | |
| } | |
| } else { | |
| var a = u.apply([], o.call(arguments, 1)); | |
| e = new Object(e); | |
| for (var f = 0, l = a.length; l > f; f++) | |
| r = a[f], | |
| r in e && (i[r] = e[r]) | |
| } | |
| return i | |
| } | |
| , | |
| p.omit = function(e, t, n) { | |
| if (p.isFunction(t)) | |
| t = p.negate(t); | |
| else { | |
| var r = p.map(u.apply([], o.call(arguments, 1)), String); | |
| t = function(e, t) { | |
| return !p.contains(r, t) | |
| } | |
| } | |
| return p.pick(e, t, n) | |
| } | |
| , | |
| p.defaults = function(e) { | |
| if (!p.isObject(e)) | |
| return e; | |
| for (var t = 1, n = arguments.length; n > t; t++) { | |
| var r = arguments[t]; | |
| for (var i in r) | |
| e[i] === void 0 && (e[i] = r[i]) | |
| } | |
| return e | |
| } | |
| , | |
| p.clone = function(e) { | |
| return p.isObject(e) ? p.isArray(e) ? e.slice() : p.extend({}, e) : e | |
| } | |
| , | |
| p.tap = function(e, t) { | |
| return t(e), | |
| e | |
| } | |
| ; | |
| var b = function(e, t, n, r) { | |
| if (e === t) | |
| return 0 !== e || 1 / e === 1 / t; | |
| if (null == e || null == t) | |
| return e === t; | |
| e instanceof p && (e = e._wrapped), | |
| t instanceof p && (t = t._wrapped); | |
| var i = a.call(e); | |
| if (i !== a.call(t)) | |
| return !1; | |
| switch (i) { | |
| case "[object RegExp]": | |
| case "[object String]": | |
| return "" + e == "" + t; | |
| case "[object Number]": | |
| return +e !== +e ? +t !== +t : 0 === +e ? 1 / +e === 1 / t : +e === +t; | |
| case "[object Date]": | |
| case "[object Boolean]": | |
| return +e === +t | |
| } | |
| if ("object" != typeof e || "object" != typeof t) | |
| return !1; | |
| for (var s = n.length; s--; ) | |
| if (n[s] === e) | |
| return r[s] === t; | |
| var o = e.constructor | |
| , u = t.constructor; | |
| if (o !== u && "constructor"in e && "constructor"in t && !(p.isFunction(o) && o instanceof o && p.isFunction(u) && u instanceof u)) | |
| return !1; | |
| n.push(e), | |
| r.push(t); | |
| var f, l; | |
| if ("[object Array]" === i) { | |
| if (f = e.length, | |
| l = f === t.length) | |
| for (; f-- && (l = b(e[f], t[f], n, r)); ) | |
| ; | |
| } else { | |
| var c, h = p.keys(e); | |
| if (f = h.length, | |
| l = p.keys(t).length === f) | |
| for (; f-- && (c = h[f], | |
| l = p.has(t, c) && b(e[c], t[c], n, r)); ) | |
| ; | |
| } | |
| return n.pop(), | |
| r.pop(), | |
| l | |
| }; | |
| p.isEqual = function(e, t) { | |
| return b(e, t, [], []) | |
| } | |
| , | |
| p.isEmpty = function(e) { | |
| if (null == e) | |
| return !0; | |
| if (p.isArray(e) || p.isString(e) || p.isArguments(e)) | |
| return 0 === e.length; | |
| for (var t in e) | |
| if (p.has(e, t)) | |
| return !1; | |
| return !0 | |
| } | |
| , | |
| p.isElement = function(e) { | |
| return !!e && 1 === e.nodeType | |
| } | |
| , | |
| p.isArray = l || function(e) { | |
| return "[object Array]" === a.call(e) | |
| } | |
| , | |
| p.isObject = function(e) { | |
| var t = typeof e; | |
| return "function" === t || "object" === t && !!e | |
| } | |
| , | |
| p.each(["Arguments", "Function", "String", "Number", "Date", "RegExp"], function(e) { | |
| p["is" + e] = function(t) { | |
| return a.call(t) === "[object " + e + "]" | |
| } | |
| }), | |
| p.isArguments(arguments) || (p.isArguments = function(e) { | |
| return p.has(e, "callee") | |
| } | |
| ), | |
| "function" != typeof /./ && (p.isFunction = function(e) { | |
| return "function" == typeof e || !1 | |
| } | |
| ), | |
| p.isFinite = function(e) { | |
| return isFinite(e) && !isNaN(parseFloat(e)) | |
| } | |
| , | |
| p.isNaN = function(e) { | |
| return p.isNumber(e) && e !== +e | |
| } | |
| , | |
| p.isBoolean = function(e) { | |
| return e === !0 || e === !1 || "[object Boolean]" === a.call(e) | |
| } | |
| , | |
| p.isNull = function(e) { | |
| return null === e | |
| } | |
| , | |
| p.isUndefined = function(e) { | |
| return e === void 0 | |
| } | |
| , | |
| p.has = function(e, t) { | |
| return null != e && f.call(e, t) | |
| } | |
| , | |
| p.noConflict = function() { | |
| return e._ = t, | |
| this | |
| } | |
| , | |
| p.identity = function(e) { | |
| return e | |
| } | |
| , | |
| p.constant = function(e) { | |
| return function() { | |
| return e | |
| } | |
| } | |
| , | |
| p.noop = function() {} | |
| , | |
| p.property = function(e) { | |
| return function(t) { | |
| return t[e] | |
| } | |
| } | |
| , | |
| p.matches = function(e) { | |
| var t = p.pairs(e) | |
| , n = t.length; | |
| return function(e) { | |
| if (null == e) | |
| return !n; | |
| e = new Object(e); | |
| for (var r = 0; n > r; r++) { | |
| var i = t[r] | |
| , s = i[0]; | |
| if (i[1] !== e[s] || !(s in e)) | |
| return !1 | |
| } | |
| return !0 | |
| } | |
| } | |
| , | |
| p.times = function(e, t, n) { | |
| var r = Array(Math.max(0, e)); | |
| t = d(t, n, 1); | |
| for (var i = 0; e > i; i++) | |
| r[i] = t(i); | |
| return r | |
| } | |
| , | |
| p.random = function(e, t) { | |
| return null == t && (t = e, | |
| e = 0), | |
| e + Math.floor(Math.random() * (t - e + 1)) | |
| } | |
| , | |
| p.now = Date.now || function() { | |
| return (new Date).getTime() | |
| } | |
| ; | |
| var w = { | |
| "&": "&", | |
| "<": "<", | |
| ">": ">", | |
| '"': """, | |
| "'": "'", | |
| "`": "`" | |
| } | |
| , E = p.invert(w) | |
| , S = function(e) { | |
| var t = function(t) { | |
| return e[t] | |
| } | |
| , n = "(?:" + p.keys(e).join("|") + ")" | |
| , r = RegExp(n) | |
| , i = RegExp(n, "g"); | |
| return function(e) { | |
| return e = null == e ? "" : "" + e, | |
| r.test(e) ? e.replace(i, t) : e | |
| } | |
| }; | |
| p.escape = S(w), | |
| p.unescape = S(E), | |
| p.result = function(e, t) { | |
| if (null == e) | |
| return void 0; | |
| var n = e[t]; | |
| return p.isFunction(n) ? e[t]() : n | |
| } | |
| ; | |
| var x = 0; | |
| p.uniqueId = function(e) { | |
| var t = ++x + ""; | |
| return e ? e + t : t | |
| } | |
| , | |
| p.templateSettings = { | |
| evaluate: /<%([\s\S]+?)%>/g, | |
| interpolate: /<%=([\s\S]+?)%>/g, | |
| escape: /<%-([\s\S]+?)%>/g | |
| }; | |
| var T = /(.)^/ | |
| , N = { | |
| "'": "'", | |
| "\\": "\\", | |
| "\r": "r", | |
| "\n": "n", | |
| "\u2028": "u2028", | |
| "\u2029": "u2029" | |
| } | |
| , C = /\\|'|\r|\n|\u2028|\u2029/g | |
| , k = function(e) { | |
| return "\\" + N[e] | |
| }; | |
| p.template = function(e, t, n) { | |
| !t && n && (t = n), | |
| t = p.defaults({}, t, p.templateSettings); | |
| var r = RegExp([(t.escape || T).source, (t.interpolate || T).source, (t.evaluate || T).source].join("|") + "|$", "g") | |
| , i = 0 | |
| , s = "__p+='"; | |
| e.replace(r, function(t, n, r, o, u) { | |
| return s += e.slice(i, u).replace(C, k), | |
| i = u + t.length, | |
| n ? s += "'+\n((__t=(" + n + "))==null?'':_.escape(__t))+\n'" : r ? s += "'+\n((__t=(" + r + "))==null?'':__t)+\n'" : o && (s += "';\n" + o + "\n__p+='"), | |
| t | |
| }), | |
| s += "';\n", | |
| t.variable || (s = "with(obj||{}){\n" + s + "}\n"), | |
| s = "var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n" + s + "return __p;\n"; | |
| try { | |
| var o = new Function(t.variable || "obj","_",s) | |
| } catch (u) { | |
| throw u.source = s, | |
| u | |
| } | |
| var a = function(e) { | |
| return o.call(this, e, p) | |
| } | |
| , f = t.variable || "obj"; | |
| return a.source = "function(" + f + "){\n" + s + "}", | |
| a | |
| } | |
| , | |
| p.chain = function(e) { | |
| var t = p(e); | |
| return t._chain = !0, | |
| t | |
| } | |
| ; | |
| var L = function(e) { | |
| return this._chain ? p(e).chain() : e | |
| }; | |
| p.mixin = function(e) { | |
| p.each(p.functions(e), function(t) { | |
| var n = p[t] = e[t]; | |
| p.prototype[t] = function() { | |
| var e = [this._wrapped]; | |
| return s.apply(e, arguments), | |
| L.call(this, n.apply(p, e)) | |
| } | |
| }) | |
| } | |
| , | |
| p.mixin(p), | |
| p.each(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(e) { | |
| var t = n[e]; | |
| p.prototype[e] = function() { | |
| var n = this._wrapped; | |
| return t.apply(n, arguments), | |
| "shift" !== e && "splice" !== e || 0 !== n.length || delete n[0], | |
| L.call(this, n) | |
| } | |
| }), | |
| p.each(["concat", "join", "slice"], function(e) { | |
| var t = n[e]; | |
| p.prototype[e] = function() { | |
| return L.call(this, t.apply(this._wrapped, arguments)) | |
| } | |
| }), | |
| p.prototype.value = function() { | |
| return this._wrapped | |
| } | |
| , | |
| "function" == typeof define && define.amd && define("underscore", [], function() { | |
| return p | |
| }) | |
| } | |
| .call(this), | |
| function(e, t) { | |
| typeof define == "function" && define.amd ? define(["exports", "underscore", "jquery"], function(n, r, i) { | |
| t(e, n, r, i) | |
| }) : typeof exports != "undefined" ? t(e, exports, require("underscore"), require("jquery")) : t(e, e.S || {}, e._, e.$) | |
| }(this, function(e, t, n, r) { | |
| var i = function(e, t) { | |
| var r = this, i; | |
| e && n.has(e, "constructor") ? i = e.constructor : i = function() { | |
| return r.apply(this, arguments) | |
| } | |
| , | |
| n.extend(i, r, t); | |
| var s = function() { | |
| this.constructor = i | |
| }; | |
| return s.prototype = r.prototype, | |
| i.prototype = new s, | |
| e && n.extend(i.prototype, e), | |
| i.__super__ = r.prototype, | |
| i | |
| }; | |
| e.S = t, | |
| t.version = "1.0"; | |
| var s = t.Core = function() { | |
| this._cid = "p" + s.unique("p"); | |
| for (var e in this) | |
| typeof this[e] == "object" && !(e in this.constructor._shareProps) && (this[e] = s.deepClone(this[e])) | |
| } | |
| ; | |
| n.extend(s, { | |
| _unique: {}, | |
| _mergeProps: [], | |
| _shareProps: [], | |
| extend: function(e, t) { | |
| var r = i.apply(this, arguments); | |
| e || (e = {}), | |
| r._mergeProps || (r._mergeProps = this._mergeProps), | |
| r._shareProps || (r._shareProps = this._shareProps); | |
| for (var s = 0, o = r._mergeProps.length; s < o; ++s) { | |
| var u = r._mergeProps[s]; | |
| if (u in e) | |
| if (n.isArray(this.prototype[u])) | |
| Array.prototype.unshift.apply(r.prototype[u], this.prototype[u]); | |
| else | |
| for (var a in this.prototype[u]) | |
| a in r.prototype[u] || (r.prototype[u][a] = this.prototype[u][a]) | |
| } | |
| e = r.prototype; | |
| if ("events"in e) { | |
| e._events = n.extend({}, e._events); | |
| for (var f in e._events) | |
| e._events[f] = e._events[f].slice(); | |
| e.on.call(e, e.events), | |
| delete e.events | |
| } | |
| return r | |
| }, | |
| stub: function() {}, | |
| unique: function(e) { | |
| return this._unique[e] = 1 + (this._unique[e] || 0) | |
| }, | |
| picker: function(e, t) { | |
| return t = s.toArray(t), | |
| function(r) { | |
| if (n.isObject(r) && e in r) | |
| return typeof r[e] == "function" ? r[e].apply(r, t) : r[e] | |
| } | |
| }, | |
| expandFunc: function(e, t) { | |
| if (typeof e == "string") { | |
| var r = e.split(/([.-].*)/); | |
| return r.length > 1 ? s.masker(r[0], r[1], t) : function() { | |
| var n = t || this; | |
| return n[e].apply(n, arguments) | |
| } | |
| } | |
| return t ? n.bind(e, t) : e | |
| }, | |
| masker: function(e, t, r, i) { | |
| var s = typeof e == "string" | |
| , o = typeof t == "number" || t == null; | |
| return t == null && (t = 1), | |
| i || (i = []), | |
| o || (t = t.replace(/\./g, function(e, t) { | |
| return t > 8 ? "-" : t + 1 | |
| }).replace(/[^1-9.\-]+/g, "-").replace(/-+$/, "")), | |
| function() { | |
| var u = r || this | |
| , a = o ? i.concat(n.rest(arguments, t)) : i.concat(); | |
| for (var f = 0; f < t.length; f++) | |
| t[f] != "-" && a.push(arguments[t[f] - 1]); | |
| return (s ? u[e] : e).apply(u, a) | |
| } | |
| }, | |
| deepClone: function(e) { | |
| if (e && typeof e == "object") | |
| if (n.isArray(e)) | |
| e = n.map(e.slice(), arguments.callee); | |
| else { | |
| e = n.extend({}, e); | |
| for (var t in e) | |
| e[t] = arguments.callee(e[t]) | |
| } | |
| return e | |
| }, | |
| parseEvent: function(e) { | |
| var t = e.match(/^([+\-=]?)([\w\d.:]+?)(_*)$/); | |
| if (!t) | |
| throw "parseEvent: " + e; | |
| return { | |
| prefix: t[1], | |
| name: t[2], | |
| args: t[3] | |
| } | |
| }, | |
| fire: function(e, t) { | |
| var r; | |
| return e && (t = arguments.length < 2 ? [] : s.toArray(t), | |
| n.each(e.concat(), function(e) { | |
| if ("args"in e && e.args != t.length) | |
| var n = e.sup ? e.sup(e.cx || this, t) : undefined; | |
| else { | |
| if (!e.sup && !e.res) | |
| var i = t; | |
| else { | |
| var i = t.slice(); | |
| e.sup && i.unshift(e.sup), | |
| e.res && i.unshift(r) | |
| } | |
| var n = e.func.apply(e.cx || this, i) | |
| } | |
| e.ret && n !== undefined && (r = n) | |
| }, this)), | |
| r | |
| }, | |
| toArray: function(e) { | |
| return n.isArguments(e) ? Array.prototype.slice.call(e) : n.isArray(e) ? e : [e] | |
| }, | |
| is$: function(e) { | |
| return e instanceof r || r.zepto && r.zepto.isZ(e) | |
| } | |
| }), | |
| n.extend(s.prototype, { | |
| _cid: "", | |
| _events: {}, | |
| _eventsByID: {}, | |
| _eventsByCx: [], | |
| _autoOff: [], | |
| _logEventID: null, | |
| fire: function(e, t) { | |
| if (this._events.all && e != "all") { | |
| var n = arguments.length < 2 ? [] : s.toArray(t).concat(); | |
| n.unshift(e); | |
| var r = s.fire.call(this, this._events.all, n); | |
| if (r !== undefined) | |
| return r | |
| } | |
| return s.fire.call(this, this._events[e], t) | |
| }, | |
| firer: function(e, t, n) { | |
| return arguments.length > 1 ? (t = s.toArray(t), | |
| function() { | |
| return (n || this).fire(e, t.concat(Array.prototype.slice.call(arguments))) | |
| } | |
| ) : function() { | |
| return (n || this).fire(e, arguments) | |
| } | |
| }, | |
| logEvents: function(e) { | |
| if (typeof e == "string") { | |
| var t = this._cid; | |
| return this.el && (t += " " + this.el[0].tagName + "." + this.el[0].className.replace(/ /g, ".")), | |
| console.log(e + " (" + (arguments.length - 1) + ") on " + t), | |
| undefined | |
| } | |
| return !e && arguments.length ? (this.off(this._logEventID), | |
| this._logEventID = null) : console && console.log && !this._logEventID && (this._logEventID = this.on("all", arguments.callee)), | |
| this | |
| }, | |
| on: function(e, t, n) { | |
| if (typeof e == "object") { | |
| for (var r in e) { | |
| var i = r.split(", "); | |
| for (var s = 0, o = i.length; s < o; ++s) | |
| this.fuse(i[s], e[r], t) | |
| } | |
| return this | |
| } | |
| if (arguments.length >= 2) | |
| return this._regHandler(this.fuse(e, t, n)); | |
| throw "on" | |
| }, | |
| once: function(e, t, n) { | |
| if (arguments.length >= 2) { | |
| var r = this.on(e, function() { | |
| if (r) | |
| return this.off(r), | |
| r = null, | |
| s.expandFunc(t, this).apply(n || this, arguments) | |
| }); | |
| return r | |
| } | |
| throw "once" | |
| }, | |
| autoOff: function(e, t, r) { | |
| if (arguments.length < 1) { | |
| var i = this._autoOff; | |
| return this._autoOff = [], | |
| n.invoke(i, "off", this), | |
| this | |
| } | |
| this._autoOff.push(e), | |
| arguments.length > 2 || (r = this); | |
| for (var s in t) { | |
| var o = s.split(", "); | |
| for (var u = 0, a = o.length; u < a; ++u) | |
| e.on(o[u], t[s], r) | |
| } | |
| return e | |
| }, | |
| fuse: function(e, t, r) { | |
| t = s.expandFunc(t), | |
| e = s.parseEvent(e); | |
| var i = this._events[e.name] || (this._events[e.name] = []); | |
| this._wrapHandler(e.name); | |
| var o = { | |
| func: t, | |
| cx: r, | |
| event: e.name | |
| }; | |
| return e.args && (o.args = e.args.length), | |
| e.prefix == "+" ? o.res = o.ret = !0 : e.prefix == "=" && (o.ret = !0, | |
| o.supList = i.splice(0, i.length), | |
| o.sup = function(e, t) { | |
| return n.isArguments(t) && t[0] === arguments.callee && (t = Array.prototype.slice.call(t, 1)), | |
| s.fire.call(e, o.supList, t) | |
| } | |
| ), | |
| e.prefix == "-" ? i.unshift(o) : i.push(o), | |
| o | |
| }, | |
| _wrapHandler: function(e) { | |
| if (this[e] !== s.stub) | |
| if (typeof this[e] == "function" && !this[e]._wrapHandler) | |
| this._events[e].unshift({ | |
| func: this[e], | |
| ret: !0 | |
| }); | |
| else if (e in this) | |
| return; | |
| this[e] = this.firer(e), | |
| this[e]._wrapHandler = !0 | |
| }, | |
| _regHandler: function(e) { | |
| var t = e.id = e.event + "/" + s.unique("e"); | |
| return this._eventsByID[t] = e, | |
| e.cx && (this._cxHandlers(e.cx, function(t) { | |
| t.push(e) | |
| }) || this._eventsByCx.push([e.cx, e])), | |
| t | |
| }, | |
| _cxHandlers: function(e, t) { | |
| if (e) | |
| for (var n = 0, r = this._eventsByCx.length; n < r; ++n) | |
| if (this._eventsByCx[n][0] === e) | |
| return t.call(this, this._eventsByCx[n], n) || !0 | |
| }, | |
| off: function(e) { | |
| if (arguments.length < 1) | |
| throw "off"; | |
| return n.isArray(e) ? n.each(e, this.off, this) : typeof e == "object" ? this._cxHandlers(e, function(e, t) { | |
| n.each(this._eventsByCx.splice(t, 1)[0].slice(1), this._unregHandler, this) | |
| }) : e.indexOf("/") == -1 ? n.each(this._events[e], this._unregHandler, this) : this._unregHandler(this._eventsByID[e]), | |
| this | |
| }, | |
| _unregHandler: function(e) { | |
| if (e && e.id) { | |
| delete this._eventsByID[e.id], | |
| e.func = s.stub, | |
| this._cxHandlers(e.cx, function(t, n) { | |
| t.splice(t.indexOf(e), 1), | |
| t.length || this._eventsByCx.splice(n, 1) | |
| }); | |
| var t = (this._events[e.event] || []).indexOf(e); | |
| if (t >= 0) { | |
| var r = [t, 1]; | |
| n.each(e.supList, function(e) { | |
| e.func === s.stub || r.push(e) | |
| }), | |
| Array.prototype.splice.apply(this._events[e.event], r) | |
| } | |
| } | |
| } | |
| }); | |
| var o = t.S = s.extend({ | |
| _opt: {}, | |
| _firingSet: null, | |
| _parent: null, | |
| _parentKey: null, | |
| _children: {}, | |
| _owning: !0, | |
| _childClass: o, | |
| _childEvents: [], | |
| _respToOpt: {}, | |
| el: { | |
| tag: "div", | |
| className: "" | |
| }, | |
| elEvents: {}, | |
| length: 0, | |
| constructor: function(e) { | |
| o.__super__.constructor.apply(this, arguments), | |
| this.init.apply(this, arguments), | |
| this.postInit.apply(this, arguments) | |
| }, | |
| init: function(e) { | |
| e && e.el && (this.el = e.el); | |
| if (this.el && !s.is$(this.el)) | |
| if (n.isElement(this.el) || typeof this.el == "string") | |
| this.el = r(this.el); | |
| else { | |
| var t = n.omit(this.el, "tag", "className"); | |
| t["class"] = this.el.className || "", | |
| this.el = r(document.createElement(this.el.tag || "div")).attr(t).data("s", this) | |
| } | |
| if (this.el && !this.el.length) | |
| throw "init"; | |
| for (var i in e) | |
| i == "el" || this.set(i, e[i]) | |
| }, | |
| postInit: s.stub, | |
| render: function() { | |
| return this.invoke("attach"), | |
| this | |
| }, | |
| attach: function(e) { | |
| e = arguments.length ? r(e) : []; | |
| if (!e[0]) { | |
| var t = this.get("attachPath"); | |
| t && (e = this._parent ? this._parent.$(t) : r(t)) | |
| } | |
| e[0] && e[0] !== this.el[0].parentNode && (e.append(this.el), | |
| this.invoke("attach")); | |
| if (this.el) { | |
| var i = ".s-" + this._cid; | |
| this.el.off(i), | |
| n.each(this.elEvents, function(e, t) { | |
| e = s.expandFunc(e, this), | |
| t = t.match(/^\s*(\S+)( .*)?$/), | |
| t[1] += i, | |
| t[2] ? this.el.on(t[1], t[2], e) : this.el.on(t[1], e) | |
| }, this) | |
| } | |
| return this | |
| }, | |
| get: function(e) { | |
| return arguments.length ? this._opt[e] : n.clone(this._opt) | |
| }, | |
| set: function(e, t, n) { | |
| return this.ifSet(e, t, n), | |
| this | |
| }, | |
| ifSet: function(e, t, r) { | |
| r || (r = {}); | |
| var i = this._opt[e] | |
| , s = "normalize_" + e; | |
| this[s] && (t = this[s](t, r)), | |
| this._opt[e] = t; | |
| if (r.forceFire || !n.isEqual(t, i)) | |
| return this._fireSet([e, [t, i, r]]), | |
| !0 | |
| }, | |
| _fireSet: function(e) { | |
| if (this._firingSet == null) { | |
| var t = this._firingSet = [e]; | |
| try { | |
| while (e = t.shift()) | |
| this.fire("change_" + e[0], e[1]), | |
| this.fire("change", [e[0]].concat(e[1])); | |
| this._firingSet = null | |
| } catch (n) { | |
| throw this._firingSet = null, | |
| n | |
| } | |
| } else | |
| this._firingSet.push(e) | |
| }, | |
| nest: function(e, t, n) { | |
| arguments.length == 1 && (t = e, | |
| e = this._defaultKey(t)); | |
| if (e == null || typeof e == "object") | |
| throw "nest"; | |
| n || (n = {}), | |
| e += ""; | |
| var r = this._children[e]; | |
| if (t instanceof this._childClass) | |
| return r !== t && (this._owning ? (r && r.unnest(), | |
| t.unnest(), | |
| this._children[e] = t, | |
| t._parent = this, | |
| t._parentKey = e) : this._children[e] = t, | |
| ++this.length, | |
| this._forward(".", this._childEvents, t), | |
| this._owning && t.owned()), | |
| t; | |
| throw "nest" | |
| }, | |
| _defaultKey: function(e) { | |
| return e._cid | |
| }, | |
| owned: s.stub, | |
| _forward: function(e, t, r) { | |
| return n.each([].concat(t), function(t) { | |
| var n = e + s.parseEvent(t).name; | |
| r.on(t, function() { | |
| var e = Array.prototype.slice.call(arguments); | |
| return e.unshift(r), | |
| this.fire(n, e) | |
| }, this) | |
| }, this), | |
| r | |
| }, | |
| unlist: function(e) { | |
| var t; | |
| if (typeof e == "object") { | |
| for (var n in this._children) | |
| if (this._children[n] === e) { | |
| t = e, | |
| e = n; | |
| break | |
| } | |
| } else | |
| t = this._children[e + ""]; | |
| return t && (this._owning ? t.remove() : (delete this._children[e + ""], | |
| --this.length, | |
| this.unnested(t))), | |
| t | |
| }, | |
| unnest: function() { | |
| var e = this._parent; | |
| return e && (delete e._children[this._parentKey], | |
| this._parent = this._parentKey = null, | |
| --e.length, | |
| e.unnested(this)), | |
| this | |
| }, | |
| unnested: function(e) { | |
| e.off(this), | |
| this.length < 0 && console && console.error && console.error("unnested") | |
| }, | |
| nested: function(e) { | |
| if (!arguments.length) | |
| return n.extend({}, this._children); | |
| if (e != null) { | |
| if (typeof e != "object") | |
| return this._children[e + ""]; | |
| for (var t in this._children) | |
| if (this._children[t] === e) | |
| return e | |
| } | |
| }, | |
| slice: function(e, t) { | |
| return t > 0 && (arguments[1] += e), | |
| Array.prototype.slice.apply(n.values(this._children), arguments) | |
| }, | |
| at: function(e) { | |
| return this.slice(e, 1)[0] | |
| }, | |
| remove: function() { | |
| return this.el && this.el.remove(), | |
| this.unnest() | |
| }, | |
| assignChildren: function(e, t) { | |
| t || (t = {}), | |
| t.assignChildren = !0; | |
| var r = t.eqFunc | |
| , i = t.keyFunc || this._defaultKey; | |
| if (r == null) | |
| t.keepMissing || this.each(this.unlist, this); | |
| else if (typeof r != "function") { | |
| var s = r; | |
| r = function(e, t) { | |
| return t && e.get(s) == t[s] | |
| } | |
| } | |
| e.data && (e = e.data), | |
| n.isArray(e) || (e = n.values(e)); | |
| var o = r ? n.extend({}, this._children) : {}; | |
| for (var u = 0; u < e.length; u++) { | |
| for (var a in o) | |
| if (r.call(this, o[a], e[u])) { | |
| o[a].assignResp(e[u], t), | |
| delete o[a], | |
| a = !0; | |
| break | |
| } | |
| if (a !== !0) { | |
| var f = (new this._childClass).assignResp(e[u], t); | |
| this.nest(i.call(this, f), f, t) | |
| } | |
| } | |
| return t.keepMissing || n.each(o, this.unlist, this), | |
| this | |
| }, | |
| assignResp: function(e, t) { | |
| t || (t = {}); | |
| for (var n in e) { | |
| var r = e[n] | |
| , i = this._respToOpt[n]; | |
| i === undefined && (i = !t.onlyDefined), | |
| i === !0 && (i = n), | |
| typeof i == "function" && (i = i.call(this, r, n, e, t), | |
| r = i[1], | |
| i = i[0]), | |
| i == 0 || this.set(i, r, t) | |
| } | |
| return this | |
| }, | |
| bubble: function(e, t, n) { | |
| return n && this[e] && this[e].apply(this, t), | |
| this._parent && this._parent.bubble(e, t, !0), | |
| this | |
| }, | |
| sink: function(e, t, n) { | |
| return n && this[e] && this[e].apply(this, t), | |
| this.invoke("sink", e, t, !0), | |
| this | |
| }, | |
| $: function(e) { | |
| return s.is$(e) || n.isElement(e) ? r(e) : this.el ? e == "" || e == "." ? this.el : this.el.find(e) : r() | |
| } | |
| }); | |
| o.prototype._childClass = o, | |
| o._mergeProps.push("_opt", "elEvents"), | |
| o._shareProps.push("_childClass"); | |
| var u = ["each", "map", "reduce", "reduceRight", "find", "filter", "reject", "every", "some", "contains", "invoke", "pluck", "where", "findWhere", "max", "min", "sortBy", "groupBy", "indexBy", "countBy", "keys", "pairs", "pick", "omit", "toArray", "chain", "first", "initial", "rest", "last", "without", "partition", "difference", "indexOf", "shuffle", "sample", "lastIndexOf", "sortedIndex"] | |
| , a = u.indexOf("first"); | |
| n.each(u, function(e) { | |
| u.indexOf(e) < a ? o.prototype[e] = function() { | |
| var t = Array.prototype.slice.call(arguments); | |
| return t.unshift(this._children), | |
| n[e].apply(n, t) | |
| } | |
| : o.prototype[e] = function() { | |
| var t = Array.prototype.slice.call(arguments); | |
| return t.unshift(n.values(this._children)), | |
| n[e].apply(n, t) | |
| } | |
| }) | |
| }), | |
| function() { | |
| function e(e) { | |
| e.find("tbody > tr").each(function() { | |
| var e = $(this).find("td.counts").text().match(/([\d,.]+)\s+[\u2013\-]\s+([\d,.]+)/); | |
| e && $(this).find("td.counts").prepend($('<div class="_pcnt_bk">').css("width", +e[2].replace(/,/g, "") / +e[1].replace(/,/g, "") * 100 + "%")); | |
| var t = $(this).find("td.valid"); | |
| t.prepend($('<div class="_pcnt_bk">').css("width", t.text())) | |
| }) | |
| } | |
| $(document).mousedown(function(e) { | |
| e.pageX || e.pageY ? $("#wait").css({ | |
| position: "absolute", | |
| left: e.pageX + 2, | |
| top: e.pageY + 2 | |
| }) : (e.clientX || e.clientY) && $("#wait").css({ | |
| position: "fixed", | |
| left: e.clientX + 2, | |
| top: e.clientY + 2 | |
| }) | |
| }), | |
| $(document).ajaxStart(function() { | |
| $("#wait").show() | |
| }), | |
| $(document).ajaxStop(function() { | |
| $("#wait").hide() | |
| }), | |
| $(function() { | |
| var t = $(".base-stats"); | |
| t.length && e(t); | |
| var n = $("#cartPopup")[0]; | |
| n && $(window).on("scroll", function() { | |
| n.style.display = "none" | |
| }), | |
| $(".wtfer-form").on("submit", function() { | |
| var e = $("[name=drop]", this); | |
| e.val() == 0 ? e.css("borderColor", "red") : e = null, | |
| e || (e = $("[name=amount]", this), | |
| e.val() < 500 ? e.val("") : e = null); | |
| if (e) | |
| return e.focus(), | |
| !1 | |
| }); | |
| var r = $("._form.login"); | |
| r.length && (r[0].onsubmit = function() { | |
| $('[type="submit"]', this).removeClass("_btng").text("Wait...")[0].disabled = !0; | |
| var e = function(e) { | |
| return e.length > 1 ? e : "0" + e | |
| } | |
| , t = $("#password", this) | |
| , n = t.val().substr(0, 255) | |
| , r = $('[name="key"]', this).val(); | |
| if (!n.length || !r.length) { | |
| t.val("#######"); | |
| return | |
| } | |
| n = encodeURIComponent(n).replace(/%../g, function(e) { | |
| return String.fromCharCode(Number("0x" + e.substr(1))) | |
| }); | |
| var i = ""; | |
| n = String.fromCharCode(n.length) + n; | |
| while (n.length < r.length) | |
| n += String.fromCharCode(48 + random(74)); | |
| for (var s = 0; s < n.length; s++) { | |
| var o = s % r.length | |
| , u = (n.charCodeAt(s) ^ r.charCodeAt(o)).toString(16); | |
| i += e(u) | |
| } | |
| t.val(i) | |
| } | |
| , | |
| r.hasClass("deferred") && r.submit()), | |
| $("._form.registration").on("submit", function() { | |
| if ($.trim($("#password").val()) != $.trim($("#password2").val())) | |
| return $("#password2").val(""), | |
| setTimeout(function() { | |
| $("#password2").focus() | |
| }, 100), | |
| !1 | |
| }), | |
| $(".support-area form").on("submit", function() { | |
| function t(t) { | |
| e.each(function() { | |
| this.disabled = !t | |
| }), | |
| e.toggleClass("_btng", t) | |
| } | |
| var e = $("[type=submit]", this); | |
| t(!1), | |
| setTimeout(function() { | |
| t(!0) | |
| }, 25e3) | |
| }) | |
| }) | |
| }(), | |
| function() { | |
| function n(t) { | |
| throw e && console.error(t), | |
| t | |
| } | |
| function i(e) { | |
| return "media/" + e | |
| } | |
| function s() { | |
| var e = document.cookie.match(/(^|;)\s*csrf=([^;]+)/); | |
| return e || n("No CSRF cookie."), | |
| e[2] | |
| } | |
| function o(t, n) { | |
| t.url.match(/\?/) || (t.url += "?"), | |
| t.url += "&csrf=" + s(); | |
| switch (t.dataType) { | |
| case "json": | |
| t.url += "&json=1" | |
| } | |
| !t.error && t.error !== null && (t.error = function(r) { | |
| try { | |
| e && console.dir([arguments]); | |
| if (u(r, t, n)) | |
| return | |
| } catch (i) {} | |
| setTimeout(function() { | |
| location.href = t.url.replace(/([&?])json=\d+/g, "$1") | |
| }, 1e3) | |
| } | |
| ); | |
| if (!(--n < 0)) | |
| return $.ajax(t); | |
| t.error && t.error() | |
| } | |
| function u(e, t, n) { | |
| var r = e && e.status; | |
| if (r == 429) | |
| return setTimeout(function() { | |
| o(t, n || 9) | |
| }, 1e3); | |
| if (r == 417) { | |
| var i = e.responseText.match(/<meta name="csrf" content="([^"]+)"/); | |
| if (i) { | |
| var s = "csrf=" + escape(i[1]) + ";path=/"; | |
| return location.protocol == "https:" && (s += ";secure"), | |
| document.cookie = s, | |
| t.url = t.url.replace(/([?&]csrf=)[^&]+/g, "$1" + i[1]), | |
| setTimeout(function() { | |
| o(t, 1) | |
| }, 1e3) | |
| } | |
| } | |
| } | |
| function C(e) { | |
| return parseFloat(e.replace(/[\s,$]+/g, "")) || 0 | |
| } | |
| function M(e, t, n) { | |
| var r = _.size(n); | |
| $(".cart-item-count").text(r), | |
| $("#cart").toggleClass("empty", !r), | |
| $(".cart-total").text(e || "0.00"), | |
| $(".cart-total-no-disc").text(t), | |
| D($(".user-balance").text()) | |
| } | |
| function D(e) { | |
| var t = parseFloat(e.replace(/,/g, "")) | |
| , n = $(".user-balance").text(e); | |
| n.next("img").remove(); | |
| var r = parseFloat($(".cart-total").text().replace(/,/g, "")) || 0 | |
| , i = $("#cart p:first").next(); | |
| i.children("img:first-child").remove(), | |
| r > t && $('<img src="media/h-warn.png">').prependTo(i) | |
| } | |
| function P() { | |
| l.attach(); | |
| var e = $("#time time"); | |
| e.length && l.nest(new c({ | |
| el: e | |
| })); | |
| var t = $('head > meta[http-equiv="Refresh"]'); | |
| t.length && $("#body.modalbox").length && l.nest(new h({ | |
| delay: t[0].content | |
| })), | |
| D($(".user-balance").text()), | |
| l.nest(new d), | |
| l.nest(new T), | |
| l.nest(new E), | |
| N.allRoots().each(function() { | |
| l.nest(new N({ | |
| el: this | |
| })) | |
| }); | |
| var n = $(".ssrch-table > tbody > tr.new"); | |
| n[0] && l.nest(new k({ | |
| el: n, | |
| randomFee: parseFloat(n.attr("data-randbase")), | |
| randomCritFee: parseFloat(n.attr("data-randcrit")), | |
| userBalance: C($(".user-balance").text()) | |
| })); | |
| var n = $(".ssrch-bulk"); | |
| n[0] && l.nest(new L({ | |
| el: n | |
| })); | |
| var n = $(".cart-contents"); | |
| if (n[0]) | |
| l.nest("cart", new y({ | |
| el: n | |
| })); | |
| else { | |
| var r = $(".dumps-table") | |
| , i = $(".dumps-filter"); | |
| r[0] ? l.nest(new g({ | |
| el: r | |
| },i)) : i.is(".bulkbuy") && l.nest(new m({ | |
| el: i | |
| })) | |
| } | |
| $("._bigsel").each(function() { | |
| (new A({ | |
| el: this | |
| })).assignFromEl().attach() | |
| }), | |
| $("._timed").each(function() { | |
| (new p({ | |
| el: this | |
| })).attach() | |
| }); | |
| var s = (new O).render().attach(), o; | |
| $(document).on("mouseenter mouseleave", "[data-hint]", function(e) { | |
| e.type == "mouseenter" ? (s.showFor(e.currentTarget), | |
| clearTimeout(o), | |
| o = setTimeout(function() { | |
| s.set("visible", !1) | |
| }, 6e4)) : s.set("visible", !1) | |
| }) | |
| } | |
| var e = location.host.indexOf(".") == -1, t, r = { | |
| confirm: "Do you absolutely want to do this?", | |
| checkAndRefund: "Do you want to check this item and get a refund in case it is bad?\n\nEach check costs $# which will be taken from your balance.", | |
| purchase: "You are going to buy # and spend your funds.\n\nAre you sure?", | |
| purchaseNoFunds: "Not enough balance - you need $# USD more to buy selected items.\n\nDo you wish to add funds now?", | |
| confirmBulkBuy: "Do you want to buy #c #t for $#p USD?", | |
| bulkError: "There was a problem with bulk-buy. Please retry later.", | |
| noNewTx: "No new transactions or enough confirmations found.", | |
| ssnNoFunds: "Your balance is insufficient. You need $# more." | |
| }, a = S.S.extend({}), f = a.extend({ | |
| el: "body" | |
| }), l = f.extend({ | |
| isLoggedIn: !1, | |
| events: { | |
| attach: function() { | |
| this.isLoggedIn = !!$("#nav .username").text(), | |
| this.isLoggedIn && setInterval(_.bind(this.checkAuth, this), this.authCheckDelay()) | |
| }, | |
| "+nest": function(e) { | |
| e.attach() | |
| } | |
| }, | |
| elEvents: { | |
| "click ._confirm_click": function() { | |
| if (!confirm(r.confirm)) | |
| return !1 | |
| } | |
| }, | |
| checkAuth: function() {}, | |
| authCheckDelay: function() { | |
| return 3e5 + Math.floor(Math.random() * 6e4) | |
| }, | |
| logOut: function() { | |
| $("#body").html("<h3>You have been logged out.</h3>"), | |
| location.href = "logout" | |
| }, | |
| adjustNavMark: function(e, t) { | |
| var n = function(e, n) { | |
| return n = (+n || 0) + t, | |
| n > 0 ? "+" + n : n | |
| }; | |
| _.isNumber(t) || (t = 1); | |
| var r = $("#n" + e); | |
| r.find("._pmark") || r.append('<mark class="_pmark">'), | |
| r.find("._pmark").text(n) | |
| } | |
| }), c = a.extend({ | |
| events: { | |
| attach: function() { | |
| var e = (new Date(this.el.attr("datetime"))).getTime(); | |
| e && this.start(e) | |
| } | |
| }, | |
| start: function(e) { | |
| function s(e) { | |
| return e < 10 ? "0" + e : e | |
| } | |
| var t = 18e5, n = Math.round((e - Date.now()) / t) * t, r, i = this; | |
| (function() { | |
| var e = new Date(Date.now() + n) | |
| , t = e.getUTCSeconds(); | |
| if (r != t) { | |
| var o = e.getUTCFullYear() + "-" + s(e.getUTCMonth() + 1) + "-" + s(e.getUTCDate()) + " " + s(e.getUTCHours()) + ":" + s(e.getUTCMinutes()) + ":" + s(t); | |
| i.el.text(o), | |
| r = t | |
| } | |
| setTimeout(arguments.callee, 490) | |
| } | |
| )() | |
| } | |
| }), h = a.extend({ | |
| el: { | |
| tag: "p", | |
| className: "refresh-bar" | |
| }, | |
| _timer: null, | |
| _opt: { | |
| attachPath: "#body", | |
| delay: 0, | |
| current: 0 | |
| }, | |
| events: { | |
| attach: "startTimer", | |
| change_delay: "render", | |
| change_current: "render", | |
| render: function() { | |
| this.el.html('<img src="media/wait.gif"><progress>').find("progress").attr({ | |
| max: this.get("delay"), | |
| value: this.get("current") | |
| }) | |
| } | |
| }, | |
| startTimer: function() { | |
| if (!this._timer) { | |
| var e = this; | |
| this._timer = setTimeout(function() { | |
| var t = e.get("current") + 1; | |
| e.set("current", t), | |
| t < e.get("delay") && setTimeout(arguments.callee, 1e3) | |
| }, 1e3) | |
| } | |
| }, | |
| stopTimer: function() { | |
| clearTimeout(this._timer), | |
| this._timer = null | |
| } | |
| }), p = a.extend({ | |
| _opt: { | |
| delay: 5, | |
| enabled: !1 | |
| }, | |
| events: { | |
| attach: function() { | |
| var e = parseInt(this.$(".timer").text()); | |
| e && this.set("delay", e), | |
| $(_.bind(this.tick, this)) | |
| }, | |
| change_delay: function(e) { | |
| this.set("enabled", e < 1), | |
| this.$(".timer").text(e) | |
| }, | |
| change_enabled: function(e) { | |
| this.$(".timed").attr("disabled", !e), | |
| this.$(".timed").toggleClass("_btng", e) | |
| } | |
| }, | |
| tick: function() { | |
| this.set("delay", this.get("delay") - 1), | |
| setTimeout(_.bind(this.tick, this), 1e3) | |
| } | |
| }), d = f.extend({ | |
| elEvents: { | |
| "click ._captcha": function(e) { | |
| var t = $(e.currentTarget) | |
| , n = t.prevAll('[type="hidden"][name$="hash"]'); | |
| n.length == 1 && this._reload(t, n) | |
| } | |
| }, | |
| _reload: function(e, t) { | |
| e.css("opacity", .3), | |
| o({ | |
| url: "captcha?json=1", | |
| dataType: "text", | |
| global: !1, | |
| error: function() { | |
| location.reload() | |
| }, | |
| success: function(n) { | |
| t.val(n), | |
| e[0].onload = function() { | |
| e.next("input").val("").focus(), | |
| e.css("opacity", 1) | |
| } | |
| , | |
| e.attr("src", function(t, r) { | |
| return (e.attr("data-reload") || r.replace(/\?.*$/, "")) + "?" + encodeURIComponent(n) + "#" + Math.random() | |
| }) | |
| } | |
| }) | |
| } | |
| }), v = a.extend({ | |
| _table: null, | |
| _linkifyBatch: 400, | |
| _linkifyDelay: 100, | |
| events: { | |
| init: function(e) { | |
| this._table = e.table | |
| }, | |
| attach: function() { | |
| if (this._table) { | |
| var e = this._table.$("tbody td"); | |
| this._linkifyNodes(e, 0) | |
| } | |
| } | |
| }, | |
| elEvents: { | |
| 'click label a[href="#"]': function(e) { | |
| var t = $(e.currentTarget) | |
| , n = t.parents("label").attr("for"); | |
| return this.filterOn(n, t) | |
| } | |
| }, | |
| _linkifyNodes: function(e, t) { | |
| for (; ; ) { | |
| var n = e.eq(t++); | |
| if (!n.length) | |
| break; | |
| if (!this._linkifyNode(n)) | |
| continue; | |
| if (t % this._linkifyBatch == 0) { | |
| setTimeout(_.bind(this._linkifyNodes, this, e, t), this._linkifyDelay); | |
| break | |
| } | |
| } | |
| }, | |
| _linkifyNode: function(e) { | |
| var t = null | |
| , n = null | |
| , r = e[0].className.replace(/ .*$/, ""); | |
| switch (r) { | |
| case "country": | |
| t = e.find("[data-value]").attr("data-value"); | |
| break; | |
| case "bank": | |
| case "brand": | |
| case "card_level": | |
| e = e.find("div"); | |
| case "base": | |
| case "state": | |
| case "city": | |
| case "card_type": | |
| case "exp_date": | |
| case "tracks": | |
| case "svc_code": | |
| case "pin": | |
| case "phone": | |
| case "dob": | |
| case "ssn": | |
| case "email": | |
| case "refund": | |
| break; | |
| case "bin": | |
| n = parseInt(e.html()); | |
| if (isNaN(n)) | |
| return !1; | |
| break; | |
| case "zip": | |
| n = $.trim(e.html()); | |
| if (!n.length) | |
| return !1; | |
| break; | |
| default: | |
| return !1 | |
| } | |
| e.wrapInner(this._filterLink(r).attr("data-value", t)); | |
| if (n != null) { | |
| var i = this._filterLink("!" + r).text("[\u2013]"); | |
| i.attr({ | |
| "data-value": n, | |
| title: "Exclude this value" | |
| }), | |
| e.append(" ", i) | |
| } | |
| return !0 | |
| }, | |
| _filterLink: function(e) { | |
| return $('<u class="to-filter" data-filter="' + e + '">') | |
| }, | |
| submit: function() { | |
| return this.el.submit(), | |
| !1 | |
| }, | |
| filterOn: function(e, t) { | |
| var n = e[0] == "!"; | |
| e = e.replace(/^!/, ""); | |
| var r = this.$("#" + e) | |
| , i = a.is$(t) ? t.text() : t; | |
| if (r[0]) { | |
| if (a.is$(t)) { | |
| var s = t.attr("data-value"); | |
| s == null && (s = t.text()), | |
| t = $.trim(s) | |
| } | |
| t = this._inputValueFor(e, t); | |
| if (t != null) | |
| return this._setInput(e, n, t, i, r), | |
| this.submit() | |
| } | |
| }, | |
| _inputValueFor: function(e, t) { | |
| switch (e) { | |
| case "tracks": | |
| return /1/.test(t) ? 1 : 2; | |
| case "exp_date": | |
| var n = t.split("/"); | |
| return n[0].length < 2 && (n[0] = "0" + n[0]), | |
| n[1].length < 2 && (n[1] = "1" + n[1]), | |
| "" + n[1] + n[0]; | |
| case "phone": | |
| return (new RegExp("-|\u2013","i")).test(t) ? "-" : "*"; | |
| case "dob": | |
| case "ssn": | |
| case "email": | |
| case "address": | |
| return (new RegExp("yes|\\+|" + e,"i")).test(t) ? "*" : "-"; | |
| case "refund": | |
| return +!!(new RegExp("yes|\\+|" + e,"i")).test(t); | |
| default: | |
| return /^(N\/A|[-\u2013\u2014])$/.test(t) ? "-" : t | |
| } | |
| }, | |
| _setInput: function(e, t, n, r, i) { | |
| var s = i.data("bigsel"); | |
| switch (e) { | |
| default: | |
| s ? s.setValCap(n, r) : i.val(n); | |
| var o = this.$("#ex" + e); | |
| o[0] && (o[0].checked = !!t) | |
| } | |
| } | |
| }), m = a.extend({ | |
| _filter: null, | |
| _xhr: null, | |
| _timer: null, | |
| _opt: { | |
| changed: !0, | |
| redoHint: !1 | |
| }, | |
| events: { | |
| init: function(e) { | |
| this._filter = this.nest(new v({ | |
| el: this.el, | |
| table: new a | |
| })), | |
| this._filter.attach() | |
| }, | |
| change_changed: function(e) { | |
| e && this.$(".do-buy").removeClass("_btng") | |
| }, | |
| change_redoHint: function(e) { | |
| this.$(".redo-hint").toggle(e) | |
| } | |
| }, | |
| elEvents: { | |
| change: "filtersChanged", | |
| submit: "updatePreview", | |
| "click .do-buy": "buy", | |
| 'click [name="reset"]': function() { | |
| location.href = this.el.attr("action") | |
| } | |
| }, | |
| filtersChanged: function(e) { | |
| return this.set("changed", !0), | |
| this.set("redoHint", !1), | |
| clearTimeout(this._timer), | |
| this._timer = setTimeout(_.bind(this.updatePreview, this), 200), | |
| !1 | |
| }, | |
| updatePreview: function() { | |
| return clearTimeout(this._timer), | |
| this._xhr && this._xhr.abort(), | |
| this.$('button[type="submit"]').removeClass("_btng"), | |
| this.get("changed") && this._ajax("preview", this._updatePreview), | |
| !1 | |
| }, | |
| _updatePreview: function(e) { | |
| this.set("changed", !1), | |
| this.$(".preview").html(e.html) | |
| }, | |
| _ajax: function(e, t) { | |
| var n = "csrf=" + s() + "&do=" + e + "&" + this.el.serialize(); | |
| this._xhr = o({ | |
| url: this.el.attr("action"), | |
| type: "POST", | |
| data: n, | |
| dataType: "json", | |
| context: this, | |
| success: t, | |
| error: function() { | |
| alert(r.bulkError) | |
| } | |
| }) | |
| }, | |
| buy: function(e) { | |
| var t = $(e.target) | |
| , n = parseInt(t.attr("data-count")) | |
| , i = t.attr("data-price") | |
| , s = r.confirmBulkBuy.replace("#c", n).replace("#t", this.el.attr("class").match(/dumps|cards/)).replace("#p", i); | |
| !this.get("changed") && confirm(s) && this._ajax("buy&count=" + n, function(e) { | |
| $("#bborders").prepend(e.html), | |
| this.$(".preview").html(e.html), | |
| this.set("changed", !0), | |
| this.set("redoHint", !0) | |
| }) | |
| } | |
| }), g = a.extend({ | |
| _filter: null, | |
| events: { | |
| init: function(e, t) { | |
| t && t.length && (this._filter = this.nest(new v({ | |
| el: t, | |
| table: this | |
| })), | |
| this._filter.attach()) | |
| }, | |
| attach: function() { | |
| $(".dumps-all-to-cart").on("click", _.bind(this.putAllIn, this)), | |
| this._addButtons() | |
| } | |
| }, | |
| elEvents: { | |
| "click .checker-check": function() { | |
| if (!confirm(r.checkAndRefund.replace("#", window.checkerCost))) | |
| return !1; | |
| $("#wait").show() | |
| }, | |
| "click .to-filter": function(e) { | |
| if (this._filter) { | |
| var t = $(e.currentTarget) | |
| , n = t.attr("data-filter"); | |
| return this._filter.filterOn(n, t) | |
| } | |
| }, | |
| "click .to-cart, .off-cart, tr.checked .btns": function(e) { | |
| if (e.target.tagName == "TD" && !this.el.hasClass("buy-dumps")) | |
| return; | |
| var t = $(e.currentTarget) | |
| , n = t.hasClass("to-cart") | |
| , r = t.parents("[data-id]") | |
| , i = parseInt(r.attr("data-id")); | |
| if (i > 0) | |
| return n ? this.putIn(i) : this.putOut(i), | |
| $("#wait").css({ | |
| position: "absolute", | |
| left: r.find("td.price").offset().left, | |
| top: r.offset().top | |
| }), | |
| !1 | |
| } | |
| }, | |
| _addButtons: function() { | |
| this.$(".to-cart").each(function() { | |
| $(this).addClass("_btn _btng").append('<img src="' + i("to-cart.png") + '" alt="Buy">') | |
| }) | |
| }, | |
| _reqURL: function(e, t) { | |
| var n = _.map(a.toArray(e), function(e) { | |
| return "items[" + parseInt(e) + "]=" + (t ? 1 : 0) | |
| }); | |
| return "cart?" + n.join("&") | |
| }, | |
| putAllIn: function() { | |
| var e = [] | |
| , t = this.$("tr[data-id]").each(function() { | |
| e.push(this.getAttribute("data-id")) | |
| }); | |
| this._putReq(e, !0, function() { | |
| this._addedToCart(t) | |
| }) | |
| }, | |
| putIn: function(e) { | |
| this._putReq(e, !0, function() { | |
| this._addedToCart(e) | |
| }) | |
| }, | |
| _addedToCart: function(e) { | |
| var t = a.is$(e) ? e : this.$('tr[data-id="' + e + '"]'); | |
| t.addClass("checked").removeClass("semichk").find(".btns").text("") | |
| }, | |
| putOut: function(e) { | |
| var t = '<u class="to-cart _btn _btng"><img src="media/to-cart.png" alt="Buy"></u>'; | |
| this._putReq(e, !1, function() { | |
| var n = this.$('tr[data-id="' + e + '"]'); | |
| n.removeClass("checked semichk").find(".btns").html(t) | |
| }) | |
| }, | |
| _putReq: function(e, t, n) { | |
| var r = a.toArray(e); | |
| if (!r.length) | |
| return; | |
| this.$(_.map(r, function(e) { | |
| return 'tr[data-id="' + e + '"]' | |
| }).join()).addClass("semichk"), | |
| o({ | |
| url: this._reqURL(e, t), | |
| dataType: "json", | |
| context: this, | |
| success: function(t) { | |
| var r = [e, n].concat(t); | |
| this._setPutResp.apply(this, r), | |
| n.call(this) | |
| } | |
| }) | |
| }, | |
| _setPutResp: function(e, n, r, i, s) { | |
| M(r, i, s); | |
| var o = $("#cartPopup"); | |
| if (o.length) { | |
| o.find("> p ~ *").remove(); | |
| for (var u in s) { | |
| var f = $("#cart").clone().attr("id", "").appendTo(o); | |
| break | |
| } | |
| var l = this.$('tr[data-id="' + a.toArray(e)[0] + '"]') | |
| , c = (l.position() || {}).top; | |
| if (!c || c < $(document).scrollTop()) { | |
| var l = this.$('tr[data-id="' + _.last(a.toArray(e)) + '"]'); | |
| c = (l.position() || {}).top | |
| } | |
| c && o.css("top", Math.floor((c - o.height() / 2) / 20) * 20), | |
| _.defer(_.bind(o.show, o)), | |
| clearTimeout(t), | |
| t = setTimeout(function() { | |
| o.fadeOut(100) | |
| }, 5e3) | |
| } | |
| n.call(this) | |
| } | |
| }), y = a.extend({ | |
| _childEvents: ["-_setBuyResp"], | |
| events: { | |
| init: function() { | |
| var t = this; | |
| this.$(".dumps-table").each(function() { | |
| e && console.log("init Cart"), | |
| t.nest(new b({ | |
| el: this | |
| })).attach() | |
| }) | |
| }, | |
| "._setBuyResp": function() { | |
| this.unnest(), | |
| _.defer(function() { | |
| var t = $(".cart-contents"); | |
| t[0] && l.nest(new y({ | |
| el: t | |
| })), | |
| e && console.log("renested CartContents") && console.dir([t]) | |
| }, 300) | |
| } | |
| }, | |
| elEvents: { | |
| "click .to-buy-all": function() { | |
| var t = _.flatten(this.invoke("getIdsToBuy")); | |
| e && console.log("buy " + t), | |
| this.first()._purchase(t) | |
| } | |
| } | |
| }), b = g.extend({ | |
| events: { | |
| "=putIn": function(e, t) { | |
| return this._buyReq(t, !0) | |
| }, | |
| "=putOut": function(e, t) { | |
| return this._buyReq(t, !1) | |
| } | |
| }, | |
| elEvents: { | |
| "click .to-buy-this": function(e) { | |
| var t = $(e.currentTarget).parents("[data-id]").attr("data-id"); | |
| this._purchase([t]) | |
| } | |
| }, | |
| getIdsToBuy: function() { | |
| var e = []; | |
| return this.$("tbody tr[data-id]:not(.checked)").each(function() { | |
| e.push($(this).attr("data-id")) | |
| }), | |
| e | |
| }, | |
| _buyReq: function(e, t) { | |
| o({ | |
| url: this._reqURL(e, t), | |
| dataType: "text", | |
| context: this, | |
| success: this._setBuyResp | |
| }) | |
| }, | |
| _setBuyResp: function(e) { | |
| var t = $(e) | |
| , n = t.find("h1").parent(); | |
| n.replaceAll("#body"), | |
| $(".user-balance").text(t.find(".user-balance").first().text()); | |
| var r = {}; | |
| for (var i = +t.find(".cart-item-count").first().text(); i > 0; --i) | |
| r[i] = 1; | |
| M(t.find(".cart-total").first().text(), t.find(".cart-total-no-disc").first().text(), r) | |
| }, | |
| _purchase: function(e) { | |
| var t = []; | |
| $.each(e, function(e, n) { | |
| n = parseInt(n), | |
| n > 0 && t.push(n) | |
| }); | |
| if (t.length == 1) | |
| var n = "this item"; | |
| else | |
| var n = "these " + t.length + " items"; | |
| var n = r.purchase.replace(/#/, n); | |
| if (!t.length || !confirm(n)) | |
| return; | |
| var i = "csrf=" + s() + "&items=" + encodeURIComponent(t.join()); | |
| o({ | |
| url: "buy", | |
| type: "POST", | |
| data: i, | |
| dataType: "text", | |
| context: this, | |
| success: this._purchaseResp, | |
| error: function() { | |
| setTimeout(function() { | |
| location.href = "buy?" + i | |
| }, 1e3) | |
| } | |
| }) | |
| }, | |
| _purchaseResp: function(e) { | |
| if (e.length < 50 && e < 0) { | |
| var t = r.purchaseNoBalance.replace(/#/, -e); | |
| confirm(t) && (location.href = "fund") | |
| } else | |
| this._setBuyResp(e), | |
| l.adjustNavMark("orders") | |
| } | |
| }), w = a.extend({}), E = f.extend({ | |
| _cache: {}, | |
| elEvents: { | |
| "click .export-order": function(e) { | |
| var t = $(e.currentTarget); | |
| return this._clicked(t, "_appearOn") | |
| }, | |
| "click .export-cc": function(e) { | |
| var t = $(e.currentTarget); | |
| return this._clicked(t, "_showCcOn") | |
| } | |
| }, | |
| _clicked: function(e, t) { | |
| var n = e.attr("href"); | |
| return this._cache[n] ? this[t](e, this._cache[n]) : o({ | |
| url: n, | |
| dataType: "json", | |
| context: this, | |
| success: function(r) { | |
| this._cache[n] = r, | |
| this[t].call(this, e, r) | |
| } | |
| }), | |
| !1 | |
| }, | |
| _appearOn: function(e, t) { | |
| this._cache[e.attr("href")] = t, | |
| e.removeClass("_btng"), | |
| e.parents("p").first().next("p").remove(), | |
| e.parents(".order").removeClass("fresh-order"); | |
| var n = e.parent().children().last() | |
| , r = n.is("textarea"); | |
| e.text(function(e, t) { | |
| return t.replace(/^\s*\w+/, r ? "Show" : "Hide") | |
| }), | |
| r ? n.remove() : ($(t).insertAfter(n).focus(), | |
| e.nextAll(".timer-hint").remove()) | |
| }, | |
| _showCcOn: function(e, t) { | |
| this._cache[e.attr("href")] = t; | |
| var n = e.parents("p:first") | |
| , r = n.nextAll(".dumps-tables").children(".dt-dumps"); | |
| $("<th class=cc>CC Number</th>").insertAfter(r.find("th.bin")), | |
| n.remove(), | |
| $.each(t, function(e, t) { | |
| $("<td class=cc>").text(t[1]).insertAfter(r.find("[data-id=" + t[0] + "] td.bin")) | |
| }) | |
| } | |
| }), x = a.extend({}), T = f.extend({ | |
| elEvents: { | |
| "click a.check-coin": function(e) { | |
| var t = $(e.currentTarget); | |
| return t.parent().nextAll("._success").remove(), | |
| o({ | |
| url: t.attr("href"), | |
| dataType: "json", | |
| context: this, | |
| success: function(e) { | |
| change = e[0], | |
| balance = e[1], | |
| D(balance), | |
| t.parents("._formver").find("time").text($("#time time").text()); | |
| if (!/^[0.]+$/.test(change)) { | |
| var n = t.parent(); | |
| n.siblings(":not(._attention)").andSelf().hide(); | |
| var i = "Added $" + change + " USD to your balance."; | |
| $("<p class=_success>").text(i).insertAfter(n); | |
| var o = t.attr("href").match(/\bsource=(\w+)/)[1] | |
| , u = "fund-wallet?do=assign&source=" + o + "&" + s() + "#" + o; | |
| $('<a class="_btn _btng">Get new address</a>').attr("href", u).appendTo($("<p>").appendTo(n.parent())) | |
| } else | |
| setTimeout(function() { | |
| alert(r.noNewTx) | |
| }, 10) | |
| } | |
| }), | |
| !1 | |
| } | |
| } | |
| }), N = a.extend({ | |
| _childClass: null, | |
| events: { | |
| init: function() { | |
| this._childClass = N.Row | |
| }, | |
| attach: function() { | |
| var e = this; | |
| this.$("tr.editable").each(function() { | |
| e.nest(new N.Row({ | |
| el: this | |
| })).attach() | |
| }); | |
| var t = this.$("tr.new-row"); | |
| t.length && this.nest(new N.NewRow({ | |
| el: t | |
| })).attach() | |
| } | |
| } | |
| }, { | |
| allRoots: function() { | |
| return $(".autobuy-table") | |
| } | |
| }); | |
| N.Row = a.extend({ | |
| _syncKeypress: null, | |
| _opt: { | |
| editing: !1, | |
| viewHTML: null, | |
| minPrice: { | |
| card: 30, | |
| dump: 50 | |
| }, | |
| type: "", | |
| bin: 0, | |
| price: 0, | |
| count: 0, | |
| total: 0, | |
| fundedSum: 0, | |
| userBalance: 0 | |
| }, | |
| events: { | |
| init: function() { | |
| this._syncKeypress = _.debounce(_.bind(function(t) { | |
| var n = t.target; | |
| try { | |
| this.set(n.name, n.value) | |
| } catch (r) { | |
| e && console.warn("norm " + n.name + ": " + r) | |
| } | |
| }, this), 100) | |
| }, | |
| attach: function() { | |
| this.set("userBalance", C($(".user-balance").text())), | |
| this.set("type", this.$("td.type").text().match(/dump/i) ? "dump" : "card"), | |
| this.el.hasClass("editable") ? (this.set("viewHTML", this.el.html()), | |
| _.each(["bin", "price", "count", "total"], function(e) { | |
| var t = this.$("td." + e); | |
| t.length && (this._opt[e] = C(t.text())) | |
| }, this), | |
| this.set("fundedSum", this.get("total"))) : this.set("editing", !0) | |
| }, | |
| change_editing: function(e) { | |
| if (e) { | |
| var t = this | |
| , r = t.newRow(); | |
| r.length && _.each(["price", "count"], function(e) { | |
| var n = t.$("td." + e).html(r.find("td." + e).html()).find("input").val(t.get(e)) | |
| }); | |
| var i = this.$(".btns").empty(); | |
| $('<u class="_btn do-submit">').text("Submit preorder").appendTo(i), | |
| $('<span class="fund-diff">').appendTo(i), | |
| this.get("viewHTML") && $('<u class="_btn do-view">').text("Return").appendTo(i) | |
| } else | |
| this.get("viewHTML") ? this.el.html(this.get("viewHTML")) : n("cannot revert editable Autobuy_Table.Row"); | |
| this.el.toggleClass("editable", !e) | |
| }, | |
| change: function(e, t) { | |
| (e == "price" || e == "count") && this.set("total", this.get("price") * this.get("count")) | |
| }, | |
| change_total: function(e) { | |
| var t = this.fundedDiff(); | |
| this.$("td.total").text(function() { | |
| return e > 0 ? "$" + Math.round(e) : "" | |
| }), | |
| this.$(".fund-diff").toggleClass("neg", t < 0).text(function() { | |
| return t ? (t < 0 ? "\u2013" : "+") + "$" + Math.abs(t) : "" | |
| }) | |
| }, | |
| "+normalize_bin": function(e, t) { | |
| t = this.normPositiveInt(e, t); | |
| if (t < 1e5 || t > 999999) | |
| throw "Malformed BIN: " + t; | |
| return t | |
| }, | |
| "+normalize_price": "normPositiveInt", | |
| "+normalize_count": "normPositiveInt", | |
| "+normalize_total": "normPositiveInt" | |
| }, | |
| elEvents: { | |
| "click .do-cancel": function() { | |
| var e = "Cancel this preorder and return $" + this.get("fundedSum") + " to your balance?"; | |
| confirm(e) && this.nav("cancel") | |
| }, | |
| "click td.price,td.count,.do-change": function(e) { | |
| this.ifSet("editing", !0) && _.defer(_.bind(function() { | |
| $(e.currentTarget).find("input").select().focus()[0] || this.$("input").first().select().focus() | |
| }, this)) | |
| }, | |
| "click .do-view": function() { | |
| this.set("editing", !1) | |
| }, | |
| "click .do-submit": "submit", | |
| 'change select[name="type"]': function(e) { | |
| this._syncKeypress(e), | |
| this.$('[name="bin"]').focus() | |
| }, | |
| "change input": "_syncKeypress", | |
| "keypress input,select": function(e) { | |
| switch (e.keyCode) { | |
| case 13: | |
| try { | |
| this.submit() | |
| } catch (e) {} | |
| return !1; | |
| case 27: | |
| try { | |
| this.set("editing", !1) | |
| } catch (e) {} | |
| return !1; | |
| default: | |
| this._syncKeypress(e) | |
| } | |
| } | |
| }, | |
| nav: function(e, t) { | |
| t = _.extend(t || {}, { | |
| "do": e, | |
| type: this.get("type"), | |
| bin: this.get("bin") | |
| }); | |
| var n = "autobuy?csrf=" + s(); | |
| $.each(t, function(e, t) { | |
| n += "&" + encodeURIComponent(e) + "=" + encodeURIComponent(t) | |
| }), | |
| location.href = n | |
| }, | |
| newRow: function() { | |
| return this._parent.$("tr.new-row") | |
| }, | |
| fundedDiff: function() { | |
| return Math.round(this.get("total") - this.get("fundedSum")) | |
| }, | |
| normFloat: function(e, t) { | |
| if (/^\s*\d+(\.\d{1,2})?\s*$/.test(t)) | |
| return parseFloat(t); | |
| throw "Malformed price: " + t | |
| }, | |
| normPositiveInt: function(e, t) { | |
| if (/^\s*\d+\s*$/.test(t) && t >= 1) | |
| return parseInt(t); | |
| throw "Malformed number: " + t | |
| }, | |
| submit: function() { | |
| var e = this.fundedDiff() | |
| , t = this.get("userBalance") - e | |
| , n = this.get("minPrice")[this.get("type")]; | |
| if (this.get("bin") < 1e5 || this.get("bin") > 999999) | |
| return this.$('[name="bin"]').select().focus(); | |
| if (this.get("price") < 1) | |
| return this.$('[name="price"]').select().focus(); | |
| if (this.get("price") < n) | |
| return alert("Minimum preorder price per piece for " + this.get("type") + "s is $" + n + "."), | |
| this.$('[name="price"]').select().focus(); | |
| if (this.get("count") < 1 || e == 0) | |
| return this.$('[name="count"]').select().focus(); | |
| if (e < 1) | |
| return this.$('[name="count"]').select().focus(), | |
| alert("You can only increase your bid."); | |
| if (t <= .01) | |
| return alert("Your balance is insufficient. You need $" + Math.round(Math.abs(t)) + " more."); | |
| var r = ["Type: " + this.get("type").toUpperCase() + "S", "BIN: " + this.get("bin"), "Price per 1 " + this.get("type") + ": $" + this.get("price"), "Number of " + this.get("type") + "s: " + this.get("count"), "Total: $" + Math.round(this.get("total")), "", "Current balance: $" + Math.round(this.get("userBalance")), "Now spending: $" + e, "", "This will put additional $" + e + " on hold RIGHT NOW.", "They can be released any time - simply cancel the preorder.", "", "Proceed?"]; | |
| confirm(r.join(" \n")) && this.nav("fund", { | |
| price: this.get("price"), | |
| count: this.get("count") | |
| }) | |
| } | |
| }), | |
| N.NewRow = N.Row.extend({}); | |
| var k = a.extend({ | |
| _opt: { | |
| randomFee: 0, | |
| randomCritFee: 0, | |
| userBalance: 0 | |
| }, | |
| events: { | |
| attach: "updatePrice" | |
| }, | |
| elEvents: { | |
| "click .do-search": "submit", | |
| "blur select,input": "updatePrice", | |
| "change select,input": "updatePrice", | |
| "keypress input": "updatePrice", | |
| "keyup input": "updatePrice" | |
| }, | |
| submit: function() { | |
| if (!this.$(".do-search").hasClass("_btng")) | |
| return; | |
| if (!$.trim(this.$('[name="name[]"]').val()).length) { | |
| this.$('[name="name[]"]')[0].focus(); | |
| return | |
| } | |
| this.updatePrice(); | |
| var e = this.calcCost() | |
| , t = this.get("userBalance") - e; | |
| if (e && t <= .01) | |
| return alert(r.ssnNoFunds.replace("#", Math.round(Math.abs(t)))); | |
| var n = ["You are going to spend up to $" + Math.round(e * 10) / 10 + " on this search.", "Your balance will be around $" + Math.round(t) + ".", "", "If there are less matches than you have requested (" + this.limit() + ") " + "then final cost will be lower.", "If there are no matches then you won't be charged at all.", "", "Proceed?"]; | |
| if (e > 0 && !confirm(n.join(" \n"))) | |
| return; | |
| this.$(".do-search").removeClass("_btng").text("Wait\u2026"), | |
| $("#wait").show(); | |
| var i = "ssn?csrf=" + s() + "&do=search"; | |
| this.$("[name]").each(function() { | |
| i += "&" + encodeURIComponent(this.name) + "=" + encodeURIComponent($(this).val()) | |
| }), | |
| location.href = i | |
| }, | |
| updatePrice: function(e) { | |
| var t = this.calcCost(); | |
| this.$("td.price").text(t ? "$" + Math.round(t * 10) / 10 : "Free").toggleClass("insuff", t > this.get("userBalance")), | |
| e && e.type == "keypress" && e.keyCode == 13 && this.submit() | |
| }, | |
| calcCost: function() { | |
| return 0 | |
| }, | |
| limit: function() { | |
| return parseInt(this.$('[name="limit"]').val()) || 0 | |
| } | |
| }) | |
| , L = a.extend({ | |
| _lines: null, | |
| _metLines: null, | |
| _index: null, | |
| _timer: null, | |
| _xhr: null, | |
| _opt: { | |
| working: !1, | |
| errored: !1 | |
| }, | |
| events: { | |
| change_working: function(e) { | |
| $("#wait").toggle(e), | |
| this.el.toggleClass("working", e), | |
| this.$("button").toggleClass("_btng", !e), | |
| this.$('[type="submit"]').text(e ? "Stop" : "Search"), | |
| this.$("textarea").attr("disabled", e ? "disabled" : null), | |
| e || this.abort() | |
| }, | |
| change_errored: function(e) { | |
| this.el.toggleClass("errored", e), | |
| e || this.$("output").html("") | |
| } | |
| }, | |
| elEvents: { | |
| submit: function() { | |
| return this.submit(), | |
| !1 | |
| }, | |
| 'click [type="submit"]': function() { | |
| if (this.get("working")) | |
| return this.set("working", !1), | |
| !1 | |
| }, | |
| "click .reload": function() { | |
| location.reload() | |
| } | |
| }, | |
| submit: function() { | |
| this.ifSet("working", !0) && (this._lines = this.$("textarea").val().split(/\n/).map(function(e) { | |
| return $.trim(e) | |
| }).filter(function(e) { | |
| return e.length > 0 | |
| }), | |
| this._metLines = {}, | |
| this._index = 0, | |
| this.set("errored", !1), | |
| this._searchNext()) | |
| }, | |
| abort: function() { | |
| clearTimeout(this._timer), | |
| this._xhr && this._xhr.abort() | |
| }, | |
| _logError: function(e) { | |
| this.$("output").text(function(t, n) { | |
| return (n ? n + "\n" : "") + "Line " + this._index + ": " + e | |
| } | |
| .bind(this)), | |
| this.set("errored", !0) | |
| }, | |
| _searchNext: function() { | |
| this.abort(); | |
| var e = this._lines[this._index++]; | |
| if (!e) { | |
| this.set("working", !1), | |
| !this._lines.length || (this.get("errored") ? this.$("output").html(function(e, t) { | |
| return t + '\n<b>Finished. <u class="_btn reload">Reload this page</u> to see the results.</b>' | |
| }) : _.defer(function() { | |
| location.reload() | |
| })); | |
| return | |
| } | |
| if (_.has(this._metLines, e)) | |
| return this._searchNext(); | |
| this._metLines[e] = !0, | |
| this.$("textarea").val(this._lines.slice(this._index).join("\n")), | |
| this.$('[type="submit"]').text("Stop (#%)".replace("#", Math.round(this._index / this._lines.length * 100))); | |
| var t = this.el.attr("action") + "?csrf=" + s() + "&do=search" | |
| , n = ["name1", "name2", "dob", "state", "city", "zip"] | |
| , r = _.object(n, e.split(/\|/)); | |
| r.name = r.name1 + " " + r.name2, | |
| _.each(r, function(e, n) { | |
| t += "&" + n + "=" + encodeURIComponent(e || "") | |
| }), | |
| this._xhr = $.ajax({ | |
| url: t, | |
| dataType: "json", | |
| context: this, | |
| success: function(e) { | |
| e.error != 0 && this._logError(e.error), | |
| this._queueNext() | |
| }, | |
| error: function() { | |
| this._logError("unknown error"), | |
| this._queueNext() | |
| } | |
| }) | |
| }, | |
| _queueNext: function() { | |
| this.abort(), | |
| this._timer = setTimeout(_.bind(this._searchNext, this), 1100) | |
| } | |
| }) | |
| , A = a.extend({ | |
| el: { | |
| tag: "input" | |
| }, | |
| _hidden: null, | |
| _list: null, | |
| _opt: { | |
| dictName: null, | |
| dict: null, | |
| cache: 3600, | |
| sort: "sa", | |
| loading: null, | |
| visible: !1, | |
| value: "" | |
| }, | |
| events: { | |
| attach: function() { | |
| this.attachHidden(), | |
| this.el.addClass("_bigsel").attr("readonly", "readonly").data("bigsel", this) | |
| }, | |
| change_visible: function(e) { | |
| e ? this.load(function(e) { | |
| this._list ? (this._list.reset(), | |
| this._list.set("dict", e), | |
| this._list.show()) : this._list = this.nest(this._makeList(e)) | |
| }) : this._list && this._list.set("visible", !1) | |
| }, | |
| change_value: function(e) { | |
| this.updateValue(), | |
| this._list && this._list.set("value", e), | |
| this._hidden.change() | |
| }, | |
| change_loading: function(e) { | |
| this.el.toggleClass("loading", !!e), | |
| e ? this.el.val("Loading, wait\u2026") : this.updateValue() | |
| } | |
| }, | |
| elEvents: { | |
| focus: "show", | |
| blur: function() { | |
| (!this._list || !this._list.get("visible")) && this.hide() | |
| } | |
| }, | |
| assignFromEl: function() { | |
| this.set("dictName", this.el.attr("data-dict")), | |
| this.set("cache", parseInt(this.el.attr("data-cache")) || this.get("cache")), | |
| this.set("sort", this.el.attr("data-sort")); | |
| var e = this.el.prev('input[type="hidden"]'); | |
| return e.length && (this._opt.value = e.val()), | |
| this | |
| }, | |
| show: function() { | |
| this.set("visible", !0) | |
| }, | |
| hide: function() { | |
| this.set("visible", !1) | |
| }, | |
| attachHidden: function() { | |
| var e = this; | |
| this._hidden = this.el.prev('[type="hidden"]'), | |
| this._hidden.length || (this._hidden = $("<input type=hidden>").attr("name", this.el.attr("id")).insertBefore(this.el)), | |
| this._hidden.val(this.get("value")).on("change", function() { | |
| e.set("value", this.value) | |
| }) | |
| }, | |
| updateValue: function() { | |
| var e = this.get("value") | |
| , t = this.get("dict"); | |
| this._hidden.val(e), | |
| this.el.val(t && t[e] ? t[e] : e) | |
| }, | |
| setValCap: function(e, t) { | |
| return this.set("value", $.trim(e)), | |
| this.el.val(t), | |
| this | |
| }, | |
| load: function(t) { | |
| if (this.get("loading")) | |
| return this._opt.loading.push(t); | |
| if (this.get("dict")) | |
| return t.call(this, this.get("dict")); | |
| this.set("loading", []), | |
| this._opt.loading.push(function(e) { | |
| this.set("dict", e) | |
| }), | |
| this._opt.loading.push(t); | |
| try { | |
| if (typeof localStorage == "object" && this._loadFromLocStorage()) | |
| return | |
| } catch (n) {} | |
| o({ | |
| url: "filters?name=" + encodeURIComponent(this.get("dictName")), | |
| dataType: "json", | |
| context: this, | |
| success: function(e) { | |
| return this._loaded(e) | |
| }, | |
| error: function() { | |
| e && console.error("bigsel fetch error") | |
| }, | |
| complete: function() { | |
| this.set("loading", null), | |
| this.updateValue() | |
| } | |
| }) | |
| }, | |
| _loaded: function(e) { | |
| var t = this.get("loading"); | |
| this.set("loading", null), | |
| _.each(t, function(t) { | |
| t.call(this, e) | |
| }, this) | |
| }, | |
| _loadFromLocStorage: function() { | |
| var t = this.get("cache") * 1e3 | |
| , n = localStorage.getItem(this.locStorageID()); | |
| try { | |
| n = $.parseJSON(n); | |
| if (n && n.time + t >= Date.now()) | |
| return this._loaded(n.dict), | |
| !0 | |
| } catch (r) { | |
| e && console.warn("bigsel _loadFromLocStorage: " + r) | |
| } | |
| this._opt.loading.unshift(function(t) { | |
| try { | |
| localStorage.setItem(this.locStorageID(), JSON.stringify({ | |
| time: Date.now(), | |
| dict: t | |
| })) | |
| } catch (n) { | |
| e && console.warn("bigsel localStorage setItem: " + n) | |
| } | |
| }) | |
| }, | |
| locStorageID: function() { | |
| return "bigsel." + this.get("dictName") | |
| }, | |
| _makeList: function(e) { | |
| var t = new A.List({ | |
| dict: e, | |
| sort: this.get("sort"), | |
| visible: this.get("visible"), | |
| value: this.get("value") | |
| }); | |
| return this.autoOff(t, { | |
| change_value: function(e) { | |
| this.set("value", e) | |
| }, | |
| change_visible: function(e) { | |
| this.set("visible", e) | |
| } | |
| }), | |
| t.el.css("width", this.el.outerWidth()).insertBefore(this.el), | |
| t.attach(), | |
| t | |
| } | |
| }); | |
| A.List = a.extend({ | |
| el: { | |
| className: "_bigsel_list" | |
| }, | |
| _input: null, | |
| _list: null, | |
| _inputTimer: null, | |
| _opt: { | |
| dict: {}, | |
| maxItems: e ? 100 : 100, | |
| value: "", | |
| filter: "", | |
| visible: !1, | |
| sort: null, | |
| selected: 0, | |
| renderOnShow: !0, | |
| submitButton: !0 | |
| }, | |
| events: { | |
| change_dict: "render", | |
| change_maxItems: "render", | |
| change_value: "render", | |
| change_selected: "updateSelected", | |
| "change_sort, change_filter": function() { | |
| this.update(), | |
| this.set("selected", 0) | |
| }, | |
| change_visible: function(t) { | |
| e && console.log("biglist visible = " + !!t), | |
| t && this.ifSet("renderOnShow", !1) && this.render(), | |
| this.el.toggle(t), | |
| _.defer(_.bind(this._input.focus, this._input)) | |
| }, | |
| attach: function() { | |
| this.get("submitButton") && !this.el.parents("form").length && this.set("submitButton", !1) | |
| } | |
| }, | |
| elEvents: { | |
| "keypress .filp": function(t) { | |
| e && console.log("bigsel list key " + t.keyCode), | |
| this.deferInputChange(); | |
| switch (t.keyCode) { | |
| case 13: | |
| this.hide(); | |
| var n = this.$("[data-value].cur").attr("data-value"); | |
| return typeof n == "string" && this.set("value", n), | |
| !1; | |
| case 27: | |
| return this.hide(), | |
| !1; | |
| case 38: | |
| case 40: | |
| var r = t.keyCode == 38 ? -1 : 1 | |
| , i = this.get("selected") | |
| , s = this._list.children().length - 1; | |
| return (r < 0 ? i == 0 : i >= s) ? i = r < 0 ? s : 0 : i += r, | |
| this.set("selected", i), | |
| !1 | |
| } | |
| }, | |
| "keyup .filp": "deferInputChange", | |
| "blur .filp": "hide", | |
| "mousedown [data-value]": function(e) { | |
| this.set("value", e.currentTarget.getAttribute("data-value")), | |
| this.hide(); | |
| if ($(e.target).hasClass("submit")) { | |
| var t = this.el.parents("form").first(); | |
| _.defer(_.bind(t.submit, t)) | |
| } | |
| } | |
| }, | |
| show: function() { | |
| this.set("visible", !0) | |
| }, | |
| hide: function() { | |
| this.set("visible", !1) | |
| }, | |
| reset: function() { | |
| this.set("filter", ""), | |
| this.set("selected", 0) | |
| }, | |
| deferInputChange: function() { | |
| var e = this; | |
| clearTimeout(this._inputTimer), | |
| this._inputTimer = setTimeout(function() { | |
| e._input && e.set("filter", e._input.val()) | |
| }, 10) | |
| }, | |
| render: function() { | |
| if (!this.get("visible")) | |
| return this.set("renderOnShow", !0); | |
| e && console.info("bigsel list RENDER"), | |
| this.el.empty().append(this._input = $("<input class=filp>")).append(this._list = $("<ol class=list>")), | |
| this._input.attr("placeholder", "Start typing\u2026"), | |
| this.update() | |
| }, | |
| update: function() { | |
| if (!this.get("visible")) | |
| return this.set("renderOnShow", !0); | |
| e && console.info("bigsel list update"); | |
| var t = this._formatFiltered(this._getFiltered()); | |
| this._input.val(this.get("filter")), | |
| this._list.empty(), | |
| _.each(t, function(e, t) { | |
| var n = $("<li>").attr("data-value", e.value).attr("title", e.text).html(e.html).appendTo(this._list); | |
| this.get("submitButton") && $('<img class=submit src="media/right.png">').prependTo(n) | |
| }, this), | |
| this.updateSelected() | |
| }, | |
| updateSelected: function() { | |
| var e = this.get("selected") | |
| , t = this._list.children(); | |
| e >= t.length && this.set("selected", e = t.length - 1), | |
| t.removeClass("cur"), | |
| t.eq(e).addClass("cur") | |
| }, | |
| _getFiltered: function() { | |
| var e = this.get("maxItems") | |
| , t = (this.get("filter") || "").toLowerCase() | |
| , n = this.get("dict") | |
| , r = this._sortFiltered(_.keys(n)); | |
| if (!t.length) | |
| return r.slice(0, e); | |
| var i = [] | |
| , s = [] | |
| , o = []; | |
| return r.find(function(r) { | |
| var u = n[r] | |
| , a = u.toLowerCase().indexOf(t); | |
| return a !== -1 && (a === 0 ? i.push(r) : u[a - 1] === " " ? s.push(r) : o.push(r)), | |
| i.length > e | |
| }, this), | |
| [].concat(i.slice(0, e - 1), s.slice(0, e - 1), o.slice(0, e - 1)).slice(0, e - 1) | |
| }, | |
| _sortFiltered: function(e) { | |
| var t = /^\d+$/ | |
| , n = this.get("sort") | |
| , r = n[1] == "d" ? -1 : 1; | |
| switch (n[0]) { | |
| case "n": | |
| n = function(e, n) { | |
| return t.test(e) ^ t.test(n) ? t.test(e) ? 1 : -1 : r * (+e - +n) | |
| } | |
| ; | |
| break; | |
| default: | |
| case "s": | |
| n = function(e, t) { | |
| return e += "", | |
| t += "", | |
| r * (e > t ? 1 : -1) | |
| } | |
| } | |
| return e.sort(n) | |
| }, | |
| _formatFiltered: function(t) { | |
| e && console.log("bigsel filtered: " + t.join()); | |
| var n = this.get("filter") || "" | |
| , r = this.get("dict") | |
| , i = $("<p>") | |
| , s = function(e) { | |
| return i.text(e).html() | |
| }; | |
| return _.map(t, function(e) { | |
| var t = r[e] | |
| , i = n ? new RegExp(escapeRE(n),"gi") : /$a/ | |
| , o = n ? new RegExp(escapeRE(s(n)),"gi") : /$a/; | |
| return { | |
| value: e, | |
| text: t.toLowerCase().replace(i, function(e) { | |
| return "<" + e.toUpperCase() + ">" | |
| }), | |
| html: s(t).replace(o, function(e) { | |
| return "<mark>" + e + "</mark>" | |
| }) | |
| } | |
| }) | |
| } | |
| }); | |
| var O = a.extend({ | |
| el: { | |
| id: "dhint" | |
| }, | |
| _opt: { | |
| attachPath: "body", | |
| hint: "", | |
| anchor: null, | |
| visible: !1 | |
| }, | |
| events: { | |
| attach: function() { | |
| var e = this; | |
| $(document).on("scroll." + this._cid, _.throttle(function() { | |
| e.set("visible", !1) | |
| }, 500, !0)) | |
| }, | |
| render: function() {}, | |
| change_hint: function(e) { | |
| this.el.text(e).html(function(e, t) { | |
| return t.replace(/(\r?\n)+/g, "<br>") | |
| }) | |
| }, | |
| change_anchor: function(e) { | |
| var t = $(e).offset(); | |
| if (t) { | |
| var n = this.el.outerWidth() + 20 | |
| , r = t.left + n | |
| , i = $(document).outerWidth(); | |
| this.el.css({ | |
| top: t.top + $(e).outerHeight(), | |
| left: r > i ? i - n : t.left | |
| }) | |
| } | |
| }, | |
| change_visible: function(e) { | |
| this.el.toggle(!!e) | |
| } | |
| }, | |
| showFor: function(t) { | |
| var n = $(t).attr("data-hint"); | |
| if (!n) { | |
| e && typeof n != "string" && console.warn("DocHint.showFor: no [data-hint]"); | |
| return | |
| } | |
| this.set("hint", n), | |
| this.set("anchor", t, { | |
| forceFire: !0 | |
| }), | |
| this.set("visible", !0) | |
| } | |
| }); | |
| l = new l, | |
| window.P = e && l, | |
| setTimeout(P, 100) | |
| }(); | |
| var x; | |
| /*!JSOK:1DQ5FG4Y*/ | |
| ;var x |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment