https://www.frankfurt-marathon.com/wp-content/themes/360vier-base-theme/js/ng-1.5.5/angular.js?ver=1.5.5

1/**
2 * @license AngularJS v1.5.5
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
38function 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.5/' +
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  shallowCopy: true,
130  equals: true,
131  csp: true,
132  jq: true,
133  concat: true,
134  sliceArgs: true,
135  bind: true,
136  toJsonReplacer: true,
137  toJson: true,
138  fromJson: true,
139  convertTimezoneToLocal: true,
140  timezoneToOffset: true,
141  startingTag: true,
142  tryDecodeURIComponent: true,
143  parseKeyValue: true,
144  toKeyValue: true,
145  encodeUriSegment: true,
146  encodeUriQuery: true,
147  angularInit: true,
148  bootstrap: true,
149  getTestability: true,
150  snake_case: true,
151  bindJQuery: true,
152  assertArg: true,
153  assertArgFn: true,
154  assertNotHasOwnProperty: true,
155  getter: true,
156  getBlockNodes: true,
157  hasOwnProperty: true,
158  createMap: true,
159
160  NODE_TYPE_ELEMENT: true,
161  NODE_TYPE_ATTRIBUTE: true,
162  NODE_TYPE_TEXT: true,
163  NODE_TYPE_COMMENT: true,
164  NODE_TYPE_DOCUMENT: true,
165  NODE_TYPE_DOCUMENT_FRAGMENT: true,
166*/
167

168////////////////////////////////////
169
170/**
171 * @ngdoc module
172 * @name ng
173 * @module ng
174 * @installation
175 * @description
176 *
177 * # ng (core module)
178 * The ng module is loaded by default when an AngularJS application is started. The module itself
179 * contains the essential components for an AngularJS application to function. The table below
180 * lists a high level breakdown of each of the services/factories, filters, directives and testing
181 * components available within this core module.
182 *
183 * <div doc-module-components="ng"></div>
184 */
185
186var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
187
188// The name of a form control's ValidityState property.
189// This is used so that it's possible for internal tests to create mock ValidityStates.
190var VALIDITY_STATE_PROPERTY = 'validity';
191
192var hasOwnProperty = Object.prototype.hasOwnProperty;
193
194var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
195var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
196
197
198var manualLowercase = function(s) {
199  /* jshint bitwise: false */
200  return isString(s)
201      ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);})
202      : s;
203};
204var manualUppercase = function(s) {
205  /* jshint bitwise: false */
206  return isString(s)
207      ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
208      : s;
209};
210
211
212// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
213// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
214// with correct but slower alternatives. See https://github.com/angular/angular.js/issues/11387
215if ('i' !== 'I'.toLowerCase()) {
216  lowercase = manualLowercase;
217  uppercase = manualUppercase;
218}
219
220
221var
222    msie,             // holds major version number for IE, or NaN if UA is not IE.
223    jqLite,           // delay binding since jQuery could be loaded after us.
224    jQuery,           // delay binding
225    slice             = [].slice,
226    splice            = [].splice,
227    push              = [].push,
228    toString          = Object.prototype.toString,
229    getPrototypeOf    = Object.getPrototypeOf,
230    ngMinErr          = minErr('ng'),
231
232    /** @name angular */
233    angular           = window.angular || (window.angular = {}),
234    angularModule,
235    uid               = 0;
236
237/**
238 * documentMode is an IE-only property
239 * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
240 */
241msie = window.document.documentMode;
242
243
244/**
245 * @private
246 * @param {*} obj
247 * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
248 *                   String ...)
249 */
250function isArrayLike(obj) {
251
252  // `null`, `undefined` and `window` are not array-like
253  if (obj == null || isWindow(obj)) return false;
254
255  // arrays, strings and jQuery/jqLite objects are array like
256  // * jqLite is either the jQuery or jqLite constructor function
257  // * we have to check the existence of jqLite first as this method is called
258  //   via the forEach method when constructing the jqLite object in the first place
259  if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
260
261  // Support: iOS 8.2 (not reproducible in simulator)
262  // "length" in obj used to prevent JIT error (gh-11508)
263  var length = "length" in Object(obj) && obj.length;
264
265  // NodeList objects (with `item` method) and
266  // other objects with suitable length characteristics are array-like
267  return isNumber(length) &&
268    (length >= 0 && ((length - 1) in obj || obj instanceof Array) || typeof obj.item == 'function');
269
270}
271
272/**
273 * @ngdoc function
274 * @name angular.forEach
275 * @module ng
276 * @kind function
277 *
278 * @description
279 * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
280 * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
281 * is the value of an object property or an array element, `key` is the object property key or
282 * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
283 *
284 * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
285 * using the `hasOwnProperty` method.
286 *
287 * Unlike ES262's
288 * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
289 * providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
290 * return the value provided.
291 *
292   ```js
293     var values = {name: 'misko', gender: 'male'};
294     var log = [];
295     angular.forEach(values, function(value, key) {
296       this.push(key + ': ' + value);
297     }, log);
298     expect(log).toEqual(['name: misko', 'gender: male']);
299   ```
300 *
301 * @param {Object|Array} obj Object to iterate over.
302 * @param {Function} iterator Iterator function.
303 * @param {Object=} context Object to become context (`this`) for the iterator function.
304 * @returns {Object|Array} Reference to `obj`.
305 */
306
307function forEach(obj, iterator, context) {
308  var key, length;
309  if (obj) {
310    if (isFunction(obj)) {
311      for (key in obj) {
312        // Need to check if hasOwnProperty exists,
313        // as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function
314        if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) {
315          iterator.call(context, obj[key], key, obj);
316        }
317      }
318    } else if (isArray(obj) || isArrayLike(obj)) {
319      var isPrimitive = typeof obj !== 'object';
320      for (key = 0, length = obj.length; key < length; key++) {
321        if (isPrimitive || key in obj) {
322          iterator.call(context, obj[key], key, obj);
323        }
324      }
325    }

325 else if (obj.forEach && obj.forEach !== forEach) {
326        obj.forEach(iterator, context, obj);
327    } else if (isBlankObject(obj)) {
328      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
329      for (key in obj) {
330        iterator.call(context, obj[key], key, obj);
331      }
332    } else if (typeof obj.hasOwnProperty === 'function') {
333      // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
334      for (key in obj) {
335        if (obj.hasOwnProperty(key)) {
336          iterator.call(context, obj[key], key, obj);
337        }
338      }
339    } else {
340      // Slow path for objects which do not have a method `hasOwnProperty`
341      for (key in obj) {
342        if (hasOwnProperty.call(obj, key)) {
343          iterator.call(context, obj[key], key, obj);
344        }
345      }
346    }
347  }
348  return obj;
349}
350
351function forEachSorted(obj, iterator, context) {
352  var keys = Object.keys(obj).sort();
353  for (var i = 0; i < keys.length; i++) {
354    iterator.call(context, obj[keys[i]], keys[i]);
355  }
356  return keys;
357}
358
359
360/**
361 * when using forEach the params are value, key, but it is often useful to have key, value.
362 * @param {function(string, *)} iteratorFn
363 * @returns {function(*, string)}
364 */
365function reverseParams(iteratorFn) {
366  return function(value, key) {iteratorFn(key, value);};
367}
368
369/**
370 * A consistent way of creating unique IDs in angular.
371 *
372 * Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before
373 * we hit number precision issues in JavaScript.
374 *
375 * Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M
376 *
377 * @returns {number} an unique alpha-numeric string
378 */
379function nextUid() {
380  return ++uid;
381}
382
383
384/**
385 * Set or clear the hashkey for an object.
386 * @param obj object
387 * @param h the hashkey (!truthy to delete the hashkey)
388 */
389function setHashKey(obj, h) {
390  if (h) {
391    obj.$$hashKey = h;
392  } else {
393    delete obj.$$hashKey;
394  }
395}
396
397
398function baseExtend(dst, objs, deep) {
399  var h = dst.$$hashKey;
400
401  for (var i = 0, ii = objs.length; i < ii; ++i) {
402    var obj = objs[i];
403    if (!isObject(obj) && !isFunction(obj)) continue;
404    var keys = Object.keys(obj);
405    for (var j = 0, jj = keys.length; j < jj; j++) {
406      var key = keys[j];
407      var src = obj[key];
408
409      if (deep && isObject(src)) {
410        if (isDate(src)) {
411          dst[key] = new Date(src.valueOf());
412        } else if (isRegExp(src)) {
413          dst[key] = new RegExp(src);
414        } else if (src.nodeName) {
415          dst[key] = src.cloneNode(true);
416        } else if (isElement(src)) {
417          dst[key] = src.clone();
418        } else {
419          if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
420          baseExtend(dst[key], [src], true);
421        }
422      } else {
423        dst[key] = src;
424      }
425    }
426  }
427
428  setHashKey(dst, h);
429  return dst;
430}
431
432/**
433 * @ngdoc function
434 * @name angular.extend
435 * @module ng
436 * @kind function
437 *
438 * @description
439 * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
440 * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
441 * by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
442 *
443 * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
444 * {@link angular.merge} for this.
445 *
446 * @param {Object} dst Destination object.
447 * @param {...Object} src Source object(s).
448 * @returns {Object} Reference to `dst`.
449 */
450function extend(dst) {
451  return baseExtend(dst, slice.call(arguments, 1), false);
452}
453
454
455/**
456* @ngdoc function
457* @name angular.merge
458* @module ng
459* @kind function
460*
461* @description
462* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
463* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
464* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.
465*
466* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
467* objects, performing a deep copy.
468*
469* @param {Object} dst Destination object.
470* @param {...Object} src Source object(s).
471* @returns {Object} Reference to `dst`.
472*/
473function merge(dst) {
474  return baseExtend(dst, slice.call(arguments, 1), true);
475}
476
477
478
479function toInt(str) {
480  return parseInt(str, 10);
481}
482
483
484function inherit(parent, extra) {
485  return extend(Object.create(parent), extra);
486}
487
488/**
489 * @ngdoc function
490 * @name angular.noop
491 * @module ng
492 * @kind function
493 *
494 * @description
495 * A function that performs no operations. This function can be useful when writing code in the
496 * functional style.
497   ```js
498     function foo(callback) {
499       var result = calculateResult();
500       (callback || angular.noop)(result);
501     }
502   ```
503 */
504function noop() {}
505noop.$inject = [];
506
507
508/**
509 * @ngdoc function
510 * @name angular.identity
511 * @module ng
512 * @kind function
513 *
514 * @description
515 * A function that returns its first argument. This function is useful when writing code in the
516 * functional style.
517 *
518   ```js
519     function transformer(transformationFn, value) {
520       return (transformationFn || angular.identity)(value);
521     };
522   ```
523  * @param {*} value to be returned.
524  * @returns {*} the value passed in.
525 */
526function identity($) {return $;}
527identity.$inject = [];
528
529
530function valueFn(value) {return function valueRef() {return value;};}
531
532function hasCustomToString(obj) {
533  return isFunction(obj.toString) && obj.toString !== toString;
534}
535
536
537/**
538 * @ngdoc function
539 * @name angular.isUndefined
540 * @module ng
541 * @kind function
542 *
543 * @description
544 * Determines if a reference is undefined.
545 *
546 * @param {*} value Reference to check.
547 * @returns {boolean} True if `value` is undefined.
548 */
549function isUndefined(value) {return typeof value === 'undefined';}
550
551
552/**
553 * @ngdoc function
554 * @name angular.isDefined
555 * @module ng
556 * @kind function
557 *
558 * @description
559 * Determines if a reference is defined.
560 *
561 * @param {*} value Reference to check.
562 * @returns {boolean} True if `value` is defined.
563 */
564function isDefined(value) {return typeof value !== 'undefined';}
565
566
567/**
568 * @ngdoc function
569 * @name angular.isObject
570 * @module ng
571 * @kind function
572 *
573 * @description
574 * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
575 * considered to be objects. Note that JavaScript arrays are objects.
576 *
577 * @param {*} value Reference to check.
578 * @returns {boolean} True if `value` is an `Object` but not `null`.
579 */
580function isObject(value) {
581  // http://jsperf.com/isobject4
582  return value !== null && typeof value === 'object';
583}
584
585
586/**
587 * Determine if a value is an object with a null prototype
588 *
589 * @returns {boolean} True if `value` is an `Object` with a null prototype
590 */
591function isBlankObject(value) {
592  return value !== null && typeof value === 'object' && !getPrototypeOf(value);
593}
594
595
596/**
597 * @ngdoc function
598 * @name angular.isString
599 * @module ng
600 * @kind function
601 *
602 * @description
603 * Determines if a reference is a `String`.
604 *
605 * @param {*} value Reference to check.
606 * @returns {boolean} True if `value` is a `String`.
607 */
608function isString(value) {return typeof value === 'string';}
609
610
611/**
612 * @ngdoc function
613 * @name angular.isNumber
614 * @module ng
615 * @kind function
616 *
617 * @description
618 * Determines if a reference is a `Number`.
619 *
620 * This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`.
621 *
622 * If you wish to exclude these then you can use the native
623 * [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
624 * method.
625 *
626 * @param {*} value Reference to check.
627 * @returns {boolean} True if `value` is a `Number`.
628 */
629function isNumber(value) {return typeof value === 'number';}
630
631
632/**
633 * @ngdoc function
634 * @name angular.isDate
635 * @module ng
636 * @kind function
637 *
638 * @description
639 * Determines if a value is a date.
640 *
641 * @param {*} value Reference to check.
642 * @returns {boolean} True if `value` is a `Date`.
643 */
644function isDate(value) {
645  return toString.call(value) === '[object Date]';
646}
647
648
649/**
650 * @ngdoc function
651 * @name angular.isArray
652 * @module ng
653 * @kind function
654 *
655 * @description
656 * Determines if a reference is an `Array`.
657 *
658 * @param {*} value Reference to check.
659 * @returns {boolean} True if `value` is an `Array`.
660 */
661var isArray = Array.isArray;
662
663/**
664 * @ngdoc function
665 * @name angular.isFunction
666 * @module ng
667 * @kind function
668 *
669 * @description
670 * Determines if a reference is a `Function`.
671 *
672 * @param {*} value Reference to check.
673 * @returns {boolean} True if `value` is a `Function`.
674 */
675function isFunction(value) {return typeof value === 'function';}
676
677
678/**
679 * Determines if a value is a regular expression object.
680 *
681 * @private
682 * @param {*} value Reference to check.
683 * @returns {boolean} True if `value` is a `RegExp`.
684 */
685function isRegExp(value) {
686  return toString.call(value) === '[object RegExp]';
687}
688
689
690/**
691 * Checks if `obj` is a window object.
692 *
693 * @private
694 * @param {*} obj Object to check
695 * @returns {boolean} True if `obj` is a window obj.
696 */
697function isWindow(obj) {
698  return obj && obj.window === obj;
699}
700
701
702function isScope(obj) {
703  return obj && obj.$evalAsync && obj.$watch;
704}
705
706
707function isFile(obj) {
708  return toString.call(obj) === '[object File]';
709}
710
711
712function isFormData(obj) {
713  return toString.call(obj) === '[object FormData]';
714}
715
716
717function isBlob(obj) {
718  return toString.call(obj) === '[object Blob]';
719}
720
721
722function isBoolean(value) {
723  return typeof value === 'boolean';
724}
725
726
727function isPromiseLike(obj) {
728  return obj && isFunction(obj.then);
729}
730
731
732var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array\]$/;
733function isTypedArray(value) {
734  return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
735}
736
737function isArrayBuffer(obj) {
738  return toString.call(obj) === '[object ArrayBuffer]';
739}
740
741
742var trim = function(value) {
743  return isString(value) ? value.trim() : value;
744};
745
746// Copied from:
747// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
748// Prereq: s is a string.
749var escapeForRegexp = function(s) {
750  return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
751           replace(/\x08/g, '\\x08');
752};
753
754
755/**
756 * @ngdoc function
757 * @name angular.isElement
758 * @module ng
759 * @kind function
760 *
761 * @description
762 * Determines if a reference is a DOM element (or wrapped jQuery element).
763 *
764 * @param {*} value Reference to check.
765 * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
766 */
767function isElement(node) {
768  return !!(node &&
769    (node.nodeName  // we are a direct element
770    || (node.prop && node.attr && node.find)));  // we have an on and find method part of jQuery API
771}
772
773/**
774 * @param str 'key1,key2,...'
775 * @returns {object} in the form of {key1:true, key2:true, ...}
776 */
777function makeMap(str) {
778  var obj = {}, items = str.split(','), i;
779  for (i = 0; i < items.length; i++) {
780    obj[items[i]] = true;
781  }
782  return obj;
783}
784
785
786function nodeName_(element) {
787  return lowercase(element.nodeName || (element[0] && element[0].nodeName));
788}
789
790function includes(array, obj) {
791  return Array.prototype.indexOf.call(array, obj) != -1;
792}
793
794function arrayRemove(array, value) {
795  var index = array.indexOf(value);
796  if (index >= 0) {
797    array.splice(index, 1);
798  }
799  return index;
800}
801
802/**
803 * @ngdoc function
804 * @name angular.copy
805 * @module ng
806 * @kind function
807 *
808 * @description
809 * Creates a deep copy of `source`, which should be an object or an array.

810 *
811 * * If no destination is supplied, a copy of the object or array is created.
812 * * If a destination is provided, all of its elements (for arrays) or properties (for objects)
813 *   are deleted and then all elements/properties from the source are copied to it.
814 * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
815 * * If `source` is identical to 'destination' an exception will be thrown.
816 *
817 * @param {*} source The source that will be used to make a copy.
818 *                   Can be any type, including primitives, `null`, and `undefined`.
819 * @param {(Object|Array)=} destination Destination into which the source is copied. If
820 *     provided, must be of the same type as `source`.
821 * @returns {*} The copy or updated `destination`, if `destination` was specified.
822 *
823 * @example
824 <example module="copyExample">
825 <file name="index.html">
826 <div ng-controller="ExampleController">
827 <form novalidate class="simple-form">
828 Name: <input type="text" ng-model="user.name" /><br />
829 E-mail: <input type="email" ng-model="user.email" /><br />
830 Gender: <input type="radio" ng-model="user.gender" value="male" />male
831 <input type="radio" ng-model="user.gender" value="female" />female<br />
832 <button ng-click="reset()">RESET</button>
833 <button ng-click="update(user)">SAVE</button>
834 </form>
835 <pre>form = {{user | json}}</pre>
836 <pre>master = {{master | json}}</pre>
837 </div>
838
839 <script>
840  angular.module('copyExample', [])
841    .controller('ExampleController', ['$scope', function($scope) {
842      $scope.master= {};
843
844      $scope.update = function(user) {
845        // Example with 1 argument
846        $scope.master= angular.copy(user);
847      };
848
849      $scope.reset = function() {
850        // Example with 2 arguments
851        angular.copy($scope.master, $scope.user);
852      };
853
854      $scope.reset();
855    }]);
856 </script>
857 </file>
858 </example>
859 */
860function copy(source, destination) {
861  var stackSource = [];
862  var stackDest = [];
863
864  if (destination) {
865    if (isTypedArray(destination) || isArrayBuffer(destination)) {
866      throw ngMinErr('cpta', "Can't copy! TypedArray destination cannot be mutated.");
867    }
868    if (source === destination) {
869      throw ngMinErr('cpi', "Can't copy! Source and destination are identical.");
870    }
871
872    // Empty the destination object
873    if (isArray(destination)) {
874      destination.length = 0;
875    } else {
876      forEach(destination, function(value, key) {
877        if (key !== '$$hashKey') {
878          delete destination[key];
879        }
880      });
881    }
882
883    stackSource.push(source);
884    stackDest.push(destination);
885    return copyRecurse(source, destination);
886  }
887
888  return copyElement(source);
889
890  function copyRecurse(source, destination) {
891    var h = destination.$$hashKey;
892    var key;
893    if (isArray(source)) {
894      for (var i = 0, ii = source.length; i < ii; i++) {
895        destination.push(copyElement(source[i]));
896      }
897    } else if (isBlankObject(source)) {
898      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
899      for (key in source) {
900        destination[key] = copyElement(source[key]);
901      }
902    } else if (source && typeof source.hasOwnProperty === 'function') {
903      // Slow path, which must rely on hasOwnProperty
904      for (key in source) {
905        if (source.hasOwnProperty(key)) {
906          destination[key] = copyElement(source[key]);
907        }
908      }
909    } else {
910      // Slowest path --- hasOwnProperty can't be called as a method
911      for (key in source) {
912        if (hasOwnProperty.call(source, key)) {
913          destination[key] = copyElement(source[key]);
914        }
915      }
916    }
917    setHashKey(destination, h);
918    return destination;
919  }
920
921  function copyElement(source) {
922    // Simple values
923    if (!isObject(source)) {
924      return source;
925    }
926
927    // Already copied values
928    var index = stackSource.indexOf(source);
929    if (index !== -1) {
930      return stackDest[index];
931    }
932
933    if (isWindow(source) || isScope(source)) {
934      throw ngMinErr('cpws',
935        "Can't copy! Making copies of Window or Scope instances is not supported.");
936    }
937
938    var needsRecurse = false;

939    var destination = copyType(source);
940
941    if (destination === undefined) {
942      destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
943      needsRecurse = true;
944    }
945
946    stackSource.push(source);
947    stackDest.push(destination);
948
949    return needsRecurse
950      ? copyRecurse(source, destination)
951      : destination;
952  }
953
954  function copyType(source) {
955    switch (toString.call(source)) {
956      case '[object Int8Array]':
957      case '[object Int16Array]':
958      case '[object Int32Array]':
959      case '[object Float32Array]':
960      case '[object Float64Array]':
961      case '[object Uint8Array]':
962      case '[object Uint8ClampedArray]':
963      case '[object Uint16Array]':
964      case '[object Uint32Array]':
965        return new source.constructor(copyElement(source.buffer));
966
967      case '[object ArrayBuffer]':
968        //Support: IE10
969        if (!source.slice) {
970          var copied = new ArrayBuffer(source.byteLength);
971          new Uint8Array(copied).set(new Uint8Array(source));
972          return copied;
973        }
974        return source.slice(0);
975
976      case '[object Boolean]':
977      case '[object Number]':
978      case '[object String]':
979      case '[object Date]':
980        return new source.constructor(source.valueOf());
981
982      case '[object RegExp]':
983        var re = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
984        re.lastIndex = source.lastIndex;
985        return re;
986
987      case '[object Blob]':
988        return new source.constructor([source], {type: source.type});
989    }
990
991    if (isFunction(source.cloneNode)) {
992      return source.cloneNode(true);
993    }
994  }
995}
996
997/**
998 * Creates a shallow copy of an object, an array or a primitive.
999 *
1000 * Assumes that there are no proto properties for objects.
1001 */
1002function shallowCopy(src, dst) {
1003  if (isArray(src)) {
1004    dst = dst || [];
1005
1006    for (var i = 0, ii = src.length; i < ii; i++) {
1007      dst[i] = src[i];
1008    }
1009  } else if (isObject(src)) {
1010    dst = dst || {};
1011
1012    for (var key in src) {
1013      if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
1014        dst[key] = src[key];
1015      }
1016    }
1017  }
1018
1019  return dst || src;
1020}
1021
1022
1023/**
1024 * @ngdoc function
1025 * @name angular.equals
1026 * @module ng
1027 * @kind function
1028 *
1029 * @description
1030 * Determines if two objects or two values are equivalent. Supports value types, regular
1031 * expressions, arrays and objects.
1032 *
1033 * Two objects or values are considered equivalent if at least one of the following is true:
1034 *
1035 * * Both objects or values pass `===` comparison.
1036 * * Both objects or values are of the same type and all of their properties are equal by
1037 *   comparing them with `angular.equals`.
1038 * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
1039 * * Both values represent the same regular expression (In JavaScript,
1040 *   /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
1041 *   representation matches).
1042 *
1043 * During a property comparison, properties of `function` type and properties with names
1044 * that begin with `$` are ignored.
1045 *
1046 * Scope and DOMWindow objects are being compared only by identify (`===`).
1047 *
1048 * @param {*} o1 Object or value to compare.
1049 * @param {*} o2 Object or value to compare.
1050 * @returns {boolean} True if arguments are equal.
1051 *
1052 * @example
1053   <example module="equalsExample" name="equalsExample">
1054     <file name="index.html">

1055      <div ng-controller="ExampleController">
1056        <form novalidate>
1057          <h3>User 1</h3>
1058          Name: <input type="text" ng-model="user1.name">
1059          Age: <input type="number" ng-model="user1.age">
1060
1061          <h3>User 2</h3>
1062          Name: <input type="text" ng-model="user2.name">
1063          Age: <input type="number" ng-model="user2.age">
1064
1065          <div>
1066            <br/>
1067            <input type="button" value="Compare" ng-click="compare()">
1068          </div>
1069          User 1: <pre>{{user1 | json}}</pre>
1070          User 2: <pre>{{user2 | json}}</pre>
1071          Equal: <pre>{{result}}</pre>
1072        </form>
1073      </div>
1074    </file>
1075    <file name="script.js">
1076        angular.module('equalsExample', []).controller('ExampleController', ['$scope', function($scope) {
1077          $scope.user1 = {};
1078          $scope.user2 = {};
1079          $scope.result;
1080          $scope.compare = function() {
1081            $scope.result = angular.equals($scope.user1, $scope.user2);
1082          };
1083        }]);
1084    </file>
1085  </example>
1086 */
1087function equals(o1, o2) {
1088  if (o1 === o2) return true;
1089  if (o1 === null || o2 === null) return false;
1090  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
1091  var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
1092  if (t1 == t2 && t1 == 'object') {
1093    if (isArray(o1)) {
1094      if (!isArray(o2)) return false;
1095      if ((length = o1.length) == o2.length) {
1096        for (key = 0; key < length; key++) {
1097          if (!equals(o1[key], o2[key])) return false;
1098        }
1099        return true;
1100      }
1101    } else if (isDate(o1)) {
1102      if (!isDate(o2)) return false;
1103      return equals(o1.getTime(), o2.getTime());
1104    } else if (isRegExp(o1)) {
1105      if (!isRegExp(o2)) return false;
1106      return o1.toString() == o2.toString();
1107    } else {
1108      if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
1109        isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
1110      keySet = createMap();
1111      for (key in o1) {
1112        if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
1113        if (!equals(o1[key], o2[key])) return false;
1114        keySet[key] = true;
1115      }
1116      for (key in o2) {
1117        if (!(key in keySet) &&
1118            key.charAt(0) !== '$' &&
1119            isDefined(o2[key]) &&
1120            !isFunction(o2[key])) return false;
1121      }
1122      return true;
1123    }
1124  }
1125  return false;
1126}
1127
1128var csp = function() {
1129  if (!isDefined(csp.rules)) {
1130
1131
1132    var ngCspElement = (window.document.querySelector('[ng-csp]') ||
1133                    window.document.querySelector('[data-ng-csp]'));
1134
1135    if (ngCspElement) {
1136      var ngCspAttribute = ngCspElement.getAttribute('ng-csp') ||
1137                    ngCspElement.getAttribute('data-ng-csp');
1138      csp.rules = {
1139        noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
1140        noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1)
1141      };
1142    } else {
1143      csp.rules = {
1144        noUnsafeEval: noUnsafeEval(),
1145        noInlineStyle: false
1146      };
1147    }
1148  }
1149
1150  return csp.rules;
1151
1152  function noUnsafeEval() {
1153    try {
1154      /* jshint -W031, -W054 */
1155      new Function('');
1156      /* jshint +W031, +W054 */
1157      return false;
1158    } catch (e) {
1159      return true;
1160    }
1161  }
1162};
1163
1164/**
1165 * @ngdoc directive
1166 * @module ng
1167 * @name ngJq
1168 *
1169 * @element ANY
1170 * @param {string=} ngJq the name of the library available under `window`
1171 * to be used for angular.element
1172 * @description
1173 * Use this directive to force the angular.element library.  This should be
1174 * used to force either jqLite by leaving ng-jq blank or setting the name of
1175 * the jquery variable under window (eg. jQuery).
1176 *
1177 * Since angular looks for this directive when it is loaded (doesn't wait for the
1178 * DOMContentLoaded event), it must be placed on an element that comes before the script
1179 * which loads angular. Also, only the first instance of `ng-jq` will be used and all
1180 * others ignored.
1181 *
1182 * @example
1183 * This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
1184 ```html
1185 <!doctype html>
1186 <html ng-app ng-jq>
1187 ...
1188 ...
1189 </html>
1190 ```
1191 * @example
1192 * This example shows how to use a jQuery based library of a different name.
1193 * The library name must be available at the top most 'window'.
1194 ```html
1195 <!doctype html>
1196 <html ng-app ng-jq="jQueryLib">
1197 ...
1198 ...
1199 </html>
1200 ```
1201 */
1202var jq = function() {
1203  if (isDefined(jq.name_)) return jq.name_;
1204  var el;
1205  var i, ii = ngAttrPrefixes.length, prefix, name;
1206  for (i = 0; i < ii; ++i) {
1207    prefix = ngAttrPrefixes[i];
1208    if (el = window.document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) {
1209      name = el.getAttribute(prefix + 'jq');
1210      break;
1211    }
1212  }
1213
1214  return (jq.name_ = name);
1215};
1216
1217function concat(array1, array2, index) {
1218  return array1.concat(slice.call(array2, index));
1219}
1220
1221function sliceArgs(args, startIndex) {
1222  return slice.call(args, startIndex || 0);
1223}
1224
1225

1226/* jshint -W101 */
1227/**
1228 * @ngdoc function
1229 * @name angular.bind
1230 * @module ng
1231 * @kind function
1232 *
1233 * @description
1234 * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
1235 * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
1236 * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
1237 * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
1238 *
1239 * @param {Object} self Context which `fn` should be evaluated in.
1240 * @param {function()} fn Function to be bound.
1241 * @param {...*} args Optional arguments to be prebound to the `fn` function call.
1242 * @returns {function()} Function that wraps the `fn` with all the specified bindings.
1243 */
1244/* jshint +W101 */
1245function bind(self, fn) {
1246  var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
1247  if (isFunction(fn) && !(fn instanceof RegExp)) {
1248    return curryArgs.length
1249      ? function() {
1250          return arguments.length
1251            ? fn.apply(self, concat(curryArgs, arguments, 0))
1252            : fn.apply(self, curryArgs);
1253        }
1254      : function() {
1255          return arguments.length
1256            ? fn.apply(self, arguments)
1257            : fn.call(self);
1258        };
1259  } else {
1260    // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
1261    return fn;
1262  }
1263}
1264
1265
1266function toJsonReplacer(key, value) {
1267  var val = value;
1268
1269  if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
1270    val = undefined;
1271  } else if (isWindow(value)) {
1272    val = '$WINDOW';
1273  } else if (value &&  window.document === value) {
1274    val = '$DOCUMENT';
1275  } else if (isScope(value)) {
1276    val = '$SCOPE';
1277  }
1278
1279  return val;
1280}
1281
1282
1283/**
1284 * @ngdoc function
1285 * @name angular.toJson
1286 * @module ng
1287 * @kind function
1288 *
1289 * @description
1290 * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
1291 * stripped since angular uses this notation internally.
1292 *
1293 * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
1294 * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
1295 *    If set to an integer, the JSON output will contain that many spaces per indentation.
1296 * @returns {string|undefined} JSON-ified string representing `obj`.
1297 */
1298function toJson(obj, pretty) {
1299  if (isUndefined(obj)) return undefined;
1300  if (!isNumber(pretty)) {
1301    pretty = pretty ? 2 : null;
1302  }
1303  return JSON.stringify(obj, toJsonReplacer, pretty);
1304}
1305
1306
1307/**
1308 * @ngdoc function
1309 * @name angular.fromJson
1310 * @module ng
1311 * @kind function
1312 *
1313 * @description
1314 * Deserializes a JSON string.
1315 *
1316 * @param {string} json JSON string to deserialize.
1317 * @returns {Object|Array|string|number} Deserialized JSON string.
1318 */
1319function fromJson(json) {
1320  return isString(json)
1321      ? JSON.parse(json)
1322      : json;
1323}
1324
1325
1326var ALL_COLONS = /:/g;
1327function timezoneToOffset(timezone, fallback) {
1328  // IE/Edge do not "understand" colon (`:`) in timezone
1329  timezone = timezone.replace(ALL_COLONS, '');
1330  var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
1331  return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
1332}
1333
1334
1335function addDateMinutes(date, minutes) {
1336  date = new Date(date.getTime());
1337  date.setMinutes(date.getMinutes() + minutes);
1338  return date;
1339}
1340
1341
1342function convertTimezoneToLocal(date, timezone, reverse) {
1343  reverse = reverse ? -1 : 1;
1344  var dateTimezoneOffset = date.getTimezoneOffset();
1345  var timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
1346  return addDateMinutes(date, reverse * (timezoneOffset - dateTimezoneOffset));
1347}
1348
1349
1350/**
1351 * @returns {string} Returns the string representation of the element.
1352 */
1353function startingTag(element) {
1354  element = jqLite(element).clone();
1355  try {
1356    // turns out IE does not let you set .html() on elements which
1357    // are not allowed to have children. So we just ignore it.
1358    element.empty();
1359  } catch (e) {}
1360  var elemHtml = jqLite('<div>').append(element).html();
1361  try {
1362    return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
1363        elemHtml.
1364          match(/^(<[^>]+>)/)[1].
1365          replace(/^<([\w\-]+)/, function(match, nodeName) {return '<' + lowercase(nodeName);});
1366  } catch (e) {
1367    return lowercase(elemHtml);
1368  }
1369
1370}
1371
1372
1373/////////////////////////////////////////////////
1374
1375/**
1376 * Tries to decode the URI component without throwing an exception.
1377 *
1378 * @private
1379 * @param str value potential URI component to check.
1380 * @returns {boolean} True if `value` can be decoded
1381 * with the decodeURIComponent function.
1382 */
1383function tryDecodeURIComponent(value) {
1384  try {
1385    return decodeURIComponent(value);
1386  } catch (e) {
1387    // Ignore any invalid uri component
1388  }
1389}
1390
1391
1392/**
1393 * Parses an escaped url query string into key-value pairs.
1394 * @returns {Object.<string,boolean|Array>}
1395 */
1396function parseKeyValue(/**string*/keyValue) {
1397  var obj = {};
1398  forEach((keyValue || "").split('&'), function(keyValue) {
1399    var splitPoint, key, val;
1400    if (keyValue) {
1401      key = keyValue = keyValue.replace(/\+/g,'%20');
1402      splitPoint = keyValue.indexOf('=');
1403      if (splitPoint !== -1) {
1404        key = keyValue.substring(0, splitPoint);
1405        val = keyValue.substring(splitPoint + 1);
1406      }
1407      key = tryDecodeURIComponent(key);
1408      if (isDefined(key)) {
1409        val = isDefined(val) ? tryDecodeURIComponent(val) : true;
1410        if (!hasOwnProperty.call(obj, key)) {
1411          obj[key] = val;
1412        } else if (isArray(obj[key])) {
1413          obj[key].push(val);
1414        } else {
1415          obj[key] = [obj[key],val];
1416        }
1417      }
1418    }
1419  });
1420  return obj;
1421}
1422
1423function toKeyValue(obj) {
1424  var parts = [];
1425  forEach(obj, function(value, key) {
1426    if (isArray(value)) {
1427      forEach(value, function(arrayValue) {
1428        parts.push(encodeUriQuery(key, true) +
1429                   (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
1430      });
1431    } else {
1432    parts.push(encodeUriQuery(key, true) +
1433               (value === true ? '' : '=' + encodeUriQuery(value, true)));
1434    }
1435  });
1436  return parts.length ? parts.join('&') : '';
1437}
1438
1439
1440/**
1441 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
1442 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
1443 * segments:
1444 *    segment       = *pchar
1445 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1446 *    pct-encoded   = "%" HEXDIG HEXDIG
1447 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1448 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1449 *                     / "*" / "+" / "," / ";" / "="
1450 */
1451function encodeUriSegment(val) {
1452  return encodeUriQuery(val, true).
1453             replace(/%26/gi, '&').
1454             replace(/%3D/gi, '=').
1455             replace(/%2B/gi, '+');
1456}
1457
1458
1459/**
1460 * This method is intended for encoding *key* or *value* parts of query component. We need a custom
1461 * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
1462 * encoded per http://tools.ietf.org/html/rfc3986:
1463 *    query       = *( pchar / "/" / "?" )
1464 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1465 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1466 *    pct-encoded   = "%" HEXDIG HEXDIG
1467 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1468 *                     / "*" / "+" / "," / ";" / "="
1469 */
1470function encodeUriQuery(val, pctEncodeSpaces) {
1471  return encodeURIComponent(val).
1472             replace(/%40/gi, '@').
1473             replace(/%3A/gi, ':').
1474             replace(/%24/g, '$').
1475             replace(/%2C/gi, ',').
1476             replace(/%3B/gi, ';').
1477             replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
1478}
1479
1480var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
1481
1482function getNgAttribute(element, ngAttr) {
1483  var attr, i, ii = ngAttrPrefixes.length;
1484  for (i = 0; i < ii; ++i) {
1485    attr = ngAttrPrefixes[i] + ngAttr;
1486    if (isString(attr = element.getAttribute(attr))) {
1487      return attr;
1488    }
1489  }
1490  return null;
1491}
1492
1493/**
1494 * @ngdoc directive
1495 * @name ngApp
1496 * @module ng
1497 *
1498 * @element ANY
1499 * @param {angular.Module} ngApp an optional application
1500 *   {@link angular.module module} name to load.
1501 * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
1502 *   created in "strict-di" mode. This means that the application will fail to invoke functions which
1503 *   do not use explicit function annotation (and are thus unsuitable for minification), as described
1504 *   in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
1505 *   tracking down the root of these bugs.
1506 *
1507 * @description
1508 *
1509 * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
1510 * designates the **root element** of the application and is typically placed near the root element
1511 * of the page - e.g. on the `<body>` or `<html>` tags.
1512 *
1513 * There are a few things to keep in mind when using `ngApp`:
1514 * - only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngAp

1514p`
1515 *   found in the document will be used to define the root element to auto-bootstrap as an
1516 *   application. To run multiple applications in an HTML document you must manually bootstrap them using
1517 *   {@link angular.bootstrap} instead.
1518 * - AngularJS applications cannot be nested within each other.
1519 * - Do not use a directive that uses {@link ng.$compile#transclusion transclusion} on the same element as `ngApp`.
1520 *   This includes directives such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and
1521 *   {@link ngRoute.ngView `ngView`}.
1522 *   Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
1523 *   causing animations to stop working and making the injector inaccessible from outside the app.
1524 *
1525 * You can specify an **AngularJS module** to be used as the root module for the application.  This
1526 * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
1527 * should contain the application code needed or have dependencies on other modules that will
1528 * contain the code. See {@link angular.module} for more information.
1529 *
1530 * In the example below if the `ngApp` directive were not placed on the `html` element then the
1531 * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
1532 * would not be resolved to `3`.
1533 *
1534 * `ngApp` is the easiest, and most common way to bootstrap an application.
1535 *
1536 <example module="ngAppDemo">
1537   <file name="index.html">
1538   <div ng-controller="ngAppDemoController">
1539     I can add: {{a}} + {{b}} =  {{ a+b }}
1540   </div>
1541   </file>
1542   <file name="script.js">
1543   angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
1544     $scope.a = 1;
1545     $scope.b = 2;
1546   });
1547   </file>
1548 </example>
1549 *
1550 * Using `ngStrictDi`, you would see something like this:
1551 *
1552 <example ng-app-included="true">
1553   <file name="index.html">
1554   <div ng-app="ngAppStrictDemo" ng-strict-di>
1555       <div ng-controller="GoodController1">
1556           I can add: {{a}} + {{b}} =  {{ a+b }}
1557
1558           <p>This renders because the controller does not fail to
1559              instantiate, by using explicit annotation style (see
1560              script.js for details)
1561           </p>
1562       </div>
1563
1564       <div ng-controller="GoodController2">
1565           Name: <input ng-model="name"><br />
1566           Hello, {{name}}!
1567
1568           <p>This renders because the controller does not fail to
1569              instantiate, by using explicit annotation style
1570              (see script.js for details)
1571           </p>
1572       </div>
1573
1574       <div ng-controller="BadController">
1575           I can add: {{a}} + {{b}} =  {{ a+b }}
1576
1577           <p>The controller could not be instantiated, due to relying
1578              on automatic function annotations (which are disabled in
1579              strict mode). As such, the content of this section is not
1580              interpolated, and there should be an error in your web console.
1581           </p>
1582       </div>
1583   </div>
1584   </file>
1585   <file name="script.js">
1586   angular.module('ngAppStrictDemo', [])
1587     // BadController will fail to instantiate, due to relying on automatic function annotation,
1588     // rather than an explicit annotation
1589     .controller('BadController', function($scope) {
1590       $scope.a = 1;
1591       $scope.b = 2;
1592     })
1593     // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
1594     // due to using explicit annotations using the array style and $inject property, respectively.
1595     .controller('GoodController1', ['$scope', function($scope) {
1596       $scope.a = 1;
1597       $scope.b = 2;
1598     }])
1599     .controller('GoodController2', GoodController2);
1600     function GoodController2($scope) {
1601       $scope.name = "World";
1602     }
1603     GoodController2.$inject = ['$scope'];
1604   </file>
1605   <file name="style.css">
1606   div[ng-controller] {
1607       margin-bottom: 1em;
1608       -webkit-border-radius: 4px;
1609       border-radius: 4px;
1610       border: 1px solid;
1611       padding: .5em;
1612   }
1613   div[ng-controller^=Good] {
1614       border-color: #d6e9c6;
1615       background-color: #dff0d8;
1616       color: #3c763d;
1617   }
1618   div[ng-controller^=Bad] {
1619       border-color: #ebccd1;
1620       background-color: #f2dede;
1621       color: #a94442;
1622       margin-bottom: 0;
1623   }
1624   </file>
1625 </example>
1626 */
1627function angularInit(element, bootstrap) {
1628  var appElement,
1629      module,
1630      config = {};
1631
1632  // The element `element` has priority over any other element
1633  forEach(ngAttrPrefixes, function(prefix) {
1634    var name = prefix + 'app';
1635
1636    if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
1637      appElement = element;
1638      module = element.getAttribute(name);
1639    }
1640  });
1641  forEach(ngAttrPrefixes, function(prefix) {
1642    var name = prefix + 'app';
1643    var candidate;
1644
1645    if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
1646      appElement = candidate;
1647      module = candidate.getAttribute(name);
1648    }
1649  });
1650  if (appElement) {
1651    config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
1652    bootstrap(appElement, module ? [module] : [], config);
1653  }
1654}
1655
1656/**
1657 * @ngdoc function
1658 * @name angular.bootstrap
1659 * @module ng
1660 * @description
1661 * Use this function to manually start up angular application.
1662 *
1663 * For more information, see the {@link guide/bootstrap Bootstrap guide}.
1664 *
1665 * Angular will detect if it has been loaded into the browser more than once and only allow the
1666 * first loaded script to be bootstrapped and will report a warning to the browser console for
1667 * each of the subsequent scripts. This prevents strange results in applications, where otherwise
1668 * multiple instances of Angular try to work on the DOM.
1669 *
1670 * <div class="alert alert-warning">

1671 * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
1672 * They must use {@link ng.directive:ngApp ngApp}.
1673 * </div>
1674 *
1675 * <div class="alert alert-warning">
1676 * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
1677 * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
1678 * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
1679 * causing animations to stop working and making the injector inaccessible from outside the app.
1680 * </div>
1681 *
1682 * ```html
1683 * <!doctype html>
1684 * <html>
1685 * <body>
1686 * <div ng-controller="WelcomeController">
1687 *   {{greeting}}
1688 * </div>
1689 *
1690 * <script src="angular.js"></script>
1691 * <script>
1692 *   var app = angular.module('demo', [])
1693 *   .controller('WelcomeController', function($scope) {
1694 *       $scope.greeting = 'Welcome!';
1695 *   });
1696 *   angular.bootstrap(document, ['demo']);
1697 * </script>
1698 * </body>
1699 * </html>
1700 * ```
1701 *
1702 * @param {DOMElement} element DOM element which is the root of angular application.
1703 * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
1704 *     Each item in the array should be the name of a predefined module or a (DI annotated)
1705 *     function that will be invoked by the injector as a `config` block.
1706 *     See: {@link angular.module modules}
1707 * @param {Object=} config an object for defining configuration options for the application. The
1708 *     following keys are supported:
1709 *
1710 * * `strictDi` - disable automatic function annotation for the application. This is meant to
1711 *   assist in finding bugs which break minified code. Defaults to `false`.
1712 *
1713 * @returns {auto.$injector} Returns the newly created injector for this app.
1714 */
1715function bootstrap(element, modules, config) {
1716  if (!isObject(config)) config = {};
1717  var defaultConfig = {
1718    strictDi: false
1719  };
1720  config = extend(defaultConfig, config);
1721  var doBootstrap = function() {
1722    element = jqLite(element);
1723
1724    if (element.injector()) {
1725      var tag = (element[0] === window.document) ? 'document' : startingTag(element);
1726      //Encode angle brackets to prevent input from being sanitized to empty string #8683
1727      throw ngMinErr(
1728          'btstrpd',
1729          "App already bootstrapped with this element '{0}'",
1730          tag.replace(/</,'&lt;').replace(/>/,'&gt;'));
1731    }
1732
1733    modules = modules || [];
1734    modules.unshift(['$provide', function($provide) {
1735      $provide.value('$rootElement', element);
1736    }]);
1737
1738    if (config.debugInfoEnabled) {
1739      // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
1740      modules.push(['$compileProvider', function($compileProvider) {
1741        $compileProvider.debugInfoEnabled(true);
1742      }]);
1743    }
1744
1745    modules.unshift('ng');
1746    var injector = createInjector(modules, config.strictDi);
1747    injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
1748       function bootstrapApply(scope, element, compile, injector) {
1749        scope.$apply(function() {
1750          element.data('$injector', injector);
1751          compile(element)(scope);
1752        });
1753      }]
1754    );
1755    return injector;
1756  };
1757
1758  var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
1759  var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
1760
1761  if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
1762    config.debugInfoEnabled = true;
1763    window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
1764  }
1765
1766  if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
1767    return doBootstrap();
1768  }
1769
1770  window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
1771  angular.resumeBootstrap = function(extraModules) {
1772    forEach(extraModules, function(module) {
1773      modules.push(module);
1774    });
1775    return doBootstrap();
1776  };
1777
1778  if (isFunction(angular.resumeDeferredBootstrap)) {
1779    angular.resumeDeferredBootstrap();
1780  }
1781}
1782
1783/**
1784 * @ngdoc function
1785 * @name angular.reloadWithDebugInfo
1786 * @module ng
1787 * @description
1788 * Use this function to reload the current application with debug information turned on.
1789 * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
1790 *
1791 * See {@link ng.$compileProvider#debugInfoEnabled} for more.
1792 */
1793function reloadWithDebugInfo() {
1794  window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
1795  window.location.reload();
1796}
1797
1798/**
1799 * @name angular.getTestability
1800 * @module ng
1801 * @description
1802 * Get the testability service for the instance of Angular on the given
1803 * element.
1804 * @param {DOMElement} element DOM element which is the root of angular application.
1805 */
1806function getTestability(rootElement) {
1807  var injector = angular.element(rootElement).injector();
1808  if (!injector) {
1809    throw ngMinErr('test',
1810      'no injector found for element argument to getTestability');
1811  }
1812  return injector.get('$$testability');
1813}
1814
1815var SNAKE_CASE_REGEXP = /[A-Z]/g;
1816function snake_case(name, separator) {
1817  separator = separator || '_';
1818  return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
1819    return (pos ? separator : '') + letter.toLowerCase();
1820  });
1821}
1822
1823var bindJQueryFired = false;

1824function bindJQuery() {
1825  var originalCleanData;
1826
1827  if (bindJQueryFired) {
1828    return;
1829  }
1830
1831  // bind to jQuery if present;
1832  var jqName = jq();
1833  jQuery = isUndefined(jqName) ? window.jQuery :   // use jQuery (if present)
1834           !jqName             ? undefined     :   // use jqLite
1835                                 window[jqName];   // use jQuery specified by `ngJq`
1836
1837  // Use jQuery if it exists with proper functionality, otherwise default to us.
1838  // Angular 1.2+ requires jQuery 1.7+ for on()/off() support.
1839  // Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older
1840  // versions. It will not work for sure with jQuery <1.7, though.
1841  if (jQuery && jQuery.fn.on) {
1842    jqLite = jQuery;
1843    extend(jQuery.fn, {
1844      scope: JQLitePrototype.scope,
1845      isolateScope: JQLitePrototype.isolateScope,
1846      controller: JQLitePrototype.controller,
1847      injector: JQLitePrototype.injector,
1848      inheritedData: JQLitePrototype.inheritedData
1849    });
1850
1851    // All nodes removed from the DOM via various jQuery APIs like .remove()
1852    // are passed through jQuery.cleanData. Monkey-patch this method to fire
1853    // the $destroy event on all removed nodes.
1854    originalCleanData = jQuery.cleanData;
1855    jQuery.cleanData = function(elems) {
1856      var events;
1857      for (var i = 0, elem; (elem = elems[i]) != null; i++) {
1858        events = jQuery._data(elem, "events");
1859        if (events && events.$destroy) {
1860          jQuery(elem).triggerHandler('$destroy');
1861        }
1862      }
1863      originalCleanData(elems);
1864    };
1865  } else {
1866    jqLite = JQLite;
1867  }
1868
1869  angular.element = jqLite;
1870
1871  // Prevent double-proxying.
1872  bindJQueryFired = true;
1873}
1874
1875/**
1876 * throw error if the argument is falsy.
1877 */
1878function assertArg(arg, name, reason) {
1879  if (!arg) {
1880    throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required"));
1881  }
1882  return arg;
1883}
1884
1885function assertArgFn(arg, name, acceptArrayAnnotation) {
1886  if (acceptArrayAnnotation && isArray(arg)) {
1887      arg = arg[arg.length - 1];
1888  }
1889
1890  assertArg(isFunction(arg), name, 'not a function, got ' +
1891      (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
1892  return arg;
1893}
1894
1895/**
1896 * throw error if the name given is hasOwnProperty
1897 * @param  {String} name    the name to test
1898 * @param  {String} context the context in which the name is used, such as module or directive
1899 */
1900function assertNotHasOwnProperty(name, context) {
1901  if (name === 'hasOwnProperty') {
1902    throw ngMinErr('badname', "hasOwnProperty is not a valid {0} name", context);
1903  }
1904}
1905
1906/**
1907 * Return the value accessible from the object by path. Any undefined traversals are ignored
1908 * @param {Object} obj starting object
1909 * @param {String} path path to traverse
1910 * @param {boolean} [bindFnToScope=true]
1911 * @returns {Object} value as accessible by path
1912 */
1913//TODO(misko): this function needs to be removed
1914function getter(obj, path, bindFnToScope) {
1915  if (!path) return obj;
1916  var keys = path.split('.');
1917  var key;
1918  var lastInstance = obj;
1919  var len = keys.length;
1920
1921  for (var i = 0; i < len; i++) {
1922    key = keys[i];
1923    if (obj) {
1924      obj = (lastInstance = obj)[key];
1925    }
1926  }
1927  if (!bindFnToScope && isFunction(obj)) {
1928    return bind(lastInstance, obj);
1929  }
1930  return obj;
1931}
1932
1933/**
1934 * Return the DOM siblings between the first and last node in the given array.
1935 * @param {Array} array like object
1936 * @returns {Array} the inputted object or a jqLite collection containing the nodes
1937 */
1938function getBlockNodes(nodes) {
1939  // TODO(perf): update `nodes` instead of creating a new object?
1940  var node = nodes[0];
1941  var endNode = nodes[nodes.length - 1];
1942  var blockNodes;
1943
1944  for (var i = 1; node !== endNode && (node = node.nextSibling); i++) {
1945    if (blockNodes || nodes[i] !== node) {
1946      if (!blockNodes) {
1947        blockNodes = jqLite(slice.call(nodes, 0, i));
1948      }
1949      blockNodes.push(node);
1950    }
1951  }
1952
1953  return blockNodes || nodes;
1954}
1955
1956
1957/**
1958 * Creates a new object without a prototype. This object is useful for lookup without having to
1959 * guard against prototypically inherited properties via hasOwnProperty.
1960 *
1961 * Related micro-benchmarks:
1962 * - http://jsperf.com/object-create2
1963 * - http://jsperf.com/proto-map-lookup/2
1964 * - http://jsperf.com/for-in-vs-object-keys2
1965 *
1966 * @returns {Object}
1967 */
1968function createMap() {
1969  return Object.create(null);
1970}
1971
1972var NODE_TYPE_ELEMENT = 1;
1973var NODE_TYPE_ATTRIBUTE = 2;
1974var NODE_TYPE_TEXT = 3;
1975var NODE_TYPE_COMMENT = 8;
1976var NODE_TYPE_DOCUMENT = 9;
1977var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
1978
1979/**
1980 * @ngdoc type
1981 * @name angular.Module
1982 * @module ng
1983 * @description
1984 *
1985 * Interface for configuring angular {@link angular.module modules}.
1986 */
1987
1988function setupModuleLoader(window) {
1989
1990  var $injectorMinErr = minErr('$injector');
1991  var ngMinErr = minErr('ng');
1992
1993  function ensure(obj, name, factory) {
1994    return obj[name] || (obj[name] = factory());
1995  }
1996
1997  var angular = ensure(window, 'angular', Object);
1998
1999  // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
2000  angular.$$minErr = angular.$$minErr || minErr;
2001
2002  return ensure(angular, 'module', function() {
2003    /** @type {Object.<string, angular.Module>} */
2004    var modules = {};
2005
2006    /**
2007     * @ngdoc function
2008     * @name angular.module
2009     * @module ng
2010     * @description
2011     *
2012     * The `angular.module` is a global place for creating, registering and retrieving Angular
2013     * modules.
2014     * All modules (angular core or 3rd party) that should be available to an application must be
2015     * registered using this mechanism.
2016     *
2017     * Passing one argument retrieves an existing {@link angular.Module},
2018     * whereas passing more than one argument creates a new {@link angular.Module}
2019     *
2020     *
2021     * # Module
2022     *
2023     * A module is a collection of services, directives, controllers, filters, and configuration information.
2024     * `angular.module` is used to configure the {@link auto.$injector $injector}.
2025     *
2026     * ```js
2027     * // Create a new module
2028     * var myModule = angular.module('myModule', []);
2029     *
2030     * // register a new service
2031     * myModule.value('appName', 'MyCoolApp');
2032     *
2033     * // configure existing services inside initialization blocks.
2034     * myModule.config(['$locationProvider', function($locationProvider) {
2035     *   // Configure existing providers
2036     *   $locationProvider.hashPrefix('!');
2037     * }]);
2038     * ```
2039     *
2040     * Then you can create an injector and load your modules like this:
2041     *
2042     * ```js
2043     * var injector = angular.injector(['ng', 'myModule'])
2044     * ```
2045     *
2046     * However it's more likely that you'll just use
2047     * {@link ng.directive:ngApp ngApp} or
2048     * {@link angular.bootstrap} to simplify this process for you.
2049     *
2050     * @param {!string} name The name of the module to create or retrieve.
2051     * @param {!Array.<string>=} requires If specified then new module is being created. If
2052     *        unspecified then the module is being retrieved for further configuration.
2053     * @param {Function=} configFn Optional configuration function for the module. Same as
2054     *        {@link angular.Module#config Module#config()}.
2055     * @returns {angular.Module} new module with the {@link angular.Module} api.
2056     */
2057    return function module(name, requires, configFn) {
2058      var assertNotHasOwnProperty = function(name, context) {
2059        if (name === 'hasOwnProperty') {
2060          throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
2061        }
2062      };
2063
2064      assertNotHasOwnProperty(name, 'module');
2065      if (requires && modules.hasOwnProperty(name)) {
2066        modules[name] = null;
2067      }
2068      return ensure(modules, name, function() {
2069        if (!requires) {
2070          throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
2071             "the module name or forgot to load it. If registering a module ensure that you " +
2072             "specify the dependencies as the second argument.", name);
2073        }
2074
2075        /** @type {!Array.<Array.<*>>} */
2076        var invokeQueue = [];
2077
2078        /** @type {!Array.<Function>} */
2079        var configBlocks = [];
2080
2081        /** @type {!Array.<Function>} */
2082        var runBlocks = [];
2083
2084        var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
2085
2086        /** @type {angular.Module} */
2087        var moduleInstance = {
2088          // Private state
2089          _invokeQueue: invokeQueue,
2090          _configBlocks: configBlocks,
2091          _runBlocks: runBlocks,
2092
2093          /**
2094           * @ngdoc property
2095           * @name angular.Module#requires
2096           * @module ng
2097           *
2098           * @description
2099           * Holds the list of modules which the injector will load before the current module is
2100           * loaded.
2101           */
2102          requires: requires,
2103
2104          /**
2105           * @ngdoc property
2106           * @name angular.Module#name
2107           * @module ng
2108           *

2109           * @description
2110           * Name of the module.
2111           */
2112          name: name,
2113
2114
2115          /**
2116           * @ngdoc method
2117           * @name angular.Module#provider
2118           * @module ng
2119           * @param {string} name service name
2120           * @param {Function} providerType Construction function for creating new instance of the
2121           *                                service.
2122           * @description
2123           * See {@link auto.$provide#provider $provide.provider()}.
2124           */
2125          provider: invokeLaterAndSetModuleName('$provide', 'provider'),
2126
2127          /**
2128           * @ngdoc method
2129           * @name angular.Module#factory
2130           * @module ng
2131           * @param {string} name service name
2132           * @param {Function} providerFunction Function for creating new instance of the service.
2133           * @description
2134           * See {@link auto.$provide#factory $provide.factory()}.
2135           */
2136          factory: invokeLaterAndSetModuleName('$provide', 'factory'),
2137
2138          /**
2139           * @ngdoc method
2140           * @name angular.Module#service
2141           * @module ng
2142           * @param {string} name service name
2143           * @param {Function} constructor A constructor function that will be instantiated.
2144           * @description
2145           * See {@link auto.$provide#service $provide.service()}.
2146           */
2147          service: invokeLaterAndSetModuleName('$provide', 'service'),
2148
2149          /**
2150           * @ngdoc method
2151           * @name angular.Module#value
2152           * @module ng
2153           * @param {string} name service name
2154           * @param {*} object Service instance object.
2155           * @description
2156           * See {@link auto.$provide#value $provide.value()}.
2157           */
2158          value: invokeLater('$provide', 'value'),
2159
2160          /**
2161           * @ngdoc method
2162           * @name angular.Module#constant
2163           * @module ng
2164           * @param {string} name constant name
2165           * @param {*} object Constant value.
2166           * @description
2167           * Because the constants are fixed, they get applied before other provide methods.
2168           * See {@link auto.$provide#constant $provide.constant()}.
2169           */
2170          constant: invokeLater('$provide', 'constant', 'unshift'),
2171
2172           /**
2173           * @ngdoc method
2174           * @name angular.Module#decorator
2175           * @module ng
2176           * @param {string} name The name of the service to decorate.
2177           * @param {Function} decorFn This function will be invoked when the service needs to be
2178           *                           instantiated and should return the decorated service instance.
2179           * @description
2180           * See {@link auto.$provide#decorator $provide.decorator()}.
2181           */
2182          decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
2183
2184          /**
2185           * @ngdoc method
2186           * @name angular.Module#animation
2187           * @module ng
2188           * @param {string} name animation name
2189           * @param {Function} animationFactory Factory function for creating new instance of an
2190           *                                    animation.
2191           * @description
2192           *
2193           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
2194           *
2195           *
2196           * Defines an animation hook that can be later used with
2197           * {@link $animate $animate} service and directives that use this service.
2198           *
2199           * ```js
2200           * module.animation('.animation-name', function($inject1, $inject2) {
2201           *   return {
2202           *     eventName : function(element, done) {
2203           *       //code to run the animation
2204           *       //once complete, then run done()
2205           *       return function cancellationFunction(element) {
2206           *         //code to cancel the animation
2207           *       }
2208           *     }
2209           *   }
2210           * })
2211           * ```
2212           *
2213           * See {@link ng.$animateProvider#register $animateProvider.register()} and
2214           * {@link ngAnimate ngAnimate module} for more information.
2215           */
2216          animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
2217
2218          /**
2219           * @ngdoc method
2220           * @name angular.Module#filter
2221           * @module ng
2222           * @param {string} name Filter name - this must be a valid angular expression identifier
2223           * @param {Function} filterFactory Factory function for creating new instance of filter.

2224           * @description
2225           * See {@link ng.$filterProvider#register $filterProvider.register()}.
2226           *
2227           * <div class="alert alert-warning">
2228           * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
2229           * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
2230           * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
2231           * (`myapp_subsection_filterx`).
2232           * </div>
2233           */
2234          filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
2235
2236          /**
2237           * @ngdoc method
2238           * @name angular.Module#controller
2239           * @module ng
2240           * @param {string|Object} name Controller name, or an object map of controllers where the
2241           *    keys are the names and the values are the constructors.
2242           * @param {Function} constructor Controller constructor function.
2243           * @description
2244           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
2245           */
2246          controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
2247
2248          /**
2249           * @ngdoc method
2250           * @name angular.Module#directive
2251           * @module ng
2252           * @param {string|Object} name Directive name, or an object map of directives where the
2253           *    keys are the names and the values are the factories.
2254           * @param {Function} directiveFactory Factory function for creating new instance of
2255           * directives.
2256           * @description
2257           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
2258           */
2259          directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
2260
2261          /**
2262           * @ngdoc method
2263           * @name angular.Module#component
2264           * @module ng
2265           * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
2266           * @param {Object} options Component definition object (a simplified
2267           *    {@link ng.$compile#directive-definition-object directive definition object})
2268           *
2269           * @description
2270           * See {@link ng.$compileProvider#component $compileProvider.component()}.
2271           */
2272          component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
2273
2274          /**
2275           * @ngdoc method
2276           * @name angular.Module#config
2277           * @module ng
2278           * @param {Function} configFn Execute this function on module load. Useful for service
2279           *    configuration.
2280           * @description
2281           * Use this method to register work which needs to be performed on module loading.
2282           * For more about how to configure services, see
2283           * {@link providers#provider-recipe Provider Recipe}.
2284           */
2285          config: config,
2286
2287          /**
2288           * @ngdoc method
2289           * @name angular.Module#run
2290           * @module ng
2291           * @param {Function} initializationFn Execute this function after injector creation.
2292           *    Useful for application initialization.
2293           * @description
2294           * Use this method to register work which should be performed when the injector is done
2295           * loading all modules.
2296           */
2297          run: function(block) {
2298            runBlocks.push(block);
2299            return this;
2300          }
2301        };
2302
2303        if (configFn) {
2304          config(configFn);
2305        }
2306
2307        return moduleInstance;
2308
2309        /**
2310         * @param {string} provider
2311         * @param {string} method
2312         * @param {String=} insertMethod
2313         * @returns {angular.Module}
2314         */
2315        function invokeLater(provider, method, insertMethod, queue) {
2316          if (!queue) queue = invokeQueue;
2317          return function() {
2318            queue[insertMethod || 'push']([provider, method, arguments]);
2319            return moduleInstance;
2320          };
2321        }
2322
2323        /**
2324         * @param {string} provider
2325         * @param {string} method
2326         * @returns {angular.Module}
2327         */

2328        function invokeLaterAndSetModuleName(provider, method) {
2329          return function(recipeName, factoryFunction) {
2330            if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
2331            invokeQueue.push([provider, method, arguments]);
2332            return moduleInstance;
2333          };
2334        }
2335      });
2336    };
2337  });
2338
2339}
2340
2341/* global: toDebugString: true */
2342
2343function serializeObject(obj) {
2344  var seen = [];
2345
2346  return JSON.stringify(obj, function(key, val) {
2347    val = toJsonReplacer(key, val);
2348    if (isObject(val)) {
2349
2350      if (seen.indexOf(val) >= 0) return '...';
2351
2352      seen.push(val);
2353    }
2354    return val;
2355  });
2356}
2357
2358function toDebugString(obj) {
2359  if (typeof obj === 'function') {
2360    return obj.toString().replace(/ \{[\s\S]*$/, '');
2361  } else if (isUndefined(obj)) {
2362    return 'undefined';
2363  } else if (typeof obj !== 'string') {
2364    return serializeObject(obj);
2365  }
2366  return obj;
2367}
2368
2369/* global angularModule: true,
2370  version: true,
2371
2372  $CompileProvider,
2373
2374  htmlAnchorDirective,
2375  inputDirective,
2376  inputDirective,
2377  formDirective,
2378  scriptDirective,
2379  selectDirective,
2380  styleDirective,
2381  optionDirective,
2382  ngBindDirective,
2383  ngBindHtmlDirective,
2384  ngBindTemplateDirective,
2385  ngClassDirective,
2386  ngClassEvenDirective,
2387  ngClassOddDirective,
2388  ngCloakDirective,
2389  ngControllerDirective,
2390  ngFormDirective,
2391  ngHideDirective,
2392  ngIfDirective,
2393  ngIncludeDirective,
2394  ngIncludeFillContentDirective,
2395  ngInitDirective,
2396  ngNonBindableDirective,
2397  ngPluralizeDirective,
2398  ngRepeatDirective,
2399  ngShowDirective,
2400  ngStyleDirective,
2401  ngSwitchDirective,
2402  ngSwitchWhenDirective,
2403  ngSwitchDefaultDirective,
2404  ngOptionsDirective,
2405  ngTranscludeDirective,
2406  ngModelDirective,
2407  ngListDirective,
2408  ngChangeDirective,
2409  patternDirective,
2410  patternDirective,
2411  requiredDirective,
2412  requiredDirective,
2413  minlengthDirective,
2414  minlengthDirective,
2415  maxlengthDirective,
2416  maxlengthDirective,
2417  ngValueDirective,
2418  ngModelOptionsDirective,
2419  ngAttributeAliasDirectives,
2420  ngEventDirectives,
2421
2422  $AnchorScrollProvider,
2423  $AnimateProvider,
2424  $CoreAnimateCssProvider,
2425  $$CoreAnimateJsProvider,
2426  $$CoreAnimateQueueProvider,
2427  $$AnimateRunnerFactoryProvider,
2428  $$AnimateAsyncRunFactoryProvider,
2429  $BrowserProvider,
2430  $CacheFactoryProvider,
2431  $ControllerProvider,
2432  $DateProvider,
2433  $DocumentProvider,
2434  $ExceptionHandlerProvider,
2435  $FilterProvider,
2436  $$ForceReflowProvider,
2437  $InterpolateProvider,
2438  $IntervalProvider,
2439  $$HashMapProvider,
2440  $HttpProvider,
2441  $HttpParamSerializerProvider,
2442  $HttpParamSerializerJQLikeProvider,
2443  $HttpBackendProvider,
2444  $xhrFactoryProvider,
2445  $LocationProvider,
2446  $LogProvider,
2447  $ParseProvider,
2448  $RootScopeProvider,
2449  $QProvider,
2450  $$QProvider,
2451  $$SanitizeUriProvider,
2452  $SceProvider,
2453  $SceDelegateProvider,
2454  $SnifferProvider,
2455  $TemplateCacheProvider,
2456  $TemplateRequestProvider,
2457  $$TestabilityProvider,
2458  $TimeoutProvider,
2459  $$RAFProvider,
2460  $WindowProvider,
2461  $$jqLiteProvider,
2462  $$CookieReaderProvider
2463*/
2464
2465
2466/**
2467 * @ngdoc object
2468 * @name angular.version
2469 * @module ng
2470 * @description
2471 * An object that contains information about the current AngularJS version.
2472 *
2473 * This object has the following properties:
2474 *
2475 * - `full` – `{string}` – Full version string, such as "0.9.18".
2476 * - `major` – `{number}` – Major version number, such as "0".
2477 * - `minor` – `{number}` – Minor version number, such as "9".
2478 * - `dot` – `{number}` – Dot version number, such as "18".
2479 * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
2480 */
2481var version = {
2482  full: '1.5.5',    // all of these placeholder strings will be replaced by grunt's
2483  major: 1,    // package task
2484  minor: 5,
2485  dot: 5,
2486  codeName: 'material-conspiration'
2487};
2488
2489
2490function publishExternalAPI(angular) {
2491  extend(angular, {
2492    'bootstrap': bootstrap,
2493    'copy': copy,
2494    'extend': extend,
2495    'merge': merge,
2496    'equals': equals,
2497    'element': jqLite,
2498    'forEach': forEach,
2499    'injector': createInjector,
2500    'noop': noop,
2501    'bind': bind,
2502    'toJson': toJson,
2503    'fromJson': fromJson,
2504    'identity': identity,
2505    'isUndefined': isUndefined,
2506    'isDefined': isDefined,
2507    'isString': isString,
2508    'isFunction': isFunction,
2509    'isObject': isObject,
2510    'isNumber': isNumber,
2511    'isElement': isElement,
2512    'isArray': isArray,
2513    'version': version,
2514    'isDate': isDate,
2515    'lowercase': lowercase,
2516    'uppercase': uppercase,
2517    'callbacks': {counter: 0},
2518    'getTestability': getTestability,
2519    '$$minErr': minErr,
2520    '$$csp': csp,
2521    'reloadWithDebugInfo': reloadWithDebugInfo
2522  });
2523
2524  angularModule = setupModuleLoader(window);
2525
2526  angularModule('ng', ['ngLocale'], ['$provide',
2527    function ngModule($provide) {

2528      // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
2529      $provide.provider({
2530        $$sanitizeUri: $$SanitizeUriProvider
2531      });
2532      $provide.provider('$compile', $CompileProvider).
2533        directive({
2534            a: htmlAnchorDirective,
2535            input: inputDirective,
2536            textarea: inputDirective,
2537            form: formDirective,
2538            script: scriptDirective,
2539            select: selectDirective,
2540            style: styleDirective,
2541            option: optionDirective,
2542            ngBind: ngBindDirective,
2543            ngBindHtml: ngBindHtmlDirective,
2544            ngBindTemplate: ngBindTemplateDirective,
2545            ngClass: ngClassDirective,
2546            ngClassEven: ngClassEvenDirective,
2547            ngClassOdd: ngClassOddDirective,
2548            ngCloak: ngCloakDirective,
2549            ngController: ngControllerDirective,
2550            ngForm: ngFormDirective,
2551            ngHide: ngHideDirective,
2552            ngIf: ngIfDirective,
2553            ngInclude: ngIncludeDirective,
2554            ngInit: ngInitDirective,
2555            ngNonBindable: ngNonBindableDirective,
2556            ngPluralize: ngPluralizeDirective,
2557            ngRepeat: ngRepeatDirective,
2558            ngShow: ngShowDirective,
2559            ngStyle: ngStyleDirective,
2560            ngSwitch: ngSwitchDirective,
2561            ngSwitchWhen: ngSwitchWhenDirective,
2562            ngSwitchDefault: ngSwitchDefaultDirective,
2563            ngOptions: ngOptionsDirective,
2564            ngTransclude: ngTranscludeDirective,
2565            ngModel: ngModelDirective,
2566            ngList: ngListDirective,
2567            ngChange: ngChangeDirective,
2568            pattern: patternDirective,
2569            ngPattern: patternDirective,
2570            required: requiredDirective,
2571            ngRequired: requiredDirective,
2572            minlength: minlengthDirective,
2573            ngMinlength: minlengthDirective,
2574            maxlength: maxlengthDirective,
2575            ngMaxlength: maxlengthDirective,
2576            ngValue: ngValueDirective,
2577            ngModelOptions: ngModelOptionsDirective
2578        }).
2579        directive({
2580          ngInclude: ngIncludeFillContentDirective
2581        }).
2582        directive(ngAttributeAliasDirectives).
2583        directive(ngEventDirectives);
2584      $provide.provider({
2585        $anchorScroll: $AnchorScrollProvider,
2586        $animate: $AnimateProvider,
2587        $animateCss: $CoreAnimateCssProvider,
2588        $$animateJs: $$CoreAnimateJsProvider,
2589        $$animateQueue: $$CoreAnimateQueueProvider,
2590        $$AnimateRunner: $$AnimateRunnerFactoryProvider,
2591        $$animateAsyncRun: $$AnimateAsyncRunFactoryProvider,
2592        $browser: $BrowserProvider,
2593        $cacheFactory: $CacheFactoryProvider,
2594        $controller: $ControllerProvider,
2595        $document: $DocumentProvider,
2596        $exceptionHandler: $ExceptionHandlerProvider,
2597        $filter: $FilterProvider,
2598        $$forceReflow: $$ForceReflowProvider,
2599        $interpolate: $InterpolateProvider,
2600        $interval: $IntervalProvider,
2601        $http: $HttpProvider,
2602        $httpParamSerializer: $HttpParamSerializerProvider,
2603        $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
2604        $httpBackend: $HttpBackendProvider,
2605        $xhrFactory: $xhrFactoryProvider,
2606        $location: $LocationProvider,
2607        $log: $LogProvider,
2608        $parse: $ParseProvider,
2609        $rootScope: $RootScopeProvider,
2610        $q: $QProvider,
2611        $$q: $$QProvider,
2612        $sce: $SceProvider,
2613        $sceDelegate: $SceDelegateProvider,
2614        $sniffer: $SnifferProvider,
2615        $templateCache: $TemplateCacheProvider,
2616        $templateRequest: $TemplateRequestProvider,
2617        $$testability: $$TestabilityProvider,
2618        $timeout: $TimeoutProvider,
2619        $window: $WindowProvider,
2620        $$rAF: $$RAFProvider,
2621        $$jqLite: $$jqLiteProvider,
2622        $$HashMap: $$HashMapProvider,
2623        $$cookieReader: $$CookieReaderProvider
2624      });
2625    }
2626  ]);
2627}
2628
2629/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2630 *     Any commits to this file should be reviewed with security in mind.  *
2631 *   Changes to this file can potentially create security vulnerabilities. *
2632 *          An approval from 2 Core members with history of modifying      *
2633 *                         this file is required.                          *
2634 *                                                                         *
2635 *  Does the change somehow allow for arbitrary javascript to be executed? *
2636 *    Or allows for someone to change the prototype of built-in objects?   *
2637 *     Or gives undesired access to variables likes document or window?    *
2638 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2639

2640/* global JQLitePrototype: true,
2641  addEventListenerFn: true,
2642  removeEventListenerFn: true,
2643  BOOLEAN_ATTR: true,
2644  ALIASED_ATTR: true,
2645*/
2646
2647//////////////////////////////////
2648//JQLite
2649//////////////////////////////////
2650
2651/**
2652 * @ngdoc function
2653 * @name angular.element
2654 * @module ng
2655 * @kind function
2656 *
2657 * @description
2658 * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
2659 *
2660 * If jQuery is available, `angular.element` is an alias for the
2661 * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
2662 * delegates to Angular's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
2663 *
2664 * jqLite is a tiny, API-compatible subset of jQuery that allows
2665 * Angular to manipulate the DOM in a cross-browser compatible way. jqLite implements only the most
2666 * commonly needed functionality with the goal of having a very small footprint.
2667 *
2668 * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
2669 * {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
2670 * specific version of jQuery if multiple versions exist on the page.
2671 *
2672 * <div class="alert alert-info">**Note:** All element references in Angular are always wrapped with jQuery or
2673 * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
2674 *
2675 * <div class="alert alert-warning">**Note:** Keep in mind that this function will not find elements
2676 * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
2677 * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
2678 *
2679 * ## Angular's jqLite
2680 * jqLite provides only the following jQuery methods:
2681 *
2682 * - [`addClass()`](http://api.jquery.com/addClass/)
2683 * - [`after()`](http://api.jquery.com/after/)
2684 * - [`append()`](http://api.jquery.com/append/)
2685 * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
2686 * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
2687 * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
2688 * - [`clone()`](http://api.jquery.com/clone/)
2689 * - [`contents()`](http://api.jquery.com/contents/)
2690 * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`.
2691 *   As a setter, does not convert numbers to strings or append 'px', and also does not have automatic property prefixing.
2692 * - [`data()`](http://api.jquery.com/data/)
2693 * - [`detach()`](http://api.jquery.com/detach/)
2694 * - [`empty()`](http://api.jquery.com/empty/)
2695 * - [`eq()`](http://api.jquery.com/eq/)
2696 * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
2697 * - [`hasClass()`](http://api.jquery.com/hasClass/)
2698 * - [`html()`](http://api.jquery.com/html/)
2699 * - [`next()`](http://api.jquery.com/next/) - Does not support selectors
2700 * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
2701 * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
2702 * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
2703 * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
2704 * - [`prepend()`](http://api.jquery.com/prepend/)
2705 * - [`prop()`](http://api.jquery.com/prop/)
2706 * - [`ready()`](http://api.jquery.com/ready/)
2707 * - [`remove()`](http://api.jquery.com/remove/)
2708 * - [`removeAttr()`](http://api.jquery.com/removeAttr/)
2709 * - [`removeClass()`](http://api.jquery.com/removeClass/)
2710 * - [`removeData()`](http://api.jquery.com/removeData/)
2711 * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
2712 * - [`text()`](http://api.jquery.com/text/)
2713 * - [`toggleClass()`](http://api.jquery.com/toggleClass/)
2714 * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
2715 * - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces or event object as parameter
2716 * - [`val()`](http://api.jquery.com/val/)
2717 * - [`wrap()`](http://api.jquery.com/wrap/)
2718 *
2719 * ## jQuery/jqLite Extras
2720 * Angular also provides the following additional methods and events to both jQuery and jqLite:
2721 *
2722 * ### Events
2723 * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction a