handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent];       forEach(eventFnsCopy, function(fn) {        if (!dummyEvent.isImmediatePropagationStopped()) {          fn.apply(element, handlerArgs);        }      });    }  }}, function(fn, name) {  /**   * chaining functions   */  JQLite.prototype[name] = function(arg1, arg2, arg3) {    var value;     for (var i = 0, ii = this.length; i < ii; i++) {      if (isUndefined(value)) {        value = fn(this[i], arg1, arg2, arg3);        if (isDefined(value)) {          // any function which returns a value needs to be wrapped          value = jqLite(value);        }      } else {        jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));      }    }    return isDefined(value) ? value : this;  };}); // bind legacy bind/unbind to on/offJQLite.prototype.bind = JQLite.prototype.on;JQLite.prototype.unbind = JQLite.prototype.off;  // Provider for private $$jqLite service/** @this */function $$jqLiteProvider() {  this.$get = function $$jqLite() {    return extend(JQLite, {      hasClass: function(node, classes) {        if (node.attr) node = node[0];        return jqLiteHasClass(node, classes);      },      addClass: function(node, classes) {        if (node.attr) node = node[0];        return jqLiteAddClass(node, classes);      },      removeClass: function(node, classes) {        if (node.attr) node = node[0];        return jqLiteRemoveClass(node, classes);      }    });  };} /** * Computes a hash of an 'obj'. * Hash of a: *  string is string *  number is number as string *  object is either result of calling $$hashKey function on the object or uniquely generated id, *         that is also assigned to the $$hashKey property of the object. * * @param obj * @returns {string} hash string such that the same input will have the same hash string. *         The resulting string key is in 'type:hashKey' format. */function hashKey(obj, nextUidFn) {  var key = obj && obj.$$hashKey;   if (key) {    if (typeof key === 'function') {      key = obj.$$hashKey();    }    return key;  }   var objType = typeof obj;  if (objType === 'function' || (objType === 'object' && obj !== null)) {    key = obj.$$hashKey = objType + ':' + (nextUidFn || nextUid)();  } else {    key = objType + ':' + obj;  }   return key;} // A minimal ES2015 Map implementation.// Should be bug/feature equivalent to the native implementations of supported browsers// (for the features required in Angular).// See https://kangax.github.io/compat-table/es6/#test-Mapvar nanKey = Object.create(null);function NgMapShim() {  this._keys = [];  this._values = [];  this._lastKey = NaN;  this._lastIndex = -1;}NgMapShim.prototype = {  _idx: function(key) {    if (key === this._lastKey) {      return this._lastIndex;    }    this._lastKey = key;    this._lastIndex = this._keys.indexOf(key);    return this._lastIndex;  },  _transformKey: function(key) {    return isNumberNaN(key) ? nanKey : key;  },  get: function(key) {    key = this._transformKey(key);    var idx = this._idx(key);    if (idx !== -1) {      return this._values[idx];    }  },  set: function(key, value) {    key = this._transformKey(key);    var idx = this._idx(key);    if (idx === -1) {      idx = this._lastIndex = this._keys.length;    }    this._keys[idx] = key;    this._values[idx] = value;     // Support: IE11    // Do not `return this` to simulate the partial IE11 implementation  },  delete: function(key) {    key = this._transformKey(key);    var idx = this._idx(key);    if (idx === -1) {      return false;    }    this._keys.splice(idx, 1);    this._values.splice(idx, 1);    this._lastKey = NaN;    this._lastIndex = -1;    return true;  }}; // For now, always use `NgMapShim`, even if `window.Map` is available. Some native implementations// are still buggy (often in subtle ways) and can cause hard-to-debug failures. When native `Map`// implementations get more stable, we can reconsider switching to `window.Map` (when available).var NgMap = NgMapShim; var $$MapProvider = [/** @this */function() {  this.$get = [function() {    return NgMap;  }];}]; /** * @ngdoc function * @module ng * @name angular.injector * @kind function * * @description * Creates an injector object that can be used for retrieving services as well as for * dependency injection (see {@link guide/di dependency injection}). * * @param {Array.<string|Function>} modules A list of module functions or their aliases. See *     {@link angular.module}. The `ng` module must be explicitly added. * @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which *     disallows argument name annotation inference. * @returns {injector} Injector object. See {@link auto.$injector $injector}. * * @example * Typical usage * ```js *   // create an injector *   var $injector = angular.injector(['ng']); * *   // use the injector to kick off your application *   // use the type inference to auto inject arguments, or use implicit injection *   $injector.invoke(function($rootScope, $compile, $document) { *     $compile($document)($rootScope); *     $rootScope.$digest(); *   }); * ``` * * Sometimes you want to get access to the injector of a currently running Angular app * from outside Angular. Perhaps, you want to inject and compile some markup after the * application has been bootstrapped. You can do this using the extra `injector()` added * to JQuery/jqLite elements. See {@link angular.element}. * * *This is fairly rare but could be the case if a third party library is injecting the * markup.* * * In the following example a new block of HTML containing a `ng-controller` * directive is added to the end of the document body by JQuery. We then compile and link * it into the current AngularJS scope. * * ```js * var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>'); * $(document.body).append($div); * * angular.element(document).injector().invoke(function($compile) { *   var scope = angular.element($div).scope(); *   $compile($div)(scope); * }); * ``` */  /** * @ngdoc module * @name auto * @installation * @description * * Implicit module which gets automatically added to each {@link auto.$injector $injector}. */ var ARROW_ARG = /^([^(]+?)=>/;var FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;var FN_ARG_SPLIT = /,/;var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;var $injectorMinErr = minErr('$injector'); function stringifyFn(fn) {  return Function.prototype.toString.call(fn);} function extractArgs(fn) {  var fnText = stringifyFn(fn).replace(STRIP_COMMENTS, ''),      args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);  return args;} function anonFn(fn) {  // For anonymous functions, showing at the very least the function signature can help in  // debugging.  var args = extractArgs(fn);  if (args) {    return 'function(' + (args[1] || '').replace(/[\s\r\n]+/, ' ') + ')';  }  return 'fn';} function annotate(fn, strictDi, name) {  var $inject,      argDecl,      last;   if (typeof fn === 'function') {    if (!($inject = fn.$inject)) {      $inject = [];      if (fn.length) {        if (strictDi) {          if (!isString(name) || !name) {            name = fn.name || anonFn(fn);          }          throw $injectorMinErr('strictdi',            '{0} is not using explicit annotation and cannot be invoked in strict mode', name);        }        argDecl = extractArgs(fn);        forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg) {          arg.replace(FN_ARG, function(all, underscore, name) {            $inject.push(name);          });        });      }      fn.$inject = $inject;    }  } else if (isArray(fn)) {    last = fn.length - 1;    assertArgFn(fn[last], 'fn');    $inject = fn.slice(0, last);  } else {    assertArgFn(fn, 'fn', true);  }  return $inject;} /////////////////////////////////////// /** * @ngdoc service * @name $injector * * @description * * `$injector` is used to retrieve object instances as defined by * {@link auto.$provide provider}, instantiate types, invoke methods, * and load modules. * * The following always holds true: * * ```js *   var $injector = angular.injector(); *   expect($injector.get('$injector')).toBe($injector); *   expect($injector.invoke(function($injector) { *     return $injector; *   })).toBe($injector); * ``` * * ## Injection Function Annotation * * JavaScript does not have annotations, and annotations are needed for dependency injection. The * following are all valid ways of annotating function with injection arguments and are equivalent. * * ```js *   // inferred (only works if code not minified/obfuscated) *   $injector.invoke(function(serviceA){}); * *   // annotated *   function explicit(serviceA) {}; *   explicit.$inject = ['serviceA']; *   $injector.invoke(explicit); * *   // inline *   $injector.invoke(['serviceA', function(serviceA){}]); * ``` * * ### Inference * * In JavaScript calling `toString()` on a function returns the function definition. The definition * can then be parsed and the function arguments can be extracted. This method of discovering * annotations is disallowed when the injector is in strict mode. * *NOTE:* This does not work with minification, and obfuscation tools since these tools change the * argument names. * * ### `$inject` Annotation * By adding an `$inject` property onto a function the injection parameters can be specified. * * ### Inline * As an array of injection names, where the last item in the array is the function to call. */ /** * @ngdoc property * @name $injector#modules * @type {Object} * @description * A hash containing all the modules that have been loaded into the * $injector. * * You can use this property to find out information about a module via the * {@link angular.Module#info `myModule.info(...)`} method. * * For example: * * ``` * var info = $injector.modules['ngAnimate'].info(); * ``` * * **Do not use this property to attempt to modify the modules after the application * has been bootstrapped.** */  /** * @ngdoc method * @name $injector#get * * @description * Return an instance of the service. * * @param {string} name The name of the instance to retrieve. * @param {string=} caller An optional string to provide the origin of the function call for error messages. * @return {*} The instance. */ /** * @ngdoc method * @name $injector#invoke * * @description * Invoke the method and supply the method arguments from the `$injector`. * * @param {Function|Array.<string|Function>} fn The injectable function to invoke. Function parameters are *   injected according to the {@link guide/di $inject Annotation} rules. * @param {Object=} self The `this` for the invoked method. * @param {Object=} locals Optional object. If preset then any argument names are read from this *                         object first, before the `$injector` is consulted. * @returns {*} the value returned by the invoked `fn` function. */ /** * @ngdoc method * @name $injector#has * * @description * Allows the user to query if the particular service exists. * * @param {string} name Name of the service to query. * @returns {boolean} `true` if injector has given service. */ /** * @ngdoc method * @name $injector#instantiate * @description * Create a new instance of JS type. The method takes a constructor function, invokes the new * operator, and supplies all of the arguments to the constructor function as specified by the * constructor annotation. * * @param {Function} Type Annotated constructor function. * @param {Object=} locals Optional object. If preset then any argument names are read from this * object first, before the `$injector` is consulted. * @returns {Object} new instance of `Type`. */ /** * @ngdoc method * @name $injector#annotate * * @description * Returns an array of service names which the function is requesting for injection. This API is * used by the injector to determine which services need to be injected into the function when the * function is invoked. There are three ways in which the function can be annotated with the needed * dependencies. * * #### Argument names * * The simplest form is to extract the dependencies from the arguments of the function. This is done * by converting the function into a string using `toString()` method and extracting the argument * names. * ```js *   // Given *   function MyController($scope, $route) { *     // ... *   } * *   // Then *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']); * ``` * * You can disallow this method by using strict injection mode. * * This method does not work with code minification / obfuscation. For this reason the following * annotation strategies are supported. * * #### The `$inject` property * * If a function has an `$inject` property and its value is an array of strings, then the strings * represent names of services to be injected into the function. * ```js *   // Given *   var MyController = function(obfuscatedScope, obfuscatedRoute) { *     // ... *   } *   // Define function dependencies *   MyController['$inject'] = ['$scope', '$route']; * *   // Then *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']); * ``` * * #### The array notation * * It is often desirable to inline Injected functions and that's when setting the `$inject` property * is very inconvenient. In these situations using the array notation to specify the dependencies in * a way that survives minification is a better choice: * * ```js *   // We wish to write this (not minification / obfuscation safe) *   injector.invoke(function($compile, $rootScope) { *     // ... *   }); * *   // We are forced to write break inlining *   var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) { *     // ... *   }; *   tmpFn.$inject = ['$compile', '$rootScope']; *   injector.invoke(tmpFn); * *   // To better support inline function the inline annotation is supported *   injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) { *     // ... *   }]); * *   // Therefore *   expect(injector.annotate( *      ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}]) *    ).toEqual(['$compile', '$rootScope']); * ``` * * @param {Function|Array.<string|Function>} fn Function for which dependent service names need to * be retrieved as described above. * * @param {boolean=} [strictDi=false] Disallow argument name annotation inference. * * @returns {Array.<string>} The names of the services which the function requires. *//** * @ngdoc method * @name $injector#loadNewModules * * @description * * **This is a dangerous API, which you use at your own risk!**

Lines 4001–4500 of 34255. Previous lines Load more