/ - Diff - Rozšíření nástroje IMiGEr (KIV) - HKMM - Redmine

« Předchozí | Další »

Revize 2f31119d

Přidáno uživatelem Pavel Fidranský před asi 6 roky(ů)

ID 2f31119da873a3cfd3a4dcd92bdb9c5c5292f259
Rodič c6756c6f
Potomek 3c3bc9ca

updated jQuery

     /*!
     * jQuery JavaScript Library v1.8.3
     * http://jquery.com/
+    *
     * Includes Sizzle.js
     * http://sizzlejs.com/
+    *
     * Copyright 2012 jQuery Foundation and other contributors
     * Released under the MIT license
     * http://jquery.org/license
+    *
     * Date: Tue Nov 13 2012 08:20:33 GMT-0500 (Eastern Standard Time)
     */
     (function( window, undefined ) {
     	var
     	// A central reference to the root jQuery(document)
     	rootjQuery,
     	// The deferred used on DOM ready
     	readyList,
     	// Use the correct document accordingly with window argument (sandbox)
     	document = window.document,
     	location = window.location,
     	navigator = window.navigator,
     	// Map over jQuery in case of overwrite
     	_jQuery = window.jQuery,
     	// Map over the $ in case of overwrite
     	_$ = window.$,
     	// Save a reference to some core methods
     	core_push = Array.prototype.push,
     	core_slice = Array.prototype.slice,
     	core_indexOf = Array.prototype.indexOf,
     	core_toString = Object.prototype.toString,
     	core_hasOwn = Object.prototype.hasOwnProperty,
     	core_trim = String.prototype.trim,
     	// Define a local copy of jQuery
     	jQuery = function( selector, context ) {
     		// The jQuery object is actually just the init constructor 'enhanced'
     		return new jQuery.fn.init( selector, context, rootjQuery );
     	},
     	// Used for matching numbers
     	core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
     	// Used for detecting and trimming whitespace
     	core_rnotwhite = /\S/,
     	core_rspace = /\s+/,
     	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
     	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
     	// A simple way to check for HTML strings
     	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
     	rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
     	// Match a standalone tag
     	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
     	// JSON RegExp
     	rvalidchars = /^[\],:{}\s]*$/,
     	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
     	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
     	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,
     	// Matches dashed string for camelizing
     	rmsPrefix = /^-ms-/,
     	rdashAlpha = /-([\da-z])/gi,
     	// Used by jQuery.camelCase as callback to replace()
     	fcamelCase = function( all, letter ) {
     		return ( letter + "" ).toUpperCase();
     	},
     	// The ready event handler and self cleanup method
     	DOMContentLoaded = function() {
     		if ( document.addEventListener ) {
     			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
     			jQuery.ready();
     			} else if ( document.readyState === "complete" ) {
     			// we're here because readyState === "complete" in oldIE
     			// which is good enough for us to call the dom ready!
     			document.detachEvent( "onreadystatechange", DOMContentLoaded );
     			jQuery.ready();
+    		}
     	},
     	// [[Class]] -> type pairs
     	class2type = {};
     	jQuery.fn = jQuery.prototype = {
     		constructor: jQuery,
     		init: function( selector, context, rootjQuery ) {
     			var match, elem, ret, doc;
     			// Handle $(""), $(null), $(undefined), $(false)
     			if ( !selector ) {
     				return this;
+    			}
     			// Handle $(DOMElement)
     			if ( selector.nodeType ) {
     				this.context = this[0] = selector;
     				this.length = 1;
     				return this;
+    			}
     			// Handle HTML strings
     			if ( typeof selector === "string" ) {
     				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 = rquickExpr.exec( selector );
+    				}
     				// Match html or make sure no context is specified for #id
     				if ( match && (match[1] || !context) ) {
     					// HANDLE: $(html) -> $(array)
     					if ( match[1] ) {
     						context = context instanceof jQuery ? context[0] : context;
     						doc = ( context && context.nodeType ? context.ownerDocument || context : document );
     						// scripts is true for back-compat
     						selector = jQuery.parseHTML( match[1], doc, true );
     						if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
     							this.attr.call( selector, context, true );
+    						}
     						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.8.3",
     		// 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 core_slice.call( this );
     		},
     		// 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 = jQuery.merge( this.constructor(), 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 ) {
     			// Add the callback
     			jQuery.ready.promise().done( 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( core_slice.apply( this, arguments ),
     			"slice", core_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: core_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 ) {
     			// Abort if there are pending holds or we're already ready
     			if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
     				return;
+    			}
     			// 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.resolveWith( document, [ jQuery ] );
     			// Trigger any bound ready events
     			if ( jQuery.fn.trigger ) {
     				jQuery( document ).trigger("ready").off("ready");
+    			}
     		},
     		// 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[ core_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 &&
     				!core_hasOwn.call(obj, "constructor") &&
     				!core_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 || core_hasOwn.call( obj, key );
     		},
     		isEmptyObject: function( obj ) {
     			var name;
     			for ( name in obj ) {
     				return false;
+    			}
     			return true;
     		},
     		error: function( msg ) {
     			throw new Error( msg );
     		},
     		// data: string of html
     		// context (optional): If specified, the fragment will be created in this context, defaults to document
     		// scripts (optional): If true, will include scripts passed in the html string
     		parseHTML: function( data, context, scripts ) {
     			var parsed;
     			if ( !data || typeof data !== "string" ) {
     				return null;
+    			}
     			if ( typeof context === "boolean" ) {
     				scripts = context;
     				context = 0;
+    			}
     			context = context || document;
     			// Single tag
     			if ( (parsed = rsingleTag.exec( data )) ) {
     				return [ context.createElement( parsed[1] ) ];
+    			}
     			parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] );
     			return jQuery.merge( [],
     			(parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes );
     		},
     		parseJSON: function( data ) {
     			if ( !data || typeof data !== "string") {
     				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 ) {
     			var xml, tmp;
     			if ( !data || typeof data !== "string" ) {
     				return null;
+    			}
     			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 && core_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.toLowerCase() === name.toLowerCase();
     		},
     		// args is for internal usage only
     		each: function( obj, callback, args ) {
     			var name,
     			i = 0,
     			length = obj.length,
     			isObj = length === undefined || jQuery.isFunction( obj );
     			if ( args ) {
     				if ( isObj ) {
     					for ( name in obj ) {
     						if ( callback.apply( obj[ name ], args ) === false ) {
     							break;
+    						}
+    					}
     					} else {
     					for ( ; i < length; ) {
     						if ( callback.apply( obj[ i++ ], args ) === false ) {
     							break;
+    						}
+    					}
+    				}
     				// A special, fast, case for the most common use of each
     				} else {
     				if ( isObj ) {
     					for ( name in obj ) {
     						if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
     							break;
+    						}
+    					}
     					} else {
     					for ( ; i < length; ) {
     						if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
     							break;
+    						}
+    					}
+    				}
+    			}
     			return obj;
     		},
     		// Use native String.trim function wherever possible
     		trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
     		function( text ) {
     			return text == null ?
     			"" :
     			core_trim.call( text );
     		} :
     		// Otherwise use our own trimming functionality
     		function( text ) {
     			return text == null ?
     			"" :
     			( text + "" ).replace( rtrim, "" );
     		},
     		// results is for internal usage only
     		makeArray: function( arr, results ) {
     			var type,
     			ret = results || [];
     			if ( arr != null ) {
     				// The window, strings (and functions) also have 'length'
     				// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
     				type = jQuery.type( arr );
     				if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
     					core_push.call( ret, arr );
     					} else {
     					jQuery.merge( ret, arr );
+    				}
+    			}
     			return ret;
     		},
     		inArray: function( elem, arr, i ) {
     			var len;
     			if ( arr ) {
     				if ( core_indexOf ) {
     					return core_indexOf.call( arr, elem, i );
+    				}
     				len = arr.length;
     				i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
     				for ( ; i < len; i++ ) {
     					// Skip accessing in sparse arrays
     					if ( i in arr && arr[ i ] === elem ) {
     						return i;
+    					}
+    				}
+    			}
     			return -1;
     		},
     		merge: function( first, second ) {
     			var l = second.length,
     			i = first.length,
     			j = 0;
     			if ( typeof l === "number" ) {
     				for ( ; 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 retVal,
     			ret = [],
     			i = 0,
     			length = elems.length;
     			inv = !!inv;
     			// Go through the array, only saving the items
     			// that pass the validator function
     			for ( ; 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 ) {
     			var tmp, args, proxy;
     			if ( typeof context === "string" ) {
     				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
     			args = core_slice.call( arguments, 2 );
     			proxy = function() {
     				return fn.apply( context, args.concat( core_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 || jQuery.guid++;
     			return proxy;
     		},
     		// Multifunctional method to get and set values of 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();
+    		}
     	});
     	jQuery.ready.promise = function( obj ) {
     		if ( !readyList ) {
     			readyList = jQuery.Deferred();
     			// Catch cases where $(document).ready() is called after the browser event has already occurred.
     			// we once tried to use readyState "interactive" here, but it caused issues like the one
     			// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
     			if ( document.readyState === "complete" ) {
     				// Handle it asynchronously to allow scripts the opportunity to delay ready
     				setTimeout( jQuery.ready, 1 );
     				// Standards-based browsers support DOMContentLoaded
     				} else 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 {
     				// 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 top = false;
     				try {
     					top = window.frameElement == null && document.documentElement;
     					} catch(e) {}
     					if ( top && top.doScroll ) {
     						(function doScrollCheck() {
     							if ( !jQuery.isReady ) {
     								try {
     									// Use the trick by Diego Perini
     									// http://javascript.nwbox.com/IEContentLoaded/
     									top.doScroll("left");
     									} catch(e) {
     									return setTimeout( doScrollCheck, 50 );
+    								}
     								// and execute any waiting functions
     								jQuery.ready();
+    							}
     						})();
+    					}
+    				}
+    			}
     			return readyList.promise( obj );
     		};
     		// Populate the class2type map
     		jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
     			class2type[ "[object " + name + "]" ] = name.toLowerCase();
     		});
     		// All jQuery objects should point back to these
     		rootjQuery = jQuery(document);
     		// String to Object options format cache
     		var optionsCache = {};
     		// Convert String-formatted options into Object-formatted ones and store in cache
     		function createOptions( options ) {
     			var object = optionsCache[ options ] = {};
     			jQuery.each( options.split( core_rspace ), function( _, flag ) {
     				object[ flag ] = true;
     			});
     			return object;
+    		}
     		/*
     		* Create a callback list using the following parameters:
+    		*
     		*	options: an optional list of space-separated options that will change how
     		*			the callback list behaves or a more traditional option object
+    		*
     		* By default a callback list will act like an event callback list and can be
     		* "fired" multiple times.
+    		*
     		* Possible options:
+    		*
     		*	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( options ) {
     			// Convert options from String-formatted to Object-formatted if needed
     			// (we check in cache first)
     			options = typeof options === "string" ?
     			( optionsCache[ options ] || createOptions( options ) ) :
     			jQuery.extend( {}, options );
     			var // 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,
     			// Actual callback list
     			list = [],
     			// Stack of fire calls for repeatable lists
     			stack = !options.once && [],
     			// Fire callbacks
     			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; // To prevent further calls using add
     						break;
+    					}
+    				}
     				firing = false;
     				if ( list ) {
     					if ( stack ) {
     						if ( stack.length ) {
     							fire( stack.shift() );
+    						}
     						} else if ( memory ) {
     						list = [];
     						} else {
     						self.disable();
+    					}
+    				}
     			},
     			// Actual Callbacks object
     			self = {
     				// Add a callback or a collection of callbacks to the list
     				add: function() {
     					if ( list ) {
     						// First, we save the current length
     						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" ) {
     									// Inspect recursively
     									add( arg );
+    								}
     							});
     						})( 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
     							} else if ( memory ) {
     							firingStart = start;
     							fire( memory );
+    						}
+    					}
     					return this;
     				},
     				// Remove a callback from the list
     				remove: function() {
     					if ( list ) {
     						jQuery.each( arguments, function( _, arg ) {
     							var index;
     							while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
     								list.splice( index, 1 );
     								// Handle firing indexes
     								if ( firing ) {
     									if ( index <= firingLength ) {
     										firingLength--;
+    									}
     									if ( index <= firingIndex ) {
     										firingIndex--;
+    									}
+    								}
+    							}
     						});
+    					}
     					return this;
     				},
     				// Control if a given callback is in the list
     				has: function( fn ) {
     					return jQuery.inArray( fn, list ) > -1;
     				},
     				// 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 ) {
     						self.disable();
+    					}
     					return this;
     				},
     				// Is it locked?
     				locked: function() {
     					return !stack;
     				},
     				// Call all callbacks with the given context and arguments
     				fireWith: function( context, args ) {
     					args = args || [];
     					args = [ context, args.slice ? args.slice() : args ];
     					if ( list && ( !fired || stack ) ) {
     						if ( firing ) {
     							stack.push( args );
     							} else {
     							fire( 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;
     		};
     		jQuery.extend({
     			Deferred: function( func ) {
     				var tuples = [
     				// action, add listener, listener list, final state
     				[ "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( /* fnDone, fnFail, fnProgress */ ) {
     						var fns = arguments;
     						return jQuery.Deferred(function( newDefer ) {
     							jQuery.each( tuples, function( i, tuple ) {
     								var action = tuple[ 0 ],
     								fn = fns[ i ];
     								// deferred[ done | fail | progress ] for forwarding actions to newDefer
     								deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
     								function() {
     									var returned = fn.apply( this, arguments );
     									if ( returned && jQuery.isFunction( returned.promise ) ) {
     										returned.promise()
     										.done( newDefer.resolve )
     										.fail( newDefer.reject )
     										.progress( newDefer.notify );
     										} else {
     										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
+    									}
     								} :
     								newDefer[ action ]
     								);
     							});
     							fns = null;
     						}).promise();
     					},
     					// Get a promise for this deferred
     					// If obj is provided, the promise aspect is added to the object
     					promise: function( obj ) {
     						return obj != null ? jQuery.extend( obj, promise ) : promise;
+    					}
     				},
     				deferred = {};
     				// Keep pipe for back-compat
     				promise.pipe = promise.then;
     				// Add list-specific methods
     				jQuery.each( tuples, function( i, tuple ) {
     					var list = tuple[ 2 ],
     					stateString = tuple[ 3 ];
     					// promise[ done | fail | progress ] = list.add
     					promise[ tuple[1] ] = list.add;
     					// Handle state
     					if ( stateString ) {
     						list.add(function() {
     							// state = [ resolved | rejected ]
     							state = stateString;
     							// [ reject_list | resolve_list ].disable; progress_list.lock
     						}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
+    					}
     					// deferred[ resolve | reject | notify ] = list.fire
     					deferred[ tuple[0] ] = list.fire;
     					deferred[ tuple[0] + "With" ] = list.fireWith;
     				});
     				// Make the deferred a promise
     				promise.promise( deferred );
     				// Call given func if any
     				if ( func ) {
     					func.call( deferred, deferred );
+    				}
     				// All done!
     				return deferred;
     			},
     			// Deferred helper
     			when: function( subordinate /* , ..., subordinateN */ ) {
     				var i = 0,
     				resolveValues = core_slice.call( arguments ),
     				length = resolveValues.length,
     				// the count of uncompleted subordinates
     				remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
     				// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
     				deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
     				// Update function for both resolve and progress values
     				updateFunc = function( i, contexts, values ) {
     					return function( value ) {
     						contexts[ i ] = this;
     						values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
     						if( values === progressValues ) {
     							deferred.notifyWith( contexts, values );
     							} else if ( !( --remaining ) ) {
     							deferred.resolveWith( contexts, values );
+    						}
     					};
     				},
     				progressValues, progressContexts, resolveContexts;
     				// add listeners to Deferred subordinates; treat others as resolved
     				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 we're not waiting on anything, resolve the master
     				if ( !remaining ) {
     					deferred.resolveWith( resolveContexts, resolveValues );
+    				}
     				return deferred.promise();
+    			}
     		});
     		jQuery.support = (function() {
     			var support,
     			all,
     			a,
     			select,
     			opt,
     			input,
     			fragment,
     			eventName,
     			i,
     			isSupported,
     			clickFn,
     			div = document.createElement("div");
     			// Setup
     			div.setAttribute( "className", "t" );
     			div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
     			// Support tests won't run in some limited or non-browser environments
     			all = div.getElementsByTagName("*");
     			a = div.getElementsByTagName("a")[ 0 ];
     			if ( !all || !a || !all.length ) {
     				return {};
+    			}
     			// First batch of tests
     			select = document.createElement("select");
     			opt = select.appendChild( document.createElement("option") );
     			input = div.getElementsByTagName("input")[ 0 ];
     			a.style.cssText = "top:1px;float:left;opacity:.5";
     			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.5/.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>",
     				// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
     				boxModel: ( document.compatMode === "CSS1Compat" ),
     				// Will be defined later
     				submitBubbles: true,
     				changeBubbles: true,
     				focusinBubbles: false,
     				deleteExpando: true,
     				noCloneEvent: true,
     				inlineBlockNeedsLayout: false,
     				shrinkWrapBlocks: false,
     				reliableMarginRight: true,
     				boxSizingReliable: true,
     				pixelPosition: false
     			};
     			// 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", clickFn = function() {
     					// Cloning a node shouldn't copy over any
     					// bound event handlers (IE does this)
     					support.noCloneEvent = false;
     				});
     				div.cloneNode( true ).fireEvent("onclick");
     				div.detachEvent( "onclick", clickFn );
+    			}
     			// 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: true,
     					change: true,
     					focusin: true
     					}) {
     					eventName = "on" + i;
     					isSupported = ( eventName in div );
     					if ( !isSupported ) {
     						div.setAttribute( eventName, "return;" );
     						isSupported = ( typeof div[ eventName ] === "function" );
+    					}
     					support[ i + "Bubbles" ] = isSupported;
+    				}
+    			}
     			// Run tests that need a body at doc ready
     			jQuery(function() {
     				var container, div, tds, marginDiv,
     				divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
     				body = document.getElementsByTagName("body")[0];
     				if ( !body ) {
     					// Return for frameset docs that don't have a body
     					return;
+    				}
     				container = document.createElement("div");
     				container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
     				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></td><td>t</td></tr></table>";
     				tds = div.getElementsByTagName("td");
     				tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
     				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 box-sizing and margin behavior
     				div.innerHTML = "";
     				div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
     				support.boxSizing = ( div.offsetWidth === 4 );
     				support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
     				// NOTE: To any future maintainer, we've window.getComputedStyle
     				// because jsdom on node.js will break without it.
     				if ( window.getComputedStyle ) {
     					support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
     					support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
     					// 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
     					marginDiv = document.createElement("div");
     					marginDiv.style.cssText = div.style.cssText = divReset;
     					marginDiv.style.marginRight = marginDiv.style.width = "0";
     					div.style.width = "1px";
     					div.appendChild( marginDiv );
     					support.reliableMarginRight =
     					!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+    				}
     				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.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
     					support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
     					// Check if elements with layout shrink-wrap their children
     					// (IE 6 does this)

... Rozdílový soubor je zkrácen, protože jeho délka přesahuje max. limit.

Také k dispozici: Unified diff

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2019 » Rozšíření nástroje IMiGEr (KIV) - HKMM

Revize 2f31119d

Přidáno uživatelem Pavel Fidranský před asi 6 roky(ů)