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/angular.js (1 of 36 files). Show all

Unified · Split

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.

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