/**
 * @license AngularJS v1.0.7
 * (c) 2010-2012 Google, Inc. http://angularjs.org
 * License: MIT
 */

(/**
 * @ngdoc interface
 * @name angular.Module
 * @description
 *
 * Interface for configuring angular {@link angular.module modules}.
 */

    function setupModuleLoader(window) {

    function ensure(obj, name, factory) {
        return obj[name] || (obj[name] = factory());
    }

    return ensure(ensure(window, 'angular', Object), 'module', function () {
        /** @type {Object.<string, angular.Module>} */
        var modules = {};

        /**
         * @ngdoc function
         * @name angular.module
         * @description
         *
         * The `angular.module` is a global place for creating and registering Angular modules. All
         * modules (angular core or 3rd party) that should be available to an application must be
         * registered using this mechanism.
         *
         *
         * # Module
         *
         * A module is a collocation of services, directives, filters, and configuration information. Module
         * is used to configure the {@link AUTO.$injector $injector}.
         *
         * <pre>
         * // 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(function($locationProvider) {
'use strict';
     *   // Configure existing providers
     *   $locationProvider.hashPrefix('!');
     * });
         * </pre>
         *
         * Then you can create an injector and load your modules like this:
         *
         * <pre>
         * var injector = angular.injector(['ng', 'MyModule'])
         * </pre>
         *
         * 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
         *        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 {module} new module with the {@link angular.Module} api.
         */
        return function module(name, requires, configFn) {
            if (requires && modules.hasOwnProperty(name)) {
                modules[name] = null;
            }
            return ensure(modules, name, function () {
                if (!requires) {
                    throw Error('No module: ' + name);
                }

                /** @type {!Array.<Array.<*>>} */
                var invokeQueue = [];

                /** @type {!Array.<Function>} */
                var runBlocks = [];

                var config = invokeLater('$injector', 'invoke');

                /** @type {angular.Module} */
                var moduleInstance = {
                    // Private state
                    _invokeQueue: invokeQueue,
                    _runBlocks: runBlocks,

                    /**
                     * @ngdoc property
                     * @name angular.Module#requires
                     * @propertyOf angular.Module
                     * @returns {Array.<string>} List of module names which must be loaded before this module.
                     * @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
                     * @propertyOf angular.Module
                     * @returns {string} Name of the module.
                     * @description
                     */
                    name: name,


                    /**
                     * @ngdoc method
                     * @name angular.Module#provider
                     * @methodOf angular.Module
                     * @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: invokeLater('$provide', 'provider'),

                    /**
                     * @ngdoc method
                     * @name angular.Module#factory
                     * @methodOf angular.Module
                     * @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: invokeLater('$provide', 'factory'),

                    /**
                     * @ngdoc method
                     * @name angular.Module#service
                     * @methodOf angular.Module
                     * @param {string} name service name
                     * @param {Function} constructor A constructor function that will be instantiated.
                     * @description
                     * See {@link AUTO.$provide#service $provide.service()}.
                     */
                    service: invokeLater('$provide', 'service'),

                    /**
                     * @ngdoc method
                     * @name angular.Module#value
                     * @methodOf angular.Module
                     * @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
                     * @methodOf angular.Module
                     * @param {string} name constant name
                     * @param {*} object Constant value.
                     * @description
                     * Because the constant 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#filter
                     * @methodOf angular.Module
                     * @param {string} name Filter name.
                     * @param {Function} filterFactory Factory function for creating new instance of filter.
                     * @description
                     * See {@link ng.$filterProvider#register $filterProvider.register()}.
                     */
                    filter: invokeLater('$filterProvider', 'register'),

                    /**
                     * @ngdoc method
                     * @name angular.Module#controller
                     * @methodOf angular.Module
                     * @param {string} name Controller name.
                     * @param {Function} constructor Controller constructor function.
                     * @description
                     * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
                     */
                    controller: invokeLater('$controllerProvider', 'register'),

                    /**
                     * @ngdoc method
                     * @name angular.Module#directive
                     * @methodOf angular.Module
                     * @param {string} name directive name
                     * @param {Function} directiveFactory Factory function for creating new instance of
                     * directives.
                     * @description
                     * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
                     */
                    directive: invokeLater('$compileProvider', 'directive'),

                    /**
                     * @ngdoc method
                     * @name angular.Module#config
                     * @methodOf angular.Module
                     * @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.
                     */
                    config: config,

                    /**
                     * @ngdoc method
                     * @name angular.Module#run
                     * @methodOf angular.Module
                     * @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) {
                    return function () {
                        invokeQueue[insertMethod || 'push']([provider, method, arguments]);
                        return moduleInstance;
                    }
                }
            });
        };
    });

})(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;