swc-project/swc
1
1
Fork 0
mirror of https://github.com/swc-project/swc.git synced 2024-12-21 04:32:01 +03:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
c9def54913
swc/crates/swc_ecma_minifier/tests/projects/refs/jquery-1.9.1.js
Donny/강동윤 2b2f6955f2
refactor: Flatten ecmascript (#2708)
2021-11-10 19:00:54 +09:00

11957 lines
387 KiB
JavaScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*!
* jQuery JavaScript Library v1.9.1
* http://jquery.com/
*
* Includes Sizzle.js
* http://sizzlejs.com/
*
* Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
* Released under the MIT license
* http://jquery.org/license
*
* Date: 2013-2-4
*/
!(function (
window, undefined
) {
var readyList,
rootjQuery,
document = window.document,
location = window.location,
_jQuery = window.jQuery,
_$ = window.$,
class2type = {
},
core_deletedIds = [],
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 = "1.9.1".trim,
jQuery = function (
selector, context
) {
return new jQuery.fn.init(
selector,
context,
rootjQuery
);
},
core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
core_rnotwhite = /\S+/g,
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
rquickExpr = /^(?:(<[\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
) {
(document.addEventListener ||
"load" === event.type ||
"complete" === document.readyState) &&
(detach(
), jQuery.ready(
));
},
detach = function (
) {
document.addEventListener
? (document.removeEventListener(
"DOMContentLoaded",
completed,
!1
),
window.removeEventListener(
"load",
completed,
!1
))
: (document.detachEvent(
"onreadystatechange",
completed
),
window.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: "1.9.1",
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,]
: rquickExpr.exec(
selector
)) ||
(!match[1] && context)
)
return !context || context.jquery
? (context || rootjQuery).find(
selector
)
: this.constructor(
context
).find(
selector
);
if (match[1]) {
if (
((context = context instanceof jQuery ? context[0] : context),
jQuery.merge(
this,
jQuery.parseHTML(
match[1],
context && context.nodeType
? context.ownerDocument || context
: document,
!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 = document.getElementById(
match[2]
)) && elem.parentNode) {
if (elem.id !== match[2]) return rootjQuery.find(
selector
);
(this.length = 1), (this[0] = elem);
}
return (this.context = document), (this.selector = selector), this;
}
return selector.nodeType
? ((this.context = this[0] = selector), (this.length = 1), this)
: jQuery.isFunction(
selector
)
? rootjQuery.ready(
selector
)
: (undefined !== 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]),
target !== (copy = options[name]) &&
(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
)))
: undefined !== copy && (target[name] = copy));
return target;
}),
jQuery.extend(
{
noConflict: function (
deep
) {
return (
window.$ === jQuery && (window.$ = _$),
deep && window.jQuery === jQuery && (window.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 (!document.body) return setTimeout(
jQuery.ready
);
(jQuery.isReady = !0),
(!0 !== wait && --jQuery.readyWait > 0) ||
(readyList.resolveWith(
document,
[jQuery,]
),
jQuery.fn.trigger &&
jQuery(
document
).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
) {
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;
}
var key;
for (key in obj);
return undefined === key || 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 || document);
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 window.JSON && window.JSON.parse
? window.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 {
window.DOMParser
? (xml = new DOMParser(
).parseFromString(
data,
"text/xml"
))
: (((xml = new ActiveXObject(
"Microsoft.XMLDOM"
)).async = "false"),
xml.loadXML(
data
));
} catch (e) {
xml = undefined;
}
return (
(xml &&
xml.documentElement &&
!xml.getElementsByTagName(
"parsererror"
).length) ||
jQuery.error(
"Invalid XML: " + data
),
xml
);
},
noop: function (
) {},
globalEval: function (
data
) {
data &&
jQuery.trim(
data
) &&
(
window.execScript ||
function (
data
) {
window.eval.call(
window,
data
);
}
)(
data
);
},
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(
"\ufeff "
)
? function (
text
) {
return null == text
? ""
: core_trim.call(
text
);
}
: function (
text
) {
return null == text
? ""
: (text + "").replace(
rtrim,
""
);
},
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 (; undefined !== 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++)
inv !== !!callback(
elems[i],
i
) && ret.push(
elems[i]
);
return ret;
},
map: function (
elems, callback, arg
) {
var value,
i = 0,
length = elems.length,
ret = [];
if (isArraylike(
elems
))
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, value, 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 (
undefined !== value &&
((chainable = !0),
jQuery.isFunction(
value
) || (raw = !0),
bulk &&
(raw
? (fn.call(
elems,
value
), (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
? value
: value.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" === document.readyState)
)
setTimeout(
jQuery.ready
);
else if (document.addEventListener)
document.addEventListener(
"DOMContentLoaded",
completed,
!1
),
window.addEventListener(
"load",
completed,
!1
);
else {
document.attachEvent(
"onreadystatechange",
completed
),
window.attachEvent(
"onload",
completed
);
var top = !1;
try {
top = null == window.frameElement && document.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(
);
},
),
(rootjQuery = jQuery(
document
));
var optionsCache = {
};
(jQuery.Callbacks = function (
options
) {
options =
"string" == typeof options
? optionsCache[options] ||
(function (
options
) {
var object = (optionsCache[options] = {
});
return (
jQuery.each(
options.match(
core_rnotwhite
) || [],
function (
_, flag
) {
object[flag] = !0;
},
),
object
);
})(
options
)
: 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 = undefined), this;
},
disabled: function (
) {
return !list;
},
lock: function (
) {
return (stack = undefined), 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,
i = 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
);
i < length;
i++
)
resolveValues[i] && jQuery.isFunction(
resolveValues[i].promise
)
? resolveValues[i]
.promise(
)
.done(
updateFunc(
i,
resolveContexts,
resolveValues
)
)
.fail(
deferred.reject
)
.progress(
updateFunc(
i,
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 = document.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 = document.createElement(
"select"
)).appendChild(
document.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: !!document.createElement(
"form"
).enctype,
html5Clone:
"<:nav></:nav>" !==
document.createElement(
"nav"
).cloneNode(
!0
).outerHTML,
boxModel: "CSS1Compat" === document.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 = document.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 = document.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 window || !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 = document.getElementsByTagName(
"body"
)[0];
body &&
(((container = document.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),
window.getComputedStyle &&
((support.pixelPosition =
"1%" !== (window.getComputedStyle(
div,
null
) || {
}).top),
(support.boxSizingReliable =
"4px" ===
(window.getComputedStyle(
div,
null
) || {
width: "4px",
}).width),
((marginDiv = div.appendChild(
document.createElement(
"div"
),
)).style.cssText = div.style.cssText = divReset),
(marginDiv.style.marginRight = marginDiv.style.width = "0"),
(div.style.width = "1px"),
(support.reliableMarginRight = !parseFloat(
(window.getComputedStyle(
marginDiv,
null
) || {
}).marginRight,
))),
void 0 !== div.style.zoom &&
((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 ||
undefined !== data
)
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)),
undefined !== data && (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 = 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 (undefined === data && 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 = undefined;
}
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" + ("1.9.1" + 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, value
) {
var attrs,
name,
elem = this[0],
i = 0,
data = null;
if (undefined === key) {
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-"
) ||
((name = jQuery.camelCase(
name.slice(
5
)
)),
dataAttr(
elem,
name,
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 (undefined === value)
return elem
? dataAttr(
elem,
key,
jQuery.data(
elem,
key
)
)
: null;
this.each(
function (
) {
jQuery.data(
this,
key,
value
);
}
);
},
null,
value,
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
)
: undefined === data
? 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),
(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 = undefined)),
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] = undefined), delete this[name];
} catch (e) {}
}
)
);
},
addClass: function (
value
) {
var classes,
elem,
cur,
clazz,
j,
i = 0,
len = this.length,
proceed = "string" == typeof value && value;
if (jQuery.isFunction(
value
))
return this.each(
function (
j
) {
jQuery(
this
).addClass(
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 (j = 0; (clazz = classes[j++]); )
cur.indexOf(
" " + clazz + " "
) < 0 && (cur += clazz + " ");
elem.className = jQuery.trim(
cur
);
}
return this;
},
removeClass: function (
value
) {
var classes,
elem,
cur,
clazz,
j,
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 (j = 0; (clazz = classes[j++]); )
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
("undefined" !== type && "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 (
value
) {
var ret,
hooks,
isFunction,
elem = this[0];
return arguments.length
? ((isFunction = jQuery.isFunction(
value
)),
this.each(
function (
i
) {
var val,
self = jQuery(
this
);
1 === this.nodeType &&
(null ==
(val = isFunction
? value.call(
this,
i,
self.val(
)
)
: value)
? (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 &&
undefined !== hooks.set(
this,
val,
"value"
)) ||
(this.value = val));
}
))
: elem
? (hooks =
jQuery.valHooks[elem.type] ||
jQuery.valHooks[elem.nodeName.toLowerCase(
)]) &&
"get" in hooks &&
undefined !== (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)
return void 0 === elem.getAttribute
? jQuery.prop(
elem,
name,
value
)
: ((notxml = 1 !== nType || !jQuery.isXMLDoc(
elem
)) &&
((name = name.toLowerCase(
)),
(hooks =
jQuery.attrHooks[name] ||
(rboolean.test(
name
)
? boolHook
: nodeHook))),
undefined === value
? hooks &&
notxml &&
"get" in hooks &&
null !== (ret = hooks.get(
elem,
name
))
? ret
: (void 0 !== elem.getAttribute &&
(ret = elem.getAttribute(
name
)),
null == ret ? undefined : ret)
: null !== value
? hooks &&
notxml &&
"set" in hooks &&
undefined !== (ret = hooks.set(
elem,
value,
name
))
? ret
: (elem.setAttribute(
name,
value + ""
), value)
: void jQuery.removeAttr(
elem,
name
));
},
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;
if (elem && 3 !== nType && 8 !== nType && 2 !== nType)
return (
(1 !== nType || !jQuery.isXMLDoc(
elem
)) &&
((name = jQuery.propFix[name] || name),
(hooks = jQuery.propHooks[name])),
undefined !== value
? hooks &&
"set" in hooks &&
undefined !== (ret = hooks.set(
elem,
value,
name
))
? ret
: (elem[name] = value)
: hooks &&
"get" in hooks &&
null !== (ret = hooks.get(
elem,
name
))
? ret
: elem[name]
);
},
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
: undefined;
},
},
},
}
),
(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(
)
: undefined;
},
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
: undefined;
},
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
: undefined;
},
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
: undefined
);
},
}),
(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 ? undefined : 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 || undefined;
},
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 void 0 === jQuery ||
(e && jQuery.event.triggered === e.type)
? undefined
: 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 (
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]);
} else
for (type in events)
jQuery.event.remove(
elem,
type + types[t],
handler,
selector,
!0
);
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 || document,],
type = core_hasOwn.call(
event,
"type"
)
? event.type
: event,
namespaces = core_hasOwn.call(
event,
"namespace"
)
? event.namespace.split(
"."
)
: [];
if (
((cur = tmp = elem = elem || document),
3 !== elem.nodeType &&
8 !== elem.nodeType &&
!rfocusMorph.test(
type + jQuery.event.triggered
) &&
(type.indexOf(
"."
) >= 0 &&
((namespaces = type.split(
"."
)),
(type = namespaces.shift(
)),
namespaces.sort(
)),
(ontype = type.indexOf(
":"
) < 0 && "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 = undefined),
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 || document) &&
eventPath.push(
tmp.defaultView || tmp.parentWindow || window
);
}
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 = undefined), 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),
undefined !==
(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 (matches = [], i = 0; i < delegateCount; i++)
undefined ===
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 || document),
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 || document)
.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 ||
undefined === button ||
(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 !== document.activeElement && this.focus)
try {
return this.focus(
), !1;
} catch (e) {}
},
delegateType: "focusin",
},
blur: {
trigger: function (
) {
if (this === document.activeElement && this.blur)
return this.blur(
), !1;
},
delegateType: "focusout",
},
beforeunload: {
postDispatch: function (
event
) {
undefined !== 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 = document.removeEventListener
? function (
elem, type, handle
) {
elem.removeEventListener &&
elem.removeEventListener(
type,
handle,
!1
);
}
: function (
elem, type, handle
) {
var name = "on" + type;
elem.detachEvent &&
(void 0 === elem[name] && (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,
target = this,
related = event.relatedTarget,
handleObj = event.handleObj;
return (
(related &&
(related === target || jQuery.contains(
target,
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
: undefined;
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++ && document.addEventListener(
orig,
handler,
!0
);
},
teardown: function (
) {
0 == --attaches && document.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 = undefined)),
types))
this.on(
type,
selector,
data,
types[type],
one
);
return this;
}
if (
(null == data && null == fn
? ((fn = selector), (data = selector = undefined))
: null == fn &&
("string" == typeof selector
? ((fn = data), (data = undefined))
: ((fn = data), (data = selector), (selector = undefined))),
!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 = undefined)),
!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
);
},
}
),
/*!
* Sizzle CSS Selector Engine
* Copyright 2012 jQuery Foundation and other contributors
* Released under the MIT license
* http://sizzlejs.com/
*/
(function (
window, undefined
) {
var i,
cachedruns,
Expr,
getText,
isXML,
compile,
hasDuplicate,
outermostContext,
setDocument,
document,
docElem,
documentIsXML,
rbuggyQSA,
rbuggyMatches,
matches,
contains,
sortOrder,
expando = "sizzle" + -new Date(
),
preferredDoc = window.document,
support = {
},
dirruns = 0,
done = 0,
classCache = createCache(
),
tokenCache = createCache(
),
compilerCache = createCache(
),
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 =
"\\[[\\x20\\t\\r\\n\\f]*(" +
characterEncoding +
")" +
whitespace +
"*(?:([*^$|!~]?=)" +
whitespace +
"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" +
identifier +
")|)|)" +
whitespace +
"*\\]",
pseudos =
":(" +
characterEncoding +
")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" +
attributes.replace(
3,
8
) +
")*)|.*)\\)|)",
rtrim = new RegExp(
"^[\\x20\\t\\r\\n\\f]+|((?:^|[^\\\\])(?:\\\\.)*)[\\x20\\t\\r\\n\\f]+$",
"g",
),
rcomma = new RegExp(
"^[\\x20\\t\\r\\n\\f]*,[\\x20\\t\\r\\n\\f]*"
),
rcombinators = new RegExp(
"^[\\x20\\t\\r\\n\\f]*([\\x20\\t\\r\\n\\f>+~])[\\x20\\t\\r\\n\\f]*",
),
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)(?:\\([\\x20\\t\\r\\n\\f]*(even|odd|(([+-]|)(\\d*)n|)[\\x20\\t\\r\\n\\f]*(?:([+-]|)[\\x20\\t\\r\\n\\f]*(\\d+)|))[\\x20\\t\\r\\n\\f]*\\)|)",
"i",
),
needsContext: new RegExp(
"^[\\x20\\t\\r\\n\\f]*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\([\\x20\\t\\r\\n\\f]*((?:-\\d)?\\d*)[\\x20\\t\\r\\n\\f]*\\)|)(?=[^-]|$)",
"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
),
(results = results || []),
!selector || "string" != typeof selector)
)
return results;
if (
1 !== (nodeType = (context = context || document).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
);
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 (function (
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-- && ((token = tokens[i]), !Expr.relative[(type = token.type)]);
)
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
);
})(
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 (i in ((isXML = Sizzle.isXML = function (
elem
) {
var documentElement =
elem && (elem.ownerDocument || elem).documentElement;
return !!documentElement && "HTML" !== documentElement.nodeName;
}),
(setDocument = Sizzle.setDocument = function (
node
) {
var doc = node ? node.ownerDocument || node : 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 &&
void 0 !== div.firstChild.getAttribute &&
"#" === 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 (void 0 !== context.getElementById && !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 (void 0 !== context.getElementById && !documentIsXML) {
var m = context.getElementById(
id
);
return m
? m.id === id ||
(void 0 !== m.getAttributeNode &&
m.getAttributeNode(
"id"
).value === id)
? [m,]
: undefined
: [];
}
}),
(Expr.filter.ID = function (
id
) {
var attrId = id.replace(
runescape,
funescape
);
return function (
elem
) {
var node =
void 0 !== elem.getAttributeNode &&
elem.getAttributeNode(
"id"
);
return node && node.value === attrId;
};
})),
(Expr.find.TAG = support.tagNameNoComments
? function (
tag, context
) {
if (void 0 !== context.getElementsByTagName)
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 (void 0 !== context.getElementsByName)
return context.getElementsByName(
name
);
}),
(Expr.find.CLASS =
support.getByClassName &&
function (
className, context
) {
if (void 0 !== context.getElementsByClassName && !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(
"\\[[\\x20\\t\\r\\n\\f]*(?: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(
"[*^$]=[\\x20\\t\\r\\n\\f]*(?:\"\"|'')"
),
div.querySelectorAll(
":enabled"
).length ||
rbuggyQSA.push(
":enabled",
":disabled"
),
div.querySelectorAll(
"*,:x"
),
rbuggyQSA.push(
",.*:"
);
}
)),
(support.matchesSelector = isNative(
(matches =
docElem.matchesSelector ||
docElem.mozMatchesSelector ||
docElem.webkitMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector),
)) &&
assert(
function (
div
) {
(support.disconnectedMatch = matches.call(
div,
"div"
)),
matches.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)
: 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 = matches.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(
"(^|[\\x20\\t\\r\\n\\f])" +
className +
"(" +
whitespace +
"|$)",
)) &&
classCache(
className,
function (
elem
) {
return pattern.test(
elem.className ||
(void 0 !== elem.getAttribute &&
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--;
)
seed[
(idx = indexOf.call(
seed,
matched[i]
))
] = !(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[i] = createInputPseudo(
i
);
for (i in {
submit: !0,
reset: !0,
})
Expr.pseudos[i] = createButtonPseudo(
i
);
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 ||
(function (
selector, contexts, results
) {
for (var i = 0, len = contexts.length; i < len; i++)
Sizzle(
selector,
contexts[i],
results
);
return results;
})(
selector || "*",
context.nodeType ? [context,] : context,
[]
),
matcherIn =
!preFilter || (!seed && selector)
? elems
: condense(
elems,
preMap,
preFilter,
context,
xml
),
matcherOut = matcher
? postFinder || (seed ? preFilter : preexisting || postFilter)
? []
: results
: matcherIn;
if (
(matcher && matcher(
matcherIn,
matcherOut,
context,
xml
),
postFilter)
)
for (
temp = condense(
matcherOut,
postMap
),
postFilter(
temp,
[],
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 setFilters(
) {}
(compile = Sizzle.compile = function (
selector, group
) {
var i,
setMatchers = [],
elementMatchers = [],
cached = compilerCache[selector + " "];
if (!cached) {
for (group || (group = tokenize(
selector
)), i = group.length; i--; )
(cached = matcherFromTokens(
group[i]
))[expando]
? setMatchers.push(
cached
)
: elementMatchers.push(
cached
);
cached = compilerCache(
selector,
(function (
elementMatchers, setMatchers
) {
var matcherCachedRuns = 0,
bySet = setMatchers.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
);
};
return bySet
? markFunction(
superMatcher
)
: superMatcher;
})(
elementMatchers,
setMatchers
),
);
}
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);
})(
window
);
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 (ret = [], i = 0; 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 &&
(undefined === until || 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(
document
).appendChild(
document.createElement(
"div"
),
);
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 =
void 0 !== context.getElementsByTagName
? context.getElementsByTagName(
tag || "*"
)
: void 0 !== context.querySelectorAll
? context.querySelectorAll(
tag || "*"
)
: undefined;
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 undefined === tag || (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 (
value
) {
return jQuery.access(
this,
function (
value
) {
return undefined === value
? jQuery.text(
this
)
: this.empty(
).append(
(
(this[0] && this[0].ownerDocument) ||
document
).createTextNode(
value
),
);
},
null,
value,
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 (
value
) {
return jQuery.access(
this,
function (
value
) {
var elem = this[0] || {
},
i = 0,
l = this.length;
if (undefined === value)
return 1 === elem.nodeType
? elem.innerHTML.replace(
rinlinejQuery,
""
)
: undefined;
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++)
1 === (elem = this[i] || {
}).nodeType &&
(jQuery.cleanData(
getAll(
elem,
!1
)
),
(elem.innerHTML = value));
elem = 0;
} catch (e) {}
}
elem && this.empty(
).append(
value
);
},
null,
value,
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,
elem,
tag,
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(
)
: undefined,
)),
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"
),
hasScripts = (scripts = jQuery.map(
getAll(
fragment,
"script"
),
disableScript,
)).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"
)
? ((elem = this[i]),
(tag = "tbody"),
elem.getElementsByTagName(
tag
)[0] ||
elem.appendChild(
elem.ownerDocument.createElement(
tag
)
))
: 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 (
destElements = getAll(
clone
), srcElements = getAll(
elem
), i = 0;
null != (node = srcElements[i]);
++i
)
destElements[i] && fixCloneNodeIssues(
node,
destElements[i]
);
if (dataAndEvents)
if (deepDataAndEvents)
for (
srcElements = srcElements || getAll(
elem
),
destElements = destElements || getAll(
clone
),
i = 0;
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"
)
),
tag = (rtagName.exec(
elem
) || ["", "",])[1].toLowerCase(
),
wrap = wrapMap[tag] || 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]
: void 0 !== elem.removeAttribute
? 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 = document,
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 (
name, value
) {
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 undefined !== value
? jQuery.style(
elem,
name,
value
)
: jQuery.css(
elem,
name
);
},
name,
value,
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]),
undefined === value)
)
return hooks &&
"get" in hooks &&
undefined !== (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 &&
undefined === (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]) &&
"get" in hooks &&
(val = hooks.get(
elem,
!0,
extra
)),
undefined === val && (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;
},
}
),
window.getComputedStyle
? ((getStyles = function (
elem
) {
return window.getComputedStyle(
elem,
null
);
}),
(curCSS = function (
elem, name, _computed
) {
var width,
minWidth,
maxWidth,
computed = _computed || getStyles(
elem
),
ret = computed
? computed.getPropertyValue(
name
) || computed[name]
: undefined,
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
);
}))
: document.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] : undefined,
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(
0,
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 val = jQuery(
this
).val(
);
return null == val
? null
: jQuery.isArray(
val
)
? jQuery.map(
val,
function (
val
) {
return {
name: elem.name,
value: val.replace(
rCRLF,
"\r\n"
),
};
}
)
: {
name: elem.name,
value: val.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 (
(undefined === traditional &&
(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?$/gm,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
_load = jQuery.fn.load,
prefilters = {
},
transports = {
},
allTypes = "*/".concat(
"*"
);
try {
ajaxLocation = location.href;
} catch (e) {
((ajaxLocation = document.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]
? ((dataType = dataType.slice(
1
) || "*"),
(structure[dataType] = 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)
undefined !== 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 = undefined))
: 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 = undefined)),
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": window.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 = undefined)),
(options = options || {
});
var parts,
i,
cacheURL,
responseHeadersString,
timeoutTimer,
fireGlobals,
transport,
responseHeaders,
s = jQuery.ajaxSetup(
{
},
options
),
callbackContext = s.context || s,
globalEventContext =
s.context && (callbackContext.nodeType || callbackContext.jquery)
? jQuery(
callbackContext
)
: jQuery.event,
deferred = jQuery.Deferred(
),
completeDeferred = jQuery.Callbacks(
"once memory"
),
statusCode = s.statusCode || {
},
requestHeaders = {
},
requestHeadersNames = {
},
state = 0,
strAbort = "canceled",
jqXHR = {
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 ||
((name = requestHeadersNames[lname] =
requestHeadersNames[lname] || name),
(requestHeaders[name] = value)),
this
);
},
overrideMimeType: function (
type
) {
return state || (s.mimeType = type), this;
},
statusCode: function (
map
) {
var code;
if (map)
if (state < 2)
for (code in map)
statusCode[code] = [statusCode[code], map[code],];
else jqXHR.always(
map[jqXHR.status]
);
return this;
},
abort: function (
statusText
) {
var finalText = statusText || strAbort;
return (
transport && transport.abort(
finalText
),
done(
0,
finalText
),
this
);
},
};
if (
((deferred.promise(
jqXHR
).complete = completeDeferred.add),
(jqXHR.success = jqXHR.done),
(jqXHR.error = jqXHR.fail),
(s.url = ((url || s.url || ajaxLocation) + "")
.replace(
rhash,
""
)
.replace(
rprotocol,
ajaxLocParts[1] + "//"
)),
(s.type = options.method || options.type || s.method || s.type),
(s.dataTypes = jQuery
.trim(
s.dataType || "*"
)
.toLowerCase(
)
.match(
core_rnotwhite
) || ["",]),
null == s.crossDomain &&
((parts = rurl.exec(
s.url.toLowerCase(
)
)),
(s.crossDomain = !(
!parts ||
(parts[1] === ajaxLocParts[1] &&
parts[2] === ajaxLocParts[2] &&
(parts[3] || ("http:" === parts[1] ? 80 : 443)) ==
(ajaxLocParts[3] || ("http:" === ajaxLocParts[1] ? 80 : 443)))
))),
s.data &&
s.processData &&
"string" != typeof s.data &&
(s.data = jQuery.param(
s.data,
s.traditional
)),
inspectPrefiltersOrTransports(
prefilters,
s,
options,
jqXHR
),
2 === state)
)
return jqXHR;
for (i in ((fireGlobals = s.global) &&
0 == jQuery.active++ &&
jQuery.event.trigger(
"ajaxStart"
),
(s.type = s.type.toUpperCase(
)),
(s.hasContent = !rnoContent.test(
s.type
)),
(cacheURL = s.url),
s.hasContent ||
(s.data &&
((cacheURL = s.url +=
(ajax_rquery.test(
cacheURL
)
? "&"
: "?") + s.data),
delete s.data),
!1 === s.cache &&
(s.url = rts.test(
cacheURL
)
? cacheURL.replace(
rts,
"$1_=" + ajax_nonce++
)
: cacheURL +
(ajax_rquery.test(
cacheURL
)
? "&"
: "?") +
"_=" +
ajax_nonce++)),
s.ifModified &&
(jQuery.lastModified[cacheURL] &&
jqXHR.setRequestHeader(
"If-Modified-Since",
jQuery.lastModified[cacheURL],
),
jQuery.etag[cacheURL] &&
jqXHR.setRequestHeader(
"If-None-Match",
jQuery.etag[cacheURL]
)),
((s.data && s.hasContent && !1 !== s.contentType) ||
options.contentType) &&
jqXHR.setRequestHeader(
"Content-Type",
s.contentType
),
jqXHR.setRequestHeader(
"Accept",
s.dataTypes[0] && s.accepts[s.dataTypes[0]]
? s.accepts[s.dataTypes[0]] +
("*" !== s.dataTypes[0] ? ", " + allTypes + "; q=0.01" : "")
: s.accepts["*"],
),
s.headers))
jqXHR.setRequestHeader(
i,
s.headers[i]
);
if (
s.beforeSend &&
(!1 === s.beforeSend.call(
callbackContext,
jqXHR,
s
) || 2 === state)
)
return jqXHR.abort(
);
for (i in ((strAbort = "abort"), {
success: 1,
error: 1,
complete: 1,
}))
jqXHR[i](
s[i]
);
if (
(transport = inspectPrefiltersOrTransports(
transports,
s,
options,
jqXHR,
))
) {
(jqXHR.readyState = 1),
fireGlobals && globalEventContext.trigger(
"ajaxSend",
[jqXHR, s,]
),
s.async &&
s.timeout > 0 &&
(timeoutTimer = setTimeout(
function (
) {
jqXHR.abort(
"timeout"
);
},
s.timeout
));
try {
(state = 1), transport.send(
requestHeaders,
done
);
} catch (e) {
if (!(state < 2)) throw e;
done(
-1,
e
);
}
} else done(
-1,
"No Transport"
);
function done(
status, nativeStatusText, responses, headers
) {
var isSuccess,
success,
error,
response,
modified,
statusText = nativeStatusText;
2 !== state &&
((state = 2),
timeoutTimer && clearTimeout(
timeoutTimer
),
(transport = undefined),
(responseHeadersString = headers || ""),
(jqXHR.readyState = status > 0 ? 4 : 0),
responses &&
(response = (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(
),
undefined === ct &&
(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]
);
})(
s,
jqXHR,
responses
)),
(status >= 200 && status < 300) || 304 === status
? (s.ifModified &&
((modified = jqXHR.getResponseHeader(
"Last-Modified"
)) &&
(jQuery.lastModified[cacheURL] = modified),
(modified = jqXHR.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];
s.dataFilter &&
(response = s.dataFilter(
response,
s.dataType
));
if (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,
};
})(
s,
response
)).state),
(success = isSuccess.data),
(isSuccess = !(error = isSuccess.error))))
: ((error = statusText),
(!status && statusText) ||
((statusText = "error"), status < 0 && (status = 0))),
(jqXHR.status = status),
(jqXHR.statusText = (nativeStatusText || statusText) + ""),
isSuccess
? deferred.resolveWith(
callbackContext,
[
success,
statusText,
jqXHR,
]
)
: deferred.rejectWith(
callbackContext,
[
jqXHR,
statusText,
error,
]
),
jqXHR.statusCode(
statusCode
),
(statusCode = undefined),
fireGlobals &&
globalEventContext.trigger(
isSuccess ? "ajaxSuccess" : "ajaxError",
[jqXHR, s, isSuccess ? success : error,],
),
completeDeferred.fireWith(
callbackContext,
[jqXHR, statusText,]
),
fireGlobals &&
(globalEventContext.trigger(
"ajaxComplete",
[jqXHR, s,]
),
--jQuery.active || jQuery.event.trigger(
"ajaxStop"
)));
}
return jqXHR;
},
getScript: function (
url, callback
) {
return jQuery.get(
url,
undefined,
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
) {
undefined === s.cache && (s.cache = !1),
s.crossDomain && ((s.type = "GET"), (s.global = !1));
}
),
jQuery.ajaxTransport(
"script",
function (
s
) {
if (s.crossDomain) {
var script,
head = document.head || jQuery(
"head"
)[0] || document.documentElement;
return {
send: function (
_, callback
) {
((script = document.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(
undefined,
!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 = window[callbackName]),
(window[callbackName] = function (
) {
responseContainer = arguments;
}),
jqXHR.always(
function (
) {
(window[callbackName] = overwritten),
s[callbackName] &&
((s.jsonpCallback = originalSettings.jsonpCallback),
oldCallbacks.push(
callbackName
)),
responseContainer &&
jQuery.isFunction(
overwritten
) &&
overwritten(
responseContainer[0]
),
(responseContainer = overwritten = undefined);
}
),
"script"
);
}
);
var xhrCallbacks,
xhrSupported,
xhrId = 0,
xhrOnUnloadAbort =
window.ActiveXObject &&
function (
) {
var key;
for (key in xhrCallbacks) xhrCallbacks[key](
undefined,
!0
);
};
function createStandardXHR(
) {
try {
return new window.XMLHttpRequest(
);
} catch (e) {}
}
(jQuery.ajaxSettings.xhr = window.ActiveXObject
? function (
) {
return (
(!this.isLocal && createStandardXHR(
)) ||
(function (
) {
try {
return new window.ActiveXObject(
"Microsoft.XMLHTTP"
);
} catch (e) {}
})(
)
);
}
: createStandardXHR),
(xhrSupported = jQuery.ajaxSettings.xhr(
)),
(jQuery.support.cors = !!xhrSupported && "withCredentials" in xhrSupported),
(xhrSupported = jQuery.support.ajax = !!xhrSupported) &&
jQuery.ajaxTransport(
function (
s
) {
var callback;
if (!s.crossDomain || jQuery.support.cors)
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 = undefined),
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(
window
).unload(
xhrOnUnloadAbort
)),
(xhrCallbacks[handle] = callback)),
(xhr.onreadystatechange = callback))
: callback(
);
},
abort: function (
) {
callback && callback(
undefined,
!0
);
},
};
}
);
var fxNow,
timerId,
rfxtypes = /^(?:toggle|show|hide)$/,
rfxnum = new RegExp(
"^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$",
"i"
),
rrun = /queueHooks$/,
animationPrefilters = [
function (
elem, props, opts
) {
var prop,
index,
length,
value,
dataShow,
toggle,
tween,
hooks,
oldfire,
anim = this,
style = elem.style,
orig = {
},
handled = [],
hidden = elem.nodeType && isHidden(
elem
);
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]);
}
));
for (index in 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)) {
"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]
);
}
);
for (index = 0; index < length; index++)
(prop = handled[index]),
(tween = anim.createTween(
prop,
hidden ? dataShow[prop] : 0
)),
(orig[prop] = dataShow[prop] || jQuery.style(
elem,
prop
)),
prop in dataShow ||
((dataShow[prop] = tween.start),
hidden &&
((tween.end = tween.start),
(tween.start =
"width" === prop || "height" === prop ? 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]),
"px" !==
(unit = parts[3] || (jQuery.cssNumber[prop] ? "" : "px")) &&
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 = undefined;
}
),
(fxNow = jQuery.now(
))
);
}
function Animation(
elem, properties, options
) {
var result,
stopped,
index = 0,
length = 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,
animation.startTime + animation.duration - currentTime,
),
percent = 1 - (remaining / animation.duration || 0),
index = 0,
length = animation.tweens.length;
index < length;
index++
)
animation.tweens[index].run(
percent
);
return (
deferred.notifyWith(
elem,
[animation, percent, remaining,]
),
percent < 1 && length
? remaining
: (deferred.resolveWith(
elem,
[animation,]
), !1)
);
},
animation = 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,
animation.opts,
prop,
end,
animation.opts.specialEasing[prop] || animation.opts.easing,
);
return animation.tweens.push(
tween
), tween;
},
stop: function (
gotoEnd
) {
var index = 0,
length = gotoEnd ? animation.tweens.length : 0;
if (stopped) return this;
for (stopped = !0; index < length; index++)
animation.tweens[index].run(
1
);
return (
gotoEnd
? deferred.resolveWith(
elem,
[animation, gotoEnd,]
)
: deferred.rejectWith(
elem,
[animation, gotoEnd,]
),
this
);
},
}
),
props = animation.props;
for (
!(function (
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]) && ("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;
})(
props,
animation.opts.specialEasing
);
index < length;
index++
)
if (
(result = animationPrefilters[index].call(
animation,
elem,
props,
animation.opts,
))
)
return result;
return (
(function (
animation, props
) {
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;
}
);
})(
animation,
props
),
jQuery.isFunction(
animation.opts.start
) &&
animation.opts.start.call(
elem,
animation
),
jQuery.fx.timer(
jQuery.extend(
tick,
{
elem: elem,
anim: animation,
queue: animation.opts.queue,
}
),
),
animation
.progress(
animation.opts.progress
)
.done(
animation.opts.done,
animation.opts.complete
)
.fail(
animation.opts.fail
)
.always(
animation.opts.always
)
);
}
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++)
(prop = props[index]),
(tweeners[prop] = 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 = undefined)),
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 = undefined);
}),
(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 undefined === options
? 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
)
? (void 0 !== elem.getBoundingClientRect &&
(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"
),
props = {
},
curPosition = {
};
("absolute" === position || "fixed" === position) &&
jQuery.inArray(
"auto",
[curCSSTop, curCSSLeft,]
) > -1
? ((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 || document.documentElement;
offsetParent &&
!jQuery.nodeName(
offsetParent,
"html"
) &&
"static" === jQuery.css(
offsetParent,
"position"
);
)
offsetParent = offsetParent.offsetParent;
return offsetParent || document.documentElement;
}
);
},
}
),
jQuery.each(
{
scrollLeft: "pageXOffset",
scrollTop: "pageYOffset",
},
function (
method, prop
) {
var top = /Y/.test(
prop
);
jQuery.fn[method] = function (
val
) {
return jQuery.access(
this,
function (
elem, method, val
) {
var win = getWindow(
elem
);
if (undefined === val)
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);
},
method,
val,
arguments.length,
null,
);
};
},
),
jQuery.each(
{
Height: "height",
Width: "width",
},
function (
name, type
) {
jQuery.each(
{
padding: "inner" + name,
content: type,
"": "outer" + name,
},
function (
defaultExtra, funcName
) {
jQuery.fn[funcName] = function (
margin, value
) {
var chainable =
arguments.length &&
(defaultExtra || "boolean" != typeof margin),
extra =
defaultExtra ||
(!0 === margin || !0 === value ? "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],
))
: undefined === value
? jQuery.css(
elem,
type,
extra
)
: jQuery.style(
elem,
type,
value,
extra
);
},
type,
chainable ? margin : undefined,
chainable,
null,
);
};
},
);
}
),
(window.jQuery = window.$ = jQuery),
"function" == typeof define &&
define.amd &&
define.amd.jQuery &&
define(
"jquery",
[],
function (
) {
return jQuery;
}
);
})(
window
);
Reference in New Issue View Git Blame Copy Permalink