@angular/core 10.0.0 → 10.0.4

package/fesm2015/core.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v10.0.0
+ * @license Angular v10.0.4
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -177,7 +177,7 @@ const Optional = makeParamDecorator('Optional');
  */
 const Self = makeParamDecorator('Self');
 /**
- * SkipSelf decorator and metadata.
+ * `SkipSelf` decorator and metadata.
  *
  * @Annotation
  * @publicApi
@@ -638,7 +638,7 @@ function ngDevModeResetPerfCounters() {
  * (and thus Ivy instructions), so a single initialization there is sufficient to ensure ngDevMode
  * is defined for the entire instruction set.
  *
- * When using checking `ngDevMode` on toplevel, always init it before referencing it
+ * When checking `ngDevMode` on toplevel, always init it before referencing it
  * (e.g. `((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode())`), otherwise you can
  *  get a `ReferenceError` like in https://github.com/angular/angular/issues/31595.
  *
@@ -989,10 +989,8 @@ function getFactoryOf(type) {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * Represents an instance of an NgModule created via a {@link NgModuleFactory}.
- *
- * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this
- * NgModule Instance.
+ * Represents an instance of an `NgModule` created by an `NgModuleFactory`.
+ * Provides access to the `NgModule` instance and related objects.
  *
  * @publicApi
  */
@@ -1410,6 +1408,8 @@ function _arrayIndexOfSorted(array, value, shift) {
  * The strategy that the default change detector uses to detect changes.
  * When set, takes effect the next time change detection is triggered.
  *
+ * @see {@link ChangeDetectorRef#usage-notes Change detection usage}
+ *
  * @publicApi
  */
 var ChangeDetectionStrategy;
@@ -3070,10 +3070,10 @@ function assertNodeType(tNode, type) {
     assertDefined(tNode, 'should be called with a TNode');
     assertEqual(tNode.type, type, `should be a ${typeName(type)}`);
 }
-function assertNodeOfPossibleTypes(tNode, ...types) {
+function assertNodeOfPossibleTypes(tNode, types, message) {
     assertDefined(tNode, 'should be called with a TNode');
     const found = types.some(type => tNode.type === type);
-    assertEqual(found, true, `Should be one of ${types.map(typeName).join(', ')} but got ${typeName(tNode.type)}`);
+    assertEqual(found, true, message !== null && message !== void 0 ? message : `Should be one of ${types.map(typeName).join(', ')} but got ${typeName(tNode.type)}`);
 }
 function assertNodeNotOfTypes(tNode, types, message) {
     assertDefined(tNode, 'should be called with a TNode');
@@ -3497,7 +3497,13 @@ let nextNgElementId = 0;
  */
 function bloomAdd(injectorIndex, tView, type) {
     ngDevMode && assertEqual(tView.firstCreatePass, true, 'expected firstCreatePass to be true');
-    let id = typeof type !== 'string' ? type[NG_ELEMENT_ID] : type.charCodeAt(0) || 0;
+    let id;
+    if (typeof type === 'string') {
+        id = type.charCodeAt(0) || 0;
+    }
+    else if (type.hasOwnProperty(NG_ELEMENT_ID)) {
+        id = type[NG_ELEMENT_ID];
+    }
     // Set a unique ID on the directive type, so if something tries to inject the directive,
     // we can easily retrieve the ID and hash it into the bloom bit that should be checked.
     if (id == null) {
@@ -3645,7 +3651,7 @@ function diPublicInInjector(injectorIndex, tView, token) {
  */
 function injectAttributeImpl(tNode, attrNameToInject) {
     ngDevMode &&
-        assertNodeOfPossibleTypes(tNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */);
+        assertNodeOfPossibleTypes(tNode, [0 /* Container */, 3 /* Element */, 4 /* ElementContainer */]);
     ngDevMode && assertDefined(tNode, 'expecting tNode');
     if (attrNameToInject === 'class') {
         return tNode.classes;
@@ -3943,7 +3949,9 @@ function bloomHashBitOrFactory(token) {
     if (typeof token === 'string') {
         return token.charCodeAt(0) || 0;
     }
-    const tokenId = token[NG_ELEMENT_ID];
+    const tokenId = 
+    // First check with `hasOwnProperty` so we don't get an inherited ID.
+    token.hasOwnProperty(NG_ELEMENT_ID) ? token[NG_ELEMENT_ID] : undefined;
     // Negative token IDs are used for special objects such as `Injector`
     return (typeof tokenId === 'number' && tokenId > 0) ? tokenId & BLOOM_MASK : tokenId;
 }
@@ -4342,77 +4350,21 @@ function enableProdMode() {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML
+ * This helper is used to get hold of an inert tree of DOM elements containing dirty HTML
  * that needs sanitizing.
- * Depending upon browser support we must use one of three strategies for doing this.
- * Support: Safari 10.x -> XHR strategy
- * Support: Firefox -> DomParser strategy
- * Default: InertDocument strategy
+ * Depending upon browser support we use one of two strategies for doing this.
+ * Default: DOMParser strategy
+ * Fallback: InertDocument strategy
  */
-class InertBodyHelper {
-    constructor(defaultDoc) {
-        this.defaultDoc = defaultDoc;
-        this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');
-        let inertBodyElement = this.inertDocument.body;
-        if (inertBodyElement == null) {
-            // usually there should be only one body element in the document, but IE doesn't have any, so
-            // we need to create one.
-            const inertHtml = this.inertDocument.createElement('html');
-            this.inertDocument.appendChild(inertHtml);
-            inertBodyElement = this.inertDocument.createElement('body');
-            inertHtml.appendChild(inertBodyElement);
-        }
-        inertBodyElement.innerHTML = '<svg><g onload="this.parentNode.remove()"></g></svg>';
-        if (inertBodyElement.querySelector && !inertBodyElement.querySelector('svg')) {
-            // We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element
-            // so use the XHR strategy.
-            this.getInertBodyElement = this.getInertBodyElement_XHR;
-            return;
-        }
-        inertBodyElement.innerHTML = '<svg><p><style><img src="</style><img src=x onerror=alert(1)//">';
-        if (inertBodyElement.querySelector && inertBodyElement.querySelector('svg img')) {
-            // We just hit the Firefox bug - which prevents the inner img JS from being sanitized
-            // so use the DOMParser strategy, if it is available.
-            // If the DOMParser is not available then we are not in Firefox (Server/WebWorker?) so we
-            // fall through to the default strategy below.
-            if (isDOMParserAvailable()) {
-                this.getInertBodyElement = this.getInertBodyElement_DOMParser;
-                return;
-            }
-        }
-        // None of the bugs were hit so it is safe for us to use the default InertDocument strategy
-        this.getInertBodyElement = this.getInertBodyElement_InertDocument;
-    }
-    /**
-     * 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
-     */
-    getInertBodyElement_XHR(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.
-        html = '<body><remove></remove>' + html + '</body>';
-        try {
-            html = encodeURI(html);
-        }
-        catch (_a) {
-            return null;
-        }
-        const xhr = new XMLHttpRequest();
-        xhr.responseType = 'document';
-        xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);
-        xhr.send(undefined);
-        const body = xhr.response.body;
-        body.removeChild(body.firstChild);
-        return body;
-    }
-    /**
-     * Use DOMParser to create and fill an inert body element (on Firefox)
-     * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7
-     *
-     */
-    getInertBodyElement_DOMParser(html) {
+function getInertBodyHelper(defaultDoc) {
+    return isDOMParserAvailable() ? new DOMParserHelper() : new InertDocumentHelper(defaultDoc);
+}
+/**
+ * Uses DOMParser to create and fill an inert body element.
+ * This is the default strategy used in browsers that support it.
+ */
+class DOMParserHelper {
+    getInertBodyElement(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.
@@ -4426,13 +4378,26 @@ class InertBodyHelper {
             return null;
         }
     }
-    /**
-     * 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.
-     */
-    getInertBodyElement_InertDocument(html) {
+}
+/**
+ * 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 fallback strategy if the browser does not support DOMParser.
+ */
+class InertDocumentHelper {
+    constructor(defaultDoc) {
+        this.defaultDoc = defaultDoc;
+        this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');
+        if (this.inertDocument.body == null) {
+            // usually there should be only one body element in the document, but IE doesn't have any, so
+            // we need to create one.
+            const inertHtml = this.inertDocument.createElement('html');
+            this.inertDocument.appendChild(inertHtml);
+            const inertBodyElement = this.inertDocument.createElement('body');
+            inertHtml.appendChild(inertBodyElement);
+        }
+    }
+    getInertBodyElement(html) {
         // Prefer using <template> element if supported.
         const templateEl = this.inertDocument.createElement('template');
         if ('content' in templateEl) {
@@ -4482,15 +4447,15 @@ class InertBodyHelper {
     }
 }
 /**
- * We need to determine whether the DOMParser exists in the global context.
- * The try-catch is because, on some browsers, trying to access this property
- * on window can actually throw an error.
+ * We need to determine whether the DOMParser exists in the global context and
+ * supports parsing HTML; HTML parsing support is not as wide as other formats, see
+ * https://developer.mozilla.org/en-US/docs/Web/API/DOMParser#Browser_compatibility.
  *
  * @suppress {uselessCode}
  */
 function isDOMParserAvailable() {
     try {
-        return !!window.DOMParser;
+        return !!new window.DOMParser().parseFromString('', 'text/html');
     }
     catch (_a) {
         return false;
@@ -4756,7 +4721,7 @@ let inertBodyHelper;
 function _sanitizeHtml(defaultDoc, unsafeHtmlInput) {
     let inertBodyElement = null;
     try {
-        inertBodyHelper = inertBodyHelper || new InertBodyHelper(defaultDoc);
+        inertBodyHelper = inertBodyHelper || getInertBodyHelper(defaultDoc);
         // Make sure unsafeHtml is actually a string (TypeScript types are not enforced at runtime).
         let unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : '';
         inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
@@ -7110,7 +7075,7 @@ function assignTViewNodeToLView(tView, tParentNode, index, lView) {
     let tNode = tView.node;
     if (tNode == null) {
         ngDevMode && tParentNode &&
-            assertNodeOfPossibleTypes(tParentNode, 3 /* Element */, 0 /* Container */);
+            assertNodeOfPossibleTypes(tParentNode, [3 /* Element */, 0 /* Container */]);
         tView.node = tNode = createTNode(tView, tParentNode, //
         2 /* View */, index, null, null);
     }
@@ -7572,20 +7537,6 @@ function storeCleanupWithContext(tView, lView, context, cleanupFn) {
         getTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
     }
 }
-/**
- * Saves the cleanup function itself in LView.cleanupInstances.
- *
- * This is necessary for functions that are wrapped with their contexts, like in renderer2
- * listeners.
- *
- * On the first template pass, the index of the cleanup function is saved in TView.
- */
-function storeCleanupFn(tView, lView, cleanupFn) {
-    getLCleanup(lView).push(cleanupFn);
-    if (tView.firstCreatePass) {
-        getTViewCleanup(tView).push(lView[CLEANUP].length - 1, null);
-    }
-}
 /**
  * Constructs a TNode object from the arguments.
  *
@@ -8016,7 +7967,7 @@ function instantiateAllDirectives(tView, lView, tNode, native) {
         const def = tView.data[i];
         const isComponent = isComponentDef(def);
         if (isComponent) {
-            ngDevMode && assertNodeOfPossibleTypes(tNode, 3 /* Element */);
+            ngDevMode && assertNodeOfPossibleTypes(tNode, [3 /* Element */]);
             addComponentLogic(lView, tNode, def);
         }
         const directive = getNodeInjectable(lView, tView, i, tNode);
@@ -8092,7 +8043,7 @@ function generateExpandoInstructionBlock(tView, tNode, directiveCount) {
 function findDirectiveDefMatches(tView, viewData, tNode) {
     ngDevMode && assertFirstCreatePass(tView);
     ngDevMode &&
-        assertNodeOfPossibleTypes(tNode, 3 /* Element */, 4 /* ElementContainer */, 0 /* Container */);
+        assertNodeOfPossibleTypes(tNode, [3 /* Element */, 4 /* ElementContainer */, 0 /* Container */]);
     const registry = tView.directiveRegistry;
     let matches = null;
     if (registry) {
@@ -8102,6 +8053,9 @@ function findDirectiveDefMatches(tView, viewData, tNode) {
                 matches || (matches = ngDevMode ? new MatchesArray() : []);
                 diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, viewData), tView, def.type);
                 if (isComponentDef(def)) {
+                    ngDevMode &&
+                        assertNodeOfPossibleTypes(tNode, [3 /* Element */], `"${tNode.tagName}" tags cannot be used as component hosts. ` +
+                            `Please use a different tag to activate the ${stringify(def.type)} component.`);
                     if (tNode.flags & 2 /* isComponentHost */)
                         throwMultipleComponentError(tNode);
                     markAsComponentHost(tView, tNode);
@@ -9183,7 +9137,7 @@ function getRenderParent(tView, tNode, currentView) {
         else {
             // We are inserting a root element of the component view into the component host element and
             // it should always be eager.
-            ngDevMode && assertNodeOfPossibleTypes(hostTNode, 3 /* Element */);
+            ngDevMode && assertNodeOfPossibleTypes(hostTNode, [3 /* Element */]);
             return currentView[HOST];
         }
     }
@@ -9320,8 +9274,10 @@ function appendChild(tView, lView, childEl, childTNode) {
  */
 function getFirstNativeNode(lView, tNode) {
     if (tNode !== null) {
-        ngDevMode &&
-            assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */, 4 /* ElementContainer */, 5 /* IcuContainer */, 1 /* Projection */);
+        ngDevMode && assertNodeOfPossibleTypes(tNode, [
+            3 /* Element */, 0 /* Container */, 4 /* ElementContainer */, 5 /* IcuContainer */,
+            1 /* Projection */
+        ]);
         const tNodeType = tNode.type;
         if (tNodeType === 3 /* Element */) {
             return getNativeByTNode(tNode, lView);
@@ -9392,8 +9348,10 @@ function nativeRemoveNode(renderer, rNode, isHostElement) {
 function applyNodes(renderer, action, tNode, lView, renderParent, beforeNode, isProjection) {
     while (tNode != null) {
         ngDevMode && assertTNodeForLView(tNode, lView);
-        ngDevMode &&
-            assertNodeOfPossibleTypes(tNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */, 1 /* Projection */, 1 /* Projection */, 5 /* IcuContainer */);
+        ngDevMode && assertNodeOfPossibleTypes(tNode, [
+            0 /* Container */, 3 /* Element */, 4 /* ElementContainer */, 1 /* Projection */,
+            5 /* IcuContainer */
+        ]);
         const rawSlotValue = lView[tNode.index];
         const tNodeType = tNode.type;
         if (isProjection) {
@@ -9411,7 +9369,7 @@ function applyNodes(renderer, action, tNode, lView, renderParent, beforeNode, is
                 applyProjectionRecursive(renderer, action, lView, tNode, renderParent, beforeNode);
             }
             else {
-                ngDevMode && assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */);
+                ngDevMode && assertNodeOfPossibleTypes(tNode, [3 /* Element */, 0 /* Container */]);
                 applyToElementOrContainer(action, renderer, renderParent, rawSlotValue, beforeNode);
             }
         }
@@ -9746,7 +9704,7 @@ class ViewRef {
         destroyLView(this._lView[TVIEW], this._lView);
     }
     onDestroy(callback) {
-        storeCleanupFn(this._lView[TVIEW], this._lView, callback);
+        storeCleanupWithContext(this._lView[TVIEW], this._lView, null, callback);
     }
     /**
      * Marks a view and all of its ancestors dirty.
@@ -9968,8 +9926,10 @@ class RootViewRef extends ViewRef {
 }
 function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
     while (tNode !== null) {
-        ngDevMode &&
-            assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */, 1 /* Projection */, 4 /* ElementContainer */, 5 /* IcuContainer */);
+        ngDevMode && assertNodeOfPossibleTypes(tNode, [
+            3 /* Element */, 0 /* Container */, 1 /* Projection */, 4 /* ElementContainer */,
+            5 /* IcuContainer */
+        ]);
         const lNode = lView[tNode.index];
         if (lNode !== null) {
             result.push(unwrapRNode(lNode));
@@ -10245,7 +10205,7 @@ function createContainerRef(ViewContainerRefToken, ElementRefToken, hostTNode, h
         };
     }
     ngDevMode &&
-        assertNodeOfPossibleTypes(hostTNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */);
+        assertNodeOfPossibleTypes(hostTNode, [0 /* Container */, 3 /* Element */, 4 /* ElementContainer */]);
     let lContainer;
     const slotValue = hostView[hostTNode.index];
     if (isLContainer(slotValue)) {
@@ -10344,10 +10304,13 @@ function injectRenderer2() {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * Base class for Angular Views, provides change detection functionality.
+ * Base class that provides change detection functionality.
  * A change-detection tree collects all views that are to be checked for changes.
  * Use the methods to add and remove views from the tree, initiate change-detection,
- * and explicitly mark views as _dirty_, meaning that they have changed and need to be rerendered.
+ * and explicitly mark views as _dirty_, meaning that they have changed and need to be re-rendered.
+ *
+ * @see [Using change detection hooks](guide/lifecycle-hooks#using-change-detection-hooks)
+ * @see [Defining custom change detection](guide/lifecycle-hooks#defining-custom-change-detection)
  *
  * @usageNotes
  *
@@ -10409,7 +10372,7 @@ const SWITCH_CHANGE_DETECTOR_REF_FACTORY = SWITCH_CHANGE_DETECTOR_REF_FACTORY__P
  *
  * Represents a type that a Component or other object is instances of.
  *
- * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
  * the `MyCustomComponent` constructor function.
  *
  * @publicApi
@@ -14241,7 +14204,7 @@ function listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn,
     // register a listener and store its cleanup function on LView.
     const lCleanup = getLCleanup(lView);
     ngDevMode &&
-        assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */, 4 /* ElementContainer */);
+        assertNodeOfPossibleTypes(tNode, [3 /* Element */, 0 /* Container */, 4 /* ElementContainer */]);
     let processOutputs = true;
     // add native event listener - applicable to elements only
     if (tNode.type === 3 /* Element */) {
@@ -19346,7 +19309,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('10.0.0');
+const VERSION = new Version('10.0.4');
 
 /**
  * @license
@@ -22277,12 +22240,6 @@ class ComponentFactory$1 extends ComponentFactory {
             elementCreate(elementName, rendererFactory.createRenderer(null, this.componentDef), getNamespace$1(elementName));
         const rootFlags = this.componentDef.onPush ? 64 /* Dirty */ | 512 /* IsRoot */ :
             16 /* CheckAlways */ | 512 /* IsRoot */;
-        // Check whether this Component needs to be isolated from other components, i.e. whether it
-        // should be placed into its own (empty) root context or existing root context should be used.
-        // Note: this is internal-only convention and might change in the future, so it should not be
-        // relied upon externally.
-        const isIsolated = typeof rootSelectorOrNode === 'string' &&
-            /^#root-ng-internal-isolated-\d+/.test(rootSelectorOrNode);
         const rootContext = createRootContext();
         // Create the root view. Uses empty TView and ContentTemplate.
         const rootTView = createTView(0 /* Root */, -1, null, 1, 0, null, null, null, null, null);
@@ -22337,12 +22294,9 @@ class ComponentFactory$1 extends ComponentFactory {
             leaveView();
         }
         const componentRef = new ComponentRef$1(this.componentType, component, createElementRef(ElementRef, tElementNode, rootLView), rootLView, tElementNode);
-        if (!rootSelectorOrNode || isIsolated) {
-            // The host element of the internal or isolated root view is attached to the component's host
-            // view node.
-            ngDevMode && assertNodeOfPossibleTypes(rootTView.node, 2 /* View */);
-            rootTView.node.child = tElementNode;
-        }
+        // The host element of the internal root view is attached to the component's host view node.
+        ngDevMode && assertNodeOfPossibleTypes(rootTView.node, [2 /* View */]);
+        rootTView.node.child = tElementNode;
         return componentRef;
     }
 }
@@ -23670,7 +23624,7 @@ function icuStart(tIcus, icuExpression, startIndex, expandoStartIndex) {
  * @param expandoStartIndex
  */
 function parseIcuCase(unsafeHtml, parentIndex, nestedIcus, tIcus, expandoStartIndex) {
-    const inertBodyHelper = new InertBodyHelper(getDocument());
+    const inertBodyHelper = getInertBodyHelper(getDocument());
     const inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
     if (!inertBodyElement) {
         throw new Error('Unable to generate inert body element');
@@ -25059,7 +25013,7 @@ function createSpecialToken(lView, tNode, read) {
     }
     else if (read === ViewContainerRef) {
         ngDevMode &&
-            assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */, 4 /* ElementContainer */);
+            assertNodeOfPossibleTypes(tNode, [3 /* Element */, 0 /* Container */, 4 /* ElementContainer */]);
         return createContainerRef(ViewContainerRef, ElementRef, tNode, lView);
     }
     else {
@@ -26439,21 +26393,25 @@ const SWITCH_COMPILE_NGMODULE = SWITCH_COMPILE_NGMODULE__PRE_R3__;
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * An injection token that allows you to provide one or more initialization functions.
- * These function are injected at application startup and executed during
+ * A [DI token](guide/glossary#di-token "DI token definition") that you can use to provide
+ * one or more initialization functions.
+ *
+ * The provided function are injected at application startup and executed during
  * app initialization. If any of these functions returns a Promise, initialization
  * does not complete until the Promise is resolved.
  *
  * You can, for example, create a factory function that loads language data
  * or an external configuration, and provide that function to the `APP_INITIALIZER` token.
- * That way, the function is executed during the application bootstrap process,
+ * The function is executed during the application bootstrap process,
  * and the needed data is available on startup.
  *
+ * @see `ApplicationInitStatus`
+ *
  * @publicApi
  */
 const APP_INITIALIZER = new InjectionToken('Application Initializer');
 /**
- * A class that reflects the state of running {@link APP_INITIALIZER}s.
+ * A class that reflects the state of running {@link APP_INITIALIZER} functions.
  *
  * @publicApi
  */
@@ -26513,13 +26471,14 @@ ApplicationInitStatus.ctorParameters = () => [
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * A DI Token representing a unique string id assigned to the application by Angular and used
+ * A [DI token](guide/glossary#di-token "DI token definition") representing a unique string ID, used
  * primarily for prefixing application attributes and CSS styles when
  * {@link ViewEncapsulation#Emulated ViewEncapsulation.Emulated} is being used.
  *
- * If you need to avoid randomly generated value to be used as an application id, you can provide
- * a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}
- * using this token.
+ * BY default, the value is randomly generated and assigned to the application by Angular.
+ * To provide a custom ID value, use a DI provider <!-- TODO: provider --> to configure
+ * the root {@link Injector} that uses this token.
+ *
  * @publicApi
  */
 const APP_ID = new InjectionToken('AppId');
@@ -26527,7 +26486,7 @@ function _appIdRandomProviderFactory() {
     return `${_randomChar()}${_randomChar()}${_randomChar()}`;
 }
 /**
- * Providers that will generate a random APP_ID_TOKEN.
+ * Providers that generate a random `APP_ID_TOKEN`.
  * @publicApi
  */
 const APP_ID_RANDOM_PROVIDER = {
@@ -26539,26 +26498,29 @@ function _randomChar() {
     return String.fromCharCode(97 + Math.floor(Math.random() * 25));
 }
 /**
- * A function that will be executed when a platform is initialized.
+ * A function that is executed when a platform is initialized.
  * @publicApi
  */
 const PLATFORM_INITIALIZER = new InjectionToken('Platform Initializer');
 /**
- * A token that indicates an opaque platform id.
+ * A token that indicates an opaque platform ID.
  * @publicApi
  */
 const PLATFORM_ID = new InjectionToken('Platform ID');
 /**
- * All callbacks provided via this token will be called for every component that is bootstrapped.
- * Signature of the callback:
+ * A [DI token](guide/glossary#di-token "DI token definition") that provides a set of callbacks to
+ * be called for every component that is bootstrapped.
  *
- * `(componentRef: ComponentRef) => void`.
+ * Each callback must take a `ComponentRef` instance and return nothing.
+ *
+ * `(componentRef: ComponentRef) => void`
  *
  * @publicApi
  */
 const APP_BOOTSTRAP_LISTENER = new InjectionToken('appBootstrapListener');
 /**
- * A token which indicates the root directory of the application
+ * A [DI token](guide/glossary#di-token "DI token definition") that indicates the root directory of
+ * the application
  * @publicApi
  */
 const PACKAGE_ROOT_URL = new InjectionToken('Application Packages Root URL');
@@ -28307,12 +28269,9 @@ function checkNotEmpty(value, modulePath, exportName) {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * Represents an Angular [view](guide/glossary#view),
- * specifically the [host view](guide/glossary#view-tree) that is defined by a component.
- * Also serves as the base class
- * that adds destroy methods for [embedded views](guide/glossary#view-tree).
+ * Represents an Angular [view](guide/glossary#view "Definition").
  *
- * @see `EmbeddedViewRef`
+ * @see {@link ChangeDetectorRef#usage-notes Change detection usage}
  *
  * @publicApi
  */