@angular-wave/angular.ts 0.0.62 → 0.0.63

package/src/shared/jqlite/jqlite.js

@@ -16,11 +16,6 @@ import {
 import { CACHE, EXPANDO } from "../../core/cache/cache";
 
 /**
- * @name angular.element
- * @module ng
- * @kind function
- *
- * @description
  * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element. Regardless of the presence of jQuery, `angular.element`
  * delegates to AngularJS's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
  *
@@ -80,12 +75,6 @@ import { CACHE, EXPANDO } from "../../core/cache/cache";
  *   Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
  * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
  *   parent element is reached.
- *
- * @knownIssue You cannot spy on `angular.element` if you are using Jasmine version 1.x. See
- * https://github.com/angular/angular.js/issues/14251 for more information.
- *
- * @param {string|Element} element HTML string or Element to be wrapped into jQuery.
- * @returns {JQLite} jQuery object.
  */
 
 /** @type {number} */
@@ -135,7 +124,7 @@ const BOOLEAN_ELEMENTS = {};
  * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
  * and execution of chain functions.
  *
- * @param {string|Element|Comment|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+ * @param {string|Node|JQLite|ArrayLike<Element>|(() => void)} element
  * @returns {JQLite}
  */
 export function JQLite(element) {
@@ -553,15 +542,7 @@ JQLite.prototype.replaceWith = function (arg1) {
     });
   };
   for (let i = 0; i < this.length; i++) {
-    if (isUndefined(value)) {
-      value = fn(this[i], arg1);
-      if (isDefined(value)) {
-        // any function which returns a value needs to be wrapped
-        value = JQLite(value);
-      }
-    } else {
-      addNodes(value, fn(this[i], arg1));
-    }
+    addNodes(value, fn(this[i], arg1));
   }
   return isDefined(value) ? value : this;
 };
@@ -893,6 +874,7 @@ function elementAcceptsData(node) {
  * @returns {DocumentFragment}
  */
 export function buildFragment(html) {
+  /** @type {HTMLDivElement} */
   let tmp;
   let tag;
   let wrap;
@@ -905,6 +887,7 @@ export function buildFragment(html) {
     nodes.push(document.createTextNode(html));
   } else {
     // Convert html into DOM nodes
+
     tmp = tempFragment.appendChild(document.createElement("div"));
     tag = (TAG_NAME_REGEXP.exec(html) || ["", ""])[1].toLowerCase();
 
@@ -914,13 +897,13 @@ export function buildFragment(html) {
     i = wrap.length;
     while (--i > -1) {
       tmp.appendChild(window.document.createElement(wrap[i]));
-      tmp = tmp.firstChild;
+      tmp = /** @type {HTMLDivElement} */ (tmp.firstChild);
     }
     tmp.innerHTML = html;
 
     nodes = concat(nodes, tmp.childNodes);
 
-    tmp = tempFragment.firstChild;
+    tmp = /** @type {HTMLDivElement} */ (tempFragment.firstChild);
     tmp.textContent = "";
   }
 
@@ -1021,7 +1004,7 @@ export function getOrSetCacheData(element, key, value) {
 /**
  * Adds nodes or elements to the root array-like object.
  *
- * @param {Array} root - The array-like object to which elements will be added.
+ * @param {JQLite} root - The array-like object to which elements will be added.
  * @param {(Node|Array|NodeList|Object)} elements - The elements to add to the root. This can be a single DOM node, an array-like object (such as an Array or NodeList), or any other object.
  */
 function addNodes(root, elements) {
@@ -1054,7 +1037,7 @@ function getController(element, name) {
 
 /**
  *
- * @param {Element} element
+ * @param {Node} element
  * @param {string|string[]} name
  * @param {any} [value]
  * @returns
@@ -1064,13 +1047,20 @@ function getInheritedData(element, name, value) {
   // this makes $(document).scope() possible
   if (element.nodeType === Node.DOCUMENT_NODE) {
     // TODO Fix types
-    element = element.documentElement;
+    element = /** @type {Document} */ (element).documentElement;
   }
   const names = Array.isArray(name) ? name : [name];
 
   while (element) {
     for (let i = 0, ii = names.length; i < ii; i++) {
-      if (isDefined((value = getOrSetCacheData(element, names[i]))))
+      if (
+        isDefined(
+          (value = getOrSetCacheData(
+            /** @type {Element} */ (element),
+            names[i],
+          )),
+        )
+      )
         return value;
     }
 
@@ -1079,7 +1069,8 @@ function getInheritedData(element, name, value) {
     // to lookup parent controllers.
     element =
       element.parentNode ||
-      (element.nodeType === Node.DOCUMENT_FRAGMENT_NODE && element.host);
+      (element.nodeType === Node.DOCUMENT_FRAGMENT_NODE &&
+        /** @type {ShadowRoot} */ (element).host);
   }
 }
 
@@ -1193,7 +1184,7 @@ function specialMouseHandlerWrapper(target, event, handler) {
 export function startingTag(elementStr) {
   const clone = JQLite(elementStr)[0].cloneNode(true);
   const element = JQLite(clone).empty();
-  var elemHtml = JQLite("<div></div>").append(element).html();
+  var elemHtml = JQLite("<div></div>").append(element[0]).html();
   try {
     return element[0].nodeType === Node.TEXT_NODE
       ? lowercase(elemHtml)

package/src/shared/jqlite/jqlite.md

@@ -0,0 +1,62 @@
+/\*\*
+
+- Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element. Regardless of the presence of jQuery, `angular.element`
+- delegates to AngularJS's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
+-
+- JQLite is a tiny, API-compatible subset of jQuery that allows
+- AngularJS to manipulate the DOM in a cross-browser compatible way. JQLite implements only the most
+- commonly needed functionality with the goal of having a very small footprint.
+-
+- <div class="alert alert-info">**Note:** All element references in AngularJS are always wrapped with
+- JQLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
+-
+- <div class="alert alert-warning">**Note:** Keep in mind that this function will not find elements
+- by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
+- or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
+-
+- ## AngularJS's JQLite
+- JQLite provides only the following jQuery methods:
+-
+- - [`after()`](http://api.jquery.com/after/)
+- - [`append()`](http://api.jquery.com/append/) - Contrary to jQuery, this doesn't clone elements
+- so will not work correctly when invoked on a JQLite object containing more than one DOM node
+- - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
+- - [`children()`](http://api.jquery.com/children/) - Does not support selectors
+- - [`data()`](http://api.jquery.com/data/)
+- - [`empty()`](http://api.jquery.com/empty/)
+- - [`eq()`](http://api.jquery.com/eq/)
+- - [`html()`](http://api.jquery.com/html/)
+- - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
+- - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
+- - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
+- - [`prepend()`](http://api.jquery.com/prepend/)
+- - [`remove()`](http://api.jquery.com/remove/)
+- - [`removeData()`](http://api.jquery.com/removeData/)
+- - [`replaceWith()`](http://api.jquery.com/replaceWith/)
+- - [`text()`](http://api.jquery.com/text/)
+- - [`val()`](http://api.jquery.com/val/)
+-
+- ## jQuery/jqLite Extras
+- AngularJS also provides the following additional methods and events to both jQuery and JQLite:
+-
+- ### Events
+- - `$destroy` - AngularJS intercepts all JQLite/jQuery's DOM destruction apis and fires this event
+- on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM
+- element before it is removed.
+-
+- ### Methods
+- - `controller(name)` - retrieves the controller of the current element or its parent. By default
+- retrieves controller associated with the `ngController` directive. If `name` is provided as
+- camelCase directive name, then the controller for this directive will be retrieved (e.g.
+- `'ngModel'`).
+- - `injector()` - retrieves the injector of the current element or its parent.
+- - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
+- element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
+- be enabled.
+- - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
+- current element. This getter should be used only on elements that contain a directive which starts a new isolate
+- scope. Calling `scope()` on this element always returns the original non-isolate scope.
+- Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
+- - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
+- parent element is reached.
+  \*/

package/src/shared/min-err.spec.js

@@ -1,5 +1,4 @@
-import { minErr, isDefined, toDebugString } from "./utils";
-import { errorHandlingConfig } from "../loader";
+import { minErr, isDefined, toDebugString, errorHandlingConfig } from "./utils";
 
 describe("errors", () => {
   afterEach(() => {});

package/src/shared/utils.js

@@ -1101,7 +1101,41 @@ export function assertArgFn(arg, name, acceptArrayAnnotation) {
   return arg;
 }
 
-export const minErrConfig = {};
+/**
+ * @typedef {Object} ErrorHandlingConfig
+ * Error configuration object. May only contain the options that need to be updated.
+ * @property {number=} objectMaxDepth - The max depth for stringifying objects. Setting to a
+ *   non-positive or non-numeric value removes the max depth limit. Default: 5.
+ * @property {boolean=} urlErrorParamsEnabled - Specifies whether the generated error URL will
+ *   contain the parameters of the thrown error. Default: true. When used without argument, it returns the current value.
+ */
+
+/** @type {ErrorHandlingConfig} */
+const minErrConfig = {
+  objectMaxDepth: 5,
+  urlErrorParamsEnabled: true,
+};
+
+/**
+ * @param {ErrorHandlingConfig} [config]
+ * @returns {ErrorHandlingConfig}
+ */
+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;
+}
 
 /**
  * This object provides a utility for producing rich Error messages within
@@ -1158,7 +1192,7 @@ export function minErr(module) {
 
     message += `\n${url}${module ? `${module}/` : ""}${code}`;
 
-    if (minErrConfig.urlErrorParamsEnabled) {
+    if (errorHandlingConfig().urlErrorParamsEnabled) {
       for (
         i = 0, paramPrefix = "?";
         i < templateArgs.length;

package/src/types.js

@@ -1,7 +1,6 @@
 /**
  * @typedef {Object} BootstrapConfig
  * @description Configuration option for AngularTS bootstrap process.
- * @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`.
  */
 
@@ -451,9 +450,9 @@
  * @property {function(string, string=): any} get - Get a service by name.
  * @property {function(Function, any?): any} instantiate - Instantiate a type constructor with optional locals.
  * @property {function(Injectable<Function | ((...args: any[]) => any)>, any=, any=): any} invoke - Invoke a function with optional context and locals.
- * @property {function(Array<Module | string | Injectable<(...args: any[]) => void>>): void} loadNewModules - Add and load new modules to the injector.
- * @property {Object.<string, Module>} modules - A map of all the modules loaded into the injector.
- * @property {boolean} strictDi - Indicates if strict dependency injection is enforced.
+ * @property {function(Array<Module | string | Injectable<(...args: any[]) => void>>): void} [loadNewModules] - Add and load new modules to the injector.
+ * @property {Object.<string, Module>} [modules] - A map of all the modules loaded into the injector.
+ * @property {boolean} [strictDi] - Indicates if strict dependency injection is enforced.
  */
 
 export {};

package/types/animations/animate-css-driver.d.ts

@@ -4,8 +4,9 @@ export class $$AnimateCssDriverProvider {
     /**
      * @returns {Function}
      */
-    $get: (string | (($animateCss: any, $$AnimateRunner: typeof import("../core/animate/animate-runner").AnimateRunner, $rootElement: any) => (animationDetails: any) => any))[];
+    $get: (string | (($animateCss: any, $$AnimateRunner: typeof import("../core/animate/animate-runner").AnimateRunner, $rootElement: JQLite) => (animationDetails: any) => any))[];
 }
 export namespace $$AnimateCssDriverProvider {
     let $inject: string[];
 }
+import { JQLite } from "../shared/jqlite/jqlite";

package/types/animations/animate-queue.d.ts

@@ -6,7 +6,7 @@ export class $$AnimateQueueProvider {
         cancel: any[];
         join: any[];
     };
-    $get: (string | (($rootScope: any, $rootElement: any, $$animation: any, $$AnimateRunner: any, $templateRequest: any) => {
+    $get: (string | (($rootScope: any, $rootElement: JQLite, $$animation: any, $$AnimateRunner: any, $templateRequest: any) => {
         on(event: any, container: any, callback: any): void;
         off(event: any, container: any, callback: any, ...args: any[]): void;
         pin(element: any, parentElement: any): void;
@@ -17,3 +17,4 @@ export class $$AnimateQueueProvider {
 export namespace $$AnimateQueueProvider {
     let $inject: string[];
 }
+import { JQLite } from "../shared/jqlite/jqlite";

package/types/core/compile/compile.d.ts

@@ -147,7 +147,6 @@ export class $CompileProvider {
      *    chaining otherwise.
      */
     imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
-    debugInfoEnabled: (enabled: any) => boolean | this;
     strictComponentBindingsEnabled: (enabled: any) => boolean | this;
     /**
      * @ngdoc method

package/types/core/location/location.d.ts

@@ -204,6 +204,7 @@ export class $LocationProvider {
      * @param {string=} newState New history state object
      * @param {string=} oldState History state object that was before it was changed.
      */
-    $get: (string | (($rootScope: any, $browser: any, $rootElement: any) => LocationHtml5Url | LocationHashbangUrl))[];
+    $get: (string | (($rootScope: any, $browser: any, $rootElement: JQLite) => LocationHtml5Url | LocationHashbangUrl))[];
 }
 export const PATH_MATCH: RegExp;
+import { JQLite } from "../../shared/jqlite/jqlite";

package/types/injector.d.ts

@@ -1,10 +1,10 @@
-export function createInjector(modulesToLoad: any, strictDi: any): {
-    invoke: (fn: any, self: any, locals: any, serviceName: any) => any;
-    instantiate: (Type: any, locals: any, serviceName: any) => any;
-    get: (serviceName: any, caller: any) => any;
-    annotate: typeof annotate;
-    has: (name: any) => any;
-};
+/**
+ *
+ * @param {*} modulesToLoad
+ * @param {*} strictDi
+ * @returns {import("./types").InjectorService}
+ */
+export function createInjector(modulesToLoad: any, strictDi: any): import("./types").InjectorService;
 export namespace createInjector {
     export { annotate as $$annotate };
 }

package/types/loader.d.ts

@@ -139,7 +139,10 @@
    </file>
  </example>
  */
-export function angularInit(element: any): void;
+/**
+ * @param {Element|Document} element
+ */
+export function angularInit(element: Element | Document): void;
 /**
  * @ngdoc type
  * @name import('./types').Module
@@ -149,34 +152,6 @@ export function angularInit(element: any): void;
  * Interface for configuring AngularJS {@link angular.module modules}.
  */
 export function setupModuleLoader(window: any): any;
-/**
- * @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?: any | undefined): {};
 /**
  * @type {string} `version` from `package.json`, injected by Rollup plugin
  */
@@ -185,7 +160,6 @@ export const VERSION: string;
  * 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`.
  */
 /**
@@ -198,126 +172,84 @@ export class Angular {
     version: string;
     /** @type {typeof import('./shared/jqlite/jqlite').JQLite} */
     element: typeof import("./shared/jqlite/jqlite").JQLite;
-    /** @type {errorHandlingConfig} */
-    errorHandlingConfig: typeof errorHandlingConfig;
+    /** @type {!Array<string|any>} */
+    bootsrappedModules: Array<string | any>;
     /** @type {Function} */
     doBootstrap: Function;
     /**
-   * @module angular
-   * @function bootstrap
-  
-   * @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.
-   */
-    bootstrap(element: string | Element | Document, modules?: Array<string | Function | any[]> | undefined, config?: AngularBootstrapConfig): any;
-    resumeBootstrap(extraModules: any): any;
-    /**
+     * Configure several aspects of error handling if used as a setter or return the
+     * current configuration if used as a getter.
      *
-     * @param {any[]} modules
-     * @param {boolean?} strictDi
-     * @returns {angular.auto.IInjectorService}
+     * Omitted or undefined options will leave the corresponding configuration values unchanged.
+     *
+     * @param {import('./shared/utils').ErrorHandlingConfig} [config]
+     * @returns {import('./shared/utils').ErrorHandlingConfig}
      */
-    injector(modules: any[], strictDi: boolean | null): angular.auto.IInjectorService;
+    errorHandlingConfig(config?: import("./shared/utils").ErrorHandlingConfig): import("./shared/utils").ErrorHandlingConfig;
     /**
+     * Use this function to manually start up AngularJS application.
      *
-     * 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.
+     * For more information, see the {@link guide/bootstrap Bootstrap guide}.
      *
-     * Passing one argument retrieves an existing {@link import('./types').Module},
-     * whereas passing more than one argument creates a new {@link import('./types').Module}
+     * 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>
      *
-     * # Module
+     * <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>
      *
-     * A module is a collection of services, directives, controllers, filters, and configuration information.
-     * `angular.module` is used to configure the {@link auto.$injector $injector}.
+     * ```html
+     * <!doctype html>
+     * <html>
+     * <body>
+     * <div ng-controller="WelcomeController">
+     *   {{greeting}}
+     * </div>
      *
-     * ```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('!');
-     * }]);
+     * <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>
      * ```
      *
-     * Then you can create an injector and load your modules like this:
+     * @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:
      *
-     * ```js
-     * let injector = angular.injector(['ng', 'myModule'])
-     * ```
+     * * `strictDi` - disable automatic function annotation for the application. This is meant to
+     *   assist in finding bugs which break minified code. Defaults to `false`.
      *
-     * 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.
+     * @returns {any} InjectorService - Returns the newly created injector for this app.
+     */
+    bootstrap(element: string | Element | Document, modules?: Array<string | any>, config?: AngularBootstrapConfig): any;
+    resumeBootstrap(extraModules: any): any;
+    /**
      *
-     * @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.
+     * @param {any[]} modules
+     * @param {boolean?} strictDi
+     * @returns {import("./types").InjectorService}
      */
-    module(name: string, requires?: Array<string> | undefined, configFn?: Function | undefined): import("./types").Module;
+    injector(modules: any[], strictDi: boolean | null): import("./types").InjectorService;
     /**
    * @module angular
    * @function reloadWithDebugInfo
@@ -334,10 +266,6 @@ export class Angular {
  * Configuration option for AngularTS bootstrap process.
  */
 export type AngularBootstrapConfig = {
-    /**
-     * - Indicates whether debug information should be enabled. Setting this to `false` can improve performance but will disable some debugging features.
-     */
-    debugInfoEnabled: boolean;
     /**
      * - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
      */

package/types/shared/jqlite/jqlite.d.ts

@@ -2,19 +2,19 @@
  * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
  * and execution of chain functions.
  *
- * @param {string|Element|Comment|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+ * @param {string|Node|JQLite|ArrayLike<Element>|(() => void)} element
  * @returns {JQLite}
  */
-export function JQLite(element: string | Element | Comment | Document | Window | JQLite | ArrayLike<Element> | (() => void)): JQLite;
+export function JQLite(element: string | Node | JQLite | ArrayLike<Element> | (() => void)): JQLite;
 export class JQLite {
     /**
      * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
      * and execution of chain functions.
      *
-     * @param {string|Element|Comment|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+     * @param {string|Node|JQLite|ArrayLike<Element>|(() => void)} element
      * @returns {JQLite}
      */
-    constructor(element: string | Element | Comment | Document | Window | JQLite | ArrayLike<Element> | (() => void));
+    constructor(element: string | Node | JQLite | ArrayLike<Element> | (() => void));
     /**
      * Remove all child nodes of the set of matched elements from the DOM and clears CACHE data, associated with the node.
      * @returns {JQLite} The current instance of JQLite.
@@ -101,7 +101,7 @@ export class JQLite {
      * @returns {JQLite|any} - The retrieved data if acting as a getter. Otherwise, returns undefined.
      */
     data(key: string | any, value?: any): JQLite | any;
-    replaceWith(arg1: any): void | JQLite;
+    replaceWith(arg1: any): this;
     children(): JQLite;
     /**
      * @param {string} node