@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/esm2020/core.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvY29yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/src/application_init.mjs

@@ -0,0 +1,140 @@
+import { Inject, Injectable, InjectionToken, Optional } from './di';
+import { isObservable, isPromise } from './util/lang';
+import { noop } from './util/noop';
+import * as i0 from "./r3_symbols";
+/**
+ * A [DI token](guide/glossary#di-token "DI token definition") that you can use to provide
+ * one or more initialization functions.
+ *
+ * The provided functions are injected at application startup and executed during
+ * app initialization. If any of these functions returns a Promise or an Observable, initialization
+ * does not complete until the Promise is resolved or the Observable is completed.
+ *
+ * You can, for example, create a factory function that loads language data
+ * or an external configuration, and provide that function to the `APP_INITIALIZER` token.
+ * The function is executed during the application bootstrap process,
+ * and the needed data is available on startup.
+ *
+ * @see `ApplicationInitStatus`
+ *
+ * @usageNotes
+ *
+ * The following example illustrates how to configure a multi-provider using `APP_INITIALIZER` token
+ * and a function returning a promise.
+ *
+ * ```
+ *  function initializeApp(): Promise<any> {
+ *    return new Promise((resolve, reject) => {
+ *      // Do some asynchronous stuff
+ *      resolve();
+ *    });
+ *  }
+ *
+ *  @NgModule({
+ *   imports: [BrowserModule],
+ *   declarations: [AppComponent],
+ *   bootstrap: [AppComponent],
+ *   providers: [{
+ *     provide: APP_INITIALIZER,
+ *     useFactory: () => initializeApp,
+ *     multi: true
+ *    }]
+ *   })
+ *  export class AppModule {}
+ * ```
+ *
+ * It's also possible to configure a multi-provider using `APP_INITIALIZER` token and a function
+ * returning an observable, see an example below. Note: the `HttpClient` in this example is used for
+ * demo purposes to illustrate how the factory function can work with other providers available
+ * through DI.
+ *
+ * ```
+ *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
+ *   return () => httpClient.get("https://someUrl.com/api/user")
+ *     .pipe(
+ *        tap(user => { ... })
+ *     );
+ *  }
+ *
+ *  @NgModule({
+ *    imports: [BrowserModule, HttpClientModule],
+ *    declarations: [AppComponent],
+ *    bootstrap: [AppComponent],
+ *    providers: [{
+ *      provide: APP_INITIALIZER,
+ *      useFactory: initializeAppFactory,
+ *      deps: [HttpClient],
+ *      multi: true
+ *    }]
+ *  })
+ *  export class AppModule {}
+ * ```
+ *
+ * @publicApi
+ */
+export const APP_INITIALIZER = new InjectionToken('Application Initializer');
+/**
+ * A class that reflects the state of running {@link APP_INITIALIZER} functions.
+ *
+ * @publicApi
+ */
+export class ApplicationInitStatus {
+    constructor(appInits) {
+        this.appInits = appInits;
+        this.resolve = noop;
+        this.reject = noop;
+        this.initialized = false;
+        this.done = false;
+        this.donePromise = new Promise((res, rej) => {
+            this.resolve = res;
+            this.reject = rej;
+        });
+    }
+    /** @internal */
+    runInitializers() {
+        if (this.initialized) {
+            return;
+        }
+        const asyncInitPromises = [];
+        const complete = () => {
+            this.done = true;
+            this.resolve();
+        };
+        if (this.appInits) {
+            for (let i = 0; i < this.appInits.length; i++) {
+                const initResult = this.appInits[i]();
+                if (isPromise(initResult)) {
+                    asyncInitPromises.push(initResult);
+                }
+                else if (isObservable(initResult)) {
+                    const observableAsPromise = new Promise((resolve, reject) => {
+                        initResult.subscribe({ complete: resolve, error: reject });
+                    });
+                    asyncInitPromises.push(observableAsPromise);
+                }
+            }
+        }
+        Promise.all(asyncInitPromises)
+            .then(() => {
+            complete();
+        })
+            .catch(e => {
+            this.reject(e);
+        });
+        if (asyncInitPromises.length === 0) {
+            complete();
+        }
+        this.initialized = true;
+    }
+}
+ApplicationInitStatus.ɵfac = function ApplicationInitStatus_Factory(t) { return new (t || ApplicationInitStatus)(i0.ɵɵinject(APP_INITIALIZER, 8)); };
+ApplicationInitStatus.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ApplicationInitStatus, factory: ApplicationInitStatus.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(ApplicationInitStatus, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [APP_INITIALIZER]
+            }, {
+                type: Optional
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application_init.js","sourceRoot":"","sources":["../../../../../../packages/core/src/application_init.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAC,MAAM,MAAM,CAAC;AAClE,OAAO,EAAC,YAAY,EAAE,SAAS,EAAC,MAAM,aAAa,CAAC;AACpD,OAAO,EAAC,IAAI,EAAC,MAAM,aAAa,CAAC;;AAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,MAAM,CAAC,MAAM,eAAe,GACxB,IAAI,cAAc,CACd,yBAAyB,CAAC,CAAC;AAEnC;;;;GAIG;AAEH,MAAM,OAAO,qBAAqB;IAOhC,YAAkE,QACc;QADd,aAAQ,GAAR,QAAQ,CACM;QAPxE,YAAO,GAAG,IAAI,CAAC;QACf,WAAM,GAAG,IAAI,CAAC;QACd,gBAAW,GAAG,KAAK,CAAC;QAEZ,SAAI,GAAG,KAAK,CAAC;QAI3B,IAAI,CAAC,WAAW,GAAG,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YAC1C,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;YACnB,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QACpB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,eAAe;QACb,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO;SACR;QAED,MAAM,iBAAiB,GAAmB,EAAE,CAAC;QAE7C,MAAM,QAAQ,GAAG,GAAG,EAAE;YACnB,IAAwB,CAAC,IAAI,GAAG,IAAI,CAAC;YACtC,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;gBACtC,IAAI,SAAS,CAAC,UAAU,CAAC,EAAE;oBACzB,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;iBACpC;qBAAM,IAAI,YAAY,CAAC,UAAU,CAAC,EAAE;oBACnC,MAAM,mBAAmB,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;wBAChE,UAAU,CAAC,SAAS,CAAC,EAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAC,CAAC,CAAC;oBAC3D,CAAC,CAAC,CAAC;oBACH,iBAAiB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;iBAC7C;aACF;SACF;QAED,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;aACzB,IAAI,CAAC,GAAG,EAAE;YACT,QAAQ,EAAE,CAAC;QACb,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,CAAC,EAAE;YACT,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,CAAC;QAEP,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE;YAClC,QAAQ,EAAE,CAAC;SACZ;QACD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;;0FAtDU,qBAAqB,cAOZ,eAAe;2EAPxB,qBAAqB,WAArB,qBAAqB;sFAArB,qBAAqB;cADjC,UAAU;;sBAQI,MAAM;uBAAC,eAAe;;sBAAG,QAAQ","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 {Observable} from 'rxjs';\nimport {Inject, Injectable, InjectionToken, Optional} from './di';\nimport {isObservable, isPromise} from './util/lang';\nimport {noop} from './util/noop';\n\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") that you can use to provide\n * one or more initialization functions.\n *\n * The provided functions are injected at application startup and executed during\n * app initialization. If any of these functions returns a Promise or an Observable, initialization\n * does not complete until the Promise is resolved or the Observable is completed.\n *\n * You can, for example, create a factory function that loads language data\n * or an external configuration, and provide that function to the `APP_INITIALIZER` token.\n * The function is executed during the application bootstrap process,\n * and the needed data is available on startup.\n *\n * @see `ApplicationInitStatus`\n *\n * @usageNotes\n *\n * The following example illustrates how to configure a multi-provider using `APP_INITIALIZER` token\n * and a function returning a promise.\n *\n * ```\n *  function initializeApp(): Promise<any> {\n *    return new Promise((resolve, reject) => {\n *      // Do some asynchronous stuff\n *      resolve();\n *    });\n *  }\n *\n *  @NgModule({\n *   imports: [BrowserModule],\n *   declarations: [AppComponent],\n *   bootstrap: [AppComponent],\n *   providers: [{\n *     provide: APP_INITIALIZER,\n *     useFactory: () => initializeApp,\n *     multi: true\n *    }]\n *   })\n *  export class AppModule {}\n * ```\n *\n * It's also possible to configure a multi-provider using `APP_INITIALIZER` token and a function\n * returning an observable, see an example below. Note: the `HttpClient` in this example is used for\n * demo purposes to illustrate how the factory function can work with other providers available\n * through DI.\n *\n * ```\n *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {\n *   return () => httpClient.get(\"https://someUrl.com/api/user\")\n *     .pipe(\n *        tap(user => { ... })\n *     );\n *  }\n *\n *  @NgModule({\n *    imports: [BrowserModule, HttpClientModule],\n *    declarations: [AppComponent],\n *    bootstrap: [AppComponent],\n *    providers: [{\n *      provide: APP_INITIALIZER,\n *      useFactory: initializeAppFactory,\n *      deps: [HttpClient],\n *      multi: true\n *    }]\n *  })\n *  export class AppModule {}\n * ```\n *\n * @publicApi\n */\nexport const APP_INITIALIZER =\n    new InjectionToken<ReadonlyArray<() => Observable<unknown>| Promise<unknown>| void>>(\n        'Application Initializer');\n\n/**\n * A class that reflects the state of running {@link APP_INITIALIZER} functions.\n *\n * @publicApi\n */\n@Injectable()\nexport class ApplicationInitStatus {\n  private resolve = noop;\n  private reject = noop;\n  private initialized = false;\n  public readonly donePromise: Promise<any>;\n  public readonly done = false;\n\n  constructor(@Inject(APP_INITIALIZER) @Optional() private readonly appInits:\n                  ReadonlyArray<() => Observable<unknown>| Promise<unknown>| void>) {\n    this.donePromise = new Promise((res, rej) => {\n      this.resolve = res;\n      this.reject = rej;\n    });\n  }\n\n  /** @internal */\n  runInitializers() {\n    if (this.initialized) {\n      return;\n    }\n\n    const asyncInitPromises: Promise<any>[] = [];\n\n    const complete = () => {\n      (this as {done: boolean}).done = true;\n      this.resolve();\n    };\n\n    if (this.appInits) {\n      for (let i = 0; i < this.appInits.length; i++) {\n        const initResult = this.appInits[i]();\n        if (isPromise(initResult)) {\n          asyncInitPromises.push(initResult);\n        } else if (isObservable(initResult)) {\n          const observableAsPromise = new Promise<void>((resolve, reject) => {\n            initResult.subscribe({complete: resolve, error: reject});\n          });\n          asyncInitPromises.push(observableAsPromise);\n        }\n      }\n    }\n\n    Promise.all(asyncInitPromises)\n        .then(() => {\n          complete();\n        })\n        .catch(e => {\n          this.reject(e);\n        });\n\n    if (asyncInitPromises.length === 0) {\n      complete();\n    }\n    this.initialized = true;\n  }\n}\n"]}

package/esm2020/src/application_module.mjs

@@ -0,0 +1,135 @@
+/**
+ * @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 { APP_INITIALIZER, ApplicationInitStatus } from './application_init';
+import { ApplicationRef } from './application_ref';
+import { APP_ID_RANDOM_PROVIDER } from './application_tokens';
+import { defaultIterableDiffers, defaultKeyValueDiffers, IterableDiffers, KeyValueDiffers } from './change_detection/change_detection';
+import { Injector } from './di';
+import { Inject, Optional, SkipSelf } from './di/metadata';
+import { ErrorHandler } from './error_handler';
+import { DEFAULT_LOCALE_ID, USD_CURRENCY_CODE } from './i18n/localization';
+import { DEFAULT_CURRENCY_CODE, LOCALE_ID } from './i18n/tokens';
+import { ivyEnabled } from './ivy_switch';
+import { ComponentFactoryResolver } from './linker';
+import { Compiler } from './linker/compiler';
+import { NgModule } from './metadata';
+import { SCHEDULER } from './render3/component_ref';
+import { setLocaleId } from './render3/i18n/i18n_locale_id';
+import { NgZone } from './zone';
+import * as i0 from "./r3_symbols";
+import * as i1 from "./application_ref";
+export function _iterableDiffersFactory() {
+    return defaultIterableDiffers;
+}
+export function _keyValueDiffersFactory() {
+    return defaultKeyValueDiffers;
+}
+export function _localeFactory(locale) {
+    locale = locale || getGlobalLocale();
+    if (ivyEnabled) {
+        setLocaleId(locale);
+    }
+    return locale;
+}
+/**
+ * Work out the locale from the potential global properties.
+ *
+ * * Closure Compiler: use `goog.getLocale()`.
+ * * Ivy enabled: use `$localize.locale`
+ */
+export function getGlobalLocale() {
+    if (typeof ngI18nClosureMode !== 'undefined' && ngI18nClosureMode &&
+        typeof goog !== 'undefined' && goog.getLocale() !== 'en') {
+        // * The default `goog.getLocale()` value is `en`, while Angular used `en-US`.
+        // * In order to preserve backwards compatibility, we use Angular default value over
+        //   Closure Compiler's one.
+        return goog.getLocale();
+    }
+    else {
+        // KEEP `typeof $localize !== 'undefined' && $localize.locale` IN SYNC WITH THE LOCALIZE
+        // COMPILE-TIME INLINER.
+        //
+        // * During compile time inlining of translations the expression will be replaced
+        //   with a string literal that is the current locale. Other forms of this expression are not
+        //   guaranteed to be replaced.
+        //
+        // * During runtime translation evaluation, the developer is required to set `$localize.locale`
+        //   if required, or just to provide their own `LOCALE_ID` provider.
+        return (ivyEnabled && typeof $localize !== 'undefined' && $localize.locale) ||
+            DEFAULT_LOCALE_ID;
+    }
+}
+/**
+ * A built-in [dependency injection token](guide/glossary#di-token)
+ * that is used to configure the root injector for bootstrapping.
+ */
+export const APPLICATION_MODULE_PROVIDERS = [
+    {
+        provide: ApplicationRef,
+        useClass: ApplicationRef,
+        deps: [NgZone, Injector, ErrorHandler, ComponentFactoryResolver, ApplicationInitStatus]
+    },
+    { provide: SCHEDULER, deps: [NgZone], useFactory: zoneSchedulerFactory },
+    {
+        provide: ApplicationInitStatus,
+        useClass: ApplicationInitStatus,
+        deps: [[new Optional(), APP_INITIALIZER]]
+    },
+    { provide: Compiler, useClass: Compiler, deps: [] },
+    APP_ID_RANDOM_PROVIDER,
+    { provide: IterableDiffers, useFactory: _iterableDiffersFactory, deps: [] },
+    { provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory, deps: [] },
+    {
+        provide: LOCALE_ID,
+        useFactory: _localeFactory,
+        deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]
+    },
+    { provide: DEFAULT_CURRENCY_CODE, useValue: USD_CURRENCY_CODE },
+];
+/**
+ * Schedule work at next available slot.
+ *
+ * In Ivy this is just `requestAnimationFrame`. For compatibility reasons when bootstrapped
+ * using `platformRef.bootstrap` we need to use `NgZone.onStable` as the scheduling mechanism.
+ * This overrides the scheduling mechanism in Ivy to `NgZone.onStable`.
+ *
+ * @param ngZone NgZone to use for scheduling.
+ */
+export function zoneSchedulerFactory(ngZone) {
+    let queue = [];
+    ngZone.onStable.subscribe(() => {
+        while (queue.length) {
+            queue.pop()();
+        }
+    });
+    return function (fn) {
+        queue.push(fn);
+    };
+}
+/**
+ * Configures the root injector for an app with
+ * providers of `@angular/core` dependencies that `ApplicationRef` needs
+ * to bootstrap components.
+ *
+ * Re-exported by `BrowserModule`, which is included automatically in the root
+ * `AppModule` when you create a new app with the CLI `new` command.
+ *
+ * @publicApi
+ */
+export class ApplicationModule {
+    // Inject ApplicationRef to make it eager...
+    constructor(appRef) { }
+}
+ApplicationModule.ɵfac = function ApplicationModule_Factory(t) { return new (t || ApplicationModule)(i0.ɵɵinject(i1.ApplicationRef)); };
+ApplicationModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ApplicationModule });
+ApplicationModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: APPLICATION_MODULE_PROVIDERS });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(ApplicationModule, [{
+        type: NgModule,
+        args: [{ providers: APPLICATION_MODULE_PROVIDERS }]
+    }], function () { return [{ type: i1.ApplicationRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application_module.js","sourceRoot":"","sources":["../../../../../../packages/core/src/application_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 {APP_INITIALIZER, ApplicationInitStatus} from './application_init';\nimport {ApplicationRef} from './application_ref';\nimport {APP_ID_RANDOM_PROVIDER} from './application_tokens';\nimport {defaultIterableDiffers, defaultKeyValueDiffers, IterableDiffers, KeyValueDiffers} from './change_detection/change_detection';\nimport {Injector, StaticProvider} from './di';\nimport {Inject, Optional, SkipSelf} from './di/metadata';\nimport {ErrorHandler} from './error_handler';\nimport {DEFAULT_LOCALE_ID, USD_CURRENCY_CODE} from './i18n/localization';\nimport {DEFAULT_CURRENCY_CODE, LOCALE_ID} from './i18n/tokens';\nimport {ivyEnabled} from './ivy_switch';\nimport {ComponentFactoryResolver} from './linker';\nimport {Compiler} from './linker/compiler';\nimport {NgModule} from './metadata';\nimport {SCHEDULER} from './render3/component_ref';\nimport {setLocaleId} from './render3/i18n/i18n_locale_id';\nimport {NgZone} from './zone';\n\ndeclare const $localize: {locale?: string};\n\nexport function _iterableDiffersFactory() {\n  return defaultIterableDiffers;\n}\n\nexport function _keyValueDiffersFactory() {\n  return defaultKeyValueDiffers;\n}\n\nexport function _localeFactory(locale?: string): string {\n  locale = locale || getGlobalLocale();\n  if (ivyEnabled) {\n    setLocaleId(locale);\n  }\n  return locale;\n}\n\n/**\n * Work out the locale from the potential global properties.\n *\n * * Closure Compiler: use `goog.getLocale()`.\n * * Ivy enabled: use `$localize.locale`\n */\nexport function getGlobalLocale(): string {\n  if (typeof ngI18nClosureMode !== 'undefined' && ngI18nClosureMode &&\n      typeof goog !== 'undefined' && goog.getLocale() !== 'en') {\n    // * The default `goog.getLocale()` value is `en`, while Angular used `en-US`.\n    // * In order to preserve backwards compatibility, we use Angular default value over\n    //   Closure Compiler's one.\n    return goog.getLocale();\n  } else {\n    // KEEP `typeof $localize !== 'undefined' && $localize.locale` IN SYNC WITH THE LOCALIZE\n    // COMPILE-TIME INLINER.\n    //\n    // * During compile time inlining of translations the expression will be replaced\n    //   with a string literal that is the current locale. Other forms of this expression are not\n    //   guaranteed to be replaced.\n    //\n    // * During runtime translation evaluation, the developer is required to set `$localize.locale`\n    //   if required, or just to provide their own `LOCALE_ID` provider.\n    return (ivyEnabled && typeof $localize !== 'undefined' && $localize.locale) ||\n        DEFAULT_LOCALE_ID;\n  }\n}\n\n/**\n * A built-in [dependency injection token](guide/glossary#di-token)\n * that is used to configure the root injector for bootstrapping.\n */\nexport const APPLICATION_MODULE_PROVIDERS: StaticProvider[] = [\n  {\n    provide: ApplicationRef,\n    useClass: ApplicationRef,\n    deps: [NgZone, Injector, ErrorHandler, ComponentFactoryResolver, ApplicationInitStatus]\n  },\n  {provide: SCHEDULER, deps: [NgZone], useFactory: zoneSchedulerFactory},\n  {\n    provide: ApplicationInitStatus,\n    useClass: ApplicationInitStatus,\n    deps: [[new Optional(), APP_INITIALIZER]]\n  },\n  {provide: Compiler, useClass: Compiler, deps: []},\n  APP_ID_RANDOM_PROVIDER,\n  {provide: IterableDiffers, useFactory: _iterableDiffersFactory, deps: []},\n  {provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory, deps: []},\n  {\n    provide: LOCALE_ID,\n    useFactory: _localeFactory,\n    deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]\n  },\n  {provide: DEFAULT_CURRENCY_CODE, useValue: USD_CURRENCY_CODE},\n];\n\n/**\n * Schedule work at next available slot.\n *\n * In Ivy this is just `requestAnimationFrame`. For compatibility reasons when bootstrapped\n * using `platformRef.bootstrap` we need to use `NgZone.onStable` as the scheduling mechanism.\n * This overrides the scheduling mechanism in Ivy to `NgZone.onStable`.\n *\n * @param ngZone NgZone to use for scheduling.\n */\nexport function zoneSchedulerFactory(ngZone: NgZone): (fn: () => void) => void {\n  let queue: (() => void)[] = [];\n  ngZone.onStable.subscribe(() => {\n    while (queue.length) {\n      queue.pop()!();\n    }\n  });\n  return function(fn: () => void) {\n    queue.push(fn);\n  };\n}\n\n/**\n * Configures the root injector for an app with\n * providers of `@angular/core` dependencies that `ApplicationRef` needs\n * to bootstrap components.\n *\n * Re-exported by `BrowserModule`, which is included automatically in the root\n * `AppModule` when you create a new app with the CLI `new` command.\n *\n * @publicApi\n */\n@NgModule({providers: APPLICATION_MODULE_PROVIDERS})\nexport class ApplicationModule {\n  // Inject ApplicationRef to make it eager...\n  constructor(appRef: ApplicationRef) {}\n}\n"]}