https://unifor.br/o/unifor-theme/vendors/js/vendors.js?browserId=c…=js&languageId=pt_BR&t=1743535993102

1/*1764360306000*/
2Liferay.Loader.define._amd = Liferay.Loader.define.amd;
3Liferay.Loader.define.amd = false;
4/*! jQuery UI - v1.12.1 - 2017-09-19
5* http://jqueryui.com
6* Includes: widget.js, position.js, keycode.js, unique-id.js, widgets/datepicker.js, widgets/menu.js
7* Copyright jQuery Foundation and other contributors; Licensed MIT */
8
9(function( factory ) {
10	if ( typeof define === "function" && define.amd ) {
11
12		// AMD. Register as an anonymous module.
13		define([ "jquery" ], factory );
14	} else {
15
16		// Browser globals
17		factory( jQuery );
18	}
19}(function( $ ) {
20
21$.ui = $.ui || {};
22
23var version = $.ui.version = "1.12.1";
24
25
26/*!
27 * jQuery UI Widget 1.12.1
28 * http://jqueryui.com
29 *
30 * Copyright jQuery Foundation and other contributors
31 * Released under the MIT license.
32 * http://jquery.org/license
33 */
34
35//>>label: Widget
36//>>group: Core
37//>>description: Provides a factory for creating stateful widgets with a common API.
38//>>docs: http://api.jqueryui.com/jQuery.widget/
39//>>demos: http://jqueryui.com/widget/
40
41
42
43var widgetUuid = 0;
44var widgetSlice = Array.prototype.slice;
45
46$.cleanData = ( function( orig ) {
47	return function( elems ) {
48		var events, elem, i;
49		for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
50			try {
51
52				// Only trigger remove when necessary to save time
53				events = $._data( elem, "events" );
54				if ( events && events.remove ) {
55					$( elem ).triggerHandler( "remove" );
56				}
57
58			// Http://bugs.jquery.com/ticket/8235
59			} catch ( e ) {}
60		}
61		orig( elems );
62	};
63} )( $.cleanData );
64
65$.widget = function( name, base, prototype ) {
66	var existingConstructor, constructor, basePrototype;
67
68	// ProxiedPrototype allows the provided prototype to remain unmodified
69	// so that it can be used as a mixin for multiple widgets (#8876)
70	var proxiedPrototype = {};
71
72	var namespace = name.split( "." )[ 0 ];
73	name = name.split( "." )[ 1 ];
74	var fullName = namespace + "-" + name;
75
76	if ( !prototype ) {
77		prototype = base;
78		base = $.Widget;
79	}
80
81	if ( $.isArray( prototype ) ) {
82		prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
83	}
84
85	// Create selector for plugin
86	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
87		return !!$.data( elem, fullName );
88	};
89
90	$[ namespace ] = $[ namespace ] || {};
91	existingConstructor = $[ namespace ][ name ];
92	constructor = $[ namespace ][ name ] = function( options, element ) {
93
94		// Allow instantiation without "new" keyword
95		if ( !this._createWidget ) {
96			return new constructor( options, element );
97		}
98
99		// Allow instantiation without initializing for simple inheritance
100		// must use "new" keyword (the code above always passes args)
101		if ( arguments.length ) {
102			this._createWidget( options, element );
103		}
104	};
105
106	// Extend with the existing constructor to carry over any static properties
107	$.extend( constructor, existingConstructor, {
108		version: prototype.version,
109
110		// Copy the object used to create the prototype in case we need to
111		// redefine the widget later
112		_proto: $.extend( {}, prototype ),
113
114		// Track widgets that inherit from this widget in case this widget is
115		// redefined after a widget inherits from it
116		_childConstructors: []
117	} );
118
119	basePrototype = new base();
120
121	// We need to make the options hash a property directly on the new instance
122	// otherwise we'll modify the options hash on the prototype that we're
123	// inheriting from
124	basePrototype.options = $.widget.extend( {}, basePrototype.options );
125	$.each( prototype, function( prop, value ) {
126		if ( !$.isFunction( value ) ) {
127			proxiedPrototype[ prop ] = value;
128			return;
129		}
130		proxiedPrototype[ prop ] = ( function() {
131			function _super() {
132				return base.prototype[ prop ].apply( this, arguments );
133			}
134
135			function _superApply( args ) {
136				return base.prototype[ prop ].apply( this, args );
137			}
138
139			return function() {
140				var __super = this._super;
141				var __superApply = this._superApply;
142				var returnValue;
143
144				this._super = _super;
145				this._superApply = _superApply;
146
147				returnValue = value.apply( this, arguments );
148
149				this._super = __super;
150				this._superApply = __superApply;
151
152				return returnValue;
153			};
154		} )();
155	} );
156	constructor.prototype = $.widget.extend( basePrototype, {
157
158		// TODO: remove support for widgetEventPrefix
159		// always use the name + a colon as the prefix, e.g., draggable:start
160		// don't prefix for widgets that aren't DOM-based
161		widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
162	}, proxiedPrototype, {
163		constructor: constructor,
164		namespace: namespace,
165		widgetName: name,
166		widgetFullName: fullName
167	} );
168
169	// If this widget is being redefined then we need to find all widgets that
170	// are inheriting from it and redefine all of them so that they inherit from
171	// the new version of this widget. We're essentially trying to replace one
172	// level in the prototype chain.

173	if ( existingConstructor ) {
174		$.each( existingConstructor._childConstructors, function( i, child ) {
175			var childPrototype = child.prototype;
176
177			// Redefine the child widget using the same prototype that was
178			// originally used, but inherit from the new version of the base
179			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
180				child._proto );
181		} );
182
183		// Remove the list of existing child constructors from the old constructor
184		// so the old child constructors can be garbage collected
185		delete existingConstructor._childConstructors;
186	} else {
187		base._childConstructors.push( constructor );
188	}
189
190	$.widget.bridge( name, constructor );
191
192	return constructor;
193};
194
195$.widget.extend = function( target ) {
196	var input = widgetSlice.call( arguments, 1 );
197	var inputIndex = 0;
198	var inputLength = input.length;
199	var key;
200	var value;
201
202	for ( ; inputIndex < inputLength; inputIndex++ ) {
203		for ( key in input[ inputIndex ] ) {
204			value = input[ inputIndex ][ key ];
205			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
206
207				// Clone objects
208				if ( $.isPlainObject( value ) ) {
209					target[ key ] = $.isPlainObject( target[ key ] ) ?
210						$.widget.extend( {}, target[ key ], value ) :
211
212						// Don't extend strings, arrays, etc. with objects
213						$.widget.extend( {}, value );
214
215				// Copy everything else by reference
216				} else {
217					target[ key ] = value;
218				}
219			}
220		}
221	}
222	return target;
223};
224
225$.widget.bridge = function( name, object ) {
226	var fullName = object.prototype.widgetFullName || name;
227	$.fn[ name ] = function( options ) {
228		var isMethodCall = typeof options === "string";
229		var args = widgetSlice.call( arguments, 1 );
230		var returnValue = this;
231
232		if ( isMethodCall ) {
233
234			// If this is an empty collection, we need to have the instance method
235			// return undefined instead of the jQuery instance
236			if ( !this.length && options === "instance" ) {
237				returnValue = undefined;
238			} else {
239				this.each( function() {
240					var methodValue;
241					var instance = $.data( this, fullName );
242
243					if ( options === "instance" ) {
244						returnValue = instance;
245						return false;
246					}
247
248					if ( !instance ) {
249						return $.error( "cannot call methods on " + name +
250							" prior to initialization; " +
251							"attempted to call method '" + options + "'" );
252					}
253
254					if ( !$.isFunction( instance[ options ] ) || options.charAt( 0 ) === "_" ) {
255						return $.error( "no such method '" + options + "' for " + name +
256							" widget instance" );
257					}
258
259					methodValue = instance[ options ].apply( instance, args );
260
261					if ( methodValue !== instance && methodValue !== undefined ) {
262						returnValue = methodValue && methodValue.jquery ?
263							returnValue.pushStack( methodValue.get() ) :
264							methodValue;
265						return false;
266					}
267				} );
268			}
269		} else {
270
271			// Allow multiple hashes to be passed on init
272			if ( args.length ) {
273				options = $.widget.extend.apply( null, [ options ].concat( args ) );
274			}
275
276			this.each( function() {
277				var instance = $.data( this, fullName );
278				if ( instance ) {
279					instance.option( options || {} );
280					if ( instance._init ) {
281						instance._init();
282					}
283				} else {
284					$.data( this, fullName, new object( options, this ) );
285				}
286			} );
287		}
288
289		return returnValue;
290	};
291};
292
293$.Widget = function( /* options, element */ ) {};
294$.Widget._childConstructors = [];
295
296$.Widget.prototype = {
297	widgetName: "widget",
298	widgetEventPrefix: "",
299	defaultElement: "<div>",
300
301	options: {
302		classes: {},
303		disabled: false,
304
305		// Callbacks
306		create: null
307	},
308
309	_createWidget: function( options, element ) {
310		element = $( element || this.defaultElement || this )[ 0 ];
311		this.element = $( element );
312		this.uuid = widgetUuid++;
313		this.eventNamespace = "." + this.widgetName + this.uuid;
314
315		this.bindings = $();
316		this.hoverable = $();
317		this.focusable = $();
318		this.classesElementLookup = {};
319
320		if ( element !== this ) {
321			$.data( element, this.widgetFullName, this );
322			this._on( true, this.element, {
323				remove: function( event ) {
324					if ( event.target === element ) {
325						this.destroy();
326					}
327				}
328			} );
329			this.document = $( element.style ?
330
331				// Element within the document
332				element.ownerDocument :
333

334				// Element is window or document
335				element.document || element );
336			this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
337		}
338
339		this.options = $.widget.extend( {},
340			this.options,
341			this._getCreateOptions(),
342			options );
343
344		this._create();
345
346		if ( this.options.disabled ) {
347			this._setOptionDisabled( this.options.disabled );
348		}
349
350		this._trigger( "create", null, this._getCreateEventData() );
351		this._init();
352	},
353
354	_getCreateOptions: function() {
355		return {};
356	},
357
358	_getCreateEventData: $.noop,
359
360	_create: $.noop,
361
362	_init: $.noop,
363
364	destroy: function() {
365		var that = this;
366
367		this._destroy();
368		$.each( this.classesElementLookup, function( key, value ) {
369			that._removeClass( value, key );
370		} );
371
372		// We can probably remove the unbind calls in 2.0
373		// all event bindings should go through this._on()
374		this.element
375			.off( this.eventNamespace )
376			.removeData( this.widgetFullName );
377		this.widget()
378			.off( this.eventNamespace )
379			.removeAttr( "aria-disabled" );
380
381		// Clean up events and states
382		this.bindings.off( this.eventNamespace );
383	},
384
385	_destroy: $.noop,
386
387	widget: function() {
388		return this.element;
389	},
390
391	option: function( key, value ) {
392		var options = key;
393		var parts;
394		var curOption;
395		var i;
396
397		if ( arguments.length === 0 ) {
398
399			// Don't return a reference to the internal hash
400			return $.widget.extend( {}, this.options );
401		}
402
403		if ( typeof key === "string" ) {
404
405			// Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
406			options = {};
407			parts = key.split( "." );
408			key = parts.shift();
409			if ( parts.length ) {
410				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
411				for ( i = 0; i < parts.length - 1; i++ ) {
412					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
413					curOption = curOption[ parts[ i ] ];
414				}
415				key = parts.pop();
416				if ( arguments.length === 1 ) {
417					return curOption[ key ] === undefined ? null : curOption[ key ];
418				}
419				curOption[ key ] = value;
420			} else {
421				if ( arguments.length === 1 ) {
422					return this.options[ key ] === undefined ? null : this.options[ key ];
423				}
424				options[ key ] = value;
425			}
426		}
427
428		this._setOptions( options );
429
430		return this;
431	},
432
433	_setOptions: function( options ) {
434		var key;
435
436		for ( key in options ) {
437			this._setOption( key, options[ key ] );
438		}
439
440		return this;
441	},
442
443	_setOption: function( key, value ) {
444		if ( key === "classes" ) {
445			this._setOptionClasses( value );
446		}
447
448		this.options[ key ] = value;
449
450		if ( key === "disabled" ) {
451			this._setOptionDisabled( value );
452		}
453
454		return this;
455	},
456
457	_setOptionClasses: function( value ) {
458		var classKey, elements, currentElements;
459
460		for ( classKey in value ) {
461			currentElements = this.classesElementLookup[ classKey ];
462			if ( value[ classKey ] === this.options.classes[ classKey ] ||
463					!currentElements ||
464					!currentElements.length ) {
465				continue;
466			}
467
468			// We are doing this to create a new jQuery object because the _removeClass() call
469			// on the next line is going to destroy the reference to the current elements being
470			// tracked. We need to save a copy of this collection so that we can add the new classes
471			// below.
472			elements = $( currentElements.get() );
473			this._removeClass( currentElements, classKey );
474
475			// We don't use _addClass() here, because that uses this.options.classes
476			// for generating the string of classes. We want to use the value passed in from
477			// _setOption(), this is the new value of the classes option which was passed to
478			// _setOption(). We pass this value directly to _classes().
479			elements.addClass( this._classes( {
480				element: elements,
481				keys: classKey,
482				classes: value,
483				add: true
484			} ) );
485		}
486	},
487
488	_setOptionDisabled: function( value ) {
489		this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
490
491		// If the widget is becoming disabled, then nothing is interactive
492		if ( value ) {
493			this._removeClass( this.hoverable, null, "ui-state-hover" );
494			this._removeClass( this.focusable, null, "ui-state-focus" );
495		}
496	},
497
498	enable: function() {
499		return this._setOptions( { disabled: false } );
500	},
501
502	disable: function() {
503		return this._setOptions( { disabled: true } );
504	},
505
506	_classes: function( options ) {
507		var full = [];
508		var that = this;
509
510		options = $.extend( {
511			element: this.element,
512			classes: this.options.classes || {}
513		}, options );
514
515		function processClassString( classes, checkOption ) {
516			var current, i;
517			for ( i = 0; i < classes.length; i++ ) {
518				current = that.classesElementLookup[ classes[ i ] ] || $();
519				if ( options.add ) {
520					current = $( $.unique( current.get().concat( options.element.get() ) ) );
521				} else {
522					current = $( current.not( options.element ).get() );
523				}
524				that.classesElementLookup[ classes[ i ] ] = current;
525				full.push( classes[ i ] );
526				if ( checkOption && options.classes[ classes[ i ] ] ) {
527					full.push( options.classes[ classes[ i ] ] );
528				}
529			}
530		}
531
532		this._on( options.element, {
533			"remove": "_untrackClassesElement"
534		} );
535
536		if ( options.keys ) {
537			processClassString( options.keys.match( /\S+/g ) || [], true );
538		}
539		if ( options.extra ) {
540			processClassString( options.extra.match( /\S+/g ) || [] );
541		}
542
543		return full.join( " " );
544	},
545
546	_untrackClassesElement: function( event ) {
547		var that = this;
548		$.each( that.classesElementLookup, function( key, value ) {
549			if ( $.inArray( event.target, value ) !== -1 ) {
550				that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
551			}
552		} );
553	},
554
555	_removeClass: function( element, keys, extra ) {
556		return this._toggleClass( element, keys, extra, false );
557	},
558
559	_addClass: function( element, keys, extra ) {
560		return this._toggleClass( element, keys, extra, true );
561	},
562
563	_toggleClass: function( element, keys, extra, add ) {
564		add = ( typeof add === "boolean" ) ? add : extra;
565		var shift = ( typeof element === "string" || element === null ),
566			options = {
567				extra: shift ? keys : extra,
568				keys: shift ? element : keys,
569				element: shift ? this.element : element,
570				add: add
571			};
572		options.element.toggleClass( this._classes( options ), add );
573		return this;
574	},
575
576	_on: function( suppressDisabledCheck, element, handlers ) {
577		var delegateElement;
578		var instance = this;
579
580		// No suppressDisabledCheck flag, shuffle arguments
581		if ( typeof suppressDisabledCheck !== "boolean" ) {
582			handlers = element;
583			element = suppressDisabledCheck;
584			suppressDisabledCheck = false;

585		}
586
587		// No element argument, shuffle and use this.element
588		if ( !handlers ) {
589			handlers = element;
590			element = this.element;
591			delegateElement = this.widget();
592		} else {
593			element = delegateElement = $( element );
594			this.bindings = this.bindings.add( element );
595		}
596
597		$.each( handlers, function( event, handler ) {
598			function handlerProxy() {
599
600				// Allow widgets to customize the disabled handling
601				// - disabled as an array instead of boolean
602				// - disabled class as method for disabling individual parts
603				if ( !suppressDisabledCheck &&
604						( instance.options.disabled === true ||
605						$( this ).hasClass( "ui-state-disabled" ) ) ) {
606					return;
607				}
608				return ( typeof handler === "string" ? instance[ handler ] : handler )
609					.apply( instance, arguments );
610			}
611
612			// Copy the guid so direct unbinding works
613			if ( typeof handler !== "string" ) {
614				handlerProxy.guid = handler.guid =
615					handler.guid || handlerProxy.guid || $.guid++;
616			}
617
618			var match = event.match( /^([\w:-]*)\s*(.*)$/ );
619			var eventName = match[ 1 ] + instance.eventNamespace;
620			var selector = match[ 2 ];
621
622			if ( selector ) {
623				delegateElement.on( eventName, selector, handlerProxy );
624			} else {
625				element.on( eventName, handlerProxy );
626			}
627		} );
628	},
629
630	_off: function( element, eventName ) {
631		eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
632			this.eventNamespace;
633		element.off( eventName ).off( eventName );
634
635		// Clear the stack to avoid memory leaks (#10056)
636		this.bindings = $( this.bindings.not( element ).get() );
637		this.focusable = $( this.focusable.not( element ).get() );
638		this.hoverable = $( this.hoverable.not( element ).get() );
639	},
640
641	_delay: function( handler, delay ) {
642		function handlerProxy() {
643			return ( typeof handler === "string" ? instance[ handler ] : handler )
644				.apply( instance, arguments );
645		}
646		var instance = this;
647		return setTimeout( handlerProxy, delay || 0 );
648	},
649
650	_hoverable: function( element ) {
651		this.hoverable = this.hoverable.add( element );
652		this._on( element, {
653			mouseenter: function( event ) {
654				this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
655			},
656			mouseleave: function( event ) {
657				this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
658			}
659		} );
660	},
661
662	_focusable: function( element ) {
663		this.focusable = this.focusable.add( element );
664		this._on( element, {
665			focusin: function( event ) {
666				this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
667			},
668			focusout: function( event ) {
669				this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
670			}
671		} );
672	},
673
674	_trigger: function( type, event, data ) {
675		var prop, orig;
676		var callback = this.options[ type ];
677
678		data = data || {};
679		event = $.Event( event );
680		event.type = ( type === this.widgetEventPrefix ?
681			type :
682			this.widgetEventPrefix + type ).toLowerCase();
683
684		// The original event may come from any element
685		// so we need to reset the target on the new event
686		event.target = this.element[ 0 ];
687
688		// Copy original event properties over to the new event
689		orig = event.originalEvent;
690		if ( orig ) {
691			for ( prop in orig ) {
692				if ( !( prop in event ) ) {
693					event[ prop ] = orig[ prop ];
694				}
695			}
696		}
697
698		this.element.trigger( event, data );
699		return !( $.isFunction( callback ) &&
700			callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
701			event.isDefaultPrevented() );
702	}
703};
704
705$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
706	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
707		if ( typeof options === "string" ) {
708			options = { effect: options };
709		}
710
711		var hasOptions;
712		var effectName = !options ?
713			method :
714			options === true || typeof options === "number" ?
715				defaultEffect :
716				options.effect || defaultEffect;
717
718		options = options || {};
719		if ( typeof options === "number" ) {
720			options = { duration: options };
721		}
722
723		hasOptions = !$.isEmptyObject( options );
724		options.complete = callback;
725
726		if ( options.delay ) {
727			element.delay( options.delay );
728		}
729
730		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
731			element[ method ]( options );
732		} else if ( effectName !== method && element[ effectName ] ) {

733			element[ effectName ]( options.duration, options.easing, callback );
734		} else {
735			element.queue( function( next ) {
736				$( this )[ method ]();
737				if ( callback ) {
738					callback.call( element[ 0 ] );
739				}
740				next();
741			} );
742		}
743	};
744} );
745
746var widget = $.widget;
747
748
749/*!
750 * jQuery UI Position 1.12.1
751 * http://jqueryui.com
752 *
753 * Copyright jQuery Foundation and other contributors
754 * Released under the MIT license.
755 * http://jquery.org/license
756 *
757 * http://api.jqueryui.com/position/
758 */
759
760//>>label: Position
761//>>group: Core
762//>>description: Positions elements relative to other elements.
763//>>docs: http://api.jqueryui.com/position/
764//>>demos: http://jqueryui.com/position/
765
766
767( function() {
768var cachedScrollbarWidth,
769	max = Math.max,
770	abs = Math.abs,
771	rhorizontal = /left|center|right/,
772	rvertical = /top|center|bottom/,
773	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
774	rposition = /^\w+/,
775	rpercent = /%$/,
776	_position = $.fn.position;
777
778function getOffsets( offsets, width, height ) {
779	return [
780		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
781		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
782	];
783}
784
785function parseCss( element, property ) {
786	return parseInt( $.css( element, property ), 10 ) || 0;
787}
788
789function getDimensions( elem ) {
790	var raw = elem[ 0 ];
791	if ( raw.nodeType === 9 ) {
792		return {
793			width: elem.width(),
794			height: elem.height(),
795			offset: { top: 0, left: 0 }
796		};
797	}
798	if ( $.isWindow( raw ) ) {
799		return {
800			width: elem.width(),
801			height: elem.height(),
802			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
803		};
804	}
805	if ( raw.preventDefault ) {
806		return {
807			width: 0,
808			height: 0,
809			offset: { top: raw.pageY, left: raw.pageX }
810		};
811	}
812	return {
813		width: elem.outerWidth(),
814		height: elem.outerHeight(),
815		offset: elem.offset()
816	};
817}
818
819$.position = {
820	scrollbarWidth: function() {
821		if ( cachedScrollbarWidth !== undefined ) {
822			return cachedScrollbarWidth;
823		}
824		var w1, w2,
825			div = $( "<div " +
826				"style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'>" +
827				"<div style='height:100px;width:auto;'></div></div>" ),
828			innerDiv = div.children()[ 0 ];
829
830		$( "body" ).append( div );
831		w1 = innerDiv.offsetWidth;
832		div.css( "overflow", "scroll" );
833
834		w2 = innerDiv.offsetWidth;
835
836		if ( w1 === w2 ) {
837			w2 = div[ 0 ].clientWidth;
838		}
839
840		div.remove();
841
842		return ( cachedScrollbarWidth = w1 - w2 );
843	},
844	getScrollInfo: function( within ) {
845		var overflowX = within.isWindow || within.isDocument ? "" :
846				within.element.css( "overflow-x" ),
847			overflowY = within.isWindow || within.isDocument ? "" :
848				within.element.css( "overflow-y" ),
849			hasOverflowX = overflowX === "scroll" ||
850				( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),
851			hasOverflowY = overflowY === "scroll" ||
852				( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );
853		return {
854			width: hasOverflowY ? $.position.scrollbarWidth() : 0,
855			height: hasOverflowX ? $.position.scrollbarWidth() : 0
856		};
857	},
858	getWithinInfo: function( element ) {
859		var withinElement = $( element || window ),
860			isWindow = $.isWindow( withinElement[ 0 ] ),
861			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
862			hasOffset = !isWindow && !isDocument;
863		return {
864			element: withinElement,
865			isWindow: isWindow,
866			isDocument: isDocument,
867			offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
868			scrollLeft: withinElement.scrollLeft(),
869			scrollTop: withinElement.scrollTop(),
870			width: withinElement.outerWidth(),
871			height: withinElement.outerHeight()
872		};
873	}
874};
875
876$.fn.position = function( options ) {
877	if ( !options || !options.of ) {
878		return _position.apply( this, arguments );
879	}
880
881	// Make a copy, we don't want to modify arguments
882	options = $.extend( {}, options );
883
884	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
885		target = $( options.of ),

885
886		within = $.position.getWithinInfo( options.within ),
887		scrollInfo = $.position.getScrollInfo( within ),
888		collision = ( options.collision || "flip" ).split( " " ),
889		offsets = {};
890
891	dimensions = getDimensions( target );
892	if ( target[ 0 ].preventDefault ) {
893
894		// Force left top to allow flipping
895		options.at = "left top";
896	}
897	targetWidth = dimensions.width;
898	targetHeight = dimensions.height;
899	targetOffset = dimensions.offset;
900
901	// Clone to reuse original targetOffset later
902	basePosition = $.extend( {}, targetOffset );
903
904	// Force my and at to have valid horizontal and vertical positions
905	// if a value is missing or invalid, it will be converted to center
906	$.each( [ "my", "at" ], function() {
907		var pos = ( options[ this ] || "" ).split( " " ),
908			horizontalOffset,
909			verticalOffset;
910
911		if ( pos.length === 1 ) {
912			pos = rhorizontal.test( pos[ 0 ] ) ?
913				pos.concat( [ "center" ] ) :
914				rvertical.test( pos[ 0 ] ) ?
915					[ "center" ].concat( pos ) :
916					[ "center", "center" ];
917		}
918		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
919		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
920
921		// Calculate offsets
922		horizontalOffset = roffset.exec( pos[ 0 ] );
923		verticalOffset = roffset.exec( pos[ 1 ] );
924		offsets[ this ] = [
925			horizontalOffset ? horizontalOffset[ 0 ] : 0,
926			verticalOffset ? verticalOffset[ 0 ] : 0
927		];
928
929		// Reduce to just the positions without the offsets
930		options[ this ] = [
931			rposition.exec( pos[ 0 ] )[ 0 ],
932			rposition.exec( pos[ 1 ] )[ 0 ]
933		];
934	} );
935
936	// Normalize collision option
937	if ( collision.length === 1 ) {
938		collision[ 1 ] = collision[ 0 ];
939	}
940
941	if ( options.at[ 0 ] === "right" ) {
942		basePosition.left += targetWidth;
943	} else if ( options.at[ 0 ] === "center" ) {
944		basePosition.left += targetWidth / 2;
945	}
946
947	if ( options.at[ 1 ] === "bottom" ) {
948		basePosition.top += targetHeight;
949	} else if ( options.at[ 1 ] === "center" ) {
950		basePosition.top += targetHeight / 2;
951	}
952
953	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
954	basePosition.left += atOffset[ 0 ];
955	basePosition.top += atOffset[ 1 ];
956
957	return this.each( function() {
958		var collisionPosition, using,
959			elem = $( this ),
960			elemWidth = elem.outerWidth(),
961			elemHeight = elem.outerHeight(),
962			marginLeft = parseCss( this, "marginLeft" ),
963			marginTop = parseCss( this, "marginTop" ),
964			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
965				scrollInfo.width,
966			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
967				scrollInfo.height,
968			position = $.extend( {}, basePosition ),
969			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
970
971		if ( options.my[ 0 ] === "right" ) {
972			position.left -= elemWidth;
973		} else if ( options.my[ 0 ] === "center" ) {
974			position.left -= elemWidth / 2;
975		}
976
977		if ( options.my[ 1 ] === "bottom" ) {
978			position.top -= elemHeight;
979		} else if ( options.my[ 1 ] === "center" ) {
980			position.top -= elemHeight / 2;
981		}
982
983		position.left += myOffset[ 0 ];
984		position.top += myOffset[ 1 ];
985
986		collisionPosition = {
987			marginLeft: marginLeft,
988			marginTop: marginTop
989		};
990
991		$.each( [ "left", "top" ], function( i, dir ) {
992			if ( $.ui.position[ collision[ i ] ] ) {
993				$.ui.position[ collision[ i ] ][ dir ]( position, {
994					targetWidth: targetWidth,
995					targetHeight: targetHeight,
996					elemWidth: elemWidth,
997					elemHeight: elemHeight,
998					collisionPosition: collisionPosition,
999					collisionWidth: collisionWidth,
1000					collisionHeight: collisionHeight,
1001					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1002					my: options.my,
1003					at: options.at,
1004					within: within,
1005					elem: elem
1006				} );
1007			}
1008		} );
1009
1010		if ( options.using ) {
1011
1012			// Adds feedback as second argument to using callback, if present
1013			using = function( props ) {
1014				var left = targetOffset.left - position.left,
1015					right = left + targetWidth - elemWidth,
1016					top = targetOffset.top - position.top,
1017					bottom = top + targetHeight - elemHeight,
1018					feedback = {
1019						target: {
1020							element: target,
1021							left: targetOffset.left,
1022							top: targetOffset.top,
1023							width: targetWidth,
1024							height: targetHeight
1025						},
1026						element: {
1027							element: elem,
1028							left: position.left,
1029							top: position.top,
1030							width: elemWidth,
1031							height: elemHeight
1032						},
1033						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1034						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1035					};
1036				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1037					feedback.horizontal = "center";
1038				}
1039				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1040					feedback.vertical = "middle";
1041				}
1042				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1043					feedback.important = "horizontal";
1044				} else {
1045					feedback.important = "vertical";
1046				}
1047				options.using.call( this, props, feedback );
1048			};
1049		}
1050
1051		elem.offset( $.extend( position, { using: using } ) );
1052	} );
1053};
1054
1055$.ui.position = {
1056	fit: {
1057		left: function( position, data ) {
1058			var within = data.within,
1059				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1060				outerWidth = within.width,
1061				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1062				overLeft = withinOffset - collisionPosLeft,
1063				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1064				newOverRight;
1065
1066			// Element is wider than within
1067			if ( data.collisionWidth > outerWidth ) {
1068
1069				// Element is initially over the left side of within
1070				if ( overLeft > 0 && overRight <= 0 ) {
1071					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
1072						withinOffset;
1073					position.left += overLeft - newOverRight;
1074
1075				// Element is initially over right side of within
1076				} else if ( overRight > 0 && overLeft <= 0 ) {
1077					position.left = withinOffset;
1078
1079				// Element is initially over both left and right sides of within
1080				} else {
1081					if ( overLeft > overRight ) {
1082						position.left = withinOffset + outerWidth - data.collisionWidth;
1083					} else {
1084						position.left = withinOffset;
1085					}
1086				}
1087
1088			// Too far left -> align with left edge
1089			} else if ( overLeft > 0 ) {
1090				position.left += overLeft;
1091
1092			// Too far right -> align with right edge
1093			} else if ( overRight > 0 ) {
1094				position.left -= overRight;
1095
1096			// Adjust based on position and margin
1097			} else {
1098				position.left = max( position.left - collisionPosLeft, position.left );
1099			}
1100		},
1101		top: function( position, data ) {
1102			var within = data.within,
1103				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1104				outerHeight = data.within.height,
1105				collisionPosTop = position.top - data.collisionPosition.marginTop,
1106				overTop = withinOffset - collisionPosTop,
1107				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1108				newOverBottom;
1109
1110			// Element is taller than within
1111			if ( data.collisionHeight > outerHeight ) {
1112
1113				// Element is initially over the top of within
1114				if ( overTop > 0 && overBottom <= 0 ) {
1115					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
1116						withinOffset;
1117					position.top += overTop - newOverBottom;
1118
1119				// Element is initially over bottom of within
1120				} else if ( overBottom > 0 && overTop <= 0 ) {
1121					position.top = withinOffset;
1122
1123				// Element is initially over both top and bottom of within
1124				} else {
1125					if ( overTop > overBottom ) {
1126						position.top = withinOffset + outerHeight - data.collisionHeight;
1127					} else {
1128						position.top = withinOffset;
1129					}
1130				}
1131
1132			// Too far up -> align with top
1133			} else if ( overTop > 0 ) {
1134				position.top += overTop;
1135
1136			// Too far down -> align with bottom edge
1137			} else if ( overBottom > 0 ) {
1138				position.top -= overBottom;
1139
1140			// Adjust based on position and margin
1141			} else {
1142				position.top = max( position.top - collisionPosTop, position.top );
1143			}
1144		}
1145	},
1146	flip: {
1147		left: function( position, data ) {
1148			var within = data.within,
1149				withinOffset = within.offset.left + within.scrollLeft,
1150				outerWidth = within.width,
1151				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1152				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1153				overLeft = collisionPosLeft - offsetLeft,
1154				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1155				myOffset = data.my[ 0 ] === "left" ?
1156					-data.elemWidth :
1157					data.my[ 0 ] === "right" ?
1158						data.elemWidth :
1159						0,
1160				atOffset = data.at[ 0 ] === "left" ?
1161					data.targetWidth :
1162					data.at[ 0 ] === "right" ?
1163						-data.targetWidth :
1164						0,
1165				offset = -2 * data.offset[ 0 ],
1166				newOverRight,
1167				newOverLeft;
1168
1169			if ( overLeft < 0 ) {
1170				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
1171					outerWidth - withinOffset;
1172				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1173					position.left += myOffset + atOffset + offset;
1174				}
1175			} else if ( overRight > 0 ) {
1176				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
1177					atOffset + offset - offsetLeft;
1178				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1179					position.left += myOffset + atOffset + offset;
1180				}
1181			}
1182		},
1183		top: function( position, data ) {
1184			var within = data.within,
1185				withinOffset = within.offset.top + within.scrollTop,
1186				outerHeight = within.height,
1187				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1188				collisionPosTop = position.top - data.collisionPosition.marginTop,
1189				overTop = collisionPosTop - offsetTop,
1190				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1191				top = data.my[ 1 ] === "top",
1192				myOffset = top ?
1193					-data.elemHeight :
1194					data.my[ 1 ] === "bottom" ?
1195						data.elemHeight :
1196						0,
1197				atOffset = data.at[ 1 ] === "top" ?
1198					data.targetHeight :
1199					data.at[ 1 ] === "bottom" ?
1200						-data.targetHeight :
1201						0,
1202				offset = -2 * data.offset[ 1 ],
1203				newOverTop,
1204				newOverBottom;
1205			if ( overTop < 0 ) {
1206				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
1207					outerHeight - withinOffset;
1208				if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1209					position.top += myOffset + atOffset + offset;
1210				}
1211			} else if ( overBottom > 0 ) {
1212				newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
1213					offset - offsetTop;
1214				if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1215					position.top += myOffset + atOffset + offset;
1216				}
1217			}
1218		}
1219	},
1220	flipfit: {
1221		left: function() {
1222			$.ui.position.flip.left.apply( this, arguments );
1223			$.ui.position.fit.left.apply( this, arguments );
1224		},
1225		top: function() {
1226			$.ui.position.flip.top.apply( this, arguments );
1227			$.ui.position.fit.top.apply( this, arguments );
1228		}
1229	}
1230};
1231
1232} )();
1233
1234var position = $.ui.position;
1235
1236
1237/*!
1238 * jQuery UI 

1238Keycode 1.12.1
1239 * http://jqueryui.com
1240 *
1241 * Copyright jQuery Foundation and other contributors
1242 * Released under the MIT license.
1243 * http://jquery.org/license
1244 */
1245
1246//>>label: Keycode
1247//>>group: Core
1248//>>description: Provide keycodes as keynames
1249//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
1250
1251
1252var keycode = $.ui.keyCode = {
1253	BACKSPACE: 8,
1254	COMMA: 188,
1255	DELETE: 46,
1256	DOWN: 40,
1257	END: 35,
1258	ENTER: 13,
1259	ESCAPE: 27,
1260	HOME: 36,
1261	LEFT: 37,
1262	PAGE_DOWN: 34,
1263	PAGE_UP: 33,
1264	PERIOD: 190,
1265	RIGHT: 39,
1266	SPACE: 32,
1267	TAB: 9,
1268	UP: 38
1269};
1270
1271
1272/*!
1273 * jQuery UI Unique ID 1.12.1
1274 * http://jqueryui.com
1275 *
1276 * Copyright jQuery Foundation and other contributors
1277 * Released under the MIT license.
1278 * http://jquery.org/license
1279 */
1280
1281//>>label: uniqueId
1282//>>group: Core
1283//>>description: Functions to generate and remove uniqueId's
1284//>>docs: http://api.jqueryui.com/uniqueId/
1285
1286
1287
1288var uniqueId = $.fn.extend( {
1289	uniqueId: ( function() {
1290		var uuid = 0;
1291
1292		return function() {
1293			return this.each( function() {
1294				if ( !this.id ) {
1295					this.id = "ui-id-" + ( ++uuid );
1296				}
1297			} );
1298		};
1299	} )(),
1300
1301	removeUniqueId: function() {
1302		return this.each( function() {
1303			if ( /^ui-id-\d+$/.test( this.id ) ) {
1304				$( this ).removeAttr( "id" );
1305			}
1306		} );
1307	}
1308} );
1309
1310
1311// jscs:disable maximumLineLength
1312/* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */
1313/*!
1314 * jQuery UI Datepicker 1.12.1
1315 * http://jqueryui.com
1316 *
1317 * Copyright jQuery Foundation and other contributors
1318 * Released under the MIT license.
1319 * http://jquery.org/license
1320 */
1321
1322//>>label: Datepicker
1323//>>group: Widgets
1324//>>description: Displays a calendar from an input or inline for selecting dates.
1325//>>docs: http://api.jqueryui.com/datepicker/
1326//>>demos: http://jqueryui.com/datepicker/
1327//>>css.structure: ../../themes/base/core.css
1328//>>css.structure: ../../themes/base/datepicker.css
1329//>>css.theme: ../../themes/base/theme.css
1330
1331
1332
1333$.extend( $.ui, { datepicker: { version: "1.12.1" } } );
1334
1335var datepicker_instActive;
1336
1337function datepicker_getZindex( elem ) {
1338	var position, value;
1339	while ( elem.length && elem[ 0 ] !== document ) {
1340
1341		// Ignore z-index if position is set to a value where z-index is ignored by the browser
1342		// This makes behavior of this function consistent across browsers
1343		// WebKit always returns auto if the element is positioned
1344		position = elem.css( "position" );
1345		if ( position === "absolute" || position === "relative" || position === "fixed" ) {
1346
1347			// IE returns 0 when zIndex is not specified
1348			// other browsers return a string
1349			// we ignore the case of nested elements with an explicit value of 0
1350			// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
1351			value = parseInt( elem.css( "zIndex" ), 10 );
1352			if ( !isNaN( value ) && value !== 0 ) {
1353				return value;
1354			}
1355		}
1356		elem = elem.parent();
1357	}
1358
1359	return 0;
1360}
1361/* Date picker manager.
1362   Use the singleton instance of this class, $.datepicker, to interact with the date picker.
1363   Settings for (groups of) date pickers are maintained in an instance object,
1364   allowing multiple different settings on the same page. */
1365
1366function Datepicker() {
1367	this._curInst = null; // The current instance in use
1368	this._keyEvent = false; // If the last event was a key event
1369	this._disabledInputs = []; // List of date picker inputs that have been disabled
1370	this._datepickerShowing = false; // True if the popup picker is showing , false if not
1371	this._inDialog = false; // True if showing within a "dialog", false if not
1372	this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
1373	this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
1374	this._appendClass = "ui-datepicker-append"; // The name of the append marker class
1375	this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
1376	this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
1377	this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
1378	this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
1379	this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
1380	this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
1381	this.regional = []; // Available regional settings, indexed by language code
1382	this.regional[ "" ] = { // Default regional settings
1383		closeText: "Done", // Display text for close link
1384		prevText: "Prev", // Display text for previous month link
1385		nextText: "Next", // Display text for next month link
1386		currentText: "Today", // Display text for current month link
1387		monthNames: [ "January","February","March","April","May","June",
1388			"July","August","September","October","November","December" ], // Names of months for drop-down and formatting
1389		monthNamesShort: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ], // For formatting
1390		dayNames: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ], // For formatting
1391		dayNamesShort: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ], // For formatting
1392		dayNamesMin: [ "Su","Mo","Tu","We","Th","Fr","Sa" ], // Column headings for days starting at Sunday
1393		weekHeader: "Wk", // Column header for week of the year
1394		dateFormat: "mm/dd/yy", // See format options on parseDate
1395		firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
1396		isRTL: false, // True if right-to-left language, false if left-to-right
1397		showMonthAfterYear: false, // True if the year select precedes month, false for month then year
1398		yearSuffix: "" // Additional text to append to the year in the month headers
1399	};
1400	this._defaults = { // Global defaults for all the date picker instances
1401		showOn: "focus", // "focus" for popup on focus,
1402			// "button" for trigger button, or "both" for either
1403		showAnim: "fadeIn", // Name of jQuery animation for popup
1404		showOptions: {}, // Options for enhanced animations
1405		defaultDate: null, // Used when field is blank: actual date,
1406			// +/-number for offset from today, null for today
1407		appendText: "", // Display text following the input box, e.g. showing the format
1408		buttonText: "...", // Text for trigger button
1409		buttonImage: "", // URL for trigger button image
1410		buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
1411		hideIfNoPrevNext: false, // True to hide next/previous month links
1412			// if not applicable, false to just disable them
1413		navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
1414		gotoCurrent: false, // True if today link goes back to current selection instead
1415		changeMonth: false, // True if month can be selected directly, false if only prev/next
1416		changeYear: false, // True if year can be selected directly, false if only prev/next
1417		yearRange: "c-10:c+10", // Range of years to display in drop-down,
1418			// either relative to today's year (-nn:+nn), relative to currently displayed year
1419			// (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
1420		showOtherMonths: false, // True to show dates in other months, false to leave blank
1421		selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
1422		showWeek: false, // True to show week of the year, false to not show it
1423		calculateWeek: this.iso8601Week, // How to calculate the week of the year,
1424			// takes a Date and returns the number of the week for it
1425		shortYearCutoff: "+10", // Short year values < this are in the current century,
1426			// > this are in the previous century,
1427			// string value starting with "+" for current year + value
1428		minDate: null, // The earliest selectable date, or null for no limit
1429		maxDate: null, // The latest selectable date, or null for no limit
1430		duration: "fast", // Duration of display/closure
1431		beforeShowDay: null, // Function that takes a date and returns an array with
1432			// [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
1433			// [2] = cell title (optional), e.g. $.datepicker.noWeekends
1434		beforeShow: null, // Function that takes an input field and
1435			// returns a set of custom settings for the date picker
1436		onSelect: null, // Define a callback function when a date is selected
1437		onChangeMonthYear: null, // Define a callback function when the month or year is changed
1438		onClose: null, // Define a callback function when the datepicker is closed
1439		numberOfMonths: 1, // Number of months to show at a time
1440		showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
1441		stepMonths: 1, // Number of months to step back/forward
1442		stepBigMonths: 12, // Number of months to step back/forward for the big links
1443		altField: "", // Selector for an alternate field to store selected dates into
1444		altFormat: "", // The date format to use for the alternate field
1445		constrainInput: true, // The input is constrained by the current date format
1446		showButtonPanel: false, // True to show button panel, false to not show it
1447		autoSize: false, // True to size the input for the date format, false to leave as is
1448		disabled: false // The initial disabled state
1449	};
1450	$.extend( this._defaults, this.regional[ "" ] );
1451	this.regional.en = $.extend( true, {}, this.regional[ "" ] );
1452	this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
1453	this.dpDiv = datepicker_bindHover( $( "<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>" ) );
1454}
1455
1456$.extend( Datepicker.prototype, {
1457	/* Class name added to elements to indicate already configured with a date picker. */
1458	markerClassName: "hasDatepicker",
1459
1460	//Keep track of the maximum number of rows displayed (see #7043)
1461	maxRows: 4,
1462
1463	// TODO rename to "widget" when switching to widget factory
1464	_widgetDatepicker: function() {
1465		return this.dpDiv;
1466	},
1467
1468	/* Override the default settings for all instances of the date picker.
1469	 * @param  settings  object - the new settings to use as defaults (anonymous object)
1470	 * @return the manager object
1471	 */
1472	setDefaults: function( settings ) {
1473		datepicker_extendRemove( this._defaults, settings || {} );
1474		return this;
1475	},
1476
1477	/* Attach the date picker to a jQuery selection.
1478	 * @param  target	element - the target input field or division or span
1479	 * @param  settings  object - the new settings to use for this date picker instance (anonymous)
1480	 */
1481	_attachDatepicker: function( target, settings ) {
1482		var nodeName, inline, inst;
1483		nodeName = target.nodeName.toLowerCase();
1484		inline = ( nodeName === "div" || nodeName === "span" );
1485		if ( !target.id ) {
1486			this.uuid += 1;
1487			target.id = "dp" + this.uuid;
1488		}
1489		inst = this._newInst( $( target ), inline );
1490		inst.settings = $.extend( {}, settings || {} );
1491		if ( nodeName === "input" ) {
1492			this._connectDatepicker( target, inst );
1493		} else if ( inline ) {
1494			this._inlineDatepicker( target, inst );
1495		}
1496	},
1497
1498	/* Create a new instance object. */
1499	_newInst: function( target, inline ) {
1500		var id = target[ 0 ].id.replace( /([^A-Za-z0-9_\-])/g, "\\\\$1" ); // escape jQuery meta chars
1501		return { id: id, input: target, // associated target
1502			selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
1503			drawMonth: 0, drawYear: 0, // month being drawn
1504			inline: inline, // is datepicker inline or not
1505			dpDiv: ( !inline ? this.dpDiv : // presentation div
1506			datepicker_bindHover( $( "<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>" ) ) ) };
1507	},
1508
1509	/* Attach the date picker to an input field. */
1510	_connectDatepicker: function( target, inst ) {
1511		var input = $( target );
1512		inst.append = $( [] );
1513		inst.trigger = $( [] );
1514		if ( input.hasClass( this.markerClassName ) ) {
1515			return;
1516		}
1517		this._attachments( input, inst );
1518		input.addClass( this.markerClassName ).on( "keydown", this._doKeyDown ).
1519			on( "keypress", this._doKeyPress ).on( "keyup", this._doKeyUp );
1520		this._autoSize( inst );
1521		$.data( target, "datepicker", inst );
1522
1523		//If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
1524		if ( inst.settings.disabled ) {
1525			this._disableDatepicker( target );
1526		}
1527	},
1528
1529	/* Make attachments based on settings. */
1530	_attachments: function( input, inst ) {
1531		var showOn, buttonText, buttonImage,
1532			appendText = this._get( inst, "appendText" ),
1533			isRTL = this._get( inst, "isRTL" );
1534
1535		if ( inst.append ) {

1536			inst.append.remove();
1537		}
1538		if ( appendText ) {
1539			inst.append = $( "<span class='" + this._appendClass + "'>" + appendText + "</span>" );
1540			input[ isRTL ? "before" : "after" ]( inst.append );
1541		}
1542
1543		input.off( "focus", this._showDatepicker );
1544
1545		if ( inst.trigger ) {
1546			inst.trigger.remove();
1547		}
1548
1549		showOn = this._get( inst, "showOn" );
1550		if ( showOn === "focus" || showOn === "both" ) { // pop-up date picker when in the marked field
1551			input.on( "focus", this._showDatepicker );
1552		}
1553		if ( showOn === "button" || showOn === "both" ) { // pop-up date picker when button clicked
1554			buttonText = this._get( inst, "buttonText" );
1555			buttonImage = this._get( inst, "buttonImage" );
1556			inst.trigger = $( this._get( inst, "buttonImageOnly" ) ?
1557				$( "<img/>" ).addClass( this._triggerClass ).
1558					attr( { src: buttonImage, alt: buttonText, title: buttonText } ) :
1559				$( "<button type='button'></button>" ).addClass( this._triggerClass ).
1560					html( !buttonImage ? buttonText : $( "<img/>" ).attr(
1561					{ src:buttonImage, alt:buttonText, title:buttonText } ) ) );
1562			input[ isRTL ? "before" : "after" ]( inst.trigger );
1563			inst.trigger.on( "click", function() {
1564				if ( $.datepicker._datepickerShowing && $.datepicker._lastInput === input[ 0 ] ) {
1565					$.datepicker._hideDatepicker();
1566				} else if ( $.datepicker._datepickerShowing && $.datepicker._lastInput !== input[ 0 ] ) {
1567					$.datepicker._hideDatepicker();
1568					$.datepicker._showDatepicker( input[ 0 ] );
1569				} else {
1570					$.datepicker._showDatepicker( input[ 0 ] );
1571				}
1572				return false;
1573			} );
1574		}
1575	},
1576
1577	/* Apply the maximum length for the date format. */
1578	_autoSize: function( inst ) {
1579		if ( this._get( inst, "autoSize" ) && !inst.inline ) {
1580			var findMax, max, maxI, i,
1581				date = new Date( 2009, 12 - 1, 20 ), // Ensure double digits
1582				dateFormat = this._get( inst, "dateFormat" );
1583
1584			if ( dateFormat.match( /[DM]/ ) ) {
1585				findMax = function( names ) {
1586					max = 0;
1587					maxI = 0;
1588					for ( i = 0; i < names.length; i++ ) {
1589						if ( names[ i ].length > max ) {
1590							max = names[ i ].length;
1591							maxI = i;
1592						}
1593					}
1594					return maxI;
1595				};
1596				date.setMonth( findMax( this._get( inst, ( dateFormat.match( /MM/ ) ?
1597					"monthNames" : "monthNamesShort" ) ) ) );
1598				date.setDate( findMax( this._get( inst, ( dateFormat.match( /DD/ ) ?
1599					"dayNames" : "dayNamesShort" ) ) ) + 20 - date.getDay() );
1600			}
1601			inst.input.attr( "size", this._formatDate( inst, date ).length );
1602		}
1603	},
1604
1605	/* Attach an inline date picker to a div. */
1606	_inlineDatepicker: function( target, inst ) {
1607		var divSpan = $( target );
1608		if ( divSpan.hasClass( this.markerClassName ) ) {
1609			return;
1610		}
1611		divSpan.addClass( this.markerClassName ).append( inst.dpDiv );
1612		$.data( target, "datepicker", inst );
1613		this._setDate( inst, this._getDefaultDate( inst ), true );
1614		this._updateDatepicker( inst );
1615		this._updateAlternate( inst );
1616
1617		//If disabled option is true, disable the datepicker before showing it (see ticket #5665)
1618		if ( inst.settings.disabled ) {
1619			this._disableDatepicker( target );
1620		}
1621
1622		// Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
1623		// http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
1624		inst.dpDiv.css( "display", "block" );
1625	},
1626
1627	/* Pop-up the date picker in a "dialog" box.
1628	 * @param  input element - ignored
1629	 * @param  date	string or Date - the initial date to display
1630	 * @param  onSelect  function - the function to call when a date is selected
1631	 * @param  settings  object - update the dialog date picker instance's settings (anonymous object)
1632	 * @param  pos int[2] - coordinates for the dialog's position within the screen or
1633	 *					event - with x/y coordinates or
1634	 *					leave empty for default (screen centre)
1635	 * @return the manager object
1636	 */
1637	_dialogDatepicker: function( input, date, onSelect, settings, pos ) {
1638		var id, browserWidth, browserHeight, scrollX, scrollY,
1639			inst = this._dialogInst; // internal instance
1640
1641		if ( !inst ) {
1642			this.uuid += 1;
1643			id = "dp" + this.uuid;
1644			this._dialogInput = $( "<input type='text' id='" + id +
1645				"' style='position: absolute; top: -100px; width: 0px;'/>" );
1646			this._dialogInput.on( "keydown", this._doKeyDown );
1647			$( "body" ).append( this._dialogInput );
1648			inst = this._dialogInst = this._newInst( this._dialogInput, false );
1649			inst.settings = {};
1650			$.data( this._dialogInput[ 0 ], "datepicker", inst );
1651		}
1652		datepicker_extendRemove( inst.settings, settings || {} );
1653		date = ( date && date.constructor === Date ? this._formatDate( inst, date ) : date );
1654		this._dialogInput.val( date );
1655
1656		this._pos = ( pos ? ( pos.length ? pos : [ pos.pageX, pos.pageY ] ) : null );
1657		if ( !this._pos ) {
1658			browserWidth = document.documentElement.clientWidth;
1659			browserHeight = document.documentElement.clientHeight;
1660			scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
1661			scrollY = document.documentElement.scrollTop || document.body.scrollTop;
1662			this._pos = // should use actual width/height below
1663				[ ( browserWidth / 2 ) - 100 + scrollX, ( browserHeight / 2 ) - 150 + scrollY ];
1664		}
1665
1666		// Move input on screen for focus, but hidden behind dialog
1667		this._dialogInput.css( "left", ( this._pos[ 0 ] + 20 ) + "px" ).css( "top", this._pos[ 1 ] + "px" );
1668		inst.settings.onSelect = onSelect;
1669		this._inDialog = true;
1670		this.dpDiv.addClass( this._dialogClass );
1671		this._showDatepicker( this._dialogInput[ 0 ] );
1672		if ( $.blockUI ) {
1673			$.blockUI( this.dpDiv );
1674		}
1675		$.data( this._dialogInput[ 0 ], "datepicker", inst );
1676		return this;
1677	},
1678
1679	/* Detach a datepicker from its control.
1680	 * @param  target	element - the target input field or division or span
1681	 */
1682	_destroyDatepicker: function( target ) {
1683		var nodeName,
1684			$target = $( target ),
1685			inst = $.data( target, "datepicker" );
1686
1687		if ( !$target.hasClass( this.markerClassName ) ) {
1688			return;
1689		}
1690
1691		nodeName = target.nodeName.toLowerCase();
1692		$.removeData( target, "datepicker" );
1693		if ( nodeName === "input" ) {
1694			inst.append.remove();
1695			inst.trigger.remove();
1696			$target.removeClass( this.markerClassName ).
1697				off( "focus", this._showDatepicker ).
1698				off( "keydown", this._doKeyDown ).
1699				off( "keypress", this._doKeyPress ).
1700				off( "keyup", this._doKeyUp );
1701		} else if ( nodeName === "div" || nodeName === "span" ) {
1702			$target.removeClass( this.markerClassName ).empty();
1703		}
1704
1705		if ( datepicker_instActive === inst ) {
1706			datepicker_instActive = null;
1707		}
1708	},
1709
1710	/* Enable the date picker to a jQuery selection.
1711	 * @param  target	element - the target input field or division or span
1712	 */
1713	_enableDatepicker: function( target ) {
1714		var nodeName, inline,
1715			$target = $( target ),
1716			inst = $.data( target, "datepicker" );
1717
1718		if ( !$target.hasClass( this.markerClassName ) ) {
1719			return;
1720		}
1721
1722		nodeName = target.nodeName.toLowerCase();
1723		if ( nodeName === "input" ) {
1724			target.disabled = false;
1725			inst.trigger.filter( "button" ).
1726				each( function() { this.disabled = false; } ).end().
1727				filter( "img" ).css( { opacity: "1.0", cursor: "" } );
1728		} else if ( nodeName === "div" || nodeName === "span" ) {
1729			inline = $target.children( "." + this._inlineClass );
1730			inline.children().removeClass( "ui-state-disabled" );
1731			inline.find( "select.ui-datepicker-month, select.ui-datepicker-year" ).
1732				prop( "disabled", false );
1733		}
1734		this._disabledInputs = $.map( this._disabledInputs,
1735			function( value ) { return ( value === target ? null : value ); } ); // delete entry
1736	},
1737
1738	/* Disable the date picker to a jQuery selection.
1739	 * @param  target	element - the target input field or division or span
1740	 */
1741	_disableDatepicker: function( target ) {
1742		var nodeName, inline,
1743			$target = $( target ),
1744			inst = $.data( target, "datepicker" );
1745
1746		if ( !$target.hasClass( this.markerClassName ) ) {
1747			return;
1748		}
1749
1750		nodeName = target.nodeName.toLowerCase();
1751		if ( nodeName === "input" ) {
1752			target.disabled = true;
1753			inst.trigger.filter( "button" ).
1754				each( function() { this.disabled = true; } ).end().
1755				filter( "img" ).css( { opacity: "0.5", cursor: "default" } );
1756		} else if ( nodeName === "div" || nodeName === "span" ) {
1757			inline = $target.children( "." + this._inlineClass );
1758			inline.children().addClass( "ui-state-disabled" );
1759			inline.find( "select.ui-datepicker-month, select.ui-datepicker-year" ).
1760				prop( "disabled", true );
1761		}
1762		this._disabledInputs = $.map( this._disabledInputs,
1763			function( value ) { return ( value === target ? null : value ); } ); // delete entry
1764		this._disabledInputs[ this._disabledInputs.length ] = target;
1765	},
1766
1767	/* Is the first field in a jQuery collection disabled as a datepicker?
1768	 * @param  target	element - the target input field or division or span
1769	 * @return boolean - true if disabled, false if enabled
1770	 */
1771	_isDisabledDatepicker: function( target ) {
1772		if ( !target ) {
1773			return false;
1774		}
1775		for ( var i = 0; i < this._disabledInputs.length; i++ ) {
1776			if ( this._disabledInputs[ i ] === target ) {
1777				return true;
1778			}
1779		}
1780		return false;
1781	},
1782
1783	/* Retrieve the instance data for the target control.
1784	 * @param  target  element - the target input field or division or span
1785	 * @return  object - the associated instance data
1786	 * @throws  error if a jQuery problem getting data
1787	 */
1788	_getInst: function( target ) {
1789		try {
1790			return $.data( target, "datepicker" );
1791		}
1792		catch ( err ) {
1793			throw "Missing instance data for this datepicker";
1794		}
1795	},
1796
1797	/* Update or retrieve the settings for a date picker attached to an input field or division.
1798	 * @param  target  element - the target input field or division or span
1799	 * @param  name	object - the new settings to update or
1800	 *				string - the name of the setting to change or retrieve,
1801	 *				when retrieving also "all" for all instance settings or
1802	 *				"defaults" for all global defaults
1803	 * @param  value   any - the new value for the setting
1804	 *				(omit if above is an object or to retrieve a value)
1805	 */
1806	_optionDatepicker: function( target, name, value ) {
1807		var settings, date, minDate, maxDate,
1808			inst = this._getInst( target );
1809
1810		if ( arguments.length === 2 && typeof name === "string" ) {
1811			return ( name === "defaults" ? $.extend( {}, $.datepicker._defaults ) :
1812				( inst ? ( name === "all" ? $.extend( {}, inst.settings ) :
1813				this._get( inst, name ) ) : null ) );
1814		}
1815
1816		settings = name || {};
1817		if ( typeof name === "string" ) {
1818			settings = {};
1819			settings[ name ] = value;
1820		}
1821
1822		if ( inst ) {
1823			if ( this._curInst === inst ) {
1824				this._hideDatepicker();
1825			}
1826
1827			date = this._getDateDatepicker( target, true );
1828			minDate = this._getMinMaxDate( inst, "min" );
1829			maxDate = this._getMinMaxDate( inst, "max" );
1830			datepicker_extendRemove( inst.settings, settings );
1831
1832			// reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
1833			if ( minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined ) {
1834				inst.settings.minDate = this._formatDate( inst, minDate );
1835			}
1836			if ( maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined ) {
1837				inst.settings.maxDate = this._formatDate( inst, maxDate );
1838			}
1839			if ( "disabled" in settings ) {
1840				if ( settings.disabled ) {
1841					this._disableDatepicker( target );
1842				} else {
1843					this._enableDatepicker( target );
1844				}
1845			}
1846			this._attachments( $( target ), inst );
1847			this._autoSize( inst );
1848			this._setDate( inst, date );
1849			this._updateAlternate( inst );
1850			this._updateDatepicker( inst );
1851		}
1852	},
1853
1854	// Change method deprecated
1855	_changeDatepicker: function( target, name, value ) {
1856		this._optionDatepicker( target, name, value );
1857	},
1858
1859	/* Redraw the date picker attached to an input field or division.
1860	 * @param  target  element - the target input field or division or span
1861	 */
1862	_refreshDatepicker: function( target ) {
1863		var inst = this._getInst( target );
1864		if ( inst ) {
1865			this._updateDatepicker( inst );
1866		}
1867	},
1868
1869	/* Set the dates for a jQuery selection.
1870	 * @param  target element - the target input field or division or span
1871	 * @param  date	Date - the new date
1872	 */
1873	_setDateDatepicker: function( target, date ) {
1874		var inst = this._getInst( target );
1875		if ( inst ) {
1876			this._setDate( inst, date );
1877			this._updateDatepicker( inst );
1878			this._updateAlternate( inst );
1879		}
1880	},
1881
1882	/* Get the date(s) for the first entry in a jQuery selection.
1883	 * @param  target element - the target input field or division or span
1884	 * @param  noDefault boolean - true if no default date is to be used
1885	 * @return Date - the current date
1886	 */
1887	_getDateDatepicker: function( target, noDefault ) {
1888		var inst = this._getInst( target );
1889		if ( inst && !inst.inline ) {
1890			this._setDateFromField( inst, noDefault );
1891		}
1892		return ( inst ? this._getDate( inst ) : null );
1893	},
1894
1895	/* Handle keystrokes. */
1896	_doKeyDown: function( event ) {
1897		var onSelect, dateStr, sel,
1898			inst = $.datepicker._getInst( event.target ),
1899			handled = true,
1900			isRTL = inst.dpDiv.is( ".ui-datepicker-rtl" );
1901
1902		inst._keyEvent = true;
1903		if ( $.datepicker._datepickerShowing ) {
1904			switch ( event.keyCode ) {
1905				case 9: $.datepicker._hideDatepicker();
1906						handled = false;

1907						break; // hide on tab out
1908				case 13: sel = $( "td." + $.datepicker._dayOverClass + ":not(." +
1909									$.datepicker._currentClass + ")", inst.dpDiv );
1910						if ( sel[ 0 ] ) {
1911							$.datepicker._selectDay( event.target, inst.selectedMonth, inst.selectedYear, sel[ 0 ] );
1912						}
1913
1914						onSelect = $.datepicker._get( inst, "onSelect" );
1915						if ( onSelect ) {
1916							dateStr = $.datepicker._formatDate( inst );
1917
1918							// Trigger custom callback
1919							onSelect.apply( ( inst.input ? inst.input[ 0 ] : null ), [ dateStr, inst ] );
1920						} else {
1921							$.datepicker._hideDatepicker();
1922						}
1923
1924						return false; // don't submit the form
1925				case 27: $.datepicker._hideDatepicker();
1926						break; // hide on escape
1927				case 33: $.datepicker._adjustDate( event.target, ( event.ctrlKey ?
1928							-$.datepicker._get( inst, "stepBigMonths" ) :
1929							-$.datepicker._get( inst, "stepMonths" ) ), "M" );
1930						break; // previous month/year on page up/+ ctrl
1931				case 34: $.datepicker._adjustDate( event.target, ( event.ctrlKey ?
1932							+$.datepicker._get( inst, "stepBigMonths" ) :
1933							+$.datepicker._get( inst, "stepMonths" ) ), "M" );
1934						break; // next month/year on page down/+ ctrl
1935				case 35: if ( event.ctrlKey || event.metaKey ) {
1936							$.datepicker._clearDate( event.target );
1937						}
1938						handled = event.ctrlKey || event.metaKey;
1939						break; // clear on ctrl or command +end
1940				case 36: if ( event.ctrlKey || event.metaKey ) {
1941							$.datepicker._gotoToday( event.target );
1942						}
1943						handled = event.ctrlKey || event.metaKey;
1944						break; // current on ctrl or command +home
1945				case 37: if ( event.ctrlKey || event.metaKey ) {
1946							$.datepicker._adjustDate( event.target, ( isRTL ? +1 : -1 ), "D" );
1947						}
1948						handled = event.ctrlKey || event.metaKey;
1949
1950						// -1 day on ctrl or command +left
1951						if ( event.originalEvent.altKey ) {
1952							$.datepicker._adjustDate( event.target, ( event.ctrlKey ?
1953								-$.datepicker._get( inst, "stepBigMonths" ) :
1954								-$.datepicker._get( inst, "stepMonths" ) ), "M" );
1955						}
1956
1957						// next month/year on alt +left on Mac
1958						break;
1959				case 38: if ( event.ctrlKey || event.metaKey ) {
1960							$.datepicker._adjustDate( event.target, -7, "D" );
1961						}
1962						handled = event.ctrlKey || event.metaKey;
1963						break; // -1 week on ctrl or command +up
1964				case 39: if ( event.ctrlKey || event.metaKey ) {
1965							$.datepicker._adjustDate( event.target, ( isRTL ? -1 : +1 ), "D" );
1966						}
1967						handled = event.ctrlKey || event.metaKey;
1968
1969						// +1 day on ctrl or command +right
1970						if ( event.originalEvent.altKey ) {
1971							$.datepicker._adjustDate( event.target, ( event.ctrlKey ?
1972								+$.datepicker._get( inst, "stepBigMonths" ) :
1973								+$.datepicker._get( inst, "stepMonths" ) ), "M" );
1974						}
1975
1976						// next month/year on alt +right
1977						break;
1978				case 40: if ( event.ctrlKey || event.metaKey ) {
1979							$.datepicker._adjustDate( event.target, +7, "D" );
1980						}
1981						handled = event.ctrlKey || event.metaKey;
1982						break; // +1 week on ctrl or command +down
1983				default: handled = false;
1984			}
1985		} else if ( event.keyCode === 36 && event.ctrlKey ) { // display the date picker on ctrl+home
1986			$.datepicker._showDatepicker( this );
1987		} else {
1988			handled = false;
1989		}
1990
1991		if ( handled ) {
1992			event.preventDefault();
1993			event.stopPropagation();
1994		}
1995	},
1996
1997	/* Filter entered characters - based on date format. */
1998	_doKeyPress: function( event ) {
1999		var chars, chr,
2000			inst = $.datepicker._getInst( event.target );
2001
2002		if ( $.datepicker._get( inst, "constrainInput" ) ) {
2003			chars = $.datepicker._possibleChars( $.datepicker._get( inst, "dateFormat" ) );
2004			chr = String.fromCharCode( event.charCode == null ? event.keyCode : event.charCode );
2005			return event.ctrlKey || event.metaKey || ( chr < " " || !chars || chars.indexOf( chr ) > -1 );
2006		}
2007	},
2008
2009	/* Synchronise manual entry and field/alternate field. */
2010	_doKeyUp: function( event ) {
2011		var date,
2012			inst = $.datepicker._getInst( event.target );
2013
2014		if ( inst.input.val() !== inst.lastVal ) {
2015			try {
2016				date = $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ),
2017					( inst.input ? inst.input.val() : null ),
2018					$.datepicker._getFormatConfig( inst ) );
2019
2020				if ( date ) { // only if valid
2021					$.datepicker._setDateFromField( inst );
2022					$.datepicker._updateAlternate( inst );
2023					$.datepicker._updateDatepicker( inst );
2024				}
2025			}
2026			catch ( err ) {
2027			}
2028		}
2029		return true;
2030	},
2031
2032	/* Pop-up the date picker for a given input field.
2033	 * If false returned from beforeShow event handler do not show.
2034	 * @param  input  element - the input field attached to the date picker or

2035	 *					event - if triggered by focus
2036	 */
2037	_showDatepicker: function( input ) {
2038		input = input.target || input;
2039		if ( input.nodeName.toLowerCase() !== "input" ) { // find from button/image trigger
2040			input = $( "input", input.parentNode )[ 0 ];
2041		}
2042
2043		if ( $.datepicker._isDisabledDatepicker( input ) || $.datepicker._lastInput === input ) { // already here
2044			return;
2045		}
2046
2047		var inst, beforeShow, beforeShowSettings, isFixed,
2048			offset, showAnim, duration;
2049
2050		inst = $.datepicker._getInst( input );
2051		if ( $.datepicker._curInst && $.datepicker._curInst !== inst ) {
2052			$.datepicker._curInst.dpDiv.stop( true, true );
2053			if ( inst && $.datepicker._datepickerShowing ) {
2054				$.datepicker._hideDatepicker( $.datepicker._curInst.input[ 0 ] );
2055			}
2056		}
2057
2058		beforeShow = $.datepicker._get( inst, "beforeShow" );
2059		beforeShowSettings = beforeShow ? beforeShow.apply( input, [ input, inst ] ) : {};
2060		if ( beforeShowSettings === false ) {
2061			return;
2062		}
2063		datepicker_extendRemove( inst.settings, beforeShowSettings );
2064
2065		inst.lastVal = null;
2066		$.datepicker._lastInput = input;
2067		$.datepicker._setDateFromField( inst );
2068
2069		if ( $.datepicker._inDialog ) { // hide cursor
2070			input.value = "";
2071		}
2072		if ( !$.datepicker._pos ) { // position below input
2073			$.datepicker._pos = $.datepicker._findPos( input );
2074			$.datepicker._pos[ 1 ] += input.offsetHeight; // add the height
2075		}
2076
2077		isFixed = false;
2078		$( input ).parents().each( function() {
2079			isFixed |= $( this ).css( "position" ) === "fixed";
2080			return !isFixed;
2081		} );
2082
2083		offset = { left: $.datepicker._pos[ 0 ], top: $.datepicker._pos[ 1 ] };
2084		$.datepicker._pos = null;
2085
2086		//to avoid flashes on Firefox
2087		inst.dpDiv.empty();
2088
2089		// determine sizing offscreen
2090		inst.dpDiv.css( { position: "absolute", display: "block", top: "-1000px" } );
2091		$.datepicker._updateDatepicker( inst );
2092
2093		// fix width for dynamic number of date pickers
2094		// and adjust position before showing
2095		offset = $.datepicker._checkOffset( inst, offset, isFixed );
2096		inst.dpDiv.css( { position: ( $.datepicker._inDialog && $.blockUI ?
2097			"static" : ( isFixed ? "fixed" : "absolute" ) ), display: "none",
2098			left: offset.left + "px", top: offset.top + "px" } );
2099
2100		if ( !inst.inline ) {
2101			showAnim = $.datepicker._get( inst, "showAnim" );
2102			duration = $.datepicker._get( inst, "duration" );
2103			inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
2104			$.datepicker._datepickerShowing = true;
2105
2106			if ( $.effects && $.effects.effect[ showAnim ] ) {
2107				inst.dpDiv.show( showAnim, $.datepicker._get( inst, "showOptions" ), duration );
2108			} else {
2109				inst.dpDiv[ showAnim || "show" ]( showAnim ? duration : null );
2110			}
2111
2112			if ( $.datepicker._shouldFocusInput( inst ) ) {
2113				inst.input.trigger( "focus" );
2114			}
2115
2116			$.datepicker._curInst = inst;
2117		}
2118	},
2119
2120	/* Generate the date picker content. */
2121	_updateDatepicker: function( inst ) {
2122		this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
2123		datepicker_instActive = inst; // for delegate hover events
2124		inst.dpDiv.empty().append( this._generateHTML( inst ) );
2125		this._attachHandlers( inst );
2126
2127		var origyearshtml,
2128			numMonths = this._getNumberOfMonths( inst ),
2129			cols = numMonths[ 1 ],
2130			width = 17,
2131			activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
2132
2133		if ( activeCell.length > 0 ) {
2134			datepicker_handleMouseover.apply( activeCell.get( 0 ) );
2135		}
2136
2137		inst.dpDiv.removeClass( "ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4" ).width( "" );
2138		if ( cols > 1 ) {
2139			inst.dpDiv.addClass( "ui-datepicker-multi-" + cols ).css( "width", ( width * cols ) + "em" );
2140		}
2141		inst.dpDiv[ ( numMonths[ 0 ] !== 1 || numMonths[ 1 ] !== 1 ? "add" : "remove" ) +
2142			"Class" ]( "ui-datepicker-multi" );
2143		inst.dpDiv[ ( this._get( inst, "isRTL" ) ? "add" : "remove" ) +
2144			"Class" ]( "ui-datepicker-rtl" );
2145
2146		if ( inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
2147			inst.input.trigger( "focus" );
2148		}
2149
2150		// Deffered render of the years select (to avoid flashes on Firefox)
2151		if ( inst.yearshtml ) {
2152			origyearshtml = inst.yearshtml;
2153			setTimeout( function() {
2154
2155				//assure that inst.yearshtml didn't change.
2156				if ( origyearshtml === inst.yearshtml && inst.yearshtml ) {
2157					inst.dpDiv.find( "select.ui-datepicker-year:first" ).replaceWith( inst.yearshtml );
2158				}
2159				origyearshtml = inst.yearshtml = null;
2160			}, 0 );
2161		}
2162	},
2163
2164	// #6694 - don't focus the input if it's already focused
2165	// this breaks the change event in IE
2166	// Support: IE and jQuery <1.9
2167	_shouldFocusInput: function( inst ) {
2168		return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
2169	},
2170
2171	/* Check positioning to remain on screen. */
2172	_checkOffset: function( inst, offset, isFixed ) {
2173		var dpWidth = inst.dpDiv.outerWidth(),
2174			dpHeight = inst.dpDiv.outerHeight(),
2175			inputWidth = inst.input ? inst.input.outerWidth() : 0,
2176			inputHeight = inst.input ? inst.input.outerHeight() : 0,
2177			viewWidth = document.documentElement.clientWidth + ( isFixed ? 0 : $( document ).scrollLeft() ),
2178			viewHeight = document.documentElement.clientHeight + ( isFixed ? 0 : $( document ).scrollTop() );
2179
2180		offset.left -= ( this._get( inst, "isRTL" ) ? ( dpWidth - inputWidth ) : 0 );
2181		offset.left -= ( isFixed && offset.left === inst.input.offset().left ) ? $( document ).scrollLeft() : 0;
2182		offset.top -= ( isFixed && offset.top === ( inst.input.offset().top + inputHeight ) ) ? $( document ).scrollTop() : 0;
2183
2184		// Now check if datepicker is showing outside window viewport - move to a better place if so.
2185		offset.left -= Math.min( offset.left, ( offset.left + dpWidth > viewWidth && viewWidth > dpWidth ) ?
2186			Math.abs( offset.left + dpWidth - viewWidth ) : 0 );
2187		offset.top -= Math.min( offset.top, ( offset.top + dpHeight > viewHeight && viewHeight > dpHeight ) ?
2188			Math.abs( dpHeight + inputHeight ) : 0 );
2189
2190		return offset;
2191	},
2192
2193	/* Find an object's position on the screen. */
2194	_findPos: function( obj ) {
2195		var position,
2196			inst = this._getInst( obj ),
2197			isRTL = this._get( inst, "isRTL" );
2198
2199		while ( obj && ( obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden( obj ) ) ) {
2200			obj = obj[ isRTL ? "previousSibling" : "nextSibling" ];
2201		}
2202
2203		position = $( obj ).offset();
2204		return [ position.left, position.top ];
2205	},
2206
2207	/* Hide the date picker from view.
2208	 * @param  input  element - the input field attached to the date picker
2209	 */
2210	_hideDatepicker: function( input ) {
2211		var showAnim, duration, postProcess, onClose,
2212			inst = this._curInst;
2213
2214		if ( !inst || ( input && inst !== $.data( input, "datepicker" ) ) ) {
2215			return;
2216		}
2217
2218		if ( this._datepickerShowing ) {
2219			showAnim = this._get( inst, "showAnim" );
2220			duration = this._get( inst, "duration" );
2221			postProcess = function() {
2222				$.datepicker._tidyDialog( inst );
2223			};
2224
2225			// DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
2226			if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
2227				inst.dpDiv.hide( showAnim, $.datepicker._get( inst, "showOptions" ), duration, postProcess );
2228			} else {
2229				inst.dpDiv[ ( showAnim === "slideDown" ? "slideUp" :
2230					( showAnim === "fadeIn" ? "fadeOut" : "hide" ) ) ]( ( showAnim ? duration : null ), postProcess );
2231			}
2232
2233			if ( !showAnim ) {
2234				postProcess();
2235			}
2236			this._datepickerShowing = false;
2237
2238			onClose = this._get( inst, "onClose" );
2239			if ( onClose ) {
2240				onClose.apply( ( inst.input ? inst.input[ 0 ] : null ), [ ( inst.input ? inst.input.val() : "" ), inst ] );
2241			}
2242
2243			this._lastInput = null;
2244			if ( this._inDialog ) {
2245				this._dialogInput.css( { position: "absolute", left: "0", top: "-100px" } );
2246				if ( $.blockUI ) {
2247					$.unblockUI();
2248					$( "body" ).append( this.dpDiv );
2249				}
2250			}
2251			this._inDialog = false;
2252		}
2253	},
2254
2255	/* Tidy up after a dialog display. */
2256	_tidyDialog: function( inst ) {
2257		inst.dpDiv.removeClass( this._dialogClass ).off( ".ui-datepicker-calendar" );
2258	},
2259
2260	/* Close date picker if clicked elsewhere. */
2261	_checkExternalClick: function( event ) {
2262		if ( !$.datepicker._curInst ) {
2263			return;
2264		}
2265
2266		var $target = $( event.target ),
2267			inst = $.datepicker._getInst( $target[ 0 ] );
2268
2269		if ( ( ( $target[ 0 ].id !== $.datepicker._mainDivId &&
2270				$target.parents( "#" + $.datepicker._mainDivId ).length === 0 &&
2271				!$target.hasClass( $.datepicker.markerClassName ) &&
2272				!$target.closest( "." + $.datepicker._triggerClass ).length &&
2273				$.datepicker._datepickerShowing && !( $.datepicker._inDialog && $.blockUI ) ) ) ||
2274			( $target.hasClass( $.datepicker.markerClassName ) && $.datepicker._curInst !== inst ) ) {
2275				$.datepicker._hideDatepicker();
2276		}
2277	},
2278
2279	/* Adjust one of the date sub-fields. */
2280	_adjustDate: function( id, offset, period ) {
2281		var target = $( id ),
2282			inst = this._getInst( target[ 0 ] );
2283
2284		if ( this._isDisabledDatepicker( target[ 0 ] ) ) {
2285			return;
2286		}
2287		this._adjustInstDate( inst, offset +
2288			( period === "M" ? this._get( inst, "showCurrentAtPos" ) : 0 ), // undo positioning
2289			period );
2290		this._updateDatepicker( inst );
2291	},
2292
2293	/* Action for current link. */
2294	_gotoToday: function( id ) {
2295		var date,
2296			target = $( id ),
2297			inst = this._getInst( target[ 0 ] );
2298
2299		if ( this._get( inst, "gotoCurrent" ) && inst.currentDay ) {
2300			inst.selectedDay = inst.currentDay;
2301			inst.drawMonth = inst.selectedMonth = inst.currentMonth;
2302			inst.drawYear = inst.selectedYear = inst.currentYear;
2303		} else {
2304			date = new Date();
2305			inst.selectedDay = date.getDate();
2306			inst.drawMonth = inst.selectedMonth = date.getMonth();
2307			inst.drawYear = inst.selectedYear = date.getFullYear();
2308		}
2309		this._notifyChange( inst );
2310		this._adjustDate( target );
2311	},
2312
2313	/* Action for selecting a new month/year. */

2314	_selectMonthYear: function( id, select, period ) {
2315		var target = $( id ),
2316			inst = this._getInst( target[ 0 ] );
2317
2318		inst[ "selected" + ( period === "M" ? "Month" : "Year" ) ] =
2319		inst[ "draw" + ( period === "M" ? "Month" : "Year" ) ] =
2320			parseInt( select.options[ select.selectedIndex ].value, 10 );
2321
2322		this._notifyChange( inst );
2323		this._adjustDate( target );
2324	},
2325
2326	/* Action for selecting a day. */
2327	_selectDay: function( id, month, year, td ) {
2328		var inst,
2329			target = $( id );
2330
2331		if ( $( td ).hasClass( this._unselectableClass ) || this._isDisabledDatepicker( target[ 0 ] ) ) {
2332			return;
2333		}
2334
2335		inst = this._getInst( target[ 0 ] );
2336		inst.selectedDay = inst.currentDay = $( "a", td ).html();
2337		inst.selectedMonth = inst.currentMonth = month;
2338		inst.selectedYear = inst.currentYear = year;
2339		this._selectDate( id, this._formatDate( inst,
2340			inst.currentDay, inst.currentMonth, inst.currentYear ) );
2341	},
2342
2343	/* Erase the input field and hide the date picker. */
2344	_clearDate: function( id ) {
2345		var target = $( id );
2346		this._selectDate( target, "" );
2347	},
2348
2349	/* Update the input field with the selected date. */
2350	_selectDate: function( id, dateStr ) {
2351		var onSelect,
2352			target = $( id ),
2353			inst = this._getInst( target[ 0 ] );
2354
2355		dateStr = ( dateStr != null ? dateStr : this._formatDate( inst ) );
2356		if ( inst.input ) {
2357			inst.input.val( dateStr );
2358		}
2359		this._updateAlternate( inst );
2360
2361		onSelect = this._get( inst, "onSelect" );
2362		if ( onSelect ) {
2363			onSelect.apply( ( inst.input ? inst.input[ 0 ] : null ), [ dateStr, inst ] );  // trigger custom callback
2364		} else if ( inst.input ) {
2365			inst.input.trigger( "change" ); // fire the change event
2366		}
2367
2368		if ( inst.inline ) {
2369			this._updateDatepicker( inst );
2370		} else {
2371			this._hideDatepicker();
2372			this._lastInput = inst.input[ 0 ];
2373			if ( typeof( inst.input[ 0 ] ) !== "object" ) {
2374				inst.input.trigger( "focus" ); // restore focus
2375			}
2376			this._lastInput = null;
2377		}
2378	},
2379
2380	/* Update any alternate field to synchronise with the main field. */
2381	_updateAlternate: function( inst ) {
2382		var altFormat, date, dateStr,
2383			altField = this._get( inst, "altField" );
2384
2385		if ( altField ) { // update alternate field too
2386			altFormat = this._get( inst, "altFormat" ) || this._get( inst, "dateFormat" );
2387			date = this._getDate( inst );
2388			dateStr = this.formatDate( altFormat, date, this._getFormatConfig( inst ) );
2389			$

2389( altField ).val( dateStr );
2390		}
2391	},
2392
2393	/* Set as beforeShowDay function to prevent selection of weekends.
2394	 * @param  date  Date - the date to customise
2395	 * @return [boolean, string] - is this date selectable?, what is its CSS class?
2396	 */
2397	noWeekends: function( date ) {
2398		var day = date.getDay();
2399		return [ ( day > 0 && day < 6 ), "" ];
2400	},
2401
2402	/* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
2403	 * @param  date  Date - the date to get the week for
2404	 * @return  number - the number of the week within the year that contains this date
2405	 */
2406	iso8601Week: function( date ) {
2407		var time,
2408			checkDate = new Date( date.getTime() );
2409
2410		// Find Thursday of this week starting on Monday
2411		checkDate.setDate( checkDate.getDate() + 4 - ( checkDate.getDay() || 7 ) );
2412
2413		time = checkDate.getTime();
2414		checkDate.setMonth( 0 ); // Compare with Jan 1
2415		checkDate.setDate( 1 );
2416		return Math.floor( Math.round( ( time - checkDate ) / 86400000 ) / 7 ) + 1;
2417	},
2418
2419	/* Parse a string value into a date object.
2420	 * See formatDate below for the possible formats.
2421	 *
2422	 * @param  format string - the expected format of the date
2423	 * @param  value string - the date in the above format
2424	 * @param  settings Object - attributes include:
2425	 *					shortYearCutoff  number - the cutoff year for determining the century (optional)
2426	 *					dayNamesShort	string[7] - abbreviated names of the days from Sunday (optional)
2427	 *					dayNames		string[7] - names of the days from Sunday (optional)
2428	 *					monthNamesShort string[12] - abbreviated names of the months (optional)
2429	 *					monthNames		string[12] - names of the months (optional)
2430	 * @return  Date - the extracted date value or null if value is blank
2431	 */
2432	parseDate: function( format, value, settings ) {
2433		if ( format == null || value == null ) {
2434			throw "Invalid arguments";
2435		}
2436
2437		value = ( typeof value === "object" ? value.toString() : value + "" );
2438		if ( value === "" ) {
2439			return null;
2440		}
2441
2442		var iFormat, dim, extra,
2443			iValue = 0,
2444			shortYearCutoffTemp = ( settings ? settings.shortYearCutoff : null ) || this._defaults.shortYearCutoff,
2445			shortYearCutoff = ( typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
2446				new Date().getFullYear() % 100 + parseInt( shortYearCutoffTemp, 10 ) ),
2447			dayNamesShort = ( settings ? settings.dayNamesShort : null ) || this._defaults.dayNamesShort,
2448			dayNames = ( settings ? settings.dayNames : null ) || this._defaults.dayNames,
2449			monthNamesShort = ( settings ? settings.monthNamesShort : null ) || this._defaults.monthNamesShort,
2450			monthNames = ( settings ? settings.monthNames : null ) || this._defaults.monthNames,
2451			year = -1,
2452			month = -1,
2453			day = -1,
2454			doy = -1,
2455			literal = false,
2456			date,
2457
2458			// Check whether a format character is doubled
2459			lookAhead = function( match ) {
2460				var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match );
2461				if ( matches ) {
2462					iFormat++;
2463				}
2464				return matches;
2465			},
2466
2467			// Extract a number from the string value
2468			getNumber = function( match ) {
2469				var isDoubled = lookAhead( match ),
2470					size = ( match === "@" ? 14 : ( match === "!" ? 20 :
2471					( match === "y" && isDoubled ? 4 : ( match === "o" ? 3 : 2 ) ) ) ),
2472					minSize = ( match === "y" ? size : 1 ),
2473					digits = new RegExp( "^\\d{" + minSize + "," + size + "}" ),
2474					num = value.substring( iValue ).match( digits );
2475				if ( !num ) {
2476					throw "Missing number at position " + iValue;
2477				}
2478				iValue += num[ 0 ].length;
2479				return parseInt( num[ 0 ], 10 );
2480			},
2481
2482			// Extract a name from the string value and convert to an index
2483			getName = function( match, shortNames, longNames ) {
2484				var index = -1,
2485					names = $.map( lookAhead( match ) ? longNames : shortNames, function( v, k ) {
2486						return [ [ k, v ] ];
2487					} ).sort( function( a, b ) {
2488						return -( a[ 1 ].length - b[ 1 ].length );
2489					} );
2490
2491				$.each( names, function( i, pair ) {
2492					var name = pair[ 1 ];
2493					if ( value.substr( iValue, name.length ).toLowerCase() === name.toLowerCase() ) {
2494						index = pair[ 0 ];
2495						iValue += name.length;
2496						return false;
2497					}
2498				} );
2499				if ( index !== -1 ) {
2500					return index + 1;
2501				} else {
2502					throw "Unknown name at position " + iValue;
2503				}
2504			},
2505
2506			// Confirm that a literal character matches the string value
2507			checkLiteral = function() {
2508				if ( value.charAt( iValue ) !== format.charAt( iFormat ) ) {
2509					throw "Unexpected literal at position " + iValue;
2510				}
2511				iValue++;
2512			};
2513
2514		for ( iFormat = 0; iFormat < format.length; iFormat++ ) {
2515			if ( literal ) {
2516				if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) {
2517					literal = false;
2518				} else {
2519					checkLiteral();
2520				}
2521			} else {
2522				switch ( format.charAt( iFormat ) ) {
2523					case "d":
2524						day = getNumber( "d" );
2525						break;
2526					case "D":
2527						getName( "D", dayNamesShort, dayNames );
2528						break;
2529					case "o":
2530						doy = getNumber( "o" );
2531						break;
2532					case "m":
2533						month = getNumber( "m" );
2534						break;
2535					case "M":
2536						month = getName( "M", monthNamesShort, monthNames );
2537						break;
2538					case "y":
2539						year = getNumber( "y" );
2540						break;
2541					case "@":
2542						date = new Date( getNumber( "@" ) );
2543						year = date.getFullYear();
2544						month = date.getMonth() + 1;
2545						day = date.getDate();
2546						break;
2547					case "!":
2548						date = new Date( ( getNumber( "!" ) - this._ticksTo1970 ) / 10000 );
2549						year = date.getFullYear();
2550						month = date.getMonth() + 1;
2551						day = date.getDate();
2552						break;
2553					case "'":
2554						if ( lookAhead( "'" ) ) {
2555							checkLiteral();
2556						} else {
2557							literal = true;
2558						}
2559						break;
2560					default:
2561						checkLiteral();
2562				}
2563			}
2564		}
2565
2566		if ( iValue < value.length ) {
2567			extra = value.substr( iValue );
2568			if ( !/^\s+/.test( extra ) ) {
2569				throw "Extra/unparsed characters found in date: " + extra;
2570			}
2571		}
2572
2573		if ( year === -1 ) {
2574			year = new Date().getFullYear();
2575		} else if ( year < 100 ) {
2576			year += new Date().getFullYear() - new Date().getFullYear() % 100 +
2577				( year <= shortYearCutoff ? 0 : -100 );
2578		}
2579
2580		if ( doy > -1 ) {
2581			month = 1;
2582			day = doy;
2583			do {
2584				dim = this._getDaysInMonth( year, month - 1 );
2585				if ( day <= dim ) {
2586					break;
2587				}
2588				month++;
2589				day -= dim;
2590			} while ( true );
2591		}
2592
2593		date = this._daylightSavingAdjust( new Date( year, month - 1, day ) );
2594		if ( date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day ) {
2595			throw "Invalid date"; // E.g. 31/02/00
2596		}
2597		return date;
2598	},
2599
2600	/* Standard date formats. */
2601	ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
2602	COOKIE: "D, dd M yy",
2603	ISO_8601: "yy-mm-dd",
2604	RFC_822: "D, d M y",
2605	RFC_850: "DD, dd-M-y",
2606	RFC_1036: "D, d M y",
2607	RFC_1123: "D, d M yy",
2608	RFC_2822: "D, d M yy",
2609	RSS: "D, d M y", // RFC 822
2610	TICKS: "!",
2611	TIMESTAMP: "@",
2612	W3C: "yy-mm-dd", // ISO 8601
2613
2614	_ticksTo1970: ( ( ( 1970 - 1 ) * 365 + Math.floor( 1970 / 4 ) - Math.floor( 1970 / 100 ) +
2615		Math.floor( 1970 / 400 ) ) * 24 * 60 * 60 * 10000000 ),
2616
2617	/* Format a date object into a string value.
2618	 * The format can be combinations of the following:
2619	 * d  - day of month (no leading zero)
2620	 * dd - day of month (two digit)
2621	 * o  - day of year (no leading zeros)
2622	 * oo - day of year (three digit)
2623	 * D  - day name short
2624	 * DD - day name long
2625	 * m  - month of year (no leading zero)
2626	 * mm - month of year (two digit)
2627	 * M  - month name short
2628	 * MM - month name long
2629	 * y  - year (two digit)
2630	 * yy - year (four digit)
2631	 * @ - Unix timestamp (ms since 01/01/1970)
2632	 * ! - Windows ticks (100ns since 01/01/0001)
2633	 * "..." - literal text
2634	 * '' - single quote
2635	 *
2636	 * @param  format string - the desired format of the date
2637	 * @param  date Date - the date value to format
2638	 * @param  settings Object - attributes include:
2639	 *					dayNamesShort	string[7] - abbreviated names of the days from Sunday (optional)
2640	 *					dayNames		string[7] - names of the days from Sunday (optional)
2641	 *					monthNamesShort string[12] - abbreviated names of the months (optional)
2642	 *					monthNames		string[12] - names of the months (optional)
2643	 * @return  string - the date in the above format
2644	 */
2645	formatDate: function( format, date, settings ) {
2646		if ( !date ) {
2647			return "";
2648		}
2649
2650		var iFormat,
2651			dayNamesShort = ( settings ? settings.dayNamesShort : null ) || this._defaults.dayNamesShort,
2652			dayNames = ( settings ? settings.dayNames : null ) || this._defaults.dayNames,
2653			monthNamesShort = ( settings ? settings.monthNamesShort : null ) || this._defaults.monthNamesShort,
2654			monthNames = ( settings ? settings.monthNames : null ) || this._defaults.monthNames,
2655
2656			// Check whether a format character is doubled
2657			lookAhead = function( match ) {
2658				var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match );
2659				if ( matches ) {
2660					iFormat++;
2661				}
2662				return matches;
2663			},
2664
2665			// Format a number, with leading zero if necessary
2666			formatNumber = function( match, value, len ) {
2667				var num = "" + value;
2668				if ( lookAhead( match ) ) {
2669					while ( num.length < len ) {
2670						num = "0" + num;
2671					}
2672				}
2673				return num;
2674			},
2675
2676			// Format a name, short or long as requested
2677			formatName = function( match, value, shortNames, longNames ) {
2678				return ( lookAhead( match ) ? longNames[ value ] : shortNames[ value ] );
2679			},
2680			output = "",
2681			literal = false;
2682
2683		if ( date ) {
2684			for ( iFormat = 0; iFormat < format.length; iFormat++ ) {
2685				if ( literal ) {
2686					if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) {
2687						literal = false;
2688					} else {
2689						output += format.charAt( iFormat );
2690					}
2691				} else {
2692					switch ( format.charAt( iFormat ) ) {
2693						case "d":
2694							output += formatNumber( "d", date.getDate(), 2 );
2695							break;
2696						case "D":
2697							output += formatName( "D", date.getDay(), dayNamesShort, dayNames );
2698							break;
2699						case "o":
2700							output += formatNumber( "o",
2701								Math.round( ( new Date( date.getFullYear(), date.getMonth(), date.getDate() ).getTime() - new Date( date.getFullYear(), 0, 0 ).getTime() ) / 86400000 ), 3 );
2702							break;
2703						case "m":
2704							output += formatNumber( "m", date.getMonth() + 1, 2 );
2705							break;
2706						case "M":
2707							output += formatName( "M", date.getMonth(), monthNamesShort, monthNames );
2708							break;
2709						case "y":
2710							output += ( lookAhead( "y" ) ? date.getFullYear() :
2711								( date.getFullYear() % 100 < 10 ? "0" : "" ) + date.getFullYear() % 100 );
2712							break;
2713						case "@":
2714							output += date.getTime();
2715							break;
2716						case "!":
2717							output += date.getTime() * 10000 + this._ticksTo1970;
2718							break;
2719						case "'":
2720							if ( lookAhead( "'" ) ) {
2721								output += "'";
2722							} else {
2723								literal = true;
2724							}
2725							break;
2726						default:
2727							output += format.charAt( iFormat );
2728					}
2729				}
2730			}
2731		}
2732		return output;
2733	},
2734
2735	/* Extract all possible characters from the date format. */
2736	_possibleChars: function( format ) {
2737		var iFormat,
2738			chars = "",
2739			literal = false,
2740
2741			// Check whether a format character is doubled
2742			lookAhead = function( match ) {
2743				var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match );
2744				if ( matches ) {
2745					iFormat++;
2746				}
2747				return matches;
2748			};
2749
2750		for ( iFormat = 0; iFormat < format.length; iFormat++ ) {
2751			if ( literal ) {
2752				if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) {
2753					literal = false;
2754				} else {
2755					chars += format.charAt( iFormat );
2756				}
2757			} else {
2758				switch ( format.charAt( iFormat ) ) {
2759					case "d": case "m": case "y": case "@":
2760						chars += "0123456789";
2761						break;
2762					case "D": case "M":
2763						return null; // Accept anything
2764					case "'":
2765						if ( lookAhead( "'" ) ) {
2766							chars += "'";
2767						} else {
2768							literal = true;
2769						}
2770						break;
2771					default:
2772						chars += format.charAt( iFormat );
2773				}
2774			}
2775		}
2776		return chars;
2777	},
2778
2779	/* Get a setting value, defaulting if necessary. */
2780	_get: function( inst, name ) {
2781		return inst.settings[ name ] !== undefined ?
2782			inst.settings[ name ] : this._defaults[ name ];
2783	},
2784
2785	/* Parse existing date and initialise date picker. */
2786	_setDateFromField: function( inst, noDefault ) {
2787		if ( inst.input.val() === inst.lastVal ) {
2788			return;
2789		}
2790
2791		var dateFormat = this._get( inst, "dateFormat" ),
2792			dates = inst.lastVal = inst.input ? inst.input.val() : null,
2793			defaultDate = this._getDefaultDate( inst ),
2794			date = defaultDate,
2795			settings = this._getFormatConfig( inst );
2796
2797		try {
2798			date = this.parseDate( dateFormat, dates, settings ) || defaultDate;
2799		} catch ( event ) {
2800			dates = ( noDefault ? "" : dates );
2801		}
2802		inst.selectedDay = date.getDate();
2803		inst.drawMonth = inst.selectedMonth = date.getMonth();
2804		inst.drawYear = inst.selectedYear = date.getFullYear();
2805		inst.currentDay = ( dates ? date.getDate() : 0 );
2806		inst.currentMonth = ( dates ? date.getMonth() : 0 );
2807		inst.currentYear = ( dates ? date.getFullYear() : 0 );
2808		this._adjustInstDate( inst );
2809	},
2810
2811	/* Retrieve the default date shown on opening. */
2812	_getDefaultDate: function( inst ) {
2813		return this._restrictMinMax( inst,
2814			this._determineDate( inst, this._get( inst, "defaultDate" ), new Date() ) );
2815	},
2816
2817	/* A date may be specified as an exact value or a relative one. */
2818	_determineDate: function( inst, date, defaultDate ) {
2819		var offsetNumeric = function( offset ) {
2820				var date = new Date();
2821				date.setDate( date.getDate() + offset );
2822				return date;
2823			},
2824			offsetString = function( offset ) {
2825				try {
2826					return $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ),
2827						offset, $.datepicker._getFormatConfig( inst ) );
2828				}