| /** |
| * @license AngularJS v1.5.6 |
| * (c) 2010-2016 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| |
| (function() {'use strict'; |
| function isFunction(value) {return typeof value === 'function';}; |
| |
| /* global: toDebugString: true */ |
| |
| function serializeObject(obj) { |
| var seen = []; |
| |
| return JSON.stringify(obj, function(key, val) { |
| val = toJsonReplacer(key, val); |
| if (isObject(val)) { |
| |
| if (seen.indexOf(val) >= 0) return '...'; |
| |
| seen.push(val); |
| } |
| return val; |
| }); |
| } |
| |
| function toDebugString(obj) { |
| if (typeof obj === 'function') { |
| return obj.toString().replace(/ \{[\s\S]*$/, ''); |
| } else if (isUndefined(obj)) { |
| return 'undefined'; |
| } else if (typeof obj !== 'string') { |
| return serializeObject(obj); |
| } |
| return obj; |
| } |
| |
| /** |
| * @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.6/' + |
| (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); |
| }; |
| } |
| |
| /** |
| * @ngdoc type |
| * @name angular.Module |
| * @module ng |
| * @description |
| * |
| * Interface for configuring angular {@link angular.module modules}. |
| */ |
| |
| function setupModuleLoader(window) { |
| |
| var $injectorMinErr = minErr('$injector'); |
| var ngMinErr = minErr('ng'); |
| |
| function ensure(obj, name, factory) { |
| return obj[name] || (obj[name] = factory()); |
| } |
| |
| var angular = ensure(window, 'angular', Object); |
| |
| // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap |
| angular.$$minErr = angular.$$minErr || minErr; |
| |
| return ensure(angular, 'module', function() { |
| /** @type {Object.<string, angular.Module>} */ |
| var modules = {}; |
| |
| /** |
| * @ngdoc function |
| * @name angular.module |
| * @module ng |
| * @description |
| * |
| * The `angular.module` is a global place for creating, registering and retrieving Angular |
| * modules. |
| * All modules (angular core or 3rd party) that should be available to an application must be |
| * registered using this mechanism. |
| * |
| * Passing one argument retrieves an existing {@link angular.Module}, |
| * whereas passing more than one argument creates a new {@link angular.Module} |
| * |
| * |
| * # Module |
| * |
| * A module is a collection of services, directives, controllers, filters, and configuration information. |
| * `angular.module` is used to configure the {@link auto.$injector $injector}. |
| * |
| * ```js |
| * // Create a new module |
| * var myModule = angular.module('myModule', []); |
| * |
| * // register a new service |
| * myModule.value('appName', 'MyCoolApp'); |
| * |
| * // configure existing services inside initialization blocks. |
| * myModule.config(['$locationProvider', function($locationProvider) { |
| * // Configure existing providers |
| * $locationProvider.hashPrefix('!'); |
| * }]); |
| * ``` |
| * |
| * Then you can create an injector and load your modules like this: |
| * |
| * ```js |
| * var injector = angular.injector(['ng', 'myModule']) |
| * ``` |
| * |
| * However it's more likely that you'll just use |
| * {@link ng.directive:ngApp ngApp} or |
| * {@link angular.bootstrap} to simplify this process for you. |
| * |
| * @param {!string} name The name of the module to create or retrieve. |
| * @param {!Array.<string>=} requires If specified then new module is being created. If |
| * unspecified then the module is being retrieved for further configuration. |
| * @param {Function=} configFn Optional configuration function for the module. Same as |
| * {@link angular.Module#config Module#config()}. |
| * @returns {angular.Module} new module with the {@link angular.Module} api. |
| */ |
| return function module(name, requires, configFn) { |
| var assertNotHasOwnProperty = function(name, context) { |
| if (name === 'hasOwnProperty') { |
| throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context); |
| } |
| }; |
| |
| assertNotHasOwnProperty(name, 'module'); |
| if (requires && modules.hasOwnProperty(name)) { |
| modules[name] = null; |
| } |
| return ensure(modules, name, function() { |
| if (!requires) { |
| throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " + |
| "the module name or forgot to load it. If registering a module ensure that you " + |
| "specify the dependencies as the second argument.", name); |
| } |
| |
| /** @type {!Array.<Array.<*>>} */ |
| var invokeQueue = []; |
| |
| /** @type {!Array.<Function>} */ |
| var configBlocks = []; |
| |
| /** @type {!Array.<Function>} */ |
| var runBlocks = []; |
| |
| var config = invokeLater('$injector', 'invoke', 'push', configBlocks); |
| |
| /** @type {angular.Module} */ |
| var moduleInstance = { |
| // Private state |
| _invokeQueue: invokeQueue, |
| _configBlocks: configBlocks, |
| _runBlocks: runBlocks, |
| |
| /** |
| * @ngdoc property |
| * @name angular.Module#requires |
| * @module ng |
| * |
| * @description |
| * Holds the list of modules which the injector will load before the current module is |
| * loaded. |
| */ |
| requires: requires, |
| |
| /** |
| * @ngdoc property |
| * @name angular.Module#name |
| * @module ng |
| * |
| * @description |
| * Name of the module. |
| */ |
| name: name, |
| |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#provider |
| * @module ng |
| * @param {string} name service name |
| * @param {Function} providerType Construction function for creating new instance of the |
| * service. |
| * @description |
| * See {@link auto.$provide#provider $provide.provider()}. |
| */ |
| provider: invokeLaterAndSetModuleName('$provide', 'provider'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#factory |
| * @module ng |
| * @param {string} name service name |
| * @param {Function} providerFunction Function for creating new instance of the service. |
| * @description |
| * See {@link auto.$provide#factory $provide.factory()}. |
| */ |
| factory: invokeLaterAndSetModuleName('$provide', 'factory'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#service |
| * @module ng |
| * @param {string} name service name |
| * @param {Function} constructor A constructor function that will be instantiated. |
| * @description |
| * See {@link auto.$provide#service $provide.service()}. |
| */ |
| service: invokeLaterAndSetModuleName('$provide', 'service'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#value |
| * @module ng |
| * @param {string} name service name |
| * @param {*} object Service instance object. |
| * @description |
| * See {@link auto.$provide#value $provide.value()}. |
| */ |
| value: invokeLater('$provide', 'value'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#constant |
| * @module ng |
| * @param {string} name constant name |
| * @param {*} object Constant value. |
| * @description |
| * Because the constants are fixed, they get applied before other provide methods. |
| * See {@link auto.$provide#constant $provide.constant()}. |
| */ |
| constant: invokeLater('$provide', 'constant', 'unshift'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#decorator |
| * @module ng |
| * @param {string} name The name of the service to decorate. |
| * @param {Function} decorFn This function will be invoked when the service needs to be |
| * instantiated and should return the decorated service instance. |
| * @description |
| * See {@link auto.$provide#decorator $provide.decorator()}. |
| */ |
| decorator: invokeLaterAndSetModuleName('$provide', 'decorator'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#animation |
| * @module ng |
| * @param {string} name animation name |
| * @param {Function} animationFactory Factory function for creating new instance of an |
| * animation. |
| * @description |
| * |
| * **NOTE**: animations take effect only if the **ngAnimate** module is loaded. |
| * |
| * |
| * Defines an animation hook that can be later used with |
| * {@link $animate $animate} service and directives that use this service. |
| * |
| * ```js |
| * module.animation('.animation-name', function($inject1, $inject2) { |
| * return { |
| * eventName : function(element, done) { |
| * //code to run the animation |
| * //once complete, then run done() |
| * return function cancellationFunction(element) { |
| * //code to cancel the animation |
| * } |
| * } |
| * } |
| * }) |
| * ``` |
| * |
| * See {@link ng.$animateProvider#register $animateProvider.register()} and |
| * {@link ngAnimate ngAnimate module} for more information. |
| */ |
| animation: invokeLaterAndSetModuleName('$animateProvider', 'register'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#filter |
| * @module ng |
| * @param {string} name Filter name - this must be a valid angular expression identifier |
| * @param {Function} filterFactory Factory function for creating new instance of filter. |
| * @description |
| * See {@link ng.$filterProvider#register $filterProvider.register()}. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`. |
| * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace |
| * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores |
| * (`myapp_subsection_filterx`). |
| * </div> |
| */ |
| filter: invokeLaterAndSetModuleName('$filterProvider', 'register'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#controller |
| * @module ng |
| * @param {string|Object} name Controller name, or an object map of controllers where the |
| * keys are the names and the values are the constructors. |
| * @param {Function} constructor Controller constructor function. |
| * @description |
| * See {@link ng.$controllerProvider#register $controllerProvider.register()}. |
| */ |
| controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#directive |
| * @module ng |
| * @param {string|Object} name Directive name, or an object map of directives where the |
| * keys are the names and the values are the factories. |
| * @param {Function} directiveFactory Factory function for creating new instance of |
| * directives. |
| * @description |
| * See {@link ng.$compileProvider#directive $compileProvider.directive()}. |
| */ |
| directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#component |
| * @module ng |
| * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp) |
| * @param {Object} options Component definition object (a simplified |
| * {@link ng.$compile#directive-definition-object directive definition object}) |
| * |
| * @description |
| * See {@link ng.$compileProvider#component $compileProvider.component()}. |
| */ |
| component: invokeLaterAndSetModuleName('$compileProvider', 'component'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#config |
| * @module ng |
| * @param {Function} configFn Execute this function on module load. Useful for service |
| * configuration. |
| * @description |
| * Use this method to register work which needs to be performed on module loading. |
| * For more about how to configure services, see |
| * {@link providers#provider-recipe Provider Recipe}. |
| */ |
| config: config, |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#run |
| * @module ng |
| * @param {Function} initializationFn Execute this function after injector creation. |
| * Useful for application initialization. |
| * @description |
| * Use this method to register work which should be performed when the injector is done |
| * loading all modules. |
| */ |
| run: function(block) { |
| runBlocks.push(block); |
| return this; |
| } |
| }; |
| |
| if (configFn) { |
| config(configFn); |
| } |
| |
| return moduleInstance; |
| |
| /** |
| * @param {string} provider |
| * @param {string} method |
| * @param {String=} insertMethod |
| * @returns {angular.Module} |
| */ |
| function invokeLater(provider, method, insertMethod, queue) { |
| if (!queue) queue = invokeQueue; |
| return function() { |
| queue[insertMethod || 'push']([provider, method, arguments]); |
| return moduleInstance; |
| }; |
| } |
| |
| /** |
| * @param {string} provider |
| * @param {string} method |
| * @returns {angular.Module} |
| */ |
| function invokeLaterAndSetModuleName(provider, method) { |
| return function(recipeName, factoryFunction) { |
| if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name; |
| invokeQueue.push([provider, method, arguments]); |
| return moduleInstance; |
| }; |
| } |
| }); |
| }; |
| }); |
| |
| } |
| |
| setupModuleLoader(window); |
| })(window); |
| |
| /** |
| * Closure compiler type information |
| * |
| * @typedef { { |
| * requires: !Array.<string>, |
| * invokeQueue: !Array.<Array.<*>>, |
| * |
| * service: function(string, Function):angular.Module, |
| * factory: function(string, Function):angular.Module, |
| * value: function(string, *):angular.Module, |
| * |
| * filter: function(string, Function):angular.Module, |
| * |
| * init: function(Function):angular.Module |
| * } } |
| */ |
| angular.Module; |
| |
