/*[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.10.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) || navigator.userAgent.indexOf('Trident/') > -1,
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);
if (syn.support.pointerEvents) {
syn.trigger(element, 'pointerdown', mouseopts);
}
syn.trigger(element, 'mousedown', mouseopts);
schedule(function () {
if (syn.support.pointerEvents) {
syn.trigger(element, 'pointerup', mouseopts);
}
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.10.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.10.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.10.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.10.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.10.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.10.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.10.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.10.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('