npm - @angular-wave/angular.ts - Versions diffs - 0.0.62 → 0.0.63 - Mend

@angular-wave/angular.ts 0.0.62 → 0.0.63

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/dist/angular-ts.esm.js +2 -2
package/dist/angular-ts.umd.js +2 -2
package/package.json +1 -1
package/src/angular.spec.js +0 -9
package/src/animations/animate-css-driver.js +1 -1
package/src/animations/animate-queue.js +9 -0
package/src/core/compile/compile.js +0 -33
package/src/core/compile/compile.spec.js +0 -47
package/src/core/location/location.js +7 -0
package/src/directive/init/init.spec.js +2 -2
package/src/injector.js +7 -0
package/src/loader.js +99 -660
package/src/shared/jqlite/jqlite.js +20 -29
package/src/shared/jqlite/jqlite.md +62 -0
package/src/shared/min-err.spec.js +1 -2
package/src/shared/utils.js +36 -2
package/src/types.js +3 -4
package/types/animations/animate-css-driver.d.ts +2 -1
package/types/animations/animate-queue.d.ts +2 -1
package/types/core/compile/compile.d.ts +0 -1
package/types/core/location/location.d.ts +2 -1
package/types/injector.d.ts +7 -7
package/types/loader.d.ts +64 -136
package/types/shared/jqlite/jqlite.d.ts +5 -5
package/types/shared/utils.d.ts +20 -1
package/types/types.d.ts +3 -3

package/src/loader.js CHANGED Viewed

@@ -1,28 +1,15 @@
 import {
   minErr,
-  extend,
   forEach,
   getNgAttribute,
   isFunction,
   isObject,
   ngAttrPrefixes,
   isDefined,
-  isDate,
-  isElement,
-  isNumber,
-  isString,
-  isUndefined,
-  merge,
-  bind,
-  fromJson,
-  toJson,
-  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";
@@ -33,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`.
  */
@@ -60,110 +43,104 @@ export class Angular {
     /** @type {typeof import('./shared/jqlite/jqlite').JQLite} */
     this.element = JQLite;
-    /** @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);
@@ -172,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);
@@ -182,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);
@@ -224,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
@@ -777,6 +357,10 @@ export class Angular {
    </file>
  </example>
  */
+/**
+ * @param {Element|Document} element
+ */
 export function angularInit(element) {
   let appElement;
   let module;
@@ -804,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);
   }
 }
@@ -841,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 = {};
@@ -929,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.
            *
@@ -977,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.
            */
@@ -988,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(
@@ -1067,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.
            *
@@ -1104,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">
@@ -1122,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(
@@ -1137,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(
@@ -1153,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(
@@ -1170,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}.
@@ -1189,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.
            */
@@ -1213,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) {
@@ -1242,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;
-}