@angular-wave/angular.ts 0.0.61 → 0.0.63

package/src/loader.js

@@ -1,29 +1,15 @@
 import {
   minErr,
-  extend,
   forEach,
   getNgAttribute,
   isFunction,
   isObject,
   ngAttrPrefixes,
   isDefined,
-  isDate,
-  isElement,
-  isNumber,
-  isString,
-  isUndefined,
-  merge,
-  bind,
-  fromJson,
-  toJson,
-  identity,
-  equals,
   assertNotHasOwnProperty,
-  isBoolean,
-  isValidObjectMaxDepth,
-  minErrConfig,
+  errorHandlingConfig,
 } from "./shared/utils";
-import { JQLite, startingTag } from "./shared/jqlite/jqlite";
+import { JQLite } from "./shared/jqlite/jqlite";
 import { createInjector } from "./injector";
 import { CACHE } from "./core/cache/cache";
 
@@ -34,14 +20,10 @@ export const VERSION = "[VI]{version}[/VI]";
 
 const ngMinErr = minErr("ng");
 
-/** @type {Object.<string, import('./types').Module>} */
-const moduleCache = {};
-
 /**
  * Configuration option for AngularTS bootstrap process.
  *
  * @typedef {Object} AngularBootstrapConfig
- * @property {boolean} debugInfoEnabled - Indicates whether debug information should be enabled. Setting this to `false` can improve performance but will disable some debugging features.
  * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
  */
 
@@ -58,162 +40,107 @@ export class Angular {
     /** @type {string} */
     this.version = VERSION;
 
-    // Utility methods kept for backwards purposes
-    /** @type {bind} */
-    this.bind = bind;
-
-    /** @type {equals} */
-    this.equals = equals;
-
     /** @type {typeof import('./shared/jqlite/jqlite').JQLite} */
     this.element = JQLite;
 
-    /** @type {extend} */
-    this.extend = extend;
-
-    /** @type {forEach} */
-    this.forEach = forEach;
-
-    /** @type {fromJson} */
-    this.fromJson = fromJson;
-
-    /** @type {toJson} */
-    this.toJson = toJson;
-
-    /** @type {identity} */
-    this.identity = identity;
-
-    /** @type {isDate} */
-    this.isDate = isDate;
-
-    /** @type {isDefined} */
-    this.isDefined = isDefined;
-
-    /** @type {isElement} */
-    this.isElement = isElement;
-
-    /** @type {isFunction} */
-    this.isFunction = isFunction;
-
-    /** @type {isNumber} */
-    this.isNumber = isNumber;
-
-    /** @type {isObject} */
-    this.isObject = isObject;
-
-    /** @type {isString} */
-    this.isString = isString;
-
-    /** @type {isUndefined} */
-    this.isUndefined = isUndefined;
-
-    /** @type {merge} */
-    this.merge = merge;
-
-    /** @type {errorHandlingConfig} */
-    this.errorHandlingConfig = errorHandlingConfig;
+    /** @type {!Array<string|any>} */
+    this.bootsrappedModules = [];
 
     /** @type {Function} */
     this.doBootstrap;
   }
 
   /**
- * @module angular
- * @function bootstrap
+   * Configure several aspects of error handling if used as a setter or return the
+   * current configuration if used as a getter.
+   *
+   * Omitted or undefined options will leave the corresponding configuration values unchanged.
+   *
+   * @param {import('./shared/utils').ErrorHandlingConfig} [config]
+   * @returns {import('./shared/utils').ErrorHandlingConfig}
+   */
+  errorHandlingConfig(config) {
+    return errorHandlingConfig(config);
+  }
 
- * @description
- * Use this function to manually start up AngularJS application.
- *
- * For more information, see the {@link guide/bootstrap Bootstrap guide}.
- *
- * AngularJS will detect if it has been loaded into the browser more than once and only allow the
- * first loaded script to be bootstrapped and will report a warning to the browser console for
- * each of the subsequent scripts. This prevents strange results in applications, where otherwise
- * multiple instances of AngularJS try to work on the DOM.
- *
- * <div class="alert alert-warning">
- * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
- * They must use {@link ng.directive:ngApp ngApp}.
- * </div>
- *
- * <div class="alert alert-warning">
- * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
- * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
- * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
- * causing animations to stop working and making the injector inaccessible from outside the app.
- * </div>
- *
- * ```html
- * <!doctype html>
- * <html>
- * <body>
- * <div ng-controller="WelcomeController">
- *   {{greeting}}
- * </div>
- *
- * <script src="angular.js"></script>
- * <script>
- *   let app = angular.module('demo', [])
- *   .controller('WelcomeController', function($scope) {
- *       $scope.greeting = 'Welcome!';
- *   });
- *   angular.bootstrap(document, ['demo']);
- * </script>
- * </body>
- * </html>
- * ```
- *
- * @param {string | Element | Document} element DOM element which is the root of AngularJS application.
- * @param {Array<string | Function | any[]>=} modules an array of modules to load into the application.
- *     Each item in the array should be the name of a predefined module or a (DI annotated)
- *     function that will be invoked by the injector as a `config` block.
- *     See: {@link angular.module modules}
- * @param {AngularBootstrapConfig} [config] an object for defining configuration options for the application. The
- *     following keys are supported:
- *
- * * `strictDi` - disable automatic function annotation for the application. This is meant to
- *   assist in finding bugs which break minified code. Defaults to `false`.
- *
- * @returns {any} InjectorService - Returns the newly created injector for this app.
- */
+  /**
+   * Use this function to manually start up AngularJS application.
+   *
+   * For more information, see the {@link guide/bootstrap Bootstrap guide}.
+   *
+   * AngularJS will detect if it has been loaded into the browser more than once and only allow the
+   * first loaded script to be bootstrapped and will report a warning to the browser console for
+   * each of the subsequent scripts. This prevents strange results in applications, where otherwise
+   * multiple instances of AngularJS try to work on the DOM.
+   *
+   * <div class="alert alert-warning">
+   * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
+   * They must use {@link ng.directive:ngApp ngApp}.
+   * </div>
+   *
+   * <div class="alert alert-warning">
+   * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
+   * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
+   * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
+   * causing animations to stop working and making the injector inaccessible from outside the app.
+   * </div>
+   *
+   * ```html
+   * <!doctype html>
+   * <html>
+   * <body>
+   * <div ng-controller="WelcomeController">
+   *   {{greeting}}
+   * </div>
+   *
+   * <script src="angular.js"></script>
+   * <script>
+   *   let app = angular.module('demo', [])
+   *   .controller('WelcomeController', function($scope) {
+   *       $scope.greeting = 'Welcome!';
+   *   });
+   *   angular.bootstrap(document, ['demo']);
+   * </script>
+   * </body>
+   * </html>
+   * ```
+   *
+   * @param {string | Element | Document} element DOM element which is the root of AngularJS application.
+   * @param {Array<String|any>} [modules] an array of modules to load into the application.
+   *     Each item in the array should be the name of a predefined module or a (DI annotated)
+   *     function that will be invoked by the injector as a `config` block.
+   *     See: {@link angular.module modules}
+   * @param {AngularBootstrapConfig} [config] an object for defining configuration options for the application. The
+   *     following keys are supported:
+   *
+   * * `strictDi` - disable automatic function annotation for the application. This is meant to
+   *   assist in finding bugs which break minified code. Defaults to `false`.
+   *
+   * @returns {any} InjectorService - Returns the newly created injector for this app.
+   */
   bootstrap(element, modules, config) {
     config = config || {
-      debugInfoEnabled: false,
       strictDi: false,
     };
 
     this.doBootstrap = function () {
-      element = JQLite(element);
-
-      if (element.injector()) {
-        const tag =
-          element[0] === window.document ? "document" : startingTag(element);
-        // Encode angle brackets to prevent input from being sanitized to empty string #8683.
-        throw ngMinErr(
-          "btstrpd",
-          "App already bootstrapped with this element '{0}'",
-          tag.replace(/</, "&lt;").replace(/>/, "&gt;"),
-        );
+      var jqLite = JQLite(element);
+
+      if (jqLite.injector()) {
+        throw ngMinErr("btstrpd", "App already bootstrapped");
+      }
+
+      if (Array.isArray(modules)) {
+        this.bootsrappedModules = modules;
       }
 
-      this.bootsrappedModules = modules || [];
       this.bootsrappedModules.unshift([
         "$provide",
         ($provide) => {
-          $provide.value("$rootElement", element);
+          $provide.value("$rootElement", jqLite);
         },
       ]);
 
-      if (config.debugInfoEnabled) {
-        // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
-        this.bootsrappedModules.push([
-          "$compileProvider",
-          function ($compileProvider) {
-            $compileProvider.debugInfoEnabled(true);
-          },
-        ]);
-      }
-
       this.bootsrappedModules.unshift("ng");
 
       const injector = createInjector(this.bootsrappedModules, config.strictDi);
@@ -222,7 +149,14 @@ export class Angular {
         "$rootElement",
         "$compile",
         "$injector",
-        function bootstrapApply(scope, el, compile, $injector) {
+        /**
+         *
+         * @param {*} scope
+         * @param {JQLite} el
+         * @param {*} compile
+         * @param {*} $injector
+         */
+        function (scope, el, compile, $injector) {
           scope.$apply(() => {
             el.data("$injector", $injector);
             compile(el)(scope);
@@ -232,36 +166,26 @@ export class Angular {
       return injector;
     };
 
-    const NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
     const NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
 
-    if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
-      config.debugInfoEnabled = true;
-      window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, "");
-    }
-
     if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
       return this.doBootstrap();
     }
 
     window.name = window.name.replace(NG_DEFER_BOOTSTRAP, "");
     this.resumeBootstrap = function (extraModules) {
-      forEach(extraModules, function (module) {
-        modules.push(module);
-      });
+      if (Array.isArray(extraModules)) {
+        extraModules.forEach((module) => modules.push(module));
+      }
       return this.doBootstrap();
     };
-
-    if (isFunction(this.resumeDeferredBootstrap)) {
-      this.resumeDeferredBootstrap();
-    }
   }
 
   /**
    *
    * @param {any[]} modules
    * @param {boolean?} strictDi
-   * @returns {angular.auto.IInjectorService}
+   * @returns {import("./types").InjectorService}
    */
   injector(modules, strictDi) {
     return createInjector(modules, strictDi);
@@ -274,400 +198,6 @@ export class Angular {
     return this.doBootstrap();
   }
 
-  /**
-   *
-   * The `angular.module` is a global place for creating, registering and retrieving AngularJS
-   * modules.
-   * All modules (AngularJS core or 3rd party) that should be available to an application must be
-   * registered using this mechanism.
-   *
-   * Passing one argument retrieves an existing {@link import('./types').Module},
-   * whereas passing more than one argument creates a new {@link import('./types').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
-   * let 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
-   * let 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 import('./types').Module#config Module#config()}.
-   * @returns {import('./types').Module} new module with the {@link import('./types').Module} api.
-   */
-  module(name, requires, configFn) {
-    const $injectorMinErr = minErr("$injector");
-    let info = {};
-
-    assertNotHasOwnProperty(name, "module");
-    if (requires && Object.prototype.hasOwnProperty.call(moduleCache, name)) {
-      moduleCache[name] = null;
-    }
-
-    function ensure(obj, name, factory) {
-      return obj[name] || (obj[name] = factory());
-    }
-
-    return ensure(moduleCache, name, () => {
-      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.<*>>} */
-      const invokeQueue = [];
-
-      /** @type {!Array.<Function>} */
-      const configBlocks = [];
-
-      /** @type {!Array.<Function>} */
-      const runBlocks = [];
-
-      const config = invokeLater("$injector", "invoke", "push", configBlocks);
-
-      /** @type {import('./types').Module} */
-      const moduleInstance = {
-        // Private state
-
-        _invokeQueue: invokeQueue,
-        _configBlocks: configBlocks,
-        _runBlocks: runBlocks,
-
-        /**
-         * @ngdoc method
-         * @name import('./types').Module#info
-         * @module ng
-         *
-         * @param {Object=} value Information about the module
-         * @returns {Object|import('./types').Module} The current info object for this module if called as a getter,
-         *                          or `this` if called as a setter.
-         *
-         * @description
-         * Read and write custom information about this module.
-         * For example you could put the version of the module in here.
-         *
-         * ```js
-         * angular.module('myModule', []).info({ version: '1.0.0' });
-         * ```
-         *
-         * The version could then be read back out by accessing the module elsewhere:
-         *
-         * ```
-         * let version = angular.module('myModule').info().version;
-         * ```
-         *
-         * You can also retrieve this information during runtime via the
-         * {@link $injector#modules `$injector.modules`} property:
-         *
-         * ```js
-         * let version = $injector.modules['myModule'].info().version;
-         * ```
-         */
-        info(value) {
-          if (isDefined(value)) {
-            if (!isObject(value))
-              throw ngMinErr(
-                "aobj",
-                "Argument '{0}' must be an object",
-                "value",
-              );
-            info = value;
-            return this;
-          }
-          return info;
-        },
-
-        /**
-         * @ngdoc property
-         * @type import('./types').Module#requires
-         * @module ng
-         *
-         * @description
-         * Holds the list of modules which the injector will load before the current module is
-         * loaded.
-         */
-        requires,
-
-        /**
-         * @ngdoc property
-         * @name import('./types').Module#name
-         * @module ng
-         *
-         * @description
-         * Name of the module.
-         */
-        name,
-
-        /**
-         * @ngdoc method
-         * @name import('./types').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 import('./types').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 import('./types').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 import('./types').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 import('./types').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 import('./types').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",
-          configBlocks,
-        ),
-
-        /**
-         * @ngdoc method
-         * @name import('./types').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 import('./types').Module#filter
-         * @module ng
-         * @param {string} name Filter name - this must be a valid AngularJS 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 AngularJS {@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 import('./types').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 import('./types').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 import('./types').Module#component
-         * @module ng
-         * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
-         *    or an object map of components where the keys are the names and the values are the component definition objects.
-         * @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 import('./types').Module#config
-         * @module ng
-         * @param {Function} configFn Execute this function on module load. Useful for service
-         *    configuration.
-         * @description
-         * Use this method to configure services by injecting their
-         * {@link import('./types').Module#provider `providers`}, e.g. for adding routes to the
-         * {@link ngRoute.$routeProvider $routeProvider}.
-         *
-         * Note that you can only inject {@link import('./types').Module#provider `providers`} and
-         * {@link import('./types').Module#constant `constants`} into this function.
-         *
-         * For more about how to configure services, see
-         * {@link providers#provider-recipe Provider Recipe}.
-         */
-        config,
-
-        /**
-         * @ngdoc method
-         * @name import('./types').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(block) {
-          runBlocks.push(block);
-          return this;
-        },
-      };
-
-      if (configFn) {
-        config(configFn);
-      }
-
-      return moduleInstance;
-
-      /**
-       * @param {string} provider
-       * @param {string} method
-       * @param {String=} insertMethod
-       * @returns {import('./types').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 {import('./types').Module}
-       */
-      function invokeLaterAndSetModuleName(provider, method, queue) {
-        if (!queue) queue = invokeQueue;
-        return function (recipeName, factoryFunction) {
-          if (factoryFunction && isFunction(factoryFunction))
-            factoryFunction.$$moduleName = name;
-          queue.push([provider, method, arguments]);
-          return moduleInstance;
-        };
-      }
-    });
-  }
-
   /**
  * @module angular
  * @function reloadWithDebugInfo
@@ -827,6 +357,10 @@ export class Angular {
    </file>
  </example>
  */
+
+/**
+ * @param {Element|Document} element
+ */
 export function angularInit(element) {
   let appElement;
   let module;
@@ -854,15 +388,7 @@ export function angularInit(element) {
     }
   });
   if (appElement) {
-    // Angular init is called manually, so why is this check here
-    // if (!confGlobal.isAutoBootstrapAllowed) {
-    //   window.console.error(
-    //     "AngularJS: disabling automatic bootstrap. <script> protocol indicates an extension, document.location.href does not match.",
-    //   );
-    //   return;
-    // }
     config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
-    //TODO maybe angular should be initialized here?
     window["angular"].bootstrap(appElement, module ? [module] : [], config);
   }
 }
@@ -891,57 +417,6 @@ export function setupModuleLoader(window) {
     /** @type {Object.<string, import('./types').Module>} */
     const modules = {};
 
-    /**
-     * @ngdoc function
-     * @name angular.module
-     * @module ng
-     * @description
-     *
-     * The `angular.module` is a global place for creating, registering and retrieving AngularJS
-     * modules.
-     * All modules (AngularJS core or 3rd party) that should be available to an application must be
-     * registered using this mechanism.
-     *
-     * Passing one argument retrieves an existing {@link import('./types').Module},
-     * whereas passing more than one argument creates a new {@link import('./types').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
-     * let 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
-     * let 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 import('./types').Module#config Module#config()}.
-     * @returns {import('./types').Module} new module with the {@link import('./types').Module} api.
-     */
     return function module(name, requires, configFn) {
       let info = {};
 
@@ -979,15 +454,13 @@ export function setupModuleLoader(window) {
           _runBlocks: runBlocks,
 
           /**
-           * @ngdoc method
            * @name import('./types').Module#info
            * @module ng
            *
-           * @param {Object=} info Information about the module
+           * @param {Object=} value Information about the module
            * @returns {Object|import('./types').Module} The current info object for this module if called as a getter,
            *                          or `this` if called as a setter.
            *
-           * @description
            * Read and write custom information about this module.
            * For example you could put the version of the module in here.
            *
@@ -1027,7 +500,6 @@ export function setupModuleLoader(window) {
            * @name import('./types').Module#requires
            * @module ng
            *
-           * @description
            * Holds the list of modules which the injector will load before the current module is
            * loaded.
            */
@@ -1038,76 +510,57 @@ export function setupModuleLoader(window) {
            * @name import('./types').Module#name
            * @module ng
            *
-           * @description
            * Name of the module.
            */
           name,
 
           /**
-           * @ngdoc method
            * @name import('./types').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 import('./types').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 import('./types').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 import('./types').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 import('./types').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 import('./types').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(
@@ -1117,13 +570,10 @@ export function setupModuleLoader(window) {
           ),
 
           /**
-           * @ngdoc method
            * @name import('./types').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.
            *
@@ -1154,12 +604,9 @@ export function setupModuleLoader(window) {
           ),
 
           /**
-           * @ngdoc method
            * @name import('./types').Module#filter
-           * @module ng
            * @param {string} name Filter name - this must be a valid AngularJS 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">
@@ -1172,13 +619,10 @@ export function setupModuleLoader(window) {
           filter: invokeLaterAndSetModuleName("$filterProvider", "register"),
 
           /**
-           * @ngdoc method
            * @name import('./types').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(
@@ -1187,14 +631,11 @@ export function setupModuleLoader(window) {
           ),
 
           /**
-           * @ngdoc method
            * @name import('./types').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(
@@ -1203,15 +644,12 @@ export function setupModuleLoader(window) {
           ),
 
           /**
-           * @ngdoc method
            * @name import('./types').Module#component
-           * @module ng
            * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
            *    or an object map of components where the keys are the names and the values are the component definition objects.
            * @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(
@@ -1220,12 +658,9 @@ export function setupModuleLoader(window) {
           ),
 
           /**
-           * @ngdoc method
            * @name import('./types').Module#config
-           * @module ng
            * @param {Function} configFn Execute this function on module load. Useful for service
            *    configuration.
-           * @description
            * Use this method to configure services by injecting their
            * {@link import('./types').Module#provider `providers`}, e.g. for adding routes to the
            * {@link ngRoute.$routeProvider $routeProvider}.
@@ -1239,12 +674,9 @@ export function setupModuleLoader(window) {
           config,
 
           /**
-           * @ngdoc method
            * @name import('./types').Module#run
-           * @module ng
-           * @param {Function} initializationFn Execute this function after injector creation.
+           * @param {Function} block 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.
            */
@@ -1263,7 +695,8 @@ export function setupModuleLoader(window) {
         /**
          * @param {string} provider
          * @param {string} method
-         * @param {String=} insertMethod
+         * @param {String=} [insertMethod]
+         * @param {Array<any>} [queue]
          * @returns {import('./types').Module}
          */
         function invokeLater(provider, method, insertMethod, queue) {
@@ -1292,47 +725,3 @@ export function setupModuleLoader(window) {
     };
   });
 }
-
-/**
- * @ngdoc function
- * @name angular.errorHandlingConfig
- * @module ng
- * @kind function
- *
- * @description
- * Configure several aspects of error handling in AngularJS if used as a setter or return the
- * current configuration if used as a getter. The following options are supported:
- *
- * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
- *
- * Omitted or undefined options will leave the corresponding configuration values unchanged.
- *
- * @param {Object=} config - The configuration object. May only contain the options that need to be
- *     updated. Supported keys:
- *
- * * `objectMaxDepth`  **{Number}** - The max depth for stringifying objects. Setting to a
- *   non-positive or non-numeric value, removes the max depth limit.
- *   Default: 5
- *
- * * `urlErrorParamsEnabled`  **{Boolean}** - Specifies whether the generated error url will
- *   contain the parameters of the thrown error. Disabling the parameters can be useful if the
- *   generated error url is very long.
- *
- *   Default: true. When used without argument, it returns the current value.
- */
-export function errorHandlingConfig(config) {
-  if (isObject(config)) {
-    if (isDefined(config.objectMaxDepth)) {
-      minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth)
-        ? config.objectMaxDepth
-        : NaN;
-    }
-    if (
-      isDefined(config.urlErrorParamsEnabled) &&
-      isBoolean(config.urlErrorParamsEnabled)
-    ) {
-      minErrConfig.urlErrorParamsEnabled = config.urlErrorParamsEnabled;
-    }
-  }
-  return minErrConfig;
-}