/** * @license AngularJS v1.5.8 * (c) 2010-2016 Google, Inc. http://angularjs.org * License: MIT */(function(window) {'use strict'; /** * @description * * This object provides a utility for producing rich Error messages within * Angular. It can be called as follows: * * var exampleMinErr = minErr('example'); * throw exampleMinErr('one', 'This {0} is {1}', foo, bar); * * The above creates an instance of minErr in the example namespace. The * resulting error will have a namespaced error code of example.one.  The * resulting error will replace {0} with the value of foo, and {1} with the * value of bar. The object is not restricted in the number of arguments it can * take. * * If fewer arguments are specified than necessary for interpolation, the extra * interpolation markers will be preserved in the final string. * * Since data will be parsed statically during a build step, some restrictions * are applied with respect to how minErr instances are created and called. * Instances should have names of the form namespaceMinErr for a minErr created * using minErr('namespace') . Error codes, namespaces and template strings * should all be static strings, not variables or general expressions. * * @param {string} module The namespace to use for the new minErr instance. * @param {function} ErrorConstructor Custom error constructor to be instantiated when returning *   error from returned function, for cases when a particular type of error is useful. * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance */ function minErr(module, ErrorConstructor) {  ErrorConstructor = ErrorConstructor || Error;  return function() {    var SKIP_INDEXES = 2;     var templateArgs = arguments,      code = templateArgs[0],      message = '[' + (module ? module + ':' : '') + code + '] ',      template = templateArgs[1],      paramPrefix, i;     message += template.replace(/\{\d+\}/g, function(match) {      var index = +match.slice(1, -1),        shiftedIndex = index + SKIP_INDEXES;       if (shiftedIndex < templateArgs.length) {        return toDebugString(templateArgs[shiftedIndex]);      }       return match;    });     message += '\nhttp://errors.angularjs.org/1.5.8/' +      (module ? module + '/' : '') + code;     for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {      message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +        encodeURIComponent(toDebugString(templateArgs[i]));    }     return new ErrorConstructor(message);  };} /* We need to tell jshint what variables are being exported *//* global angular: true,  msie: true,  jqLite: true,  jQuery: true,  slice: true,  splice: true,  push: true,  toString: true,  ngMinErr: true,  angularModule: true,  uid: true,  REGEX_STRING_REGEXP: true,  VALIDITY_STATE_PROPERTY: true,   lowercase: true,  uppercase: true,  manualLowercase: true,  manualUppercase: true,  nodeName_: true,  isArrayLike: true,  forEach: true,  forEachSorted: true,  reverseParams: true,  nextUid: true,  setHashKey: true,  extend: true,  toInt: true,  inherit: true,  merge: true,  noop: true,  identity: true,  valueFn: true,  isUndefined: true,  isDefined: true,  isObject: true,  isBlankObject: true,  isString: true,  isNumber: true,  isDate: true,  isArray: true,  isFunction: true,  isRegExp: true,  isWindow: true,  isScope: true,  isFile: true,  isFormData: true,  isBlob: true,  isBoolean: true,  isPromiseLike: true,  trim: true,  escapeForRegexp: true,  isElement: true,  makeMap: true,  includes: true,  arrayRemove: true,  copy: true,  equals: true,  csp: true,  jq: true,  concat: true,  sliceArgs: true,  bind: true,  toJsonReplacer: true,  toJson: true,  fromJson: true,  convertTimezoneToLocal: true,  timezoneToOffset: true,  startingTag: true,  tryDecodeURIComponent: true,  parseKeyValue: true,  toKeyValue: true,  encodeUriSegment: true,  encodeUriQuery: true,  angularInit: true,  bootstrap: true,  getTestability: true,  snake_case: true,  bindJQuery: true,  assertArg: true,  assertArgFn: true,  assertNotHasOwnProperty: true,  getter: true,  getBlockNodes: true,  hasOwnProperty: true,  createMap: true,   NODE_TYPE_ELEMENT: true,  NODE_TYPE_ATTRIBUTE: true,  NODE_TYPE_TEXT: true,  NODE_TYPE_COMMENT: true,  NODE_TYPE_DOCUMENT: true,  NODE_TYPE_DOCUMENT_FRAGMENT: true,*/ //////////////////////////////////// /** * @ngdoc module * @name ng * @module ng * @installation * @description * * # ng (core module) * The ng module is loaded by default when an AngularJS application is started. The module itself * contains the essential components for an AngularJS application to function. The table below * lists a high level breakdown of each of the services/factories, filters, directives and testing * components available within this core module. * * <div doc-module-components="ng"></div> */ var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/; // The name of a form control's ValidityState property.// This is used so that it's possible for internal tests to create mock ValidityStates.var VALIDITY_STATE_PROPERTY = 'validity'; var hasOwnProperty = Object.prototype.hasOwnProperty; var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};  var manualLowercase = function(s) {  /* jshint bitwise: false */  return isString(s)      ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);})      : s;};var manualUppercase = function(s) {  /* jshint bitwise: false */  return isString(s)      ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})      : s;};  // String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods// with correct but slower alternatives. See https://github.com/angular/angular.js/issues/11387if ('i' !== 'I'.toLowerCase()) {  lowercase = manualLowercase;  uppercase = manualUppercase;}  var    msie,             // holds major version number for IE, or NaN if UA is not IE.    jqLite,           // delay binding since jQuery could be loaded after us.    jQuery,           // delay binding    slice             = [].slice,    splice            = [].splice,    push              = [].push,    toString          = Object.prototype.toString,    getPrototypeOf    = Object.getPrototypeOf,    ngMinErr          = minErr('ng'),     /** @name angular */    angular           = window.angular || (window.angular = {}),    angularModule,    uid               = 0; /** * documentMode is an IE-only property * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx */msie = window.document.documentMode;  /** * @private * @param {*} obj * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments, *                   String ...) */function isArrayLike(obj) {   // `null`, `undefined` and `window` are not array-like  if (obj == null || isWindow(obj)) return false;   // arrays, strings and jQuery/jqLite objects are array like  // * jqLite is either the jQuery or jqLite constructor function  // * we have to check the existence of jqLite first as this method is called  //   via the forEach method when constructing the jqLite object in the first place  if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;   // Support: iOS 8.2 (not reproducible in simulator)  // "length" in obj used to prevent JIT error (gh-11508)  var length = "length" in Object(obj) && obj.length;   // NodeList objects (with `item` method) and  // other objects with suitable length characteristics are array-like  return isNumber(length) &&    (length >= 0 && ((length - 1) in obj || obj instanceof Array) || typeof obj.item == 'function'); } /** * @ngdoc function * @name angular.forEach * @module ng * @kind function * * @description * Invokes the `iterator` function once for each item in `obj` collection, which can be either an * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value` * is the value of an object property or an array element, `key` is the object property key or * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional. * * It is worth noting that `.forEach` does not iterate over inherited properties because it filters * using the `hasOwnProperty` method. * * Unlike ES262's * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18), * providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just * return the value provided. *   ```js     var values = {name: 'misko', gender: 'male'};     var log = [];     angular.forEach(values, function(value, key) {       this.push(key + ': ' + value);     }, log);     expect(log).toEqual(['name: misko', 'gender: male']);   ``` * * @param {Object|Array} obj Object to iterate over. * @param {Function} iterator Iterator function. * @param {Object=} context Object to become context (`this`) for the iterator function. * @returns {Object|Array} Reference to `obj`. */ function forEach(obj, iterator, context) {  var key, length;  if (obj) {    if (isFunction(obj)) {      for (key in obj) {        // Need to check if hasOwnProperty exists,        // as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function        if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) {          iterator.call(context, obj[key], key, obj);        }      }    } else if (isArray(obj) || isArrayLike(obj)) {      var isPrimitive = typeof obj !== 'object';      for (key = 0, length = obj.length; key < length; key++) {        if (isPrimitive || key in obj) {          iterator.call(context, obj[key], key, obj);        }      }    } else if (obj.forEach && obj.forEach !== forEach) {        obj.forEach(iterator, context, obj);    } else if (isBlankObject(obj)) {      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty      for (key in obj) {        iterator.call(context, obj[key], key, obj);      }    } else if (typeof obj.hasOwnProperty === 'function') {      // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed      for (key in obj) {        if (obj.hasOwnProperty(key)) {          iterator.call(context, obj[key], key, obj);        }      }    } else {      // Slow path for objects which do not have a method `hasOwnProperty`      for (key in obj) {        if (hasOwnProperty.call(obj, key)) {          iterator.call(context, obj[key], key, obj);        }      }    }  }  return obj;} function forEachSorted(obj, iterator, context) {  var keys = Object.keys(obj).sort();  for (var i = 0; i < keys.length; i++) {    iterator.call(context, obj[keys[i]], keys[i]);  }  return keys;}  /** * when using forEach the params are value, key, but it is often useful to have key, value. * @param {function(string, *)} iteratorFn * @returns {function(*, string)} */function reverseParams(iteratorFn) {  return function(value, key) {iteratorFn(key, value);};} /** * A consistent way of creating unique IDs in angular. * * Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before * we hit number precision issues in JavaScript. * * Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M * * @returns {number} an unique alpha-numeric string */function nextUid() {  return ++uid;}  /** * Set or clear the hashkey for an object. * @param obj object * @param h the hashkey (!truthy to delete the hashkey) */function setHashKey(obj, h) {  if (h) {    obj.$$hashKey = h;  } else {    delete obj.$$hashKey;  }}  function baseExtend(dst, objs, deep) {  var h = dst.$$hashKey;   for (var i = 0, ii = objs.length; i < ii; ++i) {    var obj = objs[i];    if (!isObject(obj) && !isFunction(obj)) continue;    var keys = Object.keys(obj);    for (var j = 0, jj = keys.length; j < jj; j++) {      var key = keys[j];      var src = obj[key];       if (deep && isObject(src)) {        if (isDate(src)) {          dst[key] = new Date(src.valueOf());        } else if (isRegExp(src)) {          dst[key] = new RegExp(src);        } else if (src.nodeName) {          dst[key] = src.cloneNode(true);        } else if (isElement(src)) {          dst[key] = src.clone();        } else {          if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};          baseExtend(dst[key], [src], true);        }      } else {        dst[key] = src;      }    }  }   setHashKey(dst, h);  return dst;} /** * @ngdoc function * @name angular.extend * @module ng * @kind function * * @description * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s) * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so * by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`. * * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use * {@link angular.merge} for this. * * @param {Object} dst Destination object. * @param {...Object} src Source object(s). * @returns {Object} Reference to `dst`. */function extend(dst) {  return baseExtend(dst, slice.call(arguments, 1), false);}  /*** @ngdoc function* @name angular.merge* @module ng* @kind function** @description* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.** Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source* objects, performing a deep copy.** @param {Object} dst Destination object.* @param {...Object} src Source object(s).* @returns {Object} Reference to `dst`.*/function merge(dst) {  return baseExtend(dst, slice.call(arguments, 1), true);}   function toInt(str) {  return parseInt(str, 10);}  function inherit(parent, extra) {  return extend(Object.create(parent), extra);} /** * @ngdoc function * @name angular.noop * @module ng * @kind function * * @description * A function that performs no operations. This function can be useful when writing code in the * functional style.   ```js     function foo(callback) {       var result = calculateResult();       (callback || angular.noop)(result);     }

Lines 1–500 of 31768. Load more