https://www.niosa.org/js/angular/angular.js?sv=8.6.3

1/**
2 * @license AngularJS v1.5.0-rc.1
3 * (c) 2010-2016 Google, Inc. http://angularjs.org
4 * License: MIT
5 */
6(function(window, document, undefined) {'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.0-rc.1/' +
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 * @description
175 *
176 * # ng (core module)
177 * The ng module is loaded by default when an AngularJS application is started. The module itself
178 * contains the essential components for an AngularJS application to function. The table below
179 * lists a high level breakdown of each of the services/factories, filters, directives and testing
180 * components available within this core module.
181 *
182 * <div doc-module-components="ng"></div>
183 */
184
185var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
186
187// The name of a form control's ValidityState property.
188// This is used so that it's possible for internal tests to create mock ValidityStates.
189var VALIDITY_STATE_PROPERTY = 'validity';
190
191/**
192 * @ngdoc function
193 * @name angular.lowercase
194 * @module ng
195 * @kind function
196 *
197 * @description Converts the specified string to lowercase.
198 * @param {string} string String to be converted to lowercase.
199 * @returns {string} Lowercased string.
200 */
201var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
202var hasOwnProperty = Object.prototype.hasOwnProperty;
203
204/**
205 * @ngdoc function
206 * @name angular.uppercase
207 * @module ng
208 * @kind function
209 *
210 * @description Converts the specified string to uppercase.
211 * @param {string} string String to be converted to uppercase.
212 * @returns {string} Uppercased string.
213 */
214var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
215
216
217var manualLowercase = function(s) {
218  /* jshint bitwise: false */
219  return isString(s)
220      ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCo

220deAt(0) | 32);})
221      : s;
222};
223var manualUppercase = function(s) {
224  /* jshint bitwise: false */
225  return isString(s)
226      ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
227      : s;
228};
229
230
231// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
232// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
233// with correct but slower alternatives.
234if ('i' !== 'I'.toLowerCase()) {
235  lowercase = manualLowercase;
236  uppercase = manualUppercase;
237}
238
239
240var
241    msie,             // holds major version number for IE, or NaN if UA is not IE.
242    jqLite,           // delay binding since jQuery could be loaded after us.
243    jQuery,           // delay binding
244    slice             = [].slice,
245    splice            = [].splice,
246    push              = [].push,
247    toString          = Object.prototype.toString,
248    getPrototypeOf    = Object.getPrototypeOf,
249    ngMinErr          = minErr('ng'),
250
251    /** @name angular */
252    angular           = window.angular || (window.angular = {}),
253    angularModule,
254    uid               = 0;
255
256/**
257 * documentMode is an IE-only property
258 * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
259 */
260msie = document.documentMode;
261
262
263/**
264 * @private
265 * @param {*} obj
266 * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
267 *                   String ...)
268 */
269function isArrayLike(obj) {
270
271  // `null`, `undefined` and `window` are not array-like
272  if (obj == null || isWindow(obj)) return false;
273
274  // arrays, strings and jQuery/jqLite objects are array like
275  // * jqLite is either the jQuery or jqLite constructor function
276  // * we have to check the existence of jqLite first as this method is called
277  //   via the forEach method when constructing the jqLite object in the first place
278  if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
279

280  // Support: iOS 8.2 (not reproducible in simulator)
281  // "length" in obj used to prevent JIT error (gh-11508)
282  var length = "length" in Object(obj) && obj.length;
283
284  // NodeList objects (with `item` method) and
285  // other objects with suitable length characteristics are array-like
286  return isNumber(length) &&
287    (length >= 0 && ((length - 1) in obj || obj instanceof Array) || typeof obj.item == 'function');
288
289}
290
291/**
292 * @ngdoc function
293 * @name angular.forEach
294 * @module ng
295 * @kind function
296 *
297 * @description
298 * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
299 * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
300 * is the value of an object property or an array element, `key` is the object property key or
301 * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
302 *
303 * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
304 * using the `hasOwnProperty` method.
305 *
306 * Unlike ES262's
307 * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
308 * Providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
309 * return the value provided.
310 *
311   ```js
312     var values = {name: 'misko', gender: 'male'};
313     var log = [];
314     angular.forEach(values, function(value, key) {
315       this.push(key + ': ' + value);
316     }, log);
317     expect(log).toEqual(['name: misko', 'gender: male']);
318   ```
319 *
320 * @param {Object|Array} obj Object to iterate over.
321 * @param {Function} iterator Iterator function.
322 * @param {Object=} context Object to become context (`this`) for the iterator function.
323 * @returns {Object|Array} Reference to `obj`.
324 */
325
326function forEach(obj, iterator, context) {
327  var key, length;
328  if (obj) {
329    if (isFunction(obj)) {
330      for (key in obj) {
331        // Need to check if hasOwnProperty exists,
332        // as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function
333        if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) {
334          iterator.call(context, obj[key], key, obj);
335        }
336      }
337    } else if (isArray(obj) || isArrayLike(obj)) {
338      var isPrimitive = typeof obj !== 'object';
339      for (key = 0, length = obj.length; key < length; key++) {
340        if (isPrimitive || key in obj) {
341          iterator.call(context, obj[key], key, obj);
342        }
343      }
344    } else if (obj.forEach && obj.forEach !== forEach) {
345        obj.forEach(iterator, context, obj);
346    } else if (isBlankObject(obj)) {
347      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
348      for (key in obj) {
349        iterator.call(context, obj[key], key, obj);
350      }
351    } else if (typeof obj.hasOwnProperty === 'function') {
352      // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
353      for (key in obj) {
354        if (obj.hasOwnProperty(key)) {
355          iterator.call(context, obj[key], key, obj);
356        }
357      }
358    } else {
359      // Slow path for objects which do not have a method `hasOwnProperty`
360      for (key in obj) {
361        if (hasOwnProperty.call(obj, key)) {
362          iterator.call(context, obj[key], key, obj);
363        }
364      }
365    }
366  }
367  return obj;
368}
369
370function forEachSorted(obj, iterator, context) {
371  var keys = Object.keys(obj).sort();
372  for (var i = 0; i < keys.length; i++) {
373    iterator.call(context, obj[keys[i]], keys[i]);
374  }
375  return keys;
376}
377
378
379/**
380 * when using forEach the params are value, key, but it is often useful to have key, value.
381 * @param {function(string, *)} iteratorFn
382 * @returns {function(*, string)}
383 */
384function reverseParams(iteratorFn) {
385  return function(value, key) { iteratorFn(key, value); };
386}
387
388/**
389 * A consistent way of creating unique IDs in angular.
390 *
391 * Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before
392 * we hit number precision issues in JavaScript.
393 *
394 * Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M
395 *
396 * @returns {number}

396 an unique alpha-numeric string
397 */
398function nextUid() {
399  return ++uid;
400}
401
402
403/**
404 * Set or clear the hashkey for an object.
405 * @param obj object
406 * @param h the hashkey (!truthy to delete the hashkey)
407 */
408function setHashKey(obj, h) {
409  if (h) {
410    obj.$$hashKey = h;
411  } else {
412    delete obj.$$hashKey;
413  }
414}
415
416
417function baseExtend(dst, objs, deep) {
418  var h = dst.$$hashKey;
419
420  for (var i = 0, ii = objs.length; i < ii; ++i) {
421    var obj = objs[i];
422    if (!isObject(obj) && !isFunction(obj)) continue;
423    var keys = Object.keys(obj);
424    for (var j = 0, jj = keys.length; j < jj; j++) {
425      var key = keys[j];
426      var src = obj[key];
427
428      if (deep && isObject(src)) {
429        if (isDate(src)) {
430          dst[key] = new Date(src.valueOf());
431        } else if (isRegExp(src)) {
432          dst[key] = new RegExp(src);
433        } else if (src.nodeName) {
434          dst[key] = src.cloneNode(true);
435        } else if (isElement(src)) {
436          dst[key] = src.clone();
437        } else {
438          if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
439          baseExtend(dst[key], [src], true);
440        }
441      } else {
442        dst[key] = src;
443      }
444    }
445  }
446
447  setHashKey(dst, h);
448  return dst;
449}
450
451/**
452 * @ngdoc function
453 * @name angular.extend
454 * @module ng
455 * @kind function
456 *
457 * @description
458 * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
459 * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
460 * by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
461 *
462 * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
463 * {@link angular.merge} for this.
464 *
465 * @param {Object} dst Destination object.
466 * @param {...Object} src Source object(s).
467 * @returns {Object} Reference to `dst`.
468 */
469function extend(dst) {
470  return baseExtend(dst, slice.call(arguments, 1), false);
471}
472
473
474/**
475* @ngdoc function
476* @name angular.merge
477* @module ng
478* @kind function
479*
480* @description
481* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
482* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
483* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.
484*
485* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
486* objects, performing a deep copy.
487*
488* @param {Object} dst Destination object.
489* @param {...Object} src Source object(s).
490* @returns {Object} Reference to `dst`.
491*/
492function merge(dst) {
493  return baseExtend(dst, slice.call(arguments, 1), true);
494}
495
496
497
498function toInt(str) {
499  return parseInt(str, 10);
500}
501
502
503function inherit(parent, extra) {
504  return extend(Object.create(parent), extra);
505}
506
507/**
508 * @ngdoc function
509 * @name angular.noop
510 * @module ng
511 * @kind function
512 *
513 * @description
514 * A function that performs no operations. This function can be useful when writing code in the
515 * functional style.
516   ```js
517     function foo(callback) {
518       var result = calculateResult();
519       (callback || angular.noop)(result);
520     }
521   ```
522 */
523function noop() {}
524noop.$inject = [];
525
526
527/**
528 * @ngdoc function
529 * @name angular.identity
530 * @module ng
531 * @kind function
532 *
533 * @description
534 * A function that returns its first argument. This function is useful when writing code in the
535 * functional style.
536 *
537   ```js
538     function transformer(transformationFn, value) {
539       return (transformationFn || angular.identity)(value);
540     };
541   ```
542  * @param {*} value to be returned.
543  * @returns {*} the value passed in.
544 */
545function identity($) {return $;}
546identity.$inject = [];
547
548
549function valueFn(value) {return function() {return value;};}
550
551function hasCustomToString(obj) {
552  return isFunction(obj.toString) && obj.toString !== toString;
553}
554
555
556/**
557 * @ngdoc function
558 * @name angular.isUndefined
559 * @module ng
560 * @kind function
561 *
562 * @description
563 * Determines if a reference is undefined.
564 *
565 * @param {*} value Reference to check.
566 * @returns {boolean} True if `value` is undefined.
567 */
568function isUndefined(value) {return typeof value === 'undefined';}
569
570
571/**
572 * @ngdoc function
573 * @name angular.isDefined
574 * @module ng
575 * @kind function
576 *
577 * @description
578 * Determines if a reference is defined.
579 *
580 * @param {*} value Reference to check.
581 * @returns {boolean} True if `value` is defined.
582 */
583function isDefined(value) {return typeof value !== 'undefined';}
584
585
586/**
587 * @ngdoc function
588 * @name angular.isObject
589 * @module ng
590 * @kind function
591 *
592 * @description
593 * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
594 * considered to be objects. Note that JavaScript arrays are objects.
595 *
596 * @param {*} value Reference to check.
597 * @returns {boolean} True if `value` is an `Object` but not `null`.
598 */
599function isObject(value) {
600  // http://jsperf.com/isobject4
601  return value !== null && typeof value === 'object';
602}
603
604
605/**
606 * Determine if a value is an object with a null prototype
607 *
608 * @returns {boolean} True if `value` is an `Object` with a null prototype
609 */
610function isBlankObject(value) {
611  return value !== null && typeof value === 'object' && !getPrototypeOf(value);
612}
613
614
615/**
616 * @ngdoc function
617 * @name angular.isString
618 * @module ng
619 * @kind function
620 *
621 * @description
622 * Determines if a reference is a `String`.
623 *
624 * @param {*} value Reference to check.
625 * @returns {boolean} True if `value` is a `String`.
626 */
627function isString(value) {return typeof value === 'string';}
628
629
630/**
631 * @ngdoc function
632 * @name angular.isNumber
633 * @module ng
634 * @kind function
635 *
636 * @description
637 * Determines if a reference is a `Number`.
638 *
639 * This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`.
640 *
641 * If you wish to exclude these then you can use the native
642 * [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
643 * method.
644 *
645 * @param {*} value Reference to check.
646 * @returns {boolean} True if `value` is a `Number`.
647 */
648function isNumber(value) {return typeof value === 'number';}
649
650
651/**
652 * @ngdoc function
653 * @name angular.isDate
654 * @module ng
655 * @kind function
656 *
657 * @description
658 * Determines if a value is a date.
659 *
660 * @param {*} value Reference to check.
661 * @returns {boolean} True if `value` is a `Date`.
662 */
663function isDate(value) {
664  return toString.call(value) === '[object Date]';
665}
666
667
668/**
669 * @ngdoc function
670 * @name angular.isArray
671 * @module ng
672 * @kind function
673 *
674 * @description
675 * Determines if a reference is an `Array`.
676 *
677 * @param {*} value Reference to check.
678 * @returns {boolean} True if `value` is an `Array`.
679 */
680var isArray = Array.isArray;
681
682/**
683 * @ngdoc function
684 * @name angular.isFunction
685 * @module ng
686 * @kind function
687 *
688 * @description
689 * Determines if a reference is a `Function`.
690 *
691 * @param {*} value Reference to check.
692 * @returns {boolean} True if `value` is a `Function`.
693 */
694function isFunction(value) {return typeof value === 'function';}
695
696
697/**
698 * Determines if a value is a regular expression object.
699 *
700 * @private
701 * @param {*} value Reference to check.
702 * @returns {boolean} True if `value` is a `RegExp`.
703 */
704function isRegExp(value) {
705  return toString.call(value) === '[object RegExp]';
706}
707
708
709/**
710 * Checks if `obj` is a window object.
711 *
712 * @private
713 * @param {*} obj Object to check
714 * @returns {boolean} True if `obj` is a window obj.
715 */
716function isWindow(obj) {
717  return obj && obj.window === obj;
718}
719
720
721function isScope(obj) {
722  return obj && obj.$evalAsync && obj.$watch;
723}
724
725
726function isFile(obj) {
727  return toString.call(obj) === '[object File]';
728}
729
730
731function isFormData(obj) {
732  return toString.call(obj) === '[object FormData]';
733}
734
735
736function isBlob(obj) {
737  return toString.call(obj) === '[object Blob]';
738}
739
740
741function isBoolean(value) {
742  return typeof value === 'boolean';
743}
744
745
746function isPromiseLike(obj) {
747  return obj && isFunction(obj.then);
748}
749
750
751var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array\]$/;
752function isTypedArray(value) {
753  return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
754}
755
756function isArrayBuffer(obj) {
757  return toString.call(obj) === '[object ArrayBuffer]';
758}
759
760
761var trim = function(value) {
762  return isString(value) ? value.trim() : value;
763};
764
765// Copied from:
766// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
767// Prereq: s is a string.
768var escapeForRegexp = function(s) {
769  return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
770           replace(/\x08/g, '\\x08');
771};

772
773
774/**
775 * @ngdoc function
776 * @name angular.isElement
777 * @module ng
778 * @kind function
779 *
780 * @description
781 * Determines if a reference is a DOM element (or wrapped jQuery element).
782 *
783 * @param {*} value Reference to check.
784 * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
785 */
786function isElement(node) {
787  return !!(node &&
788    (node.nodeName  // we are a direct element
789    || (node.prop && node.attr && node.find)));  // we have an on and find method part of jQuery API
790}
791
792/**
793 * @param str 'key1,key2,...'
794 * @returns {object} in the form of {key1:true, key2:true, ...}
795 */
796function makeMap(str) {
797  var obj = {}, items = str.split(","), i;
798  for (i = 0; i < items.length; i++) {
799    obj[items[i]] = true;
800  }
801  return obj;
802}
803
804
805function nodeName_(element) {
806  return lowercase(element.nodeName || (element[0] && element[0].nodeName));
807}
808
809function includes(array, obj) {
810  return Array.prototype.indexOf.call(array, obj) != -1;
811}
812
813function arrayRemove(array, value) {
814  var index = array.indexOf(value);
815  if (index >= 0) {
816    array.splice(index, 1);
817  }
818  return index;
819}
820
821/**
822 * @ngdoc function
823 * @name angular.copy
824 * @module ng
825 * @kind function
826 *
827 * @description
828 * Creates a deep copy of `source`, which should be an object or an array.
829 *
830 * * If no destination is supplied, a copy of the object or array is created.
831 * * If a destination is provided, all of its elements (for arrays) or properties (for objects)
832 *   are deleted and then all elements/properties from the source are copied to it.
833 * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
834 * * If `source` is identical to 'destination' an exception will be thrown.
835 *
836 * @param {*} source The source that will be used to make a copy.
837 *                   Can be any type, including primitives, `null`, and `undefined`.
838 * @param {(Object|Array)=} destination Destination into which the source is copied. If
839 *     provided, must be of the same type as `source`.
840 * @returns {*} The copy or updated `destination`, if `destination` was specified.
841 *
842 * @example
843 <example module="copyExample">
844 <file name="index.html">

845 <div ng-controller="ExampleController">
846 <form novalidate class="simple-form">
847 Name: <input type="text" ng-model="user.name" /><br />
848 E-mail: <input type="email" ng-model="user.email" /><br />
849 Gender: <input type="radio" ng-model="user.gender" value="male" />male
850 <input type="radio" ng-model="user.gender" value="female" />female<br />
851 <button ng-click="reset()">RESET</button>
852 <button ng-click="update(user)">SAVE</button>
853 </form>
854 <pre>form = {{user | json}}</pre>
855 <pre>master = {{master | json}}</pre>
856 </div>
857
858 <script>
859  angular.module('copyExample', [])
860    .controller('ExampleController', ['$scope', function($scope) {
861      $scope.master= {};
862
863      $scope.update = function(user) {
864        // Example with 1 argument
865        $scope.master= angular.copy(user);
866      };
867
868      $scope.reset = function() {
869        // Example with 2 arguments
870        angular.copy($scope.master, $scope.user);
871      };
872
873      $scope.reset();
874    }]);
875 </script>
876 </file>
877 </example>
878 */
879function copy(source, destination) {
880  var stackSource = [];
881  var stackDest = [];
882
883  if (destination) {
884    if (isTypedArray(destination) || isArrayBuffer(destination)) {
885      throw ngMinErr('cpta', "Can't copy! TypedArray destination cannot be mutated.");
886    }
887    if (source === destination) {
888      throw ngMinErr('cpi', "Can't copy! Source and destination are identical.");
889    }
890
891    // Empty the destination object
892    if (isArray(destination)) {
893      destination.length = 0;
894    } else {
895      forEach(destination, function(value, key) {
896        if (key !== '$$hashKey') {
897          delete destination[key];
898        }
899      });
900    }
901
902    stackSource.push(source);
903    stackDest.push(destination);
904    return copyRecurse(source, destination);
905  }
906
907  return copyElement(source);
908
909  function copyRecurse(source, destination) {
910    var h = destination.$$hashKey;
911    var result, key;
912    if (isArray(source)) {
913      for (var i = 0, ii = source.length; i < ii; i++) {
914        destination.push(copyElement(source[i]));
915      }
916    } else if (isBlankObject(source)) {
917      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
918      for (key in source) {
919        destination[key] = copyElement(source[key]);
920      }
921    } else if (source && typeof source.hasOwnProperty === 'function') {
922      // Slow path, which must rely on hasOwnProperty
923      for (key in source) {
924        if (source.hasOwnProperty(key)) {
925          destination[key] = copyElement(source[key]);
926        }
927      }
928    } else {
929      // Slowest path --- hasOwnProperty can't be called as a method
930      for (key in source) {
931        if (hasOwnProperty.call(source, key)) {
932          destination[key] = copyElement(source[key]);
933        }
934      }
935    }
936    setHashKey(destination, h);
937    return destination;
938  }
939
940  function copyElement(source) {
941    // Simple values
942    if (!isObject(source)) {
943      return source;
944    }
945
946    // Already copied values
947    var index = stackSource.indexOf(source);
948    if (index !== -1) {
949      return stackDest[index];
950    }
951
952    if (isWindow(source) || isScope(source)) {
953      throw ngMinErr('cpws',
954        "Can't copy! Making copies of Window or Scope instances is not supported.");
955    }
956
957    var needsRecurse = false;
958    var destination = copyType(source);
959
960    if (destination === undefined) {
961      destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
962      needsRecurse = true;
963    }
964
965    stackSource.push(source);
966    stackDest.push(destination);
967
968    return needsRecurse
969      ? copyRecurse(source, destination)
970      : destination;
971  }
972
973  function copyType(source) {
974    switch (toString.call(source)) {
975      case '[object Int8Array]':
976      case '[object Int16Array]':
977      case '[object Int32Array]':
978      case '[object Float32Array]':
979      case '[object Float64Array]':
980      case '[object Uint8Array]':
981      case '[object Uint8ClampedArray]':
982      case '[object Uint16Array]':
983      case '[object Uint32Array]':
984        return new source.constructor(copyElement(source.buffer));
985
986      case '[object ArrayBuffer]':
987        //Support: IE10
988        if (!source.slice) {
989          var copied = new ArrayBuffer(source.byteLength);
990          new Uint8Array(copied).set(new Uint8Array(source));
991          return copied;
992        }
993        return source.slice(0);
994
995      case '[object Boolean]':
996      case '[object Number]':
997      case '[object String]':
998      case '[object Date]':
999        return new source.constructor(source.valueOf());
1000
1001      case '[object RegExp]':
1002        var re = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
1003        re.lastIndex = source.lastIndex;
1004        return re;
1005    }
1006
1007    if (isFunction(source.cloneNode)) {
1008      return source.cloneNode(true);
1009    }
1010  }
1011}
1012
1013/**
1014 * Creates a shallow copy of an object, an array or a primitive.
1015 *
1016 * Assumes that there are no proto properties for objects.
1017 */
1018function shallowCopy(src, dst) {
1019  if (isArray(src)) {
1020    dst = dst || [];
1021
1022    for (var i = 0, ii = src.length; i < ii; i++) {
1023      dst[i] = src[i];

1024    }
1025  } else if (isObject(src)) {
1026    dst = dst || {};
1027
1028    for (var key in src) {
1029      if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
1030        dst[key] = src[key];
1031      }
1032    }
1033  }
1034
1035  return dst || src;
1036}
1037
1038
1039/**
1040 * @ngdoc function
1041 * @name angular.equals
1042 * @module ng
1043 * @kind function
1044 *
1045 * @description
1046 * Determines if two objects or two values are equivalent. Supports value types, regular
1047 * expressions, arrays and objects.
1048 *
1049 * Two objects or values are considered equivalent if at least one of the following is true:
1050 *
1051 * * Both objects or values pass `===` comparison.
1052 * * Both objects or values are of the same type and all of their properties are equal by
1053 *   comparing them with `angular.equals`.
1054 * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
1055 * * Both values represent the same regular expression (In JavaScript,
1056 *   /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
1057 *   representation matches).
1058 *
1059 * During a property comparison, properties of `function` type and properties with names
1060 * that begin with `$` are ignored.
1061 *
1062 * Scope and DOMWindow objects are being compared only by identify (`===`).
1063 *
1064 * @param {*} o1 Object or value to compare.
1065 * @param {*} o2 Object or value to compare.
1066 * @returns {boolean} True if arguments are equal.
1067 */
1068function equals(o1, o2) {
1069  if (o1 === o2) return true;
1070  if (o1 === null || o2 === null) return false;
1071  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
1072  var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
1073  if (t1 == t2) {
1074    if (t1 == 'object') {
1075      if (isArray(o1)) {
1076        if (!isArray(o2)) return false;
1077        if ((length = o1.length) == o2.length) {
1078          for (key = 0; key < length; key++) {
1079            if (!equals(o1[key], o2[key])) return false;
1080          }
1081          return true;
1082        }
1083      } else if (isDate(o1)) {
1084        if (!isDate(o2)) return false;
1085        return equals(o1.getTime(), o2.getTime());
1086      } else if (isRegExp(o1)) {
1087        return isRegExp(o2) ? o1.toString() == o2.toString() : false;
1088      } else {
1089        if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
1090          isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
1091        keySet = createMap();
1092        for (key in o1) {
1093          if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
1094          if (!equals(o1[key], o2[key])) return false;
1095          keySet[key] = true;
1096        }
1097        for (key in o2) {
1098          if (!(key in keySet) &&
1099              key.charAt(0) !== '$' &&
1100              isDefined(o2[key]) &&
1101              !isFunction(o2[key])) return false;
1102        }
1103        return true;
1104      }
1105    }
1106  }
1107  return false;
1108}
1109
1110var csp = function() {
1111  if (!isDefined(csp.rules)) {
1112
1113
1114    var ngCspElement = (document.querySelector('[ng-csp]') ||
1115                    document.querySelector('[data-ng-csp]'));
1116
1117    if (ngCspElement) {
1118      var ngCspAttribute = ngCspElement.getAttribute('ng-csp') ||
1119                    ngCspElement.getAttribute('data-ng-csp');
1120      csp.rules = {
1121        noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
1122        noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1)
1123      };
1124    } else {
1125      csp.rules = {
1126        noUnsafeEval: noUnsafeEval(),
1127        noInlineStyle: false
1128      };
1129    }
1130  }
1131
1132  return csp.rules;
1133
1134  function noUnsafeEval() {
1135    try {
1136      /* jshint -W031, -W054 */
1137      new Function('');
1138      /* jshint +W031, +W054 */
1139      return false;
1140    } catch (e) {
1141      return true;
1142    }
1143  }
1144};
1145
1146/**
1147 * @ngdoc directive
1148 * @module ng
1149 * @name ngJq
1150 *
1151 * @element ANY
1152 * @param {string=} ngJq the name of the library available under `window`
1153 * to be used for angular.element
1154 * @description
1155 * Use this directive to force the angular.element library.  This should be
1156 * used to force either jqLite by leaving ng-jq blank or setting the name of
1157 * the jquery variable under window (eg. jQuery).
1158 *
1159 * Since angular looks for this directive when it is loaded (doesn't wait for the
1160 * DOMContentLoaded event), it must be placed on an element that comes before the script
1161 * which loads angular. Also, only the first instance of `ng-jq` will be used and all
1162 * others ignored.
1163 *
1164 * @example
1165 * This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
1166 ```html
1167 <!doctype html>
1168 <html ng-app ng-jq>
1169 ...
1170 ...
1171 </html>
1172 ```
1173 * @example
1174 * This example shows how to use a jQuery based library of a different name.
1175 * The library name must be available at the top most 'window'.
1176 ```html
1177 <!doctype html>
1178 <html ng-app ng-jq="jQueryLib">
1179 ...
1180 ...
1181 </html>
1182 ```
1183 */
1184var jq = function() {
1185  if (isDefined(jq.name_)) return jq.name_;
1186  var el;
1187  var i, ii = ngAttrPrefixes.length, prefix, name;
1188  for (i = 0; i < ii; ++i) {
1189    prefix = ngAttrPrefixes[i];
1190    if (el = document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) {
1191      name = el.getAttribute(prefix + 'jq');
1192      break;
1193    }
1194  }
1195
1196  return (jq.name_ = name);
1197};
1198
1199function concat(array1, array2, index) {
1200  return array1.concat(slice.call(array2, index));
1201}
1202
1203function sliceArgs(args, startIndex) {
1204  return slice.call(args, startIndex || 0);
1205}
1206
1207
1208/* jshint -W101 */
1209/**
1210 * @ngdoc function
1211 * @name angular.bind
1212 * @module ng
1213 * @kind function
1214 *
1215 * @description
1216 * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
1217 * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
1218 * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
1219 * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
1220 *
1221 * @param {Object} self Context which `fn` should be evaluated in.
1222 * @param {function()} fn Function to be bound.
1223 * @param {...*} args Optional arguments to be prebound to the `fn` function call.
1224 * @returns {function()} Function that wraps the `fn` with all the specified bindings.
1225 */
1226/* jshint +W101 */
1227function bind(self, fn) {
1228  var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
1229  if (isFunction(fn) && !(fn instanceof RegExp)) {
1230    return curryArgs.length
1231      ? function() {
1232          return arguments.length
1233            ? fn.apply(self, concat(curryArgs, arguments, 0))
1234            : fn.apply(self, curryArgs);
1235        }
1236      : function() {
1237          return arguments.length
1238            ? fn.apply(self, arguments)
1239            : fn.call(self);
1240        };
1241  } else {
1242    // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
1243    return fn;
1244  }
1245}
1246
1247
1248function toJsonReplacer(key, value) {
1249  var val = value;
1250
1251  if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
1252    val = undefined;
1253  } else if (isWindow(value)) {
1254    val = '$WINDOW';
1255  } else if (value &&  document === value) {
1256    val = '$DOCUMENT';
1257  } else if (isScope(value)) {
1258    val = '$SCOPE';
1259  }
1260
1261  return val;
1262}
1263
1264
1265/**
1266 * @ngdoc function
1267 * @name angular.toJson
1268 * @module ng
1269 * @kind function
1270 *
1271 * @description
1272 * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
1273 * stripped since angular uses this notation internally.
1274 *
1275 * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
1276 * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
1277 *    If set to an integer, the JSON output will contain that many spaces per indentation.
1278 * @returns {string|undefined} JSON-ified string representing `obj`.
1279 */
1280function toJson(obj, pretty) {
1281  if (typeof obj === 'undefined') return undefined;
1282  if (!isNumber(pretty)) {
1283    pretty = pretty ? 2 : null;
1284  }
1285  return JSON.stringify(obj, toJsonReplacer, pretty);
1286}
1287
1288
1289/**
1290 * @ngdoc function
1291 * @name angular.fromJson
1292 * @module ng
1293 * @kind function
1294 *
1295 * @description
1296 * Deserializes a JSON string.
1297 *
1298 * @param {string} json JSON string to deserialize.
1299 * @returns {Object|Array|string|number} Deserialized JSON string.
1300 */
1301function fromJson(json) {
1302  return isString(json)
1303      ? JSON.parse(json)
1304      : json;
1305}
1306
1307
1308function timezoneToOffset(timezone, fallback) {
1309  var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
1310  return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
1311}
1312
1313
1314function addDateMinutes(date, minutes) {
1315  date = new Date(date.getTime());
1316  date.setMinutes(date.getMinutes() + minutes);
1317  return date;
1318}
1319
1320
1321function convertTimezoneToLocal(date, timezone, reverse) {
1322  reverse = reverse ? -1 : 1;
1323  var timezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset());
1324  return addDateMinutes(date, reverse * (timezoneOffset - date.getTimezoneOffset()));
1325}
1326
1327
1328/**
1329 * @returns {string} Returns the string representation of the element.
1330 */
1331function startingTag(element) {
1332  element = jqLite(element).clone();
1333  try {
1334    // turns out IE does not let you set .html() on elements which
1335    // are not allowed to have children. So we just ignore it.
1336    element.empty();
1337  } catch (e) {}
1338  var elemHtml = jqLite('<div>').append(element).html();
1339  try {
1340    return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
1341        elemHtml.
1342          match(/^(<[^>]+>)/)[1].
1343          replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
1344  } catch (e) {
1345    return lowercase(elemHtml);
1346  }
1347
1348}
1349
1350
1351/////////////////////////////////////////////////
1352
1353/**
1354 * Tries to decode the URI component without throwing an exception.
1355 *
1356 * @private
1357 * @param str value potential URI component to check.
1358 * @returns {boolean} True if `value` can be decoded
1359 * with the decodeURIComponent function.
1360 */
1361function tryDecodeURIComponent(value) {
1362  try {
1363    return decodeURIComponent(value);
1364  } catch (e) {
1365    // Ignore any invalid uri component
1366  }
1367}
1368
1369
1370/**
1371 * Parses an escaped url query string into key-value pairs.
1372 * @returns {Object.<string,boolean|Array>}
1373 */
1374function parseKeyValue(/**string*/keyValue) {
1375  var obj = {};
1376  forEach((keyValue || "").split('&'), function(keyValue) {
1377    var splitPoint, key, val;
1378    if (keyValue) {
1379      key = keyValue = keyValue.replace(/\+/g,'%20');
1380      splitPoint = keyValue.indexOf('=');
1381      if (splitPoint !== -1) {
1382        key = keyValue.substring(0, splitPoint);
1383        val = keyValue.substring(splitPoint + 1);
1384      }
1385      key = tryDecodeURIComponent(key);
1386      if (isDefined(key)) {
1387        val = isDefined(val) ? tryDecodeURIComponent(val) : true;
1388        if (!hasOwnProperty.call(obj, key)) {
1389          obj[key] = val;
1390        } else if (isArray(obj[key])) {
1391          obj[key].push(val);
1392        } else {
1393          obj[key] = [obj[key],val];
1394        }
1395      }
1396    }
1397  });
1398  return obj;
1399}
1400
1401function toKeyValue(obj) {
1402  var parts = [];
1403  forEach(obj, function(value, key) {
1404    if (isArray(value)) {
1405      forEach(value, function(arrayValue) {
1406        parts.push(encodeUriQuery(key, true) +
1407                   (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
1408      });
1409    } else {
1410    parts.push(encodeUriQuery(key, true) +
1411               (value === true ? '' : '=' + encodeUriQuery(value, true)));
1412    }
1413  });
1414  return parts.length ? parts.join('&') : '';
1415}
1416
1417
1418/**
1419 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
1420 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
1421 * segments:
1422 *    segment       = *pchar
1423 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1424 *    pct-encoded   = "%" HEXDIG HEXDIG
1425 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1426 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1427 *                     / "*" / "+" / "," / ";" / "="
1428 */
1429function encodeUriSegment(val) {
1430  return encodeUriQuery(val, true).
1431             replace(/%26/gi, '&').
1432             replace(/%3D/gi, '=').
1433             replace(/%2B/gi, '+');
1434}
1435
1436
1437/**
1438 * This method is intended for encoding *key* or *value* parts of query component. We need a custom
1439 * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
1440 * encoded per http://tools.ietf.org/html/rfc3986:
1441 *    query       = *( pchar / "/" / "?" )
1442 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1443 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1444 *    pct-encoded   = "%" HEXDIG HEXDIG
1445 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1446 *                     / "*" / "+" / "," / ";" / "="
1447 */
1448function encodeUriQuery(val, pctEncodeSpaces) {
1449  return encodeURIComponent(val).
1450             replace(/%40/gi, '@').
1451             replace(/%3A/gi, ':').
1452             replace(/%24/g, '$').
1453             replace(/%2C/gi, ',').
1454             replace(/%3B/gi, ';').
1455             replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
1456}
1457
1458var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
1459
1460function getNgAttribute(element, ngAttr) {
1461  var attr, i, ii = ngAttrPrefixes.length;
1462  for (i = 0; i < ii; ++i) {
1463    attr = ngAttrPrefixes[i] + ngAttr;
1464    if (isString(attr = element.getAttribute(attr))) {
1465      return attr;
1466    }
1467  }
1468  return null;
1469}
1470
1471/**
1472 * @ngdoc directive
1473 * @name ngApp
1474 * @module ng
1475 *
1476 * @element ANY
1477 * @param {angular.Module} ngApp an optional application
1478 *   {@link angular.module module} name to load.
1479 * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
1480 *   created in "strict-di" mode. This means that the application will fail to invoke functions which
1481 *   do not use explicit function annotation (and are thus unsuitable for minification), as described
1482 *   in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
1483 *   tracking down the root of these bugs.
1484 *
1485 * @description
1486 *
1487 * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
1488 * designates the **root element** of the application and is typically placed near the root element
1489 * of the page - e.g. on the `<body>` or `<html>` tags.
1490 *
1491 * Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngAp

1491p`
1492 * found in the document will be used to define the root element to auto-bootstrap as an
1493 * application. To run multiple applications in an HTML document you must manually bootstrap them using
1494 * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
1495 *
1496 * You can specify an **AngularJS module** to be used as the root module for the application.  This
1497 * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
1498 * should contain the application code needed or have dependencies on other modules that will
1499 * contain the code. See {@link angular.module} for more information.
1500 *
1501 * In the example below if the `ngApp` directive were not placed on the `html` element then the
1502 * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
1503 * would not be resolved to `3`.
1504 *
1505 * `ngApp` is the easiest, and most common way to bootstrap an application.
1506 *
1507 <example module="ngAppDemo">
1508   <file name="index.html">
1509   <div ng-controller="ngAppDemoController">
1510     I can add: {{a}} + {{b}} =  {{ a+b }}
1511   </div>
1512   </file>
1513   <file name="script.js">
1514   angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
1515     $scope.a = 1;
1516     $scope.b = 2;
1517   });
1518   </file>
1519 </example>
1520 *
1521 * Using `ngStrictDi`, you would see something like this:
1522 *
1523 <example ng-app-included="true">
1524   <file name="index.html">
1525   <div ng-app="ngAppStrictDemo" ng-strict-di>
1526       <div ng-controller="GoodController1">
1527           I can add: {{a}} + {{b}} =  {{ a+b }}
1528
1529           <p>This renders because the controller does not fail to
1530              instantiate, by using explicit annotation style (see
1531              script.js for details)
1532           </p>
1533       </div>
1534
1535       <div ng-controller="GoodController2">
1536           Name: <input ng-model="name"><br />
1537           Hello, {{name}}!
1538
1539           <p>This renders because the controller does not fail to
1540              instantiate, by using explicit annotation style
1541              (see script.js for details)
1542           </p>
1543       </div>
1544
1545       <div ng-controller="BadController">
1546           I can add: {{a}} + {{b}} =  {{ a+b }}
1547
1548           <p>The controller could not be instantiated, due to relying
1549              on automatic function annotations (which are disabled in
1550              strict mode). As such, the content of this section is not
1551              interpolated, and there should be an error in your web console.
1552           </p>
1553       </div>
1554   </div>
1555   </file>
1556   <file name="script.js">
1557   angular.module('ngAppStrictDemo', [])
1558     // BadController will fail to instantiate, due to relying on automatic function annotation,
1559     // rather than an explicit annotation
1560     .controller('BadController', function($scope) {
1561       $scope.a = 1;
1562       $scope.b = 2;
1563     })
1564     // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
1565     // due to using explicit annotations using the array style and $inject property, respectively.
1566     .controller('GoodController1', ['$scope', function($scope) {
1567       $scope.a = 1;
1568       $scope.b = 2;
1569     }])
1570     .controller('GoodController2', GoodController2);
1571     function GoodController2($scope) {
1572       $scope.name = "World";
1573     }
1574     GoodController2.$inject = ['$scope'];
1575   </file>
1576   <file name="style.css">
1577   div[ng-controller] {
1578       margin-bottom: 1em;
1579       -webkit-border-radius: 4px;
1580       border-radius: 4px;
1581       border: 1px solid;
1582       padding: .5em;
1583   }
1584   div[ng-controller^=Good] {
1585       border-color: #d6e9c6;
1586       background-color: #dff0d8;
1587       color: #3c763d;
1588   }
1589   div[ng-controller^=Bad] {
1590       border-color: #ebccd1;
1591       background-color: #f2dede;
1592       color: #a94442;
1593       margin-bottom: 0;
1594   }
1595   </file>
1596 </example>
1597 */
1598function angularInit(element, bootstrap) {
1599  var appElement,
1600      module,
1601      config = {};
1602
1603  // The element `element` has priority over any other element
1604  forEach(ngAttrPrefixes, function(prefix) {
1605    var name = prefix + 'app';
1606
1607    if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
1608      appElement = element;
1609      module = element.getAttribute(name);
1610    }
1611  });
1612  forEach(ngAttrPrefixes, function(prefix) {
1613    var name = prefix + 'app';
1614    var candidate;
1615
1616    if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
1617      appElement = candidate;
1618      module = candidate.getAttribute(name);
1619    }
1620  });
1621  if (appElement) {
1622    config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
1623    bootstrap(appElement, module ? [module] : [], config);
1624  }
1625}
1626
1627/**
1628 * @ngdoc function
1629 * @name angular.bootstrap
1630 * @module ng
1631 * @description
1632 * Use this function to manually start up angular application.
1633 *
1634 * See: {@link guide/bootstrap Bootstrap}
1635 *

1636 * Note that Protractor based end-to-end tests cannot use this function to bootstrap manually.
1637 * They must use {@link ng.directive:ngApp ngApp}.
1638 *
1639 * Angular will detect if it has been loaded into the browser more than once and only allow the
1640 * first loaded script to be bootstrapped and will report a warning to the browser console for
1641 * each of the subsequent scripts. This prevents strange results in applications, where otherwise
1642 * multiple instances of Angular try to work on the DOM.
1643 *
1644 * ```html
1645 * <!doctype html>
1646 * <html>
1647 * <body>
1648 * <div ng-controller="WelcomeController">
1649 *   {{greeting}}
1650 * </div>
1651 *
1652 * <script src="angular.js"></script>
1653 * <script>
1654 *   var app = angular.module('demo', [])
1655 *   .controller('WelcomeController', function($scope) {
1656 *       $scope.greeting = 'Welcome!';
1657 *   });
1658 *   angular.bootstrap(document, ['demo']);
1659 * </script>
1660 * </body>
1661 * </html>
1662 * ```
1663 *
1664 * @param {DOMElement} element DOM element which is the root of angular application.
1665 * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
1666 *     Each item in the array should be the name of a predefined module or a (DI annotated)
1667 *     function that will be invoked by the injector as a `config` block.
1668 *     See: {@link angular.module modules}
1669 * @param {Object=} config an object for defining configuration options for the application. The
1670 *     following keys are supported:
1671 *
1672 * * `strictDi` - disable automatic function annotation for the application. This is meant to
1673 *   assist in finding bugs which break minified code. Defaults to `false`.
1674 *
1675 * @returns {auto.$injector} Returns the newly created injector for this app.
1676 */
1677function bootstrap(element, modules, config) {
1678  if (!isObject(config)) config = {};
1679  var defaultConfig = {
1680    strictDi: false
1681  };
1682  config = extend(defaultConfig, config);
1683  var doBootstrap = function() {
1684    element = jqLite(element);
1685
1686    if (element.injector()) {
1687      var tag = (element[0] === document) ? 'document' : startingTag(element);
1688      //Encode angle brackets to prevent input from being sanitized to empty string #8683
1689      throw ngMinErr(
1690          'btstrpd',
1691          "App Already Bootstrapped with this Element '{0}'",
1692          tag.replace(/</,'&lt;').replace(/>/,'&gt;'));
1693    }
1694
1695    modules = modules || [];
1696    modules.unshift(['$provide', function($provide) {
1697      $provide.value('$rootElement', element);
1698    }]);
1699
1700    if (config.debugInfoEnabled) {
1701      // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
1702      modules.push(['$compileProvider', function($compileProvider) {
1703        $compileProvider.debugInfoEnabled(true);
1704      }]);
1705    }
1706
1707    modules.unshift('ng');
1708    var injector = createInjector(modules, config.strictDi);
1709    injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
1710       function bootstrapApply(scope, element, compile, injector) {
1711        scope.$apply(function() {
1712          element.data('$injector', injector);
1713          compile(element)(scope);
1714        });
1715      }]
1716    );
1717    return injector;
1718  };
1719
1720  var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
1721  var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
1722
1723  if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
1724    config.debugInfoEnabled = true;
1725    window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
1726  }
1727
1728  if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
1729    return doBootstrap();
1730  }
1731
1732  window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
1733  angular.resumeBootstrap = function(extraModules) {
1734    forEach(extraModules, function(module) {
1735      modules.push(module);
1736    });
1737    return doBootstrap();
1738  };
1739
1740  if (isFunction(angular.resumeDeferredBootstrap)) {
1741    angular.resumeDeferredBootstrap();
1742  }
1743}
1744
1745/**
1746 * @ngdoc function
1747 * @name angular.reloadWithDebugInfo
1748 * @module ng
1749 * @description
1750 * Use this function to reload the current application with debug information turned on.
1751 * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
1752 *
1753 * See {@link ng.$compileProvider#debugInfoEnabled} for more.
1754 */
1755function reloadWithDebugInfo() {
1756  window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
1757  window.location.reload();
1758}
1759
1760/**
1761 * @name angular.getTestability
1762 * @module ng
1763 * @description
1764 * Get the testability service for the instance of Angular on the given
1765 * element.
1766 * @param {DOMElement} element DOM element which is the root of angular application.
1767 */
1768function getTestability(rootElement) {
1769  var injector = angular.element(rootElement).injector();
1770  if (!injector) {
1771    throw ngMinErr('test',
1772      'no injector found for element argument to getTestability');
1773  }
1774  return injector.get('$$testability');
1775}
1776
1777var SNAKE_CASE_REGEXP = /[A-Z]/g;
1778function snake_case(name, separator) {
1779  separator = separator || '_';
1780  return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
1781    return (pos ? separator : '') + letter.toLowerCase();
1782  });
1783}
1784
1785var bindJQueryFired = false;
1786function bindJQuery() {
1787  var originalCleanData;
1788
1789  if (bindJQueryFired) {
1790    return;
1791  }
1792
1793  // bind to jQuery if present;
1794  var jqName = jq();
1795  jQuery = isUndefined(jqName) ? window.jQuery :   // use jQuery (if present)
1796           !jqName             ? undefined     :   // use jqLite
1797                                 window[jqName];   // use jQuery specified by `ngJq`
1798
1799  // Use jQuery if it exists with proper functionality, otherwise default to us.
1800  // Angular 1.2+ requires jQuery 1.7+ for on()/off() support.
1801  // Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older
1802  // versions. It will not work for sure with jQuery <1.7, though.
1803  if (jQuery && jQuery.fn.on) {
1804    jqLite = jQuery;
1805    extend(jQuery.fn, {
1806      scope: JQLitePrototype.scope,
1807      isolateScope: JQLitePrototype.isolateScope,
1808      controller: JQLitePrototype.controller,
1809      injector: JQLitePrototype.injector,
1810      inheritedData: JQLitePrototype.inheritedData
1811    });

1812
1813    // All nodes removed from the DOM via various jQuery APIs like .remove()
1814    // are passed through jQuery.cleanData. Monkey-patch this method to fire
1815    // the $destroy event on all removed nodes.
1816    originalCleanData = jQuery.cleanData;
1817    jQuery.cleanData = function(elems) {
1818      var events;
1819      for (var i = 0, elem; (elem = elems[i]) != null; i++) {
1820        events = jQuery._data(elem, "events");
1821        if (events && events.$destroy) {
1822          jQuery(elem).triggerHandler('$destroy');
1823        }
1824      }
1825      originalCleanData(elems);
1826    };
1827  } else {
1828    jqLite = JQLite;
1829  }
1830
1831  angular.element = jqLite;
1832
1833  // Prevent double-proxying.
1834  bindJQueryFired = true;
1835}
1836
1837/**
1838 * throw error if the argument is falsy.
1839 */
1840function assertArg(arg, name, reason) {
1841  if (!arg) {
1842    throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required"));
1843  }
1844  return arg;
1845}
1846
1847function assertArgFn(arg, name, acceptArrayAnnotation) {
1848  if (acceptArrayAnnotation && isArray(arg)) {
1849      arg = arg[arg.length - 1];
1850  }
1851
1852  assertArg(isFunction(arg), name, 'not a function, got ' +
1853      (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
1854  return arg;
1855}
1856
1857/**
1858 * throw error if the name given is hasOwnProperty
1859 * @param  {String} name    the name to test
1860 * @param  {String} context the context in which the name is used, such as module or directive
1861 */
1862function assertNotHasOwnProperty(name, context) {
1863  if (name === 'hasOwnProperty') {
1864    throw ngMinErr('badname', "hasOwnProperty is not a valid {0} name", context);
1865  }
1866}
1867
1868/**
1869 * Return the value accessible from the object by path. Any undefined traversals are ignored
1870 * @param {Object} obj starting object
1871 * @param {String} path path to traverse
1872 * @param {boolean} [bindFnToScope=true]
1873 * @returns {Object} value as accessible by path
1874 */
1875//TODO(misko): this function needs to be removed
1876function getter(obj, path, bindFnToScope) {
1877  if (!path) return obj;
1878  var keys = path.split('.');
1879  var key;
1880  var lastInstance = obj;
1881  var len = keys.length;
1882
1883  for (var i = 0; i < len; i++) {
1884    key = keys[i];
1885    if (obj) {
1886      obj = (lastInstance = obj)[key];
1887    }
1888  }
1889  if (!bindFnToScope && isFunction(obj)) {
1890    return bind(lastInstance, obj);
1891  }
1892  return obj;
1893}
1894
1895/**
1896 * Return the DOM siblings between the first and last node in the given array.
1897 * @param {Array} array like object
1898 * @returns {Array} the inputted object or a jqLite collection containing the nodes
1899 */
1900function getBlockNodes(nodes) {
1901  // TODO(perf): update `nodes` instead of creating a new object?
1902  var node = nodes[0];
1903  var endNode = nodes[nodes.length - 1];
1904  var blockNodes;
1905
1906  for (var i = 1; node !== endNode && (node = node.nextSibling); i++) {
1907    if (blockNodes || nodes[i] !== node) {
1908      if (!blockNodes) {
1909        blockNodes = jqLite(slice.call(nodes, 0, i));
1910      }
1911      blockNodes.push(node);
1912    }
1913  }
1914
1915  return blockNodes || nodes;
1916}
1917
1918
1919/**
1920 * Creates a new object without a prototype. This object is useful for lookup without having to
1921 * guard against prototypically inherited properties via hasOwnProperty.
1922 *
1923 * Related micro-benchmarks:
1924 * - http://jsperf.com/object-create2
1925 * - http://jsperf.com/proto-map-lookup/2
1926 * - http://jsperf.com/for-in-vs-object-keys2
1927 *
1928 * @returns {Object}
1929 */
1930function createMap() {
1931  return Object.create(null);
1932}
1933
1934var NODE_TYPE_ELEMENT = 1;
1935var NODE_TYPE_ATTRIBUTE = 2;
1936var NODE_TYPE_TEXT = 3;
1937var NODE_TYPE_COMMENT = 8;
1938var NODE_TYPE_DOCUMENT = 9;
1939var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
1940
1941/**
1942 * @ngdoc type
1943 * @name angular.Module
1944 * @module ng
1945 * @description
1946 *
1947 * Interface for configuring angular {@link angular.module modules}.
1948 */
1949
1950function setupModuleLoader(window) {
1951
1952  var $injectorMinErr = minErr('$injector');
1953  var ngMinErr = minErr('ng');
1954
1955  function ensure(obj, name, factory) {
1956    return obj[name] || (obj[name] = factory());
1957  }
1958
1959  var angular = ensure(window, 'angular', Object);
1960
1961  // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
1962  angular.$$minErr = angular.$$minErr || minErr;
1963
1964  return ensure(angular, 'module', function() {
1965    /** @type {Object.<string, angular.Module>} */
1966    var modules = {};
1967
1968    /**
1969     * @ngdoc function
1970     * @name angular.module
1971     * @module ng

1972     * @description
1973     *
1974     * The `angular.module` is a global place for creating, registering and retrieving Angular
1975     * modules.
1976     * All modules (angular core or 3rd party) that should be available to an application must be
1977     * registered using this mechanism.
1978     *
1979     * Passing one argument retrieves an existing {@link angular.Module},
1980     * whereas passing more than one argument creates a new {@link angular.Module}
1981     *
1982     *
1983     * # Module
1984     *
1985     * A module is a collection of services, directives, controllers, filters, and configuration information.
1986     * `angular.module` is used to configure the {@link auto.$injector $injector}.
1987     *
1988     * ```js
1989     * // Create a new module
1990     * var myModule = angular.module('myModule', []);
1991     *
1992     * // register a new service
1993     * myModule.value('appName', 'MyCoolApp');
1994     *
1995     * // configure existing services inside initialization blocks.
1996     * myModule.config(['$locationProvider', function($locationProvider) {
1997     *   // Configure existing providers
1998     *   $locationProvider.hashPrefix('!');
1999     * }]);
2000     * ```
2001     *
2002     * Then you can create an injector and load your modules like this:
2003     *
2004     * ```js
2005     * var injector = angular.injector(['ng', 'myModule'])
2006     * ```
2007     *
2008     * However it's more likely that you'll just use
2009     * {@link ng.directive:ngApp ngApp} or
2010     * {@link angular.bootstrap} to simplify this process for you.
2011     *
2012     * @param {!string} name The name of the module to create or retrieve.
2013     * @param {!Array.<string>=} requires If specified then new module is being created. If
2014     *        unspecified then the module is being retrieved for further configuration.
2015     * @param {Function=} configFn Optional configuration function for the module. Same as
2016     *        {@link angular.Module#config Module#config()}.
2017     * @returns {angular.Module} new module with the {@link angular.Module} api.
2018     */
2019    return function module(name, requires, configFn) {
2020      var assertNotHasOwnProperty = function(name, context) {
2021        if (name === 'hasOwnProperty') {
2022          throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
2023        }
2024      };
2025
2026      assertNotHasOwnProperty(name, 'module');
2027      if (requires && modules.hasOwnProperty(name)) {
2028        modules[name] = null;
2029      }
2030      return ensure(modules, name, function() {
2031        if (!requires) {
2032          throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
2033             "the module name or forgot to load it. If registering a module ensure that you " +
2034             "specify the dependencies as the second argument.", name);
2035        }
2036
2037        /** @type {!Array.<Array.<*>>} */
2038        var invokeQueue = [];
2039
2040        /** @type {!Array.<Function>} */
2041        var configBlocks = [];
2042
2043        /** @type {!Array.<Function>} */
2044        var runBlocks = [];
2045
2046        var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
2047
2048        /** @type {angular.Module} */
2049        var moduleInstance = {
2050          // Private state
2051          _invokeQueue: invokeQueue,
2052          _configBlocks: configBlocks,
2053          _runBlocks: runBlocks,
2054
2055          /**
2056           * @ngdoc property
2057           * @name angular.Module#requires
2058           * @module ng
2059           *
2060           * @description
2061           * Holds the list of modules which the injector will load before the current module is
2062           * loaded.
2063           */
2064          requires: requires,
2065
2066          /**
2067           * @ngdoc property
2068           * @name angular.Module#name
2069           * @module ng
2070           *
2071           * @description
2072           * Name of the module.
2073           */
2074          name: name,
2075
2076
2077          /**
2078           * @ngdoc method
2079           * @name angular.Module#provider
2080           * @module ng
2081           * @param {string} name service name
2082           * @param {Function} providerType Construction function for creating new instance of the
2083           *                                service.

2084           * @description
2085           * See {@link auto.$provide#provider $provide.provider()}.
2086           */
2087          provider: invokeLaterAndSetModuleName('$provide', 'provider'),
2088
2089          /**
2090           * @ngdoc method
2091           * @name angular.Module#factory
2092           * @module ng
2093           * @param {string} name service name
2094           * @param {Function} providerFunction Function for creating new instance of the service.
2095           * @description
2096           * See {@link auto.$provide#factory $provide.factory()}.
2097           */
2098          factory: invokeLaterAndSetModuleName('$provide', 'factory'),
2099
2100          /**
2101           * @ngdoc method
2102           * @name angular.Module#service
2103           * @module ng
2104           * @param {string} name service name
2105           * @param {Function} constructor A constructor function that will be instantiated.
2106           * @description
2107           * See {@link auto.$provide#service $provide.service()}.
2108           */
2109          service: invokeLaterAndSetModuleName('$provide', 'service'),
2110
2111          /**
2112           * @ngdoc method
2113           * @name angular.Module#value
2114           * @module ng
2115           * @param {string} name service name
2116           * @param {*} object Service instance object.
2117           * @description
2118           * See {@link auto.$provide#value $provide.value()}.
2119           */
2120          value: invokeLater('$provide', 'value'),
2121
2122          /**
2123           * @ngdoc method
2124           * @name angular.Module#constant
2125           * @module ng
2126           * @param {string} name constant name
2127           * @param {*} object Constant value.
2128           * @description
2129           * Because the constants are fixed, they get applied before other provide methods.
2130           * See {@link auto.$provide#constant $provide.constant()}.
2131           */
2132          constant: invokeLater('$provide', 'constant', 'unshift'),
2133
2134           /**
2135           * @ngdoc method
2136           * @name angular.Module#decorator
2137           * @module ng
2138           * @param {string} The name of the service to decorate.
2139           * @param {Function} This function will be invoked when the service needs to be
2140           *                                    instantiated and should return the decorated service instance.
2141           * @description
2142           * See {@link auto.$provide#decorator $provide.decorator()}.
2143           */
2144          decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
2145
2146          /**
2147           * @ngdoc method
2148           * @name angular.Module#animation
2149           * @module ng
2150           * @param {string} name animation name
2151           * @param {Function} animationFactory Factory function for creating new instance of an
2152           *                                    animation.
2153           * @description
2154           *
2155           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
2156           *
2157           *
2158           * Defines an animation hook that can be later used with
2159           * {@link $animate $animate} service and directives that use this service.
2160           *
2161           * ```js
2162           * module.animation('.animation-name', function($inject1, $inject2) {
2163           *   return {
2164           *     eventName : function(element, done) {
2165           *       //code to run the animation
2166           *       //once complete, then run done()
2167           *       return function cancellationFunction(element) {
2168           *         //code to cancel the animation
2169           *       }
2170           *     }
2171           *   }
2172           * })
2173           * ```
2174           *
2175           * See {@link ng.$animateProvider#register $animateProvider.register()} and
2176           * {@link ngAnimate ngAnimate module} for more information.
2177           */
2178          animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
2179
2180          /**
2181           * @ngdoc method
2182           * @name angular.Module#filter
2183           * @module ng
2184           * @param {string} name Filter name - this must be a valid angular expression identifier
2185           * @param {Function} filterFactory Factory function for creating new instance of filter.

2186           * @description
2187           * See {@link ng.$filterProvider#register $filterProvider.register()}.
2188           *
2189           * <div class="alert alert-warning">
2190           * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
2191           * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
2192           * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
2193           * (`myapp_subsection_filterx`).
2194           * </div>
2195           */
2196          filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
2197
2198          /**
2199           * @ngdoc method
2200           * @name angular.Module#controller
2201           * @module ng
2202           * @param {string|Object} name Controller name, or an object map of controllers where the
2203           *    keys are the names and the values are the constructors.
2204           * @param {Function} constructor Controller constructor function.
2205           * @description
2206           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
2207           */
2208          controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
2209
2210          /**
2211           * @ngdoc method
2212           * @name angular.Module#directive
2213           * @module ng
2214           * @param {string|Object} name Directive name, or an object map of directives where the
2215           *    keys are the names and the values are the factories.
2216           * @param {Function} directiveFactory Factory function for creating new instance of
2217           * directives.
2218           * @description
2219           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
2220           */
2221          directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
2222
2223          /**
2224           * @ngdoc method
2225           * @name angular.Module#component
2226           * @module ng
2227           * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
2228           * @param {Object} options Component definition object (a simplified
2229           *    {@link ng.$compile#directive-definition-object directive definition object})
2230           *
2231           * @description
2232           * See {@link ng.$compileProvider#component $compileProvider.component()}.
2233           */
2234          component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
2235
2236          /**
2237           * @ngdoc method
2238           * @name angular.Module#config
2239           * @module ng
2240           * @param {Function} configFn Execute this function on module load. Useful for service
2241           *    configuration.
2242           * @description
2243           * Use this method to register work which needs to be performed on module loading.
2244           * For more about how to configure services, see
2245           * {@link providers#provider-recipe Provider Recipe}.
2246           */
2247          config: config,
2248
2249          /**
2250           * @ngdoc method
2251           * @name angular.Module#run
2252           * @module ng
2253           * @param {Function} initializationFn Execute this function after injector creation.
2254           *    Useful for application initialization.
2255           * @description
2256           * Use this method to register work which should be performed when the injector is done
2257           * loading all modules.
2258           */
2259          run: function(block) {
2260            runBlocks.push(block);
2261            return this;
2262          }
2263        };
2264
2265        if (configFn) {
2266          config(configFn);
2267        }
2268
2269        return moduleInstance;
2270
2271        /**
2272         * @param {string} provider
2273         * @param {string} method
2274         * @param {String=} insertMethod
2275         * @returns {angular.Module}
2276         */
2277        function invokeLater(provider, method, insertMethod, queue) {
2278          if (!queue) queue = invokeQueue;
2279          return function() {
2280            queue[insertMethod || 'push']([provider, method, arguments]);
2281            return moduleInstance;
2282          };
2283        }
2284
2285        /**
2286         * @param {string} provider
2287         * @param {string} method
2288         * @returns {angular.Module}
2289         */

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

2490      // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
2491      $provide.provider({
2492        $$sanitizeUri: $$SanitizeUriProvider
2493      });
2494      $provide.provider('$compile', $CompileProvider).
2495        directive({
2496            a: htmlAnchorDirective,
2497            input: inputDirective,
2498            textarea: inputDirective,
2499            form: formDirective,
2500            script: scriptDirective,
2501            select: selectDirective,
2502            style: styleDirective,
2503            option: optionDirective,
2504            ngBind: ngBindDirective,
2505            ngBindHtml: ngBindHtmlDirective,
2506            ngBindTemplate: ngBindTemplateDirective,
2507            ngClass: ngClassDirective,
2508            ngClassEven: ngClassEvenDirective,
2509            ngClassOdd: ngClassOddDirective,
2510            ngCloak: ngCloakDirective,
2511            ngController: ngControllerDirective,
2512            ngForm: ngFormDirective,
2513            ngHide: ngHideDirective,
2514            ngIf: ngIfDirective,
2515            ngInclude: ngIncludeDirective,
2516            ngInit: ngInitDirective,
2517            ngNonBindable: ngNonBindableDirective,
2518            ngPluralize: ngPluralizeDirective,
2519            ngRepeat: ngRepeatDirective,
2520            ngShow: ngShowDirective,
2521            ngStyle: ngStyleDirective,
2522            ngSwitch: ngSwitchDirective,
2523            ngSwitchWhen: ngSwitchWhenDirective,
2524            ngSwitchDefault: ngSwitchDefaultDirective,
2525            ngOptions: ngOptionsDirective,
2526            ngTransclude: ngTranscludeDirective,
2527            ngModel: ngModelDirective,
2528            ngList: ngListDirective,
2529            ngChange: ngChangeDirective,
2530            pattern: patternDirective,
2531            ngPattern: patternDirective,
2532            required: requiredDirective,
2533            ngRequired: requiredDirective,
2534            minlength: minlengthDirective,
2535            ngMinlength: minlengthDirective,
2536            maxlength: maxlengthDirective,
2537            ngMaxlength: maxlengthDirective,
2538            ngValue: ngValueDirective,
2539            ngModelOptions: ngModelOptionsDirective
2540        }).
2541        directive({
2542          ngInclude: ngIncludeFillContentDirective
2543        }).
2544        directive(ngAttributeAliasDirectives).
2545        directive(ngEventDirectives);
2546      $provide.provider({
2547        $anchorScroll: $AnchorScrollProvider,
2548        $animate: $AnimateProvider,
2549        $animateCss: $CoreAnimateCssProvider,
2550        $$animateJs: $$CoreAnimateJsProvider,
2551        $$animateQueue: $$CoreAnimateQueueProvider,
2552        $$AnimateRunner: $$AnimateRunnerFactoryProvider,
2553        $$animateAsyncRun: $$AnimateAsyncRunFactoryProvider,
2554        $browser: $BrowserProvider,
2555        $cacheFactory: $CacheFactoryProvider,
2556        $controller: $ControllerProvider,
2557        $document: $DocumentProvider,
2558        $exceptionHandler: $ExceptionHandlerProvider,
2559        $filter: $FilterProvider,
2560        $$forceReflow: $$ForceReflowProvider,
2561        $interpolate: $InterpolateProvider,
2562        $interval: $IntervalProvider,
2563        $http: $HttpProvider,
2564        $httpParamSerializer: $HttpParamSerializerProvider,
2565        $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
2566        $httpBackend: $HttpBackendProvider,
2567        $xhrFactory: $xhrFactoryProvider,
2568        $location: $LocationProvider,
2569        $log: $LogProvider,
2570        $parse: $ParseProvider,
2571        $rootScope: $RootScopeProvider,
2572        $q: $QProvider,
2573        $$q: $$QProvider,
2574        $sce: $SceProvider,
2575        $sceDelegate: $SceDelegateProvider,
2576        $sniffer: $SnifferProvider,
2577        $templateCache: $TemplateCacheProvider,
2578        $templateRequest: $TemplateRequestProvider,
2579        $$testability: $$TestabilityProvider,
2580        $timeout: $TimeoutProvider,
2581        $window: $WindowProvider,
2582        $$rAF: $$RAFProvider,
2583        $$jqLite: $$jqLiteProvider,
2584        $$HashMap: $$HashMapProvider,
2585        $$cookieReader: $$CookieReaderProvider
2586      });
2587    }
2588  ]);
2589}
2590
2591/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2592 *     Any commits to this file should be reviewed with security in mind.  *
2593 *   Changes to this file can potentially create security vulnerabilities. *
2594 *          An approval from 2 Core members with history of modifying      *
2595 *                         this file is required.                          *
2596 *                                                                         *
2597 *  Does the change somehow allow for arbitrary javascript to be executed? *
2598 *    Or allows for someone to change the prototype of built-in objects?   *
2599 *     Or gives undesired access to variables likes document or window?    *
2600 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2601
2602/* global JQLitePrototype: true,
2603  addEventListenerFn: true,
2604  removeEventListenerFn: true,
2605  BOOLEAN_ATTR: true,
2606  ALIASED_ATTR: true,
2607*/
2608
2609//////////////////////////////////
2610//JQLite
2611//////////////////////////////////
2612
2613/**
2614 * @ngdoc function
2615 * @name angular.element
2616 * @module ng
2617 * @kind function
2618 *
2619 * @description
2620 * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
2621 *
2622 * If jQuery is available, `angular.element` is an alias for the
2623 * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
2624 * delegates to Angular's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
2625 *
2626 * jqLite is a tiny, API-compatible subset of jQuery that allows
2627 * Angular to manipulate the DOM in a cross-browser compatible way. jqLite implements only the most
2628 * commonly needed functionality with the goal of having a very small footprint.
2629 *
2630 * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
2631 * {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
2632 * specific version of jQuery if multiple versions exist on the page.
2633 *
2634 * <div class="alert alert-info">**Note:** All element references in Angular are always wrapped with 

2634jQuery or
2635 * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
2636 *
2637 * <div class="alert alert-warning">**Note:** Keep in mind that this function will not find elements
2638 * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
2639 * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
2640 *
2641 * ## Angular's jqLite
2642 * jqLite provides only the following jQuery methods:
2643 *
2644 * - [`addClass()`](http://api.jquery.com/addClass/)
2645 * - [`after()`](http://api.jquery.com/after/)
2646 * - [`append()`](http://api.jquery.com/append/)
2647 * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
2648 * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
2649 * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
2650 * - [`clone()`](http://api.jquery.com/clone/)
2651 * - [`contents()`](http://api.jquery.com/contents/)
2652 * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`.
2653 *   As a setter, does not convert numbers to strings or append 'px', and also does not have automatic property prefixing.
2654 * - [`data()`](http://api.jquery.com/data/)
2655 * - [`detach()`](http://api.jquery.com/detach/)
2656 * - [`empty()`](http://api.jquery.com/empty/)
2657 * - [`eq()`](http://api.jquery.com/eq/)
2658 * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
2659 * - [`hasClass()`](http://api.jquery.com/hasClass/)
2660 * - [`html()`](http://api.jquery.com/html/)
2661 * - [`next()`](http://api.jquery.com/next/) - Does not support selectors
2662 * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
2663 * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
2664 * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
2665 * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
2666 * - [`prepend()`](http://api.jquery.com/prepend/)
2667 * - [`prop()`](http://api.jquery.com/prop/)
2668 * - [`ready()`](http://api.jquery.com/ready/)
2669 * - [`remove()`](http://api.jquery.com/remove/)
2670 * - [`removeAttr()`](http://api.jquery.com/removeAttr/)
2671 * - [`removeClass()`](http://api.jquery.com/removeClass/)
2672 * - [`removeData()`](http://api.jquery.com/removeData/)
2673 * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
2674 * - [`text()`](http://api.jquery.com/text/)
2675 * - [`toggleClass()`](http://api.jquery.com/toggleClass/)
2676 * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
2677 * - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces or event object as parameter
2678 * - [`val()`](http://api.jquery.com/val/)
2679 * - [`wrap()`](http://api.jquery.com/wrap/)
2680 *
2681 * ## jQuery/jqLite Extras
2682 * Angular also provides the following additional methods and events to both jQuery and jqLite:
2683 *
2684 * ### Events
2685 * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
2686 *    on all DOM nodes being removed.  This can be used to clean up any 3rd party bindings to the DOM
2687 *    element before it is removed.
2688 *
2689 * ### Methods
2690 * - `controller(name)` - retrieves the controller of the current element or its parent. By default
2691 *   retrieves controller associated with the `ngController` directive. If `name` is provided as
2692 *   camelCase directive name, then the controller for this directive will be retrieved (e.g.
2693 *   `'ngModel'`).
2694 * - `injector()` - retrieves the injector of the current element or its parent.
2695 * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
2696 *   element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
2697 *   be enabled.
2698 * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
2699 *   current element. This getter should be used only on elements that contain a directive which starts a new isolate