https://www.rittal.com/us_en/apps/drawing/min/js/production.js?ver=1.10

1/**
2 * @license AngularJS v1.4.9
3 * (c) 2010-2015 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.4.9/' +
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.charCodeAt(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 existance 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    }

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} 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
756
757var trim = function(value) {
758  return isString(value) ? value.trim() : value;
759};
760
761// Copied from:
762// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
763// Prereq: s is a string.
764var escapeForRegexp = function(s) {
765  return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
766           replace(/\x08/g, '\\x08');
767};
768
769
770/**
771 * @ngdoc function
772 * @name angular.isElement
773 * @module ng
774 * @kind function
775 *
776 * @description
777 * Determines if a reference is a DOM element (or wrapped jQuery element).
778 *
779 * @param {*} value Reference to check.
780 * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
781 */
782function isElement(node) {
783  return !!(node &&
784    (node.nodeName  // we are a direct element
785    || (node.prop && node.attr && node.find)));  // we have an on and find method part of jQuery API
786}
787
788/**
789 * @param str 'key1,key2,...'
790 * @returns {object} in the form of {key1:true, key2:true, ...}
791 */
792function makeMap(str) {
793  var obj = {}, items = str.split(","), i;
794  for (i = 0; i < items.length; i++) {
795    obj[items[i]] = true;
796  }
797  return obj;
798}
799
800
801function nodeName_(element) {
802  return lowercase(element.nodeName || (element[0] && element[0].nodeName));
803}
804
805function includes(array, obj) {
806  return Array.prototype.indexOf.call(array, obj) != -1;
807}
808
809function arrayRemove(array, value) {
810  var index = array.indexOf(value);
811  if (index >= 0) {
812    array.splice(index, 1);
813  }
814  return index;
815}
816
817/**
818 * @ngdoc function
819 * @name angular.copy
820 * @module ng
821 * @kind function
822 *
823 * @description
824 * Creates a deep copy of `source`, which should be an object or an array.

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

954    var destination;
955
956    if (isArray(source)) {
957      destination = [];
958      needsRecurse = true;
959    } else if (isTypedArray(source)) {
960      destination = new source.constructor(source);
961    } else if (isDate(source)) {
962      destination = new Date(source.getTime());
963    } else if (isRegExp(source)) {
964      destination = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
965      destination.lastIndex = source.lastIndex;
966    } else if (isFunction(source.cloneNode)) {
967        destination = source.cloneNode(true);
968    } else {
969      destination = Object.create(getPrototypeOf(source));
970      needsRecurse = true;
971    }
972
973    stackSource.push(source);
974    stackDest.push(destination);
975
976    return needsRecurse
977      ? copyRecurse(source, destination)
978      : destination;
979  }
980}
981
982/**
983 * Creates a shallow copy of an object, an array or a primitive.
984 *
985 * Assumes that there are no proto properties for objects.
986 */
987function shallowCopy(src, dst) {
988  if (isArray(src)) {
989    dst = dst || [];
990
991    for (var i = 0, ii = src.length; i < ii; i++) {
992      dst[i] = src[i];
993    }
994  } else if (isObject(src)) {
995    dst = dst || {};
996
997    for (var key in src) {
998      if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
999        dst[key] = src[key];
1000      }
1001    }
1002  }
1003
1004  return dst || src;
1005}
1006
1007
1008/**
1009 * @ngdoc function
1010 * @name angular.equals
1011 * @module ng
1012 * @kind function
1013 *
1014 * @description
1015 * Determines if two objects or two values are equivalent. Supports value types, regular
1016 * expressions, arrays and objects.
1017 *
1018 * Two objects or values are considered equivalent if at least one of the following is true:
1019 *
1020 * * Both objects or values pass `===` comparison.
1021 * * Both objects or values are of the same type and all of their properties are equal by
1022 *   comparing them with `angular.equals`.
1023 * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
1024 * * Both values represent the same regular expression (In JavaScript,
1025 *   /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
1026 *   representation matches).
1027 *
1028 * During a property comparison, properties of `function` type and properties with names
1029 * that begin with `$` are ignored.
1030 *
1031 * Scope and DOMWindow objects are being compared only by identify (`===`).
1032 *
1033 * @param {*} o1 Object or value to compare.
1034 * @param {*} o2 Object or value to compare.
1035 * @returns {boolean} True if arguments are equal.
1036 */
1037function equals(o1, o2) {
1038  if (o1 === o2) return true;
1039  if (o1 === null || o2 === null) return false;
1040  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
1041  var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
1042  if (t1 == t2) {
1043    if (t1 == 'object') {
1044      if (isArray(o1)) {
1045        if (!isArray(o2)) return false;
1046        if ((length = o1.length) == o2.length) {
1047          for (key = 0; key < length; key++) {
1048            if (!equals(o1[key], o2[key])) return false;
1049          }
1050          return true;
1051        }
1052      } else if (isDate(o1)) {
1053        if (!isDate(o2)) return false;
1054        return equals(o1.getTime(), o2.getTime());
1055      } else if (isRegExp(o1)) {
1056        return isRegExp(o2) ? o1.toString() == o2.toString() : false;
1057      } else {
1058        if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
1059          isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
1060        keySet = createMap();
1061        for (key in o1) {
1062          if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
1063          if (!equals(o1[key], o2[key])) return false;
1064          keySet[key] = true;
1065        }
1066        for (key in o2) {
1067          if (!(key in keySet) &&
1068              key.charAt(0) !== '$' &&
1069              isDefined(o2[key]) &&
1070              !isFunction(o2[key])) return false;
1071        }
1072        return true;
1073      }
1074    }
1075  }
1076  return false;
1077}
1078
1079var csp = function() {
1080  if (!isDefined(csp.rules)) {
1081
1082
1083    var ngCspElement = (document.querySelector('[ng-csp]') ||
1084                    document.querySelector('[data-ng-csp]'));
1085
1086    if (ngCspElement) {
1087      var ngCspAttribute = ngCspElement.getAttribute('ng-csp') ||
1088                    ngCspElement.getAttribute('data-ng-csp');
1089      csp.rules = {
1090        noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
1091        noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1)
1092      };
1093    } else {
1094      csp.rules = {
1095        noUnsafeEval: noUnsafeEval(),
1096        noInlineStyle: false
1097      };
1098    }
1099  }
1100
1101  return csp.rules;
1102
1103  function noUnsafeEval() {
1104    try {
1105      /* jshint -W031, -W054 */
1106      new Function('');
1107      /* jshint +W031, +W054 */
1108      return false;

1109    } catch (e) {
1110      return true;
1111    }
1112  }
1113};
1114
1115/**
1116 * @ngdoc directive
1117 * @module ng
1118 * @name ngJq
1119 *
1120 * @element ANY
1121 * @param {string=} ngJq the name of the library available under `window`
1122 * to be used for angular.element
1123 * @description
1124 * Use this directive to force the angular.element library.  This should be
1125 * used to force either jqLite by leaving ng-jq blank or setting the name of
1126 * the jquery variable under window (eg. jQuery).
1127 *
1128 * Since angular looks for this directive when it is loaded (doesn't wait for the
1129 * DOMContentLoaded event), it must be placed on an element that comes before the script
1130 * which loads angular. Also, only the first instance of `ng-jq` will be used and all
1131 * others ignored.
1132 *
1133 * @example
1134 * This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
1135 ```html
1136 <!doctype html>
1137 <html ng-app ng-jq>
1138 ...
1139 ...
1140 </html>
1141 ```
1142 * @example
1143 * This example shows how to use a jQuery based library of a different name.
1144 * The library name must be available at the top most 'window'.
1145 ```html
1146 <!doctype html>
1147 <html ng-app ng-jq="jQueryLib">
1148 ...
1149 ...
1150 </html>
1151 ```
1152 */
1153var jq = function() {
1154  if (isDefined(jq.name_)) return jq.name_;
1155  var el;
1156  var i, ii = ngAttrPrefixes.length, prefix, name;
1157  for (i = 0; i < ii; ++i) {
1158    prefix = ngAttrPrefixes[i];
1159    if (el = document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) {
1160      name = el.getAttribute(prefix + 'jq');
1161      break;
1162    }
1163  }
1164
1165  return (jq.name_ = name);
1166};
1167
1168function concat(array1, array2, index) {
1169  return array1.concat(slice.call(array2, index));
1170}
1171
1172function sliceArgs(args, startIndex) {
1173  return slice.call(args, startIndex || 0);
1174}
1175
1176
1177/* jshint -W101 */
1178/**
1179 * @ngdoc function
1180 * @name angular.bind
1181 * @module ng
1182 * @kind function
1183 *
1184 * @description
1185 * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
1186 * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
1187 * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
1188 * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
1189 *
1190 * @param {Object} self Context which `fn` should be evaluated in.
1191 * @param {function()} fn Function to be bound.
1192 * @param {...*} args Optional arguments to be prebound to the `fn` function call.
1193 * @returns {function()} Function that wraps the `fn` with all the specified bindings.
1194 */
1195/* jshint +W101 */
1196function bind(self, fn) {
1197  var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
1198  if (isFunction(fn) && !(fn instanceof RegExp)) {
1199    return curryArgs.length
1200      ? function() {
1201          return arguments.length
1202            ? fn.apply(self, concat(curryArgs, arguments, 0))
1203            : fn.apply(self, curryArgs);
1204        }
1205      : function() {
1206          return arguments.length
1207            ? fn.apply(self, arguments)
1208            : fn.call(self);
1209        };
1210  } else {
1211    // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
1212    return fn;
1213  }
1214}
1215
1216
1217function toJsonReplacer(key, value) {
1218  var val = value;
1219
1220  if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
1221    val = undefined;
1222  } else if (isWindow(value)) {
1223    val = '$WINDOW';
1224  } else if (value &&  document === value) {
1225    val = '$DOCUMENT';
1226  } else if (isScope(value)) {
1227    val = '$SCOPE';
1228  }
1229
1230  return val;
1231}
1232
1233
1234/**
1235 * @ngdoc function
1236 * @name angular.toJson
1237 * @module ng
1238 * @kind function
1239 *
1240 * @description
1241 * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
1242 * stripped since angular uses this notation internally.
1243 *
1244 * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
1245 * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
1246 *    If set to an integer, the JSON output will contain that many spaces per indentation.
1247 * @returns {string|undefined} JSON-ified string representing `obj`.
1248 */
1249function toJson(obj, pretty) {
1250  if (typeof obj === 'undefined') return undefined;
1251  if (!isNumber(pretty)) {
1252    pretty = pretty ? 2 : null;
1253  }
1254  return JSON.stringify(obj, toJsonReplacer, pretty);
1255}
1256
1257
1258/**
1259 * @ngdoc function
1260 * @name angular.fromJson
1261 * @module ng
1262 * @kind function
1263 *
1264 * @description
1265 * Deserializes a JSON string.
1266 *
1267 * @param {string} json JSON string to deserialize.
1268 * @returns {Object|Array|string|number} Deserialized JSON string.
1269 */
1270function fromJson(json) {
1271  return isString(json)
1272      ? JSON.parse(json)
1273      : json;
1274}
1275
1276
1277function timezoneToOffset(timezone, fallback) {
1278  var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
1279  return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
1280}
1281
1282
1283function addDateMinutes(date, minutes) {
1284  date = new Date(date.getTime());
1285  date.setMinutes(date.getMinutes() + minutes);
1286  return date;
1287}
1288
1289
1290function convertTimezoneToLocal(date, timezone, reverse) {
1291  reverse = reverse ? -1 : 1;
1292  var timezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset());
1293  return addDateMinutes(date, reverse * (timezoneOffset - date.getTimezoneOffset()));
1294}
1295
1296
1297/**
1298 * @returns {string} Returns the string representation of the element.
1299 */
1300function startingTag(element) {
1301  element = jqLite(element).clone();
1302  try {
1303    // turns out IE does not let you set .html() on elements which
1304    // are not allowed to have children. So we just ignore it.
1305    element.empty();
1306  } catch (e) {}
1307  var elemHtml = jqLite('<div>').append(element).html();
1308  try {
1309    return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
1310        elemHtml.
1311          match(/^(<[^>]+>)/)[1].
1312          replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
1313  } catch (e) {
1314    return lowercase(elemHtml);
1315  }
1316
1317}
1318
1319
1320/////////////////////////////////////////////////
1321
1322/**
1323 * Tries to decode the URI component without throwing an exception.
1324 *
1325 * @private
1326 * @param str value potential URI component to check.
1327 * @returns {boolean} True if `value` can be decoded
1328 * with the decodeURIComponent function.
1329 */
1330function tryDecodeURIComponent(value) {
1331  try {
1332    return decodeURIComponent(value);
1333  } catch (e) {
1334    // Ignore any invalid uri component
1335  }
1336}
1337
1338
1339/**
1340 * Parses an escaped url query string into key-value pairs.
1341 * @returns {Object.<string,boolean|Array>}
1342 */
1343function parseKeyValue(/**string*/keyValue) {
1344  var obj = {};
1345  forEach((keyValue || "").split('&'), function(keyValue) {
1346    var splitPoint, key, val;
1347    if (keyValue) {
1348      key = keyValue = keyValue.replace(/\+/g,'%20');
1349      splitPoint = keyValue.indexOf('=');
1350      if (splitPoint !== -1) {
1351        key = keyValue.substring(0, splitPoint);
1352        val = keyValue.substring(splitPoint + 1);
1353      }
1354      key = tryDecodeURIComponent(key);
1355      if (isDefined(key)) {
1356        val = isDefined(val) ? tryDecodeURIComponent(val) : true;
1357        if (!hasOwnProperty.call(obj, key)) {
1358          obj[key] = val;
1359        } else if (isArray(obj[key])) {
1360          obj[key].push(val);
1361        } else {
1362          obj[key] = [obj[key],val];
1363        }
1364      }
1365    }
1366  });
1367  return obj;
1368}
1369
1370function toKeyValue(obj) {
1371  var parts = [];
1372  forEach(obj, function(value, key) {
1373    if (isArray(value)) {
1374      forEach(value, function(arrayValue) {
1375        parts.push(encodeUriQuery(key, true) +
1376                   (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
1377      });
1378    } else {
1379    parts.push(encodeUriQuery(key, true) +
1380               (value === true ? '' : '=' + encodeUriQuery(value, true)));
1381    }
1382  });
1383  return parts.length ? parts.join('&') : '';
1384}
1385
1386
1387/**
1388 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
1389 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
1390 * segments:
1391 *    segment       = *pchar
1392 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1393 *    pct-encoded   = "%" HEXDIG HEXDIG
1394 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1395 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1396 *                     / "*" / "+" / "," / ";" / "="
1397 */
1398function encodeUriSegment(val) {
1399  return encodeUriQuery(val, true).
1400             replace(/%26/gi, '&').
1401             replace(/%3D/gi, '=').
1402             replace(/%2B/gi, '+');
1403}
1404
1405
1406/**
1407 * This method is intended for encoding *key* or *value* parts of query component. We need a custom
1408 * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
1409 * encoded per http://tools.ietf.org/html/rfc3986:
1410 *    query       = *( pchar / "/" / "?" )
1411 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1412 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1413 *    pct-encoded   = "%" HEXDIG HEXDIG
1414 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1415 *                     / "*" / "+" / "," / ";" / "="
1416 */
1417function encodeUriQuery(val, pctEncodeSpaces) {
1418  return encodeURIComponent(val).
1419             replace(/%40/gi, '@').
1420             replace(/%3A/gi, ':').
1421             replace(/%24/g, '$').
1422             replace(/%2C/gi, ',').
1423             replace(/%3B/gi, ';').
1424             replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
1425}
1426
1427var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
1428
1429function getNgAttribute(element, ngAttr) {
1430  var attr, i, ii = ngAttrPrefixes.length;
1431  for (i = 0; i < ii; ++i) {
1432    attr = ngAttrPrefixes[i] + ngAttr;
1433    if (isString(attr = element.getAttribute(attr))) {
1434      return attr;
1435    }
1436  }
1437  return null;
1438}
1439
1440/**
1441 * @ngdoc directive
1442 * @name ngApp
1443 * @module ng
1444 *
1445 * @element ANY
1446 * @param {angular.Module} ngApp an optional application
1447 *   {@link angular.module module} name to load.
1448 * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
1449 *   created in "strict-di" mode. This means that the application will fail to invoke functions which
1450 *   do not use explicit function annotation (and are thus unsuitable for minification), as de

1450scribed
1451 *   in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
1452 *   tracking down the root of these bugs.
1453 *
1454 * @description
1455 *
1456 * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
1457 * designates the **root element** of the application and is typically placed near the root element
1458 * of the page - e.g. on the `<body>` or `<html>` tags.
1459 *
1460 * Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
1461 * found in the document will be used to define the root element to auto-bootstrap as an
1462 * application. To run multiple applications in an HTML document you must manually bootstrap them using
1463 * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
1464 *
1465 * You can specify an **AngularJS module** to be used as the root module for the application.  This
1466 * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
1467 * should contain the application code needed or have dependencies on other modules that will
1468 * contain the code. See {@link angular.module} for more information.
1469 *
1470 * In the example below if the `ngApp` directive were not placed on the `html` element then the
1471 * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
1472 * would not be resolved to `3`.
1473 *
1474 * `ngApp` is the easiest, and most common way to bootstrap an application.
1475 *
1476 <example module="ngAppDemo">
1477   <file name="index.html">
1478   <div ng-controller="ngAppDemoController">
1479     I can add: {{a}} + {{b}} =  {{ a+b }}
1480   </div>
1481   </file>
1482   <file name="script.js">
1483   angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
1484     $scope.a = 1;
1485     $scope.b = 2;
1486   });
1487   </file>
1488 </example>
1489 *
1490 * Using `ngStrictDi`, you would see something like this:
1491 *
1492 <example ng-app-included="true">
1493   <file name="index.html">
1494   <div ng-app="ngAppStrictDemo" ng-strict-di>
1495       <div ng-controller="GoodController1">
1496           I can add: {{a}} + {{b}} =  {{ a+b }}
1497
1498           <p>This renders because the controller does not fail to
1499              instantiate, by using explicit annotation style (see
1500              script.js for details)
1501           </p>
1502       </div>
1503
1504       <div ng-controller="GoodController2">
1505           Name: <input ng-model="name"><br />
1506           Hello, {{name}}!
1507
1508           <p>This renders because the controller does not fail to
1509              instantiate, by using explicit annotation style
1510              (see script.js for details)
1511           </p>
1512       </div>
1513
1514       <div ng-controller="BadController">
1515           I can add: {{a}} + {{b}} =  {{ a+b }}
1516
1517           <p>The controller could not be instantiated, due to relying
1518              on automatic function annotations (which are disabled in
1519              strict mode). As such, the content of this section is not
1520              interpolated, and there should be an error in your web console.
1521           </p>
1522       </div>
1523   </div>
1524   </file>
1525   <file name="script.js">
1526   angular.module('ngAppStrictDemo', [])
1527     // BadController will fail to instantiate, due to relying on automatic function annotation,
1528     // rather than an explicit annotation
1529     .controller('BadController', function($scope) {
1530       $scope.a = 1;
1531       $scope.b = 2;
1532     })
1533     // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
1534     // due to using explicit annotations using the array style and $inject property, respectively.
1535     .controller('GoodController1', ['$scope', function($scope) {
1536       $scope.a = 1;
1537       $scope.b = 2;
1538     }])
1539     .controller('GoodController2', GoodController2);
1540     function GoodController2($scope) {
1541       $scope.name = "World";
1542     }
1543     GoodController2.$inject = ['$scope'];
1544   </file>
1545   <file name="style.css">
1546   div[ng-controller] {
1547       margin-bottom: 1em;
1548       -webkit-border-radius: 4px;
1549       border-radius: 4px;
1550       border: 1px solid;
1551       padding: .5em;
1552   }
1553   div[ng-controller^=Good] {
1554       border-color: #d6e9c6;
1555       background-color: #dff0d8;
1556       color: #3c763d;
1557   }
1558   div[ng-controller^=Bad] {
1559       border-color: #ebccd1;
1560       background-color: #f2dede;
1561       color: #a94442;
1562       margin-bottom: 0;
1563   }
1564   </file>
1565 </example>
1566 */
1567function angularInit(element, bootstrap) {
1568  var appElement,
1569      module,
1570      config = {};
1571
1572  // The element `element` has priority over any other element
1573  forEach(ngAttrPrefixes, function(prefix) {
1574    var name = prefix + 'app';
1575
1576    if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
1577      appElement = element;
1578      module = element.getAttribute(name);
1579    }
1580  });
1581  forEach(ngAttrPrefixes, function(prefix) {
1582    var name = prefix + 'app';
1583    var candidate;
1584
1585    if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
1586      appElement = candidate;
1587      module = candidate.getAttribute(name);
1588    }
1589  });
1590  if (appElement) {
1591    config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
1592    bootstrap(appElement, module ? [module] : [], config);
1593  }
1594}
1595
1596/**
1597 * @ngdoc function
1598 * @name angular.bootstrap
1599 * @module ng
1600 * @description
1601 * Use this function to manually start up angular application.
1602 *
1603 * See: {@link guide/bootstrap Bootstrap}
1604 *

1605 * Note that Protractor based end-to-end tests cannot use this function to bootstrap manually.
1606 * They must use {@link ng.directive:ngApp ngApp}.
1607 *
1608 * Angular will detect if it has been loaded into the browser more than once and only allow the
1609 * first loaded script to be bootstrapped and will report a warning to the browser console for
1610 * each of the subsequent scripts. This prevents strange results in applications, where otherwise
1611 * multiple instances of Angular try to work on the DOM.
1612 *
1613 * ```html
1614 * <!doctype html>
1615 * <html>
1616 * <body>
1617 * <div ng-controller="WelcomeController">
1618 *   {{greeting}}
1619 * </div>
1620 *
1621 * <script src="angular.js"></script>
1622 * <script>
1623 *   var app = angular.module('demo', [])
1624 *   .controller('WelcomeController', function($scope) {
1625 *       $scope.greeting = 'Welcome!';
1626 *   });
1627 *   angular.bootstrap(document, ['demo']);
1628 * </script>
1629 * </body>
1630 * </html>
1631 * ```
1632 *
1633 * @param {DOMElement} element DOM element which is the root of angular application.
1634 * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
1635 *     Each item in the array should be the name of a predefined module or a (DI annotated)
1636 *     function that will be invoked by the injector as a `config` block.
1637 *     See: {@link angular.module modules}
1638 * @param {Object=} config an object for defining configuration options for the application. The
1639 *     following keys are supported:
1640 *
1641 * * `strictDi` - disable automatic function annotation for the application. This is meant to
1642 *   assist in finding bugs which break minified code. Defaults to `false`.
1643 *
1644 * @returns {auto.$injector} Returns the newly created injector for this app.
1645 */
1646function bootstrap(element, modules, config) {
1647  if (!isObject(config)) config = {};
1648  var defaultConfig = {
1649    strictDi: false
1650  };
1651  config = extend(defaultConfig, config);
1652  var doBootstrap = function() {
1653    element = jqLite(element);
1654
1655    if (element.injector()) {
1656      var tag = (element[0] === document) ? 'document' : startingTag(element);
1657      //Encode angle brackets to prevent input from being sanitized to empty string #8683
1658      throw ngMinErr(
1659          'btstrpd',
1660          "App Already Bootstrapped with this Element '{0}'",
1661          tag.replace(/</,'&lt;').replace(/>/,'&gt;'));
1662    }
1663
1664    modules = modules || [];
1665    modules.unshift(['$provide', function($provide) {
1666      $provide.value('$rootElement', element);
1667    }]);
1668
1669    if (config.debugInfoEnabled) {
1670      // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
1671      modules.push(['$compileProvider', function($compileProvider) {
1672        $compileProvider.debugInfoEnabled(true);
1673      }]);
1674    }
1675
1676    modules.unshift('ng');
1677    var injector = createInjector(modules, config.strictDi);
1678    injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
1679       function bootstrapApply(scope, element, compile, injector) {
1680        scope.$apply(function() {
1681          element.data('$injector', injector);
1682          compile(element)(scope);
1683        });
1684      }]
1685    );
1686    return injector;
1687  };
1688
1689  var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
1690  var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
1691
1692  if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
1693    config.debugInfoEnabled = true;
1694    window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
1695  }
1696
1697  if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
1698    return doBootstrap();
1699  }
1700
1701  window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
1702  angular.resumeBootstrap = function(extraModules) {
1703    forEach(extraModules, function(module) {
1704      modules.push(module);
1705    });
1706    return doBootstrap();
1707  };
1708
1709  if (isFunction(angular.resumeDeferredBootstrap)) {
1710    angular.resumeDeferredBootstrap();
1711  }
1712}
1713
1714/**
1715 * @ngdoc function
1716 * @name angular.reloadWithDebugInfo
1717 * @module ng
1718 * @description
1719 * Use this function to reload the current application with debug information turned on.
1720 * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
1721 *
1722 * See {@link ng.$compileProvider#debugInfoEnabled} for more.
1723 */
1724function reloadWithDebugInfo() {
1725  window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
1726  window.location.reload();
1727}
1728
1729/**
1730 * @name angular.getTestability
1731 * @module ng
1732 * @description
1733 * Get the testability service for the instance of Angular on the given
1734 * element.
1735 * @param {DOMElement} element DOM element which is the root of angular application.
1736 */
1737function getTestability(rootElement) {
1738  var injector = angular.element(rootElement).injector();
1739  if (!injector) {
1740    throw ngMinErr('test',
1741      'no injector found for element argument to getTestability');
1742  }
1743  return injector.get('$$testability');
1744}
1745
1746var SNAKE_CASE_REGEXP = /[A-Z]/g;
1747function snake_case(name, separator) {
1748  separator = separator || '_';
1749  return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
1750    return (pos ? separator : '') + letter.toLowerCase();
1751  });
1752}
1753
1754var bindJQueryFired = false;

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

2045           * @description
2046           * Name of the module.
2047           */
2048          name: name,
2049
2050
2051          /**
2052           * @ngdoc method
2053           * @name angular.Module#provider
2054           * @module ng
2055           * @param {string} name service name
2056           * @param {Function} providerType Construction function for creating new instance of the
2057           *                                service.
2058           * @description
2059           * See {@link auto.$provide#provider $provide.provider()}.
2060           */
2061          provider: invokeLaterAndSetModuleName('$provide', 'provider'),
2062
2063          /**
2064           * @ngdoc method
2065           * @name angular.Module#factory
2066           * @module ng
2067           * @param {string} name service name
2068           * @param {Function} providerFunction Function for creating new instance of the service.
2069           * @description
2070           * See {@link auto.$provide#factory $provide.factory()}.
2071           */
2072          factory: invokeLaterAndSetModuleName('$provide', 'factory'),
2073
2074          /**
2075           * @ngdoc method
2076           * @name angular.Module#service
2077           * @module ng
2078           * @param {string} name service name
2079           * @param {Function} constructor A constructor function that will be instantiated.
2080           * @description
2081           * See {@link auto.$provide#service $provide.service()}.
2082           */
2083          service: invokeLaterAndSetModuleName('$provide', 'service'),
2084
2085          /**
2086           * @ngdoc method
2087           * @name angular.Module#value
2088           * @module ng
2089           * @param {string} name service name
2090           * @param {*} object Service instance object.
2091           * @description
2092           * See {@link auto.$provide#value $provide.value()}.
2093           */
2094          value: invokeLater('$provide', 'value'),
2095
2096          /**
2097           * @ngdoc method
2098           * @name angular.Module#constant
2099           * @module ng
2100           * @param {string} name constant name
2101           * @param {*} object Constant value.
2102           * @description
2103           * Because the constants are fixed, they get applied before other provide methods.
2104           * See {@link auto.$provide#constant $provide.constant()}.
2105           */
2106          constant: invokeLater('$provide', 'constant', 'unshift'),
2107
2108           /**
2109           * @ngdoc method
2110           * @name angular.Module#decorator
2111           * @module ng
2112           * @param {string} The name of the service to decorate.
2113           * @param {Function} This function will be invoked when the service needs to be
2114           *                                    instantiated and should return the decorated service instance.
2115           * @description
2116           * See {@link auto.$provide#decorator $provide.decorator()}.
2117           */
2118          decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
2119
2120          /**
2121           * @ngdoc method
2122           * @name angular.Module#animation
2123           * @module ng
2124           * @param {string} name animation name
2125           * @param {Function} animationFactory Factory function for creating new instance of an
2126           *                                    animation.
2127           * @description
2128           *
2129           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
2130           *
2131           *
2132           * Defines an animation hook that can be later used with
2133           * {@link $animate $animate} service and directives that use this service.
2134           *
2135           * ```js
2136           * module.animation('.animation-name', function($inject1, $inject2) {
2137           *   return {
2138           *     eventName : function(element, done) {
2139           *       //code to run the animation
2140           *       //once complete, then run done()
2141           *       return function cancellationFunction(element) {
2142           *         //code to cancel the animation
2143           *       }
2144           *     }
2145           *   }
2146           * })
2147           * ```
2148           *
2149           * See {@link ng.$animateProvider#register $animateProvider.register()} and
2150           * {@link ngAnimate ngAnimate module} for more information.
2151           */
2152          animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
2153
2154          /**
2155           * @ngdoc method
2156           * @name angular.Module#filter
2157           * @module ng
2158           * @param {string} name Filter name - this must be a valid angular expression identifier
2159           * @param {Function} filterFactory Factory function for creating new instance of filter.

2160           * @description
2161           * See {@link ng.$filterProvider#register $filterProvider.register()}.
2162           *
2163           * <div class="alert alert-warning">
2164           * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
2165           * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
2166           * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
2167           * (`myapp_subsection_filterx`).
2168           * </div>
2169           */
2170          filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
2171
2172          /**
2173           * @ngdoc method
2174           * @name angular.Module#controller
2175           * @module ng
2176           * @param {string|Object} name Controller name, or an object map of controllers where the
2177           *    keys are the names and the values are the constructors.
2178           * @param {Function} constructor Controller constructor function.
2179           * @description
2180           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
2181           */
2182          controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
2183
2184          /**
2185           * @ngdoc method
2186           * @name angular.Module#directive
2187           * @module ng
2188           * @param {string|Object} name Directive name, or an object map of directives where the
2189           *    keys are the names and the values are the factories.
2190           * @param {Function} directiveFactory Factory function for creating new instance of
2191           * directives.
2192           * @description
2193           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
2194           */
2195          directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
2196
2197          /**
2198           * @ngdoc method
2199           * @name angular.Module#config
2200           * @module ng
2201           * @param {Function} configFn Execute this function on module load. Useful for service
2202           *    configuration.
2203           * @description
2204           * Use this method to register work which needs to be performed on module loading.
2205           * For more about how to configure services, see
2206           * {@link providers#provider-recipe Provider Recipe}.
2207           */
2208          config: config,
2209
2210          /**
2211           * @ngdoc method
2212           * @name angular.Module#run
2213           * @module ng
2214           * @param {Function} initializationFn Execute this function after injector creation.
2215           *    Useful for application initialization.
2216           * @description
2217           * Use this method to register work which should be performed when the injector is done
2218           * loading all modules.
2219           */
2220          run: function(block) {
2221            runBlocks.push(block);
2222            return this;
2223          }
2224        };
2225
2226        if (configFn) {
2227          config(configFn);
2228        }
2229
2230        return moduleInstance;
2231
2232        /**
2233         * @param {string} provider
2234         * @param {string} method
2235         * @param {String=} insertMethod
2236         * @returns {angular.Module}
2237         */
2238        function invokeLater(provider, method, insertMethod, queue) {
2239          if (!queue) queue = invokeQueue;
2240          return function() {
2241            queue[insertMethod || 'push']([provider, method, arguments]);
2242            return moduleInstance;
2243          };
2244        }
2245
2246        /**
2247         * @param {string} provider
2248         * @param {string} method
2249         * @returns {angular.Module}
2250         */
2251        function invokeLaterAndSetModuleName(provider, method) {
2252          return function(recipeName, factoryFunction) {
2253            if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
2254            invokeQueue.push([provider, method, arguments]);
2255            return moduleInstance;
2256          };
2257        }
2258      });
2259    };
2260  });
2261
2262}
2263
2264/* global: toDebugString: true */
2265
2266function serializeObject(obj) {
2267  var seen = [];
2268
2269  return JSON.stringify(obj, function(key, val) {
2270    val = toJsonReplacer(key, val);
2271    if (isObject(val)) {
2272
2273      if (seen.indexOf(val) >= 0) return '...';
2274
2275      seen.push(val);
2276    }
2277    return val;
2278  });
2279}
2280
2281function toDebugString(obj) {
2282  if (typeof obj === 'function') {
2283    return obj.toString().replace(/ \{[\s\S]*$/, '');
2284  } else if (isUndefined(obj)) {
2285    return 'undefined';
2286  } else if (typeof obj !== 'string') {
2287    return serializeObject(obj);
2288  }
2289  return obj;
2290}
2291
2292/* global angularModule: true,
2293  version: true,
2294
2295  $CompileProvider,
2296
2297  htmlAnchorDirective,
2298  inputDirective,
2299  inputDirective,
2300  formDirective,
2301  scriptDirective,
2302  selectDirective,
2303  styleDirective,
2304  optionDirective,
2305  ngBindDirective,
2306  ngBindHtmlDirective,
2307  ngBindTemplateDirective,
2308  ngClassDirective,
2309  ngClassEvenDirective,
2310  ngClassOddDirective,
2311  ngCloakDirective,
2312  ngControllerDirective,
2313  ngFormDirective,
2314  ngHideDirective,
2315  ngIfDirective,
2316  ngIncludeDirective,
2317  ngIncludeFillContentDirective,
2318  ngInitDirective,
2319  ngNonBindableDirective,
2320  ngPluralizeDirective,
2321  ngRepeatDirective,
2322  ngShowDirective,
2323  ngStyleDirective,
2324  ngSwitchDirective,
2325  ngSwitchWhenDirective,
2326  ngSwitchDefaultDirective,
2327  ngOptionsDirective,
2328  ngTranscludeDirective,
2329  ngModelDirective,
2330  ngListDirective,
2331  ngChangeDirective,
2332  patternDirective,
2333  patternDirective,
2334  requiredDirective,
2335  requiredDirective,
2336  minlengthDirective,
2337  minlengthDirective,
2338  maxlengthDirective,
2339  maxlengthDirective,
2340  ngValueDirective,
2341  ngModelOptionsDirective,
2342  ngAttributeAliasDirectives,
2343  ngEventDirectives,
2344
2345  $AnchorScrollProvider,
2346  $AnimateProvider,
2347  $CoreAnimateCssProvider,

2348  $$CoreAnimateJsProvider,
2349  $$CoreAnimateQueueProvider,
2350  $$AnimateRunnerFactoryProvider,
2351  $$AnimateAsyncRunFactoryProvider,
2352  $BrowserProvider,
2353  $CacheFactoryProvider,
2354  $ControllerProvider,
2355  $DocumentProvider,
2356  $ExceptionHandlerProvider,
2357  $FilterProvider,
2358  $$ForceReflowProvider,
2359  $InterpolateProvider,
2360  $IntervalProvider,
2361  $$HashMapProvider,
2362  $HttpProvider,
2363  $HttpParamSerializerProvider,
2364  $HttpParamSerializerJQLikeProvider,
2365  $HttpBackendProvider,
2366  $xhrFactoryProvider,
2367  $LocationProvider,
2368  $LogProvider,
2369  $ParseProvider,
2370  $RootScopeProvider,
2371  $QProvider,
2372  $$QProvider,
2373  $$SanitizeUriProvider,
2374  $SceProvider,
2375  $SceDelegateProvider,
2376  $SnifferProvider,
2377  $TemplateCacheProvider,
2378  $TemplateRequestProvider,
2379  $$TestabilityProvider,
2380  $TimeoutProvider,
2381  $$RAFProvider,
2382  $WindowProvider,
2383  $$jqLiteProvider,
2384  $$CookieReaderProvider
2385*/
2386
2387
2388/**
2389 * @ngdoc object
2390 * @name angular.version
2391 * @module ng
2392 * @description
2393 * An object that contains information about the current AngularJS version.
2394 *
2395 * This object has the following properties:
2396 *
2397 * - `full` – `{string}` – Full version string, such as "0.9.18".
2398 * - `major` – `{number}` – Major version number, such as "0".
2399 * - `minor` – `{number}` – Minor version number, such as "9".
2400 * - `dot` – `{number}` – Dot version number, such as "18".
2401 * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
2402 */
2403var version = {
2404  full: '1.4.9',    // all of these placeholder strings will be replaced by grunt's
2405  major: 1,    // package task
2406  minor: 4,
2407  dot: 9,
2408  codeName: 'implicit-superannuation'
2409};
2410
2411
2412function publishExternalAPI(angular) {
2413  extend(angular, {
2414    'bootstrap': bootstrap,
2415    'copy': copy,
2416    'extend': extend,
2417    'merge': merge,
2418    'equals': equals,
2419    'element': jqLite,
2420    'forEach': forEach,
2421    'injector': createInjector,
2422    'noop': noop,
2423    'bind': bind,
2424    'toJson': toJson,
2425    'fromJson': fromJson,
2426    'identity': identity,
2427    'isUndefined': isUndefined,
2428    'isDefined': isDefined,
2429    'isString': isString,
2430    'isFunction': isFunction,
2431    'isObject': isObject,
2432    'isNumber': isNumber,
2433    'isElement': isElement,
2434    'isArray': isArray,
2435    'version': version,
2436    'isDate': isDate,
2437    'lowercase': lowercase,
2438    'uppercase': uppercase,
2439    'callbacks': {counter: 0},
2440    'getTestability': getTestability,
2441    '$$minErr': minErr,
2442    '$$csp': csp,
2443    'reloadWithDebugInfo': reloadWithDebugInfo
2444  });
2445
2446  angularModule = setupModuleLoader(window);
2447
2448  angularModule('ng', ['ngLocale'], ['$provide',
2449    function ngModule($provide) {
2450      // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
2451      $provide.provider({
2452        $$sanitizeUri: $$SanitizeUriProvider
2453      });
2454      $provide.provider('$compile', $CompileProvider).
2455        directive({
2456            a: htmlAnchorDirective,
2457            input: inputDirective,
2458            textarea: inputDirective,
2459            form: formDirective,
2460            script: scriptDirective,
2461            select: selectDirective,
2462            style: styleDirective,
2463            option: optionDirective,
2464            ngBind: ngBindDirective,
2465            ngBindHtml: ngBindHtmlDirective,
2466            ngBindTemplate: ngBindTemplateDirective,
2467            ngClass: ngClassDirective,
2468            ngClassEven: ngClassEvenDirective,
2469            ngClassOdd: ngClassOddDirective,
2470            ngCloak: ngCloakDirective,
2471            ngController: ngControllerDirective,
2472            ngForm: ngFormDirective,
2473            ngHide: ngHideDirective,
2474            ngIf: ngIfDirective,
2475            ngInclude: ngIncludeDirective,
2476            ngInit: ngInitDirective,
2477            ngNonBindable: ngNonBindableDirective,
2478            ngPluralize: ngPluralizeDirective,
2479            ngRepeat: ngRepeatDirective,
2480            ngShow: ngShowDirective,
2481            ngStyle: ngStyleDirective,
2482            ngSwitch: ngSwitchDirective,
2483            ngSwitchWhen: ngSwitchWhenDirective,
2484            ngSwitchDefault: ngSwitchDefaultDirective,
2485            ngOptions: ngOptionsDirective,
2486            ngTransclude: ngTranscludeDirective,
2487            ngModel: ngModelDirective,
2488            ngList: ngListDirective,
2489            ngChange: ngChangeDirective,
2490            pattern: patternDirective,
2491            ngPattern: patternDirective,
2492            required: requiredDirective,
2493            ngRequired: requiredDirective,
2494            minlength: minlengthDirective,
2495            ngMinlength: minlengthDirective,
2496            maxlength: maxlengthDirective,
2497            ngMaxlength: maxlengthDirective,
2498            ngValue: ngValueDirective,
2499            ngModelOptions: ngModelOptionsDirective
2500        }).
2501        directive({
2502          ngInclude: ngIncludeFillContentDirective
2503        }).
2504        directive(ngAttributeAliasDirectives).
2505        directive(ngEventDirectives);
2506      $provide.provider({
2507        $anchorScroll: $AnchorScrollProvider,
2508        $animate: $AnimateProvider,
2509        $animateCss: $CoreAnimateCssProvider,

2510        $$animateJs: $$CoreAnimateJsProvider,
2511        $$animateQueue: $$CoreAnimateQueueProvider,
2512        $$AnimateRunner: $$AnimateRunnerFactoryProvider,
2513        $$animateAsyncRun: $$AnimateAsyncRunFactoryProvider,
2514        $browser: $BrowserProvider,
2515        $cacheFactory: $CacheFactoryProvider,
2516        $controller: $ControllerProvider,
2517        $document: $DocumentProvider,
2518        $exceptionHandler: $ExceptionHandlerProvider,
2519        $filter: $FilterProvider,
2520        $$forceReflow: $$ForceReflowProvider,
2521        $interpolate: $InterpolateProvider,
2522        $interval: $IntervalProvider,
2523        $http: $HttpProvider,
2524        $httpParamSerializer: $HttpParamSerializerProvider,
2525        $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
2526        $httpBackend: $HttpBackendProvider,
2527        $xhrFactory: $xhrFactoryProvider,
2528        $location: $LocationProvider,
2529        $log: $LogProvider,
2530        $parse: $ParseProvider,
2531        $rootScope: $RootScopeProvider,
2532        $q: $QProvider,
2533        $$q: $$QProvider,
2534        $sce: $SceProvider,
2535        $sceDelegate: $SceDelegateProvider,
2536        $sniffer: $SnifferProvider,
2537        $templateCache: $TemplateCacheProvider,
2538        $templateRequest: $TemplateRequestProvider,
2539        $$testability: $$TestabilityProvider,
2540        $timeout: $TimeoutProvider,
2541        $window: $WindowProvider,
2542        $$rAF: $$RAFProvider,
2543        $$jqLite: $$jqLiteProvider,
2544        $$HashMap: $$HashMapProvider,
2545        $$cookieReader: $$CookieReaderProvider
2546      });
2547    }
2548  ]);
2549}
2550
2551/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2552 *     Any commits to this file should be reviewed with security in mind.  *
2553 *   Changes to this file can potentially create security vulnerabilities. *
2554 *          An approval from 2 Core members with history of modifying      *
2555 *                         this file is required.                          *
2556 *                                                                         *
2557 *  Does the change somehow allow for arbitrary javascript to be executed? *
2558 *    Or allows for someone to change the prototype of built-in objects?   *
2559 *     Or gives undesired access to variables likes document or window?    *
2560 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2561
2562/* global JQLitePrototype: true,
2563  addEventListenerFn: true,
2564  removeEventListenerFn: true,
2565  BOOLEAN_ATTR: true,
2566  ALIASED_ATTR: true,
2567*/
2568
2569//////////////////////////////////
2570//JQLite
2571//////////////////////////////////
2572
2573/**
2574 * @ngdoc function
2575 * @name angular.element
2576 * @module ng
2577 * @kind function
2578 *
2579 * @description
2580 * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
2581 *
2582 * If jQuery is available, `angular.element` is an alias for the
2583 * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
2584 * delegates to Angular's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
2585 *
2586 * jqLite is a tiny, API-compatible subset of jQuery that allows
2587 * Angular to manipulate the DOM in a cross-browser compatible way. jqLite implements only the most
2588 * commonly needed functionality with the goal of having a very small footprint.
2589 *
2590 * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
2591 * {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
2592 * specific version of jQuery if multiple versions exist on the page.
2593 *
2594 * <div class="alert alert-info">**Note:** All element references in Angular are always wrapped with jQuery or
2595 * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
2596 *
2597 * <div class="alert alert-warning">**Note:** Keep in mind that this function will not find elements
2598 * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
2599 * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
2600 *
2601 * ## Angular's jqLite
2602 * jqLite provides only the following jQuery methods:
2603 *
2604 * - [`addClass()`](http://api.jquery.com/addClass/)
2605 * - [`after()`](http://api.jquery.com/after/)
2606 * - [`append()`](http://api.jquery.com/append/)
2607 * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
2608 * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
2609 * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
2610 * - [`clone()`](http://api.jquery.com/clone/)
2611 * - [`contents()`](http://api.jquery.com/contents/)
2612 * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`.

2613 *   As a setter, does not convert numbers to strings or append 'px', and also does not have automatic property prefixing.
2614 * - [`data()`](http://api.jquery.com/data/)
2615 * - [`detach()`](http://api.jquery.com/detach/)
2616 * - [`empty()`](http://api.jquery.com/empty/)
2617 * - [`eq()`](http://api.jquery.com/eq/)
2618 * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
2619 * - [`hasClass()`](http://api.jquery.com/hasClass/)
2620 * - [`html()`](http://api.jquery.com/html/)
2621 * - [`next()`](http://api.jquery.com/next/) - Does not support selectors
2622 * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
2623 * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
2624 * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
2625 * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
2626 * - [`prepend()`](http://api.jquery.com/prepend/)
2627 * - [`prop()`](http://api.jquery.com/prop/)
2628 * - [`ready()`](http://api.jquery.com/ready/)
2629 * - [`remove()`](http://api.jquery.com/remove/)
2630 * - [`removeAttr()`](http://api.jquery.com/removeAttr/)
2631 * - [`removeClass()`](http://api.jquery.com/removeClass/)
2632 * - [`removeData()`](http://api.jquery.com/removeData/)
2633 * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
2634 * - [`text()`](http://api.jquery.com/text/)
2635 * - [`toggleClass()`](http://api.jquery.com/toggleClass/)
2636 * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
2637 * - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces or event object as parameter
2638 * - [`val()`](http://api.jquery.com/val/)
2639 * - [`wrap()`](http://api.jquery.com/wrap/)
2640 *
2641 * ## jQuery/jqLite Extras
2642 * Angular also provides the following additional methods and events to both jQuery and jqLite:
2643 *
2644 * ### Events
2645 * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
2646 *    on all DOM nodes being removed.  This can be used to clean up any 3rd party bindings to the DOM
2647 *    element before it is removed.
2648 *
2649 * ### Methods
2650 * - `controller(name)` - retrieves the controller of the current element or its parent. By default
2651 *   retrieves controller associated with the `ngController` directive. If `name` is provided as
2652 *   camelCase directive name, then the controller for this directive will be retrieved (e.g.
2653 *   `'ngModel'`).
2654 * - `injector()` - retrieves the injector of the current element or its parent.
2655 * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
2656 *   element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
2657 *   be enabled.
2658 * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
2659 *   current element. This getter should be used only on elements that contain a directive which starts a new isolate
2660 *   scope. Calling `scope()` on this element always returns the original non-isolate scope.
2661 *   Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
2662 * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
2663 *   parent element is reached.
2664 *
2665 * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
2666 * @returns {Object} jQuery object.
2667 */
2668
2669JQLite.expando = 'ng339';
2670
2671var jqCache = JQLite.cache = {},
2672    jqId = 1,
2673    addEventListenerFn = function(element, type, fn) {
2674      element.addEventListener(type, fn, false);
2675    },
2676    removeEventListenerFn = function(element, type, fn) {
2677      element.removeEventListener(type, fn, false);
2678    };
2679
2680/*
2681 * !!! This is an undocumented "private" function !!!
2682 */
2683JQLite._data = function(node) {
2684  //jQuery always returns an object on cache miss
2685  return this.cache[node[this.expando]] || {};
2686};
2687
2688function jqNextId() { return ++jqId; }
2689
2690
2691var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
2692var MOZ_HACK_REGEXP = /^moz([A-Z])/;
2693var MOUSE_EVENT_MAP= { mouseleave: "mouseout", mouseenter: "mouseover"};
2694var jqLiteMinErr = minErr('jqLite');
2695
2696/**
2697 * Converts snake_case to camelCase.
2698 * Also there is special case for Moz prefix starting with upper case letter.
2699 * @param name Name to normalize
2700 */
2701function camelCase(name) {
2702  return name.
2703    replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
2704      return offset ? letter.toUpperCase() : letter;
2705    }).
2706    replace(MOZ_HACK_REGEXP, 'Moz$1');
2707}
2708
2709var SINGLE_TAG_REGEXP = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/;