Created
July 2, 2013 09:44
-
-
Save leeight/5908015 to your computer and use it in GitHub Desktop.
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
| /* Copyright (c) 2008-2013 Luminate, Inc. All Rights Reserved */ | |
| /* | |
| * jQuery JavaScript Library v1.8.2 | |
| * http://jquery.com/ | |
| * | |
| * Includes Sizzle.js | |
| * http://sizzlejs.com/ | |
| * | |
| * Copyright 2012 jQuery Foundation and other contributors | |
| * Released under the MIT license | |
| * http://jquery.org/license | |
| * | |
| * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time) | |
| */ | |
| (function(a2, aB) { | |
| var w, af, o = a2.document, | |
| aI = a2.location, | |
| d = a2.navigator, | |
| bg = a2.jQuery, | |
| I = a2.$, | |
| am = Array.prototype.push, | |
| a4 = Array.prototype.slice, | |
| aK = Array.prototype.indexOf, | |
| z = Object.prototype.toString, | |
| V = Object.prototype.hasOwnProperty, | |
| aO = String.prototype.trim, | |
| bG = function(e, bZ) { | |
| return new bG.fn.init(e, bZ, w) | |
| }, | |
| bx = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source, | |
| aa = /\S/, | |
| aV = /\s+/, | |
| C = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, | |
| bo = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, | |
| a = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, | |
| bf = /^[\],:{}\s]*$/, | |
| bi = /(?:^|:|,)(?:\s*\[)+/g, | |
| bD = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, | |
| a0 = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g, | |
| bP = /^-ms-/, | |
| aU = /-([\da-z])/gi, | |
| N = function(e, bZ) { | |
| return (bZ + "").toUpperCase() | |
| }, | |
| aF = function() { | |
| if (o.addEventListener) { | |
| o.removeEventListener("DOMContentLoaded", aF, false); | |
| bG.ready() | |
| } else { | |
| if (o.readyState === "complete") { | |
| o.detachEvent("onreadystatechange", aF); | |
| bG.ready() | |
| } | |
| } | |
| }, | |
| Z = {}; | |
| bG.fn = bG.prototype = { | |
| constructor: bG, | |
| init: function(e, b2, b1) { | |
| var b0, b3, bZ, b4; | |
| if (!e) { | |
| return this | |
| } | |
| if (e.nodeType) { | |
| this.context = this[0] = e; | |
| this.length = 1; | |
| return this | |
| } | |
| if (typeof e === "string") { | |
| if (e.charAt(0) === "<" && e.charAt(e.length - 1) === ">" && e.length >= 3) { | |
| b0 = [null, e, null] | |
| } else { | |
| b0 = bo.exec(e) | |
| } | |
| if (b0 && (b0[1] || !b2)) { | |
| if (b0[1]) { | |
| b2 = b2 instanceof bG ? b2[0] : b2; | |
| b4 = (b2 && b2.nodeType ? b2.ownerDocument || b2 : o); | |
| e = bG.parseHTML(b0[1], b4, true); | |
| if (a.test(b0[1]) && bG.isPlainObject(b2)) { | |
| this.attr.call(e, b2, true) | |
| } | |
| return bG.merge(this, e) | |
| } else { | |
| b3 = o.getElementById(b0[2]); | |
| if (b3 && b3.parentNode) { | |
| if (b3.id !== b0[2]) { | |
| return b1.find(e) | |
| } | |
| this.length = 1; | |
| this[0] = b3 | |
| } | |
| this.context = o; | |
| this.selector = e; | |
| return this | |
| } | |
| } else { | |
| if (!b2 || b2.jquery) { | |
| return (b2 || b1).find(e) | |
| } else { | |
| return this.constructor(b2).find(e) | |
| } | |
| } | |
| } else { | |
| if (bG.isFunction(e)) { | |
| return b1.ready(e) | |
| } | |
| } | |
| if (e.selector !== aB) { | |
| this.selector = e.selector; | |
| this.context = e.context | |
| } | |
| return bG.makeArray(e, this) | |
| }, | |
| selector: "", | |
| jquery: "1.8.2", | |
| length: 0, | |
| size: function() { | |
| return this.length | |
| }, | |
| toArray: function() { | |
| return a4.call(this) | |
| }, | |
| get: function(e) { | |
| return e == null ? this.toArray() : (e < 0 ? this[this.length + e] : this[e]) | |
| }, | |
| pushStack: function(bZ, b1, e) { | |
| var b0 = bG.merge(this.constructor(), bZ); | |
| b0.prevObject = this; | |
| b0.context = this.context; | |
| if (b1 === "find") { | |
| b0.selector = this.selector + (this.selector ? " " : "") + e | |
| } else { | |
| if (b1) { | |
| b0.selector = this.selector + "." + b1 + "(" + e + ")" | |
| } | |
| } | |
| return b0 | |
| }, | |
| each: function(bZ, e) { | |
| return bG.each(this, bZ, e) | |
| }, | |
| ready: function(e) { | |
| bG.ready.promise().done(e); | |
| return this | |
| }, | |
| eq: function(e) { | |
| e = +e; | |
| return e === -1 ? this.slice(e) : this.slice(e, e + 1) | |
| }, | |
| first: function() { | |
| return this.eq(0) | |
| }, | |
| last: function() { | |
| return this.eq(-1) | |
| }, | |
| slice: function() { | |
| return this.pushStack(a4.apply(this, arguments), "slice", a4.call(arguments).join(",")) | |
| }, | |
| map: function(e) { | |
| return this.pushStack(bG.map(this, function(b0, bZ) { | |
| return e.call(b0, bZ, b0) | |
| })) | |
| }, | |
| end: function() { | |
| return this.prevObject || this.constructor(null) | |
| }, | |
| push: am, | |
| sort: [].sort, | |
| splice: [].splice | |
| }; | |
| bG.fn.init.prototype = bG.fn; | |
| bG.extend = bG.fn.extend = function() { | |
| var b7, b0, e, bZ, b4, b5, b3 = arguments[0] || {}, | |
| b2 = 1, | |
| b1 = arguments.length, | |
| b6 = false; | |
| if (typeof b3 === "boolean") { | |
| b6 = b3; | |
| b3 = arguments[1] || {}; | |
| b2 = 2 | |
| } | |
| if (typeof b3 !== "object" && !bG.isFunction(b3)) { | |
| b3 = {} | |
| } | |
| if (b1 === b2) { | |
| b3 = this; | |
| --b2 | |
| } | |
| for (; b2 < b1; b2++) { | |
| if ((b7 = arguments[b2]) != null) { | |
| for (b0 in b7) { | |
| e = b3[b0]; | |
| bZ = b7[b0]; | |
| if (b3 === bZ) { | |
| continue | |
| } | |
| if (b6 && bZ && (bG.isPlainObject(bZ) || (b4 = bG.isArray(bZ)))) { | |
| if (b4) { | |
| b4 = false; | |
| b5 = e && bG.isArray(e) ? e : [] | |
| } else { | |
| b5 = e && bG.isPlainObject(e) ? e : {} | |
| } | |
| b3[b0] = bG.extend(b6, b5, bZ) | |
| } else { | |
| if (bZ !== aB) { | |
| b3[b0] = bZ | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return b3 | |
| }; | |
| bG.extend({ | |
| noConflict: function(e) { | |
| if (a2.$ === bG) { | |
| a2.$ = I | |
| } | |
| if (e && a2.jQuery === bG) { | |
| a2.jQuery = bg | |
| } | |
| return bG | |
| }, | |
| isReady: false, | |
| readyWait: 1, | |
| holdReady: function(e) { | |
| if (e) { | |
| bG.readyWait++ | |
| } else { | |
| bG.ready(true) | |
| } | |
| }, | |
| ready: function(e) { | |
| if (e === true ? --bG.readyWait : bG.isReady) { | |
| return | |
| } | |
| if (!o.body) { | |
| return setTimeout(bG.ready, 1) | |
| } | |
| bG.isReady = true; | |
| if (e !== true && --bG.readyWait > 0) { | |
| return | |
| } | |
| af.resolveWith(o, [bG]); | |
| if (bG.fn.trigger) { | |
| bG(o).trigger("ready").off("ready") | |
| } | |
| }, | |
| isFunction: function(e) { | |
| return bG.type(e) === "function" | |
| }, | |
| isArray: Array.isArray || | |
| function(e) { | |
| return bG.type(e) === "array" | |
| }, | |
| isWindow: function(e) { | |
| return e != null && e == e.window | |
| }, | |
| isNumeric: function(e) { | |
| return !isNaN(parseFloat(e)) && isFinite(e) | |
| }, | |
| type: function(e) { | |
| return e == null ? String(e) : Z[z.call(e)] || "object" | |
| }, | |
| isPlainObject: function(b1) { | |
| if (!b1 || bG.type(b1) !== "object" || b1.nodeType || bG.isWindow(b1)) { | |
| return false | |
| } | |
| try { | |
| if (b1.constructor && !V.call(b1, "constructor") && !V.call(b1.constructor.prototype, "isPrototypeOf")) { | |
| return false | |
| } | |
| } catch (b0) { | |
| return false | |
| } | |
| var bZ; | |
| for (bZ in b1) {} | |
| return bZ === aB || V.call(b1, bZ) | |
| }, | |
| isEmptyObject: function(bZ) { | |
| var e; | |
| for (e in bZ) { | |
| return false | |
| } | |
| return true | |
| }, | |
| error: function(e) { | |
| throw new Error(e) | |
| }, | |
| parseHTML: function(b1, b0, e) { | |
| var bZ; | |
| if (!b1 || typeof b1 !== "string") { | |
| return null | |
| } | |
| if (typeof b0 === "boolean") { | |
| e = b0; | |
| b0 = 0 | |
| } | |
| b0 = b0 || o; | |
| if ((bZ = a.exec(b1))) { | |
| return [b0.createElement(bZ[1])] | |
| } | |
| bZ = bG.buildFragment([b1], b0, e ? null : []); | |
| return bG.merge([], (bZ.cacheable ? bG.clone(bZ.fragment) : bZ.fragment).childNodes) | |
| }, | |
| parseJSON: function(e) { | |
| if (!e || typeof e !== "string") { | |
| return null | |
| } | |
| e = bG.trim(e); | |
| if (a2.JSON && a2.JSON.parse) { | |
| return a2.JSON.parse(e) | |
| } | |
| if (bf.test(e.replace(bD, "@").replace(a0, "]").replace(bi, ""))) { | |
| return (new Function("return " + e))() | |
| } | |
| bG.error("Invalid JSON: " + e) | |
| }, | |
| parseXML: function(b1) { | |
| var bZ, b0; | |
| if (!b1 || typeof b1 !== "string") { | |
| return null | |
| } | |
| try { | |
| if (a2.DOMParser) { | |
| b0 = new DOMParser(); | |
| bZ = b0.parseFromString(b1, "text/xml") | |
| } else { | |
| bZ = new ActiveXObject("Microsoft.XMLDOM"); | |
| bZ.async = "false"; | |
| bZ.loadXML(b1) | |
| } | |
| } catch (b2) { | |
| bZ = aB | |
| } | |
| if (!bZ || !bZ.documentElement || bZ.getElementsByTagName("parsererror").length) { | |
| bG.error("Invalid XML: " + b1) | |
| } | |
| return bZ | |
| }, | |
| noop: function() {}, | |
| globalEval: function(e) { | |
| if (e && aa.test(e)) { | |
| (a2.execScript || | |
| function(bZ) { | |
| a2["eval"].call(a2, bZ) | |
| })(e) | |
| } | |
| }, | |
| camelCase: function(e) { | |
| return e.replace(bP, "ms-").replace(aU, N) | |
| }, | |
| nodeName: function(bZ, e) { | |
| return bZ.nodeName && bZ.nodeName.toLowerCase() === e.toLowerCase() | |
| }, | |
| each: function(b3, b4, b0) { | |
| var bZ, b1 = 0, | |
| b2 = b3.length, | |
| e = b2 === aB || bG.isFunction(b3); | |
| if (b0) { | |
| if (e) { | |
| for (bZ in b3) { | |
| if (b4.apply(b3[bZ], b0) === false) { | |
| break | |
| } | |
| } | |
| } else { | |
| for (; b1 < b2;) { | |
| if (b4.apply(b3[b1++], b0) === false) { | |
| break | |
| } | |
| } | |
| } | |
| } else { | |
| if (e) { | |
| for (bZ in b3) { | |
| if (b4.call(b3[bZ], bZ, b3[bZ]) === false) { | |
| break | |
| } | |
| } | |
| } else { | |
| for (; b1 < b2;) { | |
| if (b4.call(b3[b1], b1, b3[b1++]) === false) { | |
| break | |
| } | |
| } | |
| } | |
| } | |
| return b3 | |
| }, | |
| trim: aO && !aO.call("\uFEFF\xA0") ? | |
| function(e) { | |
| return e == null ? "" : aO.call(e) | |
| } : function(e) { | |
| return e == null ? "" : (e + "").replace(C, "") | |
| }, | |
| makeArray: function(e, b0) { | |
| var b1, bZ = b0 || []; | |
| if (e != null) { | |
| b1 = bG.type(e); | |
| if (e.length == null || b1 === "string" || b1 === "function" || b1 === "regexp" || bG.isWindow(e)) { | |
| am.call(bZ, e) | |
| } else { | |
| bG.merge(bZ, e) | |
| } | |
| } | |
| return bZ | |
| }, | |
| inArray: function(b1, bZ, b0) { | |
| var e; | |
| if (bZ) { | |
| if (aK) { | |
| return aK.call(bZ, b1, b0) | |
| } | |
| e = bZ.length; | |
| b0 = b0 ? b0 < 0 ? Math.max(0, e + b0) : b0 : 0; | |
| for (; b0 < e; b0++) { | |
| if (b0 in bZ && bZ[b0] === b1) { | |
| return b0 | |
| } | |
| } | |
| } | |
| return -1 | |
| }, | |
| merge: function(b2, b0) { | |
| var e = b0.length, | |
| b1 = b2.length, | |
| bZ = 0; | |
| if (typeof e === "number") { | |
| for (; bZ < e; bZ++) { | |
| b2[b1++] = b0[bZ] | |
| } | |
| } else { | |
| while (b0[bZ] !== aB) { | |
| b2[b1++] = b0[bZ++] | |
| } | |
| } | |
| b2.length = b1; | |
| return b2 | |
| }, | |
| grep: function(bZ, b4, e) { | |
| var b3, b0 = [], | |
| b1 = 0, | |
| b2 = bZ.length; | |
| e = !! e; | |
| for (; b1 < b2; b1++) { | |
| b3 = !! b4(bZ[b1], b1); | |
| if (e !== b3) { | |
| b0.push(bZ[b1]) | |
| } | |
| } | |
| return b0 | |
| }, | |
| map: function(e, b5, b6) { | |
| var b3, b4, b2 = [], | |
| b0 = 0, | |
| bZ = e.length, | |
| b1 = e instanceof bG || bZ !== aB && typeof bZ === "number" && ((bZ > 0 && e[0] && e[bZ - 1]) || bZ === 0 || bG.isArray(e)); | |
| if (b1) { | |
| for (; b0 < bZ; b0++) { | |
| b3 = b5(e[b0], b0, b6); | |
| if (b3 != null) { | |
| b2[b2.length] = b3 | |
| } | |
| } | |
| } else { | |
| for (b4 in e) { | |
| b3 = b5(e[b4], b4, b6); | |
| if (b3 != null) { | |
| b2[b2.length] = b3 | |
| } | |
| } | |
| } | |
| return b2.concat.apply([], b2) | |
| }, | |
| guid: 1, | |
| proxy: function(b2, b1) { | |
| var b0, e, bZ; | |
| if (typeof b1 === "string") { | |
| b0 = b2[b1]; | |
| b1 = b2; | |
| b2 = b0 | |
| } | |
| if (!bG.isFunction(b2)) { | |
| return aB | |
| } | |
| e = a4.call(arguments, 2); | |
| bZ = function() { | |
| return b2.apply(b1, e.concat(a4.call(arguments))) | |
| }; | |
| bZ.guid = b2.guid = b2.guid || bG.guid++; | |
| return bZ | |
| }, | |
| access: function(e, b4, b7, b5, b2, b8, b6) { | |
| var b0, b3 = b7 == null, | |
| b1 = 0, | |
| bZ = e.length; | |
| if (b7 && typeof b7 === "object") { | |
| for (b1 in b7) { | |
| bG.access(e, b4, b1, b7[b1], 1, b8, b5) | |
| } | |
| b2 = 1 | |
| } else { | |
| if (b5 !== aB) { | |
| b0 = b6 === aB && bG.isFunction(b5); | |
| if (b3) { | |
| if (b0) { | |
| b0 = b4; | |
| b4 = function(ca, b9, cb) { | |
| return b0.call(bG(ca), cb) | |
| } | |
| } else { | |
| b4.call(e, b5); | |
| b4 = null | |
| } | |
| } | |
| if (b4) { | |
| for (; b1 < bZ; b1++) { | |
| b4(e[b1], b7, b0 ? b5.call(e[b1], b1, b4(e[b1], b7)) : b5, b6) | |
| } | |
| } | |
| b2 = 1 | |
| } | |
| } | |
| return b2 ? e : b3 ? b4.call(e) : bZ ? b4(e[0], b7) : b8 | |
| }, | |
| now: function() { | |
| return (new Date()).getTime() | |
| } | |
| }); | |
| bG.ready.promise = function(b2) { | |
| if (!af) { | |
| af = bG.Deferred(); | |
| if (o.readyState === "complete") { | |
| setTimeout(bG.ready, 1) | |
| } else { | |
| if (o.addEventListener) { | |
| o.addEventListener("DOMContentLoaded", aF, false); | |
| a2.addEventListener("load", bG.ready, false) | |
| } else { | |
| o.attachEvent("onreadystatechange", aF); | |
| a2.attachEvent("onload", bG.ready); | |
| var b1 = false; | |
| try { | |
| b1 = a2.frameElement == null && o.documentElement | |
| } catch (b0) {} | |
| if (b1 && b1.doScroll) { | |
| (function bZ() { | |
| if (!bG.isReady) { | |
| try { | |
| b1.doScroll("left") | |
| } catch (b3) { | |
| return setTimeout(bZ, 50) | |
| } | |
| bG.ready() | |
| } | |
| })() | |
| } | |
| } | |
| } | |
| } | |
| return af.promise(b2) | |
| }; | |
| bG.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(bZ, e) { | |
| Z["[object " + e + "]"] = e.toLowerCase() | |
| }); | |
| w = bG(o); | |
| var bU = {}; | |
| function ac(bZ) { | |
| var e = bU[bZ] = {}; | |
| bG.each(bZ.split(aV), function(b1, b0) { | |
| e[b0] = true | |
| }); | |
| return e | |
| } | |
| bG.Callbacks = function(b8) { | |
| b8 = typeof b8 === "string" ? (bU[b8] || ac(b8)) : bG.extend({}, b8); | |
| var b1, e, b2, b0, b3, b4, b5 = [], | |
| b6 = !b8.once && [], | |
| bZ = function(b9) { | |
| b1 = b8.memory && b9; | |
| e = true; | |
| b4 = b0 || 0; | |
| b0 = 0; | |
| b3 = b5.length; | |
| b2 = true; | |
| for (; b5 && b4 < b3; b4++) { | |
| if (b5[b4].apply(b9[0], b9[1]) === false && b8.stopOnFalse) { | |
| b1 = false; | |
| break | |
| } | |
| } | |
| b2 = false; | |
| if (b5) { | |
| if (b6) { | |
| if (b6.length) { | |
| bZ(b6.shift()) | |
| } | |
| } else { | |
| if (b1) { | |
| b5 = [] | |
| } else { | |
| b7.disable() | |
| } | |
| } | |
| } | |
| }, | |
| b7 = { | |
| add: function() { | |
| if (b5) { | |
| var ca = b5.length; | |
| (function b9(cb) { | |
| bG.each(cb, function(cd, cc) { | |
| var ce = bG.type(cc); | |
| if (ce === "function" && (!b8.unique || !b7.has(cc))) { | |
| b5.push(cc) | |
| } else { | |
| if (cc && cc.length && ce !== "string") { | |
| b9(cc) | |
| } | |
| } | |
| }) | |
| })(arguments); | |
| if (b2) { | |
| b3 = b5.length | |
| } else { | |
| if (b1) { | |
| b0 = ca; | |
| bZ(b1) | |
| } | |
| } | |
| } | |
| return this | |
| }, | |
| remove: function() { | |
| if (b5) { | |
| bG.each(arguments, function(cb, b9) { | |
| var ca; | |
| while ((ca = bG.inArray(b9, b5, ca)) > -1) { | |
| b5.splice(ca, 1); | |
| if (b2) { | |
| if (ca <= b3) { | |
| b3-- | |
| } | |
| if (ca <= b4) { | |
| b4-- | |
| } | |
| } | |
| } | |
| }) | |
| } | |
| return this | |
| }, | |
| has: function(b9) { | |
| return bG.inArray(b9, b5) > -1 | |
| }, | |
| empty: function() { | |
| b5 = []; | |
| return this | |
| }, | |
| disable: function() { | |
| b5 = b6 = b1 = aB; | |
| return this | |
| }, | |
| disabled: function() { | |
| return !b5 | |
| }, | |
| lock: function() { | |
| b6 = aB; | |
| if (!b1) { | |
| b7.disable() | |
| } | |
| return this | |
| }, | |
| locked: function() { | |
| return !b6 | |
| }, | |
| fireWith: function(ca, b9) { | |
| b9 = b9 || []; | |
| b9 = [ca, b9.slice ? b9.slice() : b9]; | |
| if (b5 && (!e || b6)) { | |
| if (b2) { | |
| b6.push(b9) | |
| } else { | |
| bZ(b9) | |
| } | |
| } | |
| return this | |
| }, | |
| fire: function() { | |
| b7.fireWith(this, arguments); | |
| return this | |
| }, | |
| fired: function() { | |
| return !!e | |
| } | |
| }; | |
| return b7 | |
| }; | |
| bG.extend({ | |
| Deferred: function(b0) { | |
| var bZ = [ | |
| ["resolve", "done", bG.Callbacks("once memory"), "resolved"], | |
| ["reject", "fail", bG.Callbacks("once memory"), "rejected"], | |
| ["notify", "progress", bG.Callbacks("memory")] | |
| ], | |
| b1 = "pending", | |
| b2 = { | |
| state: function() { | |
| return b1 | |
| }, | |
| always: function() { | |
| e.done(arguments).fail(arguments); | |
| return this | |
| }, | |
| then: function() { | |
| var b3 = arguments; | |
| return bG.Deferred(function(b4) { | |
| bG.each(bZ, function(b6, b5) { | |
| var b8 = b5[0], | |
| b7 = b3[b6]; | |
| e[b5[1]](bG.isFunction(b7) ? | |
| function() { | |
| var b9 = b7.apply(this, arguments); | |
| if (b9 && bG.isFunction(b9.promise)) { | |
| b9.promise().done(b4.resolve).fail(b4.reject).progress(b4.notify) | |
| } else { | |
| b4[b8 + "With"](this === e ? b4 : this, [b9]) | |
| } | |
| } : b4[b8]) | |
| }); | |
| b3 = null | |
| }).promise() | |
| }, | |
| promise: function(b3) { | |
| return b3 != null ? bG.extend(b3, b2) : b2 | |
| } | |
| }, | |
| e = {}; | |
| b2.pipe = b2.then; | |
| bG.each(bZ, function(b4, b3) { | |
| var b6 = b3[2], | |
| b5 = b3[3]; | |
| b2[b3[1]] = b6.add; | |
| if (b5) { | |
| b6.add(function() { | |
| b1 = b5 | |
| }, bZ[b4 ^ 1][2].disable, bZ[2][2].lock) | |
| } | |
| e[b3[0]] = b6.fire; | |
| e[b3[0] + "With"] = b6.fireWith | |
| }); | |
| b2.promise(e); | |
| if (b0) { | |
| b0.call(e, e) | |
| } | |
| return e | |
| }, | |
| when: function(b2) { | |
| var b0 = 0, | |
| b4 = a4.call(arguments), | |
| e = b4.length, | |
| bZ = e !== 1 || (b2 && bG.isFunction(b2.promise)) ? e : 0, | |
| b7 = bZ === 1 ? b2 : bG.Deferred(), | |
| b1 = function(b9, ca, b8) { | |
| return function(cb) { | |
| ca[b9] = this; | |
| b8[b9] = arguments.length > 1 ? a4.call(arguments) : cb; | |
| if (b8 === b6) { | |
| b7.notifyWith(ca, b8) | |
| } else { | |
| if (!(--bZ)) { | |
| b7.resolveWith(ca, b8) | |
| } | |
| } | |
| } | |
| }, | |
| b6, b3, b5; | |
| if (e > 1) { | |
| b6 = new Array(e); | |
| b3 = new Array(e); | |
| b5 = new Array(e); | |
| for (; b0 < e; b0++) { | |
| if (b4[b0] && bG.isFunction(b4[b0].promise)) { | |
| b4[b0].promise().done(b1(b0, b5, b4)).fail(b7.reject).progress(b1(b0, b3, b6)) | |
| } else { | |
| --bZ | |
| } | |
| } | |
| } | |
| if (!bZ) { | |
| b7.resolveWith(b5, b4) | |
| } | |
| return b7.promise() | |
| } | |
| }); | |
| bG.support = (function() { | |
| var cb, ca, b8, b9, b2, b7, b6, b4, b3, b1, bZ, b0 = o.createElement("div"); | |
| b0.setAttribute("className", "t"); | |
| b0.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; | |
| ca = b0.getElementsByTagName("*"); | |
| b8 = b0.getElementsByTagName("a")[0]; | |
| b8.style.cssText = "top:1px;float:left;opacity:.5"; | |
| if (!ca || !ca.length) { | |
| return {} | |
| } | |
| b9 = o.createElement("select"); | |
| b2 = b9.appendChild(o.createElement("option")); | |
| b7 = b0.getElementsByTagName("input")[0]; | |
| cb = { | |
| leadingWhitespace: (b0.firstChild.nodeType === 3), | |
| tbody: !b0.getElementsByTagName("tbody").length, | |
| htmlSerialize: !! b0.getElementsByTagName("link").length, | |
| style: /top/.test(b8.getAttribute("style")), | |
| hrefNormalized: (b8.getAttribute("href") === "/a"), | |
| opacity: /^0.5/.test(b8.style.opacity), | |
| cssFloat: !! b8.style.cssFloat, | |
| checkOn: (b7.value === "on"), | |
| optSelected: b2.selected, | |
| getSetAttribute: b0.className !== "t", | |
| enctype: !! o.createElement("form").enctype, | |
| html5Clone: o.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>", | |
| boxModel: (o.compatMode === "CSS1Compat"), | |
| submitBubbles: true, | |
| changeBubbles: true, | |
| focusinBubbles: false, | |
| deleteExpando: true, | |
| noCloneEvent: true, | |
| inlineBlockNeedsLayout: false, | |
| shrinkWrapBlocks: false, | |
| reliableMarginRight: true, | |
| boxSizingReliable: true, | |
| pixelPosition: false | |
| }; | |
| b7.checked = true; | |
| cb.noCloneChecked = b7.cloneNode(true).checked; | |
| b9.disabled = true; | |
| cb.optDisabled = !b2.disabled; | |
| try { | |
| delete b0.test | |
| } catch (b5) { | |
| cb.deleteExpando = false | |
| } | |
| if (!b0.addEventListener && b0.attachEvent && b0.fireEvent) { | |
| b0.attachEvent("onclick", bZ = function() { | |
| cb.noCloneEvent = false | |
| }); | |
| b0.cloneNode(true).fireEvent("onclick"); | |
| b0.detachEvent("onclick", bZ) | |
| } | |
| b7 = o.createElement("input"); | |
| b7.value = "t"; | |
| b7.setAttribute("type", "radio"); | |
| cb.radioValue = b7.value === "t"; | |
| b7.setAttribute("checked", "checked"); | |
| b7.setAttribute("name", "t"); | |
| b0.appendChild(b7); | |
| b6 = o.createDocumentFragment(); | |
| b6.appendChild(b0.lastChild); | |
| cb.checkClone = b6.cloneNode(true).cloneNode(true).lastChild.checked; | |
| cb.appendChecked = b7.checked; | |
| b6.removeChild(b7); | |
| b6.appendChild(b0); | |
| if (b0.attachEvent) { | |
| for (b3 in { | |
| submit: true, | |
| change: true, | |
| focusin: true | |
| }) { | |
| b4 = "on" + b3; | |
| b1 = (b4 in b0); | |
| if (!b1) { | |
| b0.setAttribute(b4, "return;"); | |
| b1 = (typeof b0[b4] === "function") | |
| } | |
| cb[b3 + "Bubbles"] = b1 | |
| } | |
| } | |
| bG(function() { | |
| var cc, cg, ce, cf, cd = "padding:0;margin:0;border:0;display:block;overflow:hidden;", | |
| e = o.getElementsByTagName("body")[0]; | |
| if (!e) { | |
| return | |
| } | |
| cc = o.createElement("div"); | |
| cc.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px"; | |
| e.insertBefore(cc, e.firstChild); | |
| cg = o.createElement("div"); | |
| cc.appendChild(cg); | |
| cg.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; | |
| ce = cg.getElementsByTagName("td"); | |
| ce[0].style.cssText = "padding:0;margin:0;border:0;display:none"; | |
| b1 = (ce[0].offsetHeight === 0); | |
| ce[0].style.display = ""; | |
| ce[1].style.display = "none"; | |
| cb.reliableHiddenOffsets = b1 && (ce[0].offsetHeight === 0); | |
| cg.innerHTML = ""; | |
| cg.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;"; | |
| cb.boxSizing = (cg.offsetWidth === 4); | |
| cb.doesNotIncludeMarginInBodyOffset = (e.offsetTop !== 1); | |
| if (a2.getComputedStyle) { | |
| cb.pixelPosition = (a2.getComputedStyle(cg, null) || {}).top !== "1%"; | |
| cb.boxSizingReliable = (a2.getComputedStyle(cg, null) || { | |
| width: "4px" | |
| }).width === "4px"; | |
| cf = o.createElement("div"); | |
| cf.style.cssText = cg.style.cssText = cd; | |
| cf.style.marginRight = cf.style.width = "0"; | |
| cg.style.width = "1px"; | |
| cg.appendChild(cf); | |
| cb.reliableMarginRight = !parseFloat((a2.getComputedStyle(cf, null) || {}).marginRight) | |
| } | |
| if (typeof cg.style.zoom !== "undefined") { | |
| cg.innerHTML = ""; | |
| cg.style.cssText = cd + "width:1px;padding:1px;display:inline;zoom:1"; | |
| cb.inlineBlockNeedsLayout = (cg.offsetWidth === 3); | |
| cg.style.display = "block"; | |
| cg.style.overflow = "visible"; | |
| cg.innerHTML = "<div></div>"; | |
| cg.firstChild.style.width = "5px"; | |
| cb.shrinkWrapBlocks = (cg.offsetWidth !== 3); | |
| cc.style.zoom = 1 | |
| } | |
| e.removeChild(cc); | |
| cc = cg = ce = cf = null | |
| }); | |
| b6.removeChild(b0); | |
| ca = b8 = b9 = b2 = b7 = b6 = b0 = null; | |
| return cb | |
| })(); | |
| var bt = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, | |
| aL = /([A-Z])/g; | |
| bG.extend({ | |
| cache: {}, | |
| deletedIds: [], | |
| uuid: 0, | |
| expando: "jQuery" + (bG.fn.jquery + Math.random()).replace(/\D/g, ""), | |
| noData: { | |
| embed: true, | |
| object: "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", | |
| applet: true | |
| }, | |
| hasData: function(e) { | |
| e = e.nodeType ? bG.cache[e[bG.expando]] : e[bG.expando]; | |
| return !!e && !O(e) | |
| }, | |
| data: function(b1, bZ, b3, b2) { | |
| if (!bG.acceptData(b1)) { | |
| return | |
| } | |
| var b4, b6, b7 = bG.expando, | |
| b5 = typeof bZ === "string", | |
| b8 = b1.nodeType, | |
| e = b8 ? bG.cache : b1, | |
| b0 = b8 ? b1[b7] : b1[b7] && b7; | |
| if ((!b0 || !e[b0] || (!b2 && !e[b0].data)) && b5 && b3 === aB) { | |
| return | |
| } | |
| if (!b0) { | |
| if (b8) { | |
| b1[b7] = b0 = bG.deletedIds.pop() || bG.guid++ | |
| } else { | |
| b0 = b7 | |
| } | |
| } | |
| if (!e[b0]) { | |
| e[b0] = {}; | |
| if (!b8) { | |
| e[b0].toJSON = bG.noop | |
| } | |
| } | |
| if (typeof bZ === "object" || typeof bZ === "function") { | |
| if (b2) { | |
| e[b0] = bG.extend(e[b0], bZ) | |
| } else { | |
| e[b0].data = bG.extend(e[b0].data, bZ) | |
| } | |
| } | |
| b4 = e[b0]; | |
| if (!b2) { | |
| if (!b4.data) { | |
| b4.data = {} | |
| } | |
| b4 = b4.data | |
| } | |
| if (b3 !== aB) { | |
| b4[bG.camelCase(bZ)] = b3 | |
| } | |
| if (b5) { | |
| b6 = b4[bZ]; | |
| if (b6 == null) { | |
| b6 = b4[bG.camelCase(bZ)] | |
| } | |
| } else { | |
| b6 = b4 | |
| } | |
| return b6 | |
| }, | |
| removeData: function(b1, bZ, b2) { | |
| if (!bG.acceptData(b1)) { | |
| return | |
| } | |
| var b5, b4, b3, b6 = b1.nodeType, | |
| e = b6 ? bG.cache : b1, | |
| b0 = b6 ? b1[bG.expando] : bG.expando; | |
| if (!e[b0]) { | |
| return | |
| } | |
| if (bZ) { | |
| b5 = b2 ? e[b0] : e[b0].data; | |
| if (b5) { | |
| if (!bG.isArray(bZ)) { | |
| if (bZ in b5) { | |
| bZ = [bZ] | |
| } else { | |
| bZ = bG.camelCase(bZ); | |
| if (bZ in b5) { | |
| bZ = [bZ] | |
| } else { | |
| bZ = bZ.split(" ") | |
| } | |
| } | |
| } | |
| for (b4 = 0, b3 = bZ.length; b4 < b3; b4++) { | |
| delete b5[bZ[b4]] | |
| } | |
| if (!(b2 ? O : bG.isEmptyObject)(b5)) { | |
| return | |
| } | |
| } | |
| } | |
| if (!b2) { | |
| delete e[b0].data; | |
| if (!O(e[b0])) { | |
| return | |
| } | |
| } | |
| if (b6) { | |
| bG.cleanData([b1], true) | |
| } else { | |
| if (bG.support.deleteExpando || e != e.window) { | |
| delete e[b0] | |
| } else { | |
| e[b0] = null | |
| } | |
| } | |
| }, | |
| _data: function(bZ, e, b0) { | |
| return bG.data(bZ, e, b0, true) | |
| }, | |
| acceptData: function(bZ) { | |
| var e = bZ.nodeName && bG.noData[bZ.nodeName.toLowerCase()]; | |
| return !e || e !== true && bZ.getAttribute("classid") === e | |
| } | |
| }); | |
| bG.fn.extend({ | |
| data: function(b7, b6) { | |
| var b2, bZ, b5, e, b1, b0 = this[0], | |
| b4 = 0, | |
| b3 = null; | |
| if (b7 === aB) { | |
| if (this.length) { | |
| b3 = bG.data(b0); | |
| if (b0.nodeType === 1 && !bG._data(b0, "parsedAttrs")) { | |
| b5 = b0.attributes; | |
| for (b1 = b5.length; b4 < b1; b4++) { | |
| e = b5[b4].name; | |
| if (!e.indexOf("data-")) { | |
| e = bG.camelCase(e.substring(5)); | |
| bv(b0, e, b3[e]) | |
| } | |
| } | |
| bG._data(b0, "parsedAttrs", true) | |
| } | |
| } | |
| return b3 | |
| } | |
| if (typeof b7 === "object") { | |
| return this.each(function() { | |
| bG.data(this, b7) | |
| }) | |
| } | |
| b2 = b7.split(".", 2); | |
| b2[1] = b2[1] ? "." + b2[1] : ""; | |
| bZ = b2[1] + "!"; | |
| return bG.access(this, function(b8) { | |
| if (b8 === aB) { | |
| b3 = this.triggerHandler("getData" + bZ, [b2[0]]); | |
| if (b3 === aB && b0) { | |
| b3 = bG.data(b0, b7); | |
| b3 = bv(b0, b7, b3) | |
| } | |
| return b3 === aB && b2[1] ? this.data(b2[0]) : b3 | |
| } | |
| b2[1] = b8; | |
| this.each(function() { | |
| var b9 = bG(this); | |
| b9.triggerHandler("setData" + bZ, b2); | |
| bG.data(this, b7, b8); | |
| b9.triggerHandler("changeData" + bZ, b2) | |
| }) | |
| }, null, b6, arguments.length > 1, null, false) | |
| }, | |
| removeData: function(e) { | |
| return this.each(function() { | |
| bG.removeData(this, e) | |
| }) | |
| } | |
| }); | |
| function bv(b1, b0, b2) { | |
| if (b2 === aB && b1.nodeType === 1) { | |
| var bZ = "data-" + b0.replace(aL, "-$1").toLowerCase(); | |
| b2 = b1.getAttribute(bZ); | |
| if (typeof b2 === "string") { | |
| try { | |
| b2 = b2 === "true" ? true : b2 === "false" ? false : b2 === "null" ? null : +b2 + "" === b2 ? +b2 : bt.test(b2) ? bG.parseJSON(b2) : b2 | |
| } catch (b3) {} | |
| bG.data(b1, b0, b2) | |
| } else { | |
| b2 = aB | |
| } | |
| } | |
| return b2 | |
| } | |
| function O(bZ) { | |
| var e; | |
| for (e in bZ) { | |
| if (e === "data" && bG.isEmptyObject(bZ[e])) { | |
| continue | |
| } | |
| if (e !== "toJSON") { | |
| return false | |
| } | |
| } | |
| return true | |
| } | |
| bG.extend({ | |
| queue: function(b0, bZ, b1) { | |
| var e; | |
| if (b0) { | |
| bZ = (bZ || "fx") + "queue"; | |
| e = bG._data(b0, bZ); | |
| if (b1) { | |
| if (!e || bG.isArray(b1)) { | |
| e = bG._data(b0, bZ, bG.makeArray(b1)) | |
| } else { | |
| e.push(b1) | |
| } | |
| } | |
| return e || [] | |
| } | |
| }, | |
| dequeue: function(b3, b2) { | |
| b2 = b2 || "fx"; | |
| var bZ = bG.queue(b3, b2), | |
| b4 = bZ.length, | |
| b1 = bZ.shift(), | |
| e = bG._queueHooks(b3, b2), | |
| b0 = function() { | |
| bG.dequeue(b3, b2) | |
| }; | |
| if (b1 === "inprogress") { | |
| b1 = bZ.shift(); | |
| b4-- | |
| } | |
| if (b1) { | |
| if (b2 === "fx") { | |
| bZ.unshift("inprogress") | |
| } | |
| delete e.stop; | |
| b1.call(b3, b0, e) | |
| } | |
| if (!b4 && e) { | |
| e.empty.fire() | |
| } | |
| }, | |
| _queueHooks: function(b0, bZ) { | |
| var e = bZ + "queueHooks"; | |
| return bG._data(b0, e) || bG._data(b0, e, { | |
| empty: bG.Callbacks("once memory").add(function() { | |
| bG.removeData(b0, bZ + "queue", true); | |
| bG.removeData(b0, e, true) | |
| }) | |
| }) | |
| } | |
| }); | |
| bG.fn.extend({ | |
| queue: function(e, bZ) { | |
| var b0 = 2; | |
| if (typeof e !== "string") { | |
| bZ = e; | |
| e = "fx"; | |
| b0-- | |
| } | |
| if (arguments.length < b0) { | |
| return bG.queue(this[0], e) | |
| } | |
| return bZ === aB ? this : this.each(function() { | |
| var b1 = bG.queue(this, e, bZ); | |
| bG._queueHooks(this, e); | |
| if (e === "fx" && b1[0] !== "inprogress") { | |
| bG.dequeue(this, e) | |
| } | |
| }) | |
| }, | |
| dequeue: function(e) { | |
| return this.each(function() { | |
| bG.dequeue(this, e) | |
| }) | |
| }, | |
| delay: function(bZ, e) { | |
| bZ = bG.fx ? bG.fx.speeds[bZ] || bZ : bZ; | |
| e = e || "fx"; | |
| return this.queue(e, function(b1, b0) { | |
| var b2 = setTimeout(b1, bZ); | |
| b0.stop = function() { | |
| clearTimeout(b2) | |
| } | |
| }) | |
| }, | |
| clearQueue: function(e) { | |
| return this.queue(e || "fx", []) | |
| }, | |
| promise: function(b0, b4) { | |
| var bZ, b1 = 1, | |
| b5 = bG.Deferred(), | |
| b3 = this, | |
| e = this.length, | |
| b2 = function() { | |
| if (!(--b1)) { | |
| b5.resolveWith(b3, [b3]) | |
| } | |
| }; | |
| if (typeof b0 !== "string") { | |
| b4 = b0; | |
| b0 = aB | |
| } | |
| b0 = b0 || "fx"; | |
| while (e--) { | |
| bZ = bG._data(b3[e], b0 + "queueHooks"); | |
| if (bZ && bZ.empty) { | |
| b1++; | |
| bZ.empty.add(b2) | |
| } | |
| } | |
| b2(); | |
| return b5.promise(b4) | |
| } | |
| }); | |
| var a7, bV, n, bJ = /[\t\r\n]/g, | |
| ai = /\r/g, | |
| j = /^(?:button|input)$/i, | |
| aA = /^(?:button|input|object|select|textarea)$/i, | |
| D = /^a(?:rea|)$/i, | |
| M = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, | |
| bL = bG.support.getSetAttribute; | |
| bG.fn.extend({ | |
| attr: function(e, bZ) { | |
| return bG.access(this, bG.attr, e, bZ, arguments.length > 1) | |
| }, | |
| removeAttr: function(e) { | |
| return this.each(function() { | |
| bG.removeAttr(this, e) | |
| }) | |
| }, | |
| prop: function(e, bZ) { | |
| return bG.access(this, bG.prop, e, bZ, arguments.length > 1) | |
| }, | |
| removeProp: function(e) { | |
| e = bG.propFix[e] || e; | |
| return this.each(function() { | |
| try { | |
| this[e] = aB; | |
| delete this[e] | |
| } catch (bZ) {} | |
| }) | |
| }, | |
| addClass: function(b2) { | |
| var b4, b0, bZ, b1, b3, b5, e; | |
| if (bG.isFunction(b2)) { | |
| return this.each(function(b6) { | |
| bG(this).addClass(b2.call(this, b6, this.className)) | |
| }) | |
| } | |
| if (b2 && typeof b2 === "string") { | |
| b4 = b2.split(aV); | |
| for (b0 = 0, bZ = this.length; b0 < bZ; b0++) { | |
| b1 = this[b0]; | |
| if (b1.nodeType === 1) { | |
| if (!b1.className && b4.length === 1) { | |
| b1.className = b2 | |
| } else { | |
| b3 = " " + b1.className + " "; | |
| for (b5 = 0, e = b4.length; b5 < e; b5++) { | |
| if (b3.indexOf(" " + b4[b5] + " ") < 0) { | |
| b3 += b4[b5] + " " | |
| } | |
| } | |
| b1.className = bG.trim(b3) | |
| } | |
| } | |
| } | |
| } | |
| return this | |
| }, | |
| removeClass: function(b4) { | |
| var b1, b2, b3, b5, bZ, b0, e; | |
| if (bG.isFunction(b4)) { | |
| return this.each(function(b6) { | |
| bG(this).removeClass(b4.call(this, b6, this.className)) | |
| }) | |
| } | |
| if ((b4 && typeof b4 === "string") || b4 === aB) { | |
| b1 = (b4 || "").split(aV); | |
| for (b0 = 0, e = this.length; b0 < e; b0++) { | |
| b3 = this[b0]; | |
| if (b3.nodeType === 1 && b3.className) { | |
| b2 = (" " + b3.className + " ").replace(bJ, " "); | |
| for (b5 = 0, bZ = b1.length; b5 < bZ; b5++) { | |
| while (b2.indexOf(" " + b1[b5] + " ") >= 0) { | |
| b2 = b2.replace(" " + b1[b5] + " ", " ") | |
| } | |
| } | |
| b3.className = b4 ? bG.trim(b2) : "" | |
| } | |
| } | |
| } | |
| return this | |
| }, | |
| toggleClass: function(b1, bZ) { | |
| var b0 = typeof b1, | |
| e = typeof bZ === "boolean"; | |
| if (bG.isFunction(b1)) { | |
| return this.each(function(b2) { | |
| bG(this).toggleClass(b1.call(this, b2, this.className, bZ), bZ) | |
| }) | |
| } | |
| return this.each(function() { | |
| if (b0 === "string") { | |
| var b4, b3 = 0, | |
| b2 = bG(this), | |
| b5 = bZ, | |
| b6 = b1.split(aV); | |
| while ((b4 = b6[b3++])) { | |
| b5 = e ? b5 : !b2.hasClass(b4); | |
| b2[b5 ? "addClass" : "removeClass"](b4) | |
| } | |
| } else { | |
| if (b0 === "undefined" || b0 === "boolean") { | |
| if (this.className) { | |
| bG._data(this, "__className__", this.className) | |
| } | |
| this.className = this.className || b1 === false ? "" : bG._data(this, "__className__") || "" | |
| } | |
| } | |
| }) | |
| }, | |
| hasClass: function(e) { | |
| var b1 = " " + e + " ", | |
| b0 = 0, | |
| bZ = this.length; | |
| for (; b0 < bZ; b0++) { | |
| if (this[b0].nodeType === 1 && (" " + this[b0].className + " ").replace(bJ, " ").indexOf(b1) >= 0) { | |
| return true | |
| } | |
| } | |
| return false | |
| }, | |
| val: function(b1) { | |
| var e, bZ, b2, b0 = this[0]; | |
| if (!arguments.length) { | |
| if (b0) { | |
| e = bG.valHooks[b0.type] || bG.valHooks[b0.nodeName.toLowerCase()]; | |
| if (e && "get" in e && (bZ = e.get(b0, "value")) !== aB) { | |
| return bZ | |
| } | |
| bZ = b0.value; | |
| return typeof bZ === "string" ? bZ.replace(ai, "") : bZ == null ? "" : bZ | |
| } | |
| return | |
| } | |
| b2 = bG.isFunction(b1); | |
| return this.each(function(b4) { | |
| var b5, b3 = bG(this); | |
| if (this.nodeType !== 1) { | |
| return | |
| } | |
| if (b2) { | |
| b5 = b1.call(this, b4, b3.val()) | |
| } else { | |
| b5 = b1 | |
| } | |
| if (b5 == null) { | |
| b5 = "" | |
| } else { | |
| if (typeof b5 === "number") { | |
| b5 += "" | |
| } else { | |
| if (bG.isArray(b5)) { | |
| b5 = bG.map(b5, function(b6) { | |
| return b6 == null ? "" : b6 + "" | |
| }) | |
| } | |
| } | |
| } | |
| e = bG.valHooks[this.type] || bG.valHooks[this.nodeName.toLowerCase()]; | |
| if (!e || !("set" in e) || e.set(this, b5, "value") === aB) { | |
| this.value = b5 | |
| } | |
| }) | |
| } | |
| }); | |
| bG.extend({ | |
| valHooks: { | |
| option: { | |
| get: function(e) { | |
| var bZ = e.attributes.value; | |
| return !bZ || bZ.specified ? e.value : e.text | |
| } | |
| }, | |
| select: { | |
| get: function(e) { | |
| var b4, bZ, b3, b1, b2 = e.selectedIndex, | |
| b5 = [], | |
| b6 = e.options, | |
| b0 = e.type === "select-one"; | |
| if (b2 < 0) { | |
| return null | |
| } | |
| bZ = b0 ? b2 : 0; | |
| b3 = b0 ? b2 + 1 : b6.length; | |
| for (; bZ < b3; bZ++) { | |
| b1 = b6[bZ]; | |
| if (b1.selected && (bG.support.optDisabled ? !b1.disabled : b1.getAttribute("disabled") === null) && (!b1.parentNode.disabled || !bG.nodeName(b1.parentNode, "optgroup"))) { | |
| b4 = bG(b1).val(); | |
| if (b0) { | |
| return b4 | |
| } | |
| b5.push(b4) | |
| } | |
| } | |
| if (b0 && !b5.length && b6.length) { | |
| return bG(b6[b2]).val() | |
| } | |
| return b5 | |
| }, | |
| set: function(bZ, b0) { | |
| var e = bG.makeArray(b0); | |
| bG(bZ).find("option").each(function() { | |
| this.selected = bG.inArray(bG(this).val(), e) >= 0 | |
| }); | |
| if (!e.length) { | |
| bZ.selectedIndex = -1 | |
| } | |
| return e | |
| } | |
| } | |
| }, | |
| attrFn: {}, | |
| attr: function(b4, b1, b5, b3) { | |
| var b0, e, b2, bZ = b4.nodeType; | |
| if (!b4 || bZ === 3 || bZ === 8 || bZ === 2) { | |
| return | |
| } | |
| if (b3 && bG.isFunction(bG.fn[b1])) { | |
| return bG(b4)[b1](b5) | |
| } | |
| if (typeof b4.getAttribute === "undefined") { | |
| return bG.prop(b4, b1, b5) | |
| } | |
| b2 = bZ !== 1 || !bG.isXMLDoc(b4); | |
| if (b2) { | |
| b1 = b1.toLowerCase(); | |
| e = bG.attrHooks[b1] || (M.test(b1) ? bV : a7) | |
| } | |
| if (b5 !== aB) { | |
| if (b5 === null) { | |
| bG.removeAttr(b4, b1); | |
| return | |
| } else { | |
| if (e && "set" in e && b2 && (b0 = e.set(b4, b5, b1)) !== aB) { | |
| return b0 | |
| } else { | |
| b4.setAttribute(b1, b5 + ""); | |
| return b5 | |
| } | |
| } | |
| } else { | |
| if (e && "get" in e && b2 && (b0 = e.get(b4, b1)) !== null) { | |
| return b0 | |
| } else { | |
| b0 = b4.getAttribute(b1); | |
| return b0 === null ? aB : b0 | |
| } | |
| } | |
| }, | |
| removeAttr: function(b1, b3) { | |
| var b2, b4, bZ, e, b0 = 0; | |
| if (b3 && b1.nodeType === 1) { | |
| b4 = b3.split(aV); | |
| for (; b0 < b4.length; b0++) { | |
| bZ = b4[b0]; | |
| if (bZ) { | |
| b2 = bG.propFix[bZ] || bZ; | |
| e = M.test(bZ); | |
| if (!e) { | |
| bG.attr(b1, bZ, "") | |
| } | |
| b1.removeAttribute(bL ? bZ : b2); | |
| if (e && b2 in b1) { | |
| b1[b2] = false | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| attrHooks: { | |
| type: { | |
| set: function(e, bZ) { | |
| if (j.test(e.nodeName) && e.parentNode) { | |
| bG.error("type property can't be changed") | |
| } else { | |
| if (!bG.support.radioValue && bZ === "radio" && bG.nodeName(e, "input")) { | |
| var b0 = e.value; | |
| e.setAttribute("type", bZ); | |
| if (b0) { | |
| e.value = b0 | |
| } | |
| return bZ | |
| } | |
| } | |
| } | |
| }, | |
| value: { | |
| get: function(bZ, e) { | |
| if (a7 && bG.nodeName(bZ, "button")) { | |
| return a7.get(bZ, e) | |
| } | |
| return e in bZ ? bZ.value : null | |
| }, | |
| set: function(bZ, b0, e) { | |
| if (a7 && bG.nodeName(bZ, "button")) { | |
| return a7.set(bZ, b0, e) | |
| } | |
| bZ.value = b0 | |
| } | |
| } | |
| }, | |
| propFix: { | |
| tabindex: "tabIndex", | |
| readonly: "readOnly", | |
| "for": "htmlFor", | |
| "class": "className", | |
| maxlength: "maxLength", | |
| cellspacing: "cellSpacing", | |
| cellpadding: "cellPadding", | |
| rowspan: "rowSpan", | |
| colspan: "colSpan", | |
| usemap: "useMap", | |
| frameborder: "frameBorder", | |
| contenteditable: "contentEditable" | |
| }, | |
| prop: function(b3, b1, b4) { | |
| var b0, e, b2, bZ = b3.nodeType; | |
| if (!b3 || bZ === 3 || bZ === 8 || bZ === 2) { | |
| return | |
| } | |
| b2 = bZ !== 1 || !bG.isXMLDoc(b3); | |
| if (b2) { | |
| b1 = bG.propFix[b1] || b1; | |
| e = bG.propHooks[b1] | |
| } | |
| if (b4 !== aB) { | |
| if (e && "set" in e && (b0 = e.set(b3, b4, b1)) !== aB) { | |
| return b0 | |
| } else { | |
| return (b3[b1] = b4) | |
| } | |
| } else { | |
| if (e && "get" in e && (b0 = e.get(b3, b1)) !== null) { | |
| return b0 | |
| } else { | |
| return b3[b1] | |
| } | |
| } | |
| }, | |
| propHooks: { | |
| tabIndex: { | |
| get: function(bZ) { | |
| var e = bZ.getAttributeNode("tabindex"); | |
| return e && e.specified ? parseInt(e.value, 10) : aA.test(bZ.nodeName) || D.test(bZ.nodeName) && bZ.href ? 0 : aB | |
| } | |
| } | |
| } | |
| }); | |
| bV = { | |
| get: function(bZ, e) { | |
| var b1, b0 = bG.prop(bZ, e); | |
| return b0 === true || typeof b0 !== "boolean" && (b1 = bZ.getAttributeNode(e)) && b1.nodeValue !== false ? e.toLowerCase() : aB | |
| }, | |
| set: function(bZ, b1, e) { | |
| var b0; | |
| if (b1 === false) { | |
| bG.removeAttr(bZ, e) | |
| } else { | |
| b0 = bG.propFix[e] || e; | |
| if (b0 in bZ) { | |
| bZ[b0] = true | |
| } | |
| bZ.setAttribute(e, e.toLowerCase()) | |
| } | |
| return e | |
| } | |
| }; | |
| if (!bL) { | |
| n = { | |
| name: true, | |
| id: true, | |
| coords: true | |
| }; | |
| a7 = bG.valHooks.button = { | |
| get: function(b0, bZ) { | |
| var e; | |
| e = b0.getAttributeNode(bZ); | |
| return e && (n[bZ] ? e.value !== "" : e.specified) ? e.value : aB | |
| }, | |
| set: function(b0, b1, bZ) { | |
| var e = b0.getAttributeNode(bZ); | |
| if (!e) { | |
| e = o.createAttribute(bZ); | |
| b0.setAttributeNode(e) | |
| } | |
| return (e.value = b1 + "") | |
| } | |
| }; | |
| bG.each(["width", "height"], function(bZ, e) { | |
| bG.attrHooks[e] = bG.extend(bG.attrHooks[e], { | |
| set: function(b0, b1) { | |
| if (b1 === "") { | |
| b0.setAttribute(e, "auto"); | |
| return b1 | |
| } | |
| } | |
| }) | |
| }); | |
| bG.attrHooks.contenteditable = { | |
| get: a7.get, | |
| set: function(bZ, b0, e) { | |
| if (b0 === "") { | |
| b0 = "false" | |
| } | |
| a7.set(bZ, b0, e) | |
| } | |
| } | |
| } | |
| if (!bG.support.hrefNormalized) { | |
| bG.each(["href", "src", "width", "height"], function(bZ, e) { | |
| bG.attrHooks[e] = bG.extend(bG.attrHooks[e], { | |
| get: function(b1) { | |
| var b0 = b1.getAttribute(e, 2); | |
| return b0 === null ? aB : b0 | |
| } | |
| }) | |
| }) | |
| } | |
| if (!bG.support.style) { | |
| bG.attrHooks.style = { | |
| get: function(e) { | |
| return e.style.cssText.toLowerCase() || aB | |
| }, | |
| set: function(e, bZ) { | |
| return (e.style.cssText = bZ + "") | |
| } | |
| } | |
| } | |
| if (!bG.support.optSelected) { | |
| bG.propHooks.selected = bG.extend(bG.propHooks.selected, { | |
| get: function(bZ) { | |
| var e = bZ.parentNode; | |
| if (e) { | |
| e.selectedIndex; | |
| if (e.parentNode) { | |
| e.parentNode.selectedIndex | |
| } | |
| } | |
| return null | |
| } | |
| }) | |
| } | |
| if (!bG.support.enctype) { | |
| bG.propFix.enctype = "encoding" | |
| } | |
| if (!bG.support.checkOn) { | |
| bG.each(["radio", "checkbox"], function() { | |
| bG.valHooks[this] = { | |
| get: function(e) { | |
| return e.getAttribute("value") === null ? "on" : e.value | |
| } | |
| } | |
| }) | |
| } | |
| bG.each(["radio", "checkbox"], function() { | |
| bG.valHooks[this] = bG.extend(bG.valHooks[this], { | |
| set: function(e, bZ) { | |
| if (bG.isArray(bZ)) { | |
| return (e.checked = bG.inArray(bG(e).val(), bZ) >= 0) | |
| } | |
| } | |
| }) | |
| }); | |
| var bE = /^(?:textarea|input|select)$/i, | |
| br = /^([^\.]*|)(?:\.(.+)|)$/, | |
| ba = /(?:^|\s)hover(\.\S+|)\b/, | |
| a3 = /^key/, | |
| bK = /^(?:mouse|contextmenu)|click/, | |
| by = /^(?:focusinfocus|focusoutblur)$/, | |
| aq = function(e) { | |
| return bG.event.special.hover ? e : e.replace(ba, "mouseenter$1 mouseleave$1") | |
| }; | |
| bG.event = { | |
| add: function(b1, b5, cc, b3, b2) { | |
| var b6, b4, cd, cb, ca, b8, e, b9, bZ, b0, b7; | |
| if (b1.nodeType === 3 || b1.nodeType === 8 || !b5 || !cc || !(b6 = bG._data(b1))) { | |
| return | |
| } | |
| if (cc.handler) { | |
| bZ = cc; | |
| cc = bZ.handler; | |
| b2 = bZ.selector | |
| } | |
| if (!cc.guid) { | |
| cc.guid = bG.guid++ | |
| } | |
| cd = b6.events; | |
| if (!cd) { | |
| b6.events = cd = {} | |
| } | |
| b4 = b6.handle; | |
| if (!b4) { | |
| b6.handle = b4 = function(ce) { | |
| return typeof bG !== "undefined" && (!ce || bG.event.triggered !== ce.type) ? bG.event.dispatch.apply(b4.elem, arguments) : aB | |
| }; | |
| b4.elem = b1 | |
| } | |
| b5 = bG.trim(aq(b5)).split(" "); | |
| for (cb = 0; cb < b5.length; cb++) { | |
| ca = br.exec(b5[cb]) || []; | |
| b8 = ca[1]; | |
| e = (ca[2] || "").split(".").sort(); | |
| b7 = bG.event.special[b8] || {}; | |
| b8 = (b2 ? b7.delegateType : b7.bindType) || b8; | |
| b7 = bG.event.special[b8] || {}; | |
| b9 = bG.extend({ | |
| type: b8, | |
| origType: ca[1], | |
| data: b3, | |
| handler: cc, | |
| guid: cc.guid, | |
| selector: b2, | |
| needsContext: b2 && bG.expr.match.needsContext.test(b2), | |
| namespace: e.join(".") | |
| }, bZ); | |
| b0 = cd[b8]; | |
| if (!b0) { | |
| b0 = cd[b8] = []; | |
| b0.delegateCount = 0; | |
| if (!b7.setup || b7.setup.call(b1, b3, e, b4) === false) { | |
| if (b1.addEventListener) { | |
| b1.addEventListener(b8, b4, false) | |
| } else { | |
| if (b1.attachEvent) { | |
| b1.attachEvent("on" + b8, b4) | |
| } | |
| } | |
| } | |
| } | |
| if (b7.add) { | |
| b7.add.call(b1, b9); | |
| if (!b9.handler.guid) { | |
| b9.handler.guid = cc.guid | |
| } | |
| } | |
| if (b2) { | |
| b0.splice(b0.delegateCount++, 0, b9) | |
| } else { | |
| b0.push(b9) | |
| } | |
| bG.event.global[b8] = true | |
| } | |
| b1 = null | |
| }, | |
| global: {}, | |
| remove: function(b1, b6, cc, b2, b5) { | |
| var cd, ce, b9, b0, bZ, b3, b4, cb, b8, e, ca, b7 = bG.hasData(b1) && bG._data(b1); | |
| if (!b7 || !(cb = b7.events)) { | |
| return | |
| } | |
| b6 = bG.trim(aq(b6 || "")).split(" "); | |
| for (cd = 0; cd < b6.length; cd++) { | |
| ce = br.exec(b6[cd]) || []; | |
| b9 = b0 = ce[1]; | |
| bZ = ce[2]; | |
| if (!b9) { | |
| for (b9 in cb) { | |
| bG.event.remove(b1, b9 + b6[cd], cc, b2, true) | |
| } | |
| continue | |
| } | |
| b8 = bG.event.special[b9] || {}; | |
| b9 = (b2 ? b8.delegateType : b8.bindType) || b9; | |
| e = cb[b9] || []; | |
| b3 = e.length; | |
| bZ = bZ ? new RegExp("(^|\\.)" + bZ.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null; | |
| for (b4 = 0; b4 < e.length; b4++) { | |
| ca = e[b4]; | |
| if ((b5 || b0 === ca.origType) && (!cc || cc.guid === ca.guid) && (!bZ || bZ.test(ca.namespace)) && (!b2 || b2 === ca.selector || b2 === "**" && ca.selector)) { | |
| e.splice(b4--, 1); | |
| if (ca.selector) { | |
| e.delegateCount-- | |
| } | |
| if (b8.remove) { | |
| b8.remove.call(b1, ca) | |
| } | |
| } | |
| } | |
| if (e.length === 0 && b3 !== e.length) { | |
| if (!b8.teardown || b8.teardown.call(b1, bZ, b7.handle) === false) { | |
| bG.removeEvent(b1, b9, b7.handle) | |
| } | |
| delete cb[b9] | |
| } | |
| } | |
| if (bG.isEmptyObject(cb)) { | |
| delete b7.handle; | |
| bG.removeData(b1, "events", true) | |
| } | |
| }, | |
| customEvent: { | |
| getData: true, | |
| setData: true, | |
| changeData: true | |
| }, | |
| trigger: function(bZ, b6, b4, cd) { | |
| if (b4 && (b4.nodeType === 3 || b4.nodeType === 8)) { | |
| return | |
| } | |
| var e, b1, b7, cb, b3, b2, b9, b8, b5, cc, ca = bZ.type || bZ, | |
| b0 = []; | |
| if (by.test(ca + bG.event.triggered)) { | |
| return | |
| } | |
| if (ca.indexOf("!") >= 0) { | |
| ca = ca.slice(0, -1); | |
| b1 = true | |
| } | |
| if (ca.indexOf(".") >= 0) { | |
| b0 = ca.split("."); | |
| ca = b0.shift(); | |
| b0.sort() | |
| } | |
| if ((!b4 || bG.event.customEvent[ca]) && !bG.event.global[ca]) { | |
| return | |
| } | |
| bZ = typeof bZ === "object" ? bZ[bG.expando] ? bZ : new bG.Event(ca, bZ) : new bG.Event(ca); | |
| bZ.type = ca; | |
| bZ.isTrigger = true; | |
| bZ.exclusive = b1; | |
| bZ.namespace = b0.join("."); | |
| bZ.namespace_re = bZ.namespace ? new RegExp("(^|\\.)" + b0.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; | |
| b2 = ca.indexOf(":") < 0 ? "on" + ca : ""; | |
| if (!b4) { | |
| e = bG.cache; | |
| for (b7 in e) { | |
| if (e[b7].events && e[b7].events[ca]) { | |
| bG.event.trigger(bZ, b6, e[b7].handle.elem, true) | |
| } | |
| } | |
| return | |
| } | |
| bZ.result = aB; | |
| if (!bZ.target) { | |
| bZ.target = b4 | |
| } | |
| b6 = b6 != null ? bG.makeArray(b6) : []; | |
| b6.unshift(bZ); | |
| b9 = bG.event.special[ca] || {}; | |
| if (b9.trigger && b9.trigger.apply(b4, b6) === false) { | |
| return | |
| } | |
| b5 = [ | |
| [b4, b9.bindType || ca] | |
| ]; | |
| if (!cd && !b9.noBubble && !bG.isWindow(b4)) { | |
| cc = b9.delegateType || ca; | |
| cb = by.test(cc + ca) ? b4 : b4.parentNode; | |
| for (b3 = b4; cb; cb = cb.parentNode) { | |
| b5.push([cb, cc]); | |
| b3 = cb | |
| } | |
| if (b3 === (b4.ownerDocument || o)) { | |
| b5.push([b3.defaultView || b3.parentWindow || a2, cc]) | |
| } | |
| } | |
| for (b7 = 0; b7 < b5.length && !bZ.isPropagationStopped(); b7++) { | |
| cb = b5[b7][0]; | |
| bZ.type = b5[b7][1]; | |
| b8 = (bG._data(cb, "events") || {})[bZ.type] && bG._data(cb, "handle"); | |
| if (b8) { | |
| b8.apply(cb, b6) | |
| } | |
| b8 = b2 && cb[b2]; | |
| if (b8 && bG.acceptData(cb) && b8.apply && b8.apply(cb, b6) === false) { | |
| bZ.preventDefault() | |
| } | |
| } | |
| bZ.type = ca; | |
| if (!cd && !bZ.isDefaultPrevented()) { | |
| if ((!b9._default || b9._default.apply(b4.ownerDocument, b6) === false) && !(ca === "click" && bG.nodeName(b4, "a")) && bG.acceptData(b4)) { | |
| if (b2 && b4[ca] && ((ca !== "focus" && ca !== "blur") || bZ.target.offsetWidth !== 0) && !bG.isWindow(b4)) { | |
| b3 = b4[b2]; | |
| if (b3) { | |
| b4[b2] = null | |
| } | |
| bG.event.triggered = ca; | |
| b4[ca](); | |
| bG.event.triggered = aB; | |
| if (b3) { | |
| b4[b2] = b3 | |
| } | |
| } | |
| } | |
| } | |
| return bZ.result | |
| }, | |
| dispatch: function(e) { | |
| e = bG.event.fix(e || a2.event); | |
| var b5, b4, ce, b8, b7, bZ, b6, cc, b1, cd, b2 = ((bG._data(this, "events") || {})[e.type] || []), | |
| b3 = b2.delegateCount, | |
| ca = a4.call(arguments), | |
| b0 = !e.exclusive && !e.namespace, | |
| b9 = bG.event.special[e.type] || {}, | |
| cb = []; | |
| ca[0] = e; | |
| e.delegateTarget = this; | |
| if (b9.preDispatch && b9.preDispatch.call(this, e) === false) { | |
| return | |
| } | |
| if (b3 && !(e.button && e.type === "click")) { | |
| for (ce = e.target; ce != this; ce = ce.parentNode || this) { | |
| if (ce.disabled !== true || e.type !== "click") { | |
| b7 = {}; | |
| b6 = []; | |
| for (b5 = 0; b5 < b3; b5++) { | |
| cc = b2[b5]; | |
| b1 = cc.selector; | |
| if (b7[b1] === aB) { | |
| b7[b1] = cc.needsContext ? bG(b1, this).index(ce) >= 0 : bG.find(b1, this, null, [ce]).length | |
| } | |
| if (b7[b1]) { | |
| b6.push(cc) | |
| } | |
| } | |
| if (b6.length) { | |
| cb.push({ | |
| elem: ce, | |
| matches: b6 | |
| }) | |
| } | |
| } | |
| } | |
| } | |
| if (b2.length > b3) { | |
| cb.push({ | |
| elem: this, | |
| matches: b2.slice(b3) | |
| }) | |
| } | |
| for (b5 = 0; b5 < cb.length && !e.isPropagationStopped(); b5++) { | |
| bZ = cb[b5]; | |
| e.currentTarget = bZ.elem; | |
| for (b4 = 0; b4 < bZ.matches.length && !e.isImmediatePropagationStopped(); b4++) { | |
| cc = bZ.matches[b4]; | |
| if (b0 || (!e.namespace && !cc.namespace) || e.namespace_re && e.namespace_re.test(cc.namespace)) { | |
| e.data = cc.data; | |
| e.handleObj = cc; | |
| b8 = ((bG.event.special[cc.origType] || {}).handle || cc.handler).apply(bZ.elem, ca); | |
| if (b8 !== aB) { | |
| e.result = b8; | |
| if (b8 === false) { | |
| e.preventDefault(); | |
| e.stopPropagation() | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (b9.postDispatch) { | |
| b9.postDispatch.call(this, e) | |
| } | |
| return e.result | |
| }, | |
| props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), | |
| fixHooks: {}, | |
| keyHooks: { | |
| props: "char charCode key keyCode".split(" "), | |
| filter: function(bZ, e) { | |
| if (bZ.which == null) { | |
| bZ.which = e.charCode != null ? e.charCode : e.keyCode | |
| } | |
| return bZ | |
| } | |
| }, | |
| mouseHooks: { | |
| props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), | |
| filter: function(b1, b0) { | |
| var b2, b3, e, bZ = b0.button, | |
| b4 = b0.fromElement; | |
| if (b1.pageX == null && b0.clientX != null) { | |
| b2 = b1.target.ownerDocument || o; | |
| b3 = b2.documentElement; | |
| e = b2.body; | |
| b1.pageX = b0.clientX + (b3 && b3.scrollLeft || e && e.scrollLeft || 0) - (b3 && b3.clientLeft || e && e.clientLeft || 0); | |
| b1.pageY = b0.clientY + (b3 && b3.scrollTop || e && e.scrollTop || 0) - (b3 && b3.clientTop || e && e.clientTop || 0) | |
| } | |
| if (!b1.relatedTarget && b4) { | |
| b1.relatedTarget = b4 === b1.target ? b0.toElement : b4 | |
| } | |
| if (!b1.which && bZ !== aB) { | |
| b1.which = (bZ & 1 ? 1 : (bZ & 2 ? 3 : (bZ & 4 ? 2 : 0))) | |
| } | |
| return b1 | |
| } | |
| }, | |
| fix: function(b0) { | |
| if (b0[bG.expando]) { | |
| return b0 | |
| } | |
| var bZ, b3, e = b0, | |
| b1 = bG.event.fixHooks[b0.type] || {}, | |
| b2 = b1.props ? this.props.concat(b1.props) : this.props; | |
| b0 = bG.Event(e); | |
| for (bZ = b2.length; bZ;) { | |
| b3 = b2[--bZ]; | |
| b0[b3] = e[b3] | |
| } | |
| if (!b0.target) { | |
| b0.target = e.srcElement || o | |
| } | |
| if (b0.target.nodeType === 3) { | |
| b0.target = b0.target.parentNode | |
| } | |
| b0.metaKey = !! b0.metaKey; | |
| return b1.filter ? b1.filter(b0, e) : b0 | |
| }, | |
| special: { | |
| load: { | |
| noBubble: true | |
| }, | |
| focus: { | |
| delegateType: "focusin" | |
| }, | |
| blur: { | |
| delegateType: "focusout" | |
| }, | |
| beforeunload: { | |
| setup: function(b0, bZ, e) { | |
| if (bG.isWindow(this)) { | |
| this.onbeforeunload = e | |
| } | |
| }, | |
| teardown: function(bZ, e) { | |
| if (this.onbeforeunload === e) { | |
| this.onbeforeunload = null | |
| } | |
| } | |
| } | |
| }, | |
| simulate: function(b0, b2, b1, bZ) { | |
| var b3 = bG.extend(new bG.Event(), b1, { | |
| type: b0, | |
| isSimulated: true, | |
| originalEvent: {} | |
| }); | |
| if (bZ) { | |
| bG.event.trigger(b3, null, b2) | |
| } else { | |
| bG.event.dispatch.call(b2, b3) | |
| } | |
| if (b3.isDefaultPrevented()) { | |
| b1.preventDefault() | |
| } | |
| } | |
| }; | |
| bG.event.handle = bG.event.dispatch; | |
| bG.removeEvent = o.removeEventListener ? | |
| function(bZ, e, b0) { | |
| if (bZ.removeEventListener) { | |
| bZ.removeEventListener(e, b0, false) | |
| } | |
| } : function(b0, bZ, b1) { | |
| var e = "on" + bZ; | |
| if (b0.detachEvent) { | |
| if (typeof b0[e] === "undefined") { | |
| b0[e] = null | |
| } | |
| b0.detachEvent(e, b1) | |
| } | |
| }; | |
| bG.Event = function(bZ, e) { | |
| if (!(this instanceof bG.Event)) { | |
| return new bG.Event(bZ, e) | |
| } | |
| if (bZ && bZ.type) { | |
| this.originalEvent = bZ; | |
| this.type = bZ.type; | |
| this.isDefaultPrevented = (bZ.defaultPrevented || bZ.returnValue === false || bZ.getPreventDefault && bZ.getPreventDefault()) ? R : X | |
| } else { | |
| this.type = bZ | |
| } | |
| if (e) { | |
| bG.extend(this, e) | |
| } | |
| this.timeStamp = bZ && bZ.timeStamp || bG.now(); | |
| this[bG.expando] = true | |
| }; | |
| function X() { | |
| return false | |
| } | |
| function R() { | |
| return true | |
| } | |
| bG.Event.prototype = { | |
| preventDefault: function() { | |
| this.isDefaultPrevented = R; | |
| var bZ = this.originalEvent; | |
| if (!bZ) { | |
| return | |
| } | |
| if (bZ.preventDefault) { | |
| bZ.preventDefault() | |
| } else { | |
| bZ.returnValue = false | |
| } | |
| }, | |
| stopPropagation: function() { | |
| this.isPropagationStopped = R; | |
| var bZ = this.originalEvent; | |
| if (!bZ) { | |
| return | |
| } | |
| if (bZ.stopPropagation) { | |
| bZ.stopPropagation() | |
| } | |
| bZ.cancelBubble = true | |
| }, | |
| stopImmediatePropagation: function() { | |
| this.isImmediatePropagationStopped = R; | |
| this.stopPropagation() | |
| }, | |
| isDefaultPrevented: X, | |
| isPropagationStopped: X, | |
| isImmediatePropagationStopped: X | |
| }; | |
| bG.each({ | |
| mouseenter: "mouseover", | |
| mouseleave: "mouseout" | |
| }, function(bZ, e) { | |
| bG.event.special[bZ] = { | |
| delegateType: e, | |
| bindType: e, | |
| handle: function(b3) { | |
| var b1, b5 = this, | |
| b4 = b3.relatedTarget, | |
| b2 = b3.handleObj, | |
| b0 = b2.selector; | |
| if (!b4 || (b4 !== b5 && !bG.contains(b5, b4))) { | |
| b3.type = b2.origType; | |
| b1 = b2.handler.apply(this, arguments); | |
| b3.type = e | |
| } | |
| return b1 | |
| } | |
| } | |
| }); | |
| if (!bG.support.submitBubbles) { | |
| bG.event.special.submit = { | |
| setup: function() { | |
| if (bG.nodeName(this, "form")) { | |
| return false | |
| } | |
| bG.event.add(this, "click._submit keypress._submit", function(b1) { | |
| var b0 = b1.target, | |
| bZ = bG.nodeName(b0, "input") || bG.nodeName(b0, "button") ? b0.form : aB; | |
| if (bZ && !bG._data(bZ, "_submit_attached")) { | |
| bG.event.add(bZ, "submit._submit", function(e) { | |
| e._submit_bubble = true | |
| }); | |
| bG._data(bZ, "_submit_attached", true) | |
| } | |
| }) | |
| }, | |
| postDispatch: function(e) { | |
| if (e._submit_bubble) { | |
| delete e._submit_bubble; | |
| if (this.parentNode && !e.isTrigger) { | |
| bG.event.simulate("submit", this.parentNode, e, true) | |
| } | |
| } | |
| }, | |
| teardown: function() { | |
| if (bG.nodeName(this, "form")) { | |
| return false | |
| } | |
| bG.event.remove(this, "._submit") | |
| } | |
| } | |
| } | |
| if (!bG.support.changeBubbles) { | |
| bG.event.special.change = { | |
| setup: function() { | |
| if (bE.test(this.nodeName)) { | |
| if (this.type === "checkbox" || this.type === "radio") { | |
| bG.event.add(this, "propertychange._change", function(e) { | |
| if (e.originalEvent.propertyName === "checked") { | |
| this._just_changed = true | |
| } | |
| }); | |
| bG.event.add(this, "click._change", function(e) { | |
| if (this._just_changed && !e.isTrigger) { | |
| this._just_changed = false | |
| } | |
| bG.event.simulate("change", this, e, true) | |
| }) | |
| } | |
| return false | |
| } | |
| bG.event.add(this, "beforeactivate._change", function(b0) { | |
| var bZ = b0.target; | |
| if (bE.test(bZ.nodeName) && !bG._data(bZ, "_change_attached")) { | |
| bG.event.add(bZ, "change._change", function(e) { | |
| if (this.parentNode && !e.isSimulated && !e.isTrigger) { | |
| bG.event.simulate("change", this.parentNode, e, true) | |
| } | |
| }); | |
| bG._data(bZ, "_change_attached", true) | |
| } | |
| }) | |
| }, | |
| handle: function(bZ) { | |
| var e = bZ.target; | |
| if (this !== e || bZ.isSimulated || bZ.isTrigger || (e.type !== "radio" && e.type !== "checkbox")) { | |
| return bZ.handleObj.handler.apply(this, arguments) | |
| } | |
| }, | |
| teardown: function() { | |
| bG.event.remove(this, "._change"); | |
| return !bE.test(this.nodeName) | |
| } | |
| } | |
| } | |
| if (!bG.support.focusinBubbles) { | |
| bG.each({ | |
| focus: "focusin", | |
| blur: "focusout" | |
| }, function(b1, e) { | |
| var bZ = 0, | |
| b0 = function(b2) { | |
| bG.event.simulate(e, b2.target, bG.event.fix(b2), true) | |
| }; | |
| bG.event.special[e] = { | |
| setup: function() { | |
| if (bZ++ === 0) { | |
| o.addEventListener(b1, b0, true) | |
| } | |
| }, | |
| teardown: function() { | |
| if (--bZ === 0) { | |
| o.removeEventListener(b1, b0, true) | |
| } | |
| } | |
| } | |
| }) | |
| } | |
| bG.fn.extend({ | |
| on: function(b0, e, b3, b2, bZ) { | |
| var b4, b1; | |
| if (typeof b0 === "object") { | |
| if (typeof e !== "string") { | |
| b3 = b3 || e; | |
| e = aB | |
| } | |
| for (b1 in b0) { | |
| this.on(b1, e, b3, b0[b1], bZ) | |
| } | |
| return this | |
| } | |
| if (b3 == null && b2 == null) { | |
| b2 = e; | |
| b3 = e = aB | |
| } else { | |
| if (b2 == null) { | |
| if (typeof e === "string") { | |
| b2 = b3; | |
| b3 = aB | |
| } else { | |
| b2 = b3; | |
| b3 = e; | |
| e = aB | |
| } | |
| } | |
| } | |
| if (b2 === false) { | |
| b2 = X | |
| } else { | |
| if (!b2) { | |
| return this | |
| } | |
| } | |
| if (bZ === 1) { | |
| b4 = b2; | |
| b2 = function(b5) { | |
| bG().off(b5); | |
| return b4.apply(this, arguments) | |
| }; | |
| b2.guid = b4.guid || (b4.guid = bG.guid++) | |
| } | |
| return this.each(function() { | |
| bG.event.add(this, b0, b2, b3, e) | |
| }) | |
| }, | |
| one: function(bZ, e, b1, b0) { | |
| return this.on(bZ, e, b1, b0, 1) | |
| }, | |
| off: function(b0, e, b2) { | |
| var bZ, b1; | |
| if (b0 && b0.preventDefault && b0.handleObj) { | |
| bZ = b0.handleObj; | |
| bG(b0.delegateTarget).off(bZ.namespace ? bZ.origType + "." + bZ.namespace : bZ.origType, bZ.selector, bZ.handler); | |
| return this | |
| } | |
| if (typeof b0 === "object") { | |
| for (b1 in b0) { | |
| this.off(b1, e, b0[b1]) | |
| } | |
| return this | |
| } | |
| if (e === false || typeof e === "function") { | |
| b2 = e; | |
| e = aB | |
| } | |
| if (b2 === false) { | |
| b2 = X | |
| } | |
| return this.each(function() { | |
| bG.event.remove(this, b0, b2, e) | |
| }) | |
| }, | |
| bind: function(e, b0, bZ) { | |
| return this.on(e, null, b0, bZ) | |
| }, | |
| unbind: function(e, bZ) { | |
| return this.off(e, null, bZ) | |
| }, | |
| live: function(e, b0, bZ) { | |
| bG(this.context).on(e, this.selector, b0, bZ); | |
| return this | |
| }, | |
| die: function(e, bZ) { | |
| bG(this.context).off(e, this.selector || "**", bZ); | |
| return this | |
| }, | |
| delegate: function(e, bZ, b1, b0) { | |
| return this.on(bZ, e, b1, b0) | |
| }, | |
| undelegate: function(e, bZ, b0) { | |
| return arguments.length === 1 ? this.off(e, "**") : this.off(bZ, e || "**", b0) | |
| }, | |
| trigger: function(e, bZ) { | |
| return this.each(function() { | |
| bG.event.trigger(e, bZ, this) | |
| }) | |
| }, | |
| triggerHandler: function(e, bZ) { | |
| if (this[0]) { | |
| return bG.event.trigger(e, bZ, this[0], true) | |
| } | |
| }, | |
| toggle: function(b1) { | |
| var bZ = arguments, | |
| e = b1.guid || bG.guid++, | |
| b0 = 0, | |
| b2 = function(b3) { | |
| var b4 = (bG._data(this, "lastToggle" + b1.guid) || 0) % b0; | |
| bG._data(this, "lastToggle" + b1.guid, b4 + 1); | |
| b3.preventDefault(); | |
| return bZ[b4].apply(this, arguments) || false | |
| }; | |
| b2.guid = e; | |
| while (b0 < bZ.length) { | |
| bZ[b0++].guid = e | |
| } | |
| return this.click(b2) | |
| }, | |
| hover: function(e, bZ) { | |
| return this.mouseenter(e).mouseleave(bZ || e) | |
| } | |
| }); | |
| bG.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(bZ, e) { | |
| bG.fn[e] = function(b1, b0) { | |
| if (b0 == null) { | |
| b0 = b1; | |
| b1 = null | |
| } | |
| return arguments.length > 0 ? this.on(e, null, b1, b0) : this.trigger(e) | |
| }; | |
| if (a3.test(e)) { | |
| bG.event.fixHooks[e] = bG.event.keyHooks | |
| } | |
| if (bK.test(e)) { | |
| bG.event.fixHooks[e] = bG.event.mouseHooks | |
| } | |
| }); | |
| /* | |
| * Sizzle CSS Selector Engine | |
| * Copyright 2012 jQuery Foundation and other contributors | |
| * Released under the MIT license | |
| * http://sizzlejs.com/ | |
| */ | |
| (function(cS, ch) { | |
| var cX, ca, cL, b0, cm, cA, cd, cg, cc, cJ, b9 = true, | |
| cu = "undefined", | |
| cZ = ("sizcache" + Math.random()).replace(".", ""), | |
| b4 = String, | |
| b8 = cS.document, | |
| cb = b8.documentElement, | |
| cr = 0, | |
| cf = 0, | |
| cE = [].pop, | |
| cW = [].push, | |
| cl = [].slice, | |
| co = [].indexOf || | |
| function(c8) { | |
| var c7 = 0, | |
| e = this.length; | |
| for (; c7 < e; c7++) { | |
| if (this[c7] === c8) { | |
| return c7 | |
| } | |
| } | |
| return -1 | |
| }, c1 = function(e, c7) { | |
| e[cZ] = c7 == null || c7; | |
| return e | |
| }, c5 = function() { | |
| var e = {}, | |
| c7 = []; | |
| return c1(function(c8, c9) { | |
| if (c7.push(c8) > cL.cacheLength) { | |
| delete e[c7.shift()] | |
| } | |
| return (e[c8] = c9) | |
| }, e) | |
| }, cU = c5(), cV = c5(), cn = c5(), cy = "[\\x20\\t\\r\\n\\f]", ck = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+", ci = ck.replace("w", "w#"), c4 = "([*^$|!~]?=)", cP = "\\[" + cy + "*(" + ck + ")" + cy + "*(?:" + c4 + cy + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + ci + ")|)|)" + cy + "*\\]", c6 = ":(" + ck + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + cP + ")|[^:]|\\\\.)*|.*))\\)|)", cz = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + cy + "*((?:-\\d)?\\d*)" + cy + "*\\)|)(?=[^-]|$)", cT = new RegExp("^" + cy + "+|((?:^|[^\\\\])(?:\\\\.)*)" + cy + "+$", "g"), b5 = new RegExp("^" + cy + "*," + cy + "*"), cH = new RegExp("^" + cy + "*([\\x20\\t\\r\\n\\f>+~])" + cy + "*"), cM = new RegExp(c6), cO = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/, cD = /^:not/, cR = /[\x20\t\r\n\f]*[+~]/, c0 = /:not\($/, cs = /h\d/i, cN = /input|select|textarea|button/i, ct = /\\(?!\\)/g, cG = { | |
| ID: new RegExp("^#(" + ck + ")"), | |
| CLASS: new RegExp("^\\.(" + ck + ")"), | |
| NAME: new RegExp("^\\[name=['\"]?(" + ck + ")['\"]?\\]"), | |
| TAG: new RegExp("^(" + ck.replace("w", "w*") + ")"), | |
| ATTR: new RegExp("^" + cP), | |
| PSEUDO: new RegExp("^" + c6), | |
| POS: new RegExp(cz, "i"), | |
| CHILD: new RegExp("^:(only|nth|first|last)-child(?:\\(" + cy + "*(even|odd|(([+-]|)(\\d*)n|)" + cy + "*(?:([+-]|)" + cy + "*(\\d+)|))" + cy + "*\\)|)", "i"), | |
| needsContext: new RegExp("^" + cy + "*[>+~]|" + cz, "i") | |
| }, cK = function(c7) { | |
| var c9 = b8.createElement("div"); | |
| try { | |
| return c7(c9) | |
| } catch (c8) { | |
| return false | |
| } finally { | |
| c9 = null | |
| } | |
| }, b7 = cK(function(e) { | |
| e.appendChild(b8.createComment("")); | |
| return !e.getElementsByTagName("*").length | |
| }), cC = cK(function(e) { | |
| e.innerHTML = "<a href='#'></a>"; | |
| return e.firstChild && typeof e.firstChild.getAttribute !== cu && e.firstChild.getAttribute("href") === "#" | |
| }), cq = cK(function(c7) { | |
| c7.innerHTML = "<select></select>"; | |
| var e = typeof c7.lastChild.getAttribute("multiple"); | |
| return e !== "boolean" && e !== "string" | |
| }), cB = cK(function(e) { | |
| e.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>"; | |
| if (!e.getElementsByClassName || !e.getElementsByClassName("e").length) { | |
| return false | |
| } | |
| e.lastChild.className = "e"; | |
| return e.getElementsByClassName("e").length === 2 | |
| }), bZ = cK(function(c7) { | |
| c7.id = cZ + 0; | |
| c7.innerHTML = "<a name='" + cZ + "'></a><div name='" + cZ + "'></div>"; | |
| cb.insertBefore(c7, cb.firstChild); | |
| var e = b8.getElementsByName && b8.getElementsByName(cZ).length === 2 + b8.getElementsByName(cZ + 0).length; | |
| ca = !b8.getElementById(cZ); | |
| cb.removeChild(c7); | |
| return e | |
| }); | |
| try { | |
| cl.call(cb.childNodes, 0)[0].nodeType | |
| } catch (c3) { | |
| cl = function(c7) { | |
| var c8, e = []; | |
| for (; | |
| (c8 = this[c7]); c7++) { | |
| e.push(c8) | |
| } | |
| return e | |
| } | |
| } | |
| function cQ(c9, e, db, de) { | |
| db = db || []; | |
| e = e || b8; | |
| var dc, c7, dd, c8, da = e.nodeType; | |
| if (!c9 || typeof c9 !== "string") { | |
| return db | |
| } | |
| if (da !== 1 && da !== 9) { | |
| return [] | |
| } | |
| dd = cm(e); | |
| if (!dd && !de) { | |
| if ((dc = cO.exec(c9))) { | |
| if ((c8 = dc[1])) { | |
| if (da === 9) { | |
| c7 = e.getElementById(c8); | |
| if (c7 && c7.parentNode) { | |
| if (c7.id === c8) { | |
| db.push(c7); | |
| return db | |
| } | |
| } else { | |
| return db | |
| } | |
| } else { | |
| if (e.ownerDocument && (c7 = e.ownerDocument.getElementById(c8)) && cA(e, c7) && c7.id === c8) { | |
| db.push(c7); | |
| return db | |
| } | |
| } | |
| } else { | |
| if (dc[2]) { | |
| cW.apply(db, cl.call(e.getElementsByTagName(c9), 0)); | |
| return db | |
| } else { | |
| if ((c8 = dc[3]) && cB && e.getElementsByClassName) { | |
| cW.apply(db, cl.call(e.getElementsByClassName(c8), 0)); | |
| return db | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return cY(c9.replace(cT, "$1"), e, db, de, dd) | |
| } | |
| cQ.matches = function(c7, e) { | |
| return cQ(c7, null, null, e) | |
| }; | |
| cQ.matchesSelector = function(e, c7) { | |
| return cQ(c7, null, null, [e]).length > 0 | |
| }; | |
| function cI(e) { | |
| return function(c8) { | |
| var c7 = c8.nodeName.toLowerCase(); | |
| return c7 === "input" && c8.type === e | |
| } | |
| } | |
| function b3(e) { | |
| return function(c8) { | |
| var c7 = c8.nodeName.toLowerCase(); | |
| return (c7 === "input" || c7 === "button") && c8.type === e | |
| } | |
| } | |
| function cF(e) { | |
| return c1(function(c7) { | |
| c7 = +c7; | |
| return c1(function(c8, dc) { | |
| var da, c9 = e([], c8.length, c7), | |
| db = c9.length; | |
| while (db--) { | |
| if (c8[(da = c9[db])]) { | |
| c8[da] = !(dc[da] = c8[da]) | |
| } | |
| } | |
| }) | |
| }) | |
| } | |
| b0 = cQ.getText = function(da) { | |
| var c9, c7 = "", | |
| c8 = 0, | |
| e = da.nodeType; | |
| if (e) { | |
| if (e === 1 || e === 9 || e === 11) { | |
| if (typeof da.textContent === "string") { | |
| return da.textContent | |
| } else { | |
| for (da = da.firstChild; da; da = da.nextSibling) { | |
| c7 += b0(da) | |
| } | |
| } | |
| } else { | |
| if (e === 3 || e === 4) { | |
| return da.nodeValue | |
| } | |
| } | |
| } else { | |
| for (; | |
| (c9 = da[c8]); c8++) { | |
| c7 += b0(c9) | |
| } | |
| } | |
| return c7 | |
| }; | |
| cm = cQ.isXML = function(e) { | |
| var c7 = e && (e.ownerDocument || e).documentElement; | |
| return c7 ? c7.nodeName !== "HTML" : false | |
| }; | |
| cA = cQ.contains = cb.contains ? | |
| function(c7, e) { | |
| var c9 = c7.nodeType === 9 ? c7.documentElement : c7, | |
| c8 = e && e.parentNode; | |
| return c7 === c8 || !! (c8 && c8.nodeType === 1 && c9.contains && c9.contains(c8)) | |
| } : cb.compareDocumentPosition ? | |
| function(c7, e) { | |
| return e && !! (c7.compareDocumentPosition(e) & 16) | |
| } : function(c7, e) { | |
| while ((e = e.parentNode)) { | |
| if (e === c7) { | |
| return true | |
| } | |
| } | |
| return false | |
| }; | |
| cQ.attr = function(c8, c7) { | |
| var c9, e = cm(c8); | |
| if (!e) { | |
| c7 = c7.toLowerCase() | |
| } | |
| if ((c9 = cL.attrHandle[c7])) { | |
| return c9(c8) | |
| } | |
| if (e || cq) { | |
| return c8.getAttribute(c7) | |
| } | |
| c9 = c8.getAttributeNode(c7); | |
| return c9 ? typeof c8[c7] === "boolean" ? c8[c7] ? c7 : null : c9.specified ? c9.value : null : null | |
| }; | |
| cL = cQ.selectors = { | |
| cacheLength: 50, | |
| createPseudo: c1, | |
| match: cG, | |
| attrHandle: cC ? {} : { | |
| href: function(e) { | |
| return e.getAttribute("href", 2) | |
| }, | |
| type: function(e) { | |
| return e.getAttribute("type") | |
| } | |
| }, | |
| find: { | |
| ID: ca ? | |
| function(c9, c8, c7) { | |
| if (typeof c8.getElementById !== cu && !c7) { | |
| var e = c8.getElementById(c9); | |
| return e && e.parentNode ? [e] : [] | |
| } | |
| } : function(c9, c8, c7) { | |
| if (typeof c8.getElementById !== cu && !c7) { | |
| var e = c8.getElementById(c9); | |
| return e ? e.id === c9 || typeof e.getAttributeNode !== cu && e.getAttributeNode("id").value === c9 ? [e] : ch : [] | |
| } | |
| }, | |
| TAG: b7 ? | |
| function(e, c7) { | |
| if (typeof c7.getElementsByTagName !== cu) { | |
| return c7.getElementsByTagName(e) | |
| } | |
| } : function(e, da) { | |
| var c9 = da.getElementsByTagName(e); | |
| if (e === "*") { | |
| var db, c8 = [], | |
| c7 = 0; | |
| for (; | |
| (db = c9[c7]); c7++) { | |
| if (db.nodeType === 1) { | |
| c8.push(db) | |
| } | |
| } | |
| return c8 | |
| } | |
| return c9 | |
| }, | |
| NAME: bZ && | |
| function(e, c7) { | |
| if (typeof c7.getElementsByName !== cu) { | |
| return c7.getElementsByName(name) | |
| } | |
| }, | |
| CLASS: cB && | |
| function(c8, c7, e) { | |
| if (typeof c7.getElementsByClassName !== cu && !e) { | |
| return c7.getElementsByClassName(c8) | |
| } | |
| } | |
| }, | |
| relative: { | |
| ">": { | |
| dir: "parentNode", | |
| first: true | |
| }, | |
| " ": { | |
| dir: "parentNode" | |
| }, | |
| "+": { | |
| dir: "previousSibling", | |
| first: true | |
| }, | |
| "~": { | |
| dir: "previousSibling" | |
| } | |
| }, | |
| preFilter: { | |
| ATTR: function(e) { | |
| e[1] = e[1].replace(ct, ""); | |
| e[3] = (e[4] || e[5] || "").replace(ct, ""); | |
| if (e[2] === "~=") { | |
| e[3] = " " + e[3] + " " | |
| } | |
| return e.slice(0, 4) | |
| }, | |
| CHILD: function(e) { | |
| e[1] = e[1].toLowerCase(); | |
| if (e[1] === "nth") { | |
| if (!e[2]) { | |
| cQ.error(e[0]) | |
| } | |
| e[3] = +(e[3] ? e[4] + (e[5] || 1) : 2 * (e[2] === "even" || e[2] === "odd")); | |
| e[4] = +((e[6] + e[7]) || e[2] === "odd") | |
| } else { | |
| if (e[2]) { | |
| cQ.error(e[0]) | |
| } | |
| } | |
| return e | |
| }, | |
| PSEUDO: function(c7) { | |
| var c8, e; | |
| if (cG.CHILD.test(c7[0])) { | |
| return null | |
| } | |
| if (c7[3]) { | |
| c7[2] = c7[3] | |
| } else { | |
| if ((c8 = c7[4])) { | |
| if (cM.test(c8) && (e = b1(c8, true)) && (e = c8.indexOf(")", c8.length - e) - c8.length)) { | |
| c8 = c8.slice(0, e); | |
| c7[0] = c7[0].slice(0, e) | |
| } | |
| c7[2] = c8 | |
| } | |
| } | |
| return c7.slice(0, 3) | |
| } | |
| }, | |
| filter: { | |
| ID: ca ? | |
| function(e) { | |
| e = e.replace(ct, ""); | |
| return function(c7) { | |
| return c7.getAttribute("id") === e | |
| } | |
| } : function(e) { | |
| e = e.replace(ct, ""); | |
| return function(c8) { | |
| var c7 = typeof c8.getAttributeNode !== cu && c8.getAttributeNode("id"); | |
| return c7 && c7.value === e | |
| } | |
| }, | |
| TAG: function(e) { | |
| if (e === "*") { | |
| return function() { | |
| return true | |
| } | |
| } | |
| e = e.replace(ct, "").toLowerCase(); | |
| return function(c7) { | |
| return c7.nodeName && c7.nodeName.toLowerCase() === e | |
| } | |
| }, | |
| CLASS: function(e) { | |
| var c7 = cU[cZ][e]; | |
| if (!c7) { | |
| c7 = cU(e, new RegExp("(^|" + cy + ")" + e + "(" + cy + "|$)")) | |
| } | |
| return function(c8) { | |
| return c7.test(c8.className || (typeof c8.getAttribute !== cu && c8.getAttribute("class")) || "") | |
| } | |
| }, | |
| ATTR: function(c8, c7, e) { | |
| return function(db, da) { | |
| var c9 = cQ.attr(db, c8); | |
| if (c9 == null) { | |
| return c7 === "!=" | |
| } | |
| if (!c7) { | |
| return true | |
| } | |
| c9 += ""; | |
| return c7 === "=" ? c9 === e : c7 === "!=" ? c9 !== e : c7 === "^=" ? e && c9.indexOf(e) === 0 : c7 === "*=" ? e && c9.indexOf(e) > -1 : c7 === "$=" ? e && c9.substr(c9.length - e.length) === e : c7 === "~=" ? (" " + c9 + " ").indexOf(e) > -1 : c7 === "|=" ? c9 === e || c9.substr(0, e.length + 1) === e + "-" : false | |
| } | |
| }, | |
| CHILD: function(e, c8, c9, c7) { | |
| if (e === "nth") { | |
| return function(dc) { | |
| var db, dd, da = dc.parentNode; | |
| if (c9 === 1 && c7 === 0) { | |
| return true | |
| } | |
| if (da) { | |
| dd = 0; | |
| for (db = da.firstChild; db; db = db.nextSibling) { | |
| if (db.nodeType === 1) { | |
| dd++; | |
| if (dc === db) { | |
| break | |
| } | |
| } | |
| } | |
| } | |
| dd -= c7; | |
| return dd === c9 || (dd % c9 === 0 && dd / c9 >= 0) | |
| } | |
| } | |
| return function(db) { | |
| var da = db; | |
| switch (e) { | |
| case "only": | |
| case "first": | |
| while ((da = da.previousSibling)) { | |
| if (da.nodeType === 1) { | |
| return false | |
| } | |
| } | |
| if (e === "first") { | |
| return true | |
| } | |
| da = db; | |
| case "last": | |
| while ((da = da.nextSibling)) { | |
| if (da.nodeType === 1) { | |
| return false | |
| } | |
| } | |
| return true | |
| } | |
| } | |
| }, | |
| PSEUDO: function(c9, c8) { | |
| var e, c7 = cL.pseudos[c9] || cL.setFilters[c9.toLowerCase()] || cQ.error("unsupported pseudo: " + c9); | |
| if (c7[cZ]) { | |
| return c7(c8) | |
| } | |
| if (c7.length > 1) { | |
| e = [c9, c9, "", c8]; | |
| return cL.setFilters.hasOwnProperty(c9.toLowerCase()) ? c1(function(dc, de) { | |
| var db, da = c7(dc, c8), | |
| dd = da.length; | |
| while (dd--) { | |
| db = co.call(dc, da[dd]); | |
| dc[db] = !(de[db] = da[dd]) | |
| } | |
| }) : function(da) { | |
| return c7(da, 0, e) | |
| } | |
| } | |
| return c7 | |
| } | |
| }, | |
| pseudos: { | |
| not: c1(function(e) { | |
| var c7 = [], | |
| c8 = [], | |
| c9 = cd(e.replace(cT, "$1")); | |
| return c9[cZ] ? c1(function(db, dg, de, dc) { | |
| var df, da = c9(db, null, dc, []), | |
| dd = db.length; | |
| while (dd--) { | |
| if ((df = da[dd])) { | |
| db[dd] = !(dg[dd] = df) | |
| } | |
| } | |
| }) : function(dc, db, da) { | |
| c7[0] = dc; | |
| c9(c7, null, da, c8); | |
| return !c8.pop() | |
| } | |
| }), | |
| has: c1(function(e) { | |
| return function(c7) { | |
| return cQ(e, c7).length > 0 | |
| } | |
| }), | |
| contains: c1(function(e) { | |
| return function(c7) { | |
| return (c7.textContent || c7.innerText || b0(c7)).indexOf(e) > -1 | |
| } | |
| }), | |
| enabled: function(e) { | |
| return e.disabled === false | |
| }, | |
| disabled: function(e) { | |
| return e.disabled === true | |
| }, | |
| checked: function(e) { | |
| var c7 = e.nodeName.toLowerCase(); | |
| return (c7 === "input" && !! e.checked) || (c7 === "option" && !! e.selected) | |
| }, | |
| selected: function(e) { | |
| if (e.parentNode) { | |
| e.parentNode.selectedIndex | |
| } | |
| return e.selected === true | |
| }, | |
| parent: function(e) { | |
| return !cL.pseudos.empty(e) | |
| }, | |
| empty: function(c7) { | |
| var e; | |
| c7 = c7.firstChild; | |
| while (c7) { | |
| if (c7.nodeName > "@" || (e = c7.nodeType) === 3 || e === 4) { | |
| return false | |
| } | |
| c7 = c7.nextSibling | |
| } | |
| return true | |
| }, | |
| header: function(e) { | |
| return cs.test(e.nodeName) | |
| }, | |
| text: function(c8) { | |
| var c7, e; | |
| return c8.nodeName.toLowerCase() === "input" && (c7 = c8.type) === "text" && ((e = c8.getAttribute("type")) == null || e.toLowerCase() === c7) | |
| }, | |
| radio: cI("radio"), | |
| checkbox: cI("checkbox"), | |
| file: cI("file"), | |
| password: cI("password"), | |
| image: cI("image"), | |
| submit: b3("submit"), | |
| reset: b3("reset"), | |
| button: function(c7) { | |
| var e = c7.nodeName.toLowerCase(); | |
| return e === "input" && c7.type === "button" || e === "button" | |
| }, | |
| input: function(e) { | |
| return cN.test(e.nodeName) | |
| }, | |
| focus: function(e) { | |
| var c7 = e.ownerDocument; | |
| return e === c7.activeElement && (!c7.hasFocus || c7.hasFocus()) && !! (e.type || e.href) | |
| }, | |
| active: function(e) { | |
| return e === e.ownerDocument.activeElement | |
| }, | |
| first: cF(function(e, c8, c7) { | |
| return [0] | |
| }), | |
| last: cF(function(e, c8, c7) { | |
| return [c8 - 1] | |
| }), | |
| eq: cF(function(e, c8, c7) { | |
| return [c7 < 0 ? c7 + c8 : c7] | |
| }), | |
| even: cF(function(e, c9, c8) { | |
| for (var c7 = 0; c7 < c9; c7 += 2) { | |
| e.push(c7) | |
| } | |
| return e | |
| }), | |
| odd: cF(function(e, c9, c8) { | |
| for (var c7 = 1; c7 < c9; c7 += 2) { | |
| e.push(c7) | |
| } | |
| return e | |
| }), | |
| lt: cF(function(e, c9, c8) { | |
| for (var c7 = c8 < 0 ? c8 + c9 : c8; --c7 >= 0;) { | |
| e.push(c7) | |
| } | |
| return e | |
| }), | |
| gt: cF(function(e, c9, c8) { | |
| for (var c7 = c8 < 0 ? c8 + c9 : c8; ++c7 < c9;) { | |
| e.push(c7) | |
| } | |
| return e | |
| }) | |
| } | |
| }; | |
| function b2(c7, e, c8) { | |
| if (c7 === e) { | |
| return c8 | |
| } | |
| var c9 = c7.nextSibling; | |
| while (c9) { | |
| if (c9 === e) { | |
| return -1 | |
| } | |
| c9 = c9.nextSibling | |
| } | |
| return 1 | |
| } | |
| cg = cb.compareDocumentPosition ? | |
| function(c7, e) { | |
| if (c7 === e) { | |
| cc = true; | |
| return 0 | |
| } | |
| return (!c7.compareDocumentPosition || !e.compareDocumentPosition ? c7.compareDocumentPosition : c7.compareDocumentPosition(e) & 4) ? -1 : 1 | |
| } : function(de, dd) { | |
| if (de === dd) { | |
| cc = true; | |
| return 0 | |
| } else { | |
| if (de.sourceIndex && dd.sourceIndex) { | |
| return de.sourceIndex - dd.sourceIndex | |
| } | |
| } | |
| var db, c7, c8 = [], | |
| e = [], | |
| da = de.parentNode, | |
| dc = dd.parentNode, | |
| df = da; | |
| if (da === dc) { | |
| return b2(de, dd) | |
| } else { | |
| if (!da) { | |
| return -1 | |
| } else { | |
| if (!dc) { | |
| return 1 | |
| } | |
| } | |
| } | |
| while (df) { | |
| c8.unshift(df); | |
| df = df.parentNode | |
| } | |
| df = dc; | |
| while (df) { | |
| e.unshift(df); | |
| df = df.parentNode | |
| } | |
| db = c8.length; | |
| c7 = e.length; | |
| for (var c9 = 0; c9 < db && c9 < c7; c9++) { | |
| if (c8[c9] !== e[c9]) { | |
| return b2(c8[c9], e[c9]) | |
| } | |
| } | |
| return c9 === db ? b2(de, e[c9], -1) : b2(c8[c9], dd, 1) | |
| }; | |
| [0, 0].sort(cg); | |
| b9 = !cc; | |
| cQ.uniqueSort = function(c7) { | |
| var c8, e = 1; | |
| cc = b9; | |
| c7.sort(cg); | |
| if (cc) { | |
| for (; | |
| (c8 = c7[e]); e++) { | |
| if (c8 === c7[e - 1]) { | |
| c7.splice(e--, 1) | |
| } | |
| } | |
| } | |
| return c7 | |
| }; | |
| cQ.error = function(e) { | |
| throw new Error("Syntax error, unrecognized expression: " + e) | |
| }; | |
| function b1(da, df) { | |
| var c7, db, dd, de, dc, c8, e, c9 = cV[cZ][da]; | |
| if (c9) { | |
| return df ? 0 : c9.slice(0) | |
| } | |
| dc = da; | |
| c8 = []; | |
| e = cL.preFilter; | |
| while (dc) { | |
| if (!c7 || (db = b5.exec(dc))) { | |
| if (db) { | |
| dc = dc.slice(db[0].length) | |
| } | |
| c8.push(dd = []) | |
| } | |
| c7 = false; | |
| if ((db = cH.exec(dc))) { | |
| dd.push(c7 = new b4(db.shift())); | |
| dc = dc.slice(c7.length); | |
| c7.type = db[0].replace(cT, " ") | |
| } | |
| for (de in cL.filter) { | |
| if ((db = cG[de].exec(dc)) && (!e[de] || (db = e[de](db, b8, true)))) { | |
| dd.push(c7 = new b4(db.shift())); | |
| dc = dc.slice(c7.length); | |
| c7.type = de; | |
| c7.matches = db | |
| } | |
| } | |
| if (!c7) { | |
| break | |
| } | |
| } | |
| return df ? dc.length : dc ? cQ.error(da) : cV(da, c8).slice(0) | |
| } | |
| function cw(da, c8, c9) { | |
| var e = c8.dir, | |
| db = c9 && c8.dir === "parentNode", | |
| c7 = cf++; | |
| return c8.first ? | |
| function(de, dd, dc) { | |
| while ((de = de[e])) { | |
| if (db || de.nodeType === 1) { | |
| return da(de, dd, dc) | |
| } | |
| } | |
| } : function(df, de, dd) { | |
| if (!dd) { | |
| var dc, dg = cr + " " + c7 + " ", | |
| dh = dg + cX; | |
| while ((df = df[e])) { | |
| if (db || df.nodeType === 1) { | |
| if ((dc = df[cZ]) === dh) { | |
| return df.sizset | |
| } else { | |
| if (typeof dc === "string" && dc.indexOf(dg) === 0) { | |
| if (df.sizset) { | |
| return df | |
| } | |
| } else { | |
| df[cZ] = dh; | |
| if (da(df, de, dd)) { | |
| df.sizset = true; | |
| return df | |
| } | |
| df.sizset = false | |
| } | |
| } | |
| } | |
| } | |
| } else { | |
| while ((df = df[e])) { | |
| if (db || df.nodeType === 1) { | |
| if (da(df, de, dd)) { | |
| return df | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| function ce(e) { | |
| return e.length > 1 ? | |
| function(da, c9, c7) { | |
| var c8 = e.length; | |
| while (c8--) { | |
| if (!e[c8](da, c9, c7)) { | |
| return false | |
| } | |
| } | |
| return true | |
| } : e[0] | |
| } | |
| function cv(e, c7, c8, c9, dc) { | |
| var da, df = [], | |
| db = 0, | |
| dd = e.length, | |
| de = c7 != null; | |
| for (; db < dd; db++) { | |
| if ((da = e[db])) { | |
| if (!c8 || c8(da, c9, dc)) { | |
| df.push(da); | |
| if (de) { | |
| c7.push(db) | |
| } | |
| } | |
| } | |
| } | |
| return df | |
| } | |
| function c2(c8, c7, da, c9, db, e) { | |
| if (c9 && !c9[cZ]) { | |
| c9 = c2(c9) | |
| } | |
| if (db && !db[cZ]) { | |
| db = c2(db, e) | |
| } | |
| return c1(function(dn, dk, de, dm) { | |
| if (dn && db) { | |
| return | |
| } | |
| var dl, dg, dh, df = [], | |
| dp = [], | |
| dd = dk.length, | |
| dc = dn || cp(c7 || "*", de.nodeType ? [de] : de, [], dn), | |
| di = c8 && (dn || !c7) ? cv(dc, df, c8, de, dm) : dc, | |
| dj = da ? db || (dn ? c8 : dd || c9) ? [] : dk : di; | |
| if (da) { | |
| da(di, dj, de, dm) | |
| } | |
| if (c9) { | |
| dh = cv(dj, dp); | |
| c9(dh, [], de, dm); | |
| dl = dh.length; | |
| while (dl--) { | |
| if ((dg = dh[dl])) { | |
| dj[dp[dl]] = !(di[dp[dl]] = dg) | |
| } | |
| } | |
| } | |
| if (dn) { | |
| dl = c8 && dj.length; | |
| while (dl--) { | |
| if ((dg = dj[dl])) { | |
| dn[df[dl]] = !(dk[df[dl]] = dg) | |
| } | |
| } | |
| } else { | |
| dj = cv(dj === dk ? dj.splice(dd, dj.length) : dj); | |
| if (db) { | |
| db(null, dk, dj, dm) | |
| } else { | |
| cW.apply(dk, dj) | |
| } | |
| } | |
| }) | |
| } | |
| function cx(dc) { | |
| var c7, da, c8, db = dc.length, | |
| df = cL.relative[dc[0].type], | |
| dg = df || cL.relative[" "], | |
| c9 = df ? 1 : 0, | |
| dd = cw(function(dh) { | |
| return dh === c7 | |
| }, dg, true), | |
| de = cw(function(dh) { | |
| return co.call(c7, dh) > -1 | |
| }, dg, true), | |
| e = [function(dj, di, dh) { | |
| return (!df && (dh || di !== cJ)) || ((c7 = di).nodeType ? dd(dj, di, dh) : de(dj, di, dh)) | |
| }]; | |
| for (; c9 < db; c9++) { | |
| if ((da = cL.relative[dc[c9].type])) { | |
| e = [cw(ce(e), da)] | |
| } else { | |
| da = cL.filter[dc[c9].type].apply(null, dc[c9].matches); | |
| if (da[cZ]) { | |
| c8 = ++c9; | |
| for (; c8 < db; c8++) { | |
| if (cL.relative[dc[c8].type]) { | |
| break | |
| } | |
| } | |
| return c2(c9 > 1 && ce(e), c9 > 1 && dc.slice(0, c9 - 1).join("").replace(cT, "$1"), da, c9 < c8 && cx(dc.slice(c9, c8)), c8 < db && cx((dc = dc.slice(c8))), c8 < db && dc.join("")) | |
| } | |
| e.push(da) | |
| } | |
| } | |
| return ce(e) | |
| } | |
| function b6(c9, c8) { | |
| var e = c8.length > 0, | |
| da = c9.length > 0, | |
| c7 = function(dk, de, dj, di, dr) { | |
| var df, dg, dl, dq = [], | |
| dp = 0, | |
| dh = "0", | |
| db = dk && [], | |
| dm = dr != null, | |
| dn = cJ, | |
| dd = dk || da && cL.find.TAG("*", dr && de.parentNode || de), | |
| dc = (cr += dn == null ? 1 : Math.E); | |
| if (dm) { | |
| cJ = de !== b8 && de; | |
| cX = c7.el | |
| } | |
| for (; | |
| (df = dd[dh]) != null; dh++) { | |
| if (da && df) { | |
| for (dg = 0; | |
| (dl = c9[dg]); dg++) { | |
| if (dl(df, de, dj)) { | |
| di.push(df); | |
| break | |
| } | |
| } | |
| if (dm) { | |
| cr = dc; | |
| cX = ++c7.el | |
| } | |
| } | |
| if (e) { | |
| if ((df = !dl && df)) { | |
| dp-- | |
| } | |
| if (dk) { | |
| db.push(df) | |
| } | |
| } | |
| } | |
| dp += dh; | |
| if (e && dh !== dp) { | |
| for (dg = 0; | |
| (dl = c8[dg]); dg++) { | |
| dl(db, dq, de, dj) | |
| } | |
| if (dk) { | |
| if (dp > 0) { | |
| while (dh--) { | |
| if (!(db[dh] || dq[dh])) { | |
| dq[dh] = cE.call(di) | |
| } | |
| } | |
| } | |
| dq = cv(dq) | |
| } | |
| cW.apply(di, dq); | |
| if (dm && !dk && dq.length > 0 && (dp + c8.length) > 1) { | |
| cQ.uniqueSort(di) | |
| } | |
| } | |
| if (dm) { | |
| cr = dc; | |
| cJ = dn | |
| } | |
| return db | |
| }; | |
| c7.el = 0; | |
| return e ? c1(c7) : c7 | |
| } | |
| cd = cQ.compile = function(e, db) { | |
| var c8, c7 = [], | |
| da = [], | |
| c9 = cn[cZ][e]; | |
| if (!c9) { | |
| if (!db) { | |
| db = b1(e) | |
| } | |
| c8 = db.length; | |
| while (c8--) { | |
| c9 = cx(db[c8]); | |
| if (c9[cZ]) { | |
| c7.push(c9) | |
| } else { | |
| da.push(c9) | |
| } | |
| } | |
| c9 = cn(e, b6(da, c7)) | |
| } | |
| return c9 | |
| }; | |
| function cp(c7, db, da, c8) { | |
| var c9 = 0, | |
| e = db.length; | |
| for (; c9 < e; c9++) { | |
| cQ(c7, db[c9], da, c8) | |
| } | |
| return da | |
| } | |
| function cY(c8, e, da, de, dd) { | |
| var db, dh, c7, dg, df, dc = b1(c8), | |
| c9 = dc.length; | |
| if (!de) { | |
| if (dc.length === 1) { | |
| dh = dc[0] = dc[0].slice(0); | |
| if (dh.length > 2 && (c7 = dh[0]).type === "ID" && e.nodeType === 9 && !dd && cL.relative[dh[1].type]) { | |
| e = cL.find.ID(c7.matches[0].replace(ct, ""), e, dd)[0]; | |
| if (!e) { | |
| return da | |
| } | |
| c8 = c8.slice(dh.shift().length) | |
| } | |
| for (db = cG.POS.test(c8) ? -1 : dh.length - 1; db >= 0; db--) { | |
| c7 = dh[db]; | |
| if (cL.relative[(dg = c7.type)]) { | |
| break | |
| } | |
| if ((df = cL.find[dg])) { | |
| if ((de = df(c7.matches[0].replace(ct, ""), cR.test(dh[0].type) && e.parentNode || e, dd))) { | |
| dh.splice(db, 1); | |
| c8 = de.length && dh.join(""); | |
| if (!c8) { | |
| cW.apply(da, cl.call(de, 0)); | |
| return da | |
| } | |
| break | |
| } | |
| } | |
| } | |
| } | |
| } | |
| cd(c8, dc)(de, e, dd, da, cR.test(c8)); | |
| return da | |
| } | |
| if (b8.querySelectorAll) { | |
| (function() { | |
| var db, dc = cY, | |
| da = /'|\\/g, | |
| c8 = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, | |
| c7 = [":focus"], | |
| e = [":active", ":focus"], | |
| c9 = cb.matchesSelector || cb.mozMatchesSelector || cb.webkitMatchesSelector || cb.oMatchesSelector || cb.msMatchesSelector; | |
| cK(function(dd) { | |
| dd.innerHTML = "<select><option selected=''></option></select>"; | |
| if (!dd.querySelectorAll("[selected]").length) { | |
| c7.push("\\[" + cy + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)") | |
| } | |
| if (!dd.querySelectorAll(":checked").length) { | |
| c7.push(":checked") | |
| } | |
| }); | |
| cK(function(dd) { | |
| dd.innerHTML = "<p test=''></p>"; | |
| if (dd.querySelectorAll("[test^='']").length) { | |
| c7.push("[*^$]=" + cy + "*(?:\"\"|'')") | |
| } | |
| dd.innerHTML = "<input type='hidden'/>"; | |
| if (!dd.querySelectorAll(":enabled").length) { | |
| c7.push(":enabled", ":disabled") | |
| } | |
| }); | |
| c7 = new RegExp(c7.join("|")); | |
| cY = function(dj, de, dl, dp, dn) { | |
| if (!dp && !dn && (!c7 || !c7.test(dj))) { | |
| var dh, dm, dg = true, | |
| dd = cZ, | |
| df = de, | |
| dk = de.nodeType === 9 && dj; | |
| if (de.nodeType === 1 && de.nodeName.toLowerCase() !== "object") { | |
| dh = b1(dj); | |
| if ((dg = de.getAttribute("id"))) { | |
| dd = dg.replace(da, "\\$&") | |
| } else { | |
| de.setAttribute("id", dd) | |
| } | |
| dd = "[id='" + dd + "'] "; | |
| dm = dh.length; | |
| while (dm--) { | |
| dh[dm] = dd + dh[dm].join("") | |
| } | |
| df = cR.test(dj) && de.parentNode || de; | |
| dk = dh.join(",") | |
| } | |
| if (dk) { | |
| try { | |
| cW.apply(dl, cl.call(df.querySelectorAll(dk), 0)); | |
| return dl | |
| } catch (di) {} finally { | |
| if (!dg) { | |
| de.removeAttribute("id") | |
| } | |
| } | |
| } | |
| } | |
| return dc(dj, de, dl, dp, dn) | |
| }; | |
| if (c9) { | |
| cK(function(de) { | |
| db = c9.call(de, "div"); | |
| try { | |
| c9.call(de, "[test!='']:sizzle"); | |
| e.push("!=", c6) | |
| } catch (dd) {} | |
| }); | |
| e = new RegExp(e.join("|")); | |
| cQ.matchesSelector = function(de, dg) { | |
| dg = dg.replace(c8, "='$1']"); | |
| if (!cm(de) && !e.test(dg) && (!c7 || !c7.test(dg))) { | |
| try { | |
| var dd = c9.call(de, dg); | |
| if (dd || db || de.document && de.document.nodeType !== 11) { | |
| return dd | |
| } | |
| } catch (df) {} | |
| } | |
| return cQ(dg, null, null, [de]).length > 0 | |
| } | |
| } | |
| })() | |
| } | |
| cL.pseudos.nth = cL.pseudos.eq; | |
| function cj() {} | |
| cL.filters = cj.prototype = cL.pseudos; | |
| cL.setFilters = new cj(); | |
| cQ.attr = bG.attr; | |
| bG.find = cQ; | |
| bG.expr = cQ.selectors; | |
| bG.expr[":"] = bG.expr.pseudos; | |
| bG.unique = cQ.uniqueSort; | |
| bG.text = cQ.getText; | |
| bG.isXMLDoc = cQ.isXML; | |
| bG.contains = cQ.contains | |
| })(a2); | |
| var ag = /Until$/, | |
| bq = /^(?:parents|prev(?:Until|All))/, | |
| al = /^.[^:#\[\.,]*$/, | |
| y = bG.expr.match.needsContext, | |
| bu = { | |
| children: true, | |
| contents: true, | |
| next: true, | |
| prev: true | |
| }; | |
| bG.fn.extend({ | |
| find: function(e) { | |
| var b2, bZ, b4, b5, b3, b1, b0 = this; | |
| if (typeof e !== "string") { | |
| return bG(e).filter(function() { | |
| for (b2 = 0, bZ = b0.length; b2 < bZ; b2++) { | |
| if (bG.contains(b0[b2], this)) { | |
| return true | |
| } | |
| } | |
| }) | |
| } | |
| b1 = this.pushStack("", "find", e); | |
| for (b2 = 0, bZ = this.length; b2 < bZ; b2++) { | |
| b4 = b1.length; | |
| bG.find(e, this[b2], b1); | |
| if (b2 > 0) { | |
| for (b5 = b4; b5 < b1.length; b5++) { | |
| for (b3 = 0; b3 < b4; b3++) { | |
| if (b1[b3] === b1[b5]) { | |
| b1.splice(b5--, 1); | |
| break | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return b1 | |
| }, | |
| has: function(b1) { | |
| var b0, bZ = bG(b1, this), | |
| e = bZ.length; | |
| return this.filter(function() { | |
| for (b0 = 0; b0 < e; b0++) { | |
| if (bG.contains(this, bZ[b0])) { | |
| return true | |
| } | |
| } | |
| }) | |
| }, | |
| not: function(e) { | |
| return this.pushStack(aM(this, e, false), "not", e) | |
| }, | |
| filter: function(e) { | |
| return this.pushStack(aM(this, e, true), "filter", e) | |
| }, | |
| is: function(e) { | |
| return !!e && (typeof e === "string" ? y.test(e) ? bG(e, this.context).index(this[0]) >= 0 : bG.filter(e, this).length > 0 : this.filter(e).length > 0) | |
| }, | |
| closest: function(b2, b1) { | |
| var b3, b0 = 0, | |
| e = this.length, | |
| bZ = [], | |
| b4 = y.test(b2) || typeof b2 !== "string" ? bG(b2, b1 || this.context) : 0; | |
| for (; b0 < e; b0++) { | |
| b3 = this[b0]; | |
| while (b3 && b3.ownerDocument && b3 !== b1 && b3.nodeType !== 11) { | |
| if (b4 ? b4.index(b3) > -1 : bG.find.matchesSelector(b3, b2)) { | |
| bZ.push(b3); | |
| break | |
| } | |
| b3 = b3.parentNode | |
| } | |
| } | |
| bZ = bZ.length > 1 ? bG.unique(bZ) : bZ; | |
| return this.pushStack(bZ, "closest", b2) | |
| }, | |
| index: function(e) { | |
| if (!e) { | |
| return (this[0] && this[0].parentNode) ? this.prevAll().length : -1 | |
| } | |
| if (typeof e === "string") { | |
| return bG.inArray(this[0], bG(e)) | |
| } | |
| return bG.inArray(e.jquery ? e[0] : e, this) | |
| }, | |
| add: function(e, bZ) { | |
| var b1 = typeof e === "string" ? bG(e, bZ) : bG.makeArray(e && e.nodeType ? [e] : e), | |
| b0 = bG.merge(this.get(), b1); | |
| return this.pushStack(aR(b1[0]) || aR(b0[0]) ? b0 : bG.unique(b0)) | |
| }, | |
| addBack: function(e) { | |
| return this.add(e == null ? this.prevObject : this.prevObject.filter(e)) | |
| } | |
| }); | |
| bG.fn.andSelf = bG.fn.addBack; | |
| function aR(e) { | |
| return !e || !e.parentNode || e.parentNode.nodeType === 11 | |
| } | |
| function aY(bZ, e) { | |
| do { | |
| bZ = bZ[e] | |
| } while (bZ && bZ.nodeType !== 1); | |
| return bZ | |
| } | |
| bG.each({ | |
| parent: function(bZ) { | |
| var e = bZ.parentNode; | |
| return e && e.nodeType !== 11 ? e : null | |
| }, | |
| parents: function(e) { | |
| return bG.dir(e, "parentNode") | |
| }, | |
| parentsUntil: function(bZ, e, b0) { | |
| return bG.dir(bZ, "parentNode", b0) | |
| }, | |
| next: function(e) { | |
| return aY(e, "nextSibling") | |
| }, | |
| prev: function(e) { | |
| return aY(e, "previousSibling") | |
| }, | |
| nextAll: function(e) { | |
| return bG.dir(e, "nextSibling") | |
| }, | |
| prevAll: function(e) { | |
| return bG.dir(e, "previousSibling") | |
| }, | |
| nextUntil: function(bZ, e, b0) { | |
| return bG.dir(bZ, "nextSibling", b0) | |
| }, | |
| prevUntil: function(bZ, e, b0) { | |
| return bG.dir(bZ, "previousSibling", b0) | |
| }, | |
| siblings: function(e) { | |
| return bG.sibling((e.parentNode || {}).firstChild, e) | |
| }, | |
| children: function(e) { | |
| return bG.sibling(e.firstChild) | |
| }, | |
| contents: function(e) { | |
| return bG.nodeName(e, "iframe") ? e.contentDocument || e.contentWindow.document : bG.merge([], e.childNodes) | |
| } | |
| }, function(e, bZ) { | |
| bG.fn[e] = function(b2, b0) { | |
| var b1 = bG.map(this, bZ, b2); | |
| if (!ag.test(e)) { | |
| b0 = b2 | |
| } | |
| if (b0 && typeof b0 === "string") { | |
| b1 = bG.filter(b0, b1) | |
| } | |
| b1 = this.length > 1 && !bu[e] ? bG.unique(b1) : b1; | |
| if (this.length > 1 && bq.test(e)) { | |
| b1 = b1.reverse() | |
| } | |
| return this.pushStack(b1, e, a4.call(arguments).join(",")) | |
| } | |
| }); | |
| bG.extend({ | |
| filter: function(b0, e, bZ) { | |
| if (bZ) { | |
| b0 = ":not(" + b0 + ")" | |
| } | |
| return e.length === 1 ? bG.find.matchesSelector(e[0], b0) ? [e[0]] : [] : bG.find.matches(b0, e) | |
| }, | |
| dir: function(b0, bZ, b2) { | |
| var e = [], | |
| b1 = b0[bZ]; | |
| while (b1 && b1.nodeType !== 9 && (b2 === aB || b1.nodeType !== 1 || !bG(b1).is(b2))) { | |
| if (b1.nodeType === 1) { | |
| e.push(b1) | |
| } | |
| b1 = b1[bZ] | |
| } | |
| return e | |
| }, | |
| sibling: function(b0, bZ) { | |
| var e = []; | |
| for (; b0; b0 = b0.nextSibling) { | |
| if (b0.nodeType === 1 && b0 !== bZ) { | |
| e.push(b0) | |
| } | |
| } | |
| return e | |
| } | |
| }); | |
| function aM(b1, b0, e) { | |
| b0 = b0 || 0; | |
| if (bG.isFunction(b0)) { | |
| return bG.grep(b1, function(b3, b2) { | |
| var b4 = !! b0.call(b3, b2, b3); | |
| return b4 === e | |
| }) | |
| } else { | |
| if (b0.nodeType) { | |
| return bG.grep(b1, function(b3, b2) { | |
| return (b3 === b0) === e | |
| }) | |
| } else { | |
| if (typeof b0 === "string") { | |
| var bZ = bG.grep(b1, function(b2) { | |
| return b2.nodeType === 1 | |
| }); | |
| if (al.test(b0)) { | |
| return bG.filter(b0, bZ, !e) | |
| } else { | |
| b0 = bG.filter(b0, bZ) | |
| } | |
| } | |
| } | |
| } | |
| return bG.grep(b1, function(b3, b2) { | |
| return (bG.inArray(b3, b0) >= 0) === e | |
| }) | |
| } | |
| function A(e) { | |
| var b0 = c.split("|"), | |
| bZ = e.createDocumentFragment(); | |
| if (bZ.createElement) { | |
| while (b0.length) { | |
| bZ.createElement(b0.pop()) | |
| } | |
| } | |
| return bZ | |
| } | |
| var c = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", | |
| av = / jQuery\d+="(?:null|\d+)"/g, | |
| bY = /^\s+/, | |
| ay = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, | |
| p = /<([\w:]+)/, | |
| bT = /<tbody/i, | |
| J = /<|&#?\w+;/, | |
| aj = /<(?:script|style|link)/i, | |
| ap = /<(?:script|object|embed|option|style)/i, | |
| K = new RegExp("<(?:" + c + ")[\\s/>]", "i"), | |
| aE = /^(?:checkbox|radio)$/, | |
| bR = /checked\s*(?:[^=]|=\s*.checked.)/i, | |
| bw = /\/(java|ecma)script/i, | |
| aH = /^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g, | |
| T = { | |
| option: [1, "<select multiple='multiple'>", "</select>"], | |
| legend: [1, "<fieldset>", "</fieldset>"], | |
| thead: [1, "<table>", "</table>"], | |
| tr: [2, "<table><tbody>", "</tbody></table>"], | |
| td: [3, "<table><tbody><tr>", "</tr></tbody></table>"], | |
| col: [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"], | |
| area: [1, "<map>", "</map>"], | |
| _default: [0, "", ""] | |
| }, | |
| aQ = A(o), | |
| l = aQ.appendChild(o.createElement("div")); | |
| T.optgroup = T.option; | |
| T.tbody = T.tfoot = T.colgroup = T.caption = T.thead; | |
| T.th = T.td; | |
| if (!bG.support.htmlSerialize) { | |
| T._default = [1, "X<div>", "</div>"] | |
| } | |
| bG.fn.extend({ | |
| text: function(e) { | |
| return bG.access(this, function(bZ) { | |
| return bZ === aB ? bG.text(this) : this.empty().append((this[0] && this[0].ownerDocument || o).createTextNode(bZ)) | |
| }, null, e, arguments.length) | |
| }, | |
| wrapAll: function(e) { | |
| if (bG.isFunction(e)) { | |
| return this.each(function(b0) { | |
| bG(this).wrapAll(e.call(this, b0)) | |
| }) | |
| } | |
| if (this[0]) { | |
| var bZ = bG(e, this[0].ownerDocument).eq(0).clone(true); | |
| if (this[0].parentNode) { | |
| bZ.insertBefore(this[0]) | |
| } | |
| bZ.map(function() { | |
| var b0 = this; | |
| while (b0.firstChild && b0.firstChild.nodeType === 1) { | |
| b0 = b0.firstChild | |
| } | |
| return b0 | |
| }).append(this) | |
| } | |
| return this | |
| }, | |
| wrapInner: function(e) { | |
| if (bG.isFunction(e)) { | |
| return this.each(function(bZ) { | |
| bG(this).wrapInner(e.call(this, bZ)) | |
| }) | |
| } | |
| return this.each(function() { | |
| var bZ = bG(this), | |
| b0 = bZ.contents(); | |
| if (b0.length) { | |
| b0.wrapAll(e) | |
| } else { | |
| bZ.append(e) | |
| } | |
| }) | |
| }, | |
| wrap: function(e) { | |
| var bZ = bG.isFunction(e); | |
| return this.each(function(b0) { | |
| bG(this).wrapAll(bZ ? e.call(this, b0) : e) | |
| }) | |
| }, | |
| unwrap: function() { | |
| return this.parent().each(function() { | |
| if (!bG.nodeName(this, "body")) { | |
| bG(this).replaceWith(this.childNodes) | |
| } | |
| }).end() | |
| }, | |
| append: function() { | |
| return this.domManip(arguments, true, function(e) { | |
| if (this.nodeType === 1 || this.nodeType === 11) { | |
| this.appendChild(e) | |
| } | |
| }) | |
| }, | |
| prepend: function() { | |
| return this.domManip(arguments, true, function(e) { | |
| if (this.nodeType === 1 || this.nodeType === 11) { | |
| this.insertBefore(e, this.firstChild) | |
| } | |
| }) | |
| }, | |
| before: function() { | |
| if (!aR(this[0])) { | |
| return this.domManip(arguments, false, function(bZ) { | |
| this.parentNode.insertBefore(bZ, this) | |
| }) | |
| } | |
| if (arguments.length) { | |
| var e = bG.clean(arguments); | |
| return this.pushStack(bG.merge(e, this), "before", this.selector) | |
| } | |
| }, | |
| after: function() { | |
| if (!aR(this[0])) { | |
| return this.domManip(arguments, false, function(bZ) { | |
| this.parentNode.insertBefore(bZ, this.nextSibling) | |
| }) | |
| } | |
| if (arguments.length) { | |
| var e = bG.clean(arguments); | |
| return this.pushStack(bG.merge(this, e), "after", this.selector) | |
| } | |
| }, | |
| remove: function(e, b1) { | |
| var b0, bZ = 0; | |
| for (; | |
| (b0 = this[bZ]) != null; bZ++) { | |
| if (!e || bG.filter(e, [b0]).length) { | |
| if (!b1 && b0.nodeType === 1) { | |
| bG.cleanData(b0.getElementsByTagName("*")); | |
| bG.cleanData([b0]) | |
| } | |
| if (b0.parentNode) { | |
| b0.parentNode.removeChild(b0) | |
| } | |
| } | |
| } | |
| return this | |
| }, | |
| empty: function() { | |
| var bZ, e = 0; | |
| for (; | |
| (bZ = this[e]) != null; e++) { | |
| if (bZ.nodeType === 1) { | |
| bG.cleanData(bZ.getElementsByTagName("*")) | |
| } | |
| while (bZ.firstChild) { | |
| bZ.removeChild(bZ.firstChild) | |
| } | |
| } | |
| return this | |
| }, | |
| clone: function(bZ, e) { | |
| bZ = bZ == null ? false : bZ; | |
| e = e == null ? bZ : e; | |
| return this.map(function() { | |
| return bG.clone(this, bZ, e) | |
| }) | |
| }, | |
| html: function(e) { | |
| return bG.access(this, function(b2) { | |
| var b1 = this[0] || {}, | |
| b0 = 0, | |
| bZ = this.length; | |
| if (b2 === aB) { | |
| return b1.nodeType === 1 ? b1.innerHTML.replace(av, "") : aB | |
| } | |
| if (typeof b2 === "string" && !aj.test(b2) && (bG.support.htmlSerialize || !K.test(b2)) && (bG.support.leadingWhitespace || !bY.test(b2)) && !T[(p.exec(b2) || ["", ""])[1].toLowerCase()]) { | |
| b2 = b2.replace(ay, "<$1></$2>"); | |
| try { | |
| for (; b0 < bZ; b0++) { | |
| b1 = this[b0] || {}; | |
| if (b1.nodeType === 1) { | |
| bG.cleanData(b1.getElementsByTagName("*")); | |
| b1.innerHTML = b2 | |
| } | |
| } | |
| b1 = 0 | |
| } catch (b3) {} | |
| } | |
| if (b1) { | |
| this.empty().append(b2) | |
| } | |
| }, null, e, arguments.length) | |
| }, | |
| replaceWith: function(e) { | |
| if (!aR(this[0])) { | |
| if (bG.isFunction(e)) { | |
| return this.each(function(b1) { | |
| var b0 = bG(this), | |
| bZ = b0.html(); | |
| b0.replaceWith(e.call(this, b1, bZ)) | |
| }) | |
| } | |
| if (typeof e !== "string") { | |
| e = bG(e).detach() | |
| } | |
| return this.each(function() { | |
| var b0 = this.nextSibling, | |
| bZ = this.parentNode; | |
| bG(this).remove(); | |
| if (b0) { | |
| bG(b0).before(e) | |
| } else { | |
| bG(bZ).append(e) | |
| } | |
| }) | |
| } | |
| return this.length ? this.pushStack(bG(bG.isFunction(e) ? e() : e), "replaceWith", e) : this | |
| }, | |
| detach: function(e) { | |
| return this.remove(e, true) | |
| }, | |
| domManip: function(b4, b8, b7) { | |
| b4 = [].concat.apply([], b4); | |
| var b0, b2, b3, b6, b1 = 0, | |
| b5 = b4[0], | |
| bZ = [], | |
| e = this.length; | |
| if (!bG.support.checkClone && e > 1 && typeof b5 === "string" && bR.test(b5)) { | |
| return this.each(function() { | |
| bG(this).domManip(b4, b8, b7) | |
| }) | |
| } | |
| if (bG.isFunction(b5)) { | |
| return this.each(function(ca) { | |
| var b9 = bG(this); | |
| b4[0] = b5.call(this, ca, b8 ? b9.html() : aB); | |
| b9.domManip(b4, b8, b7) | |
| }) | |
| } | |
| if (this[0]) { | |
| b0 = bG.buildFragment(b4, this, bZ); | |
| b3 = b0.fragment; | |
| b2 = b3.firstChild; | |
| if (b3.childNodes.length === 1) { | |
| b3 = b2 | |
| } | |
| if (b2) { | |
| b8 = b8 && bG.nodeName(b2, "tr"); | |
| for (b6 = b0.cacheable || e - 1; b1 < e; b1++) { | |
| b7.call(b8 && bG.nodeName(this[b1], "table") ? x(this[b1], "tbody") : this[b1], b1 === b6 ? b3 : bG.clone(b3, true, true)) | |
| } | |
| } | |
| b3 = b2 = null; | |
| if (bZ.length) { | |
| bG.each(bZ, function(b9, ca) { | |
| if (ca.src) { | |
| if (bG.ajax) { | |
| bG.ajax({ | |
| url: ca.src, | |
| type: "GET", | |
| dataType: "script", | |
| async: false, | |
| global: false, | |
| "throws": true | |
| }) | |
| } else { | |
| bG.error("no ajax") | |
| } | |
| } else { | |
| bG.globalEval((ca.text || ca.textContent || ca.innerHTML || "").replace(aH, "")) | |
| } | |
| if (ca.parentNode) { | |
| ca.parentNode.removeChild(ca) | |
| } | |
| }) | |
| } | |
| } | |
| return this | |
| } | |
| }); | |
| function x(bZ, e) { | |
| return bZ.getElementsByTagName(e)[0] || bZ.appendChild(bZ.ownerDocument.createElement(e)) | |
| } | |
| function ao(b5, bZ) { | |
| if (bZ.nodeType !== 1 || !bG.hasData(b5)) { | |
| return | |
| } | |
| var b2, b1, e, b4 = bG._data(b5), | |
| b3 = bG._data(bZ, b4), | |
| b0 = b4.events; | |
| if (b0) { | |
| delete b3.handle; | |
| b3.events = {}; | |
| for (b2 in b0) { | |
| for (b1 = 0, e = b0[b2].length; b1 < e; b1++) { | |
| bG.event.add(bZ, b2, b0[b2][b1]) | |
| } | |
| } | |
| } | |
| if (b3.data) { | |
| b3.data = bG.extend({}, b3.data) | |
| } | |
| } | |
| function F(bZ, e) { | |
| var b0; | |
| if (e.nodeType !== 1) { | |
| return | |
| } | |
| if (e.clearAttributes) { | |
| e.clearAttributes() | |
| } | |
| if (e.mergeAttributes) { | |
| e.mergeAttributes(bZ) | |
| } | |
| b0 = e.nodeName.toLowerCase(); | |
| if (b0 === "object") { | |
| if (e.parentNode) { | |
| e.outerHTML = bZ.outerHTML | |
| } | |
| if (bG.support.html5Clone && (bZ.innerHTML && !bG.trim(e.innerHTML))) { | |
| e.innerHTML = bZ.innerHTML | |
| } | |
| } else { | |
| if (b0 === "input" && aE.test(bZ.type)) { | |
| e.defaultChecked = e.checked = bZ.checked; | |
| if (e.value !== bZ.value) { | |
| e.value = bZ.value | |
| } | |
| } else { | |
| if (b0 === "option") { | |
| e.selected = bZ.defaultSelected | |
| } else { | |
| if (b0 === "input" || b0 === "textarea") { | |
| e.defaultValue = bZ.defaultValue | |
| } else { | |
| if (b0 === "script" && e.text !== bZ.text) { | |
| e.text = bZ.text | |
| } | |
| } | |
| } | |
| } | |
| } | |
| e.removeAttribute(bG.expando) | |
| } | |
| bG.buildFragment = function(b1, b2, bZ) { | |
| var b0, e, b3, b4 = b1[0]; | |
| b2 = b2 || o; | |
| b2 = !b2.nodeType && b2[0] || b2; | |
| b2 = b2.ownerDocument || b2; | |
| if (b1.length === 1 && typeof b4 === "string" && b4.length < 512 && b2 === o && b4.charAt(0) === "<" && !ap.test(b4) && (bG.support.checkClone || !bR.test(b4)) && (bG.support.html5Clone || !K.test(b4))) { | |
| e = true; | |
| b0 = bG.fragments[b4]; | |
| b3 = b0 !== aB | |
| } | |
| if (!b0) { | |
| b0 = b2.createDocumentFragment(); | |
| bG.clean(b1, b2, b0, bZ); | |
| if (e) { | |
| bG.fragments[b4] = b3 && b0 | |
| } | |
| } | |
| return { | |
| fragment: b0, | |
| cacheable: e | |
| } | |
| }; | |
| bG.fragments = {}; | |
| bG.each({ | |
| appendTo: "append", | |
| prependTo: "prepend", | |
| insertBefore: "before", | |
| insertAfter: "after", | |
| replaceAll: "replaceWith" | |
| }, function(e, bZ) { | |
| bG.fn[e] = function(b0) { | |
| var b2, b4 = 0, | |
| b3 = [], | |
| b6 = bG(b0), | |
| b1 = b6.length, | |
| b5 = this.length === 1 && this[0].parentNode; | |
| if ((b5 == null || b5 && b5.nodeType === 11 && b5.childNodes.length === 1) && b1 === 1) { | |
| b6[bZ](this[0]); | |
| return this | |
| } else { | |
| for (; b4 < b1; b4++) { | |
| b2 = (b4 > 0 ? this.clone(true) : this).get(); | |
| bG(b6[b4])[bZ](b2); | |
| b3 = b3.concat(b2) | |
| } | |
| return this.pushStack(b3, e, b6.selector) | |
| } | |
| } | |
| }); | |
| function m(e) { | |
| if (typeof e.getElementsByTagName !== "undefined") { | |
| return e.getElementsByTagName("*") | |
| } else { | |
| if (typeof e.querySelectorAll !== "undefined") { | |
| return e.querySelectorAll("*") | |
| } else { | |
| return [] | |
| } | |
| } | |
| } | |
| function bS(e) { | |
| if (aE.test(e.type)) { | |
| e.defaultChecked = e.checked | |
| } | |
| } | |
| bG.extend({ | |
| clone: function(b2, b4, b0) { | |
| var e, bZ, b1, b3; | |
| if (bG.support.html5Clone || bG.isXMLDoc(b2) || !K.test("<" + b2.nodeName + ">")) { | |
| b3 = b2.cloneNode(true) | |
| } else { | |
| l.innerHTML = b2.outerHTML; | |
| l.removeChild(b3 = l.firstChild) | |
| } | |
| if ((!bG.support.noCloneEvent || !bG.support.noCloneChecked) && (b2.nodeType === 1 || b2.nodeType === 11) && !bG.isXMLDoc(b2)) { | |
| F(b2, b3); | |
| e = m(b2); | |
| bZ = m(b3); | |
| for (b1 = 0; e[b1]; ++b1) { | |
| if (bZ[b1]) { | |
| F(e[b1], bZ[b1]) | |
| } | |
| } | |
| } | |
| if (b4) { | |
| ao(b2, b3); | |
| if (b0) { | |
| e = m(b2); | |
| bZ = m(b3); | |
| for (b1 = 0; e[b1]; ++b1) { | |
| ao(e[b1], bZ[b1]) | |
| } | |
| } | |
| } | |
| e = bZ = null; | |
| return b3 | |
| }, | |
| clean: function(cb, b0, e, b1) { | |
| var b8, b7, ca, cf, b4, ce, b5, b2, bZ, b9, cd, b6, b3 = b0 === o && aQ, | |
| cc = []; | |
| if (!b0 || typeof b0.createDocumentFragment === "undefined") { | |
| b0 = o | |
| } | |
| for (b8 = 0; | |
| (ca = cb[b8]) != null; b8++) { | |
| if (typeof ca === "number") { | |
| ca += "" | |
| } | |
| if (!ca) { | |
| continue | |
| } | |
| if (typeof ca === "string") { | |
| if (!J.test(ca)) { | |
| ca = b0.createTextNode(ca) | |
| } else { | |
| b3 = b3 || A(b0); | |
| b5 = b0.createElement("div"); | |
| b3.appendChild(b5); | |
| ca = ca.replace(ay, "<$1></$2>"); | |
| cf = (p.exec(ca) || ["", ""])[1].toLowerCase(); | |
| b4 = T[cf] || T._default; | |
| ce = b4[0]; | |
| b5.innerHTML = b4[1] + ca + b4[2]; | |
| while (ce--) { | |
| b5 = b5.lastChild | |
| } | |
| if (!bG.support.tbody) { | |
| b2 = bT.test(ca); | |
| bZ = cf === "table" && !b2 ? b5.firstChild && b5.firstChild.childNodes : b4[1] === "<table>" && !b2 ? b5.childNodes : []; | |
| for (b7 = bZ.length - 1; b7 >= 0; --b7) { | |
| if (bG.nodeName(bZ[b7], "tbody") && !bZ[b7].childNodes.length) { | |
| bZ[b7].parentNode.removeChild(bZ[b7]) | |
| } | |
| } | |
| } | |
| if (!bG.support.leadingWhitespace && bY.test(ca)) { | |
| b5.insertBefore(b0.createTextNode(bY.exec(ca)[0]), b5.firstChild) | |
| } | |
| ca = b5.childNodes; | |
| b5.parentNode.removeChild(b5) | |
| } | |
| } | |
| if (ca.nodeType) { | |
| cc.push(ca) | |
| } else { | |
| bG.merge(cc, ca) | |
| } | |
| } | |
| if (b5) { | |
| ca = b5 = b3 = null | |
| } | |
| if (!bG.support.appendChecked) { | |
| for (b8 = 0; | |
| (ca = cc[b8]) != null; b8++) { | |
| if (bG.nodeName(ca, "input")) { | |
| bS(ca) | |
| } else { | |
| if (typeof ca.getElementsByTagName !== "undefined") { | |
| bG.grep(ca.getElementsByTagName("input"), bS) | |
| } | |
| } | |
| } | |
| } | |
| if (e) { | |
| cd = function(cg) { | |
| if (!cg.type || bw.test(cg.type)) { | |
| return b1 ? b1.push(cg.parentNode ? cg.parentNode.removeChild(cg) : cg) : e.appendChild(cg) | |
| } | |
| }; | |
| for (b8 = 0; | |
| (ca = cc[b8]) != null; b8++) { | |
| if (!(bG.nodeName(ca, "script") && cd(ca))) { | |
| e.appendChild(ca); | |
| if (typeof ca.getElementsByTagName !== "undefined") { | |
| b6 = bG.grep(bG.merge([], ca.getElementsByTagName("script")), cd); | |
| cc.splice.apply(cc, [b8 + 1, 0].concat(b6)); | |
| b8 += b6.length | |
| } | |
| } | |
| } | |
| } | |
| return cc | |
| }, | |
| cleanData: function(bZ, b7) { | |
| var b2, b0, b1, b6, b3 = 0, | |
| b8 = bG.expando, | |
| e = bG.cache, | |
| b4 = bG.support.deleteExpando, | |
| b5 = bG.event.special; | |
| for (; | |
| (b1 = bZ[b3]) != null; b3++) { | |
| if (b7 || bG.acceptData(b1)) { | |
| b0 = b1[b8]; | |
| b2 = b0 && e[b0]; | |
| if (b2) { | |
| if (b2.events) { | |
| for (b6 in b2.events) { | |
| if (b5[b6]) { | |
| bG.event.remove(b1, b6) | |
| } else { | |
| bG.removeEvent(b1, b6, b2.handle) | |
| } | |
| } | |
| } | |
| if (e[b0]) { | |
| delete e[b0]; | |
| if (b4) { | |
| delete b1[b8] | |
| } else { | |
| if (b1.removeAttribute) { | |
| b1.removeAttribute(b8) | |
| } else { | |
| b1[b8] = null | |
| } | |
| } | |
| bG.deletedIds.push(b0) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }); | |
| (function() { | |
| var e, bZ; | |
| bG.uaMatch = function(b1) { | |
| b1 = b1.toLowerCase(); | |
| var b0 = /(chrome)[ \/]([\w.]+)/.exec(b1) || /(webkit)[ \/]([\w.]+)/.exec(b1) || /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(b1) || /(msie) ([\w.]+)/.exec(b1) || b1.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(b1) || []; | |
| return { | |
| browser: b0[1] || "", | |
| version: b0[2] || "0" | |
| } | |
| }; | |
| e = bG.uaMatch(d.userAgent); | |
| bZ = {}; | |
| if (e.browser) { | |
| bZ[e.browser] = true; | |
| bZ.version = e.version | |
| } | |
| if (bZ.chrome) { | |
| bZ.webkit = true | |
| } else { | |
| if (bZ.webkit) { | |
| bZ.safari = true | |
| } | |
| } | |
| bG.browser = bZ; | |
| bG.sub = function() { | |
| function b0(b3, b4) { | |
| return new b0.fn.init(b3, b4) | |
| } | |
| bG.extend(true, b0, this); | |
| b0.superclass = this; | |
| b0.fn = b0.prototype = this(); | |
| b0.fn.constructor = b0; | |
| b0.sub = this.sub; | |
| b0.fn.init = function b2(b3, b4) { | |
| if (b4 && b4 instanceof bG && !(b4 instanceof b0)) { | |
| b4 = b0(b4) | |
| } | |
| return bG.fn.init.call(this, b3, b4, b1) | |
| }; | |
| b0.fn.init.prototype = b0.fn; | |
| var b1 = b0(o); | |
| return b0 | |
| } | |
| })(); | |
| var E, az, aW, be = /alpha\([^)]*\)/i, | |
| aS = /opacity=([^)]*)/, | |
| bk = /^(top|right|bottom|left)$/, | |
| G = /^(none|table(?!-c[ea]).+)/, | |
| aZ = /^margin/, | |
| a8 = new RegExp("^(" + bx + ")(.*)$", "i"), | |
| W = new RegExp("^(" + bx + ")(?!px)[a-z%]+$", "i"), | |
| S = new RegExp("^([-+])=(" + bx + ")", "i"), | |
| bh = {}, | |
| a9 = { | |
| position: "absolute", | |
| visibility: "hidden", | |
| display: "block" | |
| }, | |
| bA = { | |
| letterSpacing: 0, | |
| fontWeight: 400 | |
| }, | |
| bQ = ["Top", "Right", "Bottom", "Left"], | |
| ar = ["Webkit", "O", "Moz", "ms"], | |
| aJ = bG.fn.toggle; | |
| function b(b1, bZ) { | |
| if (bZ in b1) { | |
| return bZ | |
| } | |
| var b2 = bZ.charAt(0).toUpperCase() + bZ.slice(1), | |
| e = bZ, | |
| b0 = ar.length; | |
| while (b0--) { | |
| bZ = ar[b0] + b2; | |
| if (bZ in b1) { | |
| return bZ | |
| } | |
| } | |
| return e | |
| } | |
| function Q(bZ, e) { | |
| bZ = e || bZ; | |
| return bG.css(bZ, "display") === "none" || !bG.contains(bZ.ownerDocument, bZ) | |
| } | |
| function s(b3, e) { | |
| var b2, b4, bZ = [], | |
| b0 = 0, | |
| b1 = b3.length; | |
| for (; b0 < b1; b0++) { | |
| b2 = b3[b0]; | |
| if (!b2.style) { | |
| continue | |
| } | |
| bZ[b0] = bG._data(b2, "olddisplay"); | |
| if (e) { | |
| if (!bZ[b0] && b2.style.display === "none") { | |
| b2.style.display = "" | |
| } | |
| if (b2.style.display === "" && Q(b2)) { | |
| bZ[b0] = bG._data(b2, "olddisplay", bC(b2.nodeName)) | |
| } | |
| } else { | |
| b4 = E(b2, "display"); | |
| if (!bZ[b0] && b4 !== "none") { | |
| bG._data(b2, "olddisplay", b4) | |
| } | |
| } | |
| } | |
| for (b0 = 0; b0 < b1; b0++) { | |
| b2 = b3[b0]; | |
| if (!b2.style) { | |
| continue | |
| } | |
| if (!e || b2.style.display === "none" || b2.style.display === "") { | |
| b2.style.display = e ? bZ[b0] || "" : "none" | |
| } | |
| } | |
| return b3 | |
| } | |
| bG.fn.extend({ | |
| css: function(e, bZ) { | |
| return bG.access(this, function(b1, b0, b2) { | |
| return b2 !== aB ? bG.style(b1, b0, b2) : bG.css(b1, b0) | |
| }, e, bZ, arguments.length > 1) | |
| }, | |
| show: function() { | |
| return s(this, true) | |
| }, | |
| hide: function() { | |
| return s(this) | |
| }, | |
| toggle: function(b0, bZ) { | |
| var e = typeof b0 === "boolean"; | |
| if (bG.isFunction(b0) && bG.isFunction(bZ)) { | |
| return aJ.apply(this, arguments) | |
| } | |
| return this.each(function() { | |
| if (e ? b0 : Q(this)) { | |
| bG(this).show() | |
| } else { | |
| bG(this).hide() | |
| } | |
| }) | |
| } | |
| }); | |
| bG.extend({ | |
| cssHooks: { | |
| opacity: { | |
| get: function(b0, bZ) { | |
| if (bZ) { | |
| var e = E(b0, "opacity"); | |
| return e === "" ? "1" : e | |
| } | |
| } | |
| } | |
| }, | |
| cssNumber: { | |
| fillOpacity: true, | |
| fontWeight: true, | |
| lineHeight: true, | |
| opacity: true, | |
| orphans: true, | |
| widows: true, | |
| zIndex: true, | |
| zoom: true | |
| }, | |
| cssProps: { | |
| "float": bG.support.cssFloat ? "cssFloat" : "styleFloat" | |
| }, | |
| style: function(b1, b0, b7, b2) { | |
| if (!b1 || b1.nodeType === 3 || b1.nodeType === 8 || !b1.style) { | |
| return | |
| } | |
| var b5, b6, b8, b3 = bG.camelCase(b0), | |
| bZ = b1.style; | |
| b0 = bG.cssProps[b3] || (bG.cssProps[b3] = b(bZ, b3)); | |
| b8 = bG.cssHooks[b0] || bG.cssHooks[b3]; | |
| if (b7 !== aB) { | |
| b6 = typeof b7; | |
| if (b6 === "string" && (b5 = S.exec(b7))) { | |
| b7 = (b5[1] + 1) * b5[2] + parseFloat(bG.css(b1, b0)); | |
| b6 = "number" | |
| } | |
| if (b7 == null || b6 === "number" && isNaN(b7)) { | |
| return | |
| } | |
| if (b6 === "number" && !bG.cssNumber[b3]) { | |
| b7 += "px" | |
| } | |
| if (!b8 || !("set" in b8) || (b7 = b8.set(b1, b7, b2)) !== aB) { | |
| try { | |
| bZ[b0] = b7 | |
| } catch (b4) {} | |
| } | |
| } else { | |
| if (b8 && "get" in b8 && (b5 = b8.get(b1, false, b2)) !== aB) { | |
| return b5 | |
| } | |
| return bZ[b0] | |
| } | |
| }, | |
| css: function(b4, b2, b3, bZ) { | |
| var b5, b1, e, b0 = bG.camelCase(b2); | |
| b2 = bG.cssProps[b0] || (bG.cssProps[b0] = b(b4.style, b0)); | |
| e = bG.cssHooks[b2] || bG.cssHooks[b0]; | |
| if (e && "get" in e) { | |
| b5 = e.get(b4, true, bZ) | |
| } | |
| if (b5 === aB) { | |
| b5 = E(b4, b2) | |
| } | |
| if (b5 === "normal" && b2 in bA) { | |
| b5 = bA[b2] | |
| } | |
| if (b3 || bZ !== aB) { | |
| b1 = parseFloat(b5); | |
| return b3 || bG.isNumeric(b1) ? b1 || 0 : b5 | |
| } | |
| return b5 | |
| }, | |
| swap: function(b2, b1, b3) { | |
| var b0, bZ, e = {}; | |
| for (bZ in b1) { | |
| e[bZ] = b2.style[bZ]; | |
| b2.style[bZ] = b1[bZ] | |
| } | |
| b0 = b3.call(b2); | |
| for (bZ in b1) { | |
| b2.style[bZ] = e[bZ] | |
| } | |
| return b0 | |
| } | |
| }); | |
| if (a2.getComputedStyle) { | |
| E = function(b5, bZ) { | |
| var e, b2, b1, b4, b3 = a2.getComputedStyle(b5, null), | |
| b0 = b5.style; | |
| if (b3) { | |
| e = b3[bZ]; | |
| if (e === "" && !bG.contains(b5.ownerDocument, b5)) { | |
| e = bG.style(b5, bZ) | |
| } | |
| if (W.test(e) && aZ.test(bZ)) { | |
| b2 = b0.width; | |
| b1 = b0.minWidth; | |
| b4 = b0.maxWidth; | |
| b0.minWidth = b0.maxWidth = b0.width = e; | |
| e = b3.width; | |
| b0.width = b2; | |
| b0.minWidth = b1; | |
| b0.maxWidth = b4 | |
| } | |
| } | |
| return e | |
| } | |
| } else { | |
| if (o.documentElement.currentStyle) { | |
| E = function(b2, b0) { | |
| var b3, e, bZ = b2.currentStyle && b2.currentStyle[b0], | |
| b1 = b2.style; | |
| if (bZ == null && b1 && b1[b0]) { | |
| bZ = b1[b0] | |
| } | |
| if (W.test(bZ) && !bk.test(b0)) { | |
| b3 = b1.left; | |
| e = b2.runtimeStyle && b2.runtimeStyle.left; | |
| if (e) { | |
| b2.runtimeStyle.left = b2.currentStyle.left | |
| } | |
| b1.left = b0 === "fontSize" ? "1em" : bZ; | |
| bZ = b1.pixelLeft + "px"; | |
| b1.left = b3; | |
| if (e) { | |
| b2.runtimeStyle.left = e | |
| } | |
| } | |
| return bZ === "" ? "auto" : bZ | |
| } | |
| } | |
| } | |
| function aG(e, b0, b1) { | |
| var bZ = a8.exec(b0); | |
| return bZ ? Math.max(0, bZ[1] - (b1 || 0)) + (bZ[2] || "px") : b0 | |
| } | |
| function at(b1, bZ, e, b3) { | |
| var b0 = e === (b3 ? "border" : "content") ? 4 : bZ === "width" ? 1 : 0, | |
| b2 = 0; | |
| for (; b0 < 4; b0 += 2) { | |
| if (e === "margin") { | |
| b2 += bG.css(b1, e + bQ[b0], true) | |
| } | |
| if (b3) { | |
| if (e === "content") { | |
| b2 -= parseFloat(E(b1, "padding" + bQ[b0])) || 0 | |
| } | |
| if (e !== "margin") { | |
| b2 -= parseFloat(E(b1, "border" + bQ[b0] + "Width")) || 0 | |
| } | |
| } else { | |
| b2 += parseFloat(E(b1, "padding" + bQ[b0])) || 0; | |
| if (e !== "padding") { | |
| b2 += parseFloat(E(b1, "border" + bQ[b0] + "Width")) || 0 | |
| } | |
| } | |
| } | |
| return b2 | |
| } | |
| function u(b1, bZ, e) { | |
| var b2 = bZ === "width" ? b1.offsetWidth : b1.offsetHeight, | |
| b0 = true, | |
| b3 = bG.support.boxSizing && bG.css(b1, "boxSizing") === "border-box"; | |
| if (b2 <= 0 || b2 == null) { | |
| b2 = E(b1, bZ); | |
| if (b2 < 0 || b2 == null) { | |
| b2 = b1.style[bZ] | |
| } | |
| if (W.test(b2)) { | |
| return b2 | |
| } | |
| b0 = b3 && (bG.support.boxSizingReliable || b2 === b1.style[bZ]); | |
| b2 = parseFloat(b2) || 0 | |
| } | |
| return (b2 + at(b1, bZ, e || (b3 ? "border" : "content"), b0)) + "px" | |
| } | |
| function bC(b0) { | |
| if (bh[b0]) { | |
| return bh[b0] | |
| } | |
| var e = bG("<" + b0 + ">").appendTo(o.body), | |
| bZ = e.css("display"); | |
| e.remove(); | |
| if (bZ === "none" || bZ === "") { | |
| az = o.body.appendChild(az || bG.extend(o.createElement("iframe"), { | |
| frameBorder: 0, | |
| width: 0, | |
| height: 0 | |
| })); | |
| if (!aW || !az.createElement) { | |
| aW = (az.contentWindow || az.contentDocument).document; | |
| aW.write("<!doctype html><html><body>"); | |
| aW.close() | |
| } | |
| e = aW.body.appendChild(aW.createElement(b0)); | |
| bZ = E(e, "display"); | |
| o.body.removeChild(az) | |
| } | |
| bh[b0] = bZ; | |
| return bZ | |
| } | |
| bG.each(["height", "width"], function(bZ, e) { | |
| bG.cssHooks[e] = { | |
| get: function(b2, b1, b0) { | |
| if (b1) { | |
| if (b2.offsetWidth === 0 && G.test(E(b2, "display"))) { | |
| return bG.swap(b2, a9, function() { | |
| return u(b2, e, b0) | |
| }) | |
| } else { | |
| return u(b2, e, b0) | |
| } | |
| } | |
| }, | |
| set: function(b1, b2, b0) { | |
| return aG(b1, b2, b0 ? at(b1, e, b0, bG.support.boxSizing && bG.css(b1, "boxSizing") === "border-box") : 0) | |
| } | |
| } | |
| }); | |
| if (!bG.support.opacity) { | |
| bG.cssHooks.opacity = { | |
| get: function(bZ, e) { | |
| return aS.test((e && bZ.currentStyle ? bZ.currentStyle.filter : bZ.style.filter) || "") ? (0.01 * parseFloat(RegExp.$1)) + "" : e ? "1" : "" | |
| }, | |
| set: function(b2, b3) { | |
| var b1 = b2.style, | |
| bZ = b2.currentStyle, | |
| e = bG.isNumeric(b3) ? "alpha(opacity=" + b3 * 100 + ")" : "", | |
| b0 = bZ && bZ.filter || b1.filter || ""; | |
| b1.zoom = 1; | |
| if (b3 >= 1 && bG.trim(b0.replace(be, "")) === "" && b1.removeAttribute) { | |
| b1.removeAttribute("filter"); | |
| if (bZ && !bZ.filter) { | |
| return | |
| } | |
| } | |
| b1.filter = be.test(b0) ? b0.replace(be, e) : b0 + " " + e | |
| } | |
| } | |
| } | |
| bG(function() { | |
| if (!bG.support.reliableMarginRight) { | |
| bG.cssHooks.marginRight = { | |
| get: function(bZ, e) { | |
| return bG.swap(bZ, { | |
| display: "inline-block" | |
| }, function() { | |
| if (e) { | |
| return E(bZ, "marginRight") | |
| } | |
| }) | |
| } | |
| } | |
| } | |
| if (!bG.support.pixelPosition && bG.fn.position) { | |
| bG.each(["top", "left"], function(e, bZ) { | |
| bG.cssHooks[bZ] = { | |
| get: function(b2, b1) { | |
| if (b1) { | |
| var b0 = E(b2, bZ); | |
| return W.test(b0) ? bG(b2).position()[bZ] + "px" : b0 | |
| } | |
| } | |
| } | |
| }) | |
| } | |
| }); | |
| if (bG.expr && bG.expr.filters) { | |
| bG.expr.filters.hidden = function(e) { | |
| return (e.offsetWidth === 0 && e.offsetHeight === 0) || (!bG.support.reliableHiddenOffsets && ((e.style && e.style.display) || E(e, "display")) === "none") | |
| }; | |
| bG.expr.filters.visible = function(e) { | |
| return !bG.expr.filters.hidden(e) | |
| } | |
| } | |
| bG.each({ | |
| margin: "", | |
| padding: "", | |
| border: "Width" | |
| }, function(e, bZ) { | |
| bG.cssHooks[e + bZ] = { | |
| expand: function(b2) { | |
| var b1, b3 = typeof b2 === "string" ? b2.split(" ") : [b2], | |
| b0 = {}; | |
| for (b1 = 0; b1 < 4; b1++) { | |
| b0[e + bQ[b1] + bZ] = b3[b1] || b3[b1 - 2] || b3[0] | |
| } | |
| return b0 | |
| } | |
| }; | |
| if (!aZ.test(e)) { | |
| bG.cssHooks[e + bZ].set = aG | |
| } | |
| }); | |
| var bs = /%20/g, | |
| aP = /\[\]$/, | |
| U = /\r?\n/g, | |
| bz = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i, | |
| aD = /^(?:select|textarea)/i; | |
| bG.fn.extend({ | |
| serialize: function() { | |
| return bG.param(this.serializeArray()) | |
| }, | |
| serializeArray: function() { | |
| return this.map(function() { | |
| return this.elements ? bG.makeArray(this.elements) : this | |
| }).filter(function() { | |
| return this.name && !this.disabled && (this.checked || aD.test(this.nodeName) || bz.test(this.type)) | |
| }).map(function(e, bZ) { | |
| var b0 = bG(this).val(); | |
| return b0 == null ? null : bG.isArray(b0) ? bG.map(b0, function(b2, b1) { | |
| return { | |
| name: bZ.name, | |
| value: b2.replace(U, "\r\n") | |
| } | |
| }) : { | |
| name: bZ.name, | |
| value: b0.replace(U, "\r\n") | |
| } | |
| }).get() | |
| } | |
| }); | |
| bG.param = function(e, b0) { | |
| var b1, bZ = [], | |
| b2 = function(b3, b4) { | |
| b4 = bG.isFunction(b4) ? b4() : (b4 == null ? "" : b4); | |
| bZ[bZ.length] = encodeURIComponent(b3) + "=" + encodeURIComponent(b4) | |
| }; | |
| if (b0 === aB) { | |
| b0 = bG.ajaxSettings && bG.ajaxSettings.traditional | |
| } | |
| if (bG.isArray(e) || (e.jquery && !bG.isPlainObject(e))) { | |
| bG.each(e, function() { | |
| b2(this.name, this.value) | |
| }) | |
| } else { | |
| for (b1 in e) { | |
| k(b1, e[b1], b0, b2) | |
| } | |
| } | |
| return bZ.join("&").replace(bs, "+") | |
| }; | |
| function k(b0, b2, bZ, b1) { | |
| var e; | |
| if (bG.isArray(b2)) { | |
| bG.each(b2, function(b4, b3) { | |
| if (bZ || aP.test(b0)) { | |
| b1(b0, b3) | |
| } else { | |
| k(b0 + "[" + (typeof b3 === "object" ? b4 : "") + "]", b3, bZ, b1) | |
| } | |
| }) | |
| } else { | |
| if (!bZ && bG.type(b2) === "object") { | |
| for (e in b2) { | |
| k(b0 + "[" + e + "]", b2[e], bZ, b1) | |
| } | |
| } else { | |
| b1(b0, b2) | |
| } | |
| } | |
| } | |
| var bX, Y, an = /#.*$/, | |
| ad = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, | |
| B = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/, | |
| r = /^(?:GET|HEAD)$/, | |
| aC = /^\/\//, | |
| bN = /\?/, | |
| g = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, | |
| P = /([?&])_=[^&]*/, | |
| aT = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/, | |
| bW = bG.fn.load, | |
| v = {}, | |
| a6 = {}, | |
| aX = ["*/"] + ["*"]; | |
| try { | |
| Y = aI.href | |
| } catch (bd) { | |
| Y = o.createElement("a"); | |
| Y.href = ""; | |
| Y = Y.href | |
| } | |
| bX = aT.exec(Y.toLowerCase()) || []; | |
| function bI(e) { | |
| return function(b2, b4) { | |
| if (typeof b2 !== "string") { | |
| b4 = b2; | |
| b2 = "*" | |
| } | |
| var bZ, b5, b6, b1 = b2.toLowerCase().split(aV), | |
| b0 = 0, | |
| b3 = b1.length; | |
| if (bG.isFunction(b4)) { | |
| for (; b0 < b3; b0++) { | |
| bZ = b1[b0]; | |
| b6 = /^\+/.test(bZ); | |
| if (b6) { | |
| bZ = bZ.substr(1) || "*" | |
| } | |
| b5 = e[bZ] = e[bZ] || []; | |
| b5[b6 ? "unshift" : "push"](b4) | |
| } | |
| } | |
| } | |
| } | |
| function q(bZ, b8, b3, b6, b5, b1) { | |
| b5 = b5 || b8.dataTypes[0]; | |
| b1 = b1 || {}; | |
| b1[b5] = true; | |
| var b7, b4 = bZ[b5], | |
| b0 = 0, | |
| e = b4 ? b4.length : 0, | |
| b2 = (bZ === v); | |
| for (; b0 < e && (b2 || !b7); b0++) { | |
| b7 = b4[b0](b8, b3, b6); | |
| if (typeof b7 === "string") { | |
| if (!b2 || b1[b7]) { | |
| b7 = aB | |
| } else { | |
| b8.dataTypes.unshift(b7); | |
| b7 = q(bZ, b8, b3, b6, b7, b1) | |
| } | |
| } | |
| } | |
| if ((b2 || !b7) && !b1["*"]) { | |
| b7 = q(bZ, b8, b3, b6, "*", b1) | |
| } | |
| return b7 | |
| } | |
| function t(b0, b1) { | |
| var bZ, e, b2 = bG.ajaxSettings.flatOptions || {}; | |
| for (bZ in b1) { | |
| if (b1[bZ] !== aB) { | |
| (b2[bZ] ? b0 : (e || (e = {})))[bZ] = b1[bZ] | |
| } | |
| } | |
| if (e) { | |
| bG.extend(true, b0, e) | |
| } | |
| } | |
| bG.fn.load = function(b1, b4, b5) { | |
| if (typeof b1 !== "string" && bW) { | |
| return bW.apply(this, arguments) | |
| } | |
| if (!this.length) { | |
| return this | |
| } | |
| var e, b2, b0, bZ = this, | |
| b3 = b1.indexOf(" "); | |
| if (b3 >= 0) { | |
| e = b1.slice(b3, b1.length); | |
| b1 = b1.slice(0, b3) | |
| } | |
| if (bG.isFunction(b4)) { | |
| b5 = b4; | |
| b4 = aB | |
| } else { | |
| if (b4 && typeof b4 === "object") { | |
| b2 = "POST" | |
| } | |
| } | |
| bG.ajax({ | |
| url: b1, | |
| type: b2, | |
| dataType: "html", | |
| data: b4, | |
| complete: function(b7, b6) { | |
| if (b5) { | |
| bZ.each(b5, b0 || [b7.responseText, b6, b7]) | |
| } | |
| } | |
| }).done(function(b6) { | |
| b0 = arguments; | |
| bZ.html(e ? bG("<div>").append(b6.replace(g, "")).find(e) : b6) | |
| }); | |
| return this | |
| }; | |
| bG.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function(e, bZ) { | |
| bG.fn[bZ] = function(b0) { | |
| return this.on(bZ, b0) | |
| } | |
| }); | |
| bG.each(["get", "post"], function(e, bZ) { | |
| bG[bZ] = function(b0, b2, b3, b1) { | |
| if (bG.isFunction(b2)) { | |
| b1 = b1 || b3; | |
| b3 = b2; | |
| b2 = aB | |
| } | |
| return bG.ajax({ | |
| type: bZ, | |
| url: b0, | |
| data: b2, | |
| success: b3, | |
| dataType: b1 | |
| }) | |
| } | |
| }); | |
| bG.extend({ | |
| getScript: function(e, bZ) { | |
| return bG.get(e, aB, bZ, "script") | |
| }, | |
| getJSON: function(e, bZ, b0) { | |
| return bG.get(e, bZ, b0, "json") | |
| }, | |
| ajaxSetup: function(bZ, e) { | |
| if (e) { | |
| t(bZ, bG.ajaxSettings) | |
| } else { | |
| e = bZ; | |
| bZ = bG.ajaxSettings | |
| } | |
| t(bZ, e); | |
| return bZ | |
| }, | |
| ajaxSettings: { | |
| url: Y, | |
| isLocal: B.test(bX[1]), | |
| global: true, | |
| type: "GET", | |
| contentType: "application/x-www-form-urlencoded; charset=UTF-8", | |
| processData: true, | |
| async: true, | |
| accepts: { | |
| xml: "application/xml, text/xml", | |
| html: "text/html", | |
| text: "text/plain", | |
| json: "application/json, text/javascript", | |
| "*": aX | |
| }, | |
| contents: { | |
| xml: /xml/, | |
| html: /html/, | |
| json: /json/ | |
| }, | |
| responseFields: { | |
| xml: "responseXML", | |
| text: "responseText" | |
| }, | |
| converters: { | |
| "* text": a2.String, | |
| "text html": true, | |
| "text json": bG.parseJSON, | |
| "text xml": bG.parseXML | |
| }, | |
| flatOptions: { | |
| context: true, | |
| url: true | |
| } | |
| }, | |
| ajaxPrefilter: bI(v), | |
| ajaxTransport: bI(a6), | |
| ajax: function(b4, b1) { | |
| if (typeof b4 === "object") { | |
| b1 = b4; | |
| b4 = aB | |
| } | |
| b1 = b1 || {}; | |
| var b7, cl, b2, cg, b9, cd, b0, cf, b8 = bG.ajaxSetup({}, b1), | |
| cn = b8.context || b8, | |
| cb = cn !== b8 && (cn.nodeType || cn instanceof bG) ? bG(cn) : bG.event, | |
| cm = bG.Deferred(), | |
| ci = bG.Callbacks("once memory"), | |
| b5 = b8.statusCode || {}, | |
| cc = {}, | |
| cj = {}, | |
| b3 = 0, | |
| b6 = "canceled", | |
| ce = { | |
| readyState: 0, | |
| setRequestHeader: function(co, cp) { | |
| if (!b3) { | |
| var e = co.toLowerCase(); | |
| co = cj[e] = cj[e] || co; | |
| cc[co] = cp | |
| } | |
| return this | |
| }, | |
| getAllResponseHeaders: function() { | |
| return b3 === 2 ? cl : null | |
| }, | |
| getResponseHeader: function(co) { | |
| var e; | |
| if (b3 === 2) { | |
| if (!b2) { | |
| b2 = {}; | |
| while ((e = ad.exec(cl))) { | |
| b2[e[1].toLowerCase()] = e[2] | |
| } | |
| } | |
| e = b2[co.toLowerCase()] | |
| } | |
| return e === aB ? null : e | |
| }, | |
| overrideMimeType: function(e) { | |
| if (!b3) { | |
| b8.mimeType = e | |
| } | |
| return this | |
| }, | |
| abort: function(e) { | |
| e = e || b6; | |
| if (cg) { | |
| cg.abort(e) | |
| } | |
| ca(0, e); | |
| return this | |
| } | |
| }; | |
| function ca(cs, co, ct, cq) { | |
| var e, cw, cu, cr, cv, cp = co; | |
| if (b3 === 2) { | |
| return | |
| } | |
| b3 = 2; | |
| if (b9) { | |
| clearTimeout(b9) | |
| } | |
| cg = aB; | |
| cl = cq || ""; | |
| ce.readyState = cs > 0 ? 4 : 0; | |
| if (ct) { | |
| cr = h(b8, ce, ct) | |
| } | |
| if (cs >= 200 && cs < 300 || cs === 304) { | |
| if (b8.ifModified) { | |
| cv = ce.getResponseHeader("Last-Modified"); | |
| if (cv) { | |
| bG.lastModified[b7] = cv | |
| } | |
| cv = ce.getResponseHeader("Etag"); | |
| if (cv) { | |
| bG.etag[b7] = cv | |
| } | |
| } | |
| if (cs === 304) { | |
| cp = "notmodified"; | |
| e = true | |
| } else { | |
| e = ae(b8, cr); | |
| cp = e.state; | |
| cw = e.data; | |
| cu = e.error; | |
| e = !cu | |
| } | |
| } else { | |
| cu = cp; | |
| if (!cp || cs) { | |
| cp = "error"; | |
| if (cs < 0) { | |
| cs = 0 | |
| } | |
| } | |
| } | |
| ce.status = cs; | |
| ce.statusText = (co || cp) + ""; | |
| if (e) { | |
| cm.resolveWith(cn, [cw, cp, ce]) | |
| } else { | |
| cm.rejectWith(cn, [ce, cp, cu]) | |
| } | |
| ce.statusCode(b5); | |
| b5 = aB; | |
| if (b0) { | |
| cb.trigger("ajax" + (e ? "Success" : "Error"), [ce, b8, e ? cw : cu]) | |
| } | |
| ci.fireWith(cn, [ce, cp]); | |
| if (b0) { | |
| cb.trigger("ajaxComplete", [ce, b8]); | |
| if (!(--bG.active)) { | |
| bG.event.trigger("ajaxStop") | |
| } | |
| } | |
| } | |
| cm.promise(ce); | |
| ce.success = ce.done; | |
| ce.error = ce.fail; | |
| ce.complete = ci.add; | |
| ce.statusCode = function(co) { | |
| if (co) { | |
| var e; | |
| if (b3 < 2) { | |
| for (e in co) { | |
| b5[e] = [b5[e], co[e]] | |
| } | |
| } else { | |
| e = co[ce.status]; | |
| ce.always(e) | |
| } | |
| } | |
| return this | |
| }; | |
| b8.url = ((b4 || b8.url) + "").replace(an, "").replace(aC, bX[1] + "//"); | |
| b8.dataTypes = bG.trim(b8.dataType || "*").toLowerCase().split(aV); | |
| if (b8.crossDomain == null) { | |
| cd = aT.exec(b8.url.toLowerCase()) || false; | |
| b8.crossDomain = cd && (cd.join(":") + (cd[3] ? "" : cd[1] === "http:" ? 80 : 443)) !== (bX.join(":") + (bX[3] ? "" : bX[1] === "http:" ? 80 : 443)) | |
| } | |
| if (b8.data && b8.processData && typeof b8.data !== "string") { | |
| b8.data = bG.param(b8.data, b8.traditional) | |
| } | |
| q(v, b8, b1, ce); | |
| if (b3 === 2) { | |
| return ce | |
| } | |
| b0 = b8.global; | |
| b8.type = b8.type.toUpperCase(); | |
| b8.hasContent = !r.test(b8.type); | |
| if (b0 && bG.active++ === 0) { | |
| bG.event.trigger("ajaxStart") | |
| } | |
| if (!b8.hasContent) { | |
| if (b8.data) { | |
| b8.url += (bN.test(b8.url) ? "&" : "?") + b8.data; | |
| delete b8.data | |
| } | |
| b7 = b8.url; | |
| if (b8.cache === false) { | |
| var bZ = bG.now(), | |
| ck = b8.url.replace(P, "$1_=" + bZ); | |
| b8.url = ck + ((ck === b8.url) ? (bN.test(b8.url) ? "&" : "?") + "_=" + bZ : "") | |
| } | |
| } | |
| if (b8.data && b8.hasContent && b8.contentType !== false || b1.contentType) { | |
| ce.setRequestHeader("Content-Type", b8.contentType) | |
| } | |
| if (b8.ifModified) { | |
| b7 = b7 || b8.url; | |
| if (bG.lastModified[b7]) { | |
| ce.setRequestHeader("If-Modified-Since", bG.lastModified[b7]) | |
| } | |
| if (bG.etag[b7]) { | |
| ce.setRequestHeader("If-None-Match", bG.etag[b7]) | |
| } | |
| } | |
| ce.setRequestHeader("Accept", b8.dataTypes[0] && b8.accepts[b8.dataTypes[0]] ? b8.accepts[b8.dataTypes[0]] + (b8.dataTypes[0] !== "*" ? ", " + aX + "; q=0.01" : "") : b8.accepts["*"]); | |
| for (cf in b8.headers) { | |
| ce.setRequestHeader(cf, b8.headers[cf]) | |
| } | |
| if (b8.beforeSend && (b8.beforeSend.call(cn, ce, b8) === false || b3 === 2)) { | |
| return ce.abort() | |
| } | |
| b6 = "abort"; | |
| for (cf in { | |
| success: 1, | |
| error: 1, | |
| complete: 1 | |
| }) { | |
| ce[cf](b8[cf]) | |
| } | |
| cg = q(a6, b8, b1, ce); | |
| if (!cg) { | |
| ca(-1, "No Transport") | |
| } else { | |
| ce.readyState = 1; | |
| if (b0) { | |
| cb.trigger("ajaxSend", [ce, b8]) | |
| } | |
| if (b8.async && b8.timeout > 0) { | |
| b9 = setTimeout(function() { | |
| ce.abort("timeout") | |
| }, b8.timeout) | |
| } | |
| try { | |
| b3 = 1; | |
| cg.send(cc, ca) | |
| } catch (ch) { | |
| if (b3 < 2) { | |
| ca(-1, ch) | |
| } else { | |
| throw ch | |
| } | |
| } | |
| } | |
| return ce | |
| }, | |
| active: 0, | |
| lastModified: {}, | |
| etag: {} | |
| }); | |
| function h(b7, b6, b3) { | |
| var b2, b4, b1, e, bZ = b7.contents, | |
| b5 = b7.dataTypes, | |
| b0 = b7.responseFields; | |
| for (b4 in b0) { | |
| if (b4 in b3) { | |
| b6[b0[b4]] = b3[b4] | |
| } | |
| } | |
| while (b5[0] === "*") { | |
| b5.shift(); | |
| if (b2 === aB) { | |
| b2 = b7.mimeType || b6.getResponseHeader("content-type") | |
| } | |
| } | |
| if (b2) { | |
| for (b4 in bZ) { | |
| if (bZ[b4] && bZ[b4].test(b2)) { | |
| b5.unshift(b4); | |
| break | |
| } | |
| } | |
| } | |
| if (b5[0] in b3) { | |
| b1 = b5[0] | |
| } else { | |
| for (b4 in b3) { | |
| if (!b5[0] || b7.converters[b4 + " " + b5[0]]) { | |
| b1 = b4; | |
| break | |
| } | |
| if (!e) { | |
| e = b4 | |
| } | |
| } | |
| b1 = b1 || e | |
| } | |
| if (b1) { | |
| if (b1 !== b5[0]) { | |
| b5.unshift(b1) | |
| } | |
| return b3[b1] | |
| } | |
| } | |
| function ae(b9, b1) { | |
| var b7, bZ, b5, b3, b6 = b9.dataTypes.slice(), | |
| b0 = b6[0], | |
| b8 = {}, | |
| b2 = 0; | |
| if (b9.dataFilter) { | |
| b1 = b9.dataFilter(b1, b9.dataType) | |
| } | |
| if (b6[1]) { | |
| for (b7 in b9.converters) { | |
| b8[b7.toLowerCase()] = b9.converters[b7] | |
| } | |
| } | |
| for (; | |
| (b5 = b6[++b2]);) { | |
| if (b5 !== "*") { | |
| if (b0 !== "*" && b0 !== b5) { | |
| b7 = b8[b0 + " " + b5] || b8["* " + b5]; | |
| if (!b7) { | |
| for (bZ in b8) { | |
| b3 = bZ.split(" "); | |
| if (b3[1] === b5) { | |
| b7 = b8[b0 + " " + b3[0]] || b8["* " + b3[0]]; | |
| if (b7) { | |
| if (b7 === true) { | |
| b7 = b8[bZ] | |
| } else { | |
| if (b8[bZ] !== true) { | |
| b5 = b3[0]; | |
| b6.splice(b2--, 0, b5) | |
| } | |
| } | |
| break | |
| } | |
| } | |
| } | |
| } | |
| if (b7 !== true) { | |
| if (b7 && b9["throws"]) { | |
| b1 = b7(b1) | |
| } else { | |
| try { | |
| b1 = b7(b1) | |
| } catch (b4) { | |
| return { | |
| state: "parsererror", | |
| error: b7 ? b4 : "No conversion from " + b0 + " to " + b5 | |
| } | |
| } | |
| } | |
| } | |
| } | |
| b0 = b5 | |
| } | |
| } | |
| return { | |
| state: "success", | |
| data: b1 | |
| } | |
| } | |
| var bp = [], | |
| aw = /\?/, | |
| a5 = /(=)\?(?=&|$)|\?\?/, | |
| bl = bG.now(); | |
| bG.ajaxSetup({ | |
| jsonp: "callback", | |
| jsonpCallback: function() { | |
| var e = bp.pop() || (bG.expando + "_" + (bl++)); | |
| this[e] = true; | |
| return e | |
| } | |
| }); | |
| bG.ajaxPrefilter("json jsonp", function(b8, b3, b7) { | |
| var b6, e, b5, b1 = b8.data, | |
| bZ = b8.url, | |
| b0 = b8.jsonp !== false, | |
| b4 = b0 && a5.test(bZ), | |
| b2 = b0 && !b4 && typeof b1 === "string" && !(b8.contentType || "").indexOf("application/x-www-form-urlencoded") && a5.test(b1); | |
| if (b8.dataTypes[0] === "jsonp" || b4 || b2) { | |
| b6 = b8.jsonpCallback = bG.isFunction(b8.jsonpCallback) ? b8.jsonpCallback() : b8.jsonpCallback; | |
| e = a2[b6]; | |
| if (b4) { | |
| b8.url = bZ.replace(a5, "$1" + b6) | |
| } else { | |
| if (b2) { | |
| b8.data = b1.replace(a5, "$1" + b6) | |
| } else { | |
| if (b0) { | |
| b8.url += (aw.test(bZ) ? "&" : "?") + b8.jsonp + "=" + b6 | |
| } | |
| } | |
| } | |
| b8.converters["script json"] = function() { | |
| if (!b5) { | |
| bG.error(b6 + " was not called") | |
| } | |
| return b5[0] | |
| }; | |
| b8.dataTypes[0] = "json"; | |
| a2[b6] = function() { | |
| b5 = arguments | |
| }; | |
| b7.always(function() { | |
| a2[b6] = e; | |
| if (b8[b6]) { | |
| b8.jsonpCallback = b3.jsonpCallback; | |
| bp.push(b6) | |
| } | |
| if (b5 && bG.isFunction(e)) { | |
| e(b5[0]) | |
| } | |
| b5 = e = aB | |
| }); | |
| return "script" | |
| } | |
| }); | |
| bG.ajaxSetup({ | |
| accepts: { | |
| script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript" | |
| }, | |
| contents: { | |
| script: /javascript|ecmascript/ | |
| }, | |
| converters: { | |
| "text script": function(e) { | |
| bG.globalEval(e); | |
| return e | |
| } | |
| } | |
| }); | |
| bG.ajaxPrefilter("script", function(e) { | |
| if (e.cache === aB) { | |
| e.cache = false | |
| } | |
| if (e.crossDomain) { | |
| e.type = "GET"; | |
| e.global = false | |
| } | |
| }); | |
| bG.ajaxTransport("script", function(b0) { | |
| if (b0.crossDomain) { | |
| var e, bZ = o.head || o.getElementsByTagName("head")[0] || o.documentElement; | |
| return { | |
| send: function(b1, b2) { | |
| e = o.createElement("script"); | |
| e.async = "async"; | |
| if (b0.scriptCharset) { | |
| e.charset = b0.scriptCharset | |
| } | |
| e.src = b0.url; | |
| e.onload = e.onreadystatechange = function(b4, b3) { | |
| if (b3 || !e.readyState || /loaded|complete/.test(e.readyState)) { | |
| e.onload = e.onreadystatechange = null; | |
| if (bZ && e.parentNode) { | |
| bZ.removeChild(e) | |
| } | |
| e = aB; | |
| if (!b3) { | |
| b2(200, "success") | |
| } | |
| } | |
| }; | |
| bZ.insertBefore(e, bZ.firstChild) | |
| }, | |
| abort: function() { | |
| if (e) { | |
| e.onload(0, 1) | |
| } | |
| } | |
| } | |
| } | |
| }); | |
| var ah, aN = a2.ActiveXObject ? | |
| function() { | |
| for (var e in ah) { | |
| ah[e](0, 1) | |
| } | |
| } : false, au = 0; | |
| function bB() { | |
| try { | |
| return new a2.XMLHttpRequest() | |
| } catch (bZ) {} | |
| } | |
| function bb() { | |
| try { | |
| return new a2.ActiveXObject("Microsoft.XMLHTTP") | |
| } catch (bZ) {} | |
| } | |
| bG.ajaxSettings.xhr = a2.ActiveXObject ? | |
| function() { | |
| return !this.isLocal && bB() || bb() | |
| } : bB; | |
| (function(e) { | |
| bG.extend(bG.support, { | |
| ajax: !! e, | |
| cors: !! e && ("withCredentials" in e) | |
| }) | |
| })(bG.ajaxSettings.xhr()); | |
| if (bG.support.ajax) { | |
| bG.ajaxTransport(function(e) { | |
| if (!e.crossDomain || bG.support.cors) { | |
| var bZ; | |
| return { | |
| send: function(b5, b0) { | |
| var b3, b2, b4 = e.xhr(); | |
| if (e.username) { | |
| b4.open(e.type, e.url, e.async, e.username, e.password) | |
| } else { | |
| b4.open(e.type, e.url, e.async) | |
| } | |
| if (e.xhrFields) { | |
| for (b2 in e.xhrFields) { | |
| b4[b2] = e.xhrFields[b2] | |
| } | |
| } | |
| if (e.mimeType && b4.overrideMimeType) { | |
| b4.overrideMimeType(e.mimeType) | |
| } | |
| if (!e.crossDomain && !b5["X-Requested-With"]) { | |
| b5["X-Requested-With"] = "XMLHttpRequest" | |
| } | |
| try { | |
| for (b2 in b5) { | |
| b4.setRequestHeader(b2, b5[b2]) | |
| } | |
| } catch (b1) {} | |
| b4.send((e.hasContent && e.data) || null); | |
| bZ = function(ce, b8) { | |
| var b9, b7, b6, cc, cb; | |
| try { | |
| if (bZ && (b8 || b4.readyState === 4)) { | |
| bZ = aB; | |
| if (b3) { | |
| b4.onreadystatechange = bG.noop; | |
| if (aN) { | |
| delete ah[b3] | |
| } | |
| } | |
| if (b8) { | |
| if (b4.readyState !== 4) { | |
| b4.abort() | |
| } | |
| } else { | |
| b9 = b4.status; | |
| b6 = b4.getAllResponseHeaders(); | |
| cc = {}; | |
| cb = b4.responseXML; | |
| if (cb && cb.documentElement) { | |
| cc.xml = cb | |
| } | |
| try { | |
| cc.text = b4.responseText | |
| } catch (ce) {} | |
| try { | |
| b7 = b4.statusText | |
| } catch (cd) { | |
| b7 = "" | |
| } | |
| if (!b9 && e.isLocal && !e.crossDomain) { | |
| b9 = cc.text ? 200 : 404 | |
| } else { | |
| if (b9 === 1223) { | |
| b9 = 204 | |
| } | |
| } | |
| } | |
| } | |
| } catch (ca) { | |
| if (!b8) { | |
| b0(-1, ca) | |
| } | |
| } | |
| if (cc) { | |
| b0(b9, b7, cc, b6) | |
| } | |
| }; | |
| if (!e.async) { | |
| bZ() | |
| } else { | |
| if (b4.readyState === 4) { | |
| setTimeout(bZ, 0) | |
| } else { | |
| b3 = ++au; | |
| if (aN) { | |
| if (!ah) { | |
| ah = {}; | |
| bG(a2).unload(aN) | |
| } | |
| ah[b3] = bZ | |
| } | |
| b4.onreadystatechange = bZ | |
| } | |
| } | |
| }, | |
| abort: function() { | |
| if (bZ) { | |
| bZ(0, 1) | |
| } | |
| } | |
| } | |
| } | |
| }) | |
| } | |
| var L, ab, bO = /^(?:toggle|show|hide)$/, | |
| bH = new RegExp("^(?:([-+])=|)(" + bx + ")([a-z%]*)$", "i"), | |
| bM = /queueHooks$/, | |
| ax = [i], | |
| a1 = { | |
| "*": [function(e, b5) { | |
| var b1, b6, b7 = this.createTween(e, b5), | |
| b2 = bH.exec(b5), | |
| b3 = b7.cur(), | |
| bZ = +b3 || 0, | |
| b0 = 1, | |
| b4 = 20; | |
| if (b2) { | |
| b1 = +b2[2]; | |
| b6 = b2[3] || (bG.cssNumber[e] ? "" : "px"); | |
| if (b6 !== "px" && bZ) { | |
| bZ = bG.css(b7.elem, e, true) || b1 || 1; | |
| do { | |
| b0 = b0 || ".5"; | |
| bZ = bZ / b0; | |
| bG.style(b7.elem, e, bZ + b6) | |
| } while (b0 !== (b0 = b7.cur() / b3) && b0 !== 1 && --b4) | |
| } | |
| b7.unit = b6; | |
| b7.start = bZ; | |
| b7.end = b2[1] ? bZ + (b2[1] + 1) * b1 : b1 | |
| } | |
| return b7 | |
| }] | |
| }; | |
| function bj() { | |
| setTimeout(function() { | |
| L = aB | |
| }, 0); | |
| return (L = bG.now()) | |
| } | |
| function bc(bZ, e) { | |
| bG.each(e, function(b4, b2) { | |
| var b3 = (a1[b4] || []).concat(a1["*"]), | |
| b0 = 0, | |
| b1 = b3.length; | |
| for (; b0 < b1; b0++) { | |
| if (b3[b0].call(bZ, b4, b2)) { | |
| return | |
| } | |
| } | |
| }) | |
| } | |
| function f(b0, b4, b7) { | |
| var b8, b3 = 0, | |
| e = 0, | |
| bZ = ax.length, | |
| b6 = bG.Deferred().always(function() { | |
| delete b2.elem | |
| }), | |
| b2 = function() { | |
| var cd = L || bj(), | |
| ca = Math.max(0, b1.startTime + b1.duration - cd), | |
| cc = 1 - (ca / b1.duration || 0), | |
| b9 = 0, | |
| cb = b1.tweens.length; | |
| for (; b9 < cb; b9++) { | |
| b1.tweens[b9].run(cc) | |
| } | |
| b6.notifyWith(b0, [b1, cc, ca]); | |
| if (cc < 1 && cb) { | |
| return ca | |
| } else { | |
| b6.resolveWith(b0, [b1]); | |
| return false | |
| } | |
| }, | |
| b1 = b6.promise({ | |
| elem: b0, | |
| props: bG.extend({}, b4), | |
| opts: bG.extend(true, { | |
| specialEasing: {} | |
| }, b7), | |
| originalProperties: b4, | |
| originalOptions: b7, | |
| startTime: L || bj(), | |
| duration: b7.duration, | |
| tweens: [], | |
| createTween: function(cc, b9, cb) { | |
| var ca = bG.Tween(b0, b1.opts, cc, b9, b1.opts.specialEasing[cc] || b1.opts.easing); | |
| b1.tweens.push(ca); | |
| return ca | |
| }, | |
| stop: function(ca) { | |
| var b9 = 0, | |
| cb = ca ? b1.tweens.length : 0; | |
| for (; b9 < cb; b9++) { | |
| b1.tweens[b9].run(1) | |
| } | |
| if (ca) { | |
| b6.resolveWith(b0, [b1, ca]) | |
| } else { | |
| b6.rejectWith(b0, [b1, ca]) | |
| } | |
| return this | |
| } | |
| }), | |
| b5 = b1.props; | |
| ak(b5, b1.opts.specialEasing); | |
| for (; b3 < bZ; b3++) { | |
| b8 = ax[b3].call(b1, b0, b5, b1.opts); | |
| if (b8) { | |
| return b8 | |
| } | |
| } | |
| bc(b1, b5); | |
| if (bG.isFunction(b1.opts.start)) { | |
| b1.opts.start.call(b0, b1) | |
| } | |
| bG.fx.timer(bG.extend(b2, { | |
| anim: b1, | |
| queue: b1.opts.queue, | |
| elem: b0 | |
| })); | |
| return b1.progress(b1.opts.progress).done(b1.opts.done, b1.opts.complete).fail(b1.opts.fail).always(b1.opts.always) | |
| } | |
| function ak(b1, b3) { | |
| var b0, bZ, b4, b2, e; | |
| for (b0 in b1) { | |
| bZ = bG.camelCase(b0); | |
| b4 = b3[bZ]; | |
| b2 = b1[b0]; | |
| if (bG.isArray(b2)) { | |
| b4 = b2[1]; | |
| b2 = b1[b0] = b2[0] | |
| } | |
| if (b0 !== bZ) { | |
| b1[bZ] = b2; | |
| delete b1[b0] | |
| } | |
| e = bG.cssHooks[bZ]; | |
| if (e && "expand" in e) { | |
| b2 = e.expand(b2); | |
| delete b1[bZ]; | |
| for (b0 in b2) { | |
| if (!(b0 in b1)) { | |
| b1[b0] = b2[b0]; | |
| b3[b0] = b4 | |
| } | |
| } | |
| } else { | |
| b3[bZ] = b4 | |
| } | |
| } | |
| } | |
| bG.Animation = bG.extend(f, { | |
| tweener: function(bZ, b2) { | |
| if (bG.isFunction(bZ)) { | |
| b2 = bZ; | |
| bZ = ["*"] | |
| } else { | |
| bZ = bZ.split(" ") | |
| } | |
| var b1, e = 0, | |
| b0 = bZ.length; | |
| for (; e < b0; e++) { | |
| b1 = bZ[e]; | |
| a1[b1] = a1[b1] || []; | |
| a1[b1].unshift(b2) | |
| } | |
| }, | |
| prefilter: function(bZ, e) { | |
| if (e) { | |
| ax.unshift(bZ) | |
| } else { | |
| ax.push(bZ) | |
| } | |
| } | |
| }); | |
| function i(b2, b7, e) { | |
| var b6, b0, b9, b1, cd, cc, cb, ca, b3 = this, | |
| bZ = b2.style, | |
| b8 = {}, | |
| b5 = [], | |
| b4 = b2.nodeType && Q(b2); | |
| if (!e.queue) { | |
| cb = bG._queueHooks(b2, "fx"); | |
| if (cb.unqueued == null) { | |
| cb.unqueued = 0; | |
| ca = cb.empty.fire; | |
| cb.empty.fire = function() { | |
| if (!cb.unqueued) { | |
| ca() | |
| } | |
| } | |
| } | |
| cb.unqueued++; | |
| b3.always(function() { | |
| b3.always(function() { | |
| cb.unqueued--; | |
| if (!bG.queue(b2, "fx").length) { | |
| cb.empty.fire() | |
| } | |
| }) | |
| }) | |
| } | |
| if (b2.nodeType === 1 && ("height" in b7 || "width" in b7)) { | |
| e.overflow = [bZ.overflow, bZ.overflowX, bZ.overflowY]; | |
| if (bG.css(b2, "display") === "inline" && bG.css(b2, "float") === "none") { | |
| if (!bG.support.inlineBlockNeedsLayout || bC(b2.nodeName) === "inline") { | |
| bZ.display = "inline-block" | |
| } else { | |
| bZ.zoom = 1 | |
| } | |
| } | |
| } | |
| if (e.overflow) { | |
| bZ.overflow = "hidden"; | |
| if (!bG.support.shrinkWrapBlocks) { | |
| b3.done(function() { | |
| bZ.overflow = e.overflow[0]; | |
| bZ.overflowX = e.overflow[1]; | |
| bZ.overflowY = e.overflow[2] | |
| }) | |
| } | |
| } | |
| for (b6 in b7) { | |
| b9 = b7[b6]; | |
| if (bO.exec(b9)) { | |
| delete b7[b6]; | |
| if (b9 === (b4 ? "hide" : "show")) { | |
| continue | |
| } | |
| b5.push(b6) | |
| } | |
| } | |
| b1 = b5.length; | |
| if (b1) { | |
| cd = bG._data(b2, "fxshow") || bG._data(b2, "fxshow", {}); | |
| if (b4) { | |
| bG(b2).show() | |
| } else { | |
| b3.done(function() { | |
| bG(b2).hide() | |
| }) | |
| } | |
| b3.done(function() { | |
| var ce; | |
| bG.removeData(b2, "fxshow", true); | |
| for (ce in b8) { | |
| bG.style(b2, ce, b8[ce]) | |
| } | |
| }); | |
| for (b6 = 0; b6 < b1; b6++) { | |
| b0 = b5[b6]; | |
| cc = b3.createTween(b0, b4 ? cd[b0] : 0); | |
| b8[b0] = cd[b0] || bG.style(b2, b0); | |
| if (!(b0 in cd)) { | |
| cd[b0] = cc.start; | |
| if (b4) { | |
| cc.end = cc.start; | |
| cc.start = b0 === "width" || b0 === "height" ? 1 : 0 | |
| } | |
| } | |
| } | |
| } | |
| } | |
| function H(b0, bZ, b2, e, b1) { | |
| return new H.prototype.init(b0, bZ, b2, e, b1) | |
| } | |
| bG.Tween = H; | |
| H.prototype = { | |
| constructor: H, | |
| init: function(b1, bZ, b3, e, b2, b0) { | |
| this.elem = b1; | |
| this.prop = b3; | |
| this.easing = b2 || "swing"; | |
| this.options = bZ; | |
| this.start = this.now = this.cur(); | |
| this.end = e; | |
| this.unit = b0 || (bG.cssNumber[b3] ? "" : "px") | |
| }, | |
| cur: function() { | |
| var e = H.propHooks[this.prop]; | |
| return e && e.get ? e.get(this) : H.propHooks._default.get(this) | |
| }, | |
| run: function(b0) { | |
| var bZ, e = H.propHooks[this.prop]; | |
| if (this.options.duration) { | |
| this.pos = bZ = bG.easing[this.easing](b0, this.options.duration * b0, 0, 1, this.options.duration) | |
| } else { | |
| this.pos = bZ = b0 | |
| } | |
| this.now = (this.end - this.start) * bZ + this.start; | |
| if (this.options.step) { | |
| this.options.step.call(this.elem, this.now, this) | |
| } | |
| if (e && e.set) { | |
| e.set(this) | |
| } else { | |
| H.propHooks._default.set(this) | |
| } | |
| return this | |
| } | |
| }; | |
| H.prototype.init.prototype = H.prototype; | |
| H.propHooks = { | |
| _default: { | |
| get: function(bZ) { | |
| var e; | |
| if (bZ.elem[bZ.prop] != null && (!bZ.elem.style || bZ.elem.style[bZ.prop] == null)) { | |
| return bZ.elem[bZ.prop] | |
| } | |
| e = bG.css(bZ.elem, bZ.prop, false, ""); | |
| return !e || e === "auto" ? 0 : e | |
| }, | |
| set: function(e) { | |
| if (bG.fx.step[e.prop]) { | |
| bG.fx.step[e.prop](e) | |
| } else { | |
| if (e.elem.style && (e.elem.style[bG.cssProps[e.prop]] != null || bG.cssHooks[e.prop])) { | |
| bG.style(e.elem, e.prop, e.now + e.unit) | |
| } else { | |
| e.elem[e.prop] = e.now | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| H.propHooks.scrollTop = H.propHooks.scrollLeft = { | |
| set: function(e) { | |
| if (e.elem.nodeType && e.elem.parentNode) { | |
| e.elem[e.prop] = e.now | |
| } | |
| } | |
| }; | |
| bG.each(["toggle", "show", "hide"], function(bZ, e) { | |
| var b0 = bG.fn[e]; | |
| bG.fn[e] = function(b1, b3, b2) { | |
| return b1 == null || typeof b1 === "boolean" || (!bZ && bG.isFunction(b1) && bG.isFunction(b3)) ? b0.apply(this, arguments) : this.animate(bF(e, true), b1, b3, b2) | |
| } | |
| }); | |
| bG.fn.extend({ | |
| fadeTo: function(e, b1, b0, bZ) { | |
| return this.filter(Q).css("opacity", 0).show().end().animate({ | |
| opacity: b1 | |
| }, e, b0, bZ) | |
| }, | |
| animate: function(b4, b1, b3, b2) { | |
| var b0 = bG.isEmptyObject(b4), | |
| e = bG.speed(b1, b3, b2), | |
| bZ = function() { | |
| var b5 = f(this, bG.extend({}, b4), e); | |
| if (b0) { | |
| b5.stop(true) | |
| } | |
| }; | |
| return b0 || e.queue === false ? this.each(bZ) : this.queue(e.queue, bZ) | |
| }, | |
| stop: function(b0, bZ, e) { | |
| var b1 = function(b2) { | |
| var b3 = b2.stop; | |
| delete b2.stop; | |
| b3(e) | |
| }; | |
| if (typeof b0 !== "string") { | |
| e = bZ; | |
| bZ = b0; | |
| b0 = aB | |
| } | |
| if (bZ && b0 !== false) { | |
| this.queue(b0 || "fx", []) | |
| } | |
| return this.each(function() { | |
| var b5 = true, | |
| b2 = b0 != null && b0 + "queueHooks", | |
| b4 = bG.timers, | |
| b3 = bG._data(this); | |
| if (b2) { | |
| if (b3[b2] && b3[b2].stop) { | |
| b1(b3[b2]) | |
| } | |
| } else { | |
| for (b2 in b3) { | |
| if (b3[b2] && b3[b2].stop && bM.test(b2)) { | |
| b1(b3[b2]) | |
| } | |
| } | |
| } | |
| for (b2 = b4.length; b2--;) { | |
| if (b4[b2].elem === this && (b0 == null || b4[b2].queue === b0)) { | |
| b4[b2].anim.stop(e); | |
| b5 = false; | |
| b4.splice(b2, 1) | |
| } | |
| } | |
| if (b5 || !e) { | |
| bG.dequeue(this, b0) | |
| } | |
| }) | |
| } | |
| }); | |
| function bF(b0, b2) { | |
| var b1, e = { | |
| height: b0 | |
| }, | |
| bZ = 0; | |
| b2 = b2 ? 1 : 0; | |
| for (; bZ < 4; bZ += 2 - b2) { | |
| b1 = bQ[bZ]; | |
| e["margin" + b1] = e["padding" + b1] = b0 | |
| } | |
| if (b2) { | |
| e.opacity = e.width = b0 | |
| } | |
| return e | |
| } | |
| bG.each({ | |
| slideDown: bF("show"), | |
| slideUp: bF("hide"), | |
| slideToggle: bF("toggle"), | |
| fadeIn: { | |
| opacity: "show" | |
| }, | |
| fadeOut: { | |
| opacity: "hide" | |
| }, | |
| fadeToggle: { | |
| opacity: "toggle" | |
| } | |
| }, function(e, bZ) { | |
| bG.fn[e] = function(b0, b2, b1) { | |
| return this.animate(bZ, b0, b2, b1) | |
| } | |
| }); | |
| bG.speed = function(b0, b1, bZ) { | |
| var e = b0 && typeof b0 === "object" ? bG.extend({}, b0) : { | |
| complete: bZ || !bZ && b1 || bG.isFunction(b0) && b0, | |
| duration: b0, | |
| easing: bZ && b1 || b1 && !bG.isFunction(b1) && b1 | |
| }; | |
| e.duration = bG.fx.off ? 0 : typeof e.duration === "number" ? e.duration : e.duration in bG.fx.speeds ? bG.fx.speeds[e.duration] : bG.fx.speeds._default; | |
| if (e.queue == null || e.queue === true) { | |
| e.queue = "fx" | |
| } | |
| e.old = e.complete; | |
| e.complete = function() { | |
| if (bG.isFunction(e.old)) { | |
| e.old.call(this) | |
| } | |
| if (e.queue) { | |
| bG.dequeue(this, e.queue) | |
| } | |
| }; | |
| return e | |
| }; | |
| bG.easing = { | |
| linear: function(e) { | |
| return e | |
| }, | |
| swing: function(e) { | |
| return 0.5 - Math.cos(e * Math.PI) / 2 | |
| } | |
| }; | |
| bG.timers = []; | |
| bG.fx = H.prototype.init; | |
| bG.fx.tick = function() { | |
| var b0, bZ = bG.timers, | |
| e = 0; | |
| for (; e < bZ.length; e++) { | |
| b0 = bZ[e]; | |
| if (!b0() && bZ[e] === b0) { | |
| bZ.splice(e--, 1) | |
| } | |
| } | |
| if (!bZ.length) { | |
| bG.fx.stop() | |
| } | |
| }; | |
| bG.fx.timer = function(e) { | |
| if (e() && bG.timers.push(e) && !ab) { | |
| ab = setInterval(bG.fx.tick, bG.fx.interval) | |
| } | |
| }; | |
| bG.fx.interval = 13; | |
| bG.fx.stop = function() { | |
| clearInterval(ab); | |
| ab = null | |
| }; | |
| bG.fx.speeds = { | |
| slow: 600, | |
| fast: 200, | |
| _default: 400 | |
| }; | |
| bG.fx.step = {}; | |
| if (bG.expr && bG.expr.filters) { | |
| bG.expr.filters.animated = function(e) { | |
| return bG.grep(bG.timers, function(bZ) { | |
| return e === bZ.elem | |
| }).length | |
| } | |
| } | |
| var bm = /^(?:body|html)$/i; | |
| bG.fn.offset = function(b8) { | |
| if (arguments.length) { | |
| return b8 === aB ? this : this.each(function(b9) { | |
| bG.offset.setOffset(this, b8, b9) | |
| }) | |
| } | |
| var bZ, b4, b5, b2, b6, e, b1, b3 = { | |
| top: 0, | |
| left: 0 | |
| }, | |
| b0 = this[0], | |
| b7 = b0 && b0.ownerDocument; | |
| if (!b7) { | |
| return | |
| } | |
| if ((b4 = b7.body) === b0) { | |
| return bG.offset.bodyOffset(b0) | |
| } | |
| bZ = b7.documentElement; | |
| if (!bG.contains(bZ, b0)) { | |
| return b3 | |
| } | |
| if (typeof b0.getBoundingClientRect !== "undefined") { | |
| b3 = b0.getBoundingClientRect() | |
| } | |
| b5 = bn(b7); | |
| b2 = bZ.clientTop || b4.clientTop || 0; | |
| b6 = bZ.clientLeft || b4.clientLeft || 0; | |
| e = b5.pageYOffset || bZ.scrollTop; | |
| b1 = b5.pageXOffset || bZ.scrollLeft; | |
| return { | |
| top: b3.top + e - b2, | |
| left: b3.left + b1 - b6 | |
| } | |
| }; | |
| bG.offset = { | |
| bodyOffset: function(e) { | |
| var b0 = e.offsetTop, | |
| bZ = e.offsetLeft; | |
| if (bG.support.doesNotIncludeMarginInBodyOffset) { | |
| b0 += parseFloat(bG.css(e, "marginTop")) || 0; | |
| bZ += parseFloat(bG.css(e, "marginLeft")) || 0 | |
| } | |
| return { | |
| top: b0, | |
| left: bZ | |
| } | |
| }, | |
| setOffset: function(b1, ca, b4) { | |
| var b5 = bG.css(b1, "position"); | |
| var b3 = bG(b1), | |
| bZ = b3.offset(), | |
| e = bG.css(b1, "top"), | |
| b8 = bG.css(b1, "left"), | |
| b9 = (b5 === "absolute" || b5 === "fixed") && bG.inArray("auto", [e, b8]) > -1, | |
| b7 = {}, | |
| b6 = {}, | |
| b0, b2; | |
| if (b9) { | |
| b6 = b3.position(); | |
| b0 = b6.top; | |
| b2 = b6.left | |
| } else { | |
| b0 = parseFloat(e) || 0; | |
| b2 = parseFloat(b8) || 0 | |
| } | |
| if (bG.isFunction(ca)) { | |
| ca = ca.call(b1, b4, bZ) | |
| } | |
| if (ca.top != null) { | |
| b7.top = (ca.top - bZ.top) + b0 | |
| } | |
| if (ca.left != null) { | |
| b7.left = (ca.left - bZ.left) + b2 | |
| } | |
| if ("using" in ca) { | |
| ca.using.call(b1, b7) | |
| } else { | |
| b3.css(b7) | |
| } | |
| } | |
| }; | |
| bG.fn.extend({ | |
| position: function() { | |
| if (!this[0]) { | |
| return | |
| } | |
| var b0 = this[0], | |
| bZ = this.offsetParent(), | |
| b1 = this.offset(), | |
| e = bm.test(bZ[0].nodeName) ? { | |
| top: 0, | |
| left: 0 | |
| } : bZ.offset(); | |
| b1.top -= parseFloat(bG.css(b0, "marginTop")) || 0; | |
| b1.left -= parseFloat(bG.css(b0, "marginLeft")) || 0; | |
| e.top += parseFloat(bG.css(bZ[0], "borderTopWidth")) || 0; | |
| e.left += parseFloat(bG.css(bZ[0], "borderLeftWidth")) || 0; | |
| return { | |
| top: b1.top - e.top, | |
| left: b1.left - e.left | |
| } | |
| }, | |
| offsetParent: function() { | |
| return this.map(function() { | |
| var e = this.offsetParent || o.body; | |
| while (e && (!bm.test(e.nodeName) && bG.css(e, "position") === "static")) { | |
| e = e.offsetParent | |
| } | |
| return e || o.body | |
| }) | |
| } | |
| }); | |
| bG.each({ | |
| scrollLeft: "pageXOffset", | |
| scrollTop: "pageYOffset" | |
| }, function(b0, bZ) { | |
| var e = /Y/.test(bZ); | |
| bG.fn[b0] = function(b1) { | |
| return bG.access(this, function(b2, b5, b4) { | |
| var b3 = bn(b2); | |
| if (b4 === aB) { | |
| return b3 ? (bZ in b3) ? b3[bZ] : b3.document.documentElement[b5] : b2[b5] | |
| } | |
| if (b3) { | |
| b3.scrollTo(!e ? b4 : bG(b3).scrollLeft(), e ? b4 : bG(b3).scrollTop()) | |
| } else { | |
| b2[b5] = b4 | |
| } | |
| }, b0, b1, arguments.length, null) | |
| } | |
| }); | |
| function bn(e) { | |
| return bG.isWindow(e) ? e : e.nodeType === 9 ? e.defaultView || e.parentWindow : false | |
| } | |
| bG.each({ | |
| Height: "height", | |
| Width: "width" | |
| }, function(e, bZ) { | |
| bG.each({ | |
| padding: "inner" + e, | |
| content: bZ, | |
| "": "outer" + e | |
| }, function(b0, b1) { | |
| bG.fn[b1] = function(b5, b4) { | |
| var b3 = arguments.length && (b0 || typeof b5 !== "boolean"), | |
| b2 = b0 || (b5 === true || b4 === true ? "margin" : "border"); | |
| return bG.access(this, function(b7, b6, b8) { | |
| var b9; | |
| if (bG.isWindow(b7)) { | |
| return b7.document.documentElement["client" + e] | |
| } | |
| if (b7.nodeType === 9) { | |
| b9 = b7.documentElement; | |
| return Math.max(b7.body["scroll" + e], b9["scroll" + e], b7.body["offset" + e], b9["offset" + e], b9["client" + e]) | |
| } | |
| return b8 === aB ? bG.css(b7, b6, b8, b2) : bG.style(b7, b6, b8, b2) | |
| }, bZ, b3 ? b5 : aB, b3, null) | |
| } | |
| }) | |
| }); | |
| a2.jQuery = a2.$ = bG; | |
| if (typeof define === "function" && define.amd && define.amd.jQuery) { | |
| define("jquery", [], function() { | |
| return bG | |
| }) | |
| } | |
| })(window); | |
| /* | |
| * jQuery UI Core 1.9.2 | |
| * http://jqueryui.com | |
| * | |
| * Copyright 2012 jQuery Foundation and other contributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| * http://api.jqueryui.com/category/ui-core/ | |
| */ | |
| (function(b, f) { | |
| var a = 0, | |
| e = /^ui-id-\d+$/; | |
| b.ui = b.ui || {}; | |
| if (b.ui.version) { | |
| return | |
| } | |
| b.extend(b.ui, { | |
| version: "1.9.2", | |
| keyCode: { | |
| BACKSPACE: 8, | |
| COMMA: 188, | |
| DELETE: 46, | |
| DOWN: 40, | |
| END: 35, | |
| ENTER: 13, | |
| ESCAPE: 27, | |
| HOME: 36, | |
| LEFT: 37, | |
| NUMPAD_ADD: 107, | |
| NUMPAD_DECIMAL: 110, | |
| NUMPAD_DIVIDE: 111, | |
| NUMPAD_ENTER: 108, | |
| NUMPAD_MULTIPLY: 106, | |
| NUMPAD_SUBTRACT: 109, | |
| PAGE_DOWN: 34, | |
| PAGE_UP: 33, | |
| PERIOD: 190, | |
| RIGHT: 39, | |
| SPACE: 32, | |
| TAB: 9, | |
| UP: 38 | |
| } | |
| }); | |
| b.fn.extend({ | |
| _focus: b.fn.focus, | |
| focus: function(g, h) { | |
| return typeof g === "number" ? this.each(function() { | |
| var i = this; | |
| setTimeout(function() { | |
| b(i).focus(); | |
| if (h) { | |
| h.call(i) | |
| } | |
| }, g) | |
| }) : this._focus.apply(this, arguments) | |
| }, | |
| scrollParent: function() { | |
| var g; | |
| if ((b.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) { | |
| g = this.parents().filter(function() { | |
| return (/(relative|absolute|fixed)/).test(b.css(this, "position")) && (/(auto|scroll)/).test(b.css(this, "overflow") + b.css(this, "overflow-y") + b.css(this, "overflow-x")) | |
| }).eq(0) | |
| } else { | |
| g = this.parents().filter(function() { | |
| return (/(auto|scroll)/).test(b.css(this, "overflow") + b.css(this, "overflow-y") + b.css(this, "overflow-x")) | |
| }).eq(0) | |
| } | |
| return (/fixed/).test(this.css("position")) || !g.length ? b(document) : g | |
| }, | |
| zIndex: function(j) { | |
| if (j !== f) { | |
| return this.css("zIndex", j) | |
| } | |
| if (this.length) { | |
| var h = b(this[0]), | |
| g, i; | |
| while (h.length && h[0] !== document) { | |
| g = h.css("position"); | |
| if (g === "absolute" || g === "relative" || g === "fixed") { | |
| i = parseInt(h.css("zIndex"), 10); | |
| if (!isNaN(i) && i !== 0) { | |
| return i | |
| } | |
| } | |
| h = h.parent() | |
| } | |
| } | |
| return 0 | |
| }, | |
| uniqueId: function() { | |
| return this.each(function() { | |
| if (!this.id) { | |
| this.id = "ui-id-" + (++a) | |
| } | |
| }) | |
| }, | |
| removeUniqueId: function() { | |
| return this.each(function() { | |
| if (e.test(this.id)) { | |
| b(this).removeAttr("id") | |
| } | |
| }) | |
| } | |
| }); | |
| function d(i, g) { | |
| var k, j, h, l = i.nodeName.toLowerCase(); | |
| if ("area" === l) { | |
| k = i.parentNode; | |
| j = k.name; | |
| if (!i.href || !j || k.nodeName.toLowerCase() !== "map") { | |
| return false | |
| } | |
| h = b("img[usemap=#" + j + "]")[0]; | |
| return !!h && c(h) | |
| } | |
| return (/input|select|textarea|button|object/.test(l) ? !i.disabled : "a" === l ? i.href || g : g) && c(i) | |
| } | |
| function c(g) { | |
| return b.expr.filters.visible(g) && !b(g).parents().andSelf().filter(function() { | |
| return b.css(this, "visibility") === "hidden" | |
| }).length | |
| } | |
| b.extend(b.expr[":"], { | |
| data: b.expr.createPseudo ? b.expr.createPseudo(function(g) { | |
| return function(h) { | |
| return !!b.data(h, g) | |
| } | |
| }) : function(j, h, g) { | |
| return !!b.data(j, g[3]) | |
| }, | |
| focusable: function(g) { | |
| return d(g, !isNaN(b.attr(g, "tabindex"))) | |
| }, | |
| tabbable: function(i) { | |
| var g = b.attr(i, "tabindex"), | |
| h = isNaN(g); | |
| return (h || g >= 0) && d(i, !h) | |
| } | |
| }); | |
| b(function() { | |
| var g = document.body, | |
| h = g.appendChild(h = document.createElement("div")); | |
| h.offsetHeight; | |
| b.extend(h.style, { | |
| minHeight: "100px", | |
| height: "auto", | |
| padding: 0, | |
| borderWidth: 0 | |
| }); | |
| b.support.minHeight = h.offsetHeight === 100; | |
| b.support.selectstart = "onselectstart" in h; | |
| g.removeChild(h).style.display = "none" | |
| }); | |
| if (!b("<a>").outerWidth(1).jquery) { | |
| b.each(["Width", "Height"], function(j, g) { | |
| var h = g === "Width" ? ["Left", "Right"] : ["Top", "Bottom"], | |
| k = g.toLowerCase(), | |
| m = { | |
| innerWidth: b.fn.innerWidth, | |
| innerHeight: b.fn.innerHeight, | |
| outerWidth: b.fn.outerWidth, | |
| outerHeight: b.fn.outerHeight | |
| }; | |
| function l(o, n, i, p) { | |
| b.each(h, function() { | |
| n -= parseFloat(b.css(o, "padding" + this)) || 0; | |
| if (i) { | |
| n -= parseFloat(b.css(o, "border" + this + "Width")) || 0 | |
| } | |
| if (p) { | |
| n -= parseFloat(b.css(o, "margin" + this)) || 0 | |
| } | |
| }); | |
| return n | |
| } | |
| b.fn["inner" + g] = function(i) { | |
| if (i === f) { | |
| return m["inner" + g].call(this) | |
| } | |
| return this.each(function() { | |
| b(this).css(k, l(this, i) + "px") | |
| }) | |
| }; | |
| b.fn["outer" + g] = function(i, n) { | |
| if (typeof i !== "number") { | |
| return m["outer" + g].call(this, i) | |
| } | |
| return this.each(function() { | |
| b(this).css(k, l(this, i, true, n) + "px") | |
| }) | |
| } | |
| }) | |
| } | |
| if (b("<a>").data("a-b", "a").removeData("a-b").data("a-b")) { | |
| b.fn.removeData = (function(g) { | |
| return function(h) { | |
| if (arguments.length) { | |
| return g.call(this, b.camelCase(h)) | |
| } else { | |
| return g.call(this) | |
| } | |
| } | |
| })(b.fn.removeData) | |
| }(function() { | |
| var g = /msie ([\w.]+)/.exec(navigator.userAgent.toLowerCase()) || []; | |
| b.ui.ie = g.length ? true : false; | |
| b.ui.ie6 = parseFloat(g[1], 10) === 6 | |
| })(); | |
| b.fn.extend({ | |
| disableSelection: function() { | |
| return this.bind((b.support.selectstart ? "selectstart" : "mousedown") + ".ui-disableSelection", function(g) { | |
| g.preventDefault() | |
| }) | |
| }, | |
| enableSelection: function() { | |
| return this.unbind(".ui-disableSelection") | |
| } | |
| }); | |
| b.extend(b.ui, { | |
| plugin: { | |
| add: function(h, j, l) { | |
| var g, k = b.ui[h].prototype; | |
| for (g in l) { | |
| k.plugins[g] = k.plugins[g] || []; | |
| k.plugins[g].push([j, l[g]]) | |
| } | |
| }, | |
| call: function(g, j, h) { | |
| var k, l = g.plugins[j]; | |
| if (!l || !g.element[0].parentNode || g.element[0].parentNode.nodeType === 11) { | |
| return | |
| } | |
| for (k = 0; k < l.length; k++) { | |
| if (g.options[l[k][0]]) { | |
| l[k][1].apply(g.element, h) | |
| } | |
| } | |
| } | |
| }, | |
| contains: b.contains, | |
| hasScroll: function(j, h) { | |
| if (b(j).css("overflow") === "hidden") { | |
| return false | |
| } | |
| var g = (h && h === "left") ? "scrollLeft" : "scrollTop", | |
| i = false; | |
| if (j[g] > 0) { | |
| return true | |
| } | |
| j[g] = 1; | |
| i = (j[g] > 0); | |
| j[g] = 0; | |
| return i | |
| }, | |
| isOverAxis: function(h, g, i) { | |
| return (h > g) && (h < (g + i)) | |
| }, | |
| isOver: function(l, h, k, j, g, i) { | |
| return b.ui.isOverAxis(l, k, g) && b.ui.isOverAxis(h, j, i) | |
| } | |
| }) | |
| })(jQuery); | |
| /* | |
| * jQuery UI Widget 1.9.2 | |
| * http://jqueryui.com | |
| * | |
| * Copyright 2012 jQuery Foundation and other contributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| * http://api.jqueryui.com/jQuery.widget/ | |
| */ | |
| (function(b, e) { | |
| var a = 0, | |
| d = Array.prototype.slice, | |
| c = b.cleanData; | |
| b.cleanData = function(f) { | |
| for (var g = 0, h; | |
| (h = f[g]) != null; g++) { | |
| try { | |
| b(h).triggerHandler("remove") | |
| } catch (j) {} | |
| } | |
| c(f) | |
| }; | |
| b.widget = function(g, j, f) { | |
| var m, l, i, k, h = g.split(".")[0]; | |
| g = g.split(".")[1]; | |
| m = h + "-" + g; | |
| if (!f) { | |
| f = j; | |
| j = b.Widget | |
| } | |
| b.expr[":"][m.toLowerCase()] = function(n) { | |
| return !!b.data(n, m) | |
| }; | |
| b[h] = b[h] || {}; | |
| l = b[h][g]; | |
| i = b[h][g] = function(n, o) { | |
| if (!this._createWidget) { | |
| return new i(n, o) | |
| } | |
| if (arguments.length) { | |
| this._createWidget(n, o) | |
| } | |
| }; | |
| b.extend(i, l, { | |
| version: f.version, | |
| _proto: b.extend({}, f), | |
| _childConstructors: [] | |
| }); | |
| k = new j(); | |
| k.options = b.widget.extend({}, k.options); | |
| b.each(f, function(o, n) { | |
| if (b.isFunction(n)) { | |
| f[o] = (function() { | |
| var p = function() { | |
| return j.prototype[o].apply(this, arguments) | |
| }, | |
| q = function(r) { | |
| return j.prototype[o].apply(this, r) | |
| }; | |
| return function() { | |
| var t = this._super, | |
| r = this._superApply, | |
| s; | |
| this._super = p; | |
| this._superApply = q; | |
| s = n.apply(this, arguments); | |
| this._super = t; | |
| this._superApply = r; | |
| return s | |
| } | |
| })() | |
| } | |
| }); | |
| i.prototype = b.widget.extend(k, { | |
| widgetEventPrefix: l ? k.widgetEventPrefix : g | |
| }, f, { | |
| constructor: i, | |
| namespace: h, | |
| widgetName: g, | |
| widgetBaseClass: m, | |
| widgetFullName: m | |
| }); | |
| if (l) { | |
| b.each(l._childConstructors, function(o, p) { | |
| var n = p.prototype; | |
| b.widget(n.namespace + "." + n.widgetName, i, p._proto) | |
| }); | |
| delete l._childConstructors | |
| } else { | |
| j._childConstructors.push(i) | |
| } | |
| b.widget.bridge(g, i) | |
| }; | |
| b.widget.extend = function(k) { | |
| var g = d.call(arguments, 1), | |
| j = 0, | |
| f = g.length, | |
| h, i; | |
| for (; j < f; j++) { | |
| for (h in g[j]) { | |
| i = g[j][h]; | |
| if (g[j].hasOwnProperty(h) && i !== e) { | |
| if (b.isPlainObject(i)) { | |
| k[h] = b.isPlainObject(k[h]) ? b.widget.extend({}, k[h], i) : b.widget.extend({}, i) | |
| } else { | |
| k[h] = i | |
| } | |
| } | |
| } | |
| } | |
| return k | |
| }; | |
| b.widget.bridge = function(g, f) { | |
| var h = f.prototype.widgetFullName || g; | |
| b.fn[g] = function(k) { | |
| var i = typeof k === "string", | |
| j = d.call(arguments, 1), | |
| l = this; | |
| k = !i && j.length ? b.widget.extend.apply(null, [k].concat(j)) : k; | |
| if (i) { | |
| this.each(function() { | |
| var n, m = b.data(this, h); | |
| if (!m) { | |
| return b.error("cannot call methods on " + g + " prior to initialization; attempted to call method '" + k + "'") | |
| } | |
| if (!b.isFunction(m[k]) || k.charAt(0) === "_") { | |
| return b.error("no such method '" + k + "' for " + g + " widget instance") | |
| } | |
| n = m[k].apply(m, j); | |
| if (n !== m && n !== e) { | |
| l = n && n.jquery ? l.pushStack(n.get()) : n; | |
| return false | |
| } | |
| }) | |
| } else { | |
| this.each(function() { | |
| var m = b.data(this, h); | |
| if (m) { | |
| m.option(k || {})._init() | |
| } else { | |
| b.data(this, h, new f(k, this)) | |
| } | |
| }) | |
| } | |
| return l | |
| } | |
| }; | |
| b.Widget = function() {}; | |
| b.Widget._childConstructors = []; | |
| b.Widget.prototype = { | |
| widgetName: "widget", | |
| widgetEventPrefix: "", | |
| defaultElement: "<div>", | |
| options: { | |
| disabled: false, | |
| create: null | |
| }, | |
| _createWidget: function(f, g) { | |
| g = b(g || this.defaultElement || this)[0]; | |
| this.element = b(g); | |
| this.uuid = a++; | |
| this.eventNamespace = "." + this.widgetName + this.uuid; | |
| this.options = b.widget.extend({}, this.options, this._getCreateOptions(), f); | |
| this.bindings = b(); | |
| this.hoverable = b(); | |
| this.focusable = b(); | |
| if (g !== this) { | |
| b.data(g, this.widgetName, this); | |
| b.data(g, this.widgetFullName, this); | |
| this._on(true, this.element, { | |
| remove: function(h) { | |
| if (h.target === g) { | |
| this.destroy() | |
| } | |
| } | |
| }); | |
| this.document = b(g.style ? g.ownerDocument : g.document || g); | |
| this.window = b(this.document[0].defaultView || this.document[0].parentWindow) | |
| } | |
| this._create(); | |
| this._trigger("create", null, this._getCreateEventData()); | |
| this._init() | |
| }, | |
| _getCreateOptions: b.noop, | |
| _getCreateEventData: b.noop, | |
| _create: b.noop, | |
| _init: b.noop, | |
| destroy: function() { | |
| this._destroy(); | |
| this.element.unbind(this.eventNamespace).removeData(this.widgetName).removeData(this.widgetFullName).removeData(b.camelCase(this.widgetFullName)); | |
| this.widget().unbind(this.eventNamespace).removeAttr("aria-disabled").removeClass(this.widgetFullName + "-disabled ui-state-disabled"); | |
| this.bindings.unbind(this.eventNamespace); | |
| this.hoverable.removeClass("ui-state-hover"); | |
| this.focusable.removeClass("ui-state-focus") | |
| }, | |
| _destroy: b.noop, | |
| widget: function() { | |
| return this.element | |
| }, | |
| option: function(j, k) { | |
| var f = j, | |
| l, h, g; | |
| if (arguments.length === 0) { | |
| return b.widget.extend({}, this.options) | |
| } | |
| if (typeof j === "string") { | |
| f = {}; | |
| l = j.split("."); | |
| j = l.shift(); | |
| if (l.length) { | |
| h = f[j] = b.widget.extend({}, this.options[j]); | |
| for (g = 0; g < l.length - 1; g++) { | |
| h[l[g]] = h[l[g]] || {}; | |
| h = h[l[g]] | |
| } | |
| j = l.pop(); | |
| if (k === e) { | |
| return h[j] === e ? null : h[j] | |
| } | |
| h[j] = k | |
| } else { | |
| if (k === e) { | |
| return this.options[j] === e ? null : this.options[j] | |
| } | |
| f[j] = k | |
| } | |
| } | |
| this._setOptions(f); | |
| return this | |
| }, | |
| _setOptions: function(f) { | |
| var g; | |
| for (g in f) { | |
| this._setOption(g, f[g]) | |
| } | |
| return this | |
| }, | |
| _setOption: function(f, g) { | |
| this.options[f] = g; | |
| if (f === "disabled") { | |
| this.widget().toggleClass(this.widgetFullName + "-disabled ui-state-disabled", !! g).attr("aria-disabled", g); | |
| this.hoverable.removeClass("ui-state-hover"); | |
| this.focusable.removeClass("ui-state-focus") | |
| } | |
| return this | |
| }, | |
| enable: function() { | |
| return this._setOption("disabled", false) | |
| }, | |
| disable: function() { | |
| return this._setOption("disabled", true) | |
| }, | |
| _on: function(i, h, g) { | |
| var j, f = this; | |
| if (typeof i !== "boolean") { | |
| g = h; | |
| h = i; | |
| i = false | |
| } | |
| if (!g) { | |
| g = h; | |
| h = this.element; | |
| j = this.widget() | |
| } else { | |
| h = j = b(h); | |
| this.bindings = this.bindings.add(h) | |
| } | |
| b.each(g, function(p, o) { | |
| function m() { | |
| if (!i && (f.options.disabled === true || b(this).hasClass("ui-state-disabled"))) { | |
| return | |
| } | |
| return (typeof o === "string" ? f[o] : o).apply(f, arguments) | |
| } | |
| if (typeof o !== "string") { | |
| m.guid = o.guid = o.guid || m.guid || b.guid++ | |
| } | |
| var n = p.match(/^(\w+)\s*(.*)$/), | |
| l = n[1] + f.eventNamespace, | |
| k = n[2]; | |
| if (k) { | |
| j.delegate(k, l, m) | |
| } else { | |
| h.bind(l, m) | |
| } | |
| }) | |
| }, | |
| _off: function(g, f) { | |
| f = (f || "").split(" ").join(this.eventNamespace + " ") + this.eventNamespace; | |
| g.unbind(f).undelegate(f) | |
| }, | |
| _delay: function(i, h) { | |
| function g() { | |
| return (typeof i === "string" ? f[i] : i).apply(f, arguments) | |
| } | |
| var f = this; | |
| return setTimeout(g, h || 0) | |
| }, | |
| _hoverable: function(f) { | |
| this.hoverable = this.hoverable.add(f); | |
| this._on(f, { | |
| mouseenter: function(g) { | |
| b(g.currentTarget).addClass("ui-state-hover") | |
| }, | |
| mouseleave: function(g) { | |
| b(g.currentTarget).removeClass("ui-state-hover") | |
| } | |
| }) | |
| }, | |
| _focusable: function(f) { | |
| this.focusable = this.focusable.add(f); | |
| this._on(f, { | |
| focusin: function(g) { | |
| b(g.currentTarget).addClass("ui-state-focus") | |
| }, | |
| focusout: function(g) { | |
| b(g.currentTarget).removeClass("ui-state-focus") | |
| } | |
| }) | |
| }, | |
| _trigger: function(f, g, h) { | |
| var k, j, i = this.options[f]; | |
| h = h || {}; | |
| g = b.Event(g); | |
| g.type = (f === this.widgetEventPrefix ? f : this.widgetEventPrefix + f).toLowerCase(); | |
| g.target = this.element[0]; | |
| j = g.originalEvent; | |
| if (j) { | |
| for (k in j) { | |
| if (!(k in g)) { | |
| g[k] = j[k] | |
| } | |
| } | |
| } | |
| this.element.trigger(g, h); | |
| return !(b.isFunction(i) && i.apply(this.element[0], [g].concat(h)) === false || g.isDefaultPrevented()) | |
| } | |
| }; | |
| b.each({ | |
| show: "fadeIn", | |
| hide: "fadeOut" | |
| }, function(g, f) { | |
| b.Widget.prototype["_" + g] = function(j, i, l) { | |
| if (typeof i === "string") { | |
| i = { | |
| effect: i | |
| } | |
| } | |
| var k, h = !i ? g : i === true || typeof i === "number" ? f : i.effect || f; | |
| i = i || {}; | |
| if (typeof i === "number") { | |
| i = { | |
| duration: i | |
| } | |
| } | |
| k = !b.isEmptyObject(i); | |
| i.complete = l; | |
| if (i.delay) { | |
| j.delay(i.delay) | |
| } | |
| if (k && b.effects && (b.effects.effect[h] || b.uiBackCompat !== false && b.effects[h])) { | |
| j[g](i) | |
| } else { | |
| if (h !== g && j[h]) { | |
| j[h](i.duration, i.easing, l) | |
| } else { | |
| j.queue(function(m) { | |
| b(this)[g](); | |
| if (l) { | |
| l.call(j[0]) | |
| } | |
| m() | |
| }) | |
| } | |
| } | |
| } | |
| }); | |
| if (b.uiBackCompat !== false) { | |
| b.Widget.prototype._getCreateOptions = function() { | |
| return b.metadata && b.metadata.get(this.element[0])[this.widgetName] | |
| } | |
| } | |
| })(jQuery); | |
| /* | |
| * jQuery UI Position 1.9.2 | |
| * http://jqueryui.com | |
| * | |
| * Copyright 2012 jQuery Foundation and other contributors | |
| * Released under the MIT license. | |
| * http://jquery.org/license | |
| * | |
| * http://api.jqueryui.com/position/ | |
| */ | |
| (function(e, c) { | |
| e.ui = e.ui || {}; | |
| var i, j = Math.max, | |
| n = Math.abs, | |
| l = Math.round, | |
| d = /left|center|right/, | |
| g = /top|center|bottom/, | |
| a = /[\+\-]\d+%?/, | |
| k = /^\w+/, | |
| b = /%$/, | |
| f = e.fn.position; | |
| function m(q, p, o) { | |
| return [parseInt(q[0], 10) * (b.test(q[0]) ? p / 100 : 1), parseInt(q[1], 10) * (b.test(q[1]) ? o / 100 : 1)] | |
| } | |
| function h(o, p) { | |
| return parseInt(e.css(o, p), 10) || 0 | |
| } | |
| e.position = { | |
| scrollbarWidth: function() { | |
| if (i !== c) { | |
| return i | |
| } | |
| var p, o, r = e("<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"), | |
| q = r.children()[0]; | |
| e("body").append(r); | |
| p = q.offsetWidth; | |
| r.css("overflow", "scroll"); | |
| o = q.offsetWidth; | |
| if (p === o) { | |
| o = r[0].clientWidth | |
| } | |
| r.remove(); | |
| return (i = p - o) | |
| }, | |
| getScrollInfo: function(s) { | |
| var r = s.isWindow ? "" : s.element.css("overflow-x"), | |
| q = s.isWindow ? "" : s.element.css("overflow-y"), | |
| p = r === "scroll" || (r === "auto" && s.width < s.element[0].scrollWidth), | |
| o = q === "scroll" || (q === "auto" && s.height < s.element[0].scrollHeight); | |
| return { | |
| width: p ? e.position.scrollbarWidth() : 0, | |
| height: o ? e.position.scrollbarWidth() : 0 | |
| } | |
| }, | |
| getWithinInfo: function(p) { | |
| var q = e(p || window), | |
| o = e.isWindow(q[0]); | |
| return { | |
| element: q, | |
| isWindow: o, | |
| offset: q.offset() || { | |
| left: 0, | |
| top: 0 | |
| }, | |
| scrollLeft: q.scrollLeft(), | |
| scrollTop: q.scrollTop(), | |
| width: o ? q.width() : q.outerWidth(), | |
| height: o ? q.height() : q.outerHeight() | |
| } | |
| } | |
| }; | |
| e.fn.position = function(y) { | |
| if (!y || !y.of) { | |
| return f.apply(this, arguments) | |
| } | |
| y = e.extend({}, y); | |
| var z, v, s, x, r, u = e(y.of), | |
| q = e.position.getWithinInfo(y.within), | |
| o = e.position.getScrollInfo(q), | |
| t = u[0], | |
| w = (y.collision || "flip").split(" "), | |
| p = {}; | |
| if (t.nodeType === 9) { | |
| v = u.width(); | |
| s = u.height(); | |
| x = { | |
| top: 0, | |
| left: 0 | |
| } | |
| } else { | |
| if (e.isWindow(t)) { | |
| v = u.width(); | |
| s = u.height(); | |
| x = { | |
| top: u.scrollTop(), | |
| left: u.scrollLeft() | |
| } | |
| } else { | |
| if (t.preventDefault) { | |
| y.at = "left top"; | |
| v = s = 0; | |
| x = { | |
| top: t.pageY, | |
| left: t.pageX | |
| } | |
| } else { | |
| v = u.outerWidth(); | |
| s = u.outerHeight(); | |
| x = u.offset() | |
| } | |
| } | |
| } | |
| r = e.extend({}, x); | |
| e.each(["my", "at"], function() { | |
| var C = (y[this] || "").split(" "), | |
| B, A; | |
| if (C.length === 1) { | |
| C = d.test(C[0]) ? C.concat(["center"]) : g.test(C[0]) ? ["center"].concat(C) : ["center", "center"] | |
| } | |
| C[0] = d.test(C[0]) ? C[0] : "center"; | |
| C[1] = g.test(C[1]) ? C[1] : "center"; | |
| B = a.exec(C[0]); | |
| A = a.exec(C[1]); | |
| p[this] = [B ? B[0] : 0, A ? A[0] : 0]; | |
| y[this] = [k.exec(C[0])[0], k.exec(C[1])[0]] | |
| }); | |
| if (w.length === 1) { | |
| w[1] = w[0] | |
| } | |
| if (y.at[0] === "right") { | |
| r.left += v | |
| } else { | |
| if (y.at[0] === "center") { | |
| r.left += v / 2 | |
| } | |
| } | |
| if (y.at[1] === "bottom") { | |
| r.top += s | |
| } else { | |
| if (y.at[1] === "center") { | |
| r.top += s / 2 | |
| } | |
| } | |
| z = m(p.at, v, s); | |
| r.left += z[0]; | |
| r.top += z[1]; | |
| return this.each(function() { | |
| var B, K, D = e(this), | |
| F = D.outerWidth(), | |
| C = D.outerHeight(), | |
| E = h(this, "marginLeft"), | |
| A = h(this, "marginTop"), | |
| J = F + E + h(this, "marginRight") + o.width, | |
| I = C + A + h(this, "marginBottom") + o.height, | |
| G = e.extend({}, r), | |
| H = m(p.my, D.outerWidth(), D.outerHeight()); | |
| if (y.my[0] === "right") { | |
| G.left -= F | |
| } else { | |
| if (y.my[0] === "center") { | |
| G.left -= F / 2 | |
| } | |
| } | |
| if (y.my[1] === "bottom") { | |
| G.top -= C | |
| } else { | |
| if (y.my[1] === "center") { | |
| G.top -= C / 2 | |
| } | |
| } | |
| G.left += H[0]; | |
| G.top += H[1]; | |
| if (!e.support.offsetFractions) { | |
| G.left = l(G.left); | |
| G.top = l(G.top) | |
| } | |
| B = { | |
| marginLeft: E, | |
| marginTop: A | |
| }; | |
| e.each(["left", "top"], function(M, L) { | |
| if (e.ui.position[w[M]]) { | |
| e.ui.position[w[M]][L](G, { | |
| targetWidth: v, | |
| targetHeight: s, | |
| elemWidth: F, | |
| elemHeight: C, | |
| collisionPosition: B, | |
| collisionWidth: J, | |
| collisionHeight: I, | |
| offset: [z[0] + H[0], z[1] + H[1]], | |
| my: y.my, | |
| at: y.at, | |
| within: q, | |
| elem: D | |
| }) | |
| } | |
| }); | |
| if (e.fn.bgiframe) { | |
| D.bgiframe() | |
| } | |
| if (y.using) { | |
| K = function(O) { | |
| var Q = x.left - G.left, | |
| N = Q + v - F, | |
| P = x.top - G.top, | |
| M = P + s - C, | |
| L = { | |
| target: { | |
| element: u, | |
| left: x.left, | |
| top: x.top, | |
| width: v, | |
| height: s | |
| }, | |
| element: { | |
| element: D, | |
| left: G.left, | |
| top: G.top, | |
| width: F, | |
| height: C | |
| }, | |
| horizontal: N < 0 ? "left" : Q > 0 ? "right" : "center", | |
| vertical: M < 0 ? "top" : P > 0 ? "bottom" : "middle" | |
| }; | |
| if (v < F && n(Q + N) < v) { | |
| L.horizontal = "center" | |
| } | |
| if (s < C && n(P + M) < s) { | |
| L.vertical = "middle" | |
| } | |
| if (j(n(Q), n(N)) > j(n(P), n(M))) { | |
| L.important = "horizontal" | |
| } else { | |
| L.important = "vertical" | |
| } | |
| y.using.call(this, O, L) | |
| } | |
| } | |
| D.offset(e.extend(G, { | |
| using: K | |
| })) | |
| }) | |
| }; | |
| e.ui.position = { | |
| fit: { | |
| left: function(s, r) { | |
| var q = r.within, | |
| u = q.isWindow ? q.scrollLeft : q.offset.left, | |
| w = q.width, | |
| t = s.left - r.collisionPosition.marginLeft, | |
| v = u - t, | |
| p = t + r.collisionWidth - w - u, | |
| o; | |
| if (r.collisionWidth > w) { | |
| if (v > 0 && p <= 0) { | |
| o = s.left + v + r.collisionWidth - w - u; | |
| s.left += v - o | |
| } else { | |
| if (p > 0 && v <= 0) { | |
| s.left = u | |
| } else { | |
| if (v > p) { | |
| s.left = u + w - r.collisionWidth | |
| } else { | |
| s.left = u | |
| } | |
| } | |
| } | |
| } else { | |
| if (v > 0) { | |
| s.left += v | |
| } else { | |
| if (p > 0) { | |
| s.left -= p | |
| } else { | |
| s.left = j(s.left - t, s.left) | |
| } | |
| } | |
| } | |
| }, | |
| top: function(r, q) { | |
| var p = q.within, | |
| v = p.isWindow ? p.scrollTop : p.offset.top, | |
| w = q.within.height, | |
| t = r.top - q.collisionPosition.marginTop, | |
| u = v - t, | |
| s = t + q.collisionHeight - w - v, | |
| o; | |
| if (q.collisionHeight > w) { | |
| if (u > 0 && s <= 0) { | |
| o = r.top + u + q.collisionHeight - w - v; | |
| r.top += u - o | |
| } else { | |
| if (s > 0 && u <= 0) { | |
| r.top = v | |
| } else { | |
| if (u > s) { | |
| r.top = v + w - q.collisionHeight | |
| } else { | |
| r.top = v | |
| } | |
| } | |
| } | |
| } else { | |
| if (u > 0) { | |
| r.top += u | |
| } else { | |
| if (s > 0) { | |
| r.top -= s | |
| } else { | |
| r.top = j(r.top - t, r.top) | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| flip: { | |
| left: function(u, t) { | |
| var s = t.within, | |
| y = s.offset.left + s.scrollLeft, | |
| B = s.width, | |
| q = s.isWindow ? s.scrollLeft : s.offset.left, | |
| v = u.left - t.collisionPosition.marginLeft, | |
| z = v - q, | |
| p = v + t.collisionWidth - B - q, | |
| x = t.my[0] === "left" ? -t.elemWidth : t.my[0] === "right" ? t.elemWidth : 0, | |
| A = t.at[0] === "left" ? t.targetWidth : t.at[0] === "right" ? -t.targetWidth : 0, | |
| r = -2 * t.offset[0], | |
| o, w; | |
| if (z < 0) { | |
| o = u.left + x + A + r + t.collisionWidth - B - y; | |
| if (o < 0 || o < n(z)) { | |
| u.left += x + A + r | |
| } | |
| } else { | |
| if (p > 0) { | |
| w = u.left - t.collisionPosition.marginLeft + x + A + r - q; | |
| if (w > 0 || n(w) < p) { | |
| u.left += x + A + r | |
| } | |
| } | |
| } | |
| }, | |
| top: function(t, s) { | |
| var r = s.within, | |
| A = r.offset.top + r.scrollTop, | |
| B = r.height, | |
| o = r.isWindow ? r.scrollTop : r.offset.top, | |
| v = t.top - s.collisionPosition.marginTop, | |
| x = v - o, | |
| u = v + s.collisionHeight - B - o, | |
| y = s.my[1] === "top", | |
| w = y ? -s.elemHeight : s.my[1] === "bottom" ? s.elemHeight : 0, | |
| C = s.at[1] === "top" ? s.targetHeight : s.at[1] === "bottom" ? -s.targetHeight : 0, | |
| q = -2 * s.offset[1], | |
| z, p; | |
| if (x < 0) { | |
| p = t.top + w + C + q + s.collisionHeight - B - A; | |
| if ((t.top + w + C + q) > x && (p < 0 || p < n(x))) { | |
| t.top += w + C + q | |
| } | |
| } else { | |
| if (u > 0) { | |
| z = t.top - s.collisionPosition.marginTop + w + C + q - o; | |
| if ((t.top + w + C + q) > u && (z > 0 || n(z) < u)) { | |
| t.top += w + C + q | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| flipfit: { | |
| left: function() { | |
| e.ui.position.flip.left.apply(this, arguments); | |
| e.ui.position.fit.left.apply(this, arguments) | |
| }, | |
| top: function() { | |
| e.ui.position.flip.top.apply(this, arguments); | |
| e.ui.position.fit.top.apply(this, arguments) | |
| } | |
| } | |
| }; | |
| (function() { | |
| var s, u, p, r, q, o = document.getElementsByTagName("body")[0], | |
| t = document.createElement("div"); | |
| s = document.createElement(o ? "div" : "body"); | |
| p = { | |
| visibility: "hidden", | |
| width: 0, | |
| height: 0, | |
| border: 0, | |
| margin: 0, | |
| background: "none" | |
| }; | |
| if (o) { | |
| e.extend(p, { | |
| position: "absolute", | |
| left: "-1000px", | |
| top: "-1000px" | |
| }) | |
| } | |
| for (q in p) { | |
| s.style[q] = p[q] | |
| } | |
| s.appendChild(t); | |
| u = o || document.documentElement; | |
| u.insertBefore(s, u.firstChild); | |
| t.style.cssText = "position: absolute; left: 10.7432222px;"; | |
| r = e(t).offset().left; | |
| e.support.offsetFractions = r > 10 && r < 11; | |
| s.innerHTML = ""; | |
| u.removeChild(s) | |
| })(); | |
| if (e.uiBackCompat !== false) { | |
| (function(p) { | |
| var o = p.fn.position; | |
| p.fn.position = function(r) { | |
| if (!r || !r.offset) { | |
| return o.call(this, r) | |
| } | |
| var s = r.offset.split(" "), | |
| q = r.at.split(" "); | |
| if (s.length === 1) { | |
| s[1] = s[0] | |
| } | |
| if (/^\d/.test(s[0])) { | |
| s[0] = "+" + s[0] | |
| } | |
| if (/^\d/.test(s[1])) { | |
| s[1] = "+" + s[1] | |
| } | |
| if (q.length === 1) { | |
| if (/left|center|right/.test(q[0])) { | |
| q[1] = "center" | |
| } else { | |
| q[1] = q[0]; | |
| q[0] = "center" | |
| } | |
| } | |
| return o.call(this, p.extend(r, { | |
| at: q[0] + s[0] + " " + q[1] + s[1], | |
| offset: c | |
| })) | |
| } | |
| }(jQuery)) | |
| } | |
| }(jQuery)); | |
| (function(a) { | |
| a.fn.watch = function(c) { | |
| var d = a.extend({ | |
| interval: 200, | |
| id: "_watcher", | |
| style: "", | |
| attr: "", | |
| func: null | |
| }, c); | |
| return this.each(function() { | |
| var h = this; | |
| var f = a(this); | |
| var i = function() { | |
| b.call(h, d.id) | |
| }; | |
| var e = null; | |
| e = setInterval(i, d.interval); | |
| var g = { | |
| id: e, | |
| attrs: d.attr ? d.attr.split(",") : [], | |
| styles: d.style ? d.style.split(",") : [], | |
| func: d.func, | |
| cssVals: {}, | |
| attrVals: {} | |
| }; | |
| a.each(g.attrs, function(j, k) { | |
| g.attrVals[k] = f.attr(k) | |
| }); | |
| a.each(g.styles, function(j, k) { | |
| g.cssVals[k] = f.css(k) | |
| }); | |
| f.data(d.id, g) | |
| }); | |
| function b(j) { | |
| var f = a(this); | |
| var h = f.data(j); | |
| if (!h) { | |
| clearInterval(j); | |
| return | |
| } | |
| var i = false; | |
| var e = {}; | |
| var g = {}; | |
| a.each(h.attrs, function(k, m) { | |
| var l = f.attr(m); | |
| if (l != h.attrVals[m]) { | |
| i = true; | |
| e[m] = h.attrVals[m] = l | |
| } | |
| }); | |
| a.each(h.styles, function(k, m) { | |
| var l = f.css(m); | |
| if (l != h.cssVals[m]) { | |
| i = true; | |
| g[m] = h.cssVals[m] = l | |
| } | |
| }); | |
| if (i && h.func) { | |
| h.func.call(this, e, g) | |
| } | |
| } | |
| }; | |
| a.fn.unwatch = function(b) { | |
| if (!b) { | |
| b = "_watcher" | |
| } | |
| this.each(function() { | |
| var c = a(this).data(b); | |
| var d = a(this); | |
| d.removeData(); | |
| clearInterval(b) | |
| }); | |
| return this | |
| } | |
| })(jQuery); | |
| /* | |
| * Derived from http://batiste.dosimple.ch/blog/posts/2007-09-11-1/rich-text-editor-jquery.html | |
| */ | |
| (function(g) { | |
| var n = ["bold", "italic", "strikethrough", "underline"]; | |
| g.widget("ui.rte", { | |
| options: { | |
| css: "", | |
| cssUrl: "", | |
| stateChangedb: null, | |
| content: "<br/>" | |
| }, | |
| _create: function f() { | |
| var t = this, | |
| u = t.options, | |
| s; | |
| t.element.text(u.content); | |
| if (document.designMode || document.contentEditable) { | |
| t.enableDesignMode(t.element) | |
| } | |
| t._currentState = {}; | |
| for (s = 0; s < n.length; s++) { | |
| t._currentState[n[s]] = false | |
| } | |
| }, | |
| formatText: function m(w, v) { | |
| var t = this, | |
| s = t._iframe.contentWindow; | |
| s.focus(); | |
| try { | |
| s.document.execCommand(w, false, v) | |
| } catch (u) {} | |
| s.focus() | |
| }, | |
| tryEnableDesignMode: function b(w, x) { | |
| var t = this, | |
| v = t._iframe, | |
| s; | |
| try { | |
| s = v.contentWindow.document; | |
| s.open(); | |
| s.write(w); | |
| s.close() | |
| } catch (u) {} | |
| if (document.contentEditable) { | |
| s.designMode = "On"; | |
| x(); | |
| return true | |
| } else { | |
| if (document.designMode) { | |
| try { | |
| s.designMode = "on"; | |
| x(); | |
| return true | |
| } catch (u) {} | |
| } | |
| } | |
| setTimeout(function() { | |
| t.tryEnableDesignMode(w, x) | |
| }, 250); | |
| return false | |
| }, | |
| enableDesignMode: function i() { | |
| var t = this, | |
| s = t.element, | |
| u = t.options, | |
| w = t._iframe = document.createElement("iframe"); | |
| w.frameBorder = 0; | |
| w.frameMargin = 0; | |
| w.framePadding = 0; | |
| if (s.attr("class")) { | |
| w.className = s.attr("class") | |
| } | |
| if (s.attr("id")) { | |
| w.id = s.attr("id") | |
| } | |
| if (s.attr("name")) { | |
| w.title = s.attr("name") | |
| } | |
| s.after(w); | |
| var x = s.text(); | |
| if (!g.trim(x)) { | |
| x = "<br>" | |
| } | |
| var v = ""; | |
| if (u.cssUrl) { | |
| v = "<link type='text/css' rel='stylesheet' href='" + u.cssUrl + "' / >" | |
| } else { | |
| if (u.css) { | |
| v = "<style type='text/css'>" + u.css + "</style>" | |
| } | |
| } | |
| var y = "<html><head>" + v + "</head><body class='frameBody'>" + x + "</body></html>"; | |
| t.tryEnableDesignMode(y, function() { | |
| t._initEvents(); | |
| s.hide() | |
| }) | |
| }, | |
| disableDesignMode: function e(y) { | |
| var u = this, | |
| w = u._iframe, | |
| s, x = u.content(); | |
| if (y) { | |
| s = g('<input type="hidden" />') | |
| } else { | |
| s = g('<textarea cols="40" rows="10"></textarea>') | |
| } | |
| s.text(x); | |
| var v = s[0]; | |
| if (w.className) { | |
| v.className = w.className | |
| } | |
| if (w.id) { | |
| v.id = w.id | |
| } | |
| if (w.title) { | |
| v.name = w.title | |
| } | |
| g(w).before(s); | |
| if (!y) { | |
| g(w).remove() | |
| } | |
| u._iframe = null; | |
| return s | |
| }, | |
| _updateState: function h() { | |
| var t = this, | |
| u = t.options, | |
| s, v, x = false, | |
| w = t._iframe.contentWindow.document; | |
| t.element.text(t.content()); | |
| if (u.stateChanged) { | |
| for (s = 0; s < n.length; s++) { | |
| v = w.queryCommandState(n[s]); | |
| if (v != t._currentState[n[s]]) { | |
| x = true; | |
| t._currentState[n[s]] = v | |
| } | |
| } | |
| if (x) { | |
| u.stateChanged(t._currentState) | |
| } | |
| } | |
| }, | |
| _initEvents: function q() { | |
| var s = this, | |
| t = s._iframe, | |
| u = t.contentWindow.document, | |
| v = g(u); | |
| v.bind("keyup paste drop blur click", function() { | |
| s._updateState(); | |
| return true | |
| }) | |
| }, | |
| bold: function c() { | |
| var s = this; | |
| s.formatText("bold"); | |
| s._updateState() | |
| }, | |
| italic: function r() { | |
| var s = this; | |
| s.formatText("italic"); | |
| s._updateState() | |
| }, | |
| underline: function p() { | |
| var s = this; | |
| s.formatText("underline"); | |
| s._updateState() | |
| }, | |
| strikethrough: function d() { | |
| var s = this; | |
| s.formatText("strikethrough"); | |
| s._updateState() | |
| }, | |
| link: function o(t) { | |
| var s = this; | |
| s.formatText("CreateLink", t); | |
| s._updateState() | |
| }, | |
| image: function j(t) { | |
| var s = this; | |
| s.formatText("InsertImage", t); | |
| s._updateState() | |
| }, | |
| focus: function k() { | |
| var s = this; | |
| if (s._iframe) { | |
| s._iframe.contentWindow.focus() | |
| } else { | |
| s.element.focus() | |
| } | |
| }, | |
| content: function a(u) { | |
| var s = this, | |
| t = s._iframe; | |
| if (u) { | |
| s.element.text(u); | |
| if (t) { | |
| t.contentWindow.document.getElementsByTagName("body")[0].innerHTML = u | |
| } | |
| } else { | |
| if (t) { | |
| u = t.contentWindow.document.getElementsByTagName("body")[0].innerHTML | |
| } else { | |
| u = s.element.text() | |
| } | |
| } | |
| return u | |
| }, | |
| selection: function l() { | |
| var t = this, | |
| v = t._iframe, | |
| u, w, s; | |
| if (v.contentWindow.document.selection) { | |
| u = v.contentWindow.document.selection; | |
| s = u.createRange(); | |
| try { | |
| w = s.parentElement() | |
| } catch (x) { | |
| return false | |
| } | |
| } else { | |
| try { | |
| u = v.contentWindow.getSelection(); | |
| s = u.getRangeAt(0) | |
| } catch (x) { | |
| return false | |
| } | |
| w = s.commonAncestorContainer | |
| } | |
| return w | |
| } | |
| }) | |
| })(jQuery); | |
| (function(i) { | |
| if (i.fn.dotdotdot) { | |
| return | |
| } | |
| i.fn.dotdotdot = function(v) { | |
| if (this.length == 0) { | |
| b(true, 'No element found for "' + this.selector + '".'); | |
| return this | |
| } | |
| if (this.length > 1) { | |
| return this.each(function() { | |
| i(this).dotdotdot(v) | |
| }) | |
| } | |
| var r = this; | |
| if (r.data("dotdotdot")) { | |
| r.trigger("destroy.dot") | |
| } | |
| r.bind_events = function() { | |
| r.bind("update.dot", function(y, A) { | |
| y.preventDefault(); | |
| y.stopPropagation(); | |
| t.maxHeight = (typeof t.height == "number") ? t.height : o(r); | |
| t.maxHeight += t.tolerance; | |
| if (typeof A != "undefined") { | |
| if (typeof A == "string" || A instanceof HTMLElement) { | |
| A = i("<div />").append(A).contents() | |
| } | |
| if (A instanceof i) { | |
| w = A | |
| } | |
| } | |
| s = r.wrapInner('<div class="dotdotdot" />').children(); | |
| s.empty().append(w.clone(true)).css({ | |
| height: "auto", | |
| width: "auto", | |
| border: "none", | |
| padding: 0, | |
| margin: 0 | |
| }); | |
| var z = false, | |
| x = false; | |
| if (q.afterElement) { | |
| z = q.afterElement.clone(true); | |
| q.afterElement.remove() | |
| } | |
| if (k(s, t)) { | |
| if (t.wrap == "children") { | |
| x = d(s, t, z) | |
| } else { | |
| x = m(s, r, s, t, z) | |
| } | |
| } | |
| s.replaceWith(s.contents()); | |
| s = null; | |
| if (i.isFunction(t.callback)) { | |
| t.callback.call(r[0], x, w) | |
| } | |
| q.isTruncated = x; | |
| return x | |
| }).bind("isTruncated.dot", function(y, x) { | |
| y.preventDefault(); | |
| y.stopPropagation(); | |
| if (typeof x == "function") { | |
| x.call(r[0], q.isTruncated) | |
| } | |
| return q.isTruncated | |
| }).bind("originalContent.dot", function(y, x) { | |
| y.preventDefault(); | |
| y.stopPropagation(); | |
| if (typeof x == "function") { | |
| x.call(r[0], w) | |
| } | |
| return w | |
| }).bind("destroy.dot", function(x) { | |
| x.preventDefault(); | |
| x.stopPropagation(); | |
| r.unwatch().unbind_events().empty().append(w).data("dotdotdot", false) | |
| }); | |
| return r | |
| }; | |
| r.unbind_events = function() { | |
| r.unbind(".dot"); | |
| return r | |
| }; | |
| r.watch = function() { | |
| r.unwatch(); | |
| if (t.watch == "window") { | |
| var z = i(window), | |
| y = z.width(), | |
| x = z.height(); | |
| z.bind("resize.dot" + q.dotId, function() { | |
| if (y != z.width() || x != z.height() || !t.windowResizeFix) { | |
| y = z.width(); | |
| x = z.height(); | |
| if (p) { | |
| clearInterval(p) | |
| } | |
| p = setTimeout(function() { | |
| r.trigger("update.dot") | |
| }, 10) | |
| } | |
| }) | |
| } else { | |
| u = j(r); | |
| p = setInterval(function() { | |
| var A = j(r); | |
| if (u.width != A.width || u.height != A.height) { | |
| r.trigger("update.dot"); | |
| u = j(r) | |
| } | |
| }, 100) | |
| } | |
| return r | |
| }; | |
| r.unwatch = function() { | |
| i(window).unbind("resize.dot" + q.dotId); | |
| if (p) { | |
| clearInterval(p) | |
| } | |
| return r | |
| }; | |
| var w = r.contents(), | |
| t = i.extend(true, {}, i.fn.dotdotdot.defaults, v), | |
| q = {}, | |
| u = {}, | |
| p = null, | |
| s = null; | |
| q.afterElement = c(t.after, r); | |
| q.isTruncated = false; | |
| q.dotId = l++; | |
| r.data("dotdotdot", true).bind_events().trigger("update.dot"); | |
| if (t.watch) { | |
| r.watch() | |
| } | |
| return r | |
| }; | |
| i.fn.dotdotdot.defaults = { | |
| ellipsis: "... ", | |
| wrap: "word", | |
| lastCharacter: { | |
| remove: [" ", ",", ";", ".", "!", "?"], | |
| noEllipsis: [] | |
| }, | |
| tolerance: 0, | |
| callback: null, | |
| after: null, | |
| height: null, | |
| watch: false, | |
| windowResizeFix: true, | |
| debug: false | |
| }; | |
| var l = 1; | |
| function d(s, w, v) { | |
| var u = s.children(), | |
| p = false; | |
| s.empty(); | |
| for (var r = 0, q = u.length; r < q; r++) { | |
| var t = u.eq(r); | |
| s.append(t); | |
| if (v) { | |
| s.append(v) | |
| } | |
| if (k(s, w)) { | |
| t.remove(); | |
| p = true; | |
| break | |
| } else { | |
| if (v) { | |
| v.remove() | |
| } | |
| } | |
| } | |
| return p | |
| } | |
| function m(s, r, A, t, q) { | |
| var w = s.contents(), | |
| x = false; | |
| s.empty(); | |
| var z = "table, thead, tbody, tfoot, tr, col, colgroup, object, embed, param, ol, ul, dl, select, optgroup, option, textarea, script, style"; | |
| for (var y = 0, u = w.length; y < u; y++) { | |
| if (x) { | |
| break | |
| } | |
| var v = w[y], | |
| p = i(v); | |
| if (typeof v == "undefined") { | |
| continue | |
| } | |
| s.append(p); | |
| if (q) { | |
| s[(s.is(z)) ? "after" : "append"](q) | |
| } | |
| if (v.nodeType == 3) { | |
| if (k(A, t)) { | |
| x = e(p, r, A, t, q) | |
| } | |
| } else { | |
| x = m(p, r, A, t, q) | |
| } | |
| if (!x) { | |
| if (q) { | |
| q.remove() | |
| } | |
| } | |
| } | |
| return x | |
| } | |
| function e(q, r, p, w, s) { | |
| var D = false, | |
| A = q[0]; | |
| if (typeof A == "undefined") { | |
| return false | |
| } | |
| var E = (w.wrap == "letter") ? "" : " ", | |
| t = h(A).split(E), | |
| F = -1, | |
| v = -1, | |
| G = 0, | |
| y = t.length - 1; | |
| while (G <= y) { | |
| var x = Math.floor((G + y) / 2); | |
| if (x == v) { | |
| break | |
| } | |
| v = x; | |
| a(A, t.slice(0, v + 1).join(E) + w.ellipsis); | |
| if (!k(p, w)) { | |
| F = v; | |
| G = v | |
| } else { | |
| y = v | |
| } | |
| } | |
| if (F != -1 && !(t.length == 1 && t[0].length == 0)) { | |
| var u = f(t.slice(0, F + 1).join(E), w); | |
| D = true; | |
| a(A, u) | |
| } else { | |
| var z = q.parent(); | |
| q.remove(); | |
| var C = (s) ? s.length : 0; | |
| if (z.contents().size() > C) { | |
| var B = z.contents().eq(-1 - C); | |
| D = e(B, r, p, w, s) | |
| } else { | |
| var A = z.prev().contents().eq(-1)[0]; | |
| if (typeof A != "undefined") { | |
| var u = f(h(A), w); | |
| a(A, u); | |
| z.remove(); | |
| D = true | |
| } | |
| } | |
| } | |
| return D | |
| } | |
| function k(q, p) { | |
| return q.innerHeight() > p.maxHeight | |
| } | |
| function f(p, q) { | |
| while (i.inArray(p.slice(-1), q.lastCharacter.remove) > -1) { | |
| p = p.slice(0, -1) | |
| } | |
| if (i.inArray(p.slice(-1), q.lastCharacter.noEllipsis) < 0) { | |
| p += q.ellipsis | |
| } | |
| return p | |
| } | |
| function j(p) { | |
| return { | |
| width: p.innerWidth(), | |
| height: p.innerHeight() | |
| } | |
| } | |
| function a(q, p) { | |
| if (q.innerText) { | |
| q.innerText = p | |
| } else { | |
| if (q.nodeValue) { | |
| q.nodeValue = p | |
| } else { | |
| if (q.textContent) { | |
| q.textContent = p | |
| } | |
| } | |
| } | |
| } | |
| function h(p) { | |
| if (p.innerText) { | |
| return p.innerText | |
| } else { | |
| if (p.nodeValue) { | |
| return p.nodeValue | |
| } else { | |
| if (p.textContent) { | |
| return p.textContent | |
| } else { | |
| return "" | |
| } | |
| } | |
| } | |
| } | |
| function c(p, q) { | |
| if (typeof p == "undefined") { | |
| return false | |
| } | |
| if (!p) { | |
| return false | |
| } | |
| if (typeof p == "string") { | |
| p = i(p, q); | |
| return (p.length) ? p : false | |
| } | |
| if (typeof p == "object") { | |
| return (typeof p.jquery == "undefined") ? false : p | |
| } | |
| return false | |
| } | |
| function o(s) { | |
| var t = s.innerHeight(), | |
| r = ["paddingTop", "paddingBottom"]; | |
| for (var u = 0, q = r.length; u < q; u++) { | |
| var p = parseInt(s.css(r[u]), 10); | |
| if (isNaN(p)) { | |
| p = 0 | |
| } | |
| t -= p | |
| } | |
| return t | |
| } | |
| function b(q, p) { | |
| if (!q) { | |
| return false | |
| } | |
| if (typeof p == "string") { | |
| p = "dotdotdot: " + p | |
| } else { | |
| p = ["dotdotdot:", p] | |
| } | |
| if (typeof window.console != "undefined") { | |
| if (typeof window.console.log != "undefined") { | |
| window.console.log(p) | |
| } | |
| } | |
| return false | |
| } | |
| var n = i.fn.html; | |
| i.fn.html = function(p) { | |
| if (typeof p != "undefined") { | |
| if (this.data("dotdotdot")) { | |
| if (typeof p != "function") { | |
| return this.trigger("update", [p]) | |
| } | |
| } | |
| return n.call(this, p) | |
| } | |
| return n.call(this) | |
| }; | |
| var g = i.fn.text; | |
| i.fn.text = function(q) { | |
| if (typeof q != "undefined") { | |
| if (this.data("dotdotdot")) { | |
| var p = i("<div />"); | |
| p.text(q); | |
| q = p.html(); | |
| p.remove(); | |
| return this.trigger("update", [q]) | |
| } | |
| return g.call(this, q) | |
| } | |
| return g.call(this) | |
| } | |
| })(jQuery); | |
| (function(f) { | |
| f.widget("luminate.appmgr", { | |
| options: {}, | |
| _create: function s() { | |
| var v = this, | |
| x = v.element, | |
| w = f.luminate.appmgr.config; | |
| if (!f.luminate.appmgr.initialized) { | |
| f.luminate.appmgr.initialized = true; | |
| v.addStyle(v.evaluate(w.style)); | |
| if (w.auxStyle) { | |
| v.addStyle(v.evaluate(w.auxStyle)) | |
| } | |
| } | |
| v.uid = x.image("uid"); | |
| v._apps = {}; | |
| v._targets = []; | |
| v._anchor = f("<div class='pxz-anchor' />").appendTo("#pxzcont"); | |
| x.image("registerOverlay", v._anchor); | |
| v._mask = f("<div class='pxz-app-anchor-mask' />"); | |
| x.image("registerOverlay", v._mask); | |
| v._mask.appendTo(v._anchor).hide(); | |
| v._maskOpen = false; | |
| v._position(); | |
| x.bind("pxz.image.moved pxz.image.resized", function() { | |
| v._position() | |
| }); | |
| v._state = null; | |
| x.bind("pxz.image.over", function() { | |
| if (v._state != "closed") { | |
| v._activate() | |
| } | |
| }); | |
| x.bind("pxz.image.out", function() { | |
| if (v._state != "closed" && !v._maskOpen) { | |
| v._deactivate() | |
| } | |
| }); | |
| var A = $lmn8.options.user.flags.taskbar_state || "minimized"; | |
| v.updateState(A); | |
| function u() { | |
| $lmn8.event(x, "image", "exposed") | |
| } | |
| if (x.image("exposed")) { | |
| u() | |
| } else { | |
| x.bind("pxz.image.exposed", function(C, B) { | |
| if (B) { | |
| x.unbind(C); | |
| u() | |
| } | |
| }) | |
| } | |
| if (!x.image("visible")) { | |
| v._anchor.hide() | |
| } | |
| x.bind("pxz.image.visible", function(B, C) { | |
| if (C) { | |
| v._anchor.show() | |
| } else { | |
| v._anchor.hide() | |
| } | |
| }); | |
| v._activeApp = null; | |
| v._appPendingActivation = null; | |
| x.bind("pxz.app.deactivated", function(C, B) { | |
| if (v._activeApp && v._activeApp.name() == B) { | |
| v._activeApp = null | |
| } | |
| v._activatePendingApp() | |
| }); | |
| var z = false, | |
| y = null; | |
| x.bind("pxz.image.over", function(B, C) { | |
| if (!y) { | |
| $lmn8.event(x, "image", "mouseover", { | |
| first: !z | |
| }); | |
| z = true; | |
| y = C | |
| } | |
| }); | |
| x.bind("pxz.image.out", function(C, D) { | |
| if (y) { | |
| var B = D - y; | |
| $lmn8.event(x, "image", "mouseout", { | |
| elapsed: B | |
| }); | |
| y = null | |
| } | |
| }) | |
| }, | |
| destroy: function a() { | |
| var u = this, | |
| v = u.element; | |
| v.unbind("pxz.image.moved pxz.image.exposed pxz.image.visible pxz.image.over pxz.image.out"); | |
| v.unbind("pxz.app.deactivated"); | |
| if (u._anchor) { | |
| u._anchor.remove() | |
| } | |
| f.Widget.prototype.destroy.apply(u, arguments) | |
| }, | |
| addApp: function k(x) { | |
| var u = this, | |
| w = u.element, | |
| v = x.name(); | |
| if (!(v in u._apps)) { | |
| u._apps[v] = x; | |
| w.trigger("pxz.app.added", [v]) | |
| } | |
| }, | |
| removeApp: function t(x) { | |
| var u = this, | |
| w = u.element, | |
| v = x.name(); | |
| if (v in u._apps) { | |
| delete u._apps[v]; | |
| w.trigger("pxz.app.removed", [v]) | |
| } | |
| }, | |
| activateApp: function o(x, w) { | |
| var u = this, | |
| v = x.name(); | |
| if (u._state == "closed" && !w) { | |
| return | |
| } | |
| if (v in u._apps) { | |
| if (x == u._activeApp) { | |
| return | |
| } | |
| if (u._activeApp) { | |
| u._appPendingActivation = x; | |
| u._activeApp.deactivate() | |
| } else { | |
| u._activateApp(x) | |
| } | |
| } else { | |
| u.debug("Uninitialized app " + v + " requested activation") | |
| } | |
| }, | |
| _activatePendingApp: function c() { | |
| var u = this, | |
| v = u._appPendingActivation; | |
| if (v) { | |
| u._appPendingActivation = null; | |
| u._activateApp(v) | |
| } | |
| }, | |
| _activateApp: function j(v) { | |
| var u = this; | |
| if (v != u._activeApp) { | |
| f(".pxz-app-anchor", u._anchor).removeClass("pxz-active"); | |
| u._activeApp = v; | |
| u.getAppAnchor(v).addClass("pxz-active"); | |
| v.activate() | |
| } | |
| }, | |
| addTarget: function k(y, x) { | |
| var u = this, | |
| w = u.element, | |
| v = y.name(); | |
| if (v in u._apps) { | |
| x._app = v; | |
| u._targets.push(x); | |
| w.trigger("pxz.target.added", [v, x]); | |
| u.debug("App " + v + " added target") | |
| } else { | |
| u.debug("Uninitialized app " + v + " added target") | |
| } | |
| }, | |
| removeTarget: function t(z, y) { | |
| var v = this, | |
| x = v.element, | |
| w = z.name(), | |
| u = f.inArray(y, v._targets); | |
| if (u >= 0) { | |
| v._targets.slice(u, 1); | |
| x.trigger("pxz.target.removed", [w, y]); | |
| v.debug("App " + w + " removed target") | |
| } | |
| }, | |
| apps: function i() { | |
| var u = this; | |
| return f.map(u._apps, function(w, v) { | |
| return v | |
| }) | |
| }, | |
| targets: function b() { | |
| var u = this; | |
| return u._targets | |
| }, | |
| activeApp: function p() { | |
| var u = this; | |
| return u._activeApp | |
| }, | |
| anchor: function q() { | |
| var u = this; | |
| return u._anchor | |
| }, | |
| getAppAnchor: function l(y) { | |
| var u = this, | |
| x = u.element, | |
| w = y.name(), | |
| v = f(".pxz-" + w + "-anchor", u._anchor); | |
| if (v.length < 1) { | |
| v = f("<div class='pxz-anchor pxz-app-anchor pxz-" + w + "-anchor' />"); | |
| u._anchor.append(v); | |
| x.image("registerOverlay", v) | |
| } | |
| return v | |
| }, | |
| _position: function n() { | |
| var u = this; | |
| u._anchor.css(u.element.image("offset")); | |
| if (u._maskOpen) { | |
| u._mask.css(u.element.image("size")) | |
| } | |
| }, | |
| _activate: function r() { | |
| var u = this; | |
| u.updateState("open") | |
| }, | |
| _deactivate: function d() { | |
| var u = this; | |
| u.updateState("minimized") | |
| }, | |
| updateState: function e(x) { | |
| var u = this, | |
| w = u.element, | |
| v = u._state; | |
| if (x == v) { | |
| return | |
| } | |
| u._state = x; | |
| w.trigger("pxz.state", [x, v]); | |
| u._anchor.removeClass("pxz-state-" + v); | |
| u._anchor.addClass("pxz-state-" + x) | |
| }, | |
| state: function h() { | |
| var u = this; | |
| return u._state | |
| }, | |
| showAppMask: function m(v) { | |
| var u = this, | |
| x = u.element, | |
| w = x.image("size"); | |
| u._mask.css(w); | |
| if (v) { | |
| u._mask.data("prevColor", u._mask.css("background-color")); | |
| u._mask.css("background-color", v) | |
| } | |
| u._mask.css({ | |
| opacity: 0 | |
| }).show().animate({ | |
| opacity: 0.5 | |
| }); | |
| u._maskOpen = true; | |
| f(".pxz-anchor:not(.pxz-active)", u._anchor).animate({ | |
| opacity: 0 | |
| }) | |
| }, | |
| hideAppMask: function g() { | |
| var u = this; | |
| u._mask.animate({ | |
| opacity: 0 | |
| }, "fast", function() { | |
| u._mask.hide(); | |
| u._mask.css("background-color", u._mask.data("prevColor")) | |
| }); | |
| f(".pxz-anchor:not(.pxz-active)", u._anchor).animate({ | |
| opacity: 1 | |
| }, "fast"); | |
| u._maskOpen = false | |
| } | |
| }); | |
| f.extend(f.luminate.appmgr, { | |
| initialized: false, | |
| config: { | |
| style: "#pxzcont .pxz-anchor{overflow:visible;width:0px;height:0px;position:absolute}#pxzcont .pxz-app-anchor{z-index:1}#pxzcont .pxz-state-open{z-index:2}#pxzcont .pxz-state-closed .pxz-app-anchor{display:none}#pxzcont .pxz-app-anchor-mask{position:absolute;z-index:2}#pxzcont .pxz-app-anchor.pxz-active{z-index:3}#pxzcont .pxz-app-anchor-mask{background-color:#FFF}", | |
| auxStyle: null | |
| } | |
| }) | |
| })(jQuery); | |
| (function(f) { | |
| f.widget("luminate.base", { | |
| options: { | |
| priority: 0 | |
| }, | |
| _create: function j() { | |
| var l = this, | |
| n = l.element, | |
| m = f.luminate.base.config, | |
| o = l.widgetName; | |
| if (!f.luminate.base.initialized) { | |
| f.luminate.base.initialized = true; | |
| l.addStyle(l.evaluate(m.style)); | |
| if (m.auxStyle) { | |
| l.addStyle(l.evaluate(m.auxStyle)) | |
| } | |
| } | |
| m = f.luminate[o].config; | |
| if (!f.luminate[o].initialized) { | |
| f.luminate[o].initialized = true; | |
| if (m.style) { | |
| l.addStyle(l.evaluate(m.style)) | |
| } | |
| if (m.auxStyle) { | |
| l.addStyle(l.evaluate(m.auxStyle)) | |
| } | |
| } | |
| l.publisherID = n.image("option", "publisherID"); | |
| if (!l.publisherID) { | |
| l.publisherID = $lmn8.options.publisherID | |
| } | |
| l.pictID = n.image("option", "pictID"); | |
| l.uid = n.image("option", "uid"); | |
| n.trigger("pxz." + o + ".created"); | |
| if (l.position) { | |
| n.bind("pxz.image.resized", function() { | |
| l.position() | |
| }) | |
| } | |
| }, | |
| destroy: function c() { | |
| var l = this; | |
| f.Widget.prototype.destroy.apply(l, arguments) | |
| }, | |
| activate: function b() { | |
| var l = this; | |
| l.debug("activated") | |
| }, | |
| deactivate: function e() { | |
| var l = this; | |
| l.debug("deactivated") | |
| }, | |
| name: function d() { | |
| var l = this; | |
| return l.widgetName | |
| }, | |
| data: function i(m, p, o, n) { | |
| var l = this; | |
| $lmn8.data(l.element, l.name(), m, p, o, n) | |
| }, | |
| event: function g(m, n) { | |
| var l = this; | |
| $lmn8.event(l.element, l.name(), m, n) | |
| }, | |
| eventUrl: function k(m, n) { | |
| var l = this; | |
| return $lmn8.eventUrl(l.element, l.name(), m, n) | |
| }, | |
| setFlag: function h(m, n, o) { | |
| var l = this; | |
| $lmn8.setf(l.element, l.name(), m, n, o) | |
| }, | |
| getFlag: function h(m, n) { | |
| var l = this; | |
| $lmn8.getf(l.element, l.name(), m, n) | |
| }, | |
| taskbarWidget: function a() { | |
| var l = this, | |
| n = l.name(), | |
| p = null, | |
| m = f.luminate[n].config, | |
| o; | |
| if (m.taskbarPngUrl || m.taskbarSvg) { | |
| p = f("<div class='pxz-taskbar-icon-" + n + "'/>"); | |
| o = { | |
| type: "taskbar", | |
| toolTip: m.taskbarTooltip || n, | |
| svg: l.evaluate(m.taskbarSvg), | |
| pngUrl: m.taskbarPngUrl, | |
| owner: l | |
| }; | |
| p.icon(o) | |
| } | |
| return l._taskbarWidget = p | |
| } | |
| }); | |
| f.extend(f.luminate.base, { | |
| initialized: false, | |
| config: { | |
| style: "#pxzcont .pxz-clear{clear:both}#pxzcont .pxz-colorize-background{background-color:${$lmn8.options.accentColor}}#pxzcont .pxz-button,#pxzcont a.pxz-button,#pxzcont a.pxz-button:visited{color:${$lmn8.options.accentColor};background-color:#F1F1F1;font-size:12px;font-weight:normal;width:100px;border-radius:5px;display:block;line-height:20px;text-align:center;-webkit-transition:all 0.3s;-moz-transition:all 0.3s;-o-transition:all 0.3s;transition:all 0.3s}#pxzcont .pxz-button:hover,#pxzcont a.pxz-button:hover,#pxzcont a.pxz-button:active{color:#333;background-color:${$lmn8.options.accentColor};text-decoration:none;-webkit-transition:all 0.3s;-moz-transition:all 0.3s;-o-transition:all 0.3s;transition:all 0.3s;cursor:pointer}#pxzcont .pxz-colorize-text{color:${$lmn8.options.accentColor}!important}#pxzcont a,#pxzcont a:link,#pxzcont a:visited{color:${$lmn8.options.accentColor};text-decoration:none;-webkit-transition:color 0.3s;-moz-transition:color 0.3s;-o-transition:color 0.3s;transition:color 0.3s}#pxzcont a:hover{color:${$lmn8.options.accentColor};text-decoration:underline;-webkit-transition:color 0.3s;-moz-transition:color 0.3s;-o-transition:color 0.3s;transition:color 0.3s}#pxzcont .pxz-closebox{position:absolute;display:block;cursor:pointer}#pxzcont .pxz-closebox-icon{}", | |
| auxStyle: null | |
| } | |
| }) | |
| })(jQuery); | |
| (function(f) { | |
| f.widget("luminate.drawer", { | |
| options: { | |
| owner: null, | |
| anchor: "#pxzcont", | |
| mode: "bottom", | |
| closebox: false | |
| }, | |
| _create: function e() { | |
| var g = this, | |
| k = g.element, | |
| i = g.options, | |
| h = f.luminate.drawer.config; | |
| if (!f.luminate.drawer.initialized) { | |
| f.luminate.drawer.initialized = true; | |
| g.addStyle(g.evaluate(h.style)); | |
| if (h.auxStyle) { | |
| g.addStyle(g.evaluate(h.auxStyle)) | |
| } | |
| } | |
| var j = (g.evaluate(h.drawerHtml)); | |
| g._drawer = f(j).appendTo(i.anchor).hide(); | |
| g._drawerContent = f(".pxz-slidedrawer-content", g._drawer); | |
| g._drawerContent.append(k); | |
| g._closebox = f(".pxz-closebox", g._drawer); | |
| k.bind("remove", function(l) { | |
| k.unbind(l); | |
| g._drawer.remove() | |
| }); | |
| if (i.owner) { | |
| i.owner.element.bind("pxz.image.resized", function() { | |
| g.position() | |
| }) | |
| } | |
| if (!f.support.touch) { | |
| g._drawer.hover(function() { | |
| k.trigger("pxz.drawer.over") | |
| }, function() { | |
| k.trigger("pxz.drawer.out") | |
| }) | |
| } | |
| g._drawer.css({ | |
| height: 0 | |
| }); | |
| g.closebox(i.closebox) | |
| }, | |
| closebox: function c(h) { | |
| var g = this; | |
| if (h) { | |
| g._closebox.bind("click", h); | |
| g._closebox.show() | |
| } else { | |
| g._closebox.unbind("click"); | |
| g._closebox.hide() | |
| } | |
| }, | |
| position: function b() { | |
| var g = this, | |
| h = g.options, | |
| j = h.owner.element, | |
| i = j.image("size"); | |
| g._drawer.css({ | |
| width: i.width | |
| }); | |
| switch (h.mode) { | |
| case "bottom": | |
| g._drawer.css({ | |
| bottom: -i.height | |
| }); | |
| break; | |
| case "top": | |
| g._drawer.css({ | |
| top: 0 | |
| }); | |
| break | |
| } | |
| }, | |
| show: function a(h) { | |
| var g = this; | |
| g._drawer.show(); | |
| if (!f.browser.msie || parseInt(f.browser.version, 10) > 7) { | |
| g._drawerHeight = g._drawerContent.height() | |
| } else { | |
| g._drawerHeight = g._drawerContent.outerHeight(true) | |
| } | |
| if (h) { | |
| g._drawer.animate({ | |
| height: g._drawerHeight | |
| }, h) | |
| } else { | |
| g._drawer.css({ | |
| height: g._drawerHeight | |
| }) | |
| } | |
| }, | |
| hide: function d(h) { | |
| var g = this; | |
| if (h) { | |
| g._drawer.animate({ | |
| height: 0 | |
| }, h) | |
| } else { | |
| g._drawer.css({ | |
| height: 0 | |
| }) | |
| } | |
| } | |
| }); | |
| f.extend(f.luminate.drawer, { | |
| initialized: false, | |
| config: { | |
| style: "#pxzcont .pxz-slidedrawer{position:absolute;padding:0;background:url(http://assets.luminate.com/4.0/backgrounds/background-00000080.png) repeat 0 0;overflow:hidden}#pxzcont .pxz-slidedrawer .pxz-closebox{top:auto;bottom:0;right:0;background-image:url(http://assets.luminate.com/4.0/icon/png/closeboxes_ads.v2.png);background-position:-0px -50px;padding:0 2px 5px 0;width:25px;height:25px;opacity:0.5;-webkit-transition:opacity 0.2s ease;-moz-transition:opacity 0.2s ease;-otransition:opacity 0.2s ease;transition:opacity 0.2s ease}#pxzcont .pxz-slidedrawer .pxz-closebox:hover,#pxzcont .pxz-slidedrawer .pxz-closebox:active{background-position:-25px -50px;opacity:1;-webkit-transition:opacity 0.2s ease;-moz-transition:opacity 0.2s ease;-otransition:opacity 0.2s ease;transition:opacity 0.2s ease}", | |
| auxStyle: null, | |
| drawerHtml: '<div class="pxz-slidedrawer"> <div class="pxz-slidedrawer-content" /> <div class="pxz-closebox" title="Close"/> </div> ' | |
| } | |
| }) | |
| })(jQuery); | |
| (function(f) { | |
| f.widget("luminate.icon", { | |
| options: { | |
| toolTip: "", | |
| pngUrl: "", | |
| svg: "", | |
| type: "", | |
| hsXratio: 0, | |
| hsYratio: 0, | |
| owner: null, | |
| visibility: { | |
| visible: { | |
| opacity: 1 | |
| }, | |
| dimmed: { | |
| opacity: 0.5 | |
| }, | |
| hidden: { | |
| opacity: 0 | |
| } | |
| }, | |
| uniqSvg: "", | |
| fixedSize: null, | |
| hoverHighlight: true, | |
| highlightEffect: true, | |
| unColor: "#333333" | |
| }, | |
| _create: function g() { | |
| var t = this, | |
| l = t.element, | |
| u = t.options, | |
| n = f.luminate.icon.config, | |
| r; | |
| t._type = u.type; | |
| t._visibility = "visible"; | |
| if (!f.luminate.icon.initialized) { | |
| f.luminate.icon.initialized = true; | |
| t.addStyle(t.evaluate(n.style)); | |
| if (n.auxStyle) { | |
| t.addStyle(t.evaluate(n.auxStyle)) | |
| } | |
| } | |
| if (f.support.svg) { | |
| u.uniqSvg = t.uniqid(u.svg) | |
| } else { | |
| u.uniqSvg = "" | |
| } | |
| l.html(t.evaluate(n.iconHtml, u)); | |
| if (!f.support.svg) { | |
| f(".pxz-icon-svg", l).remove(); | |
| f(".pxz-icon-alt-image", l).append(f("<img src='" + u.pngUrl + "' />")); | |
| f(".pxz-icon-alt-highlight-on", l).append(f("<img src='http://assets.luminate.com/4.0/icon/png/highlight/highlight." + $lmn8.options.accentColorLow + ".48.png' />")); | |
| f(".pxz-icon-alt-highlight-off", l).append(f("<img src='http://assets.luminate.com/4.0/icon/png/highlight/highlight.000.48.png' />")) | |
| } else { | |
| f(".pxz-icon-png", l).remove(); | |
| f(".highlight-fill", l).css("fill", u.unColor) | |
| } | |
| if (!u.fixedSize) { | |
| r = $lmn8.options.iconSize || "medium"; | |
| if (r == "auto" && u.owner) { | |
| var m = u.owner.element.image("cropElement"), | |
| o = m.size().width * m.size().height; | |
| if (o < 160000) { | |
| r = "small" | |
| } else { | |
| if (o <= 640000) { | |
| r = "medium" | |
| } else { | |
| r = "large" | |
| } | |
| } | |
| } | |
| f(".pxz-icon-icon", l).removeClass("pxz-small pxz-medium pxz-large"); | |
| f(".pxz-icon-icon", l).addClass("pxz-" + r) | |
| } else { | |
| var s = u.fixedSize.width || 0; | |
| var p = u.fixedSize.height || 0; | |
| var q = { | |
| width: s, | |
| height: p | |
| }; | |
| f(".pxz-icon-icon", l).css(q); | |
| f(".pxz-icon-icon .pxz-icon-svg svg", l).css(q); | |
| f(".pxz-icon-icon .pxz-icon-png img", l).css(q) | |
| } | |
| t._highlit = false; | |
| if (!f.support.touch && u.hoverHighlight) { | |
| l.hover(function() { | |
| t._doHighlight(true) | |
| }, function() { | |
| t._doHighlight(t._highlit) | |
| }) | |
| } | |
| if (!u.highlightEffect) { | |
| f(".highlight-fill", l).remove(); | |
| f(".pxz-icon-alt-highlight", l).remove() | |
| } | |
| }, | |
| destroy: function a() {}, | |
| _setOption: function b(o, p) { | |
| var l = this, | |
| n = l.element, | |
| m = l.options; | |
| f.Widget.prototype._setOption.apply(l, arguments); | |
| switch (o) { | |
| case "toolTip": | |
| f(".pxz-tooltip", n).text(p); | |
| break; | |
| case "pngUrl": | |
| f(".pxz-icon-alt-image img", n).attr("src", p); | |
| break; | |
| case "svg": | |
| if (f.support.svg) { | |
| m.uniqSvg = l.uniqid(p); | |
| f(".pxz-icon-svg", n).html(m.uniqSvg) | |
| } | |
| break | |
| } | |
| }, | |
| _doHighlight: function c(l) { | |
| var m = this, | |
| n = m.element; | |
| if (l) { | |
| if (f.support.svg) { | |
| f(".highlight-fill", n).css({ | |
| fill: $lmn8.options.accentColor | |
| }) | |
| } else { | |
| f(".pxz-icon-alt-highlight-on", n).show(); | |
| f(".pxz-icon-alt-highlight-off", n).hide() | |
| } | |
| } else { | |
| if (f.support.svg) { | |
| f(".highlight-fill", n).css({ | |
| fill: m.options.unColor | |
| }) | |
| } else { | |
| f(".pxz-icon-alt-highlight-on", n).hide(); | |
| f(".pxz-icon-alt-highlight-off", n).show() | |
| } | |
| } | |
| }, | |
| position: function j(l, q) { | |
| var m = this, | |
| p = m.element, | |
| n = m.options, | |
| o = f(".pxz-icon-icon", p).size(); | |
| p.css({ | |
| left: Math.round(l - n.hsXratio * o.width), | |
| top: Math.round(q - n.hsYratio * o.height) | |
| }) | |
| }, | |
| visibility: function h(l, n) { | |
| var m = this, | |
| o = m.element, | |
| p = m.options.visibility, | |
| q = 500; | |
| if (!l) { | |
| return m._visibility | |
| } | |
| if (!f.support.svg && l == "dimmed") { | |
| l = "visible" | |
| } | |
| if (l == m._visibility) { | |
| n = false | |
| } | |
| m._visibility = l; | |
| n = (n === false) ? false : true; | |
| n = (n === true && f.support.svg) ? true : false; | |
| if (n) { | |
| f(".pxz-" + m._type + "-icon", o).animate(p[l], q) | |
| } else { | |
| f(".pxz-" + m._type + "-icon", o).css(p[l]) | |
| } | |
| }, | |
| show: function d(m) { | |
| var l = this; | |
| m = m || false; | |
| l.visibility("visible", m) | |
| }, | |
| hide: function i(m) { | |
| var l = this; | |
| m = m || false; | |
| l.visibility("hidden", m) | |
| }, | |
| dim: function k(m) { | |
| var l = this; | |
| m = m || false; | |
| l.visibility("dimmed", m) | |
| }, | |
| highlight: function e(l) { | |
| var m = this; | |
| m._highlit = l; | |
| m._doHighlight(l) | |
| } | |
| }); | |
| f.extend(f.luminate.icon, { | |
| initialized: false, | |
| config: { | |
| style: "#pxzcont .pxz-icon-icon{cursor:pointer}#pxzcont .pxz-icon-icon.pxz-small,#pxzcont .pxz-icon-icon.pxz-small .pxz-icon-svg svg,#pxzcont .pxz-icon-icon.pxz-small .pxz-icon-png img{width:32px;height:32px}#pxzcont .pxz-icon-icon.pxz-medium,#pxzcont .pxz-icon-icon.pxz-medium .pxz-icon-svg svg,#pxzcont .pxz-icon-icon.pxz-medium .pxz-icon-png img{width:40px;height:40px}#pxzcont .pxz-icon-icon.pxz-large,#pxzcont .pxz-icon-icon.pxz-large .pxz-icon-svg svg,#pxzcont .pxz-icon-icon.pxz-large .pxz-icon-png img{width:48px;height:48px}#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-small,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-small .pxz-icon-svg svg,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-small .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-medium,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-medium .pxz-icon-svg svg,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-medium .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-large,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-large .pxz-icon-svg svg,#pxzcont.pxz-ie7 .pxz-icon-icon.pxz-large .pxz-icon-png img{width:48px;height:48px}#pxzcont .pxz-icon-svg{width:auto;height:auto;padding:0;position:absolute}#pxzcont .pxz-icon-svg svg .highlight-fill{-o-transition:all 0.3s;-moz-transition:all 0.3s;-webkit-transition:all 0.3s;transition:all 0.3s}#pxzcont .pxz-icon-alt-image,#pxzcont .pxz-icon-alt-highlight,#pxzcont .pxz-icon-alt-highlight img{position:absolute}#pxzcont .pxz-icon-png .pxz-icon-alt-highlight-on{display:none}#pxzcont .pxz-tooltip{display:none;background-color:#ffffff;opacity:0.9;color:#404040;min-width:60px;height:20px;border-radius:10px;position:absolute;font-family:Arial,sans-serif;font-size:12px;font-weight:normal;line-height:20px;text-align:center;padding:0 10px;white-space:nowrap;box-shadow:2px 2px 2px rgba(0,0,0,0.48)}", | |
| auxStyle: null, | |
| iconHtml: '<div class="pxz-icon-icon pxz-${ type }-icon"> <div class="pxz-tooltip pxz-noselect">${ toolTip }</div> <div class="pxz-icon-svg pxz-noselect"> ${ uniqSvg } </div> <div class="pxz-icon-png"> <div class="pxz-icon-alt-highlight pxz-icon-alt-highlight-on"></div> <div class="pxz-icon-alt-highlight pxz-icon-alt-highlight-off"></div> <div class="pxz-icon-alt-image"></div> </div> </div> ' | |
| } | |
| }) | |
| })(jQuery); | |
| (function(u) { | |
| var c = [], | |
| a, w, v, y = u(window), | |
| J, q, z, g; | |
| y.scroll(function() { | |
| J = y.scrollTop(); | |
| q = y.scrollLeft() | |
| }); | |
| y.resize(function() { | |
| z = y.height(); | |
| g = y.width() | |
| }); | |
| u(function() { | |
| J = y.scrollTop(); | |
| q = y.scrollLeft(); | |
| z = y.height(); | |
| g = y.width() | |
| }); | |
| function G(M) { | |
| if ($lmn8 && $lmn8.container && c.length) { | |
| var N = $lmn8.container.offset(); | |
| if (parseInt(N.left, 10) !== 0 || parseInt(N.top, 10) !== 0) { | |
| $lmn8.container.css("position", "absolute").offset({ | |
| top: 0, | |
| left: 0 | |
| }) | |
| } | |
| for (var L = 0; L < c.length; L++) { | |
| c[L].update(false, M) | |
| } | |
| } | |
| } | |
| u.widget("luminate.image", { | |
| options: { | |
| width: 0, | |
| height: 0, | |
| pictID: "0", | |
| galleryPictID: null, | |
| uid: "0", | |
| exposedThreshold: 0.5, | |
| inDelay: 100, | |
| outDelay: 1000, | |
| updateInterval: 250, | |
| canonical: null, | |
| trackMouse: false, | |
| gallery: false, | |
| cropDiv: null, | |
| articleLink: "luminate-article-link", | |
| articleTitle: "luminate-article-title", | |
| useEnter: false, | |
| hideWhenMoving: true | |
| }, | |
| _create: function s() { | |
| var M = this, | |
| Q = M.element, | |
| N = M.options; | |
| if (!u.luminate.image.initialized) { | |
| u.luminate.image.initialized = true; | |
| u("body").mousemove(function(S) { | |
| w = S.pageX; | |
| v = S.pageY | |
| }) | |
| } | |
| if (u.support.touch) { | |
| N.inDelay = 100; | |
| N.outDelay = 100 | |
| } | |
| M.element.attr("pxz:uid", N.uid); | |
| M._criteria = $lmn8.options.criteria; | |
| M._cropDiv = null; | |
| if (M._criteria.cropSelector) { | |
| M._cropDiv = Q.closest(M._criteria.cropSelector) | |
| } | |
| M._offset = Q.offset(); | |
| M._size = Q.size(); | |
| M._crop = M._computeCrop(); | |
| M._visible = M._computeVisible(); | |
| M._exposed = M._visible && (M.exposure() > N.exposedThreshold); | |
| M._overlays = []; | |
| M._mouseX = -1; | |
| M._mouseY = -1; | |
| M._tempInvisible = 0; | |
| c.push(M); | |
| if (!a) { | |
| a = window.setInterval(G, N.updateInterval); | |
| u(window).resize(G) | |
| } | |
| M._isOver = false; | |
| M._overFn = function() { | |
| M._over() | |
| }; | |
| M._outFn = function() { | |
| M._out() | |
| }; | |
| M._moveFn = function() { | |
| M._over() | |
| }; | |
| if (!$lmn8.options.useEnter && !u.support.touch) { | |
| Q.hover(M._overFn, M._outFn) | |
| } else { | |
| M._entered = M._testOver() | |
| } | |
| if (u.support.touch) { | |
| M._touchOverFn = function() { | |
| M._touchOver = true | |
| }; | |
| M._touchBodyFn = function(S) { | |
| w = S.originalEvent.touches[0].pageX; | |
| v = S.originalEvent.touches[0].pageY; | |
| if (M._touchOver) { | |
| M._over() | |
| } else { | |
| M._out() | |
| } | |
| M._touchOver = false | |
| }; | |
| M._touchOver = false; | |
| Q.bind("touchstart", M._touchOverFn); | |
| u("body").bind("touchstart", M._touchBodyFn) | |
| } | |
| var R = Q.attr(N.articleTitle), | |
| L = Q.attr(N.articleLink); | |
| if (typeof(R) == "undefined" && typeof(L) == "undefined") { | |
| var O = Q.closest(".post"), | |
| P = u('a[rel="bookmark"]', O); | |
| if (P.length) { | |
| R = u.trim(P.text()); | |
| L = u.absolutify(document.location.href, P.attr("href")) | |
| } | |
| } | |
| M._article = { | |
| title: R || document.title, | |
| location: L || document.location.href | |
| } | |
| }, | |
| destroy: function l() { | |
| var M = this, | |
| N = M.element, | |
| L; | |
| N.unbind("mouseenter", M._overFn); | |
| N.unbind("mouseleave", M._outFn); | |
| N.unbind("pxz"); | |
| if (u.support.touch) { | |
| N.unbind("touchstart", M._touchOverFn); | |
| u("body").unbind("touchStart", M._touchBodyFn) | |
| } | |
| L = u.inArray(M, c); | |
| if (L > -1) { | |
| c.splice(L, 1) | |
| } | |
| M.element.removeAttr("pxz:uid"); | |
| u.Widget.prototype.destroy.apply(M, arguments) | |
| }, | |
| _over: function t() { | |
| var L = this, | |
| M = new Date(); | |
| if (L._hoverTimer) { | |
| window.clearTimeout(L._hoverTimer) | |
| } | |
| L._hoverTimer = window.setTimeout(function() { | |
| L._hoverTimer = null; | |
| if (L._isOver) { | |
| return | |
| } | |
| L._isOver = true; | |
| L.element.trigger("pxz.image.over", [M]) | |
| }, L.options.inDelay) | |
| }, | |
| _out: function m() { | |
| var L = this, | |
| M = new Date(); | |
| L._entered = false; | |
| if (L._hoverTimer) { | |
| window.clearTimeout(L._hoverTimer) | |
| } | |
| L._hoverTimer = window.setTimeout(function() { | |
| L._hoverTimer = null; | |
| if (!L._isOver) { | |
| return | |
| } | |
| L._isOver = false; | |
| L.element.trigger("pxz.image.out", [M]) | |
| }, L.options.outDelay) | |
| }, | |
| _computeCrop: function D() { | |
| var O = this, | |
| L, M, Q, S, R, N, P; | |
| if (O._cropDiv && O._cropDiv.length) { | |
| M = O._cropDiv.bounds(); | |
| Q = O.element.bounds(); | |
| R = Math.max(M.left, Q.left); | |
| S = Math.max(M.top, Q.top); | |
| P = Math.min(M.right, Q.right); | |
| N = Math.min(M.bottom, Q.bottom); | |
| L = { | |
| top: Math.max(0, M.top - Q.top), | |
| left: Math.max(0, M.left - Q.left), | |
| width: Math.max(0, P - R), | |
| height: Math.max(0, N - S) | |
| } | |
| } else { | |
| L = { | |
| top: 0, | |
| left: 0, | |
| width: O._size.width, | |
| height: O._size.height | |
| } | |
| } | |
| return L | |
| }, | |
| _computeVisible: function x() { | |
| var L = this, | |
| M = L.element, | |
| N = L._cropDiv; | |
| return M.is(":visible") && !L.clipped() && (!N || !N.length || (N.css("opacity") == 1)) && (M.css("opacity") == 1) && (L._crop.width > 0) && (L._crop.height > 0) | |
| }, | |
| _testOver: function i(L, P) { | |
| var M = this, | |
| O = { | |
| top: M._offset.top + M._crop.top, | |
| left: M._offset.left + M._crop.left | |
| }, | |
| N = M._crop; | |
| L = L || w; | |
| P = P || v; | |
| return ((O.left < L) && (O.top < P) && (O.left + N.width > L) && (O.top + N.height > P)) | |
| }, | |
| over: function H() { | |
| var L = this; | |
| return L._isOver | |
| }, | |
| update: function I(T, V) { | |
| var Z = this, | |
| M = Z.element, | |
| S, P = Z._offset, | |
| L = Z._crop, | |
| U = Z._visible, | |
| W = Z._exposed, | |
| Y = Z._mouseX, | |
| X = Z._mouseY, | |
| O = M.offset(), | |
| aa = M.size(), | |
| R = Z._computeCrop(), | |
| N = Z._computeVisible(); | |
| if ((Math.abs(P.left - O.left) > 1) || (Math.abs(P.top - O.top) > 1)) { | |
| Z._offset = O; | |
| M.trigger("pxz.image.moved", [O, P]); | |
| if (Z.options.hideWhenMoving && !V) { | |
| Z._tempInvisible = 2 | |
| } | |
| } | |
| if (Z._tempInvisible > 0) { | |
| N = false; | |
| Z._tempInvisible-- | |
| } | |
| if (L.top != R.top || L.left != R.left || L.width != R.width || L.height != R.height) { | |
| Z._size = aa; | |
| Z._crop = R; | |
| M.trigger("pxz.image.resized", [R, L]) | |
| } | |
| if (U != N) { | |
| Z._visible = N; | |
| Z._crop = Z._computeCrop(); | |
| M.trigger("pxz.image.visible", [N, U]) | |
| } | |
| var Q = N && (Z.exposure() > Z.options.exposedThreshold); | |
| if (W != Q) { | |
| Z._exposed = Q; | |
| M.trigger("pxz.image.exposed", [Q, W]) | |
| } | |
| if (Z.options.trackMouse) { | |
| if (Y != w || X != v) { | |
| Z._mouseX = w; | |
| Z._mouseY = v; | |
| M.trigger("pxz.mousemove", [w, v]) | |
| } | |
| } | |
| if ($lmn8.options.useEnter) { | |
| S = Z._testOver(); | |
| if (!Z._entered && S) { | |
| Z._entered = true; | |
| Z._over() | |
| } else { | |
| if (Z._entered && !S) { | |
| Z._out() | |
| } | |
| } | |
| } | |
| }, | |
| uid: function f() { | |
| var L = this; | |
| return L.options.uid | |
| }, | |
| mid: function b() { | |
| return this.options.mid | |
| }, | |
| exposed: function k() { | |
| var L = this; | |
| return L._exposed | |
| }, | |
| visible: function K() { | |
| var L = this; | |
| return L._visible | |
| }, | |
| offset: function d() { | |
| var L = this, | |
| N = L.element, | |
| P = N.offset(), | |
| M = N.border(), | |
| O = N.padding(); | |
| P.left += O.left + M.left; | |
| P.top += O.top + M.top; | |
| return P | |
| }, | |
| size: function n() { | |
| var L = this; | |
| return { | |
| width: L._crop.width, | |
| height: L._crop.height | |
| } | |
| }, | |
| realSize: function o() { | |
| var L = this; | |
| return L._size | |
| }, | |
| crop: function j() { | |
| var L = this; | |
| return L._crop | |
| }, | |
| cropElement: function e() { | |
| var M = this, | |
| L = M.element, | |
| N = M._cropDiv; | |
| if (N && N.length) { | |
| L = N | |
| } | |
| return L | |
| }, | |
| scale: function C() { | |
| var L = this; | |
| return L._size.width / L.options.width | |
| }, | |
| title: function A() { | |
| var L = this; | |
| return L.element.attr("title") || L.element.attr("alt") | |
| }, | |
| article: function h() { | |
| var L = this; | |
| return L._article | |
| }, | |
| src: function r() { | |
| var L = this; | |
| return L.element.src() | |
| }, | |
| registerOverlay: function F(M) { | |
| var L = this; | |
| if (u.inArray(M, L._overlays) < 0) { | |
| if (u.support.touch) { | |
| L._touchOver = false; | |
| M.bind("touchstart", L._touchOverFn) | |
| } else { | |
| if ($lmn8.options.useEnter) { | |
| M.mousemove(L._moveFn) | |
| } | |
| M.hover(L._overFn, L._outFn) | |
| } | |
| L._overlays.push(M) | |
| } | |
| }, | |
| unregisterOverlay: function E(N) { | |
| var M = this, | |
| L; | |
| N.unbind("mouseenter", M._overFn); | |
| N.unbind("mousemove", M._moveFn); | |
| N.unbind("mouseleave", M._outFn); | |
| if (u.support.touch) { | |
| N.unbind("touchstart", M._touchOverFn) | |
| } | |
| L = u.inArray(N, M._overlays); | |
| if (L > -1) { | |
| M._overlays.splice(L, 1) | |
| } | |
| }, | |
| clipped: function B() { | |
| var N = this, | |
| O = N.element, | |
| P, S, M = false, | |
| L = N._criteria.clipSelector; | |
| if (L) { | |
| S = O.closest(L); | |
| if (S.length > 0) { | |
| var R = N._offset.top + N._crop.top, | |
| Q = N._offset.left + N._crop.left; | |
| P = { | |
| top: R + 1, | |
| left: Q + 1, | |
| bottom: R + N._crop.height - 2, | |
| right: Q + N._crop.width - 2 | |
| }; | |
| M = !S.containsRect(P) | |
| } | |
| } | |
| return M | |
| }, | |
| exposure: function p() { | |
| var N = this, | |
| Q, S, M, O = Math.min(N._crop.width, g), | |
| L = Math.min(N._crop.height, z), | |
| R = { | |
| top: N._offset.top + N._crop.top, | |
| left: N._offset.left + N._crop.left | |
| }, | |
| P = O * L; | |
| if (R.top > J) { | |
| S = (J + z) - R.top | |
| } else { | |
| S = (R.top + L) - J | |
| } | |
| if (R.left > q) { | |
| Q = (q + g) - R.left | |
| } else { | |
| Q = (R.left + O) - q | |
| } | |
| S = Math.max(0, Math.min(L, S)); | |
| Q = Math.max(0, Math.min(O, Q)); | |
| M = Q * S; | |
| return (M / P) | |
| } | |
| }); | |
| u.extend(u.luminate.image, { | |
| initialized: false | |
| }) | |
| })(jQuery); | |
| (function(g) { | |
| var C = []; | |
| var a = null; | |
| var w = {}; | |
| function d() { | |
| C = g.map(C, function(J) { | |
| if (J.complete) { | |
| n(J); | |
| return null | |
| } else { | |
| return J | |
| } | |
| }); | |
| if (C.length === 0) { | |
| window.clearInterval(a); | |
| a = null | |
| } | |
| } | |
| function k(J) { | |
| C.push(J); | |
| if (a === null) { | |
| a = window.setInterval(d, 250) | |
| } | |
| } | |
| $lmn8 = window.$pxz = luminate; | |
| var e = { | |
| version: "4.0", | |
| criteria: { | |
| selector: "img", | |
| include: null, | |
| exclude: null, | |
| clipSelector: null, | |
| minWidth: 200, | |
| minHeight: 200, | |
| minAspect: 0.3, | |
| srcFilter: null, | |
| artSel: null, | |
| artFilter: null, | |
| artRequired: false, | |
| urlFilter: null, | |
| adSizes: ["1x1", "300x250", "300x600", "240x400", "720x300", "336x280", "250x250"] | |
| }, | |
| transforms: [], | |
| cache: true, | |
| debug: false, | |
| publisherID: null, | |
| publisher: {}, | |
| configID: null, | |
| userID: null, | |
| baseurl: "http://www.luminate.com/widget/v3", | |
| style: "<style type='text/css' id='pxzstyle'>#pxzcont{position:absolute;top:0px;left:0px;width:0px;height:0px;overflow:visible}#pxzcont *{font-family:Arial,Helvetica,sans-serif;font-weight:normal;background:transparent}#pxzcont * b{font-weight:bold}#pxzcont * i{font-style:italic}#pxzcont * u{font-decoration:underline}#pxzcont div,#pxzcont span,#pxzcont img,#pxzcont td,#pxzcont p{border:0px none;margin:0px;padding:0px;line-height:normal;text-align:left;font-size:1em}#pxzcont input,#pxzcont textarea{box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;-o-box-sizing:content-box}#pxzcont div,#pxzcont img{display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;-o-box-sizing:content-box;margin:0;padding:0}#pxzcont span{display:inline}#pxzcont div{text-align:left;position:relative;overflow:visible;z-index:1}#pxzcont a,#pxzcont a:link,#pxzcont a:hover,#pxzcont a:visited,#pxzcont a:active{font-weight:normal;background:none;font-size:12px;line-height:normal}#pxzcont .pxz-clear{clear:both}#pxzcont .pxz-noselect{-webkit-user-select:none;-khtml-user-select:none;-moz-user-select:none;-o-user-select:none;user-select:none}</style>", | |
| auxStyle: null, | |
| container: "<div id='pxzcont'></div>", | |
| zIndex: 9999, | |
| accentColor: "#F37521", | |
| accentColorLow: "F72", | |
| contrastColor: null, | |
| luminateHome: "top-left", | |
| iconSize: "auto", | |
| disableShimmer: false, | |
| modules: [], | |
| moduleOptions: {}, | |
| share: { | |
| id: null, | |
| imageUrl: null | |
| }, | |
| referrer: null, | |
| country: null, | |
| pageSelect: null, | |
| pageExclude: null, | |
| user: { | |
| hasCookies: false, | |
| flags: {} | |
| }, | |
| httpsMap: [], | |
| cardMode: false | |
| }; | |
| var r = 0; | |
| var h = {}; | |
| var t = {}; | |
| var b = Math.floor(Math.random() * 999999999); | |
| function A() { | |
| return b | |
| } | |
| function n(L) { | |
| var N = g(L); | |
| var S = e.criteria; | |
| if (N.attr("pxz:uid")) { | |
| return | |
| } | |
| if (!L.complete && L.nodeName == "IMG") { | |
| k(L) | |
| } else { | |
| var J = N.src(), | |
| T = L.width || N.width(), | |
| R = L.height || N.height(), | |
| O = { | |
| width: T, | |
| height: R | |
| }, | |
| P, U, V = e.publisherID; | |
| if (e.share.imageUrl == J) { | |
| N.scrollIntoView() | |
| } | |
| if (t[J]) { | |
| o(N, { | |
| data: t[J], | |
| result: "success" | |
| }); | |
| delete t[J]; | |
| return | |
| } | |
| if (T < S.minWidth || R < S.minHeight || !T || !R) { | |
| return | |
| } | |
| if ((Math.min(T, R) / Math.max(T, R)) < S.minAspect) { | |
| return | |
| } | |
| if (g.inArray(T + "x" + R, S.adSizes) > -1) { | |
| return | |
| } | |
| if (!J || J.indexOf("http")) { | |
| return | |
| } | |
| O.idx = ++r; | |
| O.url = J; | |
| O.publisher_id = V; | |
| O.title = L.title || L.alt; | |
| O.v = e.version; | |
| if (N.attr("lmn8:modules")) { | |
| O.modules = N.attr("lmn8:modules") | |
| } else { | |
| O.modules = e.modules.join(",") | |
| } | |
| if (e.userID) { | |
| O.user_id = e.userID | |
| } | |
| if (e.publisher.cacheversion) { | |
| O._cv = e.publisher.cacheversion | |
| } | |
| if (!window.navigator.cookieEnabled) { | |
| O.cookies = "off" | |
| } | |
| if (e.appConfigHash) { | |
| O._ach = e.appConfigHash | |
| } | |
| window["$lmn8_metadata" + O.idx] = function(W) { | |
| o(N, W); | |
| window["$lmn8_metadata" + O.idx] = undefined | |
| }; | |
| if (S.artSel) { | |
| P = N.closest(S.artSel).html(); | |
| if (P) { | |
| if (S.artFilter && S.artFilter.test(P)) { | |
| O._ig = 1 | |
| } | |
| } else { | |
| if (S.artRequired) { | |
| O._ig = 1 | |
| } | |
| } | |
| } | |
| if (S.urlFilter && S.urlFilter instanceof Array) { | |
| for (var Q = 0, M = S.urlFilter.length; Q < M; Q++) { | |
| U = S.urlFilter[Q]; | |
| if (U.match(/^\/.*\/i$/)) { | |
| U = U.substr(1, U.length - 3) | |
| } | |
| if (document.URL.match(new RegExp(U, "i"))) { | |
| O._ig = 1; | |
| break | |
| } | |
| } | |
| } | |
| var K = e.baseurl + "/" + V + "/metadata/"; | |
| $lmn8.debug("request metadata: " + O.url); | |
| g.ajax({ | |
| url: K, | |
| data: O, | |
| dataType: "jsonp", | |
| jsonpCallback: "$lmn8_metadata" + O.idx, | |
| cache: e.cache | |
| }) | |
| } | |
| } | |
| function l(L) { | |
| var M = L.callback; | |
| var J = L.publisherID || e.publisherID; | |
| delete L.callback; | |
| L.idx = ++r; | |
| L.publisher_id = J; | |
| L.modules = e.modules.join(","); | |
| L.v = e.version; | |
| if (e.publisher.cacheversion) { | |
| L._cv = e.publisher.cacheversion | |
| } | |
| if (!window.navigator.cookieEnabled) { | |
| L.cookies = "off" | |
| } | |
| if (e.appConfigHash) { | |
| L._ach = e.appConfigHash | |
| } | |
| L.mode = "query"; | |
| window["$lmn8_metadata" + L.idx] = function(N) { | |
| o(null, N); | |
| window["$lmn8_metadata" + L.idx] = undefined; | |
| M(N.data) | |
| }; | |
| var K = e.baseurl + "/" + J + "/metadata/"; | |
| $lmn8.debug("queryImage: " + L.url); | |
| g.ajax({ | |
| url: K, | |
| data: L, | |
| dataType: "jsonp", | |
| jsonpCallback: "$lmn8_metadata" + L.idx, | |
| cache: e.cache | |
| }) | |
| } | |
| function y(J) { | |
| g.each(e.httpsMap, function(K, L) { | |
| if (!J.indexOf(L[0])) { | |
| J = J.replace(L[0], L[1]) | |
| } | |
| }); | |
| return J | |
| } | |
| function x(J) { | |
| g.each(e.httpsMap, function(K, L) { | |
| J = J.replace(L[2], L[1]) | |
| }); | |
| return J | |
| } | |
| function H(J, K) { | |
| J = y(J); | |
| if ((J in w) && w[J].loaded) { | |
| K() | |
| } else { | |
| if (J in w) { | |
| w[J].callbacks.push(K) | |
| } else { | |
| w[J] = { | |
| loaded: false, | |
| callbacks: [K] | |
| }; | |
| g.ajax({ | |
| type: "GET", | |
| url: J, | |
| dataType: "script", | |
| cache: e.cache, | |
| success: function() { | |
| $lmn8.debug("loaded " + J); | |
| w[J].loaded = true; | |
| g.each(w[J].callbacks, function(M, L) { | |
| L() | |
| }) | |
| } | |
| }) | |
| } | |
| } | |
| } | |
| function G(J, K) { | |
| f(J.slice(0), K) | |
| } | |
| function f(J, L) { | |
| if (!J || J.length === 0) { | |
| if (L) { | |
| L() | |
| } | |
| } else { | |
| var K = J.shift(); | |
| H(K, function() { | |
| f(J, L) | |
| }) | |
| } | |
| } | |
| function q(J) { | |
| n(J) | |
| } | |
| function v(K) { | |
| var O = g(K); | |
| if (!O.attr("pxz:uid")) { | |
| return | |
| } | |
| var L = luminate.options.modules, | |
| N = O.image("uid"); | |
| for (var J = 0; J < L.length; J++) { | |
| var M = L[J]; | |
| if (g.luminate[M]) { | |
| O[M]("destroy") | |
| } | |
| } | |
| O.appmgr("destroy"); | |
| O.image("destroy"); | |
| delete h[N] | |
| } | |
| function o(K, M) { | |
| var N = M.data, | |
| L = e.modules, | |
| P = e.moduleOptions, | |
| S = e.moduleConfig, | |
| J = L.length; | |
| $lmn8.debug("response metadata:", M, K && K.src()); | |
| if (M.result != "success") { | |
| return | |
| } | |
| if (!K) { | |
| t[N.image.url] = N; | |
| return | |
| } | |
| h[N.image.uid] = K; | |
| K.image(N.image); | |
| K.appmgr(); | |
| function O(U, W, T) { | |
| function V(Y, X) { | |
| J--; | |
| if (g.luminate[Y]) { | |
| if (!g.luminate[Y].config.initialized) { | |
| g.extend(true, g.luminate[Y].config, W) | |
| } | |
| K[Y](X); | |
| if ((N.image.pictID == e.share.pictID || K.image("src") == e.share.imageUrl) && Y == e.share.app) { | |
| if (K[Y]) { | |
| K[Y]("share", e.share) | |
| } | |
| } | |
| } else { | |
| $lmn8.debug("Unable to locate module: " + Y) | |
| } | |
| if (J < 1) { | |
| K.trigger("pxz.metadata.complete") | |
| } | |
| } | |
| if ("url" in W) { | |
| $lmn8.getScript(W.url, function() { | |
| V(U, T) | |
| }) | |
| } else { | |
| V(U, T) | |
| } | |
| } | |
| function Q(U) { | |
| if (N[U]) { | |
| var T = g.extend({}, P[U], N[U].metadata || {}); | |
| var V = g.extend({}, S[U]); | |
| var W = N[U].libs; | |
| if (g.isArray(W)) { | |
| $lmn8.getScripts(W, function() { | |
| O(U, V, T) | |
| }) | |
| } else { | |
| O(U, V, T) | |
| } | |
| } | |
| } | |
| for (var R = 0; R < L.length; R++) { | |
| Q(L[R]) | |
| } | |
| } | |
| function m() { | |
| var K = e.criteria, | |
| J = g(K.selector); | |
| if (typeof(K.srcFilter) == "string") { | |
| K.srcFilter = new RegExp(K.srcFilter) | |
| } | |
| if (typeof(K.artFilter) == "string") { | |
| K.artFilter = new RegExp(K.artFilter) | |
| } | |
| if (K.include) { | |
| J = J.filter(K.include) | |
| } | |
| if (K.exclude) { | |
| J = J.not(g(K.exclude)) | |
| } | |
| if (K.srcFilter) { | |
| J = J.filter(function() { | |
| return K.srcFilter.test(g(this).src()) | |
| }) | |
| } | |
| J.each(function() { | |
| n(this) | |
| }) | |
| } | |
| function E(L) { | |
| g.extend(true, e, L); | |
| g.support.svg = true; | |
| var M = false, | |
| J = parseInt(g.browser.version, 10); | |
| if (g.browser.msie) { | |
| g.support.svg = J > 9; | |
| M = (J < 8 || !g.support.boxModel) | |
| } else { | |
| if (g.browser.mozilla) { | |
| g.support.svg = J > 3 | |
| } | |
| } | |
| if (M && !e.allowOldIE) { | |
| return | |
| } | |
| if (e.pptcf) { | |
| document.cookie = "__pptcf=1"; | |
| return | |
| } | |
| if (document.cookie.indexOf("__pptcf=1") >= 0) { | |
| return | |
| } | |
| g.support.touch = false; | |
| if (document.ontouchend !== undefined) { | |
| g.support.touch = true | |
| } | |
| var K = function() { | |
| var aa; | |
| if (!g.thirdPartyFixed) { | |
| g.fixThirdParty() | |
| } | |
| $lmn8.debug(L); | |
| g.each(e.httpsMap, function(ad, ae) { | |
| ae[2] = new RegExp(ae[0], "g") | |
| }); | |
| if (e.pageSelect) { | |
| if (g(e.pageSelect).length === 0) { | |
| return | |
| } | |
| } | |
| if (e.pageExclude) { | |
| if (g(e.pageExclude).length !== 0) { | |
| return | |
| } | |
| } | |
| var S = e.baseurl.slice(0, -10) + "/share/"; | |
| var P = e.referrer; | |
| if (!document.referrer.indexOf(S)) { | |
| P = document.referrer | |
| } | |
| if (P) { | |
| e.share = { | |
| pictID: g.getUrlParam(P, "p"), | |
| x: g.getUrlParam(P, "x"), | |
| y: g.getUrlParam(P, "y"), | |
| fx: g.getUrlParam(P, "fx"), | |
| fy: g.getUrlParam(P, "fy"), | |
| source: g.getUrlParam(P, "src"), | |
| app: g.getUrlParam(P, "app", "sharing"), | |
| msg: g.getUrlParam(P, "m"), | |
| targetID: g.getUrlParam(P, "t"), | |
| imageUrl: g.getUrlParam(P, "i") | |
| }; | |
| e.cache = false | |
| } | |
| var Y = e.accentColor; | |
| var N = parseInt(Y.substr(1, 2), 16); | |
| var W = parseInt(Y.substr(3, 2), 16); | |
| var Z = parseInt(Y.substr(5, 2), 16); | |
| if (!e.contrastColor) { | |
| var ab = ((N * 299) + (W * 587) + (Z * 114)) / 1000; | |
| e.contrastColor = (ab >= 128) ? "black" : "white" | |
| } | |
| e.accentColorLow = (N >> 4).toString(16) + (W >> 4).toString(16) + (Z >> 4).toString(16); | |
| g("body").append(e.style); | |
| if (e.auxStyle) { | |
| g("body").append("<style type='text/css'>" + e.auxStyle + "</style>") | |
| } | |
| var ac = luminate.container = g(e.container).appendTo("body"); | |
| ac.attr("pxz:pub", e.publisherID); | |
| ac.offset({ | |
| top: 0, | |
| left: 0 | |
| }); | |
| ac.addClass("pxz-home-" + e.luminateHome); | |
| g.each(e.luminateHome.split("-"), function(ad, ae) { | |
| ac.addClass("pxz-home-" + ae) | |
| }); | |
| if (g.browser.msie) { | |
| ac.addClass("pxz-ie pxz-ie" + parseInt(g.browser.version, 10)) | |
| } | |
| if (e.zIndex) { | |
| ac.css({ | |
| zIndex: e.zIndex | |
| }) | |
| } | |
| if (g.support.touch) { | |
| ac.addClass("pxz-touch") | |
| } | |
| g(window).resize(function() { | |
| ac.offset({ | |
| top: 0, | |
| left: 0 | |
| }) | |
| }); | |
| if (e.transforms) { | |
| for (aa = 0; aa < e.transforms.length; aa++) { | |
| var U = e.transforms[aa], | |
| V = g(U.sel); | |
| if (U.css) { | |
| V.css(U.css) | |
| } | |
| if (U.attr) { | |
| V.attr(U.attr) | |
| } | |
| } | |
| } | |
| if (typeof luminateReady != "undefined") { | |
| luminateReady() | |
| } | |
| m(); | |
| if (e.watchID) { | |
| var X = g(e.watchID); | |
| X.watch({ | |
| style: "background-image", | |
| attr: "src", | |
| func: function() { | |
| v(this); | |
| q(this) | |
| } | |
| }) | |
| } | |
| if (e.watchContainerID) { | |
| var O = g(e.watchContainerID), | |
| R = e.criteria.selector, | |
| Q = g(R, O), | |
| T = 0; | |
| if (O.length) { | |
| window.setInterval(function() { | |
| if (T) { | |
| T--; | |
| return | |
| } | |
| var af = g(R, O); | |
| if (e.criteria.exclude) { | |
| af = af.not(e.criteria.exclude) | |
| } | |
| var ad = Q.not(af), | |
| ae = af.not(Q); | |
| ad.each(function() { | |
| v(this); | |
| T = 4 | |
| }); | |
| ae.each(function() { | |
| q(this); | |
| T = 4 | |
| }); | |
| Q = af | |
| }, 250) | |
| } | |
| } | |
| }; | |
| if (document.readyState == "loading") { | |
| g(K) | |
| } else { | |
| K() | |
| } | |
| } | |
| function s() { | |
| if (e.debug && typeof(console) != "undefined") { | |
| if ("debug" in console) { | |
| console.debug.apply(console, arguments) | |
| } else { | |
| if ("log" in console) { | |
| var K = []; | |
| for (var J = 0; J < arguments.length; J++) { | |
| if (typeof JSON != "undefined") { | |
| K.push(JSON.stringify(arguments[J])) | |
| } else { | |
| K.push(arguments[J]) | |
| } | |
| } | |
| console.log(K.join(" ")) | |
| } | |
| } | |
| } | |
| } | |
| function D(J, K) { | |
| K = g.extend({}, K, { | |
| mid: J.image("mid"), | |
| pg: b, | |
| v: e.version | |
| }); | |
| if (e.configID) { | |
| K.config_id = e.configID | |
| } | |
| if (e.userID) { | |
| K.user_id = e.userID | |
| } | |
| return K | |
| } | |
| function i(J) { | |
| return J.image("option", "publisherID") || e.publisherID | |
| } | |
| function I(N, K, J, P, O, M) { | |
| var L = N.image("uid"); | |
| O = D(N, g.extend({ | |
| component: K, | |
| data: J | |
| }, O)); | |
| if (N.image("option", "galleryPictID")) { | |
| O.gpid = N.image("option", "galleryPictID") | |
| } | |
| $lmn8.debug(L + ": " + K, "data request", J, O); | |
| g.ajax({ | |
| url: [e.baseurl, i(N), "data", L, K, J, ""].join("/"), | |
| data: O, | |
| dataType: "jsonp", | |
| cache: e.cache, | |
| success: function(Q) { | |
| $lmn8.debug(L + ": " + K, "data success", Q); | |
| if (Q.result == "success") { | |
| P(Q.data) | |
| } else { | |
| if (M) { | |
| M(Q) | |
| } | |
| } | |
| }, | |
| error: function(Q, S, R) { | |
| $lmn8.debug(L + ": " + K, "data failed", S); | |
| if (M) { | |
| M({ | |
| result: "failed", | |
| reason: S, | |
| errorThrown: R | |
| }) | |
| } | |
| } | |
| }) | |
| } | |
| function j(N, K, J, M, O) { | |
| var L = N.image("uid"); | |
| O = D(N, g.extend({ | |
| val: M | |
| }, O)); | |
| $lmn8.debug(L + ": " + K + ".setf(" + J + "=" + M + ")"); | |
| g.ajax({ | |
| url: [e.baseurl, i(N), "setf", L, K, J, ""].join("/"), | |
| data: O, | |
| dataType: "jsonp", | |
| success: function(P) { | |
| if (P.result == "success") { | |
| e.user.flags[J] = M | |
| } | |
| } | |
| }) | |
| } | |
| function p(M, K, J, O) { | |
| var L = M.image("uid"), | |
| N = D(M, {}); | |
| $lmn8.debug(L + ": " + K + ".getf(" + J + ")"); | |
| g.ajax({ | |
| url: [e.baseurl, i(M), "getf", L, K, J, ""].join("/"), | |
| data: N, | |
| dataType: "jsonp", | |
| success: function(P) { | |
| if (P.result == "success") { | |
| O(P.data) | |
| } | |
| } | |
| }) | |
| } | |
| function F(N, L, K, O) { | |
| var M = N.image("uid"), | |
| J; | |
| O = D(N, g.extend({}, O)); | |
| J = [e.baseurl, i(N), "event", M, L, K, ""].join("/"); | |
| return J + "?" + g.param(O) | |
| } | |
| function B(M, K, J, N) { | |
| var L = M.image("uid"); | |
| $lmn8.debug(L, "Event:", K + "." + J); | |
| g.ajax({ | |
| url: F(M, K, J, N), | |
| dataType: "jsonp" | |
| }) | |
| } | |
| var u = /^url\(['"]?(https?:\/\/[^'"]+)['"]?\)$/; | |
| g.fn.extend({ | |
| src: function() { | |
| var J, K; | |
| if (this[0].src && this.attr("src")) { | |
| J = this[0].src | |
| } else { | |
| if (this.css("background-image") != "none") { | |
| K = this.css("background-image").match(u); | |
| if (K && K.length == 2) { | |
| J = K[1] | |
| } | |
| } | |
| } | |
| return J | |
| } | |
| }); | |
| var c = {}; | |
| function z(L, K, M, J) { | |
| if (L) { | |
| L = g.event.fix(L); | |
| L.stopPropagation() | |
| } | |
| if (!c[K]) { | |
| c[K] = window.setTimeout(function() { | |
| delete c[K] | |
| }, 5000); | |
| switch (arguments.length - 1) { | |
| case 1: | |
| window.open(K); | |
| break; | |
| case 2: | |
| window.open(K, M); | |
| break; | |
| default: | |
| window.open(K, M, J); | |
| break | |
| } | |
| } | |
| return false | |
| } | |
| g.extend(luminate, { | |
| init: E, | |
| options: e, | |
| pictures: h, | |
| addImage: q, | |
| removeImage: v, | |
| queryImage: l, | |
| scanImages: m, | |
| data: I, | |
| event: B, | |
| click: z, | |
| setf: j, | |
| getf: p, | |
| eventUrl: F, | |
| secureUrl: y, | |
| secureBlob: x, | |
| page_salt: A, | |
| debug: s, | |
| getScript: H, | |
| getScripts: G, | |
| jQuery: g | |
| }) | |
| })(jQuery); | |
| (function(e) { | |
| var i = 0; | |
| e.extend(e.Widget.prototype, { | |
| evaluate: function a(q, p) { | |
| var o = this, | |
| n; | |
| n = q.replace(/\$\{\s*([^\}]+)\s*\}/g, function(u, x) { | |
| var w = e.trim(x); | |
| var v, z = w.split("."); | |
| var t, r; | |
| try { | |
| for (t = 0; t < z.length; t++) { | |
| v = z[t]; | |
| if (t > 0) { | |
| r = r[v] | |
| } else { | |
| if (v === "context") { | |
| r = p | |
| } else { | |
| if (v === "self") { | |
| r = o | |
| } else { | |
| if (p && v in p) { | |
| r = p[v] | |
| } else { | |
| r = window[v] | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } catch (y) { | |
| r = undefined | |
| } | |
| if (r === undefined) { | |
| o.debug("Unresolved expression " + w); | |
| r = "" | |
| } | |
| return r.toString() | |
| }); | |
| return $lmn8.secureBlob(n) | |
| }, | |
| uniqid: function k(o) { | |
| var p = {}, | |
| q = i++; | |
| var n = o.replace(/id\s*=\s*"([^"]+)"/gi, function(r, t) { | |
| p[t] = true; | |
| return 'id="pxz_svg_' + q + "_" + t + '"' | |
| }); | |
| e.each(p, function(u) { | |
| var t = new RegExp("#" + u, "g"), | |
| r = ""; | |
| if (document.location != document.baseURI) { | |
| r = document.location.href.split("#")[0] | |
| } | |
| n = n.replace(t, r + "#pxz_svg_" + q + "_" + u) | |
| }); | |
| return n | |
| }, | |
| addStyle: function c(p, o) { | |
| var q, n, r; | |
| if (!p.indexOf("<style")) { | |
| p = p.replace(/<\/?style[^>]*>/gi, "") | |
| } | |
| o = o || e("#pxzstyle"); | |
| r = o.attr("id"); | |
| if (e.browser.msie) { | |
| n = o.html(); | |
| p = n + p; | |
| q = e("<style type='text/css'>" + p + "</style>"); | |
| if (r) { | |
| q.attr("id", r) | |
| } | |
| o.replaceWith(q) | |
| } else { | |
| o.append(p) | |
| } | |
| }, | |
| debug: function g() { | |
| var n = this, | |
| o = Array.prototype.slice.call(arguments); | |
| o.unshift(n.widgetName + ":"); | |
| if (n.uid) { | |
| o.unshift(n.uid) | |
| } | |
| $lmn8.debug.apply($lmn8, o) | |
| } | |
| }); | |
| e.fn.extend({ | |
| bounds: function() { | |
| var n = this, | |
| o = n.offset(); | |
| return { | |
| left: o.left, | |
| right: o.left + n.width(), | |
| top: o.top, | |
| bottom: o.top + n.height() | |
| } | |
| }, | |
| box: function(p) { | |
| var n = {}, | |
| o = ["top", "right", "bottom", "left"]; | |
| for (var q = 0; q < o.length; ++q) { | |
| n[o[q]] = parseFloat(this.css(p + "-" + o[q])) | |
| } | |
| return n | |
| }, | |
| padding: function() { | |
| return this.box("padding") | |
| }, | |
| border: function() { | |
| var n = {}, | |
| o = ["top", "right", "bottom", "left"], | |
| q = function(r) { | |
| return (/^\d+/.test(r)) ? parseFloat(r) : 0 | |
| }; | |
| for (var p = 0; p < o.length; ++p) { | |
| n[o[p]] = q(this.css("border-" + o[p] + "-width")) | |
| } | |
| return n | |
| }, | |
| margin: function() { | |
| return this.box("margin") | |
| }, | |
| size: function() { | |
| return { | |
| width: this.width(), | |
| height: this.height() | |
| } | |
| }, | |
| containsRect: function(p) { | |
| var n = this, | |
| o = n.bounds(); | |
| return (p.left >= o.left && p.top >= o.top && p.right <= o.right && p.bottom <= o.bottom) | |
| }, | |
| contains: function(n, q) { | |
| var o = this, | |
| p = o.bounds(); | |
| return (n >= p.left && q >= p.top && n <= p.right && q <= p.bottom) | |
| }, | |
| scrollIntoView: function b() { | |
| var p = this, | |
| o = e(window), | |
| u = p.offset(), | |
| q = p.size(), | |
| t = o.scrollTop(), | |
| s = o.scrollLeft(), | |
| n = o.height(), | |
| r = o.width(); | |
| if (u.top < t) { | |
| t = u.top - 10 | |
| } | |
| if (u.left < s) { | |
| s = u.left - 10 | |
| } | |
| if ((u.top + q.height) > (t + n)) { | |
| t = u.top - 10 | |
| } | |
| if ((u.left + q.width) > (s + r)) { | |
| s = u.left - 10 | |
| } | |
| window.scrollTo(s, t) | |
| } | |
| }); | |
| var l = /^&(#x[\da-f]+|#\d+|[a-z]+);/i; | |
| var d = /\s/; | |
| e.extend(e, { | |
| thirdPartyFixed: false, | |
| fixThirdParty: function h() { | |
| var n = this; | |
| if (!n.thirdPartyFixed) { | |
| if (window.Prototype && window.Prototype.Version.substr(0, 3) == "1.4") { | |
| e.support.svg = false; | |
| Object.extend(Array.prototype, { | |
| shift: function() { | |
| var o; | |
| if (this.length) { | |
| o = this[0]; | |
| for (var p = 0; p < this.length - 1; p++) { | |
| this[p] = this[p + 1] | |
| } | |
| this.length-- | |
| } | |
| return o | |
| } | |
| }) | |
| } | |
| if (window.MooTools && !window.MooTools.build) { | |
| e.support.svg = false | |
| } | |
| n.thirdPartyFixed = true | |
| } | |
| }, | |
| absolutify: function(q, r) { | |
| function o(u) { | |
| if (!u) { | |
| u = "" | |
| } | |
| var v = /^(?:([^:\/?\#]+):)?(?:\/\/([^\/?\#]*))?([^?\#]*)(?:\?([^\#]*))?(?:\#(.*))?/; | |
| var t = u.match(v); | |
| this.scheme = t[1] || null; | |
| this.authority = t[2] || null; | |
| this.path = t[3] || null; | |
| this.query = t[4] || null; | |
| this.fragment = t[5] || null | |
| } | |
| o.prototype.toString = function() { | |
| var t = ""; | |
| if (this.scheme) { | |
| t += this.scheme + ":" | |
| } | |
| if (this.authority) { | |
| t += "//" + this.authority | |
| } | |
| if (this.path) { | |
| t += this.path | |
| } | |
| if (this.query) { | |
| t += "?" + this.query | |
| } | |
| if (this.fragment) { | |
| t += "#" + this.fragment | |
| } | |
| return t | |
| }; | |
| function s(t, v) { | |
| var u = /^(.*)\//; | |
| if (t.authority && !t.path) { | |
| return "/" + v | |
| } else { | |
| return t.path.match(u)[0] + v | |
| } | |
| } | |
| var p = /\/((?!\.\.\/)[^\/]*)\/\.\.\//; | |
| function n(t) { | |
| if (!t) { | |
| return "" | |
| } | |
| var u = t.replace(/\/\.\//g, "/"); | |
| u = u.replace(/\/\.$/, "/"); | |
| while (u.match(p)) { | |
| u = u.replace(p, "/") | |
| } | |
| u = u.replace(/\/([^\/]*)\/\.\.$/, "/"); | |
| while (u.match(/\/\.\.\//)) { | |
| u = u.replace(/\/\.\.\//, "/") | |
| } | |
| return u | |
| } | |
| o.prototype.resolve = function(t) { | |
| var u = new o(); | |
| if (this.scheme) { | |
| u.scheme = this.scheme; | |
| u.authority = this.authority; | |
| u.path = n(this.path); | |
| u.query = this.query | |
| } else { | |
| if (this.authority) { | |
| u.authority = this.authority; | |
| u.path = n(this.path); | |
| u.query = this.query | |
| } else { | |
| if (!this.path) { | |
| u.path = t.path; | |
| if (this.query) { | |
| u.query = this.query | |
| } else { | |
| u.query = t.query | |
| } | |
| } else { | |
| if (this.path.charAt(0) === "/") { | |
| u.path = n(this.path) | |
| } else { | |
| u.path = s(t, this.path); | |
| u.path = n(u.path) | |
| } | |
| u.query = this.query | |
| } | |
| u.authority = t.authority | |
| } | |
| u.scheme = t.scheme | |
| } | |
| u.fragment = this.fragment; | |
| return u.toString() | |
| }; | |
| return (new o(r)).resolve(new o(q)) | |
| }, | |
| safer: function(n) { | |
| if (typeof(n) === "undefined" || n === null) { | |
| return "" | |
| } | |
| return ("" + n).replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """) | |
| }, | |
| truncateWordsBeforeLen: function(q, r) { | |
| var p, o; | |
| if (!q) { | |
| return "" | |
| } | |
| if (r < 0 || q.length <= r) { | |
| return q | |
| } | |
| p = 0; | |
| while (p < r) { | |
| o = l.test(q.substr(p)); | |
| if (o) { | |
| r += o.length - 1; | |
| p += o.length | |
| } else { | |
| p++ | |
| } | |
| } | |
| if (q.length <= r) { | |
| return q | |
| } | |
| while (p > 0 && !d.test(q[p])) { | |
| p-- | |
| } | |
| return q.substr(0, p > 0 ? p : r) + "..." | |
| }, | |
| getUrlParam: function f(o, n, r) { | |
| n = n.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]"); | |
| var q = new RegExp("[\\?&]?" + n + "=([^&#]*)"); | |
| var p = q.exec(o); | |
| if (p === null) { | |
| return r || "" | |
| } else { | |
| return decodeURIComponent(p[1]) | |
| } | |
| }, | |
| keys: function m(n) { | |
| return e.map(n, function(o, p) { | |
| return p | |
| }) | |
| }, | |
| items: function j(n) { | |
| return e.map(n, function(o, p) { | |
| return [p, o] | |
| }) | |
| } | |
| }) | |
| })(jQuery); | |
| (function(f) { | |
| f.widget("luminate.window", { | |
| options: { | |
| owner: null, | |
| anchor: "#pxzcont", | |
| closebox: false, | |
| pinbox: false, | |
| position: { | |
| my: "center", | |
| at: "center", | |
| of: "body" | |
| } | |
| }, | |
| _create: function e() { | |
| var h = this, | |
| l = h.element, | |
| j = h.options, | |
| i = f.luminate.window.config; | |
| if (!f.luminate.window.initialized) { | |
| f.luminate.window.initialized = true; | |
| h.addStyle(h.evaluate(i.style)); | |
| if (i.auxStyle) { | |
| h.addStyle(h.evaluate(i.auxStyle)) | |
| } | |
| } | |
| var k = (h.evaluate(i.windowHtml)); | |
| h._window = f(k).appendTo(j.anchor).hide(); | |
| h._window.append(l); | |
| l.bind("remove", function(m) { | |
| l.unbind(m); | |
| h._window.remove() | |
| }); | |
| if (j.owner) { | |
| j.owner.element.bind("pxz.image.resized", function() { | |
| h.position() | |
| }) | |
| } | |
| if (!f.support.touch) { | |
| h._window.hover(function() { | |
| l.trigger("pxz.window.over") | |
| }, function() { | |
| l.trigger("pxz.window.out") | |
| }) | |
| } | |
| h.closebox(j.closebox); | |
| h.pinbox(j.pinbox) | |
| }, | |
| closebox: function b(k) { | |
| var h = this, | |
| j = f.luminate.window.config, | |
| i = h.options; | |
| if (k) { | |
| if (!h._closebox) { | |
| h._closebox = f(".pxz-closebox", h._window); | |
| h._closebox.icon({ | |
| type: "closebox", | |
| svg: h.evaluate(j.closeSvg), | |
| pngUrl: j.closePng, | |
| hsXratio: 0.5, | |
| hsYratio: 0.5, | |
| owner: i.owner | |
| }) | |
| } | |
| h._closebox.bind("click", k); | |
| h._closebox.show() | |
| } else { | |
| if (h._closebox) { | |
| h._closebox.unbind("click"); | |
| h._closebox.hide() | |
| } | |
| } | |
| }, | |
| pinbox: function a(i) { | |
| var h = this, | |
| k = f.luminate.window.config, | |
| j = h.options; | |
| if (i) { | |
| if (!h._pinbox) { | |
| h._pinbox = f(".pxz-pinbox", h._window); | |
| h._pinbox.icon({ | |
| type: "pinbox", | |
| svg: h.evaluate(k.pinSvg), | |
| pngUrl: k.pinPng, | |
| hsXratio: 0.5, | |
| hsYratio: 0.5, | |
| owner: j.owner | |
| }) | |
| } | |
| h._pinbox.bind("click", i); | |
| h._pinbox.show() | |
| } else { | |
| if (h._pinbox) { | |
| h._pinbox.unbind("click"); | |
| h._pinbox.hide() | |
| } | |
| } | |
| }, | |
| position: function g(i) { | |
| var j = this, | |
| k = j.options, | |
| h = {}; | |
| if (i) { | |
| k.position = i | |
| } | |
| if (k.owner && $lmn8.options.cardMode) { | |
| h = { | |
| within: k.owner.element, | |
| collision: "flipfit" | |
| } | |
| } | |
| j._window.position(f.extend(h, k.position)) | |
| }, | |
| show: function c(j) { | |
| var h = this, | |
| i = h.options; | |
| if (j) { | |
| h._window.fadeIn(j) | |
| } else { | |
| h._window.show() | |
| } | |
| h._window.position(i.position) | |
| }, | |
| hide: function d(i) { | |
| var h = this; | |
| if (i) { | |
| h._window.fadeOut(i) | |
| } else { | |
| h._window.hide() | |
| } | |
| } | |
| }); | |
| f.extend(f.luminate.window, { | |
| initialized: false, | |
| config: { | |
| style: "#pxzcont .pxz-window{position:absolute;padding:10px;color:#505050;background-color:white;border-radius:10px;border:1px solid #EDEBEB;box-shadow:2px 2px 2px rgba(0,0,0,0.48);font-size:12px}#pxzcont .pxz-window .pxz-closebox,#pxzcont .pxz-window .pxz-pinbox{position:absolute;right:-15px;top:-15px;z-index:2;display:block}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-small,#pxzcont .pxz-closebox .pxz-icon-icon.pxz-small .pxz-icon-svg svg,#pxzcont .pxz-closebox .pxz-icon-icon.pxz-small .pxz-icon-png img,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-small,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-small .pxz-icon-svg svg,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-small .pxz-icon-png img{width:20px;height:20px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-small,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-small{top:5px;right:5px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-medium,#pxzcont .pxz-closebox .pxz-icon-icon.pxz-medium .pxz-icon-svg svg,#pxzcont .pxz-closebox .pxz-icon-icon.pxz-medium .pxz-icon-png img,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-medium,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-medium .pxz-icon-svg svg,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-medium .pxz-icon-png img{width:25px;height:25px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-medium,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-medium{top:3px;right:3px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-large,#pxzcont .pxz-closebox .pxz-icon-icon.pxz-large .pxz-icon-svg svg,#pxzcont .pxz-closebox .pxz-icon-icon.pxz-large .pxz-icon-png img,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-large,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-large .pxz-icon-svg svg,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-large .pxz-icon-png img{width:30px;height:30px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-large,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-large{top:0;right:0}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-small .pxz-icon-alt-highlight img,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-small .pxz-icon-alt-highlight img{top:-3px;left:-3px;width:27px;height:27px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-medium .pxz-icon-alt-highlight img,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-medium .pxz-icon-alt-highlight img{top:-4px;left:-4px;width:33px;height:33px}#pxzcont .pxz-closebox .pxz-icon-icon.pxz-large .pxz-icon-alt-highlight img,#pxzcont .pxz-pinbox .pxz-icon-icon.pxz-large .pxz-icon-alt-highlight img{top:-5px;left:-5px;width:40px;height:40px}#pxzcont .pxz-window .pxz-window-title{color:#333;font-weight:bold;font-size:14px;line-height:18px}#pxzcont.pxz-ie7 .pxz-window .pxz-closebox,#pxzcont.pxz-ie7 .pxz-window .pxz-pinbox{position:absolute;z-index:1;display:block}#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-small,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-small .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-small,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-small .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-medium,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-medium .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-medium,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-medium .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-large,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-large .pxz-icon-png img,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-large,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-large .pxz-icon-png img{width:30px;height:30px}#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-small,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-small,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-medium,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-medium,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-large,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-large{top:0;right:30px}#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-small .pxz-icon-alt-highlight img,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-small .pxz-icon-alt-highlight img,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-medium .pxz-icon-alt-highlight img,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-medium .pxz-icon-alt-highlight img,#pxzcont.pxz-ie7 .pxz-closebox .pxz-icon-icon.pxz-large .pxz-icon-alt-highlight img,#pxzcont.pxz-ie7 .pxz-pinbox .pxz-icon-icon.pxz-large .pxz-icon-alt-highlight img{top:-5px;left:-5px;width:40px;height:40px}", | |
| auxStyle: null, | |
| windowHtml: '<div class="pxz-window"> <div class="pxz-closebox" /> <div class="pxz-pinbox" /> </div> ', | |
| closeSvg: '<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 30 30" enable-background="new 0 0 30 30" xml:space="preserve"> <g> <g> <path class="highlight-fill" d="M15,26.777C8.506,26.777,3.222,21.494,3.222,15S8.506,3.221,15,3.221c6.496,0,11.777,5.285,11.777,11.779 S21.496,26.777,15,26.777z"/> </g> <path fill="#FFFFFF" d="M15,3.942c6.107,0,11.061,4.953,11.061,11.058S21.107,26.059,15,26.059S3.942,21.105,3.942,15 S8.893,3.942,15,3.942 M15,2.5C8.105,2.5,2.5,8.105,2.5,15c0,6.891,5.605,12.5,12.5,12.5c6.891,0,12.5-5.609,12.5-12.5 C27.5,8.105,21.891,2.5,15,2.5L15,2.5z"/> <path fill="#FFFFFF" d="M16.443,15l3.684-3.682c0.395-0.396,0.395-1.045,0-1.444c-0.396-0.396-1.046-0.396-1.443,0L15,13.557 l-3.682-3.683c-0.396-0.396-1.043-0.396-1.442,0c-0.397,0.399-0.397,1.048,0,1.444L13.557,15l-3.683,3.684 c-0.399,0.396-0.399,1.047,0,1.443c0.196,0.195,0.46,0.296,0.72,0.296c0.264,0,0.523-0.101,0.723-0.296L15,16.443l3.684,3.684 c0.196,0.195,0.461,0.296,0.719,0.296c0.265,0,0.525-0.101,0.727-0.296c0.396-0.396,0.396-1.048,0-1.443L16.443,15z"/> </g> </svg> ', | |
| closePng: "http://assets.luminate.com/4.0/icon/png/closebox_clear.30.png", | |
| pinSvg: '<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 30 30" enable-background="new 0 0 30 30" xml:space="preserve"> <g> <g> <path class="highlight-fill" fill="#333333" d="M15,26.777C8.506,26.777,3.222,21.494,3.222,15S8.506,3.221,15,3.221c6.496,0,11.777,5.285,11.777,11.779 S21.496,26.777,15,26.777z"/> </g> <path id="Ring" fill="#FFFFFF" d="M15,3.942c6.107,0,11.061,4.953,11.061,11.058S21.107,26.059,15,26.059S3.942,21.105,3.942,15 S8.893,3.942,15,3.942 M15,2.5C8.105,2.5,2.5,8.105,2.5,15c0,6.891,5.605,12.5,12.5,12.5c6.891,0,12.5-5.609,12.5-12.5 C27.5,8.105,21.891,2.5,15,2.5L15,2.5z"/> <g id="Tack"> <rect x="13.842" y="9.634" transform="matrix(-0.7072 -0.707 0.707 -0.7072 18.1247 34.8771)" fill="#FFFFFF" width="4.884" height="8.103"/> <rect x="14.252" y="10.603" transform="matrix(-0.7071 -0.7071 0.7071 -0.7071 23.7788 32.5341)" fill="#FFFFFF" width="8.75" height="1.479"/> <polygon fill="#FFFFFF" points="10.128,18.688 9.241,20.708 11.279,19.837 18.014,13.104 16.863,11.952 "/> <rect x="9.528" y="15.324" transform="matrix(-0.7072 -0.707 0.707 -0.7072 12.3784 37.2531)" fill="#FFFFFF" width="8.749" height="1.48"/> </g> </g> </svg> ', | |
| pinPng: "http://assets.luminate.com/4.0/icon/png/pinbox_clear.30.png" | |
| } | |
| }) | |
| })(jQuery); | |
| jQuery.noConflict(true); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment