diff --git a/dist/amd/browser/actions.js b/dist/amd/browser/actions.js new file mode 100644 index 00000000..908e8078 --- /dev/null +++ b/dist/amd/browser/actions.js @@ -0,0 +1,150 @@ +/*funcunit@3.6.1#browser/actions*/ +define(function (require, exports, module) { + var $ = require('./jquery'); + var FuncUnit = require('./core'); + var syn = window.syn = require('syn'); + var clicks = [ + 'click', + 'dblclick', + 'rightClick' + ], makeClick = function (name) { + FuncUnit.prototype[name] = function (options, success) { + this._addExists(); + if (typeof options == 'function') { + success = options; + options = {}; + } + var selector = this.selector; + FuncUnit.add({ + method: function (success, error) { + options = options || {}; + syn('_' + name, this.bind[0], options, success); + }, + success: success, + error: 'Could not ' + name + ' \'' + this.selector + '\'', + bind: this, + type: 'action' + }); + return this; + }; + }; + for (var i = 0; i < clicks.length; i++) { + makeClick(clicks[i]); + } + $.extend(FuncUnit.prototype, { + _addExists: function () { + this.exists(false); + }, + type: function (text, success) { + this._addExists(); + this.click(); + var selector = this.selector; + if (text === '') { + text = '[ctrl]a[ctrl-up]\b'; + } + FuncUnit.add({ + method: function (success, error) { + syn('_type', this.bind[0], text, success); + }, + success: success, + error: 'Could not type ' + text + ' into ' + this.selector, + bind: this, + type: 'action' + }); + return this; + }, + sendKeys: function (keys, success) { + this._addExists(); + var selector = this.selector; + if (keys === '') { + keys = '[ctrl]a[ctrl-up]\b'; + } + FuncUnit.add({ + method: function (success, error) { + syn('_type', this.bind[0], keys, success); + }, + success: success, + error: 'Could not send the keys ' + keys + ' into ' + this.selector, + bind: this, + type: 'action' + }); + return this; + }, + trigger: function (evName, success) { + this._addExists(); + FuncUnit.add({ + method: function (success, error) { + if (!FuncUnit.win.jQuery) { + throw 'Can not trigger custom event, no jQuery found on target page.'; + } + FuncUnit.win.jQuery(this.bind.selector).trigger(evName); + success(); + }, + success: success, + error: 'Could not trigger ' + evName, + bind: this, + type: 'action' + }); + return this; + }, + drag: function (options, success) { + this._addExists(); + if (typeof options == 'string') { + options = { to: options }; + } + options.from = this.selector; + var selector = this.selector; + FuncUnit.add({ + method: function (success, error) { + syn('_drag', this.bind[0], options, success); + }, + success: success, + error: 'Could not drag ' + this.selector, + bind: this, + type: 'action' + }); + return this; + }, + move: function (options, success) { + this._addExists(); + if (typeof options == 'string') { + options = { to: options }; + } + options.from = this.selector; + var selector = this.selector; + FuncUnit.add({ + method: function (success, error) { + syn('_move', this.bind[0], options, success); + }, + success: success, + error: 'Could not move ' + this.selector, + bind: this, + type: 'action' + }); + return this; + }, + scroll: function (direction, amount, success) { + this._addExists(); + var selector = this.selector, direction; + if (direction == 'left' || direction == 'right') { + direction = 'Left'; + } else if (direction == 'top' || direction == 'bottom') { + direction = 'Top'; + } + FuncUnit.add({ + method: function (success, error) { + this.bind.each(function (i, el) { + this['scroll' + direction] = amount; + }); + success(); + }, + success: success, + error: 'Could not scroll ' + this.selector, + bind: this, + type: 'action' + }); + return this; + } + }); + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/browser/adapters/adapters.js b/dist/amd/browser/adapters/adapters.js new file mode 100644 index 00000000..0c7445b8 --- /dev/null +++ b/dist/amd/browser/adapters/adapters.js @@ -0,0 +1,59 @@ +/*funcunit@3.6.1#browser/adapters/adapters*/ +define(function (require, exports, module) { + (function (global) { + var jasmineAdapter = require('./jasmine'); + var jasmine2Adapter = require('./jasmine2'); + var qunitAdapter = require('./qunit'); + var qunit2Adapter = require('./qunit2'); + var mochaAdapter = require('./mocha'); + var FuncUnit = require('../core'); + var noop = function () { + }; + var defaultAdapter = { + pauseTest: noop, + resumeTest: noop, + assertOK: noop, + equiv: function (expected, actual) { + return expected == actual; + } + }; + FuncUnit.unit = defaultAdapter; + FuncUnit.attach = function (runner) { + var unit; + if (isQUnit(runner)) { + unit = qunitAdapter(runner); + } else if (isQUnit2(runner)) { + unit = qunit2Adapter(runner); + } else if (isMocha(runner)) { + unit = mochaAdapter(runner); + } else if (isJasmine(runner)) { + unit = jasmineAdapter(runner); + } else if (isJasmine2(runner)) { + unit = jasmine2Adapter(runner); + } else { + unit = defaultAdapter; + } + FuncUnit.unit = unit; + }; + function isQUnit(runner) { + return !!(runner.ok && runner.start && runner.stop); + } + function isQUnit2(runner) { + return !!(runner.assert && runner.assert.ok && runner.assert.async); + } + function isMocha(runner) { + return !!(runner.setup && runner.globals && runner.reporter); + } + function isJasmine(runner) { + return !!(runner.getEnv && typeof window.waitsFor === 'function'); + } + function isJasmine2(runner) { + return !!(runner.getEnv && typeof runner.clock === 'function' && !window.waitsFor); + } + FuncUnit.detach = function () { + FuncUnit.unit = defaultAdapter; + }; + }(function () { + return this; + }())); +}); \ No newline at end of file diff --git a/dist/amd/browser/adapters/jasmine.js b/dist/amd/browser/adapters/jasmine.js new file mode 100644 index 00000000..d155ce99 --- /dev/null +++ b/dist/amd/browser/adapters/jasmine.js @@ -0,0 +1,23 @@ +/*funcunit@3.6.1#browser/adapters/jasmine*/ +define(function (require, exports, module) { + module.exports = function (jasmine) { + var paused = false; + return { + pauseTest: function () { + paused = true; + waitsFor(function () { + return paused === false; + }, 60000); + }, + resumeTest: function () { + paused = false; + }, + assertOK: function (assertion) { + expect(assertion).toBeTruthy(); + }, + equiv: function (expected, actual) { + return jasmine.getEnv().equals_(expected, actual); + } + }; + }; +}); \ No newline at end of file diff --git a/dist/amd/browser/adapters/jasmine2.js b/dist/amd/browser/adapters/jasmine2.js new file mode 100644 index 00000000..5e833349 --- /dev/null +++ b/dist/amd/browser/adapters/jasmine2.js @@ -0,0 +1,19 @@ +/*funcunit@3.6.1#browser/adapters/jasmine2*/ +define(function (require, exports, module) { + var FuncUnit = require('../core'); + module.exports = function () { + FuncUnit.timeout = 4900; + return { + pauseTest: function () { + }, + resumeTest: function () { + }, + assertOK: function (assertion) { + expect(assertion).toBeTruthy(); + }, + equiv: function (expected, actual) { + return expected == actual; + } + }; + }; +}); \ No newline at end of file diff --git a/dist/amd/browser/adapters/mocha.js b/dist/amd/browser/adapters/mocha.js new file mode 100644 index 00000000..34d49b5c --- /dev/null +++ b/dist/amd/browser/adapters/mocha.js @@ -0,0 +1,23 @@ +/*funcunit@3.6.1#browser/adapters/mocha*/ +define(function (require, exports, module) { + var FuncUnit = require('../core'); + var ok = function (expr, msg) { + if (!expr) + throw new Error(msg); + }; + module.exports = function () { + FuncUnit.timeout = 1900; + return { + pauseTest: function () { + }, + resumeTest: function () { + }, + assertOK: function (assertion, message) { + ok(assertion, message); + }, + equiv: function (expected, actual) { + return expected == actual; + } + }; + }; +}); \ No newline at end of file diff --git a/dist/amd/browser/adapters/qunit.js b/dist/amd/browser/adapters/qunit.js new file mode 100644 index 00000000..3b5a544c --- /dev/null +++ b/dist/amd/browser/adapters/qunit.js @@ -0,0 +1,19 @@ +/*funcunit@3.6.1#browser/adapters/qunit*/ +define(function (require, exports, module) { + module.exports = function (QUnit) { + return { + pauseTest: function () { + QUnit.stop(); + }, + resumeTest: function () { + QUnit.start(); + }, + assertOK: function (assertion, message) { + QUnit.ok(assertion, message); + }, + equiv: function (expected, actual) { + return QUnit.equiv(expected, actual); + } + }; + }; +}); \ No newline at end of file diff --git a/dist/amd/browser/adapters/qunit2.js b/dist/amd/browser/adapters/qunit2.js new file mode 100644 index 00000000..5418aa3d --- /dev/null +++ b/dist/amd/browser/adapters/qunit2.js @@ -0,0 +1,28 @@ +/*funcunit@3.6.1#browser/adapters/qunit2*/ +define(function (require, exports, module) { + module.exports = function (runner) { + var done; + var currentTestAssert; + var originalTest = runner.test; + runner.test = function funcunitTest(title, test) { + return originalTest(title, function (assert) { + currentTestAssert = assert; + return test.apply(this, arguments); + }); + }; + return { + pauseTest: function () { + done = currentTestAssert.async(); + }, + resumeTest: function () { + done(); + }, + assertOK: function (assertion, message) { + currentTestAssert.ok(assertion, message); + }, + equiv: function (expected, actual) { + return runner.equiv(expected, actual); + } + }; + }; +}); \ No newline at end of file diff --git a/dist/amd/browser/core.js b/dist/amd/browser/core.js new file mode 100644 index 00000000..682ff3a0 --- /dev/null +++ b/dist/amd/browser/core.js @@ -0,0 +1,64 @@ +/*funcunit@3.6.1#browser/core*/ +define(function (require, exports, module) { + var jQuery = require('./jquery'); + var oldFuncUnit = require('./init'); + var FuncUnit = oldFuncUnit.jQuery.sub(); + var origFuncUnit = FuncUnit; + FuncUnit = function (selector, frame) { + var frame, forceSync, isSyncOnly = false; + if (frame && frame.forceSync) { + forceSync = frame.forceSync; + } + if (frame && typeof frame.frame !== 'undefined') { + frame = frame.frame; + } + isSyncOnly = typeof forceSync === 'boolean' ? forceSync : isSyncOnly; + if (typeof selector == 'function') { + return FuncUnit.wait(0, selector); + } + this.selector = selector; + if (isSyncOnly === true) { + var collection = performSyncQuery(selector, frame); + return collection; + } else { + performAsyncQuery(selector, frame, this); + var collection = performSyncQuery(selector, frame); + return collection; + } + }; + var getContext = function (context) { + if (typeof context === 'number' || typeof context === 'string') { + var sel = typeof context === 'number' ? 'iframe:eq(' + context + ')' : 'iframe[name=\'' + context + '\']', frames = new origFuncUnit.fn.init(sel, FuncUnit.win.document.documentElement, true); + var frame = (frames.length ? frames.get(0).contentWindow : FuncUnit.win).document.documentElement; + } else { + frame = FuncUnit.win.document.documentElement; + } + return frame; + }, performAsyncQuery = function (selector, frame, self) { + FuncUnit.add({ + method: function (success, error) { + this.frame = frame; + if (FuncUnit.win) { + frame = getContext(frame); + } + this.selector = selector; + this.bind = new origFuncUnit.fn.init(selector, frame, true); + success(); + return this; + }, + error: 'selector failed: ' + selector, + type: 'query' + }); + }, performSyncQuery = function (selector, frame) { + var origFrame = frame; + if (FuncUnit.win) { + frame = getContext(frame); + } + var obj = new origFuncUnit.fn.init(selector, frame, true); + obj.frame = origFrame; + return obj; + }; + oldFuncUnit.jQuery.extend(FuncUnit, oldFuncUnit, origFuncUnit); + FuncUnit.prototype = origFuncUnit.prototype; + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/browser/getters.js b/dist/amd/browser/getters.js new file mode 100644 index 00000000..a23a3a51 --- /dev/null +++ b/dist/amd/browser/getters.js @@ -0,0 +1,137 @@ +/*funcunit@3.6.1#browser/getters*/ +define(function (require, exports, module) { + var $ = require('./jquery'); + var FuncUnit = require('./core'); + FuncUnit.funcs = { + 'size': 0, + 'attr': 1, + 'hasClass': 1, + 'html': 0, + 'text': 0, + 'val': 0, + 'css': 1, + 'prop': 1, + 'offset': 0, + 'position': 0, + 'scrollTop': 0, + 'scrollLeft': 0, + 'height': 0, + 'width': 0, + 'innerHeight': 0, + 'innerWidth': 0, + 'outerHeight': 0, + 'outerWidth': 0 + }; + FuncUnit.makeFunc = function (fname, argIndex) { + var orig = FuncUnit.fn[fname]; + FuncUnit.prototype[fname] = function () { + var args = FuncUnit.makeArray(arguments), isWait = args.length > argIndex, success, self = this; + args.unshift(this.selector, this.frame, fname); + if (isWait) { + var tester = args[argIndex + 3], timeout = args[argIndex + 4], success = args[argIndex + 5], message = args[argIndex + 6], testVal = tester, errorMessage = 'waiting for ' + fname + ' on ' + this.selector, frame = this.frame, logMessage = 'Checking ' + fname + ' on \'' + this.selector + '\'', ret; + if (typeof tester == 'object' && !(tester instanceof RegExp)) { + timeout = tester.timeout; + success = tester.success; + message = tester.message; + if (tester.errorMessage) { + errorMessage = tester.errorMessage; + } + if (typeof tester.logMessage !== 'undefined') { + logMessage = tester.logMessage; + } + tester = tester.condition; + } + if (typeof timeout == 'function') { + message = success; + success = timeout; + timeout = undefined; + } + if (typeof timeout == 'string') { + message = timeout; + timeout = undefined; + success = undefined; + } + if (typeof message !== 'string') { + message = undefined; + } + args.splice(argIndex + 3, args.length - argIndex - 3); + if (typeof tester != 'function') { + errorMessage += ' !== ' + testVal; + tester = function (val) { + return FuncUnit.unit.equiv(val, testVal) || testVal instanceof RegExp && testVal.test(val); + }; + } + if (message) { + errorMessage = message; + } + FuncUnit.repeat({ + method: function (print) { + if (this.bind.prevObject && this.bind.prevTraverser) { + var prev = this.bind; + this.bind = this.bind.prevObject[this.bind.prevTraverser](this.bind.prevTraverserSelector); + this.bind.prevTraverser = prev.prevTraverser; + this.bind.prevTraverserSelector = prev.prevTraverserSelector; + } else { + this.bind = F(this.selector, { + frame: frame, + forceSync: true + }); + } + if (logMessage) { + print(logMessage); + } + var methodArgs = []; + if (argIndex > 0) { + methodArgs.push(args[3]); + } + FuncUnit._ignoreGetterError = true; + ret = this.bind[fname].apply(this.bind, methodArgs); + FuncUnit._ignoreGetterError = false; + var passed = tester.call(this.bind, ret); + if (this.bind.length === 0 && fname !== 'size') { + passed = false; + } + if (passed) { + if (!FuncUnit.documentLoaded()) { + passed = false; + } else { + FuncUnit.checkForNewDocument(); + } + } + return passed; + }, + success: function () { + if (message) { + FuncUnit.unit.assertOK(true, message); + } + success && success.apply(this, arguments); + }, + error: function () { + var msg = errorMessage; + if (ret) { + msg += ', actual value: ' + ret; + } + FuncUnit.unit.assertOK(false, msg); + }, + timeout: timeout, + bind: this, + type: 'wait' + }); + return this; + } else { + if (!FuncUnit._ignoreGetterError && !FuncUnit._incallback && FuncUnit._haveAsyncQueries()) { + console && console.error('You can\'t run getters after actions and waits. Please put your getters in a callback or at the beginning of the test.'); + } + var methodArgs = []; + if (argIndex > 0) { + methodArgs.push(args[3]); + } + return orig.apply(this, methodArgs); + } + }; + }; + for (var prop in FuncUnit.funcs) { + FuncUnit.makeFunc(prop, FuncUnit.funcs[prop]); + } + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/browser/init.js b/dist/amd/browser/init.js new file mode 100644 index 00000000..b10d9814 --- /dev/null +++ b/dist/amd/browser/init.js @@ -0,0 +1,26 @@ +/*funcunit@3.6.1#browser/init*/ +define(function (require, exports, module) { + var jQuery = require('./jquery'); + var FuncUnit = window.FuncUnit || {}; + jQuery.sub = function () { + function jQuerySub(selector, context) { + return new jQuerySub.fn.init(selector, context); + } + jQuery.extend(true, jQuerySub, this); + jQuerySub.superclass = this; + jQuerySub.fn = jQuerySub.prototype = this(); + jQuerySub.fn.constructor = jQuerySub; + jQuerySub.sub = this.sub; + jQuerySub.fn.init = function init(selector, context) { + if (context && context instanceof jQuery && !(context instanceof jQuerySub)) { + context = jQuerySub(context); + } + return jQuery.fn.init.call(this, selector, context, rootjQuerySub); + }; + jQuerySub.fn.init.prototype = jQuerySub.fn; + var rootjQuerySub = jQuerySub(document); + return jQuerySub; + }; + FuncUnit.jQuery = jQuery; + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/browser/jquery.js b/dist/amd/browser/jquery.js new file mode 100644 index 00000000..e6f8c2e1 --- /dev/null +++ b/dist/amd/browser/jquery.js @@ -0,0 +1,6185 @@ +/*funcunit@3.6.1#browser/jquery*/ +define(function (require, exports, module) { + (function (global) { + 'format cjs'; + (function (global, factory) { + if (typeof module === 'object' && typeof module.exports === 'object') { + module.exports = global.document ? factory(global, true) : function (w) { + if (!w.document) { + throw new Error('jQuery requires a window with a document'); + } + return factory(w); + }; + module.exports = module.exports.noConflict(true); + } else { + factory(global); + } + }(typeof window !== 'undefined' ? window : this, function (window, noGlobal) { + var deletedIds = []; + var slice = deletedIds.slice; + var concat = deletedIds.concat; + var push = deletedIds.push; + var indexOf = deletedIds.indexOf; + var class2type = {}; + var toString = class2type.toString; + var hasOwn = class2type.hasOwnProperty; + var trim = ''.trim; + var support = {}; + var version = '1.11.0', jQuery = function (selector, context) { + return new jQuery.fn.init(selector, context); + }, rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, fcamelCase = function (all, letter) { + return letter.toUpperCase(); + }; + jQuery.fn = jQuery.prototype = { + jquery: version, + constructor: jQuery, + selector: '', + length: 0, + toArray: function () { + return slice.call(this); + }, + get: function (num) { + return num != null ? num < 0 ? this[num + this.length] : this[num] : slice.call(this); + }, + pushStack: function (elems) { + var ret = jQuery.merge(this.constructor(), elems); + ret.prevObject = this; + ret.context = this.context; + return ret; + }, + each: function (callback, args) { + return jQuery.each(this, callback, args); + }, + map: function (callback) { + return this.pushStack(jQuery.map(this, function (elem, i) { + return callback.call(elem, i, elem); + })); + }, + slice: function () { + return this.pushStack(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]] : []); + }, + end: function () { + return this.prevObject || this.constructor(null); + }, + push: push, + sort: deletedIds.sort, + splice: deletedIds.splice + }; + jQuery.extend = jQuery.fn.extend = function () { + var src, copyIsArray, copy, name, options, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false; + if (typeof target === 'boolean') { + deep = target; + target = arguments[i] || {}; + i++; + } + if (typeof target !== 'object' && !jQuery.isFunction(target)) { + target = {}; + } + if (i === length) { + target = this; + i--; + } + for (; i < length; i++) { + if ((options = arguments[i]) != null) { + for (name in options) { + src = target[name]; + copy = options[name]; + if (target === copy) { + continue; + } + if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && jQuery.isArray(src) ? src : []; + } else { + clone = src && jQuery.isPlainObject(src) ? src : {}; + } + target[name] = jQuery.extend(deep, clone, copy); + } else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + return target; + }; + jQuery.extend({ + expando: 'jQuery' + (version + Math.random()).replace(/\D/g, ''), + isReady: true, + error: function (msg) { + throw new Error(msg); + }, + noop: function () { + }, + isFunction: function (obj) { + return jQuery.type(obj) === 'function'; + }, + isArray: Array.isArray || function (obj) { + return jQuery.type(obj) === 'array'; + }, + isWindow: function (obj) { + return obj != null && obj == obj.window; + }, + isNumeric: function (obj) { + return obj - parseFloat(obj) >= 0; + }, + isEmptyObject: function (obj) { + var name; + for (name in obj) { + return false; + } + return true; + }, + isPlainObject: function (obj) { + var key; + if (!obj || jQuery.type(obj) !== 'object' || obj.nodeType || jQuery.isWindow(obj)) { + return false; + } + try { + if (obj.constructor && !hasOwn.call(obj, 'constructor') && !hasOwn.call(obj.constructor.prototype, 'isPrototypeOf')) { + return false; + } + } catch (e) { + return false; + } + if (support.ownLast) { + for (key in obj) { + return hasOwn.call(obj, key); + } + } + for (key in obj) { + } + return key === undefined || hasOwn.call(obj, key); + }, + type: function (obj) { + if (obj == null) { + return obj + ''; + } + return typeof obj === 'object' || typeof obj === 'function' ? class2type[toString.call(obj)] || 'object' : typeof obj; + }, + globalEval: function (data) { + if (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 value, i = 0, length = obj.length, isArray = isArraylike(obj); + if (args) { + if (isArray) { + for (; i < length; i++) { + value = callback.apply(obj[i], args); + if (value === false) { + break; + } + } + } else { + for (i in obj) { + value = callback.apply(obj[i], args); + if (value === false) { + break; + } + } + } + } else { + if (isArray) { + for (; i < length; i++) { + value = callback.call(obj[i], i, obj[i]); + if (value === false) { + break; + } + } + } else { + for (i in obj) { + value = callback.call(obj[i], i, obj[i]); + if (value === false) { + break; + } + } + } + } + return obj; + }, + trim: trim && !trim.call('\uFEFF\xA0') ? function (text) { + return text == null ? '' : trim.call(text); + } : function (text) { + return text == null ? '' : (text + '').replace(rtrim, ''); + }, + makeArray: function (arr, results) { + var ret = results || []; + if (arr != null) { + if (isArraylike(Object(arr))) { + jQuery.merge(ret, typeof arr === 'string' ? [arr] : arr); + } else { + push.call(ret, arr); + } + } + return ret; + }, + inArray: function (elem, arr, i) { + var len; + if (arr) { + if (indexOf) { + return indexOf.call(arr, elem, i); + } + len = arr.length; + i = i ? i < 0 ? Math.max(0, len + i) : i : 0; + for (; i < len; i++) { + if (i in arr && arr[i] === elem) { + return i; + } + } + } + return -1; + }, + merge: function (first, second) { + var len = +second.length, j = 0, i = first.length; + while (j < len) { + first[i++] = second[j++]; + } + if (len !== len) { + while (second[j] !== undefined) { + first[i++] = second[j++]; + } + } + first.length = i; + return first; + }, + grep: function (elems, callback, invert) { + var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; + for (; i < length; i++) { + callbackInverse = !callback(elems[i], i); + if (callbackInverse !== callbackExpect) { + matches.push(elems[i]); + } + } + return matches; + }, + map: function (elems, callback, arg) { + var value, i = 0, length = elems.length, isArray = isArraylike(elems), ret = []; + if (isArray) { + for (; i < length; i++) { + value = callback(elems[i], i, arg); + if (value != null) { + ret.push(value); + } + } + } else { + for (i in elems) { + value = callback(elems[i], i, arg); + if (value != null) { + ret.push(value); + } + } + } + return concat.apply([], ret); + }, + guid: 1, + proxy: function (fn, context) { + var args, proxy, tmp; + if (typeof context === 'string') { + tmp = fn[context]; + context = fn; + fn = tmp; + } + if (!jQuery.isFunction(fn)) { + return undefined; + } + args = slice.call(arguments, 2); + proxy = function () { + return fn.apply(context || this, args.concat(slice.call(arguments))); + }; + proxy.guid = fn.guid = fn.guid || jQuery.guid++; + return proxy; + }, + now: function () { + return +new Date(); + }, + support: support + }); + jQuery.each('Boolean Number String Function Array Date RegExp Object Error'.split(' '), function (i, name) { + class2type['[object ' + name + ']'] = name.toLowerCase(); + }); + function isArraylike(obj) { + var length = obj.length, type = jQuery.type(obj); + if (type === 'function' || jQuery.isWindow(obj)) { + return false; + } + if (obj.nodeType === 1 && length) { + return true; + } + return type === 'array' || length === 0 || typeof length === 'number' && length > 0 && length - 1 in obj; + } + var Sizzle = function (window) { + var i, support, Expr, getText, isXML, compile, outermostContext, sortInput, hasDuplicate, setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, expando = 'sizzle' + -new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function (a, b) { + if (a === b) { + hasDuplicate = true; + } + return 0; + }, strundefined = typeof undefined, MAX_NEGATIVE = 1 << 31, hasOwn = {}.hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, indexOf = arr.indexOf || function (elem) { + var i = 0, len = this.length; + for (; i < len; i++) { + if (this[i] === elem) { + return i; + } + } + return -1; + }, booleans = 'checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped', whitespace = '[\\x20\\t\\r\\n\\f]', characterEncoding = '(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+', identifier = characterEncoding.replace('w', 'w#'), attributes = '\\[' + whitespace + '*(' + characterEncoding + ')' + whitespace + '*(?:([*^$|!~]?=)' + whitespace + '*(?:([\'"])((?:\\\\.|[^\\\\])*?)\\3|(' + identifier + ')|)|)' + whitespace + '*\\]', pseudos = ':(' + characterEncoding + ')(?:\\((([\'"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|' + attributes.replace(3, 8) + ')*)|.*)\\)|)', rtrim = new RegExp('^' + whitespace + '+|((?:^|[^\\\\])(?:\\\\.)*)' + whitespace + '+$', 'g'), rcomma = new RegExp('^' + whitespace + '*,' + whitespace + '*'), rcombinators = new RegExp('^' + whitespace + '*([>+~]|' + whitespace + ')' + whitespace + '*'), rattributeQuotes = new RegExp('=' + whitespace + '*([^\\]\'"]*?)' + whitespace + '*\\]', 'g'), rpseudo = new RegExp(pseudos), ridentifier = new RegExp('^' + identifier + '$'), matchExpr = { + 'ID': new RegExp('^#(' + characterEncoding + ')'), + 'CLASS': new RegExp('^\\.(' + characterEncoding + ')'), + 'TAG': new RegExp('^(' + characterEncoding.replace('w', 'w*') + ')'), + 'ATTR': new RegExp('^' + attributes), + 'PSEUDO': new RegExp('^' + pseudos), + 'CHILD': new RegExp('^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(' + whitespace + '*(even|odd|(([+-]|)(\\d*)n|)' + whitespace + '*(?:([+-]|)' + whitespace + '*(\\d+)|))' + whitespace + '*\\)|)', 'i'), + 'bool': new RegExp('^(?:' + booleans + ')$', 'i'), + 'needsContext': new RegExp('^' + whitespace + '*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(' + whitespace + '*((?:-\\d)?\\d*)' + whitespace + '*\\)|)(?=[^-]|$)', 'i') + }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, rescape = /'|\\/g, runescape = new RegExp('\\\\([\\da-f]{1,6}' + whitespace + '?|(' + whitespace + ')|.)', 'ig'), funescape = function (_, escaped, escapedWhitespace) { + var high = '0x' + escaped - 65536; + return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320); + }; + try { + push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes); + arr[preferredDoc.childNodes.length].nodeType; + } catch (e) { + push = { + apply: arr.length ? function (target, els) { + push_native.apply(target, slice.call(els)); + } : function (target, els) { + var j = target.length, i = 0; + while (target[j++] = els[i++]) { + } + target.length = j - 1; + } + }; + } + function Sizzle(selector, context, results, seed) { + var match, elem, m, nodeType, i, groups, old, nid, newContext, newSelector; + if ((context ? context.ownerDocument || context : preferredDoc) !== document) { + setDocument(context); + } + context = context || document; + results = results || []; + if (!selector || typeof selector !== 'string') { + return results; + } + if ((nodeType = context.nodeType) !== 1 && nodeType !== 9) { + return []; + } + if (documentIsHTML && !seed) { + if (match = rquickExpr.exec(selector)) { + if (m = match[1]) { + if (nodeType === 9) { + elem = context.getElementById(m); + if (elem && elem.parentNode) { + if (elem.id === m) { + results.push(elem); + return results; + } + } else { + return results; + } + } else { + if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) && contains(context, elem) && elem.id === m) { + results.push(elem); + return results; + } + } + } else if (match[2]) { + push.apply(results, context.getElementsByTagName(selector)); + return results; + } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) { + push.apply(results, context.getElementsByClassName(m)); + return results; + } + } + if (support.qsa && (!rbuggyQSA || !rbuggyQSA.test(selector))) { + nid = old = expando; + newContext = context; + newSelector = nodeType === 9 && selector; + if (nodeType === 1 && context.nodeName.toLowerCase() !== 'object') { + groups = tokenize(selector); + if (old = context.getAttribute('id')) { + nid = old.replace(rescape, '\\$&'); + } else { + context.setAttribute('id', nid); + } + nid = '[id=\'' + nid + '\'] '; + i = groups.length; + while (i--) { + groups[i] = nid + toSelector(groups[i]); + } + newContext = rsibling.test(selector) && testContext(context.parentNode) || context; + newSelector = groups.join(','); + } + if (newSelector) { + try { + push.apply(results, newContext.querySelectorAll(newSelector)); + return results; + } catch (qsaError) { + } finally { + if (!old) { + context.removeAttribute('id'); + } + } + } + } + } + return select(selector.replace(rtrim, '$1'), context, results, seed); + } + function createCache() { + var keys = []; + function cache(key, value) { + if (keys.push(key + ' ') > Expr.cacheLength) { + delete cache[keys.shift()]; + } + return cache[key + ' '] = value; + } + return cache; + } + function markFunction(fn) { + fn[expando] = true; + return fn; + } + function assert(fn) { + var div = document.createElement('div'); + try { + return !!fn(div); + } catch (e) { + return false; + } finally { + if (div.parentNode) { + div.parentNode.removeChild(div); + } + div = null; + } + } + function addHandle(attrs, handler) { + var arr = attrs.split('|'), i = attrs.length; + while (i--) { + Expr.attrHandle[arr[i]] = handler; + } + } + function siblingCheck(a, b) { + var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE); + if (diff) { + return diff; + } + if (cur) { + while (cur = cur.nextSibling) { + if (cur === b) { + return -1; + } + } + } + return a ? 1 : -1; + } + function createInputPseudo(type) { + return function (elem) { + var name = elem.nodeName.toLowerCase(); + return name === 'input' && elem.type === type; + }; + } + function createButtonPseudo(type) { + return function (elem) { + var name = elem.nodeName.toLowerCase(); + return (name === 'input' || name === 'button') && elem.type === type; + }; + } + function createPositionalPseudo(fn) { + return markFunction(function (argument) { + argument = +argument; + return markFunction(function (seed, matches) { + var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length; + while (i--) { + if (seed[j = matchIndexes[i]]) { + seed[j] = !(matches[j] = seed[j]); + } + } + }); + }); + } + function testContext(context) { + return context && typeof context.getElementsByTagName !== strundefined && context; + } + support = Sizzle.support = {}; + isXML = Sizzle.isXML = function (elem) { + var documentElement = elem && (elem.ownerDocument || elem).documentElement; + return documentElement ? documentElement.nodeName !== 'HTML' : false; + }; + setDocument = Sizzle.setDocument = function (node) { + var hasCompare, doc = node ? node.ownerDocument || node : preferredDoc, parent = doc.defaultView; + if (doc === document || doc.nodeType !== 9 || !doc.documentElement) { + return document; + } + document = doc; + docElem = doc.documentElement; + documentIsHTML = !isXML(doc); + if (parent && parent !== parent.top) { + if (parent.addEventListener) { + parent.addEventListener('unload', function () { + setDocument(); + }, false); + } else if (parent.attachEvent) { + parent.attachEvent('onunload', function () { + setDocument(); + }); + } + } + support.attributes = assert(function (div) { + div.className = 'i'; + return !div.getAttribute('className'); + }); + support.getElementsByTagName = assert(function (div) { + div.appendChild(doc.createComment('')); + return !div.getElementsByTagName('*').length; + }); + support.getElementsByClassName = rnative.test(doc.getElementsByClassName) && assert(function (div) { + div.innerHTML = '
'; + div.firstChild.className = 'i'; + return div.getElementsByClassName('i').length === 2; + }); + support.getById = assert(function (div) { + docElem.appendChild(div).id = expando; + return !doc.getElementsByName || !doc.getElementsByName(expando).length; + }); + if (support.getById) { + Expr.find['ID'] = function (id, context) { + if (typeof context.getElementById !== strundefined && documentIsHTML) { + 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; + }; + }; + } else { + delete Expr.find['ID']; + Expr.filter['ID'] = function (id) { + var attrId = id.replace(runescape, funescape); + return function (elem) { + var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode('id'); + return node && node.value === attrId; + }; + }; + } + Expr.find['TAG'] = support.getElementsByTagName ? function (tag, context) { + if (typeof context.getElementsByTagName !== strundefined) { + return context.getElementsByTagName(tag); + } + } : function (tag, context) { + var elem, tmp = [], i = 0, results = context.getElementsByTagName(tag); + if (tag === '*') { + while (elem = results[i++]) { + if (elem.nodeType === 1) { + tmp.push(elem); + } + } + return tmp; + } + return results; + }; + Expr.find['CLASS'] = support.getElementsByClassName && function (className, context) { + if (typeof context.getElementsByClassName !== strundefined && documentIsHTML) { + return context.getElementsByClassName(className); + } + }; + rbuggyMatches = []; + rbuggyQSA = []; + if (support.qsa = rnative.test(doc.querySelectorAll)) { + assert(function (div) { + div.innerHTML = ''; + if (div.querySelectorAll('[t^=\'\']').length) { + rbuggyQSA.push('[*^$]=' + whitespace + '*(?:\'\'|"")'); + } + if (!div.querySelectorAll('[selected]').length) { + rbuggyQSA.push('\\[' + whitespace + '*(?:value|' + booleans + ')'); + } + if (!div.querySelectorAll(':checked').length) { + rbuggyQSA.push(':checked'); + } + }); + assert(function (div) { + var input = doc.createElement('input'); + input.setAttribute('type', 'hidden'); + div.appendChild(input).setAttribute('name', 'D'); + if (div.querySelectorAll('[name=d]').length) { + rbuggyQSA.push('name' + whitespace + '*[*^$|!~]?='); + } + if (!div.querySelectorAll(':enabled').length) { + rbuggyQSA.push(':enabled', ':disabled'); + } + div.querySelectorAll('*,:x'); + rbuggyQSA.push(',.*:'); + }); + } + if (support.matchesSelector = rnative.test(matches = docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) { + assert(function (div) { + support.disconnectedMatch = matches.call(div, 'div'); + matches.call(div, '[s!=\'\']:x'); + rbuggyMatches.push('!=', pseudos); + }); + } + rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join('|')); + rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join('|')); + hasCompare = rnative.test(docElem.compareDocumentPosition); + contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) { + var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; + return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16)); + } : function (a, b) { + if (b) { + while (b = b.parentNode) { + if (b === a) { + return true; + } + } + } + return false; + }; + sortOrder = hasCompare ? function (a, b) { + if (a === b) { + hasDuplicate = true; + return 0; + } + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if (compare) { + return compare; + } + compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1; + if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) { + if (a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) { + return -1; + } + if (b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) { + return 1; + } + return sortInput ? indexOf.call(sortInput, a) - indexOf.call(sortInput, b) : 0; + } + return compare & 4 ? -1 : 1; + } : function (a, b) { + if (a === b) { + hasDuplicate = true; + return 0; + } + var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [a], bp = [b]; + if (!aup || !bup) { + return a === doc ? -1 : b === doc ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf.call(sortInput, a) - indexOf.call(sortInput, b) : 0; + } else if (aup === bup) { + return siblingCheck(a, b); + } + cur = a; + while (cur = cur.parentNode) { + ap.unshift(cur); + } + cur = b; + while (cur = cur.parentNode) { + bp.unshift(cur); + } + while (ap[i] === bp[i]) { + i++; + } + return i ? siblingCheck(ap[i], bp[i]) : ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; + }; + return doc; + }; + 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\']'); + if (support.matchesSelector && documentIsHTML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) { + try { + var ret = matches.call(elem, expr); + if (ret || support.disconnectedMatch || elem.document && elem.document.nodeType !== 11) { + return ret; + } + } catch (e) { + } + } + return Sizzle(expr, document, null, [elem]).length > 0; + }; + Sizzle.contains = function (context, elem) { + if ((context.ownerDocument || context) !== document) { + setDocument(context); + } + return contains(context, elem); + }; + Sizzle.attr = function (elem, name) { + if ((elem.ownerDocument || elem) !== document) { + setDocument(elem); + } + var fn = Expr.attrHandle[name.toLowerCase()], val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined; + return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; + }; + Sizzle.error = function (msg) { + throw new Error('Syntax error, unrecognized expression: ' + msg); + }; + Sizzle.uniqueSort = function (results) { + var elem, duplicates = [], j = 0, i = 0; + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice(0); + results.sort(sortOrder); + if (hasDuplicate) { + while (elem = results[i++]) { + if (elem === results[i]) { + j = duplicates.push(i); + } + } + while (j--) { + results.splice(duplicates[j], 1); + } + } + sortInput = null; + return results; + }; + getText = Sizzle.getText = function (elem) { + var node, ret = '', i = 0, nodeType = elem.nodeType; + if (!nodeType) { + while (node = elem[i++]) { + ret += getText(node); + } + } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) { + if (typeof elem.textContent === 'string') { + return elem.textContent; + } else { + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + ret += getText(elem); + } + } + } else if (nodeType === 3 || nodeType === 4) { + return elem.nodeValue; + } + return ret; + }; + Expr = Sizzle.selectors = { + cacheLength: 50, + createPseudo: markFunction, + match: matchExpr, + attrHandle: {}, + find: {}, + relative: { + '>': { + dir: 'parentNode', + first: true + }, + ' ': { dir: 'parentNode' }, + '+': { + dir: 'previousSibling', + first: true + }, + '~': { dir: 'previousSibling' } + }, + preFilter: { + 'ATTR': function (match) { + match[1] = match[1].replace(runescape, funescape); + match[3] = (match[4] || match[5] || '').replace(runescape, funescape); + if (match[2] === '~=') { + match[3] = ' ' + match[3] + ' '; + } + return match.slice(0, 4); + }, + 'CHILD': function (match) { + match[1] = match[1].toLowerCase(); + if (match[1].slice(0, 3) === 'nth') { + if (!match[3]) { + Sizzle.error(match[0]); + } + match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === 'even' || match[3] === 'odd')); + match[5] = +(match[7] + match[8] || match[3] === 'odd'); + } else if (match[3]) { + Sizzle.error(match[0]); + } + return match; + }, + 'PSEUDO': function (match) { + var excess, unquoted = !match[5] && match[2]; + if (matchExpr['CHILD'].test(match[0])) { + return null; + } + if (match[3] && match[4] !== undefined) { + match[2] = match[4]; + } else if (unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(')', unquoted.length - excess) - unquoted.length)) { + match[0] = match[0].slice(0, excess); + match[2] = unquoted.slice(0, excess); + } + return match.slice(0, 3); + } + }, + filter: { + 'TAG': function (nodeNameSelector) { + var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase(); + return nodeNameSelector === '*' ? function () { + return true; + } : function (elem) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + 'CLASS': function (className) { + var pattern = classCache[className + ' ']; + return pattern || (pattern = new RegExp('(^|' + whitespace + ')' + className + '(' + whitespace + '|$)')) && classCache(className, function (elem) { + return pattern.test(typeof elem.className === 'string' && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute('class') || ''); + }); + }, + 'ATTR': function (name, operator, check) { + return function (elem) { + var result = Sizzle.attr(elem, name); + if (result == null) { + return operator === '!='; + } + if (!operator) { + return true; + } + result += ''; + return operator === '=' ? result === check : operator === '!=' ? result !== check : operator === '^=' ? check && result.indexOf(check) === 0 : 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 + '-' : false; + }; + }, + 'CHILD': function (type, what, argument, first, last) { + var simple = type.slice(0, 3) !== 'nth', forward = type.slice(-4) !== 'last', ofType = what === 'of-type'; + return first === 1 && last === 0 ? 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) { + while (dir) { + node = elem; + while (node = node[dir]) { + if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) { + return false; + } + } + start = dir = type === 'only' && !start && 'nextSibling'; + } + return true; + } + start = [forward ? parent.firstChild : parent.lastChild]; + if (forward && useCache) { + outerCache = parent[expando] || (parent[expando] = {}); + cache = outerCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = cache[0] === dirruns && cache[2]; + node = nodeIndex && parent.childNodes[nodeIndex]; + while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) { + if (node.nodeType === 1 && ++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 { + while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) { + if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) { + if (useCache) { + (node[expando] || (node[expando] = {}))[type] = [ + dirruns, + diff + ]; + } + if (node === elem) { + break; + } + } + } + } + diff -= last; + return diff === 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); + if (fn[expando]) { + return fn(argument); + } + if (fn.length > 1) { + args = [ + pseudo, + pseudo, + '', + argument + ]; + return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) { + var idx, matched = fn(seed, argument), i = matched.length; + while (i--) { + idx = indexOf.call(seed, matched[i]); + seed[idx] = !(matches[idx] = matched[i]); + } + }) : function (elem) { + return fn(elem, 0, args); + }; + } + return fn; + } + }, + pseudos: { + 'not': markFunction(function (selector) { + var input = [], results = [], matcher = compile(selector.replace(rtrim, '$1')); + return matcher[expando] ? markFunction(function (seed, matches, context, xml) { + var elem, unmatched = matcher(seed, null, xml, []), i = seed.length; + while (i--) { + if (elem = unmatched[i]) { + seed[i] = !(matches[i] = elem); + } + } + }) : function (elem, context, xml) { + input[0] = elem; + matcher(input, null, xml, results); + return !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) { + if (!ridentifier.test(lang || '')) { + Sizzle.error('unsupported lang: ' + lang); + } + lang = lang.replace(runescape, funescape).toLowerCase(); + return function (elem) { + var elemLang; + do { + if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute('xml:lang') || elem.getAttribute('lang')) { + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf(lang + '-') === 0; + } + } while ((elem = elem.parentNode) && elem.nodeType === 1); + return false; + }; + }), + '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 elem.disabled === false; + }, + 'disabled': function (elem) { + return elem.disabled === true; + }, + 'checked': function (elem) { + var nodeName = elem.nodeName.toLowerCase(); + return nodeName === 'input' && !!elem.checked || nodeName === 'option' && !!elem.selected; + }, + 'selected': function (elem) { + if (elem.parentNode) { + elem.parentNode.selectedIndex; + } + return elem.selected === true; + }, + 'empty': function (elem) { + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + if (elem.nodeType < 6) { + return false; + } + } + return true; + }, + '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 name === 'input' && elem.type === 'button' || name === 'button'; + }, + 'text': function (elem) { + var attr; + return elem.nodeName.toLowerCase() === 'input' && elem.type === 'text' && ((attr = elem.getAttribute('type')) == null || attr.toLowerCase() === 'text'); + }, + '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) { + var i = 0; + for (; i < length; i += 2) { + matchIndexes.push(i); + } + return matchIndexes; + }), + 'odd': createPositionalPseudo(function (matchIndexes, length) { + var i = 1; + for (; i < length; i += 2) { + matchIndexes.push(i); + } + return matchIndexes; + }), + 'lt': createPositionalPseudo(function (matchIndexes, length, argument) { + var i = argument < 0 ? argument + length : argument; + for (; --i >= 0;) { + matchIndexes.push(i); + } + return matchIndexes; + }), + 'gt': createPositionalPseudo(function (matchIndexes, length, argument) { + var i = argument < 0 ? argument + length : argument; + for (; ++i < length;) { + matchIndexes.push(i); + } + return matchIndexes; + }) + } + }; + Expr.pseudos['nth'] = Expr.pseudos['eq']; + for (i in { + radio: true, + checkbox: true, + file: true, + password: true, + image: true + }) { + Expr.pseudos[i] = createInputPseudo(i); + } + for (i in { + submit: true, + reset: true + }) { + Expr.pseudos[i] = createButtonPseudo(i); + } + function setFilters() { + } + setFilters.prototype = Expr.filters = Expr.pseudos; + Expr.setFilters = new setFilters(); + function tokenize(selector, parseOnly) { + var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + ' ']; + if (cached) { + return parseOnly ? 0 : cached.slice(0); + } + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + while (soFar) { + if (!matched || (match = rcomma.exec(soFar))) { + if (match) { + soFar = soFar.slice(match[0].length) || soFar; + } + groups.push(tokens = []); + } + matched = false; + if (match = rcombinators.exec(soFar)) { + matched = match.shift(); + tokens.push({ + value: matched, + type: match[0].replace(rtrim, ' ') + }); + soFar = soFar.slice(matched.length); + } + for (type in Expr.filter) { + if ((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) { + var i = 0, len = tokens.length, selector = ''; + for (; i < len; i++) { + selector += tokens[i].value; + } + return selector; + } + function addCombinator(matcher, combinator, base) { + var dir = combinator.dir, checkNonElements = base && dir === 'parentNode', doneName = done++; + return combinator.first ? function (elem, context, xml) { + while (elem = elem[dir]) { + if (elem.nodeType === 1 || checkNonElements) { + return matcher(elem, context, xml); + } + } + } : function (elem, context, xml) { + var oldCache, outerCache, newCache = [ + dirruns, + doneName + ]; + if (xml) { + while (elem = elem[dir]) { + if (elem.nodeType === 1 || checkNonElements) { + if (matcher(elem, context, xml)) { + return true; + } + } + } + } else { + while (elem = elem[dir]) { + if (elem.nodeType === 1 || checkNonElements) { + outerCache = elem[expando] || (elem[expando] = {}); + if ((oldCache = outerCache[dir]) && oldCache[0] === dirruns && oldCache[1] === doneName) { + return newCache[2] = oldCache[2]; + } else { + outerCache[dir] = newCache; + if (newCache[2] = matcher(elem, context, xml)) { + return true; + } + } + } + } + } + }; + } + function elementMatcher(matchers) { + return matchers.length > 1 ? function (elem, context, xml) { + var i = matchers.length; + while (i--) { + if (!matchers[i](elem, context, xml)) { + return false; + } + } + return true; + } : matchers[0]; + } + function condense(unmatched, map, filter, context, xml) { + var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; + for (; i < len; i++) { + if (elem = unmatched[i]) { + if (!filter || filter(elem, context, xml)) { + newUnmatched.push(elem); + if (mapped) { + map.push(i); + } + } + } + } + return newUnmatched; + } + function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) { + if (postFilter && !postFilter[expando]) { + postFilter = setMatcher(postFilter); + } + if (postFinder && !postFinder[expando]) { + postFinder = setMatcher(postFinder, postSelector); + } + return markFunction(function (seed, results, context, xml) { + var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts(selector || '*', context.nodeType ? [context] : context, []), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, matcherOut = matcher ? postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results : matcherIn; + if (matcher) { + matcher(matcherIn, matcherOut, context, xml); + } + if (postFilter) { + temp = condense(matcherOut, postMap); + postFilter(temp, [], context, xml); + i = temp.length; + while (i--) { + if (elem = temp[i]) { + matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem); + } + } + } + if (seed) { + if (postFinder || preFilter) { + if (postFinder) { + temp = []; + i = matcherOut.length; + while (i--) { + if (elem = matcherOut[i]) { + temp.push(matcherIn[i] = elem); + } + } + postFinder(null, matcherOut = [], temp, xml); + } + i = matcherOut.length; + while (i--) { + if ((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); + if (postFinder) { + postFinder(null, results, matcherOut, xml); + } else { + push.apply(results, matcherOut); + } + } + }); + } + function matcherFromTokens(tokens) { + 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, true), matchAnyContext = addCombinator(function (elem) { + return indexOf.call(checkContext, elem) > -1; + }, implicitRelative, true), matchers = [function (elem, context, xml) { + return !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)); + }]; + for (; i < len; i++) { + if (matcher = Expr.relative[tokens[i].type]) { + matchers = [addCombinator(elementMatcher(matchers), matcher)]; + } else { + matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); + if (matcher[expando]) { + j = ++i; + for (; j < len; j++) { + if (Expr.relative[tokens[j].type]) { + break; + } + } + return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === ' ' ? '*' : '' })).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 matcherFromGroupMatchers(elementMatchers, setMatchers) { + var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function (seed, context, xml, results, outermost) { + var elem, j, matcher, matchedCount = 0, i = '0', unmatched = seed && [], setMatched = [], contextBackup = outermostContext, elems = seed || byElement && Expr.find['TAG']('*', outermost), dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1, len = elems.length; + if (outermost) { + outermostContext = context !== document && context; + } + for (; i !== len && (elem = elems[i]) != null; i++) { + if (byElement && elem) { + j = 0; + while (matcher = elementMatchers[j++]) { + if (matcher(elem, context, xml)) { + results.push(elem); + break; + } + } + if (outermost) { + dirruns = dirrunsUnique; + } + } + if (bySet) { + if (elem = !matcher && elem) { + matchedCount--; + } + if (seed) { + unmatched.push(elem); + } + } + } + matchedCount += i; + if (bySet && i !== matchedCount) { + j = 0; + while (matcher = setMatchers[j++]) { + matcher(unmatched, setMatched, context, xml); + } + if (seed) { + if (matchedCount > 0) { + while (i--) { + if (!(unmatched[i] || setMatched[i])) { + setMatched[i] = pop.call(results); + } + } + } + setMatched = condense(setMatched); + } + push.apply(results, setMatched); + if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) { + Sizzle.uniqueSort(results); + } + } + if (outermost) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + return unmatched; + }; + return bySet ? markFunction(superMatcher) : superMatcher; + } + compile = Sizzle.compile = function (selector, group) { + var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + ' ']; + if (!cached) { + if (!group) { + group = tokenize(selector); + } + i = group.length; + while (i--) { + cached = matcherFromTokens(group[i]); + if (cached[expando]) { + setMatchers.push(cached); + } else { + elementMatchers.push(cached); + } + } + cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); + } + return cached; + }; + function multipleContexts(selector, contexts, results) { + var i = 0, len = contexts.length; + for (; i < len; i++) { + Sizzle(selector, contexts[i], results); + } + return results; + } + function select(selector, context, results, seed) { + var i, tokens, token, type, find, match = tokenize(selector); + if (!seed) { + if (match.length === 1) { + tokens = match[0] = match[0].slice(0); + if (tokens.length > 2 && (token = tokens[0]).type === 'ID' && support.getById && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) { + context = (Expr.find['ID'](token.matches[0].replace(runescape, funescape), context) || [])[0]; + if (!context) { + return results; + } + selector = selector.slice(tokens.shift().value.length); + } + i = matchExpr['needsContext'].test(selector) ? 0 : tokens.length; + while (i--) { + token = tokens[i]; + if (Expr.relative[type = token.type]) { + break; + } + if (find = Expr.find[type]) { + if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) { + tokens.splice(i, 1); + selector = seed.length && toSelector(tokens); + if (!selector) { + push.apply(results, seed); + return results; + } + break; + } + } + } + } + } + compile(selector, match)(seed, context, !documentIsHTML, results, rsibling.test(selector) && testContext(context.parentNode) || context); + return results; + } + support.sortStable = expando.split('').sort(sortOrder).join('') === expando; + support.detectDuplicates = !!hasDuplicate; + setDocument(); + support.sortDetached = assert(function (div1) { + return div1.compareDocumentPosition(document.createElement('div')) & 1; + }); + if (!assert(function (div) { + div.innerHTML = ''; + return div.firstChild.getAttribute('href') === '#'; + })) { + addHandle('type|href|height|width', function (elem, name, isXML) { + if (!isXML) { + return elem.getAttribute(name, name.toLowerCase() === 'type' ? 1 : 2); + } + }); + } + if (!support.attributes || !assert(function (div) { + div.innerHTML = ''; + div.firstChild.setAttribute('value', ''); + return div.firstChild.getAttribute('value') === ''; + })) { + addHandle('value', function (elem, name, isXML) { + if (!isXML && elem.nodeName.toLowerCase() === 'input') { + return elem.defaultValue; + } + }); + } + if (!assert(function (div) { + return div.getAttribute('disabled') == null; + })) { + addHandle(booleans, function (elem, name, isXML) { + var val; + if (!isXML) { + return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; + } + }); + } + return Sizzle; + }(window); + 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; + var rneedsContext = jQuery.expr.match.needsContext; + var rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/; + var risSimple = /^.[^:#\[\.,]*$/; + function winnow(elements, qualifier, not) { + if (jQuery.isFunction(qualifier)) { + return jQuery.grep(elements, function (elem, i) { + return !!qualifier.call(elem, i, elem) !== not; + }); + } + if (qualifier.nodeType) { + return jQuery.grep(elements, function (elem) { + return elem === qualifier !== not; + }); + } + if (typeof qualifier === 'string') { + if (risSimple.test(qualifier)) { + return jQuery.filter(qualifier, elements, not); + } + qualifier = jQuery.filter(qualifier, elements); + } + return jQuery.grep(elements, function (elem) { + return jQuery.inArray(elem, qualifier) >= 0 !== not; + }); + } + jQuery.filter = function (expr, elems, not) { + var elem = elems[0]; + if (not) { + expr = ':not(' + expr + ')'; + } + return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function (elem) { + return elem.nodeType === 1; + })); + }; + jQuery.fn.extend({ + find: function (selector) { + var i, ret = [], self = this, len = self.length; + if (typeof selector !== 'string') { + return this.pushStack(jQuery(selector).filter(function () { + for (i = 0; i < len; i++) { + if (jQuery.contains(self[i], this)) { + return true; + } + } + })); + } + for (i = 0; i < len; i++) { + jQuery.find(selector, self[i], ret); + } + ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret); + ret.selector = this.selector ? this.selector + ' ' + selector : selector; + return ret; + }, + filter: function (selector) { + return this.pushStack(winnow(this, selector || [], false)); + }, + not: function (selector) { + return this.pushStack(winnow(this, selector || [], true)); + }, + is: function (selector) { + return !!winnow(this, typeof selector === 'string' && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length; + } + }); + var rootjQuery, document = window.document, rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, init = jQuery.fn.init = function (selector, context) { + var match, elem; + if (!selector) { + return this; + } + if (typeof selector === 'string') { + if (selector.charAt(0) === '<' && selector.charAt(selector.length - 1) === '>' && selector.length >= 3) { + match = [ + null, + selector, + null + ]; + } else { + match = rquickExpr.exec(selector); + } + if (match && (match[1] || !context)) { + if (match[1]) { + context = context instanceof jQuery ? context[0] : context; + jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)); + if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) { + for (match in context) { + if (jQuery.isFunction(this[match])) { + this[match](context[match]); + } else { + this.attr(match, context[match]); + } + } + } + return this; + } else { + elem = document.getElementById(match[2]); + if (elem && elem.parentNode) { + if (elem.id !== match[2]) { + return rootjQuery.find(selector); + } + this.length = 1; + this[0] = elem; + } + this.context = document; + this.selector = selector; + return this; + } + } else if (!context || context.jquery) { + return (context || rootjQuery).find(selector); + } else { + return this.constructor(context).find(selector); + } + } else if (selector.nodeType) { + this.context = this[0] = selector; + this.length = 1; + return this; + } else if (jQuery.isFunction(selector)) { + return typeof rootjQuery.ready !== 'undefined' ? rootjQuery.ready(selector) : selector(jQuery); + } + if (selector.selector !== undefined) { + this.selector = selector.selector; + this.context = selector.context; + } + return jQuery.makeArray(selector, this); + }; + init.prototype = jQuery.fn; + rootjQuery = jQuery(document); + var rparentsprev = /^(?:parents|prev(?:Until|All))/, guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + jQuery.extend({ + dir: function (elem, dir, until) { + var matched = [], cur = elem[dir]; + while (cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery(cur).is(until))) { + if (cur.nodeType === 1) { + matched.push(cur); + } + cur = cur[dir]; + } + return matched; + }, + sibling: function (n, elem) { + var r = []; + for (; n; n = n.nextSibling) { + if (n.nodeType === 1 && n !== elem) { + r.push(n); + } + } + return r; + } + }); + jQuery.fn.extend({ + 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 true; + } + } + }); + }, + closest: function (selectors, context) { + var cur, i = 0, l = this.length, matched = [], pos = rneedsContext.test(selectors) || typeof selectors !== 'string' ? jQuery(selectors, context || this.context) : 0; + for (; i < l; i++) { + for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) { + if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 : cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) { + matched.push(cur); + break; + } + } + } + return this.pushStack(matched.length > 1 ? jQuery.unique(matched) : matched); + }, + index: function (elem) { + if (!elem) { + return this[0] && this[0].parentNode ? this.first().prevAll().length : -1; + } + if (typeof elem === 'string') { + return jQuery.inArray(this[0], jQuery(elem)); + } + return jQuery.inArray(elem.jquery ? elem[0] : elem, this); + }, + add: function (selector, context) { + return this.pushStack(jQuery.unique(jQuery.merge(this.get(), jQuery(selector, context)))); + }, + addBack: function (selector) { + return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector)); + } + }); + function sibling(cur, dir) { + do { + cur = cur[dir]; + } while (cur && cur.nodeType !== 1); + return cur; + } + jQuery.each({ + parent: function (elem) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? 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); + if (name.slice(-5) !== 'Until') { + selector = until; + } + if (selector && typeof selector === 'string') { + ret = jQuery.filter(selector, ret); + } + if (this.length > 1) { + if (!guaranteedUnique[name]) { + ret = jQuery.unique(ret); + } + if (rparentsprev.test(name)) { + ret = ret.reverse(); + } + } + return this.pushStack(ret); + }; + }); + var rnotwhite = /\S+/g; + var optionsCache = {}; + function createOptions(options) { + var object = optionsCache[options] = {}; + jQuery.each(options.match(rnotwhite) || [], function (_, flag) { + object[flag] = true; + }); + return object; + } + jQuery.Callbacks = function (options) { + options = typeof options === 'string' ? optionsCache[options] || createOptions(options) : jQuery.extend({}, options); + var firing, memory, fired, firingLength, firingIndex, firingStart, list = [], stack = !options.once && [], fire = function (data) { + memory = options.memory && data; + fired = true; + firingIndex = firingStart || 0; + firingStart = 0; + firingLength = list.length; + firing = true; + for (; list && firingIndex < firingLength; firingIndex++) { + if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) { + memory = false; + break; + } + } + firing = false; + if (list) { + if (stack) { + if (stack.length) { + fire(stack.shift()); + } + } else if (memory) { + list = []; + } else { + self.disable(); + } + } + }, self = { + add: function () { + if (list) { + var start = list.length; + (function add(args) { + jQuery.each(args, function (_, arg) { + var type = jQuery.type(arg); + if (type === 'function') { + if (!options.unique || !self.has(arg)) { + list.push(arg); + } + } else if (arg && arg.length && type !== 'string') { + add(arg); + } + }); + }(arguments)); + if (firing) { + firingLength = list.length; + } else if (memory) { + firingStart = start; + fire(memory); + } + } + return this; + }, + remove: function () { + if (list) { + jQuery.each(arguments, function (_, arg) { + var index; + while ((index = jQuery.inArray(arg, list, index)) > -1) { + list.splice(index, 1); + if (firing) { + if (index <= firingLength) { + firingLength--; + } + if (index <= firingIndex) { + firingIndex--; + } + } + } + }); + } + return this; + }, + has: function (fn) { + return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length); + }, + empty: function () { + list = []; + firingLength = 0; + return this; + }, + disable: function () { + list = stack = memory = undefined; + return this; + }, + disabled: function () { + return !list; + }, + lock: function () { + stack = undefined; + if (!memory) { + self.disable(); + } + return this; + }, + locked: function () { + return !stack; + }, + fireWith: function (context, args) { + if (list && (!fired || stack)) { + args = args || []; + args = [ + context, + args.slice ? args.slice() : args + ]; + if (firing) { + stack.push(args); + } else { + fire(args); + } + } + return this; + }, + fire: function () { + self.fireWith(this, arguments); + return 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 () { + deferred.done(arguments).fail(arguments); + return this; + }, + then: function () { + var fns = arguments; + return jQuery.Deferred(function (newDefer) { + jQuery.each(tuples, function (i, tuple) { + var fn = jQuery.isFunction(fns[i]) && fns[i]; + deferred[tuple[1]](function () { + var returned = fn && fn.apply(this, arguments); + if (returned && jQuery.isFunction(returned.promise)) { + returned.promise().done(newDefer.resolve).fail(newDefer.reject).progress(newDefer.notify); + } else { + newDefer[tuple[0] + 'With'](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments); + } + }); + }); + fns = null; + }).promise(); + }, + promise: function (obj) { + return obj != null ? jQuery.extend(obj, promise) : promise; + } + }, deferred = {}; + promise.pipe = promise.then; + jQuery.each(tuples, function (i, tuple) { + var list = tuple[2], stateString = tuple[3]; + promise[tuple[1]] = list.add; + if (stateString) { + list.add(function () { + state = stateString; + }, tuples[i ^ 1][2].disable, tuples[2][2].lock); + } + deferred[tuple[0]] = function () { + deferred[tuple[0] + 'With'](this === deferred ? promise : this, arguments); + return this; + }; + deferred[tuple[0] + 'With'] = list.fireWith; + }); + promise.promise(deferred); + if (func) { + func.call(deferred, deferred); + } + return deferred; + }, + when: function (subordinate) { + var i = 0, resolveValues = slice.call(arguments), length = resolveValues.length, remaining = length !== 1 || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0, deferred = remaining === 1 ? subordinate : jQuery.Deferred(), updateFunc = function (i, contexts, values) { + return function (value) { + contexts[i] = this; + values[i] = arguments.length > 1 ? slice.call(arguments) : value; + if (values === progressValues) { + deferred.notifyWith(contexts, values); + } else if (!--remaining) { + deferred.resolveWith(contexts, values); + } + }; + }, progressValues, progressContexts, resolveContexts; + if (length > 1) { + progressValues = new Array(length); + progressContexts = new Array(length); + resolveContexts = new Array(length); + for (; i < length; i++) { + if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) { + resolveValues[i].promise().done(updateFunc(i, resolveContexts, resolveValues)).fail(deferred.reject).progress(updateFunc(i, progressContexts, progressValues)); + } else { + --remaining; + } + } + } + if (!remaining) { + deferred.resolveWith(resolveContexts, resolveValues); + } + return deferred.promise(); + } + }); + var readyList; + jQuery.fn.ready = function (fn) { + jQuery.ready.promise().done(fn); + return this; + }; + jQuery.extend({ + isReady: false, + readyWait: 1, + holdReady: function (hold) { + if (hold) { + jQuery.readyWait++; + } else { + jQuery.ready(true); + } + }, + ready: function (wait) { + if (wait === true ? --jQuery.readyWait : jQuery.isReady) { + return; + } + if (!document.body) { + return setTimeout(jQuery.ready); + } + jQuery.isReady = true; + if (wait !== true && --jQuery.readyWait > 0) { + return; + } + readyList.resolveWith(document, [jQuery]); + if (jQuery.fn.trigger) { + jQuery(document).trigger('ready').off('ready'); + } + } + }); + function detach() { + if (document.addEventListener) { + document.removeEventListener('DOMContentLoaded', completed, false); + window.removeEventListener('load', completed, false); + } else { + document.detachEvent('onreadystatechange', completed); + window.detachEvent('onload', completed); + } + } + function completed() { + if (document.addEventListener || event.type === 'load' || document.readyState === 'complete') { + detach(); + jQuery.ready(); + } + } + jQuery.ready.promise = function (obj) { + if (!readyList) { + readyList = jQuery.Deferred(); + if (document.readyState === 'complete') { + setTimeout(jQuery.ready); + } else if (document.addEventListener) { + document.addEventListener('DOMContentLoaded', completed, false); + window.addEventListener('load', completed, false); + } else { + document.attachEvent('onreadystatechange', completed); + window.attachEvent('onload', completed); + var top = false; + try { + top = window.frameElement == null && document.documentElement; + } catch (e) { + } + if (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); + }; + var strundefined = typeof undefined; + var i; + for (i in jQuery(support)) { + break; + } + support.ownLast = i !== '0'; + support.inlineBlockNeedsLayout = false; + jQuery(function () { + var container, div, body = document.getElementsByTagName('body')[0]; + if (!body) { + return; + } + container = document.createElement('div'); + container.style.cssText = 'border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px'; + div = document.createElement('div'); + body.appendChild(container).appendChild(div); + if (typeof div.style.zoom !== strundefined) { + div.style.cssText = 'border:0;margin:0;width:1px;padding:1px;display:inline;zoom:1'; + if (support.inlineBlockNeedsLayout = div.offsetWidth === 3) { + body.style.zoom = 1; + } + } + body.removeChild(container); + container = div = null; + }); + (function () { + var div = document.createElement('div'); + if (support.deleteExpando == null) { + support.deleteExpando = true; + try { + delete div.test; + } catch (e) { + support.deleteExpando = false; + } + } + div = null; + }()); + jQuery.acceptData = function (elem) { + var noData = jQuery.noData[(elem.nodeName + ' ').toLowerCase()], nodeType = +elem.nodeType || 1; + return nodeType !== 1 && nodeType !== 9 ? false : !noData || noData !== true && elem.getAttribute('classid') === noData; + }; + var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /([A-Z])/g; + function dataAttr(elem, key, data) { + if (data === undefined && elem.nodeType === 1) { + var name = 'data-' + key.replace(rmultiDash, '-$1').toLowerCase(); + data = elem.getAttribute(name); + if (typeof data === 'string') { + try { + data = data === 'true' ? true : data === 'false' ? false : data === 'null' ? 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 (name === 'data' && jQuery.isEmptyObject(obj[name])) { + continue; + } + if (name !== 'toJSON') { + return false; + } + } + return true; + } + function internalData(elem, name, data, pvt) { + if (!jQuery.acceptData(elem)) { + return; + } + var ret, thisCache, internalKey = jQuery.expando, isNode = elem.nodeType, cache = isNode ? jQuery.cache : elem, id = isNode ? elem[internalKey] : elem[internalKey] && internalKey; + if ((!id || !cache[id] || !pvt && !cache[id].data) && data === undefined && typeof name === 'string') { + return; + } + if (!id) { + if (isNode) { + id = elem[internalKey] = deletedIds.pop() || jQuery.guid++; + } else { + id = internalKey; + } + } + if (!cache[id]) { + cache[id] = isNode ? {} : { toJSON: jQuery.noop }; + } + if (typeof name === 'object' || typeof name === 'function') { + if (pvt) { + cache[id] = jQuery.extend(cache[id], name); + } else { + cache[id].data = jQuery.extend(cache[id].data, name); + } + } + thisCache = cache[id]; + if (!pvt) { + if (!thisCache.data) { + thisCache.data = {}; + } + thisCache = thisCache.data; + } + if (data !== undefined) { + thisCache[jQuery.camelCase(name)] = data; + } + if (typeof name === 'string') { + ret = thisCache[name]; + if (ret == null) { + ret = thisCache[jQuery.camelCase(name)]; + } + } else { + ret = thisCache; + } + return ret; + } + function internalRemoveData(elem, name, pvt) { + if (!jQuery.acceptData(elem)) { + return; + } + var thisCache, i, isNode = elem.nodeType, cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : jQuery.expando; + if (!cache[id]) { + return; + } + if (name) { + thisCache = pvt ? cache[id] : cache[id].data; + if (thisCache) { + if (!jQuery.isArray(name)) { + if (name in thisCache) { + name = [name]; + } else { + name = jQuery.camelCase(name); + if (name in thisCache) { + name = [name]; + } else { + name = name.split(' '); + } + } + } else { + name = name.concat(jQuery.map(name, jQuery.camelCase)); + } + i = name.length; + while (i--) { + delete thisCache[name[i]]; + } + if (pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache)) { + return; + } + } + } + if (!pvt) { + delete cache[id].data; + if (!isEmptyDataObject(cache[id])) { + return; + } + } + if (isNode) { + jQuery.cleanData([elem], true); + } else if (support.deleteExpando || cache != cache.window) { + delete cache[id]; + } else { + cache[id] = null; + } + } + jQuery.extend({ + cache: {}, + noData: { + 'applet ': true, + 'embed ': true, + 'object ': 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000' + }, + hasData: function (elem) { + elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando]; + return !!elem && !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, true); + }, + _removeData: function (elem, name) { + return internalRemoveData(elem, name, true); + } + }); + jQuery.fn.extend({ + data: function (key, value) { + var i, name, data, elem = this[0], attrs = elem && elem.attributes; + if (key === undefined) { + if (this.length) { + data = jQuery.data(elem); + if (elem.nodeType === 1 && !jQuery._data(elem, 'parsedAttrs')) { + i = attrs.length; + while (i--) { + name = attrs[i].name; + if (name.indexOf('data-') === 0) { + name = jQuery.camelCase(name.slice(5)); + dataAttr(elem, name, data[name]); + } + } + jQuery._data(elem, 'parsedAttrs', true); + } + } + return data; + } + if (typeof key === 'object') { + return this.each(function () { + jQuery.data(this, key); + }); + } + return arguments.length > 1 ? this.each(function () { + jQuery.data(this, key, value); + }) : elem ? dataAttr(elem, key, jQuery.data(elem, key)) : undefined; + }, + removeData: function (key) { + return this.each(function () { + jQuery.removeData(this, key); + }); + } + }); + jQuery.extend({ + queue: function (elem, type, data) { + var queue; + if (elem) { + type = (type || 'fx') + 'queue'; + queue = jQuery._data(elem, type); + if (data) { + if (!queue || jQuery.isArray(data)) { + queue = jQuery._data(elem, type, jQuery.makeArray(data)); + } else { + queue.push(data); + } + } + return 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), next = function () { + jQuery.dequeue(elem, type); + }; + if (fn === 'inprogress') { + fn = queue.shift(); + startLength--; + } + if (fn) { + if (type === 'fx') { + queue.unshift('inprogress'); + } + delete hooks.stop; + fn.call(elem, next, hooks); + } + if (!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; + if (typeof type !== 'string') { + data = type; + type = 'fx'; + setter--; + } + if (arguments.length < setter) { + return jQuery.queue(this[0], type); + } + return data === undefined ? this : this.each(function () { + var queue = jQuery.queue(this, type, data); + jQuery._queueHooks(this, type); + if (type === 'fx' && queue[0] !== 'inprogress') { + jQuery.dequeue(this, type); + } + }); + }, + dequeue: function (type) { + return this.each(function () { + jQuery.dequeue(this, type); + }); + }, + 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 () { + if (!--count) { + defer.resolveWith(elements, [elements]); + } + }; + if (typeof type !== 'string') { + obj = type; + type = undefined; + } + type = type || 'fx'; + while (i--) { + tmp = jQuery._data(elements[i], type + 'queueHooks'); + if (tmp && tmp.empty) { + count++; + tmp.empty.add(resolve); + } + } + resolve(); + return defer.promise(obj); + } + }); + var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source; + var cssExpand = [ + 'Top', + 'Right', + 'Bottom', + 'Left' + ]; + var isHidden = function (elem, el) { + elem = el || elem; + return jQuery.css(elem, 'display') === 'none' || !jQuery.contains(elem.ownerDocument, elem); + }; + var access = jQuery.access = function (elems, fn, key, value, chainable, emptyGet, raw) { + var i = 0, length = elems.length, bulk = key == null; + if (jQuery.type(key) === 'object') { + chainable = true; + for (i in key) { + jQuery.access(elems, fn, i, key[i], true, emptyGet, raw); + } + } else if (value !== undefined) { + chainable = true; + if (!jQuery.isFunction(value)) { + raw = true; + } + if (bulk) { + if (raw) { + fn.call(elems, value); + fn = null; + } else { + bulk = fn; + fn = function (elem, key, value) { + return bulk.call(jQuery(elem), value); + }; + } + } + if (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; + }; + var rcheckableType = /^(?:checkbox|radio)$/i; + (function () { + var fragment = document.createDocumentFragment(), div = document.createElement('div'), input = document.createElement('input'); + div.setAttribute('className', 't'); + div.innerHTML = '
a'; + support.leadingWhitespace = div.firstChild.nodeType === 3; + support.tbody = !div.getElementsByTagName('tbody').length; + support.htmlSerialize = !!div.getElementsByTagName('link').length; + support.html5Clone = document.createElement('nav').cloneNode(true).outerHTML !== '<:nav>'; + input.type = 'checkbox'; + input.checked = true; + fragment.appendChild(input); + support.appendChecked = input.checked; + div.innerHTML = ''; + support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; + fragment.appendChild(div); + div.innerHTML = ''; + support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; + support.noCloneEvent = true; + if (div.attachEvent) { + div.attachEvent('onclick', function () { + support.noCloneEvent = false; + }); + div.cloneNode(true).click(); + } + if (support.deleteExpando == null) { + support.deleteExpando = true; + try { + delete div.test; + } catch (e) { + support.deleteExpando = false; + } + } + fragment = div = input = null; + }()); + (function () { + var i, eventName, div = document.createElement('div'); + for (i in { + submit: true, + change: true, + focusin: true + }) { + eventName = 'on' + i; + if (!(support[i + 'Bubbles'] = eventName in window)) { + div.setAttribute(eventName, 't'); + support[i + 'Bubbles'] = div.attributes[eventName].expando === false; + } + } + div = null; + }()); + var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|contextmenu)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)$/; + function returnTrue() { + return true; + } + function returnFalse() { + return false; + } + function safeActiveElement() { + try { + return document.activeElement; + } catch (err) { + } + } + 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) { + return; + } + if (handler.handler) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + if (!handler.guid) { + handler.guid = jQuery.guid++; + } + if (!(events = elemData.events)) { + events = elemData.events = {}; + } + if (!(eventHandle = elemData.handle)) { + eventHandle = elemData.handle = function (e) { + return typeof jQuery !== strundefined && (!e || jQuery.event.triggered !== e.type) ? jQuery.event.dispatch.apply(eventHandle.elem, arguments) : undefined; + }; + eventHandle.elem = elem; + } + types = (types || '').match(rnotwhite) || ['']; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || '').split('.').sort(); + if (!type) { + continue; + } + 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); + if (!(handlers = events[type])) { + handlers = events[type] = []; + handlers.delegateCount = 0; + if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) { + if (elem.addEventListener) { + elem.addEventListener(type, eventHandle, false); + } else if (elem.attachEvent) { + elem.attachEvent('on' + type, eventHandle); + } + } + } + if (special.add) { + special.add.call(elem, handleObj); + if (!handleObj.handler.guid) { + handleObj.handler.guid = handler.guid; + } + } + if (selector) { + handlers.splice(handlers.delegateCount++, 0, handleObj); + } else { + handlers.push(handleObj); + } + jQuery.event.global[type] = true; + } + 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)) { + return; + } + types = (types || '').match(rnotwhite) || ['']; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || '').split('.').sort(); + if (!type) { + for (type in events) { + jQuery.event.remove(elem, type + types[t], handler, selector, true); + } + continue; + } + special = jQuery.event.special[type] || {}; + type = (selector ? special.delegateType : special.bindType) || type; + handlers = events[type] || []; + tmp = tmp[2] && new RegExp('(^|\\.)' + namespaces.join('\\.(?:.*\\.|)') + '(\\.|$)'); + origCount = j = handlers.length; + while (j--) { + handleObj = handlers[j]; + if ((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); + if (handleObj.selector) { + handlers.delegateCount--; + } + if (special.remove) { + special.remove.call(elem, handleObj); + } + } + } + if (origCount && !handlers.length) { + if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) { + jQuery.removeEvent(elem, type, elemData.handle); + } + delete events[type]; + } + } + if (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 = hasOwn.call(event, 'type') ? event.type : event, namespaces = hasOwn.call(event, 'namespace') ? event.namespace.split('.') : []; + cur = tmp = elem = elem || document; + if (elem.nodeType === 3 || elem.nodeType === 8) { + return; + } + if (rfocusMorph.test(type + jQuery.event.triggered)) { + return; + } + if (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, typeof event === 'object' && event); + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join('.'); + event.namespace_re = event.namespace ? new RegExp('(^|\\.)' + namespaces.join('\\.(?:.*\\.|)') + '(\\.|$)') : null; + event.result = undefined; + if (!event.target) { + event.target = elem; + } + data = data == null ? [event] : jQuery.makeArray(data, [event]); + special = jQuery.event.special[type] || {}; + if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) { + return; + } + if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) { + bubbleType = special.delegateType || type; + if (!rfocusMorph.test(bubbleType + type)) { + cur = cur.parentNode; + } + for (; cur; cur = cur.parentNode) { + eventPath.push(cur); + tmp = cur; + } + if (tmp === (elem.ownerDocument || document)) { + eventPath.push(tmp.defaultView || tmp.parentWindow || window); + } + } + i = 0; + while ((cur = eventPath[i++]) && !event.isPropagationStopped()) { + event.type = i > 1 ? bubbleType : special.bindType || type; + handle = (jQuery._data(cur, 'events') || {})[event.type] && jQuery._data(cur, 'handle'); + if (handle) { + handle.apply(cur, data); + } + handle = ontype && cur[ontype]; + if (handle && handle.apply && jQuery.acceptData(cur)) { + event.result = handle.apply(cur, data); + if (event.result === false) { + event.preventDefault(); + } + } + } + event.type = type; + if (!onlyHandlers && !event.isDefaultPrevented()) { + if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && jQuery.acceptData(elem)) { + if (ontype && elem[type] && !jQuery.isWindow(elem)) { + tmp = elem[ontype]; + if (tmp) { + elem[ontype] = null; + } + jQuery.event.triggered = type; + try { + elem[type](); + } catch (e) { + } + jQuery.event.triggered = undefined; + if (tmp) { + elem[ontype] = tmp; + } + } + } + } + return event.result; + }, + dispatch: function (event) { + event = jQuery.event.fix(event); + var i, ret, handleObj, matched, j, handlerQueue = [], args = slice.call(arguments), handlers = (jQuery._data(this, 'events') || {})[event.type] || [], special = jQuery.event.special[event.type] || {}; + args[0] = event; + event.delegateTarget = this; + if (special.preDispatch && special.preDispatch.call(this, event) === false) { + return; + } + handlerQueue = jQuery.event.handlers.call(this, event, handlers); + i = 0; + while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) { + event.currentTarget = matched.elem; + j = 0; + while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) { + if (!event.namespace_re || event.namespace_re.test(handleObj.namespace)) { + event.handleObj = handleObj; + event.data = handleObj.data; + ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args); + if (ret !== undefined) { + if ((event.result = ret) === false) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + if (special.postDispatch) { + special.postDispatch.call(this, event); + } + return event.result; + }, + handlers: function (event, handlers) { + var sel, handleObj, matches, i, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; + if (delegateCount && cur.nodeType && (!event.button || event.type !== 'click')) { + for (; cur != this; cur = cur.parentNode || this) { + if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== 'click')) { + matches = []; + for (i = 0; i < delegateCount; i++) { + handleObj = handlers[i]; + sel = handleObj.selector + ' '; + if (matches[sel] === undefined) { + matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) >= 0 : jQuery.find(sel, this, null, [cur]).length; + } + if (matches[sel]) { + matches.push(handleObj); + } + } + if (matches.length) { + handlerQueue.push({ + elem: cur, + handlers: matches + }); + } + } + } + } + if (delegateCount < handlers.length) { + handlerQueue.push({ + elem: this, + handlers: handlers.slice(delegateCount) + }); + } + return handlerQueue; + }, + fix: function (event) { + if (event[jQuery.expando]) { + return event; + } + var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type]; + if (!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; + while (i--) { + prop = copy[i]; + event[prop] = originalEvent[prop]; + } + if (!event.target) { + event.target = originalEvent.srcElement || document; + } + if (event.target.nodeType === 3) { + event.target = event.target.parentNode; + } + event.metaKey = !!event.metaKey; + return 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) { + if (event.which == null) { + event.which = original.charCode != null ? original.charCode : original.keyCode; + } + return 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; + if (event.pageX == null && original.clientX != null) { + eventDoc = event.target.ownerDocument || document; + doc = eventDoc.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); + } + if (!event.relatedTarget && fromElement) { + event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; + } + if (!event.which && button !== undefined) { + event.which = button & 1 ? 1 : button & 2 ? 3 : button & 4 ? 2 : 0; + } + return event; + } + }, + special: { + load: { noBubble: true }, + focus: { + trigger: function () { + if (this !== safeActiveElement() && this.focus) { + try { + this.focus(); + return false; + } catch (e) { + } + } + }, + delegateType: 'focusin' + }, + blur: { + trigger: function () { + if (this === safeActiveElement() && this.blur) { + this.blur(); + return false; + } + }, + delegateType: 'focusout' + }, + click: { + trigger: function () { + if (jQuery.nodeName(this, 'input') && this.type === 'checkbox' && this.click) { + this.click(); + return false; + } + }, + _default: function (event) { + return jQuery.nodeName(event.target, 'a'); + } + }, + beforeunload: { + postDispatch: function (event) { + if (event.result !== undefined) { + event.originalEvent.returnValue = event.result; + } + } + } + }, + simulate: function (type, elem, event, bubble) { + var e = jQuery.extend(new jQuery.Event(), event, { + type: type, + isSimulated: true, + originalEvent: {} + }); + if (bubble) { + jQuery.event.trigger(e, null, elem); + } else { + jQuery.event.dispatch.call(elem, e); + } + if (e.isDefaultPrevented()) { + event.preventDefault(); + } + } + }; + jQuery.removeEvent = document.removeEventListener ? function (elem, type, handle) { + if (elem.removeEventListener) { + elem.removeEventListener(type, handle, false); + } + } : function (elem, type, handle) { + var name = 'on' + type; + if (elem.detachEvent) { + if (typeof elem[name] === strundefined) { + elem[name] = null; + } + elem.detachEvent(name, handle); + } + }; + jQuery.Event = function (src, props) { + if (!(this instanceof jQuery.Event)) { + return new jQuery.Event(src, props); + } + if (src && src.type) { + this.originalEvent = src; + this.type = src.type; + this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && (src.returnValue === false || src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse; + } else { + this.type = src; + } + if (props) { + jQuery.extend(this, props); + } + this.timeStamp = src && src.timeStamp || jQuery.now(); + this[jQuery.expando] = true; + }; + jQuery.Event.prototype = { + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + preventDefault: function () { + var e = this.originalEvent; + this.isDefaultPrevented = returnTrue; + if (!e) { + return; + } + if (e.preventDefault) { + e.preventDefault(); + } else { + e.returnValue = false; + } + }, + stopPropagation: function () { + var e = this.originalEvent; + this.isPropagationStopped = returnTrue; + if (!e) { + return; + } + if (e.stopPropagation) { + e.stopPropagation(); + } + e.cancelBubble = true; + }, + 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; + if (!related || related !== target && !jQuery.contains(target, related)) { + event.type = handleObj.origType; + ret = handleObj.handler.apply(this, arguments); + event.type = fix; + } + return ret; + } + }; + }); + if (!support.submitBubbles) { + jQuery.event.special.submit = { + setup: function () { + if (jQuery.nodeName(this, 'form')) { + return false; + } + 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; + if (form && !jQuery._data(form, 'submitBubbles')) { + jQuery.event.add(form, 'submit._submit', function (event) { + event._submit_bubble = true; + }); + jQuery._data(form, 'submitBubbles', true); + } + }); + }, + postDispatch: function (event) { + if (event._submit_bubble) { + delete event._submit_bubble; + if (this.parentNode && !event.isTrigger) { + jQuery.event.simulate('submit', this.parentNode, event, true); + } + } + }, + teardown: function () { + if (jQuery.nodeName(this, 'form')) { + return false; + } + jQuery.event.remove(this, '._submit'); + } + }; + } + if (!support.changeBubbles) { + jQuery.event.special.change = { + setup: function () { + if (rformElems.test(this.nodeName)) { + if (this.type === 'checkbox' || this.type === 'radio') { + jQuery.event.add(this, 'propertychange._change', function (event) { + if (event.originalEvent.propertyName === 'checked') { + this._just_changed = true; + } + }); + jQuery.event.add(this, 'click._change', function (event) { + if (this._just_changed && !event.isTrigger) { + this._just_changed = false; + } + jQuery.event.simulate('change', this, event, true); + }); + } + return false; + } + jQuery.event.add(this, 'beforeactivate._change', function (e) { + var elem = e.target; + if (rformElems.test(elem.nodeName) && !jQuery._data(elem, 'changeBubbles')) { + jQuery.event.add(elem, 'change._change', function (event) { + if (this.parentNode && !event.isSimulated && !event.isTrigger) { + jQuery.event.simulate('change', this.parentNode, event, true); + } + }); + jQuery._data(elem, 'changeBubbles', true); + } + }); + }, + handle: function (event) { + var elem = event.target; + if (this !== elem || event.isSimulated || event.isTrigger || elem.type !== 'radio' && elem.type !== 'checkbox') { + return event.handleObj.handler.apply(this, arguments); + } + }, + teardown: function () { + jQuery.event.remove(this, '._change'); + return !rformElems.test(this.nodeName); + } + }; + } + if (!support.focusinBubbles) { + jQuery.each({ + focus: 'focusin', + blur: 'focusout' + }, function (orig, fix) { + var handler = function (event) { + jQuery.event.simulate(fix, event.target, jQuery.event.fix(event), true); + }; + jQuery.event.special[fix] = { + setup: function () { + var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix); + if (!attaches) { + doc.addEventListener(orig, handler, true); + } + jQuery._data(doc, fix, (attaches || 0) + 1); + }, + teardown: function () { + var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix) - 1; + if (!attaches) { + doc.removeEventListener(orig, handler, true); + jQuery._removeData(doc, fix); + } else { + jQuery._data(doc, fix, attaches); + } + } + }; + }); + } + jQuery.fn.extend({ + on: function (types, selector, data, fn, one) { + var type, origFn; + if (typeof types === 'object') { + if (typeof selector !== 'string') { + data = data || selector; + selector = undefined; + } + for (type in types) { + this.on(type, selector, data, types[type], one); + } + return this; + } + if (data == null && fn == null) { + fn = selector; + data = selector = undefined; + } else if (fn == null) { + if (typeof selector === 'string') { + fn = data; + data = undefined; + } else { + fn = data; + data = selector; + selector = undefined; + } + } + if (fn === false) { + fn = returnFalse; + } else if (!fn) { + return this; + } + if (one === 1) { + origFn = fn; + fn = function (event) { + jQuery().off(event); + return origFn.apply(this, arguments); + }; + fn.guid = origFn.guid || (origFn.guid = jQuery.guid++); + } + return 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) { + handleObj = types.handleObj; + jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + '.' + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler); + return this; + } + if (typeof types === 'object') { + for (type in types) { + this.off(type, selector, types[type]); + } + return this; + } + if (selector === false || typeof selector === 'function') { + fn = selector; + selector = undefined; + } + if (fn === false) { + fn = returnFalse; + } + return this.each(function () { + jQuery.event.remove(this, types, fn, selector); + }); + }, + 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, true); + } + } + }); + function createSafeFragment(document) { + var list = nodeNames.split('|'), safeFrag = document.createDocumentFragment(); + if (safeFrag.createElement) { + while (list.length) { + safeFrag.createElement(list.pop()); + } + } + return safeFrag; + } + 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 = /\s*$/g, wrapMap = { + option: [ + 1, + '' + ], + legend: [ + 1, + '
', + '
' + ], + area: [ + 1, + '', + '' + ], + param: [ + 1, + '', + '' + ], + thead: [ + 1, + '', + '
' + ], + tr: [ + 2, + '', + '
' + ], + col: [ + 2, + '', + '
' + ], + td: [ + 3, + '', + '
' + ], + _default: support.htmlSerialize ? [ + 0, + '', + '' + ] : [ + 1, + 'X
', + '
' + ] + }, safeFragment = createSafeFragment(document), fragmentDiv = safeFragment.appendChild(document.createElement('div')); + wrapMap.optgroup = wrapMap.option; + wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; + wrapMap.th = wrapMap.td; + function getAll(context, tag) { + var elems, elem, i = 0, found = typeof context.getElementsByTagName !== strundefined ? context.getElementsByTagName(tag || '*') : typeof context.querySelectorAll !== strundefined ? context.querySelectorAll(tag || '*') : undefined; + if (!found) { + for (found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++) { + if (!tag || jQuery.nodeName(elem, tag)) { + found.push(elem); + } else { + jQuery.merge(found, getAll(elem, tag)); + } + } + } + return tag === undefined || tag && jQuery.nodeName(context, tag) ? jQuery.merge([context], found) : found; + } + function fixDefaultChecked(elem) { + if (rcheckableType.test(elem.type)) { + elem.defaultChecked = elem.checked; + } + } + function manipulationTarget(elem, content) { + return jQuery.nodeName(elem, 'table') && jQuery.nodeName(content.nodeType !== 11 ? content : content.firstChild, 'tr') ? elem.getElementsByTagName('tbody')[0] || elem.appendChild(elem.ownerDocument.createElement('tbody')) : elem; + } + function disableScript(elem) { + elem.type = (jQuery.find.attr(elem, 'type') !== null) + '/' + elem.type; + return elem; + } + function restoreScript(elem) { + var match = rscriptTypeMasked.exec(elem.type); + if (match) { + elem.type = match[1]; + } else { + elem.removeAttribute('type'); + } + return elem; + } + function setGlobalEval(elems, refElements) { + var elem, i = 0; + for (; (elem = elems[i]) != null; i++) { + jQuery._data(elem, 'globalEval', !refElements || jQuery._data(refElements[i], 'globalEval')); + } + } + function cloneCopyEvent(src, dest) { + if (dest.nodeType !== 1 || !jQuery.hasData(src)) { + return; + } + var type, i, l, oldData = jQuery._data(src), curData = jQuery._data(dest, oldData), events = oldData.events; + if (events) { + delete curData.handle; + curData.events = {}; + for (type in events) { + for (i = 0, l = events[type].length; i < l; i++) { + jQuery.event.add(dest, type, events[type][i]); + } + } + } + if (curData.data) { + curData.data = jQuery.extend({}, curData.data); + } + } + function fixCloneNodeIssues(src, dest) { + var nodeName, e, data; + if (dest.nodeType !== 1) { + return; + } + nodeName = dest.nodeName.toLowerCase(); + if (!support.noCloneEvent && dest[jQuery.expando]) { + data = jQuery._data(dest); + for (e in data.events) { + jQuery.removeEvent(dest, e, data.handle); + } + dest.removeAttribute(jQuery.expando); + } + if (nodeName === 'script' && dest.text !== src.text) { + disableScript(dest).text = src.text; + restoreScript(dest); + } else if (nodeName === 'object') { + if (dest.parentNode) { + dest.outerHTML = src.outerHTML; + } + if (support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML))) { + dest.innerHTML = src.innerHTML; + } + } else if (nodeName === 'input' && rcheckableType.test(src.type)) { + dest.defaultChecked = dest.checked = src.checked; + if (dest.value !== src.value) { + dest.value = src.value; + } + } else if (nodeName === 'option') { + dest.defaultSelected = dest.selected = src.defaultSelected; + } else if (nodeName === 'input' || nodeName === 'textarea') { + dest.defaultValue = src.defaultValue; + } + } + jQuery.extend({ + clone: function (elem, dataAndEvents, deepDataAndEvents) { + var destElements, node, clone, i, srcElements, inPage = jQuery.contains(elem.ownerDocument, elem); + if (support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test('<' + elem.nodeName + '>')) { + clone = elem.cloneNode(true); + } else { + fragmentDiv.innerHTML = elem.outerHTML; + fragmentDiv.removeChild(clone = fragmentDiv.firstChild); + } + if ((!support.noCloneEvent || !support.noCloneChecked) && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) { + destElements = getAll(clone); + srcElements = getAll(elem); + for (i = 0; (node = srcElements[i]) != null; ++i) { + if (destElements[i]) { + fixCloneNodeIssues(node, destElements[i]); + } + } + } + if (dataAndEvents) { + if (deepDataAndEvents) { + srcElements = srcElements || getAll(elem); + destElements = destElements || getAll(clone); + for (i = 0; (node = srcElements[i]) != null; i++) { + cloneCopyEvent(node, destElements[i]); + } + } else { + cloneCopyEvent(elem, clone); + } + } + destElements = getAll(clone, 'script'); + if (destElements.length > 0) { + setGlobalEval(destElements, !inPage && getAll(elem, 'script')); + } + destElements = srcElements = node = null; + return clone; + }, + buildFragment: function (elems, context, scripts, selection) { + var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length, safe = createSafeFragment(context), nodes = [], i = 0; + for (; i < l; i++) { + elem = elems[i]; + if (elem || elem === 0) { + if (jQuery.type(elem) === 'object') { + jQuery.merge(nodes, elem.nodeType ? [elem] : elem); + } else if (!rhtml.test(elem)) { + nodes.push(context.createTextNode(elem)); + } else { + 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>') + wrap[2]; + j = wrap[0]; + while (j--) { + tmp = tmp.lastChild; + } + if (!support.leadingWhitespace && rleadingWhitespace.test(elem)) { + nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0])); + } + if (!support.tbody) { + elem = tag === 'table' && !rtbody.test(elem) ? tmp.firstChild : wrap[1] === '' && !rtbody.test(elem) ? tmp : 0; + j = elem && elem.childNodes.length; + while (j--) { + if (jQuery.nodeName(tbody = elem.childNodes[j], 'tbody') && !tbody.childNodes.length) { + elem.removeChild(tbody); + } + } + } + jQuery.merge(nodes, tmp.childNodes); + tmp.textContent = ''; + while (tmp.firstChild) { + tmp.removeChild(tmp.firstChild); + } + tmp = safe.lastChild; + } + } + } + if (tmp) { + safe.removeChild(tmp); + } + if (!support.appendChecked) { + jQuery.grep(getAll(nodes, 'input'), fixDefaultChecked); + } + i = 0; + while (elem = nodes[i++]) { + if (selection && jQuery.inArray(elem, selection) !== -1) { + continue; + } + contains = jQuery.contains(elem.ownerDocument, elem); + tmp = getAll(safe.appendChild(elem), 'script'); + if (contains) { + setGlobalEval(tmp); + } + if (scripts) { + j = 0; + while (elem = tmp[j++]) { + if (rscriptType.test(elem.type || '')) { + scripts.push(elem); + } + } + } + } + tmp = null; + return safe; + }, + cleanData: function (elems, acceptData) { + var elem, type, id, data, i = 0, internalKey = jQuery.expando, cache = jQuery.cache, deleteExpando = support.deleteExpando, special = jQuery.event.special; + for (; (elem = elems[i]) != null; i++) { + if (acceptData || jQuery.acceptData(elem)) { + id = elem[internalKey]; + data = id && cache[id]; + if (data) { + if (data.events) { + for (type in data.events) { + if (special[type]) { + jQuery.event.remove(elem, type); + } else { + jQuery.removeEvent(elem, type, data.handle); + } + } + } + if (cache[id]) { + delete cache[id]; + if (deleteExpando) { + delete elem[internalKey]; + } else if (typeof elem.removeAttribute !== strundefined) { + elem.removeAttribute(internalKey); + } else { + elem[internalKey] = null; + } + deletedIds.push(id); + } + } + } + } + } + }); + jQuery.fn.extend({ + text: function (value) { + return access(this, function (value) { + return value === undefined ? jQuery.text(this) : this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(value)); + }, null, value, arguments.length); + }, + append: function () { + return this.domManip(arguments, function (elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.appendChild(elem); + } + }); + }, + prepend: function () { + return this.domManip(arguments, function (elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.insertBefore(elem, target.firstChild); + } + }); + }, + before: function () { + return this.domManip(arguments, function (elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this); + } + }); + }, + after: function () { + return this.domManip(arguments, function (elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this.nextSibling); + } + }); + }, + remove: function (selector, keepData) { + var elem, elems = selector ? jQuery.filter(selector, this) : this, i = 0; + for (; (elem = elems[i]) != null; i++) { + if (!keepData && elem.nodeType === 1) { + jQuery.cleanData(getAll(elem)); + } + if (elem.parentNode) { + if (keepData && jQuery.contains(elem.ownerDocument, elem)) { + setGlobalEval(getAll(elem, 'script')); + } + elem.parentNode.removeChild(elem); + } + } + return this; + }, + empty: function () { + var elem, i = 0; + for (; (elem = this[i]) != null; i++) { + if (elem.nodeType === 1) { + jQuery.cleanData(getAll(elem, false)); + } + while (elem.firstChild) { + elem.removeChild(elem.firstChild); + } + if (elem.options && jQuery.nodeName(elem, 'select')) { + elem.options.length = 0; + } + } + return this; + }, + clone: function (dataAndEvents, deepDataAndEvents) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + return this.map(function () { + return jQuery.clone(this, dataAndEvents, deepDataAndEvents); + }); + }, + html: function (value) { + return access(this, function (value) { + var elem = this[0] || {}, i = 0, l = this.length; + if (value === undefined) { + return elem.nodeType === 1 ? elem.innerHTML.replace(rinlinejQuery, '') : undefined; + } + if (typeof value === 'string' && !rnoInnerhtml.test(value) && (support.htmlSerialize || !rnoshimcache.test(value)) && (support.leadingWhitespace || !rleadingWhitespace.test(value)) && !wrapMap[(rtagName.exec(value) || [ + '', + '' + ])[1].toLowerCase()]) { + value = value.replace(rxhtmlTag, '<$1>'); + try { + for (; i < l; i++) { + elem = this[i] || {}; + if (elem.nodeType === 1) { + jQuery.cleanData(getAll(elem, false)); + elem.innerHTML = value; + } + } + elem = 0; + } catch (e) { + } + } + if (elem) { + this.empty().append(value); + } + }, null, value, arguments.length); + }, + replaceWith: function () { + var arg = arguments[0]; + this.domManip(arguments, function (elem) { + arg = this.parentNode; + jQuery.cleanData(getAll(this)); + if (arg) { + arg.replaceChild(elem, this); + } + }); + return arg && (arg.length || arg.nodeType) ? this : this.remove(); + }, + detach: function (selector) { + return this.remove(selector, true); + }, + domManip: function (args, callback) { + args = concat.apply([], args); + var first, node, hasScripts, scripts, doc, fragment, i = 0, l = this.length, set = this, iNoClone = l - 1, value = args[0], isFunction = jQuery.isFunction(value); + if (isFunction || l > 1 && typeof value === 'string' && !support.checkClone && rchecked.test(value)) { + return this.each(function (index) { + var self = set.eq(index); + if (isFunction) { + args[0] = value.call(this, index, self.html()); + } + self.domManip(args, callback); + }); + } + if (l) { + fragment = jQuery.buildFragment(args, this[0].ownerDocument, false, this); + first = fragment.firstChild; + if (fragment.childNodes.length === 1) { + fragment = first; + } + if (first) { + scripts = jQuery.map(getAll(fragment, 'script'), disableScript); + hasScripts = scripts.length; + for (; i < l; i++) { + node = fragment; + if (i !== iNoClone) { + node = jQuery.clone(node, true, true); + if (hasScripts) { + jQuery.merge(scripts, getAll(node, 'script')); + } + } + callback.call(this[i], node, i); + } + if (hasScripts) { + doc = scripts[scripts.length - 1].ownerDocument; + jQuery.map(scripts, restoreScript); + for (i = 0; i < hasScripts; i++) { + node = scripts[i]; + if (rscriptType.test(node.type || '') && !jQuery._data(node, 'globalEval') && jQuery.contains(doc, node)) { + if (node.src) { + if (jQuery._evalUrl) { + jQuery._evalUrl(node.src); + } + } else { + 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) { + var elems, i = 0, ret = [], insert = jQuery(selector), last = insert.length - 1; + for (; i <= last; i++) { + elems = i === last ? this : this.clone(true); + jQuery(insert[i])[original](elems); + push.apply(ret, elems.get()); + } + return this.pushStack(ret); + }; + }); + var iframe, elemdisplay = {}; + function actualDisplay(name, doc) { + var elem = jQuery(doc.createElement(name)).appendTo(doc.body), display = window.getDefaultComputedStyle ? window.getDefaultComputedStyle(elem[0]).display : jQuery.css(elem[0], 'display'); + elem.detach(); + return display; + } + function defaultDisplay(nodeName) { + var doc = document, display = elemdisplay[nodeName]; + if (!display) { + display = actualDisplay(nodeName, doc); + if (display === 'none' || !display) { + iframe = (iframe || jQuery('