@angular/core 14.0.0-next.13 → 14.0.0-next.14

package/fesm2020/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.0.0-next.13
+ * @license Angular v14.0.0-next.14
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -918,19 +918,21 @@ function ɵɵdefineComponent(componentDefinition) {
             schemas: componentDefinition.schemas || null,
             tView: null,
         };
-        const directiveTypes = componentDefinition.directives;
+        const dependencies = componentDefinition.dependencies;
         const feature = componentDefinition.features;
-        const pipeTypes = componentDefinition.pipes;
         def.id += _renderCompCount++;
         def.inputs = invertObject(componentDefinition.inputs, declaredInputs),
             def.outputs = invertObject(componentDefinition.outputs),
             feature && feature.forEach((fn) => fn(def));
-        def.directiveDefs = directiveTypes ?
-            () => (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)
-                .map(extractDirectiveDef) :
+        def.directiveDefs = dependencies ?
+            (() => (typeof dependencies === 'function' ? dependencies() : dependencies)
+                .map(extractDirectiveDef)
+                .filter(nonNull)) :
             null;
-        def.pipeDefs = pipeTypes ?
-            () => (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef) :
+        def.pipeDefs = dependencies ?
+            (() => (typeof dependencies === 'function' ? dependencies() : dependencies)
+                .map(getPipeDef$1)
+                .filter(nonNull)) :
             null;
         return def;
     });
@@ -947,21 +949,13 @@ function ɵɵdefineComponent(componentDefinition) {
 function ɵɵsetComponentScope(type, directives, pipes) {
     const def = type.ɵcmp;
     def.directiveDefs = () => directives.map(extractDirectiveDef);
-    def.pipeDefs = () => pipes.map(extractPipeDef);
+    def.pipeDefs = () => pipes.map(getPipeDef$1);
 }
 function extractDirectiveDef(type) {
-    const def = getComponentDef(type) || getDirectiveDef(type);
-    if (ngDevMode && !def) {
-        throw new Error(`'${type.name}' is neither 'ComponentType' or 'DirectiveType'.`);
-    }
-    return def;
+    return getComponentDef(type) || getDirectiveDef(type);
 }
-function extractPipeDef(type) {
-    const def = getPipeDef$1(type);
-    if (ngDevMode && !def) {
-        throw new Error(`'${type.name}' is not a 'PipeType'.`);
-    }
-    return def;
+function nonNull(value) {
+    return value !== null;
 }
 const autoRegisterModuleById = {};
 /**
@@ -4015,6 +4009,12 @@ class InjectionToken {
             });
         }
     }
+    /**
+     * @internal
+     */
+    get multi() {
+        return this;
+    }
     toString() {
         return `InjectionToken ${this._desc}`;
     }
@@ -4141,6 +4141,12 @@ var FactoryTarget;
     FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
     FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
 })(FactoryTarget || (FactoryTarget = {}));
+var R3TemplateDependencyKind;
+(function (R3TemplateDependencyKind) {
+    R3TemplateDependencyKind[R3TemplateDependencyKind["Directive"] = 0] = "Directive";
+    R3TemplateDependencyKind[R3TemplateDependencyKind["Pipe"] = 1] = "Pipe";
+    R3TemplateDependencyKind[R3TemplateDependencyKind["NgModule"] = 2] = "NgModule";
+})(R3TemplateDependencyKind || (R3TemplateDependencyKind = {}));
 var ViewEncapsulation;
 (function (ViewEncapsulation) {
     ViewEncapsulation[ViewEncapsulation["Emulated"] = 0] = "Emulated";
@@ -6922,8 +6928,10 @@ function maybeUnwrapFn(value) {
  * found in the LICENSE file at https://angular.io/license
  */
 /** Called when there are multiple component selectors that match a given node */
-function throwMultipleComponentError(tNode) {
-    throw new RuntimeError(-300 /* MULTIPLE_COMPONENTS_MATCH */, `Multiple components match node with tagname ${tNode.value}`);
+function throwMultipleComponentError(tNode, first, second) {
+    throw new RuntimeError(-300 /* MULTIPLE_COMPONENTS_MATCH */, `Multiple components match node with tagname ${tNode.value}: ` +
+        `${stringifyForError(first)} and ` +
+        `${stringifyForError(second)}`);
 }
 /** Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on. */
 function throwErrorIfNoChangesMode(creationMode, oldValue, currValue, propName) {
@@ -10598,8 +10606,11 @@ function findDirectiveDefMatches(tView, viewData, tNode) {
                     if (ngDevMode) {
                         assertTNodeType(tNode, 2 /* Element */, `"${tNode.value}" 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);
+                        if (tNode.flags & 2 /* isComponentHost */) {
+                            // If another component has been matched previously, it's the first element in the
+                            // `matches` array, see how we store components/directives in `matches` below.
+                            throwMultipleComponentError(tNode, matches[0].type, def.type);
+                        }
                     }
                     markAsComponentHost(tView, tNode);
                     // The component is always stored first with directives after.
@@ -11401,6 +11412,14 @@ const NOT_YET = {};
  * a circular dependency among the providers.
  */
 const CIRCULAR = {};
+/**
+ * A multi-provider token for initialization functions that will run upon construction of a
+ * non-view injector.
+ *
+ * @publicApi
+ */
+const INJECTOR_INITIALIZER = new InjectionToken('INJECTOR_INITIALIZER');
+const INJECTOR_DEF_TYPES = new InjectionToken('INJECTOR_DEF_TYPES');
 /**
  * A lazily initialized NullInjector.
  */
@@ -11418,7 +11437,7 @@ function getNullInjector() {
  */
 function createInjector(defType, parent = null, additionalProviders = null, name) {
     const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
-    injector._resolveInjectorDefTypes();
+    injector.resolveInjectorInitializers();
     return injector;
 }
 /**
@@ -11426,42 +11445,180 @@ function createInjector(defType, parent = null, additionalProviders = null, name
  * where resolving the injector types immediately can lead to an infinite loop. The injector types
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
-function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
-    return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
+    const providers = [
+        ...flatten(additionalProviders || EMPTY_ARRAY),
+        ...importProvidersFrom(defType),
+    ];
+    name = name || (typeof defType === 'object' ? undefined : stringify(defType));
+    return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
 }
-class R3Injector {
-    constructor(def, additionalProviders, parent, source = null) {
+/**
+ * The logic visits an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive
+ * providers and invokes specified callbacks when:
+ * - an injector type is visited (typically an NgModule)
+ * - a provider is visited
+ *
+ * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
+ * the function will return "true" to indicate that the providers of the type definition need
+ * to be processed. This allows us to process providers of injector types after all imports of
+ * an injector definition are processed. (following View Engine semantics: see FW-1349)
+ */
+function walkProviderTree(container, providersOut, parents, dedup) {
+    container = resolveForwardRef(container);
+    if (!container)
+        return false;
+    // Either the defOrWrappedDef is an InjectorType (with injector def) or an
+    // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic
+    // read, so care is taken to only do the read once.
+    // First attempt to read the injector def (`ɵinj`).
+    let def = getInjectorDef(container);
+    // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.
+    const ngModule = (def == null) && container.ngModule || undefined;
+    // Determine the InjectorType. In the case where `defOrWrappedDef` is an `InjectorType`,
+    // then this is easy. In the case of an InjectorDefTypeWithProviders, then the definition type
+    // is the `ngModule`.
+    const defType = (ngModule === undefined) ? container : ngModule;
+    // Check for circular dependencies.
+    if (ngDevMode && parents.indexOf(defType) !== -1) {
+        const defName = stringify(defType);
+        const path = parents.map(stringify);
+        throwCyclicDependencyError(defName, path);
+    }
+    // Check for multiple imports of the same module
+    const isDuplicate = dedup.has(defType);
+    // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual
+    // `InjectorDef` is on its `ngModule`.
+    if (ngModule !== undefined) {
+        def = getInjectorDef(ngModule);
+    }
+    // If no definition was found, it might be from exports. Remove it.
+    if (def == null) {
+        return false;
+    }
+    // Add providers in the same way that @NgModule resolution did:
+    // First, include providers from any imports.
+    if (def.imports != null && !isDuplicate) {
+        // Before processing defType's imports, add it to the set of parents. This way, if it ends
+        // up deeply importing itself, this can be detected.
+        ngDevMode && parents.push(defType);
+        // Add it to the set of dedups. This way we can detect multiple imports of the same module
+        dedup.add(defType);
+        let importTypesWithProviders;
+        try {
+            deepForEach(def.imports, imported => {
+                if (walkProviderTree(imported, providersOut, parents, dedup)) {
+                    if (importTypesWithProviders === undefined)
+                        importTypesWithProviders = [];
+                    // If the processed import is an injector type with providers, we store it in the
+                    // list of import types with providers, so that we can process those afterwards.
+                    importTypesWithProviders.push(imported);
+                }
+            });
+        }
+        finally {
+            // Remove it from the parents set when finished.
+            ngDevMode && parents.pop();
+        }
+        // Imports which are declared with providers (TypeWithProviders) need to be processed
+        // after all imported modules are processed. This is similar to how View Engine
+        // processes/merges module imports in the metadata resolver. See: FW-1349.
+        if (importTypesWithProviders !== undefined) {
+            for (let i = 0; i < importTypesWithProviders.length; i++) {
+                const { ngModule, providers } = importTypesWithProviders[i];
+                deepForEach(providers, provider => {
+                    validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
+                    providersOut.push(provider);
+                });
+            }
+        }
+    }
+    // Track the InjectorType and add a provider for it.
+    // It's important that this is done after the def's imports.
+    const factory = getFactoryDef(defType) || (() => new defType());
+    // Provider to create `defType` using its factory.
+    providersOut.push({
+        provide: defType,
+        useFactory: factory,
+        deps: EMPTY_ARRAY,
+    });
+    providersOut.push({
+        provide: INJECTOR_DEF_TYPES,
+        useValue: defType,
+        multi: true,
+    });
+    // Provider to eagerly instantiate `defType` via `INJECTOR_INITIALIZER`.
+    providersOut.push({
+        provide: INJECTOR_INITIALIZER,
+        useValue: () => inject(defType),
+        multi: true,
+    });
+    // Next, include providers listed on the definition itself.
+    const defProviders = def.providers;
+    if (defProviders != null && !isDuplicate) {
+        const injectorType = container;
+        deepForEach(defProviders, provider => {
+            // TODO: fix cast
+            validateProvider(provider, defProviders, injectorType);
+            providersOut.push(provider);
+        });
+    }
+    return (ngModule !== undefined &&
+        container.providers !== undefined);
+}
+/**
+ * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
+ * component tree.
+ */
+class EnvironmentInjector {
+}
+/**
+ * Collects providers from all NgModules, including transitively imported ones.
+ *
+ * @returns The list of collected providers from the specified list of NgModules.
+ * @publicApi
+ */
+function importProvidersFrom(...injectorTypes) {
+    const providers = [];
+    deepForEach(injectorTypes, injectorDef => walkProviderTree(injectorDef, providers, [], new Set()));
+    return providers;
+}
+class R3Injector extends EnvironmentInjector {
+    constructor(providers, parent, source, scopes) {
+        super();
         this.parent = parent;
+        this.source = source;
+        this.scopes = scopes;
         /**
          * Map of tokens to records which contain the instances of those tokens.
          * - `null` value implies that we don't have the record. Used by tree-shakable injectors
          * to prevent further searches.
          */
         this.records = new Map();
-        /**
-         * 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.
          */
-        this.onDestroy = new Set();
+        this._ngOnDestroyHooks = new Set();
+        this._onDestroyHooks = [];
         this._destroyed = false;
-        const dedupStack = [];
-        // Start off by creating Records for every provider declared in every InjectorType
-        // included transitively in additional providers then do the same for `def`. This order is
-        // important because `def` may include providers that override ones in additionalProviders.
-        additionalProviders &&
-            deepForEach(additionalProviders, provider => this.processProvider(provider, def, additionalProviders));
-        deepForEach([def], injectorDef => this.processInjectorType(injectorDef, [], dedupStack));
+        // Start off by creating Records for every provider.
+        for (const provider of providers) {
+            this.processProvider(provider);
+        }
         // Make sure the INJECTOR token provides this injector.
         this.records.set(INJECTOR, makeRecord(undefined, this));
+        // And `EnvironmentInjector` if the current injector is supposed to be env-scoped.
+        if (scopes.has('environment')) {
+            this.records.set(EnvironmentInjector, makeRecord(undefined, this));
+        }
         // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide
         // any injectable scoped to APP_ROOT_SCOPE.
         const record = this.records.get(INJECTOR_SCOPE);
-        this.scope = record != null ? record.value : null;
-        // Source name, used for debugging
-        this.source = source || (typeof def === 'object' ? null : stringify(def));
+        if (record != null && typeof record.value === 'string') {
+            this.scopes.add(record.value);
+        }
+        this.injectorDefTypes =
+            new Set(this.get(INJECTOR_DEF_TYPES.multi, EMPTY_ARRAY, InjectFlags.Self));
     }
     /**
      * Flag indicating that this injector was previously destroyed.
@@ -11481,15 +11638,24 @@ class R3Injector {
         this._destroyed = true;
         try {
             // Call all the lifecycle hooks.
-            this.onDestroy.forEach(service => service.ngOnDestroy());
+            for (const service of this._ngOnDestroyHooks) {
+                service.ngOnDestroy();
+            }
+            for (const hook of this._onDestroyHooks) {
+                hook();
+            }
         }
         finally {
             // Release all references.
             this.records.clear();
-            this.onDestroy.clear();
+            this._ngOnDestroyHooks.clear();
             this.injectorDefTypes.clear();
+            this._onDestroyHooks.length = 0;
         }
     }
+    onDestroy(callback) {
+        this._onDestroyHooks.push(callback);
+    }
     get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
         this.assertNotDestroyed();
         // Set the injection context.
@@ -11553,12 +11719,26 @@ class R3Injector {
         }
     }
     /** @internal */
-    _resolveInjectorDefTypes() {
-        this.injectorDefTypes.forEach(defType => this.get(defType));
+    resolveInjectorInitializers() {
+        const previousInjector = setCurrentInjector(this);
+        const previousInjectImplementation = setInjectImplementation(undefined);
+        try {
+            const initializers = this.get(INJECTOR_INITIALIZER.multi, EMPTY_ARRAY, InjectFlags.Self);
+            for (const initializer of initializers) {
+                initializer();
+            }
+        }
+        finally {
+            setCurrentInjector(previousInjector);
+            setInjectImplementation(previousInjectImplementation);
+        }
     }
     toString() {
-        const tokens = [], records = this.records;
-        records.forEach((v, token) => tokens.push(stringify(token)));
+        const tokens = [];
+        const records = this.records;
+        for (const token of records.keys()) {
+            tokens.push(stringify(token));
+        }
         return `R3Injector[${tokens.join(', ')}]`;
     }
     assertNotDestroyed() {
@@ -11566,105 +11746,16 @@ class R3Injector {
             throw new RuntimeError(205 /* INJECTOR_ALREADY_DESTROYED */, ngDevMode && 'Injector has already been destroyed.');
         }
     }
-    /**
-     * Add an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive providers
-     * to this injector.
-     *
-     * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
-     * the function will return "true" to indicate that the providers of the type definition need
-     * to be processed. This allows us to process providers of injector types after all imports of
-     * an injector definition are processed. (following View Engine semantics: see FW-1349)
-     */
-    processInjectorType(defOrWrappedDef, parents, dedupStack) {
-        defOrWrappedDef = resolveForwardRef(defOrWrappedDef);
-        if (!defOrWrappedDef)
-            return false;
-        // Either the defOrWrappedDef is an InjectorType (with injector def) or an
-        // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic
-        // read, so care is taken to only do the read once.
-        // First attempt to read the injector def (`ɵinj`).
-        let def = getInjectorDef(defOrWrappedDef);
-        // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.
-        const ngModule = (def == null) && defOrWrappedDef.ngModule || undefined;
-        // Determine the InjectorType. In the case where `defOrWrappedDef` is an `InjectorType`,
-        // then this is easy. In the case of an InjectorDefTypeWithProviders, then the definition type
-        // is the `ngModule`.
-        const defType = (ngModule === undefined) ? defOrWrappedDef : ngModule;
-        // Check for circular dependencies.
-        if (ngDevMode && parents.indexOf(defType) !== -1) {
-            const defName = stringify(defType);
-            const path = parents.map(stringify);
-            throwCyclicDependencyError(defName, path);
-        }
-        // Check for multiple imports of the same module
-        const isDuplicate = dedupStack.indexOf(defType) !== -1;
-        // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual
-        // `InjectorDef` is on its `ngModule`.
-        if (ngModule !== undefined) {
-            def = getInjectorDef(ngModule);
-        }
-        // If no definition was found, it might be from exports. Remove it.
-        if (def == null) {
-            return false;
-        }
-        // Add providers in the same way that @NgModule resolution did:
-        // First, include providers from any imports.
-        if (def.imports != null && !isDuplicate) {
-            // Before processing defType's imports, add it to the set of parents. This way, if it ends
-            // up deeply importing itself, this can be detected.
-            ngDevMode && parents.push(defType);
-            // Add it to the set of dedups. This way we can detect multiple imports of the same module
-            dedupStack.push(defType);
-            let importTypesWithProviders;
-            try {
-                deepForEach(def.imports, imported => {
-                    if (this.processInjectorType(imported, parents, dedupStack)) {
-                        if (importTypesWithProviders === undefined)
-                            importTypesWithProviders = [];
-                        // If the processed import is an injector type with providers, we store it in the
-                        // list of import types with providers, so that we can process those afterwards.
-                        importTypesWithProviders.push(imported);
-                    }
-                });
-            }
-            finally {
-                // Remove it from the parents set when finished.
-                ngDevMode && parents.pop();
-            }
-            // Imports which are declared with providers (TypeWithProviders) need to be processed
-            // after all imported modules are processed. This is similar to how View Engine
-            // processes/merges module imports in the metadata resolver. See: FW-1349.
-            if (importTypesWithProviders !== undefined) {
-                for (let i = 0; i < importTypesWithProviders.length; i++) {
-                    const { ngModule, providers } = importTypesWithProviders[i];
-                    deepForEach(providers, provider => this.processProvider(provider, ngModule, providers || EMPTY_ARRAY));
-                }
-            }
-        }
-        // Track the InjectorType and add a provider for it. It's important that this is done after the
-        // def's imports.
-        this.injectorDefTypes.add(defType);
-        const factory = getFactoryDef(defType) || (() => new defType());
-        this.records.set(defType, makeRecord(factory, NOT_YET));
-        // Next, include providers listed on the definition itself.
-        const defProviders = def.providers;
-        if (defProviders != null && !isDuplicate) {
-            const injectorType = defOrWrappedDef;
-            deepForEach(defProviders, provider => this.processProvider(provider, injectorType, defProviders));
-        }
-        return (ngModule !== undefined &&
-            defOrWrappedDef.providers !== undefined);
-    }
     /**
      * Process a `SingleProvider` and add it.
      */
-    processProvider(provider, ngModuleType, providers) {
+    processProvider(provider) {
         // Determine the token from the provider. Either it's its own token, or has a {provide: ...}
         // property.
         provider = resolveForwardRef(provider);
         let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
         // Construct a `Record` for the provider.
-        const record = providerToRecord(provider, ngModuleType, providers);
+        const record = providerToRecord(provider);
         if (!isTypeProvider(provider) && provider.multi === true) {
             // If the provider indicates that it's a multi-provider, process it specially.
             // First check whether it's been defined already.
@@ -11700,7 +11791,7 @@ class R3Injector {
             record.value = record.factory();
         }
         if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {
-            this.onDestroy.add(record.value);
+            this._ngOnDestroyHooks.add(record.value);
         }
         return record.value;
     }
@@ -11710,7 +11801,7 @@ class R3Injector {
         }
         const providedIn = resolveForwardRef(def.providedIn);
         if (typeof providedIn === 'string') {
-            return providedIn === 'any' || (providedIn === this.scope);
+            return providedIn === 'any' || (this.scopes.has(providedIn));
         }
         else {
             return this.injectorDefTypes.has(providedIn);
@@ -11756,12 +11847,12 @@ function getUndecoratedInjectableFactory(token) {
         return () => new token();
     }
 }
-function providerToRecord(provider, ngModuleType, providers) {
+function providerToRecord(provider) {
     if (isValueProvider(provider)) {
         return makeRecord(undefined, provider.useValue);
     }
     else {
-        const factory = providerToFactory(provider, ngModuleType, providers);
+        const factory = providerToFactory(provider);
         return makeRecord(factory, NOT_YET);
     }
 }
@@ -11835,6 +11926,17 @@ function couldBeInjectableType(value) {
     return (typeof value === 'function') ||
         (typeof value === 'object' && value instanceof InjectionToken);
 }
+function validateProvider(provider, providers, containerType) {
+    if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) ||
+        isExistingProvider(provider)) {
+        return;
+    }
+    // Here we expect the provider to be a `useClass` provider (by elimination).
+    const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
+    if (ngDevMode && !classRef) {
+        throwInvalidProviderError(containerType, providers, provider);
+    }
+}
 
 /**
  * @license
@@ -12611,7 +12713,7 @@ function ɵɵInheritDefinitionFeature(definition) {
         else {
             if (superType.ɵcmp) {
                 const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
-                    'Directives cannot inherit Components' :
+                    `Directives cannot inherit Components. Directive ${stringifyForError(definition.type)} is attempting to extend component ${stringifyForError(superType)}` :
                     '';
                 throw new RuntimeError(903 /* INVALID_INHERITANCE */, errorMessage);
             }
@@ -21068,6 +21170,13 @@ function ɵɵProvidersFeature(providers, viewProviders = []) {
     };
 }
 
+/**
+ * TODO: Implements standalone stuff!
+ *
+ * @codeGenApi
+ */
+function ɵɵStandaloneFeature(definition) { }
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -21298,7 +21407,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('14.0.0-next.13');
+const VERSION = new Version('14.0.0-next.14');
 
 /**
  * @license
@@ -21750,9 +21859,12 @@ class ComponentFactory extends ComponentFactory$1 {
     get outputs() {
         return toRefArray(this.componentDef.outputs);
     }
-    create(injector, projectableNodes, rootSelectorOrNode, ngModule) {
-        ngModule = ngModule || this.ngModule;
-        const rootViewInjector = ngModule ? new ChainedInjector(injector, ngModule.injector) : injector;
+    create(injector, projectableNodes, rootSelectorOrNode, environmentInjector) {
+        environmentInjector = environmentInjector || this.ngModule;
+        let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector ?
+            environmentInjector :
+            environmentInjector?.injector;
+        const rootViewInjector = realEnvironmentInjector ? new ChainedInjector(injector, realEnvironmentInjector) : injector;
         const rendererFactory = rootViewInjector.get(RendererFactory2, domRendererFactory3);
         const sanitizer = rootViewInjector.get(Sanitizer, null);
         const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
@@ -21978,11 +22090,11 @@ class NgModuleRef extends NgModuleRef$1 {
                 provide: ComponentFactoryResolver$1,
                 useValue: this.componentFactoryResolver
             }
-        ], stringify(ngModuleType));
+        ], stringify(ngModuleType), new Set(['environment']));
         // We need to resolve the injector types separately from the injector creation, because
         // the module might be trying to use this ref in its constructor for DI which will cause a
         // circular error that will eventually error out, because the injector isn't created yet.
-        this._r3Injector._resolveInjectorDefTypes();
+        this._r3Injector.resolveInjectorInitializers();
         this.instance = this.get(ngModuleType);
     }
     get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, injectFlags = InjectFlags.Default) {
@@ -22012,6 +22124,35 @@ class NgModuleFactory extends NgModuleFactory$1 {
         return new NgModuleRef(this.moduleType, parentInjector);
     }
 }
+class EnvironmentNgModuleRefAdapter extends NgModuleRef$1 {
+    constructor(providers, parent, source) {
+        super();
+        this.componentFactoryResolver = new ComponentFactoryResolver(this);
+        this.instance = null;
+        const injector = new R3Injector([
+            ...providers,
+            { provide: NgModuleRef$1, useValue: this },
+            { provide: ComponentFactoryResolver$1, useValue: this.componentFactoryResolver },
+        ], parent || getNullInjector(), source, new Set(['environment']));
+        this.injector = injector;
+        injector.resolveInjectorInitializers();
+    }
+    destroy() {
+        this.injector.destroy();
+    }
+    onDestroy(callback) {
+        this.injector.onDestroy(callback);
+    }
+}
+/**
+ * Create a new environment injector.
+ *
+ * @publicApi
+ */
+function createEnvironmentInjector(providers, parent = null, debugName = null) {
+    const adapter = new EnvironmentNgModuleRefAdapter(providers, parent, debugName);
+    return adapter.injector;
+}
 
 /**
  * @license
@@ -22936,7 +23077,7 @@ const R3ViewContainerRef = class ViewContainerRef extends VE_ViewContainerRef {
         this.insert(viewRef, index);
         return viewRef;
     }
-    createComponent(componentFactoryOrType, indexOrOptions, injector, projectableNodes, ngModuleRef) {
+    createComponent(componentFactoryOrType, indexOrOptions, injector, projectableNodes, environmentInjector) {
         const isComponentFactory = componentFactoryOrType && !isType(componentFactoryOrType);
         let index;
         // This function supports 2 signatures and we need to handle options correctly for both:
@@ -22964,17 +23105,20 @@ const R3ViewContainerRef = class ViewContainerRef extends VE_ViewContainerRef {
                     'is incompatible. Please use an object as the second argument instead.');
             }
             const options = (indexOrOptions || {});
+            if (ngDevMode && options.environmentInjector && options.ngModuleRef) {
+                throwError(`Cannot pass both environmentInjector and ngModuleRef options to createComponent().`);
+            }
             index = options.index;
             injector = options.injector;
             projectableNodes = options.projectableNodes;
-            ngModuleRef = options.ngModuleRef;
+            environmentInjector = options.environmentInjector || options.ngModuleRef;
         }
         const componentFactory = isComponentFactory ?
             componentFactoryOrType :
             new ComponentFactory(getComponentDef(componentFactoryOrType));
         const contextInjector = injector || this.parentInjector;
         // If an `NgModuleRef` is not provided explicitly, try retrieving it from the DI tree.
-        if (!ngModuleRef && componentFactory.ngModule == null) {
+        if (!environmentInjector && componentFactory.ngModule == null) {
             // For the `ComponentFactory` case, entering this logic is very unlikely, since we expect that
             // an instance of a `ComponentFactory`, resolved via `ComponentFactoryResolver` would have an
             // `ngModule` field. This is possible in some test scenarios and potentially in some JIT-based
@@ -22995,12 +23139,12 @@ const R3ViewContainerRef = class ViewContainerRef extends VE_ViewContainerRef {
             // DO NOT REFACTOR. The code here used to have a `injector.get(NgModuleRef, null) ||
             // undefined` expression which seems to cause internal google apps to fail. This is documented
             // in the following internal bug issue: go/b/142967802
-            const result = _injector.get(NgModuleRef$1, null);
+            const result = _injector.get(EnvironmentInjector, null);
             if (result) {
-                ngModuleRef = result;
+                environmentInjector = result;
             }
         }
-        const componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);
+        const componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, environmentInjector);
         this.insert(componentRef.hostView, index);
         return componentRef;
     }
@@ -23690,6 +23834,7 @@ const angularCoreEnv = (() => ({
     'ɵɵProvidersFeature': ɵɵProvidersFeature,
     'ɵɵCopyDefinitionFeature': ɵɵCopyDefinitionFeature,
     'ɵɵInheritDefinitionFeature': ɵɵInheritDefinitionFeature,
+    'ɵɵStandaloneFeature': ɵɵStandaloneFeature,
     'ɵɵnextContext': ɵɵnextContext,
     'ɵɵnamespaceHTML': ɵɵnamespaceHTML,
     'ɵɵnamespaceMathML': ɵɵnamespaceMathML,
@@ -24401,9 +24546,8 @@ function compileComponent(type, metadata) {
                     preserveWhitespaces,
                     styles: metadata.styles || EMPTY_ARRAY,
                     animations: metadata.animations,
-                    directives: [],
+                    declarations: [],
                     changeDetection: metadata.changeDetection,
-                    pipes: new Map(),
                     encapsulation,
                     interpolation: metadata.interpolation,
                     viewProviders: metadata.viewProviders || null,
@@ -26076,7 +26220,20 @@ let _testabilityGetter = new _NoopGetTestability();
  * 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
  */
-let _platform;
+let _platformInjector = null;
+/**
+ * Internal token to indicate whether having multiple bootstrapped platform should be allowed (only
+ * one bootstrapped platform is allowed by default). This token helps to support SSR scenarios.
+ */
+const ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('AllowMultipleToken');
+/**
+ * Internal token that allows to register extra callbacks that should be invoked during the
+ * `PlatformRef.destroy` operation. This token is needed to avoid a direct reference to the
+ * `PlatformRef` class (i.e. register the callback via `PlatformRef.onDestroy`), thus making the
+ * entire class tree-shakeable.
+ */
+const PLATFORM_ON_DESTROY = new InjectionToken('PlatformOnDestroy');
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
 function compileNgModuleFactory(injector, options, moduleType) {
     ngDevMode && assertNgModuleType(moduleType);
     const moduleFactory = new NgModuleFactory(moduleType);
@@ -26121,7 +26278,6 @@ function publishDefaultGlobalUtils() {
 function isBoundToModule(cf) {
     return cf.isBoundToModule;
 }
-const ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('AllowMultipleToken');
 /**
  * A token for third-party components that can register themselves with NgProbe.
  *
@@ -26140,19 +26296,19 @@ class NgProbeToken {
  * @publicApi
  */
 function createPlatform(injector) {
-    if (_platform && !_platform.destroyed &&
-        !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
+    if (_platformInjector && !_platformInjector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
         const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
             'There can be only one platform. Destroy the previous one to create a new one.' :
             '';
         throw new RuntimeError(400 /* MULTIPLE_PLATFORMS */, errorMessage);
     }
     publishDefaultGlobalUtils();
-    _platform = injector.get(PlatformRef);
+    _platformInjector = injector;
+    const platform = injector.get(PlatformRef);
     const inits = injector.get(PLATFORM_INITIALIZER, null);
     if (inits)
-        inits.forEach((init) => init());
-    return _platform;
+        inits.forEach(initFn => initFn());
+    return platform;
 }
 /**
  * Creates a factory for a platform. Can be used to provide or override `Providers` specific to
@@ -26171,15 +26327,16 @@ function createPlatformFactory(parentPlatformFactory, name, providers = []) {
     return (extraProviders = []) => {
         let platform = getPlatform();
         if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
+            const platformProviders = [
+                ...providers,
+                ...extraProviders,
+                { provide: marker, useValue: true }
+            ];
             if (parentPlatformFactory) {
-                parentPlatformFactory(providers.concat(extraProviders).concat({ provide: marker, useValue: true }));
+                parentPlatformFactory(platformProviders);
             }
             else {
-                const injectedProviders = providers.concat(extraProviders).concat({ provide: marker, useValue: true }, {
-                    provide: INJECTOR_SCOPE,
-                    useValue: 'platform'
-                });
-                createPlatform(Injector.create({ providers: injectedProviders, name: desc }));
+                createPlatform(createPlatformInjector(platformProviders, desc));
             }
         }
         return assertPlatform(marker);
@@ -26202,6 +26359,20 @@ function assertPlatform(requiredToken) {
     }
     return platform;
 }
+/**
+ * Helper function to create an instance of a platform injector (that maintains the 'platform'
+ * scope).
+ */
+function createPlatformInjector(providers = [], name) {
+    return Injector.create({
+        name,
+        providers: [
+            { provide: INJECTOR_SCOPE, useValue: 'platform' },
+            { provide: PLATFORM_ON_DESTROY, useValue: () => _platformInjector = null },
+            ...providers
+        ],
+    });
+}
 /**
  * Destroys the current Angular platform and all Angular applications on the page.
  * Destroys all modules and listeners registered with the platform.
@@ -26209,9 +26380,7 @@ function assertPlatform(requiredToken) {
  * @publicApi
  */
 function destroyPlatform() {
-    if (_platform && !_platform.destroyed) {
-        _platform.destroy();
-    }
+    getPlatform()?.destroy();
 }
 /**
  * Returns the current platform.
@@ -26219,7 +26388,7 @@ function destroyPlatform() {
  * @publicApi
  */
 function getPlatform() {
-    return _platform && !_platform.destroyed ? _platform : null;
+    return _platformInjector?.get(PlatformRef) ?? null;
 }
 /**
  * The Angular platform is the entry point for Angular on a web page.
@@ -26353,12 +26522,17 @@ class PlatformRef {
             const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
                 'The platform has already been destroyed!' :
                 '';
-            throw new RuntimeError(404 /* ALREADY_DESTROYED_PLATFORM */, errorMessage);
+            throw new RuntimeError(404 /* PLATFORM_ALREADY_DESTROYED */, errorMessage);
         }
         this._modules.slice().forEach(module => module.destroy());
         this._destroyListeners.forEach(listener => listener());
+        const destroyListener = this._injector.get(PLATFORM_ON_DESTROY, null);
+        destroyListener?.();
         this._destroyed = true;
     }
+    /**
+     * Indicates whether this instance was destroyed.
+     */
     get destroyed() {
         return this._destroyed;
     }
@@ -26515,6 +26689,8 @@ class ApplicationRef {
         this._views = [];
         this._runningTick = false;
         this._stable = true;
+        this._destroyed = false;
+        this._destroyListeners = [];
         /**
          * Get a list of component types registered to this application.
          * This list is populated even before the component is created.
@@ -26574,6 +26750,12 @@ class ApplicationRef {
         this.isStable =
             merge$1(isCurrentlyStable, isStable.pipe(share()));
     }
+    /**
+     * Indicates whether this instance was destroyed.
+     */
+    get destroyed() {
+        return this._destroyed;
+    }
     /**
      * Bootstrap a component onto the element identified by its selector or, optionally, to a
      * specified element.
@@ -26612,6 +26794,7 @@ class ApplicationRef {
      * {@example core/ts/platform/platform.ts region='domNode'}
      */
     bootstrap(componentOrFactory, rootSelectorOrNode) {
+        NG_DEV_MODE && this.warnIfDestroyed();
         if (!this._initStatus.done) {
             const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
                 'Cannot bootstrap as there are still asynchronous initializers running. ' +
@@ -26663,6 +26846,7 @@ class ApplicationRef {
      * detection pass during which all change detection must complete.
      */
     tick() {
+        NG_DEV_MODE && this.warnIfDestroyed();
         if (this._runningTick) {
             const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
                 'ApplicationRef.tick is called recursively' :
@@ -26694,6 +26878,7 @@ class ApplicationRef {
      * This will throw if the view is already attached to a ViewContainer.
      */
     attachView(viewRef) {
+        NG_DEV_MODE && this.warnIfDestroyed();
         const view = viewRef;
         this._views.push(view);
         view.attachToAppRef(this);
@@ -26702,6 +26887,7 @@ class ApplicationRef {
      * Detaches a view from dirty checking again.
      */
     detachView(viewRef) {
+        NG_DEV_MODE && this.warnIfDestroyed();
         const view = viewRef;
         remove(this._views, view);
         view.detachFromAppRef();
@@ -26716,8 +26902,48 @@ class ApplicationRef {
     }
     /** @internal */
     ngOnDestroy() {
-        this._views.slice().forEach((view) => view.destroy());
-        this._onMicrotaskEmptySubscription.unsubscribe();
+        if (this._destroyed)
+            return;
+        try {
+            // Call all the lifecycle hooks.
+            this._destroyListeners.forEach(listener => listener());
+            // Destroy all registered views.
+            this._views.slice().forEach((view) => view.destroy());
+            this._onMicrotaskEmptySubscription.unsubscribe();
+        }
+        finally {
+            // Indicate that this instance is destroyed.
+            this._destroyed = true;
+            // Release all references.
+            this._views = [];
+            this._bootstrapListeners = [];
+            this._destroyListeners = [];
+        }
+    }
+    /**
+     * Registers a listener to be called when an instance is destroyed.
+     *
+     * @param callback A callback function to add as a listener.
+     * @returns A function which unregisters a listener.
+     *
+     * @internal
+     */
+    onDestroy(callback) {
+        NG_DEV_MODE && this.warnIfDestroyed();
+        this._destroyListeners.push(callback);
+        return () => remove(this._destroyListeners, callback);
+    }
+    destroy() {
+        if (this._destroyed) {
+            throw new RuntimeError(406 /* APPLICATION_REF_ALREADY_DESTROYED */, NG_DEV_MODE && 'This instance of the `ApplicationRef` has already been destroyed.');
+        }
+        const injector = this._injector;
+        // Check that this injector instance supports destroy operation.
+        if (injector.destroy && !injector.destroyed) {
+            // Destroying an underlying injector will trigger the `ngOnDestroy` lifecycle
+            // hook, which invokes the remaining cleanup actions.
+            injector.destroy();
+        }
     }
     /**
      * Returns the number of attached views.
@@ -26725,6 +26951,11 @@ class ApplicationRef {
     get viewCount() {
         return this._views.length;
     }
+    warnIfDestroyed() {
+        if (NG_DEV_MODE && this._destroyed) {
+            console.warn(formatRuntimeError(406 /* APPLICATION_REF_ALREADY_DESTROYED */, 'This instance of the `ApplicationRef` has already been destroyed.'));
+        }
+    }
 }
 ApplicationRef.ɵfac = function ApplicationRef_Factory(t) { return new (t || ApplicationRef)(ɵɵinject(NgZone), ɵɵinject(Injector), ɵɵinject(ErrorHandler), ɵɵinject(ApplicationInitStatus)); };
 ApplicationRef.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationRef, factory: ApplicationRef.ɵfac, providedIn: 'root' });
@@ -28915,5 +29146,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANALYZE_FOR_ENTRY_COMPONENTS, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, Directive, ElementRef, EmbeddedViewRef, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, asNativeElements, assertPlatform, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, inject, isDevMode, platformCore, resolveForwardRef, setTestabilityGetter, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ChangeDetectorStatus as ɵChangeDetectorStatus, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, ViewRef$1 as ɵViewRef, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, coerceToBoolean as ɵcoerceToBoolean, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, getDebugNode as ɵgetDebugNode, getDebugNodeR2 as ɵgetDebugNodeR2, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, isBoundToModule as ɵisBoundToModule, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, isListLikeIterable as ɵisListLikeIterable, isObservable as ɵisObservable, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, ɵivyEnabled, makeDecorator as ɵmakeDecorator, markDirty as ɵmarkDirty, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderComponent as ɵrenderComponent, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenRendered as ɵwhenRendered, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵviewQuery };
+export { ANALYZE_FOR_ENTRY_COMPONENTS, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, Directive, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, INJECTOR_INITIALIZER, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, asNativeElements, assertPlatform, createEnvironmentInjector, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, inject, isDevMode, platformCore, resolveForwardRef, setTestabilityGetter, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ChangeDetectorStatus as ɵChangeDetectorStatus, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, ViewRef$1 as ɵViewRef, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, coerceToBoolean as ɵcoerceToBoolean, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, getDebugNode as ɵgetDebugNode, getDebugNodeR2 as ɵgetDebugNodeR2, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, isBoundToModule as ɵisBoundToModule, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, isListLikeIterable as ɵisListLikeIterable, isObservable as ɵisObservable, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, ɵivyEnabled, makeDecorator as ɵmakeDecorator, markDirty as ɵmarkDirty, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderComponent as ɵrenderComponent, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenRendered as ɵwhenRendered, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵviewQuery };
 //# sourceMappingURL=core.mjs.map