ModbusAdapters: Fixed security issues in Modbus configuration screen GSF.Web: Cleaned up new embedded resources

J. Ritchie Carroll committed 9 years ago

Commit 970956d1 parent 230686d36 files · +72369 −1648Browse files

Showing the changes to Source/Libraries/GSF.Web/Shared/Scripts (4 of 36 files). Show all

Unified · Split

4 files

Source/Libraries/GSF.Web/Shared/Scripts/angular.js +31768 −0
Source/Libraries/GSF.Web/Shared/Scripts/gsf.web.client.js +5 −5
Source/Libraries/GSF.Web/Shared/Scripts/jquery-ui.js +16617 −0
Source/Libraries/GSF.Web/Shared/Scripts/primeui.js +13963 −0

Source/Libraries/GSF.Web/Shared/Scripts/angular.js+31768−0

@@ -0,0 +1,31768 @@
	1	/**
	2	* @license AngularJS v1.5.8
	3	* (c) 2010-2016 Google, Inc. http://angularjs.org
	4	* License: MIT
	5	*/
	6	(function(window) {'use strict';
	7
	8	/**
	9	* @description
	10	*
	11	* This object provides a utility for producing rich Error messages within
	12	* Angular. It can be called as follows:
	13	*
	14	* var exampleMinErr = minErr('example');
	15	* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
	16	*
	17	* The above creates an instance of minErr in the example namespace. The
	18	* resulting error will have a namespaced error code of example.one. The
	19	* resulting error will replace {0} with the value of foo, and {1} with the
	20	* value of bar. The object is not restricted in the number of arguments it can
	21	* take.
	22	*
	23	* If fewer arguments are specified than necessary for interpolation, the extra
	24	* interpolation markers will be preserved in the final string.
	25	*
	26	* Since data will be parsed statically during a build step, some restrictions
	27	* are applied with respect to how minErr instances are created and called.
	28	* Instances should have names of the form namespaceMinErr for a minErr created
	29	* using minErr('namespace') . Error codes, namespaces and template strings
	30	* should all be static strings, not variables or general expressions.
	31	*
	32	* @param {string} module The namespace to use for the new minErr instance.
	33	* @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
	34	* error from returned function, for cases when a particular type of error is useful.
	35	* @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
	36	*/
	37
	38	function minErr(module, ErrorConstructor) {
	39	ErrorConstructor = ErrorConstructor \|\| Error;
	40	return function() {
	41	var SKIP_INDEXES = 2;
	42
	43	var templateArgs = arguments,
	44	code = templateArgs[0],
	45	message = '[' + (module ? module + ':' : '') + code + '] ',
	46	template = templateArgs[1],
	47	paramPrefix, i;
	48
	49	message += template.replace(/\{\d+\}/g, function(match) {
	50	var index = +match.slice(1, -1),
	51	shiftedIndex = index + SKIP_INDEXES;
	52
	53	if (shiftedIndex < templateArgs.length) {
	54	return toDebugString(templateArgs[shiftedIndex]);
	55	}
	56
	57	return match;
	58	});
	59
	60	message += '\nhttp://errors.angularjs.org/1.5.8/' +
	61	(module ? module + '/' : '') + code;
	62
	63	for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
	64	message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +
	65	encodeURIComponent(toDebugString(templateArgs[i]));
	66	}
	67
	68	return new ErrorConstructor(message);
	69	};
	70	}
	71
	72	/* We need to tell jshint what variables are being exported */
	73	/* global angular: true,
	74	msie: true,
	75	jqLite: true,
	76	jQuery: true,
	77	slice: true,
	78	splice: true,
	79	push: true,
	80	toString: true,
	81	ngMinErr: true,
	82	angularModule: true,
	83	uid: true,
	84	REGEX_STRING_REGEXP: true,
	85	VALIDITY_STATE_PROPERTY: true,
	86
	87	lowercase: true,
	88	uppercase: true,
	89	manualLowercase: true,
	90	manualUppercase: true,
	91	nodeName_: true,
	92	isArrayLike: true,
	93	forEach: true,
	94	forEachSorted: true,
	95	reverseParams: true,
	96	nextUid: true,
	97	setHashKey: true,
	98	extend: true,
	99	toInt: true,
	100	inherit: true,
	101	merge: true,
	102	noop: true,
	103	identity: true,
	104	valueFn: true,
	105	isUndefined: true,
	106	isDefined: true,
	107	isObject: true,
	108	isBlankObject: true,
	109	isString: true,
	110	isNumber: true,
	111	isDate: true,
	112	isArray: true,
	113	isFunction: true,
	114	isRegExp: true,
	115	isWindow: true,
	116	isScope: true,
	117	isFile: true,
	118	isFormData: true,
	119	isBlob: true,
	120	isBoolean: true,
	121	isPromiseLike: true,
	122	trim: true,
	123	escapeForRegexp: true,
	124	isElement: true,
	125	makeMap: true,
	126	includes: true,
	127	arrayRemove: true,
	128	copy: true,
	129	equals: true,
	130	csp: true,
	131	jq: true,
	132	concat: true,
	133	sliceArgs: true,
	134	bind: true,
	135	toJsonReplacer: true,
	136	toJson: true,
	137	fromJson: true,
	138	convertTimezoneToLocal: true,
	139	timezoneToOffset: true,
	140	startingTag: true,
	141	tryDecodeURIComponent: true,
	142	parseKeyValue: true,
	143	toKeyValue: true,
	144	encodeUriSegment: true,
	145	encodeUriQuery: true,
	146	angularInit: true,
	147	bootstrap: true,
	148	getTestability: true,
	149	snake_case: true,
	150	bindJQuery: true,
	151	assertArg: true,
	152	assertArgFn: true,
	153	assertNotHasOwnProperty: true,
	154	getter: true,
	155	getBlockNodes: true,
	156	hasOwnProperty: true,
	157	createMap: true,
	158
	159	NODE_TYPE_ELEMENT: true,
	160	NODE_TYPE_ATTRIBUTE: true,
	161	NODE_TYPE_TEXT: true,
	162	NODE_TYPE_COMMENT: true,
	163	NODE_TYPE_DOCUMENT: true,
	164	NODE_TYPE_DOCUMENT_FRAGMENT: true,
	165	*/
	166
	167	////////////////////////////////////
	168
	169	/**
	170	* @ngdoc module
	171	* @name ng
	172	* @module ng
	173	* @installation
	174	* @description
	175	*
	176	* # ng (core module)
	177	* The ng module is loaded by default when an AngularJS application is started. The module itself
	178	* contains the essential components for an AngularJS application to function. The table below
	179	* lists a high level breakdown of each of the services/factories, filters, directives and testing
	180	* components available within this core module.
	181	*
	182	* <div doc-module-components="ng"></div>
	183	*/
	184
	185	var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
	186
	187	// The name of a form control's ValidityState property.
	188	// This is used so that it's possible for internal tests to create mock ValidityStates.
	189	var VALIDITY_STATE_PROPERTY = 'validity';
	190
	191	var hasOwnProperty = Object.prototype.hasOwnProperty;
	192
	193	var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
	194	var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
	195
	196
	197	var manualLowercase = function(s) {
	198	/* jshint bitwise: false */
	199	return isString(s)
	200	? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) \| 32);})
	201	: s;
	202	};
	203	var manualUppercase = function(s) {
	204	/* jshint bitwise: false */
	205	return isString(s)
	206	? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
	207	: s;
	208	};
	209
	210
	211	// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
	212	// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
	213	// with correct but slower alternatives. See https://github.com/angular/angular.js/issues/11387
	214	if ('i' !== 'I'.toLowerCase()) {
	215	lowercase = manualLowercase;
	216	uppercase = manualUppercase;
	217	}
	218
	219
	220	var
	221	msie, // holds major version number for IE, or NaN if UA is not IE.
	222	jqLite, // delay binding since jQuery could be loaded after us.
	223	jQuery, // delay binding
	224	slice = [].slice,
	225	splice = [].splice,
	226	push = [].push,
	227	toString = Object.prototype.toString,
	228	getPrototypeOf = Object.getPrototypeOf,
	229	ngMinErr = minErr('ng'),
	230
	231	/** @name angular */
	232	angular = window.angular \|\| (window.angular = {}),
	233	angularModule,
	234	uid = 0;
	235
	236	/**
	237	* documentMode is an IE-only property
	238	* http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
	239	*/
	240	msie = window.document.documentMode;
	241
	242
	243	/**
	244	* @private
	245	* @param {*} obj
	246	* @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
	247	* String ...)
	248	*/
	249	function isArrayLike(obj) {
	250
	251	// `null`, `undefined` and `window` are not array-like
	252	if (obj == null \|\| isWindow(obj)) return false;
	253
	254	// arrays, strings and jQuery/jqLite objects are array like
	255	// * jqLite is either the jQuery or jqLite constructor function
	256	// * we have to check the existence of jqLite first as this method is called
	257	// via the forEach method when constructing the jqLite object in the first place
	258	if (isArray(obj) \|\| isString(obj) \|\| (jqLite && obj instanceof jqLite)) return true;
	259
	260	// Support: iOS 8.2 (not reproducible in simulator)
	261	// "length" in obj used to prevent JIT error (gh-11508)
	262	var length = "length" in Object(obj) && obj.length;
	263
	264	// NodeList objects (with `item` method) and
	265	// other objects with suitable length characteristics are array-like
	266	return isNumber(length) &&
	267	(length >= 0 && ((length - 1) in obj \|\| obj instanceof Array) \|\| typeof obj.item == 'function');
	268
	269	}
	270
	271	/**
	272	* @ngdoc function
	273	* @name angular.forEach
	274	* @module ng
	275	* @kind function
	276	*
	277	* @description
	278	* Invokes the `iterator` function once for each item in `obj` collection, which can be either an
	279	* object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
	280	* is the value of an object property or an array element, `key` is the object property key or
	281	* array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
	282	*
	283	* It is worth noting that `.forEach` does not iterate over inherited properties because it filters
	284	* using the `hasOwnProperty` method.
	285	*
	286	* Unlike ES262's
	287	* [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
	288	* providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
	289	* return the value provided.
	290	*
	291	```js
	292	var values = {name: 'misko', gender: 'male'};
	293	var log = [];
	294	angular.forEach(values, function(value, key) {
	295	this.push(key + ': ' + value);
	296	}, log);
	297	expect(log).toEqual(['name: misko', 'gender: male']);
	298	```
	299	*
	300	* @param {Object\|Array} obj Object to iterate over.
	301	* @param {Function} iterator Iterator function.
	302	* @param {Object=} context Object to become context (`this`) for the iterator function.
	303	* @returns {Object\|Array} Reference to `obj`.
	304	*/
	305
	306	function forEach(obj, iterator, context) {
	307	var key, length;
	308	if (obj) {
	309	if (isFunction(obj)) {
	310	for (key in obj) {
	311	// Need to check if hasOwnProperty exists,
	312	// as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function
	313	if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty \|\| obj.hasOwnProperty(key))) {
	314	iterator.call(context, obj[key], key, obj);
	315	}
	316	}
	317	} else if (isArray(obj) \|\| isArrayLike(obj)) {
	318	var isPrimitive = typeof obj !== 'object';
	319	for (key = 0, length = obj.length; key < length; key++) {
	320	if (isPrimitive \|\| key in obj) {
	321	iterator.call(context, obj[key], key, obj);
	322	}
	323	}
	324	} else if (obj.forEach && obj.forEach !== forEach) {
	325	obj.forEach(iterator, context, obj);
	326	} else if (isBlankObject(obj)) {
	327	// createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
	328	for (key in obj) {
	329	iterator.call(context, obj[key], key, obj);
	330	}
	331	} else if (typeof obj.hasOwnProperty === 'function') {
	332	// Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
	333	for (key in obj) {
	334	if (obj.hasOwnProperty(key)) {
	335	iterator.call(context, obj[key], key, obj);
	336	}
	337	}
	338	} else {
	339	// Slow path for objects which do not have a method `hasOwnProperty`
	340	for (key in obj) {
	341	if (hasOwnProperty.call(obj, key)) {
	342	iterator.call(context, obj[key], key, obj);
	343	}
	344	}
	345	}
	346	}
	347	return obj;
	348	}
	349
	350	function forEachSorted(obj, iterator, context) {
	351	var keys = Object.keys(obj).sort();
	352	for (var i = 0; i < keys.length; i++) {
	353	iterator.call(context, obj[keys[i]], keys[i]);
	354	}
	355	return keys;
	356	}
	357
	358
	359	/**
	360	* when using forEach the params are value, key, but it is often useful to have key, value.
	361	* @param {function(string, *)} iteratorFn
	362	* @returns {function(*, string)}
	363	*/
	364	function reverseParams(iteratorFn) {
	365	return function(value, key) {iteratorFn(key, value);};
	366	}
	367
	368	/**
	369	* A consistent way of creating unique IDs in angular.
	370	*
	371	* Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before
	372	* we hit number precision issues in JavaScript.
	373	*
	374	* Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M
	375	*
	376	* @returns {number} an unique alpha-numeric string
	377	*/
	378	function nextUid() {
	379	return ++uid;
	380	}
	381
	382
	383	/**
	384	* Set or clear the hashkey for an object.
	385	* @param obj object
	386	* @param h the hashkey (!truthy to delete the hashkey)
	387	*/
	388	function setHashKey(obj, h) {
	389	if (h) {
	390	obj.$$hashKey = h;
	391	} else {
	392	delete obj.$$hashKey;
	393	}
	394	}
	395
	396
	397	function baseExtend(dst, objs, deep) {
	398	var h = dst.$$hashKey;
	399
	400	for (var i = 0, ii = objs.length; i < ii; ++i) {
	401	var obj = objs[i];
	402	if (!isObject(obj) && !isFunction(obj)) continue;
	403	var keys = Object.keys(obj);
	404	for (var j = 0, jj = keys.length; j < jj; j++) {
	405	var key = keys[j];
	406	var src = obj[key];
	407
	408	if (deep && isObject(src)) {
	409	if (isDate(src)) {
	410	dst[key] = new Date(src.valueOf());
	411	} else if (isRegExp(src)) {
	412	dst[key] = new RegExp(src);
	413	} else if (src.nodeName) {
	414	dst[key] = src.cloneNode(true);
	415	} else if (isElement(src)) {
	416	dst[key] = src.clone();
	417	} else {
	418	if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
	419	baseExtend(dst[key], [src], true);
	420	}
	421	} else {
	422	dst[key] = src;
	423	}
	424	}
	425	}
	426
	427	setHashKey(dst, h);
	428	return dst;
	429	}
	430
	431	/**
	432	* @ngdoc function
	433	* @name angular.extend
	434	* @module ng
	435	* @kind function
	436	*
	437	* @description
	438	* Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
	439	* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
	440	* by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
	441	*
	442	* Note: Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
	443	* {@link angular.merge} for this.
	444	*
	445	* @param {Object} dst Destination object.
	446	* @param {...Object} src Source object(s).
	447	* @returns {Object} Reference to `dst`.
	448	*/
	449	function extend(dst) {
	450	return baseExtend(dst, slice.call(arguments, 1), false);
	451	}
	452
	453
	454	/**
	455	* @ngdoc function
	456	* @name angular.merge
	457	* @module ng
	458	* @kind function
	459	*
	460	* @description
	461	* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
	462	* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
	463	* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.
	464	*
	465	* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
	466	* objects, performing a deep copy.
	467	*
	468	* @param {Object} dst Destination object.
	469	* @param {...Object} src Source object(s).
	470	* @returns {Object} Reference to `dst`.
	471	*/
	472	function merge(dst) {
	473	return baseExtend(dst, slice.call(arguments, 1), true);
	474	}
	475
	476
	477
	478	function toInt(str) {
	479	return parseInt(str, 10);
	480	}
	481
	482
	483	function inherit(parent, extra) {
	484	return extend(Object.create(parent), extra);
	485	}
	486
	487	/**
	488	* @ngdoc function
	489	* @name angular.noop
	490	* @module ng
	491	* @kind function
	492	*
	493	* @description
	494	* A function that performs no operations. This function can be useful when writing code in the
	495	* functional style.
	496	```js
	497	function foo(callback) {
	498	var result = calculateResult();
	499	(callback \|\| angular.noop)(result);
	500	}
	501	```
	502	*/
	503	function noop() {}
	504	noop.$inject = [];
	505
	506
	507	/**
	508	* @ngdoc function
	509	* @name angular.identity
	510	* @module ng
	511	* @kind function
	512	*
	513	* @description
	514	* A function that returns its first argument. This function is useful when writing code in the
	515	* functional style.
	516	*
	517	```js
	518	function transformer(transformationFn, value) {
	519	return (transformationFn \|\| angular.identity)(value);
	520	};
	521
	522	// E.g.
	523	function getResult(fn, input) {
	524	return (fn \|\| angular.identity)(input);
	525	};
	526
	527	getResult(function(n) { return n * 2; }, 21); // returns 42
	528	getResult(null, 21); // returns 21
	529	getResult(undefined, 21); // returns 21
	530	```
	531	*
	532	* @param {*} value to be returned.
	533	* @returns {*} the value passed in.
	534	*/
	535	function identity($) {return $;}
	536	identity.$inject = [];
	537
	538
	539	function valueFn(value) {return function valueRef() {return value;};}
	540
	541	function hasCustomToString(obj) {
	542	return isFunction(obj.toString) && obj.toString !== toString;
	543	}
	544
	545
	546	/**
	547	* @ngdoc function
	548	* @name angular.isUndefined
	549	* @module ng
	550	* @kind function
	551	*
	552	* @description
	553	* Determines if a reference is undefined.
	554	*
	555	* @param {*} value Reference to check.
	556	* @returns {boolean} True if `value` is undefined.
	557	*/
	558	function isUndefined(value) {return typeof value === 'undefined';}
	559
	560
	561	/**
	562	* @ngdoc function
	563	* @name angular.isDefined
	564	* @module ng
	565	* @kind function
	566	*
	567	* @description
	568	* Determines if a reference is defined.
	569	*
	570	* @param {*} value Reference to check.
	571	* @returns {boolean} True if `value` is defined.
	572	*/
	573	function isDefined(value) {return typeof value !== 'undefined';}
	574
	575
	576	/**
	577	* @ngdoc function
	578	* @name angular.isObject
	579	* @module ng
	580	* @kind function
	581	*
	582	* @description
	583	* Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
	584	* considered to be objects. Note that JavaScript arrays are objects.
	585	*
	586	* @param {*} value Reference to check.
	587	* @returns {boolean} True if `value` is an `Object` but not `null`.
	588	*/
	589	function isObject(value) {
	590	// http://jsperf.com/isobject4
	591	return value !== null && typeof value === 'object';
	592	}
	593
	594
	595	/**
	596	* Determine if a value is an object with a null prototype
	597	*
	598	* @returns {boolean} True if `value` is an `Object` with a null prototype
	599	*/
	600	function isBlankObject(value) {
	601	return value !== null && typeof value === 'object' && !getPrototypeOf(value);
	602	}
	603
	604
	605	/**
	606	* @ngdoc function
	607	* @name angular.isString
	608	* @module ng
	609	* @kind function
	610	*
	611	* @description
	612	* Determines if a reference is a `String`.
	613	*
	614	* @param {*} value Reference to check.
	615	* @returns {boolean} True if `value` is a `String`.
	616	*/
	617	function isString(value) {return typeof value === 'string';}
	618
	619
	620	/**
	621	* @ngdoc function
	622	* @name angular.isNumber
	623	* @module ng
	624	* @kind function
	625	*
	626	* @description
	627	* Determines if a reference is a `Number`.
	628	*
	629	* This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`.
	630	*
	631	* If you wish to exclude these then you can use the native
	632	* [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
	633	* method.
	634	*
	635	* @param {*} value Reference to check.
	636	* @returns {boolean} True if `value` is a `Number`.
	637	*/
	638	function isNumber(value) {return typeof value === 'number';}
	639
	640
	641	/**
	642	* @ngdoc function
	643	* @name angular.isDate
	644	* @module ng
	645	* @kind function
	646	*
	647	* @description
	648	* Determines if a value is a date.
	649	*
	650	* @param {*} value Reference to check.
	651	* @returns {boolean} True if `value` is a `Date`.
	652	*/
	653	function isDate(value) {
	654	return toString.call(value) === '[object Date]';
	655	}
	656
	657
	658	/**
	659	* @ngdoc function
	660	* @name angular.isArray
	661	* @module ng
	662	* @kind function
	663	*
	664	* @description
	665	* Determines if a reference is an `Array`.
	666	*
	667	* @param {*} value Reference to check.
	668	* @returns {boolean} True if `value` is an `Array`.
	669	*/
	670	var isArray = Array.isArray;
	671
	672	/**
	673	* @ngdoc function
	674	* @name angular.isFunction
	675	* @module ng
	676	* @kind function
	677	*
	678	* @description
	679	* Determines if a reference is a `Function`.
	680	*
	681	* @param {*} value Reference to check.
	682	* @returns {boolean} True if `value` is a `Function`.
	683	*/
	684	function isFunction(value) {return typeof value === 'function';}
	685
	686
	687	/**
	688	* Determines if a value is a regular expression object.
	689	*
	690	* @private
	691	* @param {*} value Reference to check.
	692	* @returns {boolean} True if `value` is a `RegExp`.
	693	*/
	694	function isRegExp(value) {
	695	return toString.call(value) === '[object RegExp]';
	696	}
	697
	698
	699	/**
	700	* Checks if `obj` is a window object.
	701	*
	702	* @private
	703	* @param {*} obj Object to check
	704	* @returns {boolean} True if `obj` is a window obj.
	705	*/
	706	function isWindow(obj) {
	707	return obj && obj.window === obj;
	708	}
	709
	710
	711	function isScope(obj) {
	712	return obj && obj.$evalAsync && obj.$watch;
	713	}
	714
	715
	716	function isFile(obj) {
	717	return toString.call(obj) === '[object File]';
	718	}
	719
	720
	721	function isFormData(obj) {
	722	return toString.call(obj) === '[object FormData]';
	723	}
	724
	725
	726	function isBlob(obj) {
	727	return toString.call(obj) === '[object Blob]';
	728	}
	729
	730
	731	function isBoolean(value) {
	732	return typeof value === 'boolean';
	733	}
	734
	735
	736	function isPromiseLike(obj) {
	737	return obj && isFunction(obj.then);
	738	}
	739
	740
	741	var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8\|Uint8Clamped\|Uint16\|Uint32\|Int8\|Int16\|Int32\|Float32\|Float64)Array\]$/;
	742	function isTypedArray(value) {
	743	return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
	744	}
	745
	746	function isArrayBuffer(obj) {
	747	return toString.call(obj) === '[object ArrayBuffer]';
	748	}
	749
	750
	751	var trim = function(value) {
	752	return isString(value) ? value.trim() : value;
	753	};
	754
	755	// Copied from:
	756	// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
	757	// Prereq: s is a string.
	758	var escapeForRegexp = function(s) {
	759	return s.replace(/([-()\[\]{}+?*.$\^\|,:#<!\\])/g, '\\$1').
	760	replace(/\x08/g, '\\x08');
	761	};
	762
	763
	764	/**
	765	* @ngdoc function
	766	* @name angular.isElement
	767	* @module ng
	768	* @kind function
	769	*
	770	* @description
	771	* Determines if a reference is a DOM element (or wrapped jQuery element).
	772	*
	773	* @param {*} value Reference to check.
	774	* @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
	775	*/
	776	function isElement(node) {
	777	return !!(node &&
	778	(node.nodeName // We are a direct element.
	779	\|\| (node.prop && node.attr && node.find))); // We have an on and find method part of jQuery API.
	780	}
	781
	782	/**
	783	* @param str 'key1,key2,...'
	784	* @returns {object} in the form of {key1:true, key2:true, ...}
	785	*/
	786	function makeMap(str) {
	787	var obj = {}, items = str.split(','), i;
	788	for (i = 0; i < items.length; i++) {
	789	obj[items[i]] = true;
	790	}
	791	return obj;
	792	}
	793
	794
	795	function nodeName_(element) {
	796	return lowercase(element.nodeName \|\| (element[0] && element[0].nodeName));
	797	}
	798
	799	function includes(array, obj) {
	800	return Array.prototype.indexOf.call(array, obj) != -1;
	801	}
	802
	803	function arrayRemove(array, value) {
	804	var index = array.indexOf(value);
	805	if (index >= 0) {
	806	array.splice(index, 1);
	807	}
	808	return index;
	809	}
	810
	811	/**
	812	* @ngdoc function
	813	* @name angular.copy
	814	* @module ng
	815	* @kind function
	816	*
	817	* @description
	818	* Creates a deep copy of `source`, which should be an object or an array.
	819	*
	820	* * If no destination is supplied, a copy of the object or array is created.
	821	* * If a destination is provided, all of its elements (for arrays) or properties (for objects)
	822	* are deleted and then all elements/properties from the source are copied to it.
	823	* * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
	824	* * If `source` is identical to `destination` an exception will be thrown.
	825	*
	826	* <br />
	827	* <div class="alert alert-warning">
	828	* Only enumerable properties are taken into account. Non-enumerable properties (both on `source`
	829	* and on `destination`) will be ignored.
	830	* </div>
	831	*
	832	* @param {*} source The source that will be used to make a copy.
	833	* Can be any type, including primitives, `null`, and `undefined`.
	834	* @param {(Object\|Array)=} destination Destination into which the source is copied. If
	835	* provided, must be of the same type as `source`.
	836	* @returns {*} The copy or updated `destination`, if `destination` was specified.
	837	*
	838	* @example
	839	<example module="copyExample">
	840	<file name="index.html">
	841	<div ng-controller="ExampleController">
	842	<form novalidate class="simple-form">
	843	<label>Name: <input type="text" ng-model="user.name" /></label><br />
	844	<label>Age: <input type="number" ng-model="user.age" /></label><br />
	845	Gender: <label><input type="radio" ng-model="user.gender" value="male" />male</label>
	846	<label><input type="radio" ng-model="user.gender" value="female" />female</label><br />
	847	<button ng-click="reset()">RESET</button>
	848	<button ng-click="update(user)">SAVE</button>
	849	</form>
	850	<pre>form = {{user \| json}}</pre>
	851	<pre>master = {{master \| json}}</pre>
	852	</div>
	853	</file>
	854	<file name="script.js">
	855	// Module: copyExample
	856	angular.
	857	module('copyExample', []).
	858	controller('ExampleController', ['$scope', function($scope) {
	859	$scope.master = {};
	860
	861	$scope.reset = function() {
	862	// Example with 1 argument
	863	$scope.user = angular.copy($scope.master);
	864	};
	865
	866	$scope.update = function(user) {
	867	// Example with 2 arguments
	868	angular.copy(user, $scope.master);
	869	};
	870
	871	$scope.reset();
	872	}]);
	873	</file>
	874	</example>
	875	*/
	876	function copy(source, destination) {
	877	var stackSource = [];
	878	var stackDest = [];
	879
	880	if (destination) {
	881	if (isTypedArray(destination) \|\| isArrayBuffer(destination)) {
	882	throw ngMinErr('cpta', "Can't copy! TypedArray destination cannot be mutated.");
	883	}
	884	if (source === destination) {
	885	throw ngMinErr('cpi', "Can't copy! Source and destination are identical.");
	886	}
	887
	888	// Empty the destination object
	889	if (isArray(destination)) {
	890	destination.length = 0;
	891	} else {
	892	forEach(destination, function(value, key) {
	893	if (key !== '$$hashKey') {
	894	delete destination[key];
	895	}
	896	});
	897	}
	898
	899	stackSource.push(source);
	900	stackDest.push(destination);
	901	return copyRecurse(source, destination);
	902	}
	903
	904	return copyElement(source);
	905
	906	function copyRecurse(source, destination) {
	907	var h = destination.$$hashKey;
	908	var key;
	909	if (isArray(source)) {
	910	for (var i = 0, ii = source.length; i < ii; i++) {
	911	destination.push(copyElement(source[i]));
	912	}
	913	} else if (isBlankObject(source)) {
	914	// createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
	915	for (key in source) {
	916	destination[key] = copyElement(source[key]);
	917	}
	918	} else if (source && typeof source.hasOwnProperty === 'function') {
	919	// Slow path, which must rely on hasOwnProperty
	920	for (key in source) {
	921	if (source.hasOwnProperty(key)) {
	922	destination[key] = copyElement(source[key]);
	923	}
	924	}
	925	} else {
	926	// Slowest path --- hasOwnProperty can't be called as a method
	927	for (key in source) {
	928	if (hasOwnProperty.call(source, key)) {
	929	destination[key] = copyElement(source[key]);
	930	}
	931	}
	932	}
	933	setHashKey(destination, h);
	934	return destination;
	935	}
	936
	937	function copyElement(source) {
	938	// Simple values
	939	if (!isObject(source)) {
	940	return source;
	941	}
	942
	943	// Already copied values
	944	var index = stackSource.indexOf(source);
	945	if (index !== -1) {
	946	return stackDest[index];
	947	}
	948
	949	if (isWindow(source) \|\| isScope(source)) {
	950	throw ngMinErr('cpws',
	951	"Can't copy! Making copies of Window or Scope instances is not supported.");
	952	}
	953
	954	var needsRecurse = false;
	955	var destination = copyType(source);
	956
	957	if (destination === undefined) {
	958	destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
	959	needsRecurse = true;
	960	}
	961
	962	stackSource.push(source);
	963	stackDest.push(destination);
	964
	965	return needsRecurse
	966	? copyRecurse(source, destination)
	967	: destination;
	968	}
	969
	970	function copyType(source) {
	971	switch (toString.call(source)) {
	972	case '[object Int8Array]':
	973	case '[object Int16Array]':
	974	case '[object Int32Array]':
	975	case '[object Float32Array]':
	976	case '[object Float64Array]':
	977	case '[object Uint8Array]':
	978	case '[object Uint8ClampedArray]':
	979	case '[object Uint16Array]':
	980	case '[object Uint32Array]':
	981	return new source.constructor(copyElement(source.buffer), source.byteOffset, source.length);
	982
	983	case '[object ArrayBuffer]':
	984	//Support: IE10
	985	if (!source.slice) {
	986	var copied = new ArrayBuffer(source.byteLength);
	987	new Uint8Array(copied).set(new Uint8Array(source));
	988	return copied;
	989	}
	990	return source.slice(0);
	991
	992	case '[object Boolean]':
	993	case '[object Number]':
	994	case '[object String]':
	995	case '[object Date]':
	996	return new source.constructor(source.valueOf());
	997
	998	case '[object RegExp]':
	999	var re = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
	1000	re.lastIndex = source.lastIndex;
	1001	return re;
	1002
	1003	case '[object Blob]':
	1004	return new source.constructor([source], {type: source.type});
	1005	}
	1006
	1007	if (isFunction(source.cloneNode)) {
	1008	return source.cloneNode(true);
	1009	}
	1010	}
	1011	}
	1012
	1013
	1014	/**
	1015	* @ngdoc function
	1016	* @name angular.equals
	1017	* @module ng
	1018	* @kind function
	1019	*
	1020	* @description
	1021	* Determines if two objects or two values are equivalent. Supports value types, regular
	1022	* expressions, arrays and objects.
	1023	*
	1024	* Two objects or values are considered equivalent if at least one of the following is true:
	1025	*
	1026	* * Both objects or values pass `===` comparison.
	1027	* * Both objects or values are of the same type and all of their properties are equal by
	1028	* comparing them with `angular.equals`.
	1029	* * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
	1030	* * Both values represent the same regular expression (In JavaScript,
	1031	* /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
	1032	* representation matches).
	1033	*
	1034	* During a property comparison, properties of `function` type and properties with names
	1035	* that begin with `$` are ignored.
	1036	*
	1037	* Scope and DOMWindow objects are being compared only by identify (`===`).
	1038	*
	1039	* @param {*} o1 Object or value to compare.
	1040	* @param {*} o2 Object or value to compare.
	1041	* @returns {boolean} True if arguments are equal.
	1042	*
	1043	* @example
	1044	<example module="equalsExample" name="equalsExample">
	1045	<file name="index.html">
	1046	<div ng-controller="ExampleController">
	1047	<form novalidate>
	1048	<h3>User 1</h3>
	1049	Name: <input type="text" ng-model="user1.name">
	1050	Age: <input type="number" ng-model="user1.age">
	1051
	1052	<h3>User 2</h3>
	1053	Name: <input type="text" ng-model="user2.name">
	1054	Age: <input type="number" ng-model="user2.age">
	1055
	1056	<div>
	1057	<br/>
	1058	<input type="button" value="Compare" ng-click="compare()">
	1059	</div>
	1060	User 1: <pre>{{user1 \| json}}</pre>
	1061	User 2: <pre>{{user2 \| json}}</pre>
	1062	Equal: <pre>{{result}}</pre>
	1063	</form>
	1064	</div>
	1065	</file>
	1066	<file name="script.js">
	1067	angular.module('equalsExample', []).controller('ExampleController', ['$scope', function($scope) {
	1068	$scope.user1 = {};
	1069	$scope.user2 = {};
	1070	$scope.result;
	1071	$scope.compare = function() {
	1072	$scope.result = angular.equals($scope.user1, $scope.user2);
	1073	};
	1074	}]);
	1075	</file>
	1076	</example>
	1077	*/
	1078	function equals(o1, o2) {
	1079	if (o1 === o2) return true;
	1080	if (o1 === null \|\| o2 === null) return false;
	1081	if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
	1082	var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
	1083	if (t1 == t2 && t1 == 'object') {
	1084	if (isArray(o1)) {
	1085	if (!isArray(o2)) return false;
	1086	if ((length = o1.length) == o2.length) {
	1087	for (key = 0; key < length; key++) {
	1088	if (!equals(o1[key], o2[key])) return false;
	1089	}
	1090	return true;
	1091	}
	1092	} else if (isDate(o1)) {
	1093	if (!isDate(o2)) return false;
	1094	return equals(o1.getTime(), o2.getTime());
	1095	} else if (isRegExp(o1)) {
	1096	if (!isRegExp(o2)) return false;
	1097	return o1.toString() == o2.toString();
	1098	} else {
	1099	if (isScope(o1) \|\| isScope(o2) \|\| isWindow(o1) \|\| isWindow(o2) \|\|
	1100	isArray(o2) \|\| isDate(o2) \|\| isRegExp(o2)) return false;
	1101	keySet = createMap();
	1102	for (key in o1) {
	1103	if (key.charAt(0) === '$' \|\| isFunction(o1[key])) continue;
	1104	if (!equals(o1[key], o2[key])) return false;
	1105	keySet[key] = true;
	1106	}
	1107	for (key in o2) {
	1108	if (!(key in keySet) &&
	1109	key.charAt(0) !== '$' &&
	1110	isDefined(o2[key]) &&
	1111	!isFunction(o2[key])) return false;
	1112	}
	1113	return true;
	1114	}
	1115	}
	1116	return false;
	1117	}
	1118
	1119	var csp = function() {
	1120	if (!isDefined(csp.rules)) {
	1121
	1122
	1123	var ngCspElement = (window.document.querySelector('[ng-csp]') \|\|
	1124	window.document.querySelector('[data-ng-csp]'));
	1125
	1126	if (ngCspElement) {
	1127	var ngCspAttribute = ngCspElement.getAttribute('ng-csp') \|\|
	1128	ngCspElement.getAttribute('data-ng-csp');
	1129	csp.rules = {
	1130	noUnsafeEval: !ngCspAttribute \|\| (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
	1131	noInlineStyle: !ngCspAttribute \|\| (ngCspAttribute.indexOf('no-inline-style') !== -1)
	1132	};
	1133	} else {
	1134	csp.rules = {
	1135	noUnsafeEval: noUnsafeEval(),
	1136	noInlineStyle: false
	1137	};
	1138	}
	1139	}
	1140
	1141	return csp.rules;
	1142
	1143	function noUnsafeEval() {
	1144	try {
	1145	/* jshint -W031, -W054 */
	1146	new Function('');
	1147	/* jshint +W031, +W054 */
	1148	return false;
	1149	} catch (e) {
	1150	return true;
	1151	}
	1152	}
	1153	};
	1154
	1155	/**
	1156	* @ngdoc directive
	1157	* @module ng
	1158	* @name ngJq
	1159	*
	1160	* @element ANY
	1161	* @param {string=} ngJq the name of the library available under `window`
	1162	* to be used for angular.element
	1163	* @description
	1164	* Use this directive to force the angular.element library. This should be
	1165	* used to force either jqLite by leaving ng-jq blank or setting the name of
	1166	* the jquery variable under window (eg. jQuery).
	1167	*
	1168	* Since angular looks for this directive when it is loaded (doesn't wait for the
	1169	* DOMContentLoaded event), it must be placed on an element that comes before the script
	1170	* which loads angular. Also, only the first instance of `ng-jq` will be used and all
	1171	* others ignored.
	1172	*
	1173	* @example
	1174	* This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
	1175	```html
	1176	<!doctype html>
	1177	<html ng-app ng-jq>
	1178	...
	1179	...
	1180	</html>
	1181	```
	1182	* @example
	1183	* This example shows how to use a jQuery based library of a different name.
	1184	* The library name must be available at the top most 'window'.
	1185	```html
	1186	<!doctype html>
	1187	<html ng-app ng-jq="jQueryLib">
	1188	...
	1189	...
	1190	</html>
	1191	```
	1192	*/
	1193	var jq = function() {
	1194	if (isDefined(jq.name_)) return jq.name_;
	1195	var el;
	1196	var i, ii = ngAttrPrefixes.length, prefix, name;
	1197	for (i = 0; i < ii; ++i) {
	1198	prefix = ngAttrPrefixes[i];
	1199	if (el = window.document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) {
	1200	name = el.getAttribute(prefix + 'jq');
	1201	break;
	1202	}
	1203	}
	1204
	1205	return (jq.name_ = name);
	1206	};
	1207
	1208	function concat(array1, array2, index) {
	1209	return array1.concat(slice.call(array2, index));
	1210	}
	1211
	1212	function sliceArgs(args, startIndex) {
	1213	return slice.call(args, startIndex \|\| 0);
	1214	}
	1215
	1216
	1217	/* jshint -W101 */
	1218	/**
	1219	* @ngdoc function
	1220	* @name angular.bind
	1221	* @module ng
	1222	* @kind function
	1223	*
	1224	* @description
	1225	* Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
	1226	* `fn`). You can supply optional `args` that are prebound to the function. This feature is also
	1227	* known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
	1228	* distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
	1229	*
	1230	* @param {Object} self Context which `fn` should be evaluated in.
	1231	* @param {function()} fn Function to be bound.
	1232	* @param {...*} args Optional arguments to be prebound to the `fn` function call.
	1233	* @returns {function()} Function that wraps the `fn` with all the specified bindings.
	1234	*/
	1235	/* jshint +W101 */
	1236	function bind(self, fn) {
	1237	var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
	1238	if (isFunction(fn) && !(fn instanceof RegExp)) {
	1239	return curryArgs.length
	1240	? function() {
	1241	return arguments.length
	1242	? fn.apply(self, concat(curryArgs, arguments, 0))
	1243	: fn.apply(self, curryArgs);
	1244	}
	1245	: function() {
	1246	return arguments.length
	1247	? fn.apply(self, arguments)
	1248	: fn.call(self);
	1249	};
	1250	} else {
	1251	// In IE, native methods are not functions so they cannot be bound (note: they don't need to be).
	1252	return fn;
	1253	}
	1254	}
	1255
	1256
	1257	function toJsonReplacer(key, value) {
	1258	var val = value;
	1259
	1260	if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
	1261	val = undefined;
	1262	} else if (isWindow(value)) {
	1263	val = '$WINDOW';
	1264	} else if (value && window.document === value) {
	1265	val = '$DOCUMENT';
	1266	} else if (isScope(value)) {
	1267	val = '$SCOPE';
	1268	}
	1269
	1270	return val;
	1271	}
	1272
	1273
	1274	/**
	1275	* @ngdoc function
	1276	* @name angular.toJson
	1277	* @module ng
	1278	* @kind function
	1279	*
	1280	* @description
	1281	* Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
	1282	* stripped since angular uses this notation internally.
	1283	*
	1284	* @param {Object\|Array\|Date\|string\|number} obj Input to be serialized into JSON.
	1285	* @param {boolean\|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
	1286	* If set to an integer, the JSON output will contain that many spaces per indentation.
	1287	* @returns {string\|undefined} JSON-ified string representing `obj`.
	1288	* @knownIssue
	1289	*
	1290	* The Safari browser throws a `RangeError` instead of returning `null` when it tries to stringify a `Date`
	1291	* object with an invalid date value. The only reliable way to prevent this is to monkeypatch the
	1292	* `Date.prototype.toJSON` method as follows:
	1293	*
	1294	* ```
	1295	* var _DatetoJSON = Date.prototype.toJSON;
	1296	* Date.prototype.toJSON = function() {
	1297	* try {
	1298	* return _DatetoJSON.call(this);
	1299	* } catch(e) {
	1300	* if (e instanceof RangeError) {
	1301	* return null;
	1302	* }
	1303	* throw e;
	1304	* }
	1305	* };
	1306	* ```
	1307	*
	1308	* See https://github.com/angular/angular.js/pull/14221 for more information.
	1309	*/
	1310	function toJson(obj, pretty) {
	1311	if (isUndefined(obj)) return undefined;
	1312	if (!isNumber(pretty)) {
	1313	pretty = pretty ? 2 : null;
	1314	}
	1315	return JSON.stringify(obj, toJsonReplacer, pretty);
	1316	}
	1317
	1318
	1319	/**
	1320	* @ngdoc function
	1321	* @name angular.fromJson
	1322	* @module ng
	1323	* @kind function
	1324	*
	1325	* @description
	1326	* Deserializes a JSON string.
	1327	*
	1328	* @param {string} json JSON string to deserialize.
	1329	* @returns {Object\|Array\|string\|number} Deserialized JSON string.
	1330	*/
	1331	function fromJson(json) {
	1332	return isString(json)
	1333	? JSON.parse(json)
	1334	: json;
	1335	}
	1336
	1337
	1338	var ALL_COLONS = /:/g;
	1339	function timezoneToOffset(timezone, fallback) {
	1340	// IE/Edge do not "understand" colon (`:`) in timezone
	1341	timezone = timezone.replace(ALL_COLONS, '');
	1342	var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
	1343	return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
	1344	}
	1345
	1346
	1347	function addDateMinutes(date, minutes) {
	1348	date = new Date(date.getTime());
	1349	date.setMinutes(date.getMinutes() + minutes);
	1350	return date;
	1351	}
	1352
	1353
	1354	function convertTimezoneToLocal(date, timezone, reverse) {
	1355	reverse = reverse ? -1 : 1;
	1356	var dateTimezoneOffset = date.getTimezoneOffset();
	1357	var timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
	1358	return addDateMinutes(date, reverse * (timezoneOffset - dateTimezoneOffset));
	1359	}
	1360
	1361
	1362	/**
	1363	* @returns {string} Returns the string representation of the element.
	1364	*/
	1365	function startingTag(element) {
	1366	element = jqLite(element).clone();
	1367	try {
	1368	// turns out IE does not let you set .html() on elements which
	1369	// are not allowed to have children. So we just ignore it.
	1370	element.empty();
	1371	} catch (e) {}
	1372	var elemHtml = jqLite('<div>').append(element).html();
	1373	try {
	1374	return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
	1375	elemHtml.
	1376	match(/^(<[^>]+>)/)[1].
	1377	replace(/^<([\w\-]+)/, function(match, nodeName) {return '<' + lowercase(nodeName);});
	1378	} catch (e) {
	1379	return lowercase(elemHtml);
	1380	}
	1381
	1382	}
	1383
	1384
	1385	/////////////////////////////////////////////////
	1386
	1387	/**
	1388	* Tries to decode the URI component without throwing an exception.
	1389	*
	1390	* @private
	1391	* @param str value potential URI component to check.
	1392	* @returns {boolean} True if `value` can be decoded
	1393	* with the decodeURIComponent function.
	1394	*/
	1395	function tryDecodeURIComponent(value) {
	1396	try {
	1397	return decodeURIComponent(value);
	1398	} catch (e) {
	1399	// Ignore any invalid uri component.
	1400	}
	1401	}
	1402
	1403
	1404	/**
	1405	* Parses an escaped url query string into key-value pairs.
	1406	* @returns {Object.<string,boolean\|Array>}
	1407	*/
	1408	function parseKeyValue(/*string/keyValue) {
	1409	var obj = {};
	1410	forEach((keyValue \|\| "").split('&'), function(keyValue) {
	1411	var splitPoint, key, val;
	1412	if (keyValue) {
	1413	key = keyValue = keyValue.replace(/\+/g,'%20');
	1414	splitPoint = keyValue.indexOf('=');
	1415	if (splitPoint !== -1) {
	1416	key = keyValue.substring(0, splitPoint);
	1417	val = keyValue.substring(splitPoint + 1);
	1418	}
	1419	key = tryDecodeURIComponent(key);
	1420	if (isDefined(key)) {
	1421	val = isDefined(val) ? tryDecodeURIComponent(val) : true;
	1422	if (!hasOwnProperty.call(obj, key)) {
	1423	obj[key] = val;
	1424	} else if (isArray(obj[key])) {
	1425	obj[key].push(val);
	1426	} else {
	1427	obj[key] = [obj[key],val];
	1428	}
	1429	}
	1430	}
	1431	});
	1432	return obj;
	1433	}
	1434
	1435	function toKeyValue(obj) {
	1436	var parts = [];
	1437	forEach(obj, function(value, key) {
	1438	if (isArray(value)) {
	1439	forEach(value, function(arrayValue) {
	1440	parts.push(encodeUriQuery(key, true) +
	1441	(arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
	1442	});
	1443	} else {
	1444	parts.push(encodeUriQuery(key, true) +
	1445	(value === true ? '' : '=' + encodeUriQuery(value, true)));
	1446	}
	1447	});
	1448	return parts.length ? parts.join('&') : '';
	1449	}
	1450
	1451
	1452	/**
	1453	* We need our custom method because encodeURIComponent is too aggressive and doesn't follow
	1454	* http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
	1455	* segments:
	1456	* segment = *pchar
	1457	* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
	1458	* pct-encoded = "%" HEXDIG HEXDIG
	1459	* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
	1460	* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
	1461	* / "*" / "+" / "," / ";" / "="
	1462	*/
	1463	function encodeUriSegment(val) {
	1464	return encodeUriQuery(val, true).
	1465	replace(/%26/gi, '&').
	1466	replace(/%3D/gi, '=').
	1467	replace(/%2B/gi, '+');
	1468	}
	1469
	1470
	1471	/**
	1472	* This method is intended for encoding key or value parts of query component. We need a custom
	1473	* method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
	1474	* encoded per http://tools.ietf.org/html/rfc3986:
	1475	* query = *( pchar / "/" / "?" )
	1476	* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
	1477	* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
	1478	* pct-encoded = "%" HEXDIG HEXDIG
	1479	* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
	1480	* / "*" / "+" / "," / ";" / "="
	1481	*/
	1482	function encodeUriQuery(val, pctEncodeSpaces) {
	1483	return encodeURIComponent(val).
	1484	replace(/%40/gi, '@').
	1485	replace(/%3A/gi, ':').
	1486	replace(/%24/g, '$').
	1487	replace(/%2C/gi, ',').
	1488	replace(/%3B/gi, ';').
	1489	replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
	1490	}
	1491
	1492	var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
	1493
	1494	function getNgAttribute(element, ngAttr) {
	1495	var attr, i, ii = ngAttrPrefixes.length;
	1496	for (i = 0; i < ii; ++i) {
	1497	attr = ngAttrPrefixes[i] + ngAttr;
	1498	if (isString(attr = element.getAttribute(attr))) {
	1499	return attr;
	1500	}
	1501	}
	1502	return null;
	1503	}
	1504
	1505	/**
	1506	* @ngdoc directive
	1507	* @name ngApp
	1508	* @module ng
	1509	*
	1510	* @element ANY
	1511	* @param {angular.Module} ngApp an optional application
	1512	* {@link angular.module module} name to load.
	1513	* @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
	1514	* created in "strict-di" mode. This means that the application will fail to invoke functions which
	1515	* do not use explicit function annotation (and are thus unsuitable for minification), as described
	1516	* in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
	1517	* tracking down the root of these bugs.
	1518	*
	1519	* @description
	1520	*
	1521	* Use this directive to auto-bootstrap an AngularJS application. The `ngApp` directive
	1522	* designates the root element of the application and is typically placed near the root element
	1523	* of the page - e.g. on the `<body>` or `<html>` tags.
	1524	*
	1525	* There are a few things to keep in mind when using `ngApp`:
	1526	* - only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
	1527	* found in the document will be used to define the root element to auto-bootstrap as an
	1528	* application. To run multiple applications in an HTML document you must manually bootstrap them using
	1529	* {@link angular.bootstrap} instead.
	1530	* - AngularJS applications cannot be nested within each other.
	1531	* - Do not use a directive that uses {@link ng.$compile#transclusion transclusion} on the same element as `ngApp`.
	1532	* This includes directives such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and
	1533	* {@link ngRoute.ngView `ngView`}.
	1534	* Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
	1535	* causing animations to stop working and making the injector inaccessible from outside the app.
	1536	*
	1537	* You can specify an AngularJS module to be used as the root module for the application. This
	1538	* module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
	1539	* should contain the application code needed or have dependencies on other modules that will
	1540	* contain the code. See {@link angular.module} for more information.
	1541	*
	1542	* In the example below if the `ngApp` directive were not placed on the `html` element then the
	1543	* document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
	1544	* would not be resolved to `3`.
	1545	*
	1546	* `ngApp` is the easiest, and most common way to bootstrap an application.
	1547	*
	1548	<example module="ngAppDemo">
	1549	<file name="index.html">
	1550	<div ng-controller="ngAppDemoController">
	1551	I can add: {{a}} + {{b}} = {{ a+b }}
	1552	</div>
	1553	</file>
	1554	<file name="script.js">
	1555	angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
	1556	$scope.a = 1;
	1557	$scope.b = 2;
	1558	});
	1559	</file>
	1560	</example>
	1561	*
	1562	* Using `ngStrictDi`, you would see something like this:
	1563	*
	1564	<example ng-app-included="true">
	1565	<file name="index.html">
	1566	<div ng-app="ngAppStrictDemo" ng-strict-di>
	1567	<div ng-controller="GoodController1">
	1568	I can add: {{a}} + {{b}} = {{ a+b }}
	1569
	1570	<p>This renders because the controller does not fail to
	1571	instantiate, by using explicit annotation style (see
	1572	script.js for details)
	1573	</p>
	1574	</div>
	1575
	1576	<div ng-controller="GoodController2">
	1577	Name: <input ng-model="name"><br />
	1578	Hello, {{name}}!
	1579
	1580	<p>This renders because the controller does not fail to
	1581	instantiate, by using explicit annotation style
	1582	(see script.js for details)
	1583	</p>
	1584	</div>
	1585
	1586	<div ng-controller="BadController">
	1587	I can add: {{a}} + {{b}} = {{ a+b }}
	1588
	1589	<p>The controller could not be instantiated, due to relying
	1590	on automatic function annotations (which are disabled in
	1591	strict mode). As such, the content of this section is not
	1592	interpolated, and there should be an error in your web console.
	1593	</p>
	1594	</div>
	1595	</div>
	1596	</file>
	1597	<file name="script.js">
	1598	angular.module('ngAppStrictDemo', [])
	1599	// BadController will fail to instantiate, due to relying on automatic function annotation,
	1600	// rather than an explicit annotation
	1601	.controller('BadController', function($scope) {
	1602	$scope.a = 1;
	1603	$scope.b = 2;
	1604	})
	1605	// Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
	1606	// due to using explicit annotations using the array style and $inject property, respectively.
	1607	.controller('GoodController1', ['$scope', function($scope) {
	1608	$scope.a = 1;
	1609	$scope.b = 2;
	1610	}])
	1611	.controller('GoodController2', GoodController2);
	1612	function GoodController2($scope) {
	1613	$scope.name = "World";
	1614	}
	1615	GoodController2.$inject = ['$scope'];
	1616	</file>
	1617	<file name="style.css">
	1618	div[ng-controller] {
	1619	margin-bottom: 1em;
	1620	-webkit-border-radius: 4px;
	1621	border-radius: 4px;
	1622	border: 1px solid;
	1623	padding: .5em;
	1624	}
	1625	div[ng-controller^=Good] {
	1626	border-color: #d6e9c6;
	1627	background-color: #dff0d8;
	1628	color: #3c763d;
	1629	}
	1630	div[ng-controller^=Bad] {
	1631	border-color: #ebccd1;
	1632	background-color: #f2dede;
	1633	color: #a94442;
	1634	margin-bottom: 0;
	1635	}
	1636	</file>
	1637	</example>
	1638	*/
	1639	function angularInit(element, bootstrap) {
	1640	var appElement,
	1641	module,
	1642	config = {};
	1643
	1644	// The element `element` has priority over any other element.
	1645	forEach(ngAttrPrefixes, function(prefix) {
	1646	var name = prefix + 'app';
	1647
	1648	if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
	1649	appElement = element;
	1650	module = element.getAttribute(name);
	1651	}
	1652	});
	1653	forEach(ngAttrPrefixes, function(prefix) {
	1654	var name = prefix + 'app';
	1655	var candidate;
	1656
	1657	if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
	1658	appElement = candidate;
	1659	module = candidate.getAttribute(name);
	1660	}
	1661	});
	1662	if (appElement) {
	1663	config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
	1664	bootstrap(appElement, module ? [module] : [], config);
	1665	}
	1666	}
	1667
	1668	/**
	1669	* @ngdoc function
	1670	* @name angular.bootstrap
	1671	* @module ng
	1672	* @description
	1673	* Use this function to manually start up angular application.
	1674	*
	1675	* For more information, see the {@link guide/bootstrap Bootstrap guide}.
	1676	*
	1677	* Angular will detect if it has been loaded into the browser more than once and only allow the
	1678	* first loaded script to be bootstrapped and will report a warning to the browser console for
	1679	* each of the subsequent scripts. This prevents strange results in applications, where otherwise
	1680	* multiple instances of Angular try to work on the DOM.
	1681	*
	1682	* <div class="alert alert-warning">
	1683	* Note: Protractor based end-to-end tests cannot use this function to bootstrap manually.
	1684	* They must use {@link ng.directive:ngApp ngApp}.
	1685	* </div>
	1686	*
	1687	* <div class="alert alert-warning">
	1688	* Note: Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
	1689	* such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
	1690	* Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
	1691	* causing animations to stop working and making the injector inaccessible from outside the app.
	1692	* </div>
	1693	*
	1694	* ```html
	1695	* <!doctype html>
	1696	* <html>
	1697	* <body>
	1698	* <div ng-controller="WelcomeController">
	1699	* {{greeting}}
	1700	* </div>
	1701	*
	1702	* <script src="angular.js"></script>
	1703	* <script>
	1704	* var app = angular.module('demo', [])
	1705	* .controller('WelcomeController', function($scope) {
	1706	* $scope.greeting = 'Welcome!';
	1707	* });
	1708	* angular.bootstrap(document, ['demo']);
	1709	* </script>
	1710	* </body>
	1711	* </html>
	1712	* ```
	1713	*
	1714	* @param {DOMElement} element DOM element which is the root of angular application.
	1715	* @param {Array<String\|Function\|Array>=} modules an array of modules to load into the application.
	1716	* Each item in the array should be the name of a predefined module or a (DI annotated)
	1717	* function that will be invoked by the injector as a `config` block.
	1718	* See: {@link angular.module modules}
	1719	* @param {Object=} config an object for defining configuration options for the application. The
	1720	* following keys are supported:
	1721	*
	1722	* * `strictDi` - disable automatic function annotation for the application. This is meant to
	1723	* assist in finding bugs which break minified code. Defaults to `false`.
	1724	*
	1725	* @returns {auto.$injector} Returns the newly created injector for this app.
	1726	*/
	1727	function bootstrap(element, modules, config) {
	1728	if (!isObject(config)) config = {};
	1729	var defaultConfig = {
	1730	strictDi: false
	1731	};
	1732	config = extend(defaultConfig, config);
	1733	var doBootstrap = function() {
	1734	element = jqLite(element);
	1735
	1736	if (element.injector()) {
	1737	var tag = (element[0] === window.document) ? 'document' : startingTag(element);
	1738	// Encode angle brackets to prevent input from being sanitized to empty string #8683.
	1739	throw ngMinErr(
	1740	'btstrpd',
	1741	"App already bootstrapped with this element '{0}'",
	1742	tag.replace(/</,'<').replace(/>/,'>'));
	1743	}
	1744
	1745	modules = modules \|\| [];
	1746	modules.unshift(['$provide', function($provide) {
	1747	$provide.value('$rootElement', element);
	1748	}]);
	1749
	1750	if (config.debugInfoEnabled) {
	1751	// Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
	1752	modules.push(['$compileProvider', function($compileProvider) {
	1753	$compileProvider.debugInfoEnabled(true);
	1754	}]);
	1755	}
	1756
	1757	modules.unshift('ng');
	1758	var injector = createInjector(modules, config.strictDi);
	1759	injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
	1760	function bootstrapApply(scope, element, compile, injector) {
	1761	scope.$apply(function() {
	1762	element.data('$injector', injector);
	1763	compile(element)(scope);
	1764	});
	1765	}]
	1766	);
	1767	return injector;
	1768	};
	1769
	1770	var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
	1771	var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
	1772
	1773	if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
	1774	config.debugInfoEnabled = true;
	1775	window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
	1776	}
	1777
	1778	if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
	1779	return doBootstrap();
	1780	}
	1781
	1782	window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
	1783	angular.resumeBootstrap = function(extraModules) {
	1784	forEach(extraModules, function(module) {
	1785	modules.push(module);
	1786	});
	1787	return doBootstrap();
	1788	};
	1789
	1790	if (isFunction(angular.resumeDeferredBootstrap)) {
	1791	angular.resumeDeferredBootstrap();
	1792	}
	1793	}
	1794
	1795	/**
	1796	* @ngdoc function
	1797	* @name angular.reloadWithDebugInfo
	1798	* @module ng
	1799	* @description
	1800	* Use this function to reload the current application with debug information turned on.
	1801	* This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
	1802	*
	1803	* See {@link ng.$compileProvider#debugInfoEnabled} for more.
	1804	*/
	1805	function reloadWithDebugInfo() {
	1806	window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
	1807	window.location.reload();
	1808	}
	1809
	1810	/**
	1811	* @name angular.getTestability
	1812	* @module ng
	1813	* @description
	1814	* Get the testability service for the instance of Angular on the given
	1815	* element.
	1816	* @param {DOMElement} element DOM element which is the root of angular application.
	1817	*/
	1818	function getTestability(rootElement) {
	1819	var injector = angular.element(rootElement).injector();
	1820	if (!injector) {
	1821	throw ngMinErr('test',
	1822	'no injector found for element argument to getTestability');
	1823	}
	1824	return injector.get('$$testability');
	1825	}
	1826
	1827	var SNAKE_CASE_REGEXP = /[A-Z]/g;
	1828	function snake_case(name, separator) {
	1829	separator = separator \|\| '_';
	1830	return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
	1831	return (pos ? separator : '') + letter.toLowerCase();
	1832	});
	1833	}
	1834
	1835	var bindJQueryFired = false;
	1836	function bindJQuery() {
	1837	var originalCleanData;
	1838
	1839	if (bindJQueryFired) {
	1840	return;
	1841	}
	1842
	1843	// bind to jQuery if present;
	1844	var jqName = jq();
	1845	jQuery = isUndefined(jqName) ? window.jQuery : // use jQuery (if present)
	1846	!jqName ? undefined : // use jqLite
	1847	window[jqName]; // use jQuery specified by `ngJq`
	1848
	1849	// Use jQuery if it exists with proper functionality, otherwise default to us.
	1850	// Angular 1.2+ requires jQuery 1.7+ for on()/off() support.
	1851	// Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older
	1852	// versions. It will not work for sure with jQuery <1.7, though.
	1853	if (jQuery && jQuery.fn.on) {
	1854	jqLite = jQuery;
	1855	extend(jQuery.fn, {
	1856	scope: JQLitePrototype.scope,
	1857	isolateScope: JQLitePrototype.isolateScope,
	1858	controller: JQLitePrototype.controller,
	1859	injector: JQLitePrototype.injector,
	1860	inheritedData: JQLitePrototype.inheritedData
	1861	});
	1862
	1863	// All nodes removed from the DOM via various jQuery APIs like .remove()
	1864	// are passed through jQuery.cleanData. Monkey-patch this method to fire
	1865	// the $destroy event on all removed nodes.
	1866	originalCleanData = jQuery.cleanData;
	1867	jQuery.cleanData = function(elems) {
	1868	var events;
	1869	for (var i = 0, elem; (elem = elems[i]) != null; i++) {
	1870	events = jQuery._data(elem, "events");
	1871	if (events && events.$destroy) {
	1872	jQuery(elem).triggerHandler('$destroy');
	1873	}
	1874	}
	1875	originalCleanData(elems);
	1876	};
	1877	} else {
	1878	jqLite = JQLite;
	1879	}
	1880
	1881	angular.element = jqLite;
	1882
	1883	// Prevent double-proxying.
	1884	bindJQueryFired = true;
	1885	}
	1886
	1887	/**
	1888	* throw error if the argument is falsy.
	1889	*/
	1890	function assertArg(arg, name, reason) {
	1891	if (!arg) {
	1892	throw ngMinErr('areq', "Argument '{0}' is {1}", (name \|\| '?'), (reason \|\| "required"));
	1893	}
	1894	return arg;
	1895	}
	1896
	1897	function assertArgFn(arg, name, acceptArrayAnnotation) {
	1898	if (acceptArrayAnnotation && isArray(arg)) {
	1899	arg = arg[arg.length - 1];
	1900	}
	1901
	1902	assertArg(isFunction(arg), name, 'not a function, got ' +
	1903	(arg && typeof arg === 'object' ? arg.constructor.name \|\| 'Object' : typeof arg));
	1904	return arg;
	1905	}
	1906
	1907	/**
	1908	* throw error if the name given is hasOwnProperty
	1909	* @param {String} name the name to test
	1910	* @param {String} context the context in which the name is used, such as module or directive
	1911	*/
	1912	function assertNotHasOwnProperty(name, context) {
	1913	if (name === 'hasOwnProperty') {
	1914	throw ngMinErr('badname', "hasOwnProperty is not a valid {0} name", context);
	1915	}
	1916	}
	1917
	1918	/**
	1919	* Return the value accessible from the object by path. Any undefined traversals are ignored
	1920	* @param {Object} obj starting object
	1921	* @param {String} path path to traverse
	1922	* @param {boolean} [bindFnToScope=true]
	1923	* @returns {Object} value as accessible by path
	1924	*/
	1925	//TODO(misko): this function needs to be removed
	1926	function getter(obj, path, bindFnToScope) {
	1927	if (!path) return obj;
	1928	var keys = path.split('.');
	1929	var key;
	1930	var lastInstance = obj;
	1931	var len = keys.length;
	1932
	1933	for (var i = 0; i < len; i++) {
	1934	key = keys[i];
	1935	if (obj) {
	1936	obj = (lastInstance = obj)[key];
	1937	}
	1938	}
	1939	if (!bindFnToScope && isFunction(obj)) {
	1940	return bind(lastInstance, obj);
	1941	}
	1942	return obj;
	1943	}
	1944
	1945	/**
	1946	* Return the DOM siblings between the first and last node in the given array.
	1947	* @param {Array} array like object
	1948	* @returns {Array} the inputted object or a jqLite collection containing the nodes
	1949	*/
	1950	function getBlockNodes(nodes) {
	1951	// TODO(perf): update `nodes` instead of creating a new object?
	1952	var node = nodes[0];
	1953	var endNode = nodes[nodes.length - 1];
	1954	var blockNodes;
	1955
	1956	for (var i = 1; node !== endNode && (node = node.nextSibling); i++) {
	1957	if (blockNodes \|\| nodes[i] !== node) {
	1958	if (!blockNodes) {
	1959	blockNodes = jqLite(slice.call(nodes, 0, i));
	1960	}
	1961	blockNodes.push(node);
	1962	}
	1963	}
	1964
	1965	return blockNodes \|\| nodes;
	1966	}
	1967
	1968
	1969	/**
	1970	* Creates a new object without a prototype. This object is useful for lookup without having to
	1971	* guard against prototypically inherited properties via hasOwnProperty.
	1972	*
	1973	* Related micro-benchmarks:
	1974	* - http://jsperf.com/object-create2
	1975	* - http://jsperf.com/proto-map-lookup/2
	1976	* - http://jsperf.com/for-in-vs-object-keys2
	1977	*
	1978	* @returns {Object}
	1979	*/
	1980	function createMap() {
	1981	return Object.create(null);
	1982	}
	1983
	1984	var NODE_TYPE_ELEMENT = 1;
	1985	var NODE_TYPE_ATTRIBUTE = 2;
	1986	var NODE_TYPE_TEXT = 3;
	1987	var NODE_TYPE_COMMENT = 8;
	1988	var NODE_TYPE_DOCUMENT = 9;
	1989	var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
	1990
	1991	/**
	1992	* @ngdoc type
	1993	* @name angular.Module
	1994	* @module ng
	1995	* @description
	1996	*
	1997	* Interface for configuring angular {@link angular.module modules}.
	1998	*/
	1999
	2000	function setupModuleLoader(window) {
	2001
	2002	var $injectorMinErr = minErr('$injector');
	2003	var ngMinErr = minErr('ng');
	2004
	2005	function ensure(obj, name, factory) {
	2006	return obj[name] \|\| (obj[name] = factory());
	2007	}
	2008
	2009	var angular = ensure(window, 'angular', Object);
	2010
	2011	// We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
	2012	angular.$$minErr = angular.$$minErr \|\| minErr;
	2013
	2014	return ensure(angular, 'module', function() {
	2015	/** @type {Object.<string, angular.Module>} */
	2016	var modules = {};
	2017
	2018	/**
	2019	* @ngdoc function
	2020	* @name angular.module
	2021	* @module ng
	2022	* @description
	2023	*
	2024	* The `angular.module` is a global place for creating, registering and retrieving Angular
	2025	* modules.
	2026	* All modules (angular core or 3rd party) that should be available to an application must be
	2027	* registered using this mechanism.
	2028	*
	2029	* Passing one argument retrieves an existing {@link angular.Module},
	2030	* whereas passing more than one argument creates a new {@link angular.Module}
	2031	*
	2032	*
	2033	* # Module
	2034	*
	2035	* A module is a collection of services, directives, controllers, filters, and configuration information.
	2036	* `angular.module` is used to configure the {@link auto.$injector $injector}.
	2037	*
	2038	* ```js
	2039	* // Create a new module
	2040	* var myModule = angular.module('myModule', []);
	2041	*
	2042	* // register a new service
	2043	* myModule.value('appName', 'MyCoolApp');
	2044	*
	2045	* // configure existing services inside initialization blocks.
	2046	* myModule.config(['$locationProvider', function($locationProvider) {
	2047	* // Configure existing providers
	2048	* $locationProvider.hashPrefix('!');
	2049	* }]);
	2050	* ```
	2051	*
	2052	* Then you can create an injector and load your modules like this:
	2053	*
	2054	* ```js
	2055	* var injector = angular.injector(['ng', 'myModule'])
	2056	* ```
	2057	*
	2058	* However it's more likely that you'll just use
	2059	* {@link ng.directive:ngApp ngApp} or
	2060	* {@link angular.bootstrap} to simplify this process for you.
	2061	*
	2062	* @param {!string} name The name of the module to create or retrieve.
	2063	* @param {!Array.<string>=} requires If specified then new module is being created. If
	2064	* unspecified then the module is being retrieved for further configuration.
	2065	* @param {Function=} configFn Optional configuration function for the module. Same as
	2066	* {@link angular.Module#config Module#config()}.
	2067	* @returns {angular.Module} new module with the {@link angular.Module} api.
	2068	*/
	2069	return function module(name, requires, configFn) {
	2070	var assertNotHasOwnProperty = function(name, context) {
	2071	if (name === 'hasOwnProperty') {
	2072	throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
	2073	}
	2074	};
	2075
	2076	assertNotHasOwnProperty(name, 'module');
	2077	if (requires && modules.hasOwnProperty(name)) {
	2078	modules[name] = null;
	2079	}
	2080	return ensure(modules, name, function() {
	2081	if (!requires) {
	2082	throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
	2083	"the module name or forgot to load it. If registering a module ensure that you " +
	2084	"specify the dependencies as the second argument.", name);
	2085	}
	2086
	2087	/** @type {!Array.<Array.<>>} /
	2088	var invokeQueue = [];
	2089
	2090	/** @type {!Array.<Function>} */
	2091	var configBlocks = [];
	2092
	2093	/** @type {!Array.<Function>} */
	2094	var runBlocks = [];
	2095
	2096	var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
	2097
	2098	/** @type {angular.Module} */
	2099	var moduleInstance = {
	2100	// Private state
	2101	_invokeQueue: invokeQueue,
	2102	_configBlocks: configBlocks,
	2103	_runBlocks: runBlocks,
	2104
	2105	/**
	2106	* @ngdoc property
	2107	* @name angular.Module#requires
	2108	* @module ng
	2109	*
	2110	* @description
	2111	* Holds the list of modules which the injector will load before the current module is
	2112	* loaded.
	2113	*/
	2114	requires: requires,
	2115
	2116	/**
	2117	* @ngdoc property
	2118	* @name angular.Module#name
	2119	* @module ng
	2120	*
	2121	* @description
	2122	* Name of the module.
	2123	*/
	2124	name: name,
	2125
	2126
	2127	/**
	2128	* @ngdoc method
	2129	* @name angular.Module#provider
	2130	* @module ng
	2131	* @param {string} name service name
	2132	* @param {Function} providerType Construction function for creating new instance of the
	2133	* service.
	2134	* @description
	2135	* See {@link auto.$provide#provider $provide.provider()}.
	2136	*/
	2137	provider: invokeLaterAndSetModuleName('$provide', 'provider'),
	2138
	2139	/**
	2140	* @ngdoc method
	2141	* @name angular.Module#factory
	2142	* @module ng
	2143	* @param {string} name service name
	2144	* @param {Function} providerFunction Function for creating new instance of the service.
	2145	* @description
	2146	* See {@link auto.$provide#factory $provide.factory()}.
	2147	*/
	2148	factory: invokeLaterAndSetModuleName('$provide', 'factory'),
	2149
	2150	/**
	2151	* @ngdoc method
	2152	* @name angular.Module#service
	2153	* @module ng
	2154	* @param {string} name service name
	2155	* @param {Function} constructor A constructor function that will be instantiated.
	2156	* @description
	2157	* See {@link auto.$provide#service $provide.service()}.
	2158	*/
	2159	service: invokeLaterAndSetModuleName('$provide', 'service'),
	2160
	2161	/**
	2162	* @ngdoc method
	2163	* @name angular.Module#value
	2164	* @module ng
	2165	* @param {string} name service name
	2166	* @param {*} object Service instance object.
	2167	* @description
	2168	* See {@link auto.$provide#value $provide.value()}.
	2169	*/
	2170	value: invokeLater('$provide', 'value'),
	2171
	2172	/**
	2173	* @ngdoc method
	2174	* @name angular.Module#constant
	2175	* @module ng
	2176	* @param {string} name constant name
	2177	* @param {*} object Constant value.
	2178	* @description
	2179	* Because the constants are fixed, they get applied before other provide methods.
	2180	* See {@link auto.$provide#constant $provide.constant()}.
	2181	*/
	2182	constant: invokeLater('$provide', 'constant', 'unshift'),
	2183
	2184	/**
	2185	* @ngdoc method
	2186	* @name angular.Module#decorator
	2187	* @module ng
	2188	* @param {string} name The name of the service to decorate.
	2189	* @param {Function} decorFn This function will be invoked when the service needs to be
	2190	* instantiated and should return the decorated service instance.
	2191	* @description
	2192	* See {@link auto.$provide#decorator $provide.decorator()}.
	2193	*/
	2194	decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
	2195
	2196	/**
	2197	* @ngdoc method
	2198	* @name angular.Module#animation
	2199	* @module ng
	2200	* @param {string} name animation name
	2201	* @param {Function} animationFactory Factory function for creating new instance of an
	2202	* animation.
	2203	* @description
	2204	*
	2205	* NOTE: animations take effect only if the ngAnimate module is loaded.
	2206	*
	2207	*
	2208	* Defines an animation hook that can be later used with
	2209	* {@link $animate $animate} service and directives that use this service.
	2210	*
	2211	* ```js
	2212	* module.animation('.animation-name', function($inject1, $inject2) {
	2213	* return {
	2214	* eventName : function(element, done) {
	2215	* //code to run the animation
	2216	* //once complete, then run done()
	2217	* return function cancellationFunction(element) {
	2218	* //code to cancel the animation
	2219	* }
	2220	* }
	2221	* }
	2222	* })
	2223	* ```
	2224	*
	2225	* See {@link ng.$animateProvider#register $animateProvider.register()} and
	2226	* {@link ngAnimate ngAnimate module} for more information.
	2227	*/
	2228	animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
	2229
	2230	/**
	2231	* @ngdoc method
	2232	* @name angular.Module#filter
	2233	* @module ng
	2234	* @param {string} name Filter name - this must be a valid angular expression identifier
	2235	* @param {Function} filterFactory Factory function for creating new instance of filter.
	2236	* @description
	2237	* See {@link ng.$filterProvider#register $filterProvider.register()}.
	2238	*
	2239	* <div class="alert alert-warning">
	2240	* Note: Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
	2241	* Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
	2242	* your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
	2243	* (`myapp_subsection_filterx`).
	2244	* </div>
	2245	*/
	2246	filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
	2247
	2248	/**
	2249	* @ngdoc method
	2250	* @name angular.Module#controller
	2251	* @module ng
	2252	* @param {string\|Object} name Controller name, or an object map of controllers where the
	2253	* keys are the names and the values are the constructors.
	2254	* @param {Function} constructor Controller constructor function.
	2255	* @description
	2256	* See {@link ng.$controllerProvider#register $controllerProvider.register()}.
	2257	*/
	2258	controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
	2259
	2260	/**
	2261	* @ngdoc method
	2262	* @name angular.Module#directive
	2263	* @module ng
	2264	* @param {string\|Object} name Directive name, or an object map of directives where the
	2265	* keys are the names and the values are the factories.
	2266	* @param {Function} directiveFactory Factory function for creating new instance of
	2267	* directives.
	2268	* @description
	2269	* See {@link ng.$compileProvider#directive $compileProvider.directive()}.
	2270	*/
	2271	directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
	2272
	2273	/**
	2274	* @ngdoc method
	2275	* @name angular.Module#component
	2276	* @module ng
	2277	* @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
	2278	* @param {Object} options Component definition object (a simplified
	2279	* {@link ng.$compile#directive-definition-object directive definition object})
	2280	*
	2281	* @description
	2282	* See {@link ng.$compileProvider#component $compileProvider.component()}.
	2283	*/
	2284	component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
	2285
	2286	/**
	2287	* @ngdoc method
	2288	* @name angular.Module#config
	2289	* @module ng
	2290	* @param {Function} configFn Execute this function on module load. Useful for service
	2291	* configuration.
	2292	* @description
	2293	* Use this method to register work which needs to be performed on module loading.
	2294	* For more about how to configure services, see
	2295	* {@link providers#provider-recipe Provider Recipe}.
	2296	*/
	2297	config: config,
	2298
	2299	/**
	2300	* @ngdoc method
	2301	* @name angular.Module#run
	2302	* @module ng
	2303	* @param {Function} initializationFn Execute this function after injector creation.
	2304	* Useful for application initialization.
	2305	* @description
	2306	* Use this method to register work which should be performed when the injector is done
	2307	* loading all modules.
	2308	*/
	2309	run: function(block) {
	2310	runBlocks.push(block);
	2311	return this;
	2312	}
	2313	};
	2314
	2315	if (configFn) {
	2316	config(configFn);
	2317	}
	2318
	2319	return moduleInstance;
	2320
	2321	/**
	2322	* @param {string} provider
	2323	* @param {string} method
	2324	* @param {String=} insertMethod
	2325	* @returns {angular.Module}
	2326	*/
	2327	function invokeLater(provider, method, insertMethod, queue) {
	2328	if (!queue) queue = invokeQueue;
	2329	return function() {
	2330	queue[insertMethod \|\| 'push']([provider, method, arguments]);
	2331	return moduleInstance;
	2332	};
	2333	}
	2334
	2335	/**
	2336	* @param {string} provider
	2337	* @param {string} method
	2338	* @returns {angular.Module}
	2339	*/
	2340	function invokeLaterAndSetModuleName(provider, method) {
	2341	return function(recipeName, factoryFunction) {
	2342	if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
	2343	invokeQueue.push([provider, method, arguments]);
	2344	return moduleInstance;
	2345	};
	2346	}
	2347	});
	2348	};
	2349	});
	2350
	2351	}
	2352
	2353	/* global shallowCopy: true */
	2354
	2355	/**
	2356	* Creates a shallow copy of an object, an array or a primitive.
	2357	*
	2358	* Assumes that there are no proto properties for objects.
	2359	*/
	2360	function shallowCopy(src, dst) {
	2361	if (isArray(src)) {
	2362	dst = dst \|\| [];
	2363
	2364	for (var i = 0, ii = src.length; i < ii; i++) {
	2365	dst[i] = src[i];
	2366	}
	2367	} else if (isObject(src)) {
	2368	dst = dst \|\| {};
	2369
	2370	for (var key in src) {
	2371	if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
	2372	dst[key] = src[key];
	2373	}
	2374	}
	2375	}
	2376
	2377	return dst \|\| src;
	2378	}
	2379
	2380	/* global toDebugString: true */
	2381
	2382	function serializeObject(obj) {
	2383	var seen = [];
	2384
	2385	return JSON.stringify(obj, function(key, val) {
	2386	val = toJsonReplacer(key, val);
	2387	if (isObject(val)) {
	2388
	2389	if (seen.indexOf(val) >= 0) return '...';
	2390
	2391	seen.push(val);
	2392	}
	2393	return val;
	2394	});
	2395	}
	2396
	2397	function toDebugString(obj) {
	2398	if (typeof obj === 'function') {
	2399	return obj.toString().replace(/ \{[\s\S]*$/, '');
	2400	} else if (isUndefined(obj)) {
	2401	return 'undefined';
	2402	} else if (typeof obj !== 'string') {
	2403	return serializeObject(obj);
	2404	}
	2405	return obj;
	2406	}
	2407
	2408	/* global angularModule: true,
	2409	version: true,
	2410
	2411	$CompileProvider,
	2412
	2413	htmlAnchorDirective,
	2414	inputDirective,
	2415	inputDirective,
	2416	formDirective,
	2417	scriptDirective,
	2418	selectDirective,
	2419	styleDirective,
	2420	optionDirective,
	2421	ngBindDirective,
	2422	ngBindHtmlDirective,
	2423	ngBindTemplateDirective,
	2424	ngClassDirective,
	2425	ngClassEvenDirective,
	2426	ngClassOddDirective,
	2427	ngCloakDirective,
	2428	ngControllerDirective,
	2429	ngFormDirective,
	2430	ngHideDirective,
	2431	ngIfDirective,
	2432	ngIncludeDirective,
	2433	ngIncludeFillContentDirective,
	2434	ngInitDirective,
	2435	ngNonBindableDirective,
	2436	ngPluralizeDirective,
	2437	ngRepeatDirective,
	2438	ngShowDirective,
	2439	ngStyleDirective,
	2440	ngSwitchDirective,
	2441	ngSwitchWhenDirective,
	2442	ngSwitchDefaultDirective,
	2443	ngOptionsDirective,
	2444	ngTranscludeDirective,
	2445	ngModelDirective,
	2446	ngListDirective,
	2447	ngChangeDirective,
	2448	patternDirective,
	2449	patternDirective,
	2450	requiredDirective,
	2451	requiredDirective,
	2452	minlengthDirective,
	2453	minlengthDirective,
	2454	maxlengthDirective,
	2455	maxlengthDirective,
	2456	ngValueDirective,
	2457	ngModelOptionsDirective,
	2458	ngAttributeAliasDirectives,
	2459	ngEventDirectives,
	2460
	2461	$AnchorScrollProvider,
	2462	$AnimateProvider,
	2463	$CoreAnimateCssProvider,
	2464	$$CoreAnimateJsProvider,
	2465	$$CoreAnimateQueueProvider,
	2466	$$AnimateRunnerFactoryProvider,
	2467	$$AnimateAsyncRunFactoryProvider,
	2468	$BrowserProvider,
	2469	$CacheFactoryProvider,
	2470	$ControllerProvider,
	2471	$DateProvider,
	2472	$DocumentProvider,
	2473	$ExceptionHandlerProvider,
	2474	$FilterProvider,
	2475	$$ForceReflowProvider,
	2476	$InterpolateProvider,
	2477	$IntervalProvider,
	2478	$$HashMapProvider,
	2479	$HttpProvider,
	2480	$HttpParamSerializerProvider,
	2481	$HttpParamSerializerJQLikeProvider,
	2482	$HttpBackendProvider,
	2483	$xhrFactoryProvider,
	2484	$jsonpCallbacksProvider,
	2485	$LocationProvider,
	2486	$LogProvider,
	2487	$ParseProvider,
	2488	$RootScopeProvider,
	2489	$QProvider,
	2490	$$QProvider,
	2491	$$SanitizeUriProvider,
	2492	$SceProvider,
	2493	$SceDelegateProvider,
	2494	$SnifferProvider,
	2495	$TemplateCacheProvider,
	2496	$TemplateRequestProvider,
	2497	$$TestabilityProvider,
	2498	$TimeoutProvider,
	2499	$$RAFProvider,
	2500	$WindowProvider,
	2501	$$jqLiteProvider,
	2502	$$CookieReaderProvider
	2503	*/
	2504
	2505
	2506	/**
	2507	* @ngdoc object
	2508	* @name angular.version
	2509	* @module ng
	2510	* @description
	2511	* An object that contains information about the current AngularJS version.
	2512	*
	2513	* This object has the following properties:
	2514	*
	2515	* - `full` – `{string}` – Full version string, such as "0.9.18".
	2516	* - `major` – `{number}` – Major version number, such as "0".
	2517	* - `minor` – `{number}` – Minor version number, such as "9".
	2518	* - `dot` – `{number}` – Dot version number, such as "18".
	2519	* - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
	2520	*/
	2521	var version = {
	2522	full: '1.5.8', // all of these placeholder strings will be replaced by grunt's
	2523	major: 1, // package task
	2524	minor: 5,
	2525	dot: 8,
	2526	codeName: 'arbitrary-fallbacks'
	2527	};
	2528
	2529
	2530	function publishExternalAPI(angular) {
	2531	extend(angular, {
	2532	'bootstrap': bootstrap,
	2533	'copy': copy,
	2534	'extend': extend,
	2535	'merge': merge,
	2536	'equals': equals,
	2537	'element': jqLite,
	2538	'forEach': forEach,
	2539	'injector': createInjector,
	2540	'noop': noop,
	2541	'bind': bind,
	2542	'toJson': toJson,
	2543	'fromJson': fromJson,
	2544	'identity': identity,
	2545	'isUndefined': isUndefined,
	2546	'isDefined': isDefined,
	2547	'isString': isString,
	2548	'isFunction': isFunction,
	2549	'isObject': isObject,
	2550	'isNumber': isNumber,
	2551	'isElement': isElement,
	2552	'isArray': isArray,
	2553	'version': version,
	2554	'isDate': isDate,
	2555	'lowercase': lowercase,
	2556	'uppercase': uppercase,
	2557	'callbacks': {$$counter: 0},
	2558	'getTestability': getTestability,
	2559	'$$minErr': minErr,
	2560	'$$csp': csp,
	2561	'reloadWithDebugInfo': reloadWithDebugInfo
	2562	});
	2563
	2564	angularModule = setupModuleLoader(window);
	2565
	2566	angularModule('ng', ['ngLocale'], ['$provide',
	2567	function ngModule($provide) {
	2568	// $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
	2569	$provide.provider({
	2570	$$sanitizeUri: $$SanitizeUriProvider
	2571	});
	2572	$provide.provider('$compile', $CompileProvider).
	2573	directive({
	2574	a: htmlAnchorDirective,
	2575	input: inputDirective,
	2576	textarea: inputDirective,
	2577	form: formDirective,
	2578	script: scriptDirective,
	2579	select: selectDirective,
	2580	style: styleDirective,
	2581	option: optionDirective,
	2582	ngBind: ngBindDirective,
	2583	ngBindHtml: ngBindHtmlDirective,
	2584	ngBindTemplate: ngBindTemplateDirective,
	2585	ngClass: ngClassDirective,
	2586	ngClassEven: ngClassEvenDirective,
	2587	ngClassOdd: ngClassOddDirective,
	2588	ngCloak: ngCloakDirective,
	2589	ngController: ngControllerDirective,
	2590	ngForm: ngFormDirective,
	2591	ngHide: ngHideDirective,
	2592	ngIf: ngIfDirective,
	2593	ngInclude: ngIncludeDirective,
	2594	ngInit: ngInitDirective,
	2595	ngNonBindable: ngNonBindableDirective,
	2596	ngPluralize: ngPluralizeDirective,
	2597	ngRepeat: ngRepeatDirective,
	2598	ngShow: ngShowDirective,
	2599	ngStyle: ngStyleDirective,
	2600	ngSwitch: ngSwitchDirective,
	2601	ngSwitchWhen: ngSwitchWhenDirective,
	2602	ngSwitchDefault: ngSwitchDefaultDirective,
	2603	ngOptions: ngOptionsDirective,
	2604	ngTransclude: ngTranscludeDirective,
	2605	ngModel: ngModelDirective,
	2606	ngList: ngListDirective,
	2607	ngChange: ngChangeDirective,
	2608	pattern: patternDirective,
	2609	ngPattern: patternDirective,
	2610	required: requiredDirective,
	2611	ngRequired: requiredDirective,
	2612	minlength: minlengthDirective,
	2613	ngMinlength: minlengthDirective,
	2614	maxlength: maxlengthDirective,
	2615	ngMaxlength: maxlengthDirective,
	2616	ngValue: ngValueDirective,
	2617	ngModelOptions: ngModelOptionsDirective
	2618	}).
	2619	directive({
	2620	ngInclude: ngIncludeFillContentDirective
	2621	}).
	2622	directive(ngAttributeAliasDirectives).
	2623	directive(ngEventDirectives);
	2624	$provide.provider({
	2625	$anchorScroll: $AnchorScrollProvider,
	2626	$animate: $AnimateProvider,
	2627	$animateCss: $CoreAnimateCssProvider,
	2628	$$animateJs: $$CoreAnimateJsProvider,
	2629	$$animateQueue: $$CoreAnimateQueueProvider,
	2630	$$AnimateRunner: $$AnimateRunnerFactoryProvider,
	2631	$$animateAsyncRun: $$AnimateAsyncRunFactoryProvider,
	2632	$browser: $BrowserProvider,
	2633	$cacheFactory: $CacheFactoryProvider,
	2634	$controller: $ControllerProvider,
	2635	$document: $DocumentProvider,
	2636	$exceptionHandler: $ExceptionHandlerProvider,
	2637	$filter: $FilterProvider,
	2638	$$forceReflow: $$ForceReflowProvider,
	2639	$interpolate: $InterpolateProvider,
	2640	$interval: $IntervalProvider,
	2641	$http: $HttpProvider,
	2642	$httpParamSerializer: $HttpParamSerializerProvider,
	2643	$httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
	2644	$httpBackend: $HttpBackendProvider,
	2645	$xhrFactory: $xhrFactoryProvider,
	2646	$jsonpCallbacks: $jsonpCallbacksProvider,
	2647	$location: $LocationProvider,
	2648	$log: $LogProvider,
	2649	$parse: $ParseProvider,
	2650	$rootScope: $RootScopeProvider,
	2651	$q: $QProvider,
	2652	$$q: $$QProvider,
	2653	$sce: $SceProvider,
	2654	$sceDelegate: $SceDelegateProvider,
	2655	$sniffer: $SnifferProvider,
	2656	$templateCache: $TemplateCacheProvider,
	2657	$templateRequest: $TemplateRequestProvider,
	2658	$$testability: $$TestabilityProvider,
	2659	$timeout: $TimeoutProvider,
	2660	$window: $WindowProvider,
	2661	$$rAF: $$RAFProvider,
	2662	$$jqLite: $$jqLiteProvider,
	2663	$$HashMap: $$HashMapProvider,
	2664	$$cookieReader: $$CookieReaderProvider
	2665	});
	2666	}
	2667	]);
	2668	}
	2669
	2670	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2671	* Any commits to this file should be reviewed with security in mind. *
	2672	* Changes to this file can potentially create security vulnerabilities. *
	2673	* An approval from 2 Core members with history of modifying *
	2674	* this file is required. *
	2675	* *
	2676	* Does the change somehow allow for arbitrary javascript to be executed? *
	2677	* Or allows for someone to change the prototype of built-in objects? *
	2678	* Or gives undesired access to variables likes document or window? *
	2679	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	2680
	2681	/* global JQLitePrototype: true,
	2682	addEventListenerFn: true,
	2683	removeEventListenerFn: true,
	2684	BOOLEAN_ATTR: true,
	2685	ALIASED_ATTR: true,
	2686	*/
	2687
	2688	//////////////////////////////////
	2689	//JQLite
	2690	//////////////////////////////////
	2691
	2692	/**
	2693	* @ngdoc function
	2694	* @name angular.element
	2695	* @module ng
	2696	* @kind function
	2697	*
	2698	* @description
	2699	* Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
	2700	*
	2701	* If jQuery is available, `angular.element` is an alias for the
	2702	* [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
	2703	* delegates to Angular's built-in subset of jQuery, called "jQuery lite" or jqLite.
	2704	*
	2705	* jqLite is a tiny, API-compatible subset of jQuery that allows
	2706	* Angular to manipulate the DOM in a cross-browser compatible way. jqLite implements only the most
	2707	* commonly needed functionality with the goal of having a very small footprint.
	2708	*
	2709	* To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
	2710	* {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
	2711	* specific version of jQuery if multiple versions exist on the page.
	2712	*
	2713	* <div class="alert alert-info">Note: All element references in Angular are always wrapped with jQuery or
	2714	* jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
	2715	*
	2716	* <div class="alert alert-warning">Note: Keep in mind that this function will not find elements
	2717	* by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
	2718	* or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
	2719	*
	2720	* ## Angular's jqLite
	2721	* jqLite provides only the following jQuery methods:
	2722	*
	2723	* - [`addClass()`](http://api.jquery.com/addClass/) - Does not support a function as first argument
	2724	* - [`after()`](http://api.jquery.com/after/)
	2725	* - [`append()`](http://api.jquery.com/append/)
	2726	* - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
	2727	* - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
	2728	* - [`children()`](http://api.jquery.com/children/) - Does not support selectors
	2729	* - [`clone()`](http://api.jquery.com/clone/)
	2730	* - [`contents()`](http://api.jquery.com/contents/)
	2731	* - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`.
	2732	* As a setter, does not convert numbers to strings or append 'px', and also does not have automatic property prefixing.
	2733	* - [`data()`](http://api.jquery.com/data/)
	2734	* - [`detach()`](http://api.jquery.com/detach/)
	2735	* - [`empty()`](http://api.jquery.com/empty/)
	2736	* - [`eq()`](http://api.jquery.com/eq/)
	2737	* - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
	2738	* - [`hasClass()`](http://api.jquery.com/hasClass/)
	2739	* - [`html()`](http://api.jquery.com/html/)
	2740	* - [`next()`](http://api.jquery.com/next/) - Does not support selectors
	2741	* - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
	2742	* - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
	2743	* - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
	2744	* - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
	2745	* - [`prepend()`](http://api.jquery.com/prepend/)
	2746	* - [`prop()`](http://api.jquery.com/prop/)
	2747	* - [`ready()`](http://api.jquery.com/ready/)
	2748	* - [`remove()`](http://api.jquery.com/remove/)
	2749	* - [`removeAttr()`](http://api.jquery.com/removeAttr/)
	2750	* - [`removeClass()`](http://api.jquery.com/removeClass/) - Does not support a function as first argument
	2751	* - [`removeData()`](http://api.jquery.com/removeData/)
	2752	* - [`replaceWith()`](http://api.jquery.com/replaceWith/)
	2753	* - [`text()`](http://api.jquery.com/text/)
	2754	* - [`toggleClass()`](http://api.jquery.com/toggleClass/) - Does not support a function as first argument
	2755	* - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers
	2756	* - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces or event object as parameter
	2757	* - [`val()`](http://api.jquery.com/val/)
	2758	* - [`wrap()`](http://api.jquery.com/wrap/)
	2759	*
	2760	* ## jQuery/jqLite Extras
	2761	* Angular also provides the following additional methods and events to both jQuery and jqLite:
	2762	*
	2763	* ### Events
	2764	* - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
	2765	* on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM
	2766	* element before it is removed.
	2767	*
	2768	* ### Methods
	2769	* - `controller(name)` - retrieves the controller of the current element or its parent. By default
	2770	* retrieves controller associated with the `ngController` directive. If `name` is provided as
	2771	* camelCase directive name, then the controller for this directive will be retrieved (e.g.
	2772	* `'ngModel'`).
	2773	* - `injector()` - retrieves the injector of the current element or its parent.
	2774	* - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
	2775	* element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
	2776	* be enabled.
	2777	* - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
	2778	* current element. This getter should be used only on elements that contain a directive which starts a new isolate
	2779	* scope. Calling `scope()` on this element always returns the original non-isolate scope.
	2780	* Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
	2781	* - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
	2782	* parent element is reached.
	2783	*
	2784	* @knownIssue You cannot spy on `angular.element` if you are using Jasmine version 1.x. See
	2785	* https://github.com/angular/angular.js/issues/14251 for more information.
	2786	*
	2787	* @param {string\|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
	2788	* @returns {Object} jQuery object.
	2789	*/
	2790
	2791	JQLite.expando = 'ng339';
	2792
	2793	var jqCache = JQLite.cache = {},
	2794	jqId = 1,
	2795	addEventListenerFn = function(element, type, fn) {
	2796	element.addEventListener(type, fn, false);
	2797	},
	2798	removeEventListenerFn = function(element, type, fn) {
	2799	element.removeEventListener(type, fn, false);
	2800	};
	2801
	2802	/*
	2803	* !!! This is an undocumented "private" function !!!
	2804	*/
	2805	JQLite._data = function(node) {
	2806	//jQuery always returns an object on cache miss
	2807	return this.cache[node[this.expando]] \|\| {};
	2808	};
	2809
	2810	function jqNextId() { return ++jqId; }
	2811
	2812
	2813	var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
	2814	var MOZ_HACK_REGEXP = /^moz([A-Z])/;
	2815	var MOUSE_EVENT_MAP= { mouseleave: "mouseout", mouseenter: "mouseover"};
	2816	var jqLiteMinErr = minErr('jqLite');
	2817
	2818	/**
	2819	* Converts snake_case to camelCase.
	2820	* Also there is special case for Moz prefix starting with upper case letter.
	2821	* @param name Name to normalize
	2822	*/
	2823	function camelCase(name) {
	2824	return name.
	2825	replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
	2826	return offset ? letter.toUpperCase() : letter;
	2827	}).
	2828	replace(MOZ_HACK_REGEXP, 'Moz$1');
	2829	}
	2830
	2831	var SINGLE_TAG_REGEXP = /^<([\w-]+)\s*\/?>(?:<\/\1>\|)$/;
	2832	var HTML_REGEXP = /<\|&#?\w+;/;
	2833	var TAG_NAME_REGEXP = /<([\w:-]+)/;
	2834	var XHTML_TAG_REGEXP = /<(?!area\|br\|col\|embed\|hr\|img\|input\|link\|meta\|param)(([\w:-]+)[^>]*)\/>/gi;
	2835
	2836	var wrapMap = {
	2837	'option': [1, '<select multiple="multiple">', '</select>'],
	2838
	2839	'thead': [1, '<table>', '</table>'],
	2840	'col': [2, '<table><colgroup>', '</colgroup></table>'],
	2841	'tr': [2, '<table><tbody>', '</tbody></table>'],
	2842	'td': [3, '<table><tbody><tr>', '</tr></tbody></table>'],
	2843	'_default': [0, "", ""]
	2844	};
	2845
	2846	wrapMap.optgroup = wrapMap.option;
	2847	wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
	2848	wrapMap.th = wrapMap.td;
	2849
	2850
	2851	function jqLiteIsTextNode(html) {
	2852	return !HTML_REGEXP.test(html);
	2853	}
	2854
	2855	function jqLiteAcceptsData(node) {
	2856	// The window object can accept data but has no nodeType
	2857	// Otherwise we are only interested in elements (1) and documents (9)
	2858	var nodeType = node.nodeType;
	2859	return nodeType === NODE_TYPE_ELEMENT \|\| !nodeType \|\| nodeType === NODE_TYPE_DOCUMENT;
	2860	}
	2861
	2862	function jqLiteHasData(node) {
	2863	for (var key in jqCache[node.ng339]) {
	2864	return true;
	2865	}
	2866	return false;
	2867	}
	2868
	2869	function jqLiteCleanData(nodes) {
	2870	for (var i = 0, ii = nodes.length; i < ii; i++) {
	2871	jqLiteRemoveData(nodes[i]);
	2872	}
	2873	}
	2874
	2875	function jqLiteBuildFragment(html, context) {
	2876	var tmp, tag, wrap,
	2877	fragment = context.createDocumentFragment(),
	2878	nodes = [], i;
	2879
	2880	if (jqLiteIsTextNode(html)) {
	2881	// Convert non-html into a text node
	2882	nodes.push(context.createTextNode(html));
	2883	} else {
	2884	// Convert html into DOM nodes
	2885	tmp = fragment.appendChild(context.createElement("div"));
	2886	tag = (TAG_NAME_REGEXP.exec(html) \|\| ["", ""])[1].toLowerCase();
	2887	wrap = wrapMap[tag] \|\| wrapMap._default;
	2888	tmp.innerHTML = wrap[1] + html.replace(XHTML_TAG_REGEXP, "<$1></$2>") + wrap[2];
	2889
	2890	// Descend through wrappers to the right content
	2891	i = wrap[0];
	2892	while (i--) {
	2893	tmp = tmp.lastChild;
	2894	}
	2895
	2896	nodes = concat(nodes, tmp.childNodes);
	2897
	2898	tmp = fragment.firstChild;
	2899	tmp.textContent = "";
	2900	}
	2901
	2902	// Remove wrapper from fragment
	2903	fragment.textContent = "";
	2904	fragment.innerHTML = ""; // Clear inner HTML
	2905	forEach(nodes, function(node) {
	2906	fragment.appendChild(node);
	2907	});
	2908
	2909	return fragment;
	2910	}
	2911
	2912	function jqLiteParseHTML(html, context) {
	2913	context = context \|\| window.document;
	2914	var parsed;
	2915
	2916	if ((parsed = SINGLE_TAG_REGEXP.exec(html))) {
	2917	return [context.createElement(parsed[1])];
	2918	}
	2919
	2920	if ((parsed = jqLiteBuildFragment(html, context))) {
	2921	return parsed.childNodes;
	2922	}
	2923
	2924	return [];
	2925	}
	2926
	2927	function jqLiteWrapNode(node, wrapper) {
	2928	var parent = node.parentNode;
	2929
	2930	if (parent) {
	2931	parent.replaceChild(wrapper, node);
	2932	}
	2933
	2934	wrapper.appendChild(node);
	2935	}
	2936
	2937
	2938	// IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
	2939	var jqLiteContains = window.Node.prototype.contains \|\| function(arg) {
	2940	// jshint bitwise: false
	2941	return !!(this.compareDocumentPosition(arg) & 16);
	2942	// jshint bitwise: true
	2943	};
	2944
	2945	/////////////////////////////////////////////
	2946	function JQLite(element) {
	2947	if (element instanceof JQLite) {
	2948	return element;
	2949	}
	2950
	2951	var argIsString;
	2952
	2953	if (isString(element)) {
	2954	element = trim(element);
	2955	argIsString = true;
	2956	}
	2957	if (!(this instanceof JQLite)) {
	2958	if (argIsString && element.charAt(0) != '<') {
	2959	throw jqLiteMinErr('nosel', 'Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element');
	2960	}
	2961	return new JQLite(element);
	2962	}
	2963
	2964	if (argIsString) {
	2965	jqLiteAddNodes(this, jqLiteParseHTML(element));
	2966	} else {
	2967	jqLiteAddNodes(this, element);
	2968	}
	2969	}
	2970
	2971	function jqLiteClone(element) {
	2972	return element.cloneNode(true);
	2973	}
	2974
	2975	function jqLiteDealoc(element, onlyDescendants) {
	2976	if (!onlyDescendants) jqLiteRemoveData(element);
	2977
	2978	if (element.querySelectorAll) {
	2979	var descendants = element.querySelectorAll('*');
	2980	for (var i = 0, l = descendants.length; i < l; i++) {
	2981	jqLiteRemoveData(descendants[i]);
	2982	}
	2983	}
	2984	}
	2985
	2986	function jqLiteOff(element, type, fn, unsupported) {
	2987	if (isDefined(unsupported)) throw jqLiteMinErr('offargs', 'jqLite#off() does not support the `selector` argument');
	2988
	2989	var expandoStore = jqLiteExpandoStore(element);
	2990	var events = expandoStore && expandoStore.events;
	2991	var handle = expandoStore && expandoStore.handle;
	2992
	2993	if (!handle) return; //no listeners registered
	2994
	2995	if (!type) {
	2996	for (type in events) {
	2997	if (type !== '$destroy') {
	2998	removeEventListenerFn(element, type, handle);
	2999	}
	3000	delete events[type];
	3001	}
	3002	} else {
	3003
	3004	var removeHandler = function(type) {
	3005	var listenerFns = events[type];
	3006	if (isDefined(fn)) {
	3007	arrayRemove(listenerFns \|\| [], fn);
	3008	}
	3009	if (!(isDefined(fn) && listenerFns && listenerFns.length > 0)) {
	3010	removeEventListenerFn(element, type, handle);
	3011	delete events[type];
	3012	}
	3013	};
	3014
	3015	forEach(type.split(' '), function(type) {
	3016	removeHandler(type);
	3017	if (MOUSE_EVENT_MAP[type]) {
	3018	removeHandler(MOUSE_EVENT_MAP[type]);
	3019	}
	3020	});
	3021	}
	3022	}
	3023
	3024	function jqLiteRemoveData(element, name) {
	3025	var expandoId = element.ng339;
	3026	var expandoStore = expandoId && jqCache[expandoId];
	3027
	3028	if (expandoStore) {
	3029	if (name) {
	3030	delete expandoStore.data[name];
	3031	return;
	3032	}
	3033
	3034	if (expandoStore.handle) {
	3035	if (expandoStore.events.$destroy) {
	3036	expandoStore.handle({}, '$destroy');
	3037	}
	3038	jqLiteOff(element);
	3039	}
	3040	delete jqCache[expandoId];
	3041	element.ng339 = undefined; // don't delete DOM expandos. IE and Chrome don't like it
	3042	}
	3043	}
	3044
	3045
	3046	function jqLiteExpandoStore(element, createIfNecessary) {
	3047	var expandoId = element.ng339,
	3048	expandoStore = expandoId && jqCache[expandoId];
	3049
	3050	if (createIfNecessary && !expandoStore) {
	3051	element.ng339 = expandoId = jqNextId();
	3052	expandoStore = jqCache[expandoId] = {events: {}, data: {}, handle: undefined};
	3053	}
	3054
	3055	return expandoStore;
	3056	}
	3057
	3058
	3059	function jqLiteData(element, key, value) {
	3060	if (jqLiteAcceptsData(element)) {
	3061
	3062	var isSimpleSetter = isDefined(value);
	3063	var isSimpleGetter = !isSimpleSetter && key && !isObject(key);
	3064	var massGetter = !key;
	3065	var expandoStore = jqLiteExpandoStore(element, !isSimpleGetter);
	3066	var data = expandoStore && expandoStore.data;
	3067
	3068	if (isSimpleSetter) { // data('key', value)
	3069	data[key] = value;
	3070	} else {
	3071	if (massGetter) { // data()
	3072	return data;
	3073	} else {
	3074	if (isSimpleGetter) { // data('key')
	3075	// don't force creation of expandoStore if it doesn't exist yet
	3076	return data && data[key];
	3077	} else { // mass-setter: data({key1: val1, key2: val2})
	3078	extend(data, key);
	3079	}
	3080	}
	3081	}
	3082	}
	3083	}
	3084
	3085	function jqLiteHasClass(element, selector) {
	3086	if (!element.getAttribute) return false;
	3087	return ((" " + (element.getAttribute('class') \|\| '') + " ").replace(/[\n\t]/g, " ").
	3088	indexOf(" " + selector + " ") > -1);
	3089	}
	3090
	3091	function jqLiteRemoveClass(element, cssClasses) {
	3092	if (cssClasses && element.setAttribute) {
	3093	forEach(cssClasses.split(' '), function(cssClass) {
	3094	element.setAttribute('class', trim(
	3095	(" " + (element.getAttribute('class') \|\| '') + " ")
	3096	.replace(/[\n\t]/g, " ")
	3097	.replace(" " + trim(cssClass) + " ", " "))
	3098	);
	3099	});
	3100	}
	3101	}
	3102
	3103	function jqLiteAddClass(element, cssClasses) {
	3104	if (cssClasses && element.setAttribute) {
	3105	var existingClasses = (' ' + (element.getAttribute('class') \|\| '') + ' ')
	3106	.replace(/[\n\t]/g, " ");
	3107
	3108	forEach(cssClasses.split(' '), function(cssClass) {
	3109	cssClass = trim(cssClass);
	3110	if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) {
	3111	existingClasses += cssClass + ' ';
	3112	}
	3113	});
	3114
	3115	element.setAttribute('class', trim(existingClasses));
	3116	}
	3117	}
	3118
	3119
	3120	function jqLiteAddNodes(root, elements) {
	3121	// THIS CODE IS VERY HOT. Don't make changes without benchmarking.
	3122
	3123	if (elements) {
	3124
	3125	// if a Node (the most common case)
	3126	if (elements.nodeType) {
	3127	root[root.length++] = elements;
	3128	} else {
	3129	var length = elements.length;
	3130
	3131	// if an Array or NodeList and not a Window
	3132	if (typeof length === 'number' && elements.window !== elements) {
	3133	if (length) {
	3134	for (var i = 0; i < length; i++) {
	3135	root[root.length++] = elements[i];
	3136	}
	3137	}
	3138	} else {
	3139	root[root.length++] = elements;
	3140	}
	3141	}
	3142	}
	3143	}
	3144
	3145
	3146	function jqLiteController(element, name) {
	3147	return jqLiteInheritedData(element, '$' + (name \|\| 'ngController') + 'Controller');
	3148	}
	3149
	3150	function jqLiteInheritedData(element, name, value) {
	3151	// if element is the document object work with the html element instead
	3152	// this makes $(document).scope() possible
	3153	if (element.nodeType == NODE_TYPE_DOCUMENT) {
	3154	element = element.documentElement;
	3155	}
	3156	var names = isArray(name) ? name : [name];
	3157
	3158	while (element) {
	3159	for (var i = 0, ii = names.length; i < ii; i++) {
	3160	if (isDefined(value = jqLite.data(element, names[i]))) return value;
	3161	}
	3162
	3163	// If dealing with a document fragment node with a host element, and no parent, use the host
	3164	// element as the parent. This enables directives within a Shadow DOM or polyfilled Shadow DOM
	3165	// to lookup parent controllers.
	3166	element = element.parentNode \|\| (element.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && element.host);
	3167	}
	3168	}
	3169
	3170	function jqLiteEmpty(element) {
	3171	jqLiteDealoc(element, true);
	3172	while (element.firstChild) {
	3173	element.removeChild(element.firstChild);
	3174	}
	3175	}
	3176
	3177	function jqLiteRemove(element, keepData) {
	3178	if (!keepData) jqLiteDealoc(element);
	3179	var parent = element.parentNode;
	3180	if (parent) parent.removeChild(element);
	3181	}
	3182
	3183
	3184	function jqLiteDocumentLoaded(action, win) {
	3185	win = win \|\| window;
	3186	if (win.document.readyState === 'complete') {
	3187	// Force the action to be run async for consistent behavior
	3188	// from the action's point of view
	3189	// i.e. it will definitely not be in a $apply
	3190	win.setTimeout(action);
	3191	} else {
	3192	// No need to unbind this handler as load is only ever called once
	3193	jqLite(win).on('load', action);
	3194	}
	3195	}
	3196
	3197	//////////////////////////////////////////
	3198	// Functions which are declared directly.
	3199	//////////////////////////////////////////
	3200	var JQLitePrototype = JQLite.prototype = {
	3201	ready: function(fn) {
	3202	var fired = false;
	3203
	3204	function trigger() {
	3205	if (fired) return;
	3206	fired = true;
	3207	fn();
	3208	}
	3209
	3210	// check if document is already loaded
	3211	if (window.document.readyState === 'complete') {
	3212	window.setTimeout(trigger);
	3213	} else {
	3214	this.on('DOMContentLoaded', trigger); // works for modern browsers and IE9
	3215	// we can not use jqLite since we are not done loading and jQuery could be loaded later.
	3216	// jshint -W064
	3217	JQLite(window).on('load', trigger); // fallback to window.onload for others
	3218	// jshint +W064
	3219	}
	3220	},
	3221	toString: function() {
	3222	var value = [];
	3223	forEach(this, function(e) { value.push('' + e);});
	3224	return '[' + value.join(', ') + ']';
	3225	},
	3226
	3227	eq: function(index) {
	3228	return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);
	3229	},
	3230
	3231	length: 0,
	3232	push: push,
	3233	sort: [].sort,
	3234	splice: [].splice
	3235	};
	3236
	3237	//////////////////////////////////////////
	3238	// Functions iterating getter/setters.
	3239	// these functions return self on setter and
	3240	// value on get.
	3241	//////////////////////////////////////////
	3242	var BOOLEAN_ATTR = {};
	3243	forEach('multiple,selected,checked,disabled,readOnly,required,open'.split(','), function(value) {
	3244	BOOLEAN_ATTR[lowercase(value)] = value;
	3245	});
	3246	var BOOLEAN_ELEMENTS = {};
	3247	forEach('input,select,option,textarea,button,form,details'.split(','), function(value) {
	3248	BOOLEAN_ELEMENTS[value] = true;
	3249	});
	3250	var ALIASED_ATTR = {
	3251	'ngMinlength': 'minlength',
	3252	'ngMaxlength': 'maxlength',
	3253	'ngMin': 'min',
	3254	'ngMax': 'max',
	3255	'ngPattern': 'pattern'
	3256	};
	3257
	3258	function getBooleanAttrName(element, name) {
	3259	// check dom last since we will most likely fail on name
	3260	var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
	3261
	3262	// booleanAttr is here twice to minimize DOM access
	3263	return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr;
	3264	}
	3265
	3266	function getAliasedAttrName(name) {
	3267	return ALIASED_ATTR[name];
	3268	}
	3269
	3270	forEach({
	3271	data: jqLiteData,
	3272	removeData: jqLiteRemoveData,
	3273	hasData: jqLiteHasData,
	3274	cleanData: jqLiteCleanData
	3275	}, function(fn, name) {
	3276	JQLite[name] = fn;
	3277	});
	3278
	3279	forEach({
	3280	data: jqLiteData,
	3281	inheritedData: jqLiteInheritedData,
	3282
	3283	scope: function(element) {
	3284	// Can't use jqLiteData here directly so we stay compatible with jQuery!
	3285	return jqLite.data(element, '$scope') \|\| jqLiteInheritedData(element.parentNode \|\| element, ['$isolateScope', '$scope']);
	3286	},
	3287
	3288	isolateScope: function(element) {
	3289	// Can't use jqLiteData here directly so we stay compatible with jQuery!
	3290	return jqLite.data(element, '$isolateScope') \|\| jqLite.data(element, '$isolateScopeNoTemplate');
	3291	},
	3292
	3293	controller: jqLiteController,
	3294
	3295	injector: function(element) {
	3296	return jqLiteInheritedData(element, '$injector');
	3297	},
	3298
	3299	removeAttr: function(element, name) {
	3300	element.removeAttribute(name);
	3301	},
	3302
	3303	hasClass: jqLiteHasClass,
	3304
	3305	css: function(element, name, value) {
	3306	name = camelCase(name);
	3307
	3308	if (isDefined(value)) {
	3309	element.style[name] = value;
	3310	} else {
	3311	return element.style[name];
	3312	}
	3313	},
	3314
	3315	attr: function(element, name, value) {
	3316	var nodeType = element.nodeType;
	3317	if (nodeType === NODE_TYPE_TEXT \|\| nodeType === NODE_TYPE_ATTRIBUTE \|\| nodeType === NODE_TYPE_COMMENT) {
	3318	return;
	3319	}
	3320	var lowercasedName = lowercase(name);
	3321	if (BOOLEAN_ATTR[lowercasedName]) {
	3322	if (isDefined(value)) {
	3323	if (!!value) {
	3324	element[name] = true;
	3325	element.setAttribute(name, lowercasedName);
	3326	} else {
	3327	element[name] = false;
	3328	element.removeAttribute(lowercasedName);
	3329	}
	3330	} else {
	3331	return (element[name] \|\|
	3332	(element.attributes.getNamedItem(name) \|\| noop).specified)
	3333	? lowercasedName
	3334	: undefined;
	3335	}
	3336	} else if (isDefined(value)) {
	3337	element.setAttribute(name, value);
	3338	} else if (element.getAttribute) {
	3339	// the extra argument "2" is to get the right thing for a.href in IE, see jQuery code
	3340	// some elements (e.g. Document) don't have get attribute, so return undefined
	3341	var ret = element.getAttribute(name, 2);
	3342	// normalize non-existing attributes to undefined (as jQuery)
	3343	return ret === null ? undefined : ret;
	3344	}
	3345	},
	3346
	3347	prop: function(element, name, value) {
	3348	if (isDefined(value)) {
	3349	element[name] = value;
	3350	} else {
	3351	return element[name];
	3352	}
	3353	},
	3354
	3355	text: (function() {
	3356	getText.$dv = '';
	3357	return getText;
	3358
	3359	function getText(element, value) {
	3360	if (isUndefined(value)) {
	3361	var nodeType = element.nodeType;
	3362	return (nodeType === NODE_TYPE_ELEMENT \|\| nodeType === NODE_TYPE_TEXT) ? element.textContent : '';
	3363	}
	3364	element.textContent = value;
	3365	}
	3366	})(),
	3367
	3368	val: function(element, value) {
	3369	if (isUndefined(value)) {
	3370	if (element.multiple && nodeName_(element) === 'select') {
	3371	var result = [];
	3372	forEach(element.options, function(option) {
	3373	if (option.selected) {
	3374	result.push(option.value \|\| option.text);
	3375	}
	3376	});
	3377	return result.length === 0 ? null : result;
	3378	}
	3379	return element.value;
	3380	}
	3381	element.value = value;
	3382	},
	3383
	3384	html: function(element, value) {
	3385	if (isUndefined(value)) {
	3386	return element.innerHTML;
	3387	}
	3388	jqLiteDealoc(element, true);
	3389	element.innerHTML = value;
	3390	},
	3391
	3392	empty: jqLiteEmpty
	3393	}, function(fn, name) {
	3394	/**
	3395	* Properties: writes return selection, reads return first value
	3396	*/
	3397	JQLite.prototype[name] = function(arg1, arg2) {
	3398	var i, key;
	3399	var nodeCount = this.length;
	3400
	3401	// jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
	3402	// in a way that survives minification.
	3403	// jqLiteEmpty takes no arguments but is a setter.
	3404	if (fn !== jqLiteEmpty &&
	3405	(isUndefined((fn.length == 2 && (fn !== jqLiteHasClass && fn !== jqLiteController)) ? arg1 : arg2))) {
	3406	if (isObject(arg1)) {
	3407
	3408	// we are a write, but the object properties are the key/values
	3409	for (i = 0; i < nodeCount; i++) {
	3410	if (fn === jqLiteData) {
	3411	// data() takes the whole object in jQuery
	3412	fn(this[i], arg1);
	3413	} else {
	3414	for (key in arg1) {
	3415	fn(this[i], key, arg1[key]);
	3416	}
	3417	}
	3418	}
	3419	// return self for chaining
	3420	return this;
	3421	} else {
	3422	// we are a read, so read the first child.
	3423	// TODO: do we still need this?
	3424	var value = fn.$dv;
	3425	// Only if we have $dv do we iterate over all, otherwise it is just the first element.
	3426	var jj = (isUndefined(value)) ? Math.min(nodeCount, 1) : nodeCount;
	3427	for (var j = 0; j < jj; j++) {
	3428	var nodeValue = fn(this[j], arg1, arg2);
	3429	value = value ? value + nodeValue : nodeValue;
	3430	}
	3431	return value;
	3432	}
	3433	} else {
	3434	// we are a write, so apply to all children
	3435	for (i = 0; i < nodeCount; i++) {
	3436	fn(this[i], arg1, arg2);
	3437	}
	3438	// return self for chaining
	3439	return this;
	3440	}
	3441	};
	3442	});
	3443
	3444	function createEventHandler(element, events) {
	3445	var eventHandler = function(event, type) {
	3446	// jQuery specific api
	3447	event.isDefaultPrevented = function() {
	3448	return event.defaultPrevented;
	3449	};
	3450
	3451	var eventFns = events[type \|\| event.type];
	3452	var eventFnsLength = eventFns ? eventFns.length : 0;
	3453
	3454	if (!eventFnsLength) return;
	3455
	3456	if (isUndefined(event.immediatePropagationStopped)) {
	3457	var originalStopImmediatePropagation = event.stopImmediatePropagation;
	3458	event.stopImmediatePropagation = function() {
	3459	event.immediatePropagationStopped = true;
	3460
	3461	if (event.stopPropagation) {
	3462	event.stopPropagation();
	3463	}
	3464
	3465	if (originalStopImmediatePropagation) {
	3466	originalStopImmediatePropagation.call(event);
	3467	}
	3468	};
	3469	}
	3470
	3471	event.isImmediatePropagationStopped = function() {
	3472	return event.immediatePropagationStopped === true;
	3473	};
	3474
	3475	// Some events have special handlers that wrap the real handler
	3476	var handlerWrapper = eventFns.specialHandlerWrapper \|\| defaultHandlerWrapper;
	3477
	3478	// Copy event handlers in case event handlers array is modified during execution.
	3479	if ((eventFnsLength > 1)) {
	3480	eventFns = shallowCopy(eventFns);
	3481	}
	3482
	3483	for (var i = 0; i < eventFnsLength; i++) {
	3484	if (!event.isImmediatePropagationStopped()) {
	3485	handlerWrapper(element, event, eventFns[i]);
	3486	}
	3487	}
	3488	};
	3489
	3490	// TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
	3491	// events on `element`
	3492	eventHandler.elem = element;
	3493	return eventHandler;
	3494	}
	3495
	3496	function defaultHandlerWrapper(element, event, handler) {
	3497	handler.call(element, event);
	3498	}
	3499
	3500	function specialMouseHandlerWrapper(target, event, handler) {
	3501	// Refer to jQuery's implementation of mouseenter & mouseleave
	3502	// Read about mouseenter and mouseleave:
	3503	// http://www.quirksmode.org/js/events_mouse.html#link8
	3504	var related = event.relatedTarget;
	3505	// For mousenter/leave call the handler if related is outside the target.
	3506	// NB: No relatedTarget if the mouse left/entered the browser window
	3507	if (!related \|\| (related !== target && !jqLiteContains.call(target, related))) {
	3508	handler.call(target, event);
	3509	}
	3510	}
	3511
	3512	//////////////////////////////////////////
	3513	// Functions iterating traversal.
	3514	// These functions chain results into a single
	3515	// selector.
	3516	//////////////////////////////////////////
	3517	forEach({
	3518	removeData: jqLiteRemoveData,
	3519
	3520	on: function jqLiteOn(element, type, fn, unsupported) {
	3521	if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters');
	3522
	3523	// Do not add event handlers to non-elements because they will not be cleaned up.
	3524	if (!jqLiteAcceptsData(element)) {
	3525	return;
	3526	}
	3527
	3528	var expandoStore = jqLiteExpandoStore(element, true);
	3529	var events = expandoStore.events;
	3530	var handle = expandoStore.handle;
	3531
	3532	if (!handle) {
	3533	handle = expandoStore.handle = createEventHandler(element, events);
	3534	}
	3535
	3536	// http://jsperf.com/string-indexof-vs-split
	3537	var types = type.indexOf(' ') >= 0 ? type.split(' ') : [type];
	3538	var i = types.length;
	3539
	3540	var addHandler = function(type, specialHandlerWrapper, noEventListener) {
	3541	var eventFns = events[type];
	3542
	3543	if (!eventFns) {
	3544	eventFns = events[type] = [];
	3545	eventFns.specialHandlerWrapper = specialHandlerWrapper;
	3546	if (type !== '$destroy' && !noEventListener) {
	3547	addEventListenerFn(element, type, handle);
	3548	}
	3549	}
	3550
	3551	eventFns.push(fn);
	3552	};
	3553
	3554	while (i--) {
	3555	type = types[i];
	3556	if (MOUSE_EVENT_MAP[type]) {
	3557	addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
	3558	addHandler(type, undefined, true);
	3559	} else {
	3560	addHandler(type);
	3561	}
	3562	}
	3563	},
	3564
	3565	off: jqLiteOff,
	3566
	3567	one: function(element, type, fn) {
	3568	element = jqLite(element);
	3569
	3570	//add the listener twice so that when it is called
	3571	//you can remove the original function and still be
	3572	//able to call element.off(ev, fn) normally
	3573	element.on(type, function onFn() {
	3574	element.off(type, fn);
	3575	element.off(type, onFn);
	3576	});
	3577	element.on(type, fn);
	3578	},
	3579
	3580	replaceWith: function(element, replaceNode) {
	3581	var index, parent = element.parentNode;
	3582	jqLiteDealoc(element);
	3583	forEach(new JQLite(replaceNode), function(node) {
	3584	if (index) {
	3585	parent.insertBefore(node, index.nextSibling);
	3586	} else {
	3587	parent.replaceChild(node, element);
	3588	}
	3589	index = node;
	3590	});
	3591	},
	3592
	3593	children: function(element) {
	3594	var children = [];
	3595	forEach(element.childNodes, function(element) {
	3596	if (element.nodeType === NODE_TYPE_ELEMENT) {
	3597	children.push(element);
	3598	}
	3599	});
	3600	return children;
	3601	},
	3602
	3603	contents: function(element) {
	3604	return element.contentDocument \|\| element.childNodes \|\| [];
	3605	},
	3606
	3607	append: function(element, node) {
	3608	var nodeType = element.nodeType;
	3609	if (nodeType !== NODE_TYPE_ELEMENT && nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT) return;
	3610
	3611	node = new JQLite(node);
	3612
	3613	for (var i = 0, ii = node.length; i < ii; i++) {
	3614	var child = node[i];
	3615	element.appendChild(child);
	3616	}
	3617	},
	3618
	3619	prepend: function(element, node) {
	3620	if (element.nodeType === NODE_TYPE_ELEMENT) {
	3621	var index = element.firstChild;
	3622	forEach(new JQLite(node), function(child) {
	3623	element.insertBefore(child, index);
	3624	});
	3625	}
	3626	},
	3627
	3628	wrap: function(element, wrapNode) {
	3629	jqLiteWrapNode(element, jqLite(wrapNode).eq(0).clone()[0]);
	3630	},
	3631
	3632	remove: jqLiteRemove,
	3633
	3634	detach: function(element) {
	3635	jqLiteRemove(element, true);
	3636	},
	3637
	3638	after: function(element, newElement) {
	3639	var index = element, parent = element.parentNode;
	3640	newElement = new JQLite(newElement);
	3641
	3642	for (var i = 0, ii = newElement.length; i < ii; i++) {
	3643	var node = newElement[i];
	3644	parent.insertBefore(node, index.nextSibling);
	3645	index = node;
	3646	}
	3647	},
	3648
	3649	addClass: jqLiteAddClass,
	3650	removeClass: jqLiteRemoveClass,
	3651
	3652	toggleClass: function(element, selector, condition) {
	3653	if (selector) {
	3654	forEach(selector.split(' '), function(className) {
	3655	var classCondition = condition;
	3656	if (isUndefined(classCondition)) {
	3657	classCondition = !jqLiteHasClass(element, className);
	3658	}
	3659	(classCondition ? jqLiteAddClass : jqLiteRemoveClass)(element, className);
	3660	});
	3661	}
	3662	},
	3663
	3664	parent: function(element) {
	3665	var parent = element.parentNode;
	3666	return parent && parent.nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT ? parent : null;
	3667	},
	3668
	3669	next: function(element) {
	3670	return element.nextElementSibling;
	3671	},
	3672
	3673	find: function(element, selector) {
	3674	if (element.getElementsByTagName) {
	3675	return element.getElementsByTagName(selector);
	3676	} else {
	3677	return [];
	3678	}
	3679	},
	3680
	3681	clone: jqLiteClone,
	3682
	3683	triggerHandler: function(element, event, extraParameters) {
	3684
	3685	var dummyEvent, eventFnsCopy, handlerArgs;
	3686	var eventName = event.type \|\| event;
	3687	var expandoStore = jqLiteExpandoStore(element);
	3688	var events = expandoStore && expandoStore.events;
	3689	var eventFns = events && events[eventName];
	3690
	3691	if (eventFns) {
	3692	// Create a dummy event to pass to the handlers
	3693	dummyEvent = {
	3694	preventDefault: function() { this.defaultPrevented = true; },
	3695	isDefaultPrevented: function() { return this.defaultPrevented === true; },
	3696	stopImmediatePropagation: function() { this.immediatePropagationStopped = true; },
	3697	isImmediatePropagationStopped: function() { return this.immediatePropagationStopped === true; },
	3698	stopPropagation: noop,
	3699	type: eventName,
	3700	target: element
	3701	};
	3702
	3703	// If a custom event was provided then extend our dummy event with it
	3704	if (event.type) {
	3705	dummyEvent = extend(dummyEvent, event);
	3706	}
	3707
	3708	// Copy event handlers in case event handlers array is modified during execution.
	3709	eventFnsCopy = shallowCopy(eventFns);
	3710	handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent];
	3711
	3712	forEach(eventFnsCopy, function(fn) {
	3713	if (!dummyEvent.isImmediatePropagationStopped()) {
	3714	fn.apply(element, handlerArgs);
	3715	}
	3716	});
	3717	}
	3718	}
	3719	}, function(fn, name) {
	3720	/**
	3721	* chaining functions
	3722	*/
	3723	JQLite.prototype[name] = function(arg1, arg2, arg3) {
	3724	var value;
	3725
	3726	for (var i = 0, ii = this.length; i < ii; i++) {
	3727	if (isUndefined(value)) {
	3728	value = fn(this[i], arg1, arg2, arg3);
	3729	if (isDefined(value)) {
	3730	// any function which returns a value needs to be wrapped
	3731	value = jqLite(value);
	3732	}
	3733	} else {
	3734	jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
	3735	}
	3736	}
	3737	return isDefined(value) ? value : this;
	3738	};
	3739
	3740	// bind legacy bind/unbind to on/off
	3741	JQLite.prototype.bind = JQLite.prototype.on;
	3742	JQLite.prototype.unbind = JQLite.prototype.off;
	3743	});
	3744
	3745
	3746	// Provider for private $$jqLite service
	3747	function $$jqLiteProvider() {
	3748	this.$get = function $$jqLite() {
	3749	return extend(JQLite, {
	3750	hasClass: function(node, classes) {
	3751	if (node.attr) node = node[0];
	3752	return jqLiteHasClass(node, classes);
	3753	},
	3754	addClass: function(node, classes) {
	3755	if (node.attr) node = node[0];
	3756	return jqLiteAddClass(node, classes);
	3757	},
	3758	removeClass: function(node, classes) {
	3759	if (node.attr) node = node[0];
	3760	return jqLiteRemoveClass(node, classes);
	3761	}
	3762	});
	3763	};
	3764	}
	3765
	3766	/**
	3767	* Computes a hash of an 'obj'.
	3768	* Hash of a:
	3769	* string is string
	3770	* number is number as string
	3771	* object is either result of calling $$hashKey function on the object or uniquely generated id,
	3772	* that is also assigned to the $$hashKey property of the object.
	3773	*
	3774	* @param obj
	3775	* @returns {string} hash string such that the same input will have the same hash string.
	3776	* The resulting string key is in 'type:hashKey' format.
	3777	*/
	3778	function hashKey(obj, nextUidFn) {
	3779	var key = obj && obj.$$hashKey;
	3780
	3781	if (key) {
	3782	if (typeof key === 'function') {
	3783	key = obj.$$hashKey();
	3784	}
	3785	return key;
	3786	}
	3787
	3788	var objType = typeof obj;
	3789	if (objType == 'function' \|\| (objType == 'object' && obj !== null)) {
	3790	key = obj.$$hashKey = objType + ':' + (nextUidFn \|\| nextUid)();
	3791	} else {
	3792	key = objType + ':' + obj;
	3793	}
	3794
	3795	return key;
	3796	}
	3797
	3798	/**
	3799	* HashMap which can use objects as keys
	3800	*/
	3801	function HashMap(array, isolatedUid) {
	3802	if (isolatedUid) {
	3803	var uid = 0;
	3804	this.nextUid = function() {
	3805	return ++uid;
	3806	};
	3807	}
	3808	forEach(array, this.put, this);
	3809	}
	3810	HashMap.prototype = {
	3811	/**
	3812	* Store key value pair
	3813	* @param key key to store can be any type
	3814	* @param value value to store can be any type
	3815	*/
	3816	put: function(key, value) {
	3817	this[hashKey(key, this.nextUid)] = value;
	3818	},
	3819
	3820	/**
	3821	* @param key
	3822	* @returns {Object} the value for the key
	3823	*/
	3824	get: function(key) {
	3825	return this[hashKey(key, this.nextUid)];
	3826	},
	3827
	3828	/**
	3829	* Remove the key/value pair
	3830	* @param key
	3831	*/
	3832	remove: function(key) {
	3833	var value = this[key = hashKey(key, this.nextUid)];
	3834	delete this[key];
	3835	return value;
	3836	}
	3837	};
	3838
	3839	var $$HashMapProvider = [function() {
	3840	this.$get = [function() {
	3841	return HashMap;
	3842	}];
	3843	}];
	3844
	3845	/**
	3846	* @ngdoc function
	3847	* @module ng
	3848	* @name angular.injector
	3849	* @kind function
	3850	*
	3851	* @description
	3852	* Creates an injector object that can be used for retrieving services as well as for
	3853	* dependency injection (see {@link guide/di dependency injection}).
	3854	*
	3855	* @param {Array.<string\|Function>} modules A list of module functions or their aliases. See
	3856	* {@link angular.module}. The `ng` module must be explicitly added.
	3857	* @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which
	3858	* disallows argument name annotation inference.
	3859	* @returns {injector} Injector object. See {@link auto.$injector $injector}.
	3860	*
	3861	* @example
	3862	* Typical usage
	3863	* ```js
	3864	* // create an injector
	3865	* var $injector = angular.injector(['ng']);
	3866	*
	3867	* // use the injector to kick off your application
	3868	* // use the type inference to auto inject arguments, or use implicit injection
	3869	* $injector.invoke(function($rootScope, $compile, $document) {
	3870	* $compile($document)($rootScope);
	3871	* $rootScope.$digest();
	3872	* });
	3873	* ```
	3874	*
	3875	* Sometimes you want to get access to the injector of a currently running Angular app
	3876	* from outside Angular. Perhaps, you want to inject and compile some markup after the
	3877	* application has been bootstrapped. You can do this using the extra `injector()` added
	3878	* to JQuery/jqLite elements. See {@link angular.element}.
	3879	*
	3880	* *This is fairly rare but could be the case if a third party library is injecting the
	3881	* markup.*
	3882	*
	3883	* In the following example a new block of HTML containing a `ng-controller`
	3884	* directive is added to the end of the document body by JQuery. We then compile and link
	3885	* it into the current AngularJS scope.
	3886	*
	3887	* ```js
	3888	* var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>');
	3889	* $(document.body).append($div);
	3890	*
	3891	* angular.element(document).injector().invoke(function($compile) {
	3892	* var scope = angular.element($div).scope();
	3893	* $compile($div)(scope);
	3894	* });
	3895	* ```
	3896	*/
	3897
	3898
	3899	/**
	3900	* @ngdoc module
	3901	* @name auto
	3902	* @installation
	3903	* @description
	3904	*
	3905	* Implicit module which gets automatically added to each {@link auto.$injector $injector}.
	3906	*/
	3907
	3908	var ARROW_ARG = /^([^\(]+?)=>/;
	3909	var FN_ARGS = /^[^$]\(\s([^$]*)\)/m;
	3910	var FN_ARG_SPLIT = /,/;
	3911	var FN_ARG = /^\s(_?)(\S+?)\1\s$/;
	3912	var STRIP_COMMENTS = /((\/\/.$)\|(\/\[\s\S]?\\/))/mg;
	3913	var $injectorMinErr = minErr('$injector');
	3914
	3915	function stringifyFn(fn) {
	3916	// Support: Chrome 50-51 only
	3917	// Creating a new string by adding `' '` at the end, to hack around some bug in Chrome v50/51
	3918	// (See https://github.com/angular/angular.js/issues/14487.)
	3919	// TODO (gkalpak): Remove workaround when Chrome v52 is released
	3920	return Function.prototype.toString.call(fn) + ' ';
	3921	}
	3922
	3923	function extractArgs(fn) {
	3924	var fnText = stringifyFn(fn).replace(STRIP_COMMENTS, ''),
	3925	args = fnText.match(ARROW_ARG) \|\| fnText.match(FN_ARGS);
	3926	return args;
	3927	}
	3928
	3929	function anonFn(fn) {
	3930	// For anonymous functions, showing at the very least the function signature can help in
	3931	// debugging.
	3932	var args = extractArgs(fn);
	3933	if (args) {
	3934	return 'function(' + (args[1] \|\| '').replace(/[\s\r\n]+/, ' ') + ')';
	3935	}
	3936	return 'fn';
	3937	}
	3938
	3939	function annotate(fn, strictDi, name) {
	3940	var $inject,
	3941	argDecl,
	3942	last;
	3943
	3944	if (typeof fn === 'function') {
	3945	if (!($inject = fn.$inject)) {
	3946	$inject = [];
	3947	if (fn.length) {
	3948	if (strictDi) {
	3949	if (!isString(name) \|\| !name) {
	3950	name = fn.name \|\| anonFn(fn);
	3951	}
	3952	throw $injectorMinErr('strictdi',
	3953	'{0} is not using explicit annotation and cannot be invoked in strict mode', name);
	3954	}
	3955	argDecl = extractArgs(fn);
	3956	forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg) {
	3957	arg.replace(FN_ARG, function(all, underscore, name) {
	3958	$inject.push(name);
	3959	});
	3960	});
	3961	}
	3962	fn.$inject = $inject;
	3963	}
	3964	} else if (isArray(fn)) {
	3965	last = fn.length - 1;
	3966	assertArgFn(fn[last], 'fn');
	3967	$inject = fn.slice(0, last);
	3968	} else {
	3969	assertArgFn(fn, 'fn', true);
	3970	}
	3971	return $inject;
	3972	}
	3973
	3974	///////////////////////////////////////
	3975
	3976	/**
	3977	* @ngdoc service
	3978	* @name $injector
	3979	*
	3980	* @description
	3981	*
	3982	* `$injector` is used to retrieve object instances as defined by
	3983	* {@link auto.$provide provider}, instantiate types, invoke methods,
	3984	* and load modules.
	3985	*
	3986	* The following always holds true:
	3987	*
	3988	* ```js
	3989	* var $injector = angular.injector();
	3990	* expect($injector.get('$injector')).toBe($injector);
	3991	* expect($injector.invoke(function($injector) {
	3992	* return $injector;
	3993	* })).toBe($injector);
	3994	* ```
	3995	*
	3996	* # Injection Function Annotation
	3997	*
	3998	* JavaScript does not have annotations, and annotations are needed for dependency injection. The
	3999	* following are all valid ways of annotating function with injection arguments and are equivalent.
	4000	*
	4001	* ```js
	4002	* // inferred (only works if code not minified/obfuscated)
	4003	* $injector.invoke(function(serviceA){});
	4004	*
	4005	* // annotated
	4006	* function explicit(serviceA) {};
	4007	* explicit.$inject = ['serviceA'];
	4008	* $injector.invoke(explicit);
	4009	*
	4010	* // inline
	4011	* $injector.invoke(['serviceA', function(serviceA){}]);
	4012	* ```
	4013	*
	4014	* ## Inference
	4015	*
	4016	* In JavaScript calling `toString()` on a function returns the function definition. The definition
	4017	* can then be parsed and the function arguments can be extracted. This method of discovering
	4018	* annotations is disallowed when the injector is in strict mode.
	4019	* NOTE: This does not work with minification, and obfuscation tools since these tools change the
	4020	* argument names.
	4021	*
	4022	* ## `$inject` Annotation
	4023	* By adding an `$inject` property onto a function the injection parameters can be specified.
	4024	*
	4025	* ## Inline
	4026	* As an array of injection names, where the last item in the array is the function to call.
	4027	*/
	4028
	4029	/**
	4030	* @ngdoc method
	4031	* @name $injector#get
	4032	*
	4033	* @description
	4034	* Return an instance of the service.
	4035	*
	4036	* @param {string} name The name of the instance to retrieve.
	4037	* @param {string=} caller An optional string to provide the origin of the function call for error messages.
	4038	* @return {*} The instance.
	4039	*/
	4040
	4041	/**
	4042	* @ngdoc method
	4043	* @name $injector#invoke
	4044	*
	4045	* @description
	4046	* Invoke the method and supply the method arguments from the `$injector`.
	4047	*
	4048	* @param {Function\|Array.<string\|Function>} fn The injectable function to invoke. Function parameters are
	4049	* injected according to the {@link guide/di $inject Annotation} rules.
	4050	* @param {Object=} self The `this` for the invoked method.
	4051	* @param {Object=} locals Optional object. If preset then any argument names are read from this
	4052	* object first, before the `$injector` is consulted.
	4053	* @returns {*} the value returned by the invoked `fn` function.
	4054	*/
	4055
	4056	/**
	4057	* @ngdoc method
	4058	* @name $injector#has
	4059	*
	4060	* @description
	4061	* Allows the user to query if the particular service exists.
	4062	*
	4063	* @param {string} name Name of the service to query.
	4064	* @returns {boolean} `true` if injector has given service.
	4065	*/
	4066
	4067	/**
	4068	* @ngdoc method
	4069	* @name $injector#instantiate
	4070	* @description
	4071	* Create a new instance of JS type. The method takes a constructor function, invokes the new
	4072	* operator, and supplies all of the arguments to the constructor function as specified by the
	4073	* constructor annotation.
	4074	*
	4075	* @param {Function} Type Annotated constructor function.
	4076	* @param {Object=} locals Optional object. If preset then any argument names are read from this
	4077	* object first, before the `$injector` is consulted.
	4078	* @returns {Object} new instance of `Type`.
	4079	*/
	4080
	4081	/**
	4082	* @ngdoc method
	4083	* @name $injector#annotate
	4084	*
	4085	* @description
	4086	* Returns an array of service names which the function is requesting for injection. This API is
	4087	* used by the injector to determine which services need to be injected into the function when the
	4088	* function is invoked. There are three ways in which the function can be annotated with the needed
	4089	* dependencies.
	4090	*
	4091	* # Argument names
	4092	*
	4093	* The simplest form is to extract the dependencies from the arguments of the function. This is done
	4094	* by converting the function into a string using `toString()` method and extracting the argument
	4095	* names.
	4096	* ```js
	4097	* // Given
	4098	* function MyController($scope, $route) {
	4099	* // ...
	4100	* }
	4101	*
	4102	* // Then
	4103	* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
	4104	* ```
	4105	*
	4106	* You can disallow this method by using strict injection mode.
	4107	*
	4108	* This method does not work with code minification / obfuscation. For this reason the following
	4109	* annotation strategies are supported.
	4110	*
	4111	* # The `$inject` property
	4112	*
	4113	* If a function has an `$inject` property and its value is an array of strings, then the strings
	4114	* represent names of services to be injected into the function.
	4115	* ```js
	4116	* // Given
	4117	* var MyController = function(obfuscatedScope, obfuscatedRoute) {
	4118	* // ...
	4119	* }
	4120	* // Define function dependencies
	4121	* MyController['$inject'] = ['$scope', '$route'];
	4122	*
	4123	* // Then
	4124	* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
	4125	* ```
	4126	*
	4127	* # The array notation
	4128	*
	4129	* It is often desirable to inline Injected functions and that's when setting the `$inject` property
	4130	* is very inconvenient. In these situations using the array notation to specify the dependencies in
	4131	* a way that survives minification is a better choice:
	4132	*
	4133	* ```js
	4134	* // We wish to write this (not minification / obfuscation safe)
	4135	* injector.invoke(function($compile, $rootScope) {
	4136	* // ...
	4137	* });
	4138	*
	4139	* // We are forced to write break inlining
	4140	* var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
	4141	* // ...
	4142	* };
	4143	* tmpFn.$inject = ['$compile', '$rootScope'];
	4144	* injector.invoke(tmpFn);
	4145	*
	4146	* // To better support inline function the inline annotation is supported
	4147	* injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
	4148	* // ...
	4149	* }]);
	4150	*
	4151	* // Therefore
	4152	* expect(injector.annotate(
	4153	* ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
	4154	* ).toEqual(['$compile', '$rootScope']);
	4155	* ```
	4156	*
	4157	* @param {Function\|Array.<string\|Function>} fn Function for which dependent service names need to
	4158	* be retrieved as described above.
	4159	*
	4160	* @param {boolean=} [strictDi=false] Disallow argument name annotation inference.
	4161	*
	4162	* @returns {Array.<string>} The names of the services which the function requires.
	4163	*/
	4164
	4165
	4166
	4167
	4168	/**
	4169	* @ngdoc service
	4170	* @name $provide
	4171	*
	4172	* @description
	4173	*
	4174	* The {@link auto.$provide $provide} service has a number of methods for registering components
	4175	* with the {@link auto.$injector $injector}. Many of these functions are also exposed on
	4176	* {@link angular.Module}.
	4177	*
	4178	* An Angular service is a singleton object created by a service factory. These **service
	4179	* factories are functions which, in turn, are created by a service provider**.
	4180	* The service providers are constructor functions. When instantiated they must contain a
	4181	* property called `$get`, which holds the service factory function.
	4182	*
	4183	* When you request a service, the {@link auto.$injector $injector} is responsible for finding the
	4184	* correct service provider, instantiating it and then calling its `$get` service factory
	4185	* function to get the instance of the service.
	4186	*
	4187	* Often services have no configuration options and there is no need to add methods to the service
	4188	* provider. The provider will be no more than a constructor function with a `$get` property. For
	4189	* these cases the {@link auto.$provide $provide} service has additional helper methods to register
	4190	* services without specifying a provider.
	4191	*
	4192	* * {@link auto.$provide#provider provider(name, provider)} - registers a service provider with the
	4193	* {@link auto.$injector $injector}
	4194	* * {@link auto.$provide#constant constant(name, obj)} - registers a value/object that can be accessed by
	4195	* providers and services.
	4196	* * {@link auto.$provide#value value(name, obj)} - registers a value/object that can only be accessed by
	4197	* services, not providers.
	4198	* * {@link auto.$provide#factory factory(name, fn)} - registers a service factory function
	4199	* that will be wrapped in a service provider object, whose `$get` property will contain the
	4200	* given factory function.
	4201	* * {@link auto.$provide#service service(name, Fn)} - registers a constructor function
	4202	* that will be wrapped in a service provider object, whose `$get` property will instantiate
	4203	* a new object using the given constructor function.
	4204	* * {@link auto.$provide#decorator decorator(name, decorFn)} - registers a decorator function that
	4205	* will be able to modify or replace the implementation of another service.
	4206	*
	4207	* See the individual methods for more information and examples.
	4208	*/
	4209
	4210	/**
	4211	* @ngdoc method
	4212	* @name $provide#provider
	4213	* @description
	4214	*
	4215	* Register a provider function with the {@link auto.$injector $injector}. Provider functions
	4216	* are constructor functions, whose instances are responsible for "providing" a factory for a
	4217	* service.
	4218	*
	4219	* Service provider names start with the name of the service they provide followed by `Provider`.
	4220	* For example, the {@link ng.$log $log} service has a provider called
	4221	* {@link ng.$logProvider $logProvider}.
	4222	*
	4223	* Service provider objects can have additional methods which allow configuration of the provider
	4224	* and its service. Importantly, you can configure what kind of service is created by the `$get`
	4225	* method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a
	4226	* method {@link ng.$logProvider#debugEnabled debugEnabled}
	4227	* which lets you specify whether the {@link ng.$log $log} service will log debug messages to the
	4228	* console or not.
	4229	*
	4230	* @param {string} name The name of the instance. NOTE: the provider will be available under `name +
	4231	'Provider'` key.
	4232	* @param {(Object\|function())} provider If the provider is:
	4233	*
	4234	* - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
	4235	* {@link auto.$injector#invoke $injector.invoke()} when an instance needs to be created.
	4236	* - `Constructor`: a new instance of the provider will be created using
	4237	* {@link auto.$injector#instantiate $injector.instantiate()}, then treated as `object`.
	4238	*
	4239	* @returns {Object} registered provider instance
	4240
	4241	* @example
	4242	*
	4243	* The following example shows how to create a simple event tracking service and register it using
	4244	* {@link auto.$provide#provider $provide.provider()}.
	4245	*
	4246	* ```js
	4247	* // Define the eventTracker provider
	4248	* function EventTrackerProvider() {
	4249	* var trackingUrl = '/track';
	4250	*
	4251	* // A provider method for configuring where the tracked events should been saved
	4252	* this.setTrackingUrl = function(url) {
	4253	* trackingUrl = url;
	4254	* };
	4255	*
	4256	* // The service factory function
	4257	* this.$get = ['$http', function($http) {
	4258	* var trackedEvents = {};
	4259	* return {
	4260	* // Call this to track an event
	4261	* event: function(event) {
	4262	* var count = trackedEvents[event] \|\| 0;
	4263	* count += 1;
	4264	* trackedEvents[event] = count;
	4265	* return count;
	4266	* },
	4267	* // Call this to save the tracked events to the trackingUrl
	4268	* save: function() {
	4269	* $http.post(trackingUrl, trackedEvents);
	4270	* }
	4271	* };
	4272	* }];
	4273	* }
	4274	*
	4275	* describe('eventTracker', function() {
	4276	* var postSpy;
	4277	*
	4278	* beforeEach(module(function($provide) {
	4279	* // Register the eventTracker provider
	4280	* $provide.provider('eventTracker', EventTrackerProvider);
	4281	* }));
	4282	*
	4283	* beforeEach(module(function(eventTrackerProvider) {
	4284	* // Configure eventTracker provider
	4285	* eventTrackerProvider.setTrackingUrl('/custom-track');
	4286	* }));
	4287	*
	4288	* it('tracks events', inject(function(eventTracker) {
	4289	* expect(eventTracker.event('login')).toEqual(1);
	4290	* expect(eventTracker.event('login')).toEqual(2);
	4291	* }));
	4292	*
	4293	* it('saves to the tracking url', inject(function(eventTracker, $http) {
	4294	* postSpy = spyOn($http, 'post');
	4295	* eventTracker.event('login');
	4296	* eventTracker.save();
	4297	* expect(postSpy).toHaveBeenCalled();
	4298	* expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');
	4299	* expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');
	4300	* expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });
	4301	* }));
	4302	* });
	4303	* ```
	4304	*/
	4305
	4306	/**
	4307	* @ngdoc method
	4308	* @name $provide#factory
	4309	* @description
	4310	*
	4311	* Register a service factory, which will be called to return the service instance.
	4312	* This is short for registering a service where its provider consists of only a `$get` property,
	4313	* which is the given service factory function.
	4314	* You should use {@link auto.$provide#factory $provide.factory(getFn)} if you do not need to
	4315	* configure your service in a provider.
	4316	*
	4317	* @param {string} name The name of the instance.
	4318	* @param {Function\|Array.<string\|Function>} $getFn The injectable $getFn for the instance creation.
	4319	* Internally this is a short hand for `$provide.provider(name, {$get: $getFn})`.
	4320	* @returns {Object} registered provider instance
	4321	*
	4322	* @example
	4323	* Here is an example of registering a service
	4324	* ```js
	4325	* $provide.factory('ping', ['$http', function($http) {
	4326	* return function ping() {
	4327	* return $http.send('/ping');
	4328	* };
	4329	* }]);
	4330	* ```
	4331	* You would then inject and use this service like this:
	4332	* ```js
	4333	* someModule.controller('Ctrl', ['ping', function(ping) {
	4334	* ping();
	4335	* }]);
	4336	* ```
	4337	*/
	4338
	4339
	4340	/**
	4341	* @ngdoc method
	4342	* @name $provide#service
	4343	* @description
	4344	*
	4345	* Register a service constructor, which will be invoked with `new` to create the service
	4346	* instance.
	4347	* This is short for registering a service where its provider's `$get` property is a factory
	4348	* function that returns an instance instantiated by the injector from the service constructor
	4349	* function.
	4350	*
	4351	* Internally it looks a bit like this:
	4352	*
	4353	* ```
	4354	* {
	4355	* $get: function() {
	4356	* return $injector.instantiate(constructor);
	4357	* }
	4358	* }
	4359	* ```
	4360	*
	4361	*
	4362	* You should use {@link auto.$provide#service $provide.service(class)} if you define your service
	4363	* as a type/class.
	4364	*
	4365	* @param {string} name The name of the instance.
	4366	* @param {Function\|Array.<string\|Function>} constructor An injectable class (constructor function)
	4367	* that will be instantiated.
	4368	* @returns {Object} registered provider instance
	4369	*
	4370	* @example
	4371	* Here is an example of registering a service using
	4372	* {@link auto.$provide#service $provide.service(class)}.
	4373	* ```js
	4374	* var Ping = function($http) {
	4375	* this.$http = $http;
	4376	* };
	4377	*
	4378	* Ping.$inject = ['$http'];
	4379	*
	4380	* Ping.prototype.send = function() {
	4381	* return this.$http.get('/ping');
	4382	* };
	4383	* $provide.service('ping', Ping);
	4384	* ```
	4385	* You would then inject and use this service like this:
	4386	* ```js
	4387	* someModule.controller('Ctrl', ['ping', function(ping) {
	4388	* ping.send();
	4389	* }]);
	4390	* ```
	4391	*/
	4392
	4393
	4394	/**
	4395	* @ngdoc method
	4396	* @name $provide#value
	4397	* @description
	4398	*
	4399	* Register a value service with the {@link auto.$injector $injector}, such as a string, a
	4400	* number, an array, an object or a function. This is short for registering a service where its
	4401	* provider's `$get` property is a factory function that takes no arguments and returns the **value
	4402	* service**. That also means it is not possible to inject other services into a value service.
	4403	*
	4404	* Value services are similar to constant services, except that they cannot be injected into a
	4405	* module configuration function (see {@link angular.Module#config}) but they can be overridden by
	4406	* an Angular {@link auto.$provide#decorator decorator}.
	4407	*
	4408	* @param {string} name The name of the instance.
	4409	* @param {*} value The value.
	4410	* @returns {Object} registered provider instance
	4411	*
	4412	* @example
	4413	* Here are some examples of creating value services.
	4414	* ```js
	4415	* $provide.value('ADMIN_USER', 'admin');
	4416	*
	4417	* $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });
	4418	*
	4419	* $provide.value('halfOf', function(value) {
	4420	* return value / 2;
	4421	* });
	4422	* ```
	4423	*/
	4424
	4425
	4426	/**
	4427	* @ngdoc method
	4428	* @name $provide#constant
	4429	* @description
	4430	*
	4431	* Register a constant service with the {@link auto.$injector $injector}, such as a string,
	4432	* a number, an array, an object or a function. Like the {@link auto.$provide#value value}, it is not
	4433	* possible to inject other services into a constant.
	4434	*
	4435	* But unlike {@link auto.$provide#value value}, a constant can be
	4436	* injected into a module configuration function (see {@link angular.Module#config}) and it cannot
	4437	* be overridden by an Angular {@link auto.$provide#decorator decorator}.
	4438	*
	4439	* @param {string} name The name of the constant.
	4440	* @param {*} value The constant value.
	4441	* @returns {Object} registered instance
	4442	*
	4443	* @example
	4444	* Here a some examples of creating constants:
	4445	* ```js
	4446	* $provide.constant('SHARD_HEIGHT', 306);
	4447	*
	4448	* $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);
	4449	*
	4450	* $provide.constant('double', function(value) {
	4451	* return value * 2;
	4452	* });
	4453	* ```
	4454	*/
	4455
	4456
	4457	/**
	4458	* @ngdoc method
	4459	* @name $provide#decorator
	4460	* @description
	4461	*
	4462	* Register a decorator function with the {@link auto.$injector $injector}. A decorator function
	4463	* intercepts the creation of a service, allowing it to override or modify the behavior of the
	4464	* service. The return value of the decorator function may be the original service, or a new service
	4465	* that replaces (or wraps and delegates to) the original service.
	4466	*
	4467	* You can find out more about using decorators in the {@link guide/decorators} guide.
	4468	*
	4469	* @param {string} name The name of the service to decorate.
	4470	* @param {Function\|Array.<string\|Function>} decorator This function will be invoked when the service needs to be
	4471	* provided and should return the decorated service instance. The function is called using
	4472	* the {@link auto.$injector#invoke injector.invoke} method and is therefore fully injectable.
	4473	* Local injection arguments:
	4474	*
	4475	* * `$delegate` - The original service instance, which can be replaced, monkey patched, configured,
	4476	* decorated or delegated to.
	4477	*
	4478	* @example
	4479	* Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting
	4480	* calls to {@link ng.$log#error $log.warn()}.
	4481	* ```js
	4482	* $provide.decorator('$log', ['$delegate', function($delegate) {
	4483	* $delegate.warn = $delegate.error;
	4484	* return $delegate;
	4485	* }]);
	4486	* ```
	4487	*/
	4488
	4489
	4490	function createInjector(modulesToLoad, strictDi) {
	4491	strictDi = (strictDi === true);
	4492	var INSTANTIATING = {},
	4493	providerSuffix = 'Provider',
	4494	path = [],
	4495	loadedModules = new HashMap([], true),
	4496	providerCache = {
	4497	$provide: {
	4498	provider: supportObject(provider),
	4499	factory: supportObject(factory),
	4500	service: supportObject(service),
	4501	value: supportObject(value),
	4502	constant: supportObject(constant),
	4503	decorator: decorator
	4504	}
	4505	},
	4506	providerInjector = (providerCache.$injector =
	4507	createInternalInjector(providerCache, function(serviceName, caller) {
	4508	if (angular.isString(caller)) {
	4509	path.push(caller);
	4510	}
	4511	throw $injectorMinErr('unpr', "Unknown provider: {0}", path.join(' <- '));
	4512	})),
	4513	instanceCache = {},
	4514	protoInstanceInjector =
	4515	createInternalInjector(instanceCache, function(serviceName, caller) {
	4516	var provider = providerInjector.get(serviceName + providerSuffix, caller);
	4517	return instanceInjector.invoke(
	4518	provider.$get, provider, undefined, serviceName);
	4519	}),
	4520	instanceInjector = protoInstanceInjector;
	4521
	4522	providerCache['$injector' + providerSuffix] = { $get: valueFn(protoInstanceInjector) };
	4523	var runBlocks = loadModules(modulesToLoad);
	4524	instanceInjector = protoInstanceInjector.get('$injector');
	4525	instanceInjector.strictDi = strictDi;
	4526	forEach(runBlocks, function(fn) { if (fn) instanceInjector.invoke(fn); });
	4527
	4528	return instanceInjector;
	4529
	4530	////////////////////////////////////
	4531	// $provider
	4532	////////////////////////////////////
	4533
	4534	function supportObject(delegate) {
	4535	return function(key, value) {
	4536	if (isObject(key)) {
	4537	forEach(key, reverseParams(delegate));
	4538	} else {
	4539	return delegate(key, value);
	4540	}
	4541	};
	4542	}
	4543
	4544	function provider(name, provider_) {
	4545	assertNotHasOwnProperty(name, 'service');
	4546	if (isFunction(provider_) \|\| isArray(provider_)) {
	4547	provider_ = providerInjector.instantiate(provider_);
	4548	}
	4549	if (!provider_.$get) {
	4550	throw $injectorMinErr('pget', "Provider '{0}' must define $get factory method.", name);
	4551	}
	4552	return providerCache[name + providerSuffix] = provider_;
	4553	}
	4554
	4555	function enforceReturnValue(name, factory) {
	4556	return function enforcedReturnValue() {
	4557	var result = instanceInjector.invoke(factory, this);
	4558	if (isUndefined(result)) {
	4559	throw $injectorMinErr('undef', "Provider '{0}' must return a value from $get factory method.", name);
	4560	}
	4561	return result;
	4562	};
	4563	}
	4564
	4565	function factory(name, factoryFn, enforce) {
	4566	return provider(name, {
	4567	$get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn
	4568	});
	4569	}
	4570
	4571	function service(name, constructor) {
	4572	return factory(name, ['$injector', function($injector) {
	4573	return $injector.instantiate(constructor);
	4574	}]);
	4575	}
	4576
	4577	function value(name, val) { return factory(name, valueFn(val), false); }
	4578
	4579	function constant(name, value) {
	4580	assertNotHasOwnProperty(name, 'constant');
	4581	providerCache[name] = value;
	4582	instanceCache[name] = value;
	4583	}
	4584
	4585	function decorator(serviceName, decorFn) {
	4586	var origProvider = providerInjector.get(serviceName + providerSuffix),
	4587	orig$get = origProvider.$get;
	4588
	4589	origProvider.$get = function() {
	4590	var origInstance = instanceInjector.invoke(orig$get, origProvider);
	4591	return instanceInjector.invoke(decorFn, null, {$delegate: origInstance});
	4592	};
	4593	}
	4594
	4595	////////////////////////////////////
	4596	// Module Loading
	4597	////////////////////////////////////
	4598	function loadModules(modulesToLoad) {
	4599	assertArg(isUndefined(modulesToLoad) \|\| isArray(modulesToLoad), 'modulesToLoad', 'not an array');
	4600	var runBlocks = [], moduleFn;
	4601	forEach(modulesToLoad, function(module) {
	4602	if (loadedModules.get(module)) return;
	4603	loadedModules.put(module, true);
	4604
	4605	function runInvokeQueue(queue) {
	4606	var i, ii;
	4607	for (i = 0, ii = queue.length; i < ii; i++) {
	4608	var invokeArgs = queue[i],
	4609	provider = providerInjector.get(invokeArgs[0]);
	4610
	4611	provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
	4612	}
	4613	}
	4614
	4615	try {
	4616	if (isString(module)) {
	4617	moduleFn = angularModule(module);
	4618	runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);
	4619	runInvokeQueue(moduleFn._invokeQueue);
	4620	runInvokeQueue(moduleFn._configBlocks);
	4621	} else if (isFunction(module)) {
	4622	runBlocks.push(providerInjector.invoke(module));
	4623	} else if (isArray(module)) {
	4624	runBlocks.push(providerInjector.invoke(module));
	4625	} else {
	4626	assertArgFn(module, 'module');
	4627	}
	4628	} catch (e) {
	4629	if (isArray(module)) {
	4630	module = module[module.length - 1];
	4631	}
	4632	if (e.message && e.stack && e.stack.indexOf(e.message) == -1) {
	4633	// Safari & FF's stack traces don't contain error.message content
	4634	// unlike those of Chrome and IE
	4635	// So if stack doesn't contain message, we create a new string that contains both.
	4636	// Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
	4637	/* jshint -W022 */
	4638	e = e.message + '\n' + e.stack;
	4639	}
	4640	throw $injectorMinErr('modulerr', "Failed to instantiate module {0} due to:\n{1}",
	4641	module, e.stack \|\| e.message \|\| e);
	4642	}
	4643	});
	4644	return runBlocks;
	4645	}
	4646
	4647	////////////////////////////////////
	4648	// internal Injector
	4649	////////////////////////////////////
	4650
	4651	function createInternalInjector(cache, factory) {
	4652
	4653	function getService(serviceName, caller) {
	4654	if (cache.hasOwnProperty(serviceName)) {
	4655	if (cache[serviceName] === INSTANTIATING) {
	4656	throw $injectorMinErr('cdep', 'Circular dependency found: {0}',
	4657	serviceName + ' <- ' + path.join(' <- '));
	4658	}
	4659	return cache[serviceName];
	4660	} else {
	4661	try {
	4662	path.unshift(serviceName);
	4663	cache[serviceName] = INSTANTIATING;
	4664	return cache[serviceName] = factory(serviceName, caller);
	4665	} catch (err) {
	4666	if (cache[serviceName] === INSTANTIATING) {
	4667	delete cache[serviceName];
	4668	}
	4669	throw err;
	4670	} finally {
	4671	path.shift();
	4672	}
	4673	}
	4674	}
	4675
	4676
	4677	function injectionArgs(fn, locals, serviceName) {
	4678	var args = [],
	4679	$inject = createInjector.$$annotate(fn, strictDi, serviceName);
	4680
	4681	for (var i = 0, length = $inject.length; i < length; i++) {
	4682	var key = $inject[i];
	4683	if (typeof key !== 'string') {
	4684	throw $injectorMinErr('itkn',
	4685	'Incorrect injection token! Expected service name as string, got {0}', key);
	4686	}
	4687	args.push(locals && locals.hasOwnProperty(key) ? locals[key] :
	4688	getService(key, serviceName));
	4689	}
	4690	return args;
	4691	}
	4692
	4693	function isClass(func) {
	4694	// IE 9-11 do not support classes and IE9 leaks with the code below.
	4695	if (msie <= 11) {
	4696	return false;
	4697	}
	4698	// Support: Edge 12-13 only
	4699	// See: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/6156135/
	4700	return typeof func === 'function'
	4701	&& /^(?:class\b\|constructor\()/.test(stringifyFn(func));
	4702	}
	4703
	4704	function invoke(fn, self, locals, serviceName) {
	4705	if (typeof locals === 'string') {
	4706	serviceName = locals;
	4707	locals = null;
	4708	}
	4709
	4710	var args = injectionArgs(fn, locals, serviceName);
	4711	if (isArray(fn)) {
	4712	fn = fn[fn.length - 1];
	4713	}
	4714
	4715	if (!isClass(fn)) {
	4716	// http://jsperf.com/angularjs-invoke-apply-vs-switch
	4717	// #5388
	4718	return fn.apply(self, args);
	4719	} else {
	4720	args.unshift(null);
	4721	return new (Function.prototype.bind.apply(fn, args))();
	4722	}
	4723	}
	4724
	4725
	4726	function instantiate(Type, locals, serviceName) {
	4727	// Check if Type is annotated and use just the given function at n-1 as parameter
	4728	// e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
	4729	var ctor = (isArray(Type) ? Type[Type.length - 1] : Type);
	4730	var args = injectionArgs(Type, locals, serviceName);
	4731	// Empty object at position 0 is ignored for invocation with `new`, but required.
	4732	args.unshift(null);
	4733	return new (Function.prototype.bind.apply(ctor, args))();
	4734	}
	4735
	4736
	4737	return {
	4738	invoke: invoke,
	4739	instantiate: instantiate,
	4740	get: getService,
	4741	annotate: createInjector.$$annotate,
	4742	has: function(name) {
	4743	return providerCache.hasOwnProperty(name + providerSuffix) \|\| cache.hasOwnProperty(name);
	4744	}
	4745	};
	4746	}
	4747	}
	4748
	4749	createInjector.$$annotate = annotate;
	4750
	4751	/**
	4752	* @ngdoc provider
	4753	* @name $anchorScrollProvider
	4754	*
	4755	* @description
	4756	* Use `$anchorScrollProvider` to disable automatic scrolling whenever
	4757	* {@link ng.$location#hash $location.hash()} changes.
	4758	*/
	4759	function $AnchorScrollProvider() {
	4760
	4761	var autoScrollingEnabled = true;
	4762
	4763	/**
	4764	* @ngdoc method
	4765	* @name $anchorScrollProvider#disableAutoScrolling
	4766	*
	4767	* @description
	4768	* By default, {@link ng.$anchorScroll $anchorScroll()} will automatically detect changes to
	4769	* {@link ng.$location#hash $location.hash()} and scroll to the element matching the new hash.<br />
	4770	* Use this method to disable automatic scrolling.
	4771	*
	4772	* If automatic scrolling is disabled, one must explicitly call
	4773	* {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the
	4774	* current hash.
	4775	*/
	4776	this.disableAutoScrolling = function() {
	4777	autoScrollingEnabled = false;
	4778	};
	4779
	4780	/**
	4781	* @ngdoc service
	4782	* @name $anchorScroll
	4783	* @kind function
	4784	* @requires $window
	4785	* @requires $location
	4786	* @requires $rootScope
	4787	*
	4788	* @description
	4789	* When called, it scrolls to the element related to the specified `hash` or (if omitted) to the
	4790	* current value of {@link ng.$location#hash $location.hash()}, according to the rules specified
	4791	* in the
	4792	* [HTML5 spec](http://www.w3.org/html/wg/drafts/html/master/browsers.html#an-indicated-part-of-the-document).
	4793	*
	4794	* It also watches the {@link ng.$location#hash $location.hash()} and automatically scrolls to
	4795	* match any anchor whenever it changes. This can be disabled by calling
	4796	* {@link ng.$anchorScrollProvider#disableAutoScrolling $anchorScrollProvider.disableAutoScrolling()}.
	4797	*
	4798	* Additionally, you can use its {@link ng.$anchorScroll#yOffset yOffset} property to specify a
	4799	* vertical scroll-offset (either fixed or dynamic).
	4800	*
	4801	* @param {string=} hash The hash specifying the element to scroll to. If omitted, the value of
	4802	* {@link ng.$location#hash $location.hash()} will be used.
	4803	*
	4804	* @property {(number\|function\|jqLite)} yOffset
	4805	* If set, specifies a vertical scroll-offset. This is often useful when there are fixed
	4806	* positioned elements at the top of the page, such as navbars, headers etc.
	4807	*
	4808	* `yOffset` can be specified in various ways:
	4809	* - number: A fixed number of pixels to be used as offset.<br /><br />
	4810	* - function: A getter function called everytime `$anchorScroll()` is executed. Must return
	4811	* a number representing the offset (in pixels).<br /><br />
	4812	* - jqLite: A jqLite/jQuery element to be used for specifying the offset. The distance from
	4813	* the top of the page to the element's bottom will be used as offset.<br />
	4814	* Note: The element will be taken into account only as long as its `position` is set to
	4815	* `fixed`. This option is useful, when dealing with responsive navbars/headers that adjust
	4816	* their height and/or positioning according to the viewport's size.
	4817	*
	4818	* <br />
	4819	* <div class="alert alert-warning">
	4820	* In order for `yOffset` to work properly, scrolling should take place on the document's root and
	4821	* not some child element.
	4822	* </div>
	4823	*
	4824	* @example
	4825	<example module="anchorScrollExample">
	4826	<file name="index.html">
	4827	<div id="scrollArea" ng-controller="ScrollController">
	4828	<a ng-click="gotoBottom()">Go to bottom</a>
	4829	<a id="bottom"></a> You're at the bottom!
	4830	</div>
	4831	</file>
	4832	<file name="script.js">
	4833	angular.module('anchorScrollExample', [])
	4834	.controller('ScrollController', ['$scope', '$location', '$anchorScroll',
	4835	function ($scope, $location, $anchorScroll) {
	4836	$scope.gotoBottom = function() {
	4837	// set the location.hash to the id of
	4838	// the element you wish to scroll to.
	4839	$location.hash('bottom');
	4840
	4841	// call $anchorScroll()
	4842	$anchorScroll();
	4843	};
	4844	}]);
	4845	</file>
	4846	<file name="style.css">
	4847	#scrollArea {
	4848	height: 280px;
	4849	overflow: auto;
	4850	}
	4851
	4852	#bottom {
	4853	display: block;
	4854	margin-top: 2000px;
	4855	}
	4856	</file>
	4857	</example>
	4858	*
	4859	* <hr />
	4860	* The example below illustrates the use of a vertical scroll-offset (specified as a fixed value).
	4861	* See {@link ng.$anchorScroll#yOffset $anchorScroll.yOffset} for more details.
	4862	*
	4863	* @example
	4864	<example module="anchorScrollOffsetExample">
	4865	<file name="index.html">
	4866	<div class="fixed-header" ng-controller="headerCtrl">
	4867	<a href="" ng-click="gotoAnchor(x)" ng-repeat="x in [1,2,3,4,5]">
	4868	Go to anchor {{x}}
	4869	</a>
	4870	</div>
	4871	<div id="anchor{{x}}" class="anchor" ng-repeat="x in [1,2,3,4,5]">
	4872	Anchor {{x}} of 5
	4873	</div>
	4874	</file>
	4875	<file name="script.js">
	4876	angular.module('anchorScrollOffsetExample', [])
	4877	.run(['$anchorScroll', function($anchorScroll) {
	4878	$anchorScroll.yOffset = 50; // always scroll by 50 extra pixels
	4879	}])
	4880	.controller('headerCtrl', ['$anchorScroll', '$location', '$scope',
	4881	function ($anchorScroll, $location, $scope) {
	4882	$scope.gotoAnchor = function(x) {
	4883	var newHash = 'anchor' + x;
	4884	if ($location.hash() !== newHash) {
	4885	// set the $location.hash to `newHash` and
	4886	// $anchorScroll will automatically scroll to it
	4887	$location.hash('anchor' + x);
	4888	} else {
	4889	// call $anchorScroll() explicitly,
	4890	// since $location.hash hasn't changed
	4891	$anchorScroll();
	4892	}
	4893	};
	4894	}
	4895	]);
	4896	</file>
	4897	<file name="style.css">
	4898	body {
	4899	padding-top: 50px;
	4900	}
	4901
	4902	.anchor {
	4903	border: 2px dashed DarkOrchid;
	4904	padding: 10px 10px 200px 10px;
	4905	}
	4906
	4907	.fixed-header {
	4908	background-color: rgba(0, 0, 0, 0.2);
	4909	height: 50px;
	4910	position: fixed;
	4911	top: 0; left: 0; right: 0;
	4912	}
	4913
	4914	.fixed-header > a {
	4915	display: inline-block;
	4916	margin: 5px 15px;
	4917	}
	4918	</file>
	4919	</example>
	4920	*/
	4921	this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {
	4922	var document = $window.document;
	4923
	4924	// Helper function to get first anchor from a NodeList
	4925	// (using `Array#some()` instead of `angular#forEach()` since it's more performant
	4926	// and working in all supported browsers.)
	4927	function getFirstAnchor(list) {
	4928	var result = null;
	4929	Array.prototype.some.call(list, function(element) {
	4930	if (nodeName_(element) === 'a') {
	4931	result = element;
	4932	return true;
	4933	}
	4934	});
	4935	return result;
	4936	}
	4937
	4938	function getYOffset() {
	4939
	4940	var offset = scroll.yOffset;
	4941
	4942	if (isFunction(offset)) {
	4943	offset = offset();
	4944	} else if (isElement(offset)) {
	4945	var elem = offset[0];
	4946	var style = $window.getComputedStyle(elem);
	4947	if (style.position !== 'fixed') {
	4948	offset = 0;
	4949	} else {
	4950	offset = elem.getBoundingClientRect().bottom;
	4951	}
	4952	} else if (!isNumber(offset)) {
	4953	offset = 0;
	4954	}
	4955
	4956	return offset;
	4957	}
	4958
	4959	function scrollTo(elem) {
	4960	if (elem) {
	4961	elem.scrollIntoView();
	4962
	4963	var offset = getYOffset();
	4964
	4965	if (offset) {
	4966	// `offset` is the number of pixels we should scroll UP in order to align `elem` properly.
	4967	// This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the
	4968	// top of the viewport.
	4969	//
	4970	// IF the number of pixels from the top of `elem` to the end of the page's content is less
	4971	// than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some
	4972	// way down the page.
	4973	//
	4974	// This is often the case for elements near the bottom of the page.
	4975	//
	4976	// In such cases we do not need to scroll the whole `offset` up, just the difference between
	4977	// the top of the element and the offset, which is enough to align the top of `elem` at the
	4978	// desired position.
	4979	var elemTop = elem.getBoundingClientRect().top;
	4980	$window.scrollBy(0, elemTop - offset);
	4981	}
	4982	} else {
	4983	$window.scrollTo(0, 0);
	4984	}
	4985	}
	4986
	4987	function scroll(hash) {
	4988	hash = isString(hash) ? hash : $location.hash();
	4989	var elm;
	4990
	4991	// empty hash, scroll to the top of the page
	4992	if (!hash) scrollTo(null);
	4993
	4994	// element with given id
	4995	else if ((elm = document.getElementById(hash))) scrollTo(elm);
	4996
	4997	// first anchor with given name :-D
	4998	else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) scrollTo(elm);
	4999

26769 more lines aren’t shown here.

Source/Libraries/GSF.Web/Shared/Scripts/gsf.web.client.js+5−5

@@ -786,25 +786,25 @@ $.fn.disable = function() { · 785 unmodified lines
786		786
787	$.fn.visible = function() {	787	$.fn.visible = function() {
788	return this.each(function() {	788	return this.each(function() {
789	this.css("visibility", "visible");	789	$(this).css("visibility", "visible");
790	});	790	});
791	}	791	}
792		792
793	$.fn.invisible = function() {	793	$.fn.invisible = function() {
794	return this.each(function() {	794	return this.each(function() {
795	this.css("visibility", "hidden");	795	$(this).css("visibility", "hidden");
796	});	796	});
797	}	797	}
798		798
799	$.fn.readCookie = function(name) {	799	$.fn.readCookie = function(name) {
800	this.val(Cookies.get(name));	800	$(this).val(Cookies.get(name));
801	}	801	}
802		802
803	$.fn.writeCookie = function(name, expiration) {	803	$.fn.writeCookie = function(name, expiration) {
804	if (expiration) // Date or number of days	804	if (expiration) // Date or number of days
805	Cookies.set(name, this.val(), { expires: expiration });	805	Cookies.set(name, $(this).val(), { expires: expiration });
806	else	806	else
807	Cookies.set(name, this.val());	807	Cookies.set(name, $(this).val());
808	}	808	}
809		809
810	$.fn.removeCookie = function(name) {	810	$.fn.removeCookie = function(name) {

Source/Libraries/GSF.Web/Shared/Scripts/jquery-ui.js+16617−0

@@ -0,0 +1,16617 @@
	1	/*! jQuery UI - v1.11.4 - 2016-03-31
	2	* http://jqueryui.com
	3	* Includes: core.js, widget.js, mouse.js, position.js, draggable.js, droppable.js, resizable.js, selectable.js, sortable.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, menu.js, progressbar.js, selectmenu.js, slider.js, spinner.js, tabs.js, tooltip.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js
	4	* Copyright jQuery Foundation and other contributors; Licensed MIT */
	5
	6	(function( factory ) {
	7	if ( typeof define === "function" && define.amd ) {
	8
	9	// AMD. Register as an anonymous module.
	10	define([ "jquery" ], factory );
	11	} else {
	12
	13	// Browser globals
	14	factory( jQuery );
	15	}
	16	}(function( $ ) {
	17	/*!
	18	* jQuery UI Core 1.11.4
	19	* http://jqueryui.com
	20	*
	21	* Copyright jQuery Foundation and other contributors
	22	* Released under the MIT license.
	23	* http://jquery.org/license
	24	*
	25	* http://api.jqueryui.com/category/ui-core/
	26	*/
	27
	28
	29	// $.ui might exist from components with no dependencies, e.g., $.ui.position
	30	$.ui = $.ui \|\| {};
	31
	32	$.extend( $.ui, {
	33	version: "1.11.4",
	34
	35	keyCode: {
	36	BACKSPACE: 8,
	37	COMMA: 188,
	38	DELETE: 46,
	39	DOWN: 40,
	40	END: 35,
	41	ENTER: 13,
	42	ESCAPE: 27,
	43	HOME: 36,
	44	LEFT: 37,
	45	PAGE_DOWN: 34,
	46	PAGE_UP: 33,
	47	PERIOD: 190,
	48	RIGHT: 39,
	49	SPACE: 32,
	50	TAB: 9,
	51	UP: 38
	52	}
	53	});
	54
	55	// plugins
	56	$.fn.extend({
	57	scrollParent: function( includeHidden ) {
	58	var position = this.css( "position" ),
	59	excludeStaticParent = position === "absolute",
	60	overflowRegex = includeHidden ? /(auto\|scroll\|hidden)/ : /(auto\|scroll)/,
	61	scrollParent = this.parents().filter( function() {
	62	var parent = $( this );
	63	if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
	64	return false;
	65	}
	66	return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
	67	}).eq( 0 );
	68
	69	return position === "fixed" \|\| !scrollParent.length ? $( this[ 0 ].ownerDocument \|\| document ) : scrollParent;
	70	},
	71
	72	uniqueId: (function() {
	73	var uuid = 0;
	74
	75	return function() {
	76	return this.each(function() {
	77	if ( !this.id ) {
	78	this.id = "ui-id-" + ( ++uuid );
	79	}
	80	});
	81	};
	82	})(),
	83
	84	removeUniqueId: function() {
	85	return this.each(function() {
	86	if ( /^ui-id-\d+$/.test( this.id ) ) {
	87	$( this ).removeAttr( "id" );
	88	}
	89	});
	90	}
	91	});
	92
	93	// selectors
	94	function focusable( element, isTabIndexNotNaN ) {
	95	var map, mapName, img,
	96	nodeName = element.nodeName.toLowerCase();
	97	if ( "area" === nodeName ) {
	98	map = element.parentNode;
	99	mapName = map.name;
	100	if ( !element.href \|\| !mapName \|\| map.nodeName.toLowerCase() !== "map" ) {
	101	return false;
	102	}
	103	img = $( "img[usemap='#" + mapName + "']" )[ 0 ];
	104	return !!img && visible( img );
	105	}
	106	return ( /^(input\|select\|textarea\|button\|object)$/.test( nodeName ) ?
	107	!element.disabled :
	108	"a" === nodeName ?
	109	element.href \|\| isTabIndexNotNaN :
	110	isTabIndexNotNaN) &&
	111	// the element and all of its ancestors must be visible
	112	visible( element );
	113	}
	114
	115	function visible( element ) {
	116	return $.expr.filters.visible( element ) &&
	117	!$( element ).parents().addBack().filter(function() {
	118	return $.css( this, "visibility" ) === "hidden";
	119	}).length;
	120	}
	121
	122	$.extend( $.expr[ ":" ], {
	123	data: $.expr.createPseudo ?
	124	$.expr.createPseudo(function( dataName ) {
	125	return function( elem ) {
	126	return !!$.data( elem, dataName );
	127	};
	128	}) :
	129	// support: jQuery <1.8
	130	function( elem, i, match ) {
	131	return !!$.data( elem, match[ 3 ] );
	132	},
	133
	134	focusable: function( element ) {
	135	return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
	136	},
	137
	138	tabbable: function( element ) {
	139	var tabIndex = $.attr( element, "tabindex" ),
	140	isTabIndexNaN = isNaN( tabIndex );
	141	return ( isTabIndexNaN \|\| tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
	142	}
	143	});
	144
	145	// support: jQuery <1.8
	146	if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
	147	$.each( [ "Width", "Height" ], function( i, name ) {
	148	var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
	149	type = name.toLowerCase(),
	150	orig = {
	151	innerWidth: $.fn.innerWidth,
	152	innerHeight: $.fn.innerHeight,
	153	outerWidth: $.fn.outerWidth,
	154	outerHeight: $.fn.outerHeight
	155	};
	156
	157	function reduce( elem, size, border, margin ) {
	158	$.each( side, function() {
	159	size -= parseFloat( $.css( elem, "padding" + this ) ) \|\| 0;
	160	if ( border ) {
	161	size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) \|\| 0;
	162	}
	163	if ( margin ) {
	164	size -= parseFloat( $.css( elem, "margin" + this ) ) \|\| 0;
	165	}
	166	});
	167	return size;
	168	}
	169
	170	$.fn[ "inner" + name ] = function( size ) {
	171	if ( size === undefined ) {
	172	return orig[ "inner" + name ].call( this );
	173	}
	174
	175	return this.each(function() {
	176	$( this ).css( type, reduce( this, size ) + "px" );
	177	});
	178	};
	179
	180	$.fn[ "outer" + name] = function( size, margin ) {
	181	if ( typeof size !== "number" ) {
	182	return orig[ "outer" + name ].call( this, size );
	183	}
	184
	185	return this.each(function() {
	186	$( this).css( type, reduce( this, size, true, margin ) + "px" );
	187	});
	188	};
	189	});
	190	}
	191
	192	// support: jQuery <1.8
	193	if ( !$.fn.addBack ) {
	194	$.fn.addBack = function( selector ) {
	195	return this.add( selector == null ?
	196	this.prevObject : this.prevObject.filter( selector )
	197	);
	198	};
	199	}
	200
	201	// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
	202	if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
	203	$.fn.removeData = (function( removeData ) {
	204	return function( key ) {
	205	if ( arguments.length ) {
	206	return removeData.call( this, $.camelCase( key ) );
	207	} else {
	208	return removeData.call( this );
	209	}
	210	};
	211	})( $.fn.removeData );
	212	}
	213
	214	// deprecated
	215	$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
	216
	217	$.fn.extend({
	218	focus: (function( orig ) {
	219	return function( delay, fn ) {
	220	return typeof delay === "number" ?
	221	this.each(function() {
	222	var elem = this;
	223	setTimeout(function() {
	224	$( elem ).focus();
	225	if ( fn ) {
	226	fn.call( elem );
	227	}
	228	}, delay );
	229	}) :
	230	orig.apply( this, arguments );
	231	};
	232	})( $.fn.focus ),
	233
	234	disableSelection: (function() {
	235	var eventType = "onselectstart" in document.createElement( "div" ) ?
	236	"selectstart" :
	237	"mousedown";
	238
	239	return function() {
	240	return this.bind( eventType + ".ui-disableSelection", function( event ) {
	241	event.preventDefault();
	242	});
	243	};
	244	})(),
	245
	246	enableSelection: function() {
	247	return this.unbind( ".ui-disableSelection" );
	248	},
	249
	250	zIndex: function( zIndex ) {
	251	if ( zIndex !== undefined ) {
	252	return this.css( "zIndex", zIndex );
	253	}
	254
	255	if ( this.length ) {
	256	var elem = $( this[ 0 ] ), position, value;
	257	while ( elem.length && elem[ 0 ] !== document ) {
	258	// Ignore z-index if position is set to a value where z-index is ignored by the browser
	259	// This makes behavior of this function consistent across browsers
	260	// WebKit always returns auto if the element is positioned
	261	position = elem.css( "position" );
	262	if ( position === "absolute" \|\| position === "relative" \|\| position === "fixed" ) {
	263	// IE returns 0 when zIndex is not specified
	264	// other browsers return a string
	265	// we ignore the case of nested elements with an explicit value of 0
	266	// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
	267	value = parseInt( elem.css( "zIndex" ), 10 );
	268	if ( !isNaN( value ) && value !== 0 ) {
	269	return value;
	270	}
	271	}
	272	elem = elem.parent();
	273	}
	274	}
	275
	276	return 0;
	277	}
	278	});
	279
	280	// $.ui.plugin is deprecated. Use $.widget() extensions instead.
	281	$.ui.plugin = {
	282	add: function( module, option, set ) {
	283	var i,
	284	proto = $.ui[ module ].prototype;
	285	for ( i in set ) {
	286	proto.plugins[ i ] = proto.plugins[ i ] \|\| [];
	287	proto.plugins[ i ].push( [ option, set[ i ] ] );
	288	}
	289	},
	290	call: function( instance, name, args, allowDisconnected ) {
	291	var i,
	292	set = instance.plugins[ name ];
	293
	294	if ( !set ) {
	295	return;
	296	}
	297
	298	if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode \|\| instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
	299	return;
	300	}
	301
	302	for ( i = 0; i < set.length; i++ ) {
	303	if ( instance.options[ set[ i ][ 0 ] ] ) {
	304	set[ i ][ 1 ].apply( instance.element, args );
	305	}
	306	}
	307	}
	308	};
	309
	310
	311	/*!
	312	* jQuery UI Widget 1.11.4
	313	* http://jqueryui.com
	314	*
	315	* Copyright jQuery Foundation and other contributors
	316	* Released under the MIT license.
	317	* http://jquery.org/license
	318	*
	319	* http://api.jqueryui.com/jQuery.widget/
	320	*/
	321
	322
	323	var widget_uuid = 0,
	324	widget_slice = Array.prototype.slice;
	325
	326	$.cleanData = (function( orig ) {
	327	return function( elems ) {
	328	var events, elem, i;
	329	for ( i = 0; (elem = elems[i]) != null; i++ ) {
	330	try {
	331
	332	// Only trigger remove when necessary to save time
	333	events = $._data( elem, "events" );
	334	if ( events && events.remove ) {
	335	$( elem ).triggerHandler( "remove" );
	336	}
	337
	338	// http://bugs.jquery.com/ticket/8235
	339	} catch ( e ) {}
	340	}
	341	orig( elems );
	342	};
	343	})( $.cleanData );
	344
	345	$.widget = function( name, base, prototype ) {
	346	var fullName, existingConstructor, constructor, basePrototype,
	347	// proxiedPrototype allows the provided prototype to remain unmodified
	348	// so that it can be used as a mixin for multiple widgets (#8876)
	349	proxiedPrototype = {},
	350	namespace = name.split( "." )[ 0 ];
	351
	352	name = name.split( "." )[ 1 ];
	353	fullName = namespace + "-" + name;
	354
	355	if ( !prototype ) {
	356	prototype = base;
	357	base = $.Widget;
	358	}
	359
	360	// create selector for plugin
	361	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
	362	return !!$.data( elem, fullName );
	363	};
	364
	365	$[ namespace ] = $[ namespace ] \|\| {};
	366	existingConstructor = $[ namespace ][ name ];
	367	constructor = $[ namespace ][ name ] = function( options, element ) {
	368	// allow instantiation without "new" keyword
	369	if ( !this._createWidget ) {
	370	return new constructor( options, element );
	371	}
	372
	373	// allow instantiation without initializing for simple inheritance
	374	// must use "new" keyword (the code above always passes args)
	375	if ( arguments.length ) {
	376	this._createWidget( options, element );
	377	}
	378	};
	379	// extend with the existing constructor to carry over any static properties
	380	$.extend( constructor, existingConstructor, {
	381	version: prototype.version,
	382	// copy the object used to create the prototype in case we need to
	383	// redefine the widget later
	384	_proto: $.extend( {}, prototype ),
	385	// track widgets that inherit from this widget in case this widget is
	386	// redefined after a widget inherits from it
	387	_childConstructors: []
	388	});
	389
	390	basePrototype = new base();
	391	// we need to make the options hash a property directly on the new instance
	392	// otherwise we'll modify the options hash on the prototype that we're
	393	// inheriting from
	394	basePrototype.options = $.widget.extend( {}, basePrototype.options );
	395	$.each( prototype, function( prop, value ) {
	396	if ( !$.isFunction( value ) ) {
	397	proxiedPrototype[ prop ] = value;
	398	return;
	399	}
	400	proxiedPrototype[ prop ] = (function() {
	401	var _super = function() {
	402	return base.prototype[ prop ].apply( this, arguments );
	403	},
	404	_superApply = function( args ) {
	405	return base.prototype[ prop ].apply( this, args );
	406	};
	407	return function() {
	408	var __super = this._super,
	409	__superApply = this._superApply,
	410	returnValue;
	411
	412	this._super = _super;
	413	this._superApply = _superApply;
	414
	415	returnValue = value.apply( this, arguments );
	416
	417	this._super = __super;
	418	this._superApply = __superApply;
	419
	420	return returnValue;
	421	};
	422	})();
	423	});
	424	constructor.prototype = $.widget.extend( basePrototype, {
	425	// TODO: remove support for widgetEventPrefix
	426	// always use the name + a colon as the prefix, e.g., draggable:start
	427	// don't prefix for widgets that aren't DOM-based
	428	widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix \|\| name) : name
	429	}, proxiedPrototype, {
	430	constructor: constructor,
	431	namespace: namespace,
	432	widgetName: name,
	433	widgetFullName: fullName
	434	});
	435
	436	// If this widget is being redefined then we need to find all widgets that
	437	// are inheriting from it and redefine all of them so that they inherit from
	438	// the new version of this widget. We're essentially trying to replace one
	439	// level in the prototype chain.
	440	if ( existingConstructor ) {
	441	$.each( existingConstructor._childConstructors, function( i, child ) {
	442	var childPrototype = child.prototype;
	443
	444	// redefine the child widget using the same prototype that was
	445	// originally used, but inherit from the new version of the base
	446	$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
	447	});
	448	// remove the list of existing child constructors from the old constructor
	449	// so the old child constructors can be garbage collected
	450	delete existingConstructor._childConstructors;
	451	} else {
	452	base._childConstructors.push( constructor );
	453	}
	454
	455	$.widget.bridge( name, constructor );
	456
	457	return constructor;
	458	};
	459
	460	$.widget.extend = function( target ) {
	461	var input = widget_slice.call( arguments, 1 ),
	462	inputIndex = 0,
	463	inputLength = input.length,
	464	key,
	465	value;
	466	for ( ; inputIndex < inputLength; inputIndex++ ) {
	467	for ( key in input[ inputIndex ] ) {
	468	value = input[ inputIndex ][ key ];
	469	if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
	470	// Clone objects
	471	if ( $.isPlainObject( value ) ) {
	472	target[ key ] = $.isPlainObject( target[ key ] ) ?
	473	$.widget.extend( {}, target[ key ], value ) :
	474	// Don't extend strings, arrays, etc. with objects
	475	$.widget.extend( {}, value );
	476	// Copy everything else by reference
	477	} else {
	478	target[ key ] = value;
	479	}
	480	}
	481	}
	482	}
	483	return target;
	484	};
	485
	486	$.widget.bridge = function( name, object ) {
	487	var fullName = object.prototype.widgetFullName \|\| name;
	488	$.fn[ name ] = function( options ) {
	489	var isMethodCall = typeof options === "string",
	490	args = widget_slice.call( arguments, 1 ),
	491	returnValue = this;
	492
	493	if ( isMethodCall ) {
	494	this.each(function() {
	495	var methodValue,
	496	instance = $.data( this, fullName );
	497	if ( options === "instance" ) {
	498	returnValue = instance;
	499	return false;
	500	}
	501	if ( !instance ) {
	502	return $.error( "cannot call methods on " + name + " prior to initialization; " +
	503	"attempted to call method '" + options + "'" );
	504	}
	505	if ( !$.isFunction( instance[options] ) \|\| options.charAt( 0 ) === "_" ) {
	506	return $.error( "no such method '" + options + "' for " + name + " widget instance" );
	507	}
	508	methodValue = instance[ options ].apply( instance, args );
	509	if ( methodValue !== instance && methodValue !== undefined ) {
	510	returnValue = methodValue && methodValue.jquery ?
	511	returnValue.pushStack( methodValue.get() ) :
	512	methodValue;
	513	return false;
	514	}
	515	});
	516	} else {
	517
	518	// Allow multiple hashes to be passed on init
	519	if ( args.length ) {
	520	options = $.widget.extend.apply( null, [ options ].concat(args) );
	521	}
	522
	523	this.each(function() {
	524	var instance = $.data( this, fullName );
	525	if ( instance ) {
	526	instance.option( options \|\| {} );
	527	if ( instance._init ) {
	528	instance._init();
	529	}
	530	} else {
	531	$.data( this, fullName, new object( options, this ) );
	532	}
	533	});
	534	}
	535
	536	return returnValue;
	537	};
	538	};
	539
	540	$.Widget = function( /* options, element */ ) {};
	541	$.Widget._childConstructors = [];
	542
	543	$.Widget.prototype = {
	544	widgetName: "widget",
	545	widgetEventPrefix: "",
	546	defaultElement: "<div>",
	547	options: {
	548	disabled: false,
	549
	550	// callbacks
	551	create: null
	552	},
	553	_createWidget: function( options, element ) {
	554	element = $( element \|\| this.defaultElement \|\| this )[ 0 ];
	555	this.element = $( element );
	556	this.uuid = widget_uuid++;
	557	this.eventNamespace = "." + this.widgetName + this.uuid;
	558
	559	this.bindings = $();
	560	this.hoverable = $();
	561	this.focusable = $();
	562
	563	if ( element !== this ) {
	564	$.data( element, this.widgetFullName, this );
	565	this._on( true, this.element, {
	566	remove: function( event ) {
	567	if ( event.target === element ) {
	568	this.destroy();
	569	}
	570	}
	571	});
	572	this.document = $( element.style ?
	573	// element within the document
	574	element.ownerDocument :
	575	// element is window or document
	576	element.document \|\| element );
	577	this.window = $( this.document[0].defaultView \|\| this.document[0].parentWindow );
	578	}
	579
	580	this.options = $.widget.extend( {},
	581	this.options,
	582	this._getCreateOptions(),
	583	options );
	584
	585	this._create();
	586	this._trigger( "create", null, this._getCreateEventData() );
	587	this._init();
	588	},
	589	_getCreateOptions: $.noop,
	590	_getCreateEventData: $.noop,
	591	_create: $.noop,
	592	_init: $.noop,
	593
	594	destroy: function() {
	595	this._destroy();
	596	// we can probably remove the unbind calls in 2.0
	597	// all event bindings should go through this._on()
	598	this.element
	599	.unbind( this.eventNamespace )
	600	.removeData( this.widgetFullName )
	601	// support: jquery <1.6.3
	602	// http://bugs.jquery.com/ticket/9413
	603	.removeData( $.camelCase( this.widgetFullName ) );
	604	this.widget()
	605	.unbind( this.eventNamespace )
	606	.removeAttr( "aria-disabled" )
	607	.removeClass(
	608	this.widgetFullName + "-disabled " +
	609	"ui-state-disabled" );
	610
	611	// clean up events and states
	612	this.bindings.unbind( this.eventNamespace );
	613	this.hoverable.removeClass( "ui-state-hover" );
	614	this.focusable.removeClass( "ui-state-focus" );
	615	},
	616	_destroy: $.noop,
	617
	618	widget: function() {
	619	return this.element;
	620	},
	621
	622	option: function( key, value ) {
	623	var options = key,
	624	parts,
	625	curOption,
	626	i;
	627
	628	if ( arguments.length === 0 ) {
	629	// don't return a reference to the internal hash
	630	return $.widget.extend( {}, this.options );
	631	}
	632
	633	if ( typeof key === "string" ) {
	634	// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
	635	options = {};
	636	parts = key.split( "." );
	637	key = parts.shift();
	638	if ( parts.length ) {
	639	curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
	640	for ( i = 0; i < parts.length - 1; i++ ) {
	641	curOption[ parts[ i ] ] = curOption[ parts[ i ] ] \|\| {};
	642	curOption = curOption[ parts[ i ] ];
	643	}
	644	key = parts.pop();
	645	if ( arguments.length === 1 ) {
	646	return curOption[ key ] === undefined ? null : curOption[ key ];
	647	}
	648	curOption[ key ] = value;
	649	} else {
	650	if ( arguments.length === 1 ) {
	651	return this.options[ key ] === undefined ? null : this.options[ key ];
	652	}
	653	options[ key ] = value;
	654	}
	655	}
	656
	657	this._setOptions( options );
	658
	659	return this;
	660	},
	661	_setOptions: function( options ) {
	662	var key;
	663
	664	for ( key in options ) {
	665	this._setOption( key, options[ key ] );
	666	}
	667
	668	return this;
	669	},
	670	_setOption: function( key, value ) {
	671	this.options[ key ] = value;
	672
	673	if ( key === "disabled" ) {
	674	this.widget()
	675	.toggleClass( this.widgetFullName + "-disabled", !!value );
	676
	677	// If the widget is becoming disabled, then nothing is interactive
	678	if ( value ) {
	679	this.hoverable.removeClass( "ui-state-hover" );
	680	this.focusable.removeClass( "ui-state-focus" );
	681	}
	682	}
	683
	684	return this;
	685	},
	686
	687	enable: function() {
	688	return this._setOptions({ disabled: false });
	689	},
	690	disable: function() {
	691	return this._setOptions({ disabled: true });
	692	},
	693
	694	_on: function( suppressDisabledCheck, element, handlers ) {
	695	var delegateElement,
	696	instance = this;
	697
	698	// no suppressDisabledCheck flag, shuffle arguments
	699	if ( typeof suppressDisabledCheck !== "boolean" ) {
	700	handlers = element;
	701	element = suppressDisabledCheck;
	702	suppressDisabledCheck = false;
	703	}
	704
	705	// no element argument, shuffle and use this.element
	706	if ( !handlers ) {
	707	handlers = element;
	708	element = this.element;
	709	delegateElement = this.widget();
	710	} else {
	711	element = delegateElement = $( element );
	712	this.bindings = this.bindings.add( element );
	713	}
	714
	715	$.each( handlers, function( event, handler ) {
	716	function handlerProxy() {
	717	// allow widgets to customize the disabled handling
	718	// - disabled as an array instead of boolean
	719	// - disabled class as method for disabling individual parts
	720	if ( !suppressDisabledCheck &&
	721	( instance.options.disabled === true \|\|
	722	$( this ).hasClass( "ui-state-disabled" ) ) ) {
	723	return;
	724	}
	725	return ( typeof handler === "string" ? instance[ handler ] : handler )
	726	.apply( instance, arguments );
	727	}
	728
	729	// copy the guid so direct unbinding works
	730	if ( typeof handler !== "string" ) {
	731	handlerProxy.guid = handler.guid =
	732	handler.guid \|\| handlerProxy.guid \|\| $.guid++;
	733	}
	734
	735	var match = event.match( /^([\w:-])\s(.*)$/ ),
	736	eventName = match[1] + instance.eventNamespace,
	737	selector = match[2];
	738	if ( selector ) {
	739	delegateElement.delegate( selector, eventName, handlerProxy );
	740	} else {
	741	element.bind( eventName, handlerProxy );
	742	}
	743	});
	744	},
	745
	746	_off: function( element, eventName ) {
	747	eventName = (eventName \|\| "").split( " " ).join( this.eventNamespace + " " ) +
	748	this.eventNamespace;
	749	element.unbind( eventName ).undelegate( eventName );
	750
	751	// Clear the stack to avoid memory leaks (#10056)
	752	this.bindings = $( this.bindings.not( element ).get() );
	753	this.focusable = $( this.focusable.not( element ).get() );
	754	this.hoverable = $( this.hoverable.not( element ).get() );
	755	},
	756
	757	_delay: function( handler, delay ) {
	758	function handlerProxy() {
	759	return ( typeof handler === "string" ? instance[ handler ] : handler )
	760	.apply( instance, arguments );
	761	}
	762	var instance = this;
	763	return setTimeout( handlerProxy, delay \|\| 0 );
	764	},
	765
	766	_hoverable: function( element ) {
	767	this.hoverable = this.hoverable.add( element );
	768	this._on( element, {
	769	mouseenter: function( event ) {
	770	$( event.currentTarget ).addClass( "ui-state-hover" );
	771	},
	772	mouseleave: function( event ) {
	773	$( event.currentTarget ).removeClass( "ui-state-hover" );
	774	}
	775	});
	776	},
	777
	778	_focusable: function( element ) {
	779	this.focusable = this.focusable.add( element );
	780	this._on( element, {
	781	focusin: function( event ) {
	782	$( event.currentTarget ).addClass( "ui-state-focus" );
	783	},
	784	focusout: function( event ) {
	785	$( event.currentTarget ).removeClass( "ui-state-focus" );
	786	}
	787	});
	788	},
	789
	790	_trigger: function( type, event, data ) {
	791	var prop, orig,
	792	callback = this.options[ type ];
	793
	794	data = data \|\| {};
	795	event = $.Event( event );
	796	event.type = ( type === this.widgetEventPrefix ?
	797	type :
	798	this.widgetEventPrefix + type ).toLowerCase();
	799	// the original event may come from any element
	800	// so we need to reset the target on the new event
	801	event.target = this.element[ 0 ];
	802
	803	// copy original event properties over to the new event
	804	orig = event.originalEvent;
	805	if ( orig ) {
	806	for ( prop in orig ) {
	807	if ( !( prop in event ) ) {
	808	event[ prop ] = orig[ prop ];
	809	}
	810	}
	811	}
	812
	813	this.element.trigger( event, data );
	814	return !( $.isFunction( callback ) &&
	815	callback.apply( this.element[0], [ event ].concat( data ) ) === false \|\|
	816	event.isDefaultPrevented() );
	817	}
	818	};
	819
	820	$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
	821	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
	822	if ( typeof options === "string" ) {
	823	options = { effect: options };
	824	}
	825	var hasOptions,
	826	effectName = !options ?
	827	method :
	828	options === true \|\| typeof options === "number" ?
	829	defaultEffect :
	830	options.effect \|\| defaultEffect;
	831	options = options \|\| {};
	832	if ( typeof options === "number" ) {
	833	options = { duration: options };
	834	}
	835	hasOptions = !$.isEmptyObject( options );
	836	options.complete = callback;
	837	if ( options.delay ) {
	838	element.delay( options.delay );
	839	}
	840	if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
	841	element[ method ]( options );
	842	} else if ( effectName !== method && element[ effectName ] ) {
	843	element[ effectName ]( options.duration, options.easing, callback );
	844	} else {
	845	element.queue(function( next ) {
	846	$( this )[ method ]();
	847	if ( callback ) {
	848	callback.call( element[ 0 ] );
	849	}
	850	next();
	851	});
	852	}
	853	};
	854	});
	855
	856	var widget = $.widget;
	857
	858
	859	/*!
	860	* jQuery UI Mouse 1.11.4
	861	* http://jqueryui.com
	862	*
	863	* Copyright jQuery Foundation and other contributors
	864	* Released under the MIT license.
	865	* http://jquery.org/license
	866	*
	867	* http://api.jqueryui.com/mouse/
	868	*/
	869
	870
	871	var mouseHandled = false;
	872	$( document ).mouseup( function() {
	873	mouseHandled = false;
	874	});
	875
	876	var mouse = $.widget("ui.mouse", {
	877	version: "1.11.4",
	878	options: {
	879	cancel: "input,textarea,button,select,option",
	880	distance: 1,
	881	delay: 0
	882	},
	883	_mouseInit: function() {
	884	var that = this;
	885
	886	this.element
	887	.bind("mousedown." + this.widgetName, function(event) {
	888	return that._mouseDown(event);
	889	})
	890	.bind("click." + this.widgetName, function(event) {
	891	if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
	892	$.removeData(event.target, that.widgetName + ".preventClickEvent");
	893	event.stopImmediatePropagation();
	894	return false;
	895	}
	896	});
	897
	898	this.started = false;
	899	},
	900
	901	// TODO: make sure destroying one instance of mouse doesn't mess with
	902	// other instances of mouse
	903	_mouseDestroy: function() {
	904	this.element.unbind("." + this.widgetName);
	905	if ( this._mouseMoveDelegate ) {
	906	this.document
	907	.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
	908	.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
	909	}
	910	},
	911
	912	_mouseDown: function(event) {
	913	// don't let more than one widget handle mouseStart
	914	if ( mouseHandled ) {
	915	return;
	916	}
	917
	918	this._mouseMoved = false;
	919
	920	// we may have missed mouseup (out of window)
	921	(this._mouseStarted && this._mouseUp(event));
	922
	923	this._mouseDownEvent = event;
	924
	925	var that = this,
	926	btnIsLeft = (event.which === 1),
	927	// event.target.nodeName works around a bug in IE 8 with
	928	// disabled inputs (#7620)
	929	elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
	930	if (!btnIsLeft \|\| elIsCancel \|\| !this._mouseCapture(event)) {
	931	return true;
	932	}
	933
	934	this.mouseDelayMet = !this.options.delay;
	935	if (!this.mouseDelayMet) {
	936	this._mouseDelayTimer = setTimeout(function() {
	937	that.mouseDelayMet = true;
	938	}, this.options.delay);
	939	}
	940
	941	if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
	942	this._mouseStarted = (this._mouseStart(event) !== false);
	943	if (!this._mouseStarted) {
	944	event.preventDefault();
	945	return true;
	946	}
	947	}
	948
	949	// Click event may never have fired (Gecko & Opera)
	950	if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
	951	$.removeData(event.target, this.widgetName + ".preventClickEvent");
	952	}
	953
	954	// these delegates are required to keep context
	955	this._mouseMoveDelegate = function(event) {
	956	return that._mouseMove(event);
	957	};
	958	this._mouseUpDelegate = function(event) {
	959	return that._mouseUp(event);
	960	};
	961
	962	this.document
	963	.bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
	964	.bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
	965
	966	event.preventDefault();
	967
	968	mouseHandled = true;
	969	return true;
	970	},
	971
	972	_mouseMove: function(event) {
	973	// Only check for mouseups outside the document if you've moved inside the document
	974	// at least once. This prevents the firing of mouseup in the case of IE<9, which will
	975	// fire a mousemove event if content is placed under the cursor. See #7778
	976	// Support: IE <9
	977	if ( this._mouseMoved ) {
	978	// IE mouseup check - mouseup happened when mouse was out of window
	979	if ($.ui.ie && ( !document.documentMode \|\| document.documentMode < 9 ) && !event.button) {
	980	return this._mouseUp(event);
	981
	982	// Iframe mouseup check - mouseup occurred in another document
	983	} else if ( !event.which ) {
	984	return this._mouseUp( event );
	985	}
	986	}
	987
	988	if ( event.which \|\| event.button ) {
	989	this._mouseMoved = true;
	990	}
	991
	992	if (this._mouseStarted) {
	993	this._mouseDrag(event);
	994	return event.preventDefault();
	995	}
	996
	997	if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
	998	this._mouseStarted =
	999	(this._mouseStart(this._mouseDownEvent, event) !== false);
	1000	(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
	1001	}
	1002
	1003	return !this._mouseStarted;
	1004	},
	1005
	1006	_mouseUp: function(event) {
	1007	this.document
	1008	.unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
	1009	.unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
	1010
	1011	if (this._mouseStarted) {
	1012	this._mouseStarted = false;
	1013
	1014	if (event.target === this._mouseDownEvent.target) {
	1015	$.data(event.target, this.widgetName + ".preventClickEvent", true);
	1016	}
	1017
	1018	this._mouseStop(event);
	1019	}
	1020
	1021	mouseHandled = false;
	1022	return false;
	1023	},
	1024
	1025	_mouseDistanceMet: function(event) {
	1026	return (Math.max(
	1027	Math.abs(this._mouseDownEvent.pageX - event.pageX),
	1028	Math.abs(this._mouseDownEvent.pageY - event.pageY)
	1029	) >= this.options.distance
	1030	);
	1031	},
	1032
	1033	_mouseDelayMet: function(/* event */) {
	1034	return this.mouseDelayMet;
	1035	},
	1036
	1037	// These are placeholder methods, to be overriden by extending plugin
	1038	_mouseStart: function(/* event */) {},
	1039	_mouseDrag: function(/* event */) {},
	1040	_mouseStop: function(/* event */) {},
	1041	_mouseCapture: function(/* event */) { return true; }
	1042	});
	1043
	1044
	1045	/*!
	1046	* jQuery UI Position 1.11.4
	1047	* http://jqueryui.com
	1048	*
	1049	* Copyright jQuery Foundation and other contributors
	1050	* Released under the MIT license.
	1051	* http://jquery.org/license
	1052	*
	1053	* http://api.jqueryui.com/position/
	1054	*/
	1055
	1056	(function() {
	1057
	1058	$.ui = $.ui \|\| {};
	1059
	1060	var cachedScrollbarWidth, supportsOffsetFractions,
	1061	max = Math.max,
	1062	abs = Math.abs,
	1063	round = Math.round,
	1064	rhorizontal = /left\|center\|right/,
	1065	rvertical = /top\|center\|bottom/,
	1066	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
	1067	rposition = /^\w+/,
	1068	rpercent = /%$/,
	1069	_position = $.fn.position;
	1070
	1071	function getOffsets( offsets, width, height ) {
	1072	return [
	1073	parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
	1074	parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
	1075	];
	1076	}
	1077
	1078	function parseCss( element, property ) {
	1079	return parseInt( $.css( element, property ), 10 ) \|\| 0;
	1080	}
	1081
	1082	function getDimensions( elem ) {
	1083	var raw = elem[0];
	1084	if ( raw.nodeType === 9 ) {
	1085	return {
	1086	width: elem.width(),
	1087	height: elem.height(),
	1088	offset: { top: 0, left: 0 }
	1089	};
	1090	}
	1091	if ( $.isWindow( raw ) ) {
	1092	return {
	1093	width: elem.width(),
	1094	height: elem.height(),
	1095	offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
	1096	};
	1097	}
	1098	if ( raw.preventDefault ) {
	1099	return {
	1100	width: 0,
	1101	height: 0,
	1102	offset: { top: raw.pageY, left: raw.pageX }
	1103	};
	1104	}
	1105	return {
	1106	width: elem.outerWidth(),
	1107	height: elem.outerHeight(),
	1108	offset: elem.offset()
	1109	};
	1110	}
	1111
	1112	$.position = {
	1113	scrollbarWidth: function() {
	1114	if ( cachedScrollbarWidth !== undefined ) {
	1115	return cachedScrollbarWidth;
	1116	}
	1117	var w1, w2,
	1118	div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
	1119	innerDiv = div.children()[0];
	1120
	1121	$( "body" ).append( div );
	1122	w1 = innerDiv.offsetWidth;
	1123	div.css( "overflow", "scroll" );
	1124
	1125	w2 = innerDiv.offsetWidth;
	1126
	1127	if ( w1 === w2 ) {
	1128	w2 = div[0].clientWidth;
	1129	}
	1130
	1131	div.remove();
	1132
	1133	return (cachedScrollbarWidth = w1 - w2);
	1134	},
	1135	getScrollInfo: function( within ) {
	1136	var overflowX = within.isWindow \|\| within.isDocument ? "" :
	1137	within.element.css( "overflow-x" ),
	1138	overflowY = within.isWindow \|\| within.isDocument ? "" :
	1139	within.element.css( "overflow-y" ),
	1140	hasOverflowX = overflowX === "scroll" \|\|
	1141	( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
	1142	hasOverflowY = overflowY === "scroll" \|\|
	1143	( overflowY === "auto" && within.height < within.element[0].scrollHeight );
	1144	return {
	1145	width: hasOverflowY ? $.position.scrollbarWidth() : 0,
	1146	height: hasOverflowX ? $.position.scrollbarWidth() : 0
	1147	};
	1148	},
	1149	getWithinInfo: function( element ) {
	1150	var withinElement = $( element \|\| window ),
	1151	isWindow = $.isWindow( withinElement[0] ),
	1152	isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
	1153	return {
	1154	element: withinElement,
	1155	isWindow: isWindow,
	1156	isDocument: isDocument,
	1157	offset: withinElement.offset() \|\| { left: 0, top: 0 },
	1158	scrollLeft: withinElement.scrollLeft(),
	1159	scrollTop: withinElement.scrollTop(),
	1160
	1161	// support: jQuery 1.6.x
	1162	// jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
	1163	width: isWindow \|\| isDocument ? withinElement.width() : withinElement.outerWidth(),
	1164	height: isWindow \|\| isDocument ? withinElement.height() : withinElement.outerHeight()
	1165	};
	1166	}
	1167	};
	1168
	1169	$.fn.position = function( options ) {
	1170	if ( !options \|\| !options.of ) {
	1171	return _position.apply( this, arguments );
	1172	}
	1173
	1174	// make a copy, we don't want to modify arguments
	1175	options = $.extend( {}, options );
	1176
	1177	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
	1178	target = $( options.of ),
	1179	within = $.position.getWithinInfo( options.within ),
	1180	scrollInfo = $.position.getScrollInfo( within ),
	1181	collision = ( options.collision \|\| "flip" ).split( " " ),
	1182	offsets = {};
	1183
	1184	dimensions = getDimensions( target );
	1185	if ( target[0].preventDefault ) {
	1186	// force left top to allow flipping
	1187	options.at = "left top";
	1188	}
	1189	targetWidth = dimensions.width;
	1190	targetHeight = dimensions.height;
	1191	targetOffset = dimensions.offset;
	1192	// clone to reuse original targetOffset later
	1193	basePosition = $.extend( {}, targetOffset );
	1194
	1195	// force my and at to have valid horizontal and vertical positions
	1196	// if a value is missing or invalid, it will be converted to center
	1197	$.each( [ "my", "at" ], function() {
	1198	var pos = ( options[ this ] \|\| "" ).split( " " ),
	1199	horizontalOffset,
	1200	verticalOffset;
	1201
	1202	if ( pos.length === 1) {
	1203	pos = rhorizontal.test( pos[ 0 ] ) ?
	1204	pos.concat( [ "center" ] ) :
	1205	rvertical.test( pos[ 0 ] ) ?
	1206	[ "center" ].concat( pos ) :
	1207	[ "center", "center" ];
	1208	}
	1209	pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
	1210	pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
	1211
	1212	// calculate offsets
	1213	horizontalOffset = roffset.exec( pos[ 0 ] );
	1214	verticalOffset = roffset.exec( pos[ 1 ] );
	1215	offsets[ this ] = [
	1216	horizontalOffset ? horizontalOffset[ 0 ] : 0,
	1217	verticalOffset ? verticalOffset[ 0 ] : 0
	1218	];
	1219
	1220	// reduce to just the positions without the offsets
	1221	options[ this ] = [
	1222	rposition.exec( pos[ 0 ] )[ 0 ],
	1223	rposition.exec( pos[ 1 ] )[ 0 ]
	1224	];
	1225	});
	1226
	1227	// normalize collision option
	1228	if ( collision.length === 1 ) {
	1229	collision[ 1 ] = collision[ 0 ];
	1230	}
	1231
	1232	if ( options.at[ 0 ] === "right" ) {
	1233	basePosition.left += targetWidth;
	1234	} else if ( options.at[ 0 ] === "center" ) {
	1235	basePosition.left += targetWidth / 2;
	1236	}
	1237
	1238	if ( options.at[ 1 ] === "bottom" ) {
	1239	basePosition.top += targetHeight;
	1240	} else if ( options.at[ 1 ] === "center" ) {
	1241	basePosition.top += targetHeight / 2;
	1242	}
	1243
	1244	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
	1245	basePosition.left += atOffset[ 0 ];
	1246	basePosition.top += atOffset[ 1 ];
	1247
	1248	return this.each(function() {
	1249	var collisionPosition, using,
	1250	elem = $( this ),
	1251	elemWidth = elem.outerWidth(),
	1252	elemHeight = elem.outerHeight(),
	1253	marginLeft = parseCss( this, "marginLeft" ),
	1254	marginTop = parseCss( this, "marginTop" ),
	1255	collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
	1256	collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
	1257	position = $.extend( {}, basePosition ),
	1258	myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
	1259
	1260	if ( options.my[ 0 ] === "right" ) {
	1261	position.left -= elemWidth;
	1262	} else if ( options.my[ 0 ] === "center" ) {
	1263	position.left -= elemWidth / 2;
	1264	}
	1265
	1266	if ( options.my[ 1 ] === "bottom" ) {
	1267	position.top -= elemHeight;
	1268	} else if ( options.my[ 1 ] === "center" ) {
	1269	position.top -= elemHeight / 2;
	1270	}
	1271
	1272	position.left += myOffset[ 0 ];
	1273	position.top += myOffset[ 1 ];
	1274
	1275	// if the browser doesn't support fractions, then round for consistent results
	1276	if ( !supportsOffsetFractions ) {
	1277	position.left = round( position.left );
	1278	position.top = round( position.top );
	1279	}
	1280
	1281	collisionPosition = {
	1282	marginLeft: marginLeft,
	1283	marginTop: marginTop
	1284	};
	1285
	1286	$.each( [ "left", "top" ], function( i, dir ) {
	1287	if ( $.ui.position[ collision[ i ] ] ) {
	1288	$.ui.position[ collision[ i ] ][ dir ]( position, {
	1289	targetWidth: targetWidth,
	1290	targetHeight: targetHeight,
	1291	elemWidth: elemWidth,
	1292	elemHeight: elemHeight,
	1293	collisionPosition: collisionPosition,
	1294	collisionWidth: collisionWidth,
	1295	collisionHeight: collisionHeight,
	1296	offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
	1297	my: options.my,
	1298	at: options.at,
	1299	within: within,
	1300	elem: elem
	1301	});
	1302	}
	1303	});
	1304
	1305	if ( options.using ) {
	1306	// adds feedback as second argument to using callback, if present
	1307	using = function( props ) {
	1308	var left = targetOffset.left - position.left,
	1309	right = left + targetWidth - elemWidth,
	1310	top = targetOffset.top - position.top,
	1311	bottom = top + targetHeight - elemHeight,
	1312	feedback = {
	1313	target: {
	1314	element: target,
	1315	left: targetOffset.left,
	1316	top: targetOffset.top,
	1317	width: targetWidth,
	1318	height: targetHeight
	1319	},
	1320	element: {
	1321	element: elem,
	1322	left: position.left,
	1323	top: position.top,
	1324	width: elemWidth,
	1325	height: elemHeight
	1326	},
	1327	horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
	1328	vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
	1329	};
	1330	if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
	1331	feedback.horizontal = "center";
	1332	}
	1333	if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
	1334	feedback.vertical = "middle";
	1335	}
	1336	if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
	1337	feedback.important = "horizontal";
	1338	} else {
	1339	feedback.important = "vertical";
	1340	}
	1341	options.using.call( this, props, feedback );
	1342	};
	1343	}
	1344
	1345	elem.offset( $.extend( position, { using: using } ) );
	1346	});
	1347	};
	1348
	1349	$.ui.position = {
	1350	fit: {
	1351	left: function( position, data ) {
	1352	var within = data.within,
	1353	withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
	1354	outerWidth = within.width,
	1355	collisionPosLeft = position.left - data.collisionPosition.marginLeft,
	1356	overLeft = withinOffset - collisionPosLeft,
	1357	overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
	1358	newOverRight;
	1359
	1360	// element is wider than within
	1361	if ( data.collisionWidth > outerWidth ) {
	1362	// element is initially over the left side of within
	1363	if ( overLeft > 0 && overRight <= 0 ) {
	1364	newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
	1365	position.left += overLeft - newOverRight;
	1366	// element is initially over right side of within
	1367	} else if ( overRight > 0 && overLeft <= 0 ) {
	1368	position.left = withinOffset;
	1369	// element is initially over both left and right sides of within
	1370	} else {
	1371	if ( overLeft > overRight ) {
	1372	position.left = withinOffset + outerWidth - data.collisionWidth;
	1373	} else {
	1374	position.left = withinOffset;
	1375	}
	1376	}
	1377	// too far left -> align with left edge
	1378	} else if ( overLeft > 0 ) {
	1379	position.left += overLeft;
	1380	// too far right -> align with right edge
	1381	} else if ( overRight > 0 ) {
	1382	position.left -= overRight;
	1383	// adjust based on position and margin
	1384	} else {
	1385	position.left = max( position.left - collisionPosLeft, position.left );
	1386	}
	1387	},
	1388	top: function( position, data ) {
	1389	var within = data.within,
	1390	withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
	1391	outerHeight = data.within.height,
	1392	collisionPosTop = position.top - data.collisionPosition.marginTop,
	1393	overTop = withinOffset - collisionPosTop,
	1394	overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
	1395	newOverBottom;
	1396
	1397	// element is taller than within
	1398	if ( data.collisionHeight > outerHeight ) {
	1399	// element is initially over the top of within
	1400	if ( overTop > 0 && overBottom <= 0 ) {
	1401	newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
	1402	position.top += overTop - newOverBottom;
	1403	// element is initially over bottom of within
	1404	} else if ( overBottom > 0 && overTop <= 0 ) {
	1405	position.top = withinOffset;
	1406	// element is initially over both top and bottom of within
	1407	} else {
	1408	if ( overTop > overBottom ) {
	1409	position.top = withinOffset + outerHeight - data.collisionHeight;
	1410	} else {
	1411	position.top = withinOffset;
	1412	}
	1413	}
	1414	// too far up -> align with top
	1415	} else if ( overTop > 0 ) {
	1416	position.top += overTop;
	1417	// too far down -> align with bottom edge
	1418	} else if ( overBottom > 0 ) {
	1419	position.top -= overBottom;
	1420	// adjust based on position and margin
	1421	} else {
	1422	position.top = max( position.top - collisionPosTop, position.top );
	1423	}
	1424	}
	1425	},
	1426	flip: {
	1427	left: function( position, data ) {
	1428	var within = data.within,
	1429	withinOffset = within.offset.left + within.scrollLeft,
	1430	outerWidth = within.width,
	1431	offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
	1432	collisionPosLeft = position.left - data.collisionPosition.marginLeft,
	1433	overLeft = collisionPosLeft - offsetLeft,
	1434	overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
	1435	myOffset = data.my[ 0 ] === "left" ?
	1436	-data.elemWidth :
	1437	data.my[ 0 ] === "right" ?
	1438	data.elemWidth :
	1439	0,
	1440	atOffset = data.at[ 0 ] === "left" ?
	1441	data.targetWidth :
	1442	data.at[ 0 ] === "right" ?
	1443	-data.targetWidth :
	1444	0,
	1445	offset = -2 * data.offset[ 0 ],
	1446	newOverRight,
	1447	newOverLeft;
	1448
	1449	if ( overLeft < 0 ) {
	1450	newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
	1451	if ( newOverRight < 0 \|\| newOverRight < abs( overLeft ) ) {
	1452	position.left += myOffset + atOffset + offset;
	1453	}
	1454	} else if ( overRight > 0 ) {
	1455	newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
	1456	if ( newOverLeft > 0 \|\| abs( newOverLeft ) < overRight ) {
	1457	position.left += myOffset + atOffset + offset;
	1458	}
	1459	}
	1460	},
	1461	top: function( position, data ) {
	1462	var within = data.within,
	1463	withinOffset = within.offset.top + within.scrollTop,
	1464	outerHeight = within.height,
	1465	offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
	1466	collisionPosTop = position.top - data.collisionPosition.marginTop,
	1467	overTop = collisionPosTop - offsetTop,
	1468	overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
	1469	top = data.my[ 1 ] === "top",
	1470	myOffset = top ?
	1471	-data.elemHeight :
	1472	data.my[ 1 ] === "bottom" ?
	1473	data.elemHeight :
	1474	0,
	1475	atOffset = data.at[ 1 ] === "top" ?
	1476	data.targetHeight :
	1477	data.at[ 1 ] === "bottom" ?
	1478	-data.targetHeight :
	1479	0,
	1480	offset = -2 * data.offset[ 1 ],
	1481	newOverTop,
	1482	newOverBottom;
	1483	if ( overTop < 0 ) {
	1484	newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
	1485	if ( newOverBottom < 0 \|\| newOverBottom < abs( overTop ) ) {
	1486	position.top += myOffset + atOffset + offset;
	1487	}
	1488	} else if ( overBottom > 0 ) {
	1489	newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
	1490	if ( newOverTop > 0 \|\| abs( newOverTop ) < overBottom ) {
	1491	position.top += myOffset + atOffset + offset;
	1492	}
	1493	}
	1494	}
	1495	},
	1496	flipfit: {
	1497	left: function() {
	1498	$.ui.position.flip.left.apply( this, arguments );
	1499	$.ui.position.fit.left.apply( this, arguments );
	1500	},
	1501	top: function() {
	1502	$.ui.position.flip.top.apply( this, arguments );
	1503	$.ui.position.fit.top.apply( this, arguments );
	1504	}
	1505	}
	1506	};
	1507
	1508	// fraction support test
	1509	(function() {
	1510	var testElement, testElementParent, testElementStyle, offsetLeft, i,
	1511	body = document.getElementsByTagName( "body" )[ 0 ],
	1512	div = document.createElement( "div" );
	1513
	1514	//Create a "fake body" for testing based on method used in jQuery.support
	1515	testElement = document.createElement( body ? "div" : "body" );
	1516	testElementStyle = {
	1517	visibility: "hidden",
	1518	width: 0,
	1519	height: 0,
	1520	border: 0,
	1521	margin: 0,
	1522	background: "none"
	1523	};
	1524	if ( body ) {
	1525	$.extend( testElementStyle, {
	1526	position: "absolute",
	1527	left: "-1000px",
	1528	top: "-1000px"
	1529	});
	1530	}
	1531	for ( i in testElementStyle ) {
	1532	testElement.style[ i ] = testElementStyle[ i ];
	1533	}
	1534	testElement.appendChild( div );
	1535	testElementParent = body \|\| document.documentElement;
	1536	testElementParent.insertBefore( testElement, testElementParent.firstChild );
	1537
	1538	div.style.cssText = "position: absolute; left: 10.7432222px;";
	1539
	1540	offsetLeft = $( div ).offset().left;
	1541	supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
	1542
	1543	testElement.innerHTML = "";
	1544	testElementParent.removeChild( testElement );
	1545	})();
	1546
	1547	})();
	1548
	1549	var position = $.ui.position;
	1550
	1551
	1552	/*!
	1553	* jQuery UI Draggable 1.11.4
	1554	* http://jqueryui.com
	1555	*
	1556	* Copyright jQuery Foundation and other contributors
	1557	* Released under the MIT license.
	1558	* http://jquery.org/license
	1559	*
	1560	* http://api.jqueryui.com/draggable/
	1561	*/
	1562
	1563
	1564	$.widget("ui.draggable", $.ui.mouse, {
	1565	version: "1.11.4",
	1566	widgetEventPrefix: "drag",
	1567	options: {
	1568	addClasses: true,
	1569	appendTo: "parent",
	1570	axis: false,
	1571	connectToSortable: false,
	1572	containment: false,
	1573	cursor: "auto",
	1574	cursorAt: false,
	1575	grid: false,
	1576	handle: false,
	1577	helper: "original",
	1578	iframeFix: false,
	1579	opacity: false,
	1580	refreshPositions: false,
	1581	revert: false,
	1582	revertDuration: 500,
	1583	scope: "default",
	1584	scroll: true,
	1585	scrollSensitivity: 20,
	1586	scrollSpeed: 20,
	1587	snap: false,
	1588	snapMode: "both",
	1589	snapTolerance: 20,
	1590	stack: false,
	1591	zIndex: false,
	1592
	1593	// callbacks
	1594	drag: null,
	1595	start: null,
	1596	stop: null
	1597	},
	1598	_create: function() {
	1599
	1600	if ( this.options.helper === "original" ) {
	1601	this._setPositionRelative();
	1602	}
	1603	if (this.options.addClasses){
	1604	this.element.addClass("ui-draggable");
	1605	}
	1606	if (this.options.disabled){
	1607	this.element.addClass("ui-draggable-disabled");
	1608	}
	1609	this._setHandleClassName();
	1610
	1611	this._mouseInit();
	1612	},
	1613
	1614	_setOption: function( key, value ) {
	1615	this._super( key, value );
	1616	if ( key === "handle" ) {
	1617	this._removeHandleClassName();
	1618	this._setHandleClassName();
	1619	}
	1620	},
	1621
	1622	_destroy: function() {
	1623	if ( ( this.helper \|\| this.element ).is( ".ui-draggable-dragging" ) ) {
	1624	this.destroyOnClear = true;
	1625	return;
	1626	}
	1627	this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
	1628	this._removeHandleClassName();
	1629	this._mouseDestroy();
	1630	},
	1631
	1632	_mouseCapture: function(event) {
	1633	var o = this.options;
	1634
	1635	this._blurActiveElement( event );
	1636
	1637	// among others, prevent a drag on a resizable-handle
	1638	if (this.helper \|\| o.disabled \|\| $(event.target).closest(".ui-resizable-handle").length > 0) {
	1639	return false;
	1640	}
	1641
	1642	//Quit if we're not on a valid handle
	1643	this.handle = this._getHandle(event);
	1644	if (!this.handle) {
	1645	return false;
	1646	}
	1647
	1648	this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
	1649
	1650	return true;
	1651
	1652	},
	1653
	1654	_blockFrames: function( selector ) {
	1655	this.iframeBlocks = this.document.find( selector ).map(function() {
	1656	var iframe = $( this );
	1657
	1658	return $( "<div>" )
	1659	.css( "position", "absolute" )
	1660	.appendTo( iframe.parent() )
	1661	.outerWidth( iframe.outerWidth() )
	1662	.outerHeight( iframe.outerHeight() )
	1663	.offset( iframe.offset() )[ 0 ];
	1664	});
	1665	},
	1666
	1667	_unblockFrames: function() {
	1668	if ( this.iframeBlocks ) {
	1669	this.iframeBlocks.remove();
	1670	delete this.iframeBlocks;
	1671	}
	1672	},
	1673
	1674	_blurActiveElement: function( event ) {
	1675	var document = this.document[ 0 ];
	1676
	1677	// Only need to blur if the event occurred on the draggable itself, see #10527
	1678	if ( !this.handleElement.is( event.target ) ) {
	1679	return;
	1680	}
	1681
	1682	// support: IE9
	1683	// IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
	1684	try {
	1685
	1686	// Support: IE9, IE10
	1687	// If the <body> is blurred, IE will switch windows, see #9520
	1688	if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
	1689
	1690	// Blur any element that currently has focus, see #4261
	1691	$( document.activeElement ).blur();
	1692	}
	1693	} catch ( error ) {}
	1694	},
	1695
	1696	_mouseStart: function(event) {
	1697
	1698	var o = this.options;
	1699
	1700	//Create and append the visible helper
	1701	this.helper = this._createHelper(event);
	1702
	1703	this.helper.addClass("ui-draggable-dragging");
	1704
	1705	//Cache the helper size
	1706	this._cacheHelperProportions();
	1707
	1708	//If ddmanager is used for droppables, set the global draggable
	1709	if ($.ui.ddmanager) {
	1710	$.ui.ddmanager.current = this;
	1711	}
	1712
	1713	/*
	1714	* - Position generation -
	1715	* This block generates everything position related - it's the core of draggables.
	1716	*/
	1717
	1718	//Cache the margins of the original element
	1719	this._cacheMargins();
	1720
	1721	//Store the helper's css position
	1722	this.cssPosition = this.helper.css( "position" );
	1723	this.scrollParent = this.helper.scrollParent( true );
	1724	this.offsetParent = this.helper.offsetParent();
	1725	this.hasFixedAncestor = this.helper.parents().filter(function() {
	1726	return $( this ).css( "position" ) === "fixed";
	1727	}).length > 0;
	1728
	1729	//The element's absolute position on the page minus margins
	1730	this.positionAbs = this.element.offset();
	1731	this._refreshOffsets( event );
	1732
	1733	//Generate the original position
	1734	this.originalPosition = this.position = this._generatePosition( event, false );
	1735	this.originalPageX = event.pageX;
	1736	this.originalPageY = event.pageY;
	1737
	1738	//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
	1739	(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
	1740
	1741	//Set a containment if given in the options
	1742	this._setContainment();
	1743
	1744	//Trigger event + callbacks
	1745	if (this._trigger("start", event) === false) {
	1746	this._clear();
	1747	return false;
	1748	}
	1749
	1750	//Recache the helper size
	1751	this._cacheHelperProportions();
	1752
	1753	//Prepare the droppable offsets
	1754	if ($.ui.ddmanager && !o.dropBehaviour) {
	1755	$.ui.ddmanager.prepareOffsets(this, event);
	1756	}
	1757
	1758	// Reset helper's right/bottom css if they're set and set explicit width/height instead
	1759	// as this prevents resizing of elements with right/bottom set (see #7772)
	1760	this._normalizeRightBottom();
	1761
	1762	this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
	1763
	1764	//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
	1765	if ( $.ui.ddmanager ) {
	1766	$.ui.ddmanager.dragStart(this, event);
	1767	}
	1768
	1769	return true;
	1770	},
	1771
	1772	_refreshOffsets: function( event ) {
	1773	this.offset = {
	1774	top: this.positionAbs.top - this.margins.top,
	1775	left: this.positionAbs.left - this.margins.left,
	1776	scroll: false,
	1777	parent: this._getParentOffset(),
	1778	relative: this._getRelativeOffset()
	1779	};
	1780
	1781	this.offset.click = {
	1782	left: event.pageX - this.offset.left,
	1783	top: event.pageY - this.offset.top
	1784	};
	1785	},
	1786
	1787	_mouseDrag: function(event, noPropagation) {
	1788	// reset any necessary cached properties (see #5009)
	1789	if ( this.hasFixedAncestor ) {
	1790	this.offset.parent = this._getParentOffset();
	1791	}
	1792
	1793	//Compute the helpers position
	1794	this.position = this._generatePosition( event, true );
	1795	this.positionAbs = this._convertPositionTo("absolute");
	1796
	1797	//Call plugins and callbacks and use the resulting position if something is returned
	1798	if (!noPropagation) {
	1799	var ui = this._uiHash();
	1800	if (this._trigger("drag", event, ui) === false) {
	1801	this._mouseUp({});
	1802	return false;
	1803	}
	1804	this.position = ui.position;
	1805	}
	1806
	1807	this.helper[ 0 ].style.left = this.position.left + "px";
	1808	this.helper[ 0 ].style.top = this.position.top + "px";
	1809
	1810	if ($.ui.ddmanager) {
	1811	$.ui.ddmanager.drag(this, event);
	1812	}
	1813
	1814	return false;
	1815	},
	1816
	1817	_mouseStop: function(event) {
	1818
	1819	//If we are using droppables, inform the manager about the drop
	1820	var that = this,
	1821	dropped = false;
	1822	if ($.ui.ddmanager && !this.options.dropBehaviour) {
	1823	dropped = $.ui.ddmanager.drop(this, event);
	1824	}
	1825
	1826	//if a drop comes from outside (a sortable)
	1827	if (this.dropped) {
	1828	dropped = this.dropped;
	1829	this.dropped = false;
	1830	}
	1831
	1832	if ((this.options.revert === "invalid" && !dropped) \|\| (this.options.revert === "valid" && dropped) \|\| this.options.revert === true \|\| ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
	1833	$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
	1834	if (that._trigger("stop", event) !== false) {
	1835	that._clear();
	1836	}
	1837	});
	1838	} else {
	1839	if (this._trigger("stop", event) !== false) {
	1840	this._clear();
	1841	}
	1842	}
	1843
	1844	return false;
	1845	},
	1846
	1847	_mouseUp: function( event ) {
	1848	this._unblockFrames();
	1849
	1850	//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
	1851	if ( $.ui.ddmanager ) {
	1852	$.ui.ddmanager.dragStop(this, event);
	1853	}
	1854
	1855	// Only need to focus if the event occurred on the draggable itself, see #10527
	1856	if ( this.handleElement.is( event.target ) ) {
	1857	// The interaction is over; whether or not the click resulted in a drag, focus the element
	1858	this.element.focus();
	1859	}
	1860
	1861	return $.ui.mouse.prototype._mouseUp.call(this, event);
	1862	},
	1863
	1864	cancel: function() {
	1865
	1866	if (this.helper.is(".ui-draggable-dragging")) {
	1867	this._mouseUp({});
	1868	} else {
	1869	this._clear();
	1870	}
	1871
	1872	return this;
	1873
	1874	},
	1875
	1876	_getHandle: function(event) {
	1877	return this.options.handle ?
	1878	!!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
	1879	true;
	1880	},
	1881
	1882	_setHandleClassName: function() {
	1883	this.handleElement = this.options.handle ?
	1884	this.element.find( this.options.handle ) : this.element;
	1885	this.handleElement.addClass( "ui-draggable-handle" );
	1886	},
	1887
	1888	_removeHandleClassName: function() {
	1889	this.handleElement.removeClass( "ui-draggable-handle" );
	1890	},
	1891
	1892	_createHelper: function(event) {
	1893
	1894	var o = this.options,
	1895	helperIsFunction = $.isFunction( o.helper ),
	1896	helper = helperIsFunction ?
	1897	$( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
	1898	( o.helper === "clone" ?
	1899	this.element.clone().removeAttr( "id" ) :
	1900	this.element );
	1901
	1902	if (!helper.parents("body").length) {
	1903	helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
	1904	}
	1905
	1906	// http://bugs.jqueryui.com/ticket/9446
	1907	// a helper function can return the original element
	1908	// which wouldn't have been set to relative in _create
	1909	if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
	1910	this._setPositionRelative();
	1911	}
	1912
	1913	if (helper[0] !== this.element[0] && !(/(fixed\|absolute)/).test(helper.css("position"))) {
	1914	helper.css("position", "absolute");
	1915	}
	1916
	1917	return helper;
	1918
	1919	},
	1920
	1921	_setPositionRelative: function() {
	1922	if ( !( /^(?:r\|a\|f)/ ).test( this.element.css( "position" ) ) ) {
	1923	this.element[ 0 ].style.position = "relative";
	1924	}
	1925	},
	1926
	1927	_adjustOffsetFromHelper: function(obj) {
	1928	if (typeof obj === "string") {
	1929	obj = obj.split(" ");
	1930	}
	1931	if ($.isArray(obj)) {
	1932	obj = { left: +obj[0], top: +obj[1] \|\| 0 };
	1933	}
	1934	if ("left" in obj) {
	1935	this.offset.click.left = obj.left + this.margins.left;
	1936	}
	1937	if ("right" in obj) {
	1938	this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
	1939	}
	1940	if ("top" in obj) {
	1941	this.offset.click.top = obj.top + this.margins.top;
	1942	}
	1943	if ("bottom" in obj) {
	1944	this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
	1945	}
	1946	},
	1947
	1948	_isRootNode: function( element ) {
	1949	return ( /(html\|body)/i ).test( element.tagName ) \|\| element === this.document[ 0 ];
	1950	},
	1951
	1952	_getParentOffset: function() {
	1953
	1954	//Get the offsetParent and cache its position
	1955	var po = this.offsetParent.offset(),
	1956	document = this.document[ 0 ];
	1957
	1958	// This is a special case where we need to modify a offset calculated on start, since the following happened:
	1959	// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
	1960	// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
	1961	// the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
	1962	if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
	1963	po.left += this.scrollParent.scrollLeft();
	1964	po.top += this.scrollParent.scrollTop();
	1965	}
	1966
	1967	if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
	1968	po = { top: 0, left: 0 };
	1969	}
	1970
	1971	return {
	1972	top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) \|\| 0),
	1973	left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) \|\| 0)
	1974	};
	1975
	1976	},
	1977
	1978	_getRelativeOffset: function() {
	1979	if ( this.cssPosition !== "relative" ) {
	1980	return { top: 0, left: 0 };
	1981	}
	1982
	1983	var p = this.element.position(),
	1984	scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
	1985
	1986	return {
	1987	top: p.top - ( parseInt(this.helper.css( "top" ), 10) \|\| 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
	1988	left: p.left - ( parseInt(this.helper.css( "left" ), 10) \|\| 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
	1989	};
	1990
	1991	},
	1992
	1993	_cacheMargins: function() {
	1994	this.margins = {
	1995	left: (parseInt(this.element.css("marginLeft"), 10) \|\| 0),
	1996	top: (parseInt(this.element.css("marginTop"), 10) \|\| 0),
	1997	right: (parseInt(this.element.css("marginRight"), 10) \|\| 0),
	1998	bottom: (parseInt(this.element.css("marginBottom"), 10) \|\| 0)
	1999	};
	2000	},
	2001
	2002	_cacheHelperProportions: function() {
	2003	this.helperProportions = {
	2004	width: this.helper.outerWidth(),
	2005	height: this.helper.outerHeight()
	2006	};
	2007	},
	2008
	2009	_setContainment: function() {
	2010
	2011	var isUserScrollable, c, ce,
	2012	o = this.options,
	2013	document = this.document[ 0 ];
	2014
	2015	this.relativeContainer = null;
	2016
	2017	if ( !o.containment ) {
	2018	this.containment = null;
	2019	return;
	2020	}
	2021
	2022	if ( o.containment === "window" ) {
	2023	this.containment = [
	2024	$( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
	2025	$( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
	2026	$( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
	2027	$( window ).scrollTop() + ( $( window ).height() \|\| document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
	2028	];
	2029	return;
	2030	}
	2031
	2032	if ( o.containment === "document") {
	2033	this.containment = [
	2034	0,
	2035	0,
	2036	$( document ).width() - this.helperProportions.width - this.margins.left,
	2037	( $( document ).height() \|\| document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
	2038	];
	2039	return;
	2040	}
	2041
	2042	if ( o.containment.constructor === Array ) {
	2043	this.containment = o.containment;
	2044	return;
	2045	}
	2046
	2047	if ( o.containment === "parent" ) {
	2048	o.containment = this.helper[ 0 ].parentNode;
	2049	}
	2050
	2051	c = $( o.containment );
	2052	ce = c[ 0 ];
	2053
	2054	if ( !ce ) {
	2055	return;
	2056	}
	2057
	2058	isUserScrollable = /(scroll\|auto)/.test( c.css( "overflow" ) );
	2059
	2060	this.containment = [
	2061	( parseInt( c.css( "borderLeftWidth" ), 10 ) \|\| 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) \|\| 0 ),
	2062	( parseInt( c.css( "borderTopWidth" ), 10 ) \|\| 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) \|\| 0 ),
	2063	( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
	2064	( parseInt( c.css( "borderRightWidth" ), 10 ) \|\| 0 ) -
	2065	( parseInt( c.css( "paddingRight" ), 10 ) \|\| 0 ) -
	2066	this.helperProportions.width -
	2067	this.margins.left -
	2068	this.margins.right,
	2069	( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
	2070	( parseInt( c.css( "borderBottomWidth" ), 10 ) \|\| 0 ) -
	2071	( parseInt( c.css( "paddingBottom" ), 10 ) \|\| 0 ) -
	2072	this.helperProportions.height -
	2073	this.margins.top -
	2074	this.margins.bottom
	2075	];
	2076	this.relativeContainer = c;
	2077	},
	2078
	2079	_convertPositionTo: function(d, pos) {
	2080
	2081	if (!pos) {
	2082	pos = this.position;
	2083	}
	2084
	2085	var mod = d === "absolute" ? 1 : -1,
	2086	scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
	2087
	2088	return {
	2089	top: (
	2090	pos.top + // The absolute mouse position
	2091	this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
	2092	this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
	2093	( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
	2094	),
	2095	left: (
	2096	pos.left + // The absolute mouse position
	2097	this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
	2098	this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
	2099	( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
	2100	)
	2101	};
	2102
	2103	},
	2104
	2105	_generatePosition: function( event, constrainPosition ) {
	2106
	2107	var containment, co, top, left,
	2108	o = this.options,
	2109	scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
	2110	pageX = event.pageX,
	2111	pageY = event.pageY;
	2112
	2113	// Cache the scroll
	2114	if ( !scrollIsRootNode \|\| !this.offset.scroll ) {
	2115	this.offset.scroll = {
	2116	top: this.scrollParent.scrollTop(),
	2117	left: this.scrollParent.scrollLeft()
	2118	};
	2119	}
	2120
	2121	/*
	2122	* - Position constraining -
	2123	* Constrain the position to a mix of grid, containment.
	2124	*/
	2125
	2126	// If we are not dragging yet, we won't check for options
	2127	if ( constrainPosition ) {
	2128	if ( this.containment ) {
	2129	if ( this.relativeContainer ){
	2130	co = this.relativeContainer.offset();
	2131	containment = [
	2132	this.containment[ 0 ] + co.left,
	2133	this.containment[ 1 ] + co.top,
	2134	this.containment[ 2 ] + co.left,
	2135	this.containment[ 3 ] + co.top
	2136	];
	2137	} else {
	2138	containment = this.containment;
	2139	}
	2140
	2141	if (event.pageX - this.offset.click.left < containment[0]) {
	2142	pageX = containment[0] + this.offset.click.left;
	2143	}
	2144	if (event.pageY - this.offset.click.top < containment[1]) {
	2145	pageY = containment[1] + this.offset.click.top;
	2146	}
	2147	if (event.pageX - this.offset.click.left > containment[2]) {
	2148	pageX = containment[2] + this.offset.click.left;
	2149	}
	2150	if (event.pageY - this.offset.click.top > containment[3]) {
	2151	pageY = containment[3] + this.offset.click.top;
	2152	}
	2153	}
	2154
	2155	if (o.grid) {
	2156	//Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
	2157	top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
	2158	pageY = containment ? ((top - this.offset.click.top >= containment[1] \|\| top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
	2159
	2160	left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
	2161	pageX = containment ? ((left - this.offset.click.left >= containment[0] \|\| left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
	2162	}
	2163
	2164	if ( o.axis === "y" ) {
	2165	pageX = this.originalPageX;
	2166	}
	2167
	2168	if ( o.axis === "x" ) {
	2169	pageY = this.originalPageY;
	2170	}
	2171	}
	2172
	2173	return {
	2174	top: (
	2175	pageY - // The absolute mouse position
	2176	this.offset.click.top - // Click offset (relative to the element)
	2177	this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
	2178	this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
	2179	( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
	2180	),
	2181	left: (
	2182	pageX - // The absolute mouse position
	2183	this.offset.click.left - // Click offset (relative to the element)
	2184	this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
	2185	this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
	2186	( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
	2187	)
	2188	};
	2189
	2190	},
	2191
	2192	_clear: function() {
	2193	this.helper.removeClass("ui-draggable-dragging");
	2194	if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
	2195	this.helper.remove();
	2196	}
	2197	this.helper = null;
	2198	this.cancelHelperRemoval = false;
	2199	if ( this.destroyOnClear ) {
	2200	this.destroy();
	2201	}
	2202	},
	2203
	2204	_normalizeRightBottom: function() {
	2205	if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
	2206	this.helper.width( this.helper.width() );
	2207	this.helper.css( "right", "auto" );
	2208	}
	2209	if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
	2210	this.helper.height( this.helper.height() );
	2211	this.helper.css( "bottom", "auto" );
	2212	}
	2213	},
	2214
	2215	// From now on bulk stuff - mainly helpers
	2216
	2217	_trigger: function( type, event, ui ) {
	2218	ui = ui \|\| this._uiHash();
	2219	$.ui.plugin.call( this, type, [ event, ui, this ], true );
	2220
	2221	// Absolute position and offset (see #6884 ) have to be recalculated after plugins
	2222	if ( /^(drag\|start\|stop)/.test( type ) ) {
	2223	this.positionAbs = this._convertPositionTo( "absolute" );
	2224	ui.offset = this.positionAbs;
	2225	}
	2226	return $.Widget.prototype._trigger.call( this, type, event, ui );
	2227	},
	2228
	2229	plugins: {},
	2230
	2231	_uiHash: function() {
	2232	return {
	2233	helper: this.helper,
	2234	position: this.position,
	2235	originalPosition: this.originalPosition,
	2236	offset: this.positionAbs
	2237	};
	2238	}
	2239
	2240	});
	2241
	2242	$.ui.plugin.add( "draggable", "connectToSortable", {
	2243	start: function( event, ui, draggable ) {
	2244	var uiSortable = $.extend( {}, ui, {
	2245	item: draggable.element
	2246	});
	2247
	2248	draggable.sortables = [];
	2249	$( draggable.options.connectToSortable ).each(function() {
	2250	var sortable = $( this ).sortable( "instance" );
	2251
	2252	if ( sortable && !sortable.options.disabled ) {
	2253	draggable.sortables.push( sortable );
	2254
	2255	// refreshPositions is called at drag start to refresh the containerCache
	2256	// which is used in drag. This ensures it's initialized and synchronized
	2257	// with any changes that might have happened on the page since initialization.
	2258	sortable.refreshPositions();
	2259	sortable._trigger("activate", event, uiSortable);
	2260	}
	2261	});
	2262	},
	2263	stop: function( event, ui, draggable ) {
	2264	var uiSortable = $.extend( {}, ui, {
	2265	item: draggable.element
	2266	});
	2267
	2268	draggable.cancelHelperRemoval = false;
	2269
	2270	$.each( draggable.sortables, function() {
	2271	var sortable = this;
	2272
	2273	if ( sortable.isOver ) {
	2274	sortable.isOver = 0;
	2275
	2276	// Allow this sortable to handle removing the helper
	2277	draggable.cancelHelperRemoval = true;
	2278	sortable.cancelHelperRemoval = false;
	2279
	2280	// Use _storedCSS To restore properties in the sortable,
	2281	// as this also handles revert (#9675) since the draggable
	2282	// may have modified them in unexpected ways (#8809)
	2283	sortable._storedCSS = {
	2284	position: sortable.placeholder.css( "position" ),
	2285	top: sortable.placeholder.css( "top" ),
	2286	left: sortable.placeholder.css( "left" )
	2287	};
	2288
	2289	sortable._mouseStop(event);
	2290
	2291	// Once drag has ended, the sortable should return to using
	2292	// its original helper, not the shared helper from draggable
	2293	sortable.options.helper = sortable.options._helper;
	2294	} else {
	2295	// Prevent this Sortable from removing the helper.
	2296	// However, don't set the draggable to remove the helper
	2297	// either as another connected Sortable may yet handle the removal.
	2298	sortable.cancelHelperRemoval = true;
	2299
	2300	sortable._trigger( "deactivate", event, uiSortable );
	2301	}
	2302	});
	2303	},
	2304	drag: function( event, ui, draggable ) {
	2305	$.each( draggable.sortables, function() {
	2306	var innermostIntersecting = false,
	2307	sortable = this;
	2308
	2309	// Copy over variables that sortable's _intersectsWith uses
	2310	sortable.positionAbs = draggable.positionAbs;
	2311	sortable.helperProportions = draggable.helperProportions;
	2312	sortable.offset.click = draggable.offset.click;
	2313
	2314	if ( sortable._intersectsWith( sortable.containerCache ) ) {
	2315	innermostIntersecting = true;
	2316
	2317	$.each( draggable.sortables, function() {
	2318	// Copy over variables that sortable's _intersectsWith uses
	2319	this.positionAbs = draggable.positionAbs;
	2320	this.helperProportions = draggable.helperProportions;
	2321	this.offset.click = draggable.offset.click;
	2322
	2323	if ( this !== sortable &&
	2324	this._intersectsWith( this.containerCache ) &&
	2325	$.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
	2326	innermostIntersecting = false;
	2327	}
	2328
	2329	return innermostIntersecting;
	2330	});
	2331	}
	2332
	2333	if ( innermostIntersecting ) {
	2334	// If it intersects, we use a little isOver variable and set it once,
	2335	// so that the move-in stuff gets fired only once.
	2336	if ( !sortable.isOver ) {
	2337	sortable.isOver = 1;
	2338
	2339	// Store draggable's parent in case we need to reappend to it later.
	2340	draggable._parent = ui.helper.parent();
	2341
	2342	sortable.currentItem = ui.helper
	2343	.appendTo( sortable.element )
	2344	.data( "ui-sortable-item", true );
	2345
	2346	// Store helper option to later restore it
	2347	sortable.options._helper = sortable.options.helper;
	2348
	2349	sortable.options.helper = function() {
	2350	return ui.helper[ 0 ];
	2351	};
	2352
	2353	// Fire the start events of the sortable with our passed browser event,
	2354	// and our own helper (so it doesn't create a new one)
	2355	event.target = sortable.currentItem[ 0 ];
	2356	sortable._mouseCapture( event, true );
	2357	sortable._mouseStart( event, true, true );
	2358
	2359	// Because the browser event is way off the new appended portlet,
	2360	// modify necessary variables to reflect the changes
	2361	sortable.offset.click.top = draggable.offset.click.top;
	2362	sortable.offset.click.left = draggable.offset.click.left;
	2363	sortable.offset.parent.left -= draggable.offset.parent.left -
	2364	sortable.offset.parent.left;
	2365	sortable.offset.parent.top -= draggable.offset.parent.top -
	2366	sortable.offset.parent.top;
	2367
	2368	draggable._trigger( "toSortable", event );
	2369
	2370	// Inform draggable that the helper is in a valid drop zone,
	2371	// used solely in the revert option to handle "valid/invalid".
	2372	draggable.dropped = sortable.element;
	2373
	2374	// Need to refreshPositions of all sortables in the case that
	2375	// adding to one sortable changes the location of the other sortables (#9675)
	2376	$.each( draggable.sortables, function() {
	2377	this.refreshPositions();
	2378	});
	2379
	2380	// hack so receive/update callbacks work (mostly)
	2381	draggable.currentItem = draggable.element;
	2382	sortable.fromOutside = draggable;
	2383	}
	2384
	2385	if ( sortable.currentItem ) {
	2386	sortable._mouseDrag( event );
	2387	// Copy the sortable's position because the draggable's can potentially reflect
	2388	// a relative position, while sortable is always absolute, which the dragged
	2389	// element has now become. (#8809)
	2390	ui.position = sortable.position;
	2391	}
	2392	} else {
	2393	// If it doesn't intersect with the sortable, and it intersected before,
	2394	// we fake the drag stop of the sortable, but make sure it doesn't remove
	2395	// the helper by using cancelHelperRemoval.
	2396	if ( sortable.isOver ) {
	2397
	2398	sortable.isOver = 0;
	2399	sortable.cancelHelperRemoval = true;
	2400
	2401	// Calling sortable's mouseStop would trigger a revert,
	2402	// so revert must be temporarily false until after mouseStop is called.
	2403	sortable.options._revert = sortable.options.revert;
	2404	sortable.options.revert = false;
	2405
	2406	sortable._trigger( "out", event, sortable._uiHash( sortable ) );
	2407	sortable._mouseStop( event, true );
	2408
	2409	// restore sortable behaviors that were modfied
	2410	// when the draggable entered the sortable area (#9481)
	2411	sortable.options.revert = sortable.options._revert;
	2412	sortable.options.helper = sortable.options._helper;
	2413
	2414	if ( sortable.placeholder ) {
	2415	sortable.placeholder.remove();
	2416	}
	2417
	2418	// Restore and recalculate the draggable's offset considering the sortable
	2419	// may have modified them in unexpected ways. (#8809, #10669)
	2420	ui.helper.appendTo( draggable._parent );
	2421	draggable._refreshOffsets( event );
	2422	ui.position = draggable._generatePosition( event, true );
	2423
	2424	draggable._trigger( "fromSortable", event );
	2425
	2426	// Inform draggable that the helper is no longer in a valid drop zone
	2427	draggable.dropped = false;
	2428
	2429	// Need to refreshPositions of all sortables just in case removing
	2430	// from one sortable changes the location of other sortables (#9675)
	2431	$.each( draggable.sortables, function() {
	2432	this.refreshPositions();
	2433	});
	2434	}
	2435	}
	2436	});
	2437	}
	2438	});
	2439
	2440	$.ui.plugin.add("draggable", "cursor", {
	2441	start: function( event, ui, instance ) {
	2442	var t = $( "body" ),
	2443	o = instance.options;
	2444
	2445	if (t.css("cursor")) {
	2446	o._cursor = t.css("cursor");
	2447	}
	2448	t.css("cursor", o.cursor);
	2449	},
	2450	stop: function( event, ui, instance ) {
	2451	var o = instance.options;
	2452	if (o._cursor) {
	2453	$("body").css("cursor", o._cursor);
	2454	}
	2455	}
	2456	});
	2457
	2458	$.ui.plugin.add("draggable", "opacity", {
	2459	start: function( event, ui, instance ) {
	2460	var t = $( ui.helper ),
	2461	o = instance.options;
	2462	if (t.css("opacity")) {
	2463	o._opacity = t.css("opacity");
	2464	}
	2465	t.css("opacity", o.opacity);
	2466	},
	2467	stop: function( event, ui, instance ) {
	2468	var o = instance.options;
	2469	if (o._opacity) {
	2470	$(ui.helper).css("opacity", o._opacity);
	2471	}
	2472	}
	2473	});
	2474
	2475	$.ui.plugin.add("draggable", "scroll", {
	2476	start: function( event, ui, i ) {
	2477	if ( !i.scrollParentNotHidden ) {
	2478	i.scrollParentNotHidden = i.helper.scrollParent( false );
	2479	}
	2480
	2481	if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
	2482	i.overflowOffset = i.scrollParentNotHidden.offset();
	2483	}
	2484	},
	2485	drag: function( event, ui, i ) {
	2486
	2487	var o = i.options,
	2488	scrolled = false,
	2489	scrollParent = i.scrollParentNotHidden[ 0 ],
	2490	document = i.document[ 0 ];
	2491
	2492	if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
	2493	if ( !o.axis \|\| o.axis !== "x" ) {
	2494	if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
	2495	scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
	2496	} else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
	2497	scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
	2498	}
	2499	}
	2500
	2501	if ( !o.axis \|\| o.axis !== "y" ) {
	2502	if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
	2503	scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
	2504	} else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
	2505	scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
	2506	}
	2507	}
	2508
	2509	} else {
	2510
	2511	if (!o.axis \|\| o.axis !== "x") {
	2512	if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
	2513	scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
	2514	} else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
	2515	scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
	2516	}
	2517	}
	2518
	2519	if (!o.axis \|\| o.axis !== "y") {
	2520	if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
	2521	scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
	2522	} else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
	2523	scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
	2524	}
	2525	}
	2526
	2527	}
	2528
	2529	if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
	2530	$.ui.ddmanager.prepareOffsets(i, event);
	2531	}
	2532
	2533	}
	2534	});
	2535
	2536	$.ui.plugin.add("draggable", "snap", {
	2537	start: function( event, ui, i ) {
	2538
	2539	var o = i.options;
	2540
	2541	i.snapElements = [];
	2542
	2543	$(o.snap.constructor !== String ? ( o.snap.items \|\| ":data(ui-draggable)" ) : o.snap).each(function() {
	2544	var $t = $(this),
	2545	$o = $t.offset();
	2546	if (this !== i.element[0]) {
	2547	i.snapElements.push({
	2548	item: this,
	2549	width: $t.outerWidth(), height: $t.outerHeight(),
	2550	top: $o.top, left: $o.left
	2551	});
	2552	}
	2553	});
	2554
	2555	},
	2556	drag: function( event, ui, inst ) {
	2557
	2558	var ts, bs, ls, rs, l, r, t, b, i, first,
	2559	o = inst.options,
	2560	d = o.snapTolerance,
	2561	x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
	2562	y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
	2563
	2564	for (i = inst.snapElements.length - 1; i >= 0; i--){
	2565
	2566	l = inst.snapElements[i].left - inst.margins.left;
	2567	r = l + inst.snapElements[i].width;
	2568	t = inst.snapElements[i].top - inst.margins.top;
	2569	b = t + inst.snapElements[i].height;
	2570
	2571	if ( x2 < l - d \|\| x1 > r + d \|\| y2 < t - d \|\| y1 > b + d \|\| !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
	2572	if (inst.snapElements[i].snapping) {
	2573	(inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
	2574	}
	2575	inst.snapElements[i].snapping = false;
	2576	continue;
	2577	}
	2578
	2579	if (o.snapMode !== "inner") {
	2580	ts = Math.abs(t - y2) <= d;
	2581	bs = Math.abs(b - y1) <= d;
	2582	ls = Math.abs(l - x2) <= d;
	2583	rs = Math.abs(r - x1) <= d;
	2584	if (ts) {
	2585	ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
	2586	}
	2587	if (bs) {
	2588	ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
	2589	}
	2590	if (ls) {
	2591	ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
	2592	}
	2593	if (rs) {
	2594	ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
	2595	}
	2596	}
	2597
	2598	first = (ts \|\| bs \|\| ls \|\| rs);
	2599
	2600	if (o.snapMode !== "outer") {
	2601	ts = Math.abs(t - y1) <= d;
	2602	bs = Math.abs(b - y2) <= d;
	2603	ls = Math.abs(l - x1) <= d;
	2604	rs = Math.abs(r - x2) <= d;
	2605	if (ts) {
	2606	ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
	2607	}
	2608	if (bs) {
	2609	ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
	2610	}
	2611	if (ls) {
	2612	ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
	2613	}
	2614	if (rs) {
	2615	ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
	2616	}
	2617	}
	2618
	2619	if (!inst.snapElements[i].snapping && (ts \|\| bs \|\| ls \|\| rs \|\| first)) {
	2620	(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
	2621	}
	2622	inst.snapElements[i].snapping = (ts \|\| bs \|\| ls \|\| rs \|\| first);
	2623
	2624	}
	2625
	2626	}
	2627	});
	2628
	2629	$.ui.plugin.add("draggable", "stack", {
	2630	start: function( event, ui, instance ) {
	2631	var min,
	2632	o = instance.options,
	2633	group = $.makeArray($(o.stack)).sort(function(a, b) {
	2634	return (parseInt($(a).css("zIndex"), 10) \|\| 0) - (parseInt($(b).css("zIndex"), 10) \|\| 0);
	2635	});
	2636
	2637	if (!group.length) { return; }
	2638
	2639	min = parseInt($(group[0]).css("zIndex"), 10) \|\| 0;
	2640	$(group).each(function(i) {
	2641	$(this).css("zIndex", min + i);
	2642	});
	2643	this.css("zIndex", (min + group.length));
	2644	}
	2645	});
	2646
	2647	$.ui.plugin.add("draggable", "zIndex", {
	2648	start: function( event, ui, instance ) {
	2649	var t = $( ui.helper ),
	2650	o = instance.options;
	2651
	2652	if (t.css("zIndex")) {
	2653	o._zIndex = t.css("zIndex");
	2654	}
	2655	t.css("zIndex", o.zIndex);
	2656	},
	2657	stop: function( event, ui, instance ) {
	2658	var o = instance.options;
	2659
	2660	if (o._zIndex) {
	2661	$(ui.helper).css("zIndex", o._zIndex);
	2662	}
	2663	}
	2664	});
	2665
	2666	var draggable = $.ui.draggable;
	2667
	2668
	2669	/*!
	2670	* jQuery UI Droppable 1.11.4
	2671	* http://jqueryui.com
	2672	*
	2673	* Copyright jQuery Foundation and other contributors
	2674	* Released under the MIT license.
	2675	* http://jquery.org/license
	2676	*
	2677	* http://api.jqueryui.com/droppable/
	2678	*/
	2679
	2680
	2681	$.widget( "ui.droppable", {
	2682	version: "1.11.4",
	2683	widgetEventPrefix: "drop",
	2684	options: {
	2685	accept: "*",
	2686	activeClass: false,
	2687	addClasses: true,
	2688	greedy: false,
	2689	hoverClass: false,
	2690	scope: "default",
	2691	tolerance: "intersect",
	2692
	2693	// callbacks
	2694	activate: null,
	2695	deactivate: null,
	2696	drop: null,
	2697	out: null,
	2698	over: null
	2699	},
	2700	_create: function() {
	2701
	2702	var proportions,
	2703	o = this.options,
	2704	accept = o.accept;
	2705
	2706	this.isover = false;
	2707	this.isout = true;
	2708
	2709	this.accept = $.isFunction( accept ) ? accept : function( d ) {
	2710	return d.is( accept );
	2711	};
	2712
	2713	this.proportions = function( /* valueToWrite */ ) {
	2714	if ( arguments.length ) {
	2715	// Store the droppable's proportions
	2716	proportions = arguments[ 0 ];
	2717	} else {
	2718	// Retrieve or derive the droppable's proportions
	2719	return proportions ?
	2720	proportions :
	2721	proportions = {
	2722	width: this.element[ 0 ].offsetWidth,
	2723	height: this.element[ 0 ].offsetHeight
	2724	};
	2725	}
	2726	};
	2727
	2728	this._addToManager( o.scope );
	2729
	2730	o.addClasses && this.element.addClass( "ui-droppable" );
	2731
	2732	},
	2733
	2734	_addToManager: function( scope ) {
	2735	// Add the reference and positions to the manager
	2736	$.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] \|\| [];
	2737	$.ui.ddmanager.droppables[ scope ].push( this );
	2738	},
	2739
	2740	_splice: function( drop ) {
	2741	var i = 0;
	2742	for ( ; i < drop.length; i++ ) {
	2743	if ( drop[ i ] === this ) {
	2744	drop.splice( i, 1 );
	2745	}
	2746	}
	2747	},
	2748
	2749	_destroy: function() {
	2750	var drop = $.ui.ddmanager.droppables[ this.options.scope ];
	2751
	2752	this._splice( drop );
	2753
	2754	this.element.removeClass( "ui-droppable ui-droppable-disabled" );
	2755	},
	2756
	2757	_setOption: function( key, value ) {
	2758
	2759	if ( key === "accept" ) {
	2760	this.accept = $.isFunction( value ) ? value : function( d ) {
	2761	return d.is( value );
	2762	};
	2763	} else if ( key === "scope" ) {
	2764	var drop = $.ui.ddmanager.droppables[ this.options.scope ];
	2765
	2766	this._splice( drop );
	2767	this._addToManager( value );
	2768	}
	2769
	2770	this._super( key, value );
	2771	},
	2772
	2773	_activate: function( event ) {
	2774	var draggable = $.ui.ddmanager.current;
	2775	if ( this.options.activeClass ) {
	2776	this.element.addClass( this.options.activeClass );
	2777	}
	2778	if ( draggable ){
	2779	this._trigger( "activate", event, this.ui( draggable ) );
	2780	}
	2781	},
	2782
	2783	_deactivate: function( event ) {
	2784	var draggable = $.ui.ddmanager.current;
	2785	if ( this.options.activeClass ) {
	2786	this.element.removeClass( this.options.activeClass );
	2787	}
	2788	if ( draggable ){
	2789	this._trigger( "deactivate", event, this.ui( draggable ) );
	2790	}
	2791	},
	2792
	2793	_over: function( event ) {
	2794
	2795	var draggable = $.ui.ddmanager.current;
	2796
	2797	// Bail if draggable and droppable are same element
	2798	if ( !draggable \|\| ( draggable.currentItem \|\| draggable.element )[ 0 ] === this.element[ 0 ] ) {
	2799	return;
	2800	}
	2801
	2802	if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem \|\| draggable.element ) ) ) {
	2803	if ( this.options.hoverClass ) {
	2804	this.element.addClass( this.options.hoverClass );
	2805	}
	2806	this._trigger( "over", event, this.ui( draggable ) );
	2807	}
	2808
	2809	},
	2810
	2811	_out: function( event ) {
	2812
	2813	var draggable = $.ui.ddmanager.current;
	2814
	2815	// Bail if draggable and droppable are same element
	2816	if ( !draggable \|\| ( draggable.currentItem \|\| draggable.element )[ 0 ] === this.element[ 0 ] ) {
	2817	return;
	2818	}
	2819
	2820	if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem \|\| draggable.element ) ) ) {
	2821	if ( this.options.hoverClass ) {
	2822	this.element.removeClass( this.options.hoverClass );
	2823	}
	2824	this._trigger( "out", event, this.ui( draggable ) );
	2825	}
	2826
	2827	},
	2828
	2829	_drop: function( event, custom ) {
	2830
	2831	var draggable = custom \|\| $.ui.ddmanager.current,
	2832	childrenIntersection = false;
	2833
	2834	// Bail if draggable and droppable are same element
	2835	if ( !draggable \|\| ( draggable.currentItem \|\| draggable.element )[ 0 ] === this.element[ 0 ] ) {
	2836	return false;
	2837	}
	2838
	2839	this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
	2840	var inst = $( this ).droppable( "instance" );
	2841	if (
	2842	inst.options.greedy &&
	2843	!inst.options.disabled &&
	2844	inst.options.scope === draggable.options.scope &&
	2845	inst.accept.call( inst.element[ 0 ], ( draggable.currentItem \|\| draggable.element ) ) &&
	2846	$.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
	2847	) { childrenIntersection = true; return false; }
	2848	});
	2849	if ( childrenIntersection ) {
	2850	return false;
	2851	}
	2852
	2853	if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem \|\| draggable.element ) ) ) {
	2854	if ( this.options.activeClass ) {
	2855	this.element.removeClass( this.options.activeClass );
	2856	}
	2857	if ( this.options.hoverClass ) {
	2858	this.element.removeClass( this.options.hoverClass );
	2859	}
	2860	this._trigger( "drop", event, this.ui( draggable ) );
	2861	return this.element;
	2862	}
	2863
	2864	return false;
	2865
	2866	},
	2867
	2868	ui: function( c ) {
	2869	return {
	2870	draggable: ( c.currentItem \|\| c.element ),
	2871	helper: c.helper,
	2872	position: c.position,
	2873	offset: c.positionAbs
	2874	};
	2875	}
	2876
	2877	});
	2878
	2879	$.ui.intersect = (function() {
	2880	function isOverAxis( x, reference, size ) {
	2881	return ( x >= reference ) && ( x < ( reference + size ) );
	2882	}
	2883
	2884	return function( draggable, droppable, toleranceMode, event ) {
	2885
	2886	if ( !droppable.offset ) {
	2887	return false;
	2888	}
	2889
	2890	var x1 = ( draggable.positionAbs \|\| draggable.position.absolute ).left + draggable.margins.left,
	2891	y1 = ( draggable.positionAbs \|\| draggable.position.absolute ).top + draggable.margins.top,
	2892	x2 = x1 + draggable.helperProportions.width,
	2893	y2 = y1 + draggable.helperProportions.height,
	2894	l = droppable.offset.left,
	2895	t = droppable.offset.top,
	2896	r = l + droppable.proportions().width,
	2897	b = t + droppable.proportions().height;
	2898
	2899	switch ( toleranceMode ) {
	2900	case "fit":
	2901	return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
	2902	case "intersect":
	2903	return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
	2904	x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
	2905	t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
	2906	y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
	2907	case "pointer":
	2908	return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
	2909	case "touch":
	2910	return (
	2911	( y1 >= t && y1 <= b ) \|\| // Top edge touching
	2912	( y2 >= t && y2 <= b ) \|\| // Bottom edge touching
	2913	( y1 < t && y2 > b ) // Surrounded vertically
	2914	) && (
	2915	( x1 >= l && x1 <= r ) \|\| // Left edge touching
	2916	( x2 >= l && x2 <= r ) \|\| // Right edge touching
	2917	( x1 < l && x2 > r ) // Surrounded horizontally
	2918	);
	2919	default:
	2920	return false;
	2921	}
	2922	};
	2923	})();
	2924
	2925	/*
	2926	This manager tracks offsets of draggables and droppables
	2927	*/
	2928	$.ui.ddmanager = {
	2929	current: null,
	2930	droppables: { "default": [] },
	2931	prepareOffsets: function( t, event ) {
	2932
	2933	var i, j,
	2934	m = $.ui.ddmanager.droppables[ t.options.scope ] \|\| [],
	2935	type = event ? event.type : null, // workaround for #2317
	2936	list = ( t.currentItem \|\| t.element ).find( ":data(ui-droppable)" ).addBack();
	2937
	2938	droppablesLoop: for ( i = 0; i < m.length; i++ ) {
	2939
	2940	// No disabled and non-accepted
	2941	if ( m[ i ].options.disabled \|\| ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem \|\| t.element ) ) ) ) {
	2942	continue;
	2943	}
	2944
	2945	// Filter out elements in the current dragged item
	2946	for ( j = 0; j < list.length; j++ ) {
	2947	if ( list[ j ] === m[ i ].element[ 0 ] ) {
	2948	m[ i ].proportions().height = 0;
	2949	continue droppablesLoop;
	2950	}
	2951	}
	2952
	2953	m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
	2954	if ( !m[ i ].visible ) {
	2955	continue;
	2956	}
	2957
	2958	// Activate the droppable if used directly from draggables
	2959	if ( type === "mousedown" ) {
	2960	m[ i ]._activate.call( m[ i ], event );
	2961	}
	2962
	2963	m[ i ].offset = m[ i ].element.offset();
	2964	m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
	2965
	2966	}
	2967
	2968	},
	2969	drop: function( draggable, event ) {
	2970
	2971	var dropped = false;
	2972	// Create a copy of the droppables in case the list changes during the drop (#9116)
	2973	$.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] \|\| [] ).slice(), function() {
	2974
	2975	if ( !this.options ) {
	2976	return;
	2977	}
	2978	if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
	2979	dropped = this._drop.call( this, event ) \|\| dropped;
	2980	}
	2981
	2982	if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem \|\| draggable.element ) ) ) {
	2983	this.isout = true;
	2984	this.isover = false;
	2985	this._deactivate.call( this, event );
	2986	}
	2987
	2988	});
	2989	return dropped;
	2990
	2991	},
	2992	dragStart: function( draggable, event ) {
	2993	// Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
	2994	draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
	2995	if ( !draggable.options.refreshPositions ) {
	2996	$.ui.ddmanager.prepareOffsets( draggable, event );
	2997	}
	2998	});
	2999	},
	3000	drag: function( draggable, event ) {
	3001
	3002	// If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
	3003	if ( draggable.options.refreshPositions ) {
	3004	$.ui.ddmanager.prepareOffsets( draggable, event );
	3005	}
	3006
	3007	// Run through all droppables and check their positions based on specific tolerance options
	3008	$.each( $.ui.ddmanager.droppables[ draggable.options.scope ] \|\| [], function() {
	3009
	3010	if ( this.options.disabled \|\| this.greedyChild \|\| !this.visible ) {
	3011	return;
	3012	}
	3013
	3014	var parentInstance, scope, parent,
	3015	intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
	3016	c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
	3017	if ( !c ) {
	3018	return;
	3019	}
	3020
	3021	if ( this.options.greedy ) {
	3022	// find droppable parents with same scope
	3023	scope = this.options.scope;
	3024	parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
	3025	return $( this ).droppable( "instance" ).options.scope === scope;
	3026	});
	3027
	3028	if ( parent.length ) {
	3029	parentInstance = $( parent[ 0 ] ).droppable( "instance" );
	3030	parentInstance.greedyChild = ( c === "isover" );
	3031	}
	3032	}
	3033
	3034	// we just moved into a greedy child
	3035	if ( parentInstance && c === "isover" ) {
	3036	parentInstance.isover = false;
	3037	parentInstance.isout = true;
	3038	parentInstance._out.call( parentInstance, event );
	3039	}
	3040
	3041	this[ c ] = true;
	3042	this[c === "isout" ? "isover" : "isout"] = false;
	3043	this[c === "isover" ? "_over" : "_out"].call( this, event );
	3044
	3045	// we just moved out of a greedy child
	3046	if ( parentInstance && c === "isout" ) {
	3047	parentInstance.isout = false;
	3048	parentInstance.isover = true;
	3049	parentInstance._over.call( parentInstance, event );
	3050	}
	3051	});
	3052
	3053	},
	3054	dragStop: function( draggable, event ) {
	3055	draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
	3056	// Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
	3057	if ( !draggable.options.refreshPositions ) {
	3058	$.ui.ddmanager.prepareOffsets( draggable, event );
	3059	}
	3060	}
	3061	};
	3062
	3063	var droppable = $.ui.droppable;
	3064
	3065
	3066	/*!
	3067	* jQuery UI Resizable 1.11.4
	3068	* http://jqueryui.com
	3069	*
	3070	* Copyright jQuery Foundation and other contributors
	3071	* Released under the MIT license.
	3072	* http://jquery.org/license
	3073	*
	3074	* http://api.jqueryui.com/resizable/
	3075	*/
	3076
	3077
	3078	$.widget("ui.resizable", $.ui.mouse, {
	3079	version: "1.11.4",
	3080	widgetEventPrefix: "resize",
	3081	options: {
	3082	alsoResize: false,
	3083	animate: false,
	3084	animateDuration: "slow",
	3085	animateEasing: "swing",
	3086	aspectRatio: false,
	3087	autoHide: false,
	3088	containment: false,
	3089	ghost: false,
	3090	grid: false,
	3091	handles: "e,s,se",
	3092	helper: false,
	3093	maxHeight: null,
	3094	maxWidth: null,
	3095	minHeight: 10,
	3096	minWidth: 10,
	3097	// See #7960
	3098	zIndex: 90,
	3099
	3100	// callbacks
	3101	resize: null,
	3102	start: null,
	3103	stop: null
	3104	},
	3105
	3106	_num: function( value ) {
	3107	return parseInt( value, 10 ) \|\| 0;
	3108	},
	3109
	3110	_isNumber: function( value ) {
	3111	return !isNaN( parseInt( value, 10 ) );
	3112	},
	3113
	3114	_hasScroll: function( el, a ) {
	3115
	3116	if ( $( el ).css( "overflow" ) === "hidden") {
	3117	return false;
	3118	}
	3119
	3120	var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
	3121	has = false;
	3122
	3123	if ( el[ scroll ] > 0 ) {
	3124	return true;
	3125	}
	3126
	3127	// TODO: determine which cases actually cause this to happen
	3128	// if the element doesn't have the scroll set, see if it's possible to
	3129	// set the scroll
	3130	el[ scroll ] = 1;
	3131	has = ( el[ scroll ] > 0 );
	3132	el[ scroll ] = 0;
	3133	return has;
	3134	},
	3135
	3136	_create: function() {
	3137
	3138	var n, i, handle, axis, hname,
	3139	that = this,
	3140	o = this.options;
	3141	this.element.addClass("ui-resizable");
	3142
	3143	$.extend(this, {
	3144	_aspectRatio: !!(o.aspectRatio),
	3145	aspectRatio: o.aspectRatio,
	3146	originalElement: this.element,
	3147	_proportionallyResizeElements: [],
	3148	_helper: o.helper \|\| o.ghost \|\| o.animate ? o.helper \|\| "ui-resizable-helper" : null
	3149	});
	3150
	3151	// Wrap the element if it cannot hold child nodes
	3152	if (this.element[0].nodeName.match(/^(canvas\|textarea\|input\|select\|button\|img)$/i)) {
	3153
	3154	this.element.wrap(
	3155	$("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
	3156	position: this.element.css("position"),
	3157	width: this.element.outerWidth(),
	3158	height: this.element.outerHeight(),
	3159	top: this.element.css("top"),
	3160	left: this.element.css("left")
	3161	})
	3162	);
	3163
	3164	this.element = this.element.parent().data(
	3165	"ui-resizable", this.element.resizable( "instance" )
	3166	);
	3167
	3168	this.elementIsWrapper = true;
	3169
	3170	this.element.css({
	3171	marginLeft: this.originalElement.css("marginLeft"),
	3172	marginTop: this.originalElement.css("marginTop"),
	3173	marginRight: this.originalElement.css("marginRight"),
	3174	marginBottom: this.originalElement.css("marginBottom")
	3175	});
	3176	this.originalElement.css({
	3177	marginLeft: 0,
	3178	marginTop: 0,
	3179	marginRight: 0,
	3180	marginBottom: 0
	3181	});
	3182	// support: Safari
	3183	// Prevent Safari textarea resize
	3184	this.originalResizeStyle = this.originalElement.css("resize");
	3185	this.originalElement.css("resize", "none");
	3186
	3187	this._proportionallyResizeElements.push( this.originalElement.css({
	3188	position: "static",
	3189	zoom: 1,
	3190	display: "block"
	3191	}) );
	3192
	3193	// support: IE9
	3194	// avoid IE jump (hard set the margin)
	3195	this.originalElement.css({ margin: this.originalElement.css("margin") });
	3196
	3197	this._proportionallyResize();
	3198	}
	3199
	3200	this.handles = o.handles \|\|
	3201	( !$(".ui-resizable-handle", this.element).length ?
	3202	"e,s,se" : {
	3203	n: ".ui-resizable-n",
	3204	e: ".ui-resizable-e",
	3205	s: ".ui-resizable-s",
	3206	w: ".ui-resizable-w",
	3207	se: ".ui-resizable-se",
	3208	sw: ".ui-resizable-sw",
	3209	ne: ".ui-resizable-ne",
	3210	nw: ".ui-resizable-nw"
	3211	} );
	3212
	3213	this._handles = $();
	3214	if ( this.handles.constructor === String ) {
	3215
	3216	if ( this.handles === "all") {
	3217	this.handles = "n,e,s,w,se,sw,ne,nw";
	3218	}
	3219
	3220	n = this.handles.split(",");
	3221	this.handles = {};
	3222
	3223	for (i = 0; i < n.length; i++) {
	3224
	3225	handle = $.trim(n[i]);
	3226	hname = "ui-resizable-" + handle;
	3227	axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
	3228
	3229	axis.css({ zIndex: o.zIndex });
	3230
	3231	// TODO : What's going on here?
	3232	if ("se" === handle) {
	3233	axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
	3234	}
	3235
	3236	this.handles[handle] = ".ui-resizable-" + handle;
	3237	this.element.append(axis);
	3238	}
	3239
	3240	}
	3241
	3242	this._renderAxis = function(target) {
	3243
	3244	var i, axis, padPos, padWrapper;
	3245
	3246	target = target \|\| this.element;
	3247
	3248	for (i in this.handles) {
	3249
	3250	if (this.handles[i].constructor === String) {
	3251	this.handles[i] = this.element.children( this.handles[ i ] ).first().show();
	3252	} else if ( this.handles[ i ].jquery \|\| this.handles[ i ].nodeType ) {
	3253	this.handles[ i ] = $( this.handles[ i ] );
	3254	this._on( this.handles[ i ], { "mousedown": that._mouseDown });
	3255	}
	3256
	3257	if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea\|input\|select\|button)$/i)) {
	3258
	3259	axis = $(this.handles[i], this.element);
	3260
	3261	padWrapper = /sw\|ne\|nw\|se\|n\|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
	3262
	3263	padPos = [ "padding",
	3264	/ne\|nw\|n/.test(i) ? "Top" :
	3265	/se\|sw\|s/.test(i) ? "Bottom" :
	3266	/^e$/.test(i) ? "Right" : "Left" ].join("");
	3267
	3268	target.css(padPos, padWrapper);
	3269
	3270	this._proportionallyResize();
	3271	}
	3272
	3273	this._handles = this._handles.add( this.handles[ i ] );
	3274	}
	3275	};
	3276
	3277	// TODO: make renderAxis a prototype function
	3278	this._renderAxis(this.element);
	3279
	3280	this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
	3281	this._handles.disableSelection();
	3282
	3283	this._handles.mouseover(function() {
	3284	if (!that.resizing) {
	3285	if (this.className) {
	3286	axis = this.className.match(/ui-resizable-(se\|sw\|ne\|nw\|n\|e\|s\|w)/i);
	3287	}
	3288	that.axis = axis && axis[1] ? axis[1] : "se";
	3289	}
	3290	});
	3291
	3292	if (o.autoHide) {
	3293	this._handles.hide();
	3294	$(this.element)
	3295	.addClass("ui-resizable-autohide")
	3296	.mouseenter(function() {
	3297	if (o.disabled) {
	3298	return;
	3299	}
	3300	$(this).removeClass("ui-resizable-autohide");
	3301	that._handles.show();
	3302	})
	3303	.mouseleave(function() {
	3304	if (o.disabled) {
	3305	return;
	3306	}
	3307	if (!that.resizing) {
	3308	$(this).addClass("ui-resizable-autohide");
	3309	that._handles.hide();
	3310	}
	3311	});
	3312	}
	3313
	3314	this._mouseInit();
	3315	},
	3316
	3317	_destroy: function() {
	3318
	3319	this._mouseDestroy();
	3320
	3321	var wrapper,
	3322	_destroy = function(exp) {
	3323	$(exp)
	3324	.removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
	3325	.removeData("resizable")
	3326	.removeData("ui-resizable")
	3327	.unbind(".resizable")
	3328	.find(".ui-resizable-handle")
	3329	.remove();
	3330	};
	3331
	3332	// TODO: Unwrap at same DOM position
	3333	if (this.elementIsWrapper) {
	3334	_destroy(this.element);
	3335	wrapper = this.element;
	3336	this.originalElement.css({
	3337	position: wrapper.css("position"),
	3338	width: wrapper.outerWidth(),
	3339	height: wrapper.outerHeight(),
	3340	top: wrapper.css("top"),
	3341	left: wrapper.css("left")
	3342	}).insertAfter( wrapper );
	3343	wrapper.remove();
	3344	}
	3345
	3346	this.originalElement.css("resize", this.originalResizeStyle);
	3347	_destroy(this.originalElement);
	3348
	3349	return this;
	3350	},
	3351
	3352	_mouseCapture: function(event) {
	3353	var i, handle,
	3354	capture = false;
	3355
	3356	for (i in this.handles) {
	3357	handle = $(this.handles[i])[0];
	3358	if (handle === event.target \|\| $.contains(handle, event.target)) {
	3359	capture = true;
	3360	}
	3361	}
	3362
	3363	return !this.options.disabled && capture;
	3364	},
	3365
	3366	_mouseStart: function(event) {
	3367
	3368	var curleft, curtop, cursor,
	3369	o = this.options,
	3370	el = this.element;
	3371
	3372	this.resizing = true;
	3373
	3374	this._renderProxy();
	3375
	3376	curleft = this._num(this.helper.css("left"));
	3377	curtop = this._num(this.helper.css("top"));
	3378
	3379	if (o.containment) {
	3380	curleft += $(o.containment).scrollLeft() \|\| 0;
	3381	curtop += $(o.containment).scrollTop() \|\| 0;
	3382	}
	3383
	3384	this.offset = this.helper.offset();
	3385	this.position = { left: curleft, top: curtop };
	3386
	3387	this.size = this._helper ? {
	3388	width: this.helper.width(),
	3389	height: this.helper.height()
	3390	} : {
	3391	width: el.width(),
	3392	height: el.height()
	3393	};
	3394
	3395	this.originalSize = this._helper ? {
	3396	width: el.outerWidth(),
	3397	height: el.outerHeight()
	3398	} : {
	3399	width: el.width(),
	3400	height: el.height()
	3401	};
	3402
	3403	this.sizeDiff = {
	3404	width: el.outerWidth() - el.width(),
	3405	height: el.outerHeight() - el.height()
	3406	};
	3407
	3408	this.originalPosition = { left: curleft, top: curtop };
	3409	this.originalMousePosition = { left: event.pageX, top: event.pageY };
	3410
	3411	this.aspectRatio = (typeof o.aspectRatio === "number") ?
	3412	o.aspectRatio :
	3413	((this.originalSize.width / this.originalSize.height) \|\| 1);
	3414
	3415	cursor = $(".ui-resizable-" + this.axis).css("cursor");
	3416	$("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
	3417
	3418	el.addClass("ui-resizable-resizing");
	3419	this._propagate("start", event);
	3420	return true;
	3421	},
	3422
	3423	_mouseDrag: function(event) {
	3424
	3425	var data, props,
	3426	smp = this.originalMousePosition,
	3427	a = this.axis,
	3428	dx = (event.pageX - smp.left) \|\| 0,
	3429	dy = (event.pageY - smp.top) \|\| 0,
	3430	trigger = this._change[a];
	3431
	3432	this._updatePrevProperties();
	3433
	3434	if (!trigger) {
	3435	return false;
	3436	}
	3437
	3438	data = trigger.apply(this, [ event, dx, dy ]);
	3439
	3440	this._updateVirtualBoundaries(event.shiftKey);
	3441	if (this._aspectRatio \|\| event.shiftKey) {
	3442	data = this._updateRatio(data, event);
	3443	}
	3444
	3445	data = this._respectSize(data, event);
	3446
	3447	this._updateCache(data);
	3448
	3449	this._propagate("resize", event);
	3450
	3451	props = this._applyChanges();
	3452
	3453	if ( !this._helper && this._proportionallyResizeElements.length ) {
	3454	this._proportionallyResize();
	3455	}
	3456
	3457	if ( !$.isEmptyObject( props ) ) {
	3458	this._updatePrevProperties();
	3459	this._trigger( "resize", event, this.ui() );
	3460	this._applyChanges();
	3461	}
	3462
	3463	return false;
	3464	},
	3465
	3466	_mouseStop: function(event) {
	3467
	3468	this.resizing = false;
	3469	var pr, ista, soffseth, soffsetw, s, left, top,
	3470	o = this.options, that = this;
	3471
	3472	if (this._helper) {
	3473
	3474	pr = this._proportionallyResizeElements;
	3475	ista = pr.length && (/textarea/i).test(pr[0].nodeName);
	3476	soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
	3477	soffsetw = ista ? 0 : that.sizeDiff.width;
	3478
	3479	s = {
	3480	width: (that.helper.width() - soffsetw),
	3481	height: (that.helper.height() - soffseth)
	3482	};
	3483	left = (parseInt(that.element.css("left"), 10) +
	3484	(that.position.left - that.originalPosition.left)) \|\| null;
	3485	top = (parseInt(that.element.css("top"), 10) +
	3486	(that.position.top - that.originalPosition.top)) \|\| null;
	3487
	3488	if (!o.animate) {
	3489	this.element.css($.extend(s, { top: top, left: left }));
	3490	}
	3491
	3492	that.helper.height(that.size.height);
	3493	that.helper.width(that.size.width);
	3494
	3495	if (this._helper && !o.animate) {
	3496	this._proportionallyResize();
	3497	}
	3498	}
	3499
	3500	$("body").css("cursor", "auto");
	3501
	3502	this.element.removeClass("ui-resizable-resizing");
	3503
	3504	this._propagate("stop", event);
	3505
	3506	if (this._helper) {
	3507	this.helper.remove();
	3508	}
	3509
	3510	return false;
	3511
	3512	},
	3513
	3514	_updatePrevProperties: function() {
	3515	this.prevPosition = {
	3516	top: this.position.top,
	3517	left: this.position.left
	3518	};
	3519	this.prevSize = {
	3520	width: this.size.width,
	3521	height: this.size.height
	3522	};
	3523	},
	3524
	3525	_applyChanges: function() {
	3526	var props = {};
	3527
	3528	if ( this.position.top !== this.prevPosition.top ) {
	3529	props.top = this.position.top + "px";
	3530	}
	3531	if ( this.position.left !== this.prevPosition.left ) {
	3532	props.left = this.position.left + "px";
	3533	}
	3534	if ( this.size.width !== this.prevSize.width ) {
	3535	props.width = this.size.width + "px";
	3536	}
	3537	if ( this.size.height !== this.prevSize.height ) {
	3538	props.height = this.size.height + "px";
	3539	}
	3540
	3541	this.helper.css( props );
	3542
	3543	return props;
	3544	},
	3545
	3546	_updateVirtualBoundaries: function(forceAspectRatio) {
	3547	var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
	3548	o = this.options;
	3549
	3550	b = {
	3551	minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
	3552	maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
	3553	minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
	3554	maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
	3555	};
	3556
	3557	if (this._aspectRatio \|\| forceAspectRatio) {
	3558	pMinWidth = b.minHeight * this.aspectRatio;
	3559	pMinHeight = b.minWidth / this.aspectRatio;
	3560	pMaxWidth = b.maxHeight * this.aspectRatio;
	3561	pMaxHeight = b.maxWidth / this.aspectRatio;
	3562
	3563	if (pMinWidth > b.minWidth) {
	3564	b.minWidth = pMinWidth;
	3565	}
	3566	if (pMinHeight > b.minHeight) {
	3567	b.minHeight = pMinHeight;
	3568	}
	3569	if (pMaxWidth < b.maxWidth) {
	3570	b.maxWidth = pMaxWidth;
	3571	}
	3572	if (pMaxHeight < b.maxHeight) {
	3573	b.maxHeight = pMaxHeight;
	3574	}
	3575	}
	3576	this._vBoundaries = b;
	3577	},
	3578
	3579	_updateCache: function(data) {
	3580	this.offset = this.helper.offset();
	3581	if (this._isNumber(data.left)) {
	3582	this.position.left = data.left;
	3583	}
	3584	if (this._isNumber(data.top)) {
	3585	this.position.top = data.top;
	3586	}
	3587	if (this._isNumber(data.height)) {
	3588	this.size.height = data.height;
	3589	}
	3590	if (this._isNumber(data.width)) {
	3591	this.size.width = data.width;
	3592	}
	3593	},
	3594
	3595	_updateRatio: function( data ) {
	3596
	3597	var cpos = this.position,
	3598	csize = this.size,
	3599	a = this.axis;
	3600
	3601	if (this._isNumber(data.height)) {
	3602	data.width = (data.height * this.aspectRatio);
	3603	} else if (this._isNumber(data.width)) {
	3604	data.height = (data.width / this.aspectRatio);
	3605	}
	3606
	3607	if (a === "sw") {
	3608	data.left = cpos.left + (csize.width - data.width);
	3609	data.top = null;
	3610	}
	3611	if (a === "nw") {
	3612	data.top = cpos.top + (csize.height - data.height);
	3613	data.left = cpos.left + (csize.width - data.width);
	3614	}
	3615
	3616	return data;
	3617	},
	3618
	3619	_respectSize: function( data ) {
	3620
	3621	var o = this._vBoundaries,
	3622	a = this.axis,
	3623	ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
	3624	ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
	3625	isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
	3626	isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
	3627	dw = this.originalPosition.left + this.originalSize.width,
	3628	dh = this.position.top + this.size.height,
	3629	cw = /sw\|nw\|w/.test(a), ch = /nw\|ne\|n/.test(a);
	3630	if (isminw) {
	3631	data.width = o.minWidth;
	3632	}
	3633	if (isminh) {
	3634	data.height = o.minHeight;
	3635	}
	3636	if (ismaxw) {
	3637	data.width = o.maxWidth;
	3638	}
	3639	if (ismaxh) {
	3640	data.height = o.maxHeight;
	3641	}
	3642
	3643	if (isminw && cw) {
	3644	data.left = dw - o.minWidth;
	3645	}
	3646	if (ismaxw && cw) {
	3647	data.left = dw - o.maxWidth;
	3648	}
	3649	if (isminh && ch) {
	3650	data.top = dh - o.minHeight;
	3651	}
	3652	if (ismaxh && ch) {
	3653	data.top = dh - o.maxHeight;
	3654	}
	3655
	3656	// Fixing jump error on top/left - bug #2330
	3657	if (!data.width && !data.height && !data.left && data.top) {
	3658	data.top = null;
	3659	} else if (!data.width && !data.height && !data.top && data.left) {
	3660	data.left = null;
	3661	}
	3662
	3663	return data;
	3664	},
	3665
	3666	_getPaddingPlusBorderDimensions: function( element ) {
	3667	var i = 0,
	3668	widths = [],
	3669	borders = [
	3670	element.css( "borderTopWidth" ),
	3671	element.css( "borderRightWidth" ),
	3672	element.css( "borderBottomWidth" ),
	3673	element.css( "borderLeftWidth" )
	3674	],
	3675	paddings = [
	3676	element.css( "paddingTop" ),
	3677	element.css( "paddingRight" ),
	3678	element.css( "paddingBottom" ),
	3679	element.css( "paddingLeft" )
	3680	];
	3681
	3682	for ( ; i < 4; i++ ) {
	3683	widths[ i ] = ( parseInt( borders[ i ], 10 ) \|\| 0 );
	3684	widths[ i ] += ( parseInt( paddings[ i ], 10 ) \|\| 0 );
	3685	}
	3686
	3687	return {
	3688	height: widths[ 0 ] + widths[ 2 ],
	3689	width: widths[ 1 ] + widths[ 3 ]
	3690	};
	3691	},
	3692
	3693	_proportionallyResize: function() {
	3694
	3695	if (!this._proportionallyResizeElements.length) {
	3696	return;
	3697	}
	3698
	3699	var prel,
	3700	i = 0,
	3701	element = this.helper \|\| this.element;
	3702
	3703	for ( ; i < this._proportionallyResizeElements.length; i++) {
	3704
	3705	prel = this._proportionallyResizeElements[i];
	3706
	3707	// TODO: Seems like a bug to cache this.outerDimensions
	3708	// considering that we are in a loop.
	3709	if (!this.outerDimensions) {
	3710	this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
	3711	}
	3712
	3713	prel.css({
	3714	height: (element.height() - this.outerDimensions.height) \|\| 0,
	3715	width: (element.width() - this.outerDimensions.width) \|\| 0
	3716	});
	3717
	3718	}
	3719
	3720	},
	3721
	3722	_renderProxy: function() {
	3723
	3724	var el = this.element, o = this.options;
	3725	this.elementOffset = el.offset();
	3726
	3727	if (this._helper) {
	3728
	3729	this.helper = this.helper \|\| $("<div style='overflow:hidden;'></div>");
	3730
	3731	this.helper.addClass(this._helper).css({
	3732	width: this.element.outerWidth() - 1,
	3733	height: this.element.outerHeight() - 1,
	3734	position: "absolute",
	3735	left: this.elementOffset.left + "px",
	3736	top: this.elementOffset.top + "px",
	3737	zIndex: ++o.zIndex //TODO: Don't modify option
	3738	});
	3739
	3740	this.helper
	3741	.appendTo("body")
	3742	.disableSelection();
	3743
	3744	} else {
	3745	this.helper = this.element;
	3746	}
	3747
	3748	},
	3749
	3750	_change: {
	3751	e: function(event, dx) {
	3752	return { width: this.originalSize.width + dx };
	3753	},
	3754	w: function(event, dx) {
	3755	var cs = this.originalSize, sp = this.originalPosition;
	3756	return { left: sp.left + dx, width: cs.width - dx };
	3757	},
	3758	n: function(event, dx, dy) {
	3759	var cs = this.originalSize, sp = this.originalPosition;
	3760	return { top: sp.top + dy, height: cs.height - dy };
	3761	},
	3762	s: function(event, dx, dy) {
	3763	return { height: this.originalSize.height + dy };
	3764	},
	3765	se: function(event, dx, dy) {
	3766	return $.extend(this._change.s.apply(this, arguments),
	3767	this._change.e.apply(this, [ event, dx, dy ]));
	3768	},
	3769	sw: function(event, dx, dy) {
	3770	return $.extend(this._change.s.apply(this, arguments),
	3771	this._change.w.apply(this, [ event, dx, dy ]));
	3772	},
	3773	ne: function(event, dx, dy) {
	3774	return $.extend(this._change.n.apply(this, arguments),
	3775	this._change.e.apply(this, [ event, dx, dy ]));
	3776	},
	3777	nw: function(event, dx, dy) {
	3778	return $.extend(this._change.n.apply(this, arguments),
	3779	this._change.w.apply(this, [ event, dx, dy ]));
	3780	}
	3781	},
	3782
	3783	_propagate: function(n, event) {
	3784	$.ui.plugin.call(this, n, [ event, this.ui() ]);
	3785	(n !== "resize" && this._trigger(n, event, this.ui()));
	3786	},
	3787
	3788	plugins: {},
	3789
	3790	ui: function() {
	3791	return {
	3792	originalElement: this.originalElement,
	3793	element: this.element,
	3794	helper: this.helper,
	3795	position: this.position,
	3796	size: this.size,
	3797	originalSize: this.originalSize,
	3798	originalPosition: this.originalPosition
	3799	};
	3800	}
	3801
	3802	});
	3803
	3804	/*
	3805	* Resizable Extensions
	3806	*/
	3807
	3808	$.ui.plugin.add("resizable", "animate", {
	3809
	3810	stop: function( event ) {
	3811	var that = $(this).resizable( "instance" ),
	3812	o = that.options,
	3813	pr = that._proportionallyResizeElements,
	3814	ista = pr.length && (/textarea/i).test(pr[0].nodeName),
	3815	soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
	3816	soffsetw = ista ? 0 : that.sizeDiff.width,
	3817	style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
	3818	left = (parseInt(that.element.css("left"), 10) +
	3819	(that.position.left - that.originalPosition.left)) \|\| null,
	3820	top = (parseInt(that.element.css("top"), 10) +
	3821	(that.position.top - that.originalPosition.top)) \|\| null;
	3822
	3823	that.element.animate(
	3824	$.extend(style, top && left ? { top: top, left: left } : {}), {
	3825	duration: o.animateDuration,
	3826	easing: o.animateEasing,
	3827	step: function() {
	3828
	3829	var data = {
	3830	width: parseInt(that.element.css("width"), 10),
	3831	height: parseInt(that.element.css("height"), 10),
	3832	top: parseInt(that.element.css("top"), 10),
	3833	left: parseInt(that.element.css("left"), 10)
	3834	};
	3835
	3836	if (pr && pr.length) {
	3837	$(pr[0]).css({ width: data.width, height: data.height });
	3838	}
	3839
	3840	// propagating resize, and updating values for each animation step
	3841	that._updateCache(data);
	3842	that._propagate("resize", event);
	3843
	3844	}
	3845	}
	3846	);
	3847	}
	3848
	3849	});
	3850
	3851	$.ui.plugin.add( "resizable", "containment", {
	3852
	3853	start: function() {
	3854	var element, p, co, ch, cw, width, height,
	3855	that = $( this ).resizable( "instance" ),
	3856	o = that.options,
	3857	el = that.element,
	3858	oc = o.containment,
	3859	ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
	3860
	3861	if ( !ce ) {
	3862	return;
	3863	}
	3864
	3865	that.containerElement = $( ce );
	3866
	3867	if ( /document/.test( oc ) \|\| oc === document ) {
	3868	that.containerOffset = {
	3869	left: 0,
	3870	top: 0
	3871	};
	3872	that.containerPosition = {
	3873	left: 0,
	3874	top: 0
	3875	};
	3876
	3877	that.parentData = {
	3878	element: $( document ),
	3879	left: 0,
	3880	top: 0,
	3881	width: $( document ).width(),
	3882	height: $( document ).height() \|\| document.body.parentNode.scrollHeight
	3883	};
	3884	} else {
	3885	element = $( ce );
	3886	p = [];
	3887	$([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) {
	3888	p[ i ] = that._num( element.css( "padding" + name ) );
	3889	});
	3890
	3891	that.containerOffset = element.offset();
	3892	that.containerPosition = element.position();
	3893	that.containerSize = {
	3894	height: ( element.innerHeight() - p[ 3 ] ),
	3895	width: ( element.innerWidth() - p[ 1 ] )
	3896	};
	3897
	3898	co = that.containerOffset;
	3899	ch = that.containerSize.height;
	3900	cw = that.containerSize.width;
	3901	width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
	3902	height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
	3903
	3904	that.parentData = {
	3905	element: ce,
	3906	left: co.left,
	3907	top: co.top,
	3908	width: width,
	3909	height: height
	3910	};
	3911	}
	3912	},
	3913
	3914	resize: function( event ) {
	3915	var woset, hoset, isParent, isOffsetRelative,
	3916	that = $( this ).resizable( "instance" ),
	3917	o = that.options,
	3918	co = that.containerOffset,
	3919	cp = that.position,
	3920	pRatio = that._aspectRatio \|\| event.shiftKey,
	3921	cop = {
	3922	top: 0,
	3923	left: 0
	3924	},
	3925	ce = that.containerElement,
	3926	continueResize = true;
	3927
	3928	if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
	3929	cop = co;
	3930	}
	3931
	3932	if ( cp.left < ( that._helper ? co.left : 0 ) ) {
	3933	that.size.width = that.size.width +
	3934	( that._helper ?
	3935	( that.position.left - co.left ) :
	3936	( that.position.left - cop.left ) );
	3937
	3938	if ( pRatio ) {
	3939	that.size.height = that.size.width / that.aspectRatio;
	3940	continueResize = false;
	3941	}
	3942	that.position.left = o.helper ? co.left : 0;
	3943	}
	3944
	3945	if ( cp.top < ( that._helper ? co.top : 0 ) ) {
	3946	that.size.height = that.size.height +
	3947	( that._helper ?
	3948	( that.position.top - co.top ) :
	3949	that.position.top );
	3950
	3951	if ( pRatio ) {
	3952	that.size.width = that.size.height * that.aspectRatio;
	3953	continueResize = false;
	3954	}
	3955	that.position.top = that._helper ? co.top : 0;
	3956	}
	3957
	3958	isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
	3959	isOffsetRelative = /relative\|absolute/.test( that.containerElement.css( "position" ) );
	3960
	3961	if ( isParent && isOffsetRelative ) {
	3962	that.offset.left = that.parentData.left + that.position.left;
	3963	that.offset.top = that.parentData.top + that.position.top;
	3964	} else {
	3965	that.offset.left = that.element.offset().left;
	3966	that.offset.top = that.element.offset().top;
	3967	}
	3968
	3969	woset = Math.abs( that.sizeDiff.width +
	3970	(that._helper ?
	3971	that.offset.left - cop.left :
	3972	(that.offset.left - co.left)) );
	3973
	3974	hoset = Math.abs( that.sizeDiff.height +
	3975	(that._helper ?
	3976	that.offset.top - cop.top :
	3977	(that.offset.top - co.top)) );
	3978
	3979	if ( woset + that.size.width >= that.parentData.width ) {
	3980	that.size.width = that.parentData.width - woset;
	3981	if ( pRatio ) {
	3982	that.size.height = that.size.width / that.aspectRatio;
	3983	continueResize = false;
	3984	}
	3985	}
	3986
	3987	if ( hoset + that.size.height >= that.parentData.height ) {
	3988	that.size.height = that.parentData.height - hoset;
	3989	if ( pRatio ) {
	3990	that.size.width = that.size.height * that.aspectRatio;
	3991	continueResize = false;
	3992	}
	3993	}
	3994
	3995	if ( !continueResize ) {
	3996	that.position.left = that.prevPosition.left;
	3997	that.position.top = that.prevPosition.top;
	3998	that.size.width = that.prevSize.width;
	3999	that.size.height = that.prevSize.height;
	4000	}
	4001	},
	4002
	4003	stop: function() {
	4004	var that = $( this ).resizable( "instance" ),
	4005	o = that.options,
	4006	co = that.containerOffset,
	4007	cop = that.containerPosition,
	4008	ce = that.containerElement,
	4009	helper = $( that.helper ),
	4010	ho = helper.offset(),
	4011	w = helper.outerWidth() - that.sizeDiff.width,
	4012	h = helper.outerHeight() - that.sizeDiff.height;
	4013
	4014	if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
	4015	$( this ).css({
	4016	left: ho.left - cop.left - co.left,
	4017	width: w,
	4018	height: h
	4019	});
	4020	}
	4021
	4022	if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
	4023	$( this ).css({
	4024	left: ho.left - cop.left - co.left,
	4025	width: w,
	4026	height: h
	4027	});
	4028	}
	4029	}
	4030	});
	4031
	4032	$.ui.plugin.add("resizable", "alsoResize", {
	4033
	4034	start: function() {
	4035	var that = $(this).resizable( "instance" ),
	4036	o = that.options;
	4037
	4038	$(o.alsoResize).each(function() {
	4039	var el = $(this);
	4040	el.data("ui-resizable-alsoresize", {
	4041	width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
	4042	left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
	4043	});
	4044	});
	4045	},
	4046
	4047	resize: function(event, ui) {
	4048	var that = $(this).resizable( "instance" ),
	4049	o = that.options,
	4050	os = that.originalSize,
	4051	op = that.originalPosition,
	4052	delta = {
	4053	height: (that.size.height - os.height) \|\| 0,
	4054	width: (that.size.width - os.width) \|\| 0,
	4055	top: (that.position.top - op.top) \|\| 0,
	4056	left: (that.position.left - op.left) \|\| 0
	4057	};
	4058
	4059	$(o.alsoResize).each(function() {
	4060	var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
	4061	css = el.parents(ui.originalElement[0]).length ?
	4062	[ "width", "height" ] :
	4063	[ "width", "height", "top", "left" ];
	4064
	4065	$.each(css, function(i, prop) {
	4066	var sum = (start[prop] \|\| 0) + (delta[prop] \|\| 0);
	4067	if (sum && sum >= 0) {
	4068	style[prop] = sum \|\| null;
	4069	}
	4070	});
	4071
	4072	el.css(style);
	4073	});
	4074	},
	4075
	4076	stop: function() {
	4077	$(this).removeData("resizable-alsoresize");
	4078	}
	4079	});
	4080
	4081	$.ui.plugin.add("resizable", "ghost", {
	4082
	4083	start: function() {
	4084
	4085	var that = $(this).resizable( "instance" ), o = that.options, cs = that.size;
	4086
	4087	that.ghost = that.originalElement.clone();
	4088	that.ghost
	4089	.css({
	4090	opacity: 0.25,
	4091	display: "block",
	4092	position: "relative",
	4093	height: cs.height,
	4094	width: cs.width,
	4095	margin: 0,
	4096	left: 0,
	4097	top: 0
	4098	})
	4099	.addClass("ui-resizable-ghost")
	4100	.addClass(typeof o.ghost === "string" ? o.ghost : "");
	4101
	4102	that.ghost.appendTo(that.helper);
	4103
	4104	},
	4105
	4106	resize: function() {
	4107	var that = $(this).resizable( "instance" );
	4108	if (that.ghost) {
	4109	that.ghost.css({
	4110	position: "relative",
	4111	height: that.size.height,
	4112	width: that.size.width
	4113	});
	4114	}
	4115	},
	4116
	4117	stop: function() {
	4118	var that = $(this).resizable( "instance" );
	4119	if (that.ghost && that.helper) {
	4120	that.helper.get(0).removeChild(that.ghost.get(0));
	4121	}
	4122	}
	4123
	4124	});
	4125
	4126	$.ui.plugin.add("resizable", "grid", {
	4127
	4128	resize: function() {
	4129	var outerDimensions,
	4130	that = $(this).resizable( "instance" ),
	4131	o = that.options,
	4132	cs = that.size,
	4133	os = that.originalSize,
	4134	op = that.originalPosition,
	4135	a = that.axis,
	4136	grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
	4137	gridX = (grid[0] \|\| 1),
	4138	gridY = (grid[1] \|\| 1),
	4139	ox = Math.round((cs.width - os.width) / gridX) * gridX,
	4140	oy = Math.round((cs.height - os.height) / gridY) * gridY,
	4141	newWidth = os.width + ox,
	4142	newHeight = os.height + oy,
	4143	isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
	4144	isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
	4145	isMinWidth = o.minWidth && (o.minWidth > newWidth),
	4146	isMinHeight = o.minHeight && (o.minHeight > newHeight);
	4147
	4148	o.grid = grid;
	4149
	4150	if (isMinWidth) {
	4151	newWidth += gridX;
	4152	}
	4153	if (isMinHeight) {
	4154	newHeight += gridY;
	4155	}
	4156	if (isMaxWidth) {
	4157	newWidth -= gridX;
	4158	}
	4159	if (isMaxHeight) {
	4160	newHeight -= gridY;
	4161	}
	4162
	4163	if (/^(se\|s\|e)$/.test(a)) {
	4164	that.size.width = newWidth;
	4165	that.size.height = newHeight;
	4166	} else if (/^(ne)$/.test(a)) {
	4167	that.size.width = newWidth;
	4168	that.size.height = newHeight;
	4169	that.position.top = op.top - oy;
	4170	} else if (/^(sw)$/.test(a)) {
	4171	that.size.width = newWidth;
	4172	that.size.height = newHeight;
	4173	that.position.left = op.left - ox;
	4174	} else {
	4175	if ( newHeight - gridY <= 0 \|\| newWidth - gridX <= 0) {
	4176	outerDimensions = that._getPaddingPlusBorderDimensions( this );
	4177	}
	4178
	4179	if ( newHeight - gridY > 0 ) {
	4180	that.size.height = newHeight;
	4181	that.position.top = op.top - oy;
	4182	} else {
	4183	newHeight = gridY - outerDimensions.height;
	4184	that.size.height = newHeight;
	4185	that.position.top = op.top + os.height - newHeight;
	4186	}
	4187	if ( newWidth - gridX > 0 ) {
	4188	that.size.width = newWidth;
	4189	that.position.left = op.left - ox;
	4190	} else {
	4191	newWidth = gridX - outerDimensions.width;
	4192	that.size.width = newWidth;
	4193	that.position.left = op.left + os.width - newWidth;
	4194	}
	4195	}
	4196	}
	4197
	4198	});
	4199
	4200	var resizable = $.ui.resizable;
	4201
	4202
	4203	/*!
	4204	* jQuery UI Selectable 1.11.4
	4205	* http://jqueryui.com
	4206	*
	4207	* Copyright jQuery Foundation and other contributors
	4208	* Released under the MIT license.
	4209	* http://jquery.org/license
	4210	*
	4211	* http://api.jqueryui.com/selectable/
	4212	*/
	4213
	4214
	4215	var selectable = $.widget("ui.selectable", $.ui.mouse, {
	4216	version: "1.11.4",
	4217	options: {
	4218	appendTo: "body",
	4219	autoRefresh: true,
	4220	distance: 0,
	4221	filter: "*",
	4222	tolerance: "touch",
	4223
	4224	// callbacks
	4225	selected: null,
	4226	selecting: null,
	4227	start: null,
	4228	stop: null,
	4229	unselected: null,
	4230	unselecting: null
	4231	},
	4232	_create: function() {
	4233	var selectees,
	4234	that = this;
	4235
	4236	this.element.addClass("ui-selectable");
	4237
	4238	this.dragged = false;
	4239
	4240	// cache selectee children based on filter
	4241	this.refresh = function() {
	4242	selectees = $(that.options.filter, that.element[0]);
	4243	selectees.addClass("ui-selectee");
	4244	selectees.each(function() {
	4245	var $this = $(this),
	4246	pos = $this.offset();
	4247	$.data(this, "selectable-item", {
	4248	element: this,
	4249	$element: $this,
	4250	left: pos.left,
	4251	top: pos.top,
	4252	right: pos.left + $this.outerWidth(),
	4253	bottom: pos.top + $this.outerHeight(),
	4254	startselected: false,
	4255	selected: $this.hasClass("ui-selected"),
	4256	selecting: $this.hasClass("ui-selecting"),
	4257	unselecting: $this.hasClass("ui-unselecting")
	4258	});
	4259	});
	4260	};
	4261	this.refresh();
	4262
	4263	this.selectees = selectees.addClass("ui-selectee");
	4264
	4265	this._mouseInit();
	4266
	4267	this.helper = $("<div class='ui-selectable-helper'></div>");
	4268	},
	4269
	4270	_destroy: function() {
	4271	this.selectees
	4272	.removeClass("ui-selectee")
	4273	.removeData("selectable-item");
	4274	this.element
	4275	.removeClass("ui-selectable ui-selectable-disabled");
	4276	this._mouseDestroy();
	4277	},
	4278
	4279	_mouseStart: function(event) {
	4280	var that = this,
	4281	options = this.options;
	4282
	4283	this.opos = [ event.pageX, event.pageY ];
	4284
	4285	if (this.options.disabled) {
	4286	return;
	4287	}
	4288
	4289	this.selectees = $(options.filter, this.element[0]);
	4290
	4291	this._trigger("start", event);
	4292
	4293	$(options.appendTo).append(this.helper);
	4294	// position helper (lasso)
	4295	this.helper.css({
	4296	"left": event.pageX,
	4297	"top": event.pageY,
	4298	"width": 0,
	4299	"height": 0
	4300	});
	4301
	4302	if (options.autoRefresh) {
	4303	this.refresh();
	4304	}
	4305
	4306	this.selectees.filter(".ui-selected").each(function() {
	4307	var selectee = $.data(this, "selectable-item");
	4308	selectee.startselected = true;
	4309	if (!event.metaKey && !event.ctrlKey) {
	4310	selectee.$element.removeClass("ui-selected");
	4311	selectee.selected = false;
	4312	selectee.$element.addClass("ui-unselecting");
	4313	selectee.unselecting = true;
	4314	// selectable UNSELECTING callback
	4315	that._trigger("unselecting", event, {
	4316	unselecting: selectee.element
	4317	});
	4318	}
	4319	});
	4320
	4321	$(event.target).parents().addBack().each(function() {
	4322	var doSelect,
	4323	selectee = $.data(this, "selectable-item");
	4324	if (selectee) {
	4325	doSelect = (!event.metaKey && !event.ctrlKey) \|\| !selectee.$element.hasClass("ui-selected");
	4326	selectee.$element
	4327	.removeClass(doSelect ? "ui-unselecting" : "ui-selected")
	4328	.addClass(doSelect ? "ui-selecting" : "ui-unselecting");
	4329	selectee.unselecting = !doSelect;
	4330	selectee.selecting = doSelect;
	4331	selectee.selected = doSelect;
	4332	// selectable (UN)SELECTING callback
	4333	if (doSelect) {
	4334	that._trigger("selecting", event, {
	4335	selecting: selectee.element
	4336	});
	4337	} else {
	4338	that._trigger("unselecting", event, {
	4339	unselecting: selectee.element
	4340	});
	4341	}
	4342	return false;
	4343	}
	4344	});
	4345
	4346	},
	4347
	4348	_mouseDrag: function(event) {
	4349
	4350	this.dragged = true;
	4351
	4352	if (this.options.disabled) {
	4353	return;
	4354	}
	4355
	4356	var tmp,
	4357	that = this,
	4358	options = this.options,
	4359	x1 = this.opos[0],
	4360	y1 = this.opos[1],
	4361	x2 = event.pageX,
	4362	y2 = event.pageY;
	4363
	4364	if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
	4365	if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
	4366	this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
	4367
	4368	this.selectees.each(function() {
	4369	var selectee = $.data(this, "selectable-item"),
	4370	hit = false;
	4371
	4372	//prevent helper from being selected if appendTo: selectable
	4373	if (!selectee \|\| selectee.element === that.element[0]) {
	4374	return;
	4375	}
	4376
	4377	if (options.tolerance === "touch") {
	4378	hit = ( !(selectee.left > x2 \|\| selectee.right < x1 \|\| selectee.top > y2 \|\| selectee.bottom < y1) );
	4379	} else if (options.tolerance === "fit") {
	4380	hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
	4381	}
	4382
	4383	if (hit) {
	4384	// SELECT
	4385	if (selectee.selected) {
	4386	selectee.$element.removeClass("ui-selected");
	4387	selectee.selected = false;
	4388	}
	4389	if (selectee.unselecting) {
	4390	selectee.$element.removeClass("ui-unselecting");
	4391	selectee.unselecting = false;
	4392	}
	4393	if (!selectee.selecting) {
	4394	selectee.$element.addClass("ui-selecting");
	4395	selectee.selecting = true;
	4396	// selectable SELECTING callback
	4397	that._trigger("selecting", event, {
	4398	selecting: selectee.element
	4399	});
	4400	}
	4401	} else {
	4402	// UNSELECT
	4403	if (selectee.selecting) {
	4404	if ((event.metaKey \|\| event.ctrlKey) && selectee.startselected) {
	4405	selectee.$element.removeClass("ui-selecting");
	4406	selectee.selecting = false;
	4407	selectee.$element.addClass("ui-selected");
	4408	selectee.selected = true;
	4409	} else {
	4410	selectee.$element.removeClass("ui-selecting");
	4411	selectee.selecting = false;
	4412	if (selectee.startselected) {
	4413	selectee.$element.addClass("ui-unselecting");
	4414	selectee.unselecting = true;
	4415	}
	4416	// selectable UNSELECTING callback
	4417	that._trigger("unselecting", event, {
	4418	unselecting: selectee.element
	4419	});
	4420	}
	4421	}
	4422	if (selectee.selected) {
	4423	if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
	4424	selectee.$element.removeClass("ui-selected");
	4425	selectee.selected = false;
	4426
	4427	selectee.$element.addClass("ui-unselecting");
	4428	selectee.unselecting = true;
	4429	// selectable UNSELECTING callback
	4430	that._trigger("unselecting", event, {
	4431	unselecting: selectee.element
	4432	});
	4433	}
	4434	}
	4435	}
	4436	});
	4437
	4438	return false;
	4439	},
	4440
	4441	_mouseStop: function(event) {
	4442	var that = this;
	4443
	4444	this.dragged = false;
	4445
	4446	$(".ui-unselecting", this.element[0]).each(function() {
	4447	var selectee = $.data(this, "selectable-item");
	4448	selectee.$element.removeClass("ui-unselecting");
	4449	selectee.unselecting = false;
	4450	selectee.startselected = false;
	4451	that._trigger("unselected", event, {
	4452	unselected: selectee.element
	4453	});
	4454	});
	4455	$(".ui-selecting", this.element[0]).each(function() {
	4456	var selectee = $.data(this, "selectable-item");
	4457	selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
	4458	selectee.selecting = false;
	4459	selectee.selected = true;
	4460	selectee.startselected = true;
	4461	that._trigger("selected", event, {
	4462	selected: selectee.element
	4463	});
	4464	});
	4465	this._trigger("stop", event);
	4466
	4467	this.helper.remove();
	4468
	4469	return false;
	4470	}
	4471
	4472	});
	4473
	4474
	4475	/*!
	4476	* jQuery UI Sortable 1.11.4
	4477	* http://jqueryui.com
	4478	*
	4479	* Copyright jQuery Foundation and other contributors
	4480	* Released under the MIT license.
	4481	* http://jquery.org/license
	4482	*
	4483	* http://api.jqueryui.com/sortable/
	4484	*/
	4485
	4486
	4487	var sortable = $.widget("ui.sortable", $.ui.mouse, {
	4488	version: "1.11.4",
	4489	widgetEventPrefix: "sort",
	4490	ready: false,
	4491	options: {
	4492	appendTo: "parent",
	4493	axis: false,
	4494	connectWith: false,
	4495	containment: false,
	4496	cursor: "auto",
	4497	cursorAt: false,
	4498	dropOnEmpty: true,
	4499	forcePlaceholderSize: false,
	4500	forceHelperSize: false,
	4501	grid: false,
	4502	handle: false,
	4503	helper: "original",
	4504	items: "> *",
	4505	opacity: false,
	4506	placeholder: false,
	4507	revert: false,
	4508	scroll: true,
	4509	scrollSensitivity: 20,
	4510	scrollSpeed: 20,
	4511	scope: "default",
	4512	tolerance: "intersect",
	4513	zIndex: 1000,
	4514
	4515	// callbacks
	4516	activate: null,
	4517	beforeStop: null,
	4518	change: null,
	4519	deactivate: null,
	4520	out: null,
	4521	over: null,
	4522	receive: null,
	4523	remove: null,
	4524	sort: null,
	4525	start: null,
	4526	stop: null,
	4527	update: null
	4528	},
	4529
	4530	_isOverAxis: function( x, reference, size ) {
	4531	return ( x >= reference ) && ( x < ( reference + size ) );
	4532	},
	4533
	4534	_isFloating: function( item ) {
	4535	return (/left\|right/).test(item.css("float")) \|\| (/inline\|table-cell/).test(item.css("display"));
	4536	},
	4537
	4538	_create: function() {
	4539	this.containerCache = {};
	4540	this.element.addClass("ui-sortable");
	4541
	4542	//Get the items
	4543	this.refresh();
	4544
	4545	//Let's determine the parent's offset
	4546	this.offset = this.element.offset();
	4547
	4548	//Initialize mouse events for interaction
	4549	this._mouseInit();
	4550
	4551	this._setHandleClassName();
	4552
	4553	//We're ready to go
	4554	this.ready = true;
	4555
	4556	},
	4557
	4558	_setOption: function( key, value ) {
	4559	this._super( key, value );
	4560
	4561	if ( key === "handle" ) {
	4562	this._setHandleClassName();
	4563	}
	4564	},
	4565
	4566	_setHandleClassName: function() {
	4567	this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
	4568	$.each( this.items, function() {
	4569	( this.instance.options.handle ?
	4570	this.item.find( this.instance.options.handle ) : this.item )
	4571	.addClass( "ui-sortable-handle" );
	4572	});
	4573	},
	4574
	4575	_destroy: function() {
	4576	this.element
	4577	.removeClass( "ui-sortable ui-sortable-disabled" )
	4578	.find( ".ui-sortable-handle" )
	4579	.removeClass( "ui-sortable-handle" );
	4580	this._mouseDestroy();
	4581
	4582	for ( var i = this.items.length - 1; i >= 0; i-- ) {
	4583	this.items[i].item.removeData(this.widgetName + "-item");
	4584	}
	4585
	4586	return this;
	4587	},
	4588
	4589	_mouseCapture: function(event, overrideHandle) {
	4590	var currentItem = null,
	4591	validHandle = false,
	4592	that = this;
	4593
	4594	if (this.reverting) {
	4595	return false;
	4596	}
	4597
	4598	if(this.options.disabled \|\| this.options.type === "static") {
	4599	return false;
	4600	}
	4601
	4602	//We have to refresh the items data once first
	4603	this._refreshItems(event);
	4604
	4605	//Find out if the clicked node (or one of its parents) is a actual item in this.items
	4606	$(event.target).parents().each(function() {
	4607	if($.data(this, that.widgetName + "-item") === that) {
	4608	currentItem = $(this);
	4609	return false;
	4610	}
	4611	});
	4612	if($.data(event.target, that.widgetName + "-item") === that) {
	4613	currentItem = $(event.target);
	4614	}
	4615
	4616	if(!currentItem) {
	4617	return false;
	4618	}
	4619	if(this.options.handle && !overrideHandle) {
	4620	$(this.options.handle, currentItem).find("*").addBack().each(function() {
	4621	if(this === event.target) {
	4622	validHandle = true;
	4623	}
	4624	});
	4625	if(!validHandle) {
	4626	return false;
	4627	}
	4628	}
	4629
	4630	this.currentItem = currentItem;
	4631	this._removeCurrentsFromItems();
	4632	return true;
	4633
	4634	},
	4635
	4636	_mouseStart: function(event, overrideHandle, noActivation) {
	4637
	4638	var i, body,
	4639	o = this.options;
	4640
	4641	this.currentContainer = this;
	4642
	4643	//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
	4644	this.refreshPositions();
	4645
	4646	//Create and append the visible helper
	4647	this.helper = this._createHelper(event);
	4648
	4649	//Cache the helper size
	4650	this._cacheHelperProportions();
	4651
	4652	/*
	4653	* - Position generation -
	4654	* This block generates everything position related - it's the core of draggables.
	4655	*/
	4656
	4657	//Cache the margins of the original element
	4658	this._cacheMargins();
	4659
	4660	//Get the next scrolling parent
	4661	this.scrollParent = this.helper.scrollParent();
	4662
	4663	//The element's absolute position on the page minus margins
	4664	this.offset = this.currentItem.offset();
	4665	this.offset = {
	4666	top: this.offset.top - this.margins.top,
	4667	left: this.offset.left - this.margins.left
	4668	};
	4669
	4670	$.extend(this.offset, {
	4671	click: { //Where the click happened, relative to the element
	4672	left: event.pageX - this.offset.left,
	4673	top: event.pageY - this.offset.top
	4674	},
	4675	parent: this._getParentOffset(),
	4676	relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
	4677	});
	4678
	4679	// Only after we got the offset, we can change the helper's position to absolute
	4680	// TODO: Still need to figure out a way to make relative sorting possible
	4681	this.helper.css("position", "absolute");
	4682	this.cssPosition = this.helper.css("position");
	4683
	4684	//Generate the original position
	4685	this.originalPosition = this._generatePosition(event);
	4686	this.originalPageX = event.pageX;
	4687	this.originalPageY = event.pageY;
	4688
	4689	//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
	4690	(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
	4691
	4692	//Cache the former DOM position
	4693	this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
	4694
	4695	//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
	4696	if(this.helper[0] !== this.currentItem[0]) {
	4697	this.currentItem.hide();
	4698	}
	4699
	4700	//Create the placeholder
	4701	this._createPlaceholder();
	4702
	4703	//Set a containment if given in the options
	4704	if(o.containment) {
	4705	this._setContainment();
	4706	}
	4707
	4708	if( o.cursor && o.cursor !== "auto" ) { // cursor option
	4709	body = this.document.find( "body" );
	4710
	4711	// support: IE
	4712	this.storedCursor = body.css( "cursor" );
	4713	body.css( "cursor", o.cursor );
	4714
	4715	this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
	4716	}
	4717
	4718	if(o.opacity) { // opacity option
	4719	if (this.helper.css("opacity")) {
	4720	this._storedOpacity = this.helper.css("opacity");
	4721	}
	4722	this.helper.css("opacity", o.opacity);
	4723	}
	4724
	4725	if(o.zIndex) { // zIndex option
	4726	if (this.helper.css("zIndex")) {
	4727	this._storedZIndex = this.helper.css("zIndex");
	4728	}
	4729	this.helper.css("zIndex", o.zIndex);
	4730	}
	4731
	4732	//Prepare scrolling
	4733	if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
	4734	this.overflowOffset = this.scrollParent.offset();
	4735	}
	4736
	4737	//Call callbacks
	4738	this._trigger("start", event, this._uiHash());
	4739
	4740	//Recache the helper size
	4741	if(!this._preserveHelperProportions) {
	4742	this._cacheHelperProportions();
	4743	}
	4744
	4745
	4746	//Post "activate" events to possible containers
	4747	if( !noActivation ) {
	4748	for ( i = this.containers.length - 1; i >= 0; i-- ) {
	4749	this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
	4750	}
	4751	}
	4752
	4753	//Prepare possible droppables
	4754	if($.ui.ddmanager) {
	4755	$.ui.ddmanager.current = this;
	4756	}
	4757
	4758	if ($.ui.ddmanager && !o.dropBehaviour) {
	4759	$.ui.ddmanager.prepareOffsets(this, event);
	4760	}
	4761
	4762	this.dragging = true;
	4763
	4764	this.helper.addClass("ui-sortable-helper");
	4765	this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
	4766	return true;
	4767
	4768	},
	4769
	4770	_mouseDrag: function(event) {
	4771	var i, item, itemElement, intersection,
	4772	o = this.options,
	4773	scrolled = false;
	4774
	4775	//Compute the helpers position
	4776	this.position = this._generatePosition(event);
	4777	this.positionAbs = this._convertPositionTo("absolute");
	4778
	4779	if (!this.lastPositionAbs) {
	4780	this.lastPositionAbs = this.positionAbs;
	4781	}
	4782
	4783	//Do scrolling
	4784	if(this.options.scroll) {
	4785	if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
	4786
	4787	if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
	4788	this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
	4789	} else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
	4790	this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
	4791	}
	4792
	4793	if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
	4794	this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
	4795	} else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
	4796	this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
	4797	}
	4798
	4799	} else {
	4800
	4801	if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
	4802	scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
	4803	} else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
	4804	scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
	4805	}
	4806
	4807	if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
	4808	scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
	4809	} else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
	4810	scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
	4811	}
	4812
	4813	}
	4814
	4815	if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
	4816	$.ui.ddmanager.prepareOffsets(this, event);
	4817	}
	4818	}
	4819
	4820	//Regenerate the absolute position used for position checks
	4821	this.positionAbs = this._convertPositionTo("absolute");
	4822
	4823	//Set the helper position
	4824	if(!this.options.axis \|\| this.options.axis !== "y") {
	4825	this.helper[0].style.left = this.position.left+"px";
	4826	}
	4827	if(!this.options.axis \|\| this.options.axis !== "x") {
	4828	this.helper[0].style.top = this.position.top+"px";
	4829	}
	4830
	4831	//Rearrange
	4832	for (i = this.items.length - 1; i >= 0; i--) {
	4833
	4834	//Cache variables and intersection, continue if no intersection
	4835	item = this.items[i];
	4836	itemElement = item.item[0];
	4837	intersection = this._intersectsWithPointer(item);
	4838	if (!intersection) {
	4839	continue;
	4840	}
	4841
	4842	// Only put the placeholder inside the current Container, skip all
	4843	// items from other containers. This works because when moving
	4844	// an item from one container to another the
	4845	// currentContainer is switched before the placeholder is moved.
	4846	//
	4847	// Without this, moving items in "sub-sortables" can cause
	4848	// the placeholder to jitter between the outer and inner container.
	4849	if (item.instance !== this.currentContainer) {
	4850	continue;
	4851	}
	4852
	4853	// cannot intersect with itself
	4854	// no useless actions that have been done before
	4855	// no action if the item moved is the parent of the item checked
	4856	if (itemElement !== this.currentItem[0] &&
	4857	this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
	4858	!$.contains(this.placeholder[0], itemElement) &&
	4859	(this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
	4860	) {
	4861
	4862	this.direction = intersection === 1 ? "down" : "up";
	4863
	4864	if (this.options.tolerance === "pointer" \|\| this._intersectsWithSides(item)) {
	4865	this._rearrange(event, item);
	4866	} else {
	4867	break;
	4868	}
	4869
	4870	this._trigger("change", event, this._uiHash());
	4871	break;
	4872	}
	4873	}
	4874
	4875	//Post events to containers
	4876	this._contactContainers(event);
	4877
	4878	//Interconnect with droppables
	4879	if($.ui.ddmanager) {
	4880	$.ui.ddmanager.drag(this, event);
	4881	}
	4882
	4883	//Call callbacks
	4884	this._trigger("sort", event, this._uiHash());
	4885
	4886	this.lastPositionAbs = this.positionAbs;
	4887	return false;
	4888
	4889	},
	4890
	4891	_mouseStop: function(event, noPropagation) {
	4892
	4893	if(!event) {
	4894	return;
	4895	}
	4896
	4897	//If we are using droppables, inform the manager about the drop
	4898	if ($.ui.ddmanager && !this.options.dropBehaviour) {
	4899	$.ui.ddmanager.drop(this, event);
	4900	}
	4901
	4902	if(this.options.revert) {
	4903	var that = this,
	4904	cur = this.placeholder.offset(),
	4905	axis = this.options.axis,
	4906	animation = {};
	4907
	4908	if ( !axis \|\| axis === "x" ) {
	4909	animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
	4910	}
	4911	if ( !axis \|\| axis === "y" ) {
	4912	animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
	4913	}
	4914	this.reverting = true;
	4915	$(this.helper).animate( animation, parseInt(this.options.revert, 10) \|\| 500, function() {
	4916	that._clear(event);
	4917	});
	4918	} else {
	4919	this._clear(event, noPropagation);
	4920	}
	4921
	4922	return false;
	4923
	4924	},
	4925
	4926	cancel: function() {
	4927
	4928	if(this.dragging) {
	4929
	4930	this._mouseUp({ target: null });
	4931
	4932	if(this.options.helper === "original") {
	4933	this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
	4934	} else {
	4935	this.currentItem.show();
	4936	}
	4937
	4938	//Post deactivating events to containers
	4939	for (var i = this.containers.length - 1; i >= 0; i--){
	4940	this.containers[i]._trigger("deactivate", null, this._uiHash(this));
	4941	if(this.containers[i].containerCache.over) {
	4942	this.containers[i]._trigger("out", null, this._uiHash(this));
	4943	this.containers[i].containerCache.over = 0;
	4944	}
	4945	}
	4946
	4947	}
	4948
	4949	if (this.placeholder) {
	4950	//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
	4951	if(this.placeholder[0].parentNode) {
	4952	this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
	4953	}
	4954	if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
	4955	this.helper.remove();
	4956	}
	4957
	4958	$.extend(this, {
	4959	helper: null,
	4960	dragging: false,
	4961	reverting: false,
	4962	_noFinalSort: null
	4963	});
	4964
	4965	if(this.domPosition.prev) {
	4966	$(this.domPosition.prev).after(this.currentItem);
	4967	} else {
	4968	$(this.domPosition.parent).prepend(this.currentItem);
	4969	}
	4970	}
	4971
	4972	return this;
	4973
	4974	},
	4975
	4976	serialize: function(o) {
	4977
	4978	var items = this._getItemsAsjQuery(o && o.connected),
	4979	str = [];
	4980	o = o \|\| {};
	4981
	4982	$(items).each(function() {
	4983	var res = ($(o.item \|\| this).attr(o.attribute \|\| "id") \|\| "").match(o.expression \|\| (/(.+)[\-=_](.+)/));
	4984	if (res) {
	4985	str.push((o.key \|\| res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
	4986	}
	4987	});
	4988
	4989	if(!str.length && o.key) {
	4990	str.push(o.key + "=");
	4991	}
	4992
	4993	return str.join("&");
	4994
	4995	},
	4996
	4997	toArray: function(o) {
	4998
	4999	var items = this._getItemsAsjQuery(o && o.connected),

11618 more lines aren’t shown here.

Source/Libraries/GSF.Web/Shared/Scripts/primeui.js+13963−0

@@ -0,0 +1,13963 @@
	1	/**
	2	* PUI Object
	3	*/
	4	var PUI = {
	5
	6	zindex : 1000,
	7
	8	gridColumns: {
	9	'1': 'ui-grid-col-12',
	10	'2': 'ui-grid-col-6',
	11	'3': 'ui-grid-col-4',
	12	'4': 'ui-grid-col-3',
	13	'6': 'ui-grid-col-2',
	14	'12': 'ui-grid-col-11'
	15	},
	16
	17	charSet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
	18
	19	/**
	20	* Aligns container scrollbar to keep item in container viewport, algorithm copied from jquery-ui menu widget
	21	*/
	22	scrollInView: function(container, item) {
	23	var borderTop = parseFloat(container.css('borderTopWidth')) \|\| 0,
	24	paddingTop = parseFloat(container.css('paddingTop')) \|\| 0,
	25	offset = item.offset().top - container.offset().top - borderTop - paddingTop,
	26	scroll = container.scrollTop(),
	27	elementHeight = container.height(),
	28	itemHeight = item.outerHeight(true);
	29
	30	if(offset < 0) {
	31	container.scrollTop(scroll + offset);
	32	}
	33	else if((offset + itemHeight) > elementHeight) {
	34	container.scrollTop(scroll + offset - elementHeight + itemHeight);
	35	}
	36	},
	37
	38	generateRandomId: function() {
	39	var id = '';
	40	for (var i = 1; i <= 10; i++) {
	41	var randPos = Math.floor(Math.random() * this.charSet.length);
	42	id += this.charSet[randPos];
	43	}
	44	return id;
	45	},
	46
	47	isIE: function(version) {
	48	return (this.browser.msie && parseInt(this.browser.version, 10) === version);
	49	},
	50
	51	escapeRegExp: function(text) {
	52	return text.replace(/([.?*+^$[\]\\(){}\|-])/g, "\\$1");
	53	},
	54
	55	escapeHTML: function(value) {
	56	return value.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
	57	},
	58
	59	escapeClientId: function(id) {
	60	return "#" + id.replace(/:/g,"\\:");
	61	},
	62
	63	clearSelection: function() {
	64	if(window.getSelection) {
	65	if(window.getSelection().empty) {
	66	window.getSelection().empty();
	67	} else if(window.getSelection().removeAllRanges) {
	68	window.getSelection().removeAllRanges();
	69	}
	70	} else if(document.selection && document.selection.empty) {
	71	document.selection.empty();
	72	}
	73	},
	74
	75	inArray: function(arr, item) {
	76	for(var i = 0; i < arr.length; i++) {
	77	if(arr[i] === item) {
	78	return true;
	79	}
	80	}
	81
	82	return false;
	83	},
	84
	85	calculateScrollbarWidth: function() {
	86	if(!this.scrollbarWidth) {
	87	if(this.browser.msie) {
	88	var $textarea1 = $('<textarea cols="10" rows="2"></textarea>')
	89	.css({ position: 'absolute', top: -1000, left: -1000 }).appendTo('body'),
	90	$textarea2 = $('<textarea cols="10" rows="2" style="overflow: hidden;"></textarea>')
	91	.css({ position: 'absolute', top: -1000, left: -1000 }).appendTo('body');
	92	this.scrollbarWidth = $textarea1.width() - $textarea2.width();
	93	$textarea1.add($textarea2).remove();
	94	}
	95	else {
	96	var $div = $('<div />')
	97	.css({ width: 100, height: 100, overflow: 'auto', position: 'absolute', top: -1000, left: -1000 })
	98	.prependTo('body').append('<div />').find('div')
	99	.css({ width: '100%', height: 200 });
	100	this.scrollbarWidth = 100 - $div.width();
	101	$div.parent().remove();
	102	}
	103	}
	104
	105	return this.scrollbarWidth;
	106	},
	107
	108	//adapted from jquery browser plugin
	109	resolveUserAgent: function() {
	110	var matched, browser;
	111
	112	jQuery.uaMatch = function( ua ) {
	113	ua = ua.toLowerCase();
	114
	115	var match = /(opr)[\/]([\w.]+)/.exec( ua ) \|\|
	116	/(chrome)[ \/]([\w.]+)/.exec( ua ) \|\|
	117	/(version)[ \/]([\w.]+).*(safari)[ \/]([\w.]+)/.exec( ua ) \|\|
	118	/(webkit)[ \/]([\w.]+)/.exec( ua ) \|\|
	119	/(opera)(?:.*version\|)[ \/]([\w.]+)/.exec( ua ) \|\|
	120	/(msie) ([\w.]+)/.exec( ua ) \|\|
	121	ua.indexOf("trident") >= 0 && /(rv)(?::\| )([\w.]+)/.exec( ua ) \|\|
	122	ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)\|)/.exec( ua ) \|\|
	123	[];
	124
	125	var platform_match = /(ipad)/.exec( ua ) \|\|
	126	/(iphone)/.exec( ua ) \|\|
	127	/(android)/.exec( ua ) \|\|
	128	/(windows phone)/.exec( ua ) \|\|
	129	/(win)/.exec( ua ) \|\|
	130	/(mac)/.exec( ua ) \|\|
	131	/(linux)/.exec( ua ) \|\|
	132	/(cros)/i.exec( ua ) \|\|
	133	[];
	134
	135	return {
	136	browser: match[ 3 ] \|\| match[ 1 ] \|\| "",
	137	version: match[ 2 ] \|\| "0",
	138	platform: platform_match[ 0 ] \|\| ""
	139	};
	140	};
	141
	142	matched = jQuery.uaMatch( window.navigator.userAgent );
	143	browser = {};
	144
	145	if ( matched.browser ) {
	146	browser[ matched.browser ] = true;
	147	browser.version = matched.version;
	148	browser.versionNumber = parseInt(matched.version);
	149	}
	150
	151	if ( matched.platform ) {
	152	browser[ matched.platform ] = true;
	153	}
	154
	155	// These are all considered mobile platforms, meaning they run a mobile browser
	156	if ( browser.android \|\| browser.ipad \|\| browser.iphone \|\| browser[ "windows phone" ] ) {
	157	browser.mobile = true;
	158	}
	159
	160	// These are all considered desktop platforms, meaning they run a desktop browser
	161	if ( browser.cros \|\| browser.mac \|\| browser.linux \|\| browser.win ) {
	162	browser.desktop = true;
	163	}
	164
	165	// Chrome, Opera 15+ and Safari are webkit based browsers
	166	if ( browser.chrome \|\| browser.opr \|\| browser.safari ) {
	167	browser.webkit = true;
	168	}
	169
	170	// IE11 has a new token so we will assign it msie to avoid breaking changes
	171	if ( browser.rv )
	172	{
	173	var ie = "msie";
	174
	175	matched.browser = ie;
	176	browser[ie] = true;
	177	}
	178
	179	// Opera 15+ are identified as opr
	180	if ( browser.opr )
	181	{
	182	var opera = "opera";
	183
	184	matched.browser = opera;
	185	browser[opera] = true;
	186	}
	187
	188	// Stock Android browsers are marked as Safari on Android.
	189	if ( browser.safari && browser.android )
	190	{
	191	var android = "android";
	192
	193	matched.browser = android;
	194	browser[android] = true;
	195	}
	196
	197	// Assign the name and platform variable
	198	browser.name = matched.browser;
	199	browser.platform = matched.platform;
	200
	201	this.browser = browser;
	202	$.browser = browser;
	203	},
	204
	205	getGridColumn: function(number) {
	206	return this.gridColumns[number + ''];
	207	},
	208
	209	executeFunctionByName: function(functionName /, args /) {
	210	var args = [].slice.call(arguments).splice(1),
	211	context = window,
	212	namespaces = functionName.split("."),
	213	func = namespaces.pop();
	214	for(var i = 0; i < namespaces.length; i++) {
	215	context = context[namespaces[i]];
	216	}
	217	return context[func].apply(this, args);
	218	},
	219
	220	resolveObjectByName: function(name) {
	221	if(name) {
	222	var parts = name.split(".");
	223	for(var i = 0, len = parts.length, obj = window; i < len; ++i) {
	224	obj = obj[parts[i]];
	225	}
	226	return obj;
	227	}
	228	else {
	229	return null;
	230	}
	231	},
	232
	233	getCookie : function(name) {
	234	return $.cookie(name);
	235	},
	236
	237	setCookie : function(name, value, cfg) {
	238	$.cookie(name, value, cfg);
	239	},
	240
	241	deleteCookie: function(name, cfg) {
	242	$.removeCookie(name, cfg);
	243	}
	244
	245	};
	246
	247	PUI.resolveUserAgent();
	248	/**
	249	* PrimeUI Accordion widget
	250	*/
	251	(function() {
	252
	253	$.widget("primeui.puiaccordion", {
	254
	255	options: {
	256	activeIndex: 0,
	257	multiple: false
	258	},
	259
	260	_create: function() {
	261	if(this.options.multiple) {
	262	this.options.activeIndex = this.options.activeIndex\|\|[0];
	263	}
	264
	265	var $this = this;
	266	this.element.addClass('ui-accordion ui-widget ui-helper-reset');
	267
	268	var tabContainers = this.element.children();
	269
	270	//primeui
	271	if(tabContainers.is('div')) {
	272	this.panelMode = 'native';
	273	this.headers = this.element.children('h3');
	274	this.panels = this.element.children('div');
	275	}
	276	//primeng
	277	else {
	278	this.panelMode = 'wrapped';
	279	this.headers = tabContainers.children('h3');
	280	this.panels = tabContainers.children('div');
	281	}
	282
	283	this.headers.addClass('ui-accordion-header ui-helper-reset ui-state-default').each(function(i) {
	284	var header = $(this),
	285	title = header.html(),
	286	active = $this.options.multiple ? ($.inArray(i, $this.options.activeIndex) !== -1) : (i == $this.options.activeIndex),
	287	headerClass = (active) ? 'ui-state-active ui-corner-top' : 'ui-corner-all',
	288	iconClass = (active) ? 'fa fa-fw fa-caret-down' : 'fa fa-fw fa-caret-right';
	289
	290	header.addClass(headerClass).html('<span class="' + iconClass + '"></span><a href="#">' + title + '</a>');
	291	});
	292
	293	this.panels.each(function(i) {
	294	var content = $(this);
	295	content.addClass('ui-accordion-content ui-helper-reset ui-widget-content'),
	296	active = $this.options.multiple ? ($.inArray(i, $this.options.activeIndex) !== -1) : (i == $this.options.activeIndex);
	297
	298	if(!active) {
	299	content.addClass('ui-helper-hidden');
	300	}
	301	});
	302
	303	this.headers.children('a').disableSelection();
	304
	305	this._bindEvents();
	306	},
	307
	308	_destroy: function() {
	309	this._unbindEvents();
	310	this.element.removeClass('ui-accordion ui-widget ui-helper-reset');
	311	this.headers.removeClass('ui-accordion-header ui-helper-reset ui-state-default ui-state-hover ui-state-active ui-state-disabled ui-corner-all ui-corner-top');
	312	this.panels.removeClass('ui-accordion-content ui-helper-reset ui-widget-content ui-helper-hidden');
	313	this.headers.children('.fa').remove();
	314	this.headers.children('a').contents().unwrap();
	315	},
	316
	317	_bindEvents: function() {
	318	var $this = this;
	319
	320	this.headers.on('mouseover.puiaccordion', function() {
	321	var element = $(this);
	322	if(!element.hasClass('ui-state-active')&&!element.hasClass('ui-state-disabled')) {
	323	element.addClass('ui-state-hover');
	324	}
	325	}).on('mouseout.puiaccordion', function() {
	326	var element = $(this);
	327	if(!element.hasClass('ui-state-active')&&!element.hasClass('ui-state-disabled')) {
	328	element.removeClass('ui-state-hover');
	329	}
	330	}).on('click.puiaccordion', function(e) {
	331	var element = $(this);
	332	if(!element.hasClass('ui-state-disabled')) {
	333	var tabIndex = ($this.panelMode === 'native') ? element.index() / 2 : element.parent().index();
	334
	335	if(element.hasClass('ui-state-active')) {
	336	$this.unselect(tabIndex);
	337	}
	338	else {
	339	$this.select(tabIndex, false);
	340	}
	341	}
	342
	343	e.preventDefault();
	344	});
	345	},
	346
	347	_unbindEvents: function() {
	348	this.headers.off('mouseover.puiaccordion mouseout.puiaccordion click.puiaccordion');
	349	},
	350
	351	/**
	352	* Activates a tab with given index
	353	*/
	354	select: function(index, silent) {
	355	var panel = this.panels.eq(index);
	356
	357	if(!silent) {
	358	this._trigger('change', null, {'index': index});
	359	}
	360
	361	//update state
	362	if(this.options.multiple) {
	363	this._addToSelection(index);
	364	}
	365	else {
	366	this.options.activeIndex = index;
	367	}
	368	this._show(panel);
	369	},
	370
	371	/**
	372	* Deactivates a tab with given index
	373	*/
	374	unselect: function(index) {
	375	var panel = this.panels.eq(index),
	376	header = panel.prev();
	377
	378	header.attr('aria-expanded', false).children('.fa').removeClass('fa-caret-down').addClass('fa-caret-right');
	379	header.removeClass('ui-state-active ui-corner-top').addClass('ui-corner-all');
	380	panel.attr('aria-hidden', true).slideUp();
	381
	382	this._removeFromSelection(index);
	383	},
	384
	385	_show: function(panel) {
	386	//deactivate current
	387	if(!this.options.multiple) {
	388	var oldHeader = this.headers.filter('.ui-state-active');
	389	oldHeader.children('.fa').removeClass('fa-caret-down').addClass('fa-caret-right');
	390	oldHeader.attr('aria-expanded', false).removeClass('ui-state-active ui-corner-top').addClass('ui-corner-all').next().attr('aria-hidden', true).slideUp();
	391	}
	392
	393	//activate selected
	394	var newHeader = panel.prev();
	395	newHeader.attr('aria-expanded', true).addClass('ui-state-active ui-corner-top').removeClass('ui-state-hover ui-corner-all')
	396	.children('.fa').removeClass('fa-caret-right').addClass('fa-caret-down');
	397
	398	panel.attr('aria-hidden', false).slideDown('normal');
	399	},
	400
	401	_addToSelection: function(nodeId) {
	402	this.options.activeIndex.push(nodeId);
	403	},
	404
	405	_removeFromSelection: function(index) {
	406	this.options.activeIndex = $.grep(this.options.activeIndex, function(r) {
	407	return r != index;
	408	});
	409	},
	410
	411	_setOption: function(key, value) {
	412	if(key === 'activeIndex') {
	413	this.select(value, true);
	414	}
	415	else {
	416	$.Widget.prototype._setOption.apply(this, arguments);
	417	}
	418	}
	419
	420	});
	421	})();
	422	/**
	423	* PrimeUI autocomplete widget
	424	*/
	425	(function() {
	426
	427	$.widget("primeui.puiautocomplete", {
	428
	429	options: {
	430	delay: 300,
	431	minQueryLength: 1,
	432	multiple: false,
	433	dropdown: false,
	434	scrollHeight: 200,
	435	forceSelection: false,
	436	effect:null,
	437	effectOptions: {},
	438	effectSpeed: 'normal',
	439	content: null,
	440	caseSensitive: false
	441	},
	442
	443	_create: function() {
	444	this.element.wrap('<span class="ui-autocomplete ui-widget" />');
	445	this.element.puiinputtext();
	446	this.panel = $('<div class="ui-autocomplete-panel ui-widget-content ui-corner-all ui-helper-hidden ui-shadow"></div>').appendTo('body');
	447
	448	if(this.options.multiple) {
	449	this.element.wrap('<ul class="ui-autocomplete-multiple ui-widget ui-inputtext ui-state-default ui-corner-all">' +
	450	'<li class="ui-autocomplete-input-token"></li></ul>');
	451	this.inputContainer = this.element.parent();
	452	this.multiContainer = this.inputContainer.parent();
	453	}
	454	else {
	455	if(this.options.dropdown) {
	456	this.dropdown = $('<button type="button" class="ui-autocomplete-dropdown ui-button ui-widget ui-state-default ui-corner-right ui-button-icon-only">' +
	457	'<span class="fa fa-fw fa-caret-down"></span><span class="ui-button-text"> </span></button>')
	458	.insertAfter(this.element);
	459	this.element.removeClass('ui-corner-all').addClass('ui-corner-left');
	460	}
	461	}
	462
	463	this._bindEvents();
	464	},
	465
	466	_bindEvents: function() {
	467	var $this = this;
	468
	469	this._bindKeyEvents();
	470
	471	if(this.options.dropdown) {
	472	this.dropdown.on('mouseenter.puiautocomplete', function() {
	473	if(!$this.element.prop('disabled')) {
	474	$this.dropdown.addClass('ui-state-hover');
	475	}
	476	})
	477	.on('mouseleave.puiautocomplete', function() {
	478	$this.dropdown.removeClass('ui-state-hover');
	479	})
	480	.on('mousedown.puiautocomplete', function() {
	481	if(!$this.element.prop('disabled')) {
	482	$this.dropdown.addClass('ui-state-active');
	483	}
	484	})
	485	.on('mouseup.puiautocomplete', function() {
	486	if(!$this.element.prop('disabled')) {
	487	$this.dropdown.removeClass('ui-state-active');
	488	$this.search('');
	489	$this.element.focus();
	490	}
	491	})
	492	.on('focus.puiautocomplete', function() {
	493	$this.dropdown.addClass('ui-state-focus');
	494	})
	495	.on('blur.puiautocomplete', function() {
	496	$this.dropdown.removeClass('ui-state-focus');
	497	})
	498	.on('keydown.puiautocomplete', function(e) {
	499	var keyCode = $.ui.keyCode;
	500
	501	if(e.which == keyCode.ENTER \|\| e.which == keyCode.NUMPAD_ENTER) {
	502	$this.search('');
	503	$this.input.focus();
	504
	505	e.preventDefault();
	506	}
	507	});
	508	}
	509
	510	if(this.options.multiple) {
	511	this.multiContainer.on('hover.puiautocomplete', function() {
	512	$(this).toggleClass('ui-state-hover');
	513	})
	514	.on('click.puiautocomplete', function() {
	515	$this.element.trigger('focus');
	516	});
	517
	518	this.element.on('focus.ui-autocomplete', function() {
	519	$this.multiContainer.addClass('ui-state-focus');
	520	})
	521	.on('blur.ui-autocomplete', function(e) {
	522	$this.multiContainer.removeClass('ui-state-focus');
	523	});
	524	}
	525
	526	if(this.options.forceSelection) {
	527	this.currentItems = [this.element.val()];
	528
	529	this.element.on('blur.puiautocomplete', function() {
	530	var value = $(this).val(),
	531	valid = false;
	532
	533	for(var i = 0; i < $this.currentItems.length; i++) {
	534	if($this.currentItems[i] === value) {
	535	valid = true;
	536	break;
	537	}
	538	}
	539
	540	if(!valid) {
	541	$this.element.val('');
	542	}
	543	});
	544	}
	545
	546	$(document.body).bind('mousedown.puiautocomplete', function (e) {
	547	if($this.panel.is(":hidden")) {
	548	return;
	549	}
	550
	551	if(e.target === $this.element.get(0)) {
	552	return;
	553	}
	554
	555	var offset = $this.panel.offset();
	556	if (e.pageX < offset.left \|\|
	557	e.pageX > offset.left + $this.panel.width() \|\|
	558	e.pageY < offset.top \|\|
	559	e.pageY > offset.top + $this.panel.height()) {
	560	$this.hide();
	561	}
	562	});
	563
	564	$(window).bind('resize.' + this.element.id, function() {
	565	if($this.panel.is(':visible')) {
	566	$this._alignPanel();
	567	}
	568	});
	569	},
	570
	571	_bindKeyEvents: function() {
	572	var $this = this;
	573
	574	this.element.on('keyup.puiautocomplete', function(e) {
	575	var keyCode = $.ui.keyCode,
	576	key = e.which,
	577	shouldSearch = true;
	578
	579	if(key == keyCode.UP \|\|
	580	key == keyCode.LEFT \|\|
	581	key == keyCode.DOWN \|\|
	582	key == keyCode.RIGHT \|\|
	583	key == keyCode.TAB \|\|
	584	key == keyCode.SHIFT \|\|
	585	key == keyCode.ENTER \|\|
	586	key == keyCode.NUMPAD_ENTER) {
	587	shouldSearch = false;
	588	}
	589
	590	if(shouldSearch) {
	591	var value = $this.element.val();
	592
	593	if(!value.length) {
	594	$this.hide();
	595	}
	596
	597	if(value.length >= $this.options.minQueryLength) {
	598	if($this.timeout) {
	599	window.clearTimeout($this.timeout);
	600	}
	601
	602	$this.timeout = window.setTimeout(function() {
	603	$this.search(value);
	604	},
	605	$this.options.delay);
	606	}
	607	}
	608
	609	}).on('keydown.puiautocomplete', function(e) {
	610	if($this.panel.is(':visible')) {
	611	var keyCode = $.ui.keyCode,
	612	highlightedItem = $this.items.filter('.ui-state-highlight');
	613
	614	switch(e.which) {
	615	case keyCode.UP:
	616	case keyCode.LEFT:
	617	var prev = highlightedItem.prev();
	618
	619	if(prev.length == 1) {
	620	highlightedItem.removeClass('ui-state-highlight');
	621	prev.addClass('ui-state-highlight');
	622
	623	if($this.options.scrollHeight) {
	624	PUI.scrollInView($this.panel, prev);
	625	}
	626	}
	627
	628	e.preventDefault();
	629	break;
	630
	631	case keyCode.DOWN:
	632	case keyCode.RIGHT:
	633	var next = highlightedItem.next();
	634
	635	if(next.length == 1) {
	636	highlightedItem.removeClass('ui-state-highlight');
	637	next.addClass('ui-state-highlight');
	638
	639	if($this.options.scrollHeight) {
	640	PUI.scrollInView($this.panel, next);
	641	}
	642	}
	643
	644	e.preventDefault();
	645	break;
	646
	647	case keyCode.ENTER:
	648	case keyCode.NUMPAD_ENTER:
	649	highlightedItem.trigger('click');
	650
	651	e.preventDefault();
	652	break;
	653
	654	case keyCode.ALT:
	655	case 224:
	656	break;
	657
	658	case keyCode.TAB:
	659	highlightedItem.trigger('click');
	660	$this.hide();
	661	break;
	662	}
	663	}
	664
	665	});
	666	},
	667
	668	_bindDynamicEvents: function() {
	669	var $this = this;
	670
	671	this.items.on('mouseover.puiautocomplete', function() {
	672	var item = $(this);
	673
	674	if(!item.hasClass('ui-state-highlight')) {
	675	$this.items.filter('.ui-state-highlight').removeClass('ui-state-highlight');
	676	item.addClass('ui-state-highlight');
	677	}
	678	})
	679	.on('click.puiautocomplete', function(event) {
	680	var item = $(this);
	681
	682	if($this.options.multiple) {
	683	var tokenMarkup = '<li class="ui-autocomplete-token ui-state-active ui-corner-all ui-helper-hidden">';
	684	tokenMarkup += '<span class="ui-autocomplete-token-icon fa fa-fw fa-close" />';
	685	tokenMarkup += '<span class="ui-autocomplete-token-label">' + item.data('label') + '</span></li>';
	686
	687	$(tokenMarkup).data(item.data())
	688	.insertBefore($this.inputContainer).fadeIn()
	689	.children('.ui-autocomplete-token-icon').on('click.ui-autocomplete', function(e) {
	690	var token = $(this).parent();
	691	$this._removeItem(token);
	692	$this._trigger('unselect', e, token);
	693	});
	694
	695	$this.element.val('').trigger('focus');
	696	}
	697	else {
	698	$this.element.val(item.data('label')).focus();
	699	}
	700
	701	$this._trigger('select', event, item);
	702	$this.hide();
	703	});
	704	},
	705
	706	search: function(q) {
	707	this.query = this.options.caseSensitive ? q : q.toLowerCase();
	708
	709	var request = {
	710	query: this.query
	711	};
	712
	713	if(this.options.completeSource) {
	714	if($.isArray(this.options.completeSource)) {
	715	var sourceArr = this.options.completeSource,
	716	data = [],
	717	emptyQuery = ($.trim(q) === '');
	718
	719	for(var i = 0 ; i < sourceArr.length; i++) {
	720	var item = sourceArr[i],
	721	itemLabel = item.label\|\|item;
	722
	723	if(!this.options.caseSensitive) {
	724	itemLabel = itemLabel.toLowerCase();
	725	}
	726
	727	if(emptyQuery\|\|itemLabel.indexOf(this.query) === 0) {
	728	data.push({label:sourceArr[i], value: item});
	729	}
	730	}
	731
	732	this._handleData(data);
	733	}
	734	else {
	735	this.options.completeSource.call(this, request, this._handleData);
	736	}
	737	}
	738	},
	739
	740	_handleData: function(data) {
	741	var $this = this;
	742	this.panel.html('');
	743	this.listContainer = $('<ul class="ui-autocomplete-items ui-autocomplete-list ui-widget-content ui-widget ui-corner-all ui-helper-reset"></ul>').appendTo(this.panel);
	744
	745	for(var i = 0; i < data.length; i++) {
	746	var item = $('<li class="ui-autocomplete-item ui-autocomplete-list-item ui-corner-all"></li>');
	747	item.data(data[i]);
	748
	749	if(this.options.content)
	750	item.html(this.options.content.call(this, data[i]));
	751	else
	752	item.text(data[i].label);
	753
	754	this.listContainer.append(item);
	755	}
	756
	757	this.items = this.listContainer.children('.ui-autocomplete-item');
	758
	759	this._bindDynamicEvents();
	760
	761	if(this.items.length > 0) {
	762	var firstItem = $this.items.eq(0),
	763	hidden = this.panel.is(':hidden');
	764	firstItem.addClass('ui-state-highlight');
	765
	766	if($this.query.length > 0 && !$this.options.content) {
	767	$this.items.each(function() {
	768	var item = $(this),
	769	text = item.html(),
	770	re = new RegExp(PUI.escapeRegExp($this.query), 'gi'),
	771	highlighedText = text.replace(re, '<span class="ui-autocomplete-query">$&</span>');
	772
	773	item.html(highlighedText);
	774	});
	775	}
	776
	777	if(this.options.forceSelection) {
	778	this.currentItems = [];
	779	$.each(data, function(i, item) {
	780	$this.currentItems.push(item.label);
	781	});
	782	}
	783
	784	//adjust height
	785	if($this.options.scrollHeight) {
	786	var heightConstraint = hidden ? $this.panel.height() : $this.panel.children().height();
	787
	788	if(heightConstraint > $this.options.scrollHeight)
	789	$this.panel.height($this.options.scrollHeight);
	790	else
	791	$this.panel.css('height', 'auto');
	792
	793	}
	794
	795	if(hidden) {
	796	$this.show();
	797	}
	798	else {
	799	$this._alignPanel();
	800	}
	801	}
	802	else {
	803	this.panel.hide();
	804	}
	805	},
	806
	807	show: function() {
	808	this._alignPanel();
	809
	810	if(this.options.effect)
	811	this.panel.show(this.options.effect, {}, this.options.effectSpeed);
	812	else
	813	this.panel.show();
	814	},
	815
	816	hide: function() {
	817	this.panel.hide();
	818	this.panel.css('height', 'auto');
	819	},
	820
	821	_removeItem: function(item) {
	822	item.fadeOut('fast', function() {
	823	var token = $(this);
	824
	825	token.remove();
	826	});
	827	},
	828
	829	_alignPanel: function() {
	830	var panelWidth = null;
	831
	832	if(this.options.multiple) {
	833	panelWidth = this.multiContainer.innerWidth() - (this.element.position().left - this.multiContainer.position().left);
	834	}
	835	else {
	836	if(this.panel.is(':visible')) {
	837	panelWidth = this.panel.children('.ui-autocomplete-items').outerWidth();
	838	}
	839	else {
	840	this.panel.css({'visibility':'hidden','display':'block'});
	841	panelWidth = this.panel.children('.ui-autocomplete-items').outerWidth();
	842	this.panel.css({'visibility':'visible','display':'none'});
	843	}
	844
	845	var inputWidth = this.element.outerWidth();
	846	if(panelWidth < inputWidth) {
	847	panelWidth = inputWidth;
	848	}
	849	}
	850
	851	this.panel.css({
	852	'left':'',
	853	'top':'',
	854	'width': panelWidth,
	855	'z-index': ++PUI.zindex
	856	})
	857	.position({
	858	my: 'left top',
	859	at: 'left bottom',
	860	of: this.element
	861	});
	862	}
	863	});
	864
	865	})();
	866	/**
	867	* PrimeFaces Button Widget
	868	*/
	869	(function() {
	870
	871	$.widget("primeui.puibutton", {
	872
	873	options: {
	874	value: null,
	875	icon: null,
	876	iconPos: 'left',
	877	click: null
	878	},
	879
	880	_create: function() {
	881	var element = this.element;
	882	this.elementText = this.element.text();
	883
	884	var value = this.options.value\|\|(this.elementText === '' ? 'ui-button' : this.elementText),
	885	disabled = element.prop('disabled'),
	886	styleClass = null;
	887
	888	if(this.options.icon) {
	889	styleClass = (value === 'ui-button') ? 'ui-button-icon-only' : 'ui-button-text-icon-' + this.options.iconPos;
	890	}
	891	else {
	892	styleClass = 'ui-button-text-only';
	893	}
	894
	895	if(disabled) {
	896	styleClass += ' ui-state-disabled';
	897	}
	898
	899	this.element.addClass('ui-button ui-widget ui-state-default ui-corner-all ' + styleClass).text('');
	900
	901	if(this.options.icon) {
	902	this.element.append('<span class="ui-button-icon-' + this.options.iconPos + ' ui-c fa fa-fw ' + this.options.icon + '" />');
	903	}
	904
	905	this.element.append('<span class="ui-button-text ui-c">' + value + '</span>');
	906
	907	if(!disabled) {
	908	this._bindEvents();
	909	}
	910	},
	911
	912	_destroy: function() {
	913	this.element.removeClass('ui-button ui-widget ui-state-default ui-state-hover ui-state-active ui-state-disabled ui-state-focus ui-corner-all ' +
	914	'ui-button-text-only ui-button-icon-only ui-button-text-icon-right ui-button-text-icon-left');
	915	this._unbindEvents();
	916	this.element.children('.fa').remove();
	917	this.element.children('.ui-button-text').remove();
	918	this.element.text(this.elementText);
	919	},
	920
	921	_bindEvents: function() {
	922	var element = this.element,
	923	$this = this;
	924
	925	element.on('mouseover.puibutton', function(){
	926	if(!element.prop('disabled')) {
	927	element.addClass('ui-state-hover');
	928	}
	929	}).on('mouseout.puibutton', function() {
	930	$(this).removeClass('ui-state-active ui-state-hover');
	931	}).on('mousedown.puibutton', function() {
	932	if(!element.hasClass('ui-state-disabled')) {
	933	element.addClass('ui-state-active').removeClass('ui-state-hover');
	934	}
	935	}).on('mouseup.puibutton', function(e) {
	936	element.removeClass('ui-state-active').addClass('ui-state-hover');
	937
	938	$this._trigger('click', e);
	939	}).on('focus.puibutton', function() {
	940	element.addClass('ui-state-focus');
	941	}).on('blur.puibutton', function() {
	942	element.removeClass('ui-state-focus');
	943	}).on('keydown.puibutton',function(e) {
	944	if(e.keyCode == $.ui.keyCode.SPACE \|\| e.keyCode == $.ui.keyCode.ENTER \|\| e.keyCode == $.ui.keyCode.NUMPAD_ENTER) {
	945	element.addClass('ui-state-active');
	946	}
	947	}).on('keyup.puibutton', function() {
	948	element.removeClass('ui-state-active');
	949	});
	950
	951	return this;
	952	},
	953
	954	_unbindEvents: function() {
	955	this.element.off('mouseover.puibutton mouseout.puibutton mousedown.puibutton mouseup.puibutton focus.puibutton blur.puibutton keydown.puibutton keyup.puibutton');
	956	},
	957
	958	disable: function() {
	959	this._unbindEvents();
	960	this.element.addClass('ui-state-disabled').prop('disabled',true);
	961	},
	962
	963	enable: function() {
	964	if(this.element.prop('disabled')) {
	965	this._bindEvents();
	966	this.element.prop('disabled', false).removeClass('ui-state-disabled');
	967	}
	968	},
	969
	970	_setOption: function(key, value) {
	971	if(key === 'disabled') {
	972	if(value)
	973	this.disable();
	974	else
	975	this.enable();
	976	}
	977	else {
	978	$.Widget.prototype._setOption.apply(this, arguments);
	979	}
	980	}
	981
	982	});
	983	})();
	984	/**
	985	* PrimeUI Carousel widget
	986	*/
	987	(function() {
	988
	989	$.widget("primeui.puicarousel", {
	990
	991	options: {
	992	datasource: null,
	993	numVisible: 3,
	994	firstVisible: 0,
	995	headerText: null,
	996	effectDuration: 500,
	997	circular :false,
	998	breakpoint: 560,
	999	itemContent: null,
	1000	responsive: true,
	1001	autoplayInterval: 0,
	1002	easing: 'easeInOutCirc',
	1003	pageLinks: 3,
	1004	style: null,
	1005	styleClass: null,
	1006	template: null,
	1007	enhanced: false
	1008	},
	1009
	1010	_create: function() {
	1011	this.id = this.element.attr('id');
	1012	if(!this.id) {
	1013	this.id = this.element.uniqueId().attr('id');
	1014	}
	1015
	1016	if(!this.options.enhanced) {
	1017	this.element.wrap('<div class="ui-carousel ui-widget ui-widget-content ui-corner-all"><div class="ui-carousel-viewport"></div></div>');
	1018	}
	1019
	1020	this.container = this.element.parent().parent();
	1021	this.element.addClass('ui-carousel-items');
	1022	this.viewport = this.element.parent();
	1023	this.container.prepend('<div class="ui-carousel-header ui-widget-header"><div class="ui-carousel-header-title"></div></div>');
	1024	this.header = this.container.children('.ui-carousel-header');
	1025	this.header.append('<span class="ui-carousel-button ui-carousel-next-button fa fa-arrow-circle-right"></span>' +
	1026	'<span class="ui-carousel-button ui-carousel-prev-button fa fa-arrow-circle-left"></span>');
	1027
	1028	if(this.options.headerText) {
	1029	this.header.children('.ui-carousel-header-title').html(this.options.headerText);
	1030	}
	1031
	1032	if(this.options.styleClass) {
	1033	this.container.addClass(this.options.styleClass);
	1034	}
	1035
	1036	if(this.options.style) {
	1037	this.container.attr('style', this.options.style);
	1038	}
	1039
	1040	if(this.options.datasource)
	1041	this._loadData();
	1042	else
	1043	this._render();
	1044	},
	1045
	1046	_destroy: function() {
	1047	this._unbindEvents();
	1048	this.header.remove();
	1049	this.items.removeClass('ui-carousel-item ui-widget-content ui-corner-all').css('width','auto');
	1050	this.element.removeClass('ui-carousel-items').css('left','auto');
	1051
	1052	if(!this.options.enhanced) {
	1053	this.element.unwrap().unwrap();
	1054	}
	1055
	1056	if(this.options.datasource) {
	1057	this.items.remove();
	1058	}
	1059	},
	1060
	1061	_loadData: function() {
	1062	if($.isArray(this.options.datasource))
	1063	this._render(this.options.datasource);
	1064	else if($.type(this.options.datasource) === 'function')
	1065	this.options.datasource.call(this, this._render);
	1066	},
	1067
	1068	_updateDatasource: function(value) {
	1069	this.options.datasource = value;
	1070	this.element.children().remove();
	1071	this.header.children('.ui-carousel-page-links').remove();
	1072	this.header.children('select').remove();
	1073	this._loadData();
	1074	},
	1075
	1076	_render: function(data) {
	1077	this.data = data;
	1078
	1079	if(this.data) {
	1080	for(var i = 0; i < data.length; i++) {
	1081	var itemContent = this._createItemContent(data[i]);
	1082	if($.type(itemContent) === 'string')
	1083	this.element.append('<li>' + itemContent + '</li>');
	1084	else
	1085	this.element.append($('<li></li>').wrapInner(itemContent));
	1086	}
	1087	}
	1088
	1089	this.items = this.element.children('li');
	1090	this.items.addClass('ui-carousel-item ui-widget-content ui-corner-all');
	1091	this.itemsCount = this.items.length;
	1092	this.columns = this.options.numVisible;
	1093	this.first = this.options.firstVisible;
	1094	this.page = parseInt(this.first/this.columns);
	1095	this.totalPages = Math.ceil(this.itemsCount/this.options.numVisible);
	1096
	1097	this._renderPageLinks();
	1098
	1099	this.prevNav = this.header.children('.ui-carousel-prev-button');
	1100	this.nextNav = this.header.children('.ui-carousel-next-button');
	1101	this.pageLinks = this.header.find('> .ui-carousel-page-links > .ui-carousel-page-link');
	1102	this.dropdown = this.header.children('.ui-carousel-dropdown');
	1103	this.mobileDropdown = this.header.children('.ui-carousel-mobiledropdown');
	1104
	1105	this._bindEvents();
	1106
	1107	if(this.options.responsive) {
	1108	this.refreshDimensions();
	1109	}
	1110	else {
	1111	this.calculateItemWidths();
	1112	this.container.width(this.container.width());
	1113	this.updateNavigators();
	1114	}
	1115	},
	1116
	1117	_renderPageLinks: function() {
	1118	if(this.totalPages <= this.options.pageLinks) {
	1119	this.pageLinksContainer = $('<div class="ui-carousel-page-links"></div>');
	1120	for(var i = 0; i < this.totalPages; i++) {
	1121	this.pageLinksContainer.append('<a href="#" class="ui-carousel-page-link fa fa-circle-o"></a>');
	1122	}
	1123	this.header.append(this.pageLinksContainer);
	1124	}
	1125	else {
	1126	this.dropdown = $('<select class="ui-carousel-dropdown ui-widget ui-state-default ui-corner-left"></select>');
	1127	for(var i = 0; i < this.totalPages; i++) {
	1128	var pageNumber = (i+1);
	1129	this.dropdown.append('<option value="' + pageNumber + '">' + pageNumber + '</option>');
	1130	}
	1131	this.header.append(this.dropdown);
	1132	}
	1133
	1134	if(this.options.responsive) {
	1135	this.mobileDropdown = $('<select class="ui-carousel-mobiledropdown ui-widget ui-state-default ui-corner-left"></select>');
	1136	for(var i = 0; i < this.itemsCount; i++) {
	1137	var pageNumber = (i+1);
	1138	this.mobileDropdown.append('<option value="' + pageNumber + '">' + pageNumber + '</option>');
	1139	}
	1140	this.header.append(this.mobileDropdown);
	1141	}
	1142	},
	1143
	1144	calculateItemWidths: function() {
	1145	var firstItem = this.items.eq(0);
	1146	if(firstItem.length) {
	1147	var itemFrameWidth = firstItem.outerWidth(true) - firstItem.width(); //sum of margin, border and padding
	1148	this.items.width((this.viewport.innerWidth() - itemFrameWidth * this.columns) / this.columns);
	1149	}
	1150	},
	1151
	1152	refreshDimensions: function() {
	1153	var win = $(window);
	1154	if(win.width() <= this.options.breakpoint) {
	1155	this.columns = 1;
	1156	this.calculateItemWidths(this.columns);
	1157	this.totalPages = this.itemsCount;
	1158	this.mobileDropdown.show();
	1159	this.pageLinks.hide();
	1160	}
	1161	else {
	1162	this.columns = this.options.numVisible;
	1163	this.calculateItemWidths();
	1164	this.totalPages = Math.ceil(this.itemsCount / this.options.numVisible);
	1165	this.mobileDropdown.hide();
	1166	this.pageLinks.show();
	1167	}
	1168
	1169	this.page = parseInt(this.first / this.columns);
	1170	this.updateNavigators();
	1171	this.element.css('left', (-1 * (this.viewport.innerWidth() * this.page)));
	1172	},
	1173
	1174	_bindEvents: function() {
	1175	var $this = this;
	1176
	1177	if(this.eventsBound) {
	1178	return;
	1179	}
	1180
	1181	this.prevNav.on('click.puicarousel', function() {
	1182	if($this.page !== 0) {
	1183	$this.setPage($this.page - 1);
	1184	}
	1185	else if($this.options.circular) {
	1186	$this.setPage($this.totalPages - 1);
	1187	}
	1188	});
	1189
	1190	this.nextNav.on('click.puicarousel', function() {
	1191	var lastPage = ($this.page === ($this.totalPages - 1));
	1192
	1193	if(!lastPage) {
	1194	$this.setPage($this.page + 1);
	1195	}
	1196	else if($this.options.circular) {
	1197	$this.setPage(0);
	1198	}
	1199	});
	1200
	1201	if($.swipe) {
	1202	this.element.swipe({
	1203	swipe:function(event, direction) {
	1204	if(direction === 'left') {
	1205	if($this.page === ($this.totalPages - 1)) {
	1206	if($this.options.circular)
	1207	$this.setPage(0);
	1208	}
	1209	else {
	1210	$this.setPage($this.page + 1);
	1211	}
	1212	}
	1213	else if(direction === 'right') {
	1214	if($this.page === 0) {
	1215	if($this.options.circular)
	1216	$this.setPage($this.totalPages - 1);
	1217	}
	1218	else {
	1219	$this.setPage($this.page - 1);
	1220	}
	1221	}
	1222	}
	1223	});
	1224	}
	1225
	1226	if(this.pageLinks.length) {
	1227	this.pageLinks.on('click.puicarousel', function(e) {
	1228	$this.setPage($(this).index());
	1229	e.preventDefault();
	1230	});
	1231	}
	1232
	1233	this.header.children('select').on('change.puicarousel', function() {
	1234	$this.setPage(parseInt($(this).val()) - 1);
	1235	});
	1236
	1237	if(this.options.autoplayInterval) {
	1238	this.options.circular = true;
	1239	this.startAutoplay();
	1240	}
	1241
	1242	if(this.options.responsive) {
	1243	var resizeNS = 'resize.' + this.id;
	1244	$(window).off(resizeNS).on(resizeNS, function() {
	1245	$this.refreshDimensions();
	1246	});
	1247	}
	1248
	1249	this.eventsBound = true;
	1250	},
	1251
	1252	_unbindEvents: function() {
	1253	this.prevNav.off('click.puicarousel');
	1254	this.nextNav.off('click.puicarousel');
	1255	if(this.pageLinks.length) {
	1256	this.pageLinks.off('click.puicarousel');
	1257	}
	1258	this.header.children('select').off('change.puicarousel');
	1259
	1260	if(this.options.autoplayInterval) {
	1261	this.stopAutoplay();
	1262	}
	1263
	1264	if(this.options.responsive) {
	1265	$(window).off('resize.' + this.id)
	1266	}
	1267	},
	1268
	1269	updateNavigators: function() {
	1270	if(!this.options.circular) {
	1271	if(this.page === 0) {
	1272	this.prevNav.addClass('ui-state-disabled');
	1273	this.nextNav.removeClass('ui-state-disabled');
	1274	}
	1275	else if(this.page === (this.totalPages - 1)) {
	1276	this.prevNav.removeClass('ui-state-disabled');
	1277	this.nextNav.addClass('ui-state-disabled');
	1278	}
	1279	else {
	1280	this.prevNav.removeClass('ui-state-disabled');
	1281	this.nextNav.removeClass('ui-state-disabled');
	1282	}
	1283	}
	1284
	1285	if(this.pageLinks.length) {
	1286	this.pageLinks.filter('.fa-dot-circle-o').removeClass('fa-dot-circle-o');
	1287	this.pageLinks.eq(this.page).addClass('fa-dot-circle-o');
	1288	}
	1289
	1290	if(this.dropdown.length) {
	1291	this.dropdown.val(this.page + 1);
	1292	}
	1293
	1294	if(this.mobileDropdown.length) {
	1295	this.mobileDropdown.val(this.page + 1);
	1296	}
	1297	},
	1298
	1299	setPage: function(p) {
	1300	if(p !== this.page && !this.element.is(':animated')) {
	1301	var $this = this;
	1302
	1303	this.element.animate({
	1304	left: -1 * (this.viewport.innerWidth() * p)
	1305	,easing: this.options.easing
	1306	},
	1307	{
	1308	duration: this.options.effectDuration,
	1309	easing: this.options.easing,
	1310	complete: function() {
	1311	$this.page = p;
	1312	$this.first = $this.page * $this.columns;
	1313	$this.updateNavigators();
	1314	$this._trigger('pageChange', null, {'page':p});
	1315	}
	1316	});
	1317	}
	1318	},
	1319
	1320	startAutoplay: function() {
	1321	var $this = this;
	1322
	1323	this.interval = setInterval(function() {
	1324	if($this.page === ($this.totalPages - 1))
	1325	$this.setPage(0);
	1326	else
	1327	$this.setPage($this.page + 1);
	1328	}, this.options.autoplayInterval);
	1329	},
	1330
	1331	stopAutoplay: function() {
	1332	clearInterval(this.interval);
	1333	},
	1334
	1335	_setOption: function(key, value) {
	1336	if(key === 'datasource')
	1337	this._updateDatasource(value);
	1338	else
	1339	$.Widget.prototype._setOption.apply(this, arguments);
	1340	},
	1341
	1342	_createItemContent: function(obj) {
	1343	if(this.options.template) {
	1344	var template = this.options.template.html();
	1345	Mustache.parse(template);
	1346	return Mustache.render(template, obj);
	1347	}
	1348	else {
	1349	return this.options.itemContent.call(this, obj);
	1350	}
	1351	}
	1352
	1353	});
	1354
	1355	})();
	1356	/**
	1357	* PrimeUI checkbox widget
	1358	*/
	1359	(function() {
	1360
	1361	$.widget("primeui.puicheckbox", {
	1362
	1363	_create: function() {
	1364	this.element.wrap('<div class="ui-chkbox ui-widget"><div class="ui-helper-hidden-accessible"></div></div>');
	1365	this.container = this.element.parent().parent();
	1366	this.box = $('<div class="ui-chkbox-box ui-widget ui-corner-all ui-state-default">').appendTo(this.container);
	1367	this.icon = $('<span class="ui-chkbox-icon ui-c"></span>').appendTo(this.box);
	1368	this.disabled = this.element.prop('disabled');
	1369	this.label = $('label[for="' + this.element.attr('id') + '"]');
	1370
	1371	if(this.isChecked()) {
	1372	this.box.addClass('ui-state-active');
	1373	this.icon.addClass('fa fa-fw fa-check');
	1374	}
	1375
	1376	if(this.disabled) {
	1377	this.box.addClass('ui-state-disabled');
	1378	} else {
	1379	this._bindEvents();
	1380	}
	1381	},
	1382
	1383	_bindEvents: function() {
	1384	var $this = this;
	1385
	1386	this.box.on('mouseover.puicheckbox', function() {
	1387	if(!$this.isChecked())
	1388	$this.box.addClass('ui-state-hover');
	1389	})
	1390	.on('mouseout.puicheckbox', function() {
	1391	$this.box.removeClass('ui-state-hover');
	1392	})
	1393	.on('click.puicheckbox', function() {
	1394	$this.toggle();
	1395	});
	1396
	1397	this.element.on('focus.puicheckbox', function() {
	1398	if($this.isChecked()) {
	1399	$this.box.removeClass('ui-state-active');
	1400	}
	1401
	1402	$this.box.addClass('ui-state-focus');
	1403	})
	1404	.on('blur.puicheckbox', function() {
	1405	if($this.isChecked()) {
	1406	$this.box.addClass('ui-state-active');
	1407	}
	1408
	1409	$this.box.removeClass('ui-state-focus');
	1410	})
	1411	.on('keydown.puicheckbox', function(e) {
	1412	var keyCode = $.ui.keyCode;
	1413	if(e.which == keyCode.SPACE) {
	1414	e.preventDefault();
	1415	}
	1416	})
	1417	.on('keyup.puicheckbox', function(e) {
	1418	var keyCode = $.ui.keyCode;
	1419	if(e.which == keyCode.SPACE) {
	1420	$this.toggle(true);
	1421
	1422	e.preventDefault();
	1423	}
	1424	});
	1425
	1426	this.label.on('click.puicheckbox', function(e) {
	1427	$this.toggle();
	1428	e.preventDefault();
	1429	});
	1430	},
	1431
	1432	toggle: function(keypress) {
	1433	if(this.isChecked()) {
	1434	this.uncheck(keypress);
	1435	} else {
	1436	this.check(keypress);
	1437	}
	1438
	1439	this._trigger('change', null, this.isChecked());
	1440	},
	1441
	1442	isChecked: function() {
	1443	return this.element.prop('checked');
	1444	},
	1445
	1446	check: function(activate, silent) {
	1447	if(!this.isChecked()) {
	1448	this.element.prop('checked', true);
	1449	this.icon.addClass('fa fa-fw fa-check');
	1450
	1451	if(!activate) {
	1452	this.box.addClass('ui-state-active');
	1453	}
	1454
	1455	if(!silent) {
	1456	this.element.trigger('change');
	1457	}
	1458	}
	1459	},
	1460
	1461	uncheck: function() {
	1462	if(this.isChecked()) {
	1463	this.element.prop('checked', false);
	1464	this.box.removeClass('ui-state-active');
	1465	this.icon.removeClass('fa fa-fw fa-check');
	1466
	1467	this.element.trigger('change');
	1468	}
	1469	},
	1470
	1471	_unbindEvents: function() {
	1472	this.box.off('mouseover.puicheckbox mouseout.puicheckbox click.puicheckbox');
	1473	this.element.off('focus.puicheckbox blur.puicheckbox keydown.puicheckbox keyup.puicheckbox');
	1474
	1475	if (this.label.length) {
	1476	this.label.off('click.puicheckbox');
	1477	}
	1478	},
	1479
	1480	disable: function() {
	1481	this.box.prop('disabled', true);
	1482	this.box.attr('aria-disabled', true);
	1483	this.box.addClass('ui-state-disabled').removeClass('ui-state-hover');
	1484	this._unbindEvents();
	1485	},
	1486
	1487	enable: function() {
	1488	this.box.prop('disabled', false);
	1489	this.box.attr('aria-disabled', false);
	1490	this.box.removeClass('ui-state-disabled');
	1491	this._bindEvents();
	1492	},
	1493
	1494	_destroy: function() {
	1495	this._unbindEvents();
	1496	this.container.removeClass('ui-chkbox ui-widget');
	1497	this.box.remove();
	1498	this.element.unwrap().unwrap();
	1499	}
	1500
	1501	});
	1502
	1503	})();
	1504	/**
	1505	* PrimeUI Datagrid Widget
	1506	*/
	1507	(function() {
	1508
	1509	$.widget("primeui.puidatagrid", {
	1510
	1511	options: {
	1512	columns: 3,
	1513	datasource: null,
	1514	paginator: null,
	1515	header: null,
	1516	footer: null,
	1517	content: null,
	1518	lazy: false,
	1519	template: null
	1520	},
	1521
	1522	_create: function() {
	1523	this.id = this.element.attr('id');
	1524	if(!this.id) {
	1525	this.id = this.element.uniqueId().attr('id');
	1526	}
	1527
	1528	this.element.addClass('ui-datagrid ui-widget');
	1529
	1530	//header
	1531	if(this.options.header) {
	1532	this.element.append('<div class="ui-datagrid-header ui-widget-header ui-corner-top">' + this.options.header + '</div>');
	1533	}
	1534
	1535	//content
	1536	this.content = $('<div class="ui-datagrid-content ui-widget-content ui-datagrid-col-' + this.options.columns + '"></div>').appendTo(this.element);
	1537
	1538	//footer
	1539	if(this.options.footer) {
	1540	this.element.append('<div class="ui-datagrid-footer ui-widget-header ui-corner-top">' + this.options.footer + '</div>');
	1541	}
	1542
	1543	//data
	1544	if(this.options.datasource) {
	1545	this._initDatasource();
	1546	}
	1547	},
	1548
	1549	_onDataInit: function(data) {
	1550	this._onDataUpdate(data);
	1551	this._initPaginator();
	1552	},
	1553
	1554	_onDataUpdate: function(data) {
	1555	this.data = data;
	1556	if(!this.data) {
	1557	this.data = [];
	1558	}
	1559
	1560	this.reset();
	1561
	1562	this._renderData();
	1563	},
	1564
	1565	_onLazyLoad: function(data) {
	1566	this.data = data;
	1567	if(!this.data) {
	1568	this.data = [];
	1569	}
	1570
	1571	this._renderData();
	1572	},
	1573
	1574	reset: function() {
	1575	if(this.paginator) {
	1576	this.paginator.puipaginator('setState', {
	1577	page: 0,
	1578	totalRecords: this.options.lazy ? this.options.paginator.totalRecords : this.data.length
	1579	});
	1580	}
	1581	},
	1582
	1583	paginate: function() {
	1584	if(this.options.lazy) {
	1585	this.options.datasource.call(this, this._onLazyLoad, this._createStateMeta());
	1586	}
	1587	else {
	1588	this._renderData();
	1589	}
	1590	},
	1591
	1592	_renderData: function() {
	1593	if(this.data) {
	1594	this.content.html('');
	1595
	1596	var firstNonLazy = this._getFirst(),
	1597	first = this.options.lazy ? 0 : firstNonLazy,
	1598	rows = this._getRows(),
	1599	gridRow = null;
	1600
	1601	for(var i = first; i < (first + rows); i++) {
	1602	var dataValue = this.data[i];
	1603
	1604	if(dataValue) {
	1605	var gridColumn = $('<div></div>').appendTo(this.content),
	1606	markup = this._createItemContent(dataValue);
	1607	gridColumn.append(markup);
	1608	}
	1609	}
	1610	}
	1611	},
	1612
	1613	_getFirst: function() {
	1614	if(this.paginator) {
	1615	var page = this.paginator.puipaginator('option', 'page'),
	1616	rows = this.paginator.puipaginator('option', 'rows');
	1617
	1618	return (page * rows);
	1619	}
	1620	else {
	1621	return 0;
	1622	}
	1623	},
	1624
	1625	_getRows: function() {
	1626	if(this.options.paginator)
	1627	return this.paginator ? this.paginator.puipaginator('option', 'rows') : this.options.paginator.rows;
	1628	else
	1629	return this.data ? this.data.length : 0;
	1630	},
	1631
	1632	_createStateMeta: function() {
	1633	var state = {
	1634	first: this._getFirst(),
	1635	rows: this._getRows()
	1636	};
	1637
	1638	return state;
	1639	},
	1640
	1641	_initPaginator: function() {
	1642	var $this = this;
	1643	if(this.options.paginator) {
	1644	this.options.paginator.paginate = function(event, state) {
	1645	$this.paginate();
	1646	};
	1647
	1648	this.options.paginator.totalRecords = this.options.lazy ? this.options.paginator.totalRecords : this.data.length;
	1649	this.paginator = $('<div></div>').insertAfter(this.content).puipaginator(this.options.paginator);
	1650	}
	1651	},
	1652
	1653	_initDatasource: function() {
	1654	if($.isArray(this.options.datasource)) {
	1655	this._onDataInit(this.options.datasource);
	1656	}
	1657	else {
	1658	if($.type(this.options.datasource) === 'string') {
	1659	var $this = this,
	1660	dataURL = this.options.datasource;
	1661
	1662	this.options.datasource = function() {
	1663	$.ajax({
	1664	type: 'GET',
	1665	url: dataURL,
	1666	dataType: "json",
	1667	context: $this,
	1668	success: function (response) {
	1669	this._onDataInit(response);
	1670	}
	1671	});
	1672	};
	1673	}
	1674
	1675	if($.type(this.options.datasource) === 'function') {
	1676	if(this.options.lazy)
	1677	this.options.datasource.call(this, this._onDataInit, {first:0, rows: this._getRows()});
	1678	else
	1679	this.options.datasource.call(this, this._onDataInit);
	1680	}
	1681	}
	1682	},
	1683
	1684	_updateDatasource: function(datasource) {
	1685	this.options.datasource = datasource;
	1686
	1687	if($.isArray(this.options.datasource)) {
	1688	this._onDataUpdate(this.options.datasource);
	1689	}
	1690	else if($.type(this.options.datasource) === 'function') {
	1691	if(this.options.lazy)
	1692	this.options.datasource.call(this, this._onDataUpdate, {first:0, rows: this._getRows()});
	1693	else
	1694	this.options.datasource.call(this, this._onDataUpdate);
	1695	}
	1696	},
	1697
	1698	_setOption: function(key, value) {
	1699	if(key === 'datasource') {
	1700	this._updateDatasource(value);
	1701	}
	1702	else {
	1703	$.Widget.prototype._setOption.apply(this, arguments);
	1704	}
	1705	},
	1706
	1707	_createItemContent: function(obj) {
	1708	if(this.options.template) {
	1709	var templateContent = this.options.template.html();
	1710	Mustache.parse(templateContent);
	1711	return Mustache.render(templateContent, obj);
	1712	}
	1713	else {
	1714	return this.options.content.call(this, obj);
	1715	}
	1716	}
	1717
	1718	});
	1719	})();
	1720	/**
	1721	* PrimeUI Datascroller Widget
	1722	*/
	1723	(function() {
	1724
	1725	$.widget("primeui.puidatascroller", {
	1726
	1727	options: {
	1728	header: null,
	1729	buffer: 0.9,
	1730	chunkSize: 10,
	1731	datasource: null,
	1732	lazy: false,
	1733	content: null,
	1734	template: null,
	1735	mode: 'document',
	1736	loader: null,
	1737	scrollHeight: null,
	1738	totalSize: null
	1739	},
	1740
	1741	_create: function() {
	1742	this.id = this.element.attr('id');
	1743	if(!this.id) {
	1744	this.id = this.element.uniqueId().attr('id');
	1745	}
	1746
	1747	this.element.addClass('ui-datascroller ui-widget');
	1748	if(this.options.header) {
	1749	this.header = this.element.append('<div class="ui-datascroller-header ui-widget-header ui-corner-top">' + this.options.header + '</div>').children('.ui-datascroller-header');
	1750	}
	1751
	1752	this.content = this.element.append('<div class="ui-datascroller-content ui-widget-content ui-corner-bottom"></div>').children('.ui-datascroller-content');
	1753	this.list = this.content.append('<ul class="ui-datascroller-list"></ul>').children('.ui-datascroller-list');
	1754	this.loaderContainer = this.content.append('<div class="ui-datascroller-loader"></div>').children('.ui-datascroller-loader');
	1755	this.loadStatus = $('<div class="ui-datascroller-loading"></div>');
	1756	this.loading = false;
	1757	this.allLoaded = false;
	1758	this.offset = 0;
	1759
	1760	if(this.options.mode === 'self') {
	1761	this.element.addClass('ui-datascroller-inline');
	1762
	1763	if(this.options.scrollHeight) {
	1764	this.content.css('height', this.options.scrollHeight);
	1765	}
	1766	}
	1767
	1768	if(this.options.loader) {
	1769	this.bindManualLoader();
	1770	}
	1771	else {
	1772	this.bindScrollListener();
	1773	}
	1774
	1775	if(this.options.datasource) {
	1776	if($.isArray(this.options.datasource)) {
	1777	this._onDataInit(this.options.datasource);
	1778	}
	1779	else {
	1780	if($.type(this.options.datasource) === 'string') {
	1781	var $this = this,
	1782	dataURL = this.options.datasource;
	1783
	1784	this.options.datasource = function() {
	1785	$.ajax({
	1786	type: 'GET',
	1787	url: dataURL,
	1788	dataType: "json",
	1789	context: $this,
	1790	success: function (response) {
	1791	this._onDataInit(response);
	1792	}
	1793	});
	1794	};
	1795	}
	1796
	1797	if($.type(this.options.datasource) === 'function') {
	1798	if(this.options.lazy)
	1799	this.options.datasource.call(this, this._onLazyLoad, {first:this.offset});
	1800	else
	1801	this.options.datasource.call(this, this._onDataInit);
	1802	}
	1803	}
	1804	}
	1805	},
	1806
	1807	_onDataInit: function(data) {
	1808	this.data = data\|\|[];
	1809	this.options.totalSize = this.data.length;
	1810
	1811	this._load();
	1812	},
	1813
	1814	_onLazyLoad: function(data) {
	1815	this._renderData(data, 0, this.options.chunkSize);
	1816
	1817	this._onloadComplete();
	1818	},
	1819
	1820	bindScrollListener: function() {
	1821	var $this = this;
	1822
	1823	if(this.options.mode === 'document') {
	1824	var win = $(window),
	1825	doc = $(document),
	1826	$this = this,
	1827	NS = 'scroll.' + this.id;
	1828
	1829	win.off(NS).on(NS, function () {
	1830	if(win.scrollTop() >= ((doc.height() * $this.options.buffer) - win.height()) && $this.shouldLoad()) {
	1831	$this._load();
	1832	}
	1833	});
	1834	}
	1835	else {
	1836	this.content.on('scroll', function () {
	1837	var scrollTop = this.scrollTop,
	1838	scrollHeight = this.scrollHeight,
	1839	viewportHeight = this.clientHeight;
	1840
	1841	if((scrollTop >= ((scrollHeight * $this.options.buffer) - (viewportHeight))) && $this.shouldLoad()) {
	1842	$this._load();
	1843	}
	1844	});
	1845	}
	1846	},
	1847
	1848	bindManualLoader: function() {
	1849	var $this = this;
	1850
	1851	this.options.loader.on('click.dataScroller', function(e) {
	1852	$this._load();
	1853	e.preventDefault();
	1854	});
	1855	},
	1856
	1857	_load: function() {
	1858	this.loading = true;
	1859	this.loadStatus.appendTo(this.loaderContainer);
	1860	if(this.options.loader) {
	1861	this.options.loader.hide();
	1862	}
	1863
	1864	if(this.options.lazy) {
	1865	this.options.datasource.call(this, this._onLazyLoad, {first: this.offset});
	1866	}
	1867	else {
	1868	this._renderData(this.data, this.offset, (this.offset + this.options.chunkSize));
	1869	this._onloadComplete();
	1870	}
	1871	},
	1872
	1873	_renderData: function(data, start, end) {
	1874	if(data && data.length) {
	1875	for(var i = start; i < end; i++) {
	1876	var listItem = $('<li class="ui-datascroller-item"></li>'),
	1877	content = this._createItemContent(data[i]);
	1878	listItem.append(content);
	1879
	1880	this.list.append(listItem);
	1881	}
	1882	}
	1883	},
	1884
	1885	shouldLoad: function() {
	1886	return (!this.loading && !this.allLoaded);
	1887	},
	1888
	1889	_createItemContent: function(obj) {
	1890	if(this.options.template) {
	1891	var template = this.options.template.html();
	1892	Mustache.parse(template);
	1893	return Mustache.render(template, obj);
	1894	}
	1895	else {
	1896	return this.options.content.call(this, obj);
	1897	}
	1898	},
	1899
	1900	_onloadComplete: function() {
	1901	this.offset += this.options.chunkSize;
	1902	this.loading = false;
	1903	this.allLoaded = this.offset >= this.options.totalSize;
	1904
	1905	this.loadStatus.remove();
	1906
	1907	if(this.options.loader && !this.allLoaded) {
	1908	this.options.loader.show();
	1909	}
	1910	}
	1911
	1912	});
	1913
	1914	})();
	1915	/**
	1916	* PrimeUI Datatable Widget
	1917	*/
	1918	(function() {
	1919
	1920	$.widget("primeui.puidatatable", {
	1921
	1922	options: {
	1923	columns: null,
	1924	datasource: null,
	1925	paginator: null,
	1926	globalFilter:null,
	1927	selectionMode: null,
	1928	caption: null,
	1929	footer: null,
	1930	sortField: null,
	1931	sortOrder: 1,
	1932	sortMeta: [],
	1933	sortMode: null,
	1934	scrollable: false,
	1935	scrollHeight: null,
	1936	scrollWidth: null,
	1937	responsive: false,
	1938	expandableRows: false,
	1939	expandedRowContent: null,
	1940	rowExpandMode: 'multiple',
	1941	draggableColumns: false,
	1942	resizableColumns: false,
	1943	columnResizeMode: 'fit',
	1944	draggableRows: false,
	1945	filterDelay: 300,
	1946	stickyHeader: false,
	1947	editMode: null,
	1948	tabindex: 0,
	1949	emptyMessage: 'No records found',
	1950	sort: null,
	1951	rowSelect: null,
	1952	rowUnselect: null,
	1953	rowSelectContextMenu: null,
	1954	rowCollapse: null,
	1955	rowExpand: null,
	1956	colReorder: null,
	1957	colResize: null,
	1958	rowReorder: null,
	1959	cellEdit: null
	1960	},
	1961
	1962	_create: function() {
	1963	this.id = this.element.attr('id');
	1964	if(!this.id) {
	1965	this.id = this.element.uniqueId().attr('id');
	1966	}
	1967
	1968	this.element.addClass('ui-datatable ui-widget');
	1969	if(this.options.responsive) {
	1970	this.element.addClass('ui-datatable-reflow');
	1971	}
	1972
	1973	if(this.options.scrollable) {
	1974	this._createScrollableDatatable();
	1975	}
	1976	else {
	1977	this._createRegularDatatable();
	1978	}
	1979
	1980	if(this.options.datasource) {
	1981	if($.isArray(this.options.datasource)) {
	1982	this._onDataInit(this.options.datasource);
	1983	}
	1984	else {
	1985	if($.type(this.options.datasource) === 'string') {
	1986	var $this = this,
	1987	dataURL = this.options.datasource;
	1988
	1989	this.options.datasource = function() {
	1990	$.ajax({
	1991	type: 'GET',
	1992	url: dataURL,
	1993	dataType: "json",
	1994	context: $this,
	1995	success: function (response) {
	1996	this._onDataInit(response);
	1997	}
	1998	});
	1999	};
	2000	}
	2001
	2002	if($.type(this.options.datasource) === 'function') {
	2003	if(this.options.lazy)
	2004	this.options.datasource.call(this, this._onDataInit, {first:0, rows:this._getRows(), sortField:this.options.sortField, sortOrder:this.options.sortOrder, filters: this._createFilterMap()});
	2005	else
	2006	this.options.datasource.call(this, this._onDataInit);
	2007	}
	2008	}
	2009	}
	2010	},
	2011
	2012	_createRegularDatatable: function() {
	2013	this.tableWrapper = $('<div class="ui-datatable-tablewrapper" />').appendTo(this.element);
	2014	this.table = $('<table><thead></thead><tbody></tbody></table>').appendTo(this.tableWrapper);
	2015	this.thead = this.table.children('thead');
	2016	this.tbody = this.table.children('tbody').addClass('ui-datatable-data ui-widget-content');
	2017
	2018	if(this.containsFooter()) {
	2019	this.tfoot = this.thead.after('<tfoot></tfoot>').next();
	2020	}
	2021	},
	2022
	2023	_createScrollableDatatable: function() {
	2024	this.element.append('<div class="ui-widget-header ui-datatable-scrollable-header"><div class="ui-datatable-scrollable-header-box"><table><thead></thead></table></div></div>')
	2025	.append('<div class="ui-datatable-scrollable-body"><table><tbody></tbody></table></div>');
	2026
	2027	this.thead = this.element.find('> .ui-datatable-scrollable-header > .ui-datatable-scrollable-header-box > table > thead');
	2028	this.tbody = this.element.find('> .ui-datatable-scrollable-body > table > tbody');
	2029
	2030	if(this.containsFooter()) {
	2031	this.element.append('<div class="ui-widget-header ui-datatable-scrollable-footer"><div class="ui-datatable-scrollable-footer-box"><table><tfoot></tfoot></table></div></div>');
	2032	this.tfoot = this.element.find('> .ui-datatable-scrollable-footer > .ui-datatable-scrollable-footer-box > table > tfoot');
	2033	}
	2034	},
	2035
	2036	_initialize: function() {
	2037	var $this = this;
	2038
	2039	this._initHeader();
	2040	this._initFooter();
	2041
	2042	if(this.options.caption) {
	2043	this.element.prepend('<div class="ui-datatable-header ui-widget-header">' + this.options.caption + '</div>');
	2044	}
	2045
	2046	if(this.options.paginator) {
	2047	this.options.paginator.paginate = function(event, state) {
	2048	$this.paginate();
	2049	};
	2050
	2051	this.options.paginator.totalRecords = this.options.lazy ? this.options.paginator.totalRecords : this.data.length;
	2052	this.paginator = $('<div></div>').insertAfter(this.tableWrapper).puipaginator(this.options.paginator);
	2053	if(this.options.paginator.contentLeft) {
	2054	this.paginator.prepend(this.options.paginator.contentLeft.call());
	2055	}
	2056	if(this.options.paginator.contentRight) {
	2057	this.paginator.append(this.options.paginator.contentRight.call());
	2058	}
	2059	}
	2060
	2061	if(this.options.footer) {
	2062	this.element.append('<div class="ui-datatable-footer ui-widget-header">' + this.options.footer + '</div>');
	2063	}
	2064
	2065	if(this._isSortingEnabled()) {
	2066	this._initSorting();
	2067	}
	2068
	2069	if(this.hasFiltering) {
	2070	this._initFiltering();
	2071	}
	2072
	2073	if(this.options.selectionMode) {
	2074	this._initSelection();
	2075	}
	2076
	2077	if(this.options.expandableRows) {
	2078	this._initExpandableRows();
	2079	}
	2080
	2081	if(this.options.draggableColumns) {
	2082	this._initDraggableColumns();
	2083	}
	2084
	2085	if(this.options.stickyHeader) {
	2086	this._initStickyHeader();
	2087	}
	2088
	2089	if ((this.options.sortField && this.options.sortOrder) \|\| this.options.sortMeta.length) {
	2090	this.sortByDefault();
	2091	}
	2092	else {
	2093	this._renderData();
	2094	}
	2095
	2096	if(this.options.scrollable) {
	2097	this._initScrolling();
	2098	}
	2099
	2100	if(this.options.resizableColumns) {
	2101	this._initResizableColumns();
	2102	}
	2103
	2104	if(this.options.draggableRows) {
	2105	this._initDraggableRows();
	2106	}
	2107
	2108	if(this.options.editMode) {
	2109	this._initEditing();
	2110	}
	2111
	2112	},
	2113
	2114	_initHeader: function() {
	2115	if(this.options.headerRows) {
	2116	for(var i = 0; i < this.options.headerRows.length; i++) {
	2117	this._initHeaderColumns(this.options.headerRows[i].columns);
	2118	}
	2119	}
	2120	else if(this.options.columns) {
	2121	this._initHeaderColumns(this.options.columns);
	2122	}
	2123	},
	2124
	2125	_initFooter: function() {
	2126	if(this.containsFooter()) {
	2127	if(this.options.footerRows) {
	2128	for(var i = 0; i < this.options.footerRows.length; i++) {
	2129	this._initFooterColumns(this.options.footerRows[i].columns);
	2130	}
	2131	}
	2132	else if(this.options.columns) {
	2133	this._initFooterColumns(this.options.columns);
	2134	}
	2135	}
	2136	},
	2137
	2138	_initHeaderColumns: function(columns) {
	2139	var headerRow = $('<tr class="ui-state-default"></tr>').appendTo(this.thead),
	2140	$this = this;
	2141
	2142	$.each(columns, function(i, col) {
	2143	var cell = $('<th class="ui-state-default"><span class="ui-column-title"></span></th>').data('field', col.field).uniqueId().appendTo(headerRow);
	2144
	2145	if(col.headerClass) {
	2146	cell.addClass(col.headerClass);
	2147	}
	2148
	2149	if(col.headerStyle) {
	2150	cell.attr('style', col.headerStyle);
	2151	}
	2152
	2153	if(col.headerText)
	2154	cell.children('.ui-column-title').text(col.headerText);
	2155	else if(col.headerContent)
	2156	cell.children('.ui-column-title').append(col.headerContent.call(this, col));
	2157
	2158	if(col.rowspan) {
	2159	cell.attr('rowspan', col.rowspan);
	2160	}
	2161
	2162	if(col.colspan) {
	2163	cell.attr('colspan', col.colspan);
	2164	}
	2165
	2166	if(col.sortable) {
	2167	cell.addClass('ui-sortable-column')
	2168	.data('order', 0)
	2169	.append('<span class="ui-sortable-column-icon fa fa-fw fa-sort"></span>');
	2170	}
	2171
	2172	if(col.filter) {
	2173	$this.hasFiltering = true;
	2174
	2175	var filterElement = $('<input type="text" class="ui-column-filter" />').puiinputtext().data({
	2176	'field': col.field,
	2177	'filtermatchmode': col.filterMatchMode\|\|'startsWith'
	2178	}).appendTo(cell);
	2179
	2180	if(col.filterFunction) {
	2181	filterElement.on('filter', function(event, dataValue, filterValue) {
	2182	return col.filterFunction.call($this, dataValue, filterValue);
	2183	});
	2184	}
	2185	}
	2186	});
	2187	},
	2188
	2189	_initFooterColumns: function(columns) {
	2190	var footerRow = $('<tr></tr>').appendTo(this.tfoot);
	2191	$.each(columns, function(i, col) {
	2192	var cell = $('<td class="ui-state-default"></td>');
	2193	if(col.footerText) {
	2194	cell.text(col.footerText);
	2195	}
	2196
	2197	if(col.rowspan) {
	2198	cell.attr('rowspan', col.rowspan);
	2199	}
	2200
	2201	if(col.colspan) {
	2202	cell.attr('colspan', col.colspan);
	2203	}
	2204
	2205	cell.appendTo(footerRow);
	2206	});
	2207	},
	2208
	2209	_indicateInitialSortColumn: function(sortField, sortOrder) {
	2210	var $this = this;
	2211
	2212	$.each(this.sortableColumns, function(i, column) {
	2213	var $column = $(column),
	2214	data = $column.data();
	2215
	2216	if (sortField === data.field) {
	2217	var sortIcon = $column.children('.ui-sortable-column-icon');
	2218	$column.data('order', sortOrder).removeClass('ui-state-hover').addClass('ui-state-active');
	2219
	2220	if(sortOrder == -1)
	2221	sortIcon.removeClass('fa-sort fa-sort-asc').addClass('fa-sort-desc');
	2222	else if(sortOrder == 1)
	2223	sortIcon.removeClass('fa-sort fa-sort-desc').addClass('fa-sort-asc');
	2224	}
	2225	});
	2226	},
	2227
	2228	_indicateInitialSortColumns: function() {
	2229	var $this = this;
	2230
	2231	for(var i = 0; i < this.options.sortMeta.length; i++) {
	2232	var meta = this.options.sortMeta[i];
	2233	this._indicateInitialSortColumn(meta.field, meta.order);
	2234	}
	2235	},
	2236
	2237	_onDataInit: function(data) {
	2238	this.data = data;
	2239	if(!this.data) {
	2240	this.data = [];
	2241	}
	2242
	2243	this._initialize();
	2244	},
	2245
	2246	_onDataUpdate: function(data) {
	2247	this.data = data;
	2248	if(!this.data) {
	2249	this.data = [];
	2250	}
	2251
	2252	this.reset();
	2253
	2254	this._renderData();
	2255	},
	2256
	2257	_onLazyLoad: function(data) {
	2258	this.data = data;
	2259	if(!this.data) {
	2260	this.data = [];
	2261	}
	2262
	2263	this._renderData();
	2264	},
	2265
	2266	reset: function() {
	2267	if(this.options.selectionMode) {
	2268	this.selection = [];
	2269	}
	2270
	2271	if(this.paginator) {
	2272	this.paginator.puipaginator('setState', {
	2273	page: 0,
	2274	totalRecords: this.options.lazy ? this.options.paginator.totalRecords : this.data.length
	2275	});
	2276	}
	2277
	2278	this.thead.find('> tr > th.ui-sortable-column').data('order', 0).filter('.ui-state-active').removeClass('ui-state-active')
	2279	.children('span.ui-sortable-column-icon').removeClass('fa-sort-asc fa-sort-desc').addClass('fa-sort');
	2280	},
	2281
	2282	_isMultiSort: function() {
	2283	if(this.options.sortMode === 'multiple')
	2284	return true;
	2285	else
	2286	return false;
	2287	},
	2288
	2289	_resetSortState: function(column) {
	2290	this.sortableColumns.filter('.ui-state-active').data('order', 0).removeClass('ui-state-active').children('span.ui-sortable-column-icon')
	2291	.removeClass('fa-sort-asc fa-sort-desc').addClass('fa-sort');
	2292	},
	2293
	2294	_initSorting: function() {
	2295	var $this = this;
	2296	this.sortableColumns = this.thead.find('> tr > th.ui-sortable-column');
	2297
	2298	this.sortableColumns.on('mouseover.puidatatable', function() {
	2299	var column = $(this);
	2300
	2301	if(!column.hasClass('ui-state-active'))
	2302	column.addClass('ui-state-hover');
	2303	})
	2304	.on('mouseout.puidatatable', function() {
	2305	var column = $(this);
	2306
	2307	if(!column.hasClass('ui-state-active'))
	2308	column.removeClass('ui-state-hover');
	2309	})
	2310	.on('click.puidatatable', function(event) {
	2311	if(!$(event.target).is('th,span')) {
	2312	return;
	2313	}
	2314
	2315	var column = $(this),
	2316	sortField = column.data('field'),
	2317	order = column.data('order'),
	2318	sortOrder = (order === 0) ? 1 : (order * -1),
	2319	sortIcon = column.children('.ui-sortable-column-icon'),
	2320	metaKey = event.metaKey\|\|event.ctrlKey;
	2321
	2322	if($this._isMultiSort()) {
	2323	if(metaKey) {
	2324	$this._addSortMeta({field: sortField, order: sortOrder});
	2325	$this.sort();
	2326	}
	2327	else {
	2328	$this.options.sortMeta = [];
	2329	$this._addSortMeta({field: sortField, order: sortOrder});
	2330	$this._resetSortState(column);
	2331	$this.sort();
	2332	}
	2333	}
	2334	else {
	2335	//update state
	2336	$this.options.sortField = sortField;
	2337	$this.options.sortOrder = sortOrder;
	2338
	2339	$this._resetSortState(column);
	2340	$this.sort();
	2341	}
	2342
	2343	//update visuals
	2344	column.data('order', sortOrder).removeClass('ui-state-hover').addClass('ui-state-active');
	2345	if(sortOrder === -1)
	2346	sortIcon.removeClass('fa-sort fa-sort-asc').addClass('fa-sort-desc');
	2347	else if(sortOrder === 1)
	2348	sortIcon.removeClass('fa-sort fa-sort-desc').addClass('fa-sort-asc');
	2349
	2350	$this._trigger('sort', event, {'sortOrder': sortOrder, 'sortField': sortField});
	2351	});
	2352	},
	2353
	2354	_addSortMeta: function(meta) {
	2355	var index = -1;
	2356	for(var i = 0; i < this.options.sortMeta.length; i++) {
	2357	if(this.options.sortMeta[i].field === meta.field) {
	2358	index = i;
	2359	}
	2360	}
	2361
	2362	if(index >= 0)
	2363	this.options.sortMeta[index] = meta;
	2364	else
	2365	this.options.sortMeta.push(meta);
	2366	},
	2367
	2368	paginate: function() {
	2369	if(this.options.lazy) {
	2370	this.options.datasource.call(this, this._onLazyLoad, this._createStateMeta());
	2371	}
	2372	else {
	2373	this._renderData();
	2374	}
	2375	},
	2376
	2377	_multipleSort: function() {
	2378	var $this = this;
	2379
	2380	function multisort(data1,data2,sortMeta,index) {
	2381	var value1 = data1[sortMeta[index].field],
	2382	value2 = data2[sortMeta[index].field],
	2383	result = null;
	2384
	2385	if (typeof value1 == 'string' \|\| value1 instanceof String) {
	2386	if (value1.localeCompare && (value1 != value2)) {
	2387	return (sortMeta[index].order * value1.localeCompare(value2));
	2388	}
	2389	}
	2390	else {
	2391	result = (value1 < value2) ? -1 : 1;
	2392	}
	2393
	2394	if(value1 == value2) {
	2395	return (sortMeta.length - 1) > (index) ? (multisort(data1, data2, sortMeta, index + 1)) : 0;
	2396	}
	2397
	2398	return (sortMeta[index].order * result);
	2399	}
	2400
	2401	this.data.sort(function (data1,data2) {
	2402	return multisort(data1, data2, $this.options.sortMeta, 0);
	2403	});
	2404
	2405	this._renderData();
	2406	},
	2407
	2408	sort: function() {
	2409	if(this.options.lazy) {
	2410	this.options.datasource.call(this, this._onLazyLoad, this._createStateMeta());
	2411	}
	2412	else {
	2413	if(this._isMultiSort())
	2414	this._multipleSort();
	2415	else
	2416	this._singleSort();
	2417	}
	2418	},
	2419
	2420	_singleSort: function() {
	2421	var $this = this;
	2422
	2423	this.data.sort(function(data1, data2) {
	2424	var value1 = data1[$this.options.sortField], value2 = data2[$this.options.sortField],
	2425	result = null;
	2426
	2427	if (typeof value1 == 'string' \|\| value1 instanceof String) {
	2428	if ( value1.localeCompare ) {
	2429	return ($this.options.sortOrder * value1.localeCompare(value2));
	2430	}
	2431	else {
	2432	if (value1.toLowerCase) {
	2433	value1 = value1.toLowerCase();
	2434	}
	2435	if (value2.toLowerCase) {
	2436	value2 = value2.toLowerCase();
	2437	}
	2438	result = (value1 < value2) ? -1 : (value1 > value2) ? 1 : 0;
	2439
	2440	}
	2441	}
	2442	else {
	2443	result = (value1 < value2) ? -1 : (value1 > value2) ? 1 : 0;
	2444	}
	2445
	2446	return ($this.options.sortOrder * result);
	2447	});
	2448
	2449	if(this.paginator) {
	2450	this.paginator.puipaginator('option', 'page', 0);
	2451	}
	2452
	2453	this._renderData();
	2454	},
	2455
	2456	sortByField: function(a, b) {
	2457	var aName = a.name.toLowerCase();
	2458	var bName = b.name.toLowerCase();
	2459	return ((aName < bName) ? -1 : ((aName > bName) ? 1 : 0));
	2460	},
	2461
	2462	sortByDefault: function() {
	2463	if(this._isMultiSort()) {
	2464	if(this.options.sortMeta) {
	2465	this._indicateInitialSortColumns();
	2466	this.sort();
	2467	}
	2468	}
	2469	else {
	2470	this._indicateInitialSortColumn(this.options.sortField, this.options.sortOrder);
	2471	this.sort();
	2472	}
	2473	},
	2474
	2475	_renderData: function() {
	2476	this.tbody.html('');
	2477
	2478	var dataToRender = this.filteredData\|\|this.data;
	2479	if(dataToRender && dataToRender.length) {
	2480	var firstNonLazy = this._getFirst(),
	2481	first = this.options.lazy ? 0 : firstNonLazy,
	2482	rows = this._getRows();
	2483
	2484	for(var i = first; i < (first + rows); i++) {
	2485	var rowData = dataToRender[i];
	2486
	2487	if(rowData) {
	2488	var row = $('<tr class="ui-widget-content" />').appendTo(this.tbody),
	2489	zebraStyle = (i%2 === 0) ? 'ui-datatable-even' : 'ui-datatable-odd',
	2490	rowIndex = i;
	2491
	2492	row.addClass(zebraStyle);
	2493	row.data('rowdata', rowData);
	2494
	2495	if(this.options.selectionMode && this._isSelected(rowData)) {
	2496	row.addClass("ui-state-highlight");
	2497	}
	2498
	2499	for(var j = 0; j < this.options.columns.length; j++) {
	2500	var column = $('<td />').appendTo(row),
	2501	columnOptions = this.options.columns[j];
	2502
	2503	if(columnOptions.bodyClass) {
	2504	column.addClass(columnOptions.bodyClass);
	2505	}
	2506
	2507	if(columnOptions.bodyStyle) {
	2508	column.attr('style', columnOptions.bodyStyle);
	2509	}
	2510
	2511	if(columnOptions.editor) {
	2512	column.addClass('ui-editable-column').data({
	2513	'editor': columnOptions.editor,
	2514	'rowdata': rowData,
	2515	'field': columnOptions.field
	2516	});
	2517	}
	2518
	2519	if(columnOptions.content) {
	2520	var content = columnOptions.content.call(this, rowData, columnOptions);
	2521	if($.type(content) === 'string')
	2522	column.html(content);
	2523	else
	2524	column.append(content);
	2525	}
	2526	else if(columnOptions.rowToggler) {
	2527	column.append('<div class="ui-row-toggler fa fa-fw fa-chevron-circle-right ui-c"></div>');
	2528	}
	2529	else if(columnOptions.field) {
	2530	column.text(rowData[columnOptions.field]);
	2531	}
	2532
	2533	if(this.options.responsive && columnOptions.headerText) {
	2534	column.prepend('<span class="ui-column-title">' + columnOptions.headerText + '</span>');
	2535	}
	2536	}
	2537	}
	2538	}
	2539	}
	2540	else {
	2541	var emptyRow = $('<tr class="ui-widget-content"></tr>').appendTo(this.tbody);
	2542	var emptyColumn = $('<td></td>').attr('colspan',this.options.columns.length).appendTo(emptyRow);
	2543	emptyColumn.html(this.options.emptyMessage);
	2544	}
	2545	},
	2546
	2547	_getFirst: function() {
	2548	if(this.paginator) {
	2549	var page = this.paginator.puipaginator('option', 'page'),
	2550	rows = this.paginator.puipaginator('option', 'rows');
	2551
	2552	return (page * rows);
	2553	}
	2554	else {
	2555	return 0;
	2556	}
	2557	},
	2558
	2559	_getRows: function() {
	2560	return this.paginator ? this.paginator.puipaginator('option', 'rows') : (this.data ? this.data.length : 0);
	2561	},
	2562
	2563	_isSortingEnabled: function() {
	2564	var cols = this.options.columns;
	2565	if(cols) {
	2566	for(var i = 0; i < cols.length; i++) {
	2567	if(cols[i].sortable) {
	2568	return true;
	2569	}
	2570	}
	2571	}
	2572
	2573	return false;
	2574	},
	2575
	2576	_initSelection: function() {
	2577	var $this = this;
	2578	this.selection = [];
	2579	this.rowSelector = '> tr.ui-widget-content:not(.ui-datatable-empty-message,.ui-datatable-unselectable)';
	2580
	2581	//shift key based range selection
	2582	if(this._isMultipleSelection()) {
	2583	this.originRowIndex = 0;
	2584	this.cursorIndex = null;
	2585	}
	2586
	2587	this.tbody.off('mouseover.puidatatable mouseout.puidatatable mousedown.puidatatable click.puidatatable', this.rowSelector)
	2588	.on('mouseover.datatable', this.rowSelector, null, function() {
	2589	var element = $(this);
	2590
	2591	if(!element.hasClass('ui-state-highlight')) {
	2592	element.addClass('ui-state-hover');
	2593	}
	2594	})
	2595	.on('mouseout.datatable', this.rowSelector, null, function() {
	2596	var element = $(this);
	2597
	2598	if(!element.hasClass('ui-state-highlight')) {
	2599	element.removeClass('ui-state-hover');
	2600	}
	2601	})
	2602	.on('mousedown.datatable', this.rowSelector, null, function() {
	2603	$this.mousedownOnRow = true;
	2604	})
	2605	.on('click.datatable', this.rowSelector, null, function(e) {
	2606	$this._onRowClick(e, this);
	2607	$this.mousedownOnRow = false;
	2608	});
	2609
	2610	this._bindSelectionKeyEvents();
	2611	},
	2612
	2613	_onRowClick: function(event, rowElement) {
	2614	if(!$(event.target).is(':input,:button,a,.ui-c')) {
	2615	var row = $(rowElement),
	2616	selected = row.hasClass('ui-state-highlight'),
	2617	metaKey = event.metaKey\|\|event.ctrlKey,
	2618	shiftKey = event.shiftKey;
	2619
	2620	this.focusedRow = row;
	2621
	2622	//unselect a selected row if metakey is on
	2623	if(selected && metaKey) {
	2624	this.unselectRow(row);
	2625	}
	2626	else {
	2627	//unselect previous selection if this is single selection or multiple one with no keys
	2628	if(this._isSingleSelection() \|\| (this._isMultipleSelection() && !metaKey && !shiftKey)) {
	2629	if (this._isMultipleSelection()) {
	2630	var selections = this.getSelection();
	2631	for (var i = 0; i < selections.length; i++) {
	2632	this._trigger('rowUnselect', null, selections[i]);
	2633	}
	2634	}
	2635
	2636	this.unselectAllRows();
	2637	}
	2638
	2639	this.selectRow(row, false, event);
	2640	}
	2641
	2642	PUI.clearSelection();
	2643	}
	2644	},
	2645
	2646	onRowRightClick: function(event, rowElement) {
	2647	var row = $(rowElement),
	2648	selectedData = row.data('rowdata'),
	2649	selected = row.hasClass('ui-state-highlight');
	2650
	2651	if(this._isSingleSelection() \|\| !selected) {
	2652	this.unselectAllRows();
	2653	}
	2654
	2655	this.selectRow(row, true);
	2656	this.dataSelectedByContextMenu = selectedData;
	2657	this._trigger('rowSelectContextMenu', event, selectedData);
	2658
	2659	PUI.clearSelection();
	2660	},
	2661
	2662	_bindSelectionKeyEvents: function() {
	2663	var $this = this;
	2664
	2665	this.tbody.attr('tabindex', this.options.tabindex).on('focus', function(e) {
	2666	//ignore mouse click on row
	2667	if(!$this.mousedownOnRow) {
	2668	$this.focusedRow = $this.tbody.children('tr.ui-widget-content').eq(0);
	2669	$this.focusedRow.addClass('ui-state-hover');
	2670	}
	2671	})
	2672	.on('blur', function() {
	2673	if($this.focusedRow) {
	2674	$this.focusedRow.removeClass('ui-state-hover');
	2675	$this.focusedRow = null;
	2676	}
	2677	})
	2678	.on('keydown', function(e) {
	2679	var keyCode = $.ui.keyCode,
	2680	key = e.which;
	2681
	2682	if($this.focusedRow) {
	2683	switch(key) {
	2684	case keyCode.UP:
	2685	var prevRow = $this.focusedRow.prev('tr.ui-widget-content');
	2686	if(prevRow.length) {
	2687	$this.focusedRow.removeClass('ui-state-hover');
	2688	$this.focusedRow = prevRow;
	2689	$this.focusedRow.addClass('ui-state-hover');
	2690	}
	2691	e.preventDefault();
	2692	break;
	2693
	2694	case keyCode.DOWN:
	2695	var nextRow = $this.focusedRow.next('tr.ui-widget-content');
	2696	if(nextRow.length) {
	2697	$this.focusedRow.removeClass('ui-state-hover');
	2698	$this.focusedRow = nextRow;
	2699	$this.focusedRow.addClass('ui-state-hover');
	2700	}
	2701	e.preventDefault();
	2702	break;
	2703
	2704	case keyCode.ENTER:
	2705	case keyCode.NUMPAD_ENTER:
	2706	case keyCode.SPACE:
	2707	e.target = $this.focusedRow.children().eq(0).get(0);
	2708	$this._onRowClick(e, $this.focusedRow.get(0));
	2709	e.preventDefault();
	2710	break;
	2711
	2712	default:
	2713	break;
	2714	};
	2715	}
	2716	});
	2717
	2718	},
	2719
	2720	_isSingleSelection: function() {
	2721	return this.options.selectionMode === 'single';
	2722	},
	2723
	2724	_isMultipleSelection: function() {
	2725	return this.options.selectionMode === 'multiple';
	2726	},
	2727
	2728	unselectAllRows: function() {
	2729	this.tbody.children('tr.ui-state-highlight').removeClass('ui-state-highlight').attr('aria-selected', false);
	2730	this.selection = [];
	2731	},
	2732
	2733	unselectRow: function(row, silent) {
	2734	var unselectedData = row.data('rowdata');
	2735	row.removeClass('ui-state-highlight').attr('aria-selected', false);
	2736
	2737	this._removeSelection(unselectedData);
	2738
	2739	if(!silent) {
	2740	this._trigger('rowUnselect', null, unselectedData);
	2741	}
	2742	},
	2743
	2744	selectRow: function(row, silent, event) {
	2745	var selectedData = row.data('rowdata');
	2746	row.removeClass('ui-state-hover').addClass('ui-state-highlight').attr('aria-selected', true);
	2747
	2748	this._addSelection(selectedData);
	2749
	2750	if(!silent) {
	2751	this._trigger('rowSelect', event, selectedData);
	2752	}
	2753	},
	2754
	2755	getSelection: function() {
	2756	return this.selection;
	2757	},
	2758
	2759	_removeSelection: function(rowData) {
	2760	this.selection = $.grep(this.selection, function(value) {
	2761	return value !== rowData;
	2762	});
	2763	},
	2764
	2765	_addSelection: function(rowData) {
	2766	if(!this._isSelected(rowData)) {
	2767	this.selection.push(rowData);
	2768	}
	2769	},
	2770
	2771	_isSelected: function(rowData) {
	2772	return PUI.inArray(this.selection, rowData);
	2773	},
	2774
	2775	_initExpandableRows: function() {
	2776	var $this = this,
	2777	togglerSelector = '> tr > td > div.ui-row-toggler';
	2778
	2779	this.tbody.off('click', togglerSelector)
	2780	.on('click', togglerSelector, null, function() {
	2781	$this.toggleExpansion($(this));
	2782	})
	2783	.on('keydown', togglerSelector, null, function(e) {
	2784	var key = e.which,
	2785	keyCode = $.ui.keyCode;
	2786
	2787	if((key === keyCode.ENTER\|\|key === keyCode.NUMPAD_ENTER)) {
	2788	$this.toggleExpansion($(this));
	2789	e.preventDefault();
	2790	}
	2791	});
	2792	},
	2793
	2794	toggleExpansion: function(toggler) {
	2795	var row = toggler.closest('tr'),
	2796	expanded = toggler.hasClass('fa-chevron-circle-down');
	2797
	2798	if(expanded) {
	2799	toggler.addClass('fa-chevron-circle-right').removeClass('fa-chevron-circle-down').attr('aria-expanded', false);
	2800
	2801	this.collapseRow(row);
	2802	this._trigger('rowCollapse', null, row.data('rowdata'));
	2803	}
	2804	else {
	2805	if(this.options.rowExpandMode === 'single') {
	2806	this.collapseAllRows();
	2807	}
	2808
	2809	toggler.addClass('fa-chevron-circle-down').removeClass('fa-chevron-circle-right').attr('aria-expanded', true);
	2810
	2811	this.loadExpandedRowContent(row);
	2812	}
	2813	},
	2814
	2815	loadExpandedRowContent: function(row) {
	2816	var expandedRow = $('<tr class="ui-expanded-row-content ui-datatable-unselectable ui-widget-content"><td colspan="' + this.options.columns.length + '"></td></tr>');
	2817	expandedRow.children('td').append(this.options.expandedRowContent.call(this, row.data('rowdata')));
	2818
	2819	row.addClass('ui-expanded-row').after(expandedRow);
	2820	this._trigger('rowExpand', null, row.data('rowdata'));
	2821	},
	2822
	2823	collapseRow: function(row) {
	2824	row.removeClass('ui-expanded-row').next('.ui-expanded-row-content').remove();
	2825	},
	2826
	2827	collapseAllRows: function() {
	2828	var $this = this;
	2829
	2830	this.getExpandedRows().each(function () {
	2831	var expandedRow = $(this);
	2832	$this.collapseRow(expandedRow);
	2833
	2834	var columns = expandedRow.children('td');
	2835	for (var i = 0; i < columns.length; i++) {
	2836	var column = columns.eq(i),
	2837	toggler = column.children('.ui-row-toggler');
	2838
	2839	if (toggler.length) {
	2840	toggler.addClass('fa-chevron-circle-right').removeClass('fa-chevron-circle-down');
	2841	}
	2842	}
	2843	});
	2844	},
	2845
	2846	getExpandedRows: function () {
	2847	return this.tbody.children('.ui-expanded-row');
	2848	},
	2849
	2850	_createStateMeta: function() {
	2851	var state = {
	2852	first: this._getFirst(),
	2853	rows: this._getRows(),
	2854	sortField: this.options.sortField,
	2855	sortOrder: this.options.sortOrder,
	2856	sortMeta: this.options.sortMeta,
	2857	filters: this.filterMetaMap
	2858	};
	2859
	2860	return state;
	2861	},
	2862
	2863	_updateDatasource: function(datasource) {
	2864	this.options.datasource = datasource;
	2865
	2866	if($.isArray(this.options.datasource)) {
	2867	this._onDataUpdate(this.options.datasource);
	2868	}
	2869	else if($.type(this.options.datasource) === 'function') {
	2870	if(this.options.lazy)
	2871	this.options.datasource.call(this, this._onDataUpdate, {first:0, rows: this._getRows(), sortField:this.options.sortField, sortorder:this.options.sortOrder, filters: this._createFilterMap()});
	2872	else
	2873	this.options.datasource.call(this, this._onDataUpdate);
	2874	}
	2875	},
	2876
	2877	_setOption: function(key, value) {
	2878	if(key === 'datasource') {
	2879	this._updateDatasource(value);
	2880	}
	2881	else {
	2882	$.Widget.prototype._setOption.apply(this, arguments);
	2883	}
	2884	},
	2885
	2886	_initScrolling: function() {
	2887	this.scrollHeader = this.element.children('.ui-datatable-scrollable-header');
	2888	this.scrollBody = this.element.children('.ui-datatable-scrollable-body');
	2889	this.scrollHeaderBox = this.scrollHeader.children('.ui-datatable-scrollable-header-box');
	2890	this.headerTable = this.scrollHeaderBox.children('table');
	2891	this.bodyTable = this.scrollBody.children('table');
	2892	this.percentageScrollHeight = this.options.scrollHeight && (this.options.scrollHeight.indexOf('%') !== -1);
	2893	this.percentageScrollWidth = this.options.scrollWidth && (this.options.scrollWidth.indexOf('%') !== -1);
	2894	var $this = this,
	2895	scrollBarWidth = this.getScrollbarWidth() + 'px';
	2896
	2897	if(this.options.scrollHeight) {
	2898	if(this.percentageScrollHeight)
	2899	this.adjustScrollHeight();
	2900	else
	2901	this.scrollBody.css('max-height', this.options.scrollHeight + 'px');
	2902
	2903	if(this.hasVerticalOverflow()) {
	2904	this.scrollHeaderBox.css('margin-right', scrollBarWidth);
	2905	}
	2906	}
	2907
	2908	this.fixColumnWidths();
	2909
	2910	if(this.options.scrollWidth) {
	2911	if(this.percentageScrollWidth)
	2912	this.adjustScrollWidth();
	2913	else
	2914	this.setScrollWidth(parseInt(this.options.scrollWidth));
	2915	}
	2916
	2917	this.cloneHead();
	2918
	2919	this.scrollBody.on('scroll.dataTable', function() {
	2920	var scrollLeft = $this.scrollBody.scrollLeft();
	2921	$this.scrollHeaderBox.css('margin-left', -scrollLeft);
	2922	});
	2923
	2924	this.scrollHeader.on('scroll.dataTable', function() {
	2925	$this.scrollHeader.scrollLeft(0);
	2926	});
	2927
	2928	var resizeNS = 'resize.' + this.id;
	2929	$(window).off(resizeNS).on(resizeNS, function() {
	2930	if($this.element.is(':visible')) {
	2931	if($this.percentageScrollHeight)
	2932	$this.adjustScrollHeight();
	2933
	2934	if($this.percentageScrollWidth)
	2935	$this.adjustScrollWidth();
	2936	}
	2937	});
	2938	},
	2939
	2940	cloneHead: function() {
	2941	this.theadClone = this.thead.clone();
	2942	this.theadClone.find('th').each(function() {
	2943	var header = $(this);
	2944	header.attr('id', header.attr('id') + '_clone');
	2945	$(this).children().not('.ui-column-title').remove();
	2946	});
	2947	this.theadClone.removeAttr('id').addClass('ui-datatable-scrollable-theadclone').height(0).prependTo(this.bodyTable);
	2948
	2949	//align horizontal scroller on keyboard tab
	2950	if(this.options.scrollWidth) {
	2951	var clonedSortableColumns = this.theadClone.find('> tr > th.ui-sortable-column');
	2952	clonedSortableColumns.each(function() {
	2953	$(this).data('original', $(this).attr('id').split('_clone')[0]);
	2954	});
	2955
	2956	clonedSortableColumns.on('blur.dataTable', function() {
	2957	$(PUI.escapeClientId($(this).data('original'))).removeClass('ui-state-focus');
	2958	})
	2959	.on('focus.dataTable', function() {
	2960	$(PUI.escapeClientId($(this).data('original'))).addClass('ui-state-focus');
	2961	})
	2962	.on('keydown.dataTable', function(e) {
	2963	var key = e.which,
	2964	keyCode = $.ui.keyCode;
	2965
	2966	if((key === keyCode.ENTER\|\|key === keyCode.NUMPAD_ENTER) && $(e.target).is(':not(:input)')) {
	2967	$(PUI.escapeClientId($(this).data('original'))).trigger('click.dataTable', (e.metaKey\|\|e.ctrlKey));
	2968	e.preventDefault();
	2969	}
	2970	});
	2971	}
	2972	},
	2973
	2974	adjustScrollHeight: function() {
	2975	var relativeHeight = this.element.parent().innerHeight() * (parseInt(this.options.scrollHeight) / 100),
	2976	tableHeaderHeight = this.element.children('.ui-datatable-header').outerHeight(true),
	2977	tableFooterHeight = this.element.children('.ui-datatable-footer').outerHeight(true),
	2978	scrollersHeight = (this.scrollHeader.outerHeight(true) + this.scrollFooter.outerHeight(true)),
	2979	paginatorsHeight = this.paginator ? this.paginator.getContainerHeight(true) : 0,
	2980	height = (relativeHeight - (scrollersHeight + paginatorsHeight + tableHeaderHeight + tableFooterHeight));
	2981
	2982	this.scrollBody.css('max-height', height + 'px');
	2983	},
	2984
	2985	adjustScrollWidth: function() {
	2986	var width = parseInt((this.element.parent().innerWidth() * (parseInt(this.options.scrollWidth) / 100)));
	2987	this.setScrollWidth(width);
	2988	},
	2989
	2990	setOuterWidth: function(element, width) {
	2991	var diff = element.outerWidth() - element.width();
	2992	element.width(width - diff);
	2993	},
	2994
	2995	setScrollWidth: function(width) {
	2996	var $this = this;
	2997	this.element.children('.ui-widget-header').each(function() {
	2998	$this.setOuterWidth($(this), width);
	2999	});
	3000	this.scrollHeader.width(width);
	3001	this.scrollBody.css('margin-right', 0).width(width);
	3002	},
	3003
	3004	alignScrollBody: function() {
	3005	var marginRight = this.hasVerticalOverflow() ? this.getScrollbarWidth() + 'px' : '0px';
	3006
	3007	this.scrollHeaderBox.css('margin-right', marginRight);
	3008	},
	3009
	3010	getScrollbarWidth: function() {
	3011	if(!this.scrollbarWidth) {
	3012	this.scrollbarWidth = PUI.browser.webkit ? '15' : PUI.calculateScrollbarWidth();
	3013	}
	3014
	3015	return this.scrollbarWidth;
	3016	},
	3017
	3018	hasVerticalOverflow: function() {
	3019	return (this.options.scrollHeight && this.bodyTable.outerHeight() > this.scrollBody.outerHeight())
	3020	},
	3021
	3022	restoreScrollState: function() {
	3023	var scrollState = this.scrollStateHolder.val(),
	3024	scrollValues = scrollState.split(',');
	3025
	3026	this.scrollBody.scrollLeft(scrollValues[0]);
	3027	this.scrollBody.scrollTop(scrollValues[1]);
	3028	},
	3029
	3030	saveScrollState: function() {
	3031	var scrollState = this.scrollBody.scrollLeft() + ',' + this.scrollBody.scrollTop();
	3032
	3033	this.scrollStateHolder.val(scrollState);
	3034	},
	3035
	3036	clearScrollState: function() {
	3037	this.scrollStateHolder.val('0,0');
	3038	},
	3039
	3040	fixColumnWidths: function() {
	3041	if(!this.columnWidthsFixed) {
	3042	if(this.options.scrollable) {
	3043	this.scrollHeaderBox.find('> table > thead > tr > th').each(function() {
	3044	var headerCol = $(this),
	3045	width = headerCol.width();
	3046	headerCol.width(width);
	3047	});
	3048	}
	3049	else {
	3050	this.element.find('> .ui-datatable-tablewrapper > table > thead > tr > th').each(function() {
	3051	var col = $(this);
	3052	col.width(col.width());
	3053	});
	3054	}
	3055
	3056	this.columnWidthsFixed = true;
	3057	}
	3058	},
	3059
	3060	_initDraggableColumns: function() {
	3061	var $this = this;
	3062
	3063	this.dragIndicatorTop = $('<span class="fa fa-arrow-down" style="position:absolute"/></span>').hide().appendTo(this.element);
	3064	this.dragIndicatorBottom = $('<span class="fa fa-arrow-up" style="position:absolute"/></span>').hide().appendTo(this.element);
	3065
	3066	this.thead.find('> tr > th').draggable({
	3067	appendTo: 'body',
	3068	opacity: 0.75,
	3069	cursor: 'move',
	3070	scope: this.id,
	3071	cancel: ':input,.ui-column-resizer',
	3072	drag: function(event, ui) {
	3073	var droppable = ui.helper.data('droppable-column');
	3074
	3075	if(droppable) {
	3076	var droppableOffset = droppable.offset(),
	3077	topArrowY = droppableOffset.top - 10,
	3078	bottomArrowY = droppableOffset.top + droppable.height() + 8,
	3079	arrowX = null;
	3080
	3081	//calculate coordinates of arrow depending on mouse location
	3082	if(event.originalEvent.pageX >= droppableOffset.left + (droppable.width() / 2)) {
	3083	var nextDroppable = droppable.next();
	3084	if(nextDroppable.length == 1)
	3085	arrowX = nextDroppable.offset().left - 9;
	3086	else
	3087	arrowX = droppable.offset().left + droppable.innerWidth() - 9;
	3088
	3089	ui.helper.data('drop-location', 1); //right
	3090	}
	3091	else {
	3092	arrowX = droppableOffset.left - 9;
	3093	ui.helper.data('drop-location', -1); //left
	3094	}
	3095
	3096	$this.dragIndicatorTop.offset({
	3097	'left': arrowX,
	3098	'top': topArrowY - 3
	3099	}).show();
	3100
	3101	$this.dragIndicatorBottom.offset({
	3102	'left': arrowX,
	3103	'top': bottomArrowY - 3
	3104	}).show();
	3105	}
	3106	},
	3107	stop: function(event, ui) {
	3108	//hide dnd arrows
	3109	$this.dragIndicatorTop.css({
	3110	'left':0,
	3111	'top':0
	3112	}).hide();
	3113
	3114	$this.dragIndicatorBottom.css({
	3115	'left':0,
	3116	'top':0
	3117	}).hide();
	3118	},
	3119	helper: function() {
	3120	var header = $(this),
	3121	helper = $('<div class="ui-widget ui-state-default" style="padding:4px 10px;text-align:center;"></div>');
	3122
	3123	helper.width(header.width());
	3124	helper.height(header.height());
	3125
	3126	helper.html(header.html());
	3127
	3128	return helper.get(0);
	3129	}
	3130	}).droppable({
	3131	hoverClass:'ui-state-highlight',
	3132	tolerance:'pointer',
	3133	scope: this.id,
	3134	over: function(event, ui) {
	3135	ui.helper.data('droppable-column', $(this));
	3136	},
	3137	drop: function(event, ui) {
	3138	var draggedColumnHeader = ui.draggable,
	3139	dropLocation = ui.helper.data('drop-location'),
	3140	droppedColumnHeader = $(this),
	3141	draggedColumnFooter = null,
	3142	droppedColumnFooter = null;
	3143
	3144	var draggedCells = $this.tbody.find('> tr:not(.ui-expanded-row-content) > td:nth-child(' + (draggedColumnHeader.index() + 1) + ')'),
	3145	droppedCells = $this.tbody.find('> tr:not(.ui-expanded-row-content) > td:nth-child(' + (droppedColumnHeader.index() + 1) + ')');
	3146
	3147	if($this.containsFooter()) {
	3148	var footerColumns = $this.tfoot.find('> tr > td'),
	3149	draggedColumnFooter = footerColumns.eq(draggedColumnHeader.index()),
	3150	droppedColumnFooter = footerColumns.eq(droppedColumnHeader.index());
	3151	}
	3152
	3153	//drop right
	3154	if(dropLocation > 0) {
	3155	/* TODO :Resizable columns
	3156	* if($this.options.resizableColumns) {
	3157	if(droppedColumnHeader.next().length) {
	3158	droppedColumnHeader.children('span.ui-column-resizer').show();
	3159	draggedColumnHeader.children('span.ui-column-resizer').hide();
	3160	}
	3161	}*/
	3162
	3163	draggedColumnHeader.insertAfter(droppedColumnHeader);
	3164
	3165	draggedCells.each(function(i, item) {
	3166	$(this).insertAfter(droppedCells.eq(i));
	3167	});
	3168
	3169	if(draggedColumnFooter && droppedColumnFooter) {
	3170	draggedColumnFooter.insertAfter(droppedColumnFooter);
	3171	}
	3172
	3173	//sync clone
	3174	if($this.options.scrollable) {
	3175	var draggedColumnClone = $(document.getElementById(draggedColumnHeader.attr('id') + '_clone')),
	3176	droppedColumnClone = $(document.getElementById(droppedColumnHeader.attr('id') + '_clone'));
	3177	draggedColumnClone.insertAfter(droppedColumnClone);
	3178	}
	3179	}
	3180	//drop left
	3181	else {
	3182	draggedColumnHeader.insertBefore(droppedColumnHeader);
	3183
	3184	draggedCells.each(function(i, item) {
	3185	$(this).insertBefore(droppedCells.eq(i));
	3186	});
	3187
	3188	if(draggedColumnFooter && droppedColumnFooter) {
	3189	draggedColumnFooter.insertBefore(droppedColumnFooter);
	3190	}
	3191
	3192	//sync clone
	3193	if($this.options.scrollable) {
	3194	var draggedColumnClone = $(document.getElementById(draggedColumnHeader.attr('id') + '_clone')),
	3195	droppedColumnClone = $(document.getElementById(droppedColumnHeader.attr('id') + '_clone'));
	3196	draggedColumnClone.insertBefore(droppedColumnClone);
	3197	}
	3198	}
	3199
	3200	//fire colReorder event
	3201	$this._trigger('colReorder', null, {
	3202	dragIndex: draggedColumnHeader.index(),
	3203	dropIndex: droppedColumnHeader.index()
	3204	});
	3205	}
	3206	});
	3207	},
	3208
	3209	containsFooter: function() {
	3210	if(this.hasFooter === undefined) {
	3211	this.hasFooter = this.options.footerRows !== undefined;
	3212	if(!this.hasFooter) {
	3213	if(this.options.columns) {
	3214	for(var i = 0; i < this.options.columns.length; i++) {
	3215	if(this.options.columns[i].footerText !== undefined) {
	3216	this.hasFooter = true;
	3217	break;
	3218	}
	3219	}
	3220	}
	3221	}
	3222	}
	3223
	3224	return this.hasFooter;
	3225	},
	3226
	3227	_initResizableColumns: function() {
	3228	this.element.addClass('ui-datatable-resizable');
	3229	this.thead.find('> tr > th').addClass('ui-resizable-column');
	3230	this.resizerHelper = $('<div class="ui-column-resizer-helper ui-state-highlight"></div>').appendTo(this.element);
	3231	this.addResizers();
	3232	var resizers = this.thead.find('> tr > th > span.ui-column-resizer'),
	3233	$this = this;
	3234
	3235	setTimeout(function() {
	3236	$this.fixColumnWidths();
	3237	}, 5);
	3238
	3239	resizers.draggable({
	3240	axis: 'x',
	3241	start: function(event, ui) {
	3242	ui.helper.data('originalposition', ui.helper.offset());
	3243
	3244	var height = $this.options.scrollable ? $this.scrollBody.height() : $this.thead.parent().height() - $this.thead.height() - 1;
	3245	$this.resizerHelper.height(height);
	3246	$this.resizerHelper.show();
	3247	},
	3248	drag: function(event, ui) {
	3249	$this.resizerHelper.offset({
	3250	left: ui.helper.offset().left + ui.helper.width() / 2,
	3251	top: $this.thead.offset().top + $this.thead.height()
	3252	});
	3253	},
	3254	stop: function(event, ui) {
	3255	ui.helper.css({
	3256	'left': '',
	3257	'top': '0px',
	3258	'right': '0px'
	3259	});
	3260
	3261	$this.resize(event, ui);
	3262	$this.resizerHelper.hide();
	3263
	3264	if($this.options.columnResizeMode === 'expand') {
	3265	setTimeout(function() {
	3266	$this._trigger('colResize', null, {element: ui.helper.parent()});
	3267	}, 5);
	3268	}
	3269	else {
	3270	$this._trigger('colResize', null, {element: ui.helper.parent()});
	3271	}
	3272
	3273	if($this.options.stickyHeader) {
	3274	$this.thead.find('.ui-column-filter').prop('disabled', false);
	3275	$this.clone = $this.thead.clone(true);
	3276	$this.cloneContainer.find('thead').remove();
	3277	$this.cloneContainer.children('table').append($this.clone);
	3278	$this.thead.find('.ui-column-filter').prop('disabled', true);
	3279	}
	3280	},
	3281	containment: this.element
	3282	});
	3283	},
	3284
	3285	resize: function(event, ui) {
	3286	var columnHeader, nextColumnHeader, change = null, newWidth = null, nextColumnWidth = null,
	3287	expandMode = (this.options.columnResizeMode === 'expand'),
	3288	table = this.thead.parent(),
	3289	columnHeader = ui.helper.parent(),
	3290	nextColumnHeader = columnHeader.next();
	3291
	3292	change = (ui.position.left - ui.originalPosition.left),
	3293	newWidth = (columnHeader.width() + change),
	3294	nextColumnWidth = (nextColumnHeader.width() - change);
	3295
	3296	if((newWidth > 15 && nextColumnWidth > 15) \|\| (expandMode && newWidth > 15)) {
	3297	if(expandMode) {
	3298	table.width(table.width() + change);
	3299	setTimeout(function() {
	3300	columnHeader.width(newWidth);
	3301	}, 1);
	3302	}
	3303	else {
	3304	columnHeader.width(newWidth);
	3305	nextColumnHeader.width(nextColumnWidth);
	3306	}
	3307
	3308	if(this.options.scrollable) {
	3309	var cloneTable = this.theadClone.parent(),
	3310	colIndex = columnHeader.index();
	3311
	3312	if(expandMode) {
	3313	var $this = this;
	3314
	3315	//body
	3316	cloneTable.width(cloneTable.width() + change);
	3317
	3318	//footer
	3319	this.footerTable.width(this.footerTable.width() + change);
	3320
	3321	setTimeout(function() {
	3322	if($this.hasColumnGroup) {
	3323	$this.theadClone.find('> tr:first').children('th').eq(colIndex).width(newWidth); //body
	3324	$this.footerTable.find('> tfoot > tr:first').children('th').eq(colIndex).width(newWidth); //footer
	3325	}
	3326	else {
	3327	$this.theadClone.find(PUI.escapeClientId(columnHeader.attr('id') + '_clone')).width(newWidth); //body
	3328	$this.footerCols.eq(colIndex).width(newWidth); //footer
	3329	}
	3330	}, 1);
	3331	}
	3332	else {
	3333	//body
	3334	this.theadClone.find(PUI.escapeClientId(columnHeader.attr('id') + '_clone')).width(newWidth);
	3335	this.theadClone.find(PUI.escapeClientId(nextColumnHeader.attr('id') + '_clone')).width(nextColumnWidth);
	3336
	3337	//footer
	3338	/*if(this.footerCols.length > 0) {
	3339	var footerCol = this.footerCols.eq(colIndex),
	3340	nextFooterCol = footerCol.next();
	3341
	3342	footerCol.width(newWidth);
	3343	nextFooterCol.width(nextColumnWidth);
	3344	}*/
	3345	}
	3346	}
	3347	}
	3348	},
	3349
	3350	addResizers: function() {
	3351	var resizableColumns = this.thead.find('> tr > th.ui-resizable-column');
	3352	resizableColumns.prepend('<span class="ui-column-resizer"> </span>');
	3353
	3354	if(this.options.columnResizeMode === 'fit') {
	3355	resizableColumns.filter(':last-child').children('span.ui-column-resizer').hide();
	3356	}
	3357	},
	3358
	3359	_initDraggableRows: function() {
	3360	var $this = this;
	3361
	3362	this.tbody.sortable({
	3363	placeholder: 'ui-datatable-rowordering ui-state-active',
	3364	cursor: 'move',
	3365	handle: 'td,span:not(.ui-c)',
	3366	appendTo: document.body,
	3367	helper: function(event, ui) {
	3368	var cells = ui.children(),
	3369	helper = $('<div class="ui-datatable ui-widget"><table><tbody></tbody></table></div>'),
	3370	helperRow = ui.clone(),
	3371	helperCells = helperRow.children();
	3372
	3373	for(var i = 0; i < helperCells.length; i++) {
	3374	helperCells.eq(i).width(cells.eq(i).width());
	3375	}
	3376
	3377	helperRow.appendTo(helper.find('tbody'));
	3378
	3379	return helper;
	3380	},
	3381	update: function(event, ui) {
	3382	$this.syncRowParity();
	3383
	3384	$this._trigger('rowReorder', null, {
	3385	fromIndex: ui.item.data('ri'),
	3386	toIndex: $this._getFirst() + ui.item.index()
	3387	});
	3388	},
	3389	change: function(event, ui) {
	3390	if($this.options.scrollable) {
	3391	PUI.scrollInView($this.scrollBody, ui.placeholder);
	3392	}
	3393	}
	3394	});
	3395	},
	3396
	3397	syncRowParity: function() {
	3398	var rows = this.tbody.children('tr.ui-widget-content');
	3399
	3400	for(var i = this._getFirst(); i < rows.length; i++) {
	3401	var row = rows.eq(i);
	3402
	3403	row.data('ri', i).removeClass('ui-datatable-even ui-datatable-odd');
	3404
	3405	if(i % 2 === 0)
	3406	row.addClass('ui-datatable-even');
	3407	else
	3408	row.addClass('ui-datatable-odd');
	3409
	3410	}
	3411	},
	3412
	3413	getContextMenuSelection: function(data) {
	3414	return this.dataSelectedByContextMenu;
	3415	},
	3416
	3417	_initFiltering: function() {
	3418	var $this = this;
	3419	this.filterElements = this.thead.find('.ui-column-filter');
	3420
	3421	this.filterElements.on('keyup', function() {
	3422	if($this.filterTimeout) {
	3423	clearTimeout($this.filterTimeout);
	3424	}
	3425
	3426	$this.filterTimeout = setTimeout(function() {
	3427	$this.filter();
	3428	$this.filterTimeout = null;
	3429	},
	3430	$this.options.filterDelay);
	3431	});
	3432
	3433	if(this.options.globalFilter) {
	3434	$(this.options.globalFilter).on('keyup.puidatatable', function() {
	3435	$this.filter();
	3436	});
	3437	}
	3438	},
	3439
	3440	filter: function() {
	3441	this.filterMetaMap = [];
	3442
	3443	for(var i = 0; i < this.filterElements.length; i++) {
	3444	var filterElement = this.filterElements.eq(i),
	3445	filterElementValue = filterElement.val();
	3446
	3447	this.filterMetaMap.push({
	3448	field: filterElement.data('field'),
	3449	filterMatchMode: filterElement.data('filtermatchmode'),
	3450	value: filterElementValue.toLowerCase(),
	3451	element: filterElement
	3452	});
	3453	}
	3454
	3455	if(this.options.lazy) {
	3456	this.options.datasource.call(this, this._onLazyLoad, this._createStateMeta());
	3457	}
	3458	else {
	3459	var globalFilterValue = $(this.options.globalFilter).val();
	3460	this.filteredData = [];
	3461
	3462	for(var i = 0; i < this.data.length; i++) {
	3463	var localMatch = true;
	3464	var globalMatch = false;
	3465
	3466	for(var j = 0; j < this.filterMetaMap.length; j++) {
	3467	var filterMeta = this.filterMetaMap[j],
	3468	filterValue = filterMeta.value,
	3469	filterField = filterMeta.field,
	3470	dataFieldValue = this.data[i][filterField];
	3471
	3472	var filterConstraint = this.filterConstraints[filterMeta.filterMatchMode];
	3473
	3474	//global
	3475	if(this.options.globalFilter && !globalMatch) {
	3476	var filterConstraint = this.filterConstraints['contains'];
	3477	globalMatch = filterConstraint(dataFieldValue, globalFilterValue);
	3478
	3479	}
	3480
	3481	//local
	3482	if(filterMeta.filterMatchMode === 'custom') {
	3483	localMatch = filterMeta.element.triggerHandler('filter', [dataFieldValue, filterValue]);
	3484	}
	3485	else {
	3486	var filterConstraint = this.filterConstraints[filterMeta.filterMatchMode];
	3487	if(!filterConstraint(dataFieldValue, filterValue)) {
	3488	localMatch = false;
	3489	}
	3490	}
	3491
	3492	if(!localMatch) {
	3493	break;
	3494	}
	3495	}
	3496
	3497	var matches = localMatch;
	3498
	3499	if(this.options.globalFilter) {
	3500	matches = localMatch && globalMatch;
	3501	}
	3502
	3503	if(matches) {
	3504	this.filteredData.push(this.data[i]);
	3505	}
	3506	}
	3507
	3508	if(this.filteredData.length === this.data.length) {
	3509	this.filteredData = null;
	3510	}
	3511
	3512	if(this.paginator) {
	3513	this.paginator.puipaginator('option', 'totalRecords', this.filteredData ? this.filteredData.length : this.data ? this.data.length : 0);
	3514	}
	3515
	3516	this._renderData();
	3517	}
	3518	},
	3519
	3520	filterConstraints: {
	3521
	3522	startsWith: function(value, filter) {
	3523	if(filter === undefined \|\| filter === null \|\| $.trim(filter) === '') {
	3524	return true;
	3525	}
	3526
	3527	if(value === undefined \|\| value === null) {
	3528	return false;
	3529	}
	3530
	3531	return value.toString().toLowerCase().slice(0, filter.length) === filter;
	3532	},
	3533
	3534	contains: function(value, filter) {
	3535	if(filter === undefined \|\| filter === null \|\| $.trim(filter) === '') {
	3536	return true;
	3537	}
	3538
	3539	if(value === undefined \|\| value === null) {
	3540	return false;
	3541	}
	3542
	3543	return value.toString().toLowerCase().indexOf(filter) !== -1;
	3544	}
	3545
	3546	},
	3547
	3548	_initStickyHeader: function() {
	3549	var table = this.thead.parent(),
	3550	offset = table.offset(),
	3551	win = $(window),
	3552	$this = this,
	3553	stickyNS = 'scroll.' + this.id,
	3554	resizeNS = 'resize.sticky-' + this.id;
	3555
	3556	this.cloneContainer = $('<div class="ui-datatable ui-datatable-sticky ui-widget"><table></table></div>');
	3557	this.clone = this.thead.clone(true);
	3558	this.cloneContainer.children('table').append(this.clone);
	3559
	3560	this.cloneContainer.css({
	3561	position: 'absolute',
	3562	width: table.outerWidth(),
	3563	top: offset.top,
	3564	left: offset.left,
	3565	'z-index': ++PUI.zindex
	3566	})
	3567	.appendTo(this.element);
	3568
	3569	win.off(stickyNS).on(stickyNS, function() {
	3570	var scrollTop = win.scrollTop(),
	3571	tableOffset = table.offset();
	3572
	3573	if(scrollTop > tableOffset.top) {
	3574	$this.cloneContainer.css({
	3575	'position': 'fixed',
	3576	'top': '0px'
	3577	})
	3578	.addClass('ui-shadow ui-sticky');
	3579
	3580	if(scrollTop >= (tableOffset.top + $this.tbody.height()))
	3581	$this.cloneContainer.hide();
	3582	else
	3583	$this.cloneContainer.show();
	3584	}
	3585	else {
	3586	$this.cloneContainer.css({
	3587	'position': 'absolute',
	3588	'top': tableOffset.top
	3589	})
	3590	.removeClass('ui-shadow ui-sticky');
	3591	}
	3592	})
	3593	.off(resizeNS).on(resizeNS, function() {
	3594	$this.cloneContainer.width(table.outerWidth());
	3595	});
	3596
	3597	//filter support
	3598	this.thead.find('.ui-column-filter').prop('disabled', true);
	3599	},
	3600
	3601	_initEditing: function() {
	3602	var cellSelector = '> tr > td.ui-editable-column',
	3603	$this = this;
	3604
	3605	this.tbody.off('click', cellSelector)
	3606	.on('click', cellSelector, null, function(e) {
	3607	var cell = $(this);
	3608	if(!cell.hasClass('ui-cell-editing')) {
	3609	$this._showCellEditor(cell);
	3610	e.stopPropagation();
	3611	}
	3612	});
	3613	},
	3614
	3615	_showCellEditor: function(cell) {
	3616	var editor = this.editors[cell.data('editor')].call(),
	3617	$this = this;
	3618
	3619	editor.val(cell.data('rowdata')[cell.data('field')]);
	3620
	3621	cell.addClass('ui-cell-editing').html('').append(editor);
	3622
	3623	editor.focus().on('change', function() {
	3624	$this._onCellEditorChange(cell);
	3625	})
	3626	.on('blur', function() {
	3627	$this._onCellEditorBlur(cell);
	3628	})
	3629	.on('keydown', function(e) {
	3630	var key = e.which,
	3631	keyCode = $.ui.keyCode;
	3632
	3633	if((key === keyCode.ENTER\|\|key === keyCode.NUMPAD_ENTER)) {
	3634	$(this).trigger('change').trigger('blur');
	3635	e.preventDefault();
	3636	}
	3637	else if(key === keyCode.TAB) {
	3638	if(e.shiftKey) {
	3639	var prevCell = cell.prevAll('td.ui-editable-column').eq(0);
	3640	if(!prevCell.length) {
	3641	prevCell = cell.parent().prev('tr').children('td.ui-editable-column:last');
	3642	}
	3643	if(prevCell.length) {
	3644	$this._showCellEditor(prevCell);
	3645	}
	3646	}
	3647	else {
	3648	var nextCell = cell.nextAll('td.ui-editable-column').eq(0);
	3649	if(!nextCell.length) {
	3650	nextCell = cell.parent().next('tr').children('td.ui-editable-column').eq(0);
	3651	}
	3652	if(nextCell.length) {
	3653	$this._showCellEditor(nextCell);
	3654	}
	3655	}
	3656
	3657	e.preventDefault();
	3658	} else if(key === keyCode.ESCAPE) {
	3659	$this._onCellEditorBlur(cell);
	3660	}
	3661
	3662	});
	3663	},
	3664
	3665	_onCellEditorChange: function(cell) {
	3666	var newCellValue = cell.children('.ui-cell-editor').val();
	3667
	3668	var retVal = this._trigger('cellEdit', null, {
	3669	oldValue: cell.data('rowdata')[cell.data('field')],
	3670	newValue: newCellValue,
	3671	data: cell.data('rowdata'),
	3672	field: cell.data('field')
	3673	});
	3674
	3675	if(retVal !== false) {
	3676	cell.data('rowdata')[cell.data('field')] = newCellValue;
	3677	}
	3678	},
	3679
	3680	_onCellEditorBlur: function(cell) {
	3681	cell.removeClass('ui-cell-editing').text(cell.data('rowdata')[cell.data('field')])
	3682	.children('.ui-cell-editor').remove();
	3683	},
	3684
	3685	reload: function() {
	3686	this._updateDatasource(this.options.datasource);
	3687	},
	3688
	3689	getPaginator: function() {
	3690	return this.paginator;
	3691	},
	3692
	3693	setTotalRecords: function(val) {
	3694	this.paginator.puipaginator('option','totalRecords', val);
	3695	},
	3696
	3697	_createFilterMap: function() {
	3698	var filters = null;
	3699	if(this.filterElements) {
	3700	filters = {};
	3701	for(var i = 0; i < this.filterElements.length; i++) {
	3702	var filterElement = this.filterElements.eq(i),
	3703	value = filterElement.val();
	3704	if($.trim(value).length) {
	3705	filters[filterElement.data('field')] = value;
	3706	}
	3707	}
	3708	}
	3709
	3710	return filters;
	3711	},
	3712
	3713	editors: {
	3714
	3715	'input': function() {
	3716	return $('<input type="text" class="ui-cell-editor"/>');
	3717	}
	3718	}
	3719
	3720	});
	3721	})();
	3722
	3723	/**
	3724	* PrimeUI Dialog Widget
	3725	*/
	3726	(function() {
	3727
	3728	$.widget("primeui.puidialog", {
	3729
	3730	options: {
	3731	draggable: true,
	3732	resizable: true,
	3733	location: 'center',
	3734	minWidth: 150,
	3735	minHeight: 25,
	3736	height: 'auto',
	3737	width: '300px',
	3738	visible: false,
	3739	modal: false,
	3740	showEffect: null,
	3741	hideEffect: null,
	3742	effectOptions: {},
	3743	effectSpeed: 'normal',
	3744	closeOnEscape: true,
	3745	rtl: false,
	3746	closable: true,
	3747	minimizable: false,
	3748	maximizable: false,
	3749	appendTo: null,
	3750	buttons: null,
	3751	responsive: false,
	3752	title: null,
	3753	enhanced: false
	3754	},
	3755
	3756	_create: function() {
	3757	this.id = this.element.attr('id');
	3758	if(!this.id) {
	3759	this.id = this.element.uniqueId().attr('id');
	3760	}
	3761
	3762	//container
	3763	if(!this.options.enhanced) {
	3764	this.element.addClass('ui-dialog ui-widget ui-widget-content ui-helper-hidden ui-corner-all ui-shadow')
	3765	.contents().wrapAll('<div class="ui-dialog-content ui-widget-content" />');
	3766
	3767	//header
	3768	var title = this.options.title\|\|this.element.attr('title');
	3769	this.element.prepend('<div class="ui-dialog-titlebar ui-widget-header ui-helper-clearfix ui-corner-top">' +
	3770	'<span id="' + this.element.attr('id') + '_label" class="ui-dialog-title">' + title + '</span>')
	3771	.removeAttr('title');
	3772
	3773	//footer
	3774	if(this.options.buttons) {
	3775	this.footer = $('<div class="ui-dialog-buttonpane ui-widget-content ui-helper-clearfix"></div>').appendTo(this.element);
	3776	for(var i = 0; i < this.options.buttons.length; i++) {
	3777	var buttonMeta = this.options.buttons[i],
	3778	button = $('<button type="button"></button>').appendTo(this.footer);
	3779	if(buttonMeta.text) {
	3780	button.text(buttonMeta.text);
	3781	}
	3782
	3783	button.puibutton(buttonMeta);
	3784	}
	3785	}
	3786
	3787	if(this.options.rtl) {
	3788	this.element.addClass('ui-dialog-rtl');
	3789	}
	3790	}
	3791
	3792	//elements
	3793	this.content = this.element.children('.ui-dialog-content');
	3794	this.titlebar = this.element.children('.ui-dialog-titlebar');
	3795
	3796	if(!this.options.enhanced) {
	3797	if(this.options.closable) {
	3798	this._renderHeaderIcon('ui-dialog-titlebar-close', 'fa-close');
	3799	}
	3800
	3801	if(this.options.maximizable) {
	3802	this._renderHeaderIcon('ui-dialog-titlebar-maximize', 'fa-sort');
	3803	}
	3804
	3805	if(this.options.minimizable) {
	3806	this._renderHeaderIcon('ui-dialog-titlebar-minimize', 'fa-minus');
	3807	}
	3808	}
	3809
	3810	//icons
	3811	this.icons = this.titlebar.children('.ui-dialog-titlebar-icon');
	3812	this.closeIcon = this.titlebar.children('.ui-dialog-titlebar-close');
	3813	this.minimizeIcon = this.titlebar.children('.ui-dialog-titlebar-minimize');
	3814	this.maximizeIcon = this.titlebar.children('.ui-dialog-titlebar-maximize');
	3815
	3816	this.blockEvents = 'focus.puidialog mousedown.puidialog mouseup.puidialog keydown.puidialog keyup.puidialog';
	3817	this.parent = this.element.parent();
	3818
	3819	//size
	3820	this.element.css({'width': this.options.width, 'height': 'auto'});
	3821	this.content.height(this.options.height);
	3822
	3823	//events
	3824	this._bindEvents();
	3825
	3826	if(this.options.draggable) {
	3827	this._setupDraggable();
	3828	}
	3829
	3830	if(this.options.resizable) {
	3831	this._setupResizable();
	3832	}
	3833
	3834	if(this.options.appendTo) {
	3835	this.element.appendTo(this.options.appendTo);
	3836	}
	3837
	3838	if(this.options.responsive) {
	3839	this.resizeNS = 'resize.' + this.id;
	3840	}
	3841
	3842	//docking zone
	3843	if($(document.body).children('.ui-dialog-docking-zone').length === 0) {
	3844	$(document.body).append('<div class="ui-dialog-docking-zone"></div>');
	3845	}
	3846
	3847	//aria
	3848	this._applyARIA();
	3849
	3850	if(this.options.visible) {
	3851	this.show();
	3852	}
	3853	},
	3854
	3855	_destroy: function() {
	3856	//restore dom
	3857	if(!this.options.enhanced) {
	3858	this.element.removeClass('ui-dialog ui-widget ui-widget-content ui-helper-hidden ui-corner-all ui-shadow');
	3859
	3860	if(this.options.buttons) {
	3861	this.footer.children('button').puibutton('destroy');
	3862	this.footer.remove();
	3863	}
	3864
	3865	if(this.options.rtl) {
	3866	this.element.removeClass('ui-dialog-rtl');
	3867	}
	3868
	3869	var title = this.titlebar.children('.ui-dialog-title').text()\|\|this.options.title;
	3870	if(title) {
	3871	this.element.attr('title', title);
	3872	}
	3873	this.titlebar.remove();
	3874
	3875	this.content.contents().unwrap();
	3876	}
	3877
	3878	//remove events
	3879	this._unbindEvents();
	3880
	3881	if(this.options.draggable) {
	3882	this.element.draggable('destroy');
	3883	}
	3884
	3885	if(this.options.resizable) {
	3886	this.element.resizable('destroy');
	3887	}
	3888
	3889	if(this.options.appendTo) {
	3890	this.element.appendTo(this.parent);
	3891	}
	3892
	3893	this._unbindResizeListener();
	3894
	3895	if(this.options.modal) {
	3896	this._disableModality();
	3897	}
	3898
	3899	this._removeARIA();
	3900	this.element.css({
	3901	'width': 'auto',
	3902	'height': 'auto'
	3903	});
	3904	},
	3905
	3906	_renderHeaderIcon: function(styleClass, icon) {
	3907	this.titlebar.append('<a class="ui-dialog-titlebar-icon ' + styleClass + ' ui-corner-all" href="#" role="button">' +
	3908	'<span class="fa fa-fw ' + icon + '"></span></a>');
	3909	},
	3910
	3911	_enableModality: function() {
	3912	var $this = this,
	3913	doc = $(document);
	3914
	3915	this.modality = $('<div id="' + this.element.attr('id') + '_modal" class="ui-widget-overlay ui-dialog-mask"></div>').appendTo(document.body)
	3916	.css('z-index', this.element.css('z-index') - 1);
	3917
	3918	//Disable tabbing out of modal dialog and stop events from targets outside of dialog
	3919	doc.on('keydown.puidialog',
	3920	function(event) {
	3921	if(event.keyCode == $.ui.keyCode.TAB) {
	3922	var tabbables = $this.content.find(':tabbable'),
	3923	first = tabbables.filter(':first'),
	3924	last = tabbables.filter(':last');
	3925
	3926	if(event.target === last[0] && !event.shiftKey) {
	3927	first.focus(1);
	3928	return false;
	3929	}
	3930	else if (event.target === first[0] && event.shiftKey) {
	3931	last.focus(1);
	3932	return false;
	3933	}
	3934	}
	3935	})
	3936	.bind(this.blockEvents, function(event) {
	3937	if ($(event.target).zIndex() < $this.element.zIndex()) {
	3938	return false;
	3939	}
	3940	});
	3941	},
	3942
	3943	_disableModality: function() {
	3944	if(this.modality) {
	3945	this.modality.remove();
	3946	this.modality = null;
	3947	}
	3948
	3949	$(document).off(this.blockEvents).off('keydown.dialog');
	3950	},
	3951
	3952	show: function() {
	3953	if(this.element.is(':visible')) {
	3954	return;
	3955	}
	3956
	3957	if(!this.positionInitialized) {
	3958	this._initPosition();
	3959	}
	3960
	3961	this._trigger('beforeShow', null);
	3962
	3963	if(this.options.showEffect) {
	3964	var $this = this;
	3965
	3966	this.element.show(this.options.showEffect, this.options.effectOptions, this.options.effectSpeed, function() {
	3967	$this._postShow();
	3968	});
	3969	}
	3970	else {
	3971	this.element.show();
	3972
	3973	this._postShow();
	3974	}
	3975
	3976	this._moveToTop();
	3977
	3978	if(this.options.modal) {
	3979	this._enableModality();
	3980	}
	3981	},
	3982
	3983	_postShow: function() {
	3984	//execute user defined callback
	3985	this._trigger('afterShow', null);
	3986
	3987	this.element.attr({
	3988	'aria-hidden': false,
	3989	'aria-live': 'polite'
	3990	});
	3991
	3992	this._applyFocus();
	3993
	3994	if(this.options.responsive) {
	3995	this._bindResizeListener();
	3996	}
	3997	},
	3998
	3999	hide: function() {
	4000	if(this.element.is(':hidden')) {
	4001	return;
	4002	}
	4003
	4004	this._trigger('beforeHide', null);
	4005
	4006	if(this.options.hideEffect) {
	4007	var _self = this;
	4008
	4009	this.element.hide(this.options.hideEffect, this.options.effectOptions, this.options.effectSpeed, function() {
	4010	_self._postHide();
	4011	});
	4012	}
	4013	else {
	4014	this.element.hide();
	4015
	4016	this._postHide();
	4017	}
	4018
	4019	if(this.options.modal) {
	4020	this._disableModality();
	4021	}
	4022	},
	4023
	4024	_postHide: function() {
	4025	//execute user defined callback
	4026	this._trigger('afterHide', null);
	4027
	4028	this.element.attr({
	4029	'aria-hidden': true,
	4030	'aria-live': 'off'
	4031	});
	4032
	4033	if(this.options.responsive) {
	4034	this._unbindResizeListener();
	4035	}
	4036	},
	4037
	4038	_applyFocus: function() {
	4039	this.element.find(':not(:submit):not(:button):input:visible:enabled:first').focus();
	4040	},
	4041
	4042	_bindEvents: function() {
	4043	var $this = this;
	4044	this.element.on('mousedown.puidialog', function(e) {
	4045	if(!$(e.target).data('ui-widget-overlay')) {
	4046	$this._moveToTop();
	4047	}
	4048	});
	4049
	4050	this.icons.mouseover(function() {
	4051	$(this).addClass('ui-state-hover');
	4052	}).mouseout(function() {
	4053	$(this).removeClass('ui-state-hover');
	4054	});
	4055
	4056	this.closeIcon.on('click.puidialog', function(e) {
	4057	$this.hide();
	4058	$this._trigger('clickClose');
	4059	e.preventDefault();
	4060	});
	4061
	4062	this.maximizeIcon.click(function(e) {
	4063	$this.toggleMaximize();
	4064	e.preventDefault();
	4065	});
	4066
	4067	this.minimizeIcon.click(function(e) {
	4068	$this.toggleMinimize();
	4069	e.preventDefault();
	4070	});
	4071
	4072	if(this.options.closeOnEscape) {
	4073	$(document).on('keydown.dialog_' + this.id, function(e) {
	4074	var keyCode = $.ui.keyCode,
	4075	active = parseInt($this.element.css('z-index'), 10) === PUI.zindex;
	4076
	4077	if(e.which === keyCode.ESCAPE && $this.element.is(':visible') && active) {
	4078	$this.hide();
	4079	$this._trigger('hideWithEscape');
	4080	}
	4081	});
	4082	}
	4083	},
	4084
	4085	_unbindEvents: function() {
	4086	this.element.off('mousedown.puidialog');
	4087	this.icons.off();
	4088	$(document).off('keydown.dialog_' + this.id);
	4089	},
	4090
	4091	_setupDraggable: function() {
	4092	this.element.draggable({
	4093	cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
	4094	handle: '.ui-dialog-titlebar',
	4095	containment : 'document'
	4096	});
	4097	},
	4098
	4099	_setupResizable: function() {
	4100	var $this = this;
	4101
	4102	this.element.resizable({
	4103	minWidth : this.options.minWidth,
	4104	minHeight : this.options.minHeight,
	4105	alsoResize : this.content,
	4106	containment: 'document',
	4107	start: function(event, ui) {
	4108	$this.element.data('offset', $this.element.offset());
	4109	},
	4110	stop: function(event, ui) {
	4111	var offset = $this.element.data('offset');
	4112
	4113	$this.element.css('position', 'fixed');
	4114	$this.element.offset(offset);
	4115	}
	4116	});
	4117
	4118	this.resizers = this.element.children('.ui-resizable-handle');
	4119	},
	4120
	4121	_initPosition: function() {
	4122	//reset
	4123	this.element.css({left:0,top:0});
	4124
	4125	if(/(center\|left\|top\|right\|bottom)/.test(this.options.location)) {
	4126	this.options.location = this.options.location.replace(',', ' ');
	4127
	4128	this.element.position({
	4129	my: 'center',
	4130	at: this.options.location,
	4131	collision: 'fit',
	4132	of: window,
	4133	//make sure dialog stays in viewport
	4134	using: function(pos) {
	4135	var l = pos.left < 0 ? 0 : pos.left,
	4136	t = pos.top < 0 ? 0 : pos.top;
	4137
	4138	$(this).css({
	4139	left: l,
	4140	top: t
	4141	});
	4142	}
	4143	});
	4144	}
	4145	else {
	4146	var coords = this.options.position.split(','),
	4147	x = $.trim(coords[0]),
	4148	y = $.trim(coords[1]);
	4149
	4150	this.element.offset({
	4151	left: x,
	4152	top: y
	4153	});
	4154	}
	4155
	4156	this.positionInitialized = true;
	4157	},
	4158
	4159	_moveToTop: function() {
	4160	this.element.css('z-index',++PUI.zindex);
	4161	},
	4162
	4163	toggleMaximize: function() {
	4164	if(this.minimized) {
	4165	this.toggleMinimize();
	4166	}
	4167
	4168	if(this.maximized) {
	4169	this.element.removeClass('ui-dialog-maximized');
	4170	this._restoreState();
	4171
	4172	this.maximizeIcon.removeClass('ui-state-hover');
	4173	this.maximized = false;
	4174	}
	4175	else {
	4176	this._saveState();
	4177
	4178	var win = $(window);
	4179
	4180	this.element.addClass('ui-dialog-maximized').css({
	4181	'width': win.width() - 6,
	4182	'height': win.height()
	4183	}).offset({
	4184	top: win.scrollTop(),
	4185	left: win.scrollLeft()
	4186	});
	4187
	4188	//maximize content
	4189	this.content.css({
	4190	width: 'auto',
	4191	height: 'auto'
	4192	});
	4193
	4194	this.maximizeIcon.removeClass('ui-state-hover');
	4195	this.maximized = true;
	4196	this._trigger('maximize');
	4197	}
	4198	},
	4199
	4200	toggleMinimize: function() {
	4201	var animate = true,
	4202	dockingZone = $(document.body).children('.ui-dialog-docking-zone');
	4203
	4204	if(this.maximized) {
	4205	this.toggleMaximize();
	4206	animate = false;
	4207	}
	4208
	4209	var $this = this;
	4210
	4211	if(this.minimized) {
	4212	this.element.appendTo(this.parent).removeClass('ui-dialog-minimized').css({'position':'fixed', 'float':'none'});
	4213	this._restoreState();
	4214	this.content.show();
	4215	this.minimizeIcon.removeClass('ui-state-hover').children('.fa').removeClass('fa-plus').addClass('fa-minus');
	4216	this.minimized = false;
	4217
	4218	if(this.options.resizable) {
	4219	this.resizers.show();
	4220	}
	4221
	4222	if(this.footer) {
	4223	this.footer.show();
	4224	}
	4225	}
	4226	else {
	4227	this._saveState();
	4228
	4229	if(animate) {
	4230	this.element.effect('transfer', {
	4231	to: dockingZone,
	4232	className: 'ui-dialog-minimizing'
	4233	}, 500,
	4234	function() {
	4235	$this._dock(dockingZone);
	4236	$this.element.addClass('ui-dialog-minimized');
	4237	});
	4238	}
	4239	else {
	4240	this._dock(dockingZone);
	4241	}
	4242	}
	4243	},
	4244
	4245	_dock: function(zone) {
	4246	this.element.appendTo(zone).css('position', 'static');
	4247	this.element.css({'height':'auto', 'width':'auto', 'float': 'left'});
	4248	this.content.hide();
	4249	this.minimizeIcon.removeClass('ui-state-hover').children('.fa').removeClass('fa-minus').addClass('fa-plus');
	4250	this.minimized = true;
	4251
	4252	if(this.options.resizable) {
	4253	this.resizers.hide();
	4254	}
	4255
	4256	if(this.footer) {
	4257	this.footer.hide();
	4258	}
	4259
	4260	zone.css('z-index',++PUI.zindex);
	4261
	4262	this._trigger('minimize');
	4263	},
	4264
	4265	_saveState: function() {
	4266	this.state = {
	4267	width: this.element.width(),
	4268	height: this.element.height()
	4269	};
	4270
	4271	var win = $(window);
	4272	this.state.offset = this.element.offset();
	4273	this.state.windowScrollLeft = win.scrollLeft();
	4274	this.state.windowScrollTop = win.scrollTop();
	4275	},
	4276
	4277	_restoreState: function() {
	4278	this.element.width(this.state.width).height(this.state.height);
	4279
	4280	var win = $(window);
	4281	this.element.offset({
	4282	top: this.state.offset.top + (win.scrollTop() - this.state.windowScrollTop),
	4283	left: this.state.offset.left + (win.scrollLeft() - this.state.windowScrollLeft)
	4284	});
	4285	},
	4286
	4287	_applyARIA: function() {
	4288	this.element.attr({
	4289	'role': 'dialog',
	4290	'aria-labelledby': this.element.attr('id') + '_title',
	4291	'aria-hidden': !this.options.visible
	4292	});
	4293
	4294	this.titlebar.children('a.ui-dialog-titlebar-icon').attr('role', 'button');
	4295	},
	4296
	4297	_removeARIA: function() {
	4298	this.element.removeAttr('role').removeAttr('aria-labelledby').removeAttr('aria-hidden')
	4299	.removeAttr('aria-live').removeAttr('aria-hidden');
	4300	},
	4301
	4302	_bindResizeListener: function() {
	4303	var $this = this;
	4304	$(window).on(this.resizeNS, function(e) {
	4305	if(e.target === window) {
	4306	$this._initPosition();
	4307	}
	4308	});
	4309	},
	4310
	4311	_unbindResizeListener: function() {
	4312	$(window).off(this.resizeNS);
	4313	},
	4314
	4315	_setOption: function(key, value) {
	4316	if(key === 'visible') {
	4317	if(value)
	4318	this.show();
	4319	else
	4320	this.hide();
	4321	}
	4322	else {
	4323	$.Widget.prototype._setOption.apply(this, arguments);
	4324	}
	4325	}
	4326	});
	4327	})();
	4328	/**
	4329	* PrimeUI dropdown widget
	4330	*/
	4331	(function() {
	4332
	4333	$.widget("primeui.puidropdown", {
	4334
	4335	options: {
	4336	effect: 'fade',
	4337	effectSpeed: 'normal',
	4338	filter: false,
	4339	filterMatchMode: 'startsWith',
	4340	caseSensitiveFilter: false,
	4341	filterFunction: null,
	4342	data: null,
	4343	content: null,
	4344	scrollHeight: 200,
	4345	appendTo: 'body',
	4346	editable: false,
	4347	value: null,
	4348	style: null,
	4349	styleClass: null
	4350	},
	4351
	4352	_create: function() {
	4353	this.id = this.element.attr('id');
	4354	if(!this.id) {
	4355	this.id = this.element.uniqueId().attr('id');
	4356	}
	4357
	4358	if(!this.options.enhanced) {
	4359	if(this.options.data) {
	4360	if($.isArray(this.options.data)) {
	4361	this._generateOptionElements(this.options.data);
	4362	}
	4363	else {
	4364	if($.type(this.options.data) === 'function') {
	4365	this.options.data.call(this, this._onRemoteOptionsLoad);
	4366	return;
	4367	}
	4368	else {
	4369	if($.type(this.options.data) === 'string') {
	4370	var $this = this,
	4371	dataURL = this.options.data;
	4372
	4373	var loader = function() {
	4374	$.ajax({
	4375	type: 'GET',
	4376	url: dataURL,
	4377	dataType: "json",
	4378	context: $this,
	4379	success: function (response) {
	4380	this._onRemoteOptionsLoad(response);
	4381	}
	4382	});
	4383	};
	4384	loader.call(this);
	4385	}
	4386	}
	4387	return;
	4388	}
	4389	}
	4390
	4391	this._render();
	4392	}
	4393	else {
	4394	this.choices = this.element.children('option');
	4395	this.container = this.element.closest('.ui-dropdown');
	4396	this.focusElementContainer = this.container.children('.ui-helper-hidden-accessible:last');
	4397	this.focusElement = this.focusElementContainer.children('input');
	4398	this.label = this.container.children('.ui-dropdown-label');
	4399	this.menuIcon = this.container.children('.ui-dropdown-trigger');
	4400	this.panel = this.container.children('.ui-dropdown-panel');
	4401	this.itemsWrapper = this.panel.children('.ui-dropdown-items-wrapper');
	4402	this.itemsContainer = this.itemsWrapper.children('ul');
	4403	this.itemsContainer.addClass('ui-dropdown-items ui-dropdown-list ui-widget-content ui-widget ui-corner-all ui-helper-reset');
	4404	this.items = this.itemsContainer.children('li').addClass('ui-dropdown-item ui-dropdown-list-item ui-corner-all');
	4405
	4406	var $this = this;
	4407	this.items.each(function(i) {
	4408	$(this).data('label', $this.choices.eq(i).text());
	4409	});
	4410
	4411	if(this.options.filter) {
	4412	this.filterContainer = this.panel.children('.ui-dropdown-filter-container');
	4413	this.filterInput = this.filterContainer.children('input');
	4414	}
	4415	}
	4416
	4417	this._postRender();
	4418	},
	4419
	4420	_render: function() {
	4421	this.choices = this.element.children('option');
	4422	this.element.attr('tabindex', '-1').wrap('<div class="ui-dropdown ui-widget ui-state-default ui-corner-all ui-helper-clearfix" />')
	4423	.wrap('<div class="ui-helper-hidden-accessible" />');
	4424
	4425	this.container = this.element.closest('.ui-dropdown');
	4426	this.focusElementContainer = $('<div class="ui-helper-hidden-accessible"><input type="text" /></div>').appendTo(this.container);
	4427	this.focusElement = this.focusElementContainer.children('input');
	4428	this.label = this.options.editable ? $('<input type="text" class="ui-dropdown-label ui-inputtext ui-corner-all"">')
	4429	: $('<label class="ui-dropdown-label ui-inputtext ui-corner-all"/>');
	4430	this.label.appendTo(this.container);
	4431	this.menuIcon = $('<div class="ui-dropdown-trigger ui-state-default ui-corner-right"><span class="fa fa-fw fa-caret-down"></span></div>')
	4432	.appendTo(this.container);
	4433
	4434	//panel
	4435	this.panel = $('<div class="ui-dropdown-panel ui-widget-content ui-corner-all ui-helper-hidden ui-shadow" />');
	4436	this.itemsWrapper = $('<div class="ui-dropdown-items-wrapper" />').appendTo(this.panel);
	4437	this.itemsContainer = $('<ul class="ui-dropdown-items ui-dropdown-list ui-widget-content ui-widget ui-corner-all ui-helper-reset"></ul>')
	4438	.appendTo(this.itemsWrapper);
	4439
	4440	this.optGroupsSize = this.itemsContainer.children('li.puiselectonemenu-item-group').length;
	4441
	4442	if(this.options.filter) {
	4443	this.filterContainer = $('<div class="ui-dropdown-filter-container" />').prependTo(this.panel);
	4444	this.filterInput = $('<input type="text" autocomplete="off" class="ui-dropdown-filter ui-inputtext ui-widget ui-state-default ui-corner-all" />')
	4445	.appendTo(this.filterContainer);
	4446	this.filterContainer.append('<span class="fa fa-search"></span>');
	4447	}
	4448
	4449	this._generateItems();
	4450	},
	4451
	4452	_postRender: function() {
	4453	if(this.options.style) {
	4454	this.container.attr('style', this.options.style);
	4455	}
	4456
	4457	if(this.options.styleClass) {
	4458	this.container.addClass(this.options.styleClass);
	4459	}
	4460
	4461	this.disabled = this.element.prop('disabled')\|\|this.options.disabled;
	4462
	4463	if(this.options.appendTo === 'self')
	4464	this.panel.appendTo(this.container);
	4465	else
	4466	this.panel.appendTo(this.options.appendTo);
	4467
	4468	if(this.options.scrollHeight && this.panel.outerHeight() > this.options.scrollHeight) {
	4469	this.itemsWrapper.height(this.options.scrollHeight);
	4470	}
	4471
	4472	var $this = this;
	4473
	4474	//preselection via value option
	4475	if(this.options.value) {
	4476	this.choices.filter('[value="'+this.options.value+'"]').prop('selected', true);
	4477	}
	4478
	4479	var selectedOption = this.choices.filter(':selected');
	4480
	4481	//disable options
	4482	this.choices.filter(':disabled').each(function() {
	4483	$this.items.eq($(this).index()).addClass('ui-state-disabled');
	4484	});
	4485
	4486	//triggers
	4487	this.triggers = this.options.editable ? this.menuIcon : this.container.children('.ui-dropdown-trigger, .ui-dropdown-label');
	4488
	4489	//activate selected
	4490	if(this.options.editable) {
	4491	var customInputVal = this.label.val();
	4492
	4493	//predefined input
	4494	if(customInputVal === selectedOption.text()) {
	4495	this._highlightItem(this.items.eq(selectedOption.index()));
	4496	}
	4497	//custom input
	4498	else {
	4499	this.items.eq(0).addClass('ui-state-highlight');
	4500	this.customInput = true;
	4501	this.customInputVal = customInputVal;
	4502	}
	4503	}
	4504	else {
	4505	this._highlightItem(this.items.eq(selectedOption.index()));
	4506	}
	4507
	4508	if(!this.disabled) {
	4509	this._bindEvents();
	4510	this._bindConstantEvents();
	4511	}
	4512	},
	4513
	4514	_onRemoteOptionsLoad: function(data) {
	4515	this._generateOptionElements(data);
	4516	this._render();
	4517	this._postRender();
	4518	},
	4519
	4520	_generateOptionElements: function(data) {
	4521	for(var i = 0; i < data.length; i++) {
	4522	var choice = data[i];
	4523	if(choice.label)
	4524	this.element.append('<option value="' + choice.value + '">' + choice.label + '</option>');
	4525	else
	4526	this.element.append('<option value="' + choice + '">' + choice + '</option>');
	4527	}
	4528	},
	4529
	4530	_generateItems: function() {
	4531	for(var i = 0; i < this.choices.length; i++) {
	4532	var option = this.choices.eq(i),
	4533	optionLabel = option.text(),
	4534	content = this.options.content ? this.options.content.call(this, this.options.data[i]) : optionLabel;
	4535
	4536	this.itemsContainer.append('<li data-label="' + optionLabel + '" class="ui-dropdown-item ui-dropdown-list-item ui-corner-all">' + content + '</li>');
	4537	}
	4538
	4539	this.items = this.itemsContainer.children('.ui-dropdown-item');
	4540	},
	4541
	4542	_bindEvents: function() {
	4543	var $this = this;
	4544
	4545	this.items.filter(':not(.ui-state-disabled)').each(function(i, item) {
	4546	$this._bindItemEvents($(item));
	4547	});
	4548
	4549	this.triggers.on('mouseenter.puidropdown', function() {
	4550	if(!$this.container.hasClass('ui-state-focus')) {
	4551	$this.container.addClass('ui-state-hover');
	4552	$this.menuIcon.addClass('ui-state-hover');
	4553	}
	4554	})
	4555	.on('mouseleave.puidropdown', function() {
	4556	$this.container.removeClass('ui-state-hover');
	4557	$this.menuIcon.removeClass('ui-state-hover');
	4558	})
	4559	.on('click.puidropdown', function(e) {
	4560	if($this.panel.is(":hidden")) {
	4561	$this._show();
	4562	}
	4563	else {
	4564	$this._hide();
	4565
	4566	$this._revert();
	4567	}
	4568
	4569	$this.container.removeClass('ui-state-hover');
	4570	$this.menuIcon.removeClass('ui-state-hover');
	4571	$this.focusElement.trigger('focus.puidropdown');
	4572	e.preventDefault();
	4573	});
	4574
	4575	this.focusElement.on('focus.puidropdown', function() {
	4576	$this.container.addClass('ui-state-focus');
	4577	$this.menuIcon.addClass('ui-state-focus');
	4578	})
	4579	.on('blur.puidropdown', function() {
	4580	$this.container.removeClass('ui-state-focus');
	4581	$this.menuIcon.removeClass('ui-state-focus');
	4582	});
	4583
	4584	if(this.options.editable) {
	4585	this.label.on('change.ui-dropdown', function() {
	4586	$this._triggerChange(true);
	4587	$this.customInput = true;
	4588	$this.customInputVal = $(this).val();
	4589	$this.items.filter('.ui-state-highlight').removeClass('ui-state-highlight');
	4590	$this.items.eq(0).addClass('ui-state-highlight');
	4591	});
	4592	}
	4593
	4594	this._bindKeyEvents();
	4595
	4596	if(this.options.filter) {
	4597	this._setupFilterMatcher();
	4598
	4599	this.filterInput.puiinputtext();
	4600
	4601	this.filterInput.on('keyup.ui-dropdown', function() {
	4602	$this._filter($(this).val());
	4603	});
	4604	}
	4605	},
	4606
	4607	_bindItemEvents: function(item) {
	4608	var $this = this;
	4609
	4610	item.on('mouseover.puidropdown', function() {
	4611	var el = $(this);
	4612
	4613	if(!el.hasClass('ui-state-highlight'))
	4614	$(this).addClass('ui-state-hover');
	4615	})
	4616	.on('mouseout.puidropdown', function() {
	4617	$(this).removeClass('ui-state-hover');
	4618	})
	4619	.on('click.puidropdown', function() {
	4620	$this._selectItem($(this));
	4621	});
	4622	},
	4623
	4624	_bindConstantEvents: function() {
	4625	var $this = this;
	4626
	4627	$(document.body).on('mousedown.ui-dropdown-' + this.id, function (e) {
	4628	if($this.panel.is(":hidden")) {
	4629	return;
	4630	}
	4631
	4632	var offset = $this.panel.offset();
	4633	if (e.target === $this.label.get(0) \|\|
	4634	e.target === $this.menuIcon.get(0) \|\|
	4635	e.target === $this.menuIcon.children().get(0)) {
	4636	return;
	4637	}
	4638
	4639	if (e.pageX < offset.left \|\|
	4640	e.pageX > offset.left + $this.panel.width() \|\|
	4641	e.pageY < offset.top \|\|
	4642	e.pageY > offset.top + $this.panel.height()) {
	4643
	4644	$this._hide();
	4645	$this._revert();
	4646	}
	4647	});
	4648
	4649	this.resizeNS = 'resize.' + this.id;
	4650	this._unbindResize();
	4651	this._bindResize();
	4652	},
	4653
	4654	_bindKeyEvents: function() {
	4655	var $this = this;
	4656
	4657	this.focusElement.on('keydown.puidropdown', function(e) {
	4658	var keyCode = $.ui.keyCode,
	4659	key = e.which,
	4660	activeItem;
	4661
	4662	switch(key) {
	4663	case keyCode.UP:
	4664	case keyCode.LEFT:
	4665	activeItem = $this._getActiveItem();
	4666	var prev = activeItem.prevAll(':not(.ui-state-disabled,.ui-selectonemenu-item-group):first');
	4667
	4668	if(prev.length == 1) {
	4669	if($this.panel.is(':hidden')) {
	4670	$this._selectItem(prev);
	4671	}
	4672	else {
	4673	$this._highlightItem(prev);
	4674	PUI.scrollInView($this.itemsWrapper, prev);
	4675	}
	4676	}
	4677
	4678	e.preventDefault();
	4679	break;
	4680
	4681	case keyCode.DOWN:
	4682	case keyCode.RIGHT:
	4683	activeItem = $this._getActiveItem();
	4684	var next = activeItem.nextAll(':not(.ui-state-disabled,.ui-selectonemenu-item-group):first');
	4685
	4686	if(next.length == 1) {
	4687	if($this.panel.is(':hidden')) {
	4688	if(e.altKey) {
	4689	$this._show();
	4690	} else {
	4691	$this._selectItem(next);
	4692	}
	4693	}
	4694	else {
	4695	$this._highlightItem(next);
	4696	PUI.scrollInView($this.itemsWrapper, next);
	4697	}
	4698	}
	4699
	4700	e.preventDefault();
	4701	break;
	4702
	4703	case keyCode.ENTER:
	4704	case keyCode.NUMPAD_ENTER:
	4705	if($this.panel.is(':hidden')) {
	4706	$this._show();
	4707	}
	4708	else {
	4709	$this._selectItem($this._getActiveItem());
	4710	}
	4711
	4712	e.preventDefault();
	4713	break;
	4714
	4715	case keyCode.TAB:
	4716	if($this.panel.is(':visible')) {
	4717	$this._revert();
	4718	$this._hide();
	4719	}
	4720	break;
	4721
	4722	case keyCode.ESCAPE:
	4723	if($this.panel.is(':visible')) {
	4724	$this._revert();
	4725	$this._hide();
	4726	}
	4727	break;
	4728
	4729	default:
	4730	var k = String.fromCharCode((96 <= key && key <= 105)? key-48 : key),
	4731	currentItem = $this.items.filter('.ui-state-highlight');
	4732
	4733	//Search items forward from current to end and on no result, search from start until current
	4734	var highlightItem = $this._search(k, currentItem.index() + 1, $this.options.length);
	4735	if(!highlightItem) {
	4736	highlightItem = $this._search(k, 0, currentItem.index());
	4737	}
	4738
	4739	if(highlightItem) {
	4740	if($this.panel.is(':hidden')) {
	4741	$this._selectItem(highlightItem);
	4742	}
	4743	else {
	4744	$this._highlightItem(highlightItem);
	4745	PUI.scrollInView($this.itemsWrapper, highlightItem);
	4746	}
	4747	}
	4748
	4749	break;
	4750	}
	4751	});
	4752	},
	4753
	4754	_unbindEvents: function() {
	4755	this.items.off('mouseover.puidropdown mouseout.puidropdown click.puidropdown');
	4756	this.triggers.off('mouseenter.puidropdown mouseleave.puidropdown click.puidropdown');
	4757	this.focusElement.off('keydown.puidropdown focus.puidropdown blur.puidropdown');
	4758
	4759	if(this.options.editable) {
	4760	this.label.off('change.puidropdown');
	4761	}
	4762
	4763	if(this.options.filter) {
	4764	this.filterInput.off('keyup.ui-dropdown');
	4765	}
	4766
	4767	$(document.body).off('mousedown.ui-dropdown-' + this.id);
	4768	this._unbindResize();
	4769	},
	4770
	4771	_selectItem: function(item, silent) {
	4772	var selectedOption = this.choices.eq(this._resolveItemIndex(item)),
	4773	currentOption = this.choices.filter(':selected'),
	4774	sameOption = selectedOption.val() == currentOption.val(),
	4775	shouldChange = null;
	4776
	4777	if(this.options.editable) {
	4778	shouldChange = (!sameOption)\|\|(selectedOption.text() != this.label.val());
	4779	}
	4780	else {
	4781	shouldChange = !sameOption;
	4782	}
	4783
	4784	if(shouldChange) {
	4785	this._highlightItem(item);
	4786	this.element.val(selectedOption.val());
	4787
	4788	this._triggerChange();
	4789
	4790	if(this.options.editable) {
	4791	this.customInput = false;
	4792	}
	4793	}
	4794
	4795	if(!silent) {
	4796	this.focusElement.trigger('focus.puidropdown');
	4797	}
	4798
	4799	if(this.panel.is(':visible')) {
	4800	this._hide();
	4801	}
	4802	},
	4803
	4804	_highlightItem: function(item) {
	4805	this.items.filter('.ui-state-highlight').removeClass('ui-state-highlight');
	4806
	4807	if(item.length) {
	4808	item.addClass('ui-state-highlight');
	4809
	4810	this._setLabel(item.data('label'));
	4811	}
	4812	else {
	4813	this._setLabel(' ');
	4814	}
	4815	},
	4816
	4817	_triggerChange: function(edited) {
	4818	this.changed = false;
	4819	var selectedOption = this.choices.filter(':selected');
	4820
	4821	if(this.options.change) {
	4822	this._trigger('change', null, {
	4823	value: selectedOption.val(),
	4824	index: selectedOption.index()
	4825	});
	4826	}
	4827
	4828	if(!edited) {
	4829	this.value = this.choices.filter(':selected').val();
	4830	}
	4831	},
	4832
	4833	_resolveItemIndex: function(item) {
	4834	if(this.optGroupsSize === 0) {
	4835	return item.index();
	4836	}
	4837	else {
	4838	return item.index() - item.prevAll('li.ui-dropdown-item-group').length;
	4839	}
	4840	},
	4841
	4842	_setLabel: function(value) {
	4843	if(this.options.editable) {
	4844	this.label.val(value);
	4845	}
	4846	else {
	4847	if(value === ' ') {
	4848	this.label.html(' ');
	4849	}
	4850	else {
	4851	this.label.text(value);
	4852	}
	4853	}
	4854	},
	4855
	4856	_bindResize: function() {
	4857	var $this = this;
	4858
	4859	$(window).bind(this.resizeNS, function(e) {
	4860	if($this.panel.is(':visible')) {
	4861	$this._alignPanel();
	4862	}
	4863	});
	4864	},
	4865
	4866	_unbindResize: function() {
	4867	$(window).unbind(this.resizeNS);
	4868	},
	4869
	4870	_alignPanelWidth: function() {
	4871	if(!this.panelWidthAdjusted) {
	4872	var jqWidth = this.container.outerWidth();
	4873	if(this.panel.outerWidth() < jqWidth) {
	4874	this.panel.width(jqWidth);
	4875	}
	4876
	4877	this.panelWidthAdjusted = true;
	4878	}
	4879	},
	4880
	4881	_alignPanel: function() {
	4882	if(this.panel.parent().is(this.container)) {
	4883	this.panel.css({
	4884	left: '0px',
	4885	top: this.container.outerHeight() + 'px'
	4886	})
	4887	.width(this.container.outerWidth());
	4888	}
	4889	else {
	4890	this._alignPanelWidth();
	4891	this.panel.css({left:'', top:''}).position({
	4892	my: 'left top',
	4893	at: 'left bottom',
	4894	of: this.container,
	4895	collision: 'flipfit'
	4896	});
	4897	}
	4898	},
	4899
	4900	_show: function() {
	4901	this._alignPanel();
	4902
	4903	this.panel.css('z-index', ++PUI.zindex);
	4904
	4905	if(this.options.effect !== 'none') {
	4906	this.panel.show(this.options.effect, {}, this.options.effectSpeed);
	4907	}
	4908	else {
	4909	this.panel.show();
	4910	}
	4911	this.preShowValue = this.choices.filter(':selected');
	4912	},
	4913
	4914	_hide: function() {
	4915	this.panel.hide();
	4916	},
	4917
	4918	_revert: function() {
	4919	if(this.options.editable && this.customInput) {
	4920	this._setLabel(this.customInputVal);
	4921	this.items.filter('.ui-state-active').removeClass('ui-state-active');
	4922	this.items.eq(0).addClass('ui-state-active');
	4923	}
	4924	else {
	4925	this._highlightItem(this.items.eq(this.preShowValue.index()));
	4926	}
	4927	},
	4928
	4929	_getActiveItem: function() {
	4930	return this.items.filter('.ui-state-highlight');
	4931	},
	4932
	4933	_setupFilterMatcher: function() {
	4934	this.filterMatchers = {
	4935	'startsWith': this._startsWithFilter,
	4936	'contains': this._containsFilter,
	4937	'endsWith': this._endsWithFilter,
	4938	'custom': this.options.filterFunction
	4939	};
	4940
	4941	this.filterMatcher = this.filterMatchers[this.options.filterMatchMode];
	4942	},
	4943
	4944	_startsWithFilter: function(value, filter) {
	4945	return value.indexOf(filter) === 0;
	4946	},
	4947
	4948	_containsFilter: function(value, filter) {
	4949	return value.indexOf(filter) !== -1;
	4950	},
	4951
	4952	_endsWithFilter: function(value, filter) {
	4953	return value.indexOf(filter, value.length - filter.length) !== -1;
	4954	},
	4955
	4956	_filter: function(value) {
	4957	this.initialHeight = this.initialHeight\|\|this.itemsWrapper.height();
	4958	var filterValue = this.options.caseSensitiveFilter ? $.trim(value) : $.trim(value).toLowerCase();
	4959
	4960	if(filterValue === '') {
	4961	this.items.filter(':hidden').show();
	4962	}
	4963	else {
	4964	for(var i = 0; i < this.choices.length; i++) {
	4965	var option = this.choices.eq(i),
	4966	itemLabel = this.options.caseSensitiveFilter ? option.text() : option.text().toLowerCase(),
	4967	item = this.items.eq(i);
	4968
	4969	if(this.filterMatcher(itemLabel, filterValue))
	4970	item.show();
	4971	else
	4972	item.hide();
	4973	}
	4974	}
	4975
	4976	if(this.itemsContainer.height() < this.initialHeight) {
	4977	this.itemsWrapper.css('height', 'auto');
	4978	}
	4979	else {
	4980	this.itemsWrapper.height(this.initialHeight);
	4981	}
	4982
	4983	this._alignPanel();
	4984	},
	4985
	4986	_search: function(text, start, end) {
	4987	for(var i = start; i < end; i++) {
	4988	var option = this.choices.eq(i);
	4989
	4990	if(option.text().indexOf(text) === 0) {
	4991	return this.items.eq(i);
	4992	}
	4993	}
	4994
	4995	return null;
	4996	},
	4997
	4998	getSelectedValue: function() {
	4999	return this.element.val();

8964 more lines aren’t shown here.

ModbusAdapters: Fixed security issues in Modbus configuration screen GSF.Web: Cleaned up new embedded resources

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code