/**

* @license AngularJS v1.5.3
* (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.3/' +
    (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} The name of the service to decorate.
         * @param {Function} 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;