https://thesis-5081.firebaseapp.com/bower_components/angular/angular.js

1/**
2 * @license AngularJS v1.7.3
3 * (c) 2010-2018 Google, Inc. http://angularjs.org
4 * License: MIT
5 */
6(function(window) {'use strict';
7
8/* exported
9  minErrConfig,
10  errorHandlingConfig,
11  isValidObjectMaxDepth
12*/
13
14var minErrConfig = {
15  objectMaxDepth: 5,
16  urlErrorParamsEnabled: true
17};
18
19/**
20 * @ngdoc function
21 * @name angular.errorHandlingConfig
22 * @module ng
23 * @kind function
24 *
25 * @description
26 * Configure several aspects of error handling in AngularJS if used as a setter or return the
27 * current configuration if used as a getter. The following options are supported:
28 *
29 * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
30 *
31 * Omitted or undefined options will leave the corresponding configuration values unchanged.
32 *
33 * @param {Object=} config - The configuration object. May only contain the options that need to be
34 *     updated. Supported keys:
35 *
36 * * `objectMaxDepth`  **{Number}** - The max depth for stringifying objects. Setting to a
37 *   non-positive or non-numeric value, removes the max depth limit.
38 *   Default: 5
39 *
40 * * `urlErrorParamsEnabled`  **{Boolean}** - Specifies wether the generated error url will
41 *   contain the parameters of the thrown error. Disabling the parameters can be useful if the
42 *   generated error url is very long.
43 *
44 *   Default: true. When used without argument, it returns the current value.
45 */
46function errorHandlingConfig(config) {
47  if (isObject(config)) {
48    if (isDefined(config.objectMaxDepth)) {
49      minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth) ? config.objectMaxDepth : NaN;
50    }
51    if (isDefined(config.urlErrorParamsEnabled) && isBoolean(config.urlErrorParamsEnabled)) {
52      minErrConfig.urlErrorParamsEnabled = config.urlErrorParamsEnabled;
53    }
54  } else {
55    return minErrConfig;
56  }
57}
58
59/**
60 * @private
61 * @param {Number} maxDepth
62 * @return {boolean}
63 */
64function isValidObjectMaxDepth(maxDepth) {
65  return isNumber(maxDepth) && maxDepth > 0;
66}
67
68
69/**
70 * @description
71 *
72 * This object provides a utility for producing rich Error messages within
73 * AngularJS. It can be called as follows:
74 *
75 * var exampleMinErr = minErr('example');
76 * throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
77 *
78 * The above creates an instance of minErr in the example namespace. The
79 * resulting error will have a namespaced error code of example.one.  The
80 * resulting error will replace {0} with the value of foo, and {1} with the
81 * value of bar. The object is not restricted in the number of arguments it can
82 * take.
83 *
84 * If fewer arguments are specified than necessary for interpolation, the extra
85 * interpolation markers will be preserved in the final string.
86 *
87 * Since data will be parsed statically during a build step, some restrictions
88 * are applied with respect to how minErr instances are created and called.
89 * Instances should have names of the form namespaceMinErr for a minErr created
90 * using minErr('namespace') . Error codes, namespaces and template strings
91 * should all be static strings, not variables or general expressions.
92 *
93 * @param {string} module The namespace to use for the new minErr instance.
94 * @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
95 *   error from returned function, for cases when a particular type of error is useful.
96 * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
97 */
98
99function minErr(module, ErrorConstructor) {
100  ErrorConstructor = ErrorConstructor || Error;
101
102  var url = 'https://errors.angularjs.org/1.7.3/';
103  var regex = url.replace('.', '\\.') + '[\\s\\S]*';
104  var errRegExp = new RegExp(regex, 'g');
105
106  return function() {
107    var code = arguments[0],
108      template = arguments[1],
109      message = '[' + (module ? module + ':' : '') + code + '] ',
110      templateArgs = sliceArgs(arguments, 2).map(function(arg) {
111        return toDebugString(arg, minErrConfig.objectMaxDepth);
112      }),
113      paramPrefix, i;
114
115    // A minErr message has two parts: the message itself and the url that contains the
116    // encoded message.
117    // The message's parameters can contain other error messages which also include error urls.
118    // To prevent the messages from getting too long, we strip the error urls from the parameters.
119
120    message += template.replace(/\{\d+\}/g, function(match) {
121      var index = +match.slice(1, -1);
122
123      if (index < templateArgs.length) {
124        return templateArgs[index].replace(errRegExp, '');
125      }
126
127      return match;
128    });
129
130    message += '\n' + url + (module ? module + '/' : '') + code;
131

234,
235
236  NODE_TYPE_ELEMENT,
237  NODE_TYPE_ATTRIBUTE,
238  NODE_TYPE_TEXT,
239  NODE_TYPE_COMMENT,
240  NODE_TYPE_DOCUMENT,
241  NODE_TYPE_DOCUMENT_FRAGMENT
242*/
243
244////////////////////////////////////
245
246/**
247 * @ngdoc module
248 * @name ng
249 * @module ng
250 * @installation
251 * @description
252 *
253 * The ng module is loaded by default when an AngularJS application is started. The module itself
254 * contains the essential components for an AngularJS application to function. The table below
255 * lists a high level breakdown of each of the services/factories, filters, directives and testing
256 * components available within this core module.
257 *
258 */
259
260var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
261
262// The name of a form control's ValidityState property.
263// This is used so that it's possible for internal tests to create mock ValidityStates.
264var VALIDITY_STATE_PROPERTY = 'validity';
265
266
267var hasOwnProperty = Object.prototype.hasOwnProperty;
268
269/**
270 * @private
271 *
272 * @description Converts the specified string to lowercase.
273 * @param {string} string String to be converted to lowercase.
274 * @returns {string} Lowercased string.
275 */
276var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
277
278/**
279 * @private
280 *
281 * @description Converts the specified string to uppercase.
282 * @param {string} string String to be converted to uppercase.
283 * @returns {string} Uppercased string.
284 */
285var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
286
287
288var
289    msie,             // holds major version number for IE, or NaN if UA is not IE.
290    jqLite,           // delay binding since jQuery could be loaded after us.
291    jQuery,           // delay binding
292    slice             = [].slice,
293    splice            = [].splice,
294    push              = [].push,
295    toString          = Object.prototype.toString,
296    getPrototypeOf    = Object.getPrototypeOf,
297    ngMinErr          = minErr('ng'),
298
299    /** @name angular */
300    angular           = window.angular || (window.angular = {}),
301    angularModule,
302    uid               = 0;
303
304// Support: IE 9-11 only
305/**
306 * documentMode is an IE-only property
307 * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
308 */
309msie = window.document.documentMode;
310
311
312/**
313 * @private
314 * @param {*} obj
315 * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
316 *                   String ...)
317 */
318function isArrayLike(obj) {
319
320  // `null`, `undefined` and `window` are not array-like
321  if (obj == null || isWindow(obj)) return false;
322
323  // arrays, strings and jQuery/jqLite objects are array like
324  // * jqLite is either the jQuery or jqLite constructor function
325  // * we have to check the existence of jqLite first as this method is called
326  //   via the forEach method when constructing the jqLite object in the first place
327  if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
328
329  // Support: iOS 8.2 (not reproducible in simulator)
330  // "length" in obj used to prevent JIT error (gh-11508)
331  var length = 'length' in Object(obj) && obj.length;
332
333  // NodeList objects (with `item` method) and
334  // other objects with suitable length characteristics are array-like
335  return isNumber(length) && (length >= 0 && (length - 1) in obj || typeof obj.item === 'function');
336
337}
338
339/**
340 * @ngdoc function
341 * @name angular.forEach
342 * @module ng
343 * @kind function
344 *
345 * @description
346 * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
347 * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
348 * is the value of an object property or an array element, `key` is the object property key or
349 * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
350 *
351 * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
352 * using the `hasOwnProperty` method.
353 *
354 * Unlike ES262's
355 * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
356 * providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
357 * return the value provided.
358 *
359   ```js
360     var values = {name: 'misko', gender: 'male'};
361     var log = [];
362     angular.forEach(values, function(value, key) {
363       this.push(key + ': ' + value);
364     }, log);
365     expect(log).toEqual(['name: misko', 'gender: male']);
366   ```
367 *
368 * @param {Object|Array} obj Object to iterate over.
369 * @param {Function} iterator Iterator function.
370 * @param {Object=} context Object to become context (`this`) for the iterator function.
371 * @returns {Object|Array} Reference to `obj`.
372 */
373
374function forEach(obj, iterator, context) {
375  var key, length;
376  if (obj) {
377    if (isFunction(obj)) {
378      for (key in obj) {
379        if (key !== 'prototype' && key !== 'length' && key !== 'name' && obj.hasOwnProperty(key)) {
380          iterator.call(context, obj[key], key, obj);
381        }
382      }
383    } else if (isArray(obj) || isArrayLike(obj)) {
384      var isPrimitive = typeof obj !== 'object';
385      for (key = 0, length = obj.length; key < length; key++) {
386        if (isPrimitive || key in obj) {
387          iterator.call(context, obj[key], key, obj);
388        }
389      }
390    } else if (obj.forEach && obj.forEach !== forEach) {
391        obj.forEach(iterator, context, obj);
392    } else if (isBlankObject(obj)) {
393      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
394      for (key in obj) {
395        iterator.call(context, obj[key], key, obj);
396      }
397    } else if (typeof obj.hasOwnProperty === 'function') {
398      // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
399      for (key in obj) {
400        if (obj.hasOwnProperty(key)) {
401          iterator.call(context, obj[key], key, obj);
402        }
403      }
404    } else {
405      // Slow path for objects which do not have a method `hasOwnProperty`
406      for (key in obj) {
407        if (hasOwnProperty.call(obj, key)) {
408          iterator.call(context, obj[key], key, obj);
409        }
410      }
411    }
412  }
413  return obj;
414}
415
416function forEachSorted(obj, iterator, context) {
417  var keys = Object.keys(obj).sort();
418  for (var i = 0; i < keys.length; i++) {
419    iterator.call(context, obj[keys[i]], keys[i]);
420  }
421  return keys;
422}
423
424
425/**
426 * when using forEach the params are value, key, but it is often useful to have key, value.
427 * @param {function(string, *)} iteratorFn
428 * @returns {function(*, string)}
429 */
430function reverseParams(iteratorFn) {
431  return function(value, key) {iteratorFn(key, value);};
432}
433
434/**
435 * A consistent way of creating unique IDs in angular.
436 *
437 * Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before
438 * we hit number precision issues in JavaScript.
439 *
440 * Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M
441 *
442 * @returns {number} an unique alpha-numeric string
443 */
444function nextUid() {
445  return ++uid;
446}
447
448
449/**
450 * Set or clear the hashkey for an object.
451 * @param obj object
452 * @param h the hashkey (!truthy to delete the hashkey)
453 */
454function setHashKey(obj, h) {
455  if (h) {
456    obj.$$hashKey = h;
457  } else {
458    delete obj.$$hashKey;
459  }
460}
461
462
463function baseExtend(dst, objs, deep) {
464  var h = dst.$$hashKey;
465
466  for (var i = 0, ii = objs.length; i < ii; ++i) {
467    var obj = objs[i];
468    if (!isObject(obj) && !isFunction(obj)) continue;
469    var keys = Object.keys(obj);
470    for (var j = 0, jj = keys.length; j < jj; j++) {
471      var key = keys[j];
472      var src = obj[key];
473
474      if (deep && isObject(src)) {
475        if (isDate(src)) {
476          dst[key] = new Date(src.valueOf());
477        } else if (isRegExp(src)) {
478          dst[key] = new RegExp(src);
479        } else if (src.nodeName) {
480          dst[key] = src.cloneNode(true);
481        } else if (isElement(src)) {
482          dst[key] = src.clone();
483        } else {
484          if (

484!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
485          baseExtend(dst[key], [src], true);
486        }
487      } else {
488        dst[key] = src;
489      }
490    }
491  }
492
493  setHashKey(dst, h);
494  return dst;
495}
496
497/**
498 * @ngdoc function
499 * @name angular.extend
500 * @module ng
501 * @kind function
502 *
503 * @description
504 * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
505 * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
506 * by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
507 *
508 * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
509 * {@link angular.merge} for this.
510 *
511 * @param {Object} dst Destination object.
512 * @param {...Object} src Source object(s).
513 * @returns {Object} Reference to `dst`.
514 */
515function extend(dst) {
516  return baseExtend(dst, slice.call(arguments, 1), false);
517}
518
519
520/**
521* @ngdoc function
522* @name angular.merge
523* @module ng
524* @kind function
525*
526* @description
527* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
528* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
529* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.
530*
531* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
532* objects, performing a deep copy.
533*
534* @deprecated
535* sinceVersion="1.6.5"
536* This function is deprecated, but will not be removed in the 1.x lifecycle.
537* There are edge cases (see {@link angular.merge#known-issues known issues}) that are not
538* supported by this function. We suggest
539* using [lodash's merge()](https://lodash.com/docs/4.17.4#merge) instead.
540*
541* @knownIssue
542* This is a list of (known) object types that are not handled correctly by this function:
543* - [`Blob`](https://developer.mozilla.org/docs/Web/API/Blob)
544* - [`MediaStream`](https://developer.mozilla.org/docs/Web/API/MediaStream)
545* - [`CanvasGradient`](https://developer.mozilla.org/docs/Web/API/CanvasGradient)
546* - AngularJS {@link $rootScope.Scope scopes};
547*
548* @param {Object} dst Destination object.
549* @param {...Object} src Source object(s).
550* @returns {Object} Reference to `dst`.
551*/
552function merge(dst) {
553  return baseExtend(dst, slice.call(arguments, 1), true);
554}
555
556
557
558function toInt(str) {
559  return parseInt(str, 10);
560}
561
562var isNumberNaN = Number.isNaN || function isNumberNaN(num) {
563  // eslint-disable-next-line no-self-compare
564  return num !== num;
565};
566
567
568function inherit(parent, extra) {
569  return extend(Object.create(parent), extra);
570}
571
572/**
573 * @ngdoc function
574 * @name angular.noop
575 * @module ng
576 * @kind function
577 *
578 * @description
579 * A function that performs no operations. This function can be useful when writing code in the
580 * functional style.
581   ```js
582     function foo(callback) {
583       var result = calculateResult();
584       (callback || angular.noop)(result);
585     }
586   ```
587 */
588function noop() {}
589noop.$inject = [];
590
591
592/**
593 * @ngdoc function
594 * @name angular.identity
595 * @module ng
596 * @kind function
597 *
598 * @description
599 * A function that returns its first argument. This function is useful when writing code in the
600 * functional style.
601 *
602   ```js
603   function transformer(transformationFn, value) {
604     return (transformationFn || angular.identity)(value);
605   };
606
607   // E.g.
608   function getResult(fn, input) {
609     return (fn || angular.identity)(input);
610   };
611
612   getResult(function(n) { return n * 2; }, 21);   // returns 42
613   getResult(null, 21);                            // returns 21
614   getResult(undefined, 21);                       // returns 21
615   ```
616 *
617 * @param {*} value to be returned.
618 * @returns {*} the value passed in.
619 */
620function identity($) {return $;}
621identity.$inject = [];
622
623
624function valueFn(value) {return function valueRef() {return value;};}
625
626function hasCustomToString(obj) {
627  return isFunction(obj.toString) && obj.toString !== toString;
628}
629
630
631/**
632 * @ngdoc function
633 * @name angular.isUndefined
634 * @module ng
635 * @kind function
636 *
637 * @description
638 * Determines if a reference is undefined.
639 *
640 * @param {*} value Reference to check.
641 * @returns {boolean} True if `value` is undefined.
642 */
643function isUndefined(value) {return typeof value === 'undefined';}
644
645
646/**
647 * @ngdoc function
648 * @name angular.isDefined
649 * @module ng
650 * @kind function
651 *
652 * @description
653 * Determines if a reference is defined.
654 *
655 * @param {*} value Reference to check.
656 * @returns {boolean} True if `value` is defined.
657 */
658function isDefined(value) {return typeof value !== 'undefined';}
659
660
661/**
662 * @ngdoc function
663 * @name angular.isObject
664 * @module ng
665 * @kind function
666 *
667 * @description
668 * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
669 * considered to be objects. Note that JavaScript arrays are objects.
670 *
671 * @param {*} value Reference to check.
672 * @returns {boolean} True if `value` is an `Object` but not `null`.
673 */
674function isObject(value) {
675  // http://jsperf.com/isobject4
676  return value !== null && typeof value === 'object';
677}
678
679
680/**
681 * Determine if a value is an object with a null prototype
682 *
683 * @returns {boolean} True if `value` is an `Object` with a null prototype
684 */
685function isBlankObject(value) {
686  return value !== null && typeof value === 'object' && !getPrototypeOf(value);
687}
688
689
690/**
691 * @ngdoc function
692 * @name angular.isString
693 * @module ng
694 * @kind function
695 *
696 * @description
697 * Determines if a reference is a `String`.
698 *
699 * @param {*} value Reference to check.
700 * @returns {boolean} True if `value` is a `String`.
701 */
702function isString(value) {return typeof value === 'string';}
703
704
705/**
706 * @ngdoc function
707 * @name angular.isNumber
708 * @module ng
709 * @kind function
710 *
711 * @description
712 * Determines if a reference is a `Number`.
713 *
714 * This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`.
715 *
716 * If you wish to exclude these then you can use the native
717 * [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
718 * method.
719 *
720 * @param {*} value Reference to check.
721 * @returns {boolean} True if `value` is a `Number`.
722 */
723function isNumber(value) {return typeof value === 'number';}
724
725
726/**
727 * @ngdoc function
728 * @name angular.isDate
729 * @module ng
730 * @kind function
731 *
732 * @description
733 * Determines if a value is a date.
734 *
735 * @param {*} value Reference to check.
736 * @returns {boolean} True if `value` is a `Date`.
737 */
738function isDate(value) {
739  return toString.call(value) === '[object Date]';
740}
741
742
743/**
744 * @ngdoc function
745 * @name angular.isArray
746 * @module ng
747 * @kind function
748 *
749 * @description
750 * Determines if a reference is an `Array`.
751 *
752 * @param {*} value Reference to check.
753 * @returns {boolean} True if `value` is an `Array`.
754 */
755function isArray(arr) {
756  return Array.isArray(arr) || arr instanceof Array;
757}
758
759/**
760 * @description
761 * Determines if a reference is an `Error`.
762 * Loosely based on https://www.npmjs.com/package/iserror
763 *
764 * @param {*} value Reference to check.
765 * @returns {boolean} True if `value` is an `Error`.
766 */
767function isError(value) {
768  var tag = toString.call(value);
769  switch (tag) {
770    case '[object Error]': return true;
771    case '[object Exception]': return true;
772    case '[object DOMException]': return true;
773    default: return value instanceof Error;
774  }
775}
776
777/**
778 * @ngdoc function
779 * @name angular.isFunction
780 * @module ng
781 * @kind function
782 *
783 * @description
784 * Determines if a reference is a `Function`.
785 *
786 * @param {*} value Reference to check.
787 * @returns {boolean} True if `value` is a `Function`.
788 */
789function isFunction(value) {return typeof value === 'function';}
790
791
792/**
793 * Determines if a value is a regular expression object.
794 *
795 * @private
796 * @param {*} value Reference to check.
797 * @returns {boolean} True if `value` is a `RegExp`.
798 */
799function isRegExp(value) {
800  return toString.call(value) === '[object RegExp]';
801}
802
803
804/**
805 * Checks if `obj` is a window object.
806 *
807 * @private
808 * @param {*} obj Object to check
809 * @returns {boolean} True if `obj` is a window obj.
810 */
811function isWindow(obj) {
812  return obj && obj.window === obj;
813}
814
815
816function isScope(obj) {
817  return obj && obj.$evalAsync && obj.$watch;
818}
819
820
821function isFile(obj) {
822  return toString.call(obj) === '[object File]';
823}
824
825
826function isFormData(obj) {
827  return toString.call(obj) === '[object FormData]';
828}
829
830
831function isBlob(obj) {
832  return toString.call(obj) === '[object Blob]';
833}
834
835
836function isBoolean(value) {
837  return typeof value === 'boolean';
838}
839
840
841function isPromiseLike(obj) {
842  return obj && isFunction(obj.then);
843}
844
845
846var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array]$/;
847function isTypedArray(value) {
848  return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
849}
850
851function isArrayBuffer(obj) {
852  return toString.call(obj) === '[object ArrayBuffer]';
853}
854
855
856var trim = function(value) {
857  return isString(value) ? value.trim() : value;
858};
859
860// Copied from:
861// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
862// Prereq: s is a string.
863var escapeForRegexp = function(s) {
864  return s
865    .replace(/([-()[\]{}+?*.$^|,:#<!\\])/g, '\\$1')
866    // eslint-disable-next-line no-control-regex
867    .replace(/\x08/g, '\\x08');
868};
869
870
871/**
872 * @ngdoc function
873 * @name angular.isElement
874 * @module ng
875 * @kind function
876 *
877 * @description
878 * Determines if a reference is a DOM element (or wrapped jQuery element).
879 *
880 * @param {*} value Reference to check.
881 * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
882 */
883function isElement(node) {
884  return !!(node &&
885    (node.nodeName  // We are a direct element.
886    || (node.prop && node.attr && node.find)));  // We have an on and find method part of jQuery API.
887}
888
889/**
890 * @param str 'key1,key2,...'
891 * @returns {object} in the form of {key1:true, key2:true, ...}
892 */
893function makeMap(str) {
894  var obj = {}, items = str.split(','), i;
895  for (i = 0; i < items.length; i++) {
896    obj[items[i]] = true;
897  }
898  return obj;
899}
900
901
902function nodeName_(element) {
903  return lowercase(element.nodeName || (element[0] && element[0].nodeName));
904}
905
906function includes(array, obj) {
907  return Array.prototype.indexOf.call(array, obj) !== -1;
908}
909
910function arrayRemove(array, value) {
911  var index = array.indexOf(value);
912  if (index >= 0) {
913    array.splice(index, 1);
914  }
915  return index;
916}
917
918/**
919 * @ngdoc function
920 * @name angular.copy
921 * @module ng
922 * @kind function
923 *
924 * @description
925 * Creates a deep copy of `source`, which should be an object or an array.
926 *
927 * * If no destination is supplied, a copy of the object or array is created.
928 * * If a destination is provided, all of its elements (for arrays) or properties (for objects)
929 *   are deleted and then all elements/properties from the source are copied to it.
930 * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
931 * * If `source` is identical to `destination` an exception will be thrown.
932 *
933 * <br />
934 * <div class="alert alert-warning">
935 *   Only enumerable properties are taken into account. Non-enumerable properties (both on `source`
936 *   and on `destination`) will be ignored.
937 * </div>
938 *
939 * @param {*} source The source that will be used to make a copy.
940 *                   Can be any type, including primitives, `null`, and `undefined`.
941 * @param {(Object|Array)=} destination Destination into which the source is copied. If
942 *     provided,

942 must be of the same type as `source`.
943 * @returns {*} The copy or updated `destination`, if `destination` was specified.
944 *
945 * @example
946  <example module="copyExample" name="angular-copy">
947    <file name="index.html">
948      <div ng-controller="ExampleController">
949        <form novalidate class="simple-form">
950          <label>Name: <input type="text" ng-model="user.name" /></label><br />
951          <label>Age:  <input type="number" ng-model="user.age" /></label><br />
952          Gender: <label><input type="radio" ng-model="user.gender" value="male" />male</label>
953                  <label><input type="radio" ng-model="user.gender" value="female" />female</label><br />
954          <button ng-click="reset()">RESET</button>
955          <button ng-click="update(user)">SAVE</button>
956        </form>
957        <pre>form = {{user | json}}</pre>
958        <pre>leader = {{leader | json}}</pre>
959      </div>
960    </file>
961    <file name="script.js">
962      // Module: copyExample
963      angular.
964        module('copyExample', []).
965        controller('ExampleController', ['$scope', function($scope) {
966          $scope.leader = {};
967
968          $scope.reset = function() {
969            // Example with 1 argument
970            $scope.user = angular.copy($scope.leader);
971          };
972
973          $scope.update = function(user) {
974            // Example with 2 arguments
975            angular.copy(user, $scope.leader);
976          };
977
978          $scope.reset();
979        }]);
980    </file>
981  </example>
982 */
983function copy(source, destination, maxDepth) {
984  var stackSource = [];
985  var stackDest = [];
986  maxDepth = isValidObjectMaxDepth(maxDepth) ? maxDepth : NaN;
987
988  if (destination) {
989    if (isTypedArray(destination) || isArrayBuffer(destination)) {
990      throw ngMinErr('cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
991    }
992    if (source === destination) {
993      throw ngMinErr('cpi', 'Can\'t copy! Source and destination are identical.');
994    }
995
996    // Empty the destination object
997    if (isArray(destination)) {
998      destination.length = 0;
999    } else {
1000      forEach(destination, function(value, key) {
1001        if (key !== '$$hashKey') {
1002          delete destination[key];
1003        }
1004      });
1005    }
1006
1007    stackSource.push(source);
1008    stackDest.push(destination);
1009    return copyRecurse(source, destination, maxDepth);
1010  }
1011
1012  return copyElement(source, maxDepth);
1013
1014  function copyRecurse(source, destination, maxDepth) {
1015    maxDepth--;
1016    if (maxDepth < 0) {
1017      return '...';
1018    }
1019    var h = destination.$$hashKey;
1020    var key;
1021    if (isArray(source)) {
1022      for (var i = 0, ii = source.length; i < ii; i++) {
1023        destination.push(copyElement(source[i], maxDepth));
1024      }
1025    } else if (isBlankObject(source)) {
1026      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
1027      for (key in source) {
1028        destination[key] = copyElement(source[key], maxDepth);
1029      }
1030    } else if (source && typeof source.hasOwnProperty === 'function') {
1031      // Slow path, which must rely on hasOwnProperty
1032      for (key in source) {
1033        if (source.hasOwnProperty(key)) {
1034          destination[key] = copyElement(source[key], maxDepth);
1035        }
1036      }
1037    } else {
1038      // Slowest path --- hasOwnProperty can't be called as a method
1039      for (key in source) {
1040        if (hasOwnProperty.call(source, key)) {
1041          destination[key] = copyElement(source[key], maxDepth);
1042        }
1043      }
1044    }
1045    setHashKey(destination, h);
1046    return destination;
1047  }
1048
1049  function copyElement(source, maxDepth) {
1050    // Simple values
1051    if (!isObject(source)) {
1052      return source;
1053    }
1054
1055    // Already copied values
1056    var index = stackSource.indexOf(source);
1057    if (index !== -1) {
1058      return stackDest[index];
1059    }
1060
1061    if (isWindow(source) || isScope(source)) {
1062      throw ngMinErr('cpws',
1063        'Can\'t copy! Making copies of Window or Scope instances is not supported.');
1064    }
1065
1066    var needsRecurse = false;
1067    var destination = copyType(source);
1068
1069    if (destination === undefined) {
1070      destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
1071      needsRecurse = true;
1072    }
1073
1074    stackSource.push(source);
1075    stackDest.push(destination);
1076
1077    return needsRecurse
1078      ? copyRecurse(source, destination, maxDepth)
1079      : destination;
1080  }
1081
1082  function copyType(source) {
1083    switch (toString.call(source)) {
1084      case '[object Int8Array]':
1085      case '[object Int16Array]':
1086      case '[object Int32Array]':
1087      case '[object Float32Array]':
1088      case '[object Float64Array]':
1089      case '[object Uint8Array]':
1090      case '[object Uint8ClampedArray]':
1091      case '[object Uint16Array]':
1092      case '[object Uint32Array]':
1093        return new source.constructor(copyElement(source.buffer), source.byteOffset, source.length);
1094
1095      case '[object ArrayBuffer]':
1096        // Support: IE10
1097        if (!source.slice) {
1098          // If we're in this case we know the environment supports ArrayBuffer
1099          /* eslint-disable no-undef */
1100          var copied = new ArrayBuffer(source.byteLength);
1101          new Uint8Array(copied).set(new Uint8Array(source));
1102          /* eslint-enable */
1103          return copied;
1104        }
1105        return source.slice(0);
1106
1107      case '[object Boolean]':
1108      case '[object Number]':
1109      case '[object String]':
1110      case '[object Date]':
1111        return new source.constructor(source.valueOf());
1112
1113      case '[object RegExp]':
1114        var re = new RegExp(source.source, source.toString().match(/[^/]*$/)[0]);
1115        re.lastIndex = source.lastIndex;
1116        return re;
1117
1118      case '[object Blob]':
1119        return new source.constructor([source], {type: source.type});
1120    }
1121
1122    if (isFunction(source.cloneNode)) {
1123      return source.cloneNode(true);
1124    }
1125  }
1126}
1127
1128
1129// eslint-disable-next-line no-self-compare
1130function simpleCompare(a, b) { return a === b || (a !== a && b !== b); }
1131
1132
1133/**
1134 * @ngdoc function
1135 * @name angular.equals
1136 * @module ng
1137 * @kind function
1138 *
1139 * @description
1140 * Determines if two objects or two values are equivalent. Supports value types, regular
1141 * expressions, arrays and objects.
1142 *
1143 * Two objects or values are considered equivalent if at least one of the following is true:
1144 *
1145 * * Both objects or values pass `===` comparison.
1146 * * Both objects or values are of the same type and all of their properties are equal by
1147 *   comparing them with `angular.equals`.
1148 * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
1149 * * Both values represent the same regular expression (In JavaScript,
1150 *   /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
1151 *   representation matches).
1152 *
1153 * During a property comparison, properties of `function` type and properties with names
1154 * that begin with `$` are ignored.
1155 *
1156 * Scope and DOMWindow objects are being compared only by identify (`===`).
1157 *
1158 * @param {*} o1 Object or value to compare.
1159 * @param {*} o2 Object or value to compare.
1160 * @returns {boolean} True if arguments are equal.
1161 *
1162 * @example
1163   <example module="equalsExample" name="equalsExample">
1164     <file name="index.html">
1165      <div ng-controller="ExampleController">
1166        <form novalidate>
1167          <h3>User 1</h3>
1168          Name: <input type="text" ng-model="user1.name">
1169          Age: <input type="number" ng-model="user1.age">
1170
1171          <h3>User 2</h3>
1172          Name: <input type="text" ng-model="user2.name">
1173          Age: <input type="number" ng-model="user2.age">
1174
1175          <div>
1176            <br/>
1177            <input type="button" value="Compare" ng-click="compare()">
1178          </div>
1179          User 1: <pre>{{user1 | json}}</pre>
1180          User 2: <pre>{{user2 | json}}</pre>
1181          Equal: <pre>{{result}}</pre>
1182        </form>
1183      </div>
1184    </file>
1185    <file name="script.js">
1186        angular.module('equalsExample', []).controller('ExampleController', ['$scope', function($scope) {
1187          $scope.user1 = {};
1188          $scope.user2 = {};
1189          $scope.compare = function() {
1190            $scope.result = angular.equals($scope.user1, $scope.user2);
1191          };
1192        }]);
1193    </file>
1194  </example>
1195 */
1196function equals(o1, o2) {
1197  if (o1 === o2) return true;
1198  if (o1 === null || o2 === null) return false;
1199  // eslint-disable-next-line no-self-compare
1200  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
1201  var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
1202  if (t1 === t2 && t1 === 'object') {
1203    if (isArray(o1)) {
1204      if (!isArray(o2)) return false;
1205      if ((length = o1.length) === o2.length) {
1206        for (key = 0; key < length; key++) {
1207          if (!equals(o1[key], o2[key])) return false;
1208        }
1209        return true;
1210      }
1211    } else if (isDate(o1)) {
1212      if (!isDate(o2)) return false;
1213      return simpleCompare(o1.getTime(), o2.getTime());
1214    } else if (isRegExp(o1)) {
1215      if (!isRegExp(o2)) return false;
1216      return o1.toString() === o2.toString();
1217    } else {
1218      if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
1219        isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
1220      keySet = createMap();
1221      for (key in o1) {
1222        if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
1223        if (!equals(o1[key], o2[key])) return false;
1224        keySet[key] = true;
1225      }
1226      for (key in o2) {
1227        if (!(key in keySet) &&
1228            key.charAt(0) !== '$' &&
1229            isDefined(o2[key]) &&
1230            !isFunction(o2[key])) return false;
1231      }
1232      return true;
1233    }
1234  }
1235  return false;
1236}
1237
1238var csp = function() {
1239  if (!isDefined(csp.rules)) {
1240
1241
1242    var ngCspElement = (window.document.querySelector('[ng-csp]') ||
1243                    window.document.querySelector('[data-ng-csp]'));
1244
1245    if (ngCspElement) {
1246      var ngCspAttribute = ngCspElement.getAttribute('ng-csp') ||
1247                    ngCspElement.getAttribute('data-ng-csp');
1248      csp.rules = {
1249        noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
1250        noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1)
1251      };
1252    } else {
1253      csp.rules = {
1254        noUnsafeEval: noUnsafeEval(),
1255        noInlineStyle: false
1256      };
1257    }
1258  }
1259
1260  return csp.rules;
1261
1262  function noUnsafeEval() {
1263    try {
1264      // eslint-disable-next-line no-new, no-new-func
1265      new Function('');
1266      return false;
1267    } catch (e) {
1268      return true;
1269    }
1270  }
1271};
1272
1273/**
1274 * @ngdoc directive
1275 * @module ng
1276 * @name ngJq
1277 *
1278 * @element ANY
1279 * @param {string=} ngJq the name of the library available under `window`
1280 * to be used for angular.element
1281 * @description
1282 * Use this directive to force the angular.element library.  This should be
1283 * used to force either jqLite by leaving ng-jq blank or setting the name of
1284 * the jquery variable under window (eg. jQuery).
1285 *
1286 * Since AngularJS looks for this directive when it is loaded (doesn't wait for the
1287 * DOMContentLoaded event), it must be placed on an element that comes before the script
1288 * which loads angular. Also, only the first instance of `ng-jq` will be used and all
1289 * others ignored.
1290 *
1291 * @example
1292 * This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
1293 ```html
1294 <!doctype html>
1295 <html ng-app ng-jq>
1296 ...
1297 ...
1298 </html>
1299 ```
1300 * @example
1301 * This example shows how to use a jQuery based library of a different name.
1302 * The library name must be available at the top most 'window'.
1303 ```html
1304 <!doctype html>
1305 <html ng-app ng-jq="jQueryLib">
1306 ...
1307 ...
1308 </html>
1309 ```
1310 */
1311var jq = function() {
1312  if (isDefined(jq.name_)) return jq.name_;
1313  var el;
1314  var i, ii = ngAttrPrefixes.length, prefix, name;
1315  for (i = 0; i < ii; ++i) {
1316    prefix = ngAttrPrefixes[i];
1317    el = window.document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]');
1318    if (el) {
1319      name = el.getAttribute(prefix + 'jq');
1320      break;
1321    }
1322  }
1323
1324  return (jq.name_ = name);
1325};
1326
1327function concat(array1, array2, index) {
1328  return array1.concat(slice.call(array2, index));
1329}
1330
1331function sliceArgs(args, startIndex) {
1332  return slice.call(args, startIndex || 0);
1333}
1334
1335
1336/**
1337 * @ngdoc function
1338 * @name angular.bind
1339 * @module ng
1340 * @kind function
1341 *
1342 * @description
1343 * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
1344 * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
1345 * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
1346 * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
1347 *
1348 * @param {Object} self Context which `fn` should be evaluated in.
1349 * @param {function()} fn Function to be bound.
1350 * @param {...*} args Optional arguments to be prebound to the `fn` function call.
1351 * @returns {function()} Function that wraps the `fn` with all the specified bindings.
1352 */
1353function bind(self, fn) {
1354  var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
1355  if (isFunction(fn) && !(fn instanceof RegExp)) {
1356    return curryArgs.length
1357      ? function() {
1358          return arguments.length
1359            ? fn.apply(self, concat(curryArgs, arguments, 0))
1360            : fn.apply(self, curryArgs);
1361        }
1362      : function() {
1363          return arguments.length
1364            ? fn.apply(self, arguments)
1365            : fn.call(self);
1366        };
1367  } else {
1368    // In IE, native methods are not functions so they cannot be bound (note: they don't need to be).
1369    return fn;
1370  }
1371}
1372
1373
1374function toJsonReplacer(key, value) {
1375  var val = value;
1376
1377  if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
1378    val = undefined;
1379  } else if (isWindow(value)) {
1380    val = '$WINDOW';
1381  } else if (value &&  window.document === value) {
1382    val = '$DOCUMENT';
1383  } else if (isScope(value)) {
1384    val = '$SCOPE';
1385  }
1386
1387  return val;
1388}
1389
1390
1391/**
1392 * @ngdoc function
1393 * @name angular.toJson
1394 * @module ng
1395 * @kind function
1396 *
1397 * @description
1398 * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
1399 * stripped since AngularJS uses this notation internally.
1400 *
1401 * @param {Object|Array|Date|string|number|boolean} obj Input to be serialized into JSON.
1402 * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
1403 *    If set to an integer, the JSON output will contain that many spaces per indentation.
1404 * @returns {string|undefined} JSON-ified string representing `obj`.
1405 * @knownIssue
1406 *
1407 * The Safari browser throws a `RangeError` instead of returning `null` when it tries to stringify a `Date`
1408 * object with an invalid date value. The only reliable way to prevent this is to monkeypatch the
1409 * `Date.prototype.toJSON` method as follows:
1410 *
1411 * ```
1412 * var _DatetoJSON = Date.prototype.toJSON;
1413 * Date.prototype.toJSON = function() {
1414 *   try {
1415 *     return _DatetoJSON.call(this);
1416 *   } catch(e) {
1417 *     if (e instanceof RangeError) {
1418 *       return null;
1419 *     }
1420 *     throw e;
1421 *   }
1422 * };
1423 * ```
1424 *
1425 * See https://github.com/angular/angular.js/pull/14221 for more information.
1426 */
1427function toJson(obj, pretty) {
1428  if (isUndefined(obj)) return undefined;
1429  if (!isNumber(pretty)) {
1430    pretty = pretty ? 2 : null;
1431  }
1432  return JSON.stringify(obj, toJsonReplacer, pretty);
1433}
1434
1435
1436/**
1437 * @ngdoc function
1438 * @name angular.fromJson
1439 * @module ng
1440 * @kind function
1441 *
1442 * @description
1443 * Deserializes a JSON string.
1444 *
1445 * @param {string} json JSON string to deserialize.
1446 * @returns {Object|Array|string|number} Deserialized JSON string.
1447 */
1448function fromJson(json) {
1449  return isString(json)
1450      ? JSON.parse(json)
1451      : json;
1452}
1453
1454
1455var ALL_COLONS = /:/g;
1456function timezoneToOffset(timezone, fallback) {
1457  // Support: IE 9-11 only, Edge 13-15+
1458  // IE/Edge do not "understand" colon (`:`) in timezone
1459  timezone = timezone.replace(ALL_COLONS, '');
1460  var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
1461  return isNumberNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
1462}
1463
1464
1465function addDateMinutes(date, minutes) {
1466  date = new Date(date.getTime());
1467  date.setMinutes(date.getMinutes() + minutes);
1468  return date;
1469}
1470
1471
1472function convertTimezoneToLocal(date, timezone, reverse) {
1473  reverse = reverse ? -1 : 1;
1474  var dateTimezoneOffset = date.getTimezoneOffset();
1475  var timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
1476  return addDateMinutes(date, reverse * (timezoneOffset - dateTimezoneOffset));
1477}
1478
1479
1480/**
1481 * @returns {string} Returns the string representation of the element.
1482 */
1483function startingTag(element) {
1484  element = jqLite(element).clone().empty();
1485  var elemHtml = jqLite('<div></div>').append(element).html();
1486  try {
1487    return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
1488        elemHtml.
1489          match(/^(<[^>]+>)/)[1].
1490          replace(/^<([\w-]+)/, function(match, nodeName) {return '<' + lowercase(nodeName);});
1491  } catch (e) {
1492    return lowercase(elemHtml);
1493  }
1494
1495}
1496
1497
1498/////////////////////////////////////////////////
1499
1500/**
1501 * Tries to decode the URI component without throwing an exception.
1502 *
1503 * @private
1504 * @param str value potential URI component to check.
1505 * @returns {boolean} True if `value` can be decoded
1506 * with the decodeURIComponent function.
1507 */
1508function tryDecodeURIComponent(value) {
1509  try {
1510    return decodeURIComponent(value);
1511  } catch (e) {
1512    // Ignore any invalid uri component.
1513  }
1514}
1515
1516
1517/**
1518 * Parses an escaped url query string into key-value pairs.
1519 * @returns {Object.<string,boolean|Array>}
1520 */
1521function parseKeyValue(/**string*/keyValue) {
1522  var obj = {};
1523  forEach((keyValue || '').split('&'), function(keyValue) {
1524    var splitPoint, key, val;
1525    if (keyValue) {
1526      key = keyValue = keyValue.replace(/\+/g,'%20');
1527      splitPoint = keyValue.indexOf('=');
1528      if (splitPoint !== -1) {
1529        key = keyValue.substring(0, splitPoint);
1530        val = keyValue.substring(splitPoint + 1);
1531      }
1532      key = tryDecodeURIComponent(key);
1533      if (isDefined(key)) {
1534        val = isDefined(val) ? tryDecodeURIComponent(val) : true;
1535        if (!hasOwnProperty.call(obj, key)) {
1536          obj[key] = val;
1537        } else if (isArray(obj[key])) {
1538          obj[key].push(val);
1539        } else {
1540          obj[key] = [obj[key],val];
1541        }
1542      }
1543    }
1544  });
1545  return obj;
1546}
1547
1548function toKeyValue(obj) {
1549  var parts = [];
1550  forEach(obj, function(value, key) {
1551    if (isArray(value)) {
1552      forEach(value, function(arrayValue) {
1553        parts.push(encodeUriQuery(key, true) +
1554                   (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
1555      });
1556    } else {
1557    parts.push(encodeUriQuery(key, true) +
1558               (value === true ? '' : '=' + encodeUriQuery(value, true)));
1559    }
1560  });
1561  return parts.length ? parts.join('&') : '';
1562}
1563
1564
1565/**
1566 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
1567 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
1568 * segments:
1569 *    segment       = *pchar
1570 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1571 *    pct-encoded   = "%" HEXDIG HEXDIG
1572 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1573 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1574 *                     / "*" / "+" / "," / ";" / "="
1575 */
1576function encodeUriSegment(val) {
1577  return encodeUriQuery(val, true).
1578             replace(/%26/gi, '&').
1579             replace(/%3D/gi, '=').
1580             replace(/%2B/gi, '+');
1581}
1582
1583
1584/**
1585 * This method is intended for encoding *key* or *value* parts of query component. We need a custom
1586 * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
1587 * encoded per http://tools.ietf.org/html/rfc3986:
1588 *    query         = *( pchar / "/" / "?" )
1589 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1590 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1591 *    pct-encoded   = "%" HEXDIG HEXDIG
1592 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1593 *                     / "*" / "+" / "," / ";" / "="
1594 */
1595function encodeUriQuery(val, pctEncodeSpaces) {
1596  return encodeURIComponent(val).
1597             replace(/%40/gi, '@').
1598             replace(/%3A/gi, ':').
1599             replace(/%24/g, '$').
1600             replace(/%2C/gi, ',').
1601             replace(/%3B/gi, ';').
1602             replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
1603}
1604
1605var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
1606
1607function getNgAttribute(element, ngAttr) {
1608  var attr, i, ii = ngAttrPrefixes.length;
1609  for (i = 0; i < ii; ++i) {
1610    attr = ngAttrPrefixes[i] + ngAttr;
1611    if (isString(attr = element.getAttribute(attr))) {
1612      return attr;
1613    }
1614  }
1615  return null;
1616}
1617
1618function allowAutoBootstrap(document) {
1619  var script = document.currentScript;
1620
1621  if (!script) {
1622    // Support: IE 9-11 only
1623    // IE does not have `document.currentScript`
1624    return true;
1625  }
1626
1627  // If the `currentScript` property has been clobbered just return false, since this indicates a probable attack
1628  if (!(script instanceof window.HTMLScriptElement || script instanceof window.SVGScriptElement)) {
1629    return false;
1630  }
1631
1632  var attributes = script.attributes;
1633  var srcs = [attributes.getNamedItem('src'), attributes.getNamedItem('href'), attributes.getNamedItem('xlink:href')];
1634
1635  return srcs.every(function(src) {
1636    if (!src) {
1637      return true;
1638    }
1639    if (!src.value) {
1640      return false;
1641    }
1642
1643    var link = document.createElement('a');
1644    link.href = src.value;
1645
1646    if (document.location.origin === link.origin) {
1647      // Same-origin resources are always allowed, even for 

1837      try {
1838        window.console.error('AngularJS: disabling automatic bootstrap. <script> protocol indicates ' +
1839          'an extension, document.location.href does not match.');
1840      } catch (e) {
1841        // Support: Safari 11 w/ Webdriver
1842        // The console.error will throw and make the test fail
1843      }
1844      return;
1845    }
1846    config.strictDi = getNgAttribute(appElement, 'strict-di') !== null;
1847    bootstrap(appElement, module ? [module] : [], config);
1848  }
1849}
1850
1851/**
1852 * @ngdoc function
1853 * @name angular.bootstrap
1854 * @module ng
1855 * @description
1856 * Use this function to manually start up AngularJS application.
1857 *
1858 * For more information, see the {@link guide/bootstrap Bootstrap guide}.
1859 *
1860 * AngularJS will detect if it has been loaded into the browser more than once and only allow the
1861 * first loaded script to be bootstrapped and will report a warning to the browser console for
1862 * each of the subsequent scripts. This prevents strange results in applications, where otherwise
1863 * multiple instances of AngularJS try to work on the DOM.
1864 *
1865 * <div class="alert alert-warning">
1866 * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
1867 * They must use {@link ng.directive:ngApp ngApp}.
1868 * </div>
1869 *
1870 * <div class="alert alert-warning">
1871 * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
1872 * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
1873 * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
1874 * causing animations to stop working and making the injector inaccessible from outside the app.
1875 * </div>
1876 *
1877 * ```html
1878 * <!doctype html>
1879 * <html>
1880 * <body>
1881 * <div ng-controller="WelcomeController">
1882 *   {{greeting}}
1883 * </div>
1884 *
1885 * <script src="angular.js"></script>
1886 * <script>
1887 *   var app = angular.module('demo', [])
1888 *   .controller('WelcomeController', function($scope) {
1889 *       $scope.greeting = 'Welcome!';
1890 *   });
1891 *   angular.bootstrap(document, ['demo']);
1892 * </script>
1893 * </body>
1894 * </html>
1895 * ```
1896 *
1897 * @param {DOMElement} element DOM element which is the root of AngularJS application.
1898 * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
1899 *     Each item in the array should be the name of a predefined module or a (DI annotated)
1900 *     function that will be invoked by the injector as a `config` block.
1901 *     See: {@link angular.module modules}
1902 * @param {Object=} config an object for defining configuration options for the application. The
1903 *     following keys are supported:
1904 *
1905 * * `strictDi` - disable automatic function annotation for the application. This is meant to
1906 *   assist in finding bugs which break minified code. Defaults to `false`.
1907 *
1908 * @returns {auto.$injector} Returns the newly created injector for this app.
1909 */
1910function bootstrap(element, modules, config) {
1911  if (!isObject(config)) config = {};
1912  var defaultConfig = {
1913    strictDi: false
1914  };
1915  config = extend(defaultConfig, config);
1916  var doBootstrap = function() {
1917    element = jqLite(element);
1918
1919    if (element.injector()) {
1920      var tag = (element[0] === window.document) ? 'document' : startingTag(element);
1921      // Encode angle brackets to prevent input from being sanitized to empty string #8683.
1922      throw ngMinErr(
1923          'btstrpd',
1924          'App already bootstrapped with this element \'{0}\'',
1925          tag.replace(/</,'&lt;').replace(/>/,'&gt;'));
1926    }
1927
1928    modules = modules || [];
1929    modules.unshift(['$provide', function($provide) {
1930      $provide.value('$rootElement', element);
1931    }]);
1932
1933    if (config.debugInfoEnabled) {
1934      // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
1935      modules.push(['$compileProvider', function($compileProvider) {
1936        $compileProvider.debugInfoEnabled(true);
1937      }]);
1938    }
1939
1940    modules.unshift('ng');
1941    var injector = createInjector(modules, config.strictDi);
1942    injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
1943       function bootstrapApply(scope, element, compile, injector) {
1944        scope.$apply(function() {
1945          element.data('$injector', injector);
1946          compile(element)(scope);
1947        });
1948      }]
1949    );
1950    return injector;
1951  };
1952
1953  var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
1954  var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
1955
1956  if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
1957    config.debugInfoEnabled = true;
1958    window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
1959  }
1960
1961  if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
1962    return doBootstrap();
1963  }
1964
1965  window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
1966  angular.resumeBootstrap = function(extraModules) {
1967    forEach(extraModules, function(module) {
1968      modules.push(module);
1969    });
1970    return doBootstrap();
1971  };
1972
1973  if (isFunction(angular.resumeDeferredBootstrap)) {
1974    angular.resumeDeferredBootstrap();
1975  }
1976}
1977
1978/**
1979 * @ngdoc function
1980 * @name angular.reloadWithDebugInfo
1981 * @module ng
1982 * @description
1983 * Use this function to reload the current application with debug information turned on.
1984 * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
1985 *
1986 * See {@link ng.$compileProvider#debugInfoEnabled} for more.
1987 */
1988function reloadWithDebugInfo() {
1989  window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
1990  window.location.reload();
1991}
1992
1993/**
1994 * @name angular.getTestability
1995 * @module ng
1996 * @description
1997 * Get the testability service for the instance of AngularJS on the given
1998 * element.
1999 * @param {DOMElement} element DOM element which is the root of AngularJS application.
2000 */
2001function getTestability(rootElement) {
2002  var injector = angular.element(rootElement).injector();
2003  if (!injector) {
2004    throw ngMinErr('test',
2005      'no injector found for element argument to getTestability');
2006  }
2007  return injector.get('$$testability');
2008}
2009
2010var SNAKE_CASE_REGEXP = /[A-Z]/g;
2011function snake_case(name, separator) {
2012  separator = separator || '_';
2013  return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
2014    return (pos ? separator : '') + letter.toLowerCase();
2015  });
2016}
2017
2018var bindJQueryFired = false;
2019function bindJQuery() {
2020  var originalCleanData;
2021
2022  if (bindJQueryFired) {
2023    return;
2024  }
2025
2026  // bind to jQuery if present;
2027  var jqName = jq();
2028  jQuery = isUndefined(jqName) ? window.jQuery :   // use jQuery (if present)
2029           !jqName             ? undefined     :   // use jqLite
2030                                 window[jqName];   // use jQuery specified by `ngJq`
2031
2032  // Use jQuery if it exists with proper functionality, otherwise default to us.
2033  // AngularJS 1.2+ requires jQuery 1.7+ for on()/off() support.
2034  // AngularJS 1.3+ technically requires at least jQuery 2.1+ but it may work with older
2035  // versions. It will not work for sure with jQuery <1.7, though.
2036  if (jQuery && jQuery.fn.on) {
2037    jqLite = jQuery;
2038    extend(jQuery.fn, {
2039      scope: JQLitePrototype.scope,
2040      isolateScope: JQLitePrototype.isolateScope,
2041      controller: /** @type {?} */ (JQLitePrototype).controller,
2042      injector: JQLitePrototype.injector,
2043      inheritedData: JQLitePrototype.inheritedData
2044    });
2045  } else {
2046    jqLite = JQLite;
2047  }
2048
2049  // All nodes removed from the DOM via various jqLite/jQuery APIs like .remove()
2050  // are passed through jqLite/jQuery.cleanData. Monkey-patch this method to fire
2051  // the $destroy event on all removed nodes.
2052  originalCleanData = jqLite.cleanData;
2053  jqLite.cleanData = function(elems) {
2054    var events;
2055    for (var i = 0, elem; (elem = elems[i]) != null; i++) {
2056      events = (jqLite._data(elem) || {}).events;
2057      if (events && events.$destroy) {
2058        jqLite(elem).triggerHandler('$destroy');
2059      }
2060    }
2061    originalCleanData(elems);
2062  };
2063
2064  angular.element = jqLite;
2065
2066  // Prevent double-proxying.
2067  bindJQueryFired

2067 = true;
2068}
2069
2070/**
2071 * throw error if the argument is falsy.
2072 */
2073function assertArg(arg, name, reason) {
2074  if (!arg) {
2075    throw ngMinErr('areq', 'Argument \'{0}\' is {1}', (name || '?'), (reason || 'required'));
2076  }
2077  return arg;
2078}
2079
2080function assertArgFn(arg, name, acceptArrayAnnotation) {
2081  if (acceptArrayAnnotation && isArray(arg)) {
2082      arg = arg[arg.length - 1];
2083  }
2084
2085  assertArg(isFunction(arg), name, 'not a function, got ' +
2086      (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
2087  return arg;
2088}
2089
2090/**
2091 * throw error if the name given is hasOwnProperty
2092 * @param  {String} name    the name to test
2093 * @param  {String} context the context in which the name is used, such as module or directive
2094 */
2095function assertNotHasOwnProperty(name, context) {
2096  if (name === 'hasOwnProperty') {
2097    throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
2098  }
2099}
2100
2101/**
2102 * Return the value accessible from the object by path. Any undefined traversals are ignored
2103 * @param {Object} obj starting object
2104 * @param {String} path path to traverse
2105 * @param {boolean} [bindFnToScope=true]
2106 * @returns {Object} value as accessible by path
2107 */
2108//TODO(misko): this function needs to be removed
2109function getter(obj, path, bindFnToScope) {
2110  if (!path) return obj;
2111  var keys = path.split('.');
2112  var key;
2113  var lastInstance = obj;
2114  var len = keys.length;
2115
2116  for (var i = 0; i < len; i++) {
2117    key = keys[i];
2118    if (obj) {
2119      obj = (lastInstance = obj)[key];
2120    }
2121  }
2122  if (!bindFnToScope && isFunction(obj)) {
2123    return bind(lastInstance, obj);
2124  }
2125  return obj;
2126}
2127
2128/**
2129 * Return the DOM siblings between the first and last node in the given array.
2130 * @param {Array} array like object
2131 * @returns {Array} the inputted object or a jqLite collection containing the nodes
2132 */
2133function getBlockNodes(nodes) {
2134  // TODO(perf): update `nodes` instead of creating a new object?
2135  var node = nodes[0];
2136  var endNode = nodes[nodes.length - 1];
2137  var blockNodes;
2138
2139  for (var i = 1; node !== endNode && (node = node.nextSibling); i++) {
2140    if (blockNodes || nodes[i] !== node) {
2141      if (!blockNodes) {
2142        blockNodes = jqLite(slice.call(nodes, 0, i));
2143      }
2144      blockNodes.push(node);
2145    }
2146  }
2147
2148  return blockNodes || nodes;
2149}
2150
2151
2152/**
2153 * Creates a new object without a prototype. This object is useful for lookup without having to
2154 * guard against prototypically inherited properties via hasOwnProperty.
2155 *
2156 * Related micro-benchmarks:
2157 * - http://jsperf.com/object-create2
2158 * - http://jsperf.com/proto-map-lookup/2
2159 * - http://jsperf.com/for-in-vs-object-keys2
2160 *
2161 * @returns {Object}
2162 */
2163function createMap() {
2164  return Object.create(null);
2165}
2166
2167function stringify(value) {
2168  if (value == null) { // null || undefined
2169    return '';
2170  }
2171  switch (typeof value) {
2172    case 'string':
2173      break;
2174    case 'number':
2175      value = '' + value;
2176      break;
2177    default:
2178      if (hasCustomToString(value) && !isArray(value) && !isDate(value)) {
2179        value = value.toString();
2180      } else {
2181        value = toJson(value);
2182      }
2183  }
2184
2185  return value;
2186}
2187
2188var NODE_TYPE_ELEMENT = 1;
2189var NODE_TYPE_ATTRIBUTE = 2;
2190var NODE_TYPE_TEXT = 3;
2191var NODE_TYPE_COMMENT = 8;
2192var NODE_TYPE_DOCUMENT = 9;
2193var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
2194
2195/**
2196 * @ngdoc type
2197 * @name angular.Module
2198 * @module ng
2199 * @description
2200 *
2201 * Interface for configuring AngularJS {@link angular.module modules}.
2202 */
2203
2204function setupModuleLoader(window) {
2205
2206  var $injectorMinErr = minErr('$injector');
2207  var ngMinErr = minErr('ng');
2208
2209  function ensure(obj, name, factory) {
2210    return obj[name] || (obj[name] = factory());
2211  }
2212
2213  var angular = ensure(window, 'angular', Object);
2214
2215  // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
2216  angular.$$minErr = angular.$$minErr || minErr;
2217
2218  return ensure(angular, 'module', function() {
2219    /** @type {Object.<string, angular.Module>} */
2220    var modules = {};
2221
2222    /**
2223     * @ngdoc function
2224     * @name angular.module
2225     * @module ng
2226     * @description
2227     *
2228     * The `angular.module` is a global place for creating, registering and retrieving AngularJS
2229     * modules.
2230     * All modules (AngularJS core or 3rd party) that should be available to an application must be
2231     * registered using this mechanism.
2232     *
2233     * Passing one argument retrieves an existing {@link angular.Module},
2234     * whereas passing more than one argument creates a new {@link angular.Module}
2235     *
2236     *
2237     * # Module
2238     *
2239     * A module is a collection of services, directives, controllers, filters, and configuration information.
2240     * `angular.module` is used to configure the {@link auto.$injector $injector}.
2241     *
2242     * ```js
2243     * // Create a new module
2244     * var myModule = angular.module('myModule', []);
2245     *
2246     * // register a new service
2247     * myModule.value('appName', 'MyCoolApp');
2248     *
2249     * // configure existing services inside initialization blocks.
2250     * myModule.config(['$locationProvider', function($locationProvider) {
2251     *   // Configure existing providers
2252     *   $locationProvider.hashPrefix('!');
2253     * }]);
2254     * ```
2255     *
2256     * Then you can create an injector and load your modules like this:
2257     *
2258     * ```js
2259     * var injector = angular.injector(['ng', 'myModule'])
2260     * ```
2261     *
2262     * However it's more likely that you'll just use
2263     * {@link ng.directive:ngApp ngApp} or
2264     * {@link angular.bootstrap} to simplify this process for you.
2265     *
2266     * @param {!string} name The name of the module to create or retrieve.
2267     * @param {!Array.<string>=} requires If specified then new module is being created. If
2268     *        unspecified then the module is being retrieved for further configuration.
2269     * @param {Function=} configFn Optional configuration function for the module. Same as
2270     *        {@link angular.Module#config Module#config()}.
2271     * @returns {angular.Module} new module with the {@link angular.Module} api.
2272     */
2273    return function module(name, requires, configFn) {
2274
2275      var info = {};
2276
2277      var assertNotHasOwnProperty = function(name, context) {
2278        if (name === 'hasOwnProperty') {
2279          throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
2280        }
2281      };
2282
2283      assertNotHasOwnProperty(name, 'module');
2284      if (requires && modules.hasOwnProperty(name)) {
2285        modules[name] = null;
2286      }
2287      return ensure(modules, name, function() {
2288        if (!requires) {
2289          throw $injectorMinErr('nomod', 'Module \'{0}\' is not available! You either misspelled ' +
2290             'the module name or forgot to load it. If registering a module ensure that you ' +
2291             'specify the dependencies as the second argument.', name);
2292        }
2293
2294        /** @type {!Array.<Array.<*>>} */
2295        var invokeQueue = [];
2296
2297        /** @type {!Array.<Function>} */
2298        var configBlocks = [];
2299
2300        /** @type {!Array.<Function>} */
2301        var runBlocks = [];
2302
2303        var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
2304
2305        /** @type {angular.Module} */
2306        var moduleInstance = {
2307          // Private state
2308          _invokeQueue: invokeQueue,
2309          _configBlocks: configBlocks,
2310          _runBlocks: runBlocks,
2311
2312          /**
2313           * @ngdoc method
2314           * @name angular.Module#info
2315           * @module ng
2316           *
2317           * @param {Object=} info Information about the module
2318           * @returns {Object|Module} The current info object for this module if called as a getter,
2319           *                          or `this` if called as a setter.
2320           *
2321           * @description
2322           * Read and write custom information about this module.
2323           * For example you could put the version of the module in here.
2324           *
2325           * ```js
2326           * angular.module('myModule', []).info({ version: '1.0.0' });
2327           * ```
2328           *
2329           * The version could then be read back out by accessing the module elsewhere:
2330           *
2331           * ```
2332           * var version = angular.module('myModule').info().version;
2333           * ```
2334           *
2335           * You can also retrieve this information during runtime via the
2336           * {@link $injector#modules `$injector.modules`} property:
2337           *
2338           * ```js
2339           * var version = $injector.modules['myModule'].info().version;
2340           * ```
2341           */
2342          info: function(value) {
2343            if (isDefined(value)) {
2344              if (!isObject(value)) throw ngMinErr('aobj', 'Argument \'{0}\' must be an object', 'value');
2345              info = value;
2346              return this;
2347            }
2348            return info;
2349          },
2350
2351          /**
2352           * @ngdoc property
2353           * @name angular.Module#requires
2354           * @module ng
2355           *
2356           * @description
2357           * Holds the list of modules which the injector will load before the current module is
2358           * loaded.
2359           */
2360          requires: requires,
2361
2362          /**
2363           * @ngdoc property
2364           * @name angular.Module#name
2365           * @module ng
2366           *
2367           * @description
2368           * Name of the module.
2369           */
2370          name: name,
2371
2372
2373          /**
2374           * @ngdoc method
2375           * @name angular.Module#provider
2376           * @module ng
2377           * @param {string} name service name
2378           * @param {Function} providerType Construction function for creating new instance of the
2379           *                                service.
2380           * @description
2381           * See {@link auto.$provide#provider $provide.provider()}.
2382           */
2383          provider: invokeLaterAndSetModuleName('$provide', 'provider'),
2384
2385          /**
2386           * @ngdoc method
2387           * @name angular.Module#factory
2388           * @module ng
2389           * @param {string} name service name
2390           * @param {Function} providerFunction Function for creating new instance of the service.
2391           * @description
2392           * See {@link auto.$provide#factory $provide.factory()}.
2393           */
2394          factory: invokeLaterAndSetModuleName('$provide', 'factory'),
2395
2396          /**
2397           * @ngdoc method
2398           * @name angular.Module#service
2399           * @module ng
2400           * @param {string} name service name
2401           * @param {Function} constructor A constructor function that will be instantiated.
2402           * @description
2403           * See {@link auto.$provide#service $provide.service()}.
2404           */
2405          service: invokeLaterAndSetModuleName('$provide', 'service'),
2406
2407          /**
2408           * @ngdoc method
2409           * @name angular.Module#value
2410           * @module ng
2411           * @param {string} name service name
2412           * @param {*} object Service instance object.
2413           * @description
2414           * See {@link auto.$provide#value $provide.value()}.
2415           */
2416          value: invokeLater('$provide', 'value'),
2417
2418          /**
2419           * @ngdoc method
2420           * @name angular.Module#constant
2421           * @module ng
2422           * @param {string} name constant name
2423           * @param {*} object Constant value.
2424           * @description
2425           * Because the constants are fixed, they get applied before other provide methods.
2426           * See {@link auto.$provide#constant $provide.constant()}.
2427           */
2428          constant: invokeLater('$provide', 'constant', 'unshift'),
2429
2430           /**
2431           * @ngdoc method
2432           * @name angular.Module#decorator
2433           * @module ng
2434           * @param {string} name The name of the service to decorate.
2435           * @param {Function} decorFn This function will be invoked when the service needs to be
2436           *                           instantiated and should return the decorated service instance.
2437           * @description
2438           * See {@link auto.$provide#decorator $provide.decorator()}.
2439           */
2440          decorator: invokeLaterAndSetModuleName('$provide', 'decorator', configBlocks),
2441
2442          /**
2443           * @ngdoc method
2444           * @name angular.Module#animation
2445           * @module ng
2446           * @param {string} name animation name
2447           * @param {Function} animationFactory Factory function for creating new instance of an
2448           *                                    animation.
2449           * @description
2450           *
2451           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
2452           *
2453           *
2454           * Defines an animation hook that can be later used with
2455           * {@link $animate $animate} service and directives that use this service.
2456           *
2457           * ```js
2458           * module.animation('.animation-name', function($inject1, $inject2) {
2459           *   return {
2460           *     eventName : function(element, done) {
2461           *       //code to run the animation
2462           *       //once complete, then run done()
2463           *       return function cancellationFunction(element) {
2464           *         //code to cancel the animation
2465           *       }
2466           *     }
2467           *   }
2468           * })
2469           * ```
2470           *
2471           * See {@link ng.$animateProvider#register $animateProvider.register()} and
2472           * {@link ngAnimate ngAnimate module} for more information.
2473           */
2474          animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
2475
2476          /**
2477           * @ngdoc method
2478           * @name angular.Module#filter
2479           * @module ng
2480           * @param {string} name Filter name - this must be a valid AngularJS expression identifier
2481           * @param {Function} filterFactory Factory function for creating new instance of filter.
2482           * @description
2483           * See {@link ng.$filterProvider#register $filterProvider.register()}.
2484           *
2485           * <div class="alert alert-warning">
2486           * **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
2487           * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
2488           * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
2489           * (`myapp_subsection_filterx`).
2490           * </div>
2491           */
2492          filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
2493
2494          /**
2495           * @ngdoc method
2496           * @name angular.Module#controller
2497           * @module ng
2498           * @param {string|Object} name Controller name, or an object map of controllers where the
2499           *    keys are the names and the values are the constructors.
2500           * @param {Function} constructor Controller constructor function.
2501           * @description
2502           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
2503           */
2504          controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
2505
2506          /**
2507           * @ngdoc method
2508           * @name angular.Module#directive
2509           * @module ng
2510           * @param {string|Object} name Directive name, or an object map of directives where the
2511           *    keys are the names and the values are the factories.
2512           * @param {Function} directiveFactory Factory function for creating new instance of
2513           * directives.
2514           * @description
2515           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
2516           */
2517          directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
2518
2519          /**
2520           * @ngdoc method
2521           * @name angular.Module#component
2522           * @module ng
2523           * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
2524           *    or an object map of components where the keys are the names and the values are the component definition objects.
2525           * @param {Object} options Component definition object (a simplified
2526           *    {@link ng.$compile#directive-definition-object directive definition object})
2527           *
2528           * @description
2529           * See {@link ng.$compileProvider#component $compileProvider.component()}.
2530           */
2531          component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
2532
2533          /**
2534           * @ngdoc method
2535           * @name angular.Module#config
2536           * @module ng
2537           * @param {Function} configFn Execute this function on module load. Useful for service
2538           *    configuration.
2539           * @description
2540           * Use this method to configure services by injecting their
2541           * {@link angular.Module#provider `providers`}, e.g. for adding routes to the
2542           * {@link ngRoute.$routeProvider $routeProvider}.
2543           *
2544           * Note that you can only inject {@link angular.Module#provider `providers`} and
2545           * {@link angular.Module#constant `constants`} into this function.
2546           *
2547           * For more about how to configure services, see
2548           * {@link providers#provider-recipe Provider Recipe}.
2549           */
2550          config: config,
2551
2552          /**
2553           * @ngdoc method
2554           * @name angular.Module#run
2555           * @module ng
2556           * @param {Function} initializationFn Execute this function after injector creation.
2557           *    Useful for application initialization.
2558           * @description
2559           * Use this method to register work which should be performed when the injector is done
2560           * loading all modules.
2561           */
2562          run: function(block) {
2563            runBlocks.push(block);
2564            return this;
2565          }
2566        };
2567
2568        if (configFn) {
2569          config(configFn);
2570        }
2571
2572        return moduleInstance;
2573
2574        /**
2575         * @param {string} provider
2576         * @param {string} method
2577         * @param {String=} insertMethod
2578         * @returns {angular.Module}
2579         */
2580        function invokeLater(provider, method, insertMethod, queue) {
2581          if (!queue) queue = invokeQueue;
2582          return function() {
2583            queue[insertMethod || 'push']([provider, method, arguments]);
2584            return moduleInstance;
2585          };
2586        }
2587
2588        /**
2589         * @param {string} provider
2590         * @param {string} method
2591         * @returns {angular.Module}
2592         */
2593        function invokeLaterAndSetModuleName(provider, method, queue) {
2594          if (!queue) queue = invokeQueue;
2595          return function(recipeName, factoryFunction) {
2596            if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
2597            queue.push([provider, method, arguments]);
2598            return moduleInstance;
2599          };
2600        }
2601      });
2602    };
2603  });
2604
2605}
2606
2607/* global shallowCopy: true */
2608
2609/**
2610 * Creates a shallow copy of an object, an array or a primitive.
2611 *
2612 * Assumes that there are no proto properties for objects.
2613 */
2614function shallowCopy(src, dst) {
2615  if (isArray(src)) {
2616    dst = dst || [];
2617
2618    for (var i = 0, ii = src.length; i < ii; i++) {
2619      dst[i] = src[i];
2620    }
2621  } else if (isObject(src)) {
2622    dst = dst || {};
2623
2624    for (var key in src) {
2625      if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
2626        dst[key] = src[key];
2627      }
2628    }
2629  }
2630
2631  return dst || src;
2632}
2633
2634/* exported toDebugString */
2635
2636function serializeObject(obj, maxDepth) {
2637  var seen = [];
2638
2639  // There is no direct way to stringify object until reaching a specific depth
2640  // and a very deep object can cause a performance issue, so we copy the object
2641  // based on this specific depth and then stringify it.
2642  if (isValidObjectMaxDepth(maxDepth)) {
2643    // This file is also included in `angular-loader`, so `copy()` might not always be available in
2644    // the closure. Therefore, it is lazily retrieved as `angular.copy()` when needed.
2645    obj = angular.copy(obj, null, maxDepth);
2646  }
2647  return JSON.stringify(obj, function(key, val) {
2648    val = toJsonReplacer(key, val);
2649    if (isObject(val)) {
2650
2651      if (seen.indexOf(val) >= 0) return '...';
2652
2653      seen.push(val);
2654    }
2655    return val;
2656  });
2657}
2658
2659function toDebugString(obj, maxDepth) {
2660  if (typeof obj === 'function') {
2661    return obj.toString().replace(/ \{[\s\S]*$/, '');
2662  } else if (isUndefined(obj)) {
2663    return 'undefined';
2664  } else if (typeof obj !== 'string') {
2665    return serializeObject(obj, maxDepth);
2666  }
2667  return obj;
2668}
2669
2670/* global angularModule: true,
2671  version: true,
2672
2673  $CompileProvider,
2674
2675  htmlAnchorDirective,
2676  inputDirective,
2677