@angular/core 11.1.0-next.5 → 11.1.2

package/esm2015/src/event_emitter.js

@@ -15,36 +15,36 @@ class EventEmitter_ extends Subject {
     emit(value) {
         super.next(value);
     }
-    subscribe(generatorOrNext, error, complete) {
+    subscribe(observerOrNext, error, complete) {
         let schedulerFn;
         let errorFn = (err) => null;
         let completeFn = () => null;
-        if (generatorOrNext && typeof generatorOrNext === 'object') {
+        if (observerOrNext && typeof observerOrNext === 'object') {
             schedulerFn = this.__isAsync ? (value) => {
-                setTimeout(() => generatorOrNext.next(value));
+                setTimeout(() => observerOrNext.next(value));
             } : (value) => {
-                generatorOrNext.next(value);
+                observerOrNext.next(value);
             };
-            if (generatorOrNext.error) {
+            if (observerOrNext.error) {
                 errorFn = this.__isAsync ? (err) => {
-                    setTimeout(() => generatorOrNext.error(err));
+                    setTimeout(() => observerOrNext.error(err));
                 } : (err) => {
-                    generatorOrNext.error(err);
+                    observerOrNext.error(err);
                 };
             }
-            if (generatorOrNext.complete) {
+            if (observerOrNext.complete) {
                 completeFn = this.__isAsync ? () => {
-                    setTimeout(() => generatorOrNext.complete());
+                    setTimeout(() => observerOrNext.complete());
                 } : () => {
-                    generatorOrNext.complete();
+                    observerOrNext.complete();
                 };
             }
         }
         else {
             schedulerFn = this.__isAsync ? (value) => {
-                setTimeout(() => generatorOrNext(value));
+                setTimeout(() => observerOrNext(value));
             } : (value) => {
-                generatorOrNext(value);
+                observerOrNext(value);
             };
             if (error) {
                 errorFn = this.__isAsync ? (err) => {
@@ -62,8 +62,8 @@ class EventEmitter_ extends Subject {
             }
         }
         const sink = super.subscribe(schedulerFn, errorFn, completeFn);
-        if (generatorOrNext instanceof Subscription) {
-            generatorOrNext.add(sink);
+        if (observerOrNext instanceof Subscription) {
+            observerOrNext.add(sink);
         }
         return sink;
     }
@@ -72,4 +72,4 @@ class EventEmitter_ extends Subject {
  * @publicApi
  */
 export const EventEmitter = EventEmitter_;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_emitter.js","sourceRoot":"","sources":["../../../../../../packages/core/src/event_emitter.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\n/// <reference types=\"rxjs\" />\n\nimport {Subject, Subscription} from 'rxjs';\n\n/**\n * Use in components with the `@Output` directive to emit custom events\n * synchronously or asynchronously, and register handlers for those events\n * by subscribing to an instance.\n *\n * @usageNotes\n *\n * Extends\n * [RxJS `Subject`](https://rxjs.dev/api/index/class/Subject)\n * for Angular by adding the `emit()` method.\n *\n * In the following example, a component defines two output properties\n * that create event emitters. When the title is clicked, the emitter\n * emits an open or close event to toggle the current visibility state.\n *\n * ```html\n * @Component({\n *   selector: 'zippy',\n *   template: `\n *   <div class=\"zippy\">\n *     <div (click)=\"toggle()\">Toggle</div>\n *     <div [hidden]=\"!visible\">\n *       <ng-content></ng-content>\n *     </div>\n *  </div>`})\n * export class Zippy {\n *   visible: boolean = true;\n *   @Output() open: EventEmitter<any> = new EventEmitter();\n *   @Output() close: EventEmitter<any> = new EventEmitter();\n *\n *   toggle() {\n *     this.visible = !this.visible;\n *     if (this.visible) {\n *       this.open.emit(null);\n *     } else {\n *       this.close.emit(null);\n *     }\n *   }\n * }\n * ```\n *\n * Access the event object with the `$event` argument passed to the output event\n * handler:\n *\n * ```html\n * <zippy (open)=\"onOpen($event)\" (close)=\"onClose($event)\"></zippy>\n * ```\n *\n * @see [Observables in Angular](guide/observables-in-angular)\n * @publicApi\n */\nexport interface EventEmitter<T> extends Subject<T> {\n  /**\n   * @internal\n   */\n  __isAsync: boolean;\n\n  /**\n   * Creates an instance of this class that can\n   * deliver events synchronously or asynchronously.\n   *\n   * @param [isAsync=false] When true, deliver events asynchronously.\n   *\n   */\n  new(isAsync?: boolean): EventEmitter<T>;\n\n  /**\n   * Emits an event containing a given value.\n   * @param value The value to emit.\n   */\n  emit(value?: T): void;\n  /**\n   * Registers handlers for events emitted by this instance.\n   * @param generatorOrNext When supplied, a custom handler for emitted events.\n   * @param error When supplied, a custom handler for an error notification\n   * from this emitter.\n   * @param complete When supplied, a custom handler for a completion\n   * notification from this emitter.\n   */\n  subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;\n}\n\nclass EventEmitter_ extends Subject<any> {\n  __isAsync: boolean;  // tslint:disable-line\n\n  constructor(isAsync: boolean = false) {\n    super();\n    this.__isAsync = isAsync;\n  }\n\n  emit(value?: any) {\n    super.next(value);\n  }\n\n  subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription {\n    let schedulerFn: (t: any) => any;\n    let errorFn = (err: any): any => null;\n    let completeFn = (): any => null;\n\n    if (generatorOrNext && typeof generatorOrNext === 'object') {\n      schedulerFn = this.__isAsync ? (value: any) => {\n        setTimeout(() => generatorOrNext.next(value));\n      } : (value: any) => {\n        generatorOrNext.next(value);\n      };\n\n      if (generatorOrNext.error) {\n        errorFn = this.__isAsync ? (err) => {\n          setTimeout(() => generatorOrNext.error(err));\n        } : (err) => {\n          generatorOrNext.error(err);\n        };\n      }\n\n      if (generatorOrNext.complete) {\n        completeFn = this.__isAsync ? () => {\n          setTimeout(() => generatorOrNext.complete());\n        } : () => {\n          generatorOrNext.complete();\n        };\n      }\n    } else {\n      schedulerFn = this.__isAsync ? (value: any) => {\n        setTimeout(() => generatorOrNext(value));\n      } : (value: any) => {\n        generatorOrNext(value);\n      };\n\n      if (error) {\n        errorFn = this.__isAsync ? (err) => {\n          setTimeout(() => error(err));\n        } : (err) => {\n          error(err);\n        };\n      }\n\n      if (complete) {\n        completeFn = this.__isAsync ? () => {\n          setTimeout(() => complete());\n        } : () => {\n          complete();\n        };\n      }\n    }\n\n    const sink = super.subscribe(schedulerFn, errorFn, completeFn);\n\n    if (generatorOrNext instanceof Subscription) {\n      generatorOrNext.add(sink);\n    }\n\n    return sink;\n  }\n}\n\n/**\n * @publicApi\n */\nexport const EventEmitter: {\n  new (isAsync?: boolean): EventEmitter<any>; new<T>(isAsync?: boolean): EventEmitter<T>;\n  readonly prototype: EventEmitter<any>;\n} = EventEmitter_ as any;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_emitter.js","sourceRoot":"","sources":["../../../../../../packages/core/src/event_emitter.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\n/// <reference types=\"rxjs\" />\n\nimport {Subject, Subscription} from 'rxjs';\n\n/**\n * Use in components with the `@Output` directive to emit custom events\n * synchronously or asynchronously, and register handlers for those events\n * by subscribing to an instance.\n *\n * @usageNotes\n *\n * Extends\n * [RxJS `Subject`](https://rxjs.dev/api/index/class/Subject)\n * for Angular by adding the `emit()` method.\n *\n * In the following example, a component defines two output properties\n * that create event emitters. When the title is clicked, the emitter\n * emits an open or close event to toggle the current visibility state.\n *\n * ```html\n * @Component({\n *   selector: 'zippy',\n *   template: `\n *   <div class=\"zippy\">\n *     <div (click)=\"toggle()\">Toggle</div>\n *     <div [hidden]=\"!visible\">\n *       <ng-content></ng-content>\n *     </div>\n *  </div>`})\n * export class Zippy {\n *   visible: boolean = true;\n *   @Output() open: EventEmitter<any> = new EventEmitter();\n *   @Output() close: EventEmitter<any> = new EventEmitter();\n *\n *   toggle() {\n *     this.visible = !this.visible;\n *     if (this.visible) {\n *       this.open.emit(null);\n *     } else {\n *       this.close.emit(null);\n *     }\n *   }\n * }\n * ```\n *\n * Access the event object with the `$event` argument passed to the output event\n * handler:\n *\n * ```html\n * <zippy (open)=\"onOpen($event)\" (close)=\"onClose($event)\"></zippy>\n * ```\n *\n * @see [Observables in Angular](guide/observables-in-angular)\n * @publicApi\n */\nexport interface EventEmitter<T> extends Subject<T> {\n  /**\n   * @internal\n   */\n  __isAsync: boolean;\n\n  /**\n   * Creates an instance of this class that can\n   * deliver events synchronously or asynchronously.\n   *\n   * @param [isAsync=false] When true, deliver events asynchronously.\n   *\n   */\n  new(isAsync?: boolean): EventEmitter<T>;\n\n  /**\n   * Emits an event containing a given value.\n   * @param value The value to emit.\n   */\n  emit(value?: T): void;\n\n  /**\n   * Registers handlers for events emitted by this instance.\n   * @param next When supplied, a custom handler for emitted events.\n   * @param error When supplied, a custom handler for an error notification from this emitter.\n   * @param complete When supplied, a custom handler for a completion notification from this\n   *     emitter.\n   */\n  subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void):\n      Subscription;\n  /**\n   * Registers handlers for events emitted by this instance.\n   * @param observerOrNext When supplied, a custom handler for emitted events, or an observer\n   *     object.\n   * @param error When supplied, a custom handler for an error notification from this emitter.\n   * @param complete When supplied, a custom handler for a completion notification from this\n   *     emitter.\n   */\n  subscribe(observerOrNext?: any, error?: any, complete?: any): Subscription;\n}\n\nclass EventEmitter_ extends Subject<any> {\n  __isAsync: boolean;  // tslint:disable-line\n\n  constructor(isAsync: boolean = false) {\n    super();\n    this.__isAsync = isAsync;\n  }\n\n  emit(value?: any) {\n    super.next(value);\n  }\n\n  subscribe(observerOrNext?: any, error?: any, complete?: any): Subscription {\n    let schedulerFn: (t: any) => any;\n    let errorFn = (err: any): any => null;\n    let completeFn = (): any => null;\n\n    if (observerOrNext && typeof observerOrNext === 'object') {\n      schedulerFn = this.__isAsync ? (value: any) => {\n        setTimeout(() => observerOrNext.next(value));\n      } : (value: any) => {\n        observerOrNext.next(value);\n      };\n\n      if (observerOrNext.error) {\n        errorFn = this.__isAsync ? (err) => {\n          setTimeout(() => observerOrNext.error(err));\n        } : (err) => {\n          observerOrNext.error(err);\n        };\n      }\n\n      if (observerOrNext.complete) {\n        completeFn = this.__isAsync ? () => {\n          setTimeout(() => observerOrNext.complete());\n        } : () => {\n          observerOrNext.complete();\n        };\n      }\n    } else {\n      schedulerFn = this.__isAsync ? (value: any) => {\n        setTimeout(() => observerOrNext(value));\n      } : (value: any) => {\n        observerOrNext(value);\n      };\n\n      if (error) {\n        errorFn = this.__isAsync ? (err) => {\n          setTimeout(() => error(err));\n        } : (err) => {\n          error(err);\n        };\n      }\n\n      if (complete) {\n        completeFn = this.__isAsync ? () => {\n          setTimeout(() => complete());\n        } : () => {\n          complete();\n        };\n      }\n    }\n\n    const sink = super.subscribe(schedulerFn, errorFn, completeFn);\n\n    if (observerOrNext instanceof Subscription) {\n      observerOrNext.add(sink);\n    }\n\n    return sink;\n  }\n}\n\n/**\n * @publicApi\n */\nexport const EventEmitter: {\n  new (isAsync?: boolean): EventEmitter<any>; new<T>(isAsync?: boolean): EventEmitter<T>;\n  readonly prototype: EventEmitter<any>;\n} = EventEmitter_ as any;\n"]}

package/esm2015/src/linker/compiler.js

@@ -12,7 +12,7 @@ import { getComponentDef, getNgModuleDef } from '../render3/definition';
 import { NgModuleFactory as NgModuleFactoryR3 } from '../render3/ng_module_ref';
 import { maybeUnwrapFn } from '../render3/util/misc_utils';
 /**
- * Combination of NgModuleFactory and ComponentFactorys.
+ * Combination of NgModuleFactory and ComponentFactories.
  *
  * @publicApi
  */
@@ -115,4 +115,4 @@ export const COMPILER_OPTIONS = new InjectionToken('compilerOptions');
  */
 export class CompilerFactory {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/compiler.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 {Injectable} from '../di/injectable';\nimport {InjectionToken} from '../di/injection_token';\nimport {StaticProvider} from '../di/interface/provider';\nimport {MissingTranslationStrategy} from '../i18n/tokens';\nimport {Type} from '../interface/type';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {ComponentFactory as ComponentFactoryR3} from '../render3/component_ref';\nimport {getComponentDef, getNgModuleDef} from '../render3/definition';\nimport {NgModuleFactory as NgModuleFactoryR3} from '../render3/ng_module_ref';\nimport {maybeUnwrapFn} from '../render3/util/misc_utils';\n\nimport {ComponentFactory} from './component_factory';\nimport {NgModuleFactory} from './ng_module_factory';\n\n\n\n/**\n * Combination of NgModuleFactory and ComponentFactorys.\n *\n * @publicApi\n */\nexport class ModuleWithComponentFactories<T> {\n  constructor(\n      public ngModuleFactory: NgModuleFactory<T>,\n      public componentFactories: ComponentFactory<any>[]) {}\n}\n\n\nfunction _throwError() {\n  throw new Error(`Runtime compiler is not loaded`);\n}\n\nconst Compiler_compileModuleSync__PRE_R3__: <T>(moduleType: Type<T>) => NgModuleFactory<T> =\n    _throwError as any;\nexport const Compiler_compileModuleSync__POST_R3__: <T>(moduleType: Type<T>) =>\n    NgModuleFactory<T> = function<T>(moduleType: Type<T>): NgModuleFactory<T> {\n  return new NgModuleFactoryR3(moduleType);\n};\nconst Compiler_compileModuleSync = Compiler_compileModuleSync__PRE_R3__;\n\nconst Compiler_compileModuleAsync__PRE_R3__: <T>(moduleType: Type<T>) =>\n    Promise<NgModuleFactory<T>> = _throwError as any;\nexport const Compiler_compileModuleAsync__POST_R3__: <T>(moduleType: Type<T>) =>\n    Promise<NgModuleFactory<T>> = function<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {\n  return Promise.resolve(Compiler_compileModuleSync__POST_R3__(moduleType));\n};\nconst Compiler_compileModuleAsync = Compiler_compileModuleAsync__PRE_R3__;\n\nconst Compiler_compileModuleAndAllComponentsSync__PRE_R3__: <T>(moduleType: Type<T>) =>\n    ModuleWithComponentFactories<T> = _throwError as any;\nexport const Compiler_compileModuleAndAllComponentsSync__POST_R3__: <T>(moduleType: Type<T>) =>\n    ModuleWithComponentFactories<T> = function<T>(moduleType: Type<T>):\n        ModuleWithComponentFactories<T> {\n  const ngModuleFactory = Compiler_compileModuleSync__POST_R3__(moduleType);\n  const moduleDef = getNgModuleDef(moduleType)!;\n  const componentFactories =\n      maybeUnwrapFn(moduleDef.declarations)\n          .reduce((factories: ComponentFactory<any>[], declaration: Type<any>) => {\n            const componentDef = getComponentDef(declaration);\n            componentDef && factories.push(new ComponentFactoryR3(componentDef));\n            return factories;\n          }, [] as ComponentFactory<any>[]);\n  return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n};\nconst Compiler_compileModuleAndAllComponentsSync =\n    Compiler_compileModuleAndAllComponentsSync__PRE_R3__;\n\nconst Compiler_compileModuleAndAllComponentsAsync__PRE_R3__: <T>(moduleType: Type<T>) =>\n    Promise<ModuleWithComponentFactories<T>> = _throwError as any;\nexport const Compiler_compileModuleAndAllComponentsAsync__POST_R3__: <T>(moduleType: Type<T>) =>\n    Promise<ModuleWithComponentFactories<T>> = function<T>(moduleType: Type<T>):\n        Promise<ModuleWithComponentFactories<T>> {\n  return Promise.resolve(Compiler_compileModuleAndAllComponentsSync__POST_R3__(moduleType));\n};\nconst Compiler_compileModuleAndAllComponentsAsync =\n    Compiler_compileModuleAndAllComponentsAsync__PRE_R3__;\n\n/**\n * Low-level service for running the angular compiler during runtime\n * to create {@link ComponentFactory}s, which\n * can later be used to create and render a Component instance.\n *\n * Each `@NgModule` provides an own `Compiler` to its injector,\n * that will use the directives/pipes of the ng module for compilation\n * of components.\n *\n * @publicApi\n */\n@Injectable()\nexport class Compiler {\n  /**\n   * Compiles the given NgModule and all of its components. All templates of the components listed\n   * in `entryComponents` have to be inlined.\n   */\n  compileModuleSync: <T>(moduleType: Type<T>) => NgModuleFactory<T> = Compiler_compileModuleSync;\n\n  /**\n   * Compiles the given NgModule and all of its components\n   */\n  compileModuleAsync:\n      <T>(moduleType: Type<T>) => Promise<NgModuleFactory<T>> = Compiler_compileModuleAsync;\n\n  /**\n   * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsSync: <T>(moduleType: Type<T>) => ModuleWithComponentFactories<T> =\n      Compiler_compileModuleAndAllComponentsSync;\n\n  /**\n   * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsAsync: <T>(moduleType: Type<T>) =>\n      Promise<ModuleWithComponentFactories<T>> = Compiler_compileModuleAndAllComponentsAsync;\n\n  /**\n   * Clears all caches.\n   */\n  clearCache(): void {}\n\n  /**\n   * Clears the cache for the given component/ngModule.\n   */\n  clearCacheFor(type: Type<any>) {}\n\n  /**\n   * Returns the id for a given NgModule, if one is defined and known to the compiler.\n   */\n  getModuleId(moduleType: Type<any>): string|undefined {\n    return undefined;\n  }\n}\n\n/**\n * Options for creating a compiler\n *\n * @publicApi\n */\nexport type CompilerOptions = {\n  useJit?: boolean,\n  defaultEncapsulation?: ViewEncapsulation,\n  providers?: StaticProvider[],\n  missingTranslation?: MissingTranslationStrategy,\n  preserveWhitespaces?: boolean,\n};\n\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @publicApi\n */\nexport const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>('compilerOptions');\n\n/**\n * A factory for creating a Compiler\n *\n * @publicApi\n */\nexport abstract class CompilerFactory {\n  abstract createCompiler(options?: CompilerOptions[]): Compiler;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/compiler.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 {Injectable} from '../di/injectable';\nimport {InjectionToken} from '../di/injection_token';\nimport {StaticProvider} from '../di/interface/provider';\nimport {MissingTranslationStrategy} from '../i18n/tokens';\nimport {Type} from '../interface/type';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {ComponentFactory as ComponentFactoryR3} from '../render3/component_ref';\nimport {getComponentDef, getNgModuleDef} from '../render3/definition';\nimport {NgModuleFactory as NgModuleFactoryR3} from '../render3/ng_module_ref';\nimport {maybeUnwrapFn} from '../render3/util/misc_utils';\n\nimport {ComponentFactory} from './component_factory';\nimport {NgModuleFactory} from './ng_module_factory';\n\n\n\n/**\n * Combination of NgModuleFactory and ComponentFactories.\n *\n * @publicApi\n */\nexport class ModuleWithComponentFactories<T> {\n  constructor(\n      public ngModuleFactory: NgModuleFactory<T>,\n      public componentFactories: ComponentFactory<any>[]) {}\n}\n\n\nfunction _throwError() {\n  throw new Error(`Runtime compiler is not loaded`);\n}\n\nconst Compiler_compileModuleSync__PRE_R3__: <T>(moduleType: Type<T>) => NgModuleFactory<T> =\n    _throwError as any;\nexport const Compiler_compileModuleSync__POST_R3__: <T>(moduleType: Type<T>) =>\n    NgModuleFactory<T> = function<T>(moduleType: Type<T>): NgModuleFactory<T> {\n  return new NgModuleFactoryR3(moduleType);\n};\nconst Compiler_compileModuleSync = Compiler_compileModuleSync__PRE_R3__;\n\nconst Compiler_compileModuleAsync__PRE_R3__: <T>(moduleType: Type<T>) =>\n    Promise<NgModuleFactory<T>> = _throwError as any;\nexport const Compiler_compileModuleAsync__POST_R3__: <T>(moduleType: Type<T>) =>\n    Promise<NgModuleFactory<T>> = function<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {\n  return Promise.resolve(Compiler_compileModuleSync__POST_R3__(moduleType));\n};\nconst Compiler_compileModuleAsync = Compiler_compileModuleAsync__PRE_R3__;\n\nconst Compiler_compileModuleAndAllComponentsSync__PRE_R3__: <T>(moduleType: Type<T>) =>\n    ModuleWithComponentFactories<T> = _throwError as any;\nexport const Compiler_compileModuleAndAllComponentsSync__POST_R3__: <T>(moduleType: Type<T>) =>\n    ModuleWithComponentFactories<T> = function<T>(moduleType: Type<T>):\n        ModuleWithComponentFactories<T> {\n  const ngModuleFactory = Compiler_compileModuleSync__POST_R3__(moduleType);\n  const moduleDef = getNgModuleDef(moduleType)!;\n  const componentFactories =\n      maybeUnwrapFn(moduleDef.declarations)\n          .reduce((factories: ComponentFactory<any>[], declaration: Type<any>) => {\n            const componentDef = getComponentDef(declaration);\n            componentDef && factories.push(new ComponentFactoryR3(componentDef));\n            return factories;\n          }, [] as ComponentFactory<any>[]);\n  return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n};\nconst Compiler_compileModuleAndAllComponentsSync =\n    Compiler_compileModuleAndAllComponentsSync__PRE_R3__;\n\nconst Compiler_compileModuleAndAllComponentsAsync__PRE_R3__: <T>(moduleType: Type<T>) =>\n    Promise<ModuleWithComponentFactories<T>> = _throwError as any;\nexport const Compiler_compileModuleAndAllComponentsAsync__POST_R3__: <T>(moduleType: Type<T>) =>\n    Promise<ModuleWithComponentFactories<T>> = function<T>(moduleType: Type<T>):\n        Promise<ModuleWithComponentFactories<T>> {\n  return Promise.resolve(Compiler_compileModuleAndAllComponentsSync__POST_R3__(moduleType));\n};\nconst Compiler_compileModuleAndAllComponentsAsync =\n    Compiler_compileModuleAndAllComponentsAsync__PRE_R3__;\n\n/**\n * Low-level service for running the angular compiler during runtime\n * to create {@link ComponentFactory}s, which\n * can later be used to create and render a Component instance.\n *\n * Each `@NgModule` provides an own `Compiler` to its injector,\n * that will use the directives/pipes of the ng module for compilation\n * of components.\n *\n * @publicApi\n */\n@Injectable()\nexport class Compiler {\n  /**\n   * Compiles the given NgModule and all of its components. All templates of the components listed\n   * in `entryComponents` have to be inlined.\n   */\n  compileModuleSync: <T>(moduleType: Type<T>) => NgModuleFactory<T> = Compiler_compileModuleSync;\n\n  /**\n   * Compiles the given NgModule and all of its components\n   */\n  compileModuleAsync:\n      <T>(moduleType: Type<T>) => Promise<NgModuleFactory<T>> = Compiler_compileModuleAsync;\n\n  /**\n   * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsSync: <T>(moduleType: Type<T>) => ModuleWithComponentFactories<T> =\n      Compiler_compileModuleAndAllComponentsSync;\n\n  /**\n   * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsAsync: <T>(moduleType: Type<T>) =>\n      Promise<ModuleWithComponentFactories<T>> = Compiler_compileModuleAndAllComponentsAsync;\n\n  /**\n   * Clears all caches.\n   */\n  clearCache(): void {}\n\n  /**\n   * Clears the cache for the given component/ngModule.\n   */\n  clearCacheFor(type: Type<any>) {}\n\n  /**\n   * Returns the id for a given NgModule, if one is defined and known to the compiler.\n   */\n  getModuleId(moduleType: Type<any>): string|undefined {\n    return undefined;\n  }\n}\n\n/**\n * Options for creating a compiler\n *\n * @publicApi\n */\nexport type CompilerOptions = {\n  useJit?: boolean,\n  defaultEncapsulation?: ViewEncapsulation,\n  providers?: StaticProvider[],\n  missingTranslation?: MissingTranslationStrategy,\n  preserveWhitespaces?: boolean,\n};\n\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @publicApi\n */\nexport const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>('compilerOptions');\n\n/**\n * A factory for creating a Compiler\n *\n * @publicApi\n */\nexport abstract class CompilerFactory {\n  abstract createCompiler(options?: CompilerOptions[]): Compiler;\n}\n"]}

package/esm2015/src/linker/element_ref.js

@@ -54,4 +54,13 @@ export class ElementRef {
  * @nocollapse
  */
 ElementRef.__NG_ELEMENT_ID__ = SWITCH_ELEMENT_REF_FACTORY;
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Unwraps `ElementRef` and return the `nativeElement`.
+ *
+ * @param value value to unwrap
+ * @returns `nativeElement` if `ElementRef` otherwise returns value as is.
+ */
+export function unwrapElementRef(value) {
+    return value instanceof ElementRef ? value.nativeElement : value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/linker/query_list.js

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { EventEmitter } from '../event_emitter';
-import { flatten } from '../util/array_utils';
+import { arrayEquals, flatten } from '../util/array_utils';
 import { getSymbolIterator } from '../util/symbol';
 function symbolIterator() {
     return this._results[getSymbolIterator()]();
@@ -38,11 +38,21 @@ function symbolIterator() {
  * @publicApi
  */
 export class QueryList {
-    constructor() {
+    /**
+     * @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change
+     *     has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in
+     *     the same result) This is set to `false` for backwards compatibility but will be changed to
+     *     true in v12.
+     */
+    constructor(_emitDistinctChangesOnly = false) {
+        this._emitDistinctChangesOnly = _emitDistinctChangesOnly;
         this.dirty = true;
         this._results = [];
-        this.changes = new EventEmitter();
+        this._changesDetected = false;
+        this._changes = null;
         this.length = 0;
+        this.first = undefined;
+        this.last = undefined;
         // This function should be declared on the prototype, but doing so there will cause the class
         // declaration to have side-effects and become not tree-shakable. For this reason we do it in
         // the constructor.
@@ -52,6 +62,12 @@ export class QueryList {
         if (!proto[symbol])
             proto[symbol] = symbolIterator;
     }
+    /**
+     * Returns `Observable` of `QueryList` notifying the subscriber of changes.
+     */
+    get changes() {
+        return this._changes || (this._changes = new EventEmitter());
+    }
     /**
      * Returns the QueryList entry at `index`.
      */
@@ -115,19 +131,31 @@ export class QueryList {
      * occurs.
      *
      * @param resultsTree The query results to store
+     * @param identityAccessor Optional function for extracting stable object identity from a value
+     *    in the array. This function is executed for each element of the query result list while
+     *    comparing current query list with the new one (provided as a first argument of the `reset`
+     *    function) to detect if the lists are different. If the function is not provided, elements
+     *    are compared as is (without any pre-processing).
      */
-    reset(resultsTree) {
-        this._results = flatten(resultsTree);
-        this.dirty = false;
-        this.length = this._results.length;
-        this.last = this._results[this.length - 1];
-        this.first = this._results[0];
+    reset(resultsTree, identityAccessor) {
+        // Cast to `QueryListInternal` so that we can mutate fields which are readonly for the usage of
+        // QueryList (but not for QueryList itself.)
+        const self = this;
+        self.dirty = false;
+        const newResultFlat = flatten(resultsTree);
+        if (this._changesDetected = !arrayEquals(self._results, newResultFlat, identityAccessor)) {
+            self._results = newResultFlat;
+            self.length = newResultFlat.length;
+            self.last = newResultFlat[this.length - 1];
+            self.first = newResultFlat[0];
+        }
     }
     /**
      * Triggers a change event by emitting on the `changes` {@link EventEmitter}.
      */
     notifyOnChanges() {
-        this.changes.emit(this);
+        if (this._changes && (this._changesDetected || !this._emitDistinctChangesOnly))
+            this._changes.emit(this);
     }
     /** internal */
     setDirty() {
@@ -139,4 +167,4 @@ export class QueryList {
         this.changes.unsubscribe();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query_list.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/query_list.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 {Observable} from 'rxjs';\n\nimport {EventEmitter} from '../event_emitter';\nimport {flatten} from '../util/array_utils';\nimport {getSymbolIterator} from '../util/symbol';\n\nfunction symbolIterator<T>(this: QueryList<T>): Iterator<T> {\n  return ((this as any as {_results: Array<T>})._results as any)[getSymbolIterator()]();\n}\n\n/**\n * An unmodifiable list of items that Angular keeps up to date when the state\n * of the application changes.\n *\n * The type of object that {@link ViewChildren}, {@link ContentChildren}, and {@link QueryList}\n * provide.\n *\n * Implements an iterable interface, therefore it can be used in both ES6\n * javascript `for (var i of items)` loops as well as in Angular templates with\n * `*ngFor=\"let i of myList\"`.\n *\n * Changes can be observed by subscribing to the changes `Observable`.\n *\n * NOTE: In the future this class will implement an `Observable` interface.\n *\n * @usageNotes\n * ### Example\n * ```typescript\n * @Component({...})\n * class Container {\n *   @ViewChildren(Item) items:QueryList<Item>;\n * }\n * ```\n *\n * @publicApi\n */\nexport class QueryList<T> implements Iterable<T> {\n  public readonly dirty = true;\n  private _results: Array<T> = [];\n  public readonly changes: Observable<any> = new EventEmitter();\n\n  readonly length: number = 0;\n  // TODO(issue/24571): remove '!'.\n  readonly first!: T;\n  // TODO(issue/24571): remove '!'.\n  readonly last!: T;\n\n  constructor() {\n    // This function should be declared on the prototype, but doing so there will cause the class\n    // declaration to have side-effects and become not tree-shakable. For this reason we do it in\n    // the constructor.\n    // [getSymbolIterator()](): Iterator<T> { ... }\n    const symbol = getSymbolIterator();\n    const proto = QueryList.prototype as any;\n    if (!proto[symbol]) proto[symbol] = symbolIterator;\n  }\n\n  /**\n   * Returns the QueryList entry at `index`.\n   */\n  get(index: number): T|undefined {\n    return this._results[index];\n  }\n\n  /**\n   * See\n   * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n   */\n  map<U>(fn: (item: T, index: number, array: T[]) => U): U[] {\n    return this._results.map(fn);\n  }\n\n  /**\n   * See\n   * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n   */\n  filter(fn: (item: T, index: number, array: T[]) => boolean): T[] {\n    return this._results.filter(fn);\n  }\n\n  /**\n   * See\n   * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n   */\n  find(fn: (item: T, index: number, array: T[]) => boolean): T|undefined {\n    return this._results.find(fn);\n  }\n\n  /**\n   * See\n   * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n   */\n  reduce<U>(fn: (prevValue: U, curValue: T, curIndex: number, array: T[]) => U, init: U): U {\n    return this._results.reduce(fn, init);\n  }\n\n  /**\n   * See\n   * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n   */\n  forEach(fn: (item: T, index: number, array: T[]) => void): void {\n    this._results.forEach(fn);\n  }\n\n  /**\n   * See\n   * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n   */\n  some(fn: (value: T, index: number, array: T[]) => boolean): boolean {\n    return this._results.some(fn);\n  }\n\n  /**\n   * Returns a copy of the internal results list as an Array.\n   */\n  toArray(): T[] {\n    return this._results.slice();\n  }\n\n  toString(): string {\n    return this._results.toString();\n  }\n\n  /**\n   * Updates the stored data of the query list, and resets the `dirty` flag to `false`, so that\n   * on change detection, it will not notify of changes to the queries, unless a new change\n   * occurs.\n   *\n   * @param resultsTree The query results to store\n   */\n  reset(resultsTree: Array<T|any[]>): void {\n    this._results = flatten(resultsTree);\n    (this as {dirty: boolean}).dirty = false;\n    (this as {length: number}).length = this._results.length;\n    (this as {last: T}).last = this._results[this.length - 1];\n    (this as {first: T}).first = this._results[0];\n  }\n\n  /**\n   * Triggers a change event by emitting on the `changes` {@link EventEmitter}.\n   */\n  notifyOnChanges(): void {\n    (this.changes as EventEmitter<any>).emit(this);\n  }\n\n  /** internal */\n  setDirty() {\n    (this as {dirty: boolean}).dirty = true;\n  }\n\n  /** internal */\n  destroy(): void {\n    (this.changes as EventEmitter<any>).complete();\n    (this.changes as EventEmitter<any>).unsubscribe();\n  }\n\n  // The implementation of `Symbol.iterator` should be declared here, but this would cause\n  // tree-shaking issues with `QueryList. So instead, it's added in the constructor (see comments\n  // there) and this declaration is left here to ensure that TypeScript considers QueryList to\n  // implement the Iterable interface. This is required for template type-checking of NgFor loops\n  // over QueryLists to work correctly, since QueryList must be assignable to NgIterable.\n  [Symbol.iterator]!: () => Iterator<T>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query_list.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/query_list.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 {Observable} from 'rxjs';\n\nimport {EventEmitter} from '../event_emitter';\nimport {arrayEquals, flatten} from '../util/array_utils';\nimport {getSymbolIterator} from '../util/symbol';\n\nfunction symbolIterator<T>(this: QueryList<T>): Iterator<T> {\n  return ((this as any as {_results: Array<T>})._results as any)[getSymbolIterator()]();\n}\n\n/**\n * An unmodifiable list of items that Angular keeps up to date when the state\n * of the application changes.\n *\n * The type of object that {@link ViewChildren}, {@link ContentChildren}, and {@link QueryList}\n * provide.\n *\n * Implements an iterable interface, therefore it can be used in both ES6\n * javascript `for (var i of items)` loops as well as in Angular templates with\n * `*ngFor=\"let i of myList\"`.\n *\n * Changes can be observed by subscribing to the changes `Observable`.\n *\n * NOTE: In the future this class will implement an `Observable` interface.\n *\n * @usageNotes\n * ### Example\n * ```typescript\n * @Component({...})\n * class Container {\n *   @ViewChildren(Item) items:QueryList<Item>;\n * }\n * ```\n *\n * @publicApi\n */\nexport class QueryList<T> implements Iterable<T> {\n  public readonly dirty = true;\n  private _results: Array<T> = [];\n  private _changesDetected: boolean = false;\n  private _changes: EventEmitter<QueryList<T>>|null = null;\n\n  readonly length: number = 0;\n  readonly first: T = undefined!;\n  readonly last: T = undefined!;\n\n  /**\n   * Returns `Observable` of `QueryList` notifying the subscriber of changes.\n   */\n  get changes(): Observable<any> {\n    return this._changes || (this._changes = new EventEmitter());\n  }\n\n  /**\n   * @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change\n   *     has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in\n   *     the same result) This is set to `false` for backwards compatibility but will be changed to\n   *     true in v12.\n   */\n  constructor(private _emitDistinctChangesOnly: boolean = false) {\n    // This function should be declared on the prototype, but doing so there will cause the class\n    // declaration to have side-effects and become not tree-shakable. For this reason we do it in\n    // the constructor.\n    // [getSymbolIterator()](): Iterator<T> { ... }\n    const symbol = getSymbolIterator();\n    const proto = QueryList.prototype as any;\n    if (!proto[symbol]) proto[symbol] = symbolIterator;\n  }\n\n  /**\n   * Returns the QueryList entry at `index`.\n   */\n  get(index: number): T|undefined {\n    return this._results[index];\n  }\n\n  /**\n   * See\n   * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n   */\n  map<U>(fn: (item: T, index: number, array: T[]) => U): U[] {\n    return this._results.map(fn);\n  }\n\n  /**\n   * See\n   * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n   */\n  filter(fn: (item: T, index: number, array: T[]) => boolean): T[] {\n    return this._results.filter(fn);\n  }\n\n  /**\n   * See\n   * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n   */\n  find(fn: (item: T, index: number, array: T[]) => boolean): T|undefined {\n    return this._results.find(fn);\n  }\n\n  /**\n   * See\n   * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n   */\n  reduce<U>(fn: (prevValue: U, curValue: T, curIndex: number, array: T[]) => U, init: U): U {\n    return this._results.reduce(fn, init);\n  }\n\n  /**\n   * See\n   * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n   */\n  forEach(fn: (item: T, index: number, array: T[]) => void): void {\n    this._results.forEach(fn);\n  }\n\n  /**\n   * See\n   * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n   */\n  some(fn: (value: T, index: number, array: T[]) => boolean): boolean {\n    return this._results.some(fn);\n  }\n\n  /**\n   * Returns a copy of the internal results list as an Array.\n   */\n  toArray(): T[] {\n    return this._results.slice();\n  }\n\n  toString(): string {\n    return this._results.toString();\n  }\n\n  /**\n   * Updates the stored data of the query list, and resets the `dirty` flag to `false`, so that\n   * on change detection, it will not notify of changes to the queries, unless a new change\n   * occurs.\n   *\n   * @param resultsTree The query results to store\n   * @param identityAccessor Optional function for extracting stable object identity from a value\n   *    in the array. This function is executed for each element of the query result list while\n   *    comparing current query list with the new one (provided as a first argument of the `reset`\n   *    function) to detect if the lists are different. If the function is not provided, elements\n   *    are compared as is (without any pre-processing).\n   */\n  reset(resultsTree: Array<T|any[]>, identityAccessor?: (value: T) => unknown): void {\n    // Cast to `QueryListInternal` so that we can mutate fields which are readonly for the usage of\n    // QueryList (but not for QueryList itself.)\n    const self = this as QueryListInternal<T>;\n    (self as {dirty: boolean}).dirty = false;\n    const newResultFlat = flatten(resultsTree);\n    if (this._changesDetected = !arrayEquals(self._results, newResultFlat, identityAccessor)) {\n      self._results = newResultFlat;\n      self.length = newResultFlat.length;\n      self.last = newResultFlat[this.length - 1];\n      self.first = newResultFlat[0];\n    }\n  }\n\n  /**\n   * Triggers a change event by emitting on the `changes` {@link EventEmitter}.\n   */\n  notifyOnChanges(): void {\n    if (this._changes && (this._changesDetected || !this._emitDistinctChangesOnly))\n      this._changes.emit(this);\n  }\n\n  /** internal */\n  setDirty() {\n    (this as {dirty: boolean}).dirty = true;\n  }\n\n  /** internal */\n  destroy(): void {\n    (this.changes as EventEmitter<any>).complete();\n    (this.changes as EventEmitter<any>).unsubscribe();\n  }\n\n  // The implementation of `Symbol.iterator` should be declared here, but this would cause\n  // tree-shaking issues with `QueryList. So instead, it's added in the constructor (see comments\n  // there) and this declaration is left here to ensure that TypeScript considers QueryList to\n  // implement the Iterable interface. This is required for template type-checking of NgFor loops\n  // over QueryLists to work correctly, since QueryList must be assignable to NgIterable.\n  [Symbol.iterator]!: () => Iterator<T>;\n}\n\n/**\n * Internal set of APIs used by the framework. (not to be made public)\n */\ninterface QueryListInternal<T> extends QueryList<T> {\n  reset(a: any[]): void;\n  notifyOnChanges(): void;\n  length: number;\n  last: T;\n  first: T;\n}"]}

package/esm2015/src/metadata/di.js

@@ -45,6 +45,10 @@ import { makePropDecorator } from '../util/decorators';
  * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.
  */
 export const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');
+// Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not
+// explicitly set. This value will be changed to `true` in v12.
+// TODO(misko): switch the default in v12 to `true`. See: packages/compiler/src/core.ts
+export const emitDistinctChangesOnlyDefaultValue = false;
 /**
  * Base class for query metadata.
  *
@@ -57,7 +61,7 @@ export const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryC
  */
 export class Query {
 }
-const ɵ0 = (selector, data = {}) => (Object.assign({ selector, first: false, isViewQuery: false, descendants: false }, data));
+const ɵ0 = (selector, data = {}) => (Object.assign({ selector, first: false, isViewQuery: false, descendants: false, emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue }, data));
 /**
  * ContentChildren decorator and metadata.
  *
@@ -76,7 +80,7 @@ const ɵ1 = (selector, data = {}) => (Object.assign({ selector, first: true, isV
  * @publicApi
  */
 export const ContentChild = makePropDecorator('ContentChild', ɵ1, Query);
-const ɵ2 = (selector, data = {}) => (Object.assign({ selector, first: false, isViewQuery: true, descendants: true }, data));
+const ɵ2 = (selector, data = {}) => (Object.assign({ selector, first: false, isViewQuery: true, descendants: true, emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue }, data));
 /**
  * ViewChildren decorator and metadata.
  *
@@ -93,4 +97,4 @@ const ɵ3 = (selector, data) => (Object.assign({ selector, first: true, isViewQu
  */
 export const ViewChild = makePropDecorator('ViewChild', ɵ3, Query);
 export { ɵ0, ɵ1, ɵ2, ɵ3 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/di.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,cAAc,CAAM,2BAA2B,CAAC,CAAC;AA0DjG;;;;;;;;;GASG;AACH,MAAM,OAAgB,KAAK;CAAG;WAkE1B,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAC/B,iBAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,IAAK,IAAI,EAAE;AAVnF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAA6B,iBAAiB,CACtE,iBAAiB,MAGjB,KAAK,CAAC,CAAC;WA4DP,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAC/B,iBAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAXjF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,MAGd,KAAK,CAAC,CAAC;WAsDP,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAC/B,iBAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AATjF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,MAGd,KAAK,CAAC,CAAC;WAoEP,CAAC,QAAa,EAAE,IAAS,EAAE,EAAE,CACzB,iBAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAThF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAuB,iBAAiB,CAC1D,WAAW,MAGX,KAAK,CAAC,CAAC","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 {InjectionToken} from '../di/injection_token';\nimport {Type} from '../interface/type';\nimport {makePropDecorator} from '../util/decorators';\n\n/**\n * A DI token that you can use to create a virtual [provider](guide/glossary#provider)\n * that will populate the `entryComponents` field of components and NgModules\n * based on its `useValue` property value.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) are added to the `entryComponents` property.\n *\n * @usageNotes\n *\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on a router configuration that refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @publicApi\n * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.\n */\nexport const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken<any>('AnalyzeForEntryComponents');\n\n/**\n * Type of the `Attribute` decorator / constructor function.\n *\n * @publicApi\n */\nexport interface AttributeDecorator {\n  /**\n   * Specifies that a constant attribute value should be injected.\n   *\n   * The directive can inject constant string literals of host element attributes.\n   *\n   * @usageNotes\n   *\n   * Suppose we have an `<input>` element and want to know its `type`.\n   *\n   * ```html\n   * <input type=\"text\">\n   * ```\n   *\n   * A decorator can inject string literal `text` as in the following example.\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n   *\n   * @publicApi\n   */\n  (name: string): any;\n  new(name: string): Attribute;\n}\n\n\n/**\n * Type of the Attribute metadata.\n *\n * @publicApi\n */\nexport interface Attribute {\n  /**\n   * The name of the attribute to be injected into the constructor.\n   */\n  attributeName?: string;\n}\n\n/**\n * Type of the Query metadata.\n *\n * @publicApi\n */\nexport interface Query {\n  descendants: boolean;\n  first: boolean;\n  read: any;\n  isViewQuery: boolean;\n  selector: any;\n  static?: boolean;\n}\n\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n *\n * @publicApi\n */\nexport abstract class Query {}\n\n/**\n * Type of the ContentChildren decorator / constructor function.\n *\n * @see `ContentChildren`.\n * @publicApi\n */\nexport interface ContentChildrenDecorator {\n  /**\n   * Parameter decorator that configures a content query.\n   *\n   * Use to get the `QueryList` of elements or directives from the content DOM.\n   * Any time a child element is added, removed, or moved, the query list will be\n   * updated, and the changes observable of the query list will emit a new value.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * Does not retrieve elements or directives that are in other components' templates,\n   * since a component's template is always a black box to its ancestors.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **descendants** - True to include all descendants, otherwise include only direct children.\n   * * **read** - Used to read a different token from the queried elements.\n   *\n   * @usageNotes\n   *\n   * Here is a simple demonstration of how the `ContentChildren` decorator can be used.\n   *\n   * {@example core/di/ts/contentChildren/content_children_howto.ts region='HowTo'}\n   *\n   * ### Tab-pane example\n   *\n   * Here is a slightly more realistic example that shows how `ContentChildren` decorators\n   * can be used to implement a tab pane component.\n   *\n   * {@example core/di/ts/contentChildren/content_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string,\n   opts?: {descendants?: boolean, read?: any}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {descendants?: boolean, read?: any}): Query;\n}\n\n/**\n * Type of the ContentChildren metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nexport type ContentChildren = Query;\n\n/**\n * ContentChildren decorator and metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nexport const ContentChildren: ContentChildrenDecorator = makePropDecorator(\n    'ContentChildren',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: false, isViewQuery: false, descendants: false, ...data}),\n    Query);\n\n/**\n * Type of the ContentChild decorator / constructor function.\n *\n * @publicApi\n */\nexport interface ContentChildDecorator {\n  /**\n   * Parameter decorator that configures a content query.\n   *\n   * Use to get the first element or the directive matching the selector from the content DOM.\n   * If the content DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * Does not retrieve elements or directives that are in other components' templates,\n   * since a component's template is always a black box to its ancestors.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried element.\n   * * **static** - True to resolve query results before change detection runs,\n   * false to resolve after change detection. Defaults to false.\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string,\n   opts?: {read?: any, static?: boolean}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {read?: any, static?: boolean}): ContentChild;\n}\n\n/**\n * Type of the ContentChild metadata.\n *\n * @publicApi\n */\nexport type ContentChild = Query;\n\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n *\n * @publicApi\n */\nexport const ContentChild: ContentChildDecorator = makePropDecorator(\n    'ContentChild',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: true, isViewQuery: false, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChildren decorator / constructor function.\n *\n * @see `ViewChildren`.\n *\n * @publicApi\n */\nexport interface ViewChildrenDecorator {\n  /**\n   * Parameter decorator that configures a view query.\n   *\n   * Use to get the `QueryList` of elements or directives from the view DOM.\n   * Any time a child element is added, removed, or moved, the query list will be updated,\n   * and the changes observable of the query list will emit a new value.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried elements.\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}\n   *\n   * ### Another example\n   *\n   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string, opts?: {read?: any}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {read?: any}): ViewChildren;\n}\n\n/**\n * Type of the ViewChildren metadata.\n *\n * @publicApi\n */\nexport type ViewChildren = Query;\n\n/**\n * ViewChildren decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const ViewChildren: ViewChildrenDecorator = makePropDecorator(\n    'ViewChildren',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: false, isViewQuery: true, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChild decorator / constructor function.\n *\n * @see `ViewChild`.\n * @publicApi\n */\nexport interface ViewChildDecorator {\n  /**\n   * @description\n   * Property decorator that configures a view query.\n   * The change detector looks for the first element or the directive matching the selector\n   * in the view DOM. If the view DOM changes, and a new child matches the selector,\n   * the property is updated.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried elements.\n   * * **static** - True to resolve query results before change detection runs,\n   * false to resolve after change detection. Defaults to false.\n   *\n   *\n   * The following selectors are supported.\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * A template reference variable as a string (e.g. query `<my-component #cmp></my-component>`\n   * with `@ViewChild('cmp')`)\n   *   * Any provider defined in the child component tree of the current component (e.g.\n   * `@ViewChild(SomeService) someService: SomeService`)\n   *   * Any provider defined through a string token (e.g. `@ViewChild('someToken') someTokenVal:\n   * any`)\n   *   * A `TemplateRef` (e.g. query `<ng-template></ng-template>` with `@ViewChild(TemplateRef)\n   * template;`)\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}\n   *\n   * ### Example 2\n   *\n   * {@example core/di/ts/viewChild/view_child_howto.ts region='HowTo'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string,\n   opts?: {read?: any, static?: boolean}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {read?: any, static?: boolean}): ViewChild;\n}\n\n/**\n * Type of the ViewChild metadata.\n *\n * @publicApi\n */\nexport type ViewChild = Query;\n\n/**\n * ViewChild decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const ViewChild: ViewChildDecorator = makePropDecorator(\n    'ViewChild',\n    (selector: any, data: any) =>\n        ({selector, first: true, isViewQuery: true, descendants: true, ...data}),\n    Query);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/metadata/di.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,cAAc,CAAM,2BAA2B,CAAC,CAAC;AA2DjG,kGAAkG;AAClG,+DAA+D;AAC/D,uFAAuF;AACvF,MAAM,CAAC,MAAM,mCAAmC,GAAG,KAAK,CAAC;AAGzD;;;;;;;;;GASG;AACH,MAAM,OAAgB,KAAK;CAAG;WAuEP,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAAC,iBAClC,QAAQ,EACR,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,KAAK,EAClB,WAAW,EAAE,KAAK,EAClB,uBAAuB,EAAE,mCAAmC,IACzD,IAAI,EACP;AAfzB;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAA6B,iBAAiB,CACtE,iBAAiB,MAQjB,KAAK,CAAC,CAAC;WA4DP,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAC/B,iBAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAXjF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,MAGd,KAAK,CAAC,CAAC;WAyDS,CAAC,QAAc,EAAE,OAAY,EAAE,EAAE,EAAE,CAAC,iBAClC,QAAQ,EACR,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,IAAI,EACjB,WAAW,EAAE,IAAI,EACjB,uBAAuB,EAAE,mCAAmC,IACzD,IAAI,EACP;AAdtB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,iBAAiB,CAChE,cAAc,MAQd,KAAK,CAAC,CAAC;WAoEP,CAAC,QAAa,EAAE,IAAS,EAAE,EAAE,CACzB,iBAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,IAAK,IAAI,EAAE;AAThF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAuB,iBAAiB,CAC1D,WAAW,MAGX,KAAK,CAAC,CAAC","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 {InjectionToken} from '../di/injection_token';\nimport {Type} from '../interface/type';\nimport {makePropDecorator} from '../util/decorators';\n\n/**\n * A DI token that you can use to create a virtual [provider](guide/glossary#provider)\n * that will populate the `entryComponents` field of components and NgModules\n * based on its `useValue` property value.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) are added to the `entryComponents` property.\n *\n * @usageNotes\n *\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on a router configuration that refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @publicApi\n * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.\n */\nexport const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken<any>('AnalyzeForEntryComponents');\n\n/**\n * Type of the `Attribute` decorator / constructor function.\n *\n * @publicApi\n */\nexport interface AttributeDecorator {\n  /**\n   * Specifies that a constant attribute value should be injected.\n   *\n   * The directive can inject constant string literals of host element attributes.\n   *\n   * @usageNotes\n   *\n   * Suppose we have an `<input>` element and want to know its `type`.\n   *\n   * ```html\n   * <input type=\"text\">\n   * ```\n   *\n   * A decorator can inject string literal `text` as in the following example.\n   *\n   * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n   *\n   * @publicApi\n   */\n  (name: string): any;\n  new(name: string): Attribute;\n}\n\n\n/**\n * Type of the Attribute metadata.\n *\n * @publicApi\n */\nexport interface Attribute {\n  /**\n   * The name of the attribute to be injected into the constructor.\n   */\n  attributeName?: string;\n}\n\n/**\n * Type of the Query metadata.\n *\n * @publicApi\n */\nexport interface Query {\n  descendants: boolean;\n  emitDistinctChangesOnly: boolean;\n  first: boolean;\n  read: any;\n  isViewQuery: boolean;\n  selector: any;\n  static?: boolean;\n}\n\n// Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not\n// explicitly set. This value will be changed to `true` in v12.\n// TODO(misko): switch the default in v12 to `true`. See: packages/compiler/src/core.ts\nexport const emitDistinctChangesOnlyDefaultValue = false;\n\n\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n *\n * @publicApi\n */\nexport abstract class Query {}\n\n/**\n * Type of the ContentChildren decorator / constructor function.\n *\n * @see `ContentChildren`.\n * @publicApi\n */\nexport interface ContentChildrenDecorator {\n  /**\n   * Parameter decorator that configures a content query.\n   *\n   * Use to get the `QueryList` of elements or directives from the content DOM.\n   * Any time a child element is added, removed, or moved, the query list will be\n   * updated, and the changes observable of the query list will emit a new value.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * Does not retrieve elements or directives that are in other components' templates,\n   * since a component's template is always a black box to its ancestors.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **descendants** - True to include all descendants, otherwise include only direct children.\n   * * **emitDistinctChangesOnly** - The ` QueryList#changes` observable will emit new values only\n   *   if the QueryList result has changed. The default value will change from `false` to `true` in\n   *   v12. When `false` the `changes` observable might emit even if the QueryList has not changed.\n   * * **read** - Used to read a different token from the queried elements.\n   *\n   * @usageNotes\n   *\n   * Here is a simple demonstration of how the `ContentChildren` decorator can be used.\n   *\n   * {@example core/di/ts/contentChildren/content_children_howto.ts region='HowTo'}\n   *\n   * ### Tab-pane example\n   *\n   * Here is a slightly more realistic example that shows how `ContentChildren` decorators\n   * can be used to implement a tab pane component.\n   *\n   * {@example core/di/ts/contentChildren/content_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string, opts?: {\n    descendants?: boolean,\n    emitDistinctChangesOnly?: boolean,\n    read?: any,\n  }): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {descendants?: boolean, emitDistinctChangesOnly?: boolean, read?: any}): Query;\n}\n\n/**\n * Type of the ContentChildren metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nexport type ContentChildren = Query;\n\n/**\n * ContentChildren decorator and metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nexport const ContentChildren: ContentChildrenDecorator = makePropDecorator(\n    'ContentChildren', (selector?: any, data: any = {}) => ({\n                         selector,\n                         first: false,\n                         isViewQuery: false,\n                         descendants: false,\n                         emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue,\n                         ...data\n                       }),\n    Query);\n\n/**\n * Type of the ContentChild decorator / constructor function.\n *\n * @publicApi\n */\nexport interface ContentChildDecorator {\n  /**\n   * Parameter decorator that configures a content query.\n   *\n   * Use to get the first element or the directive matching the selector from the content DOM.\n   * If the content DOM changes, and a new child matches the selector,\n   * the property will be updated.\n   *\n   * Content queries are set before the `ngAfterContentInit` callback is called.\n   *\n   * Does not retrieve elements or directives that are in other components' templates,\n   * since a component's template is always a black box to its ancestors.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried element.\n   * * **static** - True to resolve query results before change detection runs,\n   * false to resolve after change detection. Defaults to false.\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}\n   *\n   * ### Example\n   *\n   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string,\n   opts?: {read?: any, static?: boolean}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {read?: any, static?: boolean}): ContentChild;\n}\n\n/**\n * Type of the ContentChild metadata.\n *\n * @publicApi\n */\nexport type ContentChild = Query;\n\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n *\n * @publicApi\n */\nexport const ContentChild: ContentChildDecorator = makePropDecorator(\n    'ContentChild',\n    (selector?: any, data: any = {}) =>\n        ({selector, first: true, isViewQuery: false, descendants: true, ...data}),\n    Query);\n\n/**\n * Type of the ViewChildren decorator / constructor function.\n *\n * @see `ViewChildren`.\n *\n * @publicApi\n */\nexport interface ViewChildrenDecorator {\n  /**\n   * Parameter decorator that configures a view query.\n   *\n   * Use to get the `QueryList` of elements or directives from the view DOM.\n   * Any time a child element is added, removed, or moved, the query list will be updated,\n   * and the changes observable of the query list will emit a new value.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried elements.\n   * * **emitDistinctChangesOnly** - The ` QueryList#changes` observable will emit new values only\n   *   if the QueryList result has changed. The default value will change from `false` to `true` in\n   *   v12. When `false` the `changes` observable might emit even if the QueryList has not changed.\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}\n   *\n   * ### Another example\n   *\n   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string,\n   opts?: {read?: any, emitDistinctChangesOnly?: boolean}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {read?: any, emitDistinctChangesOnly?: boolean}): ViewChildren;\n}\n\n/**\n * Type of the ViewChildren metadata.\n *\n * @publicApi\n */\nexport type ViewChildren = Query;\n\n/**\n * ViewChildren decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const ViewChildren: ViewChildrenDecorator = makePropDecorator(\n    'ViewChildren', (selector?: any, data: any = {}) => ({\n                      selector,\n                      first: false,\n                      isViewQuery: true,\n                      descendants: true,\n                      emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue,\n                      ...data\n                    }),\n    Query);\n\n/**\n * Type of the ViewChild decorator / constructor function.\n *\n * @see `ViewChild`.\n * @publicApi\n */\nexport interface ViewChildDecorator {\n  /**\n   * @description\n   * Property decorator that configures a view query.\n   * The change detector looks for the first element or the directive matching the selector\n   * in the view DOM. If the view DOM changes, and a new child matches the selector,\n   * the property is updated.\n   *\n   * View queries are set before the `ngAfterViewInit` callback is called.\n   *\n   * **Metadata Properties**:\n   *\n   * * **selector** - The directive type or the name used for querying.\n   * * **read** - Used to read a different token from the queried elements.\n   * * **static** - True to resolve query results before change detection runs,\n   * false to resolve after change detection. Defaults to false.\n   *\n   *\n   * The following selectors are supported.\n   *   * Any class with the `@Component` or `@Directive` decorator\n   *   * A template reference variable as a string (e.g. query `<my-component #cmp></my-component>`\n   * with `@ViewChild('cmp')`)\n   *   * Any provider defined in the child component tree of the current component (e.g.\n   * `@ViewChild(SomeService) someService: SomeService`)\n   *   * Any provider defined through a string token (e.g. `@ViewChild('someToken') someTokenVal:\n   * any`)\n   *   * A `TemplateRef` (e.g. query `<ng-template></ng-template>` with `@ViewChild(TemplateRef)\n   * template;`)\n   *\n   * @usageNotes\n   *\n   * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}\n   *\n   * ### Example 2\n   *\n   * {@example core/di/ts/viewChild/view_child_howto.ts region='HowTo'}\n   *\n   * @Annotation\n   */\n  (selector: Type<any>|InjectionToken<unknown>|Function|string,\n   opts?: {read?: any, static?: boolean}): any;\n  new(selector: Type<any>|InjectionToken<unknown>|Function|string,\n      opts?: {read?: any, static?: boolean}): ViewChild;\n}\n\n/**\n * Type of the ViewChild metadata.\n *\n * @publicApi\n */\nexport type ViewChild = Query;\n\n/**\n * ViewChild decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nexport const ViewChild: ViewChildDecorator = makePropDecorator(\n    'ViewChild',\n    (selector: any, data: any) =>\n        ({selector, first: true, isViewQuery: true, descendants: true, ...data}),\n    Query);\n"]}

package/esm2015/src/metadata/view.js

@@ -37,9 +37,9 @@ export var ViewEncapsulation;
      * Use Shadow DOM to encapsulate styles.
      *
      * For the DOM this means using modern [Shadow
-     * DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
+     * DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM) and
      * creating a ShadowRoot for Component's Host Element.
      */
     ViewEncapsulation[ViewEncapsulation["ShadowDom"] = 3] = "ShadowDom";
 })(ViewEncapsulation || (ViewEncapsulation = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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