https://borroweraccess.ecmc.org/ba2/resources/javascript/angular.js

1/**
2 * @license AngularJS v1.3.12
3 * (c) 2010-2014 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 code = arguments[0],
42      prefix = '[' + (module ? module + ':' : '') + code + '] ',
43      template = arguments[1],
44      templateArgs = arguments,
45
46      message, i;
47
48    message = prefix + template.replace(/\{\d+\}/g, function(match) {
49      var index = +match.slice(1, -1), arg;
50
51      if (index + 2 < templateArgs.length) {
52        return toDebugString(templateArgs[index + 2]);
53      }
54      return match;
55    });
56
57    message = message + '\nhttp://errors.angularjs.org/1.3.12/' +
58      (module ? module + '/' : '') + code;
59    for (i = 2; i < arguments.length; i++) {
60      message = message + (i == 2 ? '?' : '&') + 'p' + (i - 2) + '=' +
61        encodeURIComponent(toDebugString(arguments[i]));
62    }
63    return new ErrorConstructor(message);
64  };
65}
66
67/* We need to tell jshint what variables are being exported */
68/* global angular: true,
69  msie: true,
70  jqLite: true,
71  jQuery: true,
72  slice: true,
73  splice: true,
74  push: true,
75  toString: true,
76  ngMinErr: true,
77  angularModule: true,
78  uid: true,
79  REGEX_STRING_REGEXP: true,
80  VALIDITY_STATE_PROPERTY: true,
81
82  lowercase: true,
83  uppercase: true,
84  manualLowercase: true,
85  manualUppercase: true,
86  nodeName_: true,
87  isArrayLike: true,
88  forEach: true,
89  sortedKeys: true,
90  forEachSorted: true,
91  reverseParams: true,
92  nextUid: true,
93  setHashKey: true,
94  extend: true,
95  int: true,
96  inherit: true,
97  noop: true,
98  identity: true,
99  valueFn: true,
100  isUndefined: true,
101  isDefined: true,
102  isObject: true,
103  isString: true,
104  isNumber: true,
105  isDate: true,
106  isArray: true,
107  isFunction: true,
108  isRegExp: true,
109  isWindow: true,
110  isScope: true,
111  isFile: true,
112  isFormData: true,
113  isBlob: true,
114  isBoolean: true,
115  isPromiseLike: true,
116  trim: true,
117  escapeForRegexp: true,
118  isElement: true,
119  makeMap: true,
120  includes: true,
121  arrayRemove: true,
122  copy: true,
123  shallowCopy: true,
124  equals: true,
125  csp: true,
126  concat: true,
127  sliceArgs: true,
128  bind: true,
129  toJsonReplacer: true,
130  toJson: true,
131  fromJson: true,
132  startingTag: true,
133  tryDecodeURIComponent: true,
134  parseKeyValue: true,
135  toKeyValue: true,
136  encodeUriSegment: true,
137  encodeUriQuery: true,
138  angularInit: true,
139  bootstrap: true,
140  getTestability: true,
141  snake_case: true,
142  bindJQuery: true,
143  assertArg: true,
144  assertArgFn: true,
145  assertNotHasOwnProperty: true,
146  getter: true,
147  getBlockNodes: true,
148  hasOwnProperty: true,
149  createMap: true,
150
151  NODE_TYPE_ELEMENT: true,
152  NODE_TYPE_TEXT: true,
153  NODE_TYPE_COMMENT: true,
154  NODE_TYPE_DOCUMENT: true,
155  NODE_TYPE_DOCUMENT_FRAGMENT: true,
156*/
157

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

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

721 *
722 * * If no destination is supplied, a copy of the object or array is created.
723 * * If a destination is provided, all of its elements (for arrays) or properties (for objects)
724 *   are deleted and then all elements/properties from the source are copied to it.
725 * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
726 * * If `source` is identical to 'destination' an exception will be thrown.
727 *
728 * @param {*} source The source that will be used to make a copy.
729 *                   Can be any type, including primitives, `null`, and `undefined`.
730 * @param {(Object|Array)=} destination Destination into which the source is copied. If
731 *     provided, must be of the same type as `source`.
732 * @returns {*} The copy or updated `destination`, if `destination` was specified.
733 *
734 * @example
735 <example module="copyExample">
736 <file name="index.html">
737 <div ng-controller="ExampleController">
738 <form novalidate class="simple-form">
739 Name: <input type="text" ng-model="user.name" /><br />
740 E-mail: <input type="email" ng-model="user.email" /><br />
741 Gender: <input type="radio" ng-model="user.gender" value="male" />male
742 <input type="radio" ng-model="user.gender" value="female" />female<br />
743 <button ng-click="reset()">RESET</button>
744 <button ng-click="update(user)">SAVE</button>
745 </form>
746 <pre>form = {{user | json}}</pre>
747 <pre>master = {{master | json}}</pre>
748 </div>
749
750 <script>
751  angular.module('copyExample', [])
752    .controller('ExampleController', ['$scope', function($scope) {
753      $scope.master= {};
754
755      $scope.update = function(user) {
756        // Example with 1 argument
757        $scope.master= angular.copy(user);
758      };
759
760      $scope.reset = function() {
761        // Example with 2 arguments
762        angular.copy($scope.master, $scope.user);
763      };
764
765      $scope.reset();
766    }]);
767 </script>
768 </file>
769 </example>
770 */
771function copy(source, destination, stackSource, stackDest) {
772  if (isWindow(source) || isScope(source)) {
773    throw ngMinErr('cpws',
774      "Can't copy! Making copies of Window or Scope instances is not supported.");
775  }
776
777  if (!destination) {
778    destination = source;
779    if (source) {
780      if (isArray(source)) {
781        destination = copy(source, [], stackSource, stackDest);
782      } else if (isDate(source)) {
783        destination = new Date(source.getTime());
784      } else if (isRegExp(source)) {
785        destination = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
786        destination.lastIndex = source.lastIndex;
787      } else if (isObject(source)) {
788        var emptyObject = Object.create(Object.getPrototypeOf(source));
789        destination = copy(source, emptyObject, stackSource, stackDest);
790      }
791    }
792  } else {
793    if (source === destination) throw ngMinErr('cpi',
794      "Can't copy! Source and destination are identical.");
795
796    stackSource = stackSource || [];
797    stackDest = stackDest || [];
798
799    if (isObject(source)) {
800      var index = stackSource.indexOf(source);
801      if (index !== -1) return stackDest[index];
802
803      stackSource.push(source);
804      stackDest.push(destination);
805    }
806
807    var result;
808    if (isArray(source)) {
809      destination.length = 0;
810      for (var i = 0; i < source.length; i++) {
811        result = copy(source[i], null, stackSource, stackDest);
812        if (isObject(source[i])) {
813          stackSource.push(source[i]);
814          stackDest.push(result);
815        }
816        destination.push(result);
817      }
818    } else {
819      var h = destination.$$hashKey;
820      if (isArray(destination)) {
821        destination.length = 0;
822      } else {
823        forEach(destination, function(value, key) {
824          delete destination[key];
825        });
826      }
827      for (var key in source) {
828        if (source.hasOwnProperty(key)) {
829          result = copy(source[key], null, stackSource, stackDest);
830          if (isObject(source[key])) {
831            stackSource.push(source[key]);
832            stackDest.push(result);
833          }
834          destination[key] = result;
835        }
836      }
837      setHashKey(destination,h);
838    }
839
840  }
841  return destination;
842}
843
844/**
845 * Creates a shallow copy of an object, an array or a primitive.
846 *
847 * Assumes that there are no proto properties for objects.
848 */
849function shallowCopy(src, dst) {
850  if (isArray(src)) {
851    dst = dst || [];
852
853    for (var i = 0, ii = src.length; i < ii; i++) {
854      dst[i] = src[i];
855    }
856  } else if (isObject(src)) {
857    dst = dst || {};
858
859    for (var key in src) {
860      if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
861        dst[key] = src[key];
862      }
863    }
864  }
865
866  return dst || src;
867}
868
869
870/**
871 * @ngdoc function
872 * @name angular.equals
873 * @module ng
874 * @kind function
875 *
876 * @description
877 * Determines if two objects or two values are equivalent. Supports value types, regular
878 * expressions, arrays and objects.
879 *
880 * Two objects or values are considered equivalent if at least one of the following is true:
881 *
882 * * Both objects or values pass `===` comparison.
883 * * Both objects or values are of the same type and all of their properties are equal by
884 *   comparing them with `angular.equals`.
885 * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
886 * * Both values represent the same regular expression (In JavaScript,

887 *   /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
888 *   representation matches).
889 *
890 * During a property comparison, properties of `function` type and properties with names
891 * that begin with `$` are ignored.
892 *
893 * Scope and DOMWindow objects are being compared only by identify (`===`).
894 *
895 * @param {*} o1 Object or value to compare.
896 * @param {*} o2 Object or value to compare.
897 * @returns {boolean} True if arguments are equal.
898 */
899function equals(o1, o2) {
900  if (o1 === o2) return true;
901  if (o1 === null || o2 === null) return false;
902  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
903  var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
904  if (t1 == t2) {
905    if (t1 == 'object') {
906      if (isArray(o1)) {
907        if (!isArray(o2)) return false;
908        if ((length = o1.length) == o2.length) {
909          for (key = 0; key < length; key++) {
910            if (!equals(o1[key], o2[key])) return false;
911          }
912          return true;
913        }
914      } else if (isDate(o1)) {
915        if (!isDate(o2)) return false;
916        return equals(o1.getTime(), o2.getTime());
917      } else if (isRegExp(o1) && isRegExp(o2)) {
918        return o1.toString() == o2.toString();
919      } else {
920        if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) || isArray(o2)) return false;
921        keySet = {};
922        for (key in o1) {
923          if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
924          if (!equals(o1[key], o2[key])) return false;
925          keySet[key] = true;
926        }
927        for (key in o2) {
928          if (!keySet.hasOwnProperty(key) &&
929              key.charAt(0) !== '$' &&
930              o2[key] !== undefined &&
931              !isFunction(o2[key])) return false;
932        }
933        return true;
934      }
935    }
936  }
937  return false;
938}
939
940var csp = function() {
941  if (isDefined(csp.isActive_)) return csp.isActive_;
942
943  var active = !!(document.querySelector('[ng-csp]') ||
944                  document.querySelector('[data-ng-csp]'));
945
946  if (!active) {
947    try {
948      /* jshint -W031, -W054 */
949      new Function('');
950      /* jshint +W031, +W054 */
951    } catch (e) {
952      active = true;
953    }
954  }
955
956  return (csp.isActive_ = active);
957};
958
959
960
961function concat(array1, array2, index) {
962  return array1.concat(slice.call(array2, index));
963}
964
965function sliceArgs(args, startIndex) {
966  return slice.call(args, startIndex || 0);
967}
968
969
970/* jshint -W101 */
971/**
972 * @ngdoc function
973 * @name angular.bind
974 * @module ng
975 * @kind function
976 *
977 * @description
978 * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
979 * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
980 * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
981 * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
982 *
983 * @param {Object} self Context which `fn` should be evaluated in.
984 * @param {function()} fn Function to be bound.
985 * @param {...*} args Optional arguments to be prebound to the `fn` function call.
986 * @returns {function()} Function that wraps the `fn` with all the specified bindings.
987 */
988/* jshint +W101 */
989function bind(self, fn) {
990  var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
991  if (isFunction(fn) && !(fn instanceof RegExp)) {
992    return curryArgs.length
993      ? function() {
994          return arguments.length
995            ? fn.apply(self, concat(curryArgs, arguments, 0))
996            : fn.apply(self, curryArgs);
997        }
998      : function() {
999          return arguments.length
1000            ? fn.apply(self, arguments)
1001            : fn.call(self);
1002        };
1003  } else {
1004    // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
1005    return fn;
1006  }
1007}
1008
1009
1010function toJsonReplacer(key, value) {
1011  var val = value;
1012
1013  if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
1014    val = undefined;
1015  } else if (isWindow(value)) {
1016    val = '$WINDOW';
1017  } else if (value &&  document === value) {
1018    val = '$DOCUMENT';
1019  } else if (isScope(value)) {
1020    val = '$SCOPE';
1021  }
1022
1023  return val;
1024}
1025
1026
1027/**
1028 * @ngdoc function
1029 * @name angular.toJson
1030 * @module ng
1031 * @kind function
1032 *
1033 * @description
1034 * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
1035 * stripped since angular uses this notation internally.
1036 *
1037 * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
1038 * @param {boolean|number=}

1038 pretty If set to true, the JSON output will contain newlines and whitespace.
1039 *    If set to an integer, the JSON output will contain that many spaces per indentation (the default is 2).
1040 * @returns {string|undefined} JSON-ified string representing `obj`.
1041 */
1042function toJson(obj, pretty) {
1043  if (typeof obj === 'undefined') return undefined;
1044  if (!isNumber(pretty)) {
1045    pretty = pretty ? 2 : null;
1046  }
1047  return JSON.stringify(obj, toJsonReplacer, pretty);
1048}
1049
1050
1051/**
1052 * @ngdoc function
1053 * @name angular.fromJson
1054 * @module ng
1055 * @kind function
1056 *
1057 * @description
1058 * Deserializes a JSON string.
1059 *
1060 * @param {string} json JSON string to deserialize.
1061 * @returns {Object|Array|string|number} Deserialized JSON string.
1062 */
1063function fromJson(json) {
1064  return isString(json)
1065      ? JSON.parse(json)
1066      : json;
1067}
1068
1069
1070/**
1071 * @returns {string} Returns the string representation of the element.
1072 */
1073function startingTag(element) {
1074  element = jqLite(element).clone();
1075  try {
1076    // turns out IE does not let you set .html() on elements which
1077    // are not allowed to have children. So we just ignore it.
1078    element.empty();
1079  } catch (e) {}
1080  var elemHtml = jqLite('<div>').append(element).html();
1081  try {
1082    return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
1083        elemHtml.
1084          match(/^(<[^>]+>)/)[1].
1085          replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
1086  } catch (e) {
1087    return lowercase(elemHtml);
1088  }
1089
1090}
1091
1092
1093/////////////////////////////////////////////////
1094
1095/**
1096 * Tries to decode the URI component without throwing an exception.
1097 *
1098 * @private
1099 * @param str value potential URI component to check.
1100 * @returns {boolean} True if `value` can be decoded
1101 * with the decodeURIComponent function.
1102 */
1103function tryDecodeURIComponent(value) {
1104  try {
1105    return decodeURIComponent(value);
1106  } catch (e) {
1107    // Ignore any invalid uri component
1108  }
1109}
1110
1111
1112/**
1113 * Parses an escaped url query string into key-value pairs.
1114 * @returns {Object.<string,boolean|Array>}
1115 */
1116function parseKeyValue(/**string*/keyValue) {
1117  var obj = {}, key_value, key;
1118  forEach((keyValue || "").split('&'), function(keyValue) {
1119    if (keyValue) {
1120      key_value = keyValue.replace(/\+/g,'%20').split('=');
1121      key = tryDecodeURIComponent(key_value[0]);
1122      if (isDefined(key)) {
1123        var val = isDefined(key_value[1]) ? tryDecodeURIComponent(key_value[1]) : true;
1124        if (!hasOwnProperty.call(obj, key)) {
1125          obj[key] = val;
1126        } else if (isArray(obj[key])) {
1127          obj[key].push(val);
1128        } else {
1129          obj[key] = [obj[key],val];
1130        }
1131      }
1132    }
1133  });
1134  return obj;
1135}
1136
1137function toKeyValue(obj) {
1138  var parts = [];
1139  forEach(obj, function(value, key) {
1140    if (isArray(value)) {
1141      forEach(value, function(arrayValue) {
1142        parts.push(encodeUriQuery(key, true) +
1143                   (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
1144      });
1145    } else {
1146    parts.push(encodeUriQuery(key, true) +
1147               (value === true ? '' : '=' + encodeUriQuery(value, true)));
1148    }
1149  });
1150  return parts.length ? parts.join('&') : '';
1151}
1152
1153
1154/**
1155 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
1156 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
1157 * segments:
1158 *    segment       = *pchar
1159 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1160 *    pct-encoded   = "%" HEXDIG HEXDIG
1161 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1162 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1163 *                     / "*" / "+" / "," / ";" / "="
1164 */
1165function encodeUriSegment(val) {
1166  return encodeUriQuery(val, true).
1167             replace(/%26/gi, '&').
1168             replace(/%3D/gi, '=').
1169             replace(/%2B/gi, '+');
1170}
1171
1172
1173/**
1174 * This method is intended for encoding *key* or *value* parts of query component. We need a custom
1175 * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
1176 * encoded per http://tools.ietf.org/html/rfc3986:
1177 *    query       = *( pchar / "/" / "?" )
1178 *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
1179 *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
1180 *    pct-encoded   = "%" HEXDIG HEXDIG
1181 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
1182 *                     / "*" / "+" / "," / ";" / "="
1183 */
1184function encodeUriQuery(val, pctEncodeSpaces) {
1185  return encodeURIComponent(val).
1186             replace(/%40/gi, '@').
1187             replace(/%3A/gi, ':').
1188             replace(/%24/g, '$').
1189             replace(/%2C/gi, ',').
1190             replace(/%3B/gi, ';').
1191             replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
1192}
1193
1194var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
1195
1196function getNgAttribute(element, ngAttr) {
1197  var attr, i, ii = ngAttrPrefixes.length;
1198  element = jqLite(element);
1199  for (i = 0; i < ii; ++i) {
1200    attr = ngAttrPrefixes[i] + ngAttr;
1201    if (isString(attr = element.attr(attr))) {
1202      return attr;
1203    }
1204  }
1205  return null;
1206}
1207
1208/**
1209 * @ngdoc directive
1210 * @name ngApp
1211 * @module ng
1212 *
1213 * @element ANY
1214 * @param {angular.Module} ngApp an optional application
1215 *   {@link angular.module module} name to load.
1216 * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
1217 *   created in "strict-di" mode. This means that the application will fail to invoke functions which
1218 *   do not use explicit function annotation (and are thus unsuitable for minification), as de

1218scribed
1219 *   in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
1220 *   tracking down the root of these bugs.
1221 *
1222 * @description
1223 *
1224 * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
1225 * designates the **root element** of the application and is typically placed near the root element
1226 * of the page - e.g. on the `<body>` or `<html>` tags.
1227 *
1228 * Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
1229 * found in the document will be used to define the root element to auto-bootstrap as an
1230 * application. To run multiple applications in an HTML document you must manually bootstrap them using
1231 * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
1232 *
1233 * You can specify an **AngularJS module** to be used as the root module for the application.  This
1234 * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
1235 * should contain the application code needed or have dependencies on other modules that will
1236 * contain the code. See {@link angular.module} for more information.
1237 *
1238 * In the example below if the `ngApp` directive were not placed on the `html` element then the
1239 * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
1240 * would not be resolved to `3`.
1241 *
1242 * `ngApp` is the easiest, and most common way to bootstrap an application.
1243 *
1244 <example module="ngAppDemo">
1245   <file name="index.html">
1246   <div ng-controller="ngAppDemoController">
1247     I can add: {{a}} + {{b}} =  {{ a+b }}
1248   </div>
1249   </file>
1250   <file name="script.js">
1251   angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
1252     $scope.a = 1;
1253     $scope.b = 2;
1254   });
1255   </file>
1256 </example>
1257 *
1258 * Using `ngStrictDi`, you would see something like this:
1259 *
1260 <example ng-app-included="true">
1261   <file name="index.html">
1262   <div ng-app="ngAppStrictDemo" ng-strict-di>
1263       <div ng-controller="GoodController1">
1264           I can add: {{a}} + {{b}} =  {{ a+b }}
1265
1266           <p>This renders because the controller does not fail to
1267              instantiate, by using explicit annotation style (see
1268              script.js for details)
1269           </p>
1270       </div>
1271
1272       <div ng-controller="GoodController2">
1273           Name: <input ng-model="name"><br />
1274           Hello, {{name}}!
1275
1276           <p>This renders because the controller does not fail to
1277              instantiate, by using explicit annotation style
1278              (see script.js for details)
1279           </p>
1280       </div>
1281
1282       <div ng-controller="BadController">
1283           I can add: {{a}} + {{b}} =  {{ a+b }}
1284
1285           <p>The controller could not be instantiated, due to relying
1286              on automatic function annotations (which are disabled in
1287              strict mode). As such, the content of this section is not
1288              interpolated, and there should be an error in your web console.
1289           </p>
1290       </div>
1291   </div>
1292   </file>
1293   <file name="script.js">
1294   angular.module('ngAppStrictDemo', [])
1295     // BadController will fail to instantiate, due to relying on automatic function annotation,
1296     // rather than an explicit annotation
1297     .controller('BadController', function($scope) {
1298       $scope.a = 1;
1299       $scope.b = 2;
1300     })
1301     // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
1302     // due to using explicit annotations using the array style and $inject property, respectively.
1303     .controller('GoodController1', ['$scope', function($scope) {
1304       $scope.a = 1;
1305       $scope.b = 2;
1306     }])
1307     .controller('GoodController2', GoodController2);
1308     function GoodController2($scope) {
1309       $scope.name = "World";
1310     }
1311     GoodController2.$inject = ['$scope'];
1312   </file>
1313   <file name="style.css">
1314   div[ng-controller] {
1315       margin-bottom: 1em;
1316       -webkit-border-radius: 4px;
1317       border-radius: 4px;
1318       border: 1px solid;
1319       padding: .5em;
1320   }
1321   div[ng-controller^=Good] {
1322       border-color: #d6e9c6;
1323       background-color: #dff0d8;
1324       color: #3c763d;
1325   }
1326   div[ng-controller^=Bad] {
1327       border-color: #ebccd1;
1328       background-color: #f2dede;
1329       color: #a94442;
1330       margin-bottom: 0;
1331   }
1332   </file>
1333 </example>
1334 */
1335function angularInit(element, bootstrap) {
1336  var appElement,
1337      module,
1338      config = {};
1339
1340  // The element `element` has priority over any other element
1341  forEach(ngAttrPrefixes, function(prefix) {
1342    var name = prefix + 'app';
1343
1344    if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
1345      appElement = element;
1346      module = element.getAttribute(name);
1347    }
1348  });
1349  forEach(ngAttrPrefixes, function(prefix) {
1350    var name = prefix + 'app';
1351    var candidate;
1352
1353    if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
1354      appElement = candidate;
1355      module = candidate.getAttribute(name);
1356    }
1357  });
1358  if (appElement) {
1359    config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
1360    bootstrap(appElement, module ? [module] : [], config);
1361  }
1362}
1363
1364/**
1365 * @ngdoc function
1366 * @name angular.bootstrap
1367 * @module ng
1368 * @description
1369 * Use this function to manually start up angular application.
1370 *
1371 * See: {@link guide/bootstrap Bootstrap}
1372 *

1373 * Note that Protractor based end-to-end tests cannot use this function to bootstrap manually.
1374 * They must use {@link ng.directive:ngApp ngApp}.
1375 *
1376 * Angular will detect if it has been loaded into the browser more than once and only allow the
1377 * first loaded script to be bootstrapped and will report a warning to the browser console for
1378 * each of the subsequent scripts. This prevents strange results in applications, where otherwise
1379 * multiple instances of Angular try to work on the DOM.
1380 *
1381 * ```html
1382 * <!doctype html>
1383 * <html>
1384 * <body>
1385 * <div ng-controller="WelcomeController">
1386 *   {{greeting}}
1387 * </div>
1388 *
1389 * <script src="angular.js"></script>
1390 * <script>
1391 *   var app = angular.module('demo', [])
1392 *   .controller('WelcomeController', function($scope) {
1393 *       $scope.greeting = 'Welcome!';
1394 *   });
1395 *   angular.bootstrap(document, ['demo']);
1396 * </script>
1397 * </body>
1398 * </html>
1399 * ```
1400 *
1401 * @param {DOMElement} element DOM element which is the root of angular application.
1402 * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
1403 *     Each item in the array should be the name of a predefined module or a (DI annotated)
1404 *     function that will be invoked by the injector as a `config` block.
1405 *     See: {@link angular.module modules}
1406 * @param {Object=} config an object for defining configuration options for the application. The
1407 *     following keys are supported:
1408 *
1409 * * `strictDi` - disable automatic function annotation for the application. This is meant to
1410 *   assist in finding bugs which break minified code. Defaults to `false`.
1411 *
1412 * @returns {auto.$injector} Returns the newly created injector for this app.
1413 */
1414function bootstrap(element, modules, config) {
1415  if (!isObject(config)) config = {};
1416  var defaultConfig = {
1417    strictDi: false
1418  };
1419  config = extend(defaultConfig, config);
1420  var doBootstrap = function() {
1421    element = jqLite(element);
1422
1423    if (element.injector()) {
1424      var tag = (element[0] === document) ? 'document' : startingTag(element);
1425      //Encode angle brackets to prevent input from being sanitized to empty string #8683
1426      throw ngMinErr(
1427          'btstrpd',
1428          "App Already Bootstrapped with this Element '{0}'",
1429          tag.replace(/</,'&lt;').replace(/>/,'&gt;'));
1430    }
1431
1432    modules = modules || [];
1433    modules.unshift(['$provide', function($provide) {
1434      $provide.value('$rootElement', element);
1435    }]);
1436
1437    if (config.debugInfoEnabled) {
1438      // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
1439      modules.push(['$compileProvider', function($compileProvider) {
1440        $compileProvider.debugInfoEnabled(true);
1441      }]);
1442    }
1443
1444    modules.unshift('ng');
1445    var injector = createInjector(modules, config.strictDi);
1446    injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
1447       function bootstrapApply(scope, element, compile, injector) {
1448        scope.$apply(function() {
1449          element.data('$injector', injector);
1450          compile(element)(scope);
1451        });
1452      }]
1453    );
1454    return injector;
1455  };
1456
1457  var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
1458  var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
1459
1460  if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
1461    config.debugInfoEnabled = true;
1462    window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
1463  }
1464
1465  if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
1466    return doBootstrap();
1467  }
1468
1469  window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
1470  angular.resumeBootstrap = function(extraModules) {
1471    forEach(extraModules, function(module) {
1472      modules.push(module);
1473    });
1474    return doBootstrap();
1475  };
1476
1477  if (isFunction(angular.resumeDeferredBootstrap)) {
1478    angular.resumeDeferredBootstrap();
1479  }
1480}
1481
1482/**
1483 * @ngdoc function
1484 * @name angular.reloadWithDebugInfo
1485 * @module ng
1486 * @description
1487 * Use this function to reload the current application with debug information turned on.
1488 * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
1489 *
1490 * See {@link ng.$compileProvider#debugInfoEnabled} for more.
1491 */
1492function reloadWithDebugInfo() {
1493  window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
1494  window.location.reload();
1495}
1496
1497/**
1498 * @name angular.getTestability
1499 * @module ng
1500 * @description
1501 * Get the testability service for the instance of Angular on the given
1502 * element.
1503 * @param {DOMElement} element DOM element which is the root of angular application.
1504 */
1505function getTestability(rootElement) {
1506  var injector = angular.element(rootElement).injector();
1507  if (!injector) {
1508    throw ngMinErr('test',
1509      'no injector found for element argument to getTestability');
1510  }
1511  return injector.get('$$testability');
1512}
1513
1514var SNAKE_CASE_REGEXP = /[A-Z]/g;
1515function snake_case(name, separator) {
1516  separator = separator || '_';
1517  return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
1518    return (pos ? separator : '') + letter.toLowerCase();
1519  });
1520}
1521
1522var bindJQueryFired = false;

1523var skipDestroyOnNextJQueryCleanData;
1524function bindJQuery() {
1525  var originalCleanData;
1526
1527  if (bindJQueryFired) {
1528    return;
1529  }
1530
1531  // bind to jQuery if present;
1532  jQuery = window.jQuery;
1533  // Use jQuery if it exists with proper functionality, otherwise default to us.
1534  // Angular 1.2+ requires jQuery 1.7+ for on()/off() support.
1535  // Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older
1536  // versions. It will not work for sure with jQuery <1.7, though.
1537  if (jQuery && jQuery.fn.on) {
1538    jqLite = jQuery;
1539    extend(jQuery.fn, {
1540      scope: JQLitePrototype.scope,
1541      isolateScope: JQLitePrototype.isolateScope,
1542      controller: JQLitePrototype.controller,
1543      injector: JQLitePrototype.injector,
1544      inheritedData: JQLitePrototype.inheritedData
1545    });
1546
1547    // All nodes removed from the DOM via various jQuery APIs like .remove()
1548    // are passed through jQuery.cleanData. Monkey-patch this method to fire
1549    // the $destroy event on all removed nodes.
1550    originalCleanData = jQuery.cleanData;
1551    jQuery.cleanData = function(elems) {
1552      var events;
1553      if (!skipDestroyOnNextJQueryCleanData) {
1554        for (var i = 0, elem; (elem = elems[i]) != null; i++) {
1555          events = jQuery._data(elem, "events");
1556          if (events && events.$destroy) {
1557            jQuery(elem).triggerHandler('$destroy');
1558          }
1559        }
1560      } else {
1561        skipDestroyOnNextJQueryCleanData = false;
1562      }
1563      originalCleanData(elems);
1564    };
1565  } else {
1566    jqLite = JQLite;
1567  }
1568
1569  angular.element = jqLite;
1570
1571  // Prevent double-proxying.
1572  bindJQueryFired = true;
1573}
1574
1575/**
1576 * throw error if the argument is falsy.
1577 */
1578function assertArg(arg, name, reason) {
1579  if (!arg) {
1580    throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required"));
1581  }
1582  return arg;
1583}
1584
1585function assertArgFn(arg, name, acceptArrayAnnotation) {
1586  if (acceptArrayAnnotation && isArray(arg)) {
1587      arg = arg[arg.length - 1];
1588  }
1589
1590  assertArg(isFunction(arg), name, 'not a function, got ' +
1591      (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
1592  return arg;
1593}
1594
1595/**
1596 * throw error if the name given is hasOwnProperty
1597 * @param  {String} name    the name to test
1598 * @param  {String} context the context in which the name is used, such as module or directive
1599 */
1600function assertNotHasOwnProperty(name, context) {
1601  if (name === 'hasOwnProperty') {
1602    throw ngMinErr('badname', "hasOwnProperty is not a valid {0} name", context);
1603  }
1604}
1605
1606/**
1607 * Return the value accessible from the object by path. Any undefined traversals are ignored
1608 * @param {Object} obj starting object
1609 * @param {String} path path to traverse
1610 * @param {boolean} [bindFnToScope=true]
1611 * @returns {Object} value as accessible by path
1612 */
1613//TODO(misko): this function needs to be removed
1614function getter(obj, path, bindFnToScope) {
1615  if (!path) return obj;
1616  var keys = path.split('.');
1617  var key;
1618  var lastInstance = obj;
1619  var len = keys.length;
1620
1621  for (var i = 0; i < len; i++) {
1622    key = keys[i];
1623    if (obj) {
1624      obj = (lastInstance = obj)[key];
1625    }
1626  }
1627  if (!bindFnToScope && isFunction(obj)) {
1628    return bind(lastInstance, obj);
1629  }
1630  return obj;
1631}
1632
1633/**
1634 * Return the DOM siblings between the first and last node in the given array.
1635 * @param {Array} array like object
1636 * @returns {jqLite} jqLite collection containing the nodes
1637 */
1638function getBlockNodes(nodes) {
1639  // TODO(perf): just check if all items in `nodes` are siblings and if they are return the original
1640  //             collection, otherwise update the original collection.
1641  var node = nodes[0];
1642  var endNode = nodes[nodes.length - 1];
1643  var blockNodes = [node];
1644
1645  do {
1646    node = node.nextSibling;
1647    if (!node) break;
1648    blockNodes.push(node);
1649  } while (node !== endNode);
1650
1651  return jqLite(blockNodes);
1652}
1653
1654
1655/**
1656 * Creates a new object without a prototype. This object is useful for lookup without having to
1657 * guard against prototypically inherited properties via hasOwnProperty.
1658 *
1659 * Related micro-benchmarks:
1660 * - http://jsperf.com/object-create2
1661 * - http://jsperf.com/proto-map-lookup/2
1662 * - http://jsperf.com/for-in-vs-object-keys2
1663 *
1664 * @returns {Object}
1665 */
1666function createMap() {
1667  return Object.create(null);
1668}
1669
1670var NODE_TYPE_ELEMENT = 1;
1671var NODE_TYPE_TEXT = 3;
1672var NODE_TYPE_COMMENT = 8;
1673var NODE_TYPE_DOCUMENT = 9;
1674var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
1675
1676/**
1677 * @ngdoc type
1678 * @name angular.Module
1679 * @module ng
1680 * @description
1681 *
1682 * Interface for configuring angular {@link angular.module modules}.
1683 */
1684
1685function setupModuleLoader(window) {
1686
1687  var $injectorMinErr = minErr('$injector');
1688  var ngMinErr = minErr('ng');
1689
1690  function ensure(obj, name, factory) {

1691    return obj[name] || (obj[name] = factory());
1692  }
1693
1694  var angular = ensure(window, 'angular', Object);
1695
1696  // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
1697  angular.$$minErr = angular.$$minErr || minErr;
1698
1699  return ensure(angular, 'module', function() {
1700    /** @type {Object.<string, angular.Module>} */
1701    var modules = {};
1702
1703    /**
1704     * @ngdoc function
1705     * @name angular.module
1706     * @module ng
1707     * @description
1708     *
1709     * The `angular.module` is a global place for creating, registering and retrieving Angular
1710     * modules.
1711     * All modules (angular core or 3rd party) that should be available to an application must be
1712     * registered using this mechanism.
1713     *
1714     * When passed two or more arguments, a new module is created.  If passed only one argument, an
1715     * existing module (the name passed as the first argument to `module`) is retrieved.
1716     *
1717     *
1718     * # Module
1719     *
1720     * A module is a collection of services, directives, controllers, filters, and configuration information.
1721     * `angular.module` is used to configure the {@link auto.$injector $injector}.
1722     *
1723     * ```js
1724     * // Create a new module
1725     * var myModule = angular.module('myModule', []);
1726     *
1727     * // register a new service
1728     * myModule.value('appName', 'MyCoolApp');
1729     *
1730     * // configure existing services inside initialization blocks.
1731     * myModule.config(['$locationProvider', function($locationProvider) {
1732     *   // Configure existing providers
1733     *   $locationProvider.hashPrefix('!');
1734     * }]);
1735     * ```
1736     *
1737     * Then you can create an injector and load your modules like this:
1738     *
1739     * ```js
1740     * var injector = angular.injector(['ng', 'myModule'])
1741     * ```
1742     *
1743     * However it's more likely that you'll just use
1744     * {@link ng.directive:ngApp ngApp} or
1745     * {@link angular.bootstrap} to simplify this process for you.
1746     *
1747     * @param {!string} name The name of the module to create or retrieve.
1748     * @param {!Array.<string>=} requires If specified then new module is being created. If
1749     *        unspecified then the module is being retrieved for further configuration.
1750     * @param {Function=} configFn Optional configuration function for the module. Same as
1751     *        {@link angular.Module#config Module#config()}.
1752     * @returns {module} new module with the {@link angular.Module} api.
1753     */
1754    return function module(name, requires, configFn) {
1755      var assertNotHasOwnProperty = function(name, context) {
1756        if (name === 'hasOwnProperty') {
1757          throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
1758        }
1759      };
1760
1761      assertNotHasOwnProperty(name, 'module');
1762      if (requires && modules.hasOwnProperty(name)) {
1763        modules[name] = null;
1764      }
1765      return ensure(modules, name, function() {
1766        if (!requires) {
1767          throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
1768             "the module name or forgot to load it. If registering a module ensure that you " +
1769             "specify the dependencies as the second argument.", name);
1770        }
1771
1772        /** @type {!Array.<Array.<*>>} */
1773        var invokeQueue = [];
1774
1775        /** @type {!Array.<Function>} */
1776        var configBlocks = [];
1777
1778        /** @type {!Array.<Function>} */
1779        var runBlocks = [];
1780
1781        var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
1782
1783        /** @type {angular.Module} */
1784        var moduleInstance = {
1785          // Private state
1786          _invokeQueue: invokeQueue,
1787          _configBlocks: configBlocks,
1788          _runBlocks: runBlocks,
1789
1790          /**
1791           * @ngdoc property
1792           * @name angular.Module#requires
1793           * @module ng
1794           *
1795           * @description
1796           * Holds the list of modules which the injector will load before the current module is
1797           * loaded.
1798           */
1799          requires: requires,
1800
1801          /**
1802           * @ngdoc property
1803           * @name angular.Module#name
1804           * @module ng
1805           *

1806           * @description
1807           * Name of the module.
1808           */
1809          name: name,
1810
1811
1812          /**
1813           * @ngdoc method
1814           * @name angular.Module#provider
1815           * @module ng
1816           * @param {string} name service name
1817           * @param {Function} providerType Construction function for creating new instance of the
1818           *                                service.
1819           * @description
1820           * See {@link auto.$provide#provider $provide.provider()}.
1821           */
1822          provider: invokeLater('$provide', 'provider'),
1823
1824          /**
1825           * @ngdoc method
1826           * @name angular.Module#factory
1827           * @module ng
1828           * @param {string} name service name
1829           * @param {Function} providerFunction Function for creating new instance of the service.
1830           * @description
1831           * See {@link auto.$provide#factory $provide.factory()}.
1832           */
1833          factory: invokeLater('$provide', 'factory'),
1834
1835          /**
1836           * @ngdoc method
1837           * @name angular.Module#service
1838           * @module ng
1839           * @param {string} name service name
1840           * @param {Function} constructor A constructor function that will be instantiated.
1841           * @description
1842           * See {@link auto.$provide#service $provide.service()}.
1843           */
1844          service: invokeLater('$provide', 'service'),
1845
1846          /**
1847           * @ngdoc method
1848           * @name angular.Module#value
1849           * @module ng
1850           * @param {string} name service name
1851           * @param {*} object Service instance object.
1852           * @description
1853           * See {@link auto.$provide#value $provide.value()}.
1854           */
1855          value: invokeLater('$provide', 'value'),
1856
1857          /**
1858           * @ngdoc method
1859           * @name angular.Module#constant
1860           * @module ng
1861           * @param {string} name constant name
1862           * @param {*} object Constant value.
1863           * @description
1864           * Because the constant are fixed, they get applied before other provide methods.
1865           * See {@link auto.$provide#constant $provide.constant()}.
1866           */
1867          constant: invokeLater('$provide', 'constant', 'unshift'),
1868
1869          /**
1870           * @ngdoc method
1871           * @name angular.Module#animation
1872           * @module ng
1873           * @param {string} name animation name
1874           * @param {Function} animationFactory Factory function for creating new instance of an
1875           *                                    animation.
1876           * @description
1877           *
1878           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
1879           *
1880           *
1881           * Defines an animation hook that can be later used with
1882           * {@link ngAnimate.$animate $animate} service and directives that use this service.
1883           *
1884           * ```js
1885           * module.animation('.animation-name', function($inject1, $inject2) {
1886           *   return {
1887           *     eventName : function(element, done) {
1888           *       //code to run the animation
1889           *       //once complete, then run done()
1890           *       return function cancellationFunction(element) {
1891           *         //code to cancel the animation
1892           *       }
1893           *     }
1894           *   }
1895           * })
1896           * ```
1897           *
1898           * See {@link ng.$animateProvider#register $animateProvider.register()} and
1899           * {@link ngAnimate ngAnimate module} for more information.
1900           */
1901          animation: invokeLater('$animateProvider', 'register'),
1902
1903          /**
1904           * @ngdoc method
1905           * @name angular.Module#filter
1906           * @module ng
1907           * @param {string} name Filter name.
1908           * @param {Function} filterFactory Factory function for creating new instance of filter.
1909           * @description
1910           * See {@link ng.$filterProvider#register $filterProvider.register()}.
1911           */
1912          filter: invokeLater('$filterProvider', 'register'),
1913
1914          /**
1915           * @ngdoc method
1916           * @name angular.Module#controller
1917           * @module ng
1918           * @param {string|Object} name Controller name, or an object map of controllers where the
1919           *    keys are the names and the values are the constructors.
1920           * @param {Function} constructor Controller constructor function.

1921           * @description
1922           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
1923           */
1924          controller: invokeLater('$controllerProvider', 'register'),
1925
1926          /**
1927           * @ngdoc method
1928           * @name angular.Module#directive
1929           * @module ng
1930           * @param {string|Object} name Directive name, or an object map of directives where the
1931           *    keys are the names and the values are the factories.
1932           * @param {Function} directiveFactory Factory function for creating new instance of
1933           * directives.
1934           * @description
1935           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
1936           */
1937          directive: invokeLater('$compileProvider', 'directive'),
1938
1939          /**
1940           * @ngdoc method
1941           * @name angular.Module#config
1942           * @module ng
1943           * @param {Function} configFn Execute this function on module load. Useful for service
1944           *    configuration.
1945           * @description
1946           * Use this method to register work which needs to be performed on module loading.
1947           * For more about how to configure services, see
1948           * {@link providers#provider-recipe Provider Recipe}.
1949           */
1950          config: config,
1951
1952          /**
1953           * @ngdoc method
1954           * @name angular.Module#run
1955           * @module ng
1956           * @param {Function} initializationFn Execute this function after injector creation.
1957           *    Useful for application initialization.
1958           * @description
1959           * Use this method to register work which should be performed when the injector is done
1960           * loading all modules.
1961           */
1962          run: function(block) {
1963            runBlocks.push(block);
1964            return this;
1965          }
1966        };
1967
1968        if (configFn) {
1969          config(configFn);
1970        }
1971
1972        return moduleInstance;
1973
1974        /**
1975         * @param {string} provider
1976         * @param {string} method
1977         * @param {String=} insertMethod
1978         * @returns {angular.Module}
1979         */
1980        function invokeLater(provider, method, insertMethod, queue) {
1981          if (!queue) queue = invokeQueue;
1982          return function() {
1983            queue[insertMethod || 'push']([provider, method, arguments]);
1984            return moduleInstance;
1985          };
1986        }
1987      });
1988    };
1989  });
1990
1991}
1992
1993/* global: toDebugString: true */
1994
1995function serializeObject(obj) {
1996  var seen = [];
1997
1998  return JSON.stringify(obj, function(key, val) {
1999    val = toJsonReplacer(key, val);
2000    if (isObject(val)) {
2001
2002      if (seen.indexOf(val) >= 0) return '<<already seen>>';
2003
2004      seen.push(val);
2005    }
2006    return val;
2007  });
2008}
2009
2010function toDebugString(obj) {
2011  if (typeof obj === 'function') {
2012    return obj.toString().replace(/ \{[\s\S]*$/, '');
2013  } else if (typeof obj === 'undefined') {
2014    return 'undefined';
2015  } else if (typeof obj !== 'string') {
2016    return serializeObject(obj);
2017  }
2018  return obj;
2019}
2020
2021/* global angularModule: true,
2022  version: true,
2023
2024  $LocaleProvider,
2025  $CompileProvider,
2026
2027  htmlAnchorDirective,
2028  inputDirective,
2029  inputDirective,
2030  formDirective,
2031  scriptDirective,
2032  selectDirective,
2033  styleDirective,
2034  optionDirective,
2035  ngBindDirective,
2036  ngBindHtmlDirective,
2037  ngBindTemplateDirective,
2038  ngClassDirective,
2039  ngClassEvenDirective,
2040  ngClassOddDirective,
2041  ngCspDirective,
2042  ngCloakDirective,
2043  ngControllerDirective,
2044  ngFormDirective,
2045  ngHideDirective,
2046  ngIfDirective,
2047  ngIncludeDirective,
2048  ngIncludeFillContentDirective,
2049  ngInitDirective,
2050  ngNonBindableDirective,
2051  ngPluralizeDirective,
2052  ngRepeatDirective,
2053  ngShowDirective,
2054  ngStyleDirective,
2055  ngSwitchDirective,
2056  ngSwitchWhenDirective,
2057  ngSwitchDefaultDirective,
2058  ngOptionsDirective,
2059  ngTranscludeDirective,
2060  ngModelDirective,
2061  ngListDirective,
2062  ngChangeDirective,
2063  patternDirective,
2064  patternDirective,
2065  requiredDirective,
2066  requiredDirective,
2067  minlengthDirective,
2068  minlengthDirective,
2069  maxlengthDirective,
2070  maxlengthDirective,
2071  ngValueDirective,
2072  ngModelOptionsDirective,
2073  ngAttributeAliasDirectives,
2074  ngEventDirectives,
2075
2076  $AnchorScrollProvider,
2077  $AnimateProvider,
2078  $BrowserProvider,

2079  $CacheFactoryProvider,
2080  $ControllerProvider,
2081  $DocumentProvider,
2082  $ExceptionHandlerProvider,
2083  $FilterProvider,
2084  $InterpolateProvider,
2085  $IntervalProvider,
2086  $HttpProvider,
2087  $HttpBackendProvider,
2088  $LocationProvider,
2089  $LogProvider,
2090  $ParseProvider,
2091  $RootScopeProvider,
2092  $QProvider,
2093  $$QProvider,
2094  $$SanitizeUriProvider,
2095  $SceProvider,
2096  $SceDelegateProvider,
2097  $SnifferProvider,
2098  $TemplateCacheProvider,
2099  $TemplateRequestProvider,
2100  $$TestabilityProvider,
2101  $TimeoutProvider,
2102  $$RAFProvider,
2103  $$AsyncCallbackProvider,
2104  $WindowProvider,
2105  $$jqLiteProvider
2106*/
2107
2108
2109/**
2110 * @ngdoc object
2111 * @name angular.version
2112 * @module ng
2113 * @description
2114 * An object that contains information about the current AngularJS version. This object has the
2115 * following properties:
2116 *
2117 * - `full` – `{string}` – Full version string, such as "0.9.18".
2118 * - `major` – `{number}` – Major version number, such as "0".
2119 * - `minor` – `{number}` – Minor version number, such as "9".
2120 * - `dot` – `{number}` – Dot version number, such as "18".
2121 * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
2122 */
2123var version = {
2124  full: '1.3.12',    // all of these placeholder strings will be replaced by grunt's
2125  major: 1,    // package task
2126  minor: 3,
2127  dot: 12,
2128  codeName: 'outlandish-knitting'
2129};
2130
2131
2132function publishExternalAPI(angular) {
2133  extend(angular, {
2134    'bootstrap': bootstrap,
2135    'copy': copy,
2136    'extend': extend,
2137    'equals': equals,
2138    'element': jqLite,
2139    'forEach': forEach,
2140    'injector': createInjector,
2141    'noop': noop,
2142    'bind': bind,
2143    'toJson': toJson,
2144    'fromJson': fromJson,
2145    'identity': identity,
2146    'isUndefined': isUndefined,
2147    'isDefined': isDefined,
2148    'isString': isString,
2149    'isFunction': isFunction,
2150    'isObject': isObject,
2151    'isNumber': isNumber,
2152    'isElement': isElement,
2153    'isArray': isArray,
2154    'version': version,
2155    'isDate': isDate,
2156    'lowercase': lowercase,
2157    'uppercase': uppercase,
2158    'callbacks': {counter: 0},
2159    'getTestability': getTestability,
2160    '$$minErr': minErr,
2161    '$$csp': csp,
2162    'reloadWithDebugInfo': reloadWithDebugInfo
2163  });
2164
2165  angularModule = setupModuleLoader(window);
2166  try {
2167    angularModule('ngLocale');
2168  } catch (e) {
2169    angularModule('ngLocale', []).provider('$locale', $LocaleProvider);
2170  }
2171
2172  angularModule('ng', ['ngLocale'], ['$provide',
2173    function ngModule($provide) {
2174      // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
2175      $provide.provider({
2176        $$sanitizeUri: $$SanitizeUriProvider
2177      });
2178      $provide.provider('$compile', $CompileProvider).
2179        directive({
2180            a: htmlAnchorDirective,
2181            input: inputDirective,
2182            textarea: inputDirective,
2183            form: formDirective,
2184            script: scriptDirective,
2185            select: selectDirective,
2186            style: styleDirective,
2187            option: optionDirective,
2188            ngBind: ngBindDirective,
2189            ngBindHtml: ngBindHtmlDirective,
2190            ngBindTemplate: ngBindTemplateDirective,
2191            ngClass: ngClassDirective,
2192            ngClassEven: ngClassEvenDirective,
2193            ngClassOdd: ngClassOddDirective,
2194            ngCloak: ngCloakDirective,
2195            ngController: ngControllerDirective,
2196            ngForm: ngFormDirective,
2197            ngHide: ngHideDirective,
2198            ngIf: ngIfDirective,
2199            ngInclude: ngIncludeDirective,
2200            ngInit: ngInitDirective,
2201            ngNonBindable: ngNonBindableDirective,
2202            ngPluralize: ngPluralizeDirective,
2203            ngRepeat: ngRepeatDirective,
2204            ngShow: ngShowDirective,
2205            ngStyle: ngStyleDirective,
2206            ngSwitch: ngSwitchDirective,
2207            ngSwitchWhen: ngSwitchWhenDirective,
2208            ngSwitchDefault: ngSwitchDefaultDirective,
2209            ngOptions: ngOptionsDirective,
2210            ngTransclude: ngTranscludeDirective,
2211            ngModel: ngModelDirective,
2212            ngList: ngListDirective,
2213            ngChange: ngChangeDirective,
2214            pattern: patternDirective,
2215            ngPattern: patternDirective,
2216            required: requiredDirective,
2217            ngRequired: requiredDirective,
2218            minlength: minlengthDirective,
2219            ngMinlength: minlengthDirective,
2220            maxlength: maxlengthDirective,
2221            ngMaxlength: maxlengthDirective,
2222            ngValue: ngValueDirective,
2223            ngModelOptions: ngModelOptionsDirective
2224        }).
2225        directive({
2226          ngInclude: ngIncludeFillContentDirective
2227        }).
2228        directive(ngAttributeAliasDirectives).
2229        directive(ngEventDirectives);
2230      $provide.provider({
2231        $anchorScroll: $AnchorScrollProvider,
2232        $animate: $AnimateProvider,
2233        $browser: $BrowserProvider,

2234        $cacheFactory: $CacheFactoryProvider,
2235        $controller: $ControllerProvider,
2236        $document: $DocumentProvider,
2237        $exceptionHandler: $ExceptionHandlerProvider,
2238        $filter: $FilterProvider,
2239        $interpolate: $InterpolateProvider,
2240        $interval: $IntervalProvider,
2241        $http: $HttpProvider,
2242        $httpBackend: $HttpBackendProvider,
2243        $location: $LocationProvider,
2244        $log: $LogProvider,
2245        $parse: $ParseProvider,
2246        $rootScope: $RootScopeProvider,
2247        $q: $QProvider,
2248        $$q: $$QProvider,
2249        $sce: $SceProvider,
2250        $sceDelegate: $SceDelegateProvider,
2251        $sniffer: $SnifferProvider,
2252        $templateCache: $TemplateCacheProvider,
2253        $templateRequest: $TemplateRequestProvider,
2254        $$testability: $$TestabilityProvider,
2255        $timeout: $TimeoutProvider,
2256        $window: $WindowProvider,
2257        $$rAF: $$RAFProvider,
2258        $$asyncCallback: $$AsyncCallbackProvider,
2259        $$jqLite: $$jqLiteProvider
2260      });
2261    }
2262  ]);
2263}
2264
2265/* global JQLitePrototype: true,
2266  addEventListenerFn: true,
2267  removeEventListenerFn: true,
2268  BOOLEAN_ATTR: true,
2269  ALIASED_ATTR: true,
2270*/
2271
2272//////////////////////////////////
2273//JQLite
2274//////////////////////////////////
2275
2276/**
2277 * @ngdoc function
2278 * @name angular.element
2279 * @module ng
2280 * @kind function
2281 *
2282 * @description
2283 * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
2284 *
2285 * If jQuery is available, `angular.element` is an alias for the
2286 * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
2287 * delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."
2288 *
2289 * <div class="alert alert-success">jqLite is a tiny, API-compatible subset of jQuery that allows
2290 * Angular to manipulate the DOM in a cross-browser compatible way. **jqLite** implements only the most
2291 * commonly needed functionality with the goal of having a very small footprint.</div>
2292 *
2293 * To use jQuery, simply load it before `DOMContentLoaded` event fired.
2294 *
2295 * <div class="alert">**Note:** all element references in Angular are always wrapped with jQuery or
2296 * jqLite; they are never raw DOM references.</div>
2297 *
2298 * ## Angular's jqLite
2299 * jqLite provides only the following jQuery methods:
2300 *
2301 * - [`addClass()`](http://api.jquery.com/addClass/)
2302 * - [`after()`](http://api.jquery.com/after/)
2303 * - [`append()`](http://api.jquery.com/append/)
2304 * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
2305 * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
2306 * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
2307 * - [`clone()`](http://api.jquery.com/clone/)
2308 * - [`contents()`](http://api.jquery.com/contents/)
2309 * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`
2310 * - [`data()`](http://api.jquery.com/data/)
2311 * - [`detach()`](http://api.jquery.com/detach/)
2312 * - [`empty()`](http://api.jquery.com/empty/)
2313 * - [`eq()`](http://api.jquery.com/eq/)
2314 * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
2315 * - [`hasClass()`](http://api.jquery.com/hasClass/)
2316 * - [`html()`](http://api.jquery.com/html/)
2317 * - [`next()`](http://api.jquery.com/next/) - Does not support selectors
2318 * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
2319 * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces or selectors
2320 * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
2321 * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
2322 * - [`prepend()`](http://api.jquery.com/prepend/)
2323 * - [`prop()`](http://api.jquery.com/prop/)
2324 * - [`ready()`](http://api.jquery.com/ready/)
2325 * - [`remove()`](http://api.jquery.com/remove/)
2326 * - [`removeAttr()`](http://api.jquery.com/removeAttr/)
2327 * - [`removeClass()`](http://api.jquery.com/removeClass/)
2328 * - [`removeData()`](http://api.jquery.com/removeData/)
2329 * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
2330 * - [`text()`](http://api.jquery.com/text/)
2331 * - [`toggleClass()`](http://api.jquery.com/toggleClass/)
2332 * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
2333 * - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces
2334 * - [`val()`](http://api.jquery.com/val/)
2335 * - [`wrap()`](http://api.jquery.com/wrap/)
2336 *
2337 * ## jQuery/jqLite Extras
2338 * Angular also provides the following additional methods and events to both jQuery and jqLite:
2339 *
2340 * ### Events
2341 * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction a

2341pis and fires this event
2342 *    on all DOM nodes being removed.  This can be used to clean up any 3rd party bindings to the DOM
2343 *    element before it is removed.
2344 *
2345 * ### Methods
2346 * - `controller(name)` - retrieves the controller of the current element or its parent. By default
2347 *   retrieves controller associated with the `ngController` directive. If `name` is provided as
2348 *   camelCase directive name, then the controller for this directive will be retrieved (e.g.
2349 *   `'ngModel'`).
2350 * - `injector()` - retrieves the injector of the current element or its parent.
2351 * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
2352 *   element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
2353 *   be enabled.
2354 * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
2355 *   current element. This getter should be used only on elements that contain a directive which starts a new isolate
2356 *   scope. Calling `scope()` on this element always returns the original non-isolate scope.
2357 *   Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
2358 * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
2359 *   parent element is reached.
2360 *
2361 * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
2362 * @returns {Object} jQuery object.
2363 */
2364
2365JQLite.expando = 'ng339';
2366
2367var jqCache = JQLite.cache = {},
2368    jqId = 1,
2369    addEventListenerFn = function(element, type, fn) {
2370      element.addEventListener(type, fn, false);
2371    },
2372    removeEventListenerFn = function(element, type, fn) {
2373      element.removeEventListener(type, fn, false);
2374    };
2375
2376/*
2377 * !!! This is an undocumented "private" function !!!
2378 */
2379JQLite._data = function(node) {
2380  //jQuery always returns an object on cache miss
2381  return this.cache[node[this.expando]] || {};
2382};
2383
2384function jqNextId() { return ++jqId; }
2385
2386
2387var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
2388var MOZ_HACK_REGEXP = /^moz([A-Z])/;
2389var MOUSE_EVENT_MAP= { mouseleave: "mouseout", mouseenter: "mouseover"};
2390var jqLiteMinErr = minErr('jqLite');
2391
2392/**
2393 * Converts snake_case to camelCase.
2394 * Also there is special case for Moz prefix starting with upper case letter.
2395 * @param name Name to normalize
2396 */
2397function camelCase(name) {
2398  return name.
2399    replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
2400      return offset ? letter.toUpperCase() : letter;
2401    }).
2402    replace(MOZ_HACK_REGEXP, 'Moz$1');
2403}
2404
2405var SINGLE_TAG_REGEXP = /^<(\w+)\s*\/?>(?:<\/\1>|)$/;
2406var HTML_REGEXP = /<|&#?\w+;/;
2407var TAG_NAME_REGEXP = /<([\w:]+)/;
2408var XHTML_TAG_REGEXP = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi;
2409
2410var wrapMap = {
2411  'option': [1, '<select multiple="multiple">', '</select>'],
2412
2413  'thead': [1, '<table>', '</table>'],
2414  'col': [2, '<table><colgroup>', '</colgroup></table>'],
2415  'tr': [2, '<table><tbody>', '</tbody></table>'],
2416  'td': [3, '<table><tbody><tr>', '</tr></tbody></table>'],
2417  '_default': [0, "", ""]
2418};
2419
2420wrapMap.optgroup = wrapMap.option;
2421wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
2422wrapMap.th = wrapMap.td;
2423
2424
2425function jqLiteIsTextNode(html) {
2426  return !HTML_REGEXP.test(html);
2427}
2428
2429function jqLiteAcceptsData(node) {
2430  // The window object can accept data but has no nodeType
2431  // Otherwise we are only interested in elements (1) and documents (9)
2432  var nodeType = node.nodeType;
2433  return nodeType === NODE_TYPE_ELEMENT || !nodeType || nodeType === NODE_TYPE_DOCUMENT;
2434}
2435
2436function jqLiteBuildFragment(html, context) {
2437  var tmp, tag, wrap,
2438      fragment = context.createDocumentFragment(),
2439      nodes = [], i;
2440
2441  if (jqLiteIsTextNode(html)) {
2442    // Convert non-html into a text node
2443    nodes.push(context.createTextNode(html));
2444  } else {
2445    // Convert html into DOM nodes
2446    tmp = tmp || fragment.appendChild(context.createElement("div"));
2447    tag = (TAG_NAME_REGEXP.exec(html) || ["", ""])[1].toLowerCase();
2448    wrap = wrapMap[tag] || wrapMap._default;
2449    tmp.innerHTML = wrap[1] + html.replace(XHTML_TAG_REGEXP, "<$1></$2>") + wrap[2];
2450
2451    // Descend through wrappers to the right content
2452    i = wrap[0];
2453    while (i--) {
2454      tmp = tmp.lastChild;
2455    }
2456
2457    nodes = concat(nodes, tmp.childNodes);
2458
2459    tmp = fragment.firstChild;
2460    tmp.textContent = "";
2461  }
2462
2463  // Remove wrapper from fragment
2464  fragment.textContent = "";
2465  fragment.innerHTML = ""; // Clear inner HTML
2466  forEach(nodes, function(node) {
2467    fragment.appendChild(node);
2468  });
2469
2470  return fragment;
2471}
2472
2473function jqLiteParseHTML(html, context) {
2474  context = context || document;
2475  var parsed;
2476
2477  if ((parsed = SINGLE_TAG_REGEXP.exec(html))) {
2478    return [context.createElement(parsed[1])];
2479  }
2480
2481  if ((parsed = jqLiteBuildFragment(html, context))) {
2482    return parsed.childNodes;
2483  }
2484
2485  return [];
2486}
2487

2488/////////////////////////////////////////////
2489function JQLite(element) {
2490  if (element instanceof JQLite) {
2491    return element;
2492  }
2493
2494  var argIsString;
2495
2496  if (isString(element)) {
2497    element = trim(element);
2498    argIsString = true;
2499  }
2500  if (!(this instanceof JQLite)) {
2501    if (argIsString && element.charAt(0) != '<') {
2502      throw jqLiteMinErr('nosel', 'Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element');
2503    }
2504    return new JQLite(element);
2505  }
2506
2507  if (argIsString) {
2508    jqLiteAddNodes(this, jqLiteParseHTML(element));
2509  } else {
2510    jqLiteAddNodes(this, element);
2511  }
2512}
2513
2514function jqLiteClone(element) {
2515  return element.cloneNode(true);
2516}
2517
2518function jqLiteDealoc(element, onlyDescendants) {
2519  if (!onlyDescendants) jqLiteRemoveData(element);
2520
2521  if (element.querySelectorAll) {
2522    var descendants = element.querySelectorAll('*');
2523    for (var i = 0, l = descendants.length; i < l; i++) {
2524      jqLiteRemoveData(descendants[i]);
2525    }
2526  }
2527}
2528
2529function jqLiteOff(element, type, fn, unsupported) {

2530  if (isDefined(unsupported)) throw jqLiteMinErr('offargs', 'jqLite#off() does not support the `selector` argument');
2531
2532  var expandoStore = jqLiteExpandoStore(element);
2533  var events = expandoStore && expandoStore.events;
2534  var handle = expandoStore && expandoStore.handle;
2535
2536  if (!handle) return; //no listeners registered
2537
2538  if (!type) {
2539    for (type in events) {
2540      if (type !== '$destroy') {
2541        removeEventListenerFn(element, type, handle);
2542      }
2543      delete events[type];
2544    }
2545  } else {
2546    forEach(type.split(' '), function(type) {
2547      if (isDefined(fn)) {
2548        var listenerFns = events[type];
2549        arrayRemove(listenerFns || [], fn);
2550        if (listenerFns && listenerFns.length > 0) {
2551          return;
2552        }
2553      }
2554
2555      removeEventListenerFn(element, type, handle);
2556      delete events[type];
2557    });
2558  }
2559}
2560
2561function jqLiteRemoveData(element, name) {
2562  var expandoId = element.ng339;
2563  var expandoStore = expandoId && jqCache[expandoId];
2564
2565  if (expandoStore) {
2566    if (name) {
2567      delete expandoStore.data[name];
2568      return;
2569    }
2570
2571    if (expandoStore.handle) {
2572      if (expandoStore.events.$destroy) {
2573        expandoStore.handle({}, '$destroy');
2574      }
2575      jqLiteOff(element);
2576    }
2577    delete jqCache[expandoId];
2578    element.ng339 = undefined; // don't delete DOM expandos. IE and Chrome don't like it
2579  }
2580}
2581
2582
2583function jqLiteExpandoStore(element, createIfNecessary) {
2584  var expandoId = element.ng339,
2585      expandoStore = expandoId && jqCache[expandoId];
2586
2587  if (createIfNecessary && !expandoStore) {
2588    element.ng339 = expandoId = jqNextId();
2589    expandoStore = jqCache[expandoId] = {events: {}, data: {}, handle: undefined};
2590  }
2591
2592  return expandoStore;
2593}
2594
2595
2596function jqLiteData(element, key, value) {
2597  if (jqLiteAcceptsData(element)) {
2598
2599    var isSimpleSetter = isDefined(value);
2600    var isSimpleGetter = !isSimpleSetter && key && !isObject(key);
2601    var massGetter = !key;
2602    var expandoStore = jqLiteExpandoStore(element, !isSimpleGetter);
2603    var data = expandoStore && expandoStore.data;
2604
2605    if (isSimpleSetter) { // data('key', value)
2606      data[key] = value;
2607    } else {
2608      if (massGetter) {  // data()
2609        return data;
2610      } else {
2611        if (isSimpleGetter) { // data('key')
2612          // don't force creation of expandoStore if it doesn't exist yet
2613          return data && data[key];
2614        } else { // mass-setter: data({key1: val1, key2: val2})
2615          extend(data, key);
2616        }
2617      }
2618    }
2619  }
2620}
2621
2622function jqLiteHasClass(element, selector) {
2623  if (!element.getAttribute) return false;
2624  return ((" " + (element.getAttribute('class') || '') + " ").replace(/[\n\t]/g, " ").
2625      indexOf(" " + selector + " ") > -1);
2626}
2627
2628function jqLiteRemoveClass(element, cssClasses) {
2629  if (cssClasses && element.setAttribute) {
2630    forEach(cssClasses.split(' '), function(cssClass) {
2631      element.setAttribute('class', trim(
2632          (" " + (element.getAttribute('class') || '') + " ")
2633          .replace(/[\n\t]/g, " ")
2634          .replace(" " + trim(cssClass) + " ", " "))
2635      );
2636    });
2637  }
2638}
2639
2640function jqLiteAddClass(element, cssClasses) {
2641  if (cssClasses && element.setAttribute) {
2642    var existingClasses = (' ' + (element.getAttribute('class') || '') + ' ')
2643                            .replace(/[\n\t]/g, " ");
2644
2645    forEach(cssClasses.split(' '), function(cssClass) {
2646      cssClass = trim(cssClass);
2647      if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) {
2648        existingClasses += cssClass + ' ';
2649      }
2650    });
2651
2652    element.setAttribute('class', trim(existingClasses));
2653  }
2654}
2655
2656
2657function jqLiteAddNodes(root, elements) {
2658  // THIS CODE IS VERY HOT. Don't make changes without benchmarking.
2659
2660  if (elements) {
2661
2662    // if a Node (the most common case)
2663    if (elements.nodeType) {
2664      root[root.length++] = elements;
2665    } else {
2666      var length = elements.length;
2667
2668      // if an Array or NodeList and not a Window
2669      if (typeof length === 'number' && elements.window !== elements) {
2670        if (length) {
2671          for (var i = 0; i < length; i++) {
2672            root[root.length++] = elements[i];
2673          }
2674        }
2675      } else {
2676        root[root.length++] = elements;
2677      }
2678    }
2679  }
2680}
2681
2682
2683function jqLiteController(element, name) {
2684  return jqLiteInheritedData(element, '$' + (name || 'ngController') + 'Controller');
2685}
2686
2687function jqLiteInheritedData(element, name, value) {
2688  // if element is the document object work with the html element instead
2689  // this makes $(document).scope() possible
2690  if (element.nodeType == NODE_TYPE_DOCUMENT) {
2691    element = element.documentElement;
2692  }
2693  var names = isArray(name) ? name : [name];
2694
2695  while (element) {
2696    for (var i = 0, ii = names.length; i < ii; i++) {
2697      if ((value = jqLite.data(element, names[i])) !== undefined) return value;
2698    }
2699
2700    // If dealing with a document fragment node with a host element, and no parent, use the host
2701    // element as the parent. This enables directives within a Shadow DOM or polyfilled Shadow DOM
2702    // to lookup parent controllers.
2703    element = element.parentNode || (element.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && element.host);
2704  }
2705}
2706
2707function jqLiteEmpty(element) {
2708  jqLiteDealoc(element, true);
2709  while (element.firstChild) {
2710    element.removeChild(element.firstChild);
2711  }
2712}
2713
2714function jqLiteRemove(element, keepData) {
2715  if (!keepData) jqLiteDealoc(element);
2716  var parent = element.parentNode;
2717  if (parent) parent.removeChild(element);
2718}
2719
2720
2721function jqLiteDocumentLoaded(action, win) {
2722  win = win || window;
2723  if (win.document.readyState === 'complete') {
2724    // Force the action to be run async for consistent behaviour
2725    // from the action's point of view
2726    // i.e. it will definitely not be in a $apply
2727    win.setTimeout(action);
2728  } else {
2729    // No need to unbind this handler as load is only ever called once
2730    jqLite(win).on('load', action);
2731  }
2732}
2733