5588 lines
243 KiB
JavaScript
5588 lines
243 KiB
JavaScript
(function anonymous__0(window, undefined) {
|
||
var document = window.document, navigator = window.navigator, location = window.location;
|
||
var jQuery = function anonymous__1() {
|
||
var jQuery = function anonymous__2(selector, context) {
|
||
return new jQuery.fn.init(selector, context, rootjQuery);
|
||
}, _jQuery = window.jQuery, _$ = window.$, rootjQuery, quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, rnotwhite = /\S/, trimLeft = /^\s+/, trimRight = /\s+$/, rdigit = /\d/, rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/, rvalidchars = /^[\],:{}\s]*$/, rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, rwebkit = /(webkit)[ \/]([\w.]+)/, ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/, rmsie = /(msie) ([\w.]+)/, rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/, userAgent = navigator.userAgent, browserMatch, readyList, DOMContentLoaded, toString = Object.prototype.toString, hasOwn = Object.prototype.hasOwnProperty, push = Array.prototype.push, slice = Array.prototype.slice, trim = String.prototype.trim, indexOf = Array.prototype.indexOf, class2type = {};
|
||
jQuery.fn = jQuery.prototype = {
|
||
constructor: jQuery,
|
||
init: function anonymous__3(selector, context, rootjQuery) {
|
||
var match, elem, ret, doc;
|
||
if (!selector) {
|
||
return this;
|
||
}
|
||
if (selector.nodeType) {
|
||
this.context = this[0] = selector;
|
||
this.length = 1;
|
||
return this;
|
||
}
|
||
if (selector === "body" && !context && document.body) {
|
||
this.context = document;
|
||
this[0] = document.body;
|
||
this.selector = selector;
|
||
this.length = 1;
|
||
return this;
|
||
}
|
||
if (typeof selector === "string") {
|
||
if (selector.charAt(0) === "<" && selector.charAt(selector.length - 1) === ">" && selector.length >= 3) {
|
||
match = [ null, selector, null ];
|
||
} else {
|
||
match = quickExpr.exec(selector);
|
||
}
|
||
if (match && (match[1] || !context)) {
|
||
if (match[1]) {
|
||
context = context instanceof jQuery ? context[0] : context;
|
||
doc = context ? context.ownerDocument || context : document;
|
||
ret = rsingleTag.exec(selector);
|
||
if (ret) {
|
||
if (jQuery.isPlainObject(context)) {
|
||
selector = [ document.createElement(ret[1]) ];
|
||
jQuery.fn.attr.call(selector, context, true);
|
||
} else {
|
||
selector = [ doc.createElement(ret[1]) ];
|
||
}
|
||
} else {
|
||
ret = jQuery.buildFragment([ match[1] ], [ doc ]);
|
||
selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
|
||
}
|
||
return jQuery.merge(this, selector);
|
||
} else {
|
||
elem = document.getElementById(match[2]);
|
||
if (elem && elem.parentNode) {
|
||
if (elem.id !== match[2]) {
|
||
return rootjQuery.find(selector);
|
||
}
|
||
this.length = 1;
|
||
this[0] = elem;
|
||
}
|
||
this.context = document;
|
||
this.selector = selector;
|
||
return this;
|
||
}
|
||
} else if (!context || context.jquery) {
|
||
return (context || rootjQuery).find(selector);
|
||
} else {
|
||
return this.constructor(context).find(selector);
|
||
}
|
||
} else if (jQuery.isFunction(selector)) {
|
||
return rootjQuery.ready(selector);
|
||
}
|
||
if (selector.selector !== undefined) {
|
||
this.selector = selector.selector;
|
||
this.context = selector.context;
|
||
}
|
||
return jQuery.makeArray(selector, this);
|
||
},
|
||
selector: "",
|
||
jquery: "1.6.1",
|
||
length: 0,
|
||
size: function anonymous__4() {
|
||
return this.length;
|
||
},
|
||
toArray: function anonymous__5() {
|
||
return slice.call(this, 0);
|
||
},
|
||
get: function anonymous__6(num) {
|
||
return num == null ? this.toArray() : num < 0 ? this[this.length + num] : this[num];
|
||
},
|
||
pushStack: function anonymous__7(elems, name, selector) {
|
||
var ret = this.constructor();
|
||
if (jQuery.isArray(elems)) {
|
||
push.apply(ret, elems);
|
||
} else {
|
||
jQuery.merge(ret, elems);
|
||
}
|
||
ret.prevObject = this;
|
||
ret.context = this.context;
|
||
if (name === "find") {
|
||
ret.selector = this.selector + (this.selector ? " " : "") + selector;
|
||
} else if (name) {
|
||
ret.selector = this.selector + "." + name + "(" + selector + ")";
|
||
}
|
||
return ret;
|
||
},
|
||
each: function anonymous__8(callback, args) {
|
||
return jQuery.each(this, callback, args);
|
||
},
|
||
ready: function anonymous__9(fn) {
|
||
jQuery.bindReady();
|
||
readyList.done(fn);
|
||
return this;
|
||
},
|
||
eq: function anonymous__10(i) {
|
||
return i === -1 ? this.slice(i) : this.slice(i, +i + 1);
|
||
},
|
||
first: function anonymous__11() {
|
||
return this.eq(0);
|
||
},
|
||
last: function anonymous__12() {
|
||
return this.eq(-1);
|
||
},
|
||
slice: function anonymous__13() {
|
||
return this.pushStack(slice.apply(this, arguments), "slice", slice.call(arguments).join(","));
|
||
},
|
||
map: function anonymous__14(callback) {
|
||
return this.pushStack(jQuery.map(this, function anonymous__15(elem, i) {
|
||
return callback.call(elem, i, elem);
|
||
}));
|
||
},
|
||
end: function anonymous__16() {
|
||
return this.prevObject || this.constructor(null);
|
||
},
|
||
push: push,
|
||
sort: [].sort,
|
||
splice: [].splice
|
||
};
|
||
jQuery.fn.init.prototype = jQuery.fn;
|
||
jQuery.extend = jQuery.fn.extend = function anonymous__17() {
|
||
var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false;
|
||
if (typeof target === "boolean") {
|
||
deep = target;
|
||
target = arguments[1] || {};
|
||
i = 2;
|
||
}
|
||
if (typeof target !== "object" && !jQuery.isFunction(target)) {
|
||
target = {};
|
||
}
|
||
if (length === i) {
|
||
target = this;
|
||
--i;
|
||
}
|
||
for (; i < length; i++) {
|
||
if ((options = arguments[i]) != null) {
|
||
for (name in options) {
|
||
(function _forin_body_extra_1(name) { var src = target[name];
|
||
var copy = options[name];
|
||
if (target === copy) {
|
||
return; //continue;
|
||
}
|
||
if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
|
||
if (copyIsArray) {
|
||
copyIsArray = false;
|
||
clone = src && jQuery.isArray(src) ? src : [];
|
||
} else {
|
||
clone = src && jQuery.isPlainObject(src) ? src : {};
|
||
}
|
||
target[name] = jQuery.extend(deep, clone, copy);
|
||
} else if (copy !== undefined) {
|
||
target[name] = copy;
|
||
} })(name);
|
||
}
|
||
}
|
||
}
|
||
return target;
|
||
};
|
||
jQuery.extend({
|
||
noConflict: function anonymous__18(deep) {
|
||
if (window.$ === jQuery) {
|
||
window.$ = _$;
|
||
}
|
||
if (deep && window.jQuery === jQuery) {
|
||
window.jQuery = _jQuery;
|
||
}
|
||
return jQuery;
|
||
},
|
||
isReady: false,
|
||
readyWait: 1,
|
||
holdReady: function anonymous__19(hold) {
|
||
if (hold) {
|
||
jQuery.readyWait++;
|
||
} else {
|
||
jQuery.ready(true);
|
||
}
|
||
},
|
||
ready: function anonymous__20(wait) {
|
||
if (wait === true && !--jQuery.readyWait || wait !== true && !jQuery.isReady) {
|
||
if (!document.body) {
|
||
return setTimeout(jQuery.ready, 1);
|
||
}
|
||
jQuery.isReady = true;
|
||
if (wait !== true && --jQuery.readyWait > 0) {
|
||
return;
|
||
}
|
||
readyList.resolveWith(document, [ jQuery ]);
|
||
if (jQuery.fn.trigger) {
|
||
jQuery(document).trigger("ready").unbind("ready");
|
||
}
|
||
}
|
||
},
|
||
bindReady: function anonymous__21() {
|
||
if (readyList) {
|
||
return;
|
||
}
|
||
readyList = jQuery._Deferred();
|
||
if (document.readyState === "complete") {
|
||
return setTimeout(jQuery.ready, 1);
|
||
}
|
||
if (document.addEventListener) {
|
||
document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
|
||
window.addEventListener("load", jQuery.ready, false);
|
||
} else if (document.attachEvent) {
|
||
document.attachEvent("onreadystatechange", DOMContentLoaded);
|
||
window.attachEvent("onload", jQuery.ready);
|
||
var toplevel = false;
|
||
try {
|
||
toplevel = window.frameElement == null;
|
||
} catch (e) {}
|
||
if (document.documentElement.doScroll && toplevel) {
|
||
doScrollCheck();
|
||
}
|
||
}
|
||
},
|
||
isFunction: function anonymous__22(obj) {
|
||
return jQuery.type(obj) === "function";
|
||
},
|
||
isArray: Array.isArray || function anonymous__23(obj) {
|
||
return jQuery.type(obj) === "array";
|
||
},
|
||
isWindow: function anonymous__24(obj) {
|
||
return obj && typeof obj === "object" && "setInterval" in obj;
|
||
},
|
||
isNaN: function anonymous__25(obj) {
|
||
return obj == null || !rdigit.test(obj) || isNaN(obj);
|
||
},
|
||
type: function anonymous__26(obj) {
|
||
return obj == null ? String(obj) : class2type[toString.call(obj)] || "object";
|
||
},
|
||
isPlainObject: function anonymous__27(obj) {
|
||
if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
|
||
return false;
|
||
}
|
||
if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
|
||
return false;
|
||
}
|
||
var key;
|
||
for (key in obj) {}
|
||
return key === undefined || hasOwn.call(obj, key);
|
||
},
|
||
isEmptyObject: function anonymous__28(obj) {
|
||
for (var name in obj) {
|
||
return false;
|
||
}
|
||
return true;
|
||
},
|
||
error: function anonymous__29(msg) {
|
||
throw msg;
|
||
},
|
||
parseJSON: function anonymous__30(data) {
|
||
if (typeof data !== "string" || !data) {
|
||
return null;
|
||
}
|
||
data = jQuery.trim(data);
|
||
if (window.JSON && window.JSON.parse) {
|
||
return window.JSON.parse(data);
|
||
}
|
||
if (rvalidchars.test(data.replace(rvalidescape, "@").replace(rvalidtokens, "]").replace(rvalidbraces, ""))) {
|
||
return (new Function("return " + data))();
|
||
}
|
||
jQuery.error("Invalid JSON: " + data);
|
||
},
|
||
parseXML: function anonymous__31(data, xml, tmp) {
|
||
if (window.DOMParser) {
|
||
tmp = new DOMParser;
|
||
xml = tmp.parseFromString(data, "text/xml");
|
||
} else {
|
||
xml = new ActiveXObject("Microsoft.XMLDOM");
|
||
xml.async = "false";
|
||
xml.loadXML(data);
|
||
}
|
||
tmp = xml.documentElement;
|
||
if (!tmp || !tmp.nodeName || tmp.nodeName === "parsererror") {
|
||
jQuery.error("Invalid XML: " + data);
|
||
}
|
||
return xml;
|
||
},
|
||
noop: function anonymous__32() {},
|
||
globalEval: function anonymous__33(data) {
|
||
if (data && rnotwhite.test(data)) {
|
||
(window.execScript || function anonymous__34(data) {
|
||
window["eval"].call(window, data);
|
||
})(data);
|
||
}
|
||
},
|
||
nodeName: function anonymous__35(elem, name) {
|
||
return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
|
||
},
|
||
each: function anonymous__36(object, callback, args) {
|
||
var name, i = 0, length = object.length, isObj = length === undefined || jQuery.isFunction(object);
|
||
if (args) {
|
||
if (isObj) {
|
||
for (name in object) {
|
||
if (callback.apply(object[name], args) === false) {
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
for (; i < length; ) {
|
||
if (callback.apply(object[i++], args) === false) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if (isObj) {
|
||
for (name in object) {
|
||
if((function _forin_body_extra_2(name) { if (callback.call(object[name], name, object[name]) === false) {
|
||
return true;
|
||
} })(name)) break;
|
||
}
|
||
} else {
|
||
for (; i < length; ) {
|
||
if (callback.call(object[i], i, object[i++]) === false) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return object;
|
||
},
|
||
trim: trim ? function anonymous__37(text) {
|
||
return text == null ? "" : trim.call(text);
|
||
} : function anonymous__38(text) {
|
||
return text == null ? "" : text.toString().replace(trimLeft, "").replace(trimRight, "");
|
||
},
|
||
makeArray: function anonymous__39(array, results) {
|
||
var ret = results || [];
|
||
if (array != null) {
|
||
var type = jQuery.type(array);
|
||
if (array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow(array)) {
|
||
push.call(ret, array);
|
||
} else {
|
||
jQuery.merge(ret, array);
|
||
}
|
||
}
|
||
return ret;
|
||
},
|
||
inArray: function anonymous__40(elem, array) {
|
||
if (indexOf) {
|
||
return indexOf.call(array, elem);
|
||
}
|
||
for (var i = 0, length = array.length; i < length; i++) {
|
||
if (array[i] === elem) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
},
|
||
merge: function anonymous__41(first, second) {
|
||
var i = first.length, j = 0;
|
||
if (typeof second.length === "number") {
|
||
for (var l = second.length; j < l; j++) {
|
||
first[i++] = second[j];
|
||
}
|
||
} else {
|
||
while (second[j] !== undefined) {
|
||
first[i++] = second[j++];
|
||
}
|
||
}
|
||
first.length = i;
|
||
return first;
|
||
},
|
||
grep: function anonymous__42(elems, callback, inv) {
|
||
var ret = [], retVal;
|
||
inv = !!inv;
|
||
for (var i = 0, length = elems.length; i < length; i++) {
|
||
retVal = !!callback(elems[i], i);
|
||
if (inv !== retVal) {
|
||
ret.push(elems[i]);
|
||
}
|
||
}
|
||
return ret;
|
||
},
|
||
map: function anonymous__43(elems, callback, arg) {
|
||
var value, key, ret = [], i = 0, length = elems.length, isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && (length > 0 && elems[0] && elems[length - 1] || length === 0 || jQuery.isArray(elems));
|
||
if (isArray) {
|
||
for (; i < length; i++) {
|
||
value = callback(elems[i], i, arg);
|
||
if (value != null) {
|
||
ret[ret.length] = value;
|
||
}
|
||
}
|
||
} else {
|
||
for (key in elems) {
|
||
value = (function _forin_body_extra_4(key) { return callback(elems[key], key, arg) })(key);
|
||
if (value != null) {
|
||
ret[ret.length] = value;
|
||
}
|
||
}
|
||
}
|
||
return ret.concat.apply([], ret);
|
||
},
|
||
guid: 1,
|
||
proxy: function anonymous__44(fn, context) {
|
||
if (typeof context === "string") {
|
||
var tmp = fn[context];
|
||
context = fn;
|
||
fn = tmp;
|
||
}
|
||
if (!jQuery.isFunction(fn)) {
|
||
return undefined;
|
||
}
|
||
var args = slice.call(arguments, 2), proxy = function anonymous__45() {
|
||
return fn.apply(context, args.concat(slice.call(arguments)));
|
||
};
|
||
proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
|
||
return proxy;
|
||
},
|
||
access: function anonymous__46(elems, key, value, exec, fn, pass) {
|
||
var length = elems.length;
|
||
if (typeof key === "object") {
|
||
for (var k in key) {
|
||
(function _forin_body_5(k) { jQuery.access(elems, k, key[k], exec, fn, value); })(k);
|
||
}
|
||
return elems;
|
||
}
|
||
if (value !== undefined) {
|
||
exec = !pass && exec && jQuery.isFunction(value);
|
||
for (var i = 0; i < length; i++) {
|
||
fn(elems[i], key, exec ? value.call(elems[i], i, fn(elems[i], key)) : value, pass);
|
||
}
|
||
return elems;
|
||
}
|
||
return length ? fn(elems[0], key) : undefined;
|
||
},
|
||
now: function anonymous__47() {
|
||
return (new Date).getTime();
|
||
},
|
||
uaMatch: function anonymous__48(ua) {
|
||
ua = ua.toLowerCase();
|
||
var match = rwebkit.exec(ua) || ropera.exec(ua) || rmsie.exec(ua) || ua.indexOf("compatible") < 0 && rmozilla.exec(ua) || [];
|
||
return {
|
||
browser: match[1] || "",
|
||
version: match[2] || "0"
|
||
};
|
||
},
|
||
sub: function anonymous__49() {
|
||
function jQuerySub(selector, context) {
|
||
return new jQuerySub.fn.init(selector, context);
|
||
}
|
||
jQuery.extend(true, jQuerySub, this);
|
||
jQuerySub.superclass = this;
|
||
jQuerySub.fn = jQuerySub.prototype = this();
|
||
jQuerySub.fn.constructor = jQuerySub;
|
||
jQuerySub.sub = this.sub;
|
||
jQuerySub.fn.init = function init(selector, context) {
|
||
if (context && context instanceof jQuery && !(context instanceof jQuerySub)) {
|
||
context = jQuerySub(context);
|
||
}
|
||
return jQuery.fn.init.call(this, selector, context, rootjQuerySub);
|
||
};
|
||
jQuerySub.fn.init.prototype = jQuerySub.fn;
|
||
var rootjQuerySub = jQuerySub(document);
|
||
return jQuerySub;
|
||
},
|
||
browser: {}
|
||
});
|
||
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function anonymous__50(i, name) {
|
||
class2type["[object " + name + "]"] = name.toLowerCase();
|
||
});
|
||
browserMatch = jQuery.uaMatch(userAgent);
|
||
if (browserMatch.browser) {
|
||
jQuery.browser[browserMatch.browser] = true;
|
||
jQuery.browser.version = browserMatch.version;
|
||
}
|
||
if (jQuery.browser.webkit) {
|
||
jQuery.browser.safari = true;
|
||
}
|
||
if (rnotwhite.test(" ")) {
|
||
trimLeft = /^[\s\xA0]+/;
|
||
trimRight = /[\s\xA0]+$/;
|
||
}
|
||
rootjQuery = jQuery(document);
|
||
if (document.addEventListener) {
|
||
DOMContentLoaded = function anonymous__51() {
|
||
document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
|
||
jQuery.ready();
|
||
};
|
||
} else if (document.attachEvent) {
|
||
DOMContentLoaded = function anonymous__52() {
|
||
if (document.readyState === "complete") {
|
||
document.detachEvent("onreadystatechange", DOMContentLoaded);
|
||
jQuery.ready();
|
||
}
|
||
};
|
||
}
|
||
function doScrollCheck() {
|
||
if (jQuery.isReady) {
|
||
return;
|
||
}
|
||
try {
|
||
document.documentElement.doScroll("left");
|
||
} catch (e) {
|
||
setTimeout(doScrollCheck, 1);
|
||
return;
|
||
}
|
||
jQuery.ready();
|
||
}
|
||
return jQuery;
|
||
}();
|
||
var promiseMethods = "done fail isResolved isRejected promise then always pipe".split(" "), sliceDeferred = [].slice;
|
||
jQuery.extend({
|
||
_Deferred: function anonymous__53() {
|
||
var callbacks = [], fired, firing, cancelled, deferred = {
|
||
done: function anonymous__54() {
|
||
if (!cancelled) {
|
||
var args = arguments, i, length, elem, type, _fired;
|
||
if (fired) {
|
||
_fired = fired;
|
||
fired = 0;
|
||
}
|
||
for (i = 0, length = args.length; i < length; i++) {
|
||
elem = args[i];
|
||
type = jQuery.type(elem);
|
||
if (type === "array") {
|
||
deferred.done.apply(deferred, elem);
|
||
} else if (type === "function") {
|
||
callbacks.push(elem);
|
||
}
|
||
}
|
||
if (_fired) {
|
||
deferred.resolveWith(_fired[0], _fired[1]);
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
resolveWith: function anonymous__55(context, args) {
|
||
if (!cancelled && !fired && !firing) {
|
||
args = args || [];
|
||
firing = 1;
|
||
try {
|
||
while (callbacks[0]) {
|
||
callbacks.shift().apply(context, args);
|
||
}
|
||
} finally {
|
||
fired = [ context, args ];
|
||
firing = 0;
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
resolve: function anonymous__56() {
|
||
deferred.resolveWith(this, arguments);
|
||
return this;
|
||
},
|
||
isResolved: function anonymous__57() {
|
||
return !!(firing || fired);
|
||
},
|
||
cancel: function anonymous__58() {
|
||
cancelled = 1;
|
||
callbacks = [];
|
||
return this;
|
||
}
|
||
};
|
||
return deferred;
|
||
},
|
||
Deferred: function anonymous__59(func) {
|
||
var deferred = jQuery._Deferred(), failDeferred = jQuery._Deferred(), promise;
|
||
jQuery.extend(deferred, {
|
||
then: function anonymous__60(doneCallbacks, failCallbacks) {
|
||
deferred.done(doneCallbacks).fail(failCallbacks);
|
||
return this;
|
||
},
|
||
always: function anonymous__61() {
|
||
return deferred.done.apply(deferred, arguments).fail.apply(this, arguments);
|
||
},
|
||
fail: failDeferred.done,
|
||
rejectWith: failDeferred.resolveWith,
|
||
reject: failDeferred.resolve,
|
||
isRejected: failDeferred.isResolved,
|
||
pipe: function anonymous__62(fnDone, fnFail) {
|
||
return jQuery.Deferred(function anonymous__63(newDefer) {
|
||
jQuery.each({
|
||
done: [ fnDone, "resolve" ],
|
||
fail: [ fnFail, "reject" ]
|
||
}, function anonymous__64(handler, data) {
|
||
var fn = data[0], action = data[1], returned;
|
||
if (jQuery.isFunction(fn)) {
|
||
deferred[handler](function anonymous__65() {
|
||
returned = fn.apply(this, arguments);
|
||
if (returned && jQuery.isFunction(returned.promise)) {
|
||
returned.promise().then(newDefer.resolve, newDefer.reject);
|
||
} else {
|
||
newDefer[action](returned);
|
||
}
|
||
});
|
||
} else {
|
||
deferred[handler](newDefer[action]);
|
||
}
|
||
});
|
||
}).promise();
|
||
},
|
||
promise: function anonymous__66(obj) {
|
||
if (obj == null) {
|
||
if (promise) {
|
||
return promise;
|
||
}
|
||
promise = obj = {};
|
||
}
|
||
var i = promiseMethods.length;
|
||
while (i--) {
|
||
obj[promiseMethods[i]] = deferred[promiseMethods[i]];
|
||
}
|
||
return obj;
|
||
}
|
||
});
|
||
deferred.done(failDeferred.cancel).fail(deferred.cancel);
|
||
delete deferred.cancel;
|
||
if (func) {
|
||
func.call(deferred, deferred);
|
||
}
|
||
return deferred;
|
||
},
|
||
when: function anonymous__67(firstParam) {
|
||
var args = arguments, i = 0, length = args.length, count = length, deferred = length <= 1 && firstParam && jQuery.isFunction(firstParam.promise) ? firstParam : jQuery.Deferred();
|
||
function resolveFunc(i) {
|
||
return function anonymous__68(value) {
|
||
args[i] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
|
||
if (!--count) {
|
||
deferred.resolveWith(deferred, sliceDeferred.call(args, 0));
|
||
}
|
||
};
|
||
}
|
||
if (length > 1) {
|
||
for (; i < length; i++) {
|
||
if (args[i] && jQuery.isFunction(args[i].promise)) {
|
||
args[i].promise().then(resolveFunc(i), deferred.reject);
|
||
} else {
|
||
--count;
|
||
}
|
||
}
|
||
if (!count) {
|
||
deferred.resolveWith(deferred, args);
|
||
}
|
||
} else if (deferred !== firstParam) {
|
||
deferred.resolveWith(deferred, length ? [ firstParam ] : []);
|
||
}
|
||
return deferred.promise();
|
||
}
|
||
});
|
||
jQuery.support = function anonymous__69() {
|
||
var div = document.createElement("div"), documentElement = document.documentElement, all, a, select, opt, input, marginDiv, support, fragment, body, bodyStyle, tds, events, eventName, i, isSupported;
|
||
div.setAttribute("className", "t");
|
||
div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
|
||
all = div.getElementsByTagName("*");
|
||
a = div.getElementsByTagName("a")[0];
|
||
if (!all || !all.length || !a) {
|
||
return {};
|
||
}
|
||
select = document.createElement("select");
|
||
opt = select.appendChild(document.createElement("option"));
|
||
input = div.getElementsByTagName("input")[0];
|
||
support = {
|
||
leadingWhitespace: div.firstChild.nodeType === 3,
|
||
tbody: !div.getElementsByTagName("tbody").length,
|
||
htmlSerialize: !!div.getElementsByTagName("link").length,
|
||
style: /top/.test(a.getAttribute("style")),
|
||
hrefNormalized: a.getAttribute("href") === "/a",
|
||
opacity: /^0.55$/.test(a.style.opacity),
|
||
cssFloat: !!a.style.cssFloat,
|
||
checkOn: input.value === "on",
|
||
optSelected: opt.selected,
|
||
getSetAttribute: div.className !== "t",
|
||
submitBubbles: true,
|
||
changeBubbles: true,
|
||
focusinBubbles: false,
|
||
deleteExpando: true,
|
||
noCloneEvent: true,
|
||
inlineBlockNeedsLayout: false,
|
||
shrinkWrapBlocks: false,
|
||
reliableMarginRight: true
|
||
};
|
||
input.checked = true;
|
||
support.noCloneChecked = input.cloneNode(true).checked;
|
||
select.disabled = true;
|
||
support.optDisabled = !opt.disabled;
|
||
try {
|
||
delete div.test;
|
||
} catch (e) {
|
||
support.deleteExpando = false;
|
||
}
|
||
if (!div.addEventListener && div.attachEvent && div.fireEvent) {
|
||
div.attachEvent("onclick", function click() {
|
||
support.noCloneEvent = false;
|
||
div.detachEvent("onclick", click);
|
||
});
|
||
div.cloneNode(true).fireEvent("onclick");
|
||
}
|
||
input = document.createElement("input");
|
||
input.value = "t";
|
||
input.setAttribute("type", "radio");
|
||
support.radioValue = input.value === "t";
|
||
input.setAttribute("checked", "checked");
|
||
div.appendChild(input);
|
||
fragment = document.createDocumentFragment();
|
||
fragment.appendChild(div.firstChild);
|
||
support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
|
||
div.innerHTML = "";
|
||
div.style.width = div.style.paddingLeft = "1px";
|
||
body = document.createElement("body");
|
||
bodyStyle = {
|
||
visibility: "hidden",
|
||
width: 0,
|
||
height: 0,
|
||
border: 0,
|
||
margin: 0,
|
||
background: "none"
|
||
};
|
||
for (i in bodyStyle) {
|
||
(function _forin_body_7(i) { body.style[i] = bodyStyle[i]; })(i);
|
||
}
|
||
body.appendChild(div);
|
||
documentElement.insertBefore(body, documentElement.firstChild);
|
||
support.appendChecked = input.checked;
|
||
support.boxModel = div.offsetWidth === 2;
|
||
if ("zoom" in div.style) {
|
||
div.style.display = "inline";
|
||
div.style.zoom = 1;
|
||
support.inlineBlockNeedsLayout = div.offsetWidth === 2;
|
||
div.style.display = "";
|
||
div.innerHTML = "<div style='width:4px;'></div>";
|
||
support.shrinkWrapBlocks = div.offsetWidth !== 2;
|
||
}
|
||
div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
|
||
tds = div.getElementsByTagName("td");
|
||
isSupported = tds[0].offsetHeight === 0;
|
||
tds[0].style.display = "";
|
||
tds[1].style.display = "none";
|
||
support.reliableHiddenOffsets = isSupported && tds[0].offsetHeight === 0;
|
||
div.innerHTML = "";
|
||
if (document.defaultView && document.defaultView.getComputedStyle) {
|
||
marginDiv = document.createElement("div");
|
||
marginDiv.style.width = "0";
|
||
marginDiv.style.marginRight = "0";
|
||
div.appendChild(marginDiv);
|
||
support.reliableMarginRight = (parseInt((document.defaultView.getComputedStyle(marginDiv, null) || {
|
||
marginRight: 0
|
||
}).marginRight, 10) || 0) === 0;
|
||
}
|
||
body.innerHTML = "";
|
||
documentElement.removeChild(body);
|
||
if (div.attachEvent) {
|
||
for (i in {
|
||
submit: 1,
|
||
change: 1,
|
||
focusin: 1
|
||
}) {
|
||
eventName = "on" + i;
|
||
isSupported = eventName in div;
|
||
if (!isSupported) {
|
||
div.setAttribute(eventName, "return;");
|
||
isSupported = typeof div[eventName] === "function";
|
||
}
|
||
support[i + "Bubbles"] = isSupported;
|
||
}
|
||
}
|
||
return support;
|
||
}();
|
||
jQuery.boxModel = jQuery.support.boxModel;
|
||
var rbrace = /^(?:\{.*\}|\[.*\])$/, rmultiDash = /([a-z])([A-Z])/g;
|
||
jQuery.extend({
|
||
cache: {},
|
||
uuid: 0,
|
||
expando: "jQuery" + (jQuery.fn.jquery + Math.random()).replace(/\D/g, ""),
|
||
noData: {
|
||
embed: true,
|
||
object: "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
|
||
applet: true
|
||
},
|
||
hasData: function anonymous__70(elem) {
|
||
elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando];
|
||
return !!elem && !isEmptyDataObject(elem);
|
||
},
|
||
data: function anonymous__71(elem, name, data, pvt) {
|
||
if (!jQuery.acceptData(elem)) {
|
||
return;
|
||
}
|
||
var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache, isNode = elem.nodeType, cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : elem[jQuery.expando] && jQuery.expando;
|
||
if ((!id || pvt && id && !cache[id][internalKey]) && getByName && data === undefined) {
|
||
return;
|
||
}
|
||
if (!id) {
|
||
if (isNode) {
|
||
elem[jQuery.expando] = id = ++jQuery.uuid;
|
||
} else {
|
||
id = jQuery.expando;
|
||
}
|
||
}
|
||
if (!cache[id]) {
|
||
cache[id] = {};
|
||
if (!isNode) {
|
||
cache[id].toJSON = jQuery.noop;
|
||
}
|
||
}
|
||
if (typeof name === "object" || typeof name === "function") {
|
||
if (pvt) {
|
||
cache[id][internalKey] = jQuery.extend(cache[id][internalKey], name);
|
||
} else {
|
||
cache[id] = jQuery.extend(cache[id], name);
|
||
}
|
||
}
|
||
thisCache = cache[id];
|
||
if (pvt) {
|
||
if (!thisCache[internalKey]) {
|
||
thisCache[internalKey] = {};
|
||
}
|
||
thisCache = thisCache[internalKey];
|
||
}
|
||
if (data !== undefined) {
|
||
thisCache[jQuery.camelCase(name)] = data;
|
||
}
|
||
if (name === "events" && !thisCache[name]) {
|
||
return thisCache[internalKey] && thisCache[internalKey].events;
|
||
}
|
||
return getByName ? thisCache[jQuery.camelCase(name)] : thisCache;
|
||
},
|
||
removeData: function anonymous__72(elem, name, pvt) {
|
||
if (!jQuery.acceptData(elem)) {
|
||
return;
|
||
}
|
||
var internalKey = jQuery.expando, isNode = elem.nodeType, cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : jQuery.expando;
|
||
if (!cache[id]) {
|
||
return;
|
||
}
|
||
if (name) {
|
||
var thisCache = pvt ? cache[id][internalKey] : cache[id];
|
||
if (thisCache) {
|
||
delete thisCache[name];
|
||
if (!isEmptyDataObject(thisCache)) {
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if (pvt) {
|
||
delete cache[id][internalKey];
|
||
if (!isEmptyDataObject(cache[id])) {
|
||
return;
|
||
}
|
||
}
|
||
var internalCache = cache[id][internalKey];
|
||
if (jQuery.support.deleteExpando || cache != window) {
|
||
delete cache[id];
|
||
} else {
|
||
cache[id] = null;
|
||
}
|
||
if (internalCache) {
|
||
cache[id] = {};
|
||
if (!isNode) {
|
||
cache[id].toJSON = jQuery.noop;
|
||
}
|
||
cache[id][internalKey] = internalCache;
|
||
} else if (isNode) {
|
||
if (jQuery.support.deleteExpando) {
|
||
delete elem[jQuery.expando];
|
||
} else if (elem.removeAttribute) {
|
||
elem.removeAttribute(jQuery.expando);
|
||
} else {
|
||
elem[jQuery.expando] = null;
|
||
}
|
||
}
|
||
},
|
||
_data: function anonymous__73(elem, name, data) {
|
||
return jQuery.data(elem, name, data, true);
|
||
},
|
||
acceptData: function anonymous__74(elem) {
|
||
if (elem.nodeName) {
|
||
var match = jQuery.noData[elem.nodeName.toLowerCase()];
|
||
if (match) {
|
||
return !(match === true || elem.getAttribute("classid") !== match);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
data: function anonymous__75(key, value) {
|
||
var data = null;
|
||
if (typeof key === "undefined") {
|
||
if (this.length) {
|
||
data = jQuery.data(this[0]);
|
||
if (this[0].nodeType === 1) {
|
||
var attr = this[0].attributes, name;
|
||
for (var i = 0, l = attr.length; i < l; i++) {
|
||
name = attr[i].name;
|
||
if (name.indexOf("data-") === 0) {
|
||
name = jQuery.camelCase(name.substring(5));
|
||
dataAttr(this[0], name, data[name]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return data;
|
||
} else if (typeof key === "object") {
|
||
return this.each(function anonymous__76() {
|
||
jQuery.data(this, key);
|
||
});
|
||
}
|
||
var parts = key.split(".");
|
||
parts[1] = parts[1] ? "." + parts[1] : "";
|
||
if (value === undefined) {
|
||
data = this.triggerHandler("getData" + parts[1] + "!", [ parts[0] ]);
|
||
if (data === undefined && this.length) {
|
||
data = jQuery.data(this[0], key);
|
||
data = dataAttr(this[0], key, data);
|
||
}
|
||
return data === undefined && parts[1] ? this.data(parts[0]) : data;
|
||
} else {
|
||
return this.each(function anonymous__77() {
|
||
var $this = jQuery(this), args = [ parts[0], value ];
|
||
$this.triggerHandler("setData" + parts[1] + "!", args);
|
||
jQuery.data(this, key, value);
|
||
$this.triggerHandler("changeData" + parts[1] + "!", args);
|
||
});
|
||
}
|
||
},
|
||
removeData: function anonymous__78(key) {
|
||
return this.each(function anonymous__79() {
|
||
jQuery.removeData(this, key);
|
||
});
|
||
}
|
||
});
|
||
function dataAttr(elem, key, data) {
|
||
if (data === undefined && elem.nodeType === 1) {
|
||
var name = "data-" + key.replace(rmultiDash, "$1-$2").toLowerCase();
|
||
data = elem.getAttribute(name);
|
||
if (typeof data === "string") {
|
||
try {
|
||
data = data === "true" ? true : data === "false" ? false : data === "null" ? null : !jQuery.isNaN(data) ? parseFloat(data) : rbrace.test(data) ? jQuery.parseJSON(data) : data;
|
||
} catch (e) {}
|
||
jQuery.data(elem, key, data);
|
||
} else {
|
||
data = undefined;
|
||
}
|
||
}
|
||
return data;
|
||
}
|
||
function isEmptyDataObject(obj) {
|
||
for (var name in obj) {
|
||
if (name !== "toJSON") {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
function handleQueueMarkDefer(elem, type, src) {
|
||
var deferDataKey = type + "defer", queueDataKey = type + "queue", markDataKey = type + "mark", defer = jQuery.data(elem, deferDataKey, undefined, true);
|
||
if (defer && (src === "queue" || !jQuery.data(elem, queueDataKey, undefined, true)) && (src === "mark" || !jQuery.data(elem, markDataKey, undefined, true))) {
|
||
setTimeout(function anonymous__80() {
|
||
if (!jQuery.data(elem, queueDataKey, undefined, true) && !jQuery.data(elem, markDataKey, undefined, true)) {
|
||
jQuery.removeData(elem, deferDataKey, true);
|
||
defer.resolve();
|
||
}
|
||
}, 0);
|
||
}
|
||
}
|
||
jQuery.extend({
|
||
_mark: function anonymous__81(elem, type) {
|
||
if (elem) {
|
||
type = (type || "fx") + "mark";
|
||
jQuery.data(elem, type, (jQuery.data(elem, type, undefined, true) || 0) + 1, true);
|
||
}
|
||
},
|
||
_unmark: function anonymous__82(force, elem, type) {
|
||
if (force !== true) {
|
||
type = elem;
|
||
elem = force;
|
||
force = false;
|
||
}
|
||
if (elem) {
|
||
type = type || "fx";
|
||
var key = type + "mark", count = force ? 0 : (jQuery.data(elem, key, undefined, true) || 1) - 1;
|
||
if (count) {
|
||
jQuery.data(elem, key, count, true);
|
||
} else {
|
||
jQuery.removeData(elem, key, true);
|
||
handleQueueMarkDefer(elem, type, "mark");
|
||
}
|
||
}
|
||
},
|
||
queue: function anonymous__83(elem, type, data) {
|
||
if (elem) {
|
||
type = (type || "fx") + "queue";
|
||
var q = jQuery.data(elem, type, undefined, true);
|
||
if (data) {
|
||
if (!q || jQuery.isArray(data)) {
|
||
q = jQuery.data(elem, type, jQuery.makeArray(data), true);
|
||
} else {
|
||
q.push(data);
|
||
}
|
||
}
|
||
return q || [];
|
||
}
|
||
},
|
||
dequeue: function anonymous__84(elem, type) {
|
||
type = type || "fx";
|
||
var queue = jQuery.queue(elem, type), fn = queue.shift(), defer;
|
||
if (fn === "inprogress") {
|
||
fn = queue.shift();
|
||
}
|
||
if (fn) {
|
||
if (type === "fx") {
|
||
queue.unshift("inprogress");
|
||
}
|
||
fn.call(elem, function anonymous__85() {
|
||
jQuery.dequeue(elem, type);
|
||
});
|
||
}
|
||
if (!queue.length) {
|
||
jQuery.removeData(elem, type + "queue", true);
|
||
handleQueueMarkDefer(elem, type, "queue");
|
||
}
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
queue: function anonymous__86(type, data) {
|
||
if (typeof type !== "string") {
|
||
data = type;
|
||
type = "fx";
|
||
}
|
||
if (data === undefined) {
|
||
return jQuery.queue(this[0], type);
|
||
}
|
||
return this.each(function anonymous__87() {
|
||
var queue = jQuery.queue(this, type, data);
|
||
if (type === "fx" && queue[0] !== "inprogress") {
|
||
jQuery.dequeue(this, type);
|
||
}
|
||
});
|
||
},
|
||
dequeue: function anonymous__88(type) {
|
||
return this.each(function anonymous__89() {
|
||
jQuery.dequeue(this, type);
|
||
});
|
||
},
|
||
delay: function anonymous__90(time, type) {
|
||
time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
|
||
type = type || "fx";
|
||
return this.queue(type, function anonymous__91() {
|
||
var elem = this;
|
||
setTimeout(function anonymous__92() {
|
||
jQuery.dequeue(elem, type);
|
||
}, time);
|
||
});
|
||
},
|
||
clearQueue: function anonymous__93(type) {
|
||
return this.queue(type || "fx", []);
|
||
},
|
||
promise: function anonymous__94(type, object) {
|
||
if (typeof type !== "string") {
|
||
object = type;
|
||
type = undefined;
|
||
}
|
||
type = type || "fx";
|
||
var defer = jQuery.Deferred(), elements = this, i = elements.length, count = 1, deferDataKey = type + "defer", queueDataKey = type + "queue", markDataKey = type + "mark", tmp;
|
||
function resolve() {
|
||
if (!--count) {
|
||
defer.resolveWith(elements, [ elements ]);
|
||
}
|
||
}
|
||
while (i--) {
|
||
if (tmp = jQuery.data(elements[i], deferDataKey, undefined, true) || (jQuery.data(elements[i], queueDataKey, undefined, true) || jQuery.data(elements[i], markDataKey, undefined, true)) && jQuery.data(elements[i], deferDataKey, jQuery._Deferred(), true)) {
|
||
count++;
|
||
tmp.done(resolve);
|
||
}
|
||
}
|
||
resolve();
|
||
return defer.promise();
|
||
}
|
||
});
|
||
var rclass = /[\n\t\r]/g, rspace = /\s+/, rreturn = /\r/g, rtype = /^(?:button|input)$/i, rfocusable = /^(?:button|input|object|select|textarea)$/i, rclickable = /^a(?:rea)?$/i, rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, rinvalidChar = /\:/, formHook, boolHook;
|
||
jQuery.fn.extend({
|
||
attr: function anonymous__95(name, value) {
|
||
return jQuery.access(this, name, value, true, jQuery.attr);
|
||
},
|
||
removeAttr: function anonymous__96(name) {
|
||
return this.each(function anonymous__97() {
|
||
jQuery.removeAttr(this, name);
|
||
});
|
||
},
|
||
prop: function anonymous__98(name, value) {
|
||
return jQuery.access(this, name, value, true, jQuery.prop);
|
||
},
|
||
removeProp: function anonymous__99(name) {
|
||
name = jQuery.propFix[name] || name;
|
||
return this.each(function anonymous__100() {
|
||
try {
|
||
this[name] = undefined;
|
||
delete this[name];
|
||
} catch (e) {}
|
||
});
|
||
},
|
||
addClass: function anonymous__101(value) {
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function anonymous__102(i) {
|
||
var self = jQuery(this);
|
||
self.addClass(value.call(this, i, self.attr("class") || ""));
|
||
});
|
||
}
|
||
if (value && typeof value === "string") {
|
||
var classNames = (value || "").split(rspace);
|
||
for (var i = 0, l = this.length; i < l; i++) {
|
||
var elem = this[i];
|
||
if (elem.nodeType === 1) {
|
||
if (!elem.className) {
|
||
elem.className = value;
|
||
} else {
|
||
var className = " " + elem.className + " ", setClass = elem.className;
|
||
for (var c = 0, cl = classNames.length; c < cl; c++) {
|
||
if (className.indexOf(" " + classNames[c] + " ") < 0) {
|
||
setClass += " " + classNames[c];
|
||
}
|
||
}
|
||
elem.className = jQuery.trim(setClass);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
removeClass: function anonymous__103(value) {
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function anonymous__104(i) {
|
||
var self = jQuery(this);
|
||
self.removeClass(value.call(this, i, self.attr("class")));
|
||
});
|
||
}
|
||
if (value && typeof value === "string" || value === undefined) {
|
||
var classNames = (value || "").split(rspace);
|
||
for (var i = 0, l = this.length; i < l; i++) {
|
||
var elem = this[i];
|
||
if (elem.nodeType === 1 && elem.className) {
|
||
if (value) {
|
||
var className = (" " + elem.className + " ").replace(rclass, " ");
|
||
for (var c = 0, cl = classNames.length; c < cl; c++) {
|
||
className = className.replace(" " + classNames[c] + " ", " ");
|
||
}
|
||
elem.className = jQuery.trim(className);
|
||
} else {
|
||
elem.className = "";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
toggleClass: function anonymous__105(value, stateVal) {
|
||
var type = typeof value, isBool = typeof stateVal === "boolean";
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function anonymous__106(i) {
|
||
var self = jQuery(this);
|
||
self.toggleClass(value.call(this, i, self.attr("class"), stateVal), stateVal);
|
||
});
|
||
}
|
||
return this.each(function anonymous__107() {
|
||
if (type === "string") {
|
||
var className, i = 0, self = jQuery(this), state = stateVal, classNames = value.split(rspace);
|
||
while (className = classNames[i++]) {
|
||
state = isBool ? state : !self.hasClass(className);
|
||
self[state ? "addClass" : "removeClass"](className);
|
||
}
|
||
} else if (type === "undefined" || type === "boolean") {
|
||
if (this.className) {
|
||
jQuery._data(this, "__className__", this.className);
|
||
}
|
||
this.className = this.className || value === false ? "" : jQuery._data(this, "__className__") || "";
|
||
}
|
||
});
|
||
},
|
||
hasClass: function anonymous__108(selector) {
|
||
var className = " " + selector + " ";
|
||
for (var i = 0, l = this.length; i < l; i++) {
|
||
if ((" " + this[i].className + " ").replace(rclass, " ").indexOf(className) > -1) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
val: function anonymous__109(value) {
|
||
var hooks, ret, elem = this[0];
|
||
if (!arguments.length) {
|
||
if (elem) {
|
||
hooks = jQuery.valHooks[elem.nodeName.toLowerCase()] || jQuery.valHooks[elem.type];
|
||
if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
|
||
return ret;
|
||
}
|
||
return (elem.value || "").replace(rreturn, "");
|
||
}
|
||
return undefined;
|
||
}
|
||
var isFunction = jQuery.isFunction(value);
|
||
return this.each(function anonymous__110(i) {
|
||
var self = jQuery(this), val;
|
||
if (this.nodeType !== 1) {
|
||
return;
|
||
}
|
||
if (isFunction) {
|
||
val = value.call(this, i, self.val());
|
||
} else {
|
||
val = value;
|
||
}
|
||
if (val == null) {
|
||
val = "";
|
||
} else if (typeof val === "number") {
|
||
val += "";
|
||
} else if (jQuery.isArray(val)) {
|
||
val = jQuery.map(val, function anonymous__111(value) {
|
||
return value == null ? "" : value + "";
|
||
});
|
||
}
|
||
hooks = jQuery.valHooks[this.nodeName.toLowerCase()] || jQuery.valHooks[this.type];
|
||
if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
|
||
this.value = val;
|
||
}
|
||
});
|
||
}
|
||
});
|
||
jQuery.extend({
|
||
valHooks: {
|
||
option: {
|
||
get: function anonymous__112(elem) {
|
||
var val = elem.attributes.value;
|
||
return !val || val.specified ? elem.value : elem.text;
|
||
}
|
||
},
|
||
select: {
|
||
get: function anonymous__113(elem) {
|
||
var value, index = elem.selectedIndex, values = [], options = elem.options, one = elem.type === "select-one";
|
||
if (index < 0) {
|
||
return null;
|
||
}
|
||
for (var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++) {
|
||
var option = options[i];
|
||
if (option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup"))) {
|
||
value = jQuery(option).val();
|
||
if (one) {
|
||
return value;
|
||
}
|
||
values.push(value);
|
||
}
|
||
}
|
||
if (one && !values.length && options.length) {
|
||
return jQuery(options[index]).val();
|
||
}
|
||
return values;
|
||
},
|
||
set: function anonymous__114(elem, value) {
|
||
var values = jQuery.makeArray(value);
|
||
jQuery(elem).find("option").each(function anonymous__115() {
|
||
this.selected = jQuery.inArray(jQuery(this).val(), values) >= 0;
|
||
});
|
||
if (!values.length) {
|
||
elem.selectedIndex = -1;
|
||
}
|
||
return values;
|
||
}
|
||
}
|
||
},
|
||
attrFn: {
|
||
val: true,
|
||
css: true,
|
||
html: true,
|
||
text: true,
|
||
data: true,
|
||
width: true,
|
||
height: true,
|
||
offset: true
|
||
},
|
||
attrFix: {
|
||
tabindex: "tabIndex"
|
||
},
|
||
attr: function anonymous__116(elem, name, value, pass) {
|
||
var nType = elem.nodeType;
|
||
if (!elem || nType === 3 || nType === 8 || nType === 2) {
|
||
return undefined;
|
||
}
|
||
if (pass && name in jQuery.attrFn) {
|
||
return jQuery(elem)[name](value);
|
||
}
|
||
if (!("getAttribute" in elem)) {
|
||
return jQuery.prop(elem, name, value);
|
||
}
|
||
var ret, hooks, notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
|
||
name = notxml && jQuery.attrFix[name] || name;
|
||
hooks = jQuery.attrHooks[name];
|
||
if (!hooks) {
|
||
if (rboolean.test(name) && (typeof value === "boolean" || value === undefined || value.toLowerCase() === name.toLowerCase())) {
|
||
hooks = boolHook;
|
||
} else if (formHook && (jQuery.nodeName(elem, "form") || rinvalidChar.test(name))) {
|
||
hooks = formHook;
|
||
}
|
||
}
|
||
if (value !== undefined) {
|
||
if (value === null) {
|
||
jQuery.removeAttr(elem, name);
|
||
return undefined;
|
||
} else if (hooks && "set" in hooks && notxml && (ret = hooks.set(elem, value, name)) !== undefined) {
|
||
return ret;
|
||
} else {
|
||
elem.setAttribute(name, "" + value);
|
||
return value;
|
||
}
|
||
} else if (hooks && "get" in hooks && notxml) {
|
||
return hooks.get(elem, name);
|
||
} else {
|
||
ret = elem.getAttribute(name);
|
||
return ret === null ? undefined : ret;
|
||
}
|
||
},
|
||
removeAttr: function anonymous__117(elem, name) {
|
||
var propName;
|
||
if (elem.nodeType === 1) {
|
||
name = jQuery.attrFix[name] || name;
|
||
if (jQuery.support.getSetAttribute) {
|
||
elem.removeAttribute(name);
|
||
} else {
|
||
jQuery.attr(elem, name, "");
|
||
elem.removeAttributeNode(elem.getAttributeNode(name));
|
||
}
|
||
if (rboolean.test(name) && (propName = jQuery.propFix[name] || name) in elem) {
|
||
elem[propName] = false;
|
||
}
|
||
}
|
||
},
|
||
attrHooks: {
|
||
type: {
|
||
set: function anonymous__118(elem, value) {
|
||
if (rtype.test(elem.nodeName) && elem.parentNode) {
|
||
jQuery.error("type property can't be changed");
|
||
} else if (!jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input")) {
|
||
var val = elem.value;
|
||
elem.setAttribute("type", value);
|
||
if (val) {
|
||
elem.value = val;
|
||
}
|
||
return value;
|
||
}
|
||
}
|
||
},
|
||
tabIndex: {
|
||
get: function anonymous__119(elem) {
|
||
var attributeNode = elem.getAttributeNode("tabIndex");
|
||
return attributeNode && attributeNode.specified ? parseInt(attributeNode.value, 10) : rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ? 0 : undefined;
|
||
}
|
||
}
|
||
},
|
||
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 anonymous__120(elem, name, value) {
|
||
var nType = elem.nodeType;
|
||
if (!elem || nType === 3 || nType === 8 || nType === 2) {
|
||
return undefined;
|
||
}
|
||
var ret, hooks, notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
|
||
name = notxml && jQuery.propFix[name] || name;
|
||
hooks = jQuery.propHooks[name];
|
||
if (value !== undefined) {
|
||
if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
|
||
return ret;
|
||
} else {
|
||
return elem[name] = value;
|
||
}
|
||
} else {
|
||
if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== undefined) {
|
||
return ret;
|
||
} else {
|
||
return elem[name];
|
||
}
|
||
}
|
||
},
|
||
propHooks: {}
|
||
});
|
||
boolHook = {
|
||
get: function anonymous__121(elem, name) {
|
||
return elem[jQuery.propFix[name] || name] ? name.toLowerCase() : undefined;
|
||
},
|
||
set: function anonymous__122(elem, value, name) {
|
||
var propName;
|
||
if (value === false) {
|
||
jQuery.removeAttr(elem, name);
|
||
} else {
|
||
propName = jQuery.propFix[name] || name;
|
||
if (propName in elem) {
|
||
elem[propName] = value;
|
||
}
|
||
elem.setAttribute(name, name.toLowerCase());
|
||
}
|
||
return name;
|
||
}
|
||
};
|
||
jQuery.attrHooks.value = {
|
||
get: function anonymous__123(elem, name) {
|
||
if (formHook && jQuery.nodeName(elem, "button")) {
|
||
return formHook.get(elem, name);
|
||
}
|
||
return elem.value;
|
||
},
|
||
set: function anonymous__124(elem, value, name) {
|
||
if (formHook && jQuery.nodeName(elem, "button")) {
|
||
return formHook.set(elem, value, name);
|
||
}
|
||
elem.value = value;
|
||
}
|
||
};
|
||
if (!jQuery.support.getSetAttribute) {
|
||
jQuery.attrFix = jQuery.propFix;
|
||
formHook = jQuery.attrHooks.name = jQuery.valHooks.button = {
|
||
get: function anonymous__125(elem, name) {
|
||
var ret;
|
||
ret = elem.getAttributeNode(name);
|
||
return ret && ret.nodeValue !== "" ? ret.nodeValue : undefined;
|
||
},
|
||
set: function anonymous__126(elem, value, name) {
|
||
var ret = elem.getAttributeNode(name);
|
||
if (ret) {
|
||
ret.nodeValue = value;
|
||
return value;
|
||
}
|
||
}
|
||
};
|
||
jQuery.each([ "width", "height" ], function anonymous__127(i, name) {
|
||
jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {
|
||
set: function anonymous__128(elem, value) {
|
||
if (value === "") {
|
||
elem.setAttribute(name, "auto");
|
||
return value;
|
||
}
|
||
}
|
||
});
|
||
});
|
||
}
|
||
if (!jQuery.support.hrefNormalized) {
|
||
jQuery.each([ "href", "src", "width", "height" ], function anonymous__129(i, name) {
|
||
jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {
|
||
get: function anonymous__130(elem) {
|
||
var ret = elem.getAttribute(name, 2);
|
||
return ret === null ? undefined : ret;
|
||
}
|
||
});
|
||
});
|
||
}
|
||
if (!jQuery.support.style) {
|
||
jQuery.attrHooks.style = {
|
||
get: function anonymous__131(elem) {
|
||
return elem.style.cssText.toLowerCase() || undefined;
|
||
},
|
||
set: function anonymous__132(elem, value) {
|
||
return elem.style.cssText = "" + value;
|
||
}
|
||
};
|
||
}
|
||
if (!jQuery.support.optSelected) {
|
||
jQuery.propHooks.selected = jQuery.extend(jQuery.propHooks.selected, {
|
||
get: function anonymous__133(elem) {
|
||
var parent = elem.parentNode;
|
||
if (parent) {
|
||
parent.selectedIndex;
|
||
if (parent.parentNode) {
|
||
parent.parentNode.selectedIndex;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
if (!jQuery.support.checkOn) {
|
||
jQuery.each([ "radio", "checkbox" ], function anonymous__134() {
|
||
jQuery.valHooks[this] = {
|
||
get: function anonymous__135(elem) {
|
||
return elem.getAttribute("value") === null ? "on" : elem.value;
|
||
}
|
||
};
|
||
});
|
||
}
|
||
jQuery.each([ "radio", "checkbox" ], function anonymous__136() {
|
||
jQuery.valHooks[this] = jQuery.extend(jQuery.valHooks[this], {
|
||
set: function anonymous__137(elem, value) {
|
||
if (jQuery.isArray(value)) {
|
||
return elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0;
|
||
}
|
||
}
|
||
});
|
||
});
|
||
var hasOwn = Object.prototype.hasOwnProperty, rnamespaces = /\.(.*)$/, rformElems = /^(?:textarea|input|select)$/i, rperiod = /\./g, rspaces = / /g, rescape = /[^\w\s.|`]/g, fcleanup = function anonymous__138(nm) {
|
||
return nm.replace(rescape, "\\$&");
|
||
};
|
||
jQuery.event = {
|
||
add: function anonymous__139(elem, types, handler, data) {
|
||
if (elem.nodeType === 3 || elem.nodeType === 8) {
|
||
return;
|
||
}
|
||
if (handler === false) {
|
||
handler = returnFalse;
|
||
} else if (!handler) {
|
||
return;
|
||
}
|
||
var handleObjIn, handleObj;
|
||
if (handler.handler) {
|
||
handleObjIn = handler;
|
||
handler = handleObjIn.handler;
|
||
}
|
||
if (!handler.guid) {
|
||
handler.guid = jQuery.guid++;
|
||
}
|
||
var elemData = jQuery._data(elem);
|
||
if (!elemData) {
|
||
return;
|
||
}
|
||
var events = elemData.events, eventHandle = elemData.handle;
|
||
if (!events) {
|
||
elemData.events = events = {};
|
||
}
|
||
if (!eventHandle) {
|
||
elemData.handle = eventHandle = function anonymous__140(e) {
|
||
return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? jQuery.event.handle.apply(eventHandle.elem, arguments) : undefined;
|
||
};
|
||
}
|
||
eventHandle.elem = elem;
|
||
types = types.split(" ");
|
||
var type, i = 0, namespaces;
|
||
while (type = types[i++]) {
|
||
handleObj = handleObjIn ? jQuery.extend({}, handleObjIn) : {
|
||
handler: handler,
|
||
data: data
|
||
};
|
||
if (type.indexOf(".") > -1) {
|
||
namespaces = type.split(".");
|
||
type = namespaces.shift();
|
||
handleObj.namespace = namespaces.slice(0).sort().join(".");
|
||
} else {
|
||
namespaces = [];
|
||
handleObj.namespace = "";
|
||
}
|
||
handleObj.type = type;
|
||
if (!handleObj.guid) {
|
||
handleObj.guid = handler.guid;
|
||
}
|
||
var handlers = events[type], special = jQuery.event.special[type] || {};
|
||
if (!handlers) {
|
||
handlers = events[type] = [];
|
||
if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
|
||
if (elem.addEventListener) {
|
||
elem.addEventListener(type, eventHandle, false);
|
||
} else if (elem.attachEvent) {
|
||
elem.attachEvent("on" + type, eventHandle);
|
||
}
|
||
}
|
||
}
|
||
if (special.add) {
|
||
special.add.call(elem, handleObj);
|
||
if (!handleObj.handler.guid) {
|
||
handleObj.handler.guid = handler.guid;
|
||
}
|
||
}
|
||
handlers.push(handleObj);
|
||
jQuery.event.global[type] = true;
|
||
}
|
||
elem = null;
|
||
},
|
||
global: {},
|
||
remove: function anonymous__141(elem, types, handler, pos) {
|
||
if (elem.nodeType === 3 || elem.nodeType === 8) {
|
||
return;
|
||
}
|
||
if (handler === false) {
|
||
handler = returnFalse;
|
||
}
|
||
var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType, elemData = jQuery.hasData(elem) && jQuery._data(elem), events = elemData && elemData.events;
|
||
if (!elemData || !events) {
|
||
return;
|
||
}
|
||
if (types && types.type) {
|
||
handler = types.handler;
|
||
types = types.type;
|
||
}
|
||
if (!types || typeof types === "string" && types.charAt(0) === ".") {
|
||
types = types || "";
|
||
for (type in events) {
|
||
jQuery.event.remove(elem, type + types);
|
||
}
|
||
return;
|
||
}
|
||
types = types.split(" ");
|
||
while (type = types[i++]) {
|
||
origType = type;
|
||
handleObj = null;
|
||
all = type.indexOf(".") < 0;
|
||
namespaces = [];
|
||
if (!all) {
|
||
namespaces = type.split(".");
|
||
type = namespaces.shift();
|
||
namespace = new RegExp("(^|\\.)" + jQuery.map(namespaces.slice(0).sort(), fcleanup).join("\\.(?:.*\\.)?") + "(\\.|$)");
|
||
}
|
||
eventType = events[type];
|
||
if (!eventType) {
|
||
continue;
|
||
}
|
||
if (!handler) {
|
||
for (j = 0; j < eventType.length; j++) {
|
||
handleObj = eventType[j];
|
||
if (all || namespace.test(handleObj.namespace)) {
|
||
jQuery.event.remove(elem, origType, handleObj.handler, j);
|
||
eventType.splice(j--, 1);
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
special = jQuery.event.special[type] || {};
|
||
for (j = pos || 0; j < eventType.length; j++) {
|
||
handleObj = eventType[j];
|
||
if (handler.guid === handleObj.guid) {
|
||
if (all || namespace.test(handleObj.namespace)) {
|
||
if (pos == null) {
|
||
eventType.splice(j--, 1);
|
||
}
|
||
if (special.remove) {
|
||
special.remove.call(elem, handleObj);
|
||
}
|
||
}
|
||
if (pos != null) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (eventType.length === 0 || pos != null && eventType.length === 1) {
|
||
if (!special.teardown || special.teardown.call(elem, namespaces) === false) {
|
||
jQuery.removeEvent(elem, type, elemData.handle);
|
||
}
|
||
ret = null;
|
||
delete events[type];
|
||
}
|
||
}
|
||
if (jQuery.isEmptyObject(events)) {
|
||
var handle = elemData.handle;
|
||
if (handle) {
|
||
handle.elem = null;
|
||
}
|
||
delete elemData.events;
|
||
delete elemData.handle;
|
||
if (jQuery.isEmptyObject(elemData)) {
|
||
jQuery.removeData(elem, undefined, true);
|
||
}
|
||
}
|
||
},
|
||
customEvent: {
|
||
getData: true,
|
||
setData: true,
|
||
changeData: true
|
||
},
|
||
trigger: function anonymous__142(event, data, elem, onlyHandlers) {
|
||
var type = event.type || event, namespaces = [], exclusive;
|
||
if (type.indexOf("!") >= 0) {
|
||
type = type.slice(0, -1);
|
||
exclusive = true;
|
||
}
|
||
if (type.indexOf(".") >= 0) {
|
||
namespaces = type.split(".");
|
||
type = namespaces.shift();
|
||
namespaces.sort();
|
||
}
|
||
if ((!elem || jQuery.event.customEvent[type]) && !jQuery.event.global[type]) {
|
||
return;
|
||
}
|
||
event = typeof event === "object" ? event[jQuery.expando] ? event : new jQuery.Event(type, event) : new jQuery.Event(type);
|
||
event.type = type;
|
||
event.exclusive = exclusive;
|
||
event.namespace = namespaces.join(".");
|
||
event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
|
||
if (onlyHandlers || !elem) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
}
|
||
if (!elem) {
|
||
jQuery.each(jQuery.cache, function anonymous__143() {
|
||
var internalKey = jQuery.expando, internalCache = this[internalKey];
|
||
if (internalCache && internalCache.events && internalCache.events[type]) {
|
||
jQuery.event.trigger(event, data, internalCache.handle.elem);
|
||
}
|
||
});
|
||
return;
|
||
}
|
||
if (elem.nodeType === 3 || elem.nodeType === 8) {
|
||
return;
|
||
}
|
||
event.result = undefined;
|
||
event.target = elem;
|
||
data = data ? jQuery.makeArray(data) : [];
|
||
data.unshift(event);
|
||
var cur = elem, ontype = type.indexOf(":") < 0 ? "on" + type : "";
|
||
do {
|
||
var handle = jQuery._data(cur, "handle");
|
||
event.currentTarget = cur;
|
||
if (handle) {
|
||
handle.apply(cur, data);
|
||
}
|
||
if (ontype && jQuery.acceptData(cur) && cur[ontype] && cur[ontype].apply(cur, data) === false) {
|
||
event.result = false;
|
||
event.preventDefault();
|
||
}
|
||
cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
|
||
} while (cur && !event.isPropagationStopped());
|
||
if (!event.isDefaultPrevented()) {
|
||
var old, special = jQuery.event.special[type] || {};
|
||
if ((!special._default || special._default.call(elem.ownerDocument, event) === false) && !(type === "click" && jQuery.nodeName(elem, "a")) && jQuery.acceptData(elem)) {
|
||
(function _forin_body_extra_3(ontype) { var old; try {
|
||
if (ontype && elem[type]) {
|
||
old = elem[ontype];
|
||
if (old) {
|
||
elem[ontype] = null;
|
||
}
|
||
jQuery.event.triggered = type;
|
||
elem[type]();
|
||
}
|
||
} catch (ieError) {}
|
||
if (old) {
|
||
elem[ontype] = old;
|
||
} })(ontype);
|
||
jQuery.event.triggered = undefined;
|
||
}
|
||
}
|
||
return event.result;
|
||
},
|
||
handle: function anonymous__144(event) {
|
||
event = jQuery.event.fix(event || window.event);
|
||
var handlers = ((jQuery._data(this, "events") || {})[event.type] || []).slice(0), run_all = !event.exclusive && !event.namespace, args = Array.prototype.slice.call(arguments, 0);
|
||
args[0] = event;
|
||
event.currentTarget = this;
|
||
for (var j = 0, l = handlers.length; j < l; j++) {
|
||
var handleObj = handlers[j];
|
||
if (run_all || event.namespace_re.test(handleObj.namespace)) {
|
||
event.handler = handleObj.handler;
|
||
event.data = handleObj.data;
|
||
event.handleObj = handleObj;
|
||
var ret = handleObj.handler.apply(this, args);
|
||
if (ret !== undefined) {
|
||
event.result = ret;
|
||
if (ret === false) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
}
|
||
}
|
||
if (event.isImmediatePropagationStopped()) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return event.result;
|
||
},
|
||
props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
|
||
fix: function anonymous__145(event) {
|
||
if (event[jQuery.expando]) {
|
||
return event;
|
||
}
|
||
var originalEvent = event;
|
||
event = jQuery.Event(originalEvent);
|
||
for (var i = this.props.length, prop; i; ) {
|
||
prop = this.props[--i];
|
||
event[prop] = originalEvent[prop];
|
||
}
|
||
if (!event.target) {
|
||
event.target = event.srcElement || document;
|
||
}
|
||
if (event.target.nodeType === 3) {
|
||
event.target = event.target.parentNode;
|
||
}
|
||
if (!event.relatedTarget && event.fromElement) {
|
||
event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
|
||
}
|
||
if (event.pageX == null && event.clientX != null) {
|
||
var eventDocument = event.target.ownerDocument || document, doc = eventDocument.documentElement, body = eventDocument.body;
|
||
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
|
||
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
|
||
}
|
||
if (event.which == null && (event.charCode != null || event.keyCode != null)) {
|
||
event.which = event.charCode != null ? event.charCode : event.keyCode;
|
||
}
|
||
if (!event.metaKey && event.ctrlKey) {
|
||
event.metaKey = event.ctrlKey;
|
||
}
|
||
if (!event.which && event.button !== undefined) {
|
||
event.which = event.button & 1 ? 1 : event.button & 2 ? 3 : event.button & 4 ? 2 : 0;
|
||
}
|
||
return event;
|
||
},
|
||
guid: 1e8,
|
||
proxy: jQuery.proxy,
|
||
special: {
|
||
ready: {
|
||
setup: jQuery.bindReady,
|
||
teardown: jQuery.noop
|
||
},
|
||
live: {
|
||
add: function anonymous__146(handleObj) {
|
||
jQuery.event.add(this, liveConvert(handleObj.origType, handleObj.selector), jQuery.extend({}, handleObj, {
|
||
handler: liveHandler,
|
||
guid: handleObj.handler.guid
|
||
}));
|
||
},
|
||
remove: function anonymous__147(handleObj) {
|
||
jQuery.event.remove(this, liveConvert(handleObj.origType, handleObj.selector), handleObj);
|
||
}
|
||
},
|
||
beforeunload: {
|
||
setup: function anonymous__148(data, namespaces, eventHandle) {
|
||
if (jQuery.isWindow(this)) {
|
||
this.onbeforeunload = eventHandle;
|
||
}
|
||
},
|
||
teardown: function anonymous__149(namespaces, eventHandle) {
|
||
if (this.onbeforeunload === eventHandle) {
|
||
this.onbeforeunload = null;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
jQuery.removeEvent = document.removeEventListener ? function anonymous__150(elem, type, handle) {
|
||
if (elem.removeEventListener) {
|
||
elem.removeEventListener(type, handle, false);
|
||
}
|
||
} : function anonymous__151(elem, type, handle) {
|
||
if (elem.detachEvent) {
|
||
elem.detachEvent("on" + type, handle);
|
||
}
|
||
};
|
||
jQuery.Event = function anonymous__152(src, props) {
|
||
if (!this.preventDefault) {
|
||
return new jQuery.Event(src, props);
|
||
}
|
||
if (src && src.type) {
|
||
this.originalEvent = src;
|
||
this.type = src.type;
|
||
this.isDefaultPrevented = src.defaultPrevented || src.returnValue === false || src.getPreventDefault && src.getPreventDefault() ? returnTrue : returnFalse;
|
||
} else {
|
||
this.type = src;
|
||
}
|
||
if (props) {
|
||
jQuery.extend(this, props);
|
||
}
|
||
this.timeStamp = jQuery.now();
|
||
this[jQuery.expando] = true;
|
||
};
|
||
function returnFalse() {
|
||
return false;
|
||
}
|
||
function returnTrue() {
|
||
return true;
|
||
}
|
||
jQuery.Event.prototype = {
|
||
preventDefault: function anonymous__153() {
|
||
this.isDefaultPrevented = returnTrue;
|
||
var e = this.originalEvent;
|
||
if (!e) {
|
||
return;
|
||
}
|
||
if (e.preventDefault) {
|
||
e.preventDefault();
|
||
} else {
|
||
e.returnValue = false;
|
||
}
|
||
},
|
||
stopPropagation: function anonymous__154() {
|
||
this.isPropagationStopped = returnTrue;
|
||
var e = this.originalEvent;
|
||
if (!e) {
|
||
return;
|
||
}
|
||
if (e.stopPropagation) {
|
||
e.stopPropagation();
|
||
}
|
||
e.cancelBubble = true;
|
||
},
|
||
stopImmediatePropagation: function anonymous__155() {
|
||
this.isImmediatePropagationStopped = returnTrue;
|
||
this.stopPropagation();
|
||
},
|
||
isDefaultPrevented: returnFalse,
|
||
isPropagationStopped: returnFalse,
|
||
isImmediatePropagationStopped: returnFalse
|
||
};
|
||
var withinElement = function anonymous__156(event) {
|
||
var parent = event.relatedTarget;
|
||
event.type = event.data;
|
||
try {
|
||
if (parent && parent !== document && !parent.parentNode) {
|
||
return;
|
||
}
|
||
while (parent && parent !== this) {
|
||
parent = parent.parentNode;
|
||
}
|
||
if (parent !== this) {
|
||
jQuery.event.handle.apply(this, arguments);
|
||
}
|
||
} catch (e) {}
|
||
}, delegate = function anonymous__157(event) {
|
||
event.type = event.data;
|
||
jQuery.event.handle.apply(this, arguments);
|
||
};
|
||
jQuery.each({
|
||
mouseenter: "mouseover",
|
||
mouseleave: "mouseout"
|
||
}, function anonymous__158(orig, fix) {
|
||
jQuery.event.special[orig] = {
|
||
setup: function anonymous__159(data) {
|
||
jQuery.event.add(this, fix, data && data.selector ? delegate : withinElement, orig);
|
||
},
|
||
teardown: function anonymous__160(data) {
|
||
jQuery.event.remove(this, fix, data && data.selector ? delegate : withinElement);
|
||
}
|
||
};
|
||
});
|
||
if (!jQuery.support.submitBubbles) {
|
||
jQuery.event.special.submit = {
|
||
setup: function anonymous__161(data, namespaces) {
|
||
if (!jQuery.nodeName(this, "form")) {
|
||
jQuery.event.add(this, "click.specialSubmit", function anonymous__162(e) {
|
||
var elem = e.target, type = elem.type;
|
||
if ((type === "submit" || type === "image") && jQuery(elem).closest("form").length) {
|
||
trigger("submit", this, arguments);
|
||
}
|
||
});
|
||
jQuery.event.add(this, "keypress.specialSubmit", function anonymous__163(e) {
|
||
var elem = e.target, type = elem.type;
|
||
if ((type === "text" || type === "password") && jQuery(elem).closest("form").length && e.keyCode === 13) {
|
||
trigger("submit", this, arguments);
|
||
}
|
||
});
|
||
} else {
|
||
return false;
|
||
}
|
||
},
|
||
teardown: function anonymous__164(namespaces) {
|
||
jQuery.event.remove(this, ".specialSubmit");
|
||
}
|
||
};
|
||
}
|
||
if (!jQuery.support.changeBubbles) {
|
||
var changeFilters, getVal = function anonymous__165(elem) {
|
||
var type = elem.type, val = elem.value;
|
||
if (type === "radio" || type === "checkbox") {
|
||
val = elem.checked;
|
||
} else if (type === "select-multiple") {
|
||
val = elem.selectedIndex > -1 ? jQuery.map(elem.options, function anonymous__166(elem) {
|
||
return elem.selected;
|
||
}).join("-") : "";
|
||
} else if (jQuery.nodeName(elem, "select")) {
|
||
val = elem.selectedIndex;
|
||
}
|
||
return val;
|
||
}, testChange = function testChange(e) {
|
||
var elem = e.target, data, val;
|
||
if (!rformElems.test(elem.nodeName) || elem.readOnly) {
|
||
return;
|
||
}
|
||
data = jQuery._data(elem, "_change_data");
|
||
val = getVal(elem);
|
||
if (e.type !== "focusout" || elem.type !== "radio") {
|
||
jQuery._data(elem, "_change_data", val);
|
||
}
|
||
if (data === undefined || val === data) {
|
||
return;
|
||
}
|
||
if (data != null || val) {
|
||
e.type = "change";
|
||
e.liveFired = undefined;
|
||
jQuery.event.trigger(e, arguments[1], elem);
|
||
}
|
||
};
|
||
jQuery.event.special.change = {
|
||
filters: {
|
||
focusout: testChange,
|
||
beforedeactivate: testChange,
|
||
click: function anonymous__167(e) {
|
||
var elem = e.target, type = jQuery.nodeName(elem, "input") ? elem.type : "";
|
||
if (type === "radio" || type === "checkbox" || jQuery.nodeName(elem, "select")) {
|
||
testChange.call(this, e);
|
||
}
|
||
},
|
||
keydown: function anonymous__168(e) {
|
||
var elem = e.target, type = jQuery.nodeName(elem, "input") ? elem.type : "";
|
||
if (e.keyCode === 13 && !jQuery.nodeName(elem, "textarea") || e.keyCode === 32 && (type === "checkbox" || type === "radio") || type === "select-multiple") {
|
||
testChange.call(this, e);
|
||
}
|
||
},
|
||
beforeactivate: function anonymous__169(e) {
|
||
var elem = e.target;
|
||
jQuery._data(elem, "_change_data", getVal(elem));
|
||
}
|
||
},
|
||
setup: function anonymous__170(data, namespaces) {
|
||
if (this.type === "file") {
|
||
return false;
|
||
}
|
||
for (var type in changeFilters) {
|
||
jQuery.event.add(this, type + ".specialChange", changeFilters[type]);
|
||
}
|
||
return rformElems.test(this.nodeName);
|
||
},
|
||
teardown: function anonymous__171(namespaces) {
|
||
jQuery.event.remove(this, ".specialChange");
|
||
return rformElems.test(this.nodeName);
|
||
}
|
||
};
|
||
changeFilters = jQuery.event.special.change.filters;
|
||
changeFilters.focus = changeFilters.beforeactivate;
|
||
}
|
||
function trigger(type, elem, args) {
|
||
var event = jQuery.extend({}, args[0]);
|
||
event.type = type;
|
||
event.originalEvent = {};
|
||
event.liveFired = undefined;
|
||
jQuery.event.handle.call(elem, event);
|
||
if (event.isDefaultPrevented()) {
|
||
args[0].preventDefault();
|
||
}
|
||
}
|
||
if (!jQuery.support.focusinBubbles) {
|
||
jQuery.each({
|
||
focus: "focusin",
|
||
blur: "focusout"
|
||
}, function anonymous__172(orig, fix) {
|
||
var attaches = 0;
|
||
jQuery.event.special[fix] = {
|
||
setup: function anonymous__173() {
|
||
if (attaches++ === 0) {
|
||
document.addEventListener(orig, handler, true);
|
||
}
|
||
},
|
||
teardown: function anonymous__174() {
|
||
if (--attaches === 0) {
|
||
document.removeEventListener(orig, handler, true);
|
||
}
|
||
}
|
||
};
|
||
function handler(donor) {
|
||
var e = jQuery.event.fix(donor);
|
||
e.type = fix;
|
||
e.originalEvent = {};
|
||
jQuery.event.trigger(e, null, e.target);
|
||
if (e.isDefaultPrevented()) {
|
||
donor.preventDefault();
|
||
}
|
||
}
|
||
});
|
||
}
|
||
jQuery.each([ "bind", "one" ], function anonymous__175(i, name) {
|
||
jQuery.fn[name] = function anonymous__176(type, data, fn) {
|
||
var handler;
|
||
if (typeof type === "object") {
|
||
for (var key in type) {
|
||
(function _forin_body_6(key, thi$) { thi$[name](key, data, type[key], fn); })(key, this);
|
||
}
|
||
return this;
|
||
}
|
||
if (arguments.length === 2 || data === false) {
|
||
fn = data;
|
||
data = undefined;
|
||
}
|
||
if (name === "one") {
|
||
handler = function anonymous__177(event) {
|
||
jQuery(this).unbind(event, handler);
|
||
return fn.apply(this, arguments);
|
||
};
|
||
handler.guid = fn.guid || jQuery.guid++;
|
||
} else {
|
||
handler = fn;
|
||
}
|
||
if (type === "unload" && name !== "one") {
|
||
this.one(type, data, fn);
|
||
} else {
|
||
for (var i = 0, l = this.length; i < l; i++) {
|
||
jQuery.event.add(this[i], type, handler, data);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
});
|
||
jQuery.fn.extend({
|
||
unbind: function anonymous__178(type, fn) {
|
||
if (typeof type === "object" && !type.preventDefault) {
|
||
for (var key in type) {
|
||
(function _forin_body_7(key, thi$) { thi$.unbind(key, type[key]); })(key, this);
|
||
}
|
||
} else {
|
||
for (var i = 0, l = this.length; i < l; i++) {
|
||
jQuery.event.remove(this[i], type, fn);
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
delegate: function anonymous__179(selector, types, data, fn) {
|
||
return this.live(types, data, fn, selector);
|
||
},
|
||
undelegate: function anonymous__180(selector, types, fn) {
|
||
if (arguments.length === 0) {
|
||
return this.unbind("live");
|
||
} else {
|
||
return this.die(types, null, fn, selector);
|
||
}
|
||
},
|
||
trigger: function anonymous__181(type, data) {
|
||
return this.each(function anonymous__182() {
|
||
jQuery.event.trigger(type, data, this);
|
||
});
|
||
},
|
||
triggerHandler: function anonymous__183(type, data) {
|
||
if (this[0]) {
|
||
return jQuery.event.trigger(type, data, this[0], true);
|
||
}
|
||
},
|
||
toggle: function anonymous__184(fn) {
|
||
var args = arguments, guid = fn.guid || jQuery.guid++, i = 0, toggler = function anonymous__185(event) {
|
||
var lastToggle = (jQuery.data(this, "lastToggle" + fn.guid) || 0) % i;
|
||
jQuery.data(this, "lastToggle" + fn.guid, lastToggle + 1);
|
||
event.preventDefault();
|
||
return args[lastToggle].apply(this, arguments) || false;
|
||
};
|
||
toggler.guid = guid;
|
||
while (i < args.length) {
|
||
args[i++].guid = guid;
|
||
}
|
||
return this.click(toggler);
|
||
},
|
||
hover: function anonymous__186(fnOver, fnOut) {
|
||
return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
|
||
}
|
||
});
|
||
var liveMap = {
|
||
focus: "focusin",
|
||
blur: "focusout",
|
||
mouseenter: "mouseover",
|
||
mouseleave: "mouseout"
|
||
};
|
||
jQuery.each([ "live", "die" ], function anonymous__187(i, name) {
|
||
jQuery.fn[name] = function anonymous__188(types, data, fn, origSelector) {
|
||
var type, i = 0, match, namespaces, preType, selector = origSelector || this.selector, context = origSelector ? this : jQuery(this.context);
|
||
if (typeof types === "object" && !types.preventDefault) {
|
||
for (var key in types) {
|
||
(function _forin_body_8(key) { context[name](key, data, types[key], selector); })(key);
|
||
}
|
||
return this;
|
||
}
|
||
if (name === "die" && !types && origSelector && origSelector.charAt(0) === ".") {
|
||
context.unbind(origSelector);
|
||
return this;
|
||
}
|
||
if (data === false || jQuery.isFunction(data)) {
|
||
fn = data || returnFalse;
|
||
data = undefined;
|
||
}
|
||
types = (types || "").split(" ");
|
||
while ((type = types[i++]) != null) {
|
||
match = rnamespaces.exec(type);
|
||
namespaces = "";
|
||
if (match) {
|
||
namespaces = match[0];
|
||
type = type.replace(rnamespaces, "");
|
||
}
|
||
if (type === "hover") {
|
||
types.push("mouseenter" + namespaces, "mouseleave" + namespaces);
|
||
continue;
|
||
}
|
||
preType = type;
|
||
if (liveMap[type]) {
|
||
types.push(liveMap[type] + namespaces);
|
||
type = type + namespaces;
|
||
} else {
|
||
type = (liveMap[type] || type) + namespaces;
|
||
}
|
||
if (name === "live") {
|
||
for (var j = 0, l = context.length; j < l; j++) {
|
||
jQuery.event.add(context[j], "live." + liveConvert(type, selector), {
|
||
data: data,
|
||
selector: selector,
|
||
handler: fn,
|
||
origType: type,
|
||
origHandler: fn,
|
||
preType: preType
|
||
});
|
||
}
|
||
} else {
|
||
context.unbind("live." + liveConvert(type, selector), fn);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
});
|
||
function liveHandler(event) {
|
||
var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret, elems = [], selectors = [], events = jQuery._data(this, "events");
|
||
if (event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click") {
|
||
return;
|
||
}
|
||
if (event.namespace) {
|
||
namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
|
||
}
|
||
event.liveFired = this;
|
||
var live = events.live.slice(0);
|
||
for (j = 0; j < live.length; j++) {
|
||
handleObj = live[j];
|
||
if (handleObj.origType.replace(rnamespaces, "") === event.type) {
|
||
selectors.push(handleObj.selector);
|
||
} else {
|
||
live.splice(j--, 1);
|
||
}
|
||
}
|
||
match = jQuery(event.target).closest(selectors, event.currentTarget);
|
||
for (i = 0, l = match.length; i < l; i++) {
|
||
close = match[i];
|
||
for (j = 0; j < live.length; j++) {
|
||
handleObj = live[j];
|
||
if (close.selector === handleObj.selector && (!namespace || namespace.test(handleObj.namespace)) && !close.elem.disabled) {
|
||
elem = close.elem;
|
||
related = null;
|
||
if (handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave") {
|
||
event.type = handleObj.preType;
|
||
related = jQuery(event.relatedTarget).closest(handleObj.selector)[0];
|
||
if (related && jQuery.contains(elem, related)) {
|
||
related = elem;
|
||
}
|
||
}
|
||
if (!related || related !== elem) {
|
||
elems.push({
|
||
elem: elem,
|
||
handleObj: handleObj,
|
||
level: close.level
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (i = 0, l = elems.length; i < l; i++) {
|
||
match = elems[i];
|
||
if (maxLevel && match.level > maxLevel) {
|
||
break;
|
||
}
|
||
event.currentTarget = match.elem;
|
||
event.data = match.handleObj.data;
|
||
event.handleObj = match.handleObj;
|
||
ret = match.handleObj.origHandler.apply(match.elem, arguments);
|
||
if (ret === false || event.isPropagationStopped()) {
|
||
maxLevel = match.level;
|
||
if (ret === false) {
|
||
stop = false;
|
||
}
|
||
if (event.isImmediatePropagationStopped()) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return stop;
|
||
}
|
||
function liveConvert(type, selector) {
|
||
return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
|
||
}
|
||
jQuery.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").split(" "), function anonymous__189(i, name) {
|
||
jQuery.fn[name] = function anonymous__190(data, fn) {
|
||
if (fn == null) {
|
||
fn = data;
|
||
data = null;
|
||
}
|
||
return arguments.length > 0 ? this.bind(name, data, fn) : this.trigger(name);
|
||
};
|
||
if (jQuery.attrFn) {
|
||
jQuery.attrFn[name] = true;
|
||
}
|
||
});
|
||
(function anonymous__191() {
|
||
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, done = 0, toString = Object.prototype.toString, hasDuplicate = false, baseHasDuplicate = true, rBackslash = /\\/g, rNonWord = /\W/;
|
||
[ 0, 0 ].sort(function anonymous__192() {
|
||
baseHasDuplicate = false;
|
||
return 0;
|
||
});
|
||
var Sizzle = function anonymous__193(selector, context, results, seed) {
|
||
results = results || [];
|
||
context = context || document;
|
||
var origContext = context;
|
||
if (context.nodeType !== 1 && context.nodeType !== 9) {
|
||
return [];
|
||
}
|
||
if (!selector || typeof selector !== "string") {
|
||
return results;
|
||
}
|
||
var m, set, checkSet, extra, ret, cur, pop, i, prune = true, contextXML = Sizzle.isXML(context), parts = [], soFar = selector;
|
||
do {
|
||
chunker.exec("");
|
||
m = chunker.exec(soFar);
|
||
if (m) {
|
||
soFar = m[3];
|
||
parts.push(m[1]);
|
||
if (m[2]) {
|
||
extra = m[3];
|
||
break;
|
||
}
|
||
}
|
||
} while (m);
|
||
if (parts.length > 1 && origPOS.exec(selector)) {
|
||
if (parts.length === 2 && Expr.relative[parts[0]]) {
|
||
set = posProcess(parts[0] + parts[1], context);
|
||
} else {
|
||
set = Expr.relative[parts[0]] ? [ context ] : Sizzle(parts.shift(), context);
|
||
while (parts.length) {
|
||
selector = parts.shift();
|
||
if (Expr.relative[selector]) {
|
||
selector += parts.shift();
|
||
}
|
||
set = posProcess(selector, set);
|
||
}
|
||
}
|
||
} else {
|
||
if (!seed && parts.length > 1 && context.nodeType === 9 && !contextXML && Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1])) {
|
||
ret = Sizzle.find(parts.shift(), context, contextXML);
|
||
context = ret.expr ? Sizzle.filter(ret.expr, ret.set)[0] : ret.set[0];
|
||
}
|
||
if (context) {
|
||
ret = seed ? {
|
||
expr: parts.pop(),
|
||
set: makeArray(seed)
|
||
} : Sizzle.find(parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML);
|
||
set = ret.expr ? Sizzle.filter(ret.expr, ret.set) : ret.set;
|
||
if (parts.length > 0) {
|
||
checkSet = makeArray(set);
|
||
} else {
|
||
prune = false;
|
||
}
|
||
while (parts.length) {
|
||
cur = parts.pop();
|
||
pop = cur;
|
||
if (!Expr.relative[cur]) {
|
||
cur = "";
|
||
} else {
|
||
pop = parts.pop();
|
||
}
|
||
if (pop == null) {
|
||
pop = context;
|
||
}
|
||
Expr.relative[cur](checkSet, pop, contextXML);
|
||
}
|
||
} else {
|
||
checkSet = parts = [];
|
||
}
|
||
}
|
||
if (!checkSet) {
|
||
checkSet = set;
|
||
}
|
||
if (!checkSet) {
|
||
Sizzle.error(cur || selector);
|
||
}
|
||
if (toString.call(checkSet) === "[object Array]") {
|
||
if (!prune) {
|
||
results.push.apply(results, checkSet);
|
||
} else if (context && context.nodeType === 1) {
|
||
for (i = 0; checkSet[i] != null; i++) {
|
||
if (checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i]))) {
|
||
results.push(set[i]);
|
||
}
|
||
}
|
||
} else {
|
||
for (i = 0; checkSet[i] != null; i++) {
|
||
if (checkSet[i] && checkSet[i].nodeType === 1) {
|
||
results.push(set[i]);
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
makeArray(checkSet, results);
|
||
}
|
||
if (extra) {
|
||
Sizzle(extra, origContext, results, seed);
|
||
Sizzle.uniqueSort(results);
|
||
}
|
||
return results;
|
||
};
|
||
Sizzle.uniqueSort = function anonymous__194(results) {
|
||
if (sortOrder) {
|
||
hasDuplicate = baseHasDuplicate;
|
||
results.sort(sortOrder);
|
||
if (hasDuplicate) {
|
||
for (var i = 1; i < results.length; i++) {
|
||
if (results[i] === results[i - 1]) {
|
||
results.splice(i--, 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return results;
|
||
};
|
||
Sizzle.matches = function anonymous__195(expr, set) {
|
||
return Sizzle(expr, null, null, set);
|
||
};
|
||
Sizzle.matchesSelector = function anonymous__196(node, expr) {
|
||
return Sizzle(expr, null, null, [ node ]).length > 0;
|
||
};
|
||
Sizzle.find = function anonymous__197(expr, context, isXML) {
|
||
var set;
|
||
if (!expr) {
|
||
return [];
|
||
}
|
||
for (var i = 0, l = Expr.order.length; i < l; i++) {
|
||
var match, type = Expr.order[i];
|
||
if (match = Expr.leftMatch[type].exec(expr)) {
|
||
var left = match[1];
|
||
match.splice(1, 1);
|
||
if (left.substr(left.length - 1) !== "\\") {
|
||
match[1] = (match[1] || "").replace(rBackslash, "");
|
||
set = Expr.find[type](match, context, isXML);
|
||
if (set != null) {
|
||
expr = expr.replace(Expr.match[type], "");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!set) {
|
||
set = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName("*") : [];
|
||
}
|
||
return {
|
||
set: set,
|
||
expr: expr
|
||
};
|
||
};
|
||
Sizzle.filter = function anonymous__198(expr, set, inplace, not) {
|
||
var match, anyFound, old = expr, result = [], curLoop = set, isXMLFilter = set && set[0] && Sizzle.isXML(set[0]);
|
||
while (expr && set.length) {
|
||
for (var type in Expr.filter) {
|
||
if ((match = Expr.leftMatch[type].exec(expr)) != null && match[2]) {
|
||
var found, item, filter, left;
|
||
filter = Expr.filter[type], left = match[1];
|
||
anyFound = false;
|
||
match.splice(1, 1);
|
||
if (left.substr(left.length - 1) === "\\") {
|
||
continue;
|
||
}
|
||
if (curLoop === result) {
|
||
result = [];
|
||
}
|
||
if (Expr.preFilter[type]) {
|
||
match = Expr.preFilter[type](match, curLoop, inplace, result, not, isXMLFilter);
|
||
if (!match) {
|
||
anyFound = found = true;
|
||
} else if (match === true) {
|
||
continue;
|
||
}
|
||
}
|
||
if (match) {
|
||
var i;
|
||
for (i = 0; (item = curLoop[i]) != null; i++) {
|
||
if (item) {
|
||
found = filter(item, match, i, curLoop);
|
||
var pass;
|
||
pass = not ^ !!found;
|
||
if (inplace && found != null) {
|
||
if (pass) {
|
||
anyFound = true;
|
||
} else {
|
||
curLoop[i] = false;
|
||
}
|
||
} else if (pass) {
|
||
result.push(item);
|
||
anyFound = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (found !== undefined) {
|
||
if (!inplace) {
|
||
curLoop = result;
|
||
}
|
||
expr = expr.replace(Expr.match[type], "");
|
||
if (!anyFound) {
|
||
return [];
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (expr === old) {
|
||
if (anyFound == null) {
|
||
Sizzle.error(expr);
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
old = expr;
|
||
}
|
||
return curLoop;
|
||
};
|
||
Sizzle.error = function anonymous__199(msg) {
|
||
throw "Syntax error, unrecognized expression: " + msg;
|
||
};
|
||
var Expr = Sizzle.selectors = {
|
||
order: [ "ID", "NAME", "TAG" ],
|
||
match: {
|
||
ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
||
CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
||
NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
|
||
ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
|
||
TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
|
||
CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
|
||
POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
|
||
PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
|
||
},
|
||
leftMatch: {},
|
||
attrMap: {
|
||
"class": "className",
|
||
"for": "htmlFor"
|
||
},
|
||
attrHandle: {
|
||
href: function anonymous__200(elem) {
|
||
return elem.getAttribute("href");
|
||
},
|
||
type: function anonymous__201(elem) {
|
||
return elem.getAttribute("type");
|
||
}
|
||
},
|
||
relative: {
|
||
"+": function anonymous__202(checkSet, part) {
|
||
var isPartStr = typeof part === "string", isTag = isPartStr && !rNonWord.test(part), isPartStrNotTag = isPartStr && !isTag;
|
||
if (isTag) {
|
||
part = part.toLowerCase();
|
||
}
|
||
for (var i = 0, l = checkSet.length, elem; i < l; i++) {
|
||
if (elem = checkSet[i]) {
|
||
while ((elem = elem.previousSibling) && elem.nodeType !== 1) {}
|
||
checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ? elem || false : elem === part;
|
||
}
|
||
}
|
||
if (isPartStrNotTag) {
|
||
Sizzle.filter(part, checkSet, true);
|
||
}
|
||
},
|
||
">": function anonymous__203(checkSet, part) {
|
||
var elem, isPartStr = typeof part === "string", i = 0, l = checkSet.length;
|
||
if (isPartStr && !rNonWord.test(part)) {
|
||
part = part.toLowerCase();
|
||
for (; i < l; i++) {
|
||
elem = checkSet[i];
|
||
if (elem) {
|
||
var parent = elem.parentNode;
|
||
checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
|
||
}
|
||
}
|
||
} else {
|
||
for (; i < l; i++) {
|
||
elem = checkSet[i];
|
||
if (elem) {
|
||
checkSet[i] = isPartStr ? elem.parentNode : elem.parentNode === part;
|
||
}
|
||
}
|
||
if (isPartStr) {
|
||
Sizzle.filter(part, checkSet, true);
|
||
}
|
||
}
|
||
},
|
||
"": function anonymous__204(checkSet, part, isXML) {
|
||
var nodeCheck, doneName = done++, checkFn = dirCheck;
|
||
if (typeof part === "string" && !rNonWord.test(part)) {
|
||
part = part.toLowerCase();
|
||
nodeCheck = part;
|
||
checkFn = dirNodeCheck;
|
||
}
|
||
checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
|
||
},
|
||
"~": function anonymous__205(checkSet, part, isXML) {
|
||
var nodeCheck, doneName = done++, checkFn = dirCheck;
|
||
if (typeof part === "string" && !rNonWord.test(part)) {
|
||
part = part.toLowerCase();
|
||
nodeCheck = part;
|
||
checkFn = dirNodeCheck;
|
||
}
|
||
checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
|
||
}
|
||
},
|
||
find: {
|
||
ID: function anonymous__206(match, context, isXML) {
|
||
if (typeof context.getElementById !== "undefined" && !isXML) {
|
||
var m = context.getElementById(match[1]);
|
||
return m && m.parentNode ? [ m ] : [];
|
||
}
|
||
},
|
||
NAME: function anonymous__207(match, context) {
|
||
if (typeof context.getElementsByName !== "undefined") {
|
||
var ret = [], results = context.getElementsByName(match[1]);
|
||
for (var i = 0, l = results.length; i < l; i++) {
|
||
if (results[i].getAttribute("name") === match[1]) {
|
||
ret.push(results[i]);
|
||
}
|
||
}
|
||
return ret.length === 0 ? null : ret;
|
||
}
|
||
},
|
||
TAG: function anonymous__208(match, context) {
|
||
if (typeof context.getElementsByTagName !== "undefined") {
|
||
return context.getElementsByTagName(match[1]);
|
||
}
|
||
}
|
||
},
|
||
preFilter: {
|
||
CLASS: function anonymous__209(match, curLoop, inplace, result, not, isXML) {
|
||
match = " " + match[1].replace(rBackslash, "") + " ";
|
||
if (isXML) {
|
||
return match;
|
||
}
|
||
for (var i = 0, elem; (elem = curLoop[i]) != null; i++) {
|
||
if (elem) {
|
||
if (not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0)) {
|
||
if (!inplace) {
|
||
result.push(elem);
|
||
}
|
||
} else if (inplace) {
|
||
curLoop[i] = false;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
ID: function anonymous__210(match) {
|
||
return match[1].replace(rBackslash, "");
|
||
},
|
||
TAG: function anonymous__211(match, curLoop) {
|
||
return match[1].replace(rBackslash, "").toLowerCase();
|
||
},
|
||
CHILD: function anonymous__212(match) {
|
||
if (match[1] === "nth") {
|
||
if (!match[2]) {
|
||
Sizzle.error(match[0]);
|
||
}
|
||
match[2] = match[2].replace(/^\+|\s*/g, "");
|
||
var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" || !/\D/.test(match[2]) && "0n+" + match[2] || match[2]);
|
||
match[2] = test[1] + (test[2] || 1) - 0;
|
||
match[3] = test[3] - 0;
|
||
} else if (match[2]) {
|
||
Sizzle.error(match[0]);
|
||
}
|
||
match[0] = done++;
|
||
return match;
|
||
},
|
||
ATTR: function anonymous__213(match, curLoop, inplace, result, not, isXML) {
|
||
var name = match[1] = match[1].replace(rBackslash, "");
|
||
if (!isXML && Expr.attrMap[name]) {
|
||
match[1] = Expr.attrMap[name];
|
||
}
|
||
match[4] = (match[4] || match[5] || "").replace(rBackslash, "");
|
||
if (match[2] === "~=") {
|
||
match[4] = " " + match[4] + " ";
|
||
}
|
||
return match;
|
||
},
|
||
PSEUDO: function anonymous__214(match, curLoop, inplace, result, not) {
|
||
if (match[1] === "not") {
|
||
if ((chunker.exec(match[3]) || "").length > 1 || /^\w/.test(match[3])) {
|
||
match[3] = Sizzle(match[3], null, null, curLoop);
|
||
} else {
|
||
var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
|
||
if (!inplace) {
|
||
result.push.apply(result, ret);
|
||
}
|
||
return false;
|
||
}
|
||
} else if (Expr.match.POS.test(match[0]) || Expr.match.CHILD.test(match[0])) {
|
||
return true;
|
||
}
|
||
return match;
|
||
},
|
||
POS: function anonymous__215(match) {
|
||
match.unshift(true);
|
||
return match;
|
||
}
|
||
},
|
||
filters: {
|
||
enabled: function anonymous__216(elem) {
|
||
return elem.disabled === false && elem.type !== "hidden";
|
||
},
|
||
disabled: function anonymous__217(elem) {
|
||
return elem.disabled === true;
|
||
},
|
||
checked: function anonymous__218(elem) {
|
||
return elem.checked === true;
|
||
},
|
||
selected: function anonymous__219(elem) {
|
||
if (elem.parentNode) {
|
||
elem.parentNode.selectedIndex;
|
||
}
|
||
return elem.selected === true;
|
||
},
|
||
parent: function anonymous__220(elem) {
|
||
return !!elem.firstChild;
|
||
},
|
||
empty: function anonymous__221(elem) {
|
||
return !elem.firstChild;
|
||
},
|
||
has: function anonymous__222(elem, i, match) {
|
||
return !!Sizzle(match[3], elem).length;
|
||
},
|
||
header: function anonymous__223(elem) {
|
||
return /h\d/i.test(elem.nodeName);
|
||
},
|
||
text: function anonymous__224(elem) {
|
||
var attr = elem.getAttribute("type"), type = elem.type;
|
||
return elem.nodeName.toLowerCase() === "input" && "text" === type && (attr === type || attr === null);
|
||
},
|
||
radio: function anonymous__225(elem) {
|
||
return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
|
||
},
|
||
checkbox: function anonymous__226(elem) {
|
||
return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
|
||
},
|
||
file: function anonymous__227(elem) {
|
||
return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
|
||
},
|
||
password: function anonymous__228(elem) {
|
||
return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
|
||
},
|
||
submit: function anonymous__229(elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return (name === "input" || name === "button") && "submit" === elem.type;
|
||
},
|
||
image: function anonymous__230(elem) {
|
||
return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
|
||
},
|
||
reset: function anonymous__231(elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return (name === "input" || name === "button") && "reset" === elem.type;
|
||
},
|
||
button: function anonymous__232(elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return name === "input" && "button" === elem.type || name === "button";
|
||
},
|
||
input: function anonymous__233(elem) {
|
||
return /input|select|textarea|button/i.test(elem.nodeName);
|
||
},
|
||
focus: function anonymous__234(elem) {
|
||
return elem === elem.ownerDocument.activeElement;
|
||
}
|
||
},
|
||
setFilters: {
|
||
first: function anonymous__235(elem, i) {
|
||
return i === 0;
|
||
},
|
||
last: function anonymous__236(elem, i, match, array) {
|
||
return i === array.length - 1;
|
||
},
|
||
even: function anonymous__237(elem, i) {
|
||
return i % 2 === 0;
|
||
},
|
||
odd: function anonymous__238(elem, i) {
|
||
return i % 2 === 1;
|
||
},
|
||
lt: function anonymous__239(elem, i, match) {
|
||
return i < match[3] - 0;
|
||
},
|
||
gt: function anonymous__240(elem, i, match) {
|
||
return i > match[3] - 0;
|
||
},
|
||
nth: function anonymous__241(elem, i, match) {
|
||
return match[3] - 0 === i;
|
||
},
|
||
eq: function anonymous__242(elem, i, match) {
|
||
return match[3] - 0 === i;
|
||
}
|
||
},
|
||
filter: {
|
||
PSEUDO: function anonymous__243(elem, match, i, array) {
|
||
var name = match[1], filter = Expr.filters[name];
|
||
if (filter) {
|
||
return filter(elem, i, match, array);
|
||
} else if (name === "contains") {
|
||
return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
|
||
} else if (name === "not") {
|
||
var not = match[3];
|
||
for (var j = 0, l = not.length; j < l; j++) {
|
||
if (not[j] === elem) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
} else {
|
||
Sizzle.error(name);
|
||
}
|
||
},
|
||
CHILD: function anonymous__244(elem, match) {
|
||
var type = match[1], node = elem;
|
||
switch (type) {
|
||
case "only":
|
||
case "first":
|
||
while (node = node.previousSibling) {
|
||
if (node.nodeType === 1) {
|
||
return false;
|
||
}
|
||
}
|
||
if (type === "first") {
|
||
return true;
|
||
}
|
||
node = elem;
|
||
case "last":
|
||
while (node = node.nextSibling) {
|
||
if (node.nodeType === 1) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
case "nth":
|
||
var first = match[2], last = match[3];
|
||
if (first === 1 && last === 0) {
|
||
return true;
|
||
}
|
||
var doneName = match[0], parent = elem.parentNode;
|
||
if (parent && (parent.sizcache !== doneName || !elem.nodeIndex)) {
|
||
var count = 0;
|
||
for (node = parent.firstChild; node; node = node.nextSibling) {
|
||
if (node.nodeType === 1) {
|
||
node.nodeIndex = ++count;
|
||
}
|
||
}
|
||
parent.sizcache = doneName;
|
||
}
|
||
var diff = elem.nodeIndex - last;
|
||
if (first === 0) {
|
||
return diff === 0;
|
||
} else {
|
||
return diff % first === 0 && diff / first >= 0;
|
||
}
|
||
}
|
||
},
|
||
ID: function anonymous__245(elem, match) {
|
||
return elem.nodeType === 1 && elem.getAttribute("id") === match;
|
||
},
|
||
TAG: function anonymous__246(elem, match) {
|
||
return match === "*" && elem.nodeType === 1 || elem.nodeName.toLowerCase() === match;
|
||
},
|
||
CLASS: function anonymous__247(elem, match) {
|
||
return (" " + (elem.className || elem.getAttribute("class")) + " ").indexOf(match) > -1;
|
||
},
|
||
ATTR: function anonymous__248(elem, match) {
|
||
var name = match[1], result = Expr.attrHandle[name] ? Expr.attrHandle[name](elem) : elem[name] != null ? elem[name] : elem.getAttribute(name), value = result + "", type = match[2], check = match[4];
|
||
return result == null ? type === "!=" : type === "=" ? value === check : type === "*=" ? value.indexOf(check) >= 0 : type === "~=" ? (" " + value + " ").indexOf(check) >= 0 : !check ? value && result !== false : type === "!=" ? value !== check : type === "^=" ? value.indexOf(check) === 0 : type === "$=" ? value.substr(value.length - check.length) === check : type === "|=" ? value === check || value.substr(0, check.length + 1) === check + "-" : false;
|
||
},
|
||
POS: function anonymous__249(elem, match, i, array) {
|
||
var name = match[2], filter = Expr.setFilters[name];
|
||
if (filter) {
|
||
return filter(elem, i, match, array);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
var origPOS = Expr.match.POS, fescape = function anonymous__250(all, num) {
|
||
return "\\" + (num - 0 + 1);
|
||
};
|
||
for (var type in Expr.match) {
|
||
(function _forin_body_8(type) { Expr.match[type] = new RegExp(Expr.match[type].source + /(?![^\[]*\])(?![^\(]*\))/.source);
|
||
Expr.leftMatch[type] = new RegExp(/(^(?:.|\r|\n)*?)/.source + Expr.match[type].source.replace(/\\(\d+)/g, fescape)); })(type);
|
||
}
|
||
var makeArray = function anonymous__251(array, results) {
|
||
array = Array.prototype.slice.call(array, 0);
|
||
if (results) {
|
||
results.push.apply(results, array);
|
||
return results;
|
||
}
|
||
return array;
|
||
};
|
||
try {
|
||
Array.prototype.slice.call(document.documentElement.childNodes, 0)[0].nodeType;
|
||
} catch (e) {
|
||
makeArray = function anonymous__252(array, results) {
|
||
var i = 0, ret = results || [];
|
||
if (toString.call(array) === "[object Array]") {
|
||
Array.prototype.push.apply(ret, array);
|
||
} else {
|
||
if (typeof array.length === "number") {
|
||
for (var l = array.length; i < l; i++) {
|
||
ret.push(array[i]);
|
||
}
|
||
} else {
|
||
for (; array[i]; i++) {
|
||
ret.push(array[i]);
|
||
}
|
||
}
|
||
}
|
||
return ret;
|
||
};
|
||
}
|
||
var sortOrder, siblingCheck;
|
||
if (document.documentElement.compareDocumentPosition) {
|
||
sortOrder = function anonymous__253(a, b) {
|
||
if (a === b) {
|
||
hasDuplicate = true;
|
||
return 0;
|
||
}
|
||
if (!a.compareDocumentPosition || !b.compareDocumentPosition) {
|
||
return a.compareDocumentPosition ? -1 : 1;
|
||
}
|
||
return a.compareDocumentPosition(b) & 4 ? -1 : 1;
|
||
};
|
||
} else {
|
||
sortOrder = function anonymous__254(a, b) {
|
||
if (a === b) {
|
||
hasDuplicate = true;
|
||
return 0;
|
||
} else if (a.sourceIndex && b.sourceIndex) {
|
||
return a.sourceIndex - b.sourceIndex;
|
||
}
|
||
var al, bl, ap = [], bp = [], aup = a.parentNode, bup = b.parentNode, cur = aup;
|
||
if (aup === bup) {
|
||
return siblingCheck(a, b);
|
||
} else if (!aup) {
|
||
return -1;
|
||
} else if (!bup) {
|
||
return 1;
|
||
}
|
||
while (cur) {
|
||
ap.unshift(cur);
|
||
cur = cur.parentNode;
|
||
}
|
||
cur = bup;
|
||
while (cur) {
|
||
bp.unshift(cur);
|
||
cur = cur.parentNode;
|
||
}
|
||
al = ap.length;
|
||
bl = bp.length;
|
||
for (var i = 0; i < al && i < bl; i++) {
|
||
if (ap[i] !== bp[i]) {
|
||
return siblingCheck(ap[i], bp[i]);
|
||
}
|
||
}
|
||
return i === al ? siblingCheck(a, bp[i], -1) : siblingCheck(ap[i], b, 1);
|
||
};
|
||
siblingCheck = function anonymous__255(a, b, ret) {
|
||
if (a === b) {
|
||
return ret;
|
||
}
|
||
var cur = a.nextSibling;
|
||
while (cur) {
|
||
if (cur === b) {
|
||
return -1;
|
||
}
|
||
cur = cur.nextSibling;
|
||
}
|
||
return 1;
|
||
};
|
||
}
|
||
Sizzle.getText = function anonymous__256(elems) {
|
||
var ret = "", elem;
|
||
for (var i = 0; elems[i]; i++) {
|
||
elem = elems[i];
|
||
if (elem.nodeType === 3 || elem.nodeType === 4) {
|
||
ret += elem.nodeValue;
|
||
} else if (elem.nodeType !== 8) {
|
||
ret += Sizzle.getText(elem.childNodes);
|
||
}
|
||
}
|
||
return ret;
|
||
};
|
||
(function anonymous__257() {
|
||
var form = document.createElement("div"), id = "script" + (new Date).getTime(), root = document.documentElement;
|
||
form.innerHTML = "<a name='" + id + "'/>";
|
||
root.insertBefore(form, root.firstChild);
|
||
if (document.getElementById(id)) {
|
||
Expr.find.ID = function anonymous__258(match, context, isXML) {
|
||
if (typeof context.getElementById !== "undefined" && !isXML) {
|
||
var m = context.getElementById(match[1]);
|
||
return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [ m ] : undefined : [];
|
||
}
|
||
};
|
||
Expr.filter.ID = function anonymous__259(elem, match) {
|
||
var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
|
||
return elem.nodeType === 1 && node && node.nodeValue === match;
|
||
};
|
||
}
|
||
root.removeChild(form);
|
||
root = form = null;
|
||
})();
|
||
(function anonymous__260() {
|
||
var div = document.createElement("div");
|
||
div.appendChild(document.createComment(""));
|
||
if (div.getElementsByTagName("*").length > 0) {
|
||
Expr.find.TAG = function anonymous__261(match, context) {
|
||
var results = context.getElementsByTagName(match[1]);
|
||
if (match[1] === "*") {
|
||
var tmp = [];
|
||
for (var i = 0; results[i]; i++) {
|
||
if (results[i].nodeType === 1) {
|
||
tmp.push(results[i]);
|
||
}
|
||
}
|
||
results = tmp;
|
||
}
|
||
return results;
|
||
};
|
||
}
|
||
div.innerHTML = "<a href='#'></a>";
|
||
if (div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && div.firstChild.getAttribute("href") !== "#") {
|
||
Expr.attrHandle.href = function anonymous__262(elem) {
|
||
return elem.getAttribute("href", 2);
|
||
};
|
||
}
|
||
div = null;
|
||
})();
|
||
if (document.querySelectorAll) {
|
||
(function anonymous__263() {
|
||
var oldSizzle = Sizzle, div = document.createElement("div"), id = "__sizzle__";
|
||
div.innerHTML = "<p class='TEST'></p>";
|
||
if (div.querySelectorAll && div.querySelectorAll(".TEST").length === 0) {
|
||
return;
|
||
}
|
||
Sizzle = function anonymous__264(query, context, extra, seed) {
|
||
context = context || document;
|
||
if (!seed && !Sizzle.isXML(context)) {
|
||
var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(query);
|
||
if (match && (context.nodeType === 1 || context.nodeType === 9)) {
|
||
if (match[1]) {
|
||
return makeArray(context.getElementsByTagName(query), extra);
|
||
} else if (match[2] && Expr.find.CLASS && context.getElementsByClassName) {
|
||
return makeArray(context.getElementsByClassName(match[2]), extra);
|
||
}
|
||
}
|
||
if (context.nodeType === 9) {
|
||
if (query === "body" && context.body) {
|
||
return makeArray([ context.body ], extra);
|
||
} else if (match && match[3]) {
|
||
var elem = context.getElementById(match[3]);
|
||
if (elem && elem.parentNode) {
|
||
if (elem.id === match[3]) {
|
||
return makeArray([ elem ], extra);
|
||
}
|
||
} else {
|
||
return makeArray([], extra);
|
||
}
|
||
}
|
||
try {
|
||
return makeArray(context.querySelectorAll(query), extra);
|
||
} catch (qsaError) {}
|
||
} else if (context.nodeType === 1 && context.nodeName.toLowerCase() !== "object") {
|
||
var oldContext = context, old = context.getAttribute("id"), nid = old || id, hasParent = context.parentNode, relativeHierarchySelector = /^\s*[+~]/.test(query);
|
||
if (!old) {
|
||
context.setAttribute("id", nid);
|
||
} else {
|
||
nid = nid.replace(/'/g, "\\$&");
|
||
}
|
||
if (relativeHierarchySelector && hasParent) {
|
||
context = context.parentNode;
|
||
}
|
||
try {
|
||
if (!relativeHierarchySelector || hasParent) {
|
||
return makeArray(context.querySelectorAll("[id='" + nid + "'] " + query), extra);
|
||
}
|
||
} catch (pseudoError) {} finally {
|
||
if (!old) {
|
||
oldContext.removeAttribute("id");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return oldSizzle(query, context, extra, seed);
|
||
};
|
||
for (var prop in oldSizzle) {
|
||
(function _forin_body_9(prop) { Sizzle[prop] = oldSizzle[prop]; })(prop);
|
||
}
|
||
div = null;
|
||
})();
|
||
}
|
||
(function anonymous__265() {
|
||
var html = document.documentElement, matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
|
||
if (matches) {
|
||
var disconnectedMatch = !matches.call(document.createElement("div"), "div"), pseudoWorks = false;
|
||
try {
|
||
matches.call(document.documentElement, "[test!='']:sizzle");
|
||
} catch (pseudoError) {
|
||
pseudoWorks = true;
|
||
}
|
||
Sizzle.matchesSelector = function anonymous__266(node, expr) {
|
||
expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
|
||
if (!Sizzle.isXML(node)) {
|
||
try {
|
||
if (pseudoWorks || !Expr.match.PSEUDO.test(expr) && !/!=/.test(expr)) {
|
||
var ret = matches.call(node, expr);
|
||
if (ret || !disconnectedMatch || node.document && node.document.nodeType !== 11) {
|
||
return ret;
|
||
}
|
||
}
|
||
} catch (e) {}
|
||
}
|
||
return Sizzle(expr, null, null, [ node ]).length > 0;
|
||
};
|
||
}
|
||
})();
|
||
(function anonymous__267() {
|
||
var div = document.createElement("div");
|
||
div.innerHTML = "<div class='test e'></div><div class='test'></div>";
|
||
if (!div.getElementsByClassName || div.getElementsByClassName("e").length === 0) {
|
||
return;
|
||
}
|
||
div.lastChild.className = "e";
|
||
if (div.getElementsByClassName("e").length === 1) {
|
||
return;
|
||
}
|
||
Expr.order.splice(1, 0, "CLASS");
|
||
Expr.find.CLASS = function anonymous__268(match, context, isXML) {
|
||
if (typeof context.getElementsByClassName !== "undefined" && !isXML) {
|
||
return context.getElementsByClassName(match[1]);
|
||
}
|
||
};
|
||
div = null;
|
||
})();
|
||
function dirNodeCheck(dir, cur, doneName, checkSet, nodeCheck, isXML) {
|
||
for (var i = 0, l = checkSet.length; i < l; i++) {
|
||
var elem = checkSet[i];
|
||
if (elem) {
|
||
var match = false;
|
||
elem = elem[dir];
|
||
while (elem) {
|
||
if (elem.sizcache === doneName) {
|
||
match = checkSet[elem.sizset];
|
||
break;
|
||
}
|
||
if (elem.nodeType === 1 && !isXML) {
|
||
elem.sizcache = doneName;
|
||
elem.sizset = i;
|
||
}
|
||
if (elem.nodeName.toLowerCase() === cur) {
|
||
match = elem;
|
||
break;
|
||
}
|
||
elem = elem[dir];
|
||
}
|
||
checkSet[i] = match;
|
||
}
|
||
}
|
||
}
|
||
function dirCheck(dir, cur, doneName, checkSet, nodeCheck, isXML) {
|
||
for (var i = 0, l = checkSet.length; i < l; i++) {
|
||
var elem = checkSet[i];
|
||
if (elem) {
|
||
var match = false;
|
||
elem = elem[dir];
|
||
while (elem) {
|
||
if (elem.sizcache === doneName) {
|
||
match = checkSet[elem.sizset];
|
||
break;
|
||
}
|
||
if (elem.nodeType === 1) {
|
||
if (!isXML) {
|
||
elem.sizcache = doneName;
|
||
elem.sizset = i;
|
||
}
|
||
if (typeof cur !== "string") {
|
||
if (elem === cur) {
|
||
match = true;
|
||
break;
|
||
}
|
||
} else if (Sizzle.filter(cur, [ elem ]).length > 0) {
|
||
match = elem;
|
||
break;
|
||
}
|
||
}
|
||
elem = elem[dir];
|
||
}
|
||
checkSet[i] = match;
|
||
}
|
||
}
|
||
}
|
||
if (document.documentElement.contains) {
|
||
Sizzle.contains = function anonymous__269(a, b) {
|
||
return a !== b && (a.contains ? a.contains(b) : true);
|
||
};
|
||
} else if (document.documentElement.compareDocumentPosition) {
|
||
Sizzle.contains = function anonymous__270(a, b) {
|
||
return !!(a.compareDocumentPosition(b) & 16);
|
||
};
|
||
} else {
|
||
Sizzle.contains = function anonymous__271() {
|
||
return false;
|
||
};
|
||
}
|
||
Sizzle.isXML = function anonymous__272(elem) {
|
||
var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
|
||
return documentElement ? documentElement.nodeName !== "HTML" : false;
|
||
};
|
||
var posProcess = function anonymous__273(selector, context) {
|
||
var match, tmpSet = [], later = "", root = context.nodeType ? [ context ] : context;
|
||
while (match = Expr.match.PSEUDO.exec(selector)) {
|
||
later += match[0];
|
||
selector = selector.replace(Expr.match.PSEUDO, "");
|
||
}
|
||
selector = Expr.relative[selector] ? selector + "*" : selector;
|
||
for (var i = 0, l = root.length; i < l; i++) {
|
||
Sizzle(selector, root[i], tmpSet);
|
||
}
|
||
return Sizzle.filter(later, tmpSet);
|
||
};
|
||
jQuery.find = Sizzle;
|
||
jQuery.expr = Sizzle.selectors;
|
||
jQuery.expr[":"] = jQuery.expr.filters;
|
||
jQuery.unique = Sizzle.uniqueSort;
|
||
jQuery.text = Sizzle.getText;
|
||
jQuery.isXMLDoc = Sizzle.isXML;
|
||
jQuery.contains = Sizzle.contains;
|
||
})();
|
||
var runtil = /Until$/, rparentsprev = /^(?:parents|prevUntil|prevAll)/, rmultiselector = /,/, isSimple = /^.[^:#\[\.,]*$/, slice = Array.prototype.slice, POS = jQuery.expr.match.POS, guaranteedUnique = {
|
||
children: true,
|
||
contents: true,
|
||
next: true,
|
||
prev: true
|
||
};
|
||
jQuery.fn.extend({
|
||
find: function anonymous__274(selector) {
|
||
var self = this, i, l;
|
||
if (typeof selector !== "string") {
|
||
return jQuery(selector).filter(function anonymous__275() {
|
||
for (i = 0, l = self.length; i < l; i++) {
|
||
if (jQuery.contains(self[i], this)) {
|
||
return true;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
var ret = this.pushStack("", "find", selector), length, n, r;
|
||
for (i = 0, l = this.length; i < l; i++) {
|
||
length = ret.length;
|
||
jQuery.find(selector, this[i], ret);
|
||
if (i > 0) {
|
||
for (n = length; n < ret.length; n++) {
|
||
for (r = 0; r < length; r++) {
|
||
if (ret[r] === ret[n]) {
|
||
ret.splice(n--, 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return ret;
|
||
},
|
||
has: function anonymous__276(target) {
|
||
var targets = jQuery(target);
|
||
return this.filter(function anonymous__277() {
|
||
for (var i = 0, l = targets.length; i < l; i++) {
|
||
if (jQuery.contains(this, targets[i])) {
|
||
return true;
|
||
}
|
||
}
|
||
});
|
||
},
|
||
not: function anonymous__278(selector) {
|
||
return this.pushStack(winnow(this, selector, false), "not", selector);
|
||
},
|
||
filter: function anonymous__279(selector) {
|
||
return this.pushStack(winnow(this, selector, true), "filter", selector);
|
||
},
|
||
is: function anonymous__280(selector) {
|
||
return !!selector && (typeof selector === "string" ? jQuery.filter(selector, this).length > 0 : this.filter(selector).length > 0);
|
||
},
|
||
closest: function anonymous__281(selectors, context) {
|
||
var ret = [], i, l, cur = this[0];
|
||
if (jQuery.isArray(selectors)) {
|
||
var match, selector, matches = {}, level = 1;
|
||
if (cur && selectors.length) {
|
||
for (i = 0, l = selectors.length; i < l; i++) {
|
||
selector = selectors[i];
|
||
if (!matches[selector]) {
|
||
matches[selector] = POS.test(selector) ? jQuery(selector, context || this.context) : selector;
|
||
}
|
||
}
|
||
while (cur && cur.ownerDocument && cur !== context) {
|
||
for (selector in matches) {
|
||
match = matches[selector];
|
||
if (match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match)) {
|
||
ret.push({
|
||
selector: selector,
|
||
elem: cur,
|
||
level: level
|
||
});
|
||
}
|
||
}
|
||
cur = cur.parentNode;
|
||
level++;
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
var pos = POS.test(selectors) || typeof selectors !== "string" ? jQuery(selectors, context || this.context) : 0;
|
||
for (i = 0, l = this.length; i < l; i++) {
|
||
cur = this[i];
|
||
while (cur) {
|
||
if (pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors)) {
|
||
ret.push(cur);
|
||
break;
|
||
} else {
|
||
cur = cur.parentNode;
|
||
if (!cur || !cur.ownerDocument || cur === context || cur.nodeType === 11) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ret = ret.length > 1 ? jQuery.unique(ret) : ret;
|
||
return this.pushStack(ret, "closest", selectors);
|
||
},
|
||
index: function anonymous__282(elem) {
|
||
if (!elem || typeof elem === "string") {
|
||
return jQuery.inArray(this[0], elem ? jQuery(elem) : this.parent().children());
|
||
}
|
||
return jQuery.inArray(elem.jquery ? elem[0] : elem, this);
|
||
},
|
||
add: function anonymous__283(selector, context) {
|
||
var set = typeof selector === "string" ? jQuery(selector, context) : jQuery.makeArray(selector && selector.nodeType ? [ selector ] : selector), all = jQuery.merge(this.get(), set);
|
||
return this.pushStack(isDisconnected(set[0]) || isDisconnected(all[0]) ? all : jQuery.unique(all));
|
||
},
|
||
andSelf: function anonymous__284() {
|
||
return this.add(this.prevObject);
|
||
}
|
||
});
|
||
function isDisconnected(node) {
|
||
return !node || !node.parentNode || node.parentNode.nodeType === 11;
|
||
}
|
||
jQuery.each({
|
||
parent: function anonymous__285(elem) {
|
||
var parent = elem.parentNode;
|
||
return parent && parent.nodeType !== 11 ? parent : null;
|
||
},
|
||
parents: function anonymous__286(elem) {
|
||
return jQuery.dir(elem, "parentNode");
|
||
},
|
||
parentsUntil: function anonymous__287(elem, i, until) {
|
||
return jQuery.dir(elem, "parentNode", until);
|
||
},
|
||
next: function anonymous__288(elem) {
|
||
return jQuery.nth(elem, 2, "nextSibling");
|
||
},
|
||
prev: function anonymous__289(elem) {
|
||
return jQuery.nth(elem, 2, "previousSibling");
|
||
},
|
||
nextAll: function anonymous__290(elem) {
|
||
return jQuery.dir(elem, "nextSibling");
|
||
},
|
||
prevAll: function anonymous__291(elem) {
|
||
return jQuery.dir(elem, "previousSibling");
|
||
},
|
||
nextUntil: function anonymous__292(elem, i, until) {
|
||
return jQuery.dir(elem, "nextSibling", until);
|
||
},
|
||
prevUntil: function anonymous__293(elem, i, until) {
|
||
return jQuery.dir(elem, "previousSibling", until);
|
||
},
|
||
siblings: function anonymous__294(elem) {
|
||
return jQuery.sibling(elem.parentNode.firstChild, elem);
|
||
},
|
||
children: function anonymous__295(elem) {
|
||
return jQuery.sibling(elem.firstChild);
|
||
},
|
||
contents: function anonymous__296(elem) {
|
||
return jQuery.nodeName(elem, "iframe") ? elem.contentDocument || elem.contentWindow.document : jQuery.makeArray(elem.childNodes);
|
||
}
|
||
}, function anonymous__297(name, fn) {
|
||
jQuery.fn[name] = function anonymous__298(until, selector) {
|
||
var ret = jQuery.map(this, fn, until), args = slice.call(arguments);
|
||
if (!runtil.test(name)) {
|
||
selector = until;
|
||
}
|
||
if (selector && typeof selector === "string") {
|
||
ret = jQuery.filter(selector, ret);
|
||
}
|
||
ret = this.length > 1 && !guaranteedUnique[name] ? jQuery.unique(ret) : ret;
|
||
if ((this.length > 1 || rmultiselector.test(selector)) && rparentsprev.test(name)) {
|
||
ret = ret.reverse();
|
||
}
|
||
return this.pushStack(ret, name, args.join(","));
|
||
};
|
||
});
|
||
jQuery.extend({
|
||
filter: function anonymous__299(expr, elems, not) {
|
||
if (not) {
|
||
expr = ":not(" + expr + ")";
|
||
}
|
||
return elems.length === 1 ? jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : jQuery.find.matches(expr, elems);
|
||
},
|
||
dir: function anonymous__300(elem, dir, until) {
|
||
var matched = [], cur = elem[dir];
|
||
while (cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery(cur).is(until))) {
|
||
if (cur.nodeType === 1) {
|
||
matched.push(cur);
|
||
}
|
||
cur = cur[dir];
|
||
}
|
||
return matched;
|
||
},
|
||
nth: function anonymous__301(cur, result, dir, elem) {
|
||
result = result || 1;
|
||
var num = 0;
|
||
for (; cur; cur = cur[dir]) {
|
||
if (cur.nodeType === 1 && ++num === result) {
|
||
break;
|
||
}
|
||
}
|
||
return cur;
|
||
},
|
||
sibling: function anonymous__302(n, elem) {
|
||
var r = [];
|
||
for (; n; n = n.nextSibling) {
|
||
if (n.nodeType === 1 && n !== elem) {
|
||
r.push(n);
|
||
}
|
||
}
|
||
return r;
|
||
}
|
||
});
|
||
function winnow(elements, qualifier, keep) {
|
||
qualifier = qualifier || 0;
|
||
if (jQuery.isFunction(qualifier)) {
|
||
return jQuery.grep(elements, function anonymous__303(elem, i) {
|
||
var retVal = !!qualifier.call(elem, i, elem);
|
||
return retVal === keep;
|
||
});
|
||
} else if (qualifier.nodeType) {
|
||
return jQuery.grep(elements, function anonymous__304(elem, i) {
|
||
return elem === qualifier === keep;
|
||
});
|
||
} else if (typeof qualifier === "string") {
|
||
var filtered = jQuery.grep(elements, function anonymous__305(elem) {
|
||
return elem.nodeType === 1;
|
||
});
|
||
if (isSimple.test(qualifier)) {
|
||
return jQuery.filter(qualifier, filtered, !keep);
|
||
} else {
|
||
qualifier = jQuery.filter(qualifier, filtered);
|
||
}
|
||
}
|
||
return jQuery.grep(elements, function anonymous__306(elem, i) {
|
||
return jQuery.inArray(elem, qualifier) >= 0 === keep;
|
||
});
|
||
}
|
||
var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, rleadingWhitespace = /^\s+/, rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, rtagName = /<([\w:]+)/, rtbody = /<tbody/i, rhtml = /<|&#?\w+;/, rnocache = /<(?:script|object|embed|option|style)/i, rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptType = /\/(java|ecma)script/i, rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/, wrapMap = {
|
||
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, "", "" ]
|
||
};
|
||
wrapMap.optgroup = wrapMap.option;
|
||
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
||
wrapMap.th = wrapMap.td;
|
||
if (!jQuery.support.htmlSerialize) {
|
||
wrapMap._default = [ 1, "div<div>", "</div>" ];
|
||
}
|
||
jQuery.fn.extend({
|
||
text: function anonymous__307(text) {
|
||
if (jQuery.isFunction(text)) {
|
||
return this.each(function anonymous__308(i) {
|
||
var self = jQuery(this);
|
||
self.text(text.call(this, i, self.text()));
|
||
});
|
||
}
|
||
if (typeof text !== "object" && text !== undefined) {
|
||
return this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(text));
|
||
}
|
||
return jQuery.text(this);
|
||
},
|
||
wrapAll: function anonymous__309(html) {
|
||
if (jQuery.isFunction(html)) {
|
||
return this.each(function anonymous__310(i) {
|
||
jQuery(this).wrapAll(html.call(this, i));
|
||
});
|
||
}
|
||
if (this[0]) {
|
||
var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
|
||
if (this[0].parentNode) {
|
||
wrap.insertBefore(this[0]);
|
||
}
|
||
wrap.map(function anonymous__311() {
|
||
var elem = this;
|
||
while (elem.firstChild && elem.firstChild.nodeType === 1) {
|
||
elem = elem.firstChild;
|
||
}
|
||
return elem;
|
||
}).append(this);
|
||
}
|
||
return this;
|
||
},
|
||
wrapInner: function anonymous__312(html) {
|
||
if (jQuery.isFunction(html)) {
|
||
return this.each(function anonymous__313(i) {
|
||
jQuery(this).wrapInner(html.call(this, i));
|
||
});
|
||
}
|
||
return this.each(function anonymous__314() {
|
||
var self = jQuery(this), contents = self.contents();
|
||
if (contents.length) {
|
||
contents.wrapAll(html);
|
||
} else {
|
||
self.append(html);
|
||
}
|
||
});
|
||
},
|
||
wrap: function anonymous__315(html) {
|
||
return this.each(function anonymous__316() {
|
||
jQuery(this).wrapAll(html);
|
||
});
|
||
},
|
||
unwrap: function anonymous__317() {
|
||
return this.parent().each(function anonymous__318() {
|
||
if (!jQuery.nodeName(this, "body")) {
|
||
jQuery(this).replaceWith(this.childNodes);
|
||
}
|
||
}).end();
|
||
},
|
||
append: function anonymous__319() {
|
||
return this.domManip(arguments, true, function anonymous__320(elem) {
|
||
if (this.nodeType === 1) {
|
||
this.appendChild(elem);
|
||
}
|
||
});
|
||
},
|
||
prepend: function anonymous__321() {
|
||
return this.domManip(arguments, true, function anonymous__322(elem) {
|
||
if (this.nodeType === 1) {
|
||
this.insertBefore(elem, this.firstChild);
|
||
}
|
||
});
|
||
},
|
||
before: function anonymous__323() {
|
||
if (this[0] && this[0].parentNode) {
|
||
return this.domManip(arguments, false, function anonymous__324(elem) {
|
||
this.parentNode.insertBefore(elem, this);
|
||
});
|
||
} else if (arguments.length) {
|
||
var set = jQuery(arguments[0]);
|
||
set.push.apply(set, this.toArray());
|
||
return this.pushStack(set, "before", arguments);
|
||
}
|
||
},
|
||
after: function anonymous__325() {
|
||
if (this[0] && this[0].parentNode) {
|
||
return this.domManip(arguments, false, function anonymous__326(elem) {
|
||
this.parentNode.insertBefore(elem, this.nextSibling);
|
||
});
|
||
} else if (arguments.length) {
|
||
var set = this.pushStack(this, "after", arguments);
|
||
set.push.apply(set, jQuery(arguments[0]).toArray());
|
||
return set;
|
||
}
|
||
},
|
||
remove: function anonymous__327(selector, keepData) {
|
||
for (var i = 0, elem; (elem = this[i]) != null; i++) {
|
||
if (!selector || jQuery.filter(selector, [ elem ]).length) {
|
||
if (!keepData && elem.nodeType === 1) {
|
||
jQuery.cleanData(elem.getElementsByTagName("*"));
|
||
jQuery.cleanData([ elem ]);
|
||
}
|
||
if (elem.parentNode) {
|
||
elem.parentNode.removeChild(elem);
|
||
}
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
empty: function anonymous__328() {
|
||
for (var i = 0, elem; (elem = this[i]) != null; i++) {
|
||
if (elem.nodeType === 1) {
|
||
jQuery.cleanData(elem.getElementsByTagName("*"));
|
||
}
|
||
while (elem.firstChild) {
|
||
elem.removeChild(elem.firstChild);
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
clone: function anonymous__329(dataAndEvents, deepDataAndEvents) {
|
||
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
|
||
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
|
||
return this.map(function anonymous__330() {
|
||
return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
|
||
});
|
||
},
|
||
html: function anonymous__331(value) {
|
||
if (value === undefined) {
|
||
return this[0] && this[0].nodeType === 1 ? this[0].innerHTML.replace(rinlinejQuery, "") : null;
|
||
} else if (typeof value === "string" && !rnocache.test(value) && (jQuery.support.leadingWhitespace || !rleadingWhitespace.test(value)) && !wrapMap[(rtagName.exec(value) || [ "", "" ])[1].toLowerCase()]) {
|
||
value = value.replace(rxhtmlTag, "<$1></$2>");
|
||
try {
|
||
for (var i = 0, l = this.length; i < l; i++) {
|
||
if (this[i].nodeType === 1) {
|
||
jQuery.cleanData(this[i].getElementsByTagName("*"));
|
||
this[i].innerHTML = value;
|
||
}
|
||
}
|
||
} catch (e) {
|
||
this.empty().append(value);
|
||
}
|
||
} else if (jQuery.isFunction(value)) {
|
||
this.each(function anonymous__332(i) {
|
||
var self = jQuery(this);
|
||
self.html(value.call(this, i, self.html()));
|
||
});
|
||
} else {
|
||
this.empty().append(value);
|
||
}
|
||
return this;
|
||
},
|
||
replaceWith: function anonymous__333(value) {
|
||
if (this[0] && this[0].parentNode) {
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function anonymous__334(i) {
|
||
var self = jQuery(this), old = self.html();
|
||
self.replaceWith(value.call(this, i, old));
|
||
});
|
||
}
|
||
if (typeof value !== "string") {
|
||
value = jQuery(value).detach();
|
||
}
|
||
return this.each(function anonymous__335() {
|
||
var next = this.nextSibling, parent = this.parentNode;
|
||
jQuery(this).remove();
|
||
if (next) {
|
||
jQuery(next).before(value);
|
||
} else {
|
||
jQuery(parent).append(value);
|
||
}
|
||
});
|
||
} else {
|
||
return this.length ? this.pushStack(jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value) : this;
|
||
}
|
||
},
|
||
detach: function anonymous__336(selector) {
|
||
return this.remove(selector, true);
|
||
},
|
||
domManip: function anonymous__337(args, table, callback) {
|
||
var results, first, fragment, parent, value = args[0], scripts = [];
|
||
if (!jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test(value)) {
|
||
return this.each(function anonymous__338() {
|
||
jQuery(this).domManip(args, table, callback, true);
|
||
});
|
||
}
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function anonymous__339(i) {
|
||
var self = jQuery(this);
|
||
args[0] = value.call(this, i, table ? self.html() : undefined);
|
||
self.domManip(args, table, callback);
|
||
});
|
||
}
|
||
if (this[0]) {
|
||
parent = value && value.parentNode;
|
||
if (jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length) {
|
||
results = {
|
||
fragment: parent
|
||
};
|
||
} else {
|
||
results = jQuery.buildFragment(args, this, scripts);
|
||
}
|
||
fragment = results.fragment;
|
||
if (fragment.childNodes.length === 1) {
|
||
first = fragment = fragment.firstChild;
|
||
} else {
|
||
first = fragment.firstChild;
|
||
}
|
||
if (first) {
|
||
table = table && jQuery.nodeName(first, "tr");
|
||
for (var i = 0, l = this.length, lastIndex = l - 1; i < l; i++) {
|
||
callback.call(table ? root(this[i], first) : this[i], results.cacheable || l > 1 && i < lastIndex ? jQuery.clone(fragment, true, true) : fragment);
|
||
}
|
||
}
|
||
if (scripts.length) {
|
||
jQuery.each(scripts, evalScript);
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
});
|
||
function root(elem, cur) {
|
||
return jQuery.nodeName(elem, "table") ? elem.getElementsByTagName("tbody")[0] || elem.appendChild(elem.ownerDocument.createElement("tbody")) : elem;
|
||
}
|
||
function cloneCopyEvent(src, dest) {
|
||
if (dest.nodeType !== 1 || !jQuery.hasData(src)) {
|
||
return;
|
||
}
|
||
var internalKey = jQuery.expando, oldData = jQuery.data(src), curData = jQuery.data(dest, oldData);
|
||
if (oldData = oldData[internalKey]) {
|
||
var events = oldData.events;
|
||
curData = curData[internalKey] = jQuery.extend({}, oldData);
|
||
if (events) {
|
||
delete curData.handle;
|
||
curData.events = {};
|
||
for (var type in events) {
|
||
var i;
|
||
for (i = 0, l = events[type].length; i < l; i++) {
|
||
jQuery.event.add(dest, type + (events[type][i].namespace ? "." : "") + events[type][i].namespace, events[type][i], events[type][i].data);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function cloneFixAttributes(src, dest) {
|
||
var nodeName;
|
||
if (dest.nodeType !== 1) {
|
||
return;
|
||
}
|
||
if (dest.clearAttributes) {
|
||
dest.clearAttributes();
|
||
}
|
||
if (dest.mergeAttributes) {
|
||
dest.mergeAttributes(src);
|
||
}
|
||
nodeName = dest.nodeName.toLowerCase();
|
||
if (nodeName === "object") {
|
||
dest.outerHTML = src.outerHTML;
|
||
} else if (nodeName === "input" && (src.type === "checkbox" || src.type === "radio")) {
|
||
if (src.checked) {
|
||
dest.defaultChecked = dest.checked = src.checked;
|
||
}
|
||
if (dest.value !== src.value) {
|
||
dest.value = src.value;
|
||
}
|
||
} else if (nodeName === "option") {
|
||
dest.selected = src.defaultSelected;
|
||
} else if (nodeName === "input" || nodeName === "textarea") {
|
||
dest.defaultValue = src.defaultValue;
|
||
}
|
||
dest.removeAttribute(jQuery.expando);
|
||
}
|
||
jQuery.buildFragment = function anonymous__340(args, nodes, scripts) {
|
||
var fragment, cacheable, cacheresults, doc = nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document;
|
||
if (args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document && args[0].charAt(0) === "<" && !rnocache.test(args[0]) && (jQuery.support.checkClone || !rchecked.test(args[0]))) {
|
||
cacheable = true;
|
||
cacheresults = jQuery.fragments[args[0]];
|
||
if (cacheresults && cacheresults !== 1) {
|
||
fragment = cacheresults;
|
||
}
|
||
}
|
||
if (!fragment) {
|
||
fragment = doc.createDocumentFragment();
|
||
jQuery.clean(args, doc, fragment, scripts);
|
||
}
|
||
if (cacheable) {
|
||
jQuery.fragments[args[0]] = cacheresults ? fragment : 1;
|
||
}
|
||
return {
|
||
fragment: fragment,
|
||
cacheable: cacheable
|
||
};
|
||
};
|
||
jQuery.fragments = {};
|
||
jQuery.each({
|
||
appendTo: "append",
|
||
prependTo: "prepend",
|
||
insertBefore: "before",
|
||
insertAfter: "after",
|
||
replaceAll: "replaceWith"
|
||
}, function anonymous__341(name, original) {
|
||
jQuery.fn[name] = function anonymous__342(selector) {
|
||
var ret = [], insert = jQuery(selector), parent = this.length === 1 && this[0].parentNode;
|
||
if (parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1) {
|
||
insert[original](this[0]);
|
||
return this;
|
||
} else {
|
||
for (var i = 0, l = insert.length; i < l; i++) {
|
||
var elems = (i > 0 ? this.clone(true) : this).get();
|
||
jQuery(insert[i])[original](elems);
|
||
ret = ret.concat(elems);
|
||
}
|
||
return this.pushStack(ret, name, insert.selector);
|
||
}
|
||
};
|
||
});
|
||
function getAll(elem) {
|
||
if ("getElementsByTagName" in elem) {
|
||
return elem.getElementsByTagName("*");
|
||
} else if ("querySelectorAll" in elem) {
|
||
return elem.querySelectorAll("*");
|
||
} else {
|
||
return [];
|
||
}
|
||
}
|
||
function fixDefaultChecked(elem) {
|
||
if (elem.type === "checkbox" || elem.type === "radio") {
|
||
elem.defaultChecked = elem.checked;
|
||
}
|
||
}
|
||
function findInputs(elem) {
|
||
if (jQuery.nodeName(elem, "input")) {
|
||
fixDefaultChecked(elem);
|
||
} else if (elem.getElementsByTagName) {
|
||
jQuery.grep(elem.getElementsByTagName("input"), fixDefaultChecked);
|
||
}
|
||
}
|
||
jQuery.extend({
|
||
clone: function anonymous__343(elem, dataAndEvents, deepDataAndEvents) {
|
||
var clone = elem.cloneNode(true), srcElements, destElements, i;
|
||
if ((!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
|
||
cloneFixAttributes(elem, clone);
|
||
srcElements = getAll(elem);
|
||
destElements = getAll(clone);
|
||
for (i = 0; srcElements[i]; ++i) {
|
||
cloneFixAttributes(srcElements[i], destElements[i]);
|
||
}
|
||
}
|
||
if (dataAndEvents) {
|
||
cloneCopyEvent(elem, clone);
|
||
if (deepDataAndEvents) {
|
||
srcElements = getAll(elem);
|
||
destElements = getAll(clone);
|
||
for (i = 0; srcElements[i]; ++i) {
|
||
cloneCopyEvent(srcElements[i], destElements[i]);
|
||
}
|
||
}
|
||
}
|
||
return clone;
|
||
},
|
||
clean: function anonymous__344(elems, context, fragment, scripts) {
|
||
var checkScriptType;
|
||
context = context || document;
|
||
if (typeof context.createElement === "undefined") {
|
||
context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
|
||
}
|
||
var ret = [], j;
|
||
for (var i = 0, elem; (elem = elems[i]) != null; i++) {
|
||
if (typeof elem === "number") {
|
||
elem += "";
|
||
}
|
||
if (!elem) {
|
||
continue;
|
||
}
|
||
if (typeof elem === "string") {
|
||
if (!rhtml.test(elem)) {
|
||
elem = context.createTextNode(elem);
|
||
} else {
|
||
elem = elem.replace(rxhtmlTag, "<$1></$2>");
|
||
var tag = (rtagName.exec(elem) || [ "", "" ])[1].toLowerCase(), wrap = wrapMap[tag] || wrapMap._default, depth = wrap[0], div = context.createElement("div");
|
||
div.innerHTML = wrap[1] + elem + wrap[2];
|
||
while (depth--) {
|
||
div = div.lastChild;
|
||
}
|
||
if (!jQuery.support.tbody) {
|
||
var hasBody = rtbody.test(elem), tbody = tag === "table" && !hasBody ? div.firstChild && div.firstChild.childNodes : wrap[1] === "<table>" && !hasBody ? div.childNodes : [];
|
||
for (j = tbody.length - 1; j >= 0; --j) {
|
||
if (jQuery.nodeName(tbody[j], "tbody") && !tbody[j].childNodes.length) {
|
||
tbody[j].parentNode.removeChild(tbody[j]);
|
||
}
|
||
}
|
||
}
|
||
if (!jQuery.support.leadingWhitespace && rleadingWhitespace.test(elem)) {
|
||
div.insertBefore(context.createTextNode(rleadingWhitespace.exec(elem)[0]), div.firstChild);
|
||
}
|
||
elem = div.childNodes;
|
||
}
|
||
}
|
||
var len;
|
||
if (!jQuery.support.appendChecked) {
|
||
if (elem[0] && typeof (len = elem.length) === "number") {
|
||
for (j = 0; j < len; j++) {
|
||
findInputs(elem[j]);
|
||
}
|
||
} else {
|
||
findInputs(elem);
|
||
}
|
||
}
|
||
if (elem.nodeType) {
|
||
ret.push(elem);
|
||
} else {
|
||
ret = jQuery.merge(ret, elem);
|
||
}
|
||
}
|
||
if (fragment) {
|
||
checkScriptType = function anonymous__345(elem) {
|
||
return !elem.type || rscriptType.test(elem.type);
|
||
};
|
||
for (i = 0; ret[i]; i++) {
|
||
if (scripts && jQuery.nodeName(ret[i], "script") && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript")) {
|
||
scripts.push(ret[i].parentNode ? ret[i].parentNode.removeChild(ret[i]) : ret[i]);
|
||
} else {
|
||
if (ret[i].nodeType === 1) {
|
||
var jsTags = jQuery.grep(ret[i].getElementsByTagName("script"), checkScriptType);
|
||
ret.splice.apply(ret, [ i + 1, 0 ].concat(jsTags));
|
||
}
|
||
fragment.appendChild(ret[i]);
|
||
}
|
||
}
|
||
}
|
||
return ret;
|
||
},
|
||
cleanData: function anonymous__346(elems) {
|
||
var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special, deleteExpando = jQuery.support.deleteExpando;
|
||
for (var i = 0, elem; (elem = elems[i]) != null; i++) {
|
||
if (elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) {
|
||
continue;
|
||
}
|
||
id = elem[jQuery.expando];
|
||
if (id) {
|
||
data = cache[id] && cache[id][internalKey];
|
||
if (data && data.events) {
|
||
for (var type in data.events) {
|
||
if (special[type]) {
|
||
jQuery.event.remove(elem, type);
|
||
} else {
|
||
jQuery.removeEvent(elem, type, data.handle);
|
||
}
|
||
}
|
||
if (data.handle) {
|
||
data.handle.elem = null;
|
||
}
|
||
}
|
||
if (deleteExpando) {
|
||
delete elem[jQuery.expando];
|
||
} else if (elem.removeAttribute) {
|
||
elem.removeAttribute(jQuery.expando);
|
||
}
|
||
delete cache[id];
|
||
}
|
||
}
|
||
}
|
||
});
|
||
function evalScript(i, elem) {
|
||
if (elem.src) {
|
||
jQuery.ajax({
|
||
url: elem.src,
|
||
async: false,
|
||
dataType: "script"
|
||
});
|
||
} else {
|
||
jQuery.globalEval((elem.text || elem.textContent || elem.innerHTML || "").replace(rcleanScript, "/*$0*/"));
|
||
}
|
||
if (elem.parentNode) {
|
||
elem.parentNode.removeChild(elem);
|
||
}
|
||
}
|
||
var ralpha = /alpha\([^)]*\)/i, ropacity = /opacity=([^)]*)/, rdashAlpha = /-([a-z])/ig, rupper = /([A-Z]|^ms)/g, rnumpx = /^-?\d+(?:px)?$/i, rnum = /^-?\d/, rrelNum = /^[+\-]=/, rrelNumFilter = /[^+\-\.\de]+/g, cssShow = {
|
||
position: "absolute",
|
||
visibility: "hidden",
|
||
display: "block"
|
||
}, cssWidth = [ "Left", "Right" ], cssHeight = [ "Top", "Bottom" ], curCSS, getComputedStyle, currentStyle, fcamelCase = function anonymous__347(all, letter) {
|
||
return letter.toUpperCase();
|
||
};
|
||
jQuery.fn.css = function anonymous__348(name, value) {
|
||
if (arguments.length === 2 && value === undefined) {
|
||
return this;
|
||
}
|
||
return jQuery.access(this, name, value, true, function anonymous__349(elem, name, value) {
|
||
return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
|
||
});
|
||
};
|
||
jQuery.extend({
|
||
cssHooks: {
|
||
opacity: {
|
||
get: function anonymous__350(elem, computed) {
|
||
if (computed) {
|
||
var ret = curCSS(elem, "opacity", "opacity");
|
||
return ret === "" ? "1" : ret;
|
||
} else {
|
||
return elem.style.opacity;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
cssNumber: {
|
||
zIndex: true,
|
||
fontWeight: true,
|
||
opacity: true,
|
||
zoom: true,
|
||
lineHeight: true,
|
||
widows: true,
|
||
orphans: true
|
||
},
|
||
cssProps: {
|
||
"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
|
||
},
|
||
style: function anonymous__351(elem, name, value, extra) {
|
||
if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
|
||
return;
|
||
}
|
||
var ret, type, origName = jQuery.camelCase(name), style = elem.style, hooks = jQuery.cssHooks[origName];
|
||
name = jQuery.cssProps[origName] || origName;
|
||
if (value !== undefined) {
|
||
type = typeof value;
|
||
if (type === "number" && isNaN(value) || value == null) {
|
||
return;
|
||
}
|
||
if (type === "string" && rrelNum.test(value)) {
|
||
value = +value.replace(rrelNumFilter, "") + parseFloat(jQuery.css(elem, name));
|
||
}
|
||
if (type === "number" && !jQuery.cssNumber[origName]) {
|
||
value += "px";
|
||
}
|
||
if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value)) !== undefined) {
|
||
try {
|
||
style[name] = value;
|
||
} catch (e) {}
|
||
}
|
||
} else {
|
||
if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
|
||
return ret;
|
||
}
|
||
return style[name];
|
||
}
|
||
},
|
||
css: function anonymous__352(elem, name, extra) {
|
||
var ret, hooks;
|
||
name = jQuery.camelCase(name);
|
||
hooks = jQuery.cssHooks[name];
|
||
name = jQuery.cssProps[name] || name;
|
||
if (name === "cssFloat") {
|
||
name = "float";
|
||
}
|
||
if (hooks && "get" in hooks && (ret = hooks.get(elem, true, extra)) !== undefined) {
|
||
return ret;
|
||
} else if (curCSS) {
|
||
return curCSS(elem, name);
|
||
}
|
||
},
|
||
swap: function anonymous__353(elem, options, callback) {
|
||
var old = {};
|
||
for (var name in options) {
|
||
(function _forin_body_11(name) { old[name] = elem.style[name];
|
||
elem.style[name] = options[name]; })(name);
|
||
}
|
||
callback.call(elem);
|
||
for (name in options) {
|
||
(function _forin_body_12(name) { elem.style[name] = old[name]; })(name);
|
||
}
|
||
},
|
||
camelCase: function anonymous__354(string) {
|
||
return string.replace(rdashAlpha, fcamelCase);
|
||
}
|
||
});
|
||
jQuery.curCSS = jQuery.css;
|
||
jQuery.each([ "height", "width" ], function anonymous__355(i, name) {
|
||
jQuery.cssHooks[name] = {
|
||
get: function anonymous__356(elem, computed, extra) {
|
||
var val;
|
||
if (computed) {
|
||
if (elem.offsetWidth !== 0) {
|
||
val = getWH(elem, name, extra);
|
||
} else {
|
||
jQuery.swap(elem, cssShow, function anonymous__357() {
|
||
val = getWH(elem, name, extra);
|
||
});
|
||
}
|
||
if (val <= 0) {
|
||
val = curCSS(elem, name, name);
|
||
if (val === "0px" && currentStyle) {
|
||
val = currentStyle(elem, name, name);
|
||
}
|
||
if (val != null) {
|
||
return val === "" || val === "auto" ? "0px" : val;
|
||
}
|
||
}
|
||
if (val < 0 || val == null) {
|
||
val = elem.style[name];
|
||
return val === "" || val === "auto" ? "0px" : val;
|
||
}
|
||
return typeof val === "string" ? val : val + "px";
|
||
}
|
||
},
|
||
set: function anonymous__358(elem, value) {
|
||
if (rnumpx.test(value)) {
|
||
value = parseFloat(value);
|
||
if (value >= 0) {
|
||
return value + "px";
|
||
}
|
||
} else {
|
||
return value;
|
||
}
|
||
}
|
||
};
|
||
});
|
||
if (!jQuery.support.opacity) {
|
||
jQuery.cssHooks.opacity = {
|
||
get: function anonymous__359(elem, computed) {
|
||
return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ? parseFloat(RegExp.$1) / 100 + "" : computed ? "1" : "";
|
||
},
|
||
set: function anonymous__360(elem, value) {
|
||
var style = elem.style, currentStyle = elem.currentStyle;
|
||
style.zoom = 1;
|
||
var opacity = jQuery.isNaN(value) ? "" : "alpha(opacity=" + value * 100 + ")", filter = currentStyle && currentStyle.filter || style.filter || "";
|
||
style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : filter + " " + opacity;
|
||
}
|
||
};
|
||
}
|
||
jQuery(function anonymous__361() {
|
||
if (!jQuery.support.reliableMarginRight) {
|
||
jQuery.cssHooks.marginRight = {
|
||
get: function anonymous__362(elem, computed) {
|
||
var ret;
|
||
jQuery.swap(elem, {
|
||
display: "inline-block"
|
||
}, function anonymous__363() {
|
||
if (computed) {
|
||
ret = curCSS(elem, "margin-right", "marginRight");
|
||
} else {
|
||
ret = elem.style.marginRight;
|
||
}
|
||
});
|
||
return ret;
|
||
}
|
||
};
|
||
}
|
||
});
|
||
if (document.defaultView && document.defaultView.getComputedStyle) {
|
||
getComputedStyle = function anonymous__364(elem, name) {
|
||
var ret, defaultView, computedStyle;
|
||
name = name.replace(rupper, "-$1").toLowerCase();
|
||
if (!(defaultView = elem.ownerDocument.defaultView)) {
|
||
return undefined;
|
||
}
|
||
if (computedStyle = defaultView.getComputedStyle(elem, null)) {
|
||
ret = computedStyle.getPropertyValue(name);
|
||
if (ret === "" && !jQuery.contains(elem.ownerDocument.documentElement, elem)) {
|
||
ret = jQuery.style(elem, name);
|
||
}
|
||
}
|
||
return ret;
|
||
};
|
||
}
|
||
if (document.documentElement.currentStyle) {
|
||
currentStyle = function anonymous__365(elem, name) {
|
||
var left, ret = elem.currentStyle && elem.currentStyle[name], rsLeft = elem.runtimeStyle && elem.runtimeStyle[name], style = elem.style;
|
||
if (!rnumpx.test(ret) && rnum.test(ret)) {
|
||
left = style.left;
|
||
if (rsLeft) {
|
||
elem.runtimeStyle.left = elem.currentStyle.left;
|
||
}
|
||
style.left = name === "fontSize" ? "1em" : ret || 0;
|
||
ret = style.pixelLeft + "px";
|
||
style.left = left;
|
||
if (rsLeft) {
|
||
elem.runtimeStyle.left = rsLeft;
|
||
}
|
||
}
|
||
return ret === "" ? "auto" : ret;
|
||
};
|
||
}
|
||
curCSS = getComputedStyle || currentStyle;
|
||
function getWH(elem, name, extra) {
|
||
var which = name === "width" ? cssWidth : cssHeight, val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
|
||
if (extra === "border") {
|
||
return val;
|
||
}
|
||
jQuery.each(which, function anonymous__366() {
|
||
if (!extra) {
|
||
val -= parseFloat(jQuery.css(elem, "padding" + this)) || 0;
|
||
}
|
||
if (extra === "margin") {
|
||
val += parseFloat(jQuery.css(elem, "margin" + this)) || 0;
|
||
} else {
|
||
val -= parseFloat(jQuery.css(elem, "border" + this + "Width")) || 0;
|
||
}
|
||
});
|
||
return val;
|
||
}
|
||
if (jQuery.expr && jQuery.expr.filters) {
|
||
jQuery.expr.filters.hidden = function anonymous__367(elem) {
|
||
var width = elem.offsetWidth, height = elem.offsetHeight;
|
||
return width === 0 && height === 0 || !jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css(elem, "display")) === "none";
|
||
};
|
||
jQuery.expr.filters.visible = function anonymous__368(elem) {
|
||
return !jQuery.expr.filters.hidden(elem);
|
||
};
|
||
}
|
||
var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rhash = /#.*$/, rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i, rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rquery = /\?/, rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, rselectTextarea = /^(?:select|textarea)/i, rspacesAjax = /\s+/, rts = /([?&])_=[^&]*/, rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/, _load = jQuery.fn.load, prefilters = {}, transports = {}, ajaxLocation, ajaxLocParts;
|
||
try {
|
||
ajaxLocation = location.href;
|
||
} catch (e) {
|
||
ajaxLocation = document.createElement("a");
|
||
ajaxLocation.href = "";
|
||
ajaxLocation = ajaxLocation.href;
|
||
}
|
||
ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];
|
||
function addToPrefiltersOrTransports(structure) {
|
||
return function anonymous__369(dataTypeExpression, func) {
|
||
if (typeof dataTypeExpression !== "string") {
|
||
func = dataTypeExpression;
|
||
dataTypeExpression = "*";
|
||
}
|
||
if (jQuery.isFunction(func)) {
|
||
var dataTypes = dataTypeExpression.toLowerCase().split(rspacesAjax), i = 0, length = dataTypes.length, dataType, list, placeBefore;
|
||
for (; i < length; i++) {
|
||
dataType = dataTypes[i];
|
||
placeBefore = /^\+/.test(dataType);
|
||
if (placeBefore) {
|
||
dataType = dataType.substr(1) || "*";
|
||
}
|
||
list = structure[dataType] = structure[dataType] || [];
|
||
list[placeBefore ? "unshift" : "push"](func);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR, dataType, inspected) {
|
||
dataType = dataType || options.dataTypes[0];
|
||
inspected = inspected || {};
|
||
inspected[dataType] = true;
|
||
var list = structure[dataType], i = 0, length = list ? list.length : 0, executeOnly = structure === prefilters, selection;
|
||
for (; i < length && (executeOnly || !selection); i++) {
|
||
selection = list[i](options, originalOptions, jqXHR);
|
||
if (typeof selection === "string") {
|
||
if (!executeOnly || inspected[selection]) {
|
||
selection = undefined;
|
||
} else {
|
||
options.dataTypes.unshift(selection);
|
||
selection = inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR, selection, inspected);
|
||
}
|
||
}
|
||
}
|
||
if ((executeOnly || !selection) && !inspected["*"]) {
|
||
selection = inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR, "*", inspected);
|
||
}
|
||
return selection;
|
||
}
|
||
jQuery.fn.extend({
|
||
load: function anonymous__370(url, params, callback) {
|
||
if (typeof url !== "string" && _load) {
|
||
return _load.apply(this, arguments);
|
||
} else if (!this.length) {
|
||
return this;
|
||
}
|
||
var off = url.indexOf(" ");
|
||
if (off >= 0) {
|
||
var selector = url.slice(off, url.length);
|
||
url = url.slice(0, off);
|
||
}
|
||
var type = "GET";
|
||
if (params) {
|
||
if (jQuery.isFunction(params)) {
|
||
callback = params;
|
||
params = undefined;
|
||
} else if (typeof params === "object") {
|
||
params = jQuery.param(params, jQuery.ajaxSettings.traditional);
|
||
type = "POST";
|
||
}
|
||
}
|
||
var self = this;
|
||
jQuery.ajax({
|
||
url: url,
|
||
type: type,
|
||
dataType: "html",
|
||
data: params,
|
||
complete: function anonymous__371(jqXHR, status, responseText) {
|
||
responseText = jqXHR.responseText;
|
||
if (jqXHR.isResolved()) {
|
||
jqXHR.done(function anonymous__372(r) {
|
||
responseText = r;
|
||
});
|
||
self.html(selector ? jQuery("<div>").append(responseText.replace(rscript, "")).find(selector) : responseText);
|
||
}
|
||
if (callback) {
|
||
self.each(callback, [ responseText, status, jqXHR ]);
|
||
}
|
||
}
|
||
});
|
||
return this;
|
||
},
|
||
serialize: function anonymous__373() {
|
||
return jQuery.param(this.serializeArray());
|
||
},
|
||
serializeArray: function anonymous__374() {
|
||
return this.map(function anonymous__375() {
|
||
return this.elements ? jQuery.makeArray(this.elements) : this;
|
||
}).filter(function anonymous__376() {
|
||
return this.name && !this.disabled && (this.checked || rselectTextarea.test(this.nodeName) || rinput.test(this.type));
|
||
}).map(function anonymous__377(i, elem) {
|
||
var val = jQuery(this).val();
|
||
return val == null ? null : jQuery.isArray(val) ? jQuery.map(val, function anonymous__378(val, i) {
|
||
return {
|
||
name: elem.name,
|
||
value: val.replace(rCRLF, "\r\n")
|
||
};
|
||
}) : {
|
||
name: elem.name,
|
||
value: val.replace(rCRLF, "\r\n")
|
||
};
|
||
}).get();
|
||
}
|
||
});
|
||
jQuery.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function anonymous__379(i, o) {
|
||
jQuery.fn[o] = function anonymous__380(f) {
|
||
return this.bind(o, f);
|
||
};
|
||
});
|
||
jQuery.each([ "get", "post" ], function anonymous__381(i, method) {
|
||
jQuery[method] = function anonymous__382(url, data, callback, type) {
|
||
if (jQuery.isFunction(data)) {
|
||
type = type || callback;
|
||
callback = data;
|
||
data = undefined;
|
||
}
|
||
return jQuery.ajax({
|
||
type: method,
|
||
url: url,
|
||
data: data,
|
||
success: callback,
|
||
dataType: type
|
||
});
|
||
};
|
||
});
|
||
jQuery.extend({
|
||
getScript: function anonymous__383(url, callback) {
|
||
return jQuery.get(url, undefined, callback, "script");
|
||
},
|
||
getJSON: function anonymous__384(url, data, callback) {
|
||
return jQuery.get(url, data, callback, "json");
|
||
},
|
||
ajaxSetup: function anonymous__385(target, settings) {
|
||
if (!settings) {
|
||
settings = target;
|
||
target = jQuery.extend(true, jQuery.ajaxSettings, settings);
|
||
} else {
|
||
jQuery.extend(true, target, jQuery.ajaxSettings, settings);
|
||
}
|
||
for (var field in {
|
||
context: 1,
|
||
url: 1
|
||
}) {
|
||
if (field in settings) {
|
||
(function _forin_body_12(field) { target[field] = settings[field]; })(field);
|
||
} else if (field in jQuery.ajaxSettings) {
|
||
(function _forin_body_13(field) { target[field] = jQuery.ajaxSettings[field]; })(field);
|
||
}
|
||
}
|
||
return target;
|
||
},
|
||
ajaxSettings: {
|
||
url: ajaxLocation,
|
||
isLocal: rlocalProtocol.test(ajaxLocParts[1]),
|
||
global: true,
|
||
type: "GET",
|
||
contentType: "application/x-www-form-urlencoded",
|
||
processData: true,
|
||
async: true,
|
||
accepts: {
|
||
xml: "application/xml, text/xml",
|
||
html: "text/html",
|
||
text: "text/plain",
|
||
json: "application/json, text/javascript",
|
||
"*": "*/*"
|
||
},
|
||
contents: {
|
||
xml: /xml/,
|
||
html: /html/,
|
||
json: /json/
|
||
},
|
||
responseFields: {
|
||
xml: "responseXML",
|
||
text: "responseText"
|
||
},
|
||
converters: {
|
||
"* text": window.String,
|
||
"text html": true,
|
||
"text json": jQuery.parseJSON,
|
||
"text xml": jQuery.parseXML
|
||
}
|
||
},
|
||
ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
|
||
ajaxTransport: addToPrefiltersOrTransports(transports),
|
||
ajax: function anonymous__386(url, options) {
|
||
if (typeof url === "object") {
|
||
options = url;
|
||
url = undefined;
|
||
}
|
||
options = options || {};
|
||
var s = jQuery.ajaxSetup({}, options), callbackContext = s.context || s, globalEventContext = callbackContext !== s && (callbackContext.nodeType || callbackContext instanceof jQuery) ? jQuery(callbackContext) : jQuery.event, deferred = jQuery.Deferred(), completeDeferred = jQuery._Deferred(), statusCode = s.statusCode || {}, ifModifiedKey, requestHeaders = {}, requestHeadersNames = {}, responseHeadersString, responseHeaders, transport, timeoutTimer, parts, state = 0, fireGlobals, i, jqXHR = {
|
||
readyState: 0,
|
||
setRequestHeader: function anonymous__387(name, value) {
|
||
if (!state) {
|
||
var lname = name.toLowerCase();
|
||
name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
|
||
requestHeaders[name] = value;
|
||
}
|
||
return this;
|
||
},
|
||
getAllResponseHeaders: function anonymous__388() {
|
||
return state === 2 ? responseHeadersString : null;
|
||
},
|
||
getResponseHeader: function anonymous__389(key) {
|
||
var match;
|
||
if (state === 2) {
|
||
if (!responseHeaders) {
|
||
responseHeaders = {};
|
||
while (match = rheaders.exec(responseHeadersString)) {
|
||
responseHeaders[match[1].toLowerCase()] = match[2];
|
||
}
|
||
}
|
||
match = responseHeaders[key.toLowerCase()];
|
||
}
|
||
return match === undefined ? null : match;
|
||
},
|
||
overrideMimeType: function anonymous__390(type) {
|
||
if (!state) {
|
||
s.mimeType = type;
|
||
}
|
||
return this;
|
||
},
|
||
abort: function anonymous__391(statusText) {
|
||
statusText = statusText || "abort";
|
||
if (transport) {
|
||
transport.abort(statusText);
|
||
}
|
||
done(0, statusText);
|
||
return this;
|
||
}
|
||
};
|
||
function done(status, statusText, responses, headers) {
|
||
if (state === 2) {
|
||
return;
|
||
}
|
||
state = 2;
|
||
if (timeoutTimer) {
|
||
clearTimeout(timeoutTimer);
|
||
}
|
||
transport = undefined;
|
||
responseHeadersString = headers || "";
|
||
jqXHR.readyState = status ? 4 : 0;
|
||
var isSuccess, success, error, response = responses ? ajaxHandleResponses(s, jqXHR, responses) : undefined, lastModified, etag;
|
||
if (status >= 200 && status < 300 || status === 304) {
|
||
if (s.ifModified) {
|
||
if (lastModified = jqXHR.getResponseHeader("Last-Modified")) {
|
||
jQuery.lastModified[ifModifiedKey] = lastModified;
|
||
}
|
||
if (etag = jqXHR.getResponseHeader("Etag")) {
|
||
jQuery.etag[ifModifiedKey] = etag;
|
||
}
|
||
}
|
||
if (status === 304) {
|
||
statusText = "notmodified";
|
||
isSuccess = true;
|
||
} else {
|
||
try {
|
||
success = ajaxConvert(s, response);
|
||
statusText = "success";
|
||
isSuccess = true;
|
||
} catch (e) {
|
||
statusText = "parsererror";
|
||
error = e;
|
||
}
|
||
}
|
||
} else {
|
||
error = statusText;
|
||
if (!statusText || status) {
|
||
statusText = "error";
|
||
if (status < 0) {
|
||
status = 0;
|
||
}
|
||
}
|
||
}
|
||
jqXHR.status = status;
|
||
jqXHR.statusText = statusText;
|
||
if (isSuccess) {
|
||
deferred.resolveWith(callbackContext, [ success, statusText, jqXHR ]);
|
||
} else {
|
||
deferred.rejectWith(callbackContext, [ jqXHR, statusText, error ]);
|
||
}
|
||
jqXHR.statusCode(statusCode);
|
||
statusCode = undefined;
|
||
if (fireGlobals) {
|
||
globalEventContext.trigger("ajax" + (isSuccess ? "Success" : "Error"), [ jqXHR, s, isSuccess ? success : error ]);
|
||
}
|
||
completeDeferred.resolveWith(callbackContext, [ jqXHR, statusText ]);
|
||
if (fireGlobals) {
|
||
globalEventContext.trigger("ajaxComplete", [ jqXHR, s ]);
|
||
if (!--jQuery.active) {
|
||
jQuery.event.trigger("ajaxStop");
|
||
}
|
||
}
|
||
}
|
||
deferred.promise(jqXHR);
|
||
jqXHR.success = jqXHR.done;
|
||
jqXHR.error = jqXHR.fail;
|
||
jqXHR.complete = completeDeferred.done;
|
||
jqXHR.statusCode = function anonymous__392(map) {
|
||
if (map) {
|
||
var tmp;
|
||
if (state < 2) {
|
||
for (tmp in map) {
|
||
statusCode[tmp] = [ statusCode[tmp], map[tmp] ];
|
||
}
|
||
} else {
|
||
tmp = map[jqXHR.status];
|
||
jqXHR.then(tmp, tmp);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
s.url = ((url || s.url) + "").replace(rhash, "").replace(rprotocol, ajaxLocParts[1] + "//");
|
||
s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().split(rspacesAjax);
|
||
if (s.crossDomain == null) {
|
||
parts = rurl.exec(s.url.toLowerCase());
|
||
s.crossDomain = !!(parts && (parts[1] != ajaxLocParts[1] || parts[2] != ajaxLocParts[2] || (parts[3] || (parts[1] === "http:" ? 80 : 443)) != (ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? 80 : 443))));
|
||
}
|
||
if (s.data && s.processData && typeof s.data !== "string") {
|
||
s.data = jQuery.param(s.data, s.traditional);
|
||
}
|
||
inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
|
||
if (state === 2) {
|
||
return false;
|
||
}
|
||
fireGlobals = s.global;
|
||
s.type = s.type.toUpperCase();
|
||
s.hasContent = !rnoContent.test(s.type);
|
||
if (fireGlobals && jQuery.active++ === 0) {
|
||
jQuery.event.trigger("ajaxStart");
|
||
}
|
||
if (!s.hasContent) {
|
||
if (s.data) {
|
||
s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
|
||
}
|
||
ifModifiedKey = s.url;
|
||
if (s.cache === false) {
|
||
var ts = jQuery.now(), ret = s.url.replace(rts, "$1_=" + ts);
|
||
s.url = ret + (ret === s.url ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
|
||
}
|
||
}
|
||
if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
|
||
jqXHR.setRequestHeader("Content-Type", s.contentType);
|
||
}
|
||
if (s.ifModified) {
|
||
ifModifiedKey = ifModifiedKey || s.url;
|
||
if (jQuery.lastModified[ifModifiedKey]) {
|
||
jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[ifModifiedKey]);
|
||
}
|
||
if (jQuery.etag[ifModifiedKey]) {
|
||
jqXHR.setRequestHeader("If-None-Match", jQuery.etag[ifModifiedKey]);
|
||
}
|
||
}
|
||
jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", */*; q=0.01" : "") : s.accepts["*"]);
|
||
for (i in s.headers) {
|
||
jqXHR.setRequestHeader(i, s.headers[i]);
|
||
}
|
||
if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {
|
||
jqXHR.abort();
|
||
return false;
|
||
}
|
||
for (i in {
|
||
success: 1,
|
||
error: 1,
|
||
complete: 1
|
||
}) {
|
||
jqXHR[i](s[i]);
|
||
}
|
||
transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
|
||
if (!transport) {
|
||
done(-1, "No Transport");
|
||
} else {
|
||
jqXHR.readyState = 1;
|
||
if (fireGlobals) {
|
||
globalEventContext.trigger("ajaxSend", [ jqXHR, s ]);
|
||
}
|
||
if (s.async && s.timeout > 0) {
|
||
timeoutTimer = setTimeout(function anonymous__393() {
|
||
jqXHR.abort("timeout");
|
||
}, s.timeout);
|
||
}
|
||
try {
|
||
state = 1;
|
||
transport.send(requestHeaders, done);
|
||
} catch (e) {
|
||
if (status < 2) {
|
||
done(-1, e);
|
||
} else {
|
||
jQuery.error(e);
|
||
}
|
||
}
|
||
}
|
||
return jqXHR;
|
||
},
|
||
param: function anonymous__394(a, traditional) {
|
||
var s = [], add = function anonymous__395(key, value) {
|
||
value = jQuery.isFunction(value) ? value() : value;
|
||
s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
|
||
};
|
||
if (traditional === undefined) {
|
||
traditional = jQuery.ajaxSettings.traditional;
|
||
}
|
||
if (jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
|
||
jQuery.each(a, function anonymous__396() {
|
||
add(this.name, this.value);
|
||
});
|
||
} else {
|
||
for (var prefix in a) {
|
||
buildParams(prefix, a[prefix], traditional, add);
|
||
}
|
||
}
|
||
return s.join("&").replace(r20, "+");
|
||
}
|
||
});
|
||
function buildParams(prefix, obj, traditional, add) {
|
||
if (jQuery.isArray(obj)) {
|
||
jQuery.each(obj, function anonymous__397(i, v) {
|
||
if (traditional || rbracket.test(prefix)) {
|
||
add(prefix, v);
|
||
} else {
|
||
buildParams(prefix + "[" + (typeof v === "object" || jQuery.isArray(v) ? i : "") + "]", v, traditional, add);
|
||
}
|
||
});
|
||
} else if (!traditional && obj != null && typeof obj === "object") {
|
||
for (var name in obj) {
|
||
buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
|
||
}
|
||
} else {
|
||
add(prefix, obj);
|
||
}
|
||
}
|
||
jQuery.extend({
|
||
active: 0,
|
||
lastModified: {},
|
||
etag: {}
|
||
});
|
||
function ajaxHandleResponses(s, jqXHR, responses) {
|
||
var contents = s.contents, dataTypes = s.dataTypes, responseFields = s.responseFields, ct, type, finalDataType, firstDataType;
|
||
for (type in responseFields) {
|
||
if (type in responses) {
|
||
jqXHR[responseFields[type]] = responses[type];
|
||
}
|
||
}
|
||
while (dataTypes[0] === "*") {
|
||
dataTypes.shift();
|
||
if (ct === undefined) {
|
||
ct = s.mimeType || jqXHR.getResponseHeader("content-type");
|
||
}
|
||
}
|
||
if (ct) {
|
||
for (type in contents) {
|
||
if (contents[type] && contents[type].test(ct)) {
|
||
dataTypes.unshift(type);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (dataTypes[0] in responses) {
|
||
finalDataType = dataTypes[0];
|
||
} else {
|
||
for (type in responses) {
|
||
if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
|
||
finalDataType = type;
|
||
break;
|
||
}
|
||
if (!firstDataType) {
|
||
firstDataType = type;
|
||
}
|
||
}
|
||
finalDataType = finalDataType || firstDataType;
|
||
}
|
||
if (finalDataType) {
|
||
if (finalDataType !== dataTypes[0]) {
|
||
dataTypes.unshift(finalDataType);
|
||
}
|
||
return responses[finalDataType];
|
||
}
|
||
}
|
||
function ajaxConvert(s, response) {
|
||
if (s.dataFilter) {
|
||
response = s.dataFilter(response, s.dataType);
|
||
}
|
||
var dataTypes = s.dataTypes, converters = {}, i, key, length = dataTypes.length, tmp, current = dataTypes[0], prev, conversion, conv, conv1, conv2;
|
||
for (i = 1; i < length; i++) {
|
||
if (i === 1) {
|
||
for (key in s.converters) {
|
||
if (typeof key === "string") {
|
||
converters[key.toLowerCase()] = s.converters[key];
|
||
}
|
||
}
|
||
}
|
||
prev = current;
|
||
current = dataTypes[i];
|
||
if (current === "*") {
|
||
current = prev;
|
||
} else if (prev !== "*" && prev !== current) {
|
||
conversion = prev + " " + current;
|
||
conv = converters[conversion] || converters["* " + current];
|
||
if (!conv) {
|
||
conv2 = undefined;
|
||
for (conv1 in converters) {
|
||
tmp = conv1.split(" ");
|
||
if (tmp[0] === prev || tmp[0] === "*") {
|
||
conv2 = converters[tmp[1] + " " + current];
|
||
if (conv2) {
|
||
conv1 = converters[conv1];
|
||
if (conv1 === true) {
|
||
conv = conv2;
|
||
} else if (conv2 === true) {
|
||
conv = conv1;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!(conv || conv2)) {
|
||
jQuery.error("No conversion from " + conversion.replace(" ", " to "));
|
||
}
|
||
if (conv !== true) {
|
||
response = conv ? conv(response) : conv2(conv1(response));
|
||
}
|
||
}
|
||
}
|
||
return response;
|
||
}
|
||
var jsc = jQuery.now(), jsre = /(\=)\?(&|$)|\?\?/i;
|
||
jQuery.ajaxSetup({
|
||
jsonp: "callback",
|
||
jsonpCallback: function anonymous__398() {
|
||
return jQuery.expando + "_" + jsc++;
|
||
}
|
||
});
|
||
jQuery.ajaxPrefilter("json jsonp", function anonymous__399(s, originalSettings, jqXHR) {
|
||
var inspectData = s.contentType === "application/x-www-form-urlencoded" && typeof s.data === "string";
|
||
if (s.dataTypes[0] === "jsonp" || s.jsonp !== false && (jsre.test(s.url) || inspectData && jsre.test(s.data))) {
|
||
var responseContainer, jsonpCallback = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback, previous = window[jsonpCallback], url = s.url, data = s.data, replace = "$1" + jsonpCallback + "$2";
|
||
if (s.jsonp !== false) {
|
||
url = url.replace(jsre, replace);
|
||
if (s.url === url) {
|
||
if (inspectData) {
|
||
data = data.replace(jsre, replace);
|
||
}
|
||
if (s.data === data) {
|
||
url += (/\?/.test(url) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
|
||
}
|
||
}
|
||
}
|
||
s.url = url;
|
||
s.data = data;
|
||
window[jsonpCallback] = function anonymous__400(response) {
|
||
responseContainer = [ response ];
|
||
};
|
||
jqXHR.always(function anonymous__401() {
|
||
window[jsonpCallback] = previous;
|
||
if (responseContainer && jQuery.isFunction(previous)) {
|
||
window[jsonpCallback](responseContainer[0]);
|
||
}
|
||
});
|
||
s.converters["script json"] = function anonymous__402() {
|
||
if (!responseContainer) {
|
||
jQuery.error(jsonpCallback + " was not called");
|
||
}
|
||
return responseContainer[0];
|
||
};
|
||
s.dataTypes[0] = "json";
|
||
return "script";
|
||
}
|
||
});
|
||
jQuery.ajaxSetup({
|
||
accepts: {
|
||
script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
|
||
},
|
||
contents: {
|
||
script: /javascript|ecmascript/
|
||
},
|
||
converters: {
|
||
"text script": function anonymous__403(text) {
|
||
jQuery.globalEval(text);
|
||
return text;
|
||
}
|
||
}
|
||
});
|
||
jQuery.ajaxPrefilter("script", function anonymous__404(s) {
|
||
if (s.cache === undefined) {
|
||
s.cache = false;
|
||
}
|
||
if (s.crossDomain) {
|
||
s.type = "GET";
|
||
s.global = false;
|
||
}
|
||
});
|
||
jQuery.ajaxTransport("script", function anonymous__405(s) {
|
||
if (s.crossDomain) {
|
||
var script, head = document.head || document.getElementsByTagName("head")[0] || document.documentElement;
|
||
return {
|
||
send: function anonymous__406(_, callback) {
|
||
script = document.createElement("script");
|
||
script.async = "async";
|
||
if (s.scriptCharset) {
|
||
script.charset = s.scriptCharset;
|
||
}
|
||
script.src = s.url;
|
||
script.onload = script.onreadystatechange = function anonymous__407(_, isAbort) {
|
||
if (isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) {
|
||
script.onload = script.onreadystatechange = null;
|
||
if (head && script.parentNode) {
|
||
head.removeChild(script);
|
||
}
|
||
script = undefined;
|
||
if (!isAbort) {
|
||
callback(200, "success");
|
||
}
|
||
}
|
||
};
|
||
head.insertBefore(script, head.firstChild);
|
||
},
|
||
abort: function anonymous__408() {
|
||
if (script) {
|
||
script.onload(0, 1);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
});
|
||
var xhrOnUnloadAbort = window.ActiveXObject ? function anonymous__409() {
|
||
for (var key in xhrCallbacks) {
|
||
xhrCallbacks[key](0, 1);
|
||
}
|
||
} : false, xhrId = 0, xhrCallbacks;
|
||
function createStandardXHR() {
|
||
try {
|
||
return new window.XMLHttpRequest;
|
||
} catch (e) {}
|
||
}
|
||
function createActiveXHR() {
|
||
try {
|
||
return new window.ActiveXObject("Microsoft.XMLHTTP");
|
||
} catch (e) {}
|
||
}
|
||
jQuery.ajaxSettings.xhr = window.ActiveXObject ? function anonymous__410() {
|
||
return !this.isLocal && createStandardXHR() || createActiveXHR();
|
||
} : createStandardXHR;
|
||
(function anonymous__411(xhr) {
|
||
jQuery.extend(jQuery.support, {
|
||
ajax: !!xhr,
|
||
cors: !!xhr && "withCredentials" in xhr
|
||
});
|
||
})(jQuery.ajaxSettings.xhr());
|
||
if (jQuery.support.ajax) {
|
||
jQuery.ajaxTransport(function anonymous__412(s) {
|
||
if (!s.crossDomain || jQuery.support.cors) {
|
||
var callback;
|
||
return {
|
||
send: function anonymous__413(headers, complete) {
|
||
var xhr = s.xhr(), handle, i;
|
||
if (s.username) {
|
||
xhr.open(s.type, s.url, s.async, s.username, s.password);
|
||
} else {
|
||
xhr.open(s.type, s.url, s.async);
|
||
}
|
||
if (s.xhrFields) {
|
||
for (i in s.xhrFields) {
|
||
xhr[i] = s.xhrFields[i];
|
||
}
|
||
}
|
||
if (s.mimeType && xhr.overrideMimeType) {
|
||
xhr.overrideMimeType(s.mimeType);
|
||
}
|
||
if (!s.crossDomain && !headers["X-Requested-With"]) {
|
||
headers["X-Requested-With"] = "XMLHttpRequest";
|
||
}
|
||
try {
|
||
for (i in headers) {
|
||
xhr.setRequestHeader(i, headers[i]);
|
||
}
|
||
} catch (_) {}
|
||
xhr.send(s.hasContent && s.data || null);
|
||
callback = function anonymous__414(_, isAbort) {
|
||
var status, statusText, responseHeaders, responses, xml;
|
||
try {
|
||
if (callback && (isAbort || xhr.readyState === 4)) {
|
||
callback = undefined;
|
||
if (handle) {
|
||
xhr.onreadystatechange = jQuery.noop;
|
||
if (xhrOnUnloadAbort) {
|
||
delete xhrCallbacks[handle];
|
||
}
|
||
}
|
||
if (isAbort) {
|
||
if (xhr.readyState !== 4) {
|
||
xhr.abort();
|
||
}
|
||
} else {
|
||
status = xhr.status;
|
||
responseHeaders = xhr.getAllResponseHeaders();
|
||
responses = {};
|
||
xml = xhr.responseXML;
|
||
if (xml && xml.documentElement) {
|
||
responses.xml = xml;
|
||
}
|
||
responses.text = xhr.responseText;
|
||
try {
|
||
statusText = xhr.statusText;
|
||
} catch (e) {
|
||
statusText = "";
|
||
}
|
||
if (!status && s.isLocal && !s.crossDomain) {
|
||
status = responses.text ? 200 : 404;
|
||
} else if (status === 1223) {
|
||
status = 204;
|
||
}
|
||
}
|
||
}
|
||
} catch (firefoxAccessException) {
|
||
if (!isAbort) {
|
||
complete(-1, firefoxAccessException);
|
||
}
|
||
}
|
||
if (responses) {
|
||
complete(status, statusText, responses, responseHeaders);
|
||
}
|
||
};
|
||
if (!s.async || xhr.readyState === 4) {
|
||
callback();
|
||
} else {
|
||
handle = ++xhrId;
|
||
if (xhrOnUnloadAbort) {
|
||
if (!xhrCallbacks) {
|
||
xhrCallbacks = {};
|
||
jQuery(window).unload(xhrOnUnloadAbort);
|
||
}
|
||
xhrCallbacks[handle] = callback;
|
||
}
|
||
xhr.onreadystatechange = callback;
|
||
}
|
||
},
|
||
abort: function anonymous__415() {
|
||
if (callback) {
|
||
callback(0, 1);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
});
|
||
}
|
||
var elemdisplay = {}, iframe, iframeDoc, rfxtypes = /^(?:toggle|show|hide)$/, rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i, timerId, fxAttrs = [ [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ], [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ], [ "opacity" ] ], fxNow, requestAnimationFrame = window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame;
|
||
jQuery.fn.extend({
|
||
show: function anonymous__416(speed, easing, callback) {
|
||
var elem, display;
|
||
if (speed || speed === 0) {
|
||
return this.animate(genFx("show", 3), speed, easing, callback);
|
||
} else {
|
||
for (var i = 0, j = this.length; i < j; i++) {
|
||
elem = this[i];
|
||
if (elem.style) {
|
||
display = elem.style.display;
|
||
if (!jQuery._data(elem, "olddisplay") && display === "none") {
|
||
display = elem.style.display = "";
|
||
}
|
||
if (display === "" && jQuery.css(elem, "display") === "none") {
|
||
jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
|
||
}
|
||
}
|
||
}
|
||
for (i = 0; i < j; i++) {
|
||
elem = this[i];
|
||
if (elem.style) {
|
||
display = elem.style.display;
|
||
if (display === "" || display === "none") {
|
||
elem.style.display = jQuery._data(elem, "olddisplay") || "";
|
||
}
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
},
|
||
hide: function anonymous__417(speed, easing, callback) {
|
||
if (speed || speed === 0) {
|
||
return this.animate(genFx("hide", 3), speed, easing, callback);
|
||
} else {
|
||
for (var i = 0, j = this.length; i < j; i++) {
|
||
if (this[i].style) {
|
||
var display = jQuery.css(this[i], "display");
|
||
if (display !== "none" && !jQuery._data(this[i], "olddisplay")) {
|
||
jQuery._data(this[i], "olddisplay", display);
|
||
}
|
||
}
|
||
}
|
||
for (i = 0; i < j; i++) {
|
||
if (this[i].style) {
|
||
this[i].style.display = "none";
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
},
|
||
_toggle: jQuery.fn.toggle,
|
||
toggle: function anonymous__418(fn, fn2, callback) {
|
||
var bool = typeof fn === "boolean";
|
||
if (jQuery.isFunction(fn) && jQuery.isFunction(fn2)) {
|
||
this._toggle.apply(this, arguments);
|
||
} else if (fn == null || bool) {
|
||
this.each(function anonymous__419() {
|
||
var state = bool ? fn : jQuery(this).is(":hidden");
|
||
jQuery(this)[state ? "show" : "hide"]();
|
||
});
|
||
} else {
|
||
this.animate(genFx("toggle", 3), fn, fn2, callback);
|
||
}
|
||
return this;
|
||
},
|
||
fadeTo: function anonymous__420(speed, to, easing, callback) {
|
||
return this.filter(":hidden").css("opacity", 0).show().end().animate({
|
||
opacity: to
|
||
}, speed, easing, callback);
|
||
},
|
||
animate: function anonymous__421(prop, speed, easing, callback) {
|
||
var optall = jQuery.speed(speed, easing, callback);
|
||
if (jQuery.isEmptyObject(prop)) {
|
||
return this.each(optall.complete, [ false ]);
|
||
}
|
||
prop = jQuery.extend({}, prop);
|
||
return this[optall.queue === false ? "each" : "queue"](function anonymous__422() {
|
||
if (optall.queue === false) {
|
||
jQuery._mark(this);
|
||
}
|
||
var opt = jQuery.extend({}, optall), isElement = this.nodeType === 1, hidden = isElement && jQuery(this).is(":hidden"), name, val, p, display, e, parts, start, end, unit;
|
||
opt.animatedProperties = {};
|
||
for (p in prop) {
|
||
name = jQuery.camelCase(p);
|
||
if (p !== name) {
|
||
prop[name] = prop[p];
|
||
delete prop[p];
|
||
}
|
||
val = prop[name];
|
||
if (jQuery.isArray(val)) {
|
||
opt.animatedProperties[name] = val[1];
|
||
val = prop[name] = val[0];
|
||
} else {
|
||
opt.animatedProperties[name] = opt.specialEasing && opt.specialEasing[name] || opt.easing || "swing";
|
||
}
|
||
if (val === "hide" && hidden || val === "show" && !hidden) {
|
||
return opt.complete.call(this);
|
||
}
|
||
if (isElement && (name === "height" || name === "width")) {
|
||
opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
|
||
if (jQuery.css(this, "display") === "inline" && jQuery.css(this, "float") === "none") {
|
||
if (!jQuery.support.inlineBlockNeedsLayout) {
|
||
this.style.display = "inline-block";
|
||
} else {
|
||
display = defaultDisplay(this.nodeName);
|
||
if (display === "inline") {
|
||
this.style.display = "inline-block";
|
||
} else {
|
||
this.style.display = "inline";
|
||
this.style.zoom = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (opt.overflow != null) {
|
||
this.style.overflow = "hidden";
|
||
}
|
||
for (p in prop) {
|
||
e = new jQuery.fx(this, opt, p);
|
||
val = prop[p];
|
||
if (rfxtypes.test(val)) {
|
||
e[val === "toggle" ? hidden ? "show" : "hide" : val]();
|
||
} else {
|
||
parts = rfxnum.exec(val);
|
||
start = e.cur();
|
||
if (parts) {
|
||
end = parseFloat(parts[2]);
|
||
unit = parts[3] || (jQuery.cssNumber[p] ? "" : "px");
|
||
if (unit !== "px") {
|
||
jQuery.style(this, p, (end || 1) + unit);
|
||
start = (end || 1) / e.cur() * start;
|
||
jQuery.style(this, p, start + unit);
|
||
}
|
||
if (parts[1]) {
|
||
end = (parts[1] === "-=" ? -1 : 1) * end + start;
|
||
}
|
||
e.custom(start, end, unit);
|
||
} else {
|
||
e.custom(start, val, "");
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
});
|
||
},
|
||
stop: function anonymous__423(clearQueue, gotoEnd) {
|
||
if (clearQueue) {
|
||
this.queue([]);
|
||
}
|
||
this.each(function anonymous__424() {
|
||
var timers = jQuery.timers, i = timers.length;
|
||
if (!gotoEnd) {
|
||
jQuery._unmark(true, this);
|
||
}
|
||
while (i--) {
|
||
if (timers[i].elem === this) {
|
||
if (gotoEnd) {
|
||
timers[i](true);
|
||
}
|
||
timers.splice(i, 1);
|
||
}
|
||
}
|
||
});
|
||
if (!gotoEnd) {
|
||
this.dequeue();
|
||
}
|
||
return this;
|
||
}
|
||
});
|
||
function createFxNow() {
|
||
setTimeout(clearFxNow, 0);
|
||
return fxNow = jQuery.now();
|
||
}
|
||
function clearFxNow() {
|
||
fxNow = undefined;
|
||
}
|
||
function genFx(type, num) {
|
||
var obj = {};
|
||
jQuery.each(fxAttrs.concat.apply([], fxAttrs.slice(0, num)), function anonymous__425() {
|
||
obj[this] = type;
|
||
});
|
||
return obj;
|
||
}
|
||
jQuery.each({
|
||
slideDown: genFx("show", 1),
|
||
slideUp: genFx("hide", 1),
|
||
slideToggle: genFx("toggle", 1),
|
||
fadeIn: {
|
||
opacity: "show"
|
||
},
|
||
fadeOut: {
|
||
opacity: "hide"
|
||
},
|
||
fadeToggle: {
|
||
opacity: "toggle"
|
||
}
|
||
}, function anonymous__426(name, props) {
|
||
jQuery.fn[name] = function anonymous__427(speed, easing, callback) {
|
||
return this.animate(props, speed, easing, callback);
|
||
};
|
||
});
|
||
jQuery.extend({
|
||
speed: function anonymous__428(speed, easing, fn) {
|
||
var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
|
||
complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
|
||
duration: speed,
|
||
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
|
||
};
|
||
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
|
||
opt.old = opt.complete;
|
||
opt.complete = function anonymous__429(noUnmark) {
|
||
if (opt.queue !== false) {
|
||
jQuery.dequeue(this);
|
||
} else if (noUnmark !== false) {
|
||
jQuery._unmark(this);
|
||
}
|
||
if (jQuery.isFunction(opt.old)) {
|
||
opt.old.call(this);
|
||
}
|
||
};
|
||
return opt;
|
||
},
|
||
easing: {
|
||
linear: function anonymous__430(p, n, firstNum, diff) {
|
||
return firstNum + diff * p;
|
||
},
|
||
swing: function anonymous__431(p, n, firstNum, diff) {
|
||
return (-Math.cos(p * Math.PI) / 2 + .5) * diff + firstNum;
|
||
}
|
||
},
|
||
timers: [],
|
||
fx: function anonymous__432(elem, options, prop) {
|
||
this.options = options;
|
||
this.elem = elem;
|
||
this.prop = prop;
|
||
options.orig = options.orig || {};
|
||
}
|
||
});
|
||
jQuery.fx.prototype = {
|
||
update: function anonymous__433() {
|
||
if (this.options.step) {
|
||
this.options.step.call(this.elem, this.now, this);
|
||
}
|
||
(jQuery.fx.step[this.prop] || jQuery.fx.step._default)(this);
|
||
},
|
||
cur: function anonymous__434() {
|
||
if (this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null)) {
|
||
return this.elem[this.prop];
|
||
}
|
||
var parsed, r = jQuery.css(this.elem, this.prop);
|
||
return isNaN(parsed = parseFloat(r)) ? !r || r === "auto" ? 0 : r : parsed;
|
||
},
|
||
custom: function anonymous__435(from, to, unit) {
|
||
var self = this, fx = jQuery.fx, raf;
|
||
this.startTime = fxNow || createFxNow();
|
||
this.start = from;
|
||
this.end = to;
|
||
this.unit = unit || this.unit || (jQuery.cssNumber[this.prop] ? "" : "px");
|
||
this.now = this.start;
|
||
this.pos = this.state = 0;
|
||
function t(gotoEnd) {
|
||
return self.step(gotoEnd);
|
||
}
|
||
t.elem = this.elem;
|
||
if (t() && jQuery.timers.push(t) && !timerId) {
|
||
if (requestAnimationFrame) {
|
||
timerId = 1;
|
||
raf = function anonymous__436() {
|
||
if (timerId) {
|
||
requestAnimationFrame(raf);
|
||
fx.tick();
|
||
}
|
||
};
|
||
requestAnimationFrame(raf);
|
||
} else {
|
||
timerId = setInterval(fx.tick, fx.interval);
|
||
}
|
||
}
|
||
},
|
||
show: function anonymous__437() {
|
||
this.options.orig[this.prop] = jQuery.style(this.elem, this.prop);
|
||
this.options.show = true;
|
||
this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
|
||
jQuery(this.elem).show();
|
||
},
|
||
hide: function anonymous__438() {
|
||
this.options.orig[this.prop] = jQuery.style(this.elem, this.prop);
|
||
this.options.hide = true;
|
||
this.custom(this.cur(), 0);
|
||
},
|
||
step: function anonymous__439(gotoEnd) {
|
||
var t = fxNow || createFxNow(), done = true, elem = this.elem, options = this.options, i, n;
|
||
if (gotoEnd || t >= options.duration + this.startTime) {
|
||
this.now = this.end;
|
||
this.pos = this.state = 1;
|
||
this.update();
|
||
options.animatedProperties[this.prop] = true;
|
||
for (i in options.animatedProperties) {
|
||
if (options.animatedProperties[i] !== true) {
|
||
done = false;
|
||
}
|
||
}
|
||
if (done) {
|
||
if (options.overflow != null && !jQuery.support.shrinkWrapBlocks) {
|
||
jQuery.each([ "", "X", "Y" ], function anonymous__440(index, value) {
|
||
elem.style["overflow" + value] = options.overflow[index];
|
||
});
|
||
}
|
||
if (options.hide) {
|
||
jQuery(elem).hide();
|
||
}
|
||
if (options.hide || options.show) {
|
||
for (var p in options.animatedProperties) {
|
||
jQuery.style(elem, p, options.orig[p]);
|
||
}
|
||
}
|
||
options.complete.call(elem);
|
||
}
|
||
return false;
|
||
} else {
|
||
if (options.duration == Infinity) {
|
||
this.now = t;
|
||
} else {
|
||
n = t - this.startTime;
|
||
this.state = n / options.duration;
|
||
this.pos = jQuery.easing[options.animatedProperties[this.prop]](this.state, n, 0, 1, options.duration);
|
||
this.now = this.start + (this.end - this.start) * this.pos;
|
||
}
|
||
this.update();
|
||
}
|
||
return true;
|
||
}
|
||
};
|
||
jQuery.extend(jQuery.fx, {
|
||
tick: function anonymous__441() {
|
||
for (var timers = jQuery.timers, i = 0; i < timers.length; ++i) {
|
||
if (!timers[i]()) {
|
||
timers.splice(i--, 1);
|
||
}
|
||
}
|
||
if (!timers.length) {
|
||
jQuery.fx.stop();
|
||
}
|
||
},
|
||
interval: 13,
|
||
stop: function anonymous__442() {
|
||
clearInterval(timerId);
|
||
timerId = null;
|
||
},
|
||
speeds: {
|
||
slow: 600,
|
||
fast: 200,
|
||
_default: 400
|
||
},
|
||
step: {
|
||
opacity: function anonymous__443(fx) {
|
||
jQuery.style(fx.elem, "opacity", fx.now);
|
||
},
|
||
_default: function anonymous__444(fx) {
|
||
if (fx.elem.style && fx.elem.style[fx.prop] != null) {
|
||
fx.elem.style[fx.prop] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
|
||
} else {
|
||
fx.elem[fx.prop] = fx.now;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
if (jQuery.expr && jQuery.expr.filters) {
|
||
jQuery.expr.filters.animated = function anonymous__445(elem) {
|
||
return jQuery.grep(jQuery.timers, function anonymous__446(fn) {
|
||
return elem === fn.elem;
|
||
}).length;
|
||
};
|
||
}
|
||
function defaultDisplay(nodeName) {
|
||
if (!elemdisplay[nodeName]) {
|
||
var elem = jQuery("<" + nodeName + ">").appendTo("body"), display = elem.css("display");
|
||
elem.remove();
|
||
if (display === "none" || display === "") {
|
||
if (!iframe) {
|
||
iframe = document.createElement("iframe");
|
||
iframe.frameBorder = iframe.width = iframe.height = 0;
|
||
}
|
||
document.body.appendChild(iframe);
|
||
if (!iframeDoc || !iframe.createElement) {
|
||
iframeDoc = (iframe.contentWindow || iframe.contentDocument).document;
|
||
iframeDoc.write("<!doctype><html><body></body></html>");
|
||
}
|
||
elem = iframeDoc.createElement(nodeName);
|
||
iframeDoc.body.appendChild(elem);
|
||
display = jQuery.css(elem, "display");
|
||
document.body.removeChild(iframe);
|
||
}
|
||
elemdisplay[nodeName] = display;
|
||
}
|
||
return elemdisplay[nodeName];
|
||
}
|
||
var rtable = /^t(?:able|d|h)$/i, rroot = /^(?:body|html)$/i;
|
||
if ("getBoundingClientRect" in document.documentElement) {
|
||
jQuery.fn.offset = function anonymous__447(options) {
|
||
var elem = this[0], box;
|
||
if (options) {
|
||
return this.each(function anonymous__448(i) {
|
||
jQuery.offset.setOffset(this, options, i);
|
||
});
|
||
}
|
||
if (!elem || !elem.ownerDocument) {
|
||
return null;
|
||
}
|
||
if (elem === elem.ownerDocument.body) {
|
||
return jQuery.offset.bodyOffset(elem);
|
||
}
|
||
try {
|
||
box = elem.getBoundingClientRect();
|
||
} catch (e) {}
|
||
var doc = elem.ownerDocument, docElem = doc.documentElement;
|
||
if (!box || !jQuery.contains(docElem, elem)) {
|
||
return box ? {
|
||
top: box.top,
|
||
left: box.left
|
||
} : {
|
||
top: 0,
|
||
left: 0
|
||
};
|
||
}
|
||
var body = doc.body, win = getWindow(doc), clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, scrollTop = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop, scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft, top = box.top + scrollTop - clientTop, left = box.left + scrollLeft - clientLeft;
|
||
return {
|
||
top: top,
|
||
left: left
|
||
};
|
||
};
|
||
} else {
|
||
jQuery.fn.offset = function anonymous__449(options) {
|
||
var elem = this[0];
|
||
if (options) {
|
||
return this.each(function anonymous__450(i) {
|
||
jQuery.offset.setOffset(this, options, i);
|
||
});
|
||
}
|
||
if (!elem || !elem.ownerDocument) {
|
||
return null;
|
||
}
|
||
if (elem === elem.ownerDocument.body) {
|
||
return jQuery.offset.bodyOffset(elem);
|
||
}
|
||
jQuery.offset.initialize();
|
||
var computedStyle, offsetParent = elem.offsetParent, prevOffsetParent = elem, doc = elem.ownerDocument, docElem = doc.documentElement, body = doc.body, defaultView = doc.defaultView, prevComputedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle, top = elem.offsetTop, left = elem.offsetLeft;
|
||
while ((elem = elem.parentNode) && elem !== body && elem !== docElem) {
|
||
if (jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed") {
|
||
break;
|
||
}
|
||
computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
|
||
top -= elem.scrollTop;
|
||
left -= elem.scrollLeft;
|
||
if (elem === offsetParent) {
|
||
top += elem.offsetTop;
|
||
left += elem.offsetLeft;
|
||
if (jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName))) {
|
||
top += parseFloat(computedStyle.borderTopWidth) || 0;
|
||
left += parseFloat(computedStyle.borderLeftWidth) || 0;
|
||
}
|
||
prevOffsetParent = offsetParent;
|
||
offsetParent = elem.offsetParent;
|
||
}
|
||
if (jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible") {
|
||
top += parseFloat(computedStyle.borderTopWidth) || 0;
|
||
left += parseFloat(computedStyle.borderLeftWidth) || 0;
|
||
}
|
||
prevComputedStyle = computedStyle;
|
||
}
|
||
if (prevComputedStyle.position === "relative" || prevComputedStyle.position === "static") {
|
||
top += body.offsetTop;
|
||
left += body.offsetLeft;
|
||
}
|
||
if (jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed") {
|
||
top += Math.max(docElem.scrollTop, body.scrollTop);
|
||
left += Math.max(docElem.scrollLeft, body.scrollLeft);
|
||
}
|
||
return {
|
||
top: top,
|
||
left: left
|
||
};
|
||
};
|
||
}
|
||
jQuery.offset = {
|
||
initialize: function anonymous__451() {
|
||
var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat(jQuery.css(body, "marginTop")) || 0, html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
|
||
jQuery.extend(container.style, {
|
||
position: "absolute",
|
||
top: 0,
|
||
left: 0,
|
||
margin: 0,
|
||
border: 0,
|
||
width: "1px",
|
||
height: "1px",
|
||
visibility: "hidden"
|
||
});
|
||
container.innerHTML = html;
|
||
body.insertBefore(container, body.firstChild);
|
||
innerDiv = container.firstChild;
|
||
checkDiv = innerDiv.firstChild;
|
||
td = innerDiv.nextSibling.firstChild.firstChild;
|
||
this.doesNotAddBorder = checkDiv.offsetTop !== 5;
|
||
this.doesAddBorderForTableAndCells = td.offsetTop === 5;
|
||
checkDiv.style.position = "fixed";
|
||
checkDiv.style.top = "20px";
|
||
this.supportsFixedPosition = checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15;
|
||
checkDiv.style.position = checkDiv.style.top = "";
|
||
innerDiv.style.overflow = "hidden";
|
||
innerDiv.style.position = "relative";
|
||
this.subtractsBorderForOverflowNotVisible = checkDiv.offsetTop === -5;
|
||
this.doesNotIncludeMarginInBodyOffset = body.offsetTop !== bodyMarginTop;
|
||
body.removeChild(container);
|
||
jQuery.offset.initialize = jQuery.noop;
|
||
},
|
||
bodyOffset: function anonymous__452(body) {
|
||
var top = body.offsetTop, left = body.offsetLeft;
|
||
jQuery.offset.initialize();
|
||
if (jQuery.offset.doesNotIncludeMarginInBodyOffset) {
|
||
top += parseFloat(jQuery.css(body, "marginTop")) || 0;
|
||
left += parseFloat(jQuery.css(body, "marginLeft")) || 0;
|
||
}
|
||
return {
|
||
top: top,
|
||
left: left
|
||
};
|
||
},
|
||
setOffset: function anonymous__453(elem, options, i) {
|
||
var position = jQuery.css(elem, "position");
|
||
if (position === "static") {
|
||
elem.style.position = "relative";
|
||
}
|
||
var curElem = jQuery(elem), curOffset = curElem.offset(), curCSSTop = jQuery.css(elem, "top"), curCSSLeft = jQuery.css(elem, "left"), calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [ curCSSTop, curCSSLeft ]) > -1, props = {}, curPosition = {}, curTop, curLeft;
|
||
if (calculatePosition) {
|
||
curPosition = curElem.position();
|
||
curTop = curPosition.top;
|
||
curLeft = curPosition.left;
|
||
} else {
|
||
curTop = parseFloat(curCSSTop) || 0;
|
||
curLeft = parseFloat(curCSSLeft) || 0;
|
||
}
|
||
if (jQuery.isFunction(options)) {
|
||
options = options.call(elem, i, curOffset);
|
||
}
|
||
if (options.top != null) {
|
||
props.top = options.top - curOffset.top + curTop;
|
||
}
|
||
if (options.left != null) {
|
||
props.left = options.left - curOffset.left + curLeft;
|
||
}
|
||
if ("using" in options) {
|
||
options.using.call(elem, props);
|
||
} else {
|
||
curElem.css(props);
|
||
}
|
||
}
|
||
};
|
||
jQuery.fn.extend({
|
||
position: function anonymous__454() {
|
||
if (!this[0]) {
|
||
return null;
|
||
}
|
||
var elem = this[0], offsetParent = this.offsetParent(), offset = this.offset(), parentOffset = rroot.test(offsetParent[0].nodeName) ? {
|
||
top: 0,
|
||
left: 0
|
||
} : offsetParent.offset();
|
||
offset.top -= parseFloat(jQuery.css(elem, "marginTop")) || 0;
|
||
offset.left -= parseFloat(jQuery.css(elem, "marginLeft")) || 0;
|
||
parentOffset.top += parseFloat(jQuery.css(offsetParent[0], "borderTopWidth")) || 0;
|
||
parentOffset.left += parseFloat(jQuery.css(offsetParent[0], "borderLeftWidth")) || 0;
|
||
return {
|
||
top: offset.top - parentOffset.top,
|
||
left: offset.left - parentOffset.left
|
||
};
|
||
},
|
||
offsetParent: function anonymous__455() {
|
||
return this.map(function anonymous__456() {
|
||
var offsetParent = this.offsetParent || document.body;
|
||
while (offsetParent && !rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") {
|
||
offsetParent = offsetParent.offsetParent;
|
||
}
|
||
return offsetParent;
|
||
});
|
||
}
|
||
});
|
||
jQuery.each([ "Left", "Top" ], function anonymous__457(i, name) {
|
||
var method = "scroll" + name;
|
||
jQuery.fn[method] = function anonymous__458(val) {
|
||
var elem, win;
|
||
if (val === undefined) {
|
||
elem = this[0];
|
||
if (!elem) {
|
||
return null;
|
||
}
|
||
win = getWindow(elem);
|
||
return win ? "pageXOffset" in win ? win[i ? "pageYOffset" : "pageXOffset"] : jQuery.support.boxModel && win.document.documentElement[method] || win.document.body[method] : elem[method];
|
||
}
|
||
return this.each(function anonymous__459() {
|
||
win = getWindow(this);
|
||
if (win) {
|
||
win.scrollTo(!i ? val : jQuery(win).scrollLeft(), i ? val : jQuery(win).scrollTop());
|
||
} else {
|
||
this[method] = val;
|
||
}
|
||
});
|
||
};
|
||
});
|
||
function getWindow(elem) {
|
||
return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 ? elem.defaultView || elem.parentWindow : false;
|
||
}
|
||
jQuery.each([ "Height", "Width" ], function anonymous__460(i, name) {
|
||
var type = name.toLowerCase();
|
||
jQuery.fn["inner" + name] = function anonymous__461() {
|
||
return this[0] ? parseFloat(jQuery.css(this[0], type, "padding")) : null;
|
||
};
|
||
jQuery.fn["outer" + name] = function anonymous__462(margin) {
|
||
return this[0] ? parseFloat(jQuery.css(this[0], type, margin ? "margin" : "border")) : null;
|
||
};
|
||
jQuery.fn[type] = function anonymous__463(size) {
|
||
var elem = this[0];
|
||
if (!elem) {
|
||
return size == null ? null : this;
|
||
}
|
||
if (jQuery.isFunction(size)) {
|
||
return this.each(function anonymous__464(i) {
|
||
var self = jQuery(this);
|
||
self[type](size.call(this, i, self[type]()));
|
||
});
|
||
}
|
||
if (jQuery.isWindow(elem)) {
|
||
var docElemProp = elem.document.documentElement["client" + name];
|
||
return elem.document.compatMode === "CSS1Compat" && docElemProp || elem.document.body["client" + name] || docElemProp;
|
||
} else if (elem.nodeType === 9) {
|
||
return Math.max(elem.documentElement["client" + name], elem.body["scroll" + name], elem.documentElement["scroll" + name], elem.body["offset" + name], elem.documentElement["offset" + name]);
|
||
} else if (size === undefined) {
|
||
var orig = jQuery.css(elem, type), ret = parseFloat(orig);
|
||
return jQuery.isNaN(ret) ? orig : ret;
|
||
} else {
|
||
return this.css(type, typeof size === "string" ? size : size + "px");
|
||
}
|
||
};
|
||
});
|
||
window.jQuery = window.$ = jQuery;
|
||
})(window); |