Mailing-List: contact commits-help@aurora.incubator.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@aurora.incubator.apache.org
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: mansu@apache.org
To: commits@aurora.incubator.apache.org
Date: Wed, 28 May 2014 19:05:14 -0000
Message-Id: <8b926977ea214d99ba33a3632295e6ea@git.apache.org>
In-Reply-To: <73b073571760422d96358c8129905685@git.apache.org>
References: <73b073571760422d96358c8129905685@git.apache.org>
Subject: [05/29] Upgrade Aurora UI to bootstrap3

http://git-wip-us.apache.org/repos/asf/incubator-aurora/blob/3a992e2c/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js
----------------------------------------------------------------------
diff --git a/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js
new file mode 100644
index 0000000..7fa75e9
--- /dev/null
+++ b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-scenario.js
@@ -0,0 +1,26487 @@
+/*!
+ * jQuery JavaScript Library v1.7.2
+ * http://jquery.com/
+ *
+ * Copyright 2011, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ * Copyright 2011, The Dojo Foundation
+ * Released under the MIT, BSD, and GPL Licenses.
+ *
+ * Date: Wed Mar 21 12:46:34 2012 -0700
+ */
+(function (window, undefined) {
+    'use strict';
+
+// Use the correct document accordingly with window argument (sandbox)
+    var document = window.document,
+        navigator = window.navigator,
+        location = window.location;
+    var jQuery = (function () {
+
+// Define a local copy of jQuery
+        var jQuery = function (selector, context) {
+                // The jQuery object is actually just the init constructor 'enhanced'
+                return new jQuery.fn.init(selector, context, rootjQuery);
+            },
+
+        // Map over jQuery in case of overwrite
+            _jQuery = window.jQuery,
+
+        // Map over the $ in case of overwrite
+            _$ = window.$,
+
+        // A central reference to the root jQuery(document)
+            rootjQuery,
+
+        // A simple way to check for HTML strings or ID strings
+        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+            quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
+
+        // Check if a string has a non-whitespace character in it
+            rnotwhite = /\S/,
+
+        // Used for trimming whitespace
+            trimLeft = /^\s+/,
+            trimRight = /\s+$/,
+
+        // Match a standalone tag
+            rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
+
+        // JSON RegExp
+            rvalidchars = /^[\],:{}\s]*$/,
+            rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
+            rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
+            rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+
+        // Useragent RegExp
+            rwebkit = /(webkit)[ \/]([\w.]+)/,
+            ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
+            rmsie = /(msie) ([\w.]+)/,
+            rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
+
+        // Matches dashed string for camelizing
+            rdashAlpha = /-([a-z]|[0-9])/ig,
+            rmsPrefix = /^-ms-/,
+
+        // Used by jQuery.camelCase as callback to replace()
+            fcamelCase = function (all, letter) {
+                return ( letter + "" ).toUpperCase();
+            },
+
+        // Keep a UserAgent string for use with jQuery.browser
+            userAgent = navigator.userAgent,
+
+        // For matching the engine and version of the browser
+            browserMatch,
+
+        // The deferred used on DOM ready
+            readyList,
+
+        // The ready event handler
+            DOMContentLoaded,
+
+        // Save a reference to some core methods
+            toString = Object.prototype.toString,
+            hasOwn = Object.prototype.hasOwnProperty,
+            push = Array.prototype.push,
+            slice = Array.prototype.slice,
+            trim = String.prototype.trim,
+            indexOf = Array.prototype.indexOf,
+
+        // [[Class]] -> type pairs
+            class2type = {};
+
+        jQuery.fn = jQuery.prototype = {
+            constructor: jQuery,
+            init: function (selector, context, rootjQuery) {
+                var match, elem, ret, doc;
+
+                // Handle $(""), $(null), or $(undefined)
+                if (!selector) {
+                    return this;
+                }
+
+                // Handle $(DOMElement)
+                if (selector.nodeType) {
+                    this.context = this[0] = selector;
+                    this.length = 1;
+                    return this;
+                }
+
+                // The body element only exists once, optimize finding it
+                if (selector === "body" && !context && document.body) {
+                    this.context = document;
+                    this[0] = document.body;
+                    this.selector = selector;
+                    this.length = 1;
+                    return this;
+                }
+
+                // Handle HTML strings
+                if (typeof selector === "string") {
+                    // Are we dealing with HTML string or an ID?
+                    if (selector.charAt(0) === "<" && selector.charAt(selector.length - 1) === ">" && selector.length >= 3) {
+                        // Assume that strings that start and end with <> are HTML and skip the regex check
+                        match = [ null, selector, null ];
+
+                    } else {
+                        match = quickExpr.exec(selector);
+                    }
+
+                    // Verify a match, and that no context was specified for #id
+                    if (match && (match[1] || !context)) {
+
+                        // HANDLE: $(html) -> $(array)
+                        if (match[1]) {
+                            context = context instanceof jQuery ? context[0] : context;
+                            doc = ( context ? context.ownerDocument || context : document );
+
+                            // If a single string is passed in and it's a single tag
+                            // just do a createElement and skip the rest
+                            ret = rsingleTag.exec(selector);
+
+                            if (ret) {
+                                if (jQuery.isPlainObject(context)) {
+                                    selector = [ document.createElement(ret[1]) ];
+                                    jQuery.fn.attr.call(selector, context, true);
+
+                                } else {
+                                    selector = [ doc.createElement(ret[1]) ];
+                                }
+
+                            } else {
+                                ret = jQuery.buildFragment([ match[1] ], [ doc ]);
+                                selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
+                            }
+
+                            return jQuery.merge(this, selector);
+
+                            // HANDLE: $("#id")
+                        } else {
+                            elem = document.getElementById(match[2]);
+
+                            // Check parentNode to catch when Blackberry 4.6 returns
+                            // nodes that are no longer in the document #6963
+                            if (elem && elem.parentNode) {
+                                // Handle the case where IE and Opera return items
+                                // by name instead of ID
+                                if (elem.id !== match[2]) {
+                                    return rootjQuery.find(selector);
+                                }
+
+                                // Otherwise, we inject the element directly into the jQuery object
+                                this.length = 1;
+                                this[0] = elem;
+                            }
+
+                            this.context = document;
+                            this.selector = selector;
+                            return this;
+                        }
+
+                        // HANDLE: $(expr, $(...))
+                    } else if (!context || context.jquery) {
+                        return ( context || rootjQuery ).find(selector);
+
+                        // HANDLE: $(expr, context)
+                        // (which is just equivalent to: $(context).find(expr)
+                    } else {
+                        return this.constructor(context).find(selector);
+                    }
+
+                    // HANDLE: $(function)
+                    // Shortcut for document ready
+                } else if (jQuery.isFunction(selector)) {
+                    return rootjQuery.ready(selector);
+                }
+
+                if (selector.selector !== undefined) {
+                    this.selector = selector.selector;
+                    this.context = selector.context;
+                }
+
+                return jQuery.makeArray(selector, this);
+            },
+
+            // Start with an empty selector
+            selector: "",
+
+            // The current version of jQuery being used
+            jquery: "1.7.2",
+
+            // The default length of a jQuery object is 0
+            length: 0,
+
+            // The number of elements contained in the matched element set
+            size: function () {
+                return this.length;
+            },
+
+            toArray: function () {
+                return slice.call(this, 0);
+            },
+
+            // Get the Nth element in the matched element set OR
+            // Get the whole matched element set as a clean array
+            get: function (num) {
+                return num == null ?
+
+                    // Return a 'clean' array
+                    this.toArray() :
+
+                    // Return just the object
+                    ( num < 0 ? this[ this.length + num ] : this[ num ] );
+            },
+
+            // Take an array of elements and push it onto the stack
+            // (returning the new matched element set)
+            pushStack: function (elems, name, selector) {
+                // Build a new jQuery matched element set
+                var ret = this.constructor();
+
+                if (jQuery.isArray(elems)) {
+                    push.apply(ret, elems);
+
+                } else {
+                    jQuery.merge(ret, elems);
+                }
+
+                // Add the old object onto the stack (as a reference)
+                ret.prevObject = this;
+
+                ret.context = this.context;
+
+                if (name === "find") {
+                    ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
+                } else if (name) {
+                    ret.selector = this.selector + "." + name + "(" + selector + ")";
+                }
+
+                // Return the newly-formed element set
+                return ret;
+            },
+
+            // Execute a callback for every element in the matched set.
+            // (You can seed the arguments with an array of args, but this is
+            // only used internally.)
+            each: function (callback, args) {
+                return jQuery.each(this, callback, args);
+            },
+
+            ready: function (fn) {
+                // Attach the listeners
+                jQuery.bindReady();
+
+                // Add the callback
+                readyList.add(fn);
+
+                return this;
+            },
+
+            eq: function (i) {
+                i = +i;
+                return i === -1 ?
+                    this.slice(i) :
+                    this.slice(i, i + 1);
+            },
+
+            first: function () {
+                return this.eq(0);
+            },
+
+            last: function () {
+                return this.eq(-1);
+            },
+
+            slice: function () {
+                return this.pushStack(slice.apply(this, arguments),
+                    "slice", slice.call(arguments).join(","));
+            },
+
+            map: function (callback) {
+                return this.pushStack(jQuery.map(this, function (elem, i) {
+                    return callback.call(elem, i, elem);
+                }));
+            },
+
+            end: function () {
+                return this.prevObject || this.constructor(null);
+            },
+
+            // For internal use only.
+            // Behaves like an Array's method, not like a jQuery method.
+            push: push,
+            sort: [].sort,
+            splice: [].splice
+        };
+
+// Give the init function the jQuery prototype for later instantiation
+        jQuery.fn.init.prototype = jQuery.fn;
+
+        jQuery.extend = jQuery.fn.extend = function () {
+            var options, name, src, copy, copyIsArray, clone,
+                target = arguments[0] || {},
+                i = 1,
+                length = arguments.length,
+                deep = false;
+
+            // Handle a deep copy situation
+            if (typeof target === "boolean") {
+                deep = target;
+                target = arguments[1] || {};
+                // skip the boolean and the target
+                i = 2;
+            }
+
+            // Handle case when target is a string or something (possible in deep copy)
+            if (typeof target !== "object" && !jQuery.isFunction(target)) {
+                target = {};
+            }
+
+            // extend jQuery itself if only one argument is passed
+            if (length === i) {
+                target = this;
+                --i;
+            }
+
+            for (; i < length; i++) {
+                // Only deal with non-null/undefined values
+                if ((options = arguments[ i ]) != null) {
+                    // Extend the base object
+                    for (name in options) {
+                        src = target[ name ];
+                        copy = options[ name ];
+
+                        // Prevent never-ending loop
+                        if (target === copy) {
+                            continue;
+                        }
+
+                        // Recurse if we're merging plain objects or arrays
+                        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 : {};
+                            }
+
+                            // Never move original objects, clone them
+                            target[ name ] = jQuery.extend(deep, clone, copy);
+
+                            // Don't bring in undefined values
+                        } else if (copy !== undefined) {
+                            target[ name ] = copy;
+                        }
+                    }
+                }
+            }
+
+            // Return the modified object
+            return target;
+        };
+
+        jQuery.extend({
+            noConflict: function (deep) {
+                if (window.$ === jQuery) {
+                    window.$ = _$;
+                }
+
+                if (deep && window.jQuery === jQuery) {
+                    window.jQuery = _jQuery;
+                }
+
+                return jQuery;
+            },
+
+            // Is the DOM ready to be used? Set to true once it occurs.
+            isReady: false,
+
+            // A counter to track how many items to wait for before
+            // the ready event fires. See #6781
+            readyWait: 1,
+
+            // Hold (or release) the ready event
+            holdReady: function (hold) {
+                if (hold) {
+                    jQuery.readyWait++;
+                } else {
+                    jQuery.ready(true);
+                }
+            },
+
+            // Handle when the DOM is ready
+            ready: function (wait) {
+                // Either a released hold or an DOMready/load event and not yet ready
+                if ((wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady)) {
+                    // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+                    if (!document.body) {
+                        return setTimeout(jQuery.ready, 1);
+                    }
+
+                    // Remember that the DOM is ready
+                    jQuery.isReady = true;
+
+                    // If a normal DOM Ready event fired, decrement, and wait if need be
+                    if (wait !== true && --jQuery.readyWait > 0) {
+                        return;
+                    }
+
+                    // If there are functions bound, to execute
+                    readyList.fireWith(document, [ jQuery ]);
+
+                    // Trigger any bound ready events
+                    if (jQuery.fn.trigger) {
+                        jQuery(document).trigger("ready").off("ready");
+                    }
+                }
+            },
+
+            bindReady: function () {
+                if (readyList) {
+                    return;
+                }
+
+                readyList = jQuery.Callbacks("once memory");
+
+                // Catch cases where $(document).ready() is called after the
+                // browser event has already occurred.
+                if (document.readyState === "complete") {
+                    // Handle it asynchronously to allow scripts the opportunity to delay ready
+                    return setTimeout(jQuery.ready, 1);
+                }
+
+                // Mozilla, Opera and webkit nightlies currently support this event
+                if (document.addEventListener) {
+                    // Use the handy event callback
+                    document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
+
+                    // A fallback to window.onload, that will always work
+                    window.addEventListener("load", jQuery.ready, false);
+
+                    // If IE event model is used
+                } else if (document.attachEvent) {
+                    // ensure firing before onload,
+                    // maybe late but safe also for iframes
+                    document.attachEvent("onreadystatechange", DOMContentLoaded);
+
+                    // A fallback to window.onload, that will always work
+                    window.attachEvent("onload", jQuery.ready);
+
+                    // If IE and not a frame
+                    // continually check to see if the document is ready
+                    var toplevel = false;
+
+                    try {
+                        toplevel = window.frameElement == null;
+                    } catch (e) {
+                    }
+
+                    if (document.documentElement.doScroll && toplevel) {
+                        doScrollCheck();
+                    }
+                }
+            },
+
+            // See test/unit/core.js for details concerning isFunction.
+            // Since version 1.3, DOM methods and functions like alert
+            // aren't supported. They return false on IE (#2968).
+            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 !isNaN(parseFloat(obj)) && isFinite(obj);
+            },
+
+            type: function (obj) {
+                return obj == null ?
+                    String(obj) :
+                    class2type[ toString.call(obj) ] || "object";
+            },
+
+            isPlainObject: function (obj) {
+                // Must be an Object.
+                // Because of IE, we also have to check the presence of the constructor property.
+                // Make sure that DOM nodes and window objects don't pass through, as well
+                if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
+                    return false;
+                }
+
+                try {
+                    // Not own constructor property must be Object
+                    if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+                        return false;
+                    }
+                } catch (e) {
+                    // IE8,9 Will throw exceptions on certain host objects #9897
+                    return false;
+                }
+
+                // Own properties are enumerated firstly, so to speed up,
+                // if last one is own, then all properties are own.
+
+                var key;
+                for (key in obj) {
+                }
+
+                return key === undefined || hasOwn.call(obj, key);
+            },
+
+            isEmptyObject: function (obj) {
+                for (var name in obj) {
+                    return false;
+                }
+                return true;
+            },
+
+            error: function (msg) {
+                throw new Error(msg);
+            },
+
+            parseJSON: function (data) {
+                if (typeof data !== "string" || !data) {
+                    return null;
+                }
+
+                // Make sure leading/trailing whitespace is removed (IE can't handle it)
+                data = jQuery.trim(data);
+
+                // Attempt to parse using the native JSON parser first
+                if (window.JSON && window.JSON.parse) {
+                    return window.JSON.parse(data);
+                }
+
+                // Make sure the incoming data is actual JSON
+                // Logic borrowed from http://json.org/json2.js
+                if (rvalidchars.test(data.replace(rvalidescape, "@")
+                    .replace(rvalidtokens, "]")
+                    .replace(rvalidbraces, ""))) {
+
+                    return ( new Function("return " + data) )();
+
+                }
+                jQuery.error("Invalid JSON: " + data);
+            },
+
+            // Cross-browser xml parsing
+            parseXML: function (data) {
+                if (typeof data !== "string" || !data) {
+                    return null;
+                }
+                var xml, tmp;
+                try {
+                    if (window.DOMParser) { // Standard
+                        tmp = new DOMParser();
+                        xml = tmp.parseFromString(data, "text/xml");
+                    } else { // IE
+                        xml = new ActiveXObject("Microsoft.XMLDOM");
+                        xml.async = "false";
+                        xml.loadXML(data);
+                    }
+                } catch (e) {
+                    xml = undefined;
+                }
+                if (!xml || !xml.documentElement || xml.getElementsByTagName("parsererror").length) {
+                    jQuery.error("Invalid XML: " + data);
+                }
+                return xml;
+            },
+
+            noop: function () {
+            },
+
+            // Evaluates a script in a global context
+            // Workarounds based on findings by Jim Driscoll
+            // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+            globalEval: function (data) {
+                if (data && rnotwhite.test(data)) {
+                    // We use execScript on Internet Explorer
+                    // We use an anonymous function so that context is window
+                    // rather than jQuery in Firefox
+                    ( window.execScript || function (data) {
+                        window[ "eval" ].call(window, data);
+                    } )(data);
+                }
+            },
+
+            // Convert dashed to camelCase; used by the css and data modules
+            // Microsoft forgot to hump their vendor prefix (#9572)
+            camelCase: function (string) {
+                return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
+            },
+
+            nodeName: function (elem, name) {
+                return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
+            },
+
+            // args is for internal usage only
+            each: function (object, callback, args) {
+                var name, i = 0,
+                    length = object.length,
+                    isObj = length === undefined || jQuery.isFunction(object);
+
+                if (args) {
+                    if (isObj) {
+                        for (name in object) {
+                            if (callback.apply(object[ name ], args) === false) {
+                                break;
+                            }
+                        }
+                    } else {
+                        for (; i < length;) {
+                            if (callback.apply(object[ i++ ], args) === false) {
+                                break;
+                            }
+                        }
+                    }
+
+                    // A special, fast, case for the most common use of each
+                } else {
+                    if (isObj) {
+                        for (name in object) {
+                            if (callback.call(object[ name ], name, object[ name ]) === false) {
+                                break;
+                            }
+                        }
+                    } else {
+                        for (; i < length;) {
+                            if (callback.call(object[ i ], i, object[ i++ ]) === false) {
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                return object;
+            },
+
+            // Use native String.trim function wherever possible
+            trim: trim ?
+                function (text) {
+                    return text == null ?
+                        "" :
+                        trim.call(text);
+                } :
+
+                // Otherwise use our own trimming functionality
+                function (text) {
+                    return text == null ?
+                        "" :
+                        text.toString().replace(trimLeft, "").replace(trimRight, "");
+                },
+
+            // results is for internal usage only
+            makeArray: function (array, results) {
+                var ret = results || [];
+
+                if (array != null) {
+                    // The window, strings (and functions) also have 'length'
+                    // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
+                    var type = jQuery.type(array);
+
+                    if (array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow(array)) {
+                        push.call(ret, array);
+                    } else {
+                        jQuery.merge(ret, array);
+                    }
+                }
+
+                return ret;
+            },
+
+            inArray: function (elem, array, i) {
+                var len;
+
+                if (array) {
+                    if (indexOf) {
+                        return indexOf.call(array, elem, i);
+                    }
+
+                    len = array.length;
+                    i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
+
+                    for (; i < len; i++) {
+                        // Skip accessing in sparse arrays
+                        if (i in array && array[ i ] === elem) {
+                            return i;
+                        }
+                    }
+                }
+
+                return -1;
+            },
+
+            merge: function (first, second) {
+                var i = first.length,
+                    j = 0;
+
+                if (typeof second.length === "number") {
+                    for (var l = second.length; j < l; j++) {
+                        first[ i++ ] = second[ j ];
+                    }
+
+                } else {
+                    while (second[j] !== undefined) {
+                        first[ i++ ] = second[ j++ ];
+                    }
+                }
+
+                first.length = i;
+
+                return first;
+            },
+
+            grep: function (elems, callback, inv) {
+                var ret = [], retVal;
+                inv = !!inv;
+
+                // Go through the array, only saving the items
+                // that pass the validator function
+                for (var i = 0, length = elems.length; i < length; i++) {
+                    retVal = !!callback(elems[ i ], i);
+                    if (inv !== retVal) {
+                        ret.push(elems[ i ]);
+                    }
+                }
+
+                return ret;
+            },
+
+            // arg is for internal usage only
+            map: function (elems, callback, arg) {
+                var value, key, ret = [],
+                    i = 0,
+                    length = elems.length,
+                // jquery objects are treated as arrays
+                    isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length - 1 ] ) || length === 0 || jQuery.isArray(elems) );
+
+                // Go through the array, translating each of the items to their
+                if (isArray) {
+                    for (; i < length; i++) {
+                        value = callback(elems[ i ], i, arg);
+
+                        if (value != null) {
+                            ret[ ret.length ] = value;
+                        }
+                    }
+
+                    // Go through every key on the object,
+                } else {
+                    for (key in elems) {
+                        value = callback(elems[ key ], key, arg);
+
+                        if (value != null) {
+                            ret[ ret.length ] = value;
+                        }
+                    }
+                }
+
+                // Flatten any nested arrays
+                return ret.concat.apply([], ret);
+            },
+
+            // A global GUID counter for objects
+            guid: 1,
+
+            // Bind a function to a context, optionally partially applying any
+            // arguments.
+            proxy: function (fn, context) {
+                if (typeof context === "string") {
+                    var tmp = fn[ context ];
+                    context = fn;
+                    fn = tmp;
+                }
+
+                // Quick check to determine if target is callable, in the spec
+                // this throws a TypeError, but we will just return undefined.
+                if (!jQuery.isFunction(fn)) {
+                    return undefined;
+                }
+
+                // Simulated bind
+                var args = slice.call(arguments, 2),
+                    proxy = function () {
+                        return fn.apply(context, args.concat(slice.call(arguments)));
+                    };
+
+                // Set the guid of unique handler to the same of original handler, so it can be removed
+                proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
+
+                return proxy;
+            },
+
+            // Mutifunctional method to get and set values to a collection
+            // The value/s can optionally be executed if it's a function
+            access: function (elems, fn, key, value, chainable, emptyGet, pass) {
+                var exec,
+                    bulk = key == null,
+                    i = 0,
+                    length = elems.length;
+
+                // Sets many values
+                if (key && typeof key === "object") {
+                    for (i in key) {
+                        jQuery.access(elems, fn, i, key[i], 1, emptyGet, value);
+                    }
+                    chainable = 1;
+
+                    // Sets one value
+                } else if (value !== undefined) {
+                    // Optionally, function values get executed if exec is true
+                    exec = pass === undefined && jQuery.isFunction(value);
+
+                    if (bulk) {
+                        // Bulk operations only iterate when executing function values
+                        if (exec) {
+                            exec = fn;
+                            fn = function (elem, key, value) {
+                                return exec.call(jQuery(elem), value);
+                            };
+
+                            // Otherwise they run against the entire set
+                        } else {
+                            fn.call(elems, value);
+                            fn = null;
+                        }
+                    }
+
+                    if (fn) {
+                        for (; i < length; i++) {
+                            fn(elems[i], key, exec ? value.call(elems[i], i, fn(elems[i], key)) : value, pass);
+                        }
+                    }
+
+                    chainable = 1;
+                }
+
+                return chainable ?
+                    elems :
+
+                    // Gets
+                    bulk ?
+                        fn.call(elems) :
+                        length ? fn(elems[0], key) : emptyGet;
+            },
+
+            now: function () {
+                return ( new Date() ).getTime();
+            },
+
+            // Use of jQuery.browser is frowned upon.
+            // More details: http://docs.jquery.com/Utilities/jQuery.browser
+            uaMatch: function (ua) {
+                ua = ua.toLowerCase();
+
+                var match = rwebkit.exec(ua) ||
+                    ropera.exec(ua) ||
+                    rmsie.exec(ua) ||
+                    ua.indexOf("compatible") < 0 && rmozilla.exec(ua) ||
+                    [];
+
+                return { browser: match[1] || "", version: match[2] || "0" };
+            },
+
+            sub: function () {
+                function jQuerySub(selector, context) {
+                    return new jQuerySub.fn.init(selector, context);
+                }
+
+                jQuery.extend(true, jQuerySub, this);
+                jQuerySub.superclass = this;
+                jQuerySub.fn = jQuerySub.prototype = this();
+                jQuerySub.fn.constructor = jQuerySub;
+                jQuerySub.sub = this.sub;
+                jQuerySub.fn.init = function init(selector, context) {
+                    if (context && context instanceof jQuery && !(context instanceof jQuerySub)) {
+                        context = jQuerySub(context);
+                    }
+
+                    return jQuery.fn.init.call(this, selector, context, rootjQuerySub);
+                };
+                jQuerySub.fn.init.prototype = jQuerySub.fn;
+                var rootjQuerySub = jQuerySub(document);
+                return jQuerySub;
+            },
+
+            browser: {}
+        });
+
+// Populate the class2type map
+        jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function (i, name) {
+            class2type[ "[object " + name + "]" ] = name.toLowerCase();
+        });
+
+        browserMatch = jQuery.uaMatch(userAgent);
+        if (browserMatch.browser) {
+            jQuery.browser[ browserMatch.browser ] = true;
+            jQuery.browser.version = browserMatch.version;
+        }
+
+// Deprecated, use jQuery.browser.webkit instead
+        if (jQuery.browser.webkit) {
+            jQuery.browser.safari = true;
+        }
+
+// IE doesn't match non-breaking spaces with \s
+        if (rnotwhite.test("\xA0")) {
+            trimLeft = /^[\s\xA0]+/;
+            trimRight = /[\s\xA0]+$/;
+        }
+
+// All jQuery objects should point back to these
+        rootjQuery = jQuery(document);
+
+// Cleanup functions for the document ready method
+        if (document.addEventListener) {
+            DOMContentLoaded = function () {
+                document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
+                jQuery.ready();
+            };
+
+        } else if (document.attachEvent) {
+            DOMContentLoaded = function () {
+                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+                if (document.readyState === "complete") {
+                    document.detachEvent("onreadystatechange", DOMContentLoaded);
+                    jQuery.ready();
+                }
+            };
+        }
+
+// The DOM ready check for Internet Explorer
+        function doScrollCheck() {
+            if (jQuery.isReady) {
+                return;
+            }
+
+            try {
+                // If IE is used, use the trick by Diego Perini
+                // http://javascript.nwbox.com/IEContentLoaded/
+                document.documentElement.doScroll("left");
+            } catch (e) {
+                setTimeout(doScrollCheck, 1);
+                return;
+            }
+
+            // and execute any waiting functions
+            jQuery.ready();
+        }
+
+        return jQuery;
+
+    })();
+
+
+// String to Object flags format cache
+    var flagsCache = {};
+
+// Convert String-formatted flags into Object-formatted ones and store in cache
+    function createFlags(flags) {
+        var object = flagsCache[ flags ] = {},
+            i, length;
+        flags = flags.split(/\s+/);
+        for (i = 0, length = flags.length; i < length; i++) {
+            object[ flags[i] ] = true;
+        }
+        return object;
+    }
+
+    /*
+     * Create a callback list using the following parameters:
+     *
+     *	flags:	an optional list of space-separated flags that will change how
+     *			the callback list behaves
+     *
+     * By default a callback list will act like an event callback list and can be
+     * "fired" multiple times.
+     *
+     * Possible flags:
+     *
+     *	once:			will ensure the callback list can only be fired once (like a Deferred)
+     *
+     *	memory:			will keep track of previous values and will call any callback added
+     *					after the list has been fired right away with the latest "memorized"
+     *					values (like a Deferred)
+     *
+     *	unique:			will ensure a callback can only be added once (no duplicate in the list)
+     *
+     *	stopOnFalse:	interrupt callings when a callback returns false
+     *
+     */
+    jQuery.Callbacks = function (flags) {
+
+        // Convert flags from String-formatted to Object-formatted
+        // (we check in cache first)
+        flags = flags ? ( flagsCache[ flags ] || createFlags(flags) ) : {};
+
+        var // Actual callback list
+            list = [],
+        // Stack of fire calls for repeatable lists
+            stack = [],
+        // Last fire value (for non-forgettable lists)
+            memory,
+        // Flag to know if list was already fired
+            fired,
+        // Flag to know if list is currently firing
+            firing,
+        // First callback to fire (used internally by add and fireWith)
+            firingStart,
+        // End of the loop when firing
+            firingLength,
+        // Index of currently firing callback (modified by remove if needed)
+            firingIndex,
+        // Add one or several callbacks to the list
+            add = function (args) {
+                var i,
+                    length,
+                    elem,
+                    type,
+                    actual;
+                for (i = 0, length = args.length; i < length; i++) {
+                    elem = args[ i ];
+                    type = jQuery.type(elem);
+                    if (type === "array") {
+                        // Inspect recursively
+                        add(elem);
+                    } else if (type === "function") {
+                        // Add if not in unique mode and callback is not in
+                        if (!flags.unique || !self.has(elem)) {
+                            list.push(elem);
+                        }
+                    }
+                }
+            },
+        // Fire callbacks
+            fire = function (context, args) {
+                args = args || [];
+                memory = !flags.memory || [ context, args ];
+                fired = true;
+                firing = true;
+                firingIndex = firingStart || 0;
+                firingStart = 0;
+                firingLength = list.length;
+                for (; list && firingIndex < firingLength; firingIndex++) {
+                    if (list[ firingIndex ].apply(context, args) === false && flags.stopOnFalse) {
+                        memory = true; // Mark as halted
+                        break;
+                    }
+                }
+                firing = false;
+                if (list) {
+                    if (!flags.once) {
+                        if (stack && stack.length) {
+                            memory = stack.shift();
+                            self.fireWith(memory[ 0 ], memory[ 1 ]);
+                        }
+                    } else if (memory === true) {
+                        self.disable();
+                    } else {
+                        list = [];
+                    }
+                }
+            },
+        // Actual Callbacks object
+            self = {
+                // Add a callback or a collection of callbacks to the list
+                add: function () {
+                    if (list) {
+                        var length = list.length;
+                        add(arguments);
+                        // Do we need to add the callbacks to the
+                        // current firing batch?
+                        if (firing) {
+                            firingLength = list.length;
+                            // With memory, if we're not firing then
+                            // we should call right away, unless previous
+                            // firing was halted (stopOnFalse)
+                        } else if (memory && memory !== true) {
+                            firingStart = length;
+                            fire(memory[ 0 ], memory[ 1 ]);
+                        }
+                    }
+                    return this;
+                },
+                // Remove a callback from the list
+                remove: function () {
+                    if (list) {
+                        var args = arguments,
+                            argIndex = 0,
+                            argLength = args.length;
+                        for (; argIndex < argLength; argIndex++) {
+                            for (var i = 0; i < list.length; i++) {
+                                if (args[ argIndex ] === list[ i ]) {
+                                    // Handle firingIndex and firingLength
+                                    if (firing) {
+                                        if (i <= firingLength) {
+                                            firingLength--;
+                                            if (i <= firingIndex) {
+                                                firingIndex--;
+                                            }
+                                        }
+                                    }
+                                    // Remove the element
+                                    list.splice(i--, 1);
+                                    // If we have some unicity property then
+                                    // we only need to do this once
+                                    if (flags.unique) {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return this;
+                },
+                // Control if a given callback is in the list
+                has: function (fn) {
+                    if (list) {
+                        var i = 0,
+                            length = list.length;
+                        for (; i < length; i++) {
+                            if (fn === list[ i ]) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                },
+                // Remove all callbacks from the list
+                empty: function () {
+                    list = [];
+                    return this;
+                },
+                // Have the list do nothing anymore
+                disable: function () {
+                    list = stack = memory = undefined;
+                    return this;
+                },
+                // Is it disabled?
+                disabled: function () {
+                    return !list;
+                },
+                // Lock the list in its current state
+                lock: function () {
+                    stack = undefined;
+                    if (!memory || memory === true) {
+                        self.disable();
+                    }
+                    return this;
+                },
+                // Is it locked?
+                locked: function () {
+                    return !stack;
+                },
+                // Call all callbacks with the given context and arguments
+                fireWith: function (context, args) {
+                    if (stack) {
+                        if (firing) {
+                            if (!flags.once) {
+                                stack.push([ context, args ]);
+                            }
+                        } else if (!( flags.once && memory )) {
+                            fire(context, args);
+                        }
+                    }
+                    return this;
+                },
+                // Call all the callbacks with the given arguments
+                fire: function () {
+                    self.fireWith(this, arguments);
+                    return this;
+                },
+                // To know if the callbacks have already been called at least once
+                fired: function () {
+                    return !!fired;
+                }
+            };
+
+        return self;
+    };
+
+
+    var // Static reference to slice
+        sliceDeferred = [].slice;
+
+    jQuery.extend({
+
+        Deferred: function (func) {
+            var doneList = jQuery.Callbacks("once memory"),
+                failList = jQuery.Callbacks("once memory"),
+                progressList = jQuery.Callbacks("memory"),
+                state = "pending",
+                lists = {
+                    resolve: doneList,
+                    reject: failList,
+                    notify: progressList
+                },
+                promise = {
+                    done: doneList.add,
+                    fail: failList.add,
+                    progress: progressList.add,
+
+                    state: function () {
+                        return state;
+                    },
+
+                    // Deprecated
+                    isResolved: doneList.fired,
+                    isRejected: failList.fired,
+
+                    then: function (doneCallbacks, failCallbacks, progressCallbacks) {
+                        deferred.done(doneCallbacks).fail(failCallbacks).progress(progressCallbacks);
+                        return this;
+                    },
+                    always: function () {
+                        deferred.done.apply(deferred, arguments).fail.apply(deferred, arguments);
+                        return this;
+                    },
+                    pipe: function (fnDone, fnFail, fnProgress) {
+                        return jQuery.Deferred(function (newDefer) {
+                            jQuery.each({
+                                done: [ fnDone, "resolve" ],
+                                fail: [ fnFail, "reject" ],
+                                progress: [ fnProgress, "notify" ]
+                            }, function (handler, data) {
+                                var fn = data[ 0 ],
+                                    action = data[ 1 ],
+                                    returned;
+                                if (jQuery.isFunction(fn)) {
+                                    deferred[ handler ](function () {
+                                        returned = fn.apply(this, arguments);
+                                        if (returned && jQuery.isFunction(returned.promise)) {
+                                            returned.promise().then(newDefer.resolve, newDefer.reject, newDefer.notify);
+                                        } else {
+                                            newDefer[ action + "With" ](this === deferred ? newDefer : this, [ returned ]);
+                                        }
+                                    });
+                                } else {
+                                    deferred[ handler ](newDefer[ action ]);
+                                }
+                            });
+                        }).promise();
+                    },
+                    // Get a promise for this deferred
+                    // If obj is provided, the promise aspect is added to the object
+                    promise: function (obj) {
+                        if (obj == null) {
+                            obj = promise;
+                        } else {
+                            for (var key in promise) {
+                                obj[ key ] = promise[ key ];
+                            }
+                        }
+                        return obj;
+                    }
+                },
+                deferred = promise.promise({}),
+                key;
+
+            for (key in lists) {
+                deferred[ key ] = lists[ key ].fire;
+                deferred[ key + "With" ] = lists[ key ].fireWith;
+            }
+
+            // Handle state
+            deferred.done(function () {
+                state = "resolved";
+            }, failList.disable, progressList.lock).fail(function () {
+                    state = "rejected";
+                }, doneList.disable, progressList.lock);
+
+            // Call given func if any
+            if (func) {
+                func.call(deferred, deferred);
+            }
+
+            // All done!
+            return deferred;
+        },
+
+        // Deferred helper
+        when: function (firstParam) {
+            var args = sliceDeferred.call(arguments, 0),
+                i = 0,
+                length = args.length,
+                pValues = new Array(length),
+                count = length,
+                pCount = length,
+                deferred = length <= 1 && firstParam && jQuery.isFunction(firstParam.promise) ?
+                    firstParam :
+                    jQuery.Deferred(),
+                promise = deferred.promise();
+
+            function resolveFunc(i) {
+                return function (value) {
+                    args[ i ] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
+                    if (!( --count )) {
+                        deferred.resolveWith(deferred, args);
+                    }
+                };
+            }
+
+            function progressFunc(i) {
+                return function (value) {
+                    pValues[ i ] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
+                    deferred.notifyWith(promise, pValues);
+                };
+            }
+
+            if (length > 1) {
+                for (; i < length; i++) {
+                    if (args[ i ] && args[ i ].promise && jQuery.isFunction(args[ i ].promise)) {
+                        args[ i ].promise().then(resolveFunc(i), deferred.reject, progressFunc(i));
+                    } else {
+                        --count;
+                    }
+                }
+                if (!count) {
+                    deferred.resolveWith(deferred, args);
+                }
+            } else if (deferred !== firstParam) {
+                deferred.resolveWith(deferred, length ? [ firstParam ] : []);
+            }
+            return promise;
+        }
+    });
+
+
+    jQuery.support = (function () {
+
+        var support,
+            all,
+            a,
+            select,
+            opt,
+            input,
+            fragment,
+            tds,
+            events,
+            eventName,
+            i,
+            isSupported,
+            div = document.createElement("div"),
+            documentElement = document.documentElement;
+
+        // Preliminary tests
+        div.setAttribute("className", "t");
+        div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
+
+        all = div.getElementsByTagName("*");
+        a = div.getElementsByTagName("a")[ 0 ];
+
+        // Can't get basic test support
+        if (!all || !all.length || !a) {
+            return {};
+        }
+
+        // First batch of supports tests
+        select = document.createElement("select");
+        opt = select.appendChild(document.createElement("option"));
+        input = div.getElementsByTagName("input")[ 0 ];
+
+        support = {
+            // IE strips leading whitespace when .innerHTML is used
+            leadingWhitespace: ( div.firstChild.nodeType === 3 ),
+
+            // Make sure that tbody elements aren't automatically inserted
+            // IE will insert them into empty tables
+            tbody: !div.getElementsByTagName("tbody").length,
+
+            // Make sure that link elements get serialized correctly by innerHTML
+            // This requires a wrapper element in IE
+            htmlSerialize: !!div.getElementsByTagName("link").length,
+
+            // Get the style information from getAttribute
+            // (IE uses .cssText instead)
+            style: /top/.test(a.getAttribute("style")),
+
+            // Make sure that URLs aren't manipulated
+            // (IE normalizes it by default)
+            hrefNormalized: ( a.getAttribute("href") === "/a" ),
+
+            // Make sure that element opacity exists
+            // (IE uses filter instead)
+            // Use a regex to work around a WebKit issue. See #5145
+            opacity: /^0.55/.test(a.style.opacity),
+
+            // Verify style float existence
+            // (IE uses styleFloat instead of cssFloat)
+            cssFloat: !!a.style.cssFloat,
+
+            // Make sure that if no value is specified for a checkbox
+            // that it defaults to "on".
+            // (WebKit defaults to "" instead)
+            checkOn: ( input.value === "on" ),
+
+            // Make sure that a selected-by-default option has a working selected property.
+            // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+            optSelected: opt.selected,
+
+            // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+            getSetAttribute: div.className !== "t",
+
+            // Tests for enctype support on a form(#6743)
+            enctype: !!document.createElement("form").enctype,
+
+            // Makes sure cloning an html5 element does not cause problems
+            // Where outerHTML is undefined, this still works
+            html5Clone: document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>",
+
+            // Will be defined later
+            submitBubbles: true,
+            changeBubbles: true,
+            focusinBubbles: false,
+            deleteExpando: true,
+            noCloneEvent: true,
+            inlineBlockNeedsLayout: false,
+            shrinkWrapBlocks: false,
+            reliableMarginRight: true,
+            pixelMargin: true
+        };
+
+        // jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead
+        jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat");
+
+        // Make sure checked status is properly cloned
+        input.checked = true;
+        support.noCloneChecked = input.cloneNode(true).checked;
+
+        // Make sure that the options inside disabled selects aren't marked as disabled
+        // (WebKit marks them as disabled)
+        select.disabled = true;
+        support.optDisabled = !opt.disabled;
+
+        // Test to see if it's possible to delete an expando from an element
+        // Fails in Internet Explorer
+        try {
+            delete div.test;
+        } catch (e) {
+            support.deleteExpando = false;
+        }
+
+        if (!div.addEventListener && div.attachEvent && div.fireEvent) {
+            div.attachEvent("onclick", function () {
+                // Cloning a node shouldn't copy over any
+                // bound event handlers (IE does this)
+                support.noCloneEvent = false;
+            });
+            div.cloneNode(true).fireEvent("onclick");
+        }
+
+        // Check if a radio maintains its value
+        // after being appended to the DOM
+        input = document.createElement("input");
+        input.value = "t";
+        input.setAttribute("type", "radio");
+        support.radioValue = input.value === "t";
+
+        input.setAttribute("checked", "checked");
+
+        // #11217 - WebKit loses check when the name is after the checked attribute
+        input.setAttribute("name", "t");
+
+        div.appendChild(input);
+        fragment = document.createDocumentFragment();
+        fragment.appendChild(div.lastChild);
+
+        // WebKit doesn't clone checked state correctly in fragments
+        support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
+
+        // Check if a disconnected checkbox will retain its checked
+        // value of true after appended to the DOM (IE6/7)
+        support.appendChecked = input.checked;
+
+        fragment.removeChild(input);
+        fragment.appendChild(div);
+
+        // Technique from Juriy Zaytsev
+        // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
+        // We only care about the case where non-standard event systems
+        // are used, namely in IE. Short-circuiting here helps us to
+        // avoid an eval call (in setAttribute) which can cause CSP
+        // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+        if (div.attachEvent) {
+            for (i in {
+                submit: 1,
+                change: 1,
+                focusin: 1
+            }) {
+                eventName = "on" + i;
+                isSupported = ( eventName in div );
+                if (!isSupported) {
+                    div.setAttribute(eventName, "return;");
+                    isSupported = ( typeof div[ eventName ] === "function" );
+                }
+                support[ i + "Bubbles" ] = isSupported;
+            }
+        }
+
+        fragment.removeChild(div);
+
+        // Null elements to avoid leaks in IE
+        fragment = select = opt = div = input = null;
+
+        // Run tests that need a body at doc ready
+        jQuery(function () {
+            var container, outer, inner, table, td, offsetSupport,
+                marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight,
+                paddingMarginBorderVisibility, paddingMarginBorder,
+                body = document.getElementsByTagName("body")[0];
+
+            if (!body) {
+                // Return for frameset docs that don't have a body
+                return;
+            }
+
+            conMarginTop = 1;
+            paddingMarginBorder = "padding:0;margin:0;border:";
+            positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;";
+            paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;";
+            style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;";
+            html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" +
+                "<table " + style + "' cellpadding='0' cellspacing='0'>" +
+                "<tr><td></td></tr></table>";
+
+            container = document.createElement("div");
+            container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
+            body.insertBefore(container, body.firstChild);
+
+            // Construct the test element
+            div = document.createElement("div");
+            container.appendChild(div);
+
+            // Check if table cells still have offsetWidth/Height when they are set
+            // to display:none and there are still other visible table cells in a
+            // table row; if so, offsetWidth/Height are not reliable for use when
+            // determining if an element has been hidden directly using
+            // display:none (it is still safe to use offsets if a parent element is
+            // hidden; don safety goggles and see bug #4512 for more information).
+            // (only IE 8 fails this test)
+            div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>";
+            tds = div.getElementsByTagName("td");
+            isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+            tds[ 0 ].style.display = "";
+            tds[ 1 ].style.display = "none";
+
+            // Check if empty table cells still have offsetWidth/Height
+            // (IE <= 8 fail this test)
+            support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+            // Check if div with explicit width and no margin-right incorrectly
+            // gets computed margin-right based on width of container. For more
+            // info see bug #3333
+            // Fails in WebKit before Feb 2011 nightlies
+            // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+            if (window.getComputedStyle) {
+                div.innerHTML = "";
+                marginDiv = document.createElement("div");
+                marginDiv.style.width = "0";
+                marginDiv.style.marginRight = "0";
+                div.style.width = "2px";
+                div.appendChild(marginDiv);
+                support.reliableMarginRight =
+                    ( parseInt(( window.getComputedStyle(marginDiv, null) || { marginRight: 0 } ).marginRight, 10) || 0 ) === 0;
+            }
+
+            if (typeof div.style.zoom !== "undefined") {
+                // Check if natively block-level elements act like inline-block
+                // elements when setting their display to 'inline' and giving
+                // them layout
+                // (IE < 8 does this)
+                div.innerHTML = "";
+                div.style.width = div.style.padding = "1px";
+                div.style.border = 0;
+                div.style.overflow = "hidden";
+                div.style.display = "inline";
+                div.style.zoom = 1;
+                support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+                // Check if elements with layout shrink-wrap their children
+                // (IE 6 does this)
+                div.style.display = "block";
+                div.style.overflow = "visible";
+                div.innerHTML = "<div style='width:5px;'></div>";
+                support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+            }
+
+            div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
+            div.innerHTML = html;
+
+            outer = div.firstChild;
+            inner = outer.firstChild;
+            td = outer.nextSibling.firstChild.firstChild;
+
+            offsetSupport = {
+                doesNotAddBorder: ( inner.offsetTop !== 5 ),
+                doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
+            };
+
+            inner.style.position = "fixed";
+            inner.style.top = "20px";
+
+            // safari subtracts parent border width here which is 5px
+            offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
+            inner.style.position = inner.style.top = "";
+
+            outer.style.overflow = "hidden";
+            outer.style.position = "relative";
+
+            offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
+            offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
+
+            if (window.getComputedStyle) {
+                div.style.marginTop = "1%";
+                support.pixelMargin = ( window.getComputedStyle(div, null) || { marginTop: 0 } ).marginTop !== "1%";
+            }
+
+            if (typeof container.style.zoom !== "undefined") {
+                container.style.zoom = 1;
+            }
+
+            body.removeChild(container);
+            marginDiv = div = container = null;
+
+            jQuery.extend(support, offsetSupport);
+        });
+
+        return support;
+    })();
+
+
+    var rbrace = /^(?:\{.*\}|\[.*\])$/,
+        rmultiDash = /([A-Z])/g;
+
+    jQuery.extend({
+        cache: {},
+
+        // Please use with caution
+        uuid: 0,
+
+        // Unique for each copy of jQuery on the page
+        // Non-digits removed to match rinlinejQuery
+        expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace(/\D/g, ""),
+
+        // The following elements throw uncatchable exceptions if you
+        // attempt to add expando properties to them.
+        noData: {
+            "embed": true,
+            // Ban all objects except for Flash (which handle expandos)
+            "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+            "applet": true
+        },
+
+        hasData: function (elem) {
+            elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+            return !!elem && !isEmptyDataObject(elem);
+        },
+
+        data: function (elem, name, data, pvt /* Internal Use Only */) {
+            if (!jQuery.acceptData(elem)) {
+                return;
+            }
+
+            var privateCache, thisCache, ret,
+                internalKey = jQuery.expando,
+                getByName = typeof name === "string",
+
+            // We have to handle DOM nodes and JS objects differently because IE6-7
+            // can't GC object references properly across the DOM-JS boundary
+                isNode = elem.nodeType,
+
+            // Only DOM nodes need the global jQuery cache; JS object data is
+            // attached directly to the object so GC can occur automatically
+                cache = isNode ? jQuery.cache : elem,
+
+            // Only defining an ID for JS objects if its cache already exists allows
+            // the code to shortcut on the same path as a DOM node with no cache
+                id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
+                isEvents = name === "events";
+
+            // Avoid doing any more work than we need to when trying to get data on an
+            // object that has no data at all
+            if ((!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined) {
+                return;
+            }
+
+            if (!id) {
+                // Only DOM nodes need a new unique ID for each element since their data
+                // ends up in the global cache
+                if (isNode) {
+                    elem[ internalKey ] = id = ++jQuery.uuid;
+                } else {
+                    id = internalKey;
+                }
+            }
+
+            if (!cache[ id ]) {
+                cache[ id ] = {};
+
+                // Avoids exposing jQuery metadata on plain JS objects when the object
+                // is serialized using JSON.stringify
+                if (!isNode) {
+                    cache[ id ].toJSON = jQuery.noop;
+                }
+            }
+
+            // An object can be passed to jQuery.data instead of a key/value pair; this gets
+            // shallow copied over onto the existing cache
+            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);
+                }
+            }
+
+            privateCache = thisCache = cache[ id ];
+
+            // jQuery data() is stored in a separate object inside the object's internal data
+            // cache in order to avoid key collisions between internal data and user-defined
+            // data.
+            if (!pvt) {
+                if (!thisCache.data) {
+                    thisCache.data = {};
+                }
+
+                thisCache = thisCache.data;
+            }
+
+            if (data !== undefined) {
+                thisCache[ jQuery.camelCase(name) ] = data;
+            }
+
+            // Users should not attempt to inspect the internal events object using jQuery.data,
+            // it is undocumented and subject to change. But does anyone listen? No.
+            if (isEvents && !thisCache[ name ]) {
+                return privateCache.events;
+            }
+
+            // Check for both converted-to-camel and non-converted data property names
+            // If a data property was specified
+            if (getByName) {
+
+                // First Try to find as-is property data
+                ret = thisCache[ name ];
+
+                // Test for null|undefined property data
+                if (ret == null) {
+
+                    // Try to find the camelCased property
+                    ret = thisCache[ jQuery.camelCase(name) ];
+                }
+            } else {
+                ret = thisCache;
+            }
+
+            return ret;
+        },
+
+        removeData: function (elem, name, pvt /* Internal Use Only */) {
+            if (!jQuery.acceptData(elem)) {
+                return;
+            }
+
+            var thisCache, i, l,
+
+            // Reference to internal data cache key
+                internalKey = jQuery.expando,
+
+                isNode = elem.nodeType,
+
+            // See jQuery.data for more information
+                cache = isNode ? jQuery.cache : elem,
+
+            // See jQuery.data for more information
+                id = isNode ? elem[ internalKey ] : internalKey;
+
+            // If there is already no cache entry for this object, there is no
+            // purpose in continuing
+            if (!cache[ id ]) {
+                return;
+            }
+
+            if (name) {
+
+                thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+                if (thisCache) {
+
+                    // Support array or space separated string names for data keys
+                    if (!jQuery.isArray(name)) {
+
+                        // try the string as a key before any manipulation
+                        if (name in thisCache) {
+                            name = [ name ];
+                        } else {
+
+                            // split the camel cased version by spaces unless a key with the spaces exists
+                            name = jQuery.camelCase(name);
+                            if (name in thisCache) {
+                                name = [ name ];
+                            } else {
+                                name = name.split(" ");
+                            }
+                        }
+                    }
+
+                    for (i = 0, l = name.length; i < l; i++) {
+                        delete thisCache[ name[i] ];
+                    }
+
+                    // If there is no data left in the cache, we want to continue
+                    // and let the cache object itself get destroyed
+                    if (!( pvt ? isEmptyDataObject : jQuery.isEmptyObject )(thisCache)) {
+                        return;
+                    }
+                }
+            }
+
+            // See jQuery.data for more information
+            if (!pvt) {
+                delete cache[ id ].data;
+
+                // Don't destroy the parent cache unless the internal data object
+                // had been the only thing left in it
+                if (!isEmptyDataObject(cache[ id ])) {
+                    return;
+                }
+            }
+
+            // Browsers that fail expando deletion also refuse to delete expandos on
+            // the window, but it will allow it on all other JS objects; other browsers
+            // don't care
+            // Ensure that `cache` is not a window object #10080
+            if (jQuery.support.deleteExpando || !cache.setInterval) {
+                delete cache[ id ];
+            } else {
+                cache[ id ] = null;
+            }
+
+            // We destroyed the cache and need to eliminate the expando on the node to avoid
+            // false lookups in the cache for entries that no longer exist
+            if (isNode) {
+                // IE does not allow us to delete expando properties from nodes,
+                // nor does it have a removeAttribute function on Document nodes;
+                // we must handle all of these cases
+                if (jQuery.support.deleteExpando) {
+                    delete elem[ internalKey ];
+                } else if (elem.removeAttribute) {
+                    elem.removeAttribute(internalKey);
+                } else {
+                    elem[ internalKey ] = null;
+                }
+            }
+        },
+
+        // For internal use only.
+        _data: function (elem, name, data) {
+            return jQuery.data(elem, name, data, true);
+        },
+
+        // A method for determining if a DOM node can handle the data expando
+        acceptData: function (elem) {
+            if (elem.nodeName) {
+                var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+                if (match) {
+                    return !(match === true || elem.getAttribute("classid") !== match);
+                }
+            }
+
+            return true;
+        }
+    });
+
+    jQuery.fn.extend({
+        data: function (key, value) {
+            var parts, part, attr, name, l,
+                elem = this[0],
+                i = 0,
+                data = null;
+
+            // Gets all values
+            if (key === undefined) {
+                if (this.length) {
+                    data = jQuery.data(elem);
+
+                    if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) {
+                        attr = elem.attributes;
+                        for (l = attr.length; i < l; i++) {
+                            name = attr[i].name;
+
+                            if (name.indexOf("data-") === 0) {
+                                name = jQuery.camelCase(name.substring(5));
+
+                                dataAttr(elem, name, data[ name ]);
+                            }
+                        }
+                        jQuery._data(elem, "parsedAttrs", true);
+                    }
+                }
+
+                return data;
+            }
+
+            // Sets multiple values
+            if (typeof key === "object") {
+                return this.each(function () {
+                    jQuery.data(this, key);
+                });
+            }
+
+            parts = key.split(".", 2);
+            parts[1] = parts[1] ? "." + parts[1] : "";
+            part = parts[1] + "!";
+
+            return jQuery.access(this, function (value) {
+
+                if (value === undefined) {
+                    data = this.triggerHandler("getData" + part, [ parts[0] ]);
+
+                    // Try to fetch any internally stored data first
+                    if (data === undefined && elem) {
+                        data = jQuery.data(elem, key);
+                        data = dataAttr(elem, key, data);
+                    }
+
+                    return data === undefined && parts[1] ?
+                        this.data(parts[0]) :
+                        data;
+                }
+
+                parts[1] = value;
+                this.each(function () {
+                    var self = jQuery(this);
+
+                    self.triggerHandler("setData" + part, parts);
+                    jQuery.data(this, key, value);
+                    self.triggerHandler("changeData" + part, parts);
+                });
+            }, null, value, arguments.length > 1, null, false);
+        },
+
+        removeData: function (key) {
+            return this.each(function () {
+                jQuery.removeData(this, key);
+            });
+        }
+    });
+
+    function dataAttr(elem, key, data) {
+        // If nothing was found internally, try to fetch any
+        // data from the HTML5 data-* attribute
+        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 :
+                                jQuery.isNumeric(data) ? +data :
+                                    rbrace.test(data) ? jQuery.parseJSON(data) :
+                                        data;
+                } catch (e) {
+                }
+
+                // Make sure we set the data so it isn't changed later
+                jQuery.data(elem, key, data);
+
+            } else {
+                data = undefined;
+            }
+        }
+
+        return data;
+    }
+
+// checks a cache object for emptiness
+    function isEmptyDataObject(obj) {
+        for (var name in obj) {
+
+            // if the public data object is empty, the private is still empty
+            if (name === "data" && jQuery.isEmptyObject(obj[name])) {
+                continue;
+            }
+            if (name !== "toJSON") {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+
+    function handleQueueMarkDefer(elem, type, src) {
+        var deferDataKey = type + "defer",
+            queueDataKey = type + "queue",
+            markDataKey = type + "mark",
+            defer = jQuery._data(elem, deferDataKey);
+        if (defer &&
+            ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
+            ( src === "mark" || !jQuery._data(elem, markDataKey) )) {
+            // Give room for hard-coded callbacks to fire first
+            // and eventually mark/queue something else on the element
+            setTimeout(function () {
+                if (!jQuery._data(elem, queueDataKey) && !jQuery._data(elem, markDataKey)) {
+                    jQuery.removeData(elem, deferDataKey, true);
+                    defer.fire();
+                }
+            }, 0);
+        }
+    }
+
+    jQuery.extend({
+
+        _mark: function (elem, type) {
+            if (elem) {
+                type = ( type || "fx" ) + "mark";
+                jQuery._data(elem, type, (jQuery._data(elem, type) || 0) + 1);
+            }
+        },
+
+        _unmark: function (force, elem, type) {
+            if (force !== true) {
+                type = elem;
+                elem = force;
+                force = false;
+            }
+            if (elem) {
+                type = type || "fx";
+                var key = type + "mark",
+                    count = force ? 0 : ( (jQuery._data(elem, key) || 1) - 1 );
+                if (count) {
+                    jQuery._data(elem, key, count);
+                } else {
+                    jQuery.removeData(elem, key, true);
+                    handleQueueMarkDefer(elem, type, "mark");
+                }
+            }
+        },
+
+        queue: function (elem, type, data) {
+            var q;
+            if (elem) {
+                type = ( type || "fx" ) + "queue";
+                q = jQuery._data(elem, type);
+
+                // Speed up dequeue by getting out quickly if this is just a lookup
+                if (data) {
+                    if (!q || jQuery.isArray(data)) {
+                        q = jQuery._data(elem, type, jQuery.makeArray(data));
+                    } else {
+                        q.push(data);
+                    }
+                }
+                return q || [];
+            }
+        },
+
+        dequeue: function (elem, type) {
+            type = type || "fx";
+
+            var queue = jQuery.queue(elem, type),
+                fn = queue.shift(),
+                hooks = {};
+
+            // If the fx queue is dequeued, always remove the progress sentinel
+            if (fn === "inprogress") {
+                fn = queue.shift();
+            }
+
+            if (fn) {
+                // Add a progress sentinel to prevent the fx queue from being
+                // automatically dequeued
+                if (type === "fx") {
+                    queue.unshift("inprogress");
+                }
+
+                jQuery._data(elem, type + ".run", hooks);
+                fn.call(elem, function () {
+                    jQuery.dequeue(elem, type);
+                }, hooks);
+            }
+
+            if (!queue.length) {
+                jQuery.removeData(elem, type + "queue " + type + ".run", true);
+                handleQueueMarkDefer(elem, type, "queue");
+            }
+        }
+    });
+
+    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);
+
+                    if (type === "fx" && queue[0] !== "inprogress") {
+                        jQuery.dequeue(this, type);
+                    }
+                });
+        },
+        dequeue: function (type) {
+            return this.each(function () {
+                jQuery.dequeue(this, type);
+            });
+        },
+        // Based off of the plugin by Clint Helfers, with permission.
+        // http://blindsignals.com/index.php/2009/07/jquery-delay/
+        delay: function (time, type) {
+            time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+            type = type || "fx";
+
+            return this.queue(type, function (next, hooks) {
+                var timeout = setTimeout(next, time);
+                hooks.stop = function () {
+                    clearTimeout(timeout);
+                };
+            });
+        },
+        clearQueue: function (type) {
+            return this.queue(type || "fx", []);
+        },
+        // Get a promise resolved when queues of a certain type
+        // are emptied (fx is the type by default)
+        promise: function (type, object) {
+            if (typeof type !== "string") {
+                object = type;
+                type = undefined;
+            }
+            type = type || "fx";
+            var defer = jQuery.Deferred(),
+                elements = this,
+                i = elements.length,
+                count = 1,
+                deferDataKey = type + "defer",
+                queueDataKey = type + "queue",
+                markDataKey = type + "mark",
+                tmp;
+
+            function resolve() {
+                if (!( --count )) {
+                    defer.resolveWith(elements, [ elements ]);
+                }
+            }
+
+            while (i--) {
+                if (( tmp = jQuery.data(elements[ i ], deferDataKey, undefined, true) ||
+                    ( jQuery.data(elements[ i ], queueDataKey, undefined, true) ||
+                        jQuery.data(elements[ i ], markDataKey, undefined, true) ) &&
+                        jQuery.data(elements[ i ], deferDataKey, jQuery.Callbacks("once memory"), true) )) {
+                    count++;
+                    tmp.add(resolve);
+                }
+            }
+            resolve();
+            return defer.promise(object);
+        }
+    });
+
+
+    var rclass = /[\n\t\r]/g,
+        rspace = /\s+/,
+        rreturn = /\r/g,
+        rtype = /^(?:button|input)$/i,
+        rfocusable = /^(?:button|input|object|select|textarea)$/i,
+        rclickable = /^a(?:rea)?$/i,
+        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+        getSetAttribute = jQuery.support.getSetAttribute,
+        nodeHook, boolHook, fixSpecified;
+
+    jQuery.fn.extend({
+        attr: function (name, value) {
+            return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);
+        },
+
+        removeAttr: function (name) {
+            return this.each(function () {
+                jQuery.removeAttr(this, name);
+            });
+        },
+
+        prop: function (name, value) {
+            return jQuery.access(this, jQuery.prop, name, value, arguments.length > 1);
+        },
+
+        removeProp: function (name) {
+            name = jQuery.propFix[ name ] || name;
+            return this.each(function () {
+                // try/catch handles cases where IE balks (such as removing a property on window)
+                try {
+                    this[ name ] = undefined;
+                    delete this[ name ];
+                } catch (e) {
+                }
+            });
+        },
+
+        addClass: function (value) {
+            var classNames, i, l, elem,
+                setClass, c, cl;
+
+            if (jQuery.isFunction(value)) {
+                return this.each(function (j) {
+                    jQuery(this).addClass(value.call(this, j, this.className));
+                });
+            }
+
+            if (value && typeof value === "string") {
+                classNames = value.split(rspace);
+
+                for (i = 0, l = this.length; i < l; i++) {
+                    elem = this[ i ];
+
+                    if (elem.nodeType === 1) {
+                        if (!elem.className && classNames.length === 1) {
+                            elem.className = value;
+
+                        } else {
+                            setClass = " " + elem.className + " ";
+
+                            for (c = 0, cl = classNames.length; c < cl; c++) {
+                                if (!~setClass.indexOf(" " + classNames[ c ] + " ")) {
+                                    setClass += classNames[ c ] + " ";
+                                }
+                            }
+                            elem.className = jQuery.trim(setClass);
+                        }
+                    }
+                }
+            }
+
+            return this;
+        },
+
+        removeClass: function (value) {
+            var classNames, i, l, elem, className, c, cl;
+
+            if (jQuery.isFunction(value)) {
+                return this.each(function (j) {
+                    jQuery(this).removeClass(value.call(this, j, this.className));
+                });
+            }
+
+            if ((value && typeof value === "string") || value === undefined) {
+                classNames = ( value || "" ).split(rspace);
+
+                for (i = 0, l = this.length; i < l; i++) {
+                    elem = this[ i ];
+
+                    if (elem.nodeType === 1 && elem.className) {
+                        if (value) {
+                            className = (" " + elem.className + " ").replace(rclass, " ");
+                            for (c = 0, cl = classNames.length; c < cl; c++) {
+                                className = className.replace(" " + classNames[ c ] + " ", " ");
+                            }
+                            elem.className = jQuery.trim(className);
+
+                        } else {
+                            elem.className = "";
+                        }
+                    }
+                }
+    

<TRUNCATED>