@angular/core 6.0.3 → 6.0.7

package/bundles/core.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v6.0.3
+ * @license Angular v6.0.7
  * (c) 2010-2018 Google, Inc. https://angular.io/
  * License: MIT
  */
@@ -179,16 +179,14 @@ function defineInjector(options) {
  * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
  * mentioned above, `'root'` is the default value for `providedIn`.
  *
- * ### Example
- *
- * #### Tree-shakeable InjectionToken
- *
- * {@example core/di/ts/injector_spec.ts region='ShakeableInjectionToken'}
- *
- * #### Plain InjectionToken
+ * @usageNotes
+ * ### Basic Example
  *
  * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
  *
+ * ### Tree-shakeable Example
+ *
+ * {@example core/di/ts/injector_spec.ts region='ShakeableInjectionToken'}
  *
  */
 var InjectionToken = /** @class */ (function () {
@@ -353,6 +351,7 @@ function makePropDecorator(name, props, parentClass) {
  * All components that are referenced in the `useValue` value (either directly
  * or in a nested array or map) will be added to the `entryComponents` property.
  *
+ * @usageNotes
  * ### Example
  * The following example shows how the router can populate the `entryComponents`
  * field of an NgModule based on the router configuration which refers
@@ -385,17 +384,16 @@ var ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents
 /**
  * Attribute decorator and metadata.
  *
- *
  * @Annotation
  */
 var Attribute = makeParamDecorator('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });
 /**
  * Base class for query metadata.
  *
- * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for
- * more information.
- *
- *
+ * @see `ContentChildren`.
+ * @see `ContentChild`.
+ * @see `ViewChildren`.
+ * @see `ViewChild`.
  */
 var Query = /** @class */ (function () {
     function Query() {
@@ -425,7 +423,6 @@ var ContentChild = makePropDecorator('ContentChild', function (selector, data) {
 /**
  * ViewChildren decorator and metadata.
  *
- *
  * @Annotation
  */
 var ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {
@@ -435,7 +432,6 @@ var ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {
 /**
  * ViewChild decorator and metadata.
  *
- *
  * @Annotation
  */
 var ViewChild = makePropDecorator('ViewChild', function (selector, data) {
@@ -449,29 +445,12 @@ var ViewChild = makePropDecorator('ViewChild', function (selector, data) {
  * 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
  */
-/**
- * @license
- * Copyright Google Inc. 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
- */
-/**
- * Describes within the change detector which strategy will be used the next time change
- * detection is triggered.
- *
- */
 /**
  * Describes within the change detector which strategy will be used the next time change
  * detection is triggered.
  *
  */
 
-/**
- * Describes within the change detector which strategy will be used the next time change
- * detection is triggered.
- *
- */
 (function (ChangeDetectionStrategy) {
     /**
      * `OnPush` means that the change detector's mode will be initially set to `CheckOnce`.
@@ -485,13 +464,7 @@ var ViewChild = makePropDecorator('ViewChild', function (selector, data) {
 /**
  * Describes the status of the detector.
  */
-/**
- * Describes the status of the detector.
- */
 
-/**
- * Describes the status of the detector.
- */
 (function (ChangeDetectorStatus) {
     /**
      * `CheckOnce` means that after calling detectChanges the mode of the change detector
@@ -537,10 +510,7 @@ function isDefaultChangeDetectionStrategy(changeDetectionStrategy) {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * Directive decorator and metadata.
- *
- *
- * @Annotation
+ * Type of the Component metadata.
  */
 var Directive = makeDecorator('Directive', function (dir) {
     if (dir === void 0) { dir = {}; }
@@ -549,6 +519,88 @@ var Directive = makeDecorator('Directive', function (dir) {
 /**
  * Component decorator and metadata.
  *
+ * @usageNotes
+ *
+ * ### Using animations
+ *
+ * The following snippet shows an animation trigger in a component's
+ * metadata. The trigger is attached to an element in the component's
+ * template, using "@_trigger_name_", and a state expression that is evaluated
+ * at run time to determine whether the animation should start.
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'animation-cmp',
+ *   templateUrl: 'animation-cmp.html',
+ *   animations: [
+ *     trigger('myTriggerName', [
+ *       state('on', style({ opacity: 1 }),
+ *       state('off', style({ opacity: 0 }),
+ *       transition('on => off', [
+ *         animate("1s")
+ *       ])
+ *     ])
+ *   ]
+ * })
+ * ```
+ *
+ * ```html
+ * <!-- animation-cmp.html -->
+ * <div @myTriggerName="expression">...</div>
+ * ```
+ *
+ * ### Preserving whitespace
+ *
+ * Removing whitespace can greatly reduce AOT-generated code size, and speed up view creation.
+ * As of Angular 6, default for `preserveWhitespaces` is false (whitespace is removed).
+ * To change the default setting for all components in your application, set
+ * the `preserveWhitespaces` option of the AOT compiler.
+ *
+ * Current implementation removes whitespace characters as follows:
+ * - Trims all whitespaces at the beginning and the end of a template.
+ * - Removes whitespace-only text nodes. For example,
+ * `<button>Action 1</button>  <button>Action 2</button>` becomes
+ * `<button>Action 1</button><button>Action 2</button>`.
+ * - Replaces a series of whitespace characters in text nodes with a single space.
+ * For example, `<span>\n some text\n</span>` becomes `<span> some text </span>`.
+ * - Does NOT alter text nodes inside HTML tags such as `<pre>` or `<textarea>`,
+ * where whitespace characters are significant.
+ *
+ * Note that these transformations can influence DOM nodes layout, although impact
+ * should be minimal.
+ *
+ * You can override the default behavior to preserve whitespace characters
+ * in certain fragments of a template. For example, you can exclude an entire
+ * DOM sub-tree by using the `ngPreserveWhitespaces` attribute:
+ *
+ * ```html
+ * <div ngPreserveWhitespaces>
+ *     whitespaces are preserved here
+ *     <span>    and here </span>
+ * </div>
+ * ```
+ *
+ * You can force a single space to be preserved in a text node by using `&ngsp;`,
+ * which is replaced with a space character by Angular's template
+ * compiler:
+ *
+ * ```html
+ * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>
+ * <!-->compiled to be equivalent to:</>
+ *  <a>Spaces</a> <a>between</a> <a>links.</a>
+ * ```
+ *
+ * Note that sequences of `&ngsp;` are still collapsed to just one space character when
+ * the `preserveWhitespaces` option is set to `false`.
+ *
+ * ```html
+ * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>
+ * <!-->compiled to be equivalent to:</>
+ *  <a>Spaces</a> <a>between</a> <a>links.</a>
+ * ```
+ *
+ * To preserve sequences of whitespace characters, use the
+ * `ngPreserveWhitespaces` attribute.
  *
  * @Annotation
  */
@@ -557,42 +609,54 @@ var Component = makeDecorator('Component', function (c) {
     return (__assign({ changeDetection: exports.ChangeDetectionStrategy.Default }, c));
 }, Directive);
 /**
- * Pipe decorator and metadata.
- *
- * Use the `@Pipe` annotation to declare that a given class is a pipe. A pipe
- * class must also implement {@link PipeTransform} interface.
- *
- * To use the pipe include a reference to the pipe class in
- * {@link NgModule#declarations}.
  *
  *
  * @Annotation
  */
 var Pipe = makeDecorator('Pipe', function (p) { return (__assign({ pure: true }, p)); });
 /**
- * Input decorator and metadata.
- *
  *
  * @Annotation
  */
 var Input = makePropDecorator('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });
 /**
- * Output decorator and metadata.
- *
  *
  * @Annotation
  */
 var Output = makePropDecorator('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });
 /**
- * HostBinding decorator and metadata.
- *
  *
  * @Annotation
  */
 var HostBinding = makePropDecorator('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); });
 /**
- * HostListener decorator and metadata.
+ * Binds a CSS event to a host listener and supplies configuration metadata.
+ * Angular invokes the supplied handler method when the host element emits the specified event,
+ * and updates the bound element with the result.
+ * If the handler method returns false, applies `preventDefault` on the bound element.
  *
+ * @usageNotes
+ *
+ * The following example declares a directive
+ * that attaches a click listener to a button and counts clicks.
+ *
+ * ```
+ * @Directive({selector: 'button[counting]'})
+ * class CountClicks {
+ *   numberOfClicks = 0;
+ *
+ *   @HostListener('click', ['$event.target'])
+ *   onClick(btn) {
+ *     console.log('button', btn, 'number of clicks:', this.numberOfClicks++);
+ *  }
+ * }
+ *
+ * @Component({
+ *   selector: 'app',
+ *   template: '<button counting>Increment</button>',
+ * })
+ * class App {}
+ * ```
  *
  * @Annotation
  */
@@ -717,9 +781,7 @@ var ReflectionCapabilities = /** @class */ (function () {
         return new (t.bind.apply(t, __spread([void 0], args)))();
     }; };
     /** @internal */
-    /** @internal */
-    ReflectionCapabilities.prototype._zipTypesAndAnnotations = /** @internal */
-    function (paramTypes, paramAnnotations) {
+    ReflectionCapabilities.prototype._zipTypesAndAnnotations = function (paramTypes, paramAnnotations) {
         var result;
         if (typeof paramTypes === 'undefined') {
             result = new Array(paramAnnotations.length);
@@ -893,10 +955,7 @@ var ReflectionCapabilities = /** @class */ (function () {
         return new Function('o', 'args', functionBody);
     };
     // There is not a concept of import uri in Js, but this is useful in developing Dart applications.
-    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.
-    ReflectionCapabilities.prototype.importUri = 
-    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.
-    function (type) {
+    ReflectionCapabilities.prototype.importUri = function (type) {
         // StaticSymbol
         if (typeof type === 'object' && type['filePath']) {
             return type['filePath'];
@@ -957,10 +1016,10 @@ function getClosureSafeProperty(objWithPropertyToExtract, target) {
  * Allows to refer to references which are not yet defined.
  *
  * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
- * DI is declared,
- * but not yet defined. It is also used when the `token` which we use when creating a query is not
- * yet defined.
+ * DI is declared, but not yet defined. It is also used when the `token` which we use when creating
+ * a query is not yet defined.
  *
+ * @usageNotes
  * ### Example
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
  * @experimental
@@ -975,11 +1034,12 @@ function forwardRef(forwardRefFn) {
  *
  * Acts as the identity function when given a non-forward-ref value.
  *
- * ### Example ([live demo](http://plnkr.co/edit/GU72mJrk1fiodChcmiDR?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
  *
- * See: {@link forwardRef}
+ * @see `forwardRef`
  * @experimental
  */
 function resolveForwardRef(type) {
@@ -1002,35 +1062,30 @@ function resolveForwardRef(type) {
 /**
  * Inject decorator and metadata.
  *
- *
  * @Annotation
  */
 var Inject = makeParamDecorator('Inject', function (token) { return ({ token: token }); });
 /**
  * Optional decorator and metadata.
  *
- *
  * @Annotation
  */
 var Optional = makeParamDecorator('Optional');
 /**
  * Self decorator and metadata.
  *
- *
  * @Annotation
  */
 var Self = makeParamDecorator('Self');
 /**
  * SkipSelf decorator and metadata.
  *
- *
  * @Annotation
  */
 var SkipSelf = makeParamDecorator('SkipSelf');
 /**
  * Host decorator and metadata.
  *
- *
  * @Annotation
  */
 var Host = makeParamDecorator('Host');
@@ -1067,23 +1122,17 @@ var NullInjector = /** @class */ (function () {
     return NullInjector;
 }());
 /**
- * @usageNotes
- * ```
- * const injector: Injector = ...;
- * injector.get(...);
- * ```
- *
- * @description
- *
  * Concrete injectors implement this interface.
  *
- * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
  *
+ * @usageNotes
  * ### Example
  *
  * {@example core/di/ts/injector_spec.ts region='Injector'}
  *
  * `Injector` returns itself when given `Injector` as a token:
+ *
  * {@example core/di/ts/injector_spec.ts region='injectInjector'}
  *
  *
@@ -1094,25 +1143,12 @@ var Injector = /** @class */ (function () {
     /**
      * Create a new Injector which is configure using `StaticProvider`s.
      *
+     * @usageNotes
      * ### Example
      *
      * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
      */
-    /**
-       * Create a new Injector which is configure using `StaticProvider`s.
-       *
-       * ### Example
-       *
-       * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
-       */
-    Injector.create = /**
-       * Create a new Injector which is configure using `StaticProvider`s.
-       *
-       * ### Example
-       *
-       * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
-       */
-    function (options, parent) {
+    Injector.create = function (options, parent) {
         if (Array.isArray(options)) {
             return new StaticInjector(options, parent);
         }
@@ -1303,7 +1339,12 @@ function resolveToken(token, record, records, parent, notFoundValue, flags) {
                     var childRecord = options & 2 /* CheckSelf */ ? records.get(depRecord.token) : undefined;
                     deps.push(tryResolveToken(
                     // Current Token to resolve
-                    depRecord.token, childRecord, records, 
+                    depRecord.token, 
+                    // A record which describes how to resolve the token.
+                    // If undefined, this means we don't have such a record
+                    childRecord, 
+                    // Other records we know about.
+                    records, 
                     // If we don't know how to resolve dependency and we should not check parent for it,
                     // than pass in Null injector.
                     !childRecord && !(options & 4 /* CheckParent */) ? NULL_INJECTOR : parent, options & 1 /* Optional */ ? null : Injector.THROW_IF_NOT_FOUND, 0 /* Default */));
@@ -1446,7 +1487,7 @@ function injectArgs(types) {
                     type = meta;
                 }
             }
-            args.push(inject((type), flags));
+            args.push(inject(type, flags));
         }
         else {
             args.push(inject(arg));
@@ -1503,13 +1544,12 @@ function convertInjectableProviderToFactory(type, provider) {
             var reflectionCapabilities = new ReflectionCapabilities();
             deps_3 = reflectionCapabilities.parameters(type);
         }
-        return function () { return new (type.bind.apply(type, __spread([void 0], injectArgs((deps_3)))))(); };
+        return function () { return new (type.bind.apply(type, __spread([void 0], injectArgs(deps_3))))(); };
     }
 }
 /**
 * Injectable decorator and metadata.
 *
-*
 * @Annotation
 */
 var Injectable = makeDecorator('Injectable', undefined, undefined, undefined, function (injectableType, options) {
@@ -1530,10 +1570,10 @@ var Injectable = makeDecorator('Injectable', undefined, undefined, undefined, fu
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * Defines a schema that will allow:
- * - any non-Angular elements with a `-` in their name,
- * - any properties on elements with a `-` in their name which is the common rule for custom
- * elements.
+ * Defines a schema that allows an NgModule to contain the following:
+ * - Non-Angular elements named with dash case (`-`).
+ * - Element properties named with dash case (`-`).
+ * Dash case is the naming convention for custom elements.
  *
  *
  */
@@ -1541,7 +1581,7 @@ var CUSTOM_ELEMENTS_SCHEMA = {
     name: 'custom-elements'
 };
 /**
- * Defines a schema that will allow any property on any element.
+ * Defines a schema that allows any property on any element.
  *
  * @experimental
  */
@@ -1549,12 +1589,17 @@ var NO_ERRORS_SCHEMA = {
     name: 'no-errors-schema'
 };
 /**
- * NgModule decorator and metadata.
- *
+ * Decorator that marks the following class as an NgModule, and supplies
+ * configuration metadata for it.
  *
  * @Annotation
  */
-var NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule; }, undefined, undefined, function (moduleType, metadata) {
+var NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule; }, undefined, undefined, 
+/**
+ * Decorator that marks the following class as an NgModule, and supplies
+ * configuration metadata for it.
+ */
+function (moduleType, metadata) {
     var imports = (metadata && metadata.imports) || [];
     if (metadata && metadata.exports) {
         imports = __spread(imports, [metadata.exports]);
@@ -1566,13 +1611,6 @@ var NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule;
     });
 });
 
-/**
- * @license
- * Copyright Google Inc. 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
- */
 /**
  * @license
  * Copyright Google Inc. All Rights Reserved.
@@ -1586,19 +1624,7 @@ var NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule;
  * See {@link Component#encapsulation encapsulation}.
  *
  */
-/**
- * Defines template and style encapsulation options available for Component's {@link Component}.
- *
- * See {@link Component#encapsulation encapsulation}.
- *
- */
 
-/**
- * Defines template and style encapsulation options available for Component's {@link Component}.
- *
- * See {@link Component#encapsulation encapsulation}.
- *
- */
 (function (ViewEncapsulation) {
     /**
      * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host
@@ -1651,7 +1677,7 @@ var Version = /** @class */ (function () {
     }
     return Version;
 }());
-var VERSION = new Version('6.0.3');
+var VERSION = new Version('6.0.7');
 
 /**
  * @license
@@ -1690,14 +1716,13 @@ function defaultErrorLogger(console) {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- *
- * @description
  * Provides a hook for centralized exception handling.
  *
  * The default implementation of `ErrorHandler` prints error messages to the `console`. To
  * intercept error handling, write a custom exception handler that replaces this default as
  * appropriate for your app.
  *
+ * @usageNotes
  * ### Example
  *
  * ```
@@ -1712,14 +1737,12 @@ function defaultErrorLogger(console) {
  * })
  * class MyModule {}
  * ```
- *
- *
  */
 var ErrorHandler = /** @class */ (function () {
     function ErrorHandler() {
         /**
-           * @internal
-           */
+         * @internal
+         */
         this._console = console;
     }
     ErrorHandler.prototype.handleError = function (error) {
@@ -1737,9 +1760,7 @@ var ErrorHandler = /** @class */ (function () {
         }
     };
     /** @internal */
-    /** @internal */
-    ErrorHandler.prototype._findContext = /** @internal */
-    function (error) {
+    ErrorHandler.prototype._findContext = function (error) {
         if (error) {
             return getDebugContext(error) ? getDebugContext(error) :
                 this._findContext(getOriginalError(error));
@@ -1747,9 +1768,7 @@ var ErrorHandler = /** @class */ (function () {
         return null;
     };
     /** @internal */
-    /** @internal */
-    ErrorHandler.prototype._findOriginalError = /** @internal */
-    function (error) {
+    ErrorHandler.prototype._findOriginalError = function (error) {
         var e = getOriginalError(error);
         while (e && getOriginalError(e)) {
             e = getOriginalError(e);
@@ -1812,7 +1831,8 @@ function addKey(injector, key) {
  * Thrown when trying to retrieve a dependency by key from {@link Injector}, but the
  * {@link Injector} does not have a {@link Provider} for the given key.
  *
- * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * ```typescript
  * class A {
@@ -1831,7 +1851,8 @@ function noProviderError(injector, key) {
 /**
  * Thrown when dependencies form a cycle.
  *
- * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))
+ * @usageNotes
+ * ### Example
  *
  * ```typescript
  * var injector = Injector.resolveAndCreate([
@@ -1855,7 +1876,8 @@ function cyclicDependencyError(injector, key) {
  * The `InstantiationError` class contains the original error plus the dependency graph which caused
  * this object to be instantiated.
  *
- * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * ```typescript
  * class A {
@@ -1885,7 +1907,8 @@ function instantiationError(injector, originalException, originalStack, key) {
  * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
  * creation.
  *
- * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * ```typescript
  * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
@@ -1900,7 +1923,8 @@ function invalidProviderError(provider) {
  * Lack of annotation information prevents the {@link Injector} from determining which dependencies
  * need to be injected into the constructor.
  *
- * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * ```typescript
  * class A {
@@ -1942,7 +1966,8 @@ function noAnnotationError(typeOrFunc, params) {
 /**
  * Thrown when getting an object by index.
  *
- * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * ```typescript
  * class A {}
@@ -1960,6 +1985,7 @@ function outOfBoundsError(index) {
 /**
  * Thrown when a multi provider and a regular provider are bound to the same token.
  *
+ * @usageNotes
  * ### Example
  *
  * ```typescript
@@ -2011,23 +2037,14 @@ var ReflectiveKey = /** @class */ (function () {
     /**
      * Retrieves a `Key` for a token.
      */
-    /**
-       * Retrieves a `Key` for a token.
-       */
-    ReflectiveKey.get = /**
-       * Retrieves a `Key` for a token.
-       */
-    function (token) {
+    ReflectiveKey.get = function (token) {
         return _globalKeyRegistry.get(resolveForwardRef(token));
     };
     Object.defineProperty(ReflectiveKey, "numberOfKeys", {
         /**
          * @returns the number of keys registered in the system.
          */
-        get: /**
-           * @returns the number of keys registered in the system.
-           */
-        function () { return _globalKeyRegistry.numberOfKeys; },
+        get: function () { return _globalKeyRegistry.numberOfKeys; },
         enumerable: true,
         configurable: true
     });
@@ -2145,17 +2162,18 @@ var ResolvedReflectiveProvider_ = /** @class */ (function () {
     return ResolvedReflectiveProvider_;
 }());
 /**
- * An internal resolved representation of a factory function created by resolving {@link
- * Provider}.
+ * An internal resolved representation of a factory function created by resolving `Provider`.
  * @experimental
  */
 var ResolvedReflectiveFactory = /** @class */ (function () {
-    function ResolvedReflectiveFactory(/**
-           * Factory function which can return an instance of an object represented by a key.
-           */
-    factory, /**
-           * Arguments (dependencies) to the `factory` function.
-           */
+    function ResolvedReflectiveFactory(
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+    factory, 
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
     dependencies) {
         this.factory = factory;
         this.dependencies = dependencies;
@@ -2188,10 +2206,10 @@ function resolveReflectiveFactory(provider) {
     return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
 }
 /**
- * Converts the {@link Provider} into {@link ResolvedProvider}.
+ * Converts the `Provider` into `ResolvedProvider`.
  *
- * {@link Injector} internally only uses {@link ResolvedProvider}, {@link Provider} contains
- * convenience provider syntax.
+ * `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider
+ * syntax.
  */
 function resolveReflectiveProvider(provider) {
     return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);
@@ -2206,9 +2224,8 @@ function resolveReflectiveProviders(providers) {
     return Array.from(resolvedProviderMap.values());
 }
 /**
- * Merges a list of ResolvedProviders into a list where
- * each key is contained exactly once and multi providers
- * have been merged.
+ * Merges a list of ResolvedProviders into a list where each key is contained exactly once and
+ * multi providers have been merged.
  */
 function mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {
     for (var i = 0; i < providers.length; i++) {
@@ -2336,7 +2353,8 @@ var UNDEFINED = new Object();
  * In typical use, application code asks for the dependencies in the constructor and they are
  * resolved by the `Injector`.
  *
- * ### Example ([live demo](http://plnkr.co/edit/jzjec0?p=preview))
+ * @usageNotes
+ * ### Example
  *
  * The following example creates an `Injector` configured to create `Engine` and `Car`.
  *
@@ -2368,9 +2386,10 @@ var ReflectiveInjector = /** @class */ (function () {
      * Turns an array of provider definitions into an array of resolved providers.
      *
      * A resolution is a process of flattening multiple nested arrays and converting individual
-     * providers into an array of {@link ResolvedReflectiveProvider}s.
+     * providers into an array of `ResolvedReflectiveProvider`s.
      *
-     * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))
+     * @usageNotes
+     * ### Example
      *
      * ```typescript
      * @Injectable()
@@ -2395,84 +2414,18 @@ var ReflectiveInjector = /** @class */ (function () {
      * });
      * ```
      *
-     * See {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders} for more info.
      */
-    /**
-       * Turns an array of provider definitions into an array of resolved providers.
-       *
-       * A resolution is a process of flattening multiple nested arrays and converting individual
-       * providers into an array of {@link ResolvedReflectiveProvider}s.
-       *
-       * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))
-       *
-       * ```typescript
-       * @Injectable()
-       * class Engine {
-       * }
-       *
-       * @Injectable()
-       * class Car {
-       *   constructor(public engine:Engine) {}
-       * }
-       *
-       * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
-       *
-       * expect(providers.length).toEqual(2);
-       *
-       * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
-       * expect(providers[0].key.displayName).toBe("Car");
-       * expect(providers[0].dependencies.length).toEqual(1);
-       * expect(providers[0].factory).toBeDefined();
-       *
-       * expect(providers[1].key.displayName).toBe("Engine");
-       * });
-       * ```
-       *
-       * See {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders} for more info.
-       */
-    ReflectiveInjector.resolve = /**
-       * Turns an array of provider definitions into an array of resolved providers.
-       *
-       * A resolution is a process of flattening multiple nested arrays and converting individual
-       * providers into an array of {@link ResolvedReflectiveProvider}s.
-       *
-       * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))
-       *
-       * ```typescript
-       * @Injectable()
-       * class Engine {
-       * }
-       *
-       * @Injectable()
-       * class Car {
-       *   constructor(public engine:Engine) {}
-       * }
-       *
-       * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
-       *
-       * expect(providers.length).toEqual(2);
-       *
-       * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
-       * expect(providers[0].key.displayName).toBe("Car");
-       * expect(providers[0].dependencies.length).toEqual(1);
-       * expect(providers[0].factory).toBeDefined();
-       *
-       * expect(providers[1].key.displayName).toBe("Engine");
-       * });
-       * ```
-       *
-       * See {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders} for more info.
-       */
-    function (providers) {
+    ReflectiveInjector.resolve = function (providers) {
         return resolveReflectiveProviders(providers);
     };
     /**
      * Resolves an array of providers and creates an injector from those providers.
      *
-     * The passed-in providers can be an array of `Type`, {@link Provider},
+     * The passed-in providers can be an array of `Type`, `Provider`,
      * or a recursive array of more providers.
      *
-     * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
+     * @usageNotes
+     * ### Example
      *
      * ```typescript
      * @Injectable()
@@ -2487,67 +2440,8 @@ var ReflectiveInjector = /** @class */ (function () {
      * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
      * expect(injector.get(Car) instanceof Car).toBe(true);
      * ```
-     *
-     * This function is slower than the corresponding `fromResolvedProviders`
-     * because it needs to resolve the passed-in providers first.
-     * See {@link ReflectiveInjector#resolve resolve} and
-     * {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders}.
      */
-    /**
-       * Resolves an array of providers and creates an injector from those providers.
-       *
-       * The passed-in providers can be an array of `Type`, {@link Provider},
-       * or a recursive array of more providers.
-       *
-       * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
-       *
-       * ```typescript
-       * @Injectable()
-       * class Engine {
-       * }
-       *
-       * @Injectable()
-       * class Car {
-       *   constructor(public engine:Engine) {}
-       * }
-       *
-       * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-       * expect(injector.get(Car) instanceof Car).toBe(true);
-       * ```
-       *
-       * This function is slower than the corresponding `fromResolvedProviders`
-       * because it needs to resolve the passed-in providers first.
-       * See {@link ReflectiveInjector#resolve resolve} and
-       * {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders}.
-       */
-    ReflectiveInjector.resolveAndCreate = /**
-       * Resolves an array of providers and creates an injector from those providers.
-       *
-       * The passed-in providers can be an array of `Type`, {@link Provider},
-       * or a recursive array of more providers.
-       *
-       * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
-       *
-       * ```typescript
-       * @Injectable()
-       * class Engine {
-       * }
-       *
-       * @Injectable()
-       * class Car {
-       *   constructor(public engine:Engine) {}
-       * }
-       *
-       * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-       * expect(injector.get(Car) instanceof Car).toBe(true);
-       * ```
-       *
-       * This function is slower than the corresponding `fromResolvedProviders`
-       * because it needs to resolve the passed-in providers first.
-       * See {@link ReflectiveInjector#resolve resolve} and
-       * {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders}.
-       */
-    function (providers, parent) {
+    ReflectiveInjector.resolveAndCreate = function (providers, parent) {
         var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
         return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
     };
@@ -2556,7 +2450,8 @@ var ReflectiveInjector = /** @class */ (function () {
      *
      * This API is the recommended way to construct injectors in performance-sensitive parts.
      *
-     * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
+     * @usageNotes
+     * ### Example
      *
      * ```typescript
      * @Injectable()
@@ -2574,53 +2469,7 @@ var ReflectiveInjector = /** @class */ (function () {
      * ```
      * @experimental
      */
-    /**
-       * Creates an injector from previously resolved providers.
-       *
-       * This API is the recommended way to construct injectors in performance-sensitive parts.
-       *
-       * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
-       *
-       * ```typescript
-       * @Injectable()
-       * class Engine {
-       * }
-       *
-       * @Injectable()
-       * class Car {
-       *   constructor(public engine:Engine) {}
-       * }
-       *
-       * var providers = ReflectiveInjector.resolve([Car, Engine]);
-       * var injector = ReflectiveInjector.fromResolvedProviders(providers);
-       * expect(injector.get(Car) instanceof Car).toBe(true);
-       * ```
-       * @experimental
-       */
-    ReflectiveInjector.fromResolvedProviders = /**
-       * Creates an injector from previously resolved providers.
-       *
-       * This API is the recommended way to construct injectors in performance-sensitive parts.
-       *
-       * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
-       *
-       * ```typescript
-       * @Injectable()
-       * class Engine {
-       * }
-       *
-       * @Injectable()
-       * class Car {
-       *   constructor(public engine:Engine) {}
-       * }
-       *
-       * var providers = ReflectiveInjector.resolve([Car, Engine]);
-       * var injector = ReflectiveInjector.fromResolvedProviders(providers);
-       * expect(injector.get(Car) instanceof Car).toBe(true);
-       * ```
-       * @experimental
-       */
-    function (providers, parent) {
+    ReflectiveInjector.fromResolvedProviders = function (providers, parent) {
         return new ReflectiveInjector_(providers, parent);
     };
     return ReflectiveInjector;
@@ -2668,9 +2517,7 @@ var ReflectiveInjector_ = /** @class */ (function () {
         return this._providers[index];
     };
     /** @internal */
-    /** @internal */
-    ReflectiveInjector_.prototype._new = /** @internal */
-    function (provider) {
+    ReflectiveInjector_.prototype._new = function (provider) {
         if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
             throw cyclicDependencyError(this, provider.key);
         }
@@ -2738,9 +2585,7 @@ var ReflectiveInjector_ = /** @class */ (function () {
         return UNDEFINED;
     };
     /** @internal */
-    /** @internal */
-    ReflectiveInjector_.prototype._throwOrNull = /** @internal */
-    function (key, notFoundValue) {
+    ReflectiveInjector_.prototype._throwOrNull = function (key, notFoundValue) {
         if (notFoundValue !== THROW_IF_NOT_FOUND) {
             return notFoundValue;
         }
@@ -2749,16 +2594,12 @@ var ReflectiveInjector_ = /** @class */ (function () {
         }
     };
     /** @internal */
-    /** @internal */
-    ReflectiveInjector_.prototype._getByKeySelf = /** @internal */
-    function (key, notFoundValue) {
+    ReflectiveInjector_.prototype._getByKeySelf = function (key, notFoundValue) {
         var obj = this._getObjByKeyId(key.id);
         return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);
     };
     /** @internal */
-    /** @internal */
-    ReflectiveInjector_.prototype._getByKeyDefault = /** @internal */
-    function (key, notFoundValue, visibility) {
+    ReflectiveInjector_.prototype._getByKeyDefault = function (key, notFoundValue, visibility) {
         var inj;
         if (visibility instanceof SkipSelf) {
             inj = this.parent;
@@ -2860,20 +2701,20 @@ var R3Injector = /** @class */ (function () {
         var _this = this;
         this.parent = parent;
         /**
-           * Map of tokens to records which contain the instances of those tokens.
-           */
+         * Map of tokens to records which contain the instances of those tokens.
+         */
         this.records = new Map();
         /**
-           * The transitive set of `InjectorType`s which define this injector.
-           */
+         * The transitive set of `InjectorType`s which define this injector.
+         */
         this.injectorDefTypes = new Set();
         /**
-           * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
-           */
+         * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
+         */
         this.onDestroy = new Set();
         /**
-           * Flag indicating that this injector was previously destroyed.
-           */
+         * Flag indicating that this injector was previously destroyed.
+         */
         this.destroyed = false;
         // Start off by creating Records for every provider declared in every InjectorType
         // included transitively in `def`.
@@ -2892,19 +2733,7 @@ var R3Injector = /** @class */ (function () {
      * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
      * hook was found.
      */
-    /**
-       * Destroy the injector and release references to every instance or provider associated with it.
-       *
-       * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
-       * hook was found.
-       */
-    R3Injector.prototype.destroy = /**
-       * Destroy the injector and release references to every instance or provider associated with it.
-       *
-       * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
-       * hook was found.
-       */
-    function () {
+    R3Injector.prototype.destroy = function () {
         this.assertNotDestroyed();
         // Set destroyed = true first, in case lifecycle hooks re-enter destroy().
         this.destroyed = true;
@@ -2967,15 +2796,7 @@ var R3Injector = /** @class */ (function () {
      * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers
      * to this injector.
      */
-    /**
-       * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers
-       * to this injector.
-       */
-    R3Injector.prototype.processInjectorType = /**
-       * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers
-       * to this injector.
-       */
-    function (defOrWrappedDef, parents) {
+    R3Injector.prototype.processInjectorType = function (defOrWrappedDef, parents) {
         var _this = this;
         defOrWrappedDef = resolveForwardRef(defOrWrappedDef);
         // Either the defOrWrappedDef is an InjectorType (with ngInjectorDef) or an
@@ -3033,13 +2854,7 @@ var R3Injector = /** @class */ (function () {
     /**
      * Process a `SingleProvider` and add it.
      */
-    /**
-       * Process a `SingleProvider` and add it.
-       */
-    R3Injector.prototype.processProvider = /**
-       * Process a `SingleProvider` and add it.
-       */
-    function (provider) {
+    R3Injector.prototype.processProvider = function (provider) {
         // Determine the token from the provider. Either it's its own token, or has a {provide: ...}
         // property.
         provider = resolveForwardRef(provider);
@@ -3059,7 +2874,7 @@ var R3Injector = /** @class */ (function () {
             else {
                 token = provider;
                 multiRecord_1 = makeRecord(undefined, NOT_YET, true);
-                multiRecord_1.factory = function () { return injectArgs((multiRecord_1.multi)); };
+                multiRecord_1.factory = function () { return injectArgs(multiRecord_1.multi); };
                 this.records.set(token, multiRecord_1);
             }
             token = provider;
@@ -3177,6 +2992,11 @@ function couldBeInjectableType(value) {
  * 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
  */
+/**
+ * @module
+ * @description
+ * The `di` module provides dependency injection container services.
+ */
 
 /**
  * @license
@@ -3230,9 +3050,7 @@ var ApplicationInitStatus = /** @class */ (function () {
         });
     }
     /** @internal */
-    /** @internal */
-    ApplicationInitStatus.prototype.runInitializers = /** @internal */
-    function () {
+    ApplicationInitStatus.prototype.runInitializers = function () {
         var _this = this;
         if (this.initialized) {
             return;
@@ -3261,7 +3079,7 @@ var ApplicationInitStatus = /** @class */ (function () {
     ];
     /** @nocollapse */
     ApplicationInitStatus.ctorParameters = function () { return [
-        { type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER,] }, { type: Optional },] },
+        { type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER,] }, { type: Optional }] }
     ]; };
     return ApplicationInitStatus;
 }());
@@ -3339,18 +3157,13 @@ var Console = /** @class */ (function () {
         console.log(message);
     };
     // Note: for reporting errors use `DOM.logError()` as it is platform specific
-    // Note: for reporting errors use `DOM.logError()` as it is platform specific
-    Console.prototype.warn = 
-    // Note: for reporting errors use `DOM.logError()` as it is platform specific
-    function (message) {
+    Console.prototype.warn = function (message) {
         // tslint:disable-next-line:no-console
         console.warn(message);
     };
     Console.decorators = [
         { type: Injectable }
     ];
-    /** @nocollapse */
-    Console.ctorParameters = function () { return []; };
     return Console;
 }());
 
@@ -3393,74 +3206,34 @@ var Compiler = /** @class */ (function () {
      * Compiles the given NgModule and all of its components. All templates of the components listed
      * in `entryComponents` have to be inlined.
      */
-    /**
-       * Compiles the given NgModule and all of its components. All templates of the components listed
-       * in `entryComponents` have to be inlined.
-       */
-    Compiler.prototype.compileModuleSync = /**
-       * Compiles the given NgModule and all of its components. All templates of the components listed
-       * in `entryComponents` have to be inlined.
-       */
-    function (moduleType) { throw _throwError(); };
+    Compiler.prototype.compileModuleSync = function (moduleType) { throw _throwError(); };
     /**
      * Compiles the given NgModule and all of its components
      */
-    /**
-       * Compiles the given NgModule and all of its components
-       */
-    Compiler.prototype.compileModuleAsync = /**
-       * Compiles the given NgModule and all of its components
-       */
-    function (moduleType) { throw _throwError(); };
+    Compiler.prototype.compileModuleAsync = function (moduleType) { throw _throwError(); };
     /**
      * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.
      */
-    /**
-       * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.
-       */
-    Compiler.prototype.compileModuleAndAllComponentsSync = /**
-       * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.
-       */
-    function (moduleType) {
+    Compiler.prototype.compileModuleAndAllComponentsSync = function (moduleType) {
         throw _throwError();
     };
     /**
      * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.
      */
-    /**
-       * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.
-       */
-    Compiler.prototype.compileModuleAndAllComponentsAsync = /**
-       * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.
-       */
-    function (moduleType) {
+    Compiler.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {
         throw _throwError();
     };
     /**
      * Clears all caches.
      */
-    /**
-       * Clears all caches.
-       */
-    Compiler.prototype.clearCache = /**
-       * Clears all caches.
-       */
-    function () { };
+    Compiler.prototype.clearCache = function () { };
     /**
      * Clears the cache for the given component/ngModule.
      */
-    /**
-       * Clears the cache for the given component/ngModule.
-       */
-    Compiler.prototype.clearCacheFor = /**
-       * Clears the cache for the given component/ngModule.
-       */
-    function (type) { };
+    Compiler.prototype.clearCacheFor = function (type) { };
     Compiler.decorators = [
         { type: Injectable }
     ];
-    /** @nocollapse */
-    Compiler.ctorParameters = function () { return []; };
     return Compiler;
 }());
 /**
@@ -3726,6 +3499,7 @@ var wtfEndTimeRange = wtfEnabled ? endTimeRange : function (r) { return null; };
 /**
  * Use by directives and components to emit custom Events.
  *
+ * @usageNotes
  * ### Examples
  *
  * In the following example, `Zippy` alternatively emits `open` and `close` events when its
@@ -3764,6 +3538,8 @@ var wtfEndTimeRange = wtfEnabled ? endTimeRange : function (r) { return null; };
  * <zippy (open)="onOpen($event)" (close)="onClose($event)"></zippy>
  * ```
  *
+ * ### Notes
+ *
  * Uses Rx.Observable but provides an adapter to make it work as specified here:
  * https://github.com/jhusain/observable-spec
  *
@@ -3844,6 +3620,7 @@ var EventEmitter = /** @class */ (function (_super) {
  *   - link to runOutsideAngular/run (throughout this file!)
  *   -->
  *
+ * @usageNotes
  * ### Example
  *
  * ```
@@ -3910,28 +3687,28 @@ var NgZone = /** @class */ (function () {
         this.hasPendingMicrotasks = false;
         this.hasPendingMacrotasks = false;
         /**
-           * Whether there are no outstanding microtasks or macrotasks.
-           */
+         * Whether there are no outstanding microtasks or macrotasks.
+         */
         this.isStable = true;
         /**
-           * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
-           */
+         * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
+         */
         this.onUnstable = new EventEmitter(false);
         /**
-           * Notifies when there is no more microtasks enqueued in the current VM Turn.
-           * This is a hint for Angular to do change detection, which may enqueue more microtasks.
-           * For this reason this event can fire multiple times per VM Turn.
-           */
+         * Notifies when there is no more microtasks enqueued in the current VM Turn.
+         * This is a hint for Angular to do change detection, which may enqueue more microtasks.
+         * For this reason this event can fire multiple times per VM Turn.
+         */
         this.onMicrotaskEmpty = new EventEmitter(false);
         /**
-           * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
-           * implies we are about to relinquish VM turn.
-           * This event gets called just once.
-           */
+         * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
+         * implies we are about to relinquish VM turn.
+         * This event gets called just once.
+         */
         this.onStable = new EventEmitter(false);
         /**
-           * Notifies that an error has been delivered.
-           */
+         * Notifies that an error has been delivered.
+         */
         this.onError = new EventEmitter(false);
         if (typeof Zone == 'undefined') {
             throw new Error("In this configuration Angular requires Zone.js");
@@ -3974,31 +3751,7 @@ var NgZone = /** @class */ (function () {
      *
      * If a synchronous error happens it will be rethrown and not reported via `onError`.
      */
-    /**
-       * Executes the `fn` function synchronously within the Angular zone and returns value returned by
-       * the function.
-       *
-       * Running functions via `run` allows you to reenter Angular zone from a task that was executed
-       * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
-       *
-       * Any future tasks or microtasks scheduled from within this function will continue executing from
-       * within the Angular zone.
-       *
-       * If a synchronous error happens it will be rethrown and not reported via `onError`.
-       */
-    NgZone.prototype.run = /**
-       * Executes the `fn` function synchronously within the Angular zone and returns value returned by
-       * the function.
-       *
-       * Running functions via `run` allows you to reenter Angular zone from a task that was executed
-       * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
-       *
-       * Any future tasks or microtasks scheduled from within this function will continue executing from
-       * within the Angular zone.
-       *
-       * If a synchronous error happens it will be rethrown and not reported via `onError`.
-       */
-    function (fn, applyThis, applyArgs) {
+    NgZone.prototype.run = function (fn, applyThis, applyArgs) {
         return this._inner.run(fn, applyThis, applyArgs);
     };
     /**
@@ -4013,31 +3766,7 @@ var NgZone = /** @class */ (function () {
      *
      * If a synchronous error happens it will be rethrown and not reported via `onError`.
      */
-    /**
-       * Executes the `fn` function synchronously within the Angular zone as a task and returns value
-       * returned by the function.
-       *
-       * Running functions via `run` allows you to reenter Angular zone from a task that was executed
-       * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
-       *
-       * Any future tasks or microtasks scheduled from within this function will continue executing from
-       * within the Angular zone.
-       *
-       * If a synchronous error happens it will be rethrown and not reported via `onError`.
-       */
-    NgZone.prototype.runTask = /**
-       * Executes the `fn` function synchronously within the Angular zone as a task and returns value
-       * returned by the function.
-       *
-       * Running functions via `run` allows you to reenter Angular zone from a task that was executed
-       * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
-       *
-       * Any future tasks or microtasks scheduled from within this function will continue executing from
-       * within the Angular zone.
-       *
-       * If a synchronous error happens it will be rethrown and not reported via `onError`.
-       */
-    function (fn, applyThis, applyArgs, name) {
+    NgZone.prototype.runTask = function (fn, applyThis, applyArgs, name) {
         var zone = this._inner;
         var task = zone.scheduleEventTask('NgZoneEvent: ' + name, fn, EMPTY_PAYLOAD, noop, noop);
         try {
@@ -4051,15 +3780,7 @@ var NgZone = /** @class */ (function () {
      * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
      * rethrown.
      */
-    /**
-       * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
-       * rethrown.
-       */
-    NgZone.prototype.runGuarded = /**
-       * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
-       * rethrown.
-       */
-    function (fn, applyThis, applyArgs) {
+    NgZone.prototype.runGuarded = function (fn, applyThis, applyArgs) {
         return this._inner.runGuarded(fn, applyThis, applyArgs);
     };
     /**
@@ -4075,33 +3796,7 @@ var NgZone = /** @class */ (function () {
      *
      * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
      */
-    /**
-       * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
-       * the function.
-       *
-       * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
-       * work that
-       * doesn't trigger Angular change-detection or is subject to Angular's error handling.
-       *
-       * Any future tasks or microtasks scheduled from within this function will continue executing from
-       * outside of the Angular zone.
-       *
-       * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
-       */
-    NgZone.prototype.runOutsideAngular = /**
-       * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
-       * the function.
-       *
-       * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
-       * work that
-       * doesn't trigger Angular change-detection or is subject to Angular's error handling.
-       *
-       * Any future tasks or microtasks scheduled from within this function will continue executing from
-       * outside of the Angular zone.
-       *
-       * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
-       */
-    function (fn) {
+    NgZone.prototype.runOutsideAngular = function (fn) {
         return this._outer.run(fn);
     };
     return NgZone;
@@ -4222,11 +3917,11 @@ var Testability = /** @class */ (function () {
         this._pendingCount = 0;
         this._isZoneStable = true;
         /**
-           * Whether any work was done since the last 'whenStable' callback. This is
-           * useful to detect if this could have potentially destabilized another
-           * component while it is stabilizing.
-           * @internal
-           */
+         * Whether any work was done since the last 'whenStable' callback. This is
+         * useful to detect if this could have potentially destabilized another
+         * component while it is stabilizing.
+         * @internal
+         */
         this._didWork = false;
         this._callbacks = [];
         this._watchAngularEvents();
@@ -4256,15 +3951,7 @@ var Testability = /** @class */ (function () {
      * Increases the number of pending request
      * @deprecated pending requests are now tracked with zones.
      */
-    /**
-       * Increases the number of pending request
-       * @deprecated pending requests are now tracked with zones.
-       */
-    Testability.prototype.increasePendingRequestCount = /**
-       * Increases the number of pending request
-       * @deprecated pending requests are now tracked with zones.
-       */
-    function () {
+    Testability.prototype.increasePendingRequestCount = function () {
         this._pendingCount += 1;
         this._didWork = true;
         return this._pendingCount;
@@ -4273,15 +3960,7 @@ var Testability = /** @class */ (function () {
      * Decreases the number of pending request
      * @deprecated pending requests are now tracked with zones
      */
-    /**
-       * Decreases the number of pending request
-       * @deprecated pending requests are now tracked with zones
-       */
-    Testability.prototype.decreasePendingRequestCount = /**
-       * Decreases the number of pending request
-       * @deprecated pending requests are now tracked with zones
-       */
-    function () {
+    Testability.prototype.decreasePendingRequestCount = function () {
         this._pendingCount -= 1;
         if (this._pendingCount < 0) {
             throw new Error('pending async requests below zero');
@@ -4292,13 +3971,7 @@ var Testability = /** @class */ (function () {
     /**
      * Whether an associated application is stable
      */
-    /**
-       * Whether an associated application is stable
-       */
-    Testability.prototype.isStable = /**
-       * Whether an associated application is stable
-       */
-    function () {
+    Testability.prototype.isStable = function () {
         return this._isZoneStable && this._pendingCount === 0 && !this._ngZone.hasPendingMacrotasks;
     };
     Testability.prototype._runCallbacksIfReady = function () {
@@ -4307,7 +3980,7 @@ var Testability = /** @class */ (function () {
             // Schedules the call backs in a new frame so that it is always async.
             scheduleMicroTask(function () {
                 while (_this._callbacks.length !== 0) {
-                    var cb = (_this._callbacks.pop());
+                    var cb = _this._callbacks.pop();
                     clearTimeout(cb.timeoutId);
                     cb.doneCb(_this._didWork);
                 }
@@ -4368,31 +4041,7 @@ var Testability = /** @class */ (function () {
      *    pending macrotasks changes. If this callback returns true doneCb will not be invoked
      *    and no further updates will be issued.
      */
-    /**
-       * Wait for the application to be stable with a timeout. If the timeout is reached before that
-       * happens, the callback receives a list of the macro tasks that were pending, otherwise null.
-       *
-       * @param doneCb The callback to invoke when Angular is stable or the timeout expires
-       *    whichever comes first.
-       * @param timeout Optional. The maximum time to wait for Angular to become stable. If not
-       *    specified, whenStable() will wait forever.
-       * @param updateCb Optional. If specified, this callback will be invoked whenever the set of
-       *    pending macrotasks changes. If this callback returns true doneCb will not be invoked
-       *    and no further updates will be issued.
-       */
-    Testability.prototype.whenStable = /**
-       * Wait for the application to be stable with a timeout. If the timeout is reached before that
-       * happens, the callback receives a list of the macro tasks that were pending, otherwise null.
-       *
-       * @param doneCb The callback to invoke when Angular is stable or the timeout expires
-       *    whichever comes first.
-       * @param timeout Optional. The maximum time to wait for Angular to become stable. If not
-       *    specified, whenStable() will wait forever.
-       * @param updateCb Optional. If specified, this callback will be invoked whenever the set of
-       *    pending macrotasks changes. If this callback returns true doneCb will not be invoked
-       *    and no further updates will be issued.
-       */
-    function (doneCb, timeout, updateCb) {
+    Testability.prototype.whenStable = function (doneCb, timeout, updateCb) {
         if (updateCb && !this.taskTrackingZone) {
             throw new Error('Task tracking zone is required when passing an update callback to ' +
                 'whenStable(). Is "zone.js/dist/task-tracking.js" loaded?');
@@ -4405,34 +4054,14 @@ var Testability = /** @class */ (function () {
      * Get the number of pending requests
      * @deprecated pending requests are now tracked with zones
      */
-    /**
-       * Get the number of pending requests
-       * @deprecated pending requests are now tracked with zones
-       */
-    Testability.prototype.getPendingRequestCount = /**
-       * Get the number of pending requests
-       * @deprecated pending requests are now tracked with zones
-       */
-    function () { return this._pendingCount; };
+    Testability.prototype.getPendingRequestCount = function () { return this._pendingCount; };
     /**
      * Find providers by name
      * @param using The root element to search from
      * @param provider The name of binding variable
      * @param exactMatch Whether using exactMatch
      */
-    /**
-       * Find providers by name
-       * @param using The root element to search from
-       * @param provider The name of binding variable
-       * @param exactMatch Whether using exactMatch
-       */
-    Testability.prototype.findProviders = /**
-       * Find providers by name
-       * @param using The root element to search from
-       * @param provider The name of binding variable
-       * @param exactMatch Whether using exactMatch
-       */
-    function (using, provider, exactMatch) {
+    Testability.prototype.findProviders = function (using, provider, exactMatch) {
         // TODO(juliemr): implement.
         return [];
     };
@@ -4441,7 +4070,7 @@ var Testability = /** @class */ (function () {
     ];
     /** @nocollapse */
     Testability.ctorParameters = function () { return [
-        { type: NgZone, },
+        { type: NgZone }
     ]; };
     return Testability;
 }());
@@ -4460,94 +4089,38 @@ var TestabilityRegistry = /** @class */ (function () {
      * @param token token of application, root element
      * @param testability Testability hook
      */
-    /**
-       * Registers an application with a testability hook so that it can be tracked
-       * @param token token of application, root element
-       * @param testability Testability hook
-       */
-    TestabilityRegistry.prototype.registerApplication = /**
-       * Registers an application with a testability hook so that it can be tracked
-       * @param token token of application, root element
-       * @param testability Testability hook
-       */
-    function (token, testability) {
+    TestabilityRegistry.prototype.registerApplication = function (token, testability) {
         this._applications.set(token, testability);
     };
     /**
      * Unregisters an application.
      * @param token token of application, root element
      */
-    /**
-       * Unregisters an application.
-       * @param token token of application, root element
-       */
-    TestabilityRegistry.prototype.unregisterApplication = /**
-       * Unregisters an application.
-       * @param token token of application, root element
-       */
-    function (token) { this._applications.delete(token); };
+    TestabilityRegistry.prototype.unregisterApplication = function (token) { this._applications.delete(token); };
     /**
      * Unregisters all applications
      */
-    /**
-       * Unregisters all applications
-       */
-    TestabilityRegistry.prototype.unregisterAllApplications = /**
-       * Unregisters all applications
-       */
-    function () { this._applications.clear(); };
+    TestabilityRegistry.prototype.unregisterAllApplications = function () { this._applications.clear(); };
     /**
      * Get a testability hook associated with the application
      * @param elem root element
      */
-    /**
-       * Get a testability hook associated with the application
-       * @param elem root element
-       */
-    TestabilityRegistry.prototype.getTestability = /**
-       * Get a testability hook associated with the application
-       * @param elem root element
-       */
-    function (elem) { return this._applications.get(elem) || null; };
+    TestabilityRegistry.prototype.getTestability = function (elem) { return this._applications.get(elem) || null; };
     /**
      * Get all registered testabilities
      */
-    /**
-       * Get all registered testabilities
-       */
-    TestabilityRegistry.prototype.getAllTestabilities = /**
-       * Get all registered testabilities
-       */
-    function () { return Array.from(this._applications.values()); };
+    TestabilityRegistry.prototype.getAllTestabilities = function () { return Array.from(this._applications.values()); };
     /**
      * Get all registered applications(root elements)
      */
-    /**
-       * Get all registered applications(root elements)
-       */
-    TestabilityRegistry.prototype.getAllRootElements = /**
-       * Get all registered applications(root elements)
-       */
-    function () { return Array.from(this._applications.keys()); };
+    TestabilityRegistry.prototype.getAllRootElements = function () { return Array.from(this._applications.keys()); };
     /**
      * Find testability of a node in the Tree
      * @param elem node
      * @param findInAncestors whether finding testability in ancestors if testability was not found in
      * current node
      */
-    /**
-       * Find testability of a node in the Tree
-       * @param elem node
-       * @param findInAncestors whether finding testability in ancestors if testability was not found in
-       * current node
-       */
-    TestabilityRegistry.prototype.findTestabilityInTree = /**
-       * Find testability of a node in the Tree
-       * @param elem node
-       * @param findInAncestors whether finding testability in ancestors if testability was not found in
-       * current node
-       */
-    function (elem, findInAncestors) {
+    TestabilityRegistry.prototype.findTestabilityInTree = function (elem, findInAncestors) {
         if (findInAncestors === void 0) { findInAncestors = true; }
         return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);
     };
@@ -4708,8 +4281,6 @@ function getPlatform() {
  *
  * A page's platform is initialized implicitly when a platform is created via a platform factory
  * (e.g. {@link platformBrowser}), or explicitly by calling the {@link createPlatform} function.
- *
- *
  */
 var PlatformRef = /** @class */ (function () {
     /** @internal */
@@ -4723,7 +4294,8 @@ var PlatformRef = /** @class */ (function () {
      * Creates an instance of an `@NgModule` for the given platform
      * for offline compilation.
      *
-     * ## Simple Example
+     * @usageNotes
+     * ### Simple Example
      *
      * ```typescript
      * my_module.ts:
@@ -4742,53 +4314,7 @@ var PlatformRef = /** @class */ (function () {
      *
      * @experimental APIs related to application bootstrap are currently under review.
      */
-    /**
-       * Creates an instance of an `@NgModule` for the given platform
-       * for offline compilation.
-       *
-       * ## Simple Example
-       *
-       * ```typescript
-       * my_module.ts:
-       *
-       * @NgModule({
-       *   imports: [BrowserModule]
-       * })
-       * class MyModule {}
-       *
-       * main.ts:
-       * import {MyModuleNgFactory} from './my_module.ngfactory';
-       * import {platformBrowser} from '@angular/platform-browser';
-       *
-       * let moduleRef = platformBrowser().bootstrapModuleFactory(MyModuleNgFactory);
-       * ```
-       *
-       * @experimental APIs related to application bootstrap are currently under review.
-       */
-    PlatformRef.prototype.bootstrapModuleFactory = /**
-       * Creates an instance of an `@NgModule` for the given platform
-       * for offline compilation.
-       *
-       * ## Simple Example
-       *
-       * ```typescript
-       * my_module.ts:
-       *
-       * @NgModule({
-       *   imports: [BrowserModule]
-       * })
-       * class MyModule {}
-       *
-       * main.ts:
-       * import {MyModuleNgFactory} from './my_module.ngfactory';
-       * import {platformBrowser} from '@angular/platform-browser';
-       *
-       * let moduleRef = platformBrowser().bootstrapModuleFactory(MyModuleNgFactory);
-       * ```
-       *
-       * @experimental APIs related to application bootstrap are currently under review.
-       */
-    function (moduleFactory, options) {
+    PlatformRef.prototype.bootstrapModuleFactory = function (moduleFactory, options) {
         var _this = this;
         // Note: We need to create the NgZone _before_ we instantiate the module,
         // as instantiating the module creates some providers eagerly.
@@ -4807,10 +4333,8 @@ var PlatformRef = /** @class */ (function () {
                 throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');
             }
             moduleRef.onDestroy(function () { return remove(_this._modules, moduleRef); });
-            ngZone.runOutsideAngular(function () {
-                return ngZone.onError.subscribe({ next: function (error) { exceptionHandler.handleError(error); } });
-            });
-            return _callAndReportToErrorHandler(exceptionHandler, (ngZone), function () {
+            ngZone.runOutsideAngular(function () { return ngZone.onError.subscribe({ next: function (error) { exceptionHandler.handleError(error); } }); });
+            return _callAndReportToErrorHandler(exceptionHandler, ngZone, function () {
                 var initStatus = moduleRef.injector.get(ApplicationInitStatus);
                 initStatus.runInitializers();
                 return initStatus.donePromise.then(function () {
@@ -4823,7 +4347,8 @@ var PlatformRef = /** @class */ (function () {
     /**
      * Creates an instance of an `@NgModule` for a given platform using the given runtime compiler.
      *
-     * ## Simple Example
+     * @usageNotes
+     * ### Simple Example
      *
      * ```typescript
      * @NgModule({
@@ -4835,37 +4360,7 @@ var PlatformRef = /** @class */ (function () {
      * ```
      *
      */
-    /**
-       * Creates an instance of an `@NgModule` for a given platform using the given runtime compiler.
-       *
-       * ## Simple Example
-       *
-       * ```typescript
-       * @NgModule({
-       *   imports: [BrowserModule]
-       * })
-       * class MyModule {}
-       *
-       * let moduleRef = platformBrowser().bootstrapModule(MyModule);
-       * ```
-       *
-       */
-    PlatformRef.prototype.bootstrapModule = /**
-       * Creates an instance of an `@NgModule` for a given platform using the given runtime compiler.
-       *
-       * ## Simple Example
-       *
-       * ```typescript
-       * @NgModule({
-       *   imports: [BrowserModule]
-       * })
-       * class MyModule {}
-       *
-       * let moduleRef = platformBrowser().bootstrapModule(MyModule);
-       * ```
-       *
-       */
-    function (moduleType, compilerOptions) {
+    PlatformRef.prototype.bootstrapModule = function (moduleType, compilerOptions) {
         var _this = this;
         if (compilerOptions === void 0) { compilerOptions = []; }
         var compilerFactory = this.injector.get(CompilerFactory);
@@ -4891,36 +4386,20 @@ var PlatformRef = /** @class */ (function () {
     /**
      * Register a listener to be called when the platform is disposed.
      */
-    /**
-       * Register a listener to be called when the platform is disposed.
-       */
-    PlatformRef.prototype.onDestroy = /**
-       * Register a listener to be called when the platform is disposed.
-       */
-    function (callback) { this._destroyListeners.push(callback); };
+    PlatformRef.prototype.onDestroy = function (callback) { this._destroyListeners.push(callback); };
     Object.defineProperty(PlatformRef.prototype, "injector", {
         /**
          * Retrieve the platform {@link Injector}, which is the parent injector for
          * every Angular application on the page and provides singleton providers.
          */
-        get: /**
-           * Retrieve the platform {@link Injector}, which is the parent injector for
-           * every Angular application on the page and provides singleton providers.
-           */
-        function () { return this._injector; },
+        get: function () { return this._injector; },
         enumerable: true,
         configurable: true
     });
     /**
      * Destroy the Angular platform and all Angular applications on the page.
      */
-    /**
-       * Destroy the Angular platform and all Angular applications on the page.
-       */
-    PlatformRef.prototype.destroy = /**
-       * Destroy the Angular platform and all Angular applications on the page.
-       */
-    function () {
+    PlatformRef.prototype.destroy = function () {
         if (this._destroyed) {
             throw new Error('The platform has already been destroyed!');
         }
@@ -4938,7 +4417,7 @@ var PlatformRef = /** @class */ (function () {
     ];
     /** @nocollapse */
     PlatformRef.ctorParameters = function () { return [
-        { type: Injector, },
+        { type: Injector }
     ]; };
     return PlatformRef;
 }());
@@ -4982,8 +4461,6 @@ function optionsReducer(dst, objs) {
 }
 /**
  * A reference to an Angular application running on a page.
- *
- *
  */
 var ApplicationRef = /** @class */ (function () {
     /** @internal */
@@ -5001,13 +4478,13 @@ var ApplicationRef = /** @class */ (function () {
         this._enforceNoNewChanges = false;
         this._stable = true;
         /**
-           * Get a list of component types registered to this application.
-           * This list is populated even before the component is created.
-           */
+         * Get a list of component types registered to this application.
+         * This list is populated even before the component is created.
+         */
         this.componentTypes = [];
         /**
-           * Get a list of components registered to this application.
-           */
+         * Get a list of components registered to this application.
+         */
         this.components = [];
         this._enforceNoNewChanges = isDevMode();
         this._zone.onMicrotaskEmpty.subscribe({ next: function () { _this._zone.run(function () { _this.tick(); }); } });
@@ -5055,49 +4532,20 @@ var ApplicationRef = /** @class */ (function () {
     /**
      * Bootstrap a new component at the root level of the application.
      *
+     * @usageNotes
      * ### Bootstrap process
      *
      * When bootstrapping a new root component into an application, Angular mounts the
-     * specified application component onto DOM elements identified by the [componentType]'s
+     * specified application component onto DOM elements identified by the componentType's
      * selector and kicks off automatic change detection to finish initializing the component.
      *
      * Optionally, a component can be mounted onto a DOM element that does not match the
-     * [componentType]'s selector.
+     * componentType's selector.
      *
      * ### Example
      * {@example core/ts/platform/platform.ts region='longform'}
      */
-    /**
-       * Bootstrap a new component at the root level of the application.
-       *
-       * ### Bootstrap process
-       *
-       * When bootstrapping a new root component into an application, Angular mounts the
-       * specified application component onto DOM elements identified by the [componentType]'s
-       * selector and kicks off automatic change detection to finish initializing the component.
-       *
-       * Optionally, a component can be mounted onto a DOM element that does not match the
-       * [componentType]'s selector.
-       *
-       * ### Example
-       * {@example core/ts/platform/platform.ts region='longform'}
-       */
-    ApplicationRef.prototype.bootstrap = /**
-       * Bootstrap a new component at the root level of the application.
-       *
-       * ### Bootstrap process
-       *
-       * When bootstrapping a new root component into an application, Angular mounts the
-       * specified application component onto DOM elements identified by the [componentType]'s
-       * selector and kicks off automatic change detection to finish initializing the component.
-       *
-       * Optionally, a component can be mounted onto a DOM element that does not match the
-       * [componentType]'s selector.
-       *
-       * ### Example
-       * {@example core/ts/platform/platform.ts region='longform'}
-       */
-    function (componentOrFactory, rootSelectorOrNode) {
+    ApplicationRef.prototype.bootstrap = function (componentOrFactory, rootSelectorOrNode) {
         var _this = this;
         if (!this._initStatus.done) {
             throw new Error('Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.');
@@ -5108,7 +4556,7 @@ var ApplicationRef = /** @class */ (function () {
         }
         else {
             componentFactory =
-                (this._componentFactoryResolver.resolveComponentFactory(componentOrFactory));
+                this._componentFactoryResolver.resolveComponentFactory(componentOrFactory);
         }
         this.componentTypes.push(componentFactory.componentType);
         // Create a factory associated with the current module if it's not bound to some other
@@ -5139,27 +4587,7 @@ var ApplicationRef = /** @class */ (function () {
      * In this case, Angular throws an error, since an Angular application can only have one change
      * detection pass during which all change detection must complete.
      */
-    /**
-       * Invoke this method to explicitly process change detection and its side-effects.
-       *
-       * In development mode, `tick()` also performs a second change detection cycle to ensure that no
-       * further changes are detected. If additional changes are picked up during this second cycle,
-       * bindings in the app have side-effects that cannot be resolved in a single change detection
-       * pass.
-       * In this case, Angular throws an error, since an Angular application can only have one change
-       * detection pass during which all change detection must complete.
-       */
-    ApplicationRef.prototype.tick = /**
-       * Invoke this method to explicitly process change detection and its side-effects.
-       *
-       * In development mode, `tick()` also performs a second change detection cycle to ensure that no
-       * further changes are detected. If additional changes are picked up during this second cycle,
-       * bindings in the app have side-effects that cannot be resolved in a single change detection
-       * pass.
-       * In this case, Angular throws an error, since an Angular application can only have one change
-       * detection pass during which all change detection must complete.
-       */
-    function () {
+    ApplicationRef.prototype.tick = function () {
         var _this = this;
         if (this._runningTick) {
             throw new Error('ApplicationRef.tick is called recursively');
@@ -5186,17 +4614,7 @@ var ApplicationRef = /** @class */ (function () {
      * The view will be automatically detached when it is destroyed.
      * This will throw if the view is already attached to a ViewContainer.
      */
-    /**
-       * Attaches a view so that it will be dirty checked.
-       * The view will be automatically detached when it is destroyed.
-       * This will throw if the view is already attached to a ViewContainer.
-       */
-    ApplicationRef.prototype.attachView = /**
-       * Attaches a view so that it will be dirty checked.
-       * The view will be automatically detached when it is destroyed.
-       * This will throw if the view is already attached to a ViewContainer.
-       */
-    function (viewRef) {
+    ApplicationRef.prototype.attachView = function (viewRef) {
         var view = viewRef;
         this._views.push(view);
         view.attachToAppRef(this);
@@ -5204,13 +4622,7 @@ var ApplicationRef = /** @class */ (function () {
     /**
      * Detaches a view from dirty checking again.
      */
-    /**
-       * Detaches a view from dirty checking again.
-       */
-    ApplicationRef.prototype.detachView = /**
-       * Detaches a view from dirty checking again.
-       */
-    function (viewRef) {
+    ApplicationRef.prototype.detachView = function (viewRef) {
         var view = viewRef;
         remove(this._views, view);
         view.detachFromAppRef();
@@ -5228,9 +4640,7 @@ var ApplicationRef = /** @class */ (function () {
         remove(this.components, componentRef);
     };
     /** @internal */
-    /** @internal */
-    ApplicationRef.prototype.ngOnDestroy = /** @internal */
-    function () {
+    ApplicationRef.prototype.ngOnDestroy = function () {
         // TODO(alxhub): Dispose of the NgZone.
         this._views.slice().forEach(function (view) { return view.destroy(); });
     };
@@ -5238,10 +4648,7 @@ var ApplicationRef = /** @class */ (function () {
         /**
          * Returns the number of attached views.
          */
-        get: /**
-           * Returns the number of attached views.
-           */
-        function () { return this._views.length; },
+        get: function () { return this._views.length; },
         enumerable: true,
         configurable: true
     });
@@ -5252,12 +4659,12 @@ var ApplicationRef = /** @class */ (function () {
     ];
     /** @nocollapse */
     ApplicationRef.ctorParameters = function () { return [
-        { type: NgZone, },
-        { type: Console, },
-        { type: Injector, },
-        { type: ErrorHandler, },
-        { type: ComponentFactoryResolver, },
-        { type: ApplicationInitStatus, },
+        { type: NgZone },
+        { type: Console },
+        { type: Injector },
+        { type: ErrorHandler },
+        { type: ComponentFactoryResolver },
+        { type: ApplicationInitStatus }
     ]; };
     return ApplicationRef;
 }());
@@ -5275,6 +4682,7 @@ function remove(list, el) {
  * 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
  */
+// Public API for Zone
 
 /**
  * @license
@@ -5344,13 +4752,7 @@ var RendererFactory2 = /** @class */ (function () {
 /**
  * @experimental
  */
-/**
- * @experimental
- */
 
-/**
- * @experimental
- */
 (function (RendererStyleFlags2) {
     RendererStyleFlags2[RendererStyleFlags2["Important"] = 1] = "Important";
     RendererStyleFlags2[RendererStyleFlags2["DashCase"] = 2] = "DashCase";
@@ -5371,6 +4773,7 @@ var Renderer2 = /** @class */ (function () {
  * 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
  */
+// Public API for render
 
 /**
  * @license
@@ -5465,14 +4868,14 @@ function getModuleFactory(id) {
  *
  * NOTE: In the future this class will implement an `Observable` interface.
  *
- * ### Example ([live demo](http://plnkr.co/edit/RX8sJnQYl9FWuSCWme5z?p=preview))
+ * @usageNotes
+ * ### Example
  * ```typescript
  * @Component({...})
  * class Container {
  *   @ViewChildren(Item) items:QueryList<Item>;
  * }
  * ```
- *
  */
 var QueryList = /** @class */ (function () {
     function QueryList() {
@@ -5485,86 +4888,38 @@ var QueryList = /** @class */ (function () {
      * See
      * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
      */
-    /**
-       * See
-       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
-       */
-    QueryList.prototype.map = /**
-       * See
-       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
-       */
-    function (fn) { return this._results.map(fn); };
+    QueryList.prototype.map = function (fn) { return this._results.map(fn); };
     /**
      * See
      * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
      */
-    /**
-       * See
-       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
-       */
-    QueryList.prototype.filter = /**
-       * See
-       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
-       */
-    function (fn) {
+    QueryList.prototype.filter = function (fn) {
         return this._results.filter(fn);
     };
     /**
      * See
      * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
      */
-    /**
-       * See
-       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
-       */
-    QueryList.prototype.find = /**
-       * See
-       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
-       */
-    function (fn) {
+    QueryList.prototype.find = function (fn) {
         return this._results.find(fn);
     };
     /**
      * See
      * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
      */
-    /**
-       * See
-       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
-       */
-    QueryList.prototype.reduce = /**
-       * See
-       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
-       */
-    function (fn, init) {
+    QueryList.prototype.reduce = function (fn, init) {
         return this._results.reduce(fn, init);
     };
     /**
      * See
      * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
      */
-    /**
-       * See
-       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
-       */
-    QueryList.prototype.forEach = /**
-       * See
-       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
-       */
-    function (fn) { this._results.forEach(fn); };
+    QueryList.prototype.forEach = function (fn) { this._results.forEach(fn); };
     /**
      * See
      * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
      */
-    /**
-       * See
-       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
-       */
-    QueryList.prototype.some = /**
-       * See
-       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
-       */
-    function (fn) {
+    QueryList.prototype.some = function (fn) {
         return this._results.some(fn);
     };
     QueryList.prototype.toArray = function () { return this._results.slice(); };
@@ -5579,13 +4934,9 @@ var QueryList = /** @class */ (function () {
     };
     QueryList.prototype.notifyOnChanges = function () { this.changes.emit(this); };
     /** internal */
+    QueryList.prototype.setDirty = function () { this.dirty = true; };
     /** internal */
-    QueryList.prototype.setDirty = /** internal */
-    function () { this.dirty = true; };
-    /** internal */
-    /** internal */
-    QueryList.prototype.destroy = /** internal */
-    function () {
+    QueryList.prototype.destroy = function () {
         this.changes.complete();
         this.changes.unsubscribe();
     };
@@ -5662,8 +5013,8 @@ var SystemJsNgModuleLoader = /** @class */ (function () {
     ];
     /** @nocollapse */
     SystemJsNgModuleLoader.ctorParameters = function () { return [
-        { type: Compiler, },
-        { type: SystemJsNgModuleLoaderConfig, decorators: [{ type: Optional },] },
+        { type: Compiler },
+        { type: SystemJsNgModuleLoaderConfig, decorators: [{ type: Optional }] }
     ]; };
     return SystemJsNgModuleLoader;
 }());
@@ -5766,9 +5117,10 @@ var ViewRef = /** @class */ (function (_super) {
  *
  * Properties of elements in a View can change, but the structure (number and order) of elements in
  * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
- * removing nested Views via a {@link ViewContainerRef}. Each View can contain many View Containers.
+ * removing nested Views via a `ViewContainerRef`. Each View can contain many View Containers.
  * <!-- /TODO -->
  *
+ * @usageNotes
  * ### Example
  *
  * Given this template...
@@ -5780,9 +5132,10 @@ var ViewRef = /** @class */ (function (_super) {
  * </ul>
  * ```
  *
- * We have two {@link TemplateRef}s:
+ * We have two `TemplateRef`s:
+ *
+ * Outer `TemplateRef`:
  *
- * Outer {@link TemplateRef}:
  * ```
  * Count: {{items.length}}
  * <ul>
@@ -5790,14 +5143,15 @@ var ViewRef = /** @class */ (function (_super) {
  * </ul>
  * ```
  *
- * Inner {@link TemplateRef}:
+ * Inner `TemplateRef`:
+ *
  * ```
  *   <li>{{item}}</li>
  * ```
  *
- * Notice that the original template is broken down into two separate {@link TemplateRef}s.
+ * Notice that the original template is broken down into two separate `TemplateRef`s.
  *
- * The outer/inner {@link TemplateRef}s are then assembled into views like so:
+ * The outer/inner `TemplateRef`s are then assembled into views like so:
  *
  * ```
  * <!-- ViewRef: outer-0 -->
@@ -5826,6 +5180,7 @@ var EmbeddedViewRef = /** @class */ (function (_super) {
  * 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
  */
+// Public API for compiler
 
 /**
  * @license
@@ -6060,26 +5415,14 @@ var WrappedValue = /** @class */ (function () {
         this.wrapped = value;
     }
     /** Creates a wrapped value. */
-    /** Creates a wrapped value. */
-    WrappedValue.wrap = /** Creates a wrapped value. */
-    function (value) { return new WrappedValue(value); };
+    WrappedValue.wrap = function (value) { return new WrappedValue(value); };
     /**
      * Returns the underlying value of a wrapped value.
      * Returns the given `value` when it is not wrapped.
      **/
-    /**
-       * Returns the underlying value of a wrapped value.
-       * Returns the given `value` when it is not wrapped.
-       **/
-    WrappedValue.unwrap = /**
-       * Returns the underlying value of a wrapped value.
-       * Returns the given `value` when it is not wrapped.
-       **/
-    function (value) { return WrappedValue.isWrapped(value) ? value.wrapped : value; };
+    WrappedValue.unwrap = function (value) { return WrappedValue.isWrapped(value) ? value.wrapped : value; };
     /** Returns true if `value` is a wrapped value. */
-    /** Returns true if `value` is a wrapped value. */
-    WrappedValue.isWrapped = /** Returns true if `value` is a wrapped value. */
-    function (value) { return value instanceof WrappedValue; };
+    WrappedValue.isWrapped = function (value) { return value instanceof WrappedValue; };
     return WrappedValue;
 }());
 /**
@@ -6095,13 +5438,7 @@ var SimpleChange = /** @class */ (function () {
     /**
      * Check whether the new value is the first value assigned.
      */
-    /**
-       * Check whether the new value is the first value assigned.
-       */
-    SimpleChange.prototype.isFirstChange = /**
-       * Check whether the new value is the first value assigned.
-       */
-    function () { return this.firstChange; };
+    SimpleChange.prototype.isFirstChange = function () { return this.firstChange; };
     return SimpleChange;
 }());
 function isListLikeIterable(obj) {
@@ -6109,7 +5446,6 @@ function isListLikeIterable(obj) {
         return false;
     return Array.isArray(obj) ||
         (!(obj instanceof Map) && // JS Map are iterables but return entries as [k, v]
-            // JS Map are iterables but return entries as [k, v]
             getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop
 }
 function areIterablesEqual(a, b, comparator) {
@@ -6201,7 +5537,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
             // Order: remove, add, move
             var record = !nextRemove ||
                 nextIt &&
-                    (nextIt.currentIndex) <
+                    nextIt.currentIndex <
                         getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?
                 nextIt :
                 nextRemove;
@@ -6222,7 +5558,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
                     if (!moveOffsets)
                         moveOffsets = [];
                     var localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;
-                    var localCurrentIndex = (currentIndex) - addRemoveOffset;
+                    var localCurrentIndex = currentIndex - addRemoveOffset;
                     if (localMovePreviousIndex != localCurrentIndex) {
                         for (var i = 0; i < localMovePreviousIndex; i++) {
                             var offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);
@@ -6342,10 +5678,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
         /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
          * changes.
          */
-        get: /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
-           * changes.
-           */
-        function () {
+        get: function () {
             return this._additionsHead !== null || this._movesHead !== null ||
                 this._removalsHead !== null || this._identityChangesHead !== null;
         },
@@ -6360,23 +5693,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
      *
      * @internal
      */
-    /**
-       * Reset the state of the change objects to show no changes. This means set previousKey to
-       * currentKey, and clear all of the queues (additions, moves, removals).
-       * Set the previousIndexes of moved and added items to their currentIndexes
-       * Reset the list of additions, moves and removals
-       *
-       * @internal
-       */
-    DefaultIterableDiffer.prototype._reset = /**
-       * Reset the state of the change objects to show no changes. This means set previousKey to
-       * currentKey, and clear all of the queues (additions, moves, removals).
-       * Set the previousIndexes of moved and added items to their currentIndexes
-       * Reset the list of additions, moves and removals
-       *
-       * @internal
-       */
-    function () {
+    DefaultIterableDiffer.prototype._reset = function () {
         if (this.isDirty) {
             var record = void 0;
             var nextRecord = void 0;
@@ -6408,27 +5725,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
      *
      * @internal
      */
-    /**
-       * This is the core function which handles differences between collections.
-       *
-       * - `record` is the record which we saw at this position last time. If null then it is a new
-       *   item.
-       * - `item` is the current item in the collection
-       * - `index` is the position of the item in the collection
-       *
-       * @internal
-       */
-    DefaultIterableDiffer.prototype._mismatch = /**
-       * This is the core function which handles differences between collections.
-       *
-       * - `record` is the record which we saw at this position last time. If null then it is a new
-       *   item.
-       * - `item` is the current item in the collection
-       * - `index` is the position of the item in the collection
-       *
-       * @internal
-       */
-    function (record, item, itemTrackBy, index) {
+    DefaultIterableDiffer.prototype._mismatch = function (record, item, itemTrackBy, index) {
         // The previous record after which we will append the current one.
         var previousRecord;
         if (record === null) {
@@ -6493,64 +5790,10 @@ var DefaultIterableDiffer = /** @class */ (function () {
      *
      * @internal
      */
-    /**
-       * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
-       *
-       * Use case: `[a, a]` => `[b, a, a]`
-       *
-       * If we did not have this check then the insertion of `b` would:
-       *   1) evict first `a`
-       *   2) insert `b` at `0` index.
-       *   3) leave `a` at index `1` as is. <-- this is wrong!
-       *   3) reinsert `a` at index 2. <-- this is wrong!
-       *
-       * The correct behavior is:
-       *   1) evict first `a`
-       *   2) insert `b` at `0` index.
-       *   3) reinsert `a` at index 1.
-       *   3) move `a` at from `1` to `2`.
-       *
-       *
-       * Double check that we have not evicted a duplicate item. We need to check if the item type may
-       * have already been removed:
-       * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
-       * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
-       * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
-       * at the end.
-       *
-       * @internal
-       */
-    DefaultIterableDiffer.prototype._verifyReinsertion = /**
-       * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
-       *
-       * Use case: `[a, a]` => `[b, a, a]`
-       *
-       * If we did not have this check then the insertion of `b` would:
-       *   1) evict first `a`
-       *   2) insert `b` at `0` index.
-       *   3) leave `a` at index `1` as is. <-- this is wrong!
-       *   3) reinsert `a` at index 2. <-- this is wrong!
-       *
-       * The correct behavior is:
-       *   1) evict first `a`
-       *   2) insert `b` at `0` index.
-       *   3) reinsert `a` at index 1.
-       *   3) move `a` at from `1` to `2`.
-       *
-       *
-       * Double check that we have not evicted a duplicate item. We need to check if the item type may
-       * have already been removed:
-       * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
-       * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
-       * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
-       * at the end.
-       *
-       * @internal
-       */
-    function (record, item, itemTrackBy, index) {
+    DefaultIterableDiffer.prototype._verifyReinsertion = function (record, item, itemTrackBy, index) {
         var reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
         if (reinsertRecord !== null) {
-            record = this._reinsertAfter(reinsertRecord, (record._prev), index);
+            record = this._reinsertAfter(reinsertRecord, record._prev, index);
         }
         else if (record.currentIndex != index) {
             record.currentIndex = index;
@@ -6565,21 +5808,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
      *
      * @internal
      */
-    /**
-       * Get rid of any excess {@link IterableChangeRecord_}s from the previous collection
-       *
-       * - `record` The first excess {@link IterableChangeRecord_}.
-       *
-       * @internal
-       */
-    DefaultIterableDiffer.prototype._truncate = /**
-       * Get rid of any excess {@link IterableChangeRecord_}s from the previous collection
-       *
-       * - `record` The first excess {@link IterableChangeRecord_}.
-       *
-       * @internal
-       */
-    function (record) {
+    DefaultIterableDiffer.prototype._truncate = function (record) {
         // Anything after that needs to be removed;
         while (record !== null) {
             var nextRecord = record._next;
@@ -6606,9 +5835,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
         }
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._reinsertAfter = /** @internal */
-    function (record, prevRecord, index) {
+    DefaultIterableDiffer.prototype._reinsertAfter = function (record, prevRecord, index) {
         if (this._unlinkedRecords !== null) {
             this._unlinkedRecords.remove(record);
         }
@@ -6631,18 +5858,14 @@ var DefaultIterableDiffer = /** @class */ (function () {
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._moveAfter = /** @internal */
-    function (record, prevRecord, index) {
+    DefaultIterableDiffer.prototype._moveAfter = function (record, prevRecord, index) {
         this._unlink(record);
         this._insertAfter(record, prevRecord, index);
         this._addToMoves(record, index);
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._addAfter = /** @internal */
-    function (record, prevRecord, index) {
+    DefaultIterableDiffer.prototype._addAfter = function (record, prevRecord, index) {
         this._insertAfter(record, prevRecord, index);
         if (this._additionsTail === null) {
             // TODO(vicb):
@@ -6658,9 +5881,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._insertAfter = /** @internal */
-    function (record, prevRecord, index) {
+    DefaultIterableDiffer.prototype._insertAfter = function (record, prevRecord, index) {
         // TODO(vicb):
         // assert(record != prevRecord);
         // assert(record._next === null);
@@ -6691,15 +5912,11 @@ var DefaultIterableDiffer = /** @class */ (function () {
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._remove = /** @internal */
-    function (record) {
+    DefaultIterableDiffer.prototype._remove = function (record) {
         return this._addToRemovals(this._unlink(record));
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._unlink = /** @internal */
-    function (record) {
+    DefaultIterableDiffer.prototype._unlink = function (record) {
         if (this._linkedRecords !== null) {
             this._linkedRecords.remove(record);
         }
@@ -6723,9 +5940,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._addToMoves = /** @internal */
-    function (record, toIndex) {
+    DefaultIterableDiffer.prototype._addToMoves = function (record, toIndex) {
         // TODO(vicb):
         // assert(record._nextMoved === null);
         if (record.previousIndex === toIndex) {
@@ -6766,9 +5981,7 @@ var DefaultIterableDiffer = /** @class */ (function () {
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultIterableDiffer.prototype._addIdentityChange = /** @internal */
-    function (record, item) {
+    DefaultIterableDiffer.prototype._addIdentityChange = function (record, item) {
         record.item = item;
         if (this._identityChangesTail === null) {
             this._identityChangesTail = this._identityChangesHead = record;
@@ -6822,26 +6035,13 @@ var _DuplicateItemRecordList = /** @class */ (function () {
      *
      * Note: by design all records in the list of duplicates hold the same value in record.item.
      */
-    /**
-       * Append the record to the list of duplicates.
-       *
-       * Note: by design all records in the list of duplicates hold the same value in record.item.
-       */
-    _DuplicateItemRecordList.prototype.add = /**
-       * Append the record to the list of duplicates.
-       *
-       * Note: by design all records in the list of duplicates hold the same value in record.item.
-       */
-    function (record) {
+    _DuplicateItemRecordList.prototype.add = function (record) {
         if (this._head === null) {
             this._head = this._tail = record;
             record._nextDup = null;
             record._prevDup = null;
         }
         else {
-            // TODO(vicb):
-            // assert(record.item ==  _head.item ||
-            //       record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);
             // TODO(vicb):
             // assert(record.item ==  _head.item ||
             //       record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);
@@ -6853,15 +6053,10 @@ var _DuplicateItemRecordList = /** @class */ (function () {
     };
     // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
     // IterableChangeRecord_.currentIndex >= atOrAfterIndex
-    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
-    // IterableChangeRecord_.currentIndex >= atOrAfterIndex
-    _DuplicateItemRecordList.prototype.get = 
-    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
-    // IterableChangeRecord_.currentIndex >= atOrAfterIndex
-    function (trackById, atOrAfterIndex) {
+    _DuplicateItemRecordList.prototype.get = function (trackById, atOrAfterIndex) {
         var record;
         for (record = this._head; record !== null; record = record._nextDup) {
-            if ((atOrAfterIndex === null || atOrAfterIndex <= (record.currentIndex)) &&
+            if ((atOrAfterIndex === null || atOrAfterIndex <= record.currentIndex) &&
                 looseIdentical(record.trackById, trackById)) {
                 return record;
             }
@@ -6873,17 +6068,7 @@ var _DuplicateItemRecordList = /** @class */ (function () {
      *
      * Returns whether the list of duplicates is empty.
      */
-    /**
-       * Remove one {@link IterableChangeRecord_} from the list of duplicates.
-       *
-       * Returns whether the list of duplicates is empty.
-       */
-    _DuplicateItemRecordList.prototype.remove = /**
-       * Remove one {@link IterableChangeRecord_} from the list of duplicates.
-       *
-       * Returns whether the list of duplicates is empty.
-       */
-    function (record) {
+    _DuplicateItemRecordList.prototype.remove = function (record) {
         // TODO(vicb):
         // assert(() {
         //  // verify that the record being removed is in the list.
@@ -6930,21 +6115,7 @@ var _DuplicateMap = /** @class */ (function () {
      * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
      * have any more `a`s needs to return the second `a`.
      */
-    /**
-       * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we
-       * have already iterated over, we use the `atOrAfterIndex` to pretend it is not there.
-       *
-       * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
-       * have any more `a`s needs to return the second `a`.
-       */
-    _DuplicateMap.prototype.get = /**
-       * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we
-       * have already iterated over, we use the `atOrAfterIndex` to pretend it is not there.
-       *
-       * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
-       * have any more `a`s needs to return the second `a`.
-       */
-    function (trackById, atOrAfterIndex) {
+    _DuplicateMap.prototype.get = function (trackById, atOrAfterIndex) {
         var key = trackById;
         var recordList = this.map.get(key);
         return recordList ? recordList.get(trackById, atOrAfterIndex) : null;
@@ -6954,19 +6125,9 @@ var _DuplicateMap = /** @class */ (function () {
      *
      * The list of duplicates also is removed from the map if it gets empty.
      */
-    /**
-       * Removes a {@link IterableChangeRecord_} from the list of duplicates.
-       *
-       * The list of duplicates also is removed from the map if it gets empty.
-       */
-    _DuplicateMap.prototype.remove = /**
-       * Removes a {@link IterableChangeRecord_} from the list of duplicates.
-       *
-       * The list of duplicates also is removed from the map if it gets empty.
-       */
-    function (record) {
+    _DuplicateMap.prototype.remove = function (record) {
         var key = record.trackById;
-        var recordList = (this.map.get(key));
+        var recordList = this.map.get(key);
         // Remove the list of duplicates when it gets empty
         if (recordList.remove(record)) {
             this.map.delete(key);
@@ -7072,15 +6233,7 @@ var DefaultKeyValueDiffer = /** @class */ (function () {
      * Check the current state of the map vs the previous.
      * The algorithm is optimised for when the keys do no change.
      */
-    /**
-       * Check the current state of the map vs the previous.
-       * The algorithm is optimised for when the keys do no change.
-       */
-    DefaultKeyValueDiffer.prototype.check = /**
-       * Check the current state of the map vs the previous.
-       * The algorithm is optimised for when the keys do no change.
-       */
-    function (map) {
+    DefaultKeyValueDiffer.prototype.check = function (map) {
         var _this = this;
         this._reset();
         var insertBefore = this._mapHead;
@@ -7129,23 +6282,7 @@ var DefaultKeyValueDiffer = /** @class */ (function () {
      * - This method updates `this._appendAfter`,
      * - The return value is the new value for the insertion pointer.
      */
-    /**
-       * Inserts a record before `before` or append at the end of the list when `before` is null.
-       *
-       * Notes:
-       * - This method appends at `this._appendAfter`,
-       * - This method updates `this._appendAfter`,
-       * - The return value is the new value for the insertion pointer.
-       */
-    DefaultKeyValueDiffer.prototype._insertBeforeOrAppend = /**
-       * Inserts a record before `before` or append at the end of the list when `before` is null.
-       *
-       * Notes:
-       * - This method appends at `this._appendAfter`,
-       * - This method updates `this._appendAfter`,
-       * - The return value is the new value for the insertion pointer.
-       */
-    function (before, record) {
+    DefaultKeyValueDiffer.prototype._insertBeforeOrAppend = function (before, record) {
         if (before) {
             var prev = before._prev;
             record._next = before;
@@ -7172,7 +6309,7 @@ var DefaultKeyValueDiffer = /** @class */ (function () {
     };
     DefaultKeyValueDiffer.prototype._getOrCreateRecordForKey = function (key, value) {
         if (this._records.has(key)) {
-            var record_1 = (this._records.get(key));
+            var record_1 = this._records.get(key);
             this._maybeAddToChanges(record_1, value);
             var prev = record_1._prev;
             var next = record_1._next;
@@ -7193,9 +6330,7 @@ var DefaultKeyValueDiffer = /** @class */ (function () {
         return record;
     };
     /** @internal */
-    /** @internal */
-    DefaultKeyValueDiffer.prototype._reset = /** @internal */
-    function () {
+    DefaultKeyValueDiffer.prototype._reset = function () {
         if (this.isDirty) {
             var record = void 0;
             // let `_previousMapHead` contain the state of the map before the changes
@@ -7217,10 +6352,7 @@ var DefaultKeyValueDiffer = /** @class */ (function () {
         }
     };
     // Add the record or a given key to the list of changes only when the value has actually changed
-    // Add the record or a given key to the list of changes only when the value has actually changed
-    DefaultKeyValueDiffer.prototype._maybeAddToChanges = 
-    // Add the record or a given key to the list of changes only when the value has actually changed
-    function (record, newValue) {
+    DefaultKeyValueDiffer.prototype._maybeAddToChanges = function (record, newValue) {
         if (!looseIdentical(newValue, record.currentValue)) {
             record.previousValue = record.currentValue;
             record.currentValue = newValue;
@@ -7246,9 +6378,7 @@ var DefaultKeyValueDiffer = /** @class */ (function () {
         }
     };
     /** @internal */
-    /** @internal */
-    DefaultKeyValueDiffer.prototype._forEach = /** @internal */
-    function (obj, fn) {
+    DefaultKeyValueDiffer.prototype._forEach = function (obj, fn) {
         if (obj instanceof Map) {
             obj.forEach(fn);
         }
@@ -7306,12 +6436,13 @@ var IterableDiffers = /** @class */ (function () {
      * inherited {@link IterableDiffers} instance with the provided factories and return a new
      * {@link IterableDiffers} instance.
      *
+     * @usageNotes
+     * ### Example
+     *
      * The following example shows how to extend an existing list of factories,
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link IterableDiffer} available.
      *
-     * ### Example
-     *
      * ```
      * @Component({
      *   viewProviders: [
@@ -7320,45 +6451,7 @@ var IterableDiffers = /** @class */ (function () {
      * })
      * ```
      */
-    /**
-       * Takes an array of {@link IterableDifferFactory} and returns a provider used to extend the
-       * inherited {@link IterableDiffers} instance with the provided factories and return a new
-       * {@link IterableDiffers} instance.
-       *
-       * The following example shows how to extend an existing list of factories,
-       * which will only be applied to the injector for this component and its children.
-       * This step is all that's required to make a new {@link IterableDiffer} available.
-       *
-       * ### Example
-       *
-       * ```
-       * @Component({
-       *   viewProviders: [
-       *     IterableDiffers.extend([new ImmutableListDiffer()])
-       *   ]
-       * })
-       * ```
-       */
-    IterableDiffers.extend = /**
-       * Takes an array of {@link IterableDifferFactory} and returns a provider used to extend the
-       * inherited {@link IterableDiffers} instance with the provided factories and return a new
-       * {@link IterableDiffers} instance.
-       *
-       * The following example shows how to extend an existing list of factories,
-       * which will only be applied to the injector for this component and its children.
-       * This step is all that's required to make a new {@link IterableDiffer} available.
-       *
-       * ### Example
-       *
-       * ```
-       * @Component({
-       *   viewProviders: [
-       *     IterableDiffers.extend([new ImmutableListDiffer()])
-       *   ]
-       * })
-       * ```
-       */
-    function (factories) {
+    IterableDiffers.extend = function (factories) {
         return {
             provide: IterableDiffers,
             useFactory: function (parent) {
@@ -7420,12 +6513,13 @@ var KeyValueDiffers = /** @class */ (function () {
      * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
      * {@link KeyValueDiffers} instance.
      *
+     * @usageNotes
+     * ### Example
+     *
      * The following example shows how to extend an existing list of factories,
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link KeyValueDiffer} available.
      *
-     * ### Example
-     *
      * ```
      * @Component({
      *   viewProviders: [
@@ -7434,45 +6528,7 @@ var KeyValueDiffers = /** @class */ (function () {
      * })
      * ```
      */
-    /**
-       * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
-       * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
-       * {@link KeyValueDiffers} instance.
-       *
-       * The following example shows how to extend an existing list of factories,
-       * which will only be applied to the injector for this component and its children.
-       * This step is all that's required to make a new {@link KeyValueDiffer} available.
-       *
-       * ### Example
-       *
-       * ```
-       * @Component({
-       *   viewProviders: [
-       *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
-       *   ]
-       * })
-       * ```
-       */
-    KeyValueDiffers.extend = /**
-       * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
-       * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
-       * {@link KeyValueDiffers} instance.
-       *
-       * The following example shows how to extend an existing list of factories,
-       * which will only be applied to the injector for this component and its children.
-       * This step is all that's required to make a new {@link KeyValueDiffer} available.
-       *
-       * ### Example
-       *
-       * ```
-       * @Component({
-       *   viewProviders: [
-       *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
-       *   ]
-       * })
-       * ```
-       */
-    function (factories) {
+    KeyValueDiffers.extend = function (factories) {
         return {
             provide: KeyValueDiffers,
             useFactory: function (parent) {
@@ -7522,6 +6578,11 @@ var defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
  * 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
  */
+/**
+ * @module
+ * @description
+ * Change detection enables data binding in Angular.
+ */
 
 /**
  * @license
@@ -7556,8 +6617,9 @@ var platformCore = createPlatformFactory(null, 'core', _CORE_PLATFORM_PROVIDERS)
  * It is used for i18n extraction, by i18n pipes (DatePipe, I18nPluralPipe, CurrencyPipe,
  * DecimalPipe and PercentPipe) and by ICU expressions.
  *
- * See the {@linkDocs guide/i18n#setting-up-locale i18n guide} for more information.
+ * See the [i18n guide](guide/i18n#setting-up-locale) for more information.
  *
+ * @usageNotes
  * ### Example
  *
  * ```typescript
@@ -7577,8 +6639,9 @@ var LOCALE_ID = new InjectionToken('LocaleId');
  * Use this token at bootstrap to provide the content of your translation file (`xtb`,
  * `xlf` or `xlf2`) when you want to translate your application in another language.
  *
- * See the {@linkDocs guide/i18n#merge i18n guide} for more information.
+ * See the [i18n guide](guide/i18n#merge) for more information.
  *
+ * @usageNotes
  * ### Example
  *
  * ```typescript
@@ -7601,8 +6664,9 @@ var TRANSLATIONS = new InjectionToken('Translations');
  * Provide this token at bootstrap to set the format of your {@link TRANSLATIONS}: `xtb`,
  * `xlf` or `xlf2`.
  *
- * See the {@linkDocs guide/i18n#merge i18n guide} for more information.
+ * See the [i18n guide](guide/i18n#merge) for more information.
  *
+ * @usageNotes
  * ### Example
  *
  * ```typescript
@@ -7625,30 +6689,9 @@ var TRANSLATIONS_FORMAT = new InjectionToken('TranslationsFormat');
  * - Warning (default): show a warning in the console and/or shell.
  * - Ignore: do nothing.
  *
- * See the {@linkDocs guide/i18n#missing-translation i18n guide} for more information.
- *
- * ### Example
- * ```typescript
- * import { MissingTranslationStrategy } from '@angular/core';
- * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
- * import { AppModule } from './app/app.module';
- *
- * platformBrowserDynamic().bootstrapModule(AppModule, {
- *   missingTranslation: MissingTranslationStrategy.Error
- * });
- * ```
- *
- * @experimental i18n support is experimental.
- */
-/**
- * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy
- * that the compiler should use in case of missing translations:
- * - Error: throw if you have missing translations.
- * - Warning (default): show a warning in the console and/or shell.
- * - Ignore: do nothing.
- *
- * See the {@linkDocs guide/i18n#missing-translation i18n guide} for more information.
+ * See the [i18n guide](guide/i18n#missing-translation) for more information.
  *
+ * @usageNotes
  * ### Example
  * ```typescript
  * import { MissingTranslationStrategy } from '@angular/core';
@@ -7663,28 +6706,6 @@ var TRANSLATIONS_FORMAT = new InjectionToken('TranslationsFormat');
  * @experimental i18n support is experimental.
  */
 
-/**
- * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy
- * that the compiler should use in case of missing translations:
- * - Error: throw if you have missing translations.
- * - Warning (default): show a warning in the console and/or shell.
- * - Ignore: do nothing.
- *
- * See the {@linkDocs guide/i18n#missing-translation i18n guide} for more information.
- *
- * ### Example
- * ```typescript
- * import { MissingTranslationStrategy } from '@angular/core';
- * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
- * import { AppModule } from './app/app.module';
- *
- * platformBrowserDynamic().bootstrapModule(AppModule, {
- *   missingTranslation: MissingTranslationStrategy.Error
- * });
- * ```
- *
- * @experimental i18n support is experimental.
- */
 (function (MissingTranslationStrategy) {
     MissingTranslationStrategy[MissingTranslationStrategy["Error"] = 0] = "Error";
     MissingTranslationStrategy[MissingTranslationStrategy["Warning"] = 1] = "Warning";
@@ -7736,7 +6757,7 @@ var ApplicationModule = /** @class */ (function () {
     ];
     /** @nocollapse */
     ApplicationModule.ctorParameters = function () { return [
-        { type: ApplicationRef, },
+        { type: ApplicationRef }
     ]; };
     return ApplicationModule;
 }());
@@ -7796,17 +6817,7 @@ var InertBodyHelper = /** @class */ (function () {
      * See
      * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449
      */
-    /**
-       * Use XHR to create and fill an inert body element (on Safari 10.1)
-       * See
-       * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449
-       */
-    InertBodyHelper.prototype.getInertBodyElement_XHR = /**
-       * Use XHR to create and fill an inert body element (on Safari 10.1)
-       * See
-       * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449
-       */
-    function (html) {
+    InertBodyHelper.prototype.getInertBodyElement_XHR = function (html) {
         // We add these extra elements to ensure that the rest of the content is parsed as expected
         // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the
         // `<head>` tag.
@@ -7822,7 +6833,7 @@ var InertBodyHelper = /** @class */ (function () {
         xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);
         xhr.send(null);
         var body = xhr.response.body;
-        body.removeChild((body.firstChild));
+        body.removeChild(body.firstChild);
         return body;
     };
     /**
@@ -7830,17 +6841,7 @@ var InertBodyHelper = /** @class */ (function () {
      * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7
      *
      */
-    /**
-       * Use DOMParser to create and fill an inert body element (on Firefox)
-       * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7
-       *
-       */
-    InertBodyHelper.prototype.getInertBodyElement_DOMParser = /**
-       * Use DOMParser to create and fill an inert body element (on Firefox)
-       * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7
-       *
-       */
-    function (html) {
+    InertBodyHelper.prototype.getInertBodyElement_DOMParser = function (html) {
         // We add these extra elements to ensure that the rest of the content is parsed as expected
         // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the
         // `<head>` tag.
@@ -7850,7 +6851,7 @@ var InertBodyHelper = /** @class */ (function () {
                 .DOMParser()
                 .parseFromString(html, 'text/html')
                 .body;
-            body.removeChild((body.firstChild));
+            body.removeChild(body.firstChild);
             return body;
         }
         catch (e) {
@@ -7863,19 +6864,7 @@ var InertBodyHelper = /** @class */ (function () {
      * This is the default sane strategy to use if the browser does not require one of the specialised
      * strategies above.
      */
-    /**
-       * Use an HTML5 `template` element, if supported, or an inert body element created via
-       * `createHtmlDocument` to create and fill an inert DOM element.
-       * This is the default sane strategy to use if the browser does not require one of the specialised
-       * strategies above.
-       */
-    InertBodyHelper.prototype.getInertBodyElement_InertDocument = /**
-       * Use an HTML5 `template` element, if supported, or an inert body element created via
-       * `createHtmlDocument` to create and fill an inert DOM element.
-       * This is the default sane strategy to use if the browser does not require one of the specialised
-       * strategies above.
-       */
-    function (html) {
+    InertBodyHelper.prototype.getInertBodyElement_InertDocument = function (html) {
         // Prefer using <template> element if supported.
         var templateEl = this.inertDocument.createElement('template');
         if ('content' in templateEl) {
@@ -7898,23 +6887,7 @@ var InertBodyHelper = /** @class */ (function () {
      * This is undesirable since we don't want to allow any of these custom attributes. This method
      * strips them all.
      */
-    /**
-       * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'
-       * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.
-       * 'ns1:xlink:foo').
-       *
-       * This is undesirable since we don't want to allow any of these custom attributes. This method
-       * strips them all.
-       */
-    InertBodyHelper.prototype.stripCustomNsAttrs = /**
-       * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'
-       * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.
-       * 'ns1:xlink:foo').
-       *
-       * This is undesirable since we don't want to allow any of these custom attributes. This method
-       * strips them all.
-       */
-    function (el) {
+    InertBodyHelper.prototype.stripCustomNsAttrs = function (el) {
         var elAttrs = el.attributes;
         // loop backwards so that we can support removals.
         for (var i = elAttrs.length - 1; 0 < i; i--) {
@@ -8100,20 +7073,20 @@ var SanitizingHtmlSerializer = /** @class */ (function () {
         // This cannot use a TreeWalker, as it has to run on Angular's various DOM adapters.
         // However this code never accesses properties off of `document` before deleting its contents
         // again, so it shouldn't be vulnerable to DOM clobbering.
-        var current = (el.firstChild);
+        var current = el.firstChild;
         while (current) {
             if (current.nodeType === Node.ELEMENT_NODE) {
                 this.startElement(current);
             }
             else if (current.nodeType === Node.TEXT_NODE) {
-                this.chars((current.nodeValue));
+                this.chars(current.nodeValue);
             }
             else {
                 // Strip non-element, non-text nodes.
                 this.sanitizedSomething = true;
             }
             if (current.firstChild) {
-                current = (current.firstChild);
+                current = current.firstChild;
                 continue;
             }
             while (current) {
@@ -8121,12 +7094,12 @@ var SanitizingHtmlSerializer = /** @class */ (function () {
                 if (current.nodeType === Node.ELEMENT_NODE) {
                     this.endElement(current);
                 }
-                var next = this.checkClobberedElement(current, (current.nextSibling));
+                var next = this.checkClobberedElement(current, current.nextSibling);
                 if (next) {
                     current = next;
                     break;
                 }
-                current = this.checkClobberedElement(current, (current.parentNode));
+                current = this.checkClobberedElement(current, current.parentNode);
             }
         }
         return this.buf.join('');
@@ -8224,7 +7197,7 @@ function _sanitizeHtml(defaultDoc, unsafeHtmlInput) {
             inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
         } while (unsafeHtml !== parsedHtml);
         var sanitizer = new SanitizingHtmlSerializer();
-        var safeHtml = sanitizer.sanitizeChildren(getTemplateContent((inertBodyElement)) || inertBodyElement);
+        var safeHtml = sanitizer.sanitizeChildren(getTemplateContent(inertBodyElement) || inertBodyElement);
         if (isDevMode() && sanitizer.sanitizedSomething) {
             console.warn('WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).');
         }
@@ -8348,22 +7321,6 @@ function _sanitizeStyle(value) {
  * 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
  */
-/**
- * @license
- * Copyright Google Inc. 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
- */
-/**
- * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
- * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
- * handled.
- *
- * See DomSanitizer for more details on security in Angular applications.
- *
- *
- */
 /**
  * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
  * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
@@ -8374,15 +7331,6 @@ function _sanitizeStyle(value) {
  *
  */
 
-/**
- * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
- * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
- * handled.
- *
- * See DomSanitizer for more details on security in Angular applications.
- *
- *
- */
 (function (SecurityContext) {
     SecurityContext[SecurityContext["NONE"] = 0] = "NONE";
     SecurityContext[SecurityContext["HTML"] = 1] = "HTML";
@@ -8481,23 +7429,23 @@ var DebugContext = /** @class */ (function () {
  * debug mode can hook it. It is lazily filled when `isDevMode` is known.
  */
 var Services = {
-    setCurrentNode: (undefined),
-    createRootView: (undefined),
-    createEmbeddedView: (undefined),
-    createComponentView: (undefined),
-    createNgModuleRef: (undefined),
-    overrideProvider: (undefined),
-    overrideComponentView: (undefined),
-    clearOverrides: (undefined),
-    checkAndUpdateView: (undefined),
-    checkNoChangesView: (undefined),
-    destroyView: (undefined),
-    resolveDep: (undefined),
-    createDebugContext: (undefined),
-    handleEvent: (undefined),
-    updateDirectives: (undefined),
-    updateRenderer: (undefined),
-    dirtyParentQueries: (undefined),
+    setCurrentNode: undefined,
+    createRootView: undefined,
+    createEmbeddedView: undefined,
+    createComponentView: undefined,
+    createNgModuleRef: undefined,
+    overrideProvider: undefined,
+    overrideComponentView: undefined,
+    clearOverrides: undefined,
+    checkAndUpdateView: undefined,
+    checkNoChangesView: undefined,
+    destroyView: undefined,
+    resolveDep: undefined,
+    createDebugContext: undefined,
+    handleEvent: undefined,
+    updateDirectives: undefined,
+    updateRenderer: undefined,
+    dirtyParentQueries: undefined,
 };
 
 /**
@@ -8761,7 +7709,7 @@ function rootRenderNodes(view) {
 function visitRootRenderNodes(view, action, parentNode, nextSibling, target) {
     // We need to re-compute the parent node in case the nodes have been moved around manually
     if (action === 3 /* RemoveChild */) {
-        parentNode = view.renderer.parentNode(renderNode(view, (view.def.lastRenderRootNode)));
+        parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode));
     }
     visitSiblingRenderNodes(view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);
 }
@@ -8781,13 +7729,13 @@ function visitProjectedRenderNodes(view, ngContentIndex, action, parentNode, nex
         compView = compView.parent;
     }
     var hostView = compView.parent;
-    var hostElDef = viewParentEl((compView));
+    var hostElDef = viewParentEl(compView);
     var startIndex = hostElDef.nodeIndex + 1;
     var endIndex = hostElDef.nodeIndex + hostElDef.childCount;
     for (var i = startIndex; i <= endIndex; i++) {
         var nodeDef = hostView.def.nodes[i];
         if (nodeDef.ngContentIndex === ngContentIndex) {
-            visitRenderNode((hostView), nodeDef, action, parentNode, nextSibling, target);
+            visitRenderNode(hostView, nodeDef, action, parentNode, nextSibling, target);
         }
         // jump to next sibling
         i += nodeDef.childCount;
@@ -8853,7 +7801,7 @@ function execRenderNodeAction(view, renderNode, action, parentNode, nextSibling,
 var NS_PREFIX_RE = /^:([^:]+):(.+)$/;
 function splitNamespace(name) {
     if (name[0] === ':') {
-        var match = (name.match(NS_PREFIX_RE));
+        var match = name.match(NS_PREFIX_RE);
         return [match[1], match[2]];
     }
     return ['', name];
@@ -8962,8 +7910,8 @@ function elementDef(checkIndex, flags, matchedQueriesDsl, ngContentIndex, childC
         handleEvent = NOOP;
     }
     var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;
-    var ns = (null);
-    var name = (null);
+    var ns = null;
+    var name = null;
     if (namespaceAndName) {
         _b = __read(splitNamespace(namespaceAndName), 2), ns = _b[0], name = _b[1];
     }
@@ -8972,8 +7920,8 @@ function elementDef(checkIndex, flags, matchedQueriesDsl, ngContentIndex, childC
     for (var i = 0; i < bindings.length; i++) {
         var _c = __read(bindings[i], 3), bindingFlags = _c[0], namespaceAndName_1 = _c[1], suffixOrSecurityContext = _c[2];
         var _d = __read(splitNamespace(namespaceAndName_1), 2), ns_1 = _d[0], name_1 = _d[1];
-        var securityContext = (undefined);
-        var suffix = (undefined);
+        var securityContext = undefined;
+        var suffix = undefined;
         switch (bindingFlags & 15 /* Types */) {
             case 4 /* TypeElementStyle */:
                 suffix = suffixOrSecurityContext;
@@ -9044,7 +7992,7 @@ function elementDef(checkIndex, flags, matchedQueriesDsl, ngContentIndex, childC
     var _b;
 }
 function createElement(view, renderHost, def) {
-    var elDef = (def.element);
+    var elDef = def.element;
     var rootSelectorOrNode = view.root.selectorOrNode;
     var renderer = view.renderer;
     var el;
@@ -9128,7 +8076,7 @@ function checkAndUpdateElementValue(view, def, bindingIdx, value) {
     var binding = def.bindings[bindingIdx];
     var elData = asElementData(view, def.nodeIndex);
     var renderNode$$1 = elData.renderElement;
-    var name = (binding.name);
+    var name = binding.name;
     switch (binding.flags & 15 /* Types */) {
         case 1 /* TypeElementAttribute */:
             setElementAttribute(view, binding, renderNode$$1, binding.ns, name, value);
@@ -9298,6 +8246,9 @@ function resolveNgModuleDep(data, depDef, notFoundValue) {
             return (data._providers[index] =
                 _createProviderInstance$1(data, data._def.providersByKey[depDef.tokenKey]));
         }
+        else if (depDef.flags & 4 /* Self */) {
+            return notFoundValue;
+        }
         return data._parent.get(depDef.token, notFoundValue);
     }
     finally {
@@ -9406,10 +8357,10 @@ function attachEmbeddedView(parentView, elementData, viewIndex, view) {
         viewIndex = embeddedViews.length;
     }
     view.viewContainerParent = parentView;
-    addToArray(embeddedViews, (viewIndex), view);
+    addToArray(embeddedViews, viewIndex, view);
     attachProjectedView(elementData, view);
     Services.dirtyParentQueries(view);
-    var prevView = (viewIndex) > 0 ? embeddedViews[(viewIndex) - 1] : null;
+    var prevView = viewIndex > 0 ? embeddedViews[viewIndex - 1] : null;
     renderAttachEmbeddedView(elementData, prevView, view);
 }
 function attachProjectedView(vcElementData, view) {
@@ -9433,7 +8384,7 @@ function attachProjectedView(vcElementData, view) {
     projectedViews.push(view);
     // Note: we are changing the NodeDef here as we cannot calculate
     // the fact whether a template is used for projection during compilation.
-    markNodeAsProjectedTemplate(view.parent.def, (view.parentNodeDef));
+    markNodeAsProjectedTemplate(view.parent.def, view.parentNodeDef);
 }
 function markNodeAsProjectedTemplate(viewDef, nodeDef) {
     if (nodeDef.flags & 4 /* ProjectedTemplate */) {
@@ -9493,7 +8444,7 @@ function moveEmbeddedView(elementData, oldViewIndex, newViewIndex) {
     return view;
 }
 function renderAttachEmbeddedView(elementData, prevView, view) {
-    var prevRenderNode = prevView ? renderNode(prevView, (prevView.def.lastRenderRootNode)) :
+    var prevRenderNode = prevView ? renderNode(prevView, prevView.def.lastRenderRootNode) :
         elementData.renderElement;
     var parentNode = view.renderer.parentNode(prevRenderNode);
     var nextSibling = view.renderer.nextSibling(prevRenderNode);
@@ -9557,7 +8508,7 @@ var ComponentFactory_ = /** @class */ (function (_super) {
     Object.defineProperty(ComponentFactory_.prototype, "inputs", {
         get: function () {
             var inputsArr = [];
-            var inputs = (this._inputs);
+            var inputs = this._inputs;
             for (var propName in inputs) {
                 var templateName = inputs[propName];
                 inputsArr.push({ propName: propName, templateName: templateName });
@@ -9582,13 +8533,7 @@ var ComponentFactory_ = /** @class */ (function (_super) {
     /**
      * Creates a new component.
      */
-    /**
-       * Creates a new component.
-       */
-    ComponentFactory_.prototype.create = /**
-       * Creates a new component.
-       */
-    function (injector, projectableNodes, rootSelectorOrNode, ngModule) {
+    ComponentFactory_.prototype.create = function (injector, projectableNodes, rootSelectorOrNode, ngModule) {
         if (!ngModule) {
             throw new Error('ngModule should be provided');
         }
@@ -9646,8 +8591,8 @@ var ViewContainerRef_ = /** @class */ (function () {
         this._elDef = _elDef;
         this._data = _data;
         /**
-           * @internal
-           */
+         * @internal
+         */
         this._embeddedViews = [];
     }
     Object.defineProperty(ViewContainerRef_.prototype, "element", {
@@ -9666,7 +8611,7 @@ var ViewContainerRef_ = /** @class */ (function () {
             var elDef = this._elDef.parent;
             while (!elDef && view) {
                 elDef = viewParentEl(view);
-                view = (view.parent);
+                view = view.parent;
             }
             return view ? new Injector_(view, elDef) : new Injector_(this._view, null);
         },
@@ -9676,7 +8621,7 @@ var ViewContainerRef_ = /** @class */ (function () {
     ViewContainerRef_.prototype.clear = function () {
         var len = this._embeddedViews.length;
         for (var i = len - 1; i >= 0; i--) {
-            var view = (detachEmbeddedView(this._data, i));
+            var view = detachEmbeddedView(this._data, i);
             Services.destroyView(view);
         }
     };
@@ -9829,7 +8774,7 @@ var TemplateRef_ = /** @class */ (function (_super) {
         return _this;
     }
     TemplateRef_.prototype.createEmbeddedView = function (context) {
-        return new ViewRef_(Services.createEmbeddedView(this._parentView, this._def, (this._def.element.template), context));
+        return new ViewRef_(Services.createEmbeddedView(this._parentView, this._def, this._def.element.template, context));
     };
     Object.defineProperty(TemplateRef_.prototype, "elementRef", {
         get: function () {
@@ -10108,13 +9053,13 @@ function createPipeInstance(view, def) {
     // pipes can see the private services of the component
     var allowPrivateServices = true;
     // pipes are always eager and classes!
-    return createClass((compView.parent), (viewParentEl(compView)), allowPrivateServices, def.provider.value, def.provider.deps);
+    return createClass(compView.parent, viewParentEl(compView), allowPrivateServices, def.provider.value, def.provider.deps);
 }
 function createDirectiveInstance(view, def) {
     // components can see other private services, other directives can't.
     var allowPrivateServices = (def.flags & 32768 /* Component */) > 0;
     // directives are always eager and classes!
-    var instance = createClass(view, (def.parent), allowPrivateServices, def.provider.value, def.provider.deps);
+    var instance = createClass(view, def.parent, allowPrivateServices, def.provider.value, def.provider.deps);
     if (def.outputs.length) {
         for (var i = 0; i < def.outputs.length; i++) {
             var output = def.outputs[i];
@@ -10131,7 +9076,7 @@ function checkAndUpdateDirectiveInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7
     var providerData = asProviderData(view, def.nodeIndex);
     var directive = providerData.instance;
     var changed = false;
-    var changes = (undefined);
+    var changes = undefined;
     var bindLen = def.bindings.length;
     if (bindLen > 0 && checkBinding(view, def, 0, v0)) {
         changed = true;
@@ -10189,7 +9134,7 @@ function checkAndUpdateDirectiveDynamic(view, def, values) {
     var providerData = asProviderData(view, def.nodeIndex);
     var directive = providerData.instance;
     var changed = false;
-    var changes = (undefined);
+    var changes = undefined;
     for (var i = 0; i < values.length; i++) {
         if (checkBinding(view, def, i, values[i])) {
             changed = true;
@@ -10214,11 +9159,11 @@ function _createProviderInstance(view, def) {
     var providerDef = def.provider;
     switch (def.flags & 201347067 /* Types */) {
         case 512 /* TypeClassProvider */:
-            return createClass(view, (def.parent), allowPrivateServices, providerDef.value, providerDef.deps);
+            return createClass(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);
         case 1024 /* TypeFactoryProvider */:
-            return callFactory(view, (def.parent), allowPrivateServices, providerDef.value, providerDef.deps);
+            return callFactory(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);
         case 2048 /* TypeUseExistingProvider */:
-            return resolveDep(view, (def.parent), allowPrivateServices, providerDef.deps[0]);
+            return resolveDep(view, def.parent, allowPrivateServices, providerDef.deps[0]);
         case 256 /* TypeValueProvider */:
             return providerDef.value;
     }
@@ -10296,7 +9241,7 @@ function resolveDep(view, elDef, allowPrivateServices, depDef, notFoundValue) {
     }
     if (elDef && (depDef.flags & 1 /* SkipSelf */)) {
         allowPrivateServices = false;
-        elDef = (elDef.parent);
+        elDef = elDef.parent;
     }
     var searchView = view;
     while (searchView) {
@@ -10341,8 +9286,8 @@ function resolveDep(view, elDef, allowPrivateServices, depDef, notFoundValue) {
             }
         }
         allowPrivateServices = isComponentView(searchView);
-        elDef = (viewParentEl(searchView));
-        searchView = (searchView.parent);
+        elDef = viewParentEl(searchView);
+        searchView = searchView.parent;
         if (depDef.flags & 4 /* Self */) {
             searchView = null;
         }
@@ -10380,7 +9325,7 @@ function updateProp(view, providerData, def, bindingIdx, value, changes) {
         }
     }
     var binding = def.bindings[bindingIdx];
-    var propName = (binding.name);
+    var propName = binding.name;
     // Note: This is still safe with Closure Compiler as
     // the user passed in the property name as an object has to `providerDef`,
     // so Closure Compiler will have renamed the property correctly already.
@@ -10552,7 +9497,7 @@ function createQuery() {
 function dirtyParentQueries(view) {
     var queryIds = view.def.nodeMatchedQueries;
     while (view.parent && isEmbeddedView(view)) {
-        var tplDef = (view.parentNodeDef);
+        var tplDef = view.parentNodeDef;
         view = view.parent;
         // content queries
         var end = tplDef.nodeIndex + tplDef.childCount;
@@ -10589,14 +9534,14 @@ function checkAndUpdateQuery(view, nodeDef) {
         return;
     }
     var directiveInstance;
-    var newValues = (undefined);
+    var newValues = undefined;
     if (nodeDef.flags & 67108864 /* TypeContentQuery */) {
-        var elementDef = (nodeDef.parent.parent);
-        newValues = calcQueryValues(view, elementDef.nodeIndex, elementDef.nodeIndex + elementDef.childCount, (nodeDef.query), []);
+        var elementDef = nodeDef.parent.parent;
+        newValues = calcQueryValues(view, elementDef.nodeIndex, elementDef.nodeIndex + elementDef.childCount, nodeDef.query, []);
         directiveInstance = asProviderData(view, nodeDef.parent.nodeIndex).instance;
     }
     else if (nodeDef.flags & 134217728 /* TypeViewQuery */) {
-        newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, (nodeDef.query), []);
+        newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, nodeDef.query, []);
         directiveInstance = view.component;
     }
     queryList.reset(newValues);
@@ -11123,7 +10068,6 @@ function viewDef(flags, nodes, updateDirectives, updateRenderer) {
             if (!currentElementHasPublicProviders) {
                 currentElementHasPublicProviders = true;
                 // Use prototypical inheritance to not get O(n^2) complexity...
-                // Use prototypical inheritance to not get O(n^2) complexity...
                 currentParent.element.publicProviders =
                     Object.create(currentParent.element.publicProviders);
                 currentParent.element.allProviders = currentParent.element.publicProviders;
@@ -11137,7 +10081,6 @@ function viewDef(flags, nodes, updateDirectives, updateRenderer) {
                 if (!currentElementHasPrivateProviders) {
                     currentElementHasPrivateProviders = true;
                     // Use prototypical inheritance to not get O(n^2) complexity...
-                    // Use prototypical inheritance to not get O(n^2) complexity...
                     currentParent.element.allProviders =
                         Object.create(currentParent.element.publicProviders);
                 }
@@ -11287,7 +10230,7 @@ function createViewNodes(view) {
     var renderHost;
     if (isComponentView(view)) {
         var hostDef = view.parentNodeDef;
-        renderHost = asElementData((view.parent), hostDef.parent.nodeIndex).renderElement;
+        renderHost = asElementData(view.parent, hostDef.parent.nodeIndex).renderElement;
     }
     var def = view.def;
     var nodes = view.nodes;
@@ -11298,9 +10241,9 @@ function createViewNodes(view) {
         switch (nodeDef.flags & 201347067 /* Types */) {
             case 1 /* TypeElement */:
                 var el = createElement(view, renderHost, nodeDef);
-                var componentView = (undefined);
+                var componentView = undefined;
                 if (nodeDef.flags & 33554432 /* ComponentView */) {
-                    var compViewDef = resolveDefinition((nodeDef.element.componentView));
+                    var compViewDef = resolveDefinition(nodeDef.element.componentView);
                     componentView = Services.createComponentView(view, nodeDef, compViewDef, el);
                 }
                 listenToElementOutputs(view, componentView, nodeDef, el);
@@ -11735,14 +10678,10 @@ function createProdServices() {
         handleEvent: function (view, nodeIndex, eventName, event) {
             return view.def.handleEvent(view, nodeIndex, eventName, event);
         },
-        updateDirectives: function (view, checkType) {
-            return view.def.updateDirectives(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :
-                prodCheckNoChangesNode, view);
-        },
-        updateRenderer: function (view, checkType) {
-            return view.def.updateRenderer(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :
-                prodCheckNoChangesNode, view);
-        },
+        updateDirectives: function (view, checkType) { return view.def.updateDirectives(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :
+            prodCheckNoChangesNode, view); },
+        updateRenderer: function (view, checkType) { return view.def.updateRenderer(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :
+            prodCheckNoChangesNode, view); },
     };
 }
 function createDebugServices() {
@@ -11814,7 +10753,7 @@ function debugOverrideProvider(override) {
 }
 function debugOverrideComponentView(comp, compFactory) {
     var hostViewDef = resolveDefinition(getComponentViewDefinitionFactory(compFactory));
-    var compViewDef = resolveDefinition((hostViewDef.nodes[0].element.componentView));
+    var compViewDef = resolveDefinition(hostViewDef.nodes[0].element.componentView);
     viewDefOverrides.set(comp, compViewDef);
 }
 function debugClearOverrides() {
@@ -11867,7 +10806,7 @@ function applyProviderOverridesToView(def) {
                 return;
             }
             if (nodeDef.flags & 3840 /* CatProviderNoDirective */) {
-                var provider = (nodeDef.provider);
+                var provider = nodeDef.provider;
                 var override = providerOverrides.get(provider.token);
                 if (override) {
                     nodeDef.flags = (nodeDef.flags & ~3840 /* CatProviderNoDirective */) | override.flags;
@@ -12052,11 +10991,11 @@ function debugCheckAndUpdateNode(view, nodeDef, argStyle, givenValues) {
                 var binding = nodeDef.bindings[i];
                 var value = values[i];
                 if (binding.flags & 8 /* TypeProperty */) {
-                    bindingValues[normalizeDebugBindingName((binding.nonMinifiedName))] =
+                    bindingValues[normalizeDebugBindingName(binding.nonMinifiedName)] =
                         normalizeDebugBindingValue(value);
                 }
             }
-            var elDef = (nodeDef.parent);
+            var elDef = nodeDef.parent;
             var el = asElementData(view, elDef.nodeIndex).renderElement;
             if (!elDef.element.name) {
                 // a comment.
@@ -12133,12 +11072,12 @@ var DebugContext_ = /** @class */ (function () {
         var elDef = this.nodeDef;
         var elView = view;
         while (elDef && (elDef.flags & 1 /* TypeElement */) === 0) {
-            elDef = (elDef.parent);
+            elDef = elDef.parent;
         }
         if (!elDef) {
             while (!elDef && elView) {
-                elDef = (viewParentEl(elView));
-                elView = (elView.parent);
+                elDef = viewParentEl(elView);
+                elView = elView.parent;
             }
         }
         this.elDef = elDef;
@@ -12267,7 +11206,7 @@ function getRenderNodeIndex(viewDef$$1, nodeIndex) {
 }
 function findHostElement(view) {
     while (view && !isComponentView(view)) {
-        view = (view.parent);
+        view = view.parent;
     }
     if (view.parent) {
         return asElementData(view.parent, viewParentEl(view).nodeIndex);
@@ -12295,7 +11234,7 @@ function callWithDebugContext(action, fn, self, args) {
         if (isViewDebugError(e) || !_currentView) {
             throw e;
         }
-        throw viewWrappedDebugError(e, (getCurrentDebugContext()));
+        throw viewWrappedDebugError(e, getCurrentDebugContext());
     }
 }
 function getCurrentDebugContext() {
@@ -12332,7 +11271,7 @@ var DebugRenderer2 = /** @class */ (function () {
         this.data = this.delegate.data;
     }
     DebugRenderer2.prototype.destroyNode = function (node) {
-        removeDebugNodeFromIndex((getDebugNode(node)));
+        removeDebugNodeFromIndex(getDebugNode(node));
         if (this.delegate.destroyNode) {
             this.delegate.destroyNode(node);
         }
@@ -12375,7 +11314,7 @@ var DebugRenderer2 = /** @class */ (function () {
     DebugRenderer2.prototype.insertBefore = function (parent, newChild, refChild) {
         var debugEl = getDebugNode(parent);
         var debugChildEl = getDebugNode(newChild);
-        var debugRefEl = (getDebugNode(refChild));
+        var debugRefEl = getDebugNode(refChild);
         if (debugEl && debugChildEl && debugEl instanceof DebugElement) {
             debugEl.insertBefore(debugRefEl, debugChildEl);
         }
@@ -12664,7 +11603,7 @@ function queueDestroyHooks(def, tView, i) {
  */
 function executeInitHooks(currentView, tView, creationMode) {
     if (currentView.lifecycleStage === 1 /* Init */) {
-        executeHooks((currentView.directives), tView.initHooks, tView.checkHooks, creationMode);
+        executeHooks(currentView.directives, tView.initHooks, tView.checkHooks, creationMode);
         currentView.lifecycleStage = 2 /* AfterInit */;
     }
 }
@@ -12779,9 +11718,7 @@ function typeName(type) {
  * found in the LICENSE file at https://angular.io/license
  */
 // TODO: cleanup once the code is merged in angular/angular
-// TODO: cleanup once the code is merged in angular/angular
 var RendererStyleFlags3;
-// TODO: cleanup once the code is merged in angular/angular
 (function (RendererStyleFlags3) {
     RendererStyleFlags3[RendererStyleFlags3["Important"] = 1] = "Important";
     RendererStyleFlags3[RendererStyleFlags3["DashCase"] = 2] = "DashCase";
@@ -12893,7 +11830,7 @@ function findNextRNodeSibling(node, stopNode) {
                 if (nativeNode) {
                     return nativeNode;
                 }
-                pNextOrParent = (pNextOrParent.pNextOrParent);
+                pNextOrParent = pNextOrParent.pNextOrParent;
             }
             currentNode = pNextOrParent;
         }
@@ -13011,21 +11948,18 @@ function addRemoveViewFromContainer(container, rootNode, insertMode, beforeNode)
             if (node.type === 3 /* Element */) {
                 if (insertMode) {
                     if (!node.native) {
-                        // If the native element doesn't exist, this is a bound text node that hasn't yet been
-                        // created because update mode has not run (occurs when a bound text node is a root
-                        // node of a dynamically created view). See textBinding() in instructions for ctx.
                         // If the native element doesn't exist, this is a bound text node that hasn't yet been
                         // created because update mode has not run (occurs when a bound text node is a root
                         // node of a dynamically created view). See textBinding() in instructions for ctx.
                         node.native = createTextNode('', renderer);
                     }
                     isProceduralRenderer(renderer) ?
-                        renderer.insertBefore(parent, (node.native), beforeNode) :
-                        parent.insertBefore((node.native), beforeNode, true);
+                        renderer.insertBefore(parent, node.native, beforeNode) :
+                        parent.insertBefore(node.native, beforeNode, true);
                 }
                 else {
-                    isProceduralRenderer(renderer) ? renderer.removeChild(parent, (node.native)) :
-                        parent.removeChild((node.native));
+                    isProceduralRenderer(renderer) ? renderer.removeChild(parent, node.native) :
+                        parent.removeChild(node.native);
                 }
                 nextNode = node.next;
             }
@@ -13207,7 +12141,7 @@ function cleanUpView(view) {
 }
 /** Removes listeners and unsubscribes from output subscriptions */
 function removeListeners(view) {
-    var cleanup = (view.cleanup);
+    var cleanup = view.cleanup;
     if (cleanup != null) {
         for (var i = 0; i < cleanup.length - 1; i += 2) {
             if (typeof cleanup[i] === 'string') {
@@ -13226,14 +12160,14 @@ function executeOnDestroys(view) {
     var tView = view.tView;
     var destroyHooks;
     if (tView != null && (destroyHooks = tView.destroyHooks) != null) {
-        callHooks((view.directives), destroyHooks);
+        callHooks(view.directives, destroyHooks);
     }
 }
 /** Calls pipe destroy hooks for this view */
 function executePipeOnDestroys(view) {
     var pipeDestroyHooks = view.tView && view.tView.pipeDestroyHooks;
     if (pipeDestroyHooks) {
-        callHooks((view.data), pipeDestroyHooks);
+        callHooks(view.data, pipeDestroyHooks);
     }
 }
 /**
@@ -13287,13 +12221,13 @@ function appendChild(parent, child, currentView) {
  * @param currentView Current LView
  */
 function insertChild(node, currentView) {
-    var parent = (node.parent);
+    var parent = node.parent;
     if (canInsertNativeNode(parent, currentView)) {
         var nativeSibling = findNextRNodeSibling(node, null);
         var renderer = currentView.renderer;
         isProceduralRenderer(renderer) ?
-            renderer.insertBefore((parent.native), (node.native), nativeSibling) :
-            parent.native.insertBefore((node.native), nativeSibling, false);
+            renderer.insertBefore(parent.native, node.native, nativeSibling) :
+            parent.native.insertBefore(node.native, nativeSibling, false);
     }
 }
 /**
@@ -13355,7 +12289,7 @@ function isCssClassMatching(nodeClassAttrVal, cssClassToMatch) {
 function isNodeMatchingSelector(tNode, selector) {
     ngDevMode && assertNotNull(selector[0], 'Selector should have a tag name');
     var mode = 4;
-    var nodeAttrs = (tNode.attrs);
+    var nodeAttrs = tNode.attrs;
     // When processing ":not" selectors, we skip to the next ":not" if the
     // current one doesn't match
     var skipToNextSelector = false;
@@ -13564,7 +12498,7 @@ var tData;
  * as we enter the view. Declaring the type as `null` would require us to place `!`
  * in most instructions since they all assume that `currentView` is defined.
  */
-var currentView = (null);
+var currentView = null;
 var currentQueries;
 function getCurrentQueries(QueryType) {
     // top level variables should not be exported for performance reason (PERF_NOTES.md)
@@ -13654,7 +12588,7 @@ function enterView(newView, host) {
  */
 function leaveView(newView) {
     if (!checkNoChangesMode) {
-        executeHooks((directives), currentView.tView.viewHooks, currentView.tView.viewCheckHooks, creationMode);
+        executeHooks(directives, currentView.tView.viewHooks, currentView.tView.viewCheckHooks, creationMode);
     }
     // Views should be clean and in update mode after being checked, so these bits are cleared
     currentView.flags &= ~(1 /* CreationMode */ | 4 /* Dirty */);
@@ -13674,7 +12608,7 @@ function refreshDirectives() {
 /** Sets the host bindings for the current view. */
 function setHostBindings(bindings) {
     if (bindings != null) {
-        var defs = (currentView.tView.directives);
+        var defs = currentView.tView.directives;
         for (var i = 0; i < bindings.length; i += 2) {
             var dirIndex = bindings[i];
             var def = defs[dirIndex];
@@ -13694,17 +12628,15 @@ function executeInitAndContentHooks() {
     if (!checkNoChangesMode) {
         var tView = currentView.tView;
         executeInitHooks(currentView, tView, creationMode);
-        executeHooks((directives), tView.contentHooks, tView.contentCheckHooks, creationMode);
+        executeHooks(directives, tView.contentHooks, tView.contentCheckHooks, creationMode);
     }
 }
 function createLView(viewId, renderer, tView, template, context, flags) {
     var newView = {
         parent: currentView,
         id: viewId,
-        // -1 for component views
         flags: flags | 1 /* CreationMode */ | 8 /* Attached */,
-        node: (null),
-        // until we initialize it in createNode.
+        node: null,
         data: [],
         directives: null,
         tView: tView,
@@ -13794,12 +12726,15 @@ function createLNode(index, type, native, state) {
     isParent = true;
     return node;
 }
+//////////////////////////
+//// Render
+//////////////////////////
 /**
  * Resets the application state.
  */
 function resetApplicationState() {
     isParent = false;
-    previousOrParentNode = (null);
+    previousOrParentNode = null;
 }
 /**
  *
@@ -13818,7 +12753,7 @@ function renderEmbeddedTemplate(viewNode, template, context, renderer, directive
     var oldView;
     try {
         isParent = true;
-        previousOrParentNode = (null);
+        previousOrParentNode = null;
         var rf = 2;
         if (viewNode == null) {
             var tView = getOrCreateTView(template, directives || null, pipes || null);
@@ -13832,7 +12767,7 @@ function renderEmbeddedTemplate(viewNode, template, context, renderer, directive
         refreshDynamicChildren();
     }
     finally {
-        leaveView((oldView));
+        leaveView(oldView);
         isParent = _isParent;
         previousOrParentNode = _previousOrParentNode;
     }
@@ -13845,7 +12780,7 @@ function renderComponentOrTemplate(node, hostView, componentOrContext, template)
             rendererFactory.begin();
         }
         if (template) {
-            template(getRenderFlags(hostView), (componentOrContext));
+            template(getRenderFlags(hostView), componentOrContext);
             refreshDynamicChildren();
             refreshDirectives();
         }
@@ -13877,6 +12812,9 @@ function getRenderFlags(view) {
     return view.flags & 1 /* CreationMode */ ? 1 /* Create */ | 2 /* Update */ :
         2 /* Update */;
 }
+//////////////////////////
+//// Element
+//////////////////////////
 /**
  * Create DOM element. The instruction must later be followed by `elementEnd()` call.
  *
@@ -13893,10 +12831,10 @@ function elementStart(index, name, attrs, localRefs) {
     ngDevMode &&
         assertEqual(currentView.bindingStartIndex, -1, 'elements should be created before any bindings');
     var native = renderer.createElement(name);
-    var node = createLNode(index, 3 /* Element */, (native), null);
+    var node = createLNode(index, 3 /* Element */, native, null);
     if (attrs)
         setUpAttributes(native, attrs);
-    appendChild((node.parent), native, currentView);
+    appendChild(node.parent, native, currentView);
     createDirectivesAndLocals(index, name, attrs, localRefs, null);
     return native;
 }
@@ -13939,7 +12877,7 @@ function findDirectiveMatches(tNode) {
     if (registry) {
         for (var i = 0; i < registry.length; i++) {
             var def = registry[i];
-            if (isNodeMatchingSelectorList(tNode, (def.selectors))) {
+            if (isNodeMatchingSelectorList(tNode, def.selectors)) {
                 if (def.template) {
                     if (tNode.flags & 4096 /* isComponent */)
                         throwMultipleComponentError(tNode);
@@ -13992,12 +12930,12 @@ function isComponent(tNode) {
  * This function instantiates the given directives.
  */
 function instantiateDirectivesDirectly() {
-    var tNode = (previousOrParentNode.tNode);
+    var tNode = previousOrParentNode.tNode;
     var count = tNode.flags & 4095;
     if (count > 0) {
         var start = tNode.flags >> 13;
         var end = start + count;
-        var tDirectives = (currentView.tView.directives);
+        var tDirectives = currentView.tView.directives;
         for (var i = start; i < end; i++) {
             var def = tDirectives[i];
             directiveCreate(i, def.factory(), def);
@@ -14166,7 +13104,7 @@ function listener(eventName, listenerFn, useCapture) {
         native.addEventListener(eventName, wrappedListener, useCapture);
         cleanupFns.push(eventName, native, wrappedListener, useCapture);
     }
-    var tNode = (node.tNode);
+    var tNode = node.tNode;
     if (tNode.outputs === undefined) {
         // if we create TNode here, inputs must be undefined so we know they still need to be
         // checked
@@ -14184,7 +13122,7 @@ function listener(eventName, listenerFn, useCapture) {
  */
 function createOutput(outputs, listener) {
     for (var i = 0; i < outputs.length; i += 2) {
-        ngDevMode && assertDataInRange(outputs[i], (directives));
+        ngDevMode && assertDataInRange(outputs[i], directives);
         var subscription = directives[outputs[i]][outputs[i + 1]].subscribe(listener);
         cleanup.push(subscription.unsubscribe, subscription);
     }
@@ -14196,7 +13134,7 @@ function elementEnd() {
     }
     else {
         ngDevMode && assertHasParent();
-        previousOrParentNode = (previousOrParentNode.parent);
+        previousOrParentNode = previousOrParentNode.parent;
     }
     ngDevMode && assertNodeType(previousOrParentNode, 3 /* Element */);
     var queries = previousOrParentNode.queries;
@@ -14243,7 +13181,7 @@ function elementProperty(index, propName, value, sanitizer) {
     if (value === NO_CHANGE)
         return;
     var node = data[index];
-    var tNode = (node.tNode);
+    var tNode = node.tNode;
     // if tNode.inputs is undefined, a listener has created outputs, but inputs haven't
     // yet been checked
     if (tNode && tNode.inputs === undefined) {
@@ -14293,7 +13231,7 @@ function createTNode(tagName, attrs, data) {
  */
 function setInputsForProperty(inputs, value) {
     for (var i = 0; i < inputs.length; i += 2) {
-        ngDevMode && assertDataInRange(inputs[i], (directives));
+        ngDevMode && assertDataInRange(inputs[i], directives);
         directives[inputs[i]][inputs[i + 1]] = value;
     }
 }
@@ -14311,7 +13249,7 @@ function generatePropertyAliases(tNodeFlags, direction) {
         var start = tNodeFlags >> 13;
         var end = start + count;
         var isInput = direction === 0;
-        var defs = (currentView.tView.directives);
+        var defs = currentView.tView.directives;
         for (var i = start; i < end; i++) {
             var directiveDef = defs[i];
             var propertyAliasMap = isInput ? directiveDef.inputs : directiveDef.outputs;
@@ -14423,6 +13361,9 @@ function elementStyle(index, value) {
         }
     }
 }
+//////////////////////////
+//// Text
+//////////////////////////
 /**
  * Create static text node
  *
@@ -14437,7 +13378,7 @@ function text(index, value) {
     var node = createLNode(index, 3 /* Element */, textNode);
     // Text nodes are self closing.
     isParent = false;
-    appendChild((node.parent), textNode, currentView);
+    appendChild(node.parent, textNode, currentView);
 }
 /**
  * Create text node with binding
@@ -14462,6 +13403,9 @@ function textBinding(index, value) {
         insertChild(existingNode, currentView);
     }
 }
+//////////////////////////
+//// Directive
+//////////////////////////
 /**
  * Create a directive.
  *
@@ -14520,9 +13464,6 @@ function baseDirectiveCreate(index, directive, directiveDef) {
     if (firstTemplatePass) {
         var flags = previousOrParentNode.tNode.flags;
         if ((flags & 4095 /* DirectiveCountMask */) === 0) {
-            // When the first directive is created:
-            // - save the index,
-            // - set the number of directives to 1
             // When the first directive is created:
             // - save the index,
             // - set the number of directives to 1
@@ -14538,7 +13479,7 @@ function baseDirectiveCreate(index, directive, directiveDef) {
     else {
         var diPublic = directiveDef.diPublic;
         if (diPublic)
-            diPublic((directiveDef));
+            diPublic(directiveDef);
     }
     if (directiveDef.attributes != null && previousOrParentNode.type == 3 /* Element */) {
         setUpAttributes(previousOrParentNode.native, directiveDef.attributes);
@@ -14583,7 +13524,7 @@ function setInputsFromAttrs(directiveIndex, instance, inputs, tNode) {
 function generateInitialInputs(directiveIndex, inputs, tNode) {
     var initialInputData = tNode.initialInputs || (tNode.initialInputs = []);
     initialInputData[directiveIndex] = null;
-    var attrs = (tNode.attrs);
+    var attrs = tNode.attrs;
     for (var i = 0; i < attrs.length; i += 2) {
         var attrName = attrs[i];
         var minifiedInputName = inputs[attrName];
@@ -14594,6 +13535,9 @@ function generateInitialInputs(directiveIndex, inputs, tNode) {
     }
     return initialInputData;
 }
+//////////////////////////
+//// ViewContainer & View
+//////////////////////////
 function createLContainer(parentLNode, currentView, template) {
     ngDevMode && assertNotNull(parentLNode, 'containers should have a parent');
     return {
@@ -14669,7 +13613,7 @@ function containerRefreshEnd() {
     else {
         ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);
         ngDevMode && assertHasParent();
-        previousOrParentNode = (previousOrParentNode.parent);
+        previousOrParentNode = previousOrParentNode.parent;
     }
     ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);
     var container = previousOrParentNode;
@@ -14688,7 +13632,7 @@ function refreshDynamicChildren() {
             for (var i = 0; i < container_1.views.length; i++) {
                 var view = container_1.views[i];
                 // The directives and pipes are not needed here as an existing view is only being refreshed.
-                renderEmbeddedTemplate(view, (view.data.template), (view.data.context), renderer);
+                renderEmbeddedTemplate(view, view.data.template, view.data.context, renderer);
             }
         }
     }
@@ -14789,7 +13733,7 @@ function embeddedViewEnd() {
         }
         lContainer.nextIndex++;
     }
-    leaveView((currentView.parent));
+    leaveView(currentView.parent);
     ngDevMode && assertEqual(isParent, false, 'isParent');
     ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);
 }
@@ -14817,6 +13761,7 @@ function setRenderParentInProjectedNodes(renderParent, viewNode) {
         }
     }
 }
+/////////////
 /**
  * Refreshes components by entering the component view and processing its bindings, queries, etc.
  *
@@ -14828,10 +13773,10 @@ function componentRefresh(directiveIndex, elementIndex) {
     var element = data[elementIndex];
     ngDevMode && assertNodeType(element, 3 /* Element */);
     ngDevMode && assertNotNull(element.data, "Component's host node should have an LView attached.");
-    var hostView = (element.data);
+    var hostView = element.data;
     // Only attached CheckAlways components or attached, dirty OnPush components should be checked
     if (viewAttached(hostView) && hostView.flags & (2 /* CheckAlways */ | 4 /* Dirty */)) {
-        ngDevMode && assertDataInRange(directiveIndex, (directives));
+        ngDevMode && assertDataInRange(directiveIndex, directives);
         var def = currentView.tView.directives[directiveIndex];
         detectChangesInternal(hostView, element, def, getDirectiveInstance(directives[directiveIndex]));
     }
@@ -14874,7 +13819,7 @@ function projectionDef(index, selectors, textSelectors) {
         // - there are selectors defined
         // - a node has a tag name / attributes that can be matched
         if (selectors && componentChild.tNode) {
-            var matchedIdx = matchingSelectorIndex(componentChild.tNode, selectors, (textSelectors));
+            var matchedIdx = matchingSelectorIndex(componentChild.tNode, selectors, textSelectors);
             distributedNodes[matchedIdx].push(componentChild);
         }
         else {
@@ -14961,7 +13906,7 @@ function findComponentHost(lView) {
     var viewRootLNode = lView.node;
     while (viewRootLNode.type === 2 /* View */) {
         ngDevMode && assertNotNull(lView.parent, 'lView.parent');
-        lView = (lView.parent);
+        lView = lView.parent;
         viewRootLNode = lView.node;
     }
     ngDevMode && assertNodeType(viewRootLNode, 3 /* Element */);
@@ -14983,6 +13928,9 @@ function addToViewTree(currentView, state) {
     currentView.tail = state;
     return state;
 }
+///////////////////////////////
+//// Change detection
+///////////////////////////////
 /** If node is an OnPush component, marks its LView dirty. */
 function markDirtyIfOnPush(node) {
     // Because data flows down the component tree, ancestors do not need to be marked dirty
@@ -15294,7 +14242,7 @@ function load(index) {
 /** Retrieves a value from the `directives` array. */
 function loadDirective(index) {
     ngDevMode && assertNotNull(directives, 'Directives array should be defined if reading a dir.');
-    ngDevMode && assertDataInRange(index, (directives));
+    ngDevMode && assertDataInRange(index, directives);
     return directives[index];
 }
 /** Gets the current binding value and increments the binding index. */
@@ -15378,12 +14326,10 @@ var ROOT_DIRECTIVE_INDICES = _ROOT_DIRECTIVE_INDICES;
 var ViewRef$1 = /** @class */ (function () {
     function ViewRef(_view, context) {
         this._view = _view;
-        this.context = (context);
+        this.context = context;
     }
     /** @internal */
-    /** @internal */
-    ViewRef.prototype._setComponentContext = /** @internal */
-    function (view, context) {
+    ViewRef.prototype._setComponentContext = function (view, context) {
         this._view = view;
         this.context = context;
     };
@@ -15401,7 +14347,8 @@ var ViewRef$1 = /** @class */ (function () {
      *
      * <!-- TODO: Add a link to a chapter on OnPush components -->
      *
-     * ### Example ([live demo](https://stackblitz.com/edit/angular-kx7rrw))
+     * @usageNotes
+     * ### Example
      *
      * ```typescript
      * @Component({
@@ -15422,73 +14369,7 @@ var ViewRef$1 = /** @class */ (function () {
      * }
      * ```
      */
-    /**
-       * Marks a view and all of its ancestors dirty.
-       *
-       * It also triggers change detection by calling `scheduleTick` internally, which coalesces
-       * multiple `markForCheck` calls to into one change detection run.
-       *
-       * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is
-       * checked when it needs to be re-rendered but the two normal triggers haven't marked it
-       * dirty (i.e. inputs haven't changed and events haven't fired in the view).
-       *
-       * <!-- TODO: Add a link to a chapter on OnPush components -->
-       *
-       * ### Example ([live demo](https://stackblitz.com/edit/angular-kx7rrw))
-       *
-       * ```typescript
-       * @Component({
-       *   selector: 'my-app',
-       *   template: `Number of ticks: {{numberOfTicks}}`
-       *   changeDetection: ChangeDetectionStrategy.OnPush,
-       * })
-       * class AppComponent {
-       *   numberOfTicks = 0;
-       *
-       *   constructor(private ref: ChangeDetectorRef) {
-       *     setInterval(() => {
-       *       this.numberOfTicks++;
-       *       // the following is required, otherwise the view will not be updated
-       *       this.ref.markForCheck();
-       *     }, 1000);
-       *   }
-       * }
-       * ```
-       */
-    ViewRef.prototype.markForCheck = /**
-       * Marks a view and all of its ancestors dirty.
-       *
-       * It also triggers change detection by calling `scheduleTick` internally, which coalesces
-       * multiple `markForCheck` calls to into one change detection run.
-       *
-       * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is
-       * checked when it needs to be re-rendered but the two normal triggers haven't marked it
-       * dirty (i.e. inputs haven't changed and events haven't fired in the view).
-       *
-       * <!-- TODO: Add a link to a chapter on OnPush components -->
-       *
-       * ### Example ([live demo](https://stackblitz.com/edit/angular-kx7rrw))
-       *
-       * ```typescript
-       * @Component({
-       *   selector: 'my-app',
-       *   template: `Number of ticks: {{numberOfTicks}}`
-       *   changeDetection: ChangeDetectionStrategy.OnPush,
-       * })
-       * class AppComponent {
-       *   numberOfTicks = 0;
-       *
-       *   constructor(private ref: ChangeDetectorRef) {
-       *     setInterval(() => {
-       *       this.numberOfTicks++;
-       *       // the following is required, otherwise the view will not be updated
-       *       this.ref.markForCheck();
-       *     }, 1000);
-       *   }
-       * }
-       * ```
-       */
-    function () { markViewDirty(this._view); };
+    ViewRef.prototype.markForCheck = function () { markViewDirty(this._view); };
     /**
      * Detaches the view from the change detection tree.
      *
@@ -15500,6 +14381,7 @@ var ViewRef$1 = /** @class */ (function () {
      * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
      * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
      *
+     * @usageNotes
      * ### Example
      *
      * The following example defines a component with a large list of readonly data.
@@ -15541,111 +14423,7 @@ var ViewRef$1 = /** @class */ (function () {
      * }
      * ```
      */
-    /**
-       * Detaches the view from the change detection tree.
-       *
-       * Detached views will not be checked during change detection runs until they are
-       * re-attached, even if they are dirty. `detach` can be used in combination with
-       * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change
-       * detection checks.
-       *
-       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
-       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
-       *
-       * ### Example
-       *
-       * The following example defines a component with a large list of readonly data.
-       * Imagine the data changes constantly, many times per second. For performance reasons,
-       * we want to check and update the list every five seconds. We can do that by detaching
-       * the component's change detector and doing a local check every five seconds.
-       *
-       * ```typescript
-       * class DataProvider {
-       *   // in a real application the returned data will be different every time
-       *   get data() {
-       *     return [1,2,3,4,5];
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'giant-list',
-       *   template: `
-       *     <li *ngFor="let d of dataProvider.data">Data {{d}}</li>
-       *   `,
-       * })
-       * class GiantList {
-       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {
-       *     ref.detach();
-       *     setInterval(() => {
-       *       this.ref.detectChanges();
-       *     }, 5000);
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'app',
-       *   providers: [DataProvider],
-       *   template: `
-       *     <giant-list><giant-list>
-       *   `,
-       * })
-       * class App {
-       * }
-       * ```
-       */
-    ViewRef.prototype.detach = /**
-       * Detaches the view from the change detection tree.
-       *
-       * Detached views will not be checked during change detection runs until they are
-       * re-attached, even if they are dirty. `detach` can be used in combination with
-       * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change
-       * detection checks.
-       *
-       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
-       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
-       *
-       * ### Example
-       *
-       * The following example defines a component with a large list of readonly data.
-       * Imagine the data changes constantly, many times per second. For performance reasons,
-       * we want to check and update the list every five seconds. We can do that by detaching
-       * the component's change detector and doing a local check every five seconds.
-       *
-       * ```typescript
-       * class DataProvider {
-       *   // in a real application the returned data will be different every time
-       *   get data() {
-       *     return [1,2,3,4,5];
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'giant-list',
-       *   template: `
-       *     <li *ngFor="let d of dataProvider.data">Data {{d}}</li>
-       *   `,
-       * })
-       * class GiantList {
-       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {
-       *     ref.detach();
-       *     setInterval(() => {
-       *       this.ref.detectChanges();
-       *     }, 5000);
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'app',
-       *   providers: [DataProvider],
-       *   template: `
-       *     <giant-list><giant-list>
-       *   `,
-       * })
-       * class App {
-       * }
-       * ```
-       */
-    function () { this._view.flags &= ~8 /* Attached */; };
+    ViewRef.prototype.detach = function () { this._view.flags &= ~8 /* Attached */; };
     /**
      * Re-attaches a view to the change detection tree.
      *
@@ -15654,7 +14432,8 @@ var ViewRef$1 = /** @class */ (function () {
      *
      * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
      *
-     * ### Example ([live demo](https://stackblitz.com/edit/angular-ymgsxw))
+     * @usageNotes
+     * ### Example
      *
      * The following example creates a component displaying `live` data. The component will detach
      * its change detector from the main change detector tree when the component's live property
@@ -15701,117 +14480,7 @@ var ViewRef$1 = /** @class */ (function () {
      * }
      * ```
      */
-    /**
-       * Re-attaches a view to the change detection tree.
-       *
-       * This can be used to re-attach views that were previously detached from the tree
-       * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.
-       *
-       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
-       *
-       * ### Example ([live demo](https://stackblitz.com/edit/angular-ymgsxw))
-       *
-       * The following example creates a component displaying `live` data. The component will detach
-       * its change detector from the main change detector tree when the component's live property
-       * is set to false.
-       *
-       * ```typescript
-       * class DataProvider {
-       *   data = 1;
-       *
-       *   constructor() {
-       *     setInterval(() => {
-       *       this.data = this.data * 2;
-       *     }, 500);
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'live-data',
-       *   inputs: ['live'],
-       *   template: 'Data: {{dataProvider.data}}'
-       * })
-       * class LiveData {
-       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}
-       *
-       *   set live(value) {
-       *     if (value) {
-       *       this.ref.reattach();
-       *     } else {
-       *       this.ref.detach();
-       *     }
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'my-app',
-       *   providers: [DataProvider],
-       *   template: `
-       *     Live Update: <input type="checkbox" [(ngModel)]="live">
-       *     <live-data [live]="live"><live-data>
-       *   `,
-       * })
-       * class AppComponent {
-       *   live = true;
-       * }
-       * ```
-       */
-    ViewRef.prototype.reattach = /**
-       * Re-attaches a view to the change detection tree.
-       *
-       * This can be used to re-attach views that were previously detached from the tree
-       * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.
-       *
-       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
-       *
-       * ### Example ([live demo](https://stackblitz.com/edit/angular-ymgsxw))
-       *
-       * The following example creates a component displaying `live` data. The component will detach
-       * its change detector from the main change detector tree when the component's live property
-       * is set to false.
-       *
-       * ```typescript
-       * class DataProvider {
-       *   data = 1;
-       *
-       *   constructor() {
-       *     setInterval(() => {
-       *       this.data = this.data * 2;
-       *     }, 500);
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'live-data',
-       *   inputs: ['live'],
-       *   template: 'Data: {{dataProvider.data}}'
-       * })
-       * class LiveData {
-       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}
-       *
-       *   set live(value) {
-       *     if (value) {
-       *       this.ref.reattach();
-       *     } else {
-       *       this.ref.detach();
-       *     }
-       *   }
-       * }
-       *
-       * @Component({
-       *   selector: 'my-app',
-       *   providers: [DataProvider],
-       *   template: `
-       *     Live Update: <input type="checkbox" [(ngModel)]="live">
-       *     <live-data [live]="live"><live-data>
-       *   `,
-       * })
-       * class AppComponent {
-       *   live = true;
-       * }
-       * ```
-       */
-    function () { this._view.flags |= 8 /* Attached */; };
+    ViewRef.prototype.reattach = function () { this._view.flags |= 8 /* Attached */; };
     /**
      * Checks the view and its children.
      *
@@ -15821,6 +14490,7 @@ var ViewRef$1 = /** @class */ (function () {
      * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
      * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
      *
+     * @usageNotes
      * ### Example
      *
      * The following example defines a component with a large list of readonly data.
@@ -15832,66 +14502,14 @@ var ViewRef$1 = /** @class */ (function () {
      *
      * See {@link ChangeDetectorRef#detach detach} for more information.
      */
-    /**
-       * Checks the view and its children.
-       *
-       * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement
-       * local change detection checks.
-       *
-       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
-       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
-       *
-       * ### Example
-       *
-       * The following example defines a component with a large list of readonly data.
-       * Imagine, the data changes constantly, many times per second. For performance reasons,
-       * we want to check and update the list every five seconds.
-       *
-       * We can do that by detaching the component's change detector and doing a local change detection
-       * check every five seconds.
-       *
-       * See {@link ChangeDetectorRef#detach detach} for more information.
-       */
-    ViewRef.prototype.detectChanges = /**
-       * Checks the view and its children.
-       *
-       * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement
-       * local change detection checks.
-       *
-       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
-       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
-       *
-       * ### Example
-       *
-       * The following example defines a component with a large list of readonly data.
-       * Imagine, the data changes constantly, many times per second. For performance reasons,
-       * we want to check and update the list every five seconds.
-       *
-       * We can do that by detaching the component's change detector and doing a local change detection
-       * check every five seconds.
-       *
-       * See {@link ChangeDetectorRef#detach detach} for more information.
-       */
-    function () { detectChanges(this.context); };
+    ViewRef.prototype.detectChanges = function () { detectChanges(this.context); };
     /**
      * Checks the change detector and its children, and throws if any changes are detected.
      *
      * This is used in development mode to verify that running change detection doesn't
      * introduce other changes.
      */
-    /**
-       * Checks the change detector and its children, and throws if any changes are detected.
-       *
-       * This is used in development mode to verify that running change detection doesn't
-       * introduce other changes.
-       */
-    ViewRef.prototype.checkNoChanges = /**
-       * Checks the change detector and its children, and throws if any changes are detected.
-       *
-       * This is used in development mode to verify that running change detection doesn't
-       * introduce other changes.
-       */
-    function () { checkNoChanges(this.context); };
+    ViewRef.prototype.checkNoChanges = function () { checkNoChanges(this.context); };
     return ViewRef;
 }());
 var EmbeddedViewRef$1 = /** @class */ (function (_super) {
@@ -15911,7 +14529,7 @@ var EmbeddedViewRef$1 = /** @class */ (function (_super) {
  */
 function createViewRef(view, context) {
     // TODO: add detectChanges back in when implementing ChangeDetectorRef.detectChanges
-    return addDestroyable(new ViewRef$1((view), context));
+    return addDestroyable(new ViewRef$1(view, context));
 }
 /**
  * Decorates an object with destroy logic (implementing the DestroyRef interface)
@@ -15973,13 +14591,13 @@ function renderComponent(componentType /* Type as workaround for: Microsoft/Type
     var hostNode = locateHostElement(rendererFactory, opts.host || componentTag);
     var rootContext = {
         // Incomplete initialization due to circular reference.
-        component: (null),
+        component: null,
         scheduler: opts.scheduler || requestAnimationFrame.bind(window),
         clean: CLEAN_PROMISE,
     };
     var rootView = createLView(-1, rendererFactory.createRenderer(hostNode, componentDef.rendererType), createTView(null, null), null, rootContext, componentDef.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */);
     rootView.injector = opts.injector || null;
-    var oldView = enterView(rootView, (null));
+    var oldView = enterView(rootView, null);
     var elementNode;
     try {
         if (rendererFactory.begin)
@@ -15987,8 +14605,9 @@ function renderComponent(componentType /* Type as workaround for: Microsoft/Type
         // Create element node at index 0 in data array
         elementNode = hostElement(componentTag, hostNode, componentDef);
         // Create directive instance with factory() and store at index 0 in directives array
-        component = rootContext.component = baseDirectiveCreate(0, componentDef.factory(), componentDef);
-        initChangeDetectorIfExisting(elementNode.nodeInjector, component, (elementNode.data));
+        component = rootContext.component =
+            baseDirectiveCreate(0, componentDef.factory(), componentDef);
+        initChangeDetectorIfExisting(elementNode.nodeInjector, component, elementNode.data);
         opts.hostFeatures && opts.hostFeatures.forEach(function (feature) { return feature(component, componentDef); });
         executeInitAndContentHooks();
         setHostBindings(ROOT_DIRECTIVE_INDICES);
@@ -16248,7 +14867,7 @@ function injectAttribute(attrName) {
     ngDevMode && assertPreviousIsParent();
     var lElement = getPreviousOrParentNode();
     ngDevMode && assertNodeType(lElement, 3 /* Element */);
-    var tElement = (lElement.tNode);
+    var tElement = lElement.tNode;
     ngDevMode && assertNotNull(tElement, 'expecting tNode');
     var attrs = tElement.attrs;
     if (attrs) {
@@ -16270,7 +14889,7 @@ function getOrCreateChangeDetectorRef(di, context) {
     if (di.changeDetectorRef)
         return di.changeDetectorRef;
     var currentNode = di.node;
-    if (isComponent((currentNode.tNode))) {
+    if (isComponent(currentNode.tNode)) {
         return di.changeDetectorRef = createViewRef(currentNode.data, context);
     }
     else if (currentNode.type === 3 /* Element */) {
@@ -16349,7 +14968,7 @@ function getOrCreateInjectable(di, token, flags) {
             if (count !== 0) {
                 var start = flags_1 >> 13;
                 var end = start + count;
-                var defs = (node.view.tView.directives);
+                var defs = node.view.tView.directives;
                 for (var i = start; i < end; i++) {
                     // Get the definition for the directive at this index and, if it is injectable (diPublic),
                     // and matches the given token, return the directive instance.
@@ -16500,8 +15119,8 @@ function getOrCreateContainerRef(di) {
     if (!di.viewContainerRef) {
         var vcRefHost = di.node;
         ngDevMode && assertNodeOfPossibleTypes(vcRefHost, 0 /* Container */, 3 /* Element */);
-        var lContainer = createLContainer((vcRefHost.parent), vcRefHost.view);
-        var lContainerNode = createLNodeObject(0 /* Container */, vcRefHost.view, (vcRefHost.parent), undefined, lContainer, null);
+        var lContainer = createLContainer(vcRefHost.parent, vcRefHost.view);
+        var lContainerNode = createLNodeObject(0 /* Container */, vcRefHost.view, vcRefHost.parent, undefined, lContainer, null);
         vcRefHost.dynamicLContainerNode = lContainerNode;
         addToViewTree(vcRefHost.view, lContainer);
         di.viewContainerRef = new ViewContainerRef$1(lContainerNode);
@@ -16605,7 +15224,7 @@ function getOrCreateTemplateRef(di) {
     ngDevMode && assertNodeType(di.node, 0 /* Container */);
     var data = di.node.data;
     var tView = di.node.view.tView;
-    return di.templateRef || (di.templateRef = new TemplateRef$1(getOrCreateElementRef(di), (data.template), getRenderer(), tView.directiveRegistry, tView.pipeRegistry));
+    return di.templateRef || (di.templateRef = new TemplateRef$1(getOrCreateElementRef(di), data.template, getRenderer(), tView.directiveRegistry, tView.pipeRegistry));
 }
 var TemplateRef$1 = /** @class */ (function () {
     function TemplateRef(elementRef, template, _renderer, _directives, _pipes) {
@@ -16646,13 +15265,13 @@ var TemplateRef$1 = /** @class */ (function () {
  */
 function defineComponent(componentDefinition) {
     var type = componentDefinition.type;
-    var pipeTypes = (componentDefinition.pipes);
-    var directiveTypes = (componentDefinition.directives);
+    var pipeTypes = componentDefinition.pipes;
+    var directiveTypes = componentDefinition.directives;
     var def = {
         type: type,
         diPublic: null,
         factory: componentDefinition.factory,
-        template: componentDefinition.template || (null),
+        template: componentDefinition.template || null,
         hostBindings: componentDefinition.hostBindings || null,
         attributes: componentDefinition.attributes || null,
         inputs: invertObject(componentDefinition.inputs),
@@ -16668,10 +15287,8 @@ function defineComponent(componentDefinition) {
         onDestroy: type.prototype.ngOnDestroy || null,
         onPush: componentDefinition.changeDetection === exports.ChangeDetectionStrategy.OnPush,
         directiveDefs: directiveTypes ?
-            function () {
-                return (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)
-                    .map(extractDirectiveDef);
-            } :
+            function () { return (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)
+                .map(extractDirectiveDef); } :
             null,
         pipeDefs: pipeTypes ?
             function () { return (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef); } :
@@ -17273,7 +15890,7 @@ function getIdxOfMatchingSelector(tNode, selector) {
  * @returns Index of a found directive or null when none found.
  */
 function getIdxOfMatchingDirective(node, type) {
-    var defs = (node.view.tView.directives);
+    var defs = node.view.tView.directives;
     var flags = node.tNode.flags;
     var count = flags & 4095;
     var start = flags >> 13;
@@ -17315,15 +15932,15 @@ function add(query, node) {
             }
         }
         else {
-            var selector = (predicate.selector);
+            var selector = predicate.selector;
             for (var i = 0; i < selector.length; i++) {
                 ngDevMode && assertNotNull(node.tNode, 'node.tNode');
-                var directiveIdx = getIdxOfMatchingSelector((node.tNode), selector[i]);
+                var directiveIdx = getIdxOfMatchingSelector(node.tNode, selector[i]);
                 if (directiveIdx !== null) {
                     // a node is matching a predicate - determine what to read
                     // note that queries using name selector must specify read strategy
                     ngDevMode && assertNotNull(predicate.read, 'the node should have a predicate');
-                    var result = readFromNodeInjector(nodeInjector, node, (predicate.read), directiveIdx);
+                    var result = readFromNodeInjector(nodeInjector, node, predicate.read, directiveIdx);
                     if (result !== null) {
                         addMatch(query, result);
                     }
@@ -17386,86 +16003,38 @@ var QueryList_ = /** @class */ (function () {
      * See
      * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
      */
-    /**
-       * See
-       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
-       */
-    QueryList_.prototype.map = /**
-       * See
-       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
-       */
-    function (fn) { return this._values.map(fn); };
+    QueryList_.prototype.map = function (fn) { return this._values.map(fn); };
     /**
      * See
      * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
      */
-    /**
-       * See
-       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
-       */
-    QueryList_.prototype.filter = /**
-       * See
-       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
-       */
-    function (fn) {
+    QueryList_.prototype.filter = function (fn) {
         return this._values.filter(fn);
     };
     /**
      * See
      * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
      */
-    /**
-       * See
-       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
-       */
-    QueryList_.prototype.find = /**
-       * See
-       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
-       */
-    function (fn) {
+    QueryList_.prototype.find = function (fn) {
         return this._values.find(fn);
     };
     /**
      * See
      * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
      */
-    /**
-       * See
-       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
-       */
-    QueryList_.prototype.reduce = /**
-       * See
-       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
-       */
-    function (fn, init) {
+    QueryList_.prototype.reduce = function (fn, init) {
         return this._values.reduce(fn, init);
     };
     /**
      * See
      * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
      */
-    /**
-       * See
-       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
-       */
-    QueryList_.prototype.forEach = /**
-       * See
-       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
-       */
-    function (fn) { this._values.forEach(fn); };
+    QueryList_.prototype.forEach = function (fn) { this._values.forEach(fn); };
     /**
      * See
      * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
      */
-    /**
-       * See
-       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
-       */
-    QueryList_.prototype.some = /**
-       * See
-       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
-       */
-    function (fn) {
+    QueryList_.prototype.some = function (fn) {
         return this._values.some(fn);
     };
     QueryList_.prototype.toArray = function () { return this._values.slice(0); };
@@ -17692,6 +16261,7 @@ function bypassSanitizationTrustString(trustedString, mode) {
  * 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
  */
+// clang-format off
 
 // clang-format on
 
@@ -17710,6 +16280,11 @@ function bypassSanitizationTrustString(trustedString, mode) {
  * 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
  */
+/**
+ * @module
+ * @description
+ * Entry point from which you should import all public core APIs.
+ */
 
 /**
  * @license
@@ -17718,6 +16293,11 @@ function bypassSanitizationTrustString(trustedString, mode) {
  * 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
  */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
 
 // This file only reexports content of the `src` folder. Keep it that way.
 
@@ -17728,6 +16308,10 @@ function bypassSanitizationTrustString(trustedString, mode) {
  * 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
  */
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
 
 /**
  * Generated bundle index. Do not edit.