@angular/upgrade
Version:
Angular - the library for easing update from v1 to v2
283 lines • 39.7 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Injector, isDevMode, NgModule, NgZone, PlatformRef, Testability } from '@angular/core';
import { bootstrap, element as angularElement, module_ as angularModule } from '../../src/common/src/angular1';
import { $$TESTABILITY, $DELEGATE, $INJECTOR, $INTERVAL, $PROVIDE, INJECTOR_KEY, LAZY_MODULE_REF, UPGRADE_APP_TYPE_KEY, UPGRADE_MODULE_NAME } from '../../src/common/src/constants';
import { controllerKey, destroyApp } from '../../src/common/src/util';
import { angular1Providers, setTempInjectorRef } from './angular1_providers';
import { NgAdapterInjector } from './util';
/**
* @description
*
* An `NgModule`, which you import to provide AngularJS core services,
* and has an instance method used to bootstrap the hybrid upgrade application.
*
* *Part of the [upgrade/static](api?query=upgrade/static)
* library for hybrid upgrade apps that support AOT compilation*
*
* The `upgrade/static` package contains helpers that allow AngularJS and Angular components
* to be used together inside a hybrid upgrade application, which supports AOT compilation.
*
* Specifically, the classes and functions in the `upgrade/static` module allow the following:
*
* 1. Creation of an Angular directive that wraps and exposes an AngularJS component so
* that it can be used in an Angular template. See `UpgradeComponent`.
* 2. Creation of an AngularJS directive that wraps and exposes an Angular component so
* that it can be used in an AngularJS template. See `downgradeComponent`.
* 3. Creation of an Angular root injector provider that wraps and exposes an AngularJS
* service so that it can be injected into an Angular context. See
* {@link UpgradeModule#upgrading-an-angular-1-service Upgrading an AngularJS service} below.
* 4. Creation of an AngularJS service that wraps and exposes an Angular injectable
* so that it can be injected into an AngularJS context. See `downgradeInjectable`.
* 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks
* coexisting in a single application.
*
* @usageNotes
*
* ```ts
* import {UpgradeModule} from '@angular/upgrade/static';
* ```
*
* See also the {@link UpgradeModule#examples examples} below.
*
* ### Mental Model
*
* When reasoning about how a hybrid application works it is useful to have a mental model which
* describes what is happening and explains what is happening at the lowest level.
*
* 1. There are two independent frameworks running in a single application, each framework treats
* the other as a black box.
* 2. Each DOM element on the page is owned exactly by one framework. Whichever framework
* instantiated the element is the owner. Each framework only updates/interacts with its own
* DOM elements and ignores others.
* 3. AngularJS directives always execute inside the AngularJS framework codebase regardless of
* where they are instantiated.
* 4. Angular components always execute inside the Angular framework codebase regardless of
* where they are instantiated.
* 5. An AngularJS component can be "upgraded"" to an Angular component. This is achieved by
* defining an Angular directive, which bootstraps the AngularJS component at its location
* in the DOM. See `UpgradeComponent`.
* 6. An Angular component can be "downgraded" to an AngularJS component. This is achieved by
* defining an AngularJS directive, which bootstraps the Angular component at its location
* in the DOM. See `downgradeComponent`.
* 7. Whenever an "upgraded"/"downgraded" component is instantiated the host element is owned by
* the framework doing the instantiation. The other framework then instantiates and owns the
* view for that component.
* 1. This implies that the component bindings will always follow the semantics of the
* instantiation framework.
* 2. The DOM attributes are parsed by the framework that owns the current template. So
* attributes in AngularJS templates must use kebab-case, while AngularJS templates must use
* camelCase.
* 3. However the template binding syntax will always use the Angular style, e.g. square
* brackets (`[...]`) for property binding.
* 8. Angular is bootstrapped first; AngularJS is bootstrapped second. AngularJS always owns the
* root component of the application.
* 9. The new application is running in an Angular zone, and therefore it no longer needs calls to
* `$apply()`.
*
* ### The `UpgradeModule` class
*
* This class is an `NgModule`, which you import to provide AngularJS core services,
* and has an instance method used to bootstrap the hybrid upgrade application.
*
* * Core AngularJS services
* Importing this `NgModule` will add providers for the core
* [AngularJS services](https://docs.angularjs.org/api/ng/service) to the root injector.
*
* * Bootstrap
* The runtime instance of this class contains a {@link UpgradeModule#bootstrap `bootstrap()`}
* method, which you use to bootstrap the top level AngularJS module onto an element in the
* DOM for the hybrid upgrade app.
*
* It also contains properties to access the {@link UpgradeModule#injector root injector}, the
* bootstrap `NgZone` and the
* [AngularJS $injector](https://docs.angularjs.org/api/auto/service/$injector).
*
* ### Examples
*
* Import the `UpgradeModule` into your top level {@link NgModule Angular `NgModule`}.
*
* {@example upgrade/static/ts/full/module.ts region='ng2-module'}
*
* Then inject `UpgradeModule` into your Angular `NgModule` and use it to bootstrap the top level
* [AngularJS module](https://docs.angularjs.org/api/ng/type/angular.Module) in the
* `ngDoBootstrap()` method.
*
* {@example upgrade/static/ts/full/module.ts region='bootstrap-ng1'}
*
* Finally, kick off the whole process, by bootstraping your top level Angular `NgModule`.
*
* {@example upgrade/static/ts/full/module.ts region='bootstrap-ng2'}
*
* {@a upgrading-an-angular-1-service}
* ### Upgrading an AngularJS service
*
* There is no specific API for upgrading an AngularJS service. Instead you should just follow the
* following recipe:
*
* Let's say you have an AngularJS service:
*
* {@example upgrade/static/ts/full/module.ts region="ng1-text-formatter-service"}
*
* Then you should define an Angular provider to be included in your `NgModule` `providers`
* property.
*
* {@example upgrade/static/ts/full/module.ts region="upgrade-ng1-service"}
*
* Then you can use the "upgraded" AngularJS service by injecting it into an Angular component
* or service.
*
* {@example upgrade/static/ts/full/module.ts region="use-ng1-upgraded-service"}
*
* @publicApi
*/
export class UpgradeModule {
constructor(
/** The root `Injector` for the upgrade application. */
injector,
/** The bootstrap zone for the upgrade application */
ngZone,
/**
* The owning `NgModuleRef`s `PlatformRef` instance.
* This is used to tie the lifecycle of the bootstrapped AngularJS apps to that of the Angular
* `PlatformRef`.
*/
platformRef) {
this.ngZone = ngZone;
this.platformRef = platformRef;
this.injector = new NgAdapterInjector(injector);
}
/**
* Bootstrap an AngularJS application from this NgModule
* @param element the element on which to bootstrap the AngularJS application
* @param [modules] the AngularJS modules to bootstrap for this application
* @param [config] optional extra AngularJS bootstrap configuration
*/
bootstrap(element, modules = [], config /*angular.IAngularBootstrapConfig*/) {
const INIT_MODULE_NAME = UPGRADE_MODULE_NAME + '.init';
// Create an ng1 module to bootstrap
angularModule(INIT_MODULE_NAME, [])
.constant(UPGRADE_APP_TYPE_KEY, 2 /* Static */)
.value(INJECTOR_KEY, this.injector)
.factory(LAZY_MODULE_REF, [INJECTOR_KEY, (injector) => ({ injector })])
.config([
$PROVIDE, $INJECTOR,
($provide, $injector) => {
if ($injector.has($$TESTABILITY)) {
$provide.decorator($$TESTABILITY, [
$DELEGATE,
(testabilityDelegate) => {
const originalWhenStable = testabilityDelegate.whenStable;
const injector = this.injector;
// Cannot use arrow function below because we need the context
const newWhenStable = function (callback) {
originalWhenStable.call(testabilityDelegate, function () {
const ng2Testability = injector.get(Testability);
if (ng2Testability.isStable()) {
callback();
}
else {
ng2Testability.whenStable(newWhenStable.bind(testabilityDelegate, callback));
}
});
};
testabilityDelegate.whenStable = newWhenStable;
return testabilityDelegate;
}
]);
}
if ($injector.has($INTERVAL)) {
$provide.decorator($INTERVAL, [
$DELEGATE,
(intervalDelegate) => {
// Wrap the $interval service so that setInterval is called outside NgZone,
// but the callback is still invoked within it. This is so that $interval
// won't block stability, which preserves the behavior from AngularJS.
let wrappedInterval = (fn, delay, count, invokeApply, ...pass) => {
return this.ngZone.runOutsideAngular(() => {
return intervalDelegate((...args) => {
// Run callback in the next VM turn - $interval calls
// $rootScope.$apply, and running the callback in NgZone will
// cause a '$digest already in progress' error if it's in the
// same vm turn.
setTimeout(() => {
this.ngZone.run(() => fn(...args));
});
}, delay, count, invokeApply, ...pass);
});
};
wrappedInterval['cancel'] = intervalDelegate.cancel;
return wrappedInterval;
}
]);
}
}
])
.run([
$INJECTOR,
($injector) => {
this.$injector = $injector;
const $rootScope = $injector.get('$rootScope');
// Initialize the ng1 $injector provider
setTempInjectorRef($injector);
this.injector.get($INJECTOR);
// Put the injector on the DOM, so that it can be "required"
angularElement(element).data(controllerKey(INJECTOR_KEY), this.injector);
// Destroy the AngularJS app once the Angular `PlatformRef` is destroyed.
// This does not happen in a typical SPA scenario, but it might be useful for
// other use-cases where disposing of an Angular/AngularJS app is necessary
// (such as Hot Module Replacement (HMR)).
// See https://github.com/angular/angular/issues/39935.
this.platformRef.onDestroy(() => destroyApp($injector));
// Wire up the ng1 rootScope to run a digest cycle whenever the zone settles
// We need to do this in the next tick so that we don't prevent the bootup stabilizing
setTimeout(() => {
const subscription = this.ngZone.onMicrotaskEmpty.subscribe(() => {
if ($rootScope.$$phase) {
if (isDevMode()) {
console.warn('A digest was triggered while one was already in progress. This may mean that something is triggering digests outside the Angular zone.');
}
return $rootScope.$evalAsync();
}
return $rootScope.$digest();
});
$rootScope.$on('$destroy', () => {
subscription.unsubscribe();
});
}, 0);
}
]);
const upgradeModule = angularModule(UPGRADE_MODULE_NAME, [INIT_MODULE_NAME].concat(modules));
// Make sure resumeBootstrap() only exists if the current bootstrap is deferred
const windowAngular = window['angular'];
windowAngular.resumeBootstrap = undefined;
// Bootstrap the AngularJS application inside our zone
this.ngZone.run(() => {
bootstrap(element, [upgradeModule.name], config);
});
// Patch resumeBootstrap() to run inside the ngZone
if (windowAngular.resumeBootstrap) {
const originalResumeBootstrap = windowAngular.resumeBootstrap;
const ngZone = this.ngZone;
windowAngular.resumeBootstrap = function () {
let args = arguments;
windowAngular.resumeBootstrap = originalResumeBootstrap;
return ngZone.run(() => windowAngular.resumeBootstrap.apply(this, args));
};
}
}
}
UpgradeModule.decorators = [
{ type: NgModule, args: [{ providers: [angular1Providers] },] }
];
UpgradeModule.ctorParameters = () => [
{ type: Injector },
{ type: NgZone },
{ type: PlatformRef }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade_module.js","sourceRoot":"","sources":["../../../../../../../packages/upgrade/static/src/upgrade_module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector, isDevMode, NgModule, NgZone, PlatformRef, Testability} from '@angular/core';\n\nimport {bootstrap, element as angularElement, IInjectorService, IIntervalService, IProvideService, ITestabilityService, module_ as angularModule} from '../../src/common/src/angular1';\nimport {$$TESTABILITY, $DELEGATE, $INJECTOR, $INTERVAL, $PROVIDE, INJECTOR_KEY, LAZY_MODULE_REF, UPGRADE_APP_TYPE_KEY, UPGRADE_MODULE_NAME} from '../../src/common/src/constants';\nimport {controllerKey, destroyApp, LazyModuleRef, UpgradeAppType} from '../../src/common/src/util';\n\nimport {angular1Providers, setTempInjectorRef} from './angular1_providers';\nimport {NgAdapterInjector} from './util';\n\n\n\n/**\n * @description\n *\n * An `NgModule`, which you import to provide AngularJS core services,\n * and has an instance method used to bootstrap the hybrid upgrade application.\n *\n * *Part of the [upgrade/static](api?query=upgrade/static)\n * library for hybrid upgrade apps that support AOT compilation*\n *\n * The `upgrade/static` package contains helpers that allow AngularJS and Angular components\n * to be used together inside a hybrid upgrade application, which supports AOT compilation.\n *\n * Specifically, the classes and functions in the `upgrade/static` module allow the following:\n *\n * 1. Creation of an Angular directive that wraps and exposes an AngularJS component so\n *    that it can be used in an Angular template. See `UpgradeComponent`.\n * 2. Creation of an AngularJS directive that wraps and exposes an Angular component so\n *    that it can be used in an AngularJS template. See `downgradeComponent`.\n * 3. Creation of an Angular root injector provider that wraps and exposes an AngularJS\n *    service so that it can be injected into an Angular context. See\n *    {@link UpgradeModule#upgrading-an-angular-1-service Upgrading an AngularJS service} below.\n * 4. Creation of an AngularJS service that wraps and exposes an Angular injectable\n *    so that it can be injected into an AngularJS context. See `downgradeInjectable`.\n * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks\n *    coexisting in a single application.\n *\n * @usageNotes\n *\n * ```ts\n * import {UpgradeModule} from '@angular/upgrade/static';\n * ```\n *\n * See also the {@link UpgradeModule#examples examples} below.\n *\n * ### Mental Model\n *\n * When reasoning about how a hybrid application works it is useful to have a mental model which\n * describes what is happening and explains what is happening at the lowest level.\n *\n * 1. There are two independent frameworks running in a single application, each framework treats\n *    the other as a black box.\n * 2. Each DOM element on the page is owned exactly by one framework. Whichever framework\n *    instantiated the element is the owner. Each framework only updates/interacts with its own\n *    DOM elements and ignores others.\n * 3. AngularJS directives always execute inside the AngularJS framework codebase regardless of\n *    where they are instantiated.\n * 4. Angular components always execute inside the Angular framework codebase regardless of\n *    where they are instantiated.\n * 5. An AngularJS component can be \"upgraded\"\" to an Angular component. This is achieved by\n *    defining an Angular directive, which bootstraps the AngularJS component at its location\n *    in the DOM. See `UpgradeComponent`.\n * 6. An Angular component can be \"downgraded\" to an AngularJS component. This is achieved by\n *    defining an AngularJS directive, which bootstraps the Angular component at its location\n *    in the DOM. See `downgradeComponent`.\n * 7. Whenever an \"upgraded\"/\"downgraded\" component is instantiated the host element is owned by\n *    the framework doing the instantiation. The other framework then instantiates and owns the\n *    view for that component.\n *    1. This implies that the component bindings will always follow the semantics of the\n *       instantiation framework.\n *    2. The DOM attributes are parsed by the framework that owns the current template. So\n *       attributes in AngularJS templates must use kebab-case, while AngularJS templates must use\n *       camelCase.\n *    3. However the template binding syntax will always use the Angular style, e.g. square\n *       brackets (`[...]`) for property binding.\n * 8. Angular is bootstrapped first; AngularJS is bootstrapped second. AngularJS always owns the\n *    root component of the application.\n * 9. The new application is running in an Angular zone, and therefore it no longer needs calls to\n *    `$apply()`.\n *\n * ### The `UpgradeModule` class\n *\n * This class is an `NgModule`, which you import to provide AngularJS core services,\n * and has an instance method used to bootstrap the hybrid upgrade application.\n *\n * * Core AngularJS services\n *   Importing this `NgModule` will add providers for the core\n *   [AngularJS services](https://docs.angularjs.org/api/ng/service) to the root injector.\n *\n * * Bootstrap\n *   The runtime instance of this class contains a {@link UpgradeModule#bootstrap `bootstrap()`}\n *   method, which you use to bootstrap the top level AngularJS module onto an element in the\n *   DOM for the hybrid upgrade app.\n *\n *   It also contains properties to access the {@link UpgradeModule#injector root injector}, the\n *   bootstrap `NgZone` and the\n *   [AngularJS $injector](https://docs.angularjs.org/api/auto/service/$injector).\n *\n * ### Examples\n *\n * Import the `UpgradeModule` into your top level {@link NgModule Angular `NgModule`}.\n *\n * {@example upgrade/static/ts/full/module.ts region='ng2-module'}\n *\n * Then inject `UpgradeModule` into your Angular `NgModule` and use it to bootstrap the top level\n * [AngularJS module](https://docs.angularjs.org/api/ng/type/angular.Module) in the\n * `ngDoBootstrap()` method.\n *\n * {@example upgrade/static/ts/full/module.ts region='bootstrap-ng1'}\n *\n * Finally, kick off the whole process, by bootstraping your top level Angular `NgModule`.\n *\n * {@example upgrade/static/ts/full/module.ts region='bootstrap-ng2'}\n *\n * {@a upgrading-an-angular-1-service}\n * ### Upgrading an AngularJS service\n *\n * There is no specific API for upgrading an AngularJS service. Instead you should just follow the\n * following recipe:\n *\n * Let's say you have an AngularJS service:\n *\n * {@example upgrade/static/ts/full/module.ts region=\"ng1-text-formatter-service\"}\n *\n * Then you should define an Angular provider to be included in your `NgModule` `providers`\n * property.\n *\n * {@example upgrade/static/ts/full/module.ts region=\"upgrade-ng1-service\"}\n *\n * Then you can use the \"upgraded\" AngularJS service by injecting it into an Angular component\n * or service.\n *\n * {@example upgrade/static/ts/full/module.ts region=\"use-ng1-upgraded-service\"}\n *\n * @publicApi\n */\n@NgModule({providers: [angular1Providers]})\nexport class UpgradeModule {\n  /**\n   * The AngularJS `$injector` for the upgrade application.\n   */\n  public $injector: any /*angular.IInjectorService*/;\n  /** The Angular Injector **/\n  public injector: Injector;\n\n  constructor(\n      /** The root `Injector` for the upgrade application. */\n      injector: Injector,\n      /** The bootstrap zone for the upgrade application */\n      public ngZone: NgZone,\n      /**\n       * The owning `NgModuleRef`s `PlatformRef` instance.\n       * This is used to tie the lifecycle of the bootstrapped AngularJS apps to that of the Angular\n       * `PlatformRef`.\n       */\n      private platformRef: PlatformRef) {\n    this.injector = new NgAdapterInjector(injector);\n  }\n\n  /**\n   * Bootstrap an AngularJS application from this NgModule\n   * @param element the element on which to bootstrap the AngularJS application\n   * @param [modules] the AngularJS modules to bootstrap for this application\n   * @param [config] optional extra AngularJS bootstrap configuration\n   */\n  bootstrap(\n      element: Element, modules: string[] = [], config?: any /*angular.IAngularBootstrapConfig*/) {\n    const INIT_MODULE_NAME = UPGRADE_MODULE_NAME + '.init';\n\n    // Create an ng1 module to bootstrap\n    angularModule(INIT_MODULE_NAME, [])\n\n        .constant(UPGRADE_APP_TYPE_KEY, UpgradeAppType.Static)\n\n        .value(INJECTOR_KEY, this.injector)\n\n        .factory(\n            LAZY_MODULE_REF, [INJECTOR_KEY, (injector: Injector) => ({injector} as LazyModuleRef)])\n\n        .config([\n          $PROVIDE, $INJECTOR,\n          ($provide: IProvideService, $injector: IInjectorService) => {\n            if ($injector.has($$TESTABILITY)) {\n              $provide.decorator($$TESTABILITY, [\n                $DELEGATE,\n                (testabilityDelegate: ITestabilityService) => {\n                  const originalWhenStable: Function = testabilityDelegate.whenStable;\n                  const injector = this.injector;\n                  // Cannot use arrow function below because we need the context\n                  const newWhenStable = function(callback: Function) {\n                    originalWhenStable.call(testabilityDelegate, function() {\n                      const ng2Testability: Testability = injector.get(Testability);\n                      if (ng2Testability.isStable()) {\n                        callback();\n                      } else {\n                        ng2Testability.whenStable(\n                            newWhenStable.bind(testabilityDelegate, callback));\n                      }\n                    });\n                  };\n\n                  testabilityDelegate.whenStable = newWhenStable;\n                  return testabilityDelegate;\n                }\n              ]);\n            }\n\n            if ($injector.has($INTERVAL)) {\n              $provide.decorator($INTERVAL, [\n                $DELEGATE,\n                (intervalDelegate: IIntervalService) => {\n                  // Wrap the $interval service so that setInterval is called outside NgZone,\n                  // but the callback is still invoked within it. This is so that $interval\n                  // won't block stability, which preserves the behavior from AngularJS.\n                  let wrappedInterval =\n                      (fn: Function, delay: number, count?: number, invokeApply?: boolean,\n                       ...pass: any[]) => {\n                        return this.ngZone.runOutsideAngular(() => {\n                          return intervalDelegate((...args: any[]) => {\n                            // Run callback in the next VM turn - $interval calls\n                            // $rootScope.$apply, and running the callback in NgZone will\n                            // cause a '$digest already in progress' error if it's in the\n                            // same vm turn.\n                            setTimeout(() => {\n                              this.ngZone.run(() => fn(...args));\n                            });\n                          }, delay, count, invokeApply, ...pass);\n                        });\n                      };\n\n                  (wrappedInterval as any)['cancel'] = intervalDelegate.cancel;\n                  return wrappedInterval;\n                }\n              ]);\n            }\n          }\n        ])\n\n        .run([\n          $INJECTOR,\n          ($injector: IInjectorService) => {\n            this.$injector = $injector;\n            const $rootScope = $injector.get('$rootScope');\n\n            // Initialize the ng1 $injector provider\n            setTempInjectorRef($injector);\n            this.injector.get($INJECTOR);\n\n            // Put the injector on the DOM, so that it can be \"required\"\n            angularElement(element).data!(controllerKey(INJECTOR_KEY), this.injector);\n\n            // Destroy the AngularJS app once the Angular `PlatformRef` is destroyed.\n            // This does not happen in a typical SPA scenario, but it might be useful for\n            // other use-cases where disposing of an Angular/AngularJS app is necessary\n            // (such as Hot Module Replacement (HMR)).\n            // See https://github.com/angular/angular/issues/39935.\n            this.platformRef.onDestroy(() => destroyApp($injector));\n\n            // Wire up the ng1 rootScope to run a digest cycle whenever the zone settles\n            // We need to do this in the next tick so that we don't prevent the bootup stabilizing\n            setTimeout(() => {\n              const subscription = this.ngZone.onMicrotaskEmpty.subscribe(() => {\n                if ($rootScope.$$phase) {\n                  if (isDevMode()) {\n                    console.warn(\n                        'A digest was triggered while one was already in progress. This may mean that something is triggering digests outside the Angular zone.');\n                  }\n\n                  return $rootScope.$evalAsync();\n                }\n\n                return $rootScope.$digest();\n              });\n              $rootScope.$on('$destroy', () => {\n                subscription.unsubscribe();\n              });\n            }, 0);\n          }\n        ]);\n\n    const upgradeModule = angularModule(UPGRADE_MODULE_NAME, [INIT_MODULE_NAME].concat(modules));\n\n    // Make sure resumeBootstrap() only exists if the current bootstrap is deferred\n    const windowAngular = (window as any)['angular'];\n    windowAngular.resumeBootstrap = undefined;\n\n    // Bootstrap the AngularJS application inside our zone\n    this.ngZone.run(() => {\n      bootstrap(element, [upgradeModule.name], config);\n    });\n\n    // Patch resumeBootstrap() to run inside the ngZone\n    if (windowAngular.resumeBootstrap) {\n      const originalResumeBootstrap: () => void = windowAngular.resumeBootstrap;\n      const ngZone = this.ngZone;\n      windowAngular.resumeBootstrap = function() {\n        let args = arguments;\n        windowAngular.resumeBootstrap = originalResumeBootstrap;\n        return ngZone.run(() => windowAngular.resumeBootstrap.apply(this, args));\n      };\n    }\n  }\n}\n"]}