diff --git a/dist/amd/browser/actions.js b/dist/amd/browser/actions.js new file mode 100644 index 00000000..929a0194 --- /dev/null +++ b/dist/amd/browser/actions.js @@ -0,0 +1,150 @@ +/*funcunit@3.2.2#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..6315f76d --- /dev/null +++ b/dist/amd/browser/adapters/adapters.js @@ -0,0 +1,53 @@ +/*funcunit@3.2.2#browser/adapters/adapters*/ +define(function (require, exports, module) { + (function (global) { + var jasmineAdapter = require('./jasmine'); + var jasmine2Adapter = require('./jasmine2'); + var qunitAdapter = require('./qunit'); + 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 (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 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..3c2b37fa --- /dev/null +++ b/dist/amd/browser/adapters/jasmine.js @@ -0,0 +1,23 @@ +/*funcunit@3.2.2#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, message) { + 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..2a9bfcbe --- /dev/null +++ b/dist/amd/browser/adapters/jasmine2.js @@ -0,0 +1,19 @@ +/*funcunit@3.2.2#browser/adapters/jasmine2*/ +define(function (require, exports, module) { + var FuncUnit = require('../core'); + module.exports = function (jasmine) { + FuncUnit.timeout = 4900; + return { + pauseTest: function () { + }, + resumeTest: function () { + }, + assertOK: function (assertion, message) { + 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..a65531b8 --- /dev/null +++ b/dist/amd/browser/adapters/mocha.js @@ -0,0 +1,23 @@ +/*funcunit@3.2.2#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 (mocha) { + 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..1ea124c0 --- /dev/null +++ b/dist/amd/browser/adapters/qunit.js @@ -0,0 +1,19 @@ +/*funcunit@3.2.2#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/core.js b/dist/amd/browser/core.js new file mode 100644 index 00000000..68d00f5e --- /dev/null +++ b/dist/amd/browser/core.js @@ -0,0 +1,64 @@ +/*funcunit@3.2.2#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..2891375a --- /dev/null +++ b/dist/amd/browser/getters.js @@ -0,0 +1,137 @@ +/*funcunit@3.2.2#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..f9d24fd7 --- /dev/null +++ b/dist/amd/browser/init.js @@ -0,0 +1,26 @@ +/*funcunit@3.2.2#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..f173980b --- /dev/null +++ b/dist/amd/browser/jquery.js @@ -0,0 +1,5 @@ +/*funcunit@3.2.2#browser/jquery*/ +define(function (require, exports, module) { + var $ = require('jquery'); + module.exports = $.noConflict(true); +}); \ No newline at end of file diff --git a/dist/amd/browser/open.js b/dist/amd/browser/open.js new file mode 100644 index 00000000..e3b8157e --- /dev/null +++ b/dist/amd/browser/open.js @@ -0,0 +1,198 @@ +/*funcunit@3.2.2#browser/open*/ +define(function (require, exports, module) { + var $ = require('./jquery'); + var FuncUnit = require('./core'); + var syn = require('syn'); + if (FuncUnit.frameMode) { + var ifrm = document.createElement('iframe'); + ifrm.id = 'funcunit_app'; + document.body.insertBefore(ifrm, document.body.firstChild); + } + var confirms = [], prompts = [], currentDocument, currentHref, appWin, lookingForNewDocument = false, urlWithoutHash = function (url) { + return url.replace(/\#.*$/, ''); + }, isCurrentPage = function (url) { + var pathname = urlWithoutHash(FuncUnit.win.location.pathname), href = urlWithoutHash(FuncUnit.win.location.href), url = urlWithoutHash(url); + if (pathname === url || href === url) { + return true; + } + return false; + }; + $.extend(FuncUnit, { + open: function (path, success, timeout) { + if (typeof success != 'function') { + timeout = success; + success = undefined; + } + FuncUnit.add({ + method: function (success, error) { + if (typeof path === 'string') { + var fullPath = FuncUnit.getAbsolutePath(path); + FuncUnit._open(fullPath, error); + FuncUnit._onload(function () { + success(); + }, error); + } else { + FuncUnit.win = path; + success(); + } + }, + success: success, + error: 'Page ' + path + ' not loaded in time!', + timeout: timeout || 30000 + }); + }, + _open: function (url) { + FuncUnit.win = appWin; + hasSteal = false; + FuncUnit.frame = $('#funcunit_app').length ? $('#funcunit_app')[0] : null; + if (newPage) { + if (FuncUnit.frame) { + FuncUnit.win = FuncUnit.frame.contentWindow; + FuncUnit.win.location = url; + } else { + var width = $(window).width(); + FuncUnit.win = window.open(url, 'funcunit', 'height=1000,toolbar=yes,status=yes,width=' + width / 2 + ',left=' + width / 2); + if (FuncUnit.win && FuncUnit.win.___FUNCUNIT_OPENED) { + FuncUnit.win.close(); + FuncUnit.win = window.open(url, 'funcunit', 'height=1000,toolbar=yes,status=yes,left=' + width / 2); + } + if (!FuncUnit.win) { + throw 'Could not open a popup window. Your popup blocker is probably on. Please turn it off and try again'; + } + } + appWin = FuncUnit.win; + } else { + lookingForNewDocument = true; + if (isCurrentPage(url)) { + FuncUnit.win.document.body.parentNode.removeChild(FuncUnit.win.document.body); + FuncUnit.win.location.hash = url.split('#')[1] || ''; + FuncUnit.win.location.reload(true); + } else { + FuncUnit.win.location = url; + } + currentDocument = null; + } + lookingForNewDocument = true; + }, + confirm: function (answer) { + confirms.push(!!answer); + }, + prompt: function (answer) { + prompts.push(answer); + }, + _opened: function () { + if (!this._isOverridden('alert')) { + FuncUnit.win.alert = function () { + }; + } + if (!this._isOverridden('confirm')) { + FuncUnit.win.confirm = function () { + var res = confirms.shift(); + return res; + }; + } + if (!this._isOverridden('prompt')) { + FuncUnit.win.prompt = function () { + return prompts.shift(); + }; + } + }, + _isOverridden: function (type) { + return !/(native code)|(source code not available)/.test(FuncUnit.win[type]); + }, + _onload: function (success, error) { + loadSuccess = function () { + if (FuncUnit.win.steal) { + hasSteal = true; + } + if (!hasSteal) { + return success(); + } + FuncUnit.win.steal.done().then(success); + }; + if (!newPage) { + return; + } + newPage = false; + if (FuncUnit.support.readystate) { + poller(); + } else { + unloadLoader(); + } + }, + getAbsolutePath: function (path) { + if (/^\/\//.test(path)) { + path = path.substr(2); + } + return path; + }, + win: window, + support: { readystate: 'readyState' in document }, + eval: function (str) { + return FuncUnit.win.eval(str); + }, + documentLoaded: function () { + var loaded = FuncUnit.win.document.readyState === 'complete' && FuncUnit.win.location.href != 'about:blank' && FuncUnit.win.document.body; + return loaded; + }, + checkForNewDocument: function () { + var documentFound = false; + try { + documentFound = (FuncUnit.win.document !== currentDocument && !FuncUnit.win.___FUNCUNIT_OPENED || currentHref != FuncUnit.win.location.href) && FuncUnit.documentLoaded(); + } catch (e) { + } + if (documentFound) { + lookingForNewDocument = false; + currentDocument = FuncUnit.win.document; + currentHref = FuncUnit.win.location.href; + FuncUnit.win.___FUNCUNIT_OPENED = true; + FuncUnit._opened(); + } + return documentFound; + } + }); + var newPage = true, hasSteal = false, unloadLoader, loadSuccess, firstLoad = true, onload = function () { + FuncUnit.win.document.documentElement.tabIndex = 0; + setTimeout(function () { + FuncUnit.win.focus(); + var ls = loadSuccess; + loadSuccess = null; + if (ls) { + ls(); + } + }, 0); + syn.unbind(FuncUnit.win, 'load', onload); + }, onunload = function () { + FuncUnit.stop = true; + removeListeners(); + setTimeout(unloadLoader, 0); + }, removeListeners = function () { + syn.unbind(FuncUnit.win, 'unload', onunload); + Syn.unbind(FuncUnit.win, 'load', onload); + }; + unloadLoader = function () { + if (!firstLoad) + removeListeners(); + syn.bind(FuncUnit.win, 'load', onload); + syn.bind(FuncUnit.win, 'unload', onunload); + }; + var newDocument = false, poller = function () { + var ls; + if (lookingForNewDocument && FuncUnit.checkForNewDocument()) { + ls = loadSuccess; + loadSuccess = null; + if (ls) { + FuncUnit.win.focus(); + FuncUnit.win.document.documentElement.tabIndex = 0; + ls(); + } + } + setTimeout(arguments.callee, 500); + }; + $(window).unload(function () { + if (FuncUnit.win && FuncUnit.win !== window.top) { + FuncUnit.win.close(); + } + }); + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/browser/queue.js b/dist/amd/browser/queue.js new file mode 100644 index 00000000..78a53d42 --- /dev/null +++ b/dist/amd/browser/queue.js @@ -0,0 +1,114 @@ +/*funcunit@3.2.2#browser/queue*/ +define(function (require, exports, module) { + (function (global) { + var FuncUnit = require('./core'); + FuncUnit._incallback = false; + var currentPosition = 0, startedQueue = false; + FuncUnit.speed = 0; + FuncUnit.timeout = 10000; + FuncUnit._queue = []; + FuncUnit._needSyncQuery = function () { + if (FuncUnit._queue.length === 1) { + if (FuncUnit._queue[0].type === 'query') { + FuncUnit._queue = []; + return true; + } + } + if (FuncUnit._queue.length === 0) { + return true; + } + return false; + }; + FuncUnit._lastQueuedItem = function () { + if (!FuncUnit._queue.length) { + return null; + } + return FuncUnit._queue[FuncUnit._queue.length - 1]; + }; + FuncUnit._haveAsyncQueries = function () { + for (var i = 0; i < FuncUnit._queue.length; i++) { + if (FuncUnit._queue[i].type === 'action' || FuncUnit._queue[i].type === 'wait') + return true; + } + return false; + }; + FuncUnit.add = function (handler, error, context) { + if (handler instanceof Function) { + if (typeof error === 'object') { + context = error; + delete error; + } + error = error && error.toString() || 'Custom method has failed.'; + var cb = handler; + handler = { + method: function (success, error) { + success(); + }, + success: cb, + error: error, + bind: context + }; + } + if (FuncUnit._incallback) { + FuncUnit._queue.splice(currentPosition, 0, handler); + currentPosition++; + } else { + FuncUnit._queue.push(handler); + } + if (FuncUnit._queue.length == 1 && !FuncUnit._incallback) { + FuncUnit.unit.pauseTest(); + setTimeout(FuncUnit._done, 13); + } + }; + var currentEl; + FuncUnit._done = function (el, selector) { + var next, timer, speed = FuncUnit.speed || 0; + if (FuncUnit.speed === 'slow') { + speed = 500; + } + if (FuncUnit._queue.length > 0) { + next = FuncUnit._queue.shift(); + currentPosition = 0; + setTimeout(function () { + timer = setTimeout(function () { + next.stop && next.stop(); + if (typeof next.error === 'function') { + next.error(); + } else { + FuncUnit.unit.assertOK(false, next.error); + } + FuncUnit._done(); + }, (next.timeout || FuncUnit.timeout) + speed); + if (el && el.jquery) { + currentEl = el; + } + if (currentEl) { + next.bind = currentEl; + } + next.selector = selector; + next.method(function (el) { + if (el && el.jquery) { + next.bind = el; + } + clearTimeout(timer); + FuncUnit._incallback = true; + if (next.success) { + next.success.apply(next.bind, arguments); + } + FuncUnit._incallback = false; + FuncUnit._done(next.bind, next.selector); + }, function (message) { + clearTimeout(timer); + FuncUnit.unit.assertOK(false, message); + FuncUnit._done(); + }); + }, speed); + } else { + FuncUnit.unit.resumeTest(); + } + }; + module.exports = FuncUnit; + }(function () { + return this; + }())); +}); \ No newline at end of file diff --git a/dist/amd/browser/traversers.js b/dist/amd/browser/traversers.js new file mode 100644 index 00000000..d435baac --- /dev/null +++ b/dist/amd/browser/traversers.js @@ -0,0 +1,36 @@ +/*funcunit@3.2.2#browser/traversers*/ +define(function (require, exports, module) { + var $ = require('./jquery'); + var FuncUnit = require('./core'); + var traversers = [ + 'closest', + 'next', + 'prev', + 'siblings', + 'last', + 'first', + 'find' + ], makeTraverser = function (name) { + var orig = FuncUnit.prototype[name]; + FuncUnit.prototype[name] = function (selector) { + var args = arguments; + if (FuncUnit.win && this[0] && this[0].parentNode && this[0].parentNode.nodeType !== 9) { + FuncUnit.add({ + method: function (success, error) { + var newBind = orig.apply(this.bind, args); + newBind.prevTraverser = name; + newBind.prevTraverserSelector = selector; + success(newBind); + }, + error: 'Could not traverse: ' + name + ' ' + selector, + bind: this + }); + } + return orig.apply(this, arguments); + }; + }; + for (var i = 0; i < traversers.length; i++) { + makeTraverser(traversers[i]); + } + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/browser/waits.js b/dist/amd/browser/waits.js new file mode 100644 index 00000000..125a52b4 --- /dev/null +++ b/dist/amd/browser/waits.js @@ -0,0 +1,130 @@ +/*funcunit@3.2.2#browser/waits*/ +define(function (require, exports, module) { + var $ = require('./jquery'); + var FuncUnit = require('./core'); + FuncUnit.wait = function (time, success) { + if (typeof time == 'function') { + success = time; + time = undefined; + } + time = time != null ? time : 5000; + FuncUnit.add({ + method: function (success, error) { + setTimeout(success, time); + }, + success: success, + error: 'Couldn\'t wait!', + timeout: time + 1000 + }); + return this; + }; + FuncUnit.branch = function (check1, success1, check2, success2, timeout) { + FuncUnit.repeat({ + method: function (print) { + print('Running a branch statement'); + if (check1()) { + success1(); + return true; + } + if (check2()) { + success2(); + return true; + } + }, + error: 'no branch condition was ever true', + timeout: timeout, + type: 'branch' + }); + }; + FuncUnit.repeat = function (options) { + var interval, stopped = false, stop = function () { + clearTimeout(interval); + stopped = true; + }; + FuncUnit.add({ + method: function (success, error) { + options.bind = this.bind; + options.selector = this.selector; + var printed = false, print = function (msg) { + if (!printed) { + printed = true; + } + }; + interval = setTimeout(function () { + var result = null; + try { + result = options.method(print); + } catch (e) { + } + if (result) { + success(options.bind); + } else if (!stopped) { + interval = setTimeout(arguments.callee, 10); + } + }, 10); + }, + success: options.success, + error: options.error, + timeout: options.timeout, + stop: stop, + bind: options.bind, + type: options.type + }); + }; + FuncUnit.animationEnd = function () { + F('body').wait(200).size(function () { + return F.win.$(':animated').length === 0; + }); + }; + FuncUnit.animationsDone = FuncUnit.animationEnd; + $.extend(FuncUnit.prototype, { + exists: function (timeout, success, message) { + var logMessage = 'Waiting for \'' + this.selector + '\' to exist'; + if (timeout === false) { + logMessage = false; + } + return this.size({ + condition: function (size) { + return size > 0; + }, + timeout: timeout, + success: success, + message: message, + errorMessage: 'Exist failed: element with selector \'' + this.selector + '\' not found', + logMessage: logMessage + }); + }, + missing: function (timeout, success, message) { + return this.size(0, timeout, success, message); + }, + visible: function (timeout, success, message) { + var self = this, sel = this.selector, ret; + return this.size(function (size) { + return this.is(':visible') === true; + }, timeout, success, message); + }, + invisible: function (timeout, success, message) { + var self = this, sel = this.selector, ret; + return this.size(function (size) { + return this.is(':visible') === false; + }, timeout, success, message); + }, + wait: function (checker, timeout, success, message) { + if (typeof checker === 'number') { + timeout = checker; + FuncUnit.wait(timeout, success); + return this; + } else { + return this.size(checker, timeout, success, message); + } + }, + then: function (success) { + var self = this; + FuncUnit.wait(0, function () { + success.call(this, this); + }); + return this; + } + }); + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/funcunit.js b/dist/amd/funcunit.js new file mode 100644 index 00000000..f235b8f9 --- /dev/null +++ b/dist/amd/funcunit.js @@ -0,0 +1,14 @@ +/*funcunit*/ +define(function (require, exports, module) { + var syn = require('syn'); + var FuncUnit = require('./browser/core'); + require('./browser\\adapters/adapters'); + require('./browser/open'); + require('./browser/actions'); + require('./browser/getters'); + require('./browser/traversers'); + require('./browser/queue'); + require('./browser/waits'); + window.FuncUnit = window.S = window.F = FuncUnit; + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/amd/global.js b/dist/amd/global.js new file mode 100644 index 00000000..4dae3ede --- /dev/null +++ b/dist/amd/global.js @@ -0,0 +1,7 @@ +/*global*/ +define(function (require, exports, module) { + require('./funcunit'); + var FuncUnit = window.FuncUnit || {}; + window.jQuery = jQuery; + module.exports = FuncUnit; +}); \ No newline at end of file diff --git a/dist/cjs/browser/actions.js b/dist/cjs/browser/actions.js new file mode 100644 index 00000000..cad2087e --- /dev/null +++ b/dist/cjs/browser/actions.js @@ -0,0 +1,148 @@ +/*funcunit@3.2.2#browser/actions*/ +var $ = require('./jquery.js'); +var FuncUnit = require('./core.js'); +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/cjs/browser/adapters/adapters.js b/dist/cjs/browser/adapters/adapters.js new file mode 100644 index 00000000..277c3286 --- /dev/null +++ b/dist/cjs/browser/adapters/adapters.js @@ -0,0 +1,47 @@ +/*funcunit@3.2.2#browser/adapters/adapters*/ +var jasmineAdapter = require('./jasmine.js'); +var jasmine2Adapter = require('./jasmine2.js'); +var qunitAdapter = require('./qunit.js'); +var mochaAdapter = require('./mocha.js'); +var FuncUnit = require('../core.js'); +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 (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 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; +}; \ No newline at end of file diff --git a/dist/cjs/browser/adapters/jasmine.js b/dist/cjs/browser/adapters/jasmine.js new file mode 100644 index 00000000..bc3d0c86 --- /dev/null +++ b/dist/cjs/browser/adapters/jasmine.js @@ -0,0 +1,21 @@ +/*funcunit@3.2.2#browser/adapters/jasmine*/ +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, message) { + expect(assertion).toBeTruthy(); + }, + equiv: function (expected, actual) { + return jasmine.getEnv().equals_(expected, actual); + } + }; +}; \ No newline at end of file diff --git a/dist/cjs/browser/adapters/jasmine2.js b/dist/cjs/browser/adapters/jasmine2.js new file mode 100644 index 00000000..47f0c6e2 --- /dev/null +++ b/dist/cjs/browser/adapters/jasmine2.js @@ -0,0 +1,17 @@ +/*funcunit@3.2.2#browser/adapters/jasmine2*/ +var FuncUnit = require('../core.js'); +module.exports = function (jasmine) { + FuncUnit.timeout = 4900; + return { + pauseTest: function () { + }, + resumeTest: function () { + }, + assertOK: function (assertion, message) { + expect(assertion).toBeTruthy(); + }, + equiv: function (expected, actual) { + return expected == actual; + } + }; +}; \ No newline at end of file diff --git a/dist/cjs/browser/adapters/mocha.js b/dist/cjs/browser/adapters/mocha.js new file mode 100644 index 00000000..c9e37094 --- /dev/null +++ b/dist/cjs/browser/adapters/mocha.js @@ -0,0 +1,21 @@ +/*funcunit@3.2.2#browser/adapters/mocha*/ +var FuncUnit = require('../core.js'); +var ok = function (expr, msg) { + if (!expr) + throw new Error(msg); +}; +module.exports = function (mocha) { + 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/cjs/browser/adapters/qunit.js b/dist/cjs/browser/adapters/qunit.js new file mode 100644 index 00000000..cda023fe --- /dev/null +++ b/dist/cjs/browser/adapters/qunit.js @@ -0,0 +1,17 @@ +/*funcunit@3.2.2#browser/adapters/qunit*/ +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/cjs/browser/core.js b/dist/cjs/browser/core.js new file mode 100644 index 00000000..a4a43e51 --- /dev/null +++ b/dist/cjs/browser/core.js @@ -0,0 +1,62 @@ +/*funcunit@3.2.2#browser/core*/ +var jQuery = require('./jquery.js'); +var oldFuncUnit = require('./init.js'); +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/cjs/browser/getters.js b/dist/cjs/browser/getters.js new file mode 100644 index 00000000..c01bf218 --- /dev/null +++ b/dist/cjs/browser/getters.js @@ -0,0 +1,135 @@ +/*funcunit@3.2.2#browser/getters*/ +var $ = require('./jquery.js'); +var FuncUnit = require('./core.js'); +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/cjs/browser/init.js b/dist/cjs/browser/init.js new file mode 100644 index 00000000..4c256cbc --- /dev/null +++ b/dist/cjs/browser/init.js @@ -0,0 +1,24 @@ +/*funcunit@3.2.2#browser/init*/ +var jQuery = require('./jquery.js'); +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/cjs/browser/jquery.js b/dist/cjs/browser/jquery.js new file mode 100644 index 00000000..f815ecf0 --- /dev/null +++ b/dist/cjs/browser/jquery.js @@ -0,0 +1,3 @@ +/*funcunit@3.2.2#browser/jquery*/ +var $ = require('jquery'); +module.exports = $.noConflict(true); \ No newline at end of file diff --git a/dist/cjs/browser/open.js b/dist/cjs/browser/open.js new file mode 100644 index 00000000..683a18d9 --- /dev/null +++ b/dist/cjs/browser/open.js @@ -0,0 +1,196 @@ +/*funcunit@3.2.2#browser/open*/ +var $ = require('./jquery.js'); +var FuncUnit = require('./core.js'); +var syn = require('syn'); +if (FuncUnit.frameMode) { + var ifrm = document.createElement('iframe'); + ifrm.id = 'funcunit_app'; + document.body.insertBefore(ifrm, document.body.firstChild); +} +var confirms = [], prompts = [], currentDocument, currentHref, appWin, lookingForNewDocument = false, urlWithoutHash = function (url) { + return url.replace(/\#.*$/, ''); + }, isCurrentPage = function (url) { + var pathname = urlWithoutHash(FuncUnit.win.location.pathname), href = urlWithoutHash(FuncUnit.win.location.href), url = urlWithoutHash(url); + if (pathname === url || href === url) { + return true; + } + return false; + }; +$.extend(FuncUnit, { + open: function (path, success, timeout) { + if (typeof success != 'function') { + timeout = success; + success = undefined; + } + FuncUnit.add({ + method: function (success, error) { + if (typeof path === 'string') { + var fullPath = FuncUnit.getAbsolutePath(path); + FuncUnit._open(fullPath, error); + FuncUnit._onload(function () { + success(); + }, error); + } else { + FuncUnit.win = path; + success(); + } + }, + success: success, + error: 'Page ' + path + ' not loaded in time!', + timeout: timeout || 30000 + }); + }, + _open: function (url) { + FuncUnit.win = appWin; + hasSteal = false; + FuncUnit.frame = $('#funcunit_app').length ? $('#funcunit_app')[0] : null; + if (newPage) { + if (FuncUnit.frame) { + FuncUnit.win = FuncUnit.frame.contentWindow; + FuncUnit.win.location = url; + } else { + var width = $(window).width(); + FuncUnit.win = window.open(url, 'funcunit', 'height=1000,toolbar=yes,status=yes,width=' + width / 2 + ',left=' + width / 2); + if (FuncUnit.win && FuncUnit.win.___FUNCUNIT_OPENED) { + FuncUnit.win.close(); + FuncUnit.win = window.open(url, 'funcunit', 'height=1000,toolbar=yes,status=yes,left=' + width / 2); + } + if (!FuncUnit.win) { + throw 'Could not open a popup window. Your popup blocker is probably on. Please turn it off and try again'; + } + } + appWin = FuncUnit.win; + } else { + lookingForNewDocument = true; + if (isCurrentPage(url)) { + FuncUnit.win.document.body.parentNode.removeChild(FuncUnit.win.document.body); + FuncUnit.win.location.hash = url.split('#')[1] || ''; + FuncUnit.win.location.reload(true); + } else { + FuncUnit.win.location = url; + } + currentDocument = null; + } + lookingForNewDocument = true; + }, + confirm: function (answer) { + confirms.push(!!answer); + }, + prompt: function (answer) { + prompts.push(answer); + }, + _opened: function () { + if (!this._isOverridden('alert')) { + FuncUnit.win.alert = function () { + }; + } + if (!this._isOverridden('confirm')) { + FuncUnit.win.confirm = function () { + var res = confirms.shift(); + return res; + }; + } + if (!this._isOverridden('prompt')) { + FuncUnit.win.prompt = function () { + return prompts.shift(); + }; + } + }, + _isOverridden: function (type) { + return !/(native code)|(source code not available)/.test(FuncUnit.win[type]); + }, + _onload: function (success, error) { + loadSuccess = function () { + if (FuncUnit.win.steal) { + hasSteal = true; + } + if (!hasSteal) { + return success(); + } + FuncUnit.win.steal.done().then(success); + }; + if (!newPage) { + return; + } + newPage = false; + if (FuncUnit.support.readystate) { + poller(); + } else { + unloadLoader(); + } + }, + getAbsolutePath: function (path) { + if (/^\/\//.test(path)) { + path = path.substr(2); + } + return path; + }, + win: window, + support: { readystate: 'readyState' in document }, + eval: function (str) { + return FuncUnit.win.eval(str); + }, + documentLoaded: function () { + var loaded = FuncUnit.win.document.readyState === 'complete' && FuncUnit.win.location.href != 'about:blank' && FuncUnit.win.document.body; + return loaded; + }, + checkForNewDocument: function () { + var documentFound = false; + try { + documentFound = (FuncUnit.win.document !== currentDocument && !FuncUnit.win.___FUNCUNIT_OPENED || currentHref != FuncUnit.win.location.href) && FuncUnit.documentLoaded(); + } catch (e) { + } + if (documentFound) { + lookingForNewDocument = false; + currentDocument = FuncUnit.win.document; + currentHref = FuncUnit.win.location.href; + FuncUnit.win.___FUNCUNIT_OPENED = true; + FuncUnit._opened(); + } + return documentFound; + } +}); +var newPage = true, hasSteal = false, unloadLoader, loadSuccess, firstLoad = true, onload = function () { + FuncUnit.win.document.documentElement.tabIndex = 0; + setTimeout(function () { + FuncUnit.win.focus(); + var ls = loadSuccess; + loadSuccess = null; + if (ls) { + ls(); + } + }, 0); + syn.unbind(FuncUnit.win, 'load', onload); + }, onunload = function () { + FuncUnit.stop = true; + removeListeners(); + setTimeout(unloadLoader, 0); + }, removeListeners = function () { + syn.unbind(FuncUnit.win, 'unload', onunload); + Syn.unbind(FuncUnit.win, 'load', onload); + }; +unloadLoader = function () { + if (!firstLoad) + removeListeners(); + syn.bind(FuncUnit.win, 'load', onload); + syn.bind(FuncUnit.win, 'unload', onunload); +}; +var newDocument = false, poller = function () { + var ls; + if (lookingForNewDocument && FuncUnit.checkForNewDocument()) { + ls = loadSuccess; + loadSuccess = null; + if (ls) { + FuncUnit.win.focus(); + FuncUnit.win.document.documentElement.tabIndex = 0; + ls(); + } + } + setTimeout(arguments.callee, 500); + }; +$(window).unload(function () { + if (FuncUnit.win && FuncUnit.win !== window.top) { + FuncUnit.win.close(); + } +}); +module.exports = FuncUnit; \ No newline at end of file diff --git a/dist/cjs/browser/queue.js b/dist/cjs/browser/queue.js new file mode 100644 index 00000000..87acaacc --- /dev/null +++ b/dist/cjs/browser/queue.js @@ -0,0 +1,108 @@ +/*funcunit@3.2.2#browser/queue*/ +var FuncUnit = require('./core.js'); +FuncUnit._incallback = false; +var currentPosition = 0, startedQueue = false; +FuncUnit.speed = 0; +FuncUnit.timeout = 10000; +FuncUnit._queue = []; +FuncUnit._needSyncQuery = function () { + if (FuncUnit._queue.length === 1) { + if (FuncUnit._queue[0].type === 'query') { + FuncUnit._queue = []; + return true; + } + } + if (FuncUnit._queue.length === 0) { + return true; + } + return false; +}; +FuncUnit._lastQueuedItem = function () { + if (!FuncUnit._queue.length) { + return null; + } + return FuncUnit._queue[FuncUnit._queue.length - 1]; +}; +FuncUnit._haveAsyncQueries = function () { + for (var i = 0; i < FuncUnit._queue.length; i++) { + if (FuncUnit._queue[i].type === 'action' || FuncUnit._queue[i].type === 'wait') + return true; + } + return false; +}; +FuncUnit.add = function (handler, error, context) { + if (handler instanceof Function) { + if (typeof error === 'object') { + context = error; + delete error; + } + error = error && error.toString() || 'Custom method has failed.'; + var cb = handler; + handler = { + method: function (success, error) { + success(); + }, + success: cb, + error: error, + bind: context + }; + } + if (FuncUnit._incallback) { + FuncUnit._queue.splice(currentPosition, 0, handler); + currentPosition++; + } else { + FuncUnit._queue.push(handler); + } + if (FuncUnit._queue.length == 1 && !FuncUnit._incallback) { + FuncUnit.unit.pauseTest(); + setTimeout(FuncUnit._done, 13); + } +}; +var currentEl; +FuncUnit._done = function (el, selector) { + var next, timer, speed = FuncUnit.speed || 0; + if (FuncUnit.speed === 'slow') { + speed = 500; + } + if (FuncUnit._queue.length > 0) { + next = FuncUnit._queue.shift(); + currentPosition = 0; + setTimeout(function () { + timer = setTimeout(function () { + next.stop && next.stop(); + if (typeof next.error === 'function') { + next.error(); + } else { + FuncUnit.unit.assertOK(false, next.error); + } + FuncUnit._done(); + }, (next.timeout || FuncUnit.timeout) + speed); + if (el && el.jquery) { + currentEl = el; + } + if (currentEl) { + next.bind = currentEl; + } + next.selector = selector; + next.method(function (el) { + if (el && el.jquery) { + next.bind = el; + } + clearTimeout(timer); + FuncUnit._incallback = true; + if (next.success) { + next.success.apply(next.bind, arguments); + } + FuncUnit._incallback = false; + FuncUnit._done(next.bind, next.selector); + }, function (message) { + clearTimeout(timer); + FuncUnit.unit.assertOK(false, message); + FuncUnit._done(); + }); + }, speed); + } else { + FuncUnit.unit.resumeTest(); + } +}; +module.exports = FuncUnit; \ No newline at end of file diff --git a/dist/cjs/browser/traversers.js b/dist/cjs/browser/traversers.js new file mode 100644 index 00000000..a2b25865 --- /dev/null +++ b/dist/cjs/browser/traversers.js @@ -0,0 +1,34 @@ +/*funcunit@3.2.2#browser/traversers*/ +var $ = require('./jquery.js'); +var FuncUnit = require('./core.js'); +var traversers = [ + 'closest', + 'next', + 'prev', + 'siblings', + 'last', + 'first', + 'find' + ], makeTraverser = function (name) { + var orig = FuncUnit.prototype[name]; + FuncUnit.prototype[name] = function (selector) { + var args = arguments; + if (FuncUnit.win && this[0] && this[0].parentNode && this[0].parentNode.nodeType !== 9) { + FuncUnit.add({ + method: function (success, error) { + var newBind = orig.apply(this.bind, args); + newBind.prevTraverser = name; + newBind.prevTraverserSelector = selector; + success(newBind); + }, + error: 'Could not traverse: ' + name + ' ' + selector, + bind: this + }); + } + return orig.apply(this, arguments); + }; + }; +for (var i = 0; i < traversers.length; i++) { + makeTraverser(traversers[i]); +} +module.exports = FuncUnit; \ No newline at end of file diff --git a/dist/cjs/browser/waits.js b/dist/cjs/browser/waits.js new file mode 100644 index 00000000..a6c63d71 --- /dev/null +++ b/dist/cjs/browser/waits.js @@ -0,0 +1,128 @@ +/*funcunit@3.2.2#browser/waits*/ +var $ = require('./jquery.js'); +var FuncUnit = require('./core.js'); +FuncUnit.wait = function (time, success) { + if (typeof time == 'function') { + success = time; + time = undefined; + } + time = time != null ? time : 5000; + FuncUnit.add({ + method: function (success, error) { + setTimeout(success, time); + }, + success: success, + error: 'Couldn\'t wait!', + timeout: time + 1000 + }); + return this; +}; +FuncUnit.branch = function (check1, success1, check2, success2, timeout) { + FuncUnit.repeat({ + method: function (print) { + print('Running a branch statement'); + if (check1()) { + success1(); + return true; + } + if (check2()) { + success2(); + return true; + } + }, + error: 'no branch condition was ever true', + timeout: timeout, + type: 'branch' + }); +}; +FuncUnit.repeat = function (options) { + var interval, stopped = false, stop = function () { + clearTimeout(interval); + stopped = true; + }; + FuncUnit.add({ + method: function (success, error) { + options.bind = this.bind; + options.selector = this.selector; + var printed = false, print = function (msg) { + if (!printed) { + printed = true; + } + }; + interval = setTimeout(function () { + var result = null; + try { + result = options.method(print); + } catch (e) { + } + if (result) { + success(options.bind); + } else if (!stopped) { + interval = setTimeout(arguments.callee, 10); + } + }, 10); + }, + success: options.success, + error: options.error, + timeout: options.timeout, + stop: stop, + bind: options.bind, + type: options.type + }); +}; +FuncUnit.animationEnd = function () { + F('body').wait(200).size(function () { + return F.win.$(':animated').length === 0; + }); +}; +FuncUnit.animationsDone = FuncUnit.animationEnd; +$.extend(FuncUnit.prototype, { + exists: function (timeout, success, message) { + var logMessage = 'Waiting for \'' + this.selector + '\' to exist'; + if (timeout === false) { + logMessage = false; + } + return this.size({ + condition: function (size) { + return size > 0; + }, + timeout: timeout, + success: success, + message: message, + errorMessage: 'Exist failed: element with selector \'' + this.selector + '\' not found', + logMessage: logMessage + }); + }, + missing: function (timeout, success, message) { + return this.size(0, timeout, success, message); + }, + visible: function (timeout, success, message) { + var self = this, sel = this.selector, ret; + return this.size(function (size) { + return this.is(':visible') === true; + }, timeout, success, message); + }, + invisible: function (timeout, success, message) { + var self = this, sel = this.selector, ret; + return this.size(function (size) { + return this.is(':visible') === false; + }, timeout, success, message); + }, + wait: function (checker, timeout, success, message) { + if (typeof checker === 'number') { + timeout = checker; + FuncUnit.wait(timeout, success); + return this; + } else { + return this.size(checker, timeout, success, message); + } + }, + then: function (success) { + var self = this; + FuncUnit.wait(0, function () { + success.call(this, this); + }); + return this; + } +}); +module.exports = FuncUnit; \ No newline at end of file diff --git a/dist/cjs/funcunit.js b/dist/cjs/funcunit.js new file mode 100644 index 00000000..5ea7f22e --- /dev/null +++ b/dist/cjs/funcunit.js @@ -0,0 +1,12 @@ +/*funcunit*/ +var syn = require('syn'); +var FuncUnit = require('./browser/core.js'); +require('./browser\\adapters/adapters.js'); +require('./browser/open.js'); +require('./browser/actions.js'); +require('./browser/getters.js'); +require('./browser/traversers.js'); +require('./browser/queue.js'); +require('./browser/waits.js'); +window.FuncUnit = window.S = window.F = FuncUnit; +module.exports = FuncUnit; \ No newline at end of file diff --git a/dist/cjs/global.js b/dist/cjs/global.js new file mode 100644 index 00000000..349c4950 --- /dev/null +++ b/dist/cjs/global.js @@ -0,0 +1,5 @@ +/*global*/ +require('./funcunit.js'); +var FuncUnit = window.FuncUnit || {}; +window.jQuery = jQuery; +module.exports = FuncUnit; \ No newline at end of file diff --git a/dist/funcunit.js b/dist/funcunit.js new file mode 100644 index 00000000..bf964e67 --- /dev/null +++ b/dist/funcunit.js @@ -0,0 +1,9725 @@ +/*[global-shim-start]*/ +(function(exports, global, doEval){ // jshint ignore:line + var origDefine = global.define; + + var get = function(name){ + var parts = name.split("."), + cur = global, + i; + for(i = 0 ; i < parts.length; i++){ + if(!cur) { + break; + } + cur = cur[parts[i]]; + } + return cur; + }; + var set = function(name, val){ + var parts = name.split("."), + cur = global, + i, part, next; + for(i = 0; i < parts.length - 1; i++) { + part = parts[i]; + next = cur[part]; + if(!next) { + next = cur[part] = {}; + } + cur = next; + } + part = parts[parts.length - 1]; + cur[part] = val; + }; + var useDefault = function(mod){ + if(!mod || !mod.__esModule) return false; + var esProps = { __esModule: true, "default": true }; + for(var p in mod) { + if(!esProps[p]) return false; + } + return true; + }; + var modules = (global.define && global.define.modules) || + (global._define && global._define.modules) || {}; + var ourDefine = global.define = function(moduleName, deps, callback){ + var module; + if(typeof deps === "function") { + callback = deps; + deps = []; + } + var args = [], + i; + for(i =0; i < deps.length; i++) { + args.push( exports[deps[i]] ? get(exports[deps[i]]) : ( modules[deps[i]] || get(deps[i]) ) ); + } + // CJS has no dependencies but 3 callback arguments + if(!deps.length && callback.length) { + module = { exports: {} }; + var require = function(name) { + return exports[name] ? get(exports[name]) : modules[name]; + }; + args.push(require, module.exports, module); + } + // Babel uses the exports and module object. + else if(!args[0] && deps[0] === "exports") { + module = { exports: {} }; + args[0] = module.exports; + if(deps[1] === "module") { + args[1] = module; + } + } else if(!args[0] && deps[0] === "module") { + args[0] = { id: moduleName }; + } + + global.define = origDefine; + var result = callback ? callback.apply(null, args) : undefined; + global.define = ourDefine; + + // Favor CJS module.exports over the return value + result = module && module.exports ? module.exports : result; + modules[moduleName] = result; + + // Set global exports + var globalExport = exports[moduleName]; + if(globalExport && !get(globalExport)) { + if(useDefault(result)) { + result = result["default"]; + } + set(globalExport, result); + } + }; + global.define.orig = origDefine; + global.define.modules = modules; + global.define.amd = true; + ourDefine("@loader", [], function(){ + // shim for @@global-helpers + var noop = function(){}; + return { + get: function(){ + return { prepareGlobal: noop, retrieveGlobal: noop }; + }, + global: global, + __exec: function(__load){ + doEval(__load.source, global); + } + }; + }); +} +)({"jquery":"jQuery"},window,function(__$source__, __$global__) { // jshint ignore:line + eval("(function() { " + __$source__ + " \n }).call(__$global__);"); +} +) +/*syn@0.5.0#dist/cjs/synthetic.js*/ +define('syn/dist/cjs/synthetic.js', function (require, exports, module) { + var opts = window.syn ? window.syn : {}; + var extend = function (d, s) { + var p; + for (p in s) { + d[p] = s[p]; + } + return d; + }, browser = { + msie: !!(window.attachEvent && !window.opera), + opera: !!window.opera, + webkit: navigator.userAgent.indexOf('AppleWebKit/') > -1, + safari: navigator.userAgent.indexOf('AppleWebKit/') > -1 && navigator.userAgent.indexOf('Chrome/') === -1, + gecko: navigator.userAgent.indexOf('Gecko') > -1, + mobilesafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/), + rhino: navigator.userAgent.match(/Rhino/) && true + }, createEventObject = function (type, options, element) { + var event = element.ownerDocument.createEventObject(); + return extend(event, options); + }, data = {}, id = 1, expando = '_synthetic' + new Date().getTime(), bind, unbind, schedule, key = /keypress|keyup|keydown/, page = /load|unload|abort|error|select|change|submit|reset|focus|blur|resize|scroll/, activeElement, syn = function (type, element, options, callback) { + return new syn.init(type, element, options, callback); + }; + syn.config = opts; + syn.__tryFocus = function tryFocus(element) { + try { + element.focus(); + } catch (e) { + } + }; + bind = function (el, ev, f) { + return el.addEventListener ? el.addEventListener(ev, f, false) : el.attachEvent('on' + ev, f); + }; + unbind = function (el, ev, f) { + return el.addEventListener ? el.removeEventListener(ev, f, false) : el.detachEvent('on' + ev, f); + }; + schedule = syn.config.schedule || function (fn, ms) { + setTimeout(fn, ms); + }; + extend(syn, { + init: function (type, element, options, callback) { + var args = syn.args(options, element, callback), self = this; + this.queue = []; + this.element = args.element; + if (typeof this[type] === 'function') { + this[type](args.element, args.options, function (defaults, el) { + if (args.callback) { + args.callback.apply(self, arguments); + } + self.done.apply(self, arguments); + }); + } else { + this.result = syn.trigger(args.element, type, args.options); + if (args.callback) { + args.callback.call(this, args.element, this.result); + } + } + }, + jquery: function (el, fast) { + if (window.FuncUnit && window.FuncUnit.jQuery) { + return window.FuncUnit.jQuery; + } + if (el) { + return syn.helpers.getWindow(el).jQuery || window.jQuery; + } else { + return window.jQuery; + } + }, + args: function () { + var res = {}, i = 0; + for (; i < arguments.length; i++) { + if (typeof arguments[i] === 'function') { + res.callback = arguments[i]; + } else if (arguments[i] && arguments[i].jquery) { + res.element = arguments[i][0]; + } else if (arguments[i] && arguments[i].nodeName) { + res.element = arguments[i]; + } else if (res.options && typeof arguments[i] === 'string') { + res.element = document.getElementById(arguments[i]); + } else if (arguments[i]) { + res.options = arguments[i]; + } + } + return res; + }, + click: function (element, options, callback) { + syn('click!', element, options, callback); + }, + defaults: { + focus: function focus() { + if (!syn.support.focusChanges) { + var element = this, nodeName = element.nodeName.toLowerCase(); + syn.data(element, 'syntheticvalue', element.value); + if (nodeName === 'input' || nodeName === 'textarea') { + bind(element, 'blur', function blur() { + if (syn.data(element, 'syntheticvalue') !== element.value) { + syn.trigger(element, 'change', {}); + } + unbind(element, 'blur', blur); + }); + } + } + }, + submit: function () { + syn.onParents(this, function (el) { + if (el.nodeName.toLowerCase() === 'form') { + el.submit(); + return false; + } + }); + } + }, + changeOnBlur: function (element, prop, value) { + bind(element, 'blur', function onblur() { + if (value !== element[prop]) { + syn.trigger(element, 'change', {}); + } + unbind(element, 'blur', onblur); + }); + }, + closest: function (el, type) { + while (el && el.nodeName.toLowerCase() !== type.toLowerCase()) { + el = el.parentNode; + } + return el; + }, + data: function (el, key, value) { + var d; + if (!el[expando]) { + el[expando] = id++; + } + if (!data[el[expando]]) { + data[el[expando]] = {}; + } + d = data[el[expando]]; + if (value) { + data[el[expando]][key] = value; + } else { + return data[el[expando]][key]; + } + }, + onParents: function (el, func) { + var res; + while (el && res !== false) { + res = func(el); + el = el.parentNode; + } + return el; + }, + focusable: /^(a|area|frame|iframe|label|input|select|textarea|button|html|object)$/i, + isFocusable: function (elem) { + var attributeNode; + if (elem.getAttributeNode) { + attributeNode = elem.getAttributeNode('tabIndex'); + } + return this.focusable.test(elem.nodeName) || attributeNode && attributeNode.specified && syn.isVisible(elem); + }, + isVisible: function (elem) { + return elem.offsetWidth && elem.offsetHeight || elem.clientWidth && elem.clientHeight; + }, + tabIndex: function (elem) { + var attributeNode = elem.getAttributeNode('tabIndex'); + return attributeNode && attributeNode.specified && (parseInt(elem.getAttribute('tabIndex')) || 0); + }, + bind: bind, + unbind: unbind, + schedule: schedule, + browser: browser, + helpers: { + createEventObject: createEventObject, + createBasicStandardEvent: function (type, defaults, doc) { + var event; + try { + event = doc.createEvent('Events'); + } catch (e2) { + event = doc.createEvent('UIEvents'); + } finally { + event.initEvent(type, true, true); + extend(event, defaults); + } + return event; + }, + inArray: function (item, array) { + var i = 0; + for (; i < array.length; i++) { + if (array[i] === item) { + return i; + } + } + return -1; + }, + getWindow: function (element) { + if (element.ownerDocument) { + return element.ownerDocument.defaultView || element.ownerDocument.parentWindow; + } + }, + extend: extend, + scrollOffset: function (win, set) { + var doc = win.document.documentElement, body = win.document.body; + if (set) { + window.scrollTo(set.left, set.top); + } else { + return { + left: (doc && doc.scrollLeft || body && body.scrollLeft || 0) + (doc.clientLeft || 0), + top: (doc && doc.scrollTop || body && body.scrollTop || 0) + (doc.clientTop || 0) + }; + } + }, + scrollDimensions: function (win) { + var doc = win.document.documentElement, body = win.document.body, docWidth = doc.clientWidth, docHeight = doc.clientHeight, compat = win.document.compatMode === 'CSS1Compat'; + return { + height: compat && docHeight || body.clientHeight || docHeight, + width: compat && docWidth || body.clientWidth || docWidth + }; + }, + addOffset: function (options, el) { + var jq = syn.jquery(el), off; + if (typeof options === 'object' && options.clientX === undefined && options.clientY === undefined && options.pageX === undefined && options.pageY === undefined && jq) { + el = jq(el); + off = el.offset(); + options.pageX = off.left + el.width() / 2; + options.pageY = off.top + el.height() / 2; + } + } + }, + key: { + ctrlKey: null, + altKey: null, + shiftKey: null, + metaKey: null + }, + dispatch: function (event, element, type, autoPrevent) { + if (element.dispatchEvent && event) { + var preventDefault = event.preventDefault, prevents = autoPrevent ? -1 : 0; + if (autoPrevent) { + bind(element, type, function ontype(ev) { + ev.preventDefault(); + unbind(this, type, ontype); + }); + } + event.preventDefault = function () { + prevents++; + if (++prevents > 0) { + preventDefault.apply(this, []); + } + }; + element.dispatchEvent(event); + return prevents <= 0; + } else { + try { + window.event = event; + } catch (e) { + } + return element.sourceIndex <= 0 || element.fireEvent && element.fireEvent('on' + type, event); + } + }, + create: { + page: { + event: function (type, options, element) { + var doc = syn.helpers.getWindow(element).document || document, event; + if (doc.createEvent) { + event = doc.createEvent('Events'); + event.initEvent(type, true, true); + return event; + } else { + try { + event = createEventObject(type, options, element); + } catch (e) { + } + return event; + } + } + }, + focus: { + event: function (type, options, element) { + syn.onParents(element, function (el) { + if (syn.isFocusable(el)) { + if (el.nodeName.toLowerCase() !== 'html') { + syn.__tryFocus(el); + activeElement = el; + } else if (activeElement) { + var doc = syn.helpers.getWindow(element).document; + if (doc !== window.document) { + return false; + } else if (doc.activeElement) { + doc.activeElement.blur(); + activeElement = null; + } else { + activeElement.blur(); + activeElement = null; + } + } + return false; + } + }); + return true; + } + } + }, + support: { + clickChanges: false, + clickSubmits: false, + keypressSubmits: false, + mouseupSubmits: false, + radioClickChanges: false, + focusChanges: false, + linkHrefJS: false, + keyCharacters: false, + backspaceWorks: false, + mouseDownUpClicks: false, + tabKeyTabs: false, + keypressOnAnchorClicks: false, + optionClickBubbles: false, + pointerEvents: false, + touchEvents: false, + ready: 0 + }, + trigger: function (element, type, options) { + if (!options) { + options = {}; + } + var create = syn.create, setup = create[type] && create[type].setup, kind = key.test(type) ? 'key' : page.test(type) ? 'page' : 'mouse', createType = create[type] || {}, createKind = create[kind], event, ret, autoPrevent, dispatchEl = element; + if (syn.support.ready === 2 && setup) { + setup(type, options, element); + } + autoPrevent = options._autoPrevent; + delete options._autoPrevent; + if (createType.event) { + ret = createType.event(type, options, element); + } else { + options = createKind.options ? createKind.options(type, options, element) : options; + if (!syn.support.changeBubbles && /option/i.test(element.nodeName)) { + dispatchEl = element.parentNode; + } + event = createKind.event(type, options, dispatchEl); + ret = syn.dispatch(event, dispatchEl, type, autoPrevent); + } + if (ret && syn.support.ready === 2 && syn.defaults[type]) { + syn.defaults[type].call(element, options, autoPrevent); + } + return ret; + }, + eventSupported: function (eventName) { + var el = document.createElement('div'); + eventName = 'on' + eventName; + var isSupported = eventName in el; + if (!isSupported) { + el.setAttribute(eventName, 'return;'); + isSupported = typeof el[eventName] === 'function'; + } + el = null; + return isSupported; + } + }); + extend(syn.init.prototype, { + then: function (type, element, options, callback) { + if (syn.autoDelay) { + this.delay(); + } + var args = syn.args(options, element, callback), self = this; + this.queue.unshift(function (el, prevented) { + if (typeof this[type] === 'function') { + this.element = args.element || el; + this[type](this.element, args.options, function (defaults, el) { + if (args.callback) { + args.callback.apply(self, arguments); + } + self.done.apply(self, arguments); + }); + } else { + this.result = syn.trigger(args.element, type, args.options); + if (args.callback) { + args.callback.call(this, args.element, this.result); + } + return this; + } + }); + return this; + }, + delay: function (timeout, callback) { + if (typeof timeout === 'function') { + callback = timeout; + timeout = null; + } + timeout = timeout || 600; + var self = this; + this.queue.unshift(function () { + schedule(function () { + if (callback) { + callback.apply(self, []); + } + self.done.apply(self, arguments); + }, timeout); + }); + return this; + }, + done: function (defaults, el) { + if (el) { + this.element = el; + } + if (this.queue.length) { + this.queue.pop().call(this, this.element, defaults); + } + }, + '_click': function (element, options, callback, force) { + syn.helpers.addOffset(options, element); + if (syn.support.pointerEvents) { + syn.trigger(element, 'pointerdown', options); + } + if (syn.support.touchEvents) { + syn.trigger(element, 'touchstart', options); + } + syn.trigger(element, 'mousedown', options); + schedule(function () { + if (syn.support.pointerEvents) { + syn.trigger(element, 'pointerup', options); + } + if (syn.support.touchEvents) { + syn.trigger(element, 'touchend', options); + } + syn.trigger(element, 'mouseup', options); + if (!syn.support.mouseDownUpClicks || force) { + syn.trigger(element, 'click', options); + callback(true); + } else { + syn.create.click.setup('click', options, element); + syn.defaults.click.call(element); + schedule(function () { + callback(true); + }, 1); + } + }, 1); + }, + '_rightClick': function (element, options, callback) { + syn.helpers.addOffset(options, element); + var mouseopts = extend(extend({}, syn.mouse.browser.right.mouseup), options); + syn.trigger(element, 'mousedown', mouseopts); + schedule(function () { + syn.trigger(element, 'mouseup', mouseopts); + if (syn.mouse.browser.right.contextmenu) { + syn.trigger(element, 'contextmenu', extend(extend({}, syn.mouse.browser.right.contextmenu), options)); + } + callback(true); + }, 1); + }, + '_dblclick': function (element, options, callback) { + syn.helpers.addOffset(options, element); + var self = this; + this._click(element, options, function () { + schedule(function () { + self._click(element, options, function () { + syn.trigger(element, 'dblclick', options); + callback(true); + }, true); + }, 2); + }); + } + }); + var actions = [ + 'click', + 'dblclick', + 'move', + 'drag', + 'key', + 'type', + 'rightClick' + ], makeAction = function (name) { + syn[name] = function (element, options, callback) { + return syn('_' + name, element, options, callback); + }; + syn.init.prototype[name] = function (element, options, callback) { + return this.then('_' + name, element, options, callback); + }; + }, i = 0; + for (; i < actions.length; i++) { + makeAction(actions[i]); + } + module.exports = syn; +}); +/*syn@0.5.0#dist/cjs/mouse.js*/ +define('syn/dist/cjs/mouse.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + var h = syn.helpers, getWin = h.getWindow; + syn.mouse = {}; + h.extend(syn.defaults, { + mousedown: function (options) { + syn.trigger(this, 'focus', {}); + }, + click: function () { + var element = this, href, type, createChange, radioChanged, nodeName, scope; + try { + href = element.href; + type = element.type; + createChange = syn.data(element, 'createChange'); + radioChanged = syn.data(element, 'radioChanged'); + scope = getWin(element); + nodeName = element.nodeName.toLowerCase(); + } catch (e) { + return; + } + if (!syn.support.linkHrefJS && /^\s*javascript:/.test(href)) { + var code = href.replace(/^\s*javascript:/, ''); + if (code !== '//' && code.indexOf('void(0)') === -1) { + if (window.selenium) { + eval('with(selenium.browserbot.getCurrentWindow()){' + code + '}'); + } else { + eval('with(scope){' + code + '}'); + } + } + } + if (!syn.support.clickSubmits && ((nodeName === 'input' || nodeName === 'button') && type === 'submit')) { + var form = syn.closest(element, 'form'); + if (form) { + syn.trigger(form, 'submit', {}); + } + } + if (nodeName === 'a' && element.href && !/^\s*javascript:/.test(href)) { + scope.location.href = href; + } + if (nodeName === 'input' && type === 'checkbox') { + if (!syn.support.clickChanges) { + syn.trigger(element, 'change', {}); + } + } + if (nodeName === 'input' && type === 'radio') { + if (radioChanged && !syn.support.radioClickChanges) { + syn.trigger(element, 'change', {}); + } + } + if (nodeName === 'option' && createChange) { + syn.trigger(element.parentNode, 'change', {}); + syn.data(element, 'createChange', false); + } + } + }); + h.extend(syn.create, { + mouse: { + options: function (type, options, element) { + var doc = document.documentElement, body = document.body, center = [ + options.pageX || 0, + options.pageY || 0 + ], left = syn.mouse.browser && syn.mouse.browser.left[type], right = syn.mouse.browser && syn.mouse.browser.right[type]; + return h.extend({ + bubbles: true, + cancelable: true, + view: window, + detail: 1, + screenX: 1, + screenY: 1, + clientX: options.clientX || center[0] - (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0), + clientY: options.clientY || center[1] - (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0), + ctrlKey: !!syn.key.ctrlKey, + altKey: !!syn.key.altKey, + shiftKey: !!syn.key.shiftKey, + metaKey: !!syn.key.metaKey, + button: left && left.button !== null ? left.button : right && right.button || (type === 'contextmenu' ? 2 : 0), + relatedTarget: document.documentElement + }, options); + }, + event: function (type, defaults, element) { + var doc = getWin(element).document || document, event; + if (doc.createEvent) { + try { + event = doc.createEvent('MouseEvents'); + event.initMouseEvent(type, defaults.bubbles, defaults.cancelable, defaults.view, defaults.detail, defaults.screenX, defaults.screenY, defaults.clientX, defaults.clientY, defaults.ctrlKey, defaults.altKey, defaults.shiftKey, defaults.metaKey, defaults.button, defaults.relatedTarget); + } catch (e) { + event = h.createBasicStandardEvent(type, defaults, doc); + } + event.synthetic = true; + return event; + } else { + try { + event = h.createEventObject(type, defaults, element); + } catch (e) { + } + return event; + } + } + }, + click: { + setup: function (type, options, element) { + var nodeName = element.nodeName.toLowerCase(); + if (!syn.support.clickChecks && !syn.support.changeChecks && nodeName === 'input') { + type = element.type.toLowerCase(); + if (type === 'checkbox') { + element.checked = !element.checked; + } + if (type === 'radio') { + if (!element.checked) { + try { + syn.data(element, 'radioChanged', true); + } catch (e) { + } + element.checked = true; + } + } + } + if (nodeName === 'a' && element.href && !/^\s*javascript:/.test(element.href)) { + syn.data(element, 'href', element.href); + } + if (/option/i.test(element.nodeName)) { + var child = element.parentNode.firstChild, i = -1; + while (child) { + if (child.nodeType === 1) { + i++; + if (child === element) { + break; + } + } + child = child.nextSibling; + } + if (i !== element.parentNode.selectedIndex) { + element.parentNode.selectedIndex = i; + syn.data(element, 'createChange', true); + } + } + } + }, + mousedown: { + setup: function (type, options, element) { + var nn = element.nodeName.toLowerCase(); + if (syn.browser.safari && (nn === 'select' || nn === 'option')) { + options._autoPrevent = true; + } + } + } + }); +}); +/*syn@0.5.0#dist/cjs/mouse.support.js*/ +define('syn/dist/cjs/mouse.support.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + require('syn/dist/cjs/mouse.js'); + (function checkSupport() { + if (!document.body) { + return syn.schedule(checkSupport, 1); + } + window.__synthTest = function () { + syn.support.linkHrefJS = true; + }; + var div = document.createElement('div'), checkbox, submit, form, select; + div.innerHTML = '
' + '' + '' + '' + '' + '' + '' + '' + '' + '
'; + document.documentElement.appendChild(div); + form = div.firstChild; + checkbox = form.childNodes[0]; + submit = form.childNodes[2]; + select = form.getElementsByTagName('select')[0]; + syn.trigger(form.childNodes[6], 'click', {}); + checkbox.checked = false; + checkbox.onchange = function () { + syn.support.clickChanges = true; + }; + syn.trigger(checkbox, 'click', {}); + syn.support.clickChecks = checkbox.checked; + checkbox.checked = false; + syn.trigger(checkbox, 'change', {}); + syn.support.changeChecks = checkbox.checked; + form.onsubmit = function (ev) { + if (ev.preventDefault) { + ev.preventDefault(); + } + syn.support.clickSubmits = true; + return false; + }; + syn.trigger(submit, 'click', {}); + form.childNodes[1].onchange = function () { + syn.support.radioClickChanges = true; + }; + syn.trigger(form.childNodes[1], 'click', {}); + syn.bind(div, 'click', function onclick() { + syn.support.optionClickBubbles = true; + syn.unbind(div, 'click', onclick); + }); + syn.trigger(select.firstChild, 'click', {}); + syn.support.changeBubbles = syn.eventSupported('change'); + div.onclick = function () { + syn.support.mouseDownUpClicks = true; + }; + syn.trigger(div, 'mousedown', {}); + syn.trigger(div, 'mouseup', {}); + document.documentElement.removeChild(div); + syn.support.pointerEvents = syn.eventSupported('pointerdown'); + syn.support.touchEvents = syn.eventSupported('touchstart'); + syn.support.ready++; + }()); +}); +/*syn@0.5.0#dist/cjs/browsers.js*/ +define('syn/dist/cjs/browsers.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + require('syn/dist/cjs/mouse.js'); + syn.key.browsers = { + webkit: { + 'prevent': { + 'keyup': [], + 'keydown': [ + 'char', + 'keypress' + ], + 'keypress': ['char'] + }, + 'character': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 'char', + 'char' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'specialChars': { + 'keydown': [ + 0, + 'char' + ], + 'keyup': [ + 0, + 'char' + ] + }, + 'navigation': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'special': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'tab': { + 'keydown': [ + 0, + 'char' + ], + 'keyup': [ + 0, + 'char' + ] + }, + 'pause-break': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'caps': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'escape': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'num-lock': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'scroll-lock': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'print': { + 'keyup': [ + 0, + 'key' + ] + }, + 'function': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + '\r': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 'char', + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + } + }, + gecko: { + 'prevent': { + 'keyup': [], + 'keydown': ['char'], + 'keypress': ['char'] + }, + 'character': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 'char', + 0 + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'specialChars': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'navigation': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'special': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + '\t': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'pause-break': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'caps': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'escape': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'num-lock': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'scroll-lock': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + 'print': { + 'keyup': [ + 0, + 'key' + ] + }, + 'function': { + 'keydown': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + }, + '\r': { + 'keydown': [ + 0, + 'key' + ], + 'keypress': [ + 0, + 'key' + ], + 'keyup': [ + 0, + 'key' + ] + } + }, + msie: { + 'prevent': { + 'keyup': [], + 'keydown': [ + 'char', + 'keypress' + ], + 'keypress': ['char'] + }, + 'character': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'char' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'specialChars': { + 'keydown': [ + null, + 'char' + ], + 'keyup': [ + null, + 'char' + ] + }, + 'navigation': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'special': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'tab': { + 'keydown': [ + null, + 'char' + ], + 'keyup': [ + null, + 'char' + ] + }, + 'pause-break': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'caps': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'escape': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'num-lock': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'scroll-lock': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'print': { + 'keyup': [ + null, + 'key' + ] + }, + 'function': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + '\r': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + } + }, + opera: { + 'prevent': { + 'keyup': [], + 'keydown': [], + 'keypress': ['char'] + }, + 'character': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'char' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'specialChars': { + 'keydown': [ + null, + 'char' + ], + 'keypress': [ + null, + 'char' + ], + 'keyup': [ + null, + 'char' + ] + }, + 'navigation': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ] + }, + 'special': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'tab': { + 'keydown': [ + null, + 'char' + ], + 'keypress': [ + null, + 'char' + ], + 'keyup': [ + null, + 'char' + ] + }, + 'pause-break': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'caps': { + 'keydown': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'escape': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ] + }, + 'num-lock': { + 'keyup': [ + null, + 'key' + ], + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ] + }, + 'scroll-lock': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + 'print': {}, + 'function': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + }, + '\r': { + 'keydown': [ + null, + 'key' + ], + 'keypress': [ + null, + 'key' + ], + 'keyup': [ + null, + 'key' + ] + } + } + }; + syn.mouse.browsers = { + webkit: { + 'right': { + 'mousedown': { + 'button': 2, + 'which': 3 + }, + 'mouseup': { + 'button': 2, + 'which': 3 + }, + 'contextmenu': { + 'button': 2, + 'which': 3 + } + }, + 'left': { + 'mousedown': { + 'button': 0, + 'which': 1 + }, + 'mouseup': { + 'button': 0, + 'which': 1 + }, + 'click': { + 'button': 0, + 'which': 1 + } + } + }, + opera: { + 'right': { + 'mousedown': { + 'button': 2, + 'which': 3 + }, + 'mouseup': { + 'button': 2, + 'which': 3 + } + }, + 'left': { + 'mousedown': { + 'button': 0, + 'which': 1 + }, + 'mouseup': { + 'button': 0, + 'which': 1 + }, + 'click': { + 'button': 0, + 'which': 1 + } + } + }, + msie: { + 'right': { + 'mousedown': { 'button': 2 }, + 'mouseup': { 'button': 2 }, + 'contextmenu': { 'button': 0 } + }, + 'left': { + 'mousedown': { 'button': 1 }, + 'mouseup': { 'button': 1 }, + 'click': { 'button': 0 } + } + }, + chrome: { + 'right': { + 'mousedown': { + 'button': 2, + 'which': 3 + }, + 'mouseup': { + 'button': 2, + 'which': 3 + }, + 'contextmenu': { + 'button': 2, + 'which': 3 + } + }, + 'left': { + 'mousedown': { + 'button': 0, + 'which': 1 + }, + 'mouseup': { + 'button': 0, + 'which': 1 + }, + 'click': { + 'button': 0, + 'which': 1 + } + } + }, + gecko: { + 'left': { + 'mousedown': { + 'button': 0, + 'which': 1 + }, + 'mouseup': { + 'button': 0, + 'which': 1 + }, + 'click': { + 'button': 0, + 'which': 1 + } + }, + 'right': { + 'mousedown': { + 'button': 2, + 'which': 3 + }, + 'mouseup': { + 'button': 2, + 'which': 3 + }, + 'contextmenu': { + 'button': 2, + 'which': 3 + } + } + } + }; + syn.key.browser = function () { + if (syn.key.browsers[window.navigator.userAgent]) { + return syn.key.browsers[window.navigator.userAgent]; + } + for (var browser in syn.browser) { + if (syn.browser[browser] && syn.key.browsers[browser]) { + return syn.key.browsers[browser]; + } + } + return syn.key.browsers.gecko; + }(); + syn.mouse.browser = function () { + if (syn.mouse.browsers[window.navigator.userAgent]) { + return syn.mouse.browsers[window.navigator.userAgent]; + } + for (var browser in syn.browser) { + if (syn.browser[browser] && syn.mouse.browsers[browser]) { + return syn.mouse.browsers[browser]; + } + } + return syn.mouse.browsers.gecko; + }(); +}); +/*syn@0.5.0#dist/cjs/typeable.js*/ +define('syn/dist/cjs/typeable.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + var typeables = []; + var __indexOf = [].indexOf || function (item) { + for (var i = 0, l = this.length; i < l; i++) { + if (i in this && this[i] === item) { + return i; + } + } + return -1; + }; + syn.typeable = function (fn) { + if (__indexOf.call(typeables, fn) === -1) { + typeables.push(fn); + } + }; + syn.typeable.test = function (el) { + for (var i = 0, len = typeables.length; i < len; i++) { + if (typeables[i](el)) { + return true; + } + } + return false; + }; + var type = syn.typeable; + var typeableExp = /input|textarea/i; + type(function (el) { + return typeableExp.test(el.nodeName); + }); + type(function (el) { + return __indexOf.call([ + '', + 'true' + ], el.getAttribute('contenteditable')) !== -1; + }); +}); +/*syn@0.5.0#dist/cjs/key.js*/ +define('syn/dist/cjs/key.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + require('syn/dist/cjs/typeable.js'); + require('syn/dist/cjs/browsers.js'); + var h = syn.helpers, formElExp = /input|textarea/i, supportsSelection = function (el) { + var result; + try { + result = el.selectionStart !== undefined && el.selectionStart !== null; + } catch (e) { + result = false; + } + return result; + }, getSelection = function (el) { + var real, r, start; + if (supportsSelection(el)) { + if (document.activeElement && document.activeElement !== el && el.selectionStart === el.selectionEnd && el.selectionStart === 0) { + return { + start: el.value.length, + end: el.value.length + }; + } + return { + start: el.selectionStart, + end: el.selectionEnd + }; + } else { + try { + if (el.nodeName.toLowerCase() === 'input') { + real = h.getWindow(el).document.selection.createRange(); + r = el.createTextRange(); + r.setEndPoint('EndToStart', real); + start = r.text.length; + return { + start: start, + end: start + real.text.length + }; + } else { + real = h.getWindow(el).document.selection.createRange(); + r = real.duplicate(); + var r2 = real.duplicate(), r3 = real.duplicate(); + r2.collapse(); + r3.collapse(false); + r2.moveStart('character', -1); + r3.moveStart('character', -1); + r.moveToElementText(el); + r.setEndPoint('EndToEnd', real); + start = r.text.length - real.text.length; + var end = r.text.length; + if (start !== 0 && r2.text === '') { + start += 2; + } + if (end !== 0 && r3.text === '') { + end += 2; + } + return { + start: start, + end: end + }; + } + } catch (e) { + var prop = formElExp.test(el.nodeName) ? 'value' : 'textContent'; + return { + start: el[prop].length, + end: el[prop].length + }; + } + } + }, getFocusable = function (el) { + var document = h.getWindow(el).document, res = []; + var els = document.getElementsByTagName('*'), len = els.length; + for (var i = 0; i < len; i++) { + if (syn.isFocusable(els[i]) && els[i] !== document.documentElement) { + res.push(els[i]); + } + } + return res; + }, textProperty = function () { + var el = document.createElement('span'); + return el.textContent != null ? 'textContent' : 'innerText'; + }(), getText = function (el) { + if (formElExp.test(el.nodeName)) { + return el.value; + } + return el[textProperty]; + }, setText = function (el, value) { + if (formElExp.test(el.nodeName)) { + el.value = value; + } else { + el[textProperty] = value; + } + }; + h.extend(syn, { + keycodes: { + '\b': 8, + '\t': 9, + '\r': 13, + 'shift': 16, + 'ctrl': 17, + 'alt': 18, + 'meta': 91, + 'pause-break': 19, + 'caps': 20, + 'escape': 27, + 'num-lock': 144, + 'scroll-lock': 145, + 'print': 44, + 'page-up': 33, + 'page-down': 34, + 'end': 35, + 'home': 36, + 'left': 37, + 'up': 38, + 'right': 39, + 'down': 40, + 'insert': 45, + 'delete': 46, + ' ': 32, + '0': 48, + '1': 49, + '2': 50, + '3': 51, + '4': 52, + '5': 53, + '6': 54, + '7': 55, + '8': 56, + '9': 57, + 'a': 65, + 'b': 66, + 'c': 67, + 'd': 68, + 'e': 69, + 'f': 70, + 'g': 71, + 'h': 72, + 'i': 73, + 'j': 74, + 'k': 75, + 'l': 76, + 'm': 77, + 'n': 78, + 'o': 79, + 'p': 80, + 'q': 81, + 'r': 82, + 's': 83, + 't': 84, + 'u': 85, + 'v': 86, + 'w': 87, + 'x': 88, + 'y': 89, + 'z': 90, + 'num0': 96, + 'num1': 97, + 'num2': 98, + 'num3': 99, + 'num4': 100, + 'num5': 101, + 'num6': 102, + 'num7': 103, + 'num8': 104, + 'num9': 105, + '*': 106, + '+': 107, + 'subtract': 109, + 'decimal': 110, + 'divide': 111, + ';': 186, + '=': 187, + ',': 188, + 'dash': 189, + '-': 189, + 'period': 190, + '.': 190, + 'forward-slash': 191, + '/': 191, + '`': 192, + '[': 219, + '\\': 220, + ']': 221, + '\'': 222, + 'left window key': 91, + 'right window key': 92, + 'select key': 93, + 'f1': 112, + 'f2': 113, + 'f3': 114, + 'f4': 115, + 'f5': 116, + 'f6': 117, + 'f7': 118, + 'f8': 119, + 'f9': 120, + 'f10': 121, + 'f11': 122, + 'f12': 123 + }, + selectText: function (el, start, end) { + if (supportsSelection(el)) { + if (!end) { + syn.__tryFocus(el); + el.setSelectionRange(start, start); + } else { + el.selectionStart = start; + el.selectionEnd = end; + } + } else if (el.createTextRange) { + var r = el.createTextRange(); + r.moveStart('character', start); + end = end || start; + r.moveEnd('character', end - el.value.length); + r.select(); + } + }, + getText: function (el) { + if (syn.typeable.test(el)) { + var sel = getSelection(el); + return el.value.substring(sel.start, sel.end); + } + var win = syn.helpers.getWindow(el); + if (win.getSelection) { + return win.getSelection().toString(); + } else if (win.document.getSelection) { + return win.document.getSelection().toString(); + } else { + return win.document.selection.createRange().text; + } + }, + getSelection: getSelection + }); + h.extend(syn.key, { + data: function (key) { + if (syn.key.browser[key]) { + return syn.key.browser[key]; + } + for (var kind in syn.key.kinds) { + if (h.inArray(key, syn.key.kinds[kind]) > -1) { + return syn.key.browser[kind]; + } + } + return syn.key.browser.character; + }, + isSpecial: function (keyCode) { + var specials = syn.key.kinds.special; + for (var i = 0; i < specials.length; i++) { + if (syn.keycodes[specials[i]] === keyCode) { + return specials[i]; + } + } + }, + options: function (key, event) { + var keyData = syn.key.data(key); + if (!keyData[event]) { + return null; + } + var charCode = keyData[event][0], keyCode = keyData[event][1], result = {}; + if (keyCode === 'key') { + result.keyCode = syn.keycodes[key]; + } else if (keyCode === 'char') { + result.keyCode = key.charCodeAt(0); + } else { + result.keyCode = keyCode; + } + if (charCode === 'char') { + result.charCode = key.charCodeAt(0); + } else if (charCode !== null) { + result.charCode = charCode; + } + if (result.keyCode) { + result.which = result.keyCode; + } else { + result.which = result.charCode; + } + return result; + }, + kinds: { + special: [ + 'shift', + 'ctrl', + 'alt', + 'meta', + 'caps' + ], + specialChars: ['\b'], + navigation: [ + 'page-up', + 'page-down', + 'end', + 'home', + 'left', + 'up', + 'right', + 'down', + 'insert', + 'delete' + ], + 'function': [ + 'f1', + 'f2', + 'f3', + 'f4', + 'f5', + 'f6', + 'f7', + 'f8', + 'f9', + 'f10', + 'f11', + 'f12' + ] + }, + getDefault: function (key) { + if (syn.key.defaults[key]) { + return syn.key.defaults[key]; + } + for (var kind in syn.key.kinds) { + if (h.inArray(key, syn.key.kinds[kind]) > -1 && syn.key.defaults[kind]) { + return syn.key.defaults[kind]; + } + } + return syn.key.defaults.character; + }, + defaults: { + 'character': function (options, scope, key, force, sel) { + if (/num\d+/.test(key)) { + key = key.match(/\d+/)[0]; + } + if (force || !syn.support.keyCharacters && syn.typeable.test(this)) { + var current = getText(this), before = current.substr(0, sel.start), after = current.substr(sel.end), character = key; + setText(this, before + character + after); + var charLength = character === '\n' && syn.support.textareaCarriage ? 2 : character.length; + syn.selectText(this, before.length + charLength); + } + }, + 'c': function (options, scope, key, force, sel) { + if (syn.key.ctrlKey) { + syn.key.clipboard = syn.getText(this); + } else { + syn.key.defaults.character.apply(this, arguments); + } + }, + 'v': function (options, scope, key, force, sel) { + if (syn.key.ctrlKey) { + syn.key.defaults.character.call(this, options, scope, syn.key.clipboard, true, sel); + } else { + syn.key.defaults.character.apply(this, arguments); + } + }, + 'a': function (options, scope, key, force, sel) { + if (syn.key.ctrlKey) { + syn.selectText(this, 0, getText(this).length); + } else { + syn.key.defaults.character.apply(this, arguments); + } + }, + 'home': function () { + syn.onParents(this, function (el) { + if (el.scrollHeight !== el.clientHeight) { + el.scrollTop = 0; + return false; + } + }); + }, + 'end': function () { + syn.onParents(this, function (el) { + if (el.scrollHeight !== el.clientHeight) { + el.scrollTop = el.scrollHeight; + return false; + } + }); + }, + 'page-down': function () { + syn.onParents(this, function (el) { + if (el.scrollHeight !== el.clientHeight) { + var ch = el.clientHeight; + el.scrollTop += ch; + return false; + } + }); + }, + 'page-up': function () { + syn.onParents(this, function (el) { + if (el.scrollHeight !== el.clientHeight) { + var ch = el.clientHeight; + el.scrollTop -= ch; + return false; + } + }); + }, + '\b': function (options, scope, key, force, sel) { + if (!syn.support.backspaceWorks && syn.typeable.test(this)) { + var current = getText(this), before = current.substr(0, sel.start), after = current.substr(sel.end); + if (sel.start === sel.end && sel.start > 0) { + setText(this, before.substring(0, before.length - 1) + after); + syn.selectText(this, sel.start - 1); + } else { + setText(this, before + after); + syn.selectText(this, sel.start); + } + } + }, + 'delete': function (options, scope, key, force, sel) { + if (!syn.support.backspaceWorks && syn.typeable.test(this)) { + var current = getText(this), before = current.substr(0, sel.start), after = current.substr(sel.end); + if (sel.start === sel.end && sel.start <= getText(this).length - 1) { + setText(this, before + after.substring(1)); + } else { + setText(this, before + after); + } + syn.selectText(this, sel.start); + } + }, + '\r': function (options, scope, key, force, sel) { + var nodeName = this.nodeName.toLowerCase(); + if (nodeName === 'input') { + syn.trigger(this, 'change', {}); + } + if (!syn.support.keypressSubmits && nodeName === 'input') { + var form = syn.closest(this, 'form'); + if (form) { + syn.trigger(form, 'submit', {}); + } + } + if (!syn.support.keyCharacters && nodeName === 'textarea') { + syn.key.defaults.character.call(this, options, scope, '\n', undefined, sel); + } + if (!syn.support.keypressOnAnchorClicks && nodeName === 'a') { + syn.trigger(this, 'click', {}); + } + }, + '\t': function (options, scope) { + var focusEls = getFocusable(this), current = null, i = 0, el, firstNotIndexed, orders = []; + for (; i < focusEls.length; i++) { + orders.push([ + focusEls[i], + i + ]); + } + var sort = function (order1, order2) { + var el1 = order1[0], el2 = order2[0], tab1 = syn.tabIndex(el1) || 0, tab2 = syn.tabIndex(el2) || 0; + if (tab1 === tab2) { + return order1[1] - order2[1]; + } else { + if (tab1 === 0) { + return 1; + } else if (tab2 === 0) { + return -1; + } else { + return tab1 - tab2; + } + } + }; + orders.sort(sort); + for (i = 0; i < orders.length; i++) { + el = orders[i][0]; + if (this === el) { + if (!syn.key.shiftKey) { + current = orders[i + 1][0]; + if (!current) { + current = orders[0][0]; + } + } else { + current = orders[i - 1][0]; + if (!current) { + current = orders[focusEls.length - 1][0]; + } + } + } + } + if (!current) { + current = firstNotIndexed; + } else { + syn.__tryFocus(current); + } + return current; + }, + 'left': function (options, scope, key, force, sel) { + if (syn.typeable.test(this)) { + if (syn.key.shiftKey) { + syn.selectText(this, sel.start === 0 ? 0 : sel.start - 1, sel.end); + } else { + syn.selectText(this, sel.start === 0 ? 0 : sel.start - 1); + } + } + }, + 'right': function (options, scope, key, force, sel) { + if (syn.typeable.test(this)) { + if (syn.key.shiftKey) { + syn.selectText(this, sel.start, sel.end + 1 > getText(this).length ? getText(this).length : sel.end + 1); + } else { + syn.selectText(this, sel.end + 1 > getText(this).length ? getText(this).length : sel.end + 1); + } + } + }, + 'up': function () { + if (/select/i.test(this.nodeName)) { + this.selectedIndex = this.selectedIndex ? this.selectedIndex - 1 : 0; + } + }, + 'down': function () { + if (/select/i.test(this.nodeName)) { + syn.changeOnBlur(this, 'selectedIndex', this.selectedIndex); + this.selectedIndex = this.selectedIndex + 1; + } + }, + 'shift': function () { + return null; + }, + 'ctrl': function () { + return null; + }, + 'alt': function () { + return null; + }, + 'meta': function () { + return null; + } + } + }); + h.extend(syn.create, { + keydown: { + setup: function (type, options, element) { + if (h.inArray(options, syn.key.kinds.special) !== -1) { + syn.key[options + 'Key'] = element; + } + } + }, + keypress: { + setup: function (type, options, element) { + if (syn.support.keyCharacters && !syn.support.keysOnNotFocused) { + syn.__tryFocus(element); + } + } + }, + keyup: { + setup: function (type, options, element) { + if (h.inArray(options, syn.key.kinds.special) !== -1) { + syn.key[options + 'Key'] = null; + } + } + }, + key: { + options: function (type, options, element) { + options = typeof options !== 'object' ? { character: options } : options; + options = h.extend({}, options); + if (options.character) { + h.extend(options, syn.key.options(options.character, type)); + delete options.character; + } + options = h.extend({ + ctrlKey: !!syn.key.ctrlKey, + altKey: !!syn.key.altKey, + shiftKey: !!syn.key.shiftKey, + metaKey: !!syn.key.metaKey + }, options); + return options; + }, + event: function (type, options, element) { + var doc = h.getWindow(element).document || document, event; + if (doc.createEvent) { + try { + event = doc.createEvent('KeyEvents'); + event.initKeyEvent(type, true, true, window, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.keyCode, options.charCode); + } catch (e) { + event = h.createBasicStandardEvent(type, options, doc); + } + event.synthetic = true; + return event; + } else { + try { + event = h.createEventObject.apply(this, arguments); + h.extend(event, options); + } catch (e) { + } + return event; + } + } + } + }); + var convert = { + 'enter': '\r', + 'backspace': '\b', + 'tab': '\t', + 'space': ' ' + }; + h.extend(syn.init.prototype, { + _key: function (element, options, callback) { + if (/-up$/.test(options) && h.inArray(options.replace('-up', ''), syn.key.kinds.special) !== -1) { + syn.trigger(element, 'keyup', options.replace('-up', '')); + return callback(true, element); + } + var activeElement = h.getWindow(element).document.activeElement, caret = syn.typeable.test(element) && getSelection(element), key = convert[options] || options, runDefaults = syn.trigger(element, 'keydown', key), getDefault = syn.key.getDefault, prevent = syn.key.browser.prevent, defaultResult, keypressOptions = syn.key.options(key, 'keypress'); + if (runDefaults) { + if (!keypressOptions) { + defaultResult = getDefault(key).call(element, keypressOptions, h.getWindow(element), key, undefined, caret); + } else { + if (activeElement !== h.getWindow(element).document.activeElement) { + element = h.getWindow(element).document.activeElement; + } + runDefaults = syn.trigger(element, 'keypress', keypressOptions); + if (runDefaults) { + defaultResult = getDefault(key).call(element, keypressOptions, h.getWindow(element), key, undefined, caret); + } + } + } else { + if (keypressOptions && h.inArray('keypress', prevent.keydown) === -1) { + if (activeElement !== h.getWindow(element).document.activeElement) { + element = h.getWindow(element).document.activeElement; + } + syn.trigger(element, 'keypress', keypressOptions); + } + } + if (defaultResult && defaultResult.nodeName) { + element = defaultResult; + } + if (defaultResult !== null) { + syn.schedule(function () { + if (syn.support.oninput) { + syn.trigger(element, 'input', syn.key.options(key, 'input')); + } + syn.trigger(element, 'keyup', syn.key.options(key, 'keyup')); + callback(runDefaults, element); + }, 1); + } else { + callback(runDefaults, element); + } + return element; + }, + _type: function (element, options, callback) { + var parts = (options + '').match(/(\[[^\]]+\])|([^\[])/g), self = this, runNextPart = function (runDefaults, el) { + var part = parts.shift(); + if (!part) { + callback(runDefaults, el); + return; + } + el = el || element; + if (part.length > 1) { + part = part.substr(1, part.length - 2); + } + self._key(el, part, runNextPart); + }; + runNextPart(); + } + }); +}); +/*syn@0.5.0#dist/cjs/key.support.js*/ +define('syn/dist/cjs/key.support.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + require('syn/dist/cjs/key.js'); + if (!syn.config.support) { + (function checkForSupport() { + if (!document.body) { + return syn.schedule(checkForSupport, 1); + } + var div = document.createElement('div'), checkbox, submit, form, anchor, textarea, inputter, one, doc; + doc = document.documentElement; + div.innerHTML = '
' + '' + '' + '' + '' + '' + '' + '' + '' + '
'; + doc.insertBefore(div, doc.firstElementChild || doc.children[0]); + form = div.firstChild; + checkbox = form.childNodes[0]; + submit = form.childNodes[2]; + anchor = form.getElementsByTagName('a')[0]; + textarea = form.getElementsByTagName('textarea')[0]; + inputter = form.childNodes[3]; + one = form.childNodes[4]; + form.onsubmit = function (ev) { + if (ev.preventDefault) { + ev.preventDefault(); + } + syn.support.keypressSubmits = true; + ev.returnValue = false; + return false; + }; + syn.__tryFocus(inputter); + syn.trigger(inputter, 'keypress', '\r'); + syn.trigger(inputter, 'keypress', 'a'); + syn.support.keyCharacters = inputter.value === 'a'; + inputter.value = 'a'; + syn.trigger(inputter, 'keypress', '\b'); + syn.support.backspaceWorks = inputter.value === ''; + inputter.onchange = function () { + syn.support.focusChanges = true; + }; + syn.__tryFocus(inputter); + syn.trigger(inputter, 'keypress', 'a'); + syn.__tryFocus(form.childNodes[5]); + syn.trigger(inputter, 'keypress', 'b'); + syn.support.keysOnNotFocused = inputter.value === 'ab'; + syn.bind(anchor, 'click', function (ev) { + if (ev.preventDefault) { + ev.preventDefault(); + } + syn.support.keypressOnAnchorClicks = true; + ev.returnValue = false; + return false; + }); + syn.trigger(anchor, 'keypress', '\r'); + syn.support.textareaCarriage = textarea.value.length === 4; + syn.support.oninput = 'oninput' in one; + doc.removeChild(div); + syn.support.ready++; + }()); + } else { + syn.helpers.extend(syn.support, syn.config.support); + } +}); +/*syn@0.5.0#dist/cjs/drag.js*/ +define('syn/dist/cjs/drag.js', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + (function dragSupport() { + if (!document.body) { + syn.schedule(dragSupport, 1); + return; + } + var div = document.createElement('div'); + document.body.appendChild(div); + syn.helpers.extend(div.style, { + width: '100px', + height: '10000px', + backgroundColor: 'blue', + position: 'absolute', + top: '10px', + left: '0px', + zIndex: 19999 + }); + document.body.scrollTop = 11; + if (!document.elementFromPoint) { + return; + } + var el = document.elementFromPoint(3, 1); + if (el === div) { + syn.support.elementFromClient = true; + } else { + syn.support.elementFromPage = true; + } + document.body.removeChild(div); + document.body.scrollTop = 0; + }()); + var elementFromPoint = function (point, element) { + var clientX = point.clientX, clientY = point.clientY, win = syn.helpers.getWindow(element), el; + if (syn.support.elementFromPage) { + var off = syn.helpers.scrollOffset(win); + clientX = clientX + off.left; + clientY = clientY + off.top; + } + el = win.document.elementFromPoint ? win.document.elementFromPoint(clientX, clientY) : element; + if (el === win.document.documentElement && (point.clientY < 0 || point.clientX < 0)) { + return element; + } else { + return el; + } + }, createEventAtPoint = function (event, point, element) { + var el = elementFromPoint(point, element); + syn.trigger(el || element, event, point); + return el; + }, mouseMove = function (point, element, last) { + var el = elementFromPoint(point, element); + if (last !== el && el && last) { + var options = syn.helpers.extend({}, point); + options.relatedTarget = el; + if (syn.support.pointerEvents) { + syn.trigger(last, 'pointerout', options); + } + syn.trigger(last, 'mouseout', options); + options.relatedTarget = last; + if (syn.support.pointerEvents) { + syn.trigger(el, 'pointerover', options); + } + syn.trigger(el, 'mouseover', options); + } + if (syn.support.pointerEvents) { + syn.trigger(el || element, 'pointermove', point); + } + if (syn.support.touchEvents) { + syn.trigger(el || element, 'touchmove', point); + } + syn.trigger(el || element, 'mousemove', point); + return el; + }, startMove = function (start, end, duration, element, callback) { + var startTime = new Date(), distX = end.clientX - start.clientX, distY = end.clientY - start.clientY, win = syn.helpers.getWindow(element), current = elementFromPoint(start, element), cursor = win.document.createElement('div'), calls = 0, move; + move = function onmove() { + var now = new Date(), scrollOffset = syn.helpers.scrollOffset(win), fraction = (calls === 0 ? 0 : now - startTime) / duration, options = { + clientX: distX * fraction + start.clientX, + clientY: distY * fraction + start.clientY + }; + calls++; + if (fraction < 1) { + syn.helpers.extend(cursor.style, { + left: options.clientX + scrollOffset.left + 2 + 'px', + top: options.clientY + scrollOffset.top + 2 + 'px' + }); + current = mouseMove(options, element, current); + syn.schedule(onmove, 15); + } else { + current = mouseMove(end, element, current); + win.document.body.removeChild(cursor); + callback(); + } + }; + syn.helpers.extend(cursor.style, { + height: '5px', + width: '5px', + backgroundColor: 'red', + position: 'absolute', + zIndex: 19999, + fontSize: '1px' + }); + win.document.body.appendChild(cursor); + move(); + }, startDrag = function (start, end, duration, element, callback) { + if (syn.support.pointerEvents) { + createEventAtPoint('pointerdown', start, element); + } + if (syn.support.touchEvents) { + createEventAtPoint('touchstart', start, element); + } + createEventAtPoint('mousedown', start, element); + startMove(start, end, duration, element, function () { + if (syn.support.pointerEvents) { + createEventAtPoint('pointerup', end, element); + } + if (syn.support.touchEvents) { + createEventAtPoint('touchend', end, element); + } + createEventAtPoint('mouseup', end, element); + callback(); + }); + }, center = function (el) { + var j = syn.jquery()(el), o = j.offset(); + return { + pageX: o.left + j.outerWidth() / 2, + pageY: o.top + j.outerHeight() / 2 + }; + }, convertOption = function (option, win, from) { + var page = /(\d+)[x ](\d+)/, client = /(\d+)X(\d+)/, relative = /([+-]\d+)[xX ]([+-]\d+)/, parts; + if (typeof option === 'string' && relative.test(option) && from) { + var cent = center(from); + parts = option.match(relative); + option = { + pageX: cent.pageX + parseInt(parts[1]), + pageY: cent.pageY + parseInt(parts[2]) + }; + } + if (typeof option === 'string' && page.test(option)) { + parts = option.match(page); + option = { + pageX: parseInt(parts[1]), + pageY: parseInt(parts[2]) + }; + } + if (typeof option === 'string' && client.test(option)) { + parts = option.match(client); + option = { + clientX: parseInt(parts[1]), + clientY: parseInt(parts[2]) + }; + } + if (typeof option === 'string') { + option = syn.jquery()(option, win.document)[0]; + } + if (option.nodeName) { + option = center(option); + } + if (option.pageX != null) { + var off = syn.helpers.scrollOffset(win); + option = { + clientX: option.pageX - off.left, + clientY: option.pageY - off.top + }; + } + return option; + }, adjust = function (from, to, win) { + if (from.clientY < 0) { + var off = syn.helpers.scrollOffset(win); + var top = off.top + from.clientY - 100, diff = top - off.top; + if (top > 0) { + } else { + top = 0; + diff = -off.top; + } + from.clientY = from.clientY - diff; + to.clientY = to.clientY - diff; + syn.helpers.scrollOffset(win, { + top: top, + left: off.left + }); + } + }; + syn.helpers.extend(syn.init.prototype, { + _move: function (from, options, callback) { + var win = syn.helpers.getWindow(from), fro = convertOption(options.from || from, win, from), to = convertOption(options.to || options, win, from); + if (options.adjust !== false) { + adjust(fro, to, win); + } + startMove(fro, to, options.duration || 500, from, callback); + }, + _drag: function (from, options, callback) { + var win = syn.helpers.getWindow(from), fro = convertOption(options.from || from, win, from), to = convertOption(options.to || options, win, from); + if (options.adjust !== false) { + adjust(fro, to, win); + } + startDrag(fro, to, options.duration || 500, from, callback); + } + }); +}); +/*syn@0.5.0#dist/cjs/syn*/ +define('syn/dist/cjs/syn', function (require, exports, module) { + var syn = require('syn/dist/cjs/synthetic.js'); + require('syn/dist/cjs/mouse.support.js'); + require('syn/dist/cjs/browsers.js'); + require('syn/dist/cjs/key.support.js'); + require('syn/dist/cjs/drag.js'); + window.syn = syn; + module.exports = syn; +}); +/*jquery@1.11.0#dist/jquery*/ +(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); + }; + } 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('