mirror of
https://github.com/swc-project/swc.git
synced 2024-12-24 06:05:02 +03:00
3007 lines
191 KiB
JavaScript
3007 lines
191 KiB
JavaScript
!function(window1, undefined1) {
|
||
var readyList, rootjQuery1, core_strundefined = "undefined", document1 = window1.document, location = window1.location, _jQuery = window1.jQuery, _$ = window1.$, class2type = {}, core_deletedIds = [], core_version = "1.9.1", core_concat = core_deletedIds.concat, core_push = core_deletedIds.push, core_slice = core_deletedIds.slice, core_indexOf = core_deletedIds.indexOf, core_toString = class2type.toString, core_hasOwn = class2type.hasOwnProperty, core_trim = core_version.trim, jQuery = function(selector, context) {
|
||
return new jQuery.fn.init(selector, context, rootjQuery1);
|
||
}, core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source, core_rnotwhite = /\S+/g, rtrim1 = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, rquickExpr1 = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/, rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, rvalidchars = /^[\],:{}\s]*$/, rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g, rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, fcamelCase = function(all, letter) {
|
||
return letter.toUpperCase();
|
||
}, completed = function(event) {
|
||
(document1.addEventListener || "load" === event.type || "complete" === document1.readyState) && (detach(), jQuery.ready());
|
||
}, detach = function() {
|
||
document1.addEventListener ? (document1.removeEventListener("DOMContentLoaded", completed, !1), window1.removeEventListener("load", completed, !1)) : (document1.detachEvent("onreadystatechange", completed), window1.detachEvent("onload", completed));
|
||
};
|
||
function isArraylike(obj) {
|
||
var length = obj.length, type = jQuery.type(obj);
|
||
return !jQuery.isWindow(obj) && (1 === obj.nodeType && !!length || "array" === type || "function" !== type && (0 === length || "number" == typeof length && length > 0 && length - 1 in obj));
|
||
}
|
||
jQuery.fn = jQuery.prototype = {
|
||
jquery: core_version,
|
||
constructor: jQuery,
|
||
init: function(selector, context, rootjQuery) {
|
||
var match, elem;
|
||
if (!selector) return this;
|
||
if ("string" == typeof selector) {
|
||
if ((match = "<" === selector.charAt(0) && ">" === selector.charAt(selector.length - 1) && selector.length >= 3 ? [
|
||
null,
|
||
selector,
|
||
null
|
||
] : rquickExpr1.exec(selector)) && (match[1] || !context)) {
|
||
if (match[1]) {
|
||
if (context = context instanceof jQuery ? context[0] : context, jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document1, !0)), rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) for(match in context)jQuery.isFunction(this[match]) ? this[match](context[match]) : this.attr(match, context[match]);
|
||
return this;
|
||
}
|
||
if ((elem = document1.getElementById(match[2])) && elem.parentNode) {
|
||
if (elem.id !== match[2]) return rootjQuery.find(selector);
|
||
this.length = 1, this[0] = elem;
|
||
}
|
||
return this.context = document1, this.selector = selector, this;
|
||
}
|
||
return !context || context.jquery ? (context || rootjQuery).find(selector) : this.constructor(context).find(selector);
|
||
}
|
||
return selector.nodeType ? (this.context = this[0] = selector, this.length = 1, this) : jQuery.isFunction(selector) ? rootjQuery.ready(selector) : (undefined1 !== selector.selector && (this.selector = selector.selector, this.context = selector.context), jQuery.makeArray(selector, this));
|
||
},
|
||
selector: "",
|
||
length: 0,
|
||
size: function() {
|
||
return this.length;
|
||
},
|
||
toArray: function() {
|
||
return core_slice.call(this);
|
||
},
|
||
get: function(num) {
|
||
return null == num ? this.toArray() : num < 0 ? this[this.length + num] : this[num];
|
||
},
|
||
pushStack: function(elems) {
|
||
var ret = jQuery.merge(this.constructor(), elems);
|
||
return ret.prevObject = this, ret.context = this.context, ret;
|
||
},
|
||
each: function(callback, args) {
|
||
return jQuery.each(this, callback, args);
|
||
},
|
||
ready: function(fn) {
|
||
return jQuery.ready.promise().done(fn), this;
|
||
},
|
||
slice: function() {
|
||
return this.pushStack(core_slice.apply(this, arguments));
|
||
},
|
||
first: function() {
|
||
return this.eq(0);
|
||
},
|
||
last: function() {
|
||
return this.eq(-1);
|
||
},
|
||
eq: function(i) {
|
||
var len = this.length, j = +i + (i < 0 ? len : 0);
|
||
return this.pushStack(j >= 0 && j < len ? [
|
||
this[j]
|
||
] : []);
|
||
},
|
||
map: function(callback) {
|
||
return this.pushStack(jQuery.map(this, function(elem, i) {
|
||
return callback.call(elem, i, elem);
|
||
}));
|
||
},
|
||
end: function() {
|
||
return this.prevObject || this.constructor(null);
|
||
},
|
||
push: core_push,
|
||
sort: [].sort,
|
||
splice: [].splice
|
||
}, jQuery.fn.init.prototype = jQuery.fn, jQuery.extend = jQuery.fn.extend = function() {
|
||
var src, copyIsArray, copy, name, options, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = !1;
|
||
for("boolean" == typeof target && (deep = target, target = arguments[1] || {}, i = 2), "object" == typeof target || jQuery.isFunction(target) || (target = {}), length === i && (target = this, --i); i < length; i++)if (null != (options = arguments[i])) for(name in options)src = target[name], copy = options[name], target !== copy && (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy))) ? (copyIsArray ? (copyIsArray = !1, clone = src && jQuery.isArray(src) ? src : []) : clone = src && jQuery.isPlainObject(src) ? src : {}, target[name] = jQuery.extend(deep, clone, copy)) : copy !== undefined1 && (target[name] = copy));
|
||
return target;
|
||
}, jQuery.extend({
|
||
noConflict: function(deep) {
|
||
return window1.$ === jQuery && (window1.$ = _$), deep && window1.jQuery === jQuery && (window1.jQuery = _jQuery), jQuery;
|
||
},
|
||
isReady: !1,
|
||
readyWait: 1,
|
||
holdReady: function(hold) {
|
||
hold ? jQuery.readyWait++ : jQuery.ready(!0);
|
||
},
|
||
ready: function(wait) {
|
||
if (!(!0 === wait ? --jQuery.readyWait : jQuery.isReady)) {
|
||
if (!document1.body) return setTimeout(jQuery.ready);
|
||
jQuery.isReady = !0, !(!0 !== wait && --jQuery.readyWait > 0) && (readyList.resolveWith(document1, [
|
||
jQuery
|
||
]), jQuery.fn.trigger && jQuery(document1).trigger("ready").off("ready"));
|
||
}
|
||
},
|
||
isFunction: function(obj) {
|
||
return "function" === jQuery.type(obj);
|
||
},
|
||
isArray: Array.isArray || function(obj) {
|
||
return "array" === jQuery.type(obj);
|
||
},
|
||
isWindow: function(obj) {
|
||
return null != obj && obj == obj.window;
|
||
},
|
||
isNumeric: function(obj) {
|
||
return !isNaN(parseFloat(obj)) && isFinite(obj);
|
||
},
|
||
type: function(obj) {
|
||
return null == obj ? String(obj) : "object" == typeof obj || "function" == typeof obj ? class2type[core_toString.call(obj)] || "object" : typeof obj;
|
||
},
|
||
isPlainObject: function(obj) {
|
||
var key;
|
||
if (!obj || "object" !== jQuery.type(obj) || obj.nodeType || jQuery.isWindow(obj)) return !1;
|
||
try {
|
||
if (obj.constructor && !core_hasOwn.call(obj, "constructor") && !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) return !1;
|
||
} catch (e) {
|
||
return !1;
|
||
}
|
||
for(key in obj);
|
||
return key === undefined1 || core_hasOwn.call(obj, key);
|
||
},
|
||
isEmptyObject: function(obj) {
|
||
var name;
|
||
for(name in obj)return !1;
|
||
return !0;
|
||
},
|
||
error: function(msg) {
|
||
throw new Error(msg);
|
||
},
|
||
parseHTML: function(data, context, keepScripts) {
|
||
if (!data || "string" != typeof data) return null;
|
||
"boolean" == typeof context && (keepScripts = context, context = !1), context = context || document1;
|
||
var parsed = rsingleTag.exec(data), scripts = !keepScripts && [];
|
||
return parsed ? [
|
||
context.createElement(parsed[1])
|
||
] : (parsed = jQuery.buildFragment([
|
||
data
|
||
], context, scripts), scripts && jQuery(scripts).remove(), jQuery.merge([], parsed.childNodes));
|
||
},
|
||
parseJSON: function(data) {
|
||
return window1.JSON && window1.JSON.parse ? window1.JSON.parse(data) : null === data ? data : "string" == typeof data && (data = jQuery.trim(data)) && rvalidchars.test(data.replace(rvalidescape, "@").replace(rvalidtokens, "]").replace(rvalidbraces, "")) ? new Function("return " + data)() : void jQuery.error("Invalid JSON: " + data);
|
||
},
|
||
parseXML: function(data) {
|
||
var xml;
|
||
if (!data || "string" != typeof data) return null;
|
||
try {
|
||
window1.DOMParser ? xml = new DOMParser().parseFromString(data, "text/xml") : ((xml = new ActiveXObject("Microsoft.XMLDOM")).async = "false", xml.loadXML(data));
|
||
} catch (e) {
|
||
xml = undefined1;
|
||
}
|
||
return xml && xml.documentElement && !xml.getElementsByTagName("parsererror").length || jQuery.error("Invalid XML: " + data), xml;
|
||
},
|
||
noop: function() {},
|
||
globalEval: function(data1) {
|
||
data1 && jQuery.trim(data1) && (window1.execScript || function(data) {
|
||
window1.eval.call(window1, data);
|
||
})(data1);
|
||
},
|
||
camelCase: function(string) {
|
||
return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
|
||
},
|
||
nodeName: function(elem, name) {
|
||
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
|
||
},
|
||
each: function(obj, callback, args) {
|
||
var i = 0, length = obj.length, isArray = isArraylike(obj);
|
||
if (args) {
|
||
if (isArray) for(; i < length && !1 !== callback.apply(obj[i], args); i++);
|
||
else for(i in obj)if (!1 === callback.apply(obj[i], args)) break;
|
||
} else if (isArray) for(; i < length && !1 !== callback.call(obj[i], i, obj[i]); i++);
|
||
else for(i in obj)if (!1 === callback.call(obj[i], i, obj[i])) break;
|
||
return obj;
|
||
},
|
||
trim: core_trim && !core_trim.call("\xa0") ? function(text) {
|
||
return null == text ? "" : core_trim.call(text);
|
||
} : function(text) {
|
||
return null == text ? "" : (text + "").replace(rtrim1, "");
|
||
},
|
||
makeArray: function(arr, results) {
|
||
var ret = results || [];
|
||
return null != arr && (isArraylike(Object(arr)) ? jQuery.merge(ret, "string" == typeof arr ? [
|
||
arr
|
||
] : arr) : core_push.call(ret, arr)), ret;
|
||
},
|
||
inArray: function(elem, arr, i) {
|
||
var len;
|
||
if (arr) {
|
||
if (core_indexOf) return core_indexOf.call(arr, elem, i);
|
||
for(len = arr.length, i = i ? i < 0 ? Math.max(0, len + i) : i : 0; i < len; i++)if (i in arr && arr[i] === elem) return i;
|
||
}
|
||
return -1;
|
||
},
|
||
merge: function(first, second) {
|
||
var l = second.length, i = first.length, j = 0;
|
||
if ("number" == typeof l) for(; j < l; j++)first[i++] = second[j];
|
||
else for(; undefined1 !== second[j];)first[i++] = second[j++];
|
||
return first.length = i, first;
|
||
},
|
||
grep: function(elems, callback, inv) {
|
||
var ret = [], i = 0, length = elems.length;
|
||
for(inv = !!inv; i < length; i++)!!callback(elems[i], i) !== inv && ret.push(elems[i]);
|
||
return ret;
|
||
},
|
||
map: function(elems, callback, arg) {
|
||
var value, i = 0, length = elems.length, isArray = isArraylike(elems), ret = [];
|
||
if (isArray) for(; i < length; i++)null != (value = callback(elems[i], i, arg)) && (ret[ret.length] = value);
|
||
else for(i in elems)null != (value = callback(elems[i], i, arg)) && (ret[ret.length] = value);
|
||
return core_concat.apply([], ret);
|
||
},
|
||
guid: 1,
|
||
proxy: function(fn, context) {
|
||
var args, proxy, tmp;
|
||
if ("string" == typeof context && (tmp = fn[context], context = fn, fn = tmp), jQuery.isFunction(fn)) return args = core_slice.call(arguments, 2), (proxy = function() {
|
||
return fn.apply(context || this, args.concat(core_slice.call(arguments)));
|
||
}).guid = fn.guid = fn.guid || jQuery.guid++, proxy;
|
||
},
|
||
access: function(elems, fn, key, value1, chainable, emptyGet, raw) {
|
||
var i = 0, length = elems.length, bulk = null == key;
|
||
if ("object" === jQuery.type(key)) for(i in chainable = !0, key)jQuery.access(elems, fn, i, key[i], !0, emptyGet, raw);
|
||
else if (value1 !== undefined1 && (chainable = !0, jQuery.isFunction(value1) || (raw = !0), bulk && (raw ? (fn.call(elems, value1), fn = null) : (bulk = fn, fn = function(elem, key, value) {
|
||
return bulk.call(jQuery(elem), value);
|
||
})), fn)) for(; i < length; i++)fn(elems[i], key, raw ? value1 : value1.call(elems[i], i, fn(elems[i], key)));
|
||
return chainable ? elems : bulk ? fn.call(elems) : length ? fn(elems[0], key) : emptyGet;
|
||
},
|
||
now: function() {
|
||
return new Date().getTime();
|
||
}
|
||
}), jQuery.ready.promise = function(obj) {
|
||
if (!readyList) if (readyList = jQuery.Deferred(), "complete" === document1.readyState) setTimeout(jQuery.ready);
|
||
else if (document1.addEventListener) document1.addEventListener("DOMContentLoaded", completed, !1), window1.addEventListener("load", completed, !1);
|
||
else {
|
||
document1.attachEvent("onreadystatechange", completed), window1.attachEvent("onload", completed);
|
||
var top = !1;
|
||
try {
|
||
top = null == window1.frameElement && document1.documentElement;
|
||
} catch (e) {}
|
||
top && top.doScroll && (function doScrollCheck() {
|
||
if (!jQuery.isReady) {
|
||
try {
|
||
top.doScroll("left");
|
||
} catch (e) {
|
||
return setTimeout(doScrollCheck, 50);
|
||
}
|
||
detach(), jQuery.ready();
|
||
}
|
||
})();
|
||
}
|
||
return readyList.promise(obj);
|
||
}, jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
|
||
class2type["[object " + name + "]"] = name.toLowerCase();
|
||
}), rootjQuery1 = jQuery(document1);
|
||
var optionsCache = {};
|
||
jQuery.Callbacks = function(options) {
|
||
var options1, object;
|
||
options = "string" == typeof options ? optionsCache[options] || (object = optionsCache[options1 = options] = {}, jQuery.each(options1.match(core_rnotwhite) || [], function(_, flag) {
|
||
object[flag] = !0;
|
||
}), object) : jQuery.extend({}, options);
|
||
var firing, memory, fired, firingLength, firingIndex, firingStart, list = [], stack = !options.once && [], fire = function(data) {
|
||
for(memory = options.memory && data, fired = !0, firingIndex = firingStart || 0, firingStart = 0, firingLength = list.length, firing = !0; list && firingIndex < firingLength; firingIndex++)if (!1 === list[firingIndex].apply(data[0], data[1]) && options.stopOnFalse) {
|
||
memory = !1;
|
||
break;
|
||
}
|
||
firing = !1, list && (stack ? stack.length && fire(stack.shift()) : memory ? list = [] : self.disable());
|
||
}, self = {
|
||
add: function() {
|
||
if (list) {
|
||
var start = list.length;
|
||
(function add(args) {
|
||
jQuery.each(args, function(_, arg) {
|
||
var type = jQuery.type(arg);
|
||
"function" === type ? options.unique && self.has(arg) || list.push(arg) : arg && arg.length && "string" !== type && add(arg);
|
||
});
|
||
})(arguments), firing ? firingLength = list.length : memory && (firingStart = start, fire(memory));
|
||
}
|
||
return this;
|
||
},
|
||
remove: function() {
|
||
return list && jQuery.each(arguments, function(_, arg) {
|
||
for(var index; (index = jQuery.inArray(arg, list, index)) > -1;)list.splice(index, 1), firing && (index <= firingLength && firingLength--, index <= firingIndex && firingIndex--);
|
||
}), this;
|
||
},
|
||
has: function(fn) {
|
||
return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length);
|
||
},
|
||
empty: function() {
|
||
return list = [], this;
|
||
},
|
||
disable: function() {
|
||
return list = stack = memory = undefined1, this;
|
||
},
|
||
disabled: function() {
|
||
return !list;
|
||
},
|
||
lock: function() {
|
||
return stack = undefined1, memory || self.disable(), this;
|
||
},
|
||
locked: function() {
|
||
return !stack;
|
||
},
|
||
fireWith: function(context, args) {
|
||
return args = [
|
||
context,
|
||
(args = args || []).slice ? args.slice() : args
|
||
], list && (!fired || stack) && (firing ? stack.push(args) : fire(args)), this;
|
||
},
|
||
fire: function() {
|
||
return self.fireWith(this, arguments), this;
|
||
},
|
||
fired: function() {
|
||
return !!fired;
|
||
}
|
||
};
|
||
return self;
|
||
}, jQuery.extend({
|
||
Deferred: function(func) {
|
||
var tuples = [
|
||
[
|
||
"resolve",
|
||
"done",
|
||
jQuery.Callbacks("once memory"),
|
||
"resolved"
|
||
],
|
||
[
|
||
"reject",
|
||
"fail",
|
||
jQuery.Callbacks("once memory"),
|
||
"rejected"
|
||
],
|
||
[
|
||
"notify",
|
||
"progress",
|
||
jQuery.Callbacks("memory")
|
||
]
|
||
], state = "pending", promise = {
|
||
state: function() {
|
||
return state;
|
||
},
|
||
always: function() {
|
||
return deferred.done(arguments).fail(arguments), this;
|
||
},
|
||
then: function() {
|
||
var fns = arguments;
|
||
return jQuery.Deferred(function(newDefer) {
|
||
jQuery.each(tuples, function(i, tuple) {
|
||
var action = tuple[0], fn = jQuery.isFunction(fns[i]) && fns[i];
|
||
deferred[tuple[1]](function() {
|
||
var returned = fn && fn.apply(this, arguments);
|
||
returned && jQuery.isFunction(returned.promise) ? returned.promise().done(newDefer.resolve).fail(newDefer.reject).progress(newDefer.notify) : newDefer[action + "With"](this === promise ? newDefer.promise() : this, fn ? [
|
||
returned
|
||
] : arguments);
|
||
});
|
||
}), fns = null;
|
||
}).promise();
|
||
},
|
||
promise: function(obj) {
|
||
return null != obj ? jQuery.extend(obj, promise) : promise;
|
||
}
|
||
}, deferred = {};
|
||
return promise.pipe = promise.then, jQuery.each(tuples, function(i, tuple) {
|
||
var list = tuple[2], stateString = tuple[3];
|
||
promise[tuple[1]] = list.add, stateString && list.add(function() {
|
||
state = stateString;
|
||
}, tuples[1 ^ i][2].disable, tuples[2][2].lock), deferred[tuple[0]] = function() {
|
||
return deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments), this;
|
||
}, deferred[tuple[0] + "With"] = list.fireWith;
|
||
}), promise.promise(deferred), func && func.call(deferred, deferred), deferred;
|
||
},
|
||
when: function(subordinate) {
|
||
var progressValues, progressContexts, resolveContexts, i1 = 0, resolveValues = core_slice.call(arguments), length = resolveValues.length, remaining = 1 !== length || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0, deferred = 1 === remaining ? subordinate : jQuery.Deferred(), updateFunc = function(i, contexts, values) {
|
||
return function(value) {
|
||
contexts[i] = this, values[i] = arguments.length > 1 ? core_slice.call(arguments) : value, values === progressValues ? deferred.notifyWith(contexts, values) : --remaining || deferred.resolveWith(contexts, values);
|
||
};
|
||
};
|
||
if (length > 1) for(progressValues = new Array(length), progressContexts = new Array(length), resolveContexts = new Array(length); i1 < length; i1++)resolveValues[i1] && jQuery.isFunction(resolveValues[i1].promise) ? resolveValues[i1].promise().done(updateFunc(i1, resolveContexts, resolveValues)).fail(deferred.reject).progress(updateFunc(i1, progressContexts, progressValues)) : --remaining;
|
||
return remaining || deferred.resolveWith(resolveContexts, resolveValues), deferred.promise();
|
||
}
|
||
}), jQuery.support = (function() {
|
||
var support, all, a, input, select, fragment, opt, eventName, isSupported, i, div = document1.createElement("div");
|
||
if (div.setAttribute("className", "t"), div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>", all = div.getElementsByTagName("*"), a = div.getElementsByTagName("a")[0], !all || !a || !all.length) return {};
|
||
opt = (select = document1.createElement("select")).appendChild(document1.createElement("option")), input = div.getElementsByTagName("input")[0], a.style.cssText = "top:1px;float:left;opacity:.5", support = {
|
||
getSetAttribute: "t" !== div.className,
|
||
leadingWhitespace: 3 === div.firstChild.nodeType,
|
||
tbody: !div.getElementsByTagName("tbody").length,
|
||
htmlSerialize: !!div.getElementsByTagName("link").length,
|
||
style: /top/.test(a.getAttribute("style")),
|
||
hrefNormalized: "/a" === a.getAttribute("href"),
|
||
opacity: /^0.5/.test(a.style.opacity),
|
||
cssFloat: !!a.style.cssFloat,
|
||
checkOn: !!input.value,
|
||
optSelected: opt.selected,
|
||
enctype: !!document1.createElement("form").enctype,
|
||
html5Clone: "<:nav></:nav>" !== document1.createElement("nav").cloneNode(!0).outerHTML,
|
||
boxModel: "CSS1Compat" === document1.compatMode,
|
||
deleteExpando: !0,
|
||
noCloneEvent: !0,
|
||
inlineBlockNeedsLayout: !1,
|
||
shrinkWrapBlocks: !1,
|
||
reliableMarginRight: !0,
|
||
boxSizingReliable: !0,
|
||
pixelPosition: !1
|
||
}, input.checked = !0, support.noCloneChecked = input.cloneNode(!0).checked, select.disabled = !0, support.optDisabled = !opt.disabled;
|
||
try {
|
||
delete div.test;
|
||
} catch (e) {
|
||
support.deleteExpando = !1;
|
||
}
|
||
for(i in (input = document1.createElement("input")).setAttribute("value", ""), support.input = "" === input.getAttribute("value"), input.value = "t", input.setAttribute("type", "radio"), support.radioValue = "t" === input.value, input.setAttribute("checked", "t"), input.setAttribute("name", "t"), (fragment = document1.createDocumentFragment()).appendChild(input), support.appendChecked = input.checked, support.checkClone = fragment.cloneNode(!0).cloneNode(!0).lastChild.checked, div.attachEvent && (div.attachEvent("onclick", function() {
|
||
support.noCloneEvent = !1;
|
||
}), div.cloneNode(!0).click()), {
|
||
submit: !0,
|
||
change: !0,
|
||
focusin: !0
|
||
})div.setAttribute(eventName = "on" + i, "t"), support[i + "Bubbles"] = eventName in window1 || !1 === div.attributes[eventName].expando;
|
||
return div.style.backgroundClip = "content-box", div.cloneNode(!0).style.backgroundClip = "", support.clearCloneStyle = "content-box" === div.style.backgroundClip, jQuery(function() {
|
||
var container, marginDiv, tds, divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;", body = document1.getElementsByTagName("body")[0];
|
||
body && ((container = document1.createElement("div")).style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px", body.appendChild(container).appendChild(div), div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>", (tds = div.getElementsByTagName("td"))[0].style.cssText = "padding:0;margin:0;border:0;display:none", isSupported = 0 === tds[0].offsetHeight, tds[0].style.display = "", tds[1].style.display = "none", support.reliableHiddenOffsets = isSupported && 0 === tds[0].offsetHeight, div.innerHTML = "", div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;", support.boxSizing = 4 === div.offsetWidth, support.doesNotIncludeMarginInBodyOffset = 1 !== body.offsetTop, window1.getComputedStyle && (support.pixelPosition = "1%" !== (window1.getComputedStyle(div, null) || {}).top, support.boxSizingReliable = "4px" === (window1.getComputedStyle(div, null) || {
|
||
width: "4px"
|
||
}).width, (marginDiv = div.appendChild(document1.createElement("div"))).style.cssText = div.style.cssText = divReset, marginDiv.style.marginRight = marginDiv.style.width = "0", div.style.width = "1px", support.reliableMarginRight = !parseFloat((window1.getComputedStyle(marginDiv, null) || {}).marginRight)), typeof div.style.zoom !== core_strundefined && (div.innerHTML = "", div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1", support.inlineBlockNeedsLayout = 3 === div.offsetWidth, div.style.display = "block", div.innerHTML = "<div></div>", div.firstChild.style.width = "5px", support.shrinkWrapBlocks = 3 !== div.offsetWidth, support.inlineBlockNeedsLayout && (body.style.zoom = 1)), body.removeChild(container), container = div = tds = marginDiv = null);
|
||
}), all = select = fragment = opt = a = input = null, support;
|
||
})();
|
||
var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, rmultiDash = /([A-Z])/g;
|
||
function internalData(elem, name, data, pvt) {
|
||
if (jQuery.acceptData(elem)) {
|
||
var thisCache, ret, internalKey = jQuery.expando, getByName = "string" == typeof name, isNode = elem.nodeType, cache = isNode ? jQuery.cache : elem, id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;
|
||
if (id && cache[id] && (pvt || cache[id].data) || !getByName || data !== undefined1) return id || (isNode ? elem[internalKey] = id = core_deletedIds.pop() || jQuery.guid++ : id = internalKey), cache[id] || (cache[id] = {}, isNode || (cache[id].toJSON = jQuery.noop)), ("object" == typeof name || "function" == typeof name) && (pvt ? cache[id] = jQuery.extend(cache[id], name) : cache[id].data = jQuery.extend(cache[id].data, name)), thisCache = cache[id], pvt || (thisCache.data || (thisCache.data = {}), thisCache = thisCache.data), data !== undefined1 && (thisCache[jQuery.camelCase(name)] = data), getByName ? null == (ret = thisCache[name]) && (ret = thisCache[jQuery.camelCase(name)]) : ret = thisCache, ret;
|
||
}
|
||
}
|
||
function internalRemoveData(elem, name, pvt) {
|
||
if (jQuery.acceptData(elem)) {
|
||
var i, l, thisCache, isNode = elem.nodeType, cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : jQuery.expando;
|
||
if (cache[id]) {
|
||
if (name && (thisCache = pvt ? cache[id] : cache[id].data)) {
|
||
for(i = 0, l = (name = jQuery.isArray(name) ? name.concat(jQuery.map(name, jQuery.camelCase)) : (name in thisCache) ? [
|
||
name
|
||
] : ((name = jQuery.camelCase(name)) in thisCache) ? [
|
||
name
|
||
] : name.split(" ")).length; i < l; i++)delete thisCache[name[i]];
|
||
if (!(pvt ? isEmptyDataObject : jQuery.isEmptyObject)(thisCache)) return;
|
||
}
|
||
(pvt || (delete cache[id].data, isEmptyDataObject(cache[id]))) && (isNode ? jQuery.cleanData([
|
||
elem
|
||
], !0) : jQuery.support.deleteExpando || cache != cache.window ? delete cache[id] : cache[id] = null);
|
||
}
|
||
}
|
||
}
|
||
function dataAttr(elem, key, data) {
|
||
if (data === undefined1 && 1 === elem.nodeType) {
|
||
var name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
|
||
if ("string" == typeof (data = elem.getAttribute(name))) {
|
||
try {
|
||
data = "true" === data || "false" !== data && ("null" === data ? null : +data + "" === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data);
|
||
} catch (e) {}
|
||
jQuery.data(elem, key, data);
|
||
} else data = undefined1;
|
||
}
|
||
return data;
|
||
}
|
||
function isEmptyDataObject(obj) {
|
||
var name;
|
||
for(name in obj)if (!("data" === name && jQuery.isEmptyObject(obj[name])) && "toJSON" !== name) return !1;
|
||
return !0;
|
||
}
|
||
jQuery.extend({
|
||
cache: {},
|
||
expando: "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
|
||
noData: {
|
||
embed: !0,
|
||
object: "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
|
||
applet: !0
|
||
},
|
||
hasData: function(elem) {
|
||
return !!(elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando]) && !isEmptyDataObject(elem);
|
||
},
|
||
data: function(elem, name, data) {
|
||
return internalData(elem, name, data);
|
||
},
|
||
removeData: function(elem, name) {
|
||
return internalRemoveData(elem, name);
|
||
},
|
||
_data: function(elem, name, data) {
|
||
return internalData(elem, name, data, !0);
|
||
},
|
||
_removeData: function(elem, name) {
|
||
return internalRemoveData(elem, name, !0);
|
||
},
|
||
acceptData: function(elem) {
|
||
if (elem.nodeType && 1 !== elem.nodeType && 9 !== elem.nodeType) return !1;
|
||
var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];
|
||
return !noData || !0 !== noData && elem.getAttribute("classid") === noData;
|
||
}
|
||
}), jQuery.fn.extend({
|
||
data: function(key, value2) {
|
||
var attrs, name, elem = this[0], i = 0, data = null;
|
||
if (key === undefined1) {
|
||
if (this.length && (data = jQuery.data(elem), 1 === elem.nodeType && !jQuery._data(elem, "parsedAttrs"))) {
|
||
for(attrs = elem.attributes; i < attrs.length; i++)(name = attrs[i].name).indexOf("data-") || dataAttr(elem, name = jQuery.camelCase(name.slice(5)), data[name]);
|
||
jQuery._data(elem, "parsedAttrs", !0);
|
||
}
|
||
return data;
|
||
}
|
||
return "object" == typeof key ? this.each(function() {
|
||
jQuery.data(this, key);
|
||
}) : jQuery.access(this, function(value) {
|
||
if (value === undefined1) return elem ? dataAttr(elem, key, jQuery.data(elem, key)) : null;
|
||
this.each(function() {
|
||
jQuery.data(this, key, value);
|
||
});
|
||
}, null, value2, arguments.length > 1, null, !0);
|
||
},
|
||
removeData: function(key) {
|
||
return this.each(function() {
|
||
jQuery.removeData(this, key);
|
||
});
|
||
}
|
||
}), jQuery.extend({
|
||
queue: function(elem, type, data) {
|
||
var queue;
|
||
if (elem) return type = (type || "fx") + "queue", queue = jQuery._data(elem, type), data && (!queue || jQuery.isArray(data) ? queue = jQuery._data(elem, type, jQuery.makeArray(data)) : queue.push(data)), queue || [];
|
||
},
|
||
dequeue: function(elem, type) {
|
||
type = type || "fx";
|
||
var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks(elem, type);
|
||
"inprogress" === fn && (fn = queue.shift(), startLength--), hooks.cur = fn, fn && ("fx" === type && queue.unshift("inprogress"), delete hooks.stop, fn.call(elem, function() {
|
||
jQuery.dequeue(elem, type);
|
||
}, hooks)), !startLength && hooks && hooks.empty.fire();
|
||
},
|
||
_queueHooks: function(elem, type) {
|
||
var key = type + "queueHooks";
|
||
return jQuery._data(elem, key) || jQuery._data(elem, key, {
|
||
empty: jQuery.Callbacks("once memory").add(function() {
|
||
jQuery._removeData(elem, type + "queue"), jQuery._removeData(elem, key);
|
||
})
|
||
});
|
||
}
|
||
}), jQuery.fn.extend({
|
||
queue: function(type, data) {
|
||
var setter = 2;
|
||
return ("string" != typeof type && (data = type, type = "fx", setter--), arguments.length < setter) ? jQuery.queue(this[0], type) : data === undefined1 ? this : this.each(function() {
|
||
var queue = jQuery.queue(this, type, data);
|
||
jQuery._queueHooks(this, type), "fx" === type && "inprogress" !== queue[0] && jQuery.dequeue(this, type);
|
||
});
|
||
},
|
||
dequeue: function(type) {
|
||
return this.each(function() {
|
||
jQuery.dequeue(this, type);
|
||
});
|
||
},
|
||
delay: function(time, type) {
|
||
return time = jQuery.fx ? jQuery.fx.speeds[time] || time : time, type = type || "fx", this.queue(type, function(next, hooks) {
|
||
var timeout = setTimeout(next, time);
|
||
hooks.stop = function() {
|
||
clearTimeout(timeout);
|
||
};
|
||
});
|
||
},
|
||
clearQueue: function(type) {
|
||
return this.queue(type || "fx", []);
|
||
},
|
||
promise: function(type, obj) {
|
||
var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() {
|
||
--count || defer.resolveWith(elements, [
|
||
elements
|
||
]);
|
||
};
|
||
for("string" != typeof type && (obj = type, type = undefined1), type = type || "fx"; i--;)(tmp = jQuery._data(elements[i], type + "queueHooks")) && tmp.empty && (count++, tmp.empty.add(resolve));
|
||
return resolve(), defer.promise(obj);
|
||
}
|
||
});
|
||
var nodeHook, boolHook, rclass = /[\t\r\n]/g, rreturn = /\r/g, rfocusable = /^(?:input|select|textarea|button|object)$/i, rclickable = /^(?:a|area)$/i, rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i, ruseDefault = /^(?:checked|selected)$/i, getSetAttribute = jQuery.support.getSetAttribute, getSetInput = jQuery.support.input;
|
||
jQuery.fn.extend({
|
||
attr: function(name, value) {
|
||
return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);
|
||
},
|
||
removeAttr: function(name) {
|
||
return this.each(function() {
|
||
jQuery.removeAttr(this, name);
|
||
});
|
||
},
|
||
prop: function(name, value) {
|
||
return jQuery.access(this, jQuery.prop, name, value, arguments.length > 1);
|
||
},
|
||
removeProp: function(name) {
|
||
return name = jQuery.propFix[name] || name, this.each(function() {
|
||
try {
|
||
this[name] = undefined1, delete this[name];
|
||
} catch (e) {}
|
||
});
|
||
},
|
||
addClass: function(value) {
|
||
var classes, elem, cur, clazz, j1, i = 0, len = this.length;
|
||
if (jQuery.isFunction(value)) return this.each(function(j) {
|
||
jQuery(this).addClass(value.call(this, j, this.className));
|
||
});
|
||
if ("string" == typeof value && value) {
|
||
for(classes = (value || "").match(core_rnotwhite) || []; i < len; i++)if (cur = 1 === (elem = this[i]).nodeType && (elem.className ? (" " + elem.className + " ").replace(rclass, " ") : " ")) {
|
||
for(j1 = 0; clazz = classes[j1++];)0 > cur.indexOf(" " + clazz + " ") && (cur += clazz + " ");
|
||
elem.className = jQuery.trim(cur);
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
removeClass: function(value) {
|
||
var classes, elem, cur, clazz, j2, i = 0, len = this.length, proceed = 0 === arguments.length || "string" == typeof value && value;
|
||
if (jQuery.isFunction(value)) return this.each(function(j) {
|
||
jQuery(this).removeClass(value.call(this, j, this.className));
|
||
});
|
||
if (proceed) {
|
||
for(classes = (value || "").match(core_rnotwhite) || []; i < len; i++)if (cur = 1 === (elem = this[i]).nodeType && (elem.className ? (" " + elem.className + " ").replace(rclass, " ") : "")) {
|
||
for(j2 = 0; clazz = classes[j2++];)for(; cur.indexOf(" " + clazz + " ") >= 0;)cur = cur.replace(" " + clazz + " ", " ");
|
||
elem.className = value ? jQuery.trim(cur) : "";
|
||
}
|
||
}
|
||
return this;
|
||
},
|
||
toggleClass: function(value, stateVal) {
|
||
var type = typeof value, isBool = "boolean" == typeof stateVal;
|
||
return jQuery.isFunction(value) ? this.each(function(i) {
|
||
jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);
|
||
}) : this.each(function() {
|
||
if ("string" === type) for(var className, i = 0, self = jQuery(this), state = stateVal, classNames = value.match(core_rnotwhite) || []; className = classNames[i++];)state = isBool ? state : !self.hasClass(className), self[state ? "addClass" : "removeClass"](className);
|
||
else (type === core_strundefined || "boolean" === type) && (this.className && jQuery._data(this, "__className__", this.className), this.className = this.className || !1 === value ? "" : jQuery._data(this, "__className__") || "");
|
||
});
|
||
},
|
||
hasClass: function(selector) {
|
||
for(var className = " " + selector + " ", i = 0, l = this.length; i < l; i++)if (1 === this[i].nodeType && (" " + this[i].className + " ").replace(rclass, " ").indexOf(className) >= 0) return !0;
|
||
return !1;
|
||
},
|
||
val: function(value3) {
|
||
var ret, hooks, isFunction, elem = this[0];
|
||
return arguments.length ? (isFunction = jQuery.isFunction(value3), this.each(function(i) {
|
||
var val, self = jQuery(this);
|
||
1 === this.nodeType && (null == (val = isFunction ? value3.call(this, i, self.val()) : value3) ? val = "" : "number" == typeof val ? val += "" : jQuery.isArray(val) && (val = jQuery.map(val, function(value) {
|
||
return null == value ? "" : value + "";
|
||
})), (hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]) && "set" in hooks && undefined1 !== hooks.set(this, val, "value") || (this.value = val));
|
||
})) : elem ? (hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()]) && "get" in hooks && undefined1 !== (ret = hooks.get(elem, "value")) ? ret : "string" == typeof (ret = elem.value) ? ret.replace(rreturn, "") : null == ret ? "" : ret : void 0;
|
||
}
|
||
}), jQuery.extend({
|
||
valHooks: {
|
||
option: {
|
||
get: function(elem) {
|
||
var val = elem.attributes.value;
|
||
return !val || val.specified ? elem.value : elem.text;
|
||
}
|
||
},
|
||
select: {
|
||
get: function(elem) {
|
||
for(var value, option, options = elem.options, index = elem.selectedIndex, one = "select-one" === elem.type || index < 0, values = one ? null : [], max = one ? index + 1 : options.length, i = index < 0 ? max : one ? index : 0; i < max; i++)if (((option = options[i]).selected || i === index) && (jQuery.support.optDisabled ? !option.disabled : null === option.getAttribute("disabled")) && (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup"))) {
|
||
if (value = jQuery(option).val(), one) return value;
|
||
values.push(value);
|
||
}
|
||
return values;
|
||
},
|
||
set: function(elem, value) {
|
||
var values = jQuery.makeArray(value);
|
||
return jQuery(elem).find("option").each(function() {
|
||
this.selected = jQuery.inArray(jQuery(this).val(), values) >= 0;
|
||
}), values.length || (elem.selectedIndex = -1), values;
|
||
}
|
||
}
|
||
},
|
||
attr: function(elem, name, value) {
|
||
var hooks, notxml, ret, nType = elem.nodeType;
|
||
if (elem && 3 !== nType && 8 !== nType && 2 !== nType) {
|
||
if (typeof elem.getAttribute === core_strundefined) return jQuery.prop(elem, name, value);
|
||
if ((notxml = 1 !== nType || !jQuery.isXMLDoc(elem)) && (name = name.toLowerCase(), hooks = jQuery.attrHooks[name] || (rboolean.test(name) ? boolHook : nodeHook)), value !== undefined1) if (null === value) jQuery.removeAttr(elem, name);
|
||
else if (hooks && notxml && "set" in hooks && undefined1 !== (ret = hooks.set(elem, value, name))) return ret;
|
||
else return elem.setAttribute(name, value + ""), value;
|
||
else if (hooks && notxml && "get" in hooks && null !== (ret = hooks.get(elem, name))) return ret;
|
||
else return typeof elem.getAttribute !== core_strundefined && (ret = elem.getAttribute(name)), null == ret ? undefined1 : ret;
|
||
}
|
||
},
|
||
removeAttr: function(elem, value) {
|
||
var name, propName, i = 0, attrNames = value && value.match(core_rnotwhite);
|
||
if (attrNames && 1 === elem.nodeType) for(; name = attrNames[i++];)propName = jQuery.propFix[name] || name, rboolean.test(name) ? !getSetAttribute && ruseDefault.test(name) ? elem[jQuery.camelCase("default-" + name)] = elem[propName] = !1 : elem[propName] = !1 : jQuery.attr(elem, name, ""), elem.removeAttribute(getSetAttribute ? name : propName);
|
||
},
|
||
attrHooks: {
|
||
type: {
|
||
set: function(elem, value) {
|
||
if (!jQuery.support.radioValue && "radio" === value && jQuery.nodeName(elem, "input")) {
|
||
var val = elem.value;
|
||
return elem.setAttribute("type", value), val && (elem.value = val), value;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
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(elem, name, value) {
|
||
var ret, hooks, nType = elem.nodeType;
|
||
return elem && 3 !== nType && 8 !== nType && 2 !== nType ? (1 === nType && jQuery.isXMLDoc(elem) || (name = jQuery.propFix[name] || name, hooks = jQuery.propHooks[name]), value !== undefined1) ? hooks && "set" in hooks && undefined1 !== (ret = hooks.set(elem, value, name)) ? ret : elem[name] = value : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name)) ? ret : elem[name] : void 0;
|
||
},
|
||
propHooks: {
|
||
tabIndex: {
|
||
get: function(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 : undefined1;
|
||
}
|
||
}
|
||
}
|
||
}), boolHook = {
|
||
get: function(elem, name) {
|
||
var prop = jQuery.prop(elem, name), attr = "boolean" == typeof prop && elem.getAttribute(name), detail = "boolean" == typeof prop ? getSetInput && getSetAttribute ? null != attr : ruseDefault.test(name) ? elem[jQuery.camelCase("default-" + name)] : !!attr : elem.getAttributeNode(name);
|
||
return detail && !1 !== detail.value ? name.toLowerCase() : undefined1;
|
||
},
|
||
set: function(elem, value, name) {
|
||
return !1 === value ? jQuery.removeAttr(elem, name) : getSetInput && getSetAttribute || !ruseDefault.test(name) ? elem.setAttribute(!getSetAttribute && jQuery.propFix[name] || name, name) : elem[jQuery.camelCase("default-" + name)] = elem[name] = !0, name;
|
||
}
|
||
}, getSetInput && getSetAttribute || (jQuery.attrHooks.value = {
|
||
get: function(elem, name) {
|
||
var ret = elem.getAttributeNode(name);
|
||
return jQuery.nodeName(elem, "input") ? elem.defaultValue : ret && ret.specified ? ret.value : undefined1;
|
||
},
|
||
set: function(elem, value, name) {
|
||
if (!jQuery.nodeName(elem, "input")) return nodeHook && nodeHook.set(elem, value, name);
|
||
elem.defaultValue = value;
|
||
}
|
||
}), getSetAttribute || (nodeHook = jQuery.valHooks.button = {
|
||
get: function(elem, name) {
|
||
var ret = elem.getAttributeNode(name);
|
||
return ret && ("id" === name || "name" === name || "coords" === name ? "" !== ret.value : ret.specified) ? ret.value : undefined1;
|
||
},
|
||
set: function(elem, value, name) {
|
||
var ret = elem.getAttributeNode(name);
|
||
return ret || elem.setAttributeNode(ret = elem.ownerDocument.createAttribute(name)), ret.value = value += "", "value" === name || value === elem.getAttribute(name) ? value : undefined1;
|
||
}
|
||
}, jQuery.attrHooks.contenteditable = {
|
||
get: nodeHook.get,
|
||
set: function(elem, value, name) {
|
||
nodeHook.set(elem, "" !== value && value, name);
|
||
}
|
||
}, jQuery.each([
|
||
"width",
|
||
"height"
|
||
], function(i, name) {
|
||
jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {
|
||
set: function(elem, value) {
|
||
if ("" === value) return elem.setAttribute(name, "auto"), value;
|
||
}
|
||
});
|
||
})), jQuery.support.hrefNormalized || (jQuery.each([
|
||
"href",
|
||
"src",
|
||
"width",
|
||
"height"
|
||
], function(i, name) {
|
||
jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {
|
||
get: function(elem) {
|
||
var ret = elem.getAttribute(name, 2);
|
||
return null == ret ? undefined1 : ret;
|
||
}
|
||
});
|
||
}), jQuery.each([
|
||
"href",
|
||
"src"
|
||
], function(i, name) {
|
||
jQuery.propHooks[name] = {
|
||
get: function(elem) {
|
||
return elem.getAttribute(name, 4);
|
||
}
|
||
};
|
||
})), jQuery.support.style || (jQuery.attrHooks.style = {
|
||
get: function(elem) {
|
||
return elem.style.cssText || undefined1;
|
||
},
|
||
set: function(elem, value) {
|
||
return elem.style.cssText = value + "";
|
||
}
|
||
}), jQuery.support.optSelected || (jQuery.propHooks.selected = jQuery.extend(jQuery.propHooks.selected, {
|
||
get: function(elem) {
|
||
var parent = elem.parentNode;
|
||
return parent && (parent.selectedIndex, parent.parentNode && parent.parentNode.selectedIndex), null;
|
||
}
|
||
})), jQuery.support.enctype || (jQuery.propFix.enctype = "encoding"), jQuery.support.checkOn || jQuery.each([
|
||
"radio",
|
||
"checkbox"
|
||
], function() {
|
||
jQuery.valHooks[this] = {
|
||
get: function(elem) {
|
||
return null === elem.getAttribute("value") ? "on" : elem.value;
|
||
}
|
||
};
|
||
}), jQuery.each([
|
||
"radio",
|
||
"checkbox"
|
||
], function() {
|
||
jQuery.valHooks[this] = jQuery.extend(jQuery.valHooks[this], {
|
||
set: function(elem, value) {
|
||
if (jQuery.isArray(value)) return elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0;
|
||
}
|
||
});
|
||
});
|
||
var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|contextmenu)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
|
||
function returnTrue() {
|
||
return !0;
|
||
}
|
||
function returnFalse() {
|
||
return !1;
|
||
}
|
||
jQuery.event = {
|
||
global: {},
|
||
add: function(elem, types, handler, data, selector) {
|
||
var tmp, events, t, handleObjIn, special, eventHandle, handleObj, handlers, type, namespaces, origType, elemData = jQuery._data(elem);
|
||
if (elemData) {
|
||
for(handler.handler && (handler = (handleObjIn = handler).handler, selector = handleObjIn.selector), handler.guid || (handler.guid = jQuery.guid++), (events = elemData.events) || (events = elemData.events = {}), (eventHandle = elemData.handle) || ((eventHandle = elemData.handle = function(e) {
|
||
return "function" === core_strundefined || e && jQuery.event.triggered === e.type ? undefined1 : jQuery.event.dispatch.apply(eventHandle.elem, arguments);
|
||
}).elem = elem), t = (types = (types || "").match(core_rnotwhite) || [
|
||
""
|
||
]).length; t--;)type = origType = (tmp = rtypenamespace.exec(types[t]) || [])[1], namespaces = (tmp[2] || "").split(".").sort(), special = jQuery.event.special[type] || {}, type = (selector ? special.delegateType : special.bindType) || type, special = jQuery.event.special[type] || {}, handleObj = jQuery.extend({
|
||
type: type,
|
||
origType: origType,
|
||
data: data,
|
||
handler: handler,
|
||
guid: handler.guid,
|
||
selector: selector,
|
||
needsContext: selector && jQuery.expr.match.needsContext.test(selector),
|
||
namespace: namespaces.join(".")
|
||
}, handleObjIn), (handlers = events[type]) || ((handlers = events[type] = []).delegateCount = 0, (!special.setup || !1 === special.setup.call(elem, data, namespaces, eventHandle)) && (elem.addEventListener ? elem.addEventListener(type, eventHandle, !1) : elem.attachEvent && elem.attachEvent("on" + type, eventHandle))), special.add && (special.add.call(elem, handleObj), handleObj.handler.guid || (handleObj.handler.guid = handler.guid)), selector ? handlers.splice(handlers.delegateCount++, 0, handleObj) : handlers.push(handleObj), jQuery.event.global[type] = !0;
|
||
elem = null;
|
||
}
|
||
},
|
||
remove: function(elem, types, handler, selector, mappedTypes) {
|
||
var j, handleObj, tmp, origCount, t, events, special, handlers, type, namespaces, origType, elemData = jQuery.hasData(elem) && jQuery._data(elem);
|
||
if (elemData && (events = elemData.events)) {
|
||
for(t = (types = (types || "").match(core_rnotwhite) || [
|
||
""
|
||
]).length; t--;){
|
||
if (type = origType = (tmp = rtypenamespace.exec(types[t]) || [])[1], namespaces = (tmp[2] || "").split(".").sort(), !type) {
|
||
for(type in events)jQuery.event.remove(elem, type + types[t], handler, selector, !0);
|
||
continue;
|
||
}
|
||
for(special = jQuery.event.special[type] || {}, handlers = events[type = (selector ? special.delegateType : special.bindType) || type] || [], tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"), origCount = j = handlers.length; j--;)handleObj = handlers[j], (mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || "**" === selector && handleObj.selector) && (handlers.splice(j, 1), handleObj.selector && handlers.delegateCount--, special.remove && special.remove.call(elem, handleObj));
|
||
origCount && !handlers.length && (special.teardown && !1 !== special.teardown.call(elem, namespaces, elemData.handle) || jQuery.removeEvent(elem, type, elemData.handle), delete events[type]);
|
||
}
|
||
jQuery.isEmptyObject(events) && (delete elemData.handle, jQuery._removeData(elem, "events"));
|
||
}
|
||
},
|
||
trigger: function(event, data, elem, onlyHandlers) {
|
||
var handle, ontype, cur, bubbleType, special, tmp, i, eventPath = [
|
||
elem || document1
|
||
], type = core_hasOwn.call(event, "type") ? event.type : event, namespaces = core_hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
|
||
if (cur = tmp = elem = elem || document1, 3 !== elem.nodeType && 8 !== elem.nodeType && !rfocusMorph.test(type + jQuery.event.triggered) && (type.indexOf(".") >= 0 && (type = (namespaces = type.split(".")).shift(), namespaces.sort()), ontype = 0 > type.indexOf(":") && "on" + type, (event = event[jQuery.expando] ? event : new jQuery.Event(type, "object" == typeof event && event)).isTrigger = !0, event.namespace = namespaces.join("."), event.namespace_re = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, event.result = undefined1, event.target || (event.target = elem), data = null == data ? [
|
||
event
|
||
] : jQuery.makeArray(data, [
|
||
event
|
||
]), special = jQuery.event.special[type] || {}, onlyHandlers || !special.trigger || !1 !== special.trigger.apply(elem, data))) {
|
||
if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
|
||
for(bubbleType = special.delegateType || type, rfocusMorph.test(bubbleType + type) || (cur = cur.parentNode); cur; cur = cur.parentNode)eventPath.push(cur), tmp = cur;
|
||
tmp === (elem.ownerDocument || document1) && eventPath.push(tmp.defaultView || tmp.parentWindow || window1);
|
||
}
|
||
for(i = 0; (cur = eventPath[i++]) && !event.isPropagationStopped();)event.type = i > 1 ? bubbleType : special.bindType || type, (handle = (jQuery._data(cur, "events") || {})[event.type] && jQuery._data(cur, "handle")) && handle.apply(cur, data), (handle = ontype && cur[ontype]) && jQuery.acceptData(cur) && handle.apply && !1 === handle.apply(cur, data) && event.preventDefault();
|
||
if (event.type = type, !onlyHandlers && !event.isDefaultPrevented() && (!special._default || !1 === special._default.apply(elem.ownerDocument, data)) && !("click" === type && jQuery.nodeName(elem, "a")) && jQuery.acceptData(elem) && ontype && elem[type] && !jQuery.isWindow(elem)) {
|
||
(tmp = elem[ontype]) && (elem[ontype] = null), jQuery.event.triggered = type;
|
||
try {
|
||
elem[type]();
|
||
} catch (e) {}
|
||
jQuery.event.triggered = undefined1, tmp && (elem[ontype] = tmp);
|
||
}
|
||
return event.result;
|
||
}
|
||
},
|
||
dispatch: function(event) {
|
||
event = jQuery.event.fix(event);
|
||
var i, ret, handleObj, matched, j, handlerQueue = [], args = core_slice.call(arguments), handlers = (jQuery._data(this, "events") || {})[event.type] || [], special = jQuery.event.special[event.type] || {};
|
||
if (args[0] = event, event.delegateTarget = this, !special.preDispatch || !1 !== special.preDispatch.call(this, event)) {
|
||
for(handlerQueue = jQuery.event.handlers.call(this, event, handlers), i = 0; (matched = handlerQueue[i++]) && !event.isPropagationStopped();)for(event.currentTarget = matched.elem, j = 0; (handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped();)(!event.namespace_re || event.namespace_re.test(handleObj.namespace)) && (event.handleObj = handleObj, event.data = handleObj.data, undefined1 !== (ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args)) && !1 === (event.result = ret) && (event.preventDefault(), event.stopPropagation()));
|
||
return special.postDispatch && special.postDispatch.call(this, event), event.result;
|
||
}
|
||
},
|
||
handlers: function(event, handlers) {
|
||
var sel, handleObj, matches, i, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;
|
||
if (delegateCount && cur.nodeType && (!event.button || "click" !== event.type)) {
|
||
for(; cur != this; cur = cur.parentNode || this)if (1 === cur.nodeType && (!0 !== cur.disabled || "click" !== event.type)) {
|
||
for(i = 0, matches = []; i < delegateCount; i++)undefined1 === matches[sel = (handleObj = handlers[i]).selector + " "] && (matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) >= 0 : jQuery.find(sel, this, null, [
|
||
cur
|
||
]).length), matches[sel] && matches.push(handleObj);
|
||
matches.length && handlerQueue.push({
|
||
elem: cur,
|
||
handlers: matches
|
||
});
|
||
}
|
||
}
|
||
return delegateCount < handlers.length && handlerQueue.push({
|
||
elem: this,
|
||
handlers: handlers.slice(delegateCount)
|
||
}), handlerQueue;
|
||
},
|
||
fix: function(event) {
|
||
if (event[jQuery.expando]) return event;
|
||
var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type];
|
||
for(fixHook || (this.fixHooks[type] = fixHook = rmouseEvent.test(type) ? this.mouseHooks : rkeyEvent.test(type) ? this.keyHooks : {}), copy = fixHook.props ? this.props.concat(fixHook.props) : this.props, event = new jQuery.Event(originalEvent), i = copy.length; i--;)event[prop = copy[i]] = originalEvent[prop];
|
||
return event.target || (event.target = originalEvent.srcElement || document1), 3 === event.target.nodeType && (event.target = event.target.parentNode), event.metaKey = !!event.metaKey, fixHook.filter ? fixHook.filter(event, originalEvent) : event;
|
||
},
|
||
props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
|
||
fixHooks: {},
|
||
keyHooks: {
|
||
props: "char charCode key keyCode".split(" "),
|
||
filter: function(event, original) {
|
||
return null == event.which && (event.which = null != original.charCode ? original.charCode : original.keyCode), event;
|
||
}
|
||
},
|
||
mouseHooks: {
|
||
props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
|
||
filter: function(event, original) {
|
||
var body, eventDoc, doc, button = original.button, fromElement = original.fromElement;
|
||
return null == event.pageX && null != original.clientX && (doc = (eventDoc = event.target.ownerDocument || document1).documentElement, body = eventDoc.body, event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0), event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0)), !event.relatedTarget && fromElement && (event.relatedTarget = fromElement === event.target ? original.toElement : fromElement), event.which || button === undefined1 || (event.which = 1 & button ? 1 : 2 & button ? 3 : 4 & button ? 2 : 0), event;
|
||
}
|
||
},
|
||
special: {
|
||
load: {
|
||
noBubble: !0
|
||
},
|
||
click: {
|
||
trigger: function() {
|
||
if (jQuery.nodeName(this, "input") && "checkbox" === this.type && this.click) return this.click(), !1;
|
||
}
|
||
},
|
||
focus: {
|
||
trigger: function() {
|
||
if (this !== document1.activeElement && this.focus) try {
|
||
return this.focus(), !1;
|
||
} catch (e) {}
|
||
},
|
||
delegateType: "focusin"
|
||
},
|
||
blur: {
|
||
trigger: function() {
|
||
if (this === document1.activeElement && this.blur) return this.blur(), !1;
|
||
},
|
||
delegateType: "focusout"
|
||
},
|
||
beforeunload: {
|
||
postDispatch: function(event) {
|
||
undefined1 !== event.result && (event.originalEvent.returnValue = event.result);
|
||
}
|
||
}
|
||
},
|
||
simulate: function(type, elem, event, bubble) {
|
||
var e = jQuery.extend(new jQuery.Event(), event, {
|
||
type: type,
|
||
isSimulated: !0,
|
||
originalEvent: {}
|
||
});
|
||
bubble ? jQuery.event.trigger(e, null, elem) : jQuery.event.dispatch.call(elem, e), e.isDefaultPrevented() && event.preventDefault();
|
||
}
|
||
}, jQuery.removeEvent = document1.removeEventListener ? function(elem, type, handle) {
|
||
elem.removeEventListener && elem.removeEventListener(type, handle, !1);
|
||
} : function(elem, type, handle) {
|
||
var name = "on" + type;
|
||
elem.detachEvent && (typeof elem[name] === core_strundefined && (elem[name] = null), elem.detachEvent(name, handle));
|
||
}, jQuery.Event = function(src, props) {
|
||
if (!(this instanceof jQuery.Event)) return new jQuery.Event(src, props);
|
||
src && src.type ? (this.originalEvent = src, this.type = src.type, this.isDefaultPrevented = src.defaultPrevented || !1 === src.returnValue || src.getPreventDefault && src.getPreventDefault() ? returnTrue : returnFalse) : this.type = src, props && jQuery.extend(this, props), this.timeStamp = src && src.timeStamp || jQuery.now(), this[jQuery.expando] = !0;
|
||
}, jQuery.Event.prototype = {
|
||
isDefaultPrevented: returnFalse,
|
||
isPropagationStopped: returnFalse,
|
||
isImmediatePropagationStopped: returnFalse,
|
||
preventDefault: function() {
|
||
var e = this.originalEvent;
|
||
this.isDefaultPrevented = returnTrue, e && (e.preventDefault ? e.preventDefault() : e.returnValue = !1);
|
||
},
|
||
stopPropagation: function() {
|
||
var e = this.originalEvent;
|
||
this.isPropagationStopped = returnTrue, e && (e.stopPropagation && e.stopPropagation(), e.cancelBubble = !0);
|
||
},
|
||
stopImmediatePropagation: function() {
|
||
this.isImmediatePropagationStopped = returnTrue, this.stopPropagation();
|
||
}
|
||
}, jQuery.each({
|
||
mouseenter: "mouseover",
|
||
mouseleave: "mouseout"
|
||
}, function(orig, fix) {
|
||
jQuery.event.special[orig] = {
|
||
delegateType: fix,
|
||
bindType: fix,
|
||
handle: function(event) {
|
||
var ret, related = event.relatedTarget, handleObj = event.handleObj;
|
||
return related && (related === this || jQuery.contains(this, related)) || (event.type = handleObj.origType, ret = handleObj.handler.apply(this, arguments), event.type = fix), ret;
|
||
}
|
||
};
|
||
}), jQuery.support.submitBubbles || (jQuery.event.special.submit = {
|
||
setup: function() {
|
||
if (jQuery.nodeName(this, "form")) return !1;
|
||
jQuery.event.add(this, "click._submit keypress._submit", function(e) {
|
||
var elem = e.target, form = jQuery.nodeName(elem, "input") || jQuery.nodeName(elem, "button") ? elem.form : undefined1;
|
||
form && !jQuery._data(form, "submitBubbles") && (jQuery.event.add(form, "submit._submit", function(event) {
|
||
event._submit_bubble = !0;
|
||
}), jQuery._data(form, "submitBubbles", !0));
|
||
});
|
||
},
|
||
postDispatch: function(event) {
|
||
event._submit_bubble && (delete event._submit_bubble, this.parentNode && !event.isTrigger && jQuery.event.simulate("submit", this.parentNode, event, !0));
|
||
},
|
||
teardown: function() {
|
||
if (jQuery.nodeName(this, "form")) return !1;
|
||
jQuery.event.remove(this, "._submit");
|
||
}
|
||
}), jQuery.support.changeBubbles || (jQuery.event.special.change = {
|
||
setup: function() {
|
||
if (rformElems.test(this.nodeName)) return ("checkbox" === this.type || "radio" === this.type) && (jQuery.event.add(this, "propertychange._change", function(event) {
|
||
"checked" === event.originalEvent.propertyName && (this._just_changed = !0);
|
||
}), jQuery.event.add(this, "click._change", function(event) {
|
||
this._just_changed && !event.isTrigger && (this._just_changed = !1), jQuery.event.simulate("change", this, event, !0);
|
||
})), !1;
|
||
jQuery.event.add(this, "beforeactivate._change", function(e) {
|
||
var elem = e.target;
|
||
rformElems.test(elem.nodeName) && !jQuery._data(elem, "changeBubbles") && (jQuery.event.add(elem, "change._change", function(event) {
|
||
!this.parentNode || event.isSimulated || event.isTrigger || jQuery.event.simulate("change", this.parentNode, event, !0);
|
||
}), jQuery._data(elem, "changeBubbles", !0));
|
||
});
|
||
},
|
||
handle: function(event) {
|
||
var elem = event.target;
|
||
if (this !== elem || event.isSimulated || event.isTrigger || "radio" !== elem.type && "checkbox" !== elem.type) return event.handleObj.handler.apply(this, arguments);
|
||
},
|
||
teardown: function() {
|
||
return jQuery.event.remove(this, "._change"), !rformElems.test(this.nodeName);
|
||
}
|
||
}), jQuery.support.focusinBubbles || jQuery.each({
|
||
focus: "focusin",
|
||
blur: "focusout"
|
||
}, function(orig, fix) {
|
||
var attaches = 0, handler = function(event) {
|
||
jQuery.event.simulate(fix, event.target, jQuery.event.fix(event), !0);
|
||
};
|
||
jQuery.event.special[fix] = {
|
||
setup: function() {
|
||
0 == attaches++ && document1.addEventListener(orig, handler, !0);
|
||
},
|
||
teardown: function() {
|
||
0 == --attaches && document1.removeEventListener(orig, handler, !0);
|
||
}
|
||
};
|
||
}), jQuery.fn.extend({
|
||
on: function(types, selector, data, fn, one) {
|
||
var type, origFn;
|
||
if ("object" == typeof types) {
|
||
for(type in "string" != typeof selector && (data = data || selector, selector = undefined1), types)this.on(type, selector, data, types[type], one);
|
||
return this;
|
||
}
|
||
if (null == data && null == fn ? (fn = selector, data = selector = undefined1) : null == fn && ("string" == typeof selector ? (fn = data, data = undefined1) : (fn = data, data = selector, selector = undefined1)), !1 === fn) fn = returnFalse;
|
||
else if (!fn) return this;
|
||
return 1 === one && (origFn = fn, (fn = function(event) {
|
||
return jQuery().off(event), origFn.apply(this, arguments);
|
||
}).guid = origFn.guid || (origFn.guid = jQuery.guid++)), this.each(function() {
|
||
jQuery.event.add(this, types, fn, data, selector);
|
||
});
|
||
},
|
||
one: function(types, selector, data, fn) {
|
||
return this.on(types, selector, data, fn, 1);
|
||
},
|
||
off: function(types, selector, fn) {
|
||
var handleObj, type;
|
||
if (types && types.preventDefault && types.handleObj) return handleObj = types.handleObj, jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler), this;
|
||
if ("object" == typeof types) {
|
||
for(type in types)this.off(type, selector, types[type]);
|
||
return this;
|
||
}
|
||
return (!1 === selector || "function" == typeof selector) && (fn = selector, selector = undefined1), !1 === fn && (fn = returnFalse), this.each(function() {
|
||
jQuery.event.remove(this, types, fn, selector);
|
||
});
|
||
},
|
||
bind: function(types, data, fn) {
|
||
return this.on(types, null, data, fn);
|
||
},
|
||
unbind: function(types, fn) {
|
||
return this.off(types, null, fn);
|
||
},
|
||
delegate: function(selector, types, data, fn) {
|
||
return this.on(types, selector, data, fn);
|
||
},
|
||
undelegate: function(selector, types, fn) {
|
||
return 1 === arguments.length ? this.off(selector, "**") : this.off(types, selector || "**", fn);
|
||
},
|
||
trigger: function(type, data) {
|
||
return this.each(function() {
|
||
jQuery.event.trigger(type, data, this);
|
||
});
|
||
},
|
||
triggerHandler: function(type, data) {
|
||
var elem = this[0];
|
||
if (elem) return jQuery.event.trigger(type, data, elem, !0);
|
||
}
|
||
}), (function(window, undefined) {
|
||
var i2, cachedruns, Expr, getText, isXML, compile, hasDuplicate, outermostContext, setDocument, document, docElem, documentIsXML, rbuggyQSA, rbuggyMatches, matches1, contains, sortOrder, expando = "sizzle" + -new Date(), preferredDoc = window.document, support = {}, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), strundefined = "undefined", arr = [], pop = arr.pop, push = arr.push, slice = arr.slice, indexOf = arr.indexOf || function(elem) {
|
||
for(var i = 0, len = this.length; i < len; i++)if (this[i] === elem) return i;
|
||
return -1;
|
||
}, whitespace = "[\\x20\\t\\r\\n\\f]", characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", identifier = characterEncoding.replace("w", "w#"), attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + "*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace(3, 8) + ")*)|.*)\\)|)", rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"), rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rcombinators = new RegExp("^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*"), rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), matchExpr = {
|
||
ID: new RegExp("^#(" + characterEncoding + ")"),
|
||
CLASS: new RegExp("^\\.(" + characterEncoding + ")"),
|
||
NAME: new RegExp("^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]"),
|
||
TAG: new RegExp("^(" + characterEncoding.replace("w", "w*") + ")"),
|
||
ATTR: new RegExp("^" + attributes),
|
||
PSEUDO: new RegExp("^" + pseudos),
|
||
CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
|
||
needsContext: new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
|
||
}, rsibling = /[\x20\t\r\n\f]*[+~]/, rnative = /^[^{]+\{\s*\[native code/, rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rescape = /'|\\/g, rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g, funescape = function(_, escaped) {
|
||
var high = "0x" + escaped - 65536;
|
||
return high != high ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, 1023 & high | 56320);
|
||
};
|
||
try {
|
||
slice.call(preferredDoc.documentElement.childNodes, 0)[0].nodeType;
|
||
} catch (e) {
|
||
slice = function(i) {
|
||
for(var elem, results = []; elem = this[i++];)results.push(elem);
|
||
return results;
|
||
};
|
||
}
|
||
function isNative(fn) {
|
||
return rnative.test(fn + "");
|
||
}
|
||
function createCache() {
|
||
var cache, keys = [];
|
||
return cache = function(key, value) {
|
||
return keys.push(key += " ") > Expr.cacheLength && delete cache[keys.shift()], cache[key] = value;
|
||
};
|
||
}
|
||
function markFunction(fn) {
|
||
return fn[expando] = !0, fn;
|
||
}
|
||
function assert(fn) {
|
||
var div = document.createElement("div");
|
||
try {
|
||
return fn(div);
|
||
} catch (e) {
|
||
return !1;
|
||
} finally{
|
||
div = null;
|
||
}
|
||
}
|
||
function Sizzle(selector, context, results, seed) {
|
||
var match, elem, m, nodeType, i, groups, old, nid, newContext, newSelector;
|
||
if ((context ? context.ownerDocument || context : preferredDoc) !== document && setDocument(context), context = context || document, results = results || [], !selector || "string" != typeof selector) return results;
|
||
if (1 !== (nodeType = context.nodeType) && 9 !== nodeType) return [];
|
||
if (!documentIsXML && !seed) {
|
||
if (match = rquickExpr.exec(selector)) {
|
||
if (m = match[1]) {
|
||
if (9 === nodeType) {
|
||
if (!(elem = context.getElementById(m)) || !elem.parentNode) return results;
|
||
if (elem.id === m) return results.push(elem), results;
|
||
} else if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) && contains(context, elem) && elem.id === m) return results.push(elem), results;
|
||
} else if (match[2]) return push.apply(results, slice.call(context.getElementsByTagName(selector), 0)), results;
|
||
else if ((m = match[3]) && support.getByClassName && context.getElementsByClassName) return push.apply(results, slice.call(context.getElementsByClassName(m), 0)), results;
|
||
}
|
||
if (support.qsa && !rbuggyQSA.test(selector)) {
|
||
if (old = !0, nid = expando, newContext = context, newSelector = 9 === nodeType && selector, 1 === nodeType && "object" !== context.nodeName.toLowerCase()) {
|
||
for(groups = tokenize(selector), (old = context.getAttribute("id")) ? nid = old.replace(rescape, "\\$&") : context.setAttribute("id", nid), nid = "[id='" + nid + "'] ", i = groups.length; i--;)groups[i] = nid + toSelector(groups[i]);
|
||
newContext = rsibling.test(selector) && context.parentNode || context, newSelector = groups.join(",");
|
||
}
|
||
if (newSelector) try {
|
||
return push.apply(results, slice.call(newContext.querySelectorAll(newSelector), 0)), results;
|
||
} catch (qsaError) {} finally{
|
||
old || context.removeAttribute("id");
|
||
}
|
||
}
|
||
}
|
||
return select(selector.replace(rtrim, "$1"), context, results, seed);
|
||
}
|
||
function siblingCheck(a, b) {
|
||
var cur = b && a, diff = cur && (~b.sourceIndex || -2147483648) - (~a.sourceIndex || -2147483648);
|
||
if (diff) return diff;
|
||
if (cur) {
|
||
for(; cur = cur.nextSibling;)if (cur === b) return -1;
|
||
}
|
||
return a ? 1 : -1;
|
||
}
|
||
function createInputPseudo(type) {
|
||
return function(elem) {
|
||
return "input" === elem.nodeName.toLowerCase() && elem.type === type;
|
||
};
|
||
}
|
||
function createButtonPseudo(type) {
|
||
return function(elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return ("input" === name || "button" === name) && elem.type === type;
|
||
};
|
||
}
|
||
function createPositionalPseudo(fn) {
|
||
return markFunction(function(argument) {
|
||
return argument = +argument, markFunction(function(seed, matches) {
|
||
for(var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length; i--;)seed[j = matchIndexes[i]] && (seed[j] = !(matches[j] = seed[j]));
|
||
});
|
||
});
|
||
}
|
||
for(i2 in isXML = Sizzle.isXML = function(elem) {
|
||
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
|
||
return !!documentElement && "HTML" !== documentElement.nodeName;
|
||
}, setDocument = Sizzle.setDocument = function(node1) {
|
||
var doc = node1 ? node1.ownerDocument || node1 : preferredDoc;
|
||
return doc !== document && 9 === doc.nodeType && doc.documentElement && (document = doc, docElem = doc.documentElement, documentIsXML = isXML(doc), support.tagNameNoComments = assert(function(div) {
|
||
return div.appendChild(doc.createComment("")), !div.getElementsByTagName("*").length;
|
||
}), support.attributes = assert(function(div) {
|
||
div.innerHTML = "<select></select>";
|
||
var type = typeof div.lastChild.getAttribute("multiple");
|
||
return "boolean" !== type && "string" !== type;
|
||
}), support.getByClassName = assert(function(div) {
|
||
return div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>", !!div.getElementsByClassName && !!div.getElementsByClassName("e").length && (div.lastChild.className = "e", 2 === div.getElementsByClassName("e").length);
|
||
}), support.getByName = assert(function(div) {
|
||
div.id = expando + 0, div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>", docElem.insertBefore(div, docElem.firstChild);
|
||
var pass = doc.getElementsByName && doc.getElementsByName(expando).length === 2 + doc.getElementsByName(expando + 0).length;
|
||
return support.getIdNotName = !doc.getElementById(expando), docElem.removeChild(div), pass;
|
||
}), Expr.attrHandle = assert(function(div) {
|
||
return div.innerHTML = "<a href='#'></a>", div.firstChild && typeof div.firstChild.getAttribute !== strundefined && "#" === div.firstChild.getAttribute("href");
|
||
}) ? {} : {
|
||
href: function(elem) {
|
||
return elem.getAttribute("href", 2);
|
||
},
|
||
type: function(elem) {
|
||
return elem.getAttribute("type");
|
||
}
|
||
}, support.getIdNotName ? (Expr.find.ID = function(id, context) {
|
||
if (typeof context.getElementById !== strundefined && !documentIsXML) {
|
||
var m = context.getElementById(id);
|
||
return m && m.parentNode ? [
|
||
m
|
||
] : [];
|
||
}
|
||
}, Expr.filter.ID = function(id) {
|
||
var attrId = id.replace(runescape, funescape);
|
||
return function(elem) {
|
||
return elem.getAttribute("id") === attrId;
|
||
};
|
||
}) : (Expr.find.ID = function(id, context) {
|
||
if (typeof context.getElementById !== strundefined && !documentIsXML) {
|
||
var m = context.getElementById(id);
|
||
return m ? m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? [
|
||
m
|
||
] : undefined : [];
|
||
}
|
||
}, Expr.filter.ID = function(id) {
|
||
var attrId = id.replace(runescape, funescape);
|
||
return function(elem) {
|
||
var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
|
||
return node && node.value === attrId;
|
||
};
|
||
}), Expr.find.TAG = support.tagNameNoComments ? function(tag, context) {
|
||
if (typeof context.getElementsByTagName !== strundefined) return context.getElementsByTagName(tag);
|
||
} : function(tag, context) {
|
||
var elem, tmp = [], i = 0, results = context.getElementsByTagName(tag);
|
||
if ("*" === tag) {
|
||
for(; elem = results[i++];)1 === elem.nodeType && tmp.push(elem);
|
||
return tmp;
|
||
}
|
||
return results;
|
||
}, Expr.find.NAME = support.getByName && function(tag, context) {
|
||
if (typeof context.getElementsByName !== strundefined) return context.getElementsByName(name);
|
||
}, Expr.find.CLASS = support.getByClassName && function(className, context) {
|
||
if (typeof context.getElementsByClassName !== strundefined && !documentIsXML) return context.getElementsByClassName(className);
|
||
}, rbuggyMatches = [], rbuggyQSA = [
|
||
":focus"
|
||
], (support.qsa = isNative(doc.querySelectorAll)) && (assert(function(div) {
|
||
div.innerHTML = "<select><option selected=''></option></select>", div.querySelectorAll("[selected]").length || rbuggyQSA.push("\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)"), div.querySelectorAll(":checked").length || rbuggyQSA.push(":checked");
|
||
}), assert(function(div) {
|
||
div.innerHTML = "<input type='hidden' i=''/>", div.querySelectorAll("[i^='']").length && rbuggyQSA.push("[*^$]=" + whitespace + "*(?:\"\"|'')"), div.querySelectorAll(":enabled").length || rbuggyQSA.push(":enabled", ":disabled"), div.querySelectorAll("*,:x"), rbuggyQSA.push(",.*:");
|
||
})), (support.matchesSelector = isNative(matches1 = docElem.matchesSelector || docElem.mozMatchesSelector || docElem.webkitMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) && assert(function(div) {
|
||
support.disconnectedMatch = matches1.call(div, "div"), matches1.call(div, "[s!='']:x"), rbuggyMatches.push("!=", pseudos);
|
||
}), rbuggyQSA = new RegExp(rbuggyQSA.join("|")), rbuggyMatches = new RegExp(rbuggyMatches.join("|")), contains = isNative(docElem.contains) || docElem.compareDocumentPosition ? function(a, b) {
|
||
var adown = 9 === a.nodeType ? a.documentElement : a, bup = b && b.parentNode;
|
||
return a === bup || !!(bup && 1 === bup.nodeType && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && 16 & a.compareDocumentPosition(bup)));
|
||
} : function(a, b) {
|
||
if (b) {
|
||
for(; b = b.parentNode;)if (b === a) return !0;
|
||
}
|
||
return !1;
|
||
}, sortOrder = docElem.compareDocumentPosition ? function(a, b) {
|
||
var compare;
|
||
return a === b ? (hasDuplicate = !0, 0) : (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition(b)) ? 1 & compare || a.parentNode && 11 === a.parentNode.nodeType ? a === doc || contains(preferredDoc, a) ? -1 : b === doc || contains(preferredDoc, b) ? 1 : 0 : 4 & compare ? -1 : 1 : a.compareDocumentPosition ? -1 : 1;
|
||
} : function(a, b) {
|
||
var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [
|
||
a
|
||
], bp = [
|
||
b
|
||
];
|
||
if (a === b) return hasDuplicate = !0, 0;
|
||
if (!aup || !bup) return a === doc ? -1 : b === doc ? 1 : aup ? -1 : bup ? 1 : 0;
|
||
if (aup === bup) return siblingCheck(a, b);
|
||
for(cur = a; cur = cur.parentNode;)ap.unshift(cur);
|
||
for(cur = b; cur = cur.parentNode;)bp.unshift(cur);
|
||
for(; ap[i] === bp[i];)i++;
|
||
return i ? siblingCheck(ap[i], bp[i]) : ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
|
||
}, hasDuplicate = !1, [
|
||
0,
|
||
0
|
||
].sort(sortOrder), support.detectDuplicates = hasDuplicate), document;
|
||
}, Sizzle.matches = function(expr, elements) {
|
||
return Sizzle(expr, null, null, elements);
|
||
}, Sizzle.matchesSelector = function(elem, expr) {
|
||
if ((elem.ownerDocument || elem) !== document && setDocument(elem), expr = expr.replace(rattributeQuotes, "='$1']"), support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr)) try {
|
||
var ret = matches1.call(elem, expr);
|
||
if (ret || support.disconnectedMatch || elem.document && 11 !== elem.document.nodeType) return ret;
|
||
} catch (e) {}
|
||
return Sizzle(expr, document, null, [
|
||
elem
|
||
]).length > 0;
|
||
}, Sizzle.contains = function(context, elem) {
|
||
return (context.ownerDocument || context) !== document && setDocument(context), contains(context, elem);
|
||
}, Sizzle.attr = function(elem, name) {
|
||
var val;
|
||
return ((elem.ownerDocument || elem) !== document && setDocument(elem), documentIsXML || (name = name.toLowerCase()), val = Expr.attrHandle[name]) ? val(elem) : documentIsXML || support.attributes ? elem.getAttribute(name) : ((val = elem.getAttributeNode(name)) || elem.getAttribute(name)) && !0 === elem[name] ? name : val && val.specified ? val.value : null;
|
||
}, Sizzle.error = function(msg) {
|
||
throw new Error("Syntax error, unrecognized expression: " + msg);
|
||
}, Sizzle.uniqueSort = function(results) {
|
||
var elem, duplicates = [], i = 1, j = 0;
|
||
if (hasDuplicate = !support.detectDuplicates, results.sort(sortOrder), hasDuplicate) {
|
||
for(; elem = results[i]; i++)elem === results[i - 1] && (j = duplicates.push(i));
|
||
for(; j--;)results.splice(duplicates[j], 1);
|
||
}
|
||
return results;
|
||
}, getText = Sizzle.getText = function(elem) {
|
||
var node, ret = "", i = 0, nodeType = elem.nodeType;
|
||
if (nodeType) {
|
||
if (1 === nodeType || 9 === nodeType || 11 === nodeType) {
|
||
if ("string" == typeof elem.textContent) return elem.textContent;
|
||
for(elem = elem.firstChild; elem; elem = elem.nextSibling)ret += getText(elem);
|
||
} else if (3 === nodeType || 4 === nodeType) return elem.nodeValue;
|
||
} else for(; node = elem[i]; i++)ret += getText(node);
|
||
return ret;
|
||
}, Expr = Sizzle.selectors = {
|
||
cacheLength: 50,
|
||
createPseudo: markFunction,
|
||
match: matchExpr,
|
||
find: {},
|
||
relative: {
|
||
">": {
|
||
dir: "parentNode",
|
||
first: !0
|
||
},
|
||
" ": {
|
||
dir: "parentNode"
|
||
},
|
||
"+": {
|
||
dir: "previousSibling",
|
||
first: !0
|
||
},
|
||
"~": {
|
||
dir: "previousSibling"
|
||
}
|
||
},
|
||
preFilter: {
|
||
ATTR: function(match) {
|
||
return match[1] = match[1].replace(runescape, funescape), match[3] = (match[4] || match[5] || "").replace(runescape, funescape), "~=" === match[2] && (match[3] = " " + match[3] + " "), match.slice(0, 4);
|
||
},
|
||
CHILD: function(match) {
|
||
return match[1] = match[1].toLowerCase(), "nth" === match[1].slice(0, 3) ? (match[3] || Sizzle.error(match[0]), match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * ("even" === match[3] || "odd" === match[3])), match[5] = +(match[7] + match[8] || "odd" === match[3])) : match[3] && Sizzle.error(match[0]), match;
|
||
},
|
||
PSEUDO: function(match) {
|
||
var excess, unquoted = !match[5] && match[2];
|
||
return matchExpr.CHILD.test(match[0]) ? null : (match[4] ? match[2] = match[4] : unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, !0)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length) && (match[0] = match[0].slice(0, excess), match[2] = unquoted.slice(0, excess)), match.slice(0, 3));
|
||
}
|
||
},
|
||
filter: {
|
||
TAG: function(nodeName) {
|
||
return "*" === nodeName ? function() {
|
||
return !0;
|
||
} : (nodeName = nodeName.replace(runescape, funescape).toLowerCase(), function(elem) {
|
||
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
|
||
});
|
||
},
|
||
CLASS: function(className) {
|
||
var pattern = classCache[className + " "];
|
||
return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)"), classCache(className, function(elem) {
|
||
return pattern.test(elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "");
|
||
}));
|
||
},
|
||
ATTR: function(name, operator, check) {
|
||
return function(elem) {
|
||
var result = Sizzle.attr(elem, name);
|
||
return null == result ? "!=" === operator : !operator || (result += "", "=" === operator ? result === check : "!=" === operator ? result !== check : "^=" === operator ? check && 0 === result.indexOf(check) : "*=" === operator ? check && result.indexOf(check) > -1 : "$=" === operator ? check && result.slice(-check.length) === check : "~=" === operator ? (" " + result + " ").indexOf(check) > -1 : "|=" === operator && (result === check || result.slice(0, check.length + 1) === check + "-"));
|
||
};
|
||
},
|
||
CHILD: function(type, what, argument, first, last) {
|
||
var simple = "nth" !== type.slice(0, 3), forward = "last" !== type.slice(-4), ofType = "of-type" === what;
|
||
return 1 === first && 0 === last ? function(elem) {
|
||
return !!elem.parentNode;
|
||
} : function(elem, context, xml) {
|
||
var cache, outerCache, node, diff, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType;
|
||
if (parent) {
|
||
if (simple) {
|
||
for(; dir;){
|
||
for(node = elem; node = node[dir];)if (ofType ? node.nodeName.toLowerCase() === name : 1 === node.nodeType) return !1;
|
||
start = dir = "only" === type && !start && "nextSibling";
|
||
}
|
||
return !0;
|
||
}
|
||
if (start = [
|
||
forward ? parent.firstChild : parent.lastChild
|
||
], forward && useCache) {
|
||
for(nodeIndex = (cache = (outerCache = parent[expando] || (parent[expando] = {}))[type] || [])[0] === dirruns && cache[1], diff = cache[0] === dirruns && cache[2], node = nodeIndex && parent.childNodes[nodeIndex]; node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop();)if (1 === node.nodeType && ++diff && node === elem) {
|
||
outerCache[type] = [
|
||
dirruns,
|
||
nodeIndex,
|
||
diff
|
||
];
|
||
break;
|
||
}
|
||
} else if (useCache && (cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns) diff = cache[1];
|
||
else for(; (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) && (!((ofType ? node.nodeName.toLowerCase() === name : 1 === node.nodeType) && ++diff) || (useCache && ((node[expando] || (node[expando] = {}))[type] = [
|
||
dirruns,
|
||
diff
|
||
]), node !== elem)););
|
||
return (diff -= last) === first || diff % first == 0 && diff / first >= 0;
|
||
}
|
||
};
|
||
},
|
||
PSEUDO: function(pseudo, argument) {
|
||
var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
|
||
return fn[expando] ? fn(argument) : fn.length > 1 ? (args = [
|
||
pseudo,
|
||
pseudo,
|
||
"",
|
||
argument
|
||
], Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches) {
|
||
for(var idx, matched = fn(seed, argument), i = matched.length; i--;)idx = indexOf.call(seed, matched[i]), seed[idx] = !(matches[idx] = matched[i]);
|
||
}) : function(elem) {
|
||
return fn(elem, 0, args);
|
||
}) : fn;
|
||
}
|
||
},
|
||
pseudos: {
|
||
not: markFunction(function(selector) {
|
||
var input = [], results = [], matcher = compile(selector.replace(rtrim, "$1"));
|
||
return matcher[expando] ? markFunction(function(seed, matches, context, xml) {
|
||
for(var elem, unmatched = matcher(seed, null, xml, []), i = seed.length; i--;)(elem = unmatched[i]) && (seed[i] = !(matches[i] = elem));
|
||
}) : function(elem, context, xml) {
|
||
return input[0] = elem, matcher(input, null, xml, results), !results.pop();
|
||
};
|
||
}),
|
||
has: markFunction(function(selector) {
|
||
return function(elem) {
|
||
return Sizzle(selector, elem).length > 0;
|
||
};
|
||
}),
|
||
contains: markFunction(function(text) {
|
||
return function(elem) {
|
||
return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
|
||
};
|
||
}),
|
||
lang: markFunction(function(lang) {
|
||
return ridentifier.test(lang || "") || Sizzle.error("unsupported lang: " + lang), lang = lang.replace(runescape, funescape).toLowerCase(), function(elem) {
|
||
var elemLang;
|
||
do if (elemLang = documentIsXML ? elem.getAttribute("xml:lang") || elem.getAttribute("lang") : elem.lang) return (elemLang = elemLang.toLowerCase()) === lang || 0 === elemLang.indexOf(lang + "-");
|
||
while ((elem = elem.parentNode) && 1 === elem.nodeType)
|
||
return !1;
|
||
};
|
||
}),
|
||
target: function(elem) {
|
||
var hash = window.location && window.location.hash;
|
||
return hash && hash.slice(1) === elem.id;
|
||
},
|
||
root: function(elem) {
|
||
return elem === docElem;
|
||
},
|
||
focus: function(elem) {
|
||
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
|
||
},
|
||
enabled: function(elem) {
|
||
return !1 === elem.disabled;
|
||
},
|
||
disabled: function(elem) {
|
||
return !0 === elem.disabled;
|
||
},
|
||
checked: function(elem) {
|
||
var nodeName = elem.nodeName.toLowerCase();
|
||
return "input" === nodeName && !!elem.checked || "option" === nodeName && !!elem.selected;
|
||
},
|
||
selected: function(elem) {
|
||
return elem.parentNode && elem.parentNode.selectedIndex, !0 === elem.selected;
|
||
},
|
||
empty: function(elem) {
|
||
for(elem = elem.firstChild; elem; elem = elem.nextSibling)if (elem.nodeName > "@" || 3 === elem.nodeType || 4 === elem.nodeType) return !1;
|
||
return !0;
|
||
},
|
||
parent: function(elem) {
|
||
return !Expr.pseudos.empty(elem);
|
||
},
|
||
header: function(elem) {
|
||
return rheader.test(elem.nodeName);
|
||
},
|
||
input: function(elem) {
|
||
return rinputs.test(elem.nodeName);
|
||
},
|
||
button: function(elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return "input" === name && "button" === elem.type || "button" === name;
|
||
},
|
||
text: function(elem) {
|
||
var attr;
|
||
return "input" === elem.nodeName.toLowerCase() && "text" === elem.type && (null == (attr = elem.getAttribute("type")) || attr.toLowerCase() === elem.type);
|
||
},
|
||
first: createPositionalPseudo(function() {
|
||
return [
|
||
0
|
||
];
|
||
}),
|
||
last: createPositionalPseudo(function(matchIndexes, length) {
|
||
return [
|
||
length - 1
|
||
];
|
||
}),
|
||
eq: createPositionalPseudo(function(matchIndexes, length, argument) {
|
||
return [
|
||
argument < 0 ? argument + length : argument
|
||
];
|
||
}),
|
||
even: createPositionalPseudo(function(matchIndexes, length) {
|
||
for(var i = 0; i < length; i += 2)matchIndexes.push(i);
|
||
return matchIndexes;
|
||
}),
|
||
odd: createPositionalPseudo(function(matchIndexes, length) {
|
||
for(var i = 1; i < length; i += 2)matchIndexes.push(i);
|
||
return matchIndexes;
|
||
}),
|
||
lt: createPositionalPseudo(function(matchIndexes, length, argument) {
|
||
for(var i = argument < 0 ? argument + length : argument; --i >= 0;)matchIndexes.push(i);
|
||
return matchIndexes;
|
||
}),
|
||
gt: createPositionalPseudo(function(matchIndexes, length, argument) {
|
||
for(var i = argument < 0 ? argument + length : argument; ++i < length;)matchIndexes.push(i);
|
||
return matchIndexes;
|
||
})
|
||
}
|
||
}, {
|
||
radio: !0,
|
||
checkbox: !0,
|
||
file: !0,
|
||
password: !0,
|
||
image: !0
|
||
})Expr.pseudos[i2] = createInputPseudo(i2);
|
||
for(i2 in {
|
||
submit: !0,
|
||
reset: !0
|
||
})Expr.pseudos[i2] = createButtonPseudo(i2);
|
||
function tokenize(selector, parseOnly) {
|
||
var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
|
||
if (cached) return parseOnly ? 0 : cached.slice(0);
|
||
for(soFar = selector, groups = [], preFilters = Expr.preFilter; soFar;){
|
||
for(type in (!matched || (match = rcomma.exec(soFar))) && (match && (soFar = soFar.slice(match[0].length) || soFar), groups.push(tokens = [])), matched = !1, (match = rcombinators.exec(soFar)) && (matched = match.shift(), tokens.push({
|
||
value: matched,
|
||
type: match[0].replace(rtrim, " ")
|
||
}), soFar = soFar.slice(matched.length)), Expr.filter)(match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match))) && (matched = match.shift(), tokens.push({
|
||
value: matched,
|
||
type: type,
|
||
matches: match
|
||
}), soFar = soFar.slice(matched.length));
|
||
if (!matched) break;
|
||
}
|
||
return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector, groups).slice(0);
|
||
}
|
||
function toSelector(tokens) {
|
||
for(var i = 0, len = tokens.length, selector = ""; i < len; i++)selector += tokens[i].value;
|
||
return selector;
|
||
}
|
||
function addCombinator(matcher, combinator, base) {
|
||
var dir = combinator.dir, checkNonElements = base && "parentNode" === dir, doneName = done++;
|
||
return combinator.first ? function(elem, context, xml) {
|
||
for(; elem = elem[dir];)if (1 === elem.nodeType || checkNonElements) return matcher(elem, context, xml);
|
||
} : function(elem, context, xml) {
|
||
var data, cache, outerCache, dirkey = dirruns + " " + doneName;
|
||
if (xml) {
|
||
for(; elem = elem[dir];)if ((1 === elem.nodeType || checkNonElements) && matcher(elem, context, xml)) return !0;
|
||
} else for(; elem = elem[dir];)if (1 === elem.nodeType || checkNonElements) {
|
||
if ((cache = (outerCache = elem[expando] || (elem[expando] = {}))[dir]) && cache[0] === dirkey) {
|
||
if (!0 === (data = cache[1]) || data === cachedruns) return !0 === data;
|
||
} else if ((cache = outerCache[dir] = [
|
||
dirkey
|
||
])[1] = matcher(elem, context, xml) || cachedruns, !0 === cache[1]) return !0;
|
||
}
|
||
};
|
||
}
|
||
function elementMatcher(matchers) {
|
||
return matchers.length > 1 ? function(elem, context, xml) {
|
||
for(var i = matchers.length; i--;)if (!matchers[i](elem, context, xml)) return !1;
|
||
return !0;
|
||
} : matchers[0];
|
||
}
|
||
function condense(unmatched, map, filter, context, xml) {
|
||
for(var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = null != map; i < len; i++)(elem = unmatched[i]) && (!filter || filter(elem, context, xml)) && (newUnmatched.push(elem), mapped && map.push(i));
|
||
return newUnmatched;
|
||
}
|
||
function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
|
||
return postFilter && !postFilter[expando] && (postFilter = setMatcher(postFilter)), postFinder && !postFinder[expando] && (postFinder = setMatcher(postFinder, postSelector)), markFunction(function(seed, results, context, xml) {
|
||
var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts(selector || "*", context.nodeType ? [
|
||
context
|
||
] : context, []), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, matcherOut = matcher ? postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results : matcherIn;
|
||
if (matcher && matcher(matcherIn, matcherOut, context, xml), postFilter) for(postFilter(temp = condense(matcherOut, postMap), [], context, xml), i = temp.length; i--;)(elem = temp[i]) && (matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem));
|
||
if (seed) {
|
||
if (postFinder || preFilter) {
|
||
if (postFinder) {
|
||
for(temp = [], i = matcherOut.length; i--;)(elem = matcherOut[i]) && temp.push(matcherIn[i] = elem);
|
||
postFinder(null, matcherOut = [], temp, xml);
|
||
}
|
||
for(i = matcherOut.length; i--;)(elem = matcherOut[i]) && (temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1 && (seed[temp] = !(results[temp] = elem));
|
||
}
|
||
} else matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut), postFinder ? postFinder(null, results, matcherOut, xml) : push.apply(results, matcherOut);
|
||
});
|
||
}
|
||
function matcherFromTokens(tokens) {
|
||
for(var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, matchContext = addCombinator(function(elem) {
|
||
return elem === checkContext;
|
||
}, implicitRelative, !0), matchAnyContext = addCombinator(function(elem) {
|
||
return indexOf.call(checkContext, elem) > -1;
|
||
}, implicitRelative, !0), matchers = [
|
||
function(elem, context, xml) {
|
||
return !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
|
||
}
|
||
]; i < len; i++)if (matcher = Expr.relative[tokens[i].type]) matchers = [
|
||
addCombinator(elementMatcher(matchers), matcher)
|
||
];
|
||
else {
|
||
if ((matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches))[expando]) {
|
||
for(j = ++i; j < len && !Expr.relative[tokens[j].type]; j++);
|
||
return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1)).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
|
||
}
|
||
matchers.push(matcher);
|
||
}
|
||
return elementMatcher(matchers);
|
||
}
|
||
function multipleContexts(selector, contexts, results) {
|
||
for(var i = 0, len = contexts.length; i < len; i++)Sizzle(selector, contexts[i], results);
|
||
return results;
|
||
}
|
||
function select(selector, context, results, seed) {
|
||
var i, tokens, token, type, find, match = tokenize(selector);
|
||
if (!seed && 1 === match.length) {
|
||
if ((tokens = match[0] = match[0].slice(0)).length > 2 && "ID" === (token = tokens[0]).type && 9 === context.nodeType && !documentIsXML && Expr.relative[tokens[1].type]) {
|
||
if (!(context = Expr.find.ID(token.matches[0].replace(runescape, funescape), context)[0])) return results;
|
||
selector = selector.slice(tokens.shift().value.length);
|
||
}
|
||
for(i = matchExpr.needsContext.test(selector) ? 0 : tokens.length; i--;){
|
||
if (token = tokens[i], Expr.relative[type = token.type]) break;
|
||
if ((find = Expr.find[type]) && (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && context.parentNode || context))) {
|
||
if (tokens.splice(i, 1), !(selector = seed.length && toSelector(tokens))) return push.apply(results, slice.call(seed, 0)), results;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return compile(selector, match)(seed, context, documentIsXML, results, rsibling.test(selector)), results;
|
||
}
|
||
function setFilters() {}
|
||
compile = Sizzle.compile = function(selector, group) {
|
||
var elementMatchers, setMatchers, matcherCachedRuns, bySet, byElement, superMatcher, i3, setMatchers1 = [], elementMatchers1 = [], cached = compilerCache[selector + " "];
|
||
if (!cached) {
|
||
for(group || (group = tokenize(selector)), i3 = group.length; i3--;)(cached = matcherFromTokens(group[i3]))[expando] ? setMatchers1.push(cached) : elementMatchers1.push(cached);
|
||
cached = compilerCache(selector, (elementMatchers = elementMatchers1, matcherCachedRuns = 0, bySet = (setMatchers = setMatchers1).length > 0, byElement = elementMatchers.length > 0, superMatcher = function(seed, context, xml, results, expandContext) {
|
||
var elem, j, matcher, setMatched = [], matchedCount = 0, i = "0", unmatched = seed && [], outermost = null != expandContext, contextBackup = outermostContext, elems = seed || byElement && Expr.find.TAG("*", expandContext && context.parentNode || context), dirrunsUnique = dirruns += null == contextBackup ? 1 : Math.random() || 0.1;
|
||
for(outermost && (outermostContext = context !== document && context, cachedruns = matcherCachedRuns); null != (elem = elems[i]); i++){
|
||
if (byElement && elem) {
|
||
for(j = 0; matcher = elementMatchers[j++];)if (matcher(elem, context, xml)) {
|
||
results.push(elem);
|
||
break;
|
||
}
|
||
outermost && (dirruns = dirrunsUnique, cachedruns = ++matcherCachedRuns);
|
||
}
|
||
bySet && ((elem = !matcher && elem) && matchedCount--, seed && unmatched.push(elem));
|
||
}
|
||
if (matchedCount += i, bySet && i !== matchedCount) {
|
||
for(j = 0; matcher = setMatchers[j++];)matcher(unmatched, setMatched, context, xml);
|
||
if (seed) {
|
||
if (matchedCount > 0) for(; i--;)unmatched[i] || setMatched[i] || (setMatched[i] = pop.call(results));
|
||
setMatched = condense(setMatched);
|
||
}
|
||
push.apply(results, setMatched), outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1 && Sizzle.uniqueSort(results);
|
||
}
|
||
return outermost && (dirruns = dirrunsUnique, outermostContext = contextBackup), unmatched;
|
||
}, bySet ? markFunction(superMatcher) : superMatcher));
|
||
}
|
||
return cached;
|
||
}, Expr.pseudos.nth = Expr.pseudos.eq, Expr.filters = setFilters.prototype = Expr.pseudos, Expr.setFilters = new setFilters(), setDocument(), Sizzle.attr = jQuery.attr, jQuery.find = Sizzle, jQuery.expr = Sizzle.selectors, jQuery.expr[":"] = jQuery.expr.pseudos, jQuery.unique = Sizzle.uniqueSort, jQuery.text = Sizzle.getText, jQuery.isXMLDoc = Sizzle.isXML, jQuery.contains = Sizzle.contains;
|
||
})(window1);
|
||
var runtil = /Until$/, rparentsprev = /^(?:parents|prev(?:Until|All))/, isSimple = /^.[^:#\[\.,]*$/, rneedsContext = jQuery.expr.match.needsContext, guaranteedUnique = {
|
||
children: !0,
|
||
contents: !0,
|
||
next: !0,
|
||
prev: !0
|
||
};
|
||
function sibling(cur, dir) {
|
||
do cur = cur[dir];
|
||
while (cur && 1 !== cur.nodeType)
|
||
return cur;
|
||
}
|
||
function winnow(elements, qualifier, keep) {
|
||
if (qualifier = qualifier || 0, jQuery.isFunction(qualifier)) return jQuery.grep(elements, function(elem, i) {
|
||
return !!qualifier.call(elem, i, elem) === keep;
|
||
});
|
||
if (qualifier.nodeType) return jQuery.grep(elements, function(elem) {
|
||
return elem === qualifier === keep;
|
||
});
|
||
if ("string" == typeof qualifier) {
|
||
var filtered = jQuery.grep(elements, function(elem) {
|
||
return 1 === elem.nodeType;
|
||
});
|
||
if (isSimple.test(qualifier)) return jQuery.filter(qualifier, filtered, !keep);
|
||
qualifier = jQuery.filter(qualifier, filtered);
|
||
}
|
||
return jQuery.grep(elements, function(elem) {
|
||
return jQuery.inArray(elem, qualifier) >= 0 === keep;
|
||
});
|
||
}
|
||
function createSafeFragment(document) {
|
||
var list = nodeNames.split("|"), safeFrag = document.createDocumentFragment();
|
||
if (safeFrag.createElement) for(; list.length;)safeFrag.createElement(list.pop());
|
||
return safeFrag;
|
||
}
|
||
jQuery.fn.extend({
|
||
find: function(selector) {
|
||
var i, ret, self, len = this.length;
|
||
if ("string" != typeof selector) return self = this, this.pushStack(jQuery(selector).filter(function() {
|
||
for(i = 0; i < len; i++)if (jQuery.contains(self[i], this)) return !0;
|
||
}));
|
||
for(i = 0, ret = []; i < len; i++)jQuery.find(selector, this[i], ret);
|
||
return (ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret)).selector = (this.selector ? this.selector + " " : "") + selector, ret;
|
||
},
|
||
has: function(target) {
|
||
var i, targets = jQuery(target, this), len = targets.length;
|
||
return this.filter(function() {
|
||
for(i = 0; i < len; i++)if (jQuery.contains(this, targets[i])) return !0;
|
||
});
|
||
},
|
||
not: function(selector) {
|
||
return this.pushStack(winnow(this, selector, !1));
|
||
},
|
||
filter: function(selector) {
|
||
return this.pushStack(winnow(this, selector, !0));
|
||
},
|
||
is: function(selector) {
|
||
return !!selector && ("string" == typeof selector ? rneedsContext.test(selector) ? jQuery(selector, this.context).index(this[0]) >= 0 : jQuery.filter(selector, this).length > 0 : this.filter(selector).length > 0);
|
||
},
|
||
closest: function(selectors, context) {
|
||
for(var cur, i = 0, l = this.length, ret = [], pos = rneedsContext.test(selectors) || "string" != typeof selectors ? jQuery(selectors, context || this.context) : 0; i < l; i++)for(cur = this[i]; cur && cur.ownerDocument && cur !== context && 11 !== cur.nodeType;){
|
||
if (pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors)) {
|
||
ret.push(cur);
|
||
break;
|
||
}
|
||
cur = cur.parentNode;
|
||
}
|
||
return this.pushStack(ret.length > 1 ? jQuery.unique(ret) : ret);
|
||
},
|
||
index: function(elem) {
|
||
return elem ? "string" == typeof elem ? jQuery.inArray(this[0], jQuery(elem)) : jQuery.inArray(elem.jquery ? elem[0] : elem, this) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
|
||
},
|
||
add: function(selector, context) {
|
||
var set = "string" == typeof selector ? jQuery(selector, context) : jQuery.makeArray(selector && selector.nodeType ? [
|
||
selector
|
||
] : selector), all = jQuery.merge(this.get(), set);
|
||
return this.pushStack(jQuery.unique(all));
|
||
},
|
||
addBack: function(selector) {
|
||
return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
|
||
}
|
||
}), jQuery.fn.andSelf = jQuery.fn.addBack, jQuery.each({
|
||
parent: function(elem) {
|
||
var parent = elem.parentNode;
|
||
return parent && 11 !== parent.nodeType ? parent : null;
|
||
},
|
||
parents: function(elem) {
|
||
return jQuery.dir(elem, "parentNode");
|
||
},
|
||
parentsUntil: function(elem, i, until) {
|
||
return jQuery.dir(elem, "parentNode", until);
|
||
},
|
||
next: function(elem) {
|
||
return sibling(elem, "nextSibling");
|
||
},
|
||
prev: function(elem) {
|
||
return sibling(elem, "previousSibling");
|
||
},
|
||
nextAll: function(elem) {
|
||
return jQuery.dir(elem, "nextSibling");
|
||
},
|
||
prevAll: function(elem) {
|
||
return jQuery.dir(elem, "previousSibling");
|
||
},
|
||
nextUntil: function(elem, i, until) {
|
||
return jQuery.dir(elem, "nextSibling", until);
|
||
},
|
||
prevUntil: function(elem, i, until) {
|
||
return jQuery.dir(elem, "previousSibling", until);
|
||
},
|
||
siblings: function(elem) {
|
||
return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
|
||
},
|
||
children: function(elem) {
|
||
return jQuery.sibling(elem.firstChild);
|
||
},
|
||
contents: function(elem) {
|
||
return jQuery.nodeName(elem, "iframe") ? elem.contentDocument || elem.contentWindow.document : jQuery.merge([], elem.childNodes);
|
||
}
|
||
}, function(name, fn) {
|
||
jQuery.fn[name] = function(until, selector) {
|
||
var ret = jQuery.map(this, fn, until);
|
||
return runtil.test(name) || (selector = until), selector && "string" == typeof selector && (ret = jQuery.filter(selector, ret)), ret = this.length > 1 && !guaranteedUnique[name] ? jQuery.unique(ret) : ret, this.length > 1 && rparentsprev.test(name) && (ret = ret.reverse()), this.pushStack(ret);
|
||
};
|
||
}), jQuery.extend({
|
||
filter: function(expr, elems, not) {
|
||
return not && (expr = ":not(" + expr + ")"), 1 === elems.length ? jQuery.find.matchesSelector(elems[0], expr) ? [
|
||
elems[0]
|
||
] : [] : jQuery.find.matches(expr, elems);
|
||
},
|
||
dir: function(elem, dir, until) {
|
||
for(var matched = [], cur = elem[dir]; cur && 9 !== cur.nodeType && (until === undefined1 || 1 !== cur.nodeType || !jQuery(cur).is(until));)1 === cur.nodeType && matched.push(cur), cur = cur[dir];
|
||
return matched;
|
||
},
|
||
sibling: function(n, elem) {
|
||
for(var r = []; n; n = n.nextSibling)1 === n.nodeType && n !== elem && r.push(n);
|
||
return r;
|
||
}
|
||
});
|
||
var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"), rleadingWhitespace = /^\s+/, rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, rtagName = /<([\w:]+)/, rtbody = /<tbody/i, rhtml = /<|&#?\w+;/, rnoInnerhtml = /<(?:script|style|link)/i, manipulation_rcheckableType = /^(?:checkbox|radio)$/i, rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptType = /^$|\/(?:java|ecma)script/i, rscriptTypeMasked = /^true\/(.*)/, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, wrapMap = {
|
||
option: [
|
||
1,
|
||
"<select multiple='multiple'>",
|
||
"</select>"
|
||
],
|
||
legend: [
|
||
1,
|
||
"<fieldset>",
|
||
"</fieldset>"
|
||
],
|
||
area: [
|
||
1,
|
||
"<map>",
|
||
"</map>"
|
||
],
|
||
param: [
|
||
1,
|
||
"<object>",
|
||
"</object>"
|
||
],
|
||
thead: [
|
||
1,
|
||
"<table>",
|
||
"</table>"
|
||
],
|
||
tr: [
|
||
2,
|
||
"<table><tbody>",
|
||
"</tbody></table>"
|
||
],
|
||
col: [
|
||
2,
|
||
"<table><tbody></tbody><colgroup>",
|
||
"</colgroup></table>"
|
||
],
|
||
td: [
|
||
3,
|
||
"<table><tbody><tr>",
|
||
"</tr></tbody></table>"
|
||
],
|
||
_default: jQuery.support.htmlSerialize ? [
|
||
0,
|
||
"",
|
||
""
|
||
] : [
|
||
1,
|
||
"X<div>",
|
||
"</div>"
|
||
]
|
||
}, fragmentDiv = createSafeFragment(document1).appendChild(document1.createElement("div"));
|
||
function findOrAppend(elem, tag) {
|
||
return elem.getElementsByTagName(tag)[0] || elem.appendChild(elem.ownerDocument.createElement(tag));
|
||
}
|
||
function disableScript(elem) {
|
||
var attr = elem.getAttributeNode("type");
|
||
return elem.type = (attr && attr.specified) + "/" + elem.type, elem;
|
||
}
|
||
function restoreScript(elem) {
|
||
var match = rscriptTypeMasked.exec(elem.type);
|
||
return match ? elem.type = match[1] : elem.removeAttribute("type"), elem;
|
||
}
|
||
function setGlobalEval(elems, refElements) {
|
||
for(var elem, i = 0; null != (elem = elems[i]); i++)jQuery._data(elem, "globalEval", !refElements || jQuery._data(refElements[i], "globalEval"));
|
||
}
|
||
function cloneCopyEvent(src, dest) {
|
||
if (1 === dest.nodeType && jQuery.hasData(src)) {
|
||
var type, i, l, oldData = jQuery._data(src), curData = jQuery._data(dest, oldData), events = oldData.events;
|
||
if (events) for(type in delete curData.handle, curData.events = {}, events)for(i = 0, l = events[type].length; i < l; i++)jQuery.event.add(dest, type, events[type][i]);
|
||
curData.data && (curData.data = jQuery.extend({}, curData.data));
|
||
}
|
||
}
|
||
function fixCloneNodeIssues(src, dest) {
|
||
var nodeName, e, data;
|
||
if (1 === dest.nodeType) {
|
||
if (nodeName = dest.nodeName.toLowerCase(), !jQuery.support.noCloneEvent && dest[jQuery.expando]) {
|
||
for(e in (data = jQuery._data(dest)).events)jQuery.removeEvent(dest, e, data.handle);
|
||
dest.removeAttribute(jQuery.expando);
|
||
}
|
||
"script" === nodeName && dest.text !== src.text ? (disableScript(dest).text = src.text, restoreScript(dest)) : "object" === nodeName ? (dest.parentNode && (dest.outerHTML = src.outerHTML), jQuery.support.html5Clone && src.innerHTML && !jQuery.trim(dest.innerHTML) && (dest.innerHTML = src.innerHTML)) : "input" === nodeName && manipulation_rcheckableType.test(src.type) ? (dest.defaultChecked = dest.checked = src.checked, dest.value !== src.value && (dest.value = src.value)) : "option" === nodeName ? dest.defaultSelected = dest.selected = src.defaultSelected : ("input" === nodeName || "textarea" === nodeName) && (dest.defaultValue = src.defaultValue);
|
||
}
|
||
}
|
||
function getAll(context, tag) {
|
||
var elems, elem, i = 0, found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName(tag || "*") : typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll(tag || "*") : undefined1;
|
||
if (!found) for(found = [], elems = context.childNodes || context; null != (elem = elems[i]); i++)!tag || jQuery.nodeName(elem, tag) ? found.push(elem) : jQuery.merge(found, getAll(elem, tag));
|
||
return tag === undefined1 || tag && jQuery.nodeName(context, tag) ? jQuery.merge([
|
||
context
|
||
], found) : found;
|
||
}
|
||
function fixDefaultChecked(elem) {
|
||
manipulation_rcheckableType.test(elem.type) && (elem.defaultChecked = elem.checked);
|
||
}
|
||
wrapMap.optgroup = wrapMap.option, wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead, wrapMap.th = wrapMap.td, jQuery.fn.extend({
|
||
text: function(value4) {
|
||
return jQuery.access(this, function(value) {
|
||
return value === undefined1 ? jQuery.text(this) : this.empty().append((this[0] && this[0].ownerDocument || document1).createTextNode(value));
|
||
}, null, value4, arguments.length);
|
||
},
|
||
wrapAll: function(html) {
|
||
if (jQuery.isFunction(html)) return this.each(function(i) {
|
||
jQuery(this).wrapAll(html.call(this, i));
|
||
});
|
||
if (this[0]) {
|
||
var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(!0);
|
||
this[0].parentNode && wrap.insertBefore(this[0]), wrap.map(function() {
|
||
for(var elem = this; elem.firstChild && 1 === elem.firstChild.nodeType;)elem = elem.firstChild;
|
||
return elem;
|
||
}).append(this);
|
||
}
|
||
return this;
|
||
},
|
||
wrapInner: function(html) {
|
||
return jQuery.isFunction(html) ? this.each(function(i) {
|
||
jQuery(this).wrapInner(html.call(this, i));
|
||
}) : this.each(function() {
|
||
var self = jQuery(this), contents = self.contents();
|
||
contents.length ? contents.wrapAll(html) : self.append(html);
|
||
});
|
||
},
|
||
wrap: function(html) {
|
||
var isFunction = jQuery.isFunction(html);
|
||
return this.each(function(i) {
|
||
jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
|
||
});
|
||
},
|
||
unwrap: function() {
|
||
return this.parent().each(function() {
|
||
jQuery.nodeName(this, "body") || jQuery(this).replaceWith(this.childNodes);
|
||
}).end();
|
||
},
|
||
append: function() {
|
||
return this.domManip(arguments, !0, function(elem) {
|
||
(1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) && this.appendChild(elem);
|
||
});
|
||
},
|
||
prepend: function() {
|
||
return this.domManip(arguments, !0, function(elem) {
|
||
(1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) && this.insertBefore(elem, this.firstChild);
|
||
});
|
||
},
|
||
before: function() {
|
||
return this.domManip(arguments, !1, function(elem) {
|
||
this.parentNode && this.parentNode.insertBefore(elem, this);
|
||
});
|
||
},
|
||
after: function() {
|
||
return this.domManip(arguments, !1, function(elem) {
|
||
this.parentNode && this.parentNode.insertBefore(elem, this.nextSibling);
|
||
});
|
||
},
|
||
remove: function(selector, keepData) {
|
||
for(var elem, i = 0; null != (elem = this[i]); i++)(!selector || jQuery.filter(selector, [
|
||
elem
|
||
]).length > 0) && (keepData || 1 !== elem.nodeType || jQuery.cleanData(getAll(elem)), elem.parentNode && (keepData && jQuery.contains(elem.ownerDocument, elem) && setGlobalEval(getAll(elem, "script")), elem.parentNode.removeChild(elem)));
|
||
return this;
|
||
},
|
||
empty: function() {
|
||
for(var elem, i = 0; null != (elem = this[i]); i++){
|
||
for(1 === elem.nodeType && jQuery.cleanData(getAll(elem, !1)); elem.firstChild;)elem.removeChild(elem.firstChild);
|
||
elem.options && jQuery.nodeName(elem, "select") && (elem.options.length = 0);
|
||
}
|
||
return this;
|
||
},
|
||
clone: function(dataAndEvents, deepDataAndEvents) {
|
||
return dataAndEvents = null != dataAndEvents && dataAndEvents, deepDataAndEvents = null == deepDataAndEvents ? dataAndEvents : deepDataAndEvents, this.map(function() {
|
||
return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
|
||
});
|
||
},
|
||
html: function(value5) {
|
||
return jQuery.access(this, function(value) {
|
||
var elem = this[0] || {}, i = 0, l = this.length;
|
||
if (value === undefined1) return 1 === elem.nodeType ? elem.innerHTML.replace(rinlinejQuery, "") : undefined1;
|
||
if ("string" == typeof value && !rnoInnerhtml.test(value) && (jQuery.support.htmlSerialize || !rnoshimcache.test(value)) && (jQuery.support.leadingWhitespace || !rleadingWhitespace.test(value)) && !wrapMap[(rtagName.exec(value) || [
|
||
"",
|
||
""
|
||
])[1].toLowerCase()]) {
|
||
value = value.replace(rxhtmlTag, "<$1></$2>");
|
||
try {
|
||
for(; i < l; i++)elem = this[i] || {}, 1 === elem.nodeType && (jQuery.cleanData(getAll(elem, !1)), elem.innerHTML = value);
|
||
elem = 0;
|
||
} catch (e) {}
|
||
}
|
||
elem && this.empty().append(value);
|
||
}, null, value5, arguments.length);
|
||
},
|
||
replaceWith: function(value) {
|
||
return jQuery.isFunction(value) || "string" == typeof value || (value = jQuery(value).not(this).detach()), this.domManip([
|
||
value
|
||
], !0, function(elem) {
|
||
var next = this.nextSibling, parent = this.parentNode;
|
||
parent && (jQuery(this).remove(), parent.insertBefore(elem, next));
|
||
});
|
||
},
|
||
detach: function(selector) {
|
||
return this.remove(selector, !0);
|
||
},
|
||
domManip: function(args, table, callback) {
|
||
args = core_concat.apply([], args);
|
||
var first, node, hasScripts, scripts, doc, fragment, i = 0, l = this.length, set = this, iNoClone = l - 1, value = args[0], isFunction = jQuery.isFunction(value);
|
||
if (isFunction || !(l <= 1 || "string" != typeof value || jQuery.support.checkClone || !rchecked.test(value))) return this.each(function(index) {
|
||
var self = set.eq(index);
|
||
isFunction && (args[0] = value.call(this, index, table ? self.html() : undefined1)), self.domManip(args, table, callback);
|
||
});
|
||
if (l && (first = (fragment = jQuery.buildFragment(args, this[0].ownerDocument, !1, this)).firstChild, 1 === fragment.childNodes.length && (fragment = first), first)) {
|
||
for(table = table && jQuery.nodeName(first, "tr"), scripts = jQuery.map(getAll(fragment, "script"), disableScript), hasScripts = scripts.length; i < l; i++)node = fragment, i !== iNoClone && (node = jQuery.clone(node, !0, !0), hasScripts && jQuery.merge(scripts, getAll(node, "script"))), callback.call(table && jQuery.nodeName(this[i], "table") ? findOrAppend(this[i], "tbody") : this[i], node, i);
|
||
if (hasScripts) for(doc = scripts[scripts.length - 1].ownerDocument, jQuery.map(scripts, restoreScript), i = 0; i < hasScripts; i++)node = scripts[i], rscriptType.test(node.type || "") && !jQuery._data(node, "globalEval") && jQuery.contains(doc, node) && (node.src ? jQuery.ajax({
|
||
url: node.src,
|
||
type: "GET",
|
||
dataType: "script",
|
||
async: !1,
|
||
global: !1,
|
||
"throws": !0
|
||
}) : jQuery.globalEval((node.text || node.textContent || node.innerHTML || "").replace(rcleanScript, "")));
|
||
fragment = first = null;
|
||
}
|
||
return this;
|
||
}
|
||
}), jQuery.each({
|
||
appendTo: "append",
|
||
prependTo: "prepend",
|
||
insertBefore: "before",
|
||
insertAfter: "after",
|
||
replaceAll: "replaceWith"
|
||
}, function(name, original) {
|
||
jQuery.fn[name] = function(selector) {
|
||
for(var elems, i = 0, ret = [], insert = jQuery(selector), last = insert.length - 1; i <= last; i++)elems = i === last ? this : this.clone(!0), jQuery(insert[i])[original](elems), core_push.apply(ret, elems.get());
|
||
return this.pushStack(ret);
|
||
};
|
||
}), jQuery.extend({
|
||
clone: function(elem, dataAndEvents, deepDataAndEvents) {
|
||
var destElements, node, clone, i, srcElements, inPage = jQuery.contains(elem.ownerDocument, elem);
|
||
if (jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test("<" + elem.nodeName + ">") ? clone = elem.cloneNode(!0) : (fragmentDiv.innerHTML = elem.outerHTML, fragmentDiv.removeChild(clone = fragmentDiv.firstChild)), (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) && (1 === elem.nodeType || 11 === elem.nodeType) && !jQuery.isXMLDoc(elem)) for(i = 0, destElements = getAll(clone), srcElements = getAll(elem); null != (node = srcElements[i]); ++i)destElements[i] && fixCloneNodeIssues(node, destElements[i]);
|
||
if (dataAndEvents) if (deepDataAndEvents) for(i = 0, srcElements = srcElements || getAll(elem), destElements = destElements || getAll(clone); null != (node = srcElements[i]); i++)cloneCopyEvent(node, destElements[i]);
|
||
else cloneCopyEvent(elem, clone);
|
||
return (destElements = getAll(clone, "script")).length > 0 && setGlobalEval(destElements, !inPage && getAll(elem, "script")), destElements = srcElements = node = null, clone;
|
||
},
|
||
buildFragment: function(elems, context, scripts, selection) {
|
||
for(var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length, safe = createSafeFragment(context), nodes = [], i = 0; i < l; i++)if ((elem = elems[i]) || 0 === elem) if ("object" === jQuery.type(elem)) jQuery.merge(nodes, elem.nodeType ? [
|
||
elem
|
||
] : elem);
|
||
else if (rhtml.test(elem)) {
|
||
for(tmp = tmp || safe.appendChild(context.createElement("div")), wrap = wrapMap[tag = (rtagName.exec(elem) || [
|
||
"",
|
||
""
|
||
])[1].toLowerCase()] || wrapMap._default, tmp.innerHTML = wrap[1] + elem.replace(rxhtmlTag, "<$1></$2>") + wrap[2], j = wrap[0]; j--;)tmp = tmp.lastChild;
|
||
if (!jQuery.support.leadingWhitespace && rleadingWhitespace.test(elem) && nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0])), !jQuery.support.tbody) for(j = (elem = "table" !== tag || rtbody.test(elem) ? "<table>" !== wrap[1] || rtbody.test(elem) ? 0 : tmp : tmp.firstChild) && elem.childNodes.length; j--;)jQuery.nodeName(tbody = elem.childNodes[j], "tbody") && !tbody.childNodes.length && elem.removeChild(tbody);
|
||
for(jQuery.merge(nodes, tmp.childNodes), tmp.textContent = ""; tmp.firstChild;)tmp.removeChild(tmp.firstChild);
|
||
tmp = safe.lastChild;
|
||
} else nodes.push(context.createTextNode(elem));
|
||
for(tmp && safe.removeChild(tmp), jQuery.support.appendChecked || jQuery.grep(getAll(nodes, "input"), fixDefaultChecked), i = 0; elem = nodes[i++];)if ((!selection || -1 === jQuery.inArray(elem, selection)) && (contains = jQuery.contains(elem.ownerDocument, elem), tmp = getAll(safe.appendChild(elem), "script"), contains && setGlobalEval(tmp), scripts)) for(j = 0; elem = tmp[j++];)rscriptType.test(elem.type || "") && scripts.push(elem);
|
||
return tmp = null, safe;
|
||
},
|
||
cleanData: function(elems, acceptData) {
|
||
for(var elem, type, id, data, i = 0, internalKey = jQuery.expando, cache = jQuery.cache, deleteExpando = jQuery.support.deleteExpando, special = jQuery.event.special; null != (elem = elems[i]); i++)if ((acceptData || jQuery.acceptData(elem)) && (data = (id = elem[internalKey]) && cache[id])) {
|
||
if (data.events) for(type in data.events)special[type] ? jQuery.event.remove(elem, type) : jQuery.removeEvent(elem, type, data.handle);
|
||
cache[id] && (delete cache[id], deleteExpando ? delete elem[internalKey] : typeof elem.removeAttribute !== core_strundefined ? elem.removeAttribute(internalKey) : elem[internalKey] = null, core_deletedIds.push(id));
|
||
}
|
||
}
|
||
});
|
||
var iframe, getStyles, curCSS, ralpha = /alpha\([^)]*\)/i, ropacity = /opacity\s*=\s*([^)]*)/, rposition = /^(top|right|bottom|left)$/, rdisplayswap = /^(none|table(?!-c[ea]).+)/, rmargin = /^margin/, rnumsplit = new RegExp("^(" + core_pnum + ")(.*)$", "i"), rnumnonpx = new RegExp("^(" + core_pnum + ")(?!px)[a-z%]+$", "i"), rrelNum = new RegExp("^([+-])=(" + core_pnum + ")", "i"), elemdisplay = {
|
||
BODY: "block"
|
||
}, cssShow = {
|
||
position: "absolute",
|
||
visibility: "hidden",
|
||
display: "block"
|
||
}, cssNormalTransform = {
|
||
letterSpacing: 0,
|
||
fontWeight: 400
|
||
}, cssExpand = [
|
||
"Top",
|
||
"Right",
|
||
"Bottom",
|
||
"Left"
|
||
], cssPrefixes = [
|
||
"Webkit",
|
||
"O",
|
||
"Moz",
|
||
"ms"
|
||
];
|
||
function vendorPropName(style, name) {
|
||
if (name in style) return name;
|
||
for(var capName = name.charAt(0).toUpperCase() + name.slice(1), origName = name, i = cssPrefixes.length; i--;)if ((name = cssPrefixes[i] + capName) in style) return name;
|
||
return origName;
|
||
}
|
||
function isHidden(elem, el) {
|
||
return elem = el || elem, "none" === jQuery.css(elem, "display") || !jQuery.contains(elem.ownerDocument, elem);
|
||
}
|
||
function showHide(elements, show) {
|
||
for(var display, elem, hidden, values = [], index = 0, length = elements.length; index < length; index++)!!(elem = elements[index]).style && (values[index] = jQuery._data(elem, "olddisplay"), display = elem.style.display, show ? (values[index] || "none" !== display || (elem.style.display = ""), "" === elem.style.display && isHidden(elem) && (values[index] = jQuery._data(elem, "olddisplay", css_defaultDisplay(elem.nodeName)))) : values[index] || (hidden = isHidden(elem), (display && "none" !== display || !hidden) && jQuery._data(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display"))));
|
||
for(index = 0; index < length; index++)!!(elem = elements[index]).style && (show && "none" !== elem.style.display && "" !== elem.style.display || (elem.style.display = show ? values[index] || "" : "none"));
|
||
return elements;
|
||
}
|
||
function setPositiveNumber(elem, value, subtract) {
|
||
var matches = rnumsplit.exec(value);
|
||
return matches ? Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || "px") : value;
|
||
}
|
||
function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
|
||
for(var i = extra === (isBorderBox ? "border" : "content") ? 4 : "width" === name ? 1 : 0, val = 0; i < 4; i += 2)"margin" === extra && (val += jQuery.css(elem, extra + cssExpand[i], !0, styles)), isBorderBox ? ("content" === extra && (val -= jQuery.css(elem, "padding" + cssExpand[i], !0, styles)), "margin" !== extra && (val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", !0, styles))) : (val += jQuery.css(elem, "padding" + cssExpand[i], !0, styles), "padding" !== extra && (val += jQuery.css(elem, "border" + cssExpand[i] + "Width", !0, styles)));
|
||
return val;
|
||
}
|
||
function getWidthOrHeight(elem, name, extra) {
|
||
var valueIsBorderBox = !0, val = "width" === name ? elem.offsetWidth : elem.offsetHeight, styles = getStyles(elem), isBorderBox = jQuery.support.boxSizing && "border-box" === jQuery.css(elem, "boxSizing", !1, styles);
|
||
if (val <= 0 || null == val) {
|
||
if (((val = curCSS(elem, name, styles)) < 0 || null == val) && (val = elem.style[name]), rnumnonpx.test(val)) return val;
|
||
valueIsBorderBox = isBorderBox && (jQuery.support.boxSizingReliable || val === elem.style[name]), val = parseFloat(val) || 0;
|
||
}
|
||
return val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles) + "px";
|
||
}
|
||
function css_defaultDisplay(nodeName) {
|
||
var doc = document1, display = elemdisplay[nodeName];
|
||
return display || ("none" !== (display = actualDisplay(nodeName, doc)) && display || ((doc = ((iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>").css("cssText", "display:block !important")).appendTo(doc.documentElement))[0].contentWindow || iframe[0].contentDocument).document).write("<!doctype html><html><body>"), doc.close(), display = actualDisplay(nodeName, doc), iframe.detach()), elemdisplay[nodeName] = display), display;
|
||
}
|
||
function actualDisplay(name, doc) {
|
||
var elem = jQuery(doc.createElement(name)).appendTo(doc.body), display = jQuery.css(elem[0], "display");
|
||
return elem.remove(), display;
|
||
}
|
||
jQuery.fn.extend({
|
||
css: function(name1, value6) {
|
||
return jQuery.access(this, function(elem, name, value) {
|
||
var len, styles, map = {}, i = 0;
|
||
if (jQuery.isArray(name)) {
|
||
for(styles = getStyles(elem), len = name.length; i < len; i++)map[name[i]] = jQuery.css(elem, name[i], !1, styles);
|
||
return map;
|
||
}
|
||
return value !== undefined1 ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
|
||
}, name1, value6, arguments.length > 1);
|
||
},
|
||
show: function() {
|
||
return showHide(this, !0);
|
||
},
|
||
hide: function() {
|
||
return showHide(this);
|
||
},
|
||
toggle: function(state) {
|
||
var bool = "boolean" == typeof state;
|
||
return this.each(function() {
|
||
(bool ? state : isHidden(this)) ? jQuery(this).show() : jQuery(this).hide();
|
||
});
|
||
}
|
||
}), jQuery.extend({
|
||
cssHooks: {
|
||
opacity: {
|
||
get: function(elem, computed) {
|
||
if (computed) {
|
||
var ret = curCSS(elem, "opacity");
|
||
return "" === ret ? "1" : ret;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
cssNumber: {
|
||
columnCount: !0,
|
||
fillOpacity: !0,
|
||
fontWeight: !0,
|
||
lineHeight: !0,
|
||
opacity: !0,
|
||
orphans: !0,
|
||
widows: !0,
|
||
zIndex: !0,
|
||
zoom: !0
|
||
},
|
||
cssProps: {
|
||
"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
|
||
},
|
||
style: function(elem, name, value, extra) {
|
||
if (elem && 3 !== elem.nodeType && 8 !== elem.nodeType && elem.style) {
|
||
var ret, type, hooks, origName = jQuery.camelCase(name), style = elem.style;
|
||
if (name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(style, origName)), hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName], value === undefined1) return hooks && "get" in hooks && undefined1 !== (ret = hooks.get(elem, !1, extra)) ? ret : style[name];
|
||
if ("string" == (type = typeof value) && (ret = rrelNum.exec(value)) && (value = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name)), type = "number"), !(null == value || "number" === type && isNaN(value)) && ("number" !== type || jQuery.cssNumber[origName] || (value += "px"), jQuery.support.clearCloneStyle || "" !== value || 0 !== name.indexOf("background") || (style[name] = "inherit"), !hooks || !("set" in hooks) || undefined1 !== (value = hooks.set(elem, value, extra)))) try {
|
||
style[name] = value;
|
||
} catch (e) {}
|
||
}
|
||
},
|
||
css: function(elem, name, extra, styles) {
|
||
var num, val, hooks, origName = jQuery.camelCase(name);
|
||
return (name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(elem.style, origName)), hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName], hooks && "get" in hooks && (val = hooks.get(elem, !0, extra)), val === undefined1 && (val = curCSS(elem, name, styles)), "normal" === val && name in cssNormalTransform && (val = cssNormalTransform[name]), "" === extra || extra) ? (num = parseFloat(val), !0 === extra || jQuery.isNumeric(num) ? num || 0 : val) : val;
|
||
},
|
||
swap: function(elem, options, callback, args) {
|
||
var ret, name, old = {};
|
||
for(name in options)old[name] = elem.style[name], elem.style[name] = options[name];
|
||
for(name in ret = callback.apply(elem, args || []), options)elem.style[name] = old[name];
|
||
return ret;
|
||
}
|
||
}), window1.getComputedStyle ? (getStyles = function(elem) {
|
||
return window1.getComputedStyle(elem, null);
|
||
}, curCSS = function(elem, name, _computed) {
|
||
var width, minWidth, maxWidth, computed = _computed || getStyles(elem), ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined1, style = elem.style;
|
||
return computed && ("" !== ret || jQuery.contains(elem.ownerDocument, elem) || (ret = jQuery.style(elem, name)), rnumnonpx.test(ret) && rmargin.test(name) && (width = style.width, minWidth = style.minWidth, maxWidth = style.maxWidth, style.minWidth = style.maxWidth = style.width = ret, ret = computed.width, style.width = width, style.minWidth = minWidth, style.maxWidth = maxWidth)), ret;
|
||
}) : document1.documentElement.currentStyle && (getStyles = function(elem) {
|
||
return elem.currentStyle;
|
||
}, curCSS = function(elem, name, _computed) {
|
||
var left, rs, rsLeft, computed = _computed || getStyles(elem), ret = computed ? computed[name] : undefined1, style = elem.style;
|
||
return null == ret && style && style[name] && (ret = style[name]), rnumnonpx.test(ret) && !rposition.test(name) && (left = style.left, (rsLeft = (rs = elem.runtimeStyle) && rs.left) && (rs.left = elem.currentStyle.left), style.left = "fontSize" === name ? "1em" : ret, ret = style.pixelLeft + "px", style.left = left, rsLeft && (rs.left = rsLeft)), "" === ret ? "auto" : ret;
|
||
}), jQuery.each([
|
||
"height",
|
||
"width"
|
||
], function(i, name) {
|
||
jQuery.cssHooks[name] = {
|
||
get: function(elem, computed, extra) {
|
||
if (computed) return 0 === elem.offsetWidth && rdisplayswap.test(jQuery.css(elem, "display")) ? jQuery.swap(elem, cssShow, function() {
|
||
return getWidthOrHeight(elem, name, extra);
|
||
}) : getWidthOrHeight(elem, name, extra);
|
||
},
|
||
set: function(elem, value, extra) {
|
||
var styles = extra && getStyles(elem);
|
||
return setPositiveNumber(elem, value, extra ? augmentWidthOrHeight(elem, name, extra, jQuery.support.boxSizing && "border-box" === jQuery.css(elem, "boxSizing", !1, styles), styles) : 0);
|
||
}
|
||
};
|
||
}), jQuery.support.opacity || (jQuery.cssHooks.opacity = {
|
||
get: function(elem, computed) {
|
||
return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ? 0.01 * parseFloat(RegExp.$1) + "" : computed ? "1" : "";
|
||
},
|
||
set: function(elem, value) {
|
||
var style = elem.style, currentStyle = elem.currentStyle, opacity = jQuery.isNumeric(value) ? "alpha(opacity=" + 100 * value + ")" : "", filter = currentStyle && currentStyle.filter || style.filter || "";
|
||
style.zoom = 1, (value >= 1 || "" === value) && "" === jQuery.trim(filter.replace(ralpha, "")) && style.removeAttribute && (style.removeAttribute("filter"), "" === value || currentStyle && !currentStyle.filter) || (style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : filter + " " + opacity);
|
||
}
|
||
}), jQuery(function() {
|
||
jQuery.support.reliableMarginRight || (jQuery.cssHooks.marginRight = {
|
||
get: function(elem, computed) {
|
||
if (computed) return jQuery.swap(elem, {
|
||
display: "inline-block"
|
||
}, curCSS, [
|
||
elem,
|
||
"marginRight"
|
||
]);
|
||
}
|
||
}), !jQuery.support.pixelPosition && jQuery.fn.position && jQuery.each([
|
||
"top",
|
||
"left"
|
||
], function(i, prop) {
|
||
jQuery.cssHooks[prop] = {
|
||
get: function(elem, computed) {
|
||
if (computed) return computed = curCSS(elem, prop), rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
|
||
}
|
||
};
|
||
});
|
||
}), jQuery.expr && jQuery.expr.filters && (jQuery.expr.filters.hidden = function(elem) {
|
||
return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 || !jQuery.support.reliableHiddenOffsets && "none" === (elem.style && elem.style.display || jQuery.css(elem, "display"));
|
||
}, jQuery.expr.filters.visible = function(elem) {
|
||
return !jQuery.expr.filters.hidden(elem);
|
||
}), jQuery.each({
|
||
margin: "",
|
||
padding: "",
|
||
border: "Width"
|
||
}, function(prefix, suffix) {
|
||
jQuery.cssHooks[prefix + suffix] = {
|
||
expand: function(value) {
|
||
for(var i = 0, expanded = {}, parts = "string" == typeof value ? value.split(" ") : [
|
||
value
|
||
]; i < 4; i++)expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
|
||
return expanded;
|
||
}
|
||
}, rmargin.test(prefix) || (jQuery.cssHooks[prefix + suffix].set = setPositiveNumber);
|
||
});
|
||
var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;
|
||
function buildParams(prefix, obj, traditional, add) {
|
||
var name;
|
||
if (jQuery.isArray(obj)) jQuery.each(obj, function(i, v) {
|
||
traditional || rbracket.test(prefix) ? add(prefix, v) : buildParams(prefix + "[" + ("object" == typeof v ? i : "") + "]", v, traditional, add);
|
||
});
|
||
else if (traditional || "object" !== jQuery.type(obj)) add(prefix, obj);
|
||
else for(name in obj)buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
|
||
}
|
||
jQuery.fn.extend({
|
||
serialize: function() {
|
||
return jQuery.param(this.serializeArray());
|
||
},
|
||
serializeArray: function() {
|
||
return this.map(function() {
|
||
var elements = jQuery.prop(this, "elements");
|
||
return elements ? jQuery.makeArray(elements) : this;
|
||
}).filter(function() {
|
||
var type = this.type;
|
||
return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !manipulation_rcheckableType.test(type));
|
||
}).map(function(i, elem) {
|
||
var val1 = jQuery(this).val();
|
||
return null == val1 ? null : jQuery.isArray(val1) ? jQuery.map(val1, function(val) {
|
||
return {
|
||
name: elem.name,
|
||
value: val.replace(rCRLF, "\r\n")
|
||
};
|
||
}) : {
|
||
name: elem.name,
|
||
value: val1.replace(rCRLF, "\r\n")
|
||
};
|
||
}).get();
|
||
}
|
||
}), jQuery.param = function(a, traditional) {
|
||
var prefix, s = [], add = function(key, value) {
|
||
value = jQuery.isFunction(value) ? value() : null == value ? "" : value, s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
|
||
};
|
||
if (traditional === undefined1 && (traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional), jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) jQuery.each(a, function() {
|
||
add(this.name, this.value);
|
||
});
|
||
else for(prefix in a)buildParams(prefix, a[prefix], traditional, add);
|
||
return s.join("&").replace(r20, "+");
|
||
}, 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 contextmenu".split(" "), function(i, name) {
|
||
jQuery.fn[name] = function(data, fn) {
|
||
return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
|
||
};
|
||
}), jQuery.fn.hover = function(fnOver, fnOut) {
|
||
return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
|
||
};
|
||
var ajaxLocParts, ajaxLocation, ajax_nonce = jQuery.now(), ajax_rquery = /\?/, rhash = /#.*$/, rts = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/, _load = jQuery.fn.load, prefilters = {}, transports = {}, allTypes = "*/".concat("*");
|
||
try {
|
||
ajaxLocation = location.href;
|
||
} catch (e1) {
|
||
(ajaxLocation = document1.createElement("a")).href = "", ajaxLocation = ajaxLocation.href;
|
||
}
|
||
function addToPrefiltersOrTransports(structure) {
|
||
return function(dataTypeExpression, func) {
|
||
"string" != typeof dataTypeExpression && (func = dataTypeExpression, dataTypeExpression = "*");
|
||
var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(core_rnotwhite) || [];
|
||
if (jQuery.isFunction(func)) for(; dataType = dataTypes[i++];)"+" === dataType[0] ? (structure[dataType = dataType.slice(1) || "*"] = structure[dataType] || []).unshift(func) : (structure[dataType] = structure[dataType] || []).push(func);
|
||
};
|
||
}
|
||
function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
|
||
var inspected = {}, seekingTransport = structure === transports;
|
||
function inspect(dataType) {
|
||
var selected;
|
||
return inspected[dataType] = !0, jQuery.each(structure[dataType] || [], function(_, prefilterOrFactory) {
|
||
var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
|
||
return "string" != typeof dataTypeOrTransport || seekingTransport || inspected[dataTypeOrTransport] ? seekingTransport ? !(selected = dataTypeOrTransport) : void 0 : (options.dataTypes.unshift(dataTypeOrTransport), inspect(dataTypeOrTransport), !1);
|
||
}), selected;
|
||
}
|
||
return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
|
||
}
|
||
function ajaxExtend(target, src) {
|
||
var deep, key, flatOptions = jQuery.ajaxSettings.flatOptions || {};
|
||
for(key in src)undefined1 !== src[key] && ((flatOptions[key] ? target : deep || (deep = {}))[key] = src[key]);
|
||
return deep && jQuery.extend(!0, target, deep), target;
|
||
}
|
||
ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [], jQuery.fn.load = function(url, params, callback) {
|
||
if ("string" != typeof url && _load) return _load.apply(this, arguments);
|
||
var selector, response, type, self = this, off = url.indexOf(" ");
|
||
return off >= 0 && (selector = url.slice(off, url.length), url = url.slice(0, off)), jQuery.isFunction(params) ? (callback = params, params = undefined1) : params && "object" == typeof params && (type = "POST"), self.length > 0 && jQuery.ajax({
|
||
url: url,
|
||
type: type,
|
||
dataType: "html",
|
||
data: params
|
||
}).done(function(responseText) {
|
||
response = arguments, self.html(selector ? jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
|
||
}).complete(callback && function(jqXHR, status) {
|
||
self.each(callback, response || [
|
||
jqXHR.responseText,
|
||
status,
|
||
jqXHR
|
||
]);
|
||
}), this;
|
||
}, jQuery.each([
|
||
"ajaxStart",
|
||
"ajaxStop",
|
||
"ajaxComplete",
|
||
"ajaxError",
|
||
"ajaxSuccess",
|
||
"ajaxSend"
|
||
], function(i, type) {
|
||
jQuery.fn[type] = function(fn) {
|
||
return this.on(type, fn);
|
||
};
|
||
}), jQuery.each([
|
||
"get",
|
||
"post"
|
||
], function(i, method) {
|
||
jQuery[method] = function(url, data, callback, type) {
|
||
return jQuery.isFunction(data) && (type = type || callback, callback = data, data = undefined1), jQuery.ajax({
|
||
url: url,
|
||
type: method,
|
||
dataType: type,
|
||
data: data,
|
||
success: callback
|
||
});
|
||
};
|
||
}), jQuery.extend({
|
||
active: 0,
|
||
lastModified: {},
|
||
etag: {},
|
||
ajaxSettings: {
|
||
url: ajaxLocation,
|
||
type: "GET",
|
||
isLocal: /^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(ajaxLocParts[1]),
|
||
global: !0,
|
||
processData: !0,
|
||
async: !0,
|
||
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
|
||
accepts: {
|
||
"*": allTypes,
|
||
text: "text/plain",
|
||
html: "text/html",
|
||
xml: "application/xml, text/xml",
|
||
json: "application/json, text/javascript"
|
||
},
|
||
contents: {
|
||
xml: /xml/,
|
||
html: /html/,
|
||
json: /json/
|
||
},
|
||
responseFields: {
|
||
xml: "responseXML",
|
||
text: "responseText"
|
||
},
|
||
converters: {
|
||
"* text": window1.String,
|
||
"text html": !0,
|
||
"text json": jQuery.parseJSON,
|
||
"text xml": jQuery.parseXML
|
||
},
|
||
flatOptions: {
|
||
url: !0,
|
||
context: !0
|
||
}
|
||
},
|
||
ajaxSetup: function(target, settings) {
|
||
return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
|
||
},
|
||
ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
|
||
ajaxTransport: addToPrefiltersOrTransports(transports),
|
||
ajax: function(url, options) {
|
||
"object" == typeof url && (options = url, url = undefined1), options = options || {};
|
||
var parts, i4, cacheURL, responseHeadersString, timeoutTimer, fireGlobals, transport, responseHeaders, s1 = jQuery.ajaxSetup({}, options), callbackContext = s1.context || s1, globalEventContext = s1.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event, deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks("once memory"), statusCode = s1.statusCode || {}, requestHeaders = {}, requestHeadersNames = {}, state = 0, strAbort = "canceled", jqXHR1 = {
|
||
readyState: 0,
|
||
getResponseHeader: function(key) {
|
||
var match;
|
||
if (2 === state) {
|
||
if (!responseHeaders) for(responseHeaders = {}; match = rheaders.exec(responseHeadersString);)responseHeaders[match[1].toLowerCase()] = match[2];
|
||
match = responseHeaders[key.toLowerCase()];
|
||
}
|
||
return null == match ? null : match;
|
||
},
|
||
getAllResponseHeaders: function() {
|
||
return 2 === state ? responseHeadersString : null;
|
||
},
|
||
setRequestHeader: function(name, value) {
|
||
var lname = name.toLowerCase();
|
||
return state || (requestHeaders[name = requestHeadersNames[lname] = requestHeadersNames[lname] || name] = value), this;
|
||
},
|
||
overrideMimeType: function(type) {
|
||
return state || (s1.mimeType = type), this;
|
||
},
|
||
statusCode: function(map) {
|
||
var code;
|
||
if (map) if (state < 2) for(code in map)statusCode[code] = [
|
||
statusCode[code],
|
||
map[code]
|
||
];
|
||
else jqXHR1.always(map[jqXHR1.status]);
|
||
return this;
|
||
},
|
||
abort: function(statusText) {
|
||
var finalText = statusText || strAbort;
|
||
return transport && transport.abort(finalText), done(0, finalText), this;
|
||
}
|
||
};
|
||
if (deferred.promise(jqXHR1).complete = completeDeferred.add, jqXHR1.success = jqXHR1.done, jqXHR1.error = jqXHR1.fail, s1.url = ((url || s1.url || ajaxLocation) + "").replace(rhash, "").replace(rprotocol, ajaxLocParts[1] + "//"), s1.type = options.method || options.type || s1.method || s1.type, s1.dataTypes = jQuery.trim(s1.dataType || "*").toLowerCase().match(core_rnotwhite) || [
|
||
""
|
||
], null == s1.crossDomain && (parts = rurl.exec(s1.url.toLowerCase()), s1.crossDomain = !!(parts && (parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2] || (parts[3] || ("http:" === parts[1] ? 80 : 443)) != (ajaxLocParts[3] || ("http:" === ajaxLocParts[1] ? 80 : 443))))), s1.data && s1.processData && "string" != typeof s1.data && (s1.data = jQuery.param(s1.data, s1.traditional)), inspectPrefiltersOrTransports(prefilters, s1, options, jqXHR1), 2 === state) return jqXHR1;
|
||
for(i4 in (fireGlobals = s1.global) && 0 == jQuery.active++ && jQuery.event.trigger("ajaxStart"), s1.type = s1.type.toUpperCase(), s1.hasContent = !rnoContent.test(s1.type), cacheURL = s1.url, s1.hasContent || (s1.data && (cacheURL = s1.url += (ajax_rquery.test(cacheURL) ? "&" : "?") + s1.data, delete s1.data), !1 === s1.cache && (s1.url = rts.test(cacheURL) ? cacheURL.replace(rts, "$1_=" + ajax_nonce++) : cacheURL + (ajax_rquery.test(cacheURL) ? "&" : "?") + "_=" + ajax_nonce++)), s1.ifModified && (jQuery.lastModified[cacheURL] && jqXHR1.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]), jQuery.etag[cacheURL] && jqXHR1.setRequestHeader("If-None-Match", jQuery.etag[cacheURL])), (s1.data && s1.hasContent && !1 !== s1.contentType || options.contentType) && jqXHR1.setRequestHeader("Content-Type", s1.contentType), jqXHR1.setRequestHeader("Accept", s1.dataTypes[0] && s1.accepts[s1.dataTypes[0]] ? s1.accepts[s1.dataTypes[0]] + ("*" !== s1.dataTypes[0] ? ", " + allTypes + "; q=0.01" : "") : s1.accepts["*"]), s1.headers)jqXHR1.setRequestHeader(i4, s1.headers[i4]);
|
||
if (s1.beforeSend && (!1 === s1.beforeSend.call(callbackContext, jqXHR1, s1) || 2 === state)) return jqXHR1.abort();
|
||
for(i4 in strAbort = "abort", {
|
||
success: 1,
|
||
error: 1,
|
||
complete: 1
|
||
})jqXHR1[i4](s1[i4]);
|
||
if (transport = inspectPrefiltersOrTransports(transports, s1, options, jqXHR1)) {
|
||
jqXHR1.readyState = 1, fireGlobals && globalEventContext.trigger("ajaxSend", [
|
||
jqXHR1,
|
||
s1
|
||
]), s1.async && s1.timeout > 0 && (timeoutTimer = setTimeout(function() {
|
||
jqXHR1.abort("timeout");
|
||
}, s1.timeout));
|
||
try {
|
||
state = 1, transport.send(requestHeaders, done);
|
||
} catch (e) {
|
||
if (state < 2) done(-1, e);
|
||
else throw e;
|
||
}
|
||
} else done(-1, "No Transport");
|
||
function done(status, nativeStatusText, responses1, headers) {
|
||
var isSuccess, success, error, response1, modified, statusText = nativeStatusText;
|
||
2 !== state && (state = 2, timeoutTimer && clearTimeout(timeoutTimer), transport = undefined1, responseHeadersString = headers || "", jqXHR1.readyState = status > 0 ? 4 : 0, responses1 && (response1 = (function(s, jqXHR, responses) {
|
||
var firstDataType, ct, finalDataType, type, contents = s.contents, dataTypes = s.dataTypes, responseFields = s.responseFields;
|
||
for(type in responseFields)type in responses && (jqXHR[responseFields[type]] = responses[type]);
|
||
for(; "*" === dataTypes[0];)dataTypes.shift(), ct === undefined1 && (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;
|
||
}
|
||
firstDataType || (firstDataType = type);
|
||
}
|
||
finalDataType = finalDataType || firstDataType;
|
||
}
|
||
if (finalDataType) return finalDataType !== dataTypes[0] && dataTypes.unshift(finalDataType), responses[finalDataType];
|
||
})(s1, jqXHR1, responses1)), status >= 200 && status < 300 || 304 === status ? (s1.ifModified && ((modified = jqXHR1.getResponseHeader("Last-Modified")) && (jQuery.lastModified[cacheURL] = modified), (modified = jqXHR1.getResponseHeader("etag")) && (jQuery.etag[cacheURL] = modified)), 204 === status ? (isSuccess = !0, statusText = "nocontent") : 304 === status ? (isSuccess = !0, statusText = "notmodified") : (statusText = (isSuccess = (function(s, response) {
|
||
var conv2, current, conv, tmp, converters = {}, i = 0, dataTypes = s.dataTypes.slice(), prev = dataTypes[0];
|
||
if (s.dataFilter && (response = s.dataFilter(response, s.dataType)), dataTypes[1]) for(conv in s.converters)converters[conv.toLowerCase()] = s.converters[conv];
|
||
for(; current = dataTypes[++i];)if ("*" !== current) {
|
||
if ("*" !== prev && prev !== current) {
|
||
if (!(conv = converters[prev + " " + current] || converters["* " + current])) {
|
||
for(conv2 in converters)if ((tmp = conv2.split(" "))[1] === current && (conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]])) {
|
||
!0 === conv ? conv = converters[conv2] : !0 !== converters[conv2] && (current = tmp[0], dataTypes.splice(i--, 0, current));
|
||
break;
|
||
}
|
||
}
|
||
if (!0 !== conv) if (conv && s.throws) response = conv(response);
|
||
else try {
|
||
response = conv(response);
|
||
} catch (e) {
|
||
return {
|
||
state: "parsererror",
|
||
error: conv ? e : "No conversion from " + prev + " to " + current
|
||
};
|
||
}
|
||
}
|
||
prev = current;
|
||
}
|
||
return {
|
||
state: "success",
|
||
data: response
|
||
};
|
||
})(s1, response1)).state, success = isSuccess.data, error = isSuccess.error, isSuccess = !error)) : (error = statusText, (status || !statusText) && (statusText = "error", status < 0 && (status = 0))), jqXHR1.status = status, jqXHR1.statusText = (nativeStatusText || statusText) + "", isSuccess ? deferred.resolveWith(callbackContext, [
|
||
success,
|
||
statusText,
|
||
jqXHR1
|
||
]) : deferred.rejectWith(callbackContext, [
|
||
jqXHR1,
|
||
statusText,
|
||
error
|
||
]), jqXHR1.statusCode(statusCode), statusCode = undefined1, fireGlobals && globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [
|
||
jqXHR1,
|
||
s1,
|
||
isSuccess ? success : error
|
||
]), completeDeferred.fireWith(callbackContext, [
|
||
jqXHR1,
|
||
statusText
|
||
]), !fireGlobals || (globalEventContext.trigger("ajaxComplete", [
|
||
jqXHR1,
|
||
s1
|
||
]), --jQuery.active || jQuery.event.trigger("ajaxStop")));
|
||
}
|
||
return jqXHR1;
|
||
},
|
||
getScript: function(url, callback) {
|
||
return jQuery.get(url, undefined1, callback, "script");
|
||
},
|
||
getJSON: function(url, data, callback) {
|
||
return jQuery.get(url, data, callback, "json");
|
||
}
|
||
}), jQuery.ajaxSetup({
|
||
accepts: {
|
||
script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
|
||
},
|
||
contents: {
|
||
script: /(?:java|ecma)script/
|
||
},
|
||
converters: {
|
||
"text script": function(text) {
|
||
return jQuery.globalEval(text), text;
|
||
}
|
||
}
|
||
}), jQuery.ajaxPrefilter("script", function(s) {
|
||
undefined1 === s.cache && (s.cache = !1), s.crossDomain && (s.type = "GET", s.global = !1);
|
||
}), jQuery.ajaxTransport("script", function(s) {
|
||
if (s.crossDomain) {
|
||
var script, head = document1.head || jQuery("head")[0] || document1.documentElement;
|
||
return {
|
||
send: function(_, callback) {
|
||
(script = document1.createElement("script")).async = !0, s.scriptCharset && (script.charset = s.scriptCharset), script.src = s.url, script.onload = script.onreadystatechange = function(_, isAbort) {
|
||
(isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) && (script.onload = script.onreadystatechange = null, script.parentNode && script.parentNode.removeChild(script), script = null, isAbort || callback(200, "success"));
|
||
}, head.insertBefore(script, head.firstChild);
|
||
},
|
||
abort: function() {
|
||
script && script.onload(undefined1, !0);
|
||
}
|
||
};
|
||
}
|
||
});
|
||
var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/;
|
||
jQuery.ajaxSetup({
|
||
jsonp: "callback",
|
||
jsonpCallback: function() {
|
||
var callback = oldCallbacks.pop() || jQuery.expando + "_" + ajax_nonce++;
|
||
return this[callback] = !0, callback;
|
||
}
|
||
}), jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) {
|
||
var callbackName, overwritten, responseContainer, jsonProp = !1 !== s.jsonp && (rjsonp.test(s.url) ? "url" : "string" == typeof s.data && !(s.contentType || "").indexOf("application/x-www-form-urlencoded") && rjsonp.test(s.data) && "data");
|
||
if (jsonProp || "jsonp" === s.dataTypes[0]) return callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback, jsonProp ? s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName) : !1 !== s.jsonp && (s.url += (ajax_rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName), s.converters["script json"] = function() {
|
||
return responseContainer || jQuery.error(callbackName + " was not called"), responseContainer[0];
|
||
}, s.dataTypes[0] = "json", overwritten = window1[callbackName], window1[callbackName] = function() {
|
||
responseContainer = arguments;
|
||
}, jqXHR.always(function() {
|
||
window1[callbackName] = overwritten, s[callbackName] && (s.jsonpCallback = originalSettings.jsonpCallback, oldCallbacks.push(callbackName)), responseContainer && jQuery.isFunction(overwritten) && overwritten(responseContainer[0]), responseContainer = overwritten = undefined1;
|
||
}), "script";
|
||
});
|
||
var xhrCallbacks, xhrSupported, xhrId = 0, xhrOnUnloadAbort = window1.ActiveXObject && function() {
|
||
var key;
|
||
for(key in xhrCallbacks)xhrCallbacks[key](undefined1, !0);
|
||
};
|
||
function createStandardXHR() {
|
||
try {
|
||
return new window1.XMLHttpRequest();
|
||
} catch (e) {}
|
||
}
|
||
jQuery.ajaxSettings.xhr = window1.ActiveXObject ? function() {
|
||
return !this.isLocal && createStandardXHR() || (function() {
|
||
try {
|
||
return new window1.ActiveXObject("Microsoft.XMLHTTP");
|
||
} catch (e) {}
|
||
})();
|
||
} : createStandardXHR, xhrSupported = jQuery.ajaxSettings.xhr(), jQuery.support.cors = !!xhrSupported && "withCredentials" in xhrSupported, xhrSupported = jQuery.support.ajax = !!xhrSupported, xhrSupported && jQuery.ajaxTransport(function(s) {
|
||
if (!s.crossDomain || jQuery.support.cors) {
|
||
var callback;
|
||
return {
|
||
send: function(headers, complete) {
|
||
var handle, i, xhr = s.xhr();
|
||
if (s.username ? xhr.open(s.type, s.url, s.async, s.username, s.password) : xhr.open(s.type, s.url, s.async), s.xhrFields) for(i in s.xhrFields)xhr[i] = s.xhrFields[i];
|
||
s.mimeType && xhr.overrideMimeType && xhr.overrideMimeType(s.mimeType), s.crossDomain || headers["X-Requested-With"] || (headers["X-Requested-With"] = "XMLHttpRequest");
|
||
try {
|
||
for(i in headers)xhr.setRequestHeader(i, headers[i]);
|
||
} catch (err) {}
|
||
xhr.send(s.hasContent && s.data || null), callback = function(_, isAbort) {
|
||
var status, responseHeaders, statusText, responses;
|
||
try {
|
||
if (callback && (isAbort || 4 === xhr.readyState)) if (callback = undefined1, handle && (xhr.onreadystatechange = jQuery.noop, xhrOnUnloadAbort && delete xhrCallbacks[handle]), isAbort) 4 !== xhr.readyState && xhr.abort();
|
||
else {
|
||
responses = {}, status = xhr.status, responseHeaders = xhr.getAllResponseHeaders(), "string" == typeof xhr.responseText && (responses.text = xhr.responseText);
|
||
try {
|
||
statusText = xhr.statusText;
|
||
} catch (e) {
|
||
statusText = "";
|
||
}
|
||
status || !s.isLocal || s.crossDomain ? 1223 === status && (status = 204) : status = responses.text ? 200 : 404;
|
||
}
|
||
} catch (firefoxAccessException) {
|
||
isAbort || complete(-1, firefoxAccessException);
|
||
}
|
||
responses && complete(status, statusText, responses, responseHeaders);
|
||
}, s.async ? 4 === xhr.readyState ? setTimeout(callback) : (handle = ++xhrId, xhrOnUnloadAbort && (xhrCallbacks || (xhrCallbacks = {}, jQuery(window1).unload(xhrOnUnloadAbort)), xhrCallbacks[handle] = callback), xhr.onreadystatechange = callback) : callback();
|
||
},
|
||
abort: function() {
|
||
callback && callback(undefined1, !0);
|
||
}
|
||
};
|
||
}
|
||
});
|
||
var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rfxnum = new RegExp("^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i"), rrun = /queueHooks$/, animationPrefilters = [
|
||
function(elem, props, opts) {
|
||
var prop1, index, length, value, dataShow, toggle, tween, hooks, oldfire, anim = this, style = elem.style, orig = {}, handled = [], hidden = elem.nodeType && isHidden(elem);
|
||
for(index in opts.queue || (null == (hooks = jQuery._queueHooks(elem, "fx")).unqueued && (hooks.unqueued = 0, oldfire = hooks.empty.fire, hooks.empty.fire = function() {
|
||
hooks.unqueued || oldfire();
|
||
}), hooks.unqueued++, anim.always(function() {
|
||
anim.always(function() {
|
||
hooks.unqueued--, jQuery.queue(elem, "fx").length || hooks.empty.fire();
|
||
});
|
||
})), 1 === elem.nodeType && ("height" in props || "width" in props) && (opts.overflow = [
|
||
style.overflow,
|
||
style.overflowX,
|
||
style.overflowY
|
||
], "inline" === jQuery.css(elem, "display") && "none" === jQuery.css(elem, "float") && (jQuery.support.inlineBlockNeedsLayout && "inline" !== css_defaultDisplay(elem.nodeName) ? style.zoom = 1 : style.display = "inline-block")), opts.overflow && (style.overflow = "hidden", jQuery.support.shrinkWrapBlocks || anim.always(function() {
|
||
style.overflow = opts.overflow[0], style.overflowX = opts.overflow[1], style.overflowY = opts.overflow[2];
|
||
})), props)if (value = props[index], rfxtypes.exec(value)) {
|
||
if (delete props[index], toggle = toggle || "toggle" === value, value === (hidden ? "hide" : "show")) continue;
|
||
handled.push(index);
|
||
}
|
||
if (length = handled.length) for(("hidden" in (dataShow = jQuery._data(elem, "fxshow") || jQuery._data(elem, "fxshow", {}))) && (hidden = dataShow.hidden), toggle && (dataShow.hidden = !hidden), hidden ? jQuery(elem).show() : anim.done(function() {
|
||
jQuery(elem).hide();
|
||
}), anim.done(function() {
|
||
var prop;
|
||
for(prop in jQuery._removeData(elem, "fxshow"), orig)jQuery.style(elem, prop, orig[prop]);
|
||
}), index = 0; index < length; index++)prop1 = handled[index], tween = anim.createTween(prop1, hidden ? dataShow[prop1] : 0), orig[prop1] = dataShow[prop1] || jQuery.style(elem, prop1), prop1 in dataShow || (dataShow[prop1] = tween.start, hidden && (tween.end = tween.start, tween.start = "width" === prop1 || "height" === prop1 ? 1 : 0));
|
||
}
|
||
], tweeners = {
|
||
"*": [
|
||
function(prop, value) {
|
||
var end, unit, tween = this.createTween(prop, value), parts = rfxnum.exec(value), target = tween.cur(), start = +target || 0, scale = 1, maxIterations = 20;
|
||
if (parts) {
|
||
if (end = +parts[2], unit = parts[3] || (jQuery.cssNumber[prop] ? "" : "px"), "px" !== unit && start) {
|
||
start = jQuery.css(tween.elem, prop, !0) || end || 1;
|
||
do start /= scale = scale || ".5", jQuery.style(tween.elem, prop, start + unit);
|
||
while (scale !== (scale = tween.cur() / target) && 1 !== scale && --maxIterations)
|
||
}
|
||
tween.unit = unit, tween.start = start, tween.end = parts[1] ? start + (parts[1] + 1) * end : end;
|
||
}
|
||
return tween;
|
||
}
|
||
]
|
||
};
|
||
function createFxNow() {
|
||
return setTimeout(function() {
|
||
fxNow = undefined1;
|
||
}), fxNow = jQuery.now();
|
||
}
|
||
function Animation(elem, properties, options) {
|
||
var animation, props, result, stopped, index1 = 0, length1 = animationPrefilters.length, deferred = jQuery.Deferred().always(function() {
|
||
delete tick.elem;
|
||
}), tick = function() {
|
||
if (stopped) return !1;
|
||
for(var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation1.startTime + animation1.duration - currentTime), percent = 1 - (remaining / animation1.duration || 0), index = 0, length = animation1.tweens.length; index < length; index++)animation1.tweens[index].run(percent);
|
||
return (deferred.notifyWith(elem, [
|
||
animation1,
|
||
percent,
|
||
remaining
|
||
]), percent < 1 && length) ? remaining : (deferred.resolveWith(elem, [
|
||
animation1
|
||
]), !1);
|
||
}, animation1 = deferred.promise({
|
||
elem: elem,
|
||
props: jQuery.extend({}, properties),
|
||
opts: jQuery.extend(!0, {
|
||
specialEasing: {}
|
||
}, options),
|
||
originalProperties: properties,
|
||
originalOptions: options,
|
||
startTime: fxNow || createFxNow(),
|
||
duration: options.duration,
|
||
tweens: [],
|
||
createTween: function(prop, end) {
|
||
var tween = jQuery.Tween(elem, animation1.opts, prop, end, animation1.opts.specialEasing[prop] || animation1.opts.easing);
|
||
return animation1.tweens.push(tween), tween;
|
||
},
|
||
stop: function(gotoEnd) {
|
||
var index = 0, length = gotoEnd ? animation1.tweens.length : 0;
|
||
if (stopped) return this;
|
||
for(stopped = !0; index < length; index++)animation1.tweens[index].run(1);
|
||
return gotoEnd ? deferred.resolveWith(elem, [
|
||
animation1,
|
||
gotoEnd
|
||
]) : deferred.rejectWith(elem, [
|
||
animation1,
|
||
gotoEnd
|
||
]), this;
|
||
}
|
||
}), props1 = animation1.props;
|
||
for(propFilter(props1, animation1.opts.specialEasing); index1 < length1; index1++)if (result = animationPrefilters[index1].call(animation1, elem, props1, animation1.opts)) return result;
|
||
return animation = animation1, props = props1, jQuery.each(props, function(prop, value) {
|
||
for(var collection = (tweeners[prop] || []).concat(tweeners["*"]), index = 0, length = collection.length; index < length; index++)if (collection[index].call(animation, prop, value)) return;
|
||
}), jQuery.isFunction(animation1.opts.start) && animation1.opts.start.call(elem, animation1), jQuery.fx.timer(jQuery.extend(tick, {
|
||
elem: elem,
|
||
anim: animation1,
|
||
queue: animation1.opts.queue
|
||
})), animation1.progress(animation1.opts.progress).done(animation1.opts.done, animation1.opts.complete).fail(animation1.opts.fail).always(animation1.opts.always);
|
||
}
|
||
function propFilter(props, specialEasing) {
|
||
var value, name, index, easing, hooks;
|
||
for(index in props)if (easing = specialEasing[name = jQuery.camelCase(index)], value = props[index], jQuery.isArray(value) && (easing = value[1], value = props[index] = value[0]), index !== name && (props[name] = value, delete props[index]), hooks = jQuery.cssHooks[name], hooks && "expand" in hooks) for(index in value = hooks.expand(value), delete props[name], value)index in props || (props[index] = value[index], specialEasing[index] = easing);
|
||
else specialEasing[name] = easing;
|
||
}
|
||
function Tween(elem, options, prop, end, easing) {
|
||
return new Tween.prototype.init(elem, options, prop, end, easing);
|
||
}
|
||
function genFx(type, includeWidth) {
|
||
var which, attrs = {
|
||
height: type
|
||
}, i = 0;
|
||
for(includeWidth = includeWidth ? 1 : 0; i < 4; i += 2 - includeWidth)attrs["margin" + (which = cssExpand[i])] = attrs["padding" + which] = type;
|
||
return includeWidth && (attrs.opacity = attrs.width = type), attrs;
|
||
}
|
||
function getWindow(elem) {
|
||
return jQuery.isWindow(elem) ? elem : 9 === elem.nodeType && (elem.defaultView || elem.parentWindow);
|
||
}
|
||
jQuery.Animation = jQuery.extend(Animation, {
|
||
tweener: function(props, callback) {
|
||
jQuery.isFunction(props) ? (callback = props, props = [
|
||
"*"
|
||
]) : props = props.split(" ");
|
||
for(var prop, index = 0, length = props.length; index < length; index++)tweeners[prop = props[index]] = tweeners[prop] || [], tweeners[prop].unshift(callback);
|
||
},
|
||
prefilter: function(callback, prepend) {
|
||
prepend ? animationPrefilters.unshift(callback) : animationPrefilters.push(callback);
|
||
}
|
||
}), jQuery.Tween = Tween, Tween.prototype = {
|
||
constructor: Tween,
|
||
init: function(elem, options, prop, end, easing, unit) {
|
||
this.elem = elem, this.prop = prop, this.easing = easing || "swing", this.options = options, this.start = this.now = this.cur(), this.end = end, this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
|
||
},
|
||
cur: function() {
|
||
var hooks = Tween.propHooks[this.prop];
|
||
return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
|
||
},
|
||
run: function(percent) {
|
||
var eased, hooks = Tween.propHooks[this.prop];
|
||
return this.options.duration ? this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration) : this.pos = eased = percent, this.now = (this.end - this.start) * eased + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), hooks && hooks.set ? hooks.set(this) : Tween.propHooks._default.set(this), this;
|
||
}
|
||
}, Tween.prototype.init.prototype = Tween.prototype, Tween.propHooks = {
|
||
_default: {
|
||
get: function(tween) {
|
||
var result;
|
||
return null == tween.elem[tween.prop] || tween.elem.style && null != tween.elem.style[tween.prop] ? (result = jQuery.css(tween.elem, tween.prop, "")) && "auto" !== result ? result : 0 : tween.elem[tween.prop];
|
||
},
|
||
set: function(tween) {
|
||
jQuery.fx.step[tween.prop] ? jQuery.fx.step[tween.prop](tween) : tween.elem.style && (null != tween.elem.style[jQuery.cssProps[tween.prop]] || jQuery.cssHooks[tween.prop]) ? jQuery.style(tween.elem, tween.prop, tween.now + tween.unit) : tween.elem[tween.prop] = tween.now;
|
||
}
|
||
}
|
||
}, Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
|
||
set: function(tween) {
|
||
tween.elem.nodeType && tween.elem.parentNode && (tween.elem[tween.prop] = tween.now);
|
||
}
|
||
}, jQuery.each([
|
||
"toggle",
|
||
"show",
|
||
"hide"
|
||
], function(i, name) {
|
||
var cssFn = jQuery.fn[name];
|
||
jQuery.fn[name] = function(speed, easing, callback) {
|
||
return null == speed || "boolean" == typeof speed ? cssFn.apply(this, arguments) : this.animate(genFx(name, !0), speed, easing, callback);
|
||
};
|
||
}), jQuery.fn.extend({
|
||
fadeTo: function(speed, to, easing, callback) {
|
||
return this.filter(isHidden).css("opacity", 0).show().end().animate({
|
||
opacity: to
|
||
}, speed, easing, callback);
|
||
},
|
||
animate: function(prop, speed, easing, callback) {
|
||
var empty = jQuery.isEmptyObject(prop), optall = jQuery.speed(speed, easing, callback), doAnimation = function() {
|
||
var anim = Animation(this, jQuery.extend({}, prop), optall);
|
||
doAnimation.finish = function() {
|
||
anim.stop(!0);
|
||
}, (empty || jQuery._data(this, "finish")) && anim.stop(!0);
|
||
};
|
||
return doAnimation.finish = doAnimation, empty || !1 === optall.queue ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
|
||
},
|
||
stop: function(type, clearQueue, gotoEnd) {
|
||
var stopQueue = function(hooks) {
|
||
var stop = hooks.stop;
|
||
delete hooks.stop, stop(gotoEnd);
|
||
};
|
||
return "string" != typeof type && (gotoEnd = clearQueue, clearQueue = type, type = undefined1), clearQueue && !1 !== type && this.queue(type || "fx", []), this.each(function() {
|
||
var dequeue = !0, index = null != type && type + "queueHooks", timers = jQuery.timers, data = jQuery._data(this);
|
||
if (index) data[index] && data[index].stop && stopQueue(data[index]);
|
||
else for(index in data)data[index] && data[index].stop && rrun.test(index) && stopQueue(data[index]);
|
||
for(index = timers.length; index--;)timers[index].elem === this && (null == type || timers[index].queue === type) && (timers[index].anim.stop(gotoEnd), dequeue = !1, timers.splice(index, 1));
|
||
(dequeue || !gotoEnd) && jQuery.dequeue(this, type);
|
||
});
|
||
},
|
||
finish: function(type) {
|
||
return !1 !== type && (type = type || "fx"), this.each(function() {
|
||
var index, data = jQuery._data(this), queue = data[type + "queue"], hooks = data[type + "queueHooks"], timers = jQuery.timers, length = queue ? queue.length : 0;
|
||
for(data.finish = !0, jQuery.queue(this, type, []), hooks && hooks.cur && hooks.cur.finish && hooks.cur.finish.call(this), index = timers.length; index--;)timers[index].elem === this && timers[index].queue === type && (timers[index].anim.stop(!0), timers.splice(index, 1));
|
||
for(index = 0; index < length; index++)queue[index] && queue[index].finish && queue[index].finish.call(this);
|
||
delete data.finish;
|
||
});
|
||
}
|
||
}), jQuery.each({
|
||
slideDown: genFx("show"),
|
||
slideUp: genFx("hide"),
|
||
slideToggle: genFx("toggle"),
|
||
fadeIn: {
|
||
opacity: "show"
|
||
},
|
||
fadeOut: {
|
||
opacity: "hide"
|
||
},
|
||
fadeToggle: {
|
||
opacity: "toggle"
|
||
}
|
||
}, function(name, props) {
|
||
jQuery.fn[name] = function(speed, easing, callback) {
|
||
return this.animate(props, speed, easing, callback);
|
||
};
|
||
}), jQuery.speed = function(speed, easing, fn) {
|
||
var opt = speed && "object" == typeof speed ? jQuery.extend({}, speed) : {
|
||
complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
|
||
duration: speed,
|
||
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
|
||
};
|
||
return opt.duration = jQuery.fx.off ? 0 : "number" == typeof opt.duration ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default, (null == opt.queue || !0 === opt.queue) && (opt.queue = "fx"), opt.old = opt.complete, opt.complete = function() {
|
||
jQuery.isFunction(opt.old) && opt.old.call(this), opt.queue && jQuery.dequeue(this, opt.queue);
|
||
}, opt;
|
||
}, jQuery.easing = {
|
||
linear: function(p) {
|
||
return p;
|
||
},
|
||
swing: function(p) {
|
||
return 0.5 - Math.cos(p * Math.PI) / 2;
|
||
}
|
||
}, jQuery.timers = [], jQuery.fx = Tween.prototype.init, jQuery.fx.tick = function() {
|
||
var timer, timers = jQuery.timers, i = 0;
|
||
for(fxNow = jQuery.now(); i < timers.length; i++)(timer = timers[i])() || timers[i] !== timer || timers.splice(i--, 1);
|
||
timers.length || jQuery.fx.stop(), fxNow = undefined1;
|
||
}, jQuery.fx.timer = function(timer) {
|
||
timer() && jQuery.timers.push(timer) && jQuery.fx.start();
|
||
}, jQuery.fx.interval = 13, jQuery.fx.start = function() {
|
||
timerId || (timerId = setInterval(jQuery.fx.tick, jQuery.fx.interval));
|
||
}, jQuery.fx.stop = function() {
|
||
clearInterval(timerId), timerId = null;
|
||
}, jQuery.fx.speeds = {
|
||
slow: 600,
|
||
fast: 200,
|
||
_default: 400
|
||
}, jQuery.fx.step = {}, jQuery.expr && jQuery.expr.filters && (jQuery.expr.filters.animated = function(elem) {
|
||
return jQuery.grep(jQuery.timers, function(fn) {
|
||
return elem === fn.elem;
|
||
}).length;
|
||
}), jQuery.fn.offset = function(options) {
|
||
if (arguments.length) return options === undefined1 ? this : this.each(function(i) {
|
||
jQuery.offset.setOffset(this, options, i);
|
||
});
|
||
var docElem, win, box = {
|
||
top: 0,
|
||
left: 0
|
||
}, elem = this[0], doc = elem && elem.ownerDocument;
|
||
return doc ? (docElem = doc.documentElement, jQuery.contains(docElem, elem)) ? (typeof elem.getBoundingClientRect !== core_strundefined && (box = elem.getBoundingClientRect()), win = getWindow(doc), {
|
||
top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
|
||
left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)
|
||
}) : box : void 0;
|
||
}, jQuery.offset = {
|
||
setOffset: function(elem, options, i) {
|
||
var position = jQuery.css(elem, "position");
|
||
"static" === position && (elem.style.position = "relative");
|
||
var curTop, curLeft, curElem = jQuery(elem), curOffset = curElem.offset(), curCSSTop = jQuery.css(elem, "top"), curCSSLeft = jQuery.css(elem, "left"), calculatePosition = ("absolute" === position || "fixed" === position) && jQuery.inArray("auto", [
|
||
curCSSTop,
|
||
curCSSLeft
|
||
]) > -1, props = {}, curPosition = {};
|
||
calculatePosition ? (curTop = (curPosition = curElem.position()).top, curLeft = curPosition.left) : (curTop = parseFloat(curCSSTop) || 0, curLeft = parseFloat(curCSSLeft) || 0), jQuery.isFunction(options) && (options = options.call(elem, i, curOffset)), null != options.top && (props.top = options.top - curOffset.top + curTop), null != options.left && (props.left = options.left - curOffset.left + curLeft), "using" in options ? options.using.call(elem, props) : curElem.css(props);
|
||
}
|
||
}, jQuery.fn.extend({
|
||
position: function() {
|
||
if (this[0]) {
|
||
var offsetParent, offset, parentOffset = {
|
||
top: 0,
|
||
left: 0
|
||
}, elem = this[0];
|
||
return "fixed" === jQuery.css(elem, "position") ? offset = elem.getBoundingClientRect() : (offsetParent = this.offsetParent(), offset = this.offset(), jQuery.nodeName(offsetParent[0], "html") || (parentOffset = offsetParent.offset()), parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", !0), parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", !0)), {
|
||
top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", !0),
|
||
left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", !0)
|
||
};
|
||
}
|
||
},
|
||
offsetParent: function() {
|
||
return this.map(function() {
|
||
for(var offsetParent = this.offsetParent || document1.documentElement; offsetParent && !jQuery.nodeName(offsetParent, "html") && "static" === jQuery.css(offsetParent, "position");)offsetParent = offsetParent.offsetParent;
|
||
return offsetParent || document1.documentElement;
|
||
});
|
||
}
|
||
}), jQuery.each({
|
||
scrollLeft: "pageXOffset",
|
||
scrollTop: "pageYOffset"
|
||
}, function(method1, prop) {
|
||
var top = /Y/.test(prop);
|
||
jQuery.fn[method1] = function(val2) {
|
||
return jQuery.access(this, function(elem, method, val) {
|
||
var win = getWindow(elem);
|
||
if (val === undefined1) return win ? prop in win ? win[prop] : win.document.documentElement[method] : elem[method];
|
||
win ? win.scrollTo(top ? jQuery(win).scrollLeft() : val, top ? val : jQuery(win).scrollTop()) : elem[method] = val;
|
||
}, method1, val2, arguments.length, null);
|
||
};
|
||
}), jQuery.each({
|
||
Height: "height",
|
||
Width: "width"
|
||
}, function(name, type1) {
|
||
jQuery.each({
|
||
padding: "inner" + name,
|
||
content: type1,
|
||
"": "outer" + name
|
||
}, function(defaultExtra, funcName) {
|
||
jQuery.fn[funcName] = function(margin, value7) {
|
||
var chainable = arguments.length && (defaultExtra || "boolean" != typeof margin), extra = defaultExtra || (!0 === margin || !0 === value7 ? "margin" : "border");
|
||
return jQuery.access(this, function(elem, type, value) {
|
||
var doc;
|
||
return jQuery.isWindow(elem) ? elem.document.documentElement["client" + name] : 9 === elem.nodeType ? (doc = elem.documentElement, Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name])) : value === undefined1 ? jQuery.css(elem, type, extra) : jQuery.style(elem, type, value, extra);
|
||
}, type1, chainable ? margin : undefined1, chainable, null);
|
||
};
|
||
});
|
||
}), window1.jQuery = window1.$ = jQuery, "function" == typeof define && define.amd && define.amd.jQuery && define("jquery", [], function() {
|
||
return jQuery;
|
||
});
|
||
}(window);
|