@angular/core 13.0.0-next.8 → 13.0.0-rc.2

package/esm2020/src/render3/jit/environment.mjs

@@ -0,0 +1,165 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { forwardRef, resolveForwardRef } from '../../di/forward_ref';
+import { ɵɵinject, ɵɵinvalidFactoryDep } from '../../di/injector_compatibility';
+import { ɵɵdefineInjectable, ɵɵdefineInjector } from '../../di/interface/defs';
+import * as sanitization from '../../sanitization/sanitization';
+import * as r3 from '../index';
+/**
+ * A mapping of the @angular/core API surface used in generated expressions to the actual symbols.
+ *
+ * This should be kept up to date with the public exports of @angular/core.
+ */
+export const angularCoreEnv = (() => ({
+    'ɵɵattribute': r3.ɵɵattribute,
+    'ɵɵattributeInterpolate1': r3.ɵɵattributeInterpolate1,
+    'ɵɵattributeInterpolate2': r3.ɵɵattributeInterpolate2,
+    'ɵɵattributeInterpolate3': r3.ɵɵattributeInterpolate3,
+    'ɵɵattributeInterpolate4': r3.ɵɵattributeInterpolate4,
+    'ɵɵattributeInterpolate5': r3.ɵɵattributeInterpolate5,
+    'ɵɵattributeInterpolate6': r3.ɵɵattributeInterpolate6,
+    'ɵɵattributeInterpolate7': r3.ɵɵattributeInterpolate7,
+    'ɵɵattributeInterpolate8': r3.ɵɵattributeInterpolate8,
+    'ɵɵattributeInterpolateV': r3.ɵɵattributeInterpolateV,
+    'ɵɵdefineComponent': r3.ɵɵdefineComponent,
+    'ɵɵdefineDirective': r3.ɵɵdefineDirective,
+    'ɵɵdefineInjectable': ɵɵdefineInjectable,
+    'ɵɵdefineInjector': ɵɵdefineInjector,
+    'ɵɵdefineNgModule': r3.ɵɵdefineNgModule,
+    'ɵɵdefinePipe': r3.ɵɵdefinePipe,
+    'ɵɵdirectiveInject': r3.ɵɵdirectiveInject,
+    'ɵɵgetInheritedFactory': r3.ɵɵgetInheritedFactory,
+    'ɵɵinject': ɵɵinject,
+    'ɵɵinjectAttribute': r3.ɵɵinjectAttribute,
+    'ɵɵinvalidFactory': r3.ɵɵinvalidFactory,
+    'ɵɵinvalidFactoryDep': ɵɵinvalidFactoryDep,
+    'ɵɵtemplateRefExtractor': r3.ɵɵtemplateRefExtractor,
+    'ɵɵNgOnChangesFeature': r3.ɵɵNgOnChangesFeature,
+    'ɵɵProvidersFeature': r3.ɵɵProvidersFeature,
+    'ɵɵCopyDefinitionFeature': r3.ɵɵCopyDefinitionFeature,
+    'ɵɵInheritDefinitionFeature': r3.ɵɵInheritDefinitionFeature,
+    'ɵɵnextContext': r3.ɵɵnextContext,
+    'ɵɵnamespaceHTML': r3.ɵɵnamespaceHTML,
+    'ɵɵnamespaceMathML': r3.ɵɵnamespaceMathML,
+    'ɵɵnamespaceSVG': r3.ɵɵnamespaceSVG,
+    'ɵɵenableBindings': r3.ɵɵenableBindings,
+    'ɵɵdisableBindings': r3.ɵɵdisableBindings,
+    'ɵɵelementStart': r3.ɵɵelementStart,
+    'ɵɵelementEnd': r3.ɵɵelementEnd,
+    'ɵɵelement': r3.ɵɵelement,
+    'ɵɵelementContainerStart': r3.ɵɵelementContainerStart,
+    'ɵɵelementContainerEnd': r3.ɵɵelementContainerEnd,
+    'ɵɵelementContainer': r3.ɵɵelementContainer,
+    'ɵɵpureFunction0': r3.ɵɵpureFunction0,
+    'ɵɵpureFunction1': r3.ɵɵpureFunction1,
+    'ɵɵpureFunction2': r3.ɵɵpureFunction2,
+    'ɵɵpureFunction3': r3.ɵɵpureFunction3,
+    'ɵɵpureFunction4': r3.ɵɵpureFunction4,
+    'ɵɵpureFunction5': r3.ɵɵpureFunction5,
+    'ɵɵpureFunction6': r3.ɵɵpureFunction6,
+    'ɵɵpureFunction7': r3.ɵɵpureFunction7,
+    'ɵɵpureFunction8': r3.ɵɵpureFunction8,
+    'ɵɵpureFunctionV': r3.ɵɵpureFunctionV,
+    'ɵɵgetCurrentView': r3.ɵɵgetCurrentView,
+    'ɵɵrestoreView': r3.ɵɵrestoreView,
+    'ɵɵlistener': r3.ɵɵlistener,
+    'ɵɵprojection': r3.ɵɵprojection,
+    'ɵɵsyntheticHostProperty': r3.ɵɵsyntheticHostProperty,
+    'ɵɵsyntheticHostListener': r3.ɵɵsyntheticHostListener,
+    'ɵɵpipeBind1': r3.ɵɵpipeBind1,
+    'ɵɵpipeBind2': r3.ɵɵpipeBind2,
+    'ɵɵpipeBind3': r3.ɵɵpipeBind3,
+    'ɵɵpipeBind4': r3.ɵɵpipeBind4,
+    'ɵɵpipeBindV': r3.ɵɵpipeBindV,
+    'ɵɵprojectionDef': r3.ɵɵprojectionDef,
+    'ɵɵhostProperty': r3.ɵɵhostProperty,
+    'ɵɵproperty': r3.ɵɵproperty,
+    'ɵɵpropertyInterpolate': r3.ɵɵpropertyInterpolate,
+    'ɵɵpropertyInterpolate1': r3.ɵɵpropertyInterpolate1,
+    'ɵɵpropertyInterpolate2': r3.ɵɵpropertyInterpolate2,
+    'ɵɵpropertyInterpolate3': r3.ɵɵpropertyInterpolate3,
+    'ɵɵpropertyInterpolate4': r3.ɵɵpropertyInterpolate4,
+    'ɵɵpropertyInterpolate5': r3.ɵɵpropertyInterpolate5,
+    'ɵɵpropertyInterpolate6': r3.ɵɵpropertyInterpolate6,
+    'ɵɵpropertyInterpolate7': r3.ɵɵpropertyInterpolate7,
+    'ɵɵpropertyInterpolate8': r3.ɵɵpropertyInterpolate8,
+    'ɵɵpropertyInterpolateV': r3.ɵɵpropertyInterpolateV,
+    'ɵɵpipe': r3.ɵɵpipe,
+    'ɵɵqueryRefresh': r3.ɵɵqueryRefresh,
+    'ɵɵviewQuery': r3.ɵɵviewQuery,
+    'ɵɵloadQuery': r3.ɵɵloadQuery,
+    'ɵɵcontentQuery': r3.ɵɵcontentQuery,
+    'ɵɵreference': r3.ɵɵreference,
+    'ɵɵclassMap': r3.ɵɵclassMap,
+    'ɵɵclassMapInterpolate1': r3.ɵɵclassMapInterpolate1,
+    'ɵɵclassMapInterpolate2': r3.ɵɵclassMapInterpolate2,
+    'ɵɵclassMapInterpolate3': r3.ɵɵclassMapInterpolate3,
+    'ɵɵclassMapInterpolate4': r3.ɵɵclassMapInterpolate4,
+    'ɵɵclassMapInterpolate5': r3.ɵɵclassMapInterpolate5,
+    'ɵɵclassMapInterpolate6': r3.ɵɵclassMapInterpolate6,
+    'ɵɵclassMapInterpolate7': r3.ɵɵclassMapInterpolate7,
+    'ɵɵclassMapInterpolate8': r3.ɵɵclassMapInterpolate8,
+    'ɵɵclassMapInterpolateV': r3.ɵɵclassMapInterpolateV,
+    'ɵɵstyleMap': r3.ɵɵstyleMap,
+    'ɵɵstyleMapInterpolate1': r3.ɵɵstyleMapInterpolate1,
+    'ɵɵstyleMapInterpolate2': r3.ɵɵstyleMapInterpolate2,
+    'ɵɵstyleMapInterpolate3': r3.ɵɵstyleMapInterpolate3,
+    'ɵɵstyleMapInterpolate4': r3.ɵɵstyleMapInterpolate4,
+    'ɵɵstyleMapInterpolate5': r3.ɵɵstyleMapInterpolate5,
+    'ɵɵstyleMapInterpolate6': r3.ɵɵstyleMapInterpolate6,
+    'ɵɵstyleMapInterpolate7': r3.ɵɵstyleMapInterpolate7,
+    'ɵɵstyleMapInterpolate8': r3.ɵɵstyleMapInterpolate8,
+    'ɵɵstyleMapInterpolateV': r3.ɵɵstyleMapInterpolateV,
+    'ɵɵstyleProp': r3.ɵɵstyleProp,
+    'ɵɵstylePropInterpolate1': r3.ɵɵstylePropInterpolate1,
+    'ɵɵstylePropInterpolate2': r3.ɵɵstylePropInterpolate2,
+    'ɵɵstylePropInterpolate3': r3.ɵɵstylePropInterpolate3,
+    'ɵɵstylePropInterpolate4': r3.ɵɵstylePropInterpolate4,
+    'ɵɵstylePropInterpolate5': r3.ɵɵstylePropInterpolate5,
+    'ɵɵstylePropInterpolate6': r3.ɵɵstylePropInterpolate6,
+    'ɵɵstylePropInterpolate7': r3.ɵɵstylePropInterpolate7,
+    'ɵɵstylePropInterpolate8': r3.ɵɵstylePropInterpolate8,
+    'ɵɵstylePropInterpolateV': r3.ɵɵstylePropInterpolateV,
+    'ɵɵclassProp': r3.ɵɵclassProp,
+    'ɵɵadvance': r3.ɵɵadvance,
+    'ɵɵtemplate': r3.ɵɵtemplate,
+    'ɵɵtext': r3.ɵɵtext,
+    'ɵɵtextInterpolate': r3.ɵɵtextInterpolate,
+    'ɵɵtextInterpolate1': r3.ɵɵtextInterpolate1,
+    'ɵɵtextInterpolate2': r3.ɵɵtextInterpolate2,
+    'ɵɵtextInterpolate3': r3.ɵɵtextInterpolate3,
+    'ɵɵtextInterpolate4': r3.ɵɵtextInterpolate4,
+    'ɵɵtextInterpolate5': r3.ɵɵtextInterpolate5,
+    'ɵɵtextInterpolate6': r3.ɵɵtextInterpolate6,
+    'ɵɵtextInterpolate7': r3.ɵɵtextInterpolate7,
+    'ɵɵtextInterpolate8': r3.ɵɵtextInterpolate8,
+    'ɵɵtextInterpolateV': r3.ɵɵtextInterpolateV,
+    'ɵɵi18n': r3.ɵɵi18n,
+    'ɵɵi18nAttributes': r3.ɵɵi18nAttributes,
+    'ɵɵi18nExp': r3.ɵɵi18nExp,
+    'ɵɵi18nStart': r3.ɵɵi18nStart,
+    'ɵɵi18nEnd': r3.ɵɵi18nEnd,
+    'ɵɵi18nApply': r3.ɵɵi18nApply,
+    'ɵɵi18nPostprocess': r3.ɵɵi18nPostprocess,
+    'ɵɵresolveWindow': r3.ɵɵresolveWindow,
+    'ɵɵresolveDocument': r3.ɵɵresolveDocument,
+    'ɵɵresolveBody': r3.ɵɵresolveBody,
+    'ɵɵsetComponentScope': r3.ɵɵsetComponentScope,
+    'ɵɵsetNgModuleScope': r3.ɵɵsetNgModuleScope,
+    'ɵɵsanitizeHtml': sanitization.ɵɵsanitizeHtml,
+    'ɵɵsanitizeStyle': sanitization.ɵɵsanitizeStyle,
+    'ɵɵsanitizeResourceUrl': sanitization.ɵɵsanitizeResourceUrl,
+    'ɵɵsanitizeScript': sanitization.ɵɵsanitizeScript,
+    'ɵɵsanitizeUrl': sanitization.ɵɵsanitizeUrl,
+    'ɵɵsanitizeUrlOrResourceUrl': sanitization.ɵɵsanitizeUrlOrResourceUrl,
+    'ɵɵtrustConstantHtml': sanitization.ɵɵtrustConstantHtml,
+    'ɵɵtrustConstantResourceUrl': sanitization.ɵɵtrustConstantResourceUrl,
+    'forwardRef': forwardRef,
+    'resolveForwardRef': resolveForwardRef,
+}))();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/jit/environment.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {forwardRef, resolveForwardRef} from '../../di/forward_ref';\nimport {ɵɵinject, ɵɵinvalidFactoryDep} from '../../di/injector_compatibility';\nimport {ɵɵdefineInjectable, ɵɵdefineInjector} from '../../di/interface/defs';\nimport * as sanitization from '../../sanitization/sanitization';\nimport * as r3 from '../index';\n\n\n/**\n * A mapping of the @angular/core API surface used in generated expressions to the actual symbols.\n *\n * This should be kept up to date with the public exports of @angular/core.\n */\nexport const angularCoreEnv: {[name: string]: Function} =\n    (() => ({\n       'ɵɵattribute': r3.ɵɵattribute,\n       'ɵɵattributeInterpolate1': r3.ɵɵattributeInterpolate1,\n       'ɵɵattributeInterpolate2': r3.ɵɵattributeInterpolate2,\n       'ɵɵattributeInterpolate3': r3.ɵɵattributeInterpolate3,\n       'ɵɵattributeInterpolate4': r3.ɵɵattributeInterpolate4,\n       'ɵɵattributeInterpolate5': r3.ɵɵattributeInterpolate5,\n       'ɵɵattributeInterpolate6': r3.ɵɵattributeInterpolate6,\n       'ɵɵattributeInterpolate7': r3.ɵɵattributeInterpolate7,\n       'ɵɵattributeInterpolate8': r3.ɵɵattributeInterpolate8,\n       'ɵɵattributeInterpolateV': r3.ɵɵattributeInterpolateV,\n       'ɵɵdefineComponent': r3.ɵɵdefineComponent,\n       'ɵɵdefineDirective': r3.ɵɵdefineDirective,\n       'ɵɵdefineInjectable': ɵɵdefineInjectable,\n       'ɵɵdefineInjector': ɵɵdefineInjector,\n       'ɵɵdefineNgModule': r3.ɵɵdefineNgModule,\n       'ɵɵdefinePipe': r3.ɵɵdefinePipe,\n       'ɵɵdirectiveInject': r3.ɵɵdirectiveInject,\n       'ɵɵgetInheritedFactory': r3.ɵɵgetInheritedFactory,\n       'ɵɵinject': ɵɵinject,\n       'ɵɵinjectAttribute': r3.ɵɵinjectAttribute,\n       'ɵɵinvalidFactory': r3.ɵɵinvalidFactory,\n       'ɵɵinvalidFactoryDep': ɵɵinvalidFactoryDep,\n       'ɵɵtemplateRefExtractor': r3.ɵɵtemplateRefExtractor,\n       'ɵɵNgOnChangesFeature': r3.ɵɵNgOnChangesFeature,\n       'ɵɵProvidersFeature': r3.ɵɵProvidersFeature,\n       'ɵɵCopyDefinitionFeature': r3.ɵɵCopyDefinitionFeature,\n       'ɵɵInheritDefinitionFeature': r3.ɵɵInheritDefinitionFeature,\n       'ɵɵnextContext': r3.ɵɵnextContext,\n       'ɵɵnamespaceHTML': r3.ɵɵnamespaceHTML,\n       'ɵɵnamespaceMathML': r3.ɵɵnamespaceMathML,\n       'ɵɵnamespaceSVG': r3.ɵɵnamespaceSVG,\n       'ɵɵenableBindings': r3.ɵɵenableBindings,\n       'ɵɵdisableBindings': r3.ɵɵdisableBindings,\n       'ɵɵelementStart': r3.ɵɵelementStart,\n       'ɵɵelementEnd': r3.ɵɵelementEnd,\n       'ɵɵelement': r3.ɵɵelement,\n       'ɵɵelementContainerStart': r3.ɵɵelementContainerStart,\n       'ɵɵelementContainerEnd': r3.ɵɵelementContainerEnd,\n       'ɵɵelementContainer': r3.ɵɵelementContainer,\n       'ɵɵpureFunction0': r3.ɵɵpureFunction0,\n       'ɵɵpureFunction1': r3.ɵɵpureFunction1,\n       'ɵɵpureFunction2': r3.ɵɵpureFunction2,\n       'ɵɵpureFunction3': r3.ɵɵpureFunction3,\n       'ɵɵpureFunction4': r3.ɵɵpureFunction4,\n       'ɵɵpureFunction5': r3.ɵɵpureFunction5,\n       'ɵɵpureFunction6': r3.ɵɵpureFunction6,\n       'ɵɵpureFunction7': r3.ɵɵpureFunction7,\n       'ɵɵpureFunction8': r3.ɵɵpureFunction8,\n       'ɵɵpureFunctionV': r3.ɵɵpureFunctionV,\n       'ɵɵgetCurrentView': r3.ɵɵgetCurrentView,\n       'ɵɵrestoreView': r3.ɵɵrestoreView,\n       'ɵɵlistener': r3.ɵɵlistener,\n       'ɵɵprojection': r3.ɵɵprojection,\n       'ɵɵsyntheticHostProperty': r3.ɵɵsyntheticHostProperty,\n       'ɵɵsyntheticHostListener': r3.ɵɵsyntheticHostListener,\n       'ɵɵpipeBind1': r3.ɵɵpipeBind1,\n       'ɵɵpipeBind2': r3.ɵɵpipeBind2,\n       'ɵɵpipeBind3': r3.ɵɵpipeBind3,\n       'ɵɵpipeBind4': r3.ɵɵpipeBind4,\n       'ɵɵpipeBindV': r3.ɵɵpipeBindV,\n       'ɵɵprojectionDef': r3.ɵɵprojectionDef,\n       'ɵɵhostProperty': r3.ɵɵhostProperty,\n       'ɵɵproperty': r3.ɵɵproperty,\n       'ɵɵpropertyInterpolate': r3.ɵɵpropertyInterpolate,\n       'ɵɵpropertyInterpolate1': r3.ɵɵpropertyInterpolate1,\n       'ɵɵpropertyInterpolate2': r3.ɵɵpropertyInterpolate2,\n       'ɵɵpropertyInterpolate3': r3.ɵɵpropertyInterpolate3,\n       'ɵɵpropertyInterpolate4': r3.ɵɵpropertyInterpolate4,\n       'ɵɵpropertyInterpolate5': r3.ɵɵpropertyInterpolate5,\n       'ɵɵpropertyInterpolate6': r3.ɵɵpropertyInterpolate6,\n       'ɵɵpropertyInterpolate7': r3.ɵɵpropertyInterpolate7,\n       'ɵɵpropertyInterpolate8': r3.ɵɵpropertyInterpolate8,\n       'ɵɵpropertyInterpolateV': r3.ɵɵpropertyInterpolateV,\n       'ɵɵpipe': r3.ɵɵpipe,\n       'ɵɵqueryRefresh': r3.ɵɵqueryRefresh,\n       'ɵɵviewQuery': r3.ɵɵviewQuery,\n       'ɵɵloadQuery': r3.ɵɵloadQuery,\n       'ɵɵcontentQuery': r3.ɵɵcontentQuery,\n       'ɵɵreference': r3.ɵɵreference,\n       'ɵɵclassMap': r3.ɵɵclassMap,\n       'ɵɵclassMapInterpolate1': r3.ɵɵclassMapInterpolate1,\n       'ɵɵclassMapInterpolate2': r3.ɵɵclassMapInterpolate2,\n       'ɵɵclassMapInterpolate3': r3.ɵɵclassMapInterpolate3,\n       'ɵɵclassMapInterpolate4': r3.ɵɵclassMapInterpolate4,\n       'ɵɵclassMapInterpolate5': r3.ɵɵclassMapInterpolate5,\n       'ɵɵclassMapInterpolate6': r3.ɵɵclassMapInterpolate6,\n       'ɵɵclassMapInterpolate7': r3.ɵɵclassMapInterpolate7,\n       'ɵɵclassMapInterpolate8': r3.ɵɵclassMapInterpolate8,\n       'ɵɵclassMapInterpolateV': r3.ɵɵclassMapInterpolateV,\n       'ɵɵstyleMap': r3.ɵɵstyleMap,\n       'ɵɵstyleMapInterpolate1': r3.ɵɵstyleMapInterpolate1,\n       'ɵɵstyleMapInterpolate2': r3.ɵɵstyleMapInterpolate2,\n       'ɵɵstyleMapInterpolate3': r3.ɵɵstyleMapInterpolate3,\n       'ɵɵstyleMapInterpolate4': r3.ɵɵstyleMapInterpolate4,\n       'ɵɵstyleMapInterpolate5': r3.ɵɵstyleMapInterpolate5,\n       'ɵɵstyleMapInterpolate6': r3.ɵɵstyleMapInterpolate6,\n       'ɵɵstyleMapInterpolate7': r3.ɵɵstyleMapInterpolate7,\n       'ɵɵstyleMapInterpolate8': r3.ɵɵstyleMapInterpolate8,\n       'ɵɵstyleMapInterpolateV': r3.ɵɵstyleMapInterpolateV,\n       'ɵɵstyleProp': r3.ɵɵstyleProp,\n       'ɵɵstylePropInterpolate1': r3.ɵɵstylePropInterpolate1,\n       'ɵɵstylePropInterpolate2': r3.ɵɵstylePropInterpolate2,\n       'ɵɵstylePropInterpolate3': r3.ɵɵstylePropInterpolate3,\n       'ɵɵstylePropInterpolate4': r3.ɵɵstylePropInterpolate4,\n       'ɵɵstylePropInterpolate5': r3.ɵɵstylePropInterpolate5,\n       'ɵɵstylePropInterpolate6': r3.ɵɵstylePropInterpolate6,\n       'ɵɵstylePropInterpolate7': r3.ɵɵstylePropInterpolate7,\n       'ɵɵstylePropInterpolate8': r3.ɵɵstylePropInterpolate8,\n       'ɵɵstylePropInterpolateV': r3.ɵɵstylePropInterpolateV,\n       'ɵɵclassProp': r3.ɵɵclassProp,\n       'ɵɵadvance': r3.ɵɵadvance,\n       'ɵɵtemplate': r3.ɵɵtemplate,\n       'ɵɵtext': r3.ɵɵtext,\n       'ɵɵtextInterpolate': r3.ɵɵtextInterpolate,\n       'ɵɵtextInterpolate1': r3.ɵɵtextInterpolate1,\n       'ɵɵtextInterpolate2': r3.ɵɵtextInterpolate2,\n       'ɵɵtextInterpolate3': r3.ɵɵtextInterpolate3,\n       'ɵɵtextInterpolate4': r3.ɵɵtextInterpolate4,\n       'ɵɵtextInterpolate5': r3.ɵɵtextInterpolate5,\n       'ɵɵtextInterpolate6': r3.ɵɵtextInterpolate6,\n       'ɵɵtextInterpolate7': r3.ɵɵtextInterpolate7,\n       'ɵɵtextInterpolate8': r3.ɵɵtextInterpolate8,\n       'ɵɵtextInterpolateV': r3.ɵɵtextInterpolateV,\n       'ɵɵi18n': r3.ɵɵi18n,\n       'ɵɵi18nAttributes': r3.ɵɵi18nAttributes,\n       'ɵɵi18nExp': r3.ɵɵi18nExp,\n       'ɵɵi18nStart': r3.ɵɵi18nStart,\n       'ɵɵi18nEnd': r3.ɵɵi18nEnd,\n       'ɵɵi18nApply': r3.ɵɵi18nApply,\n       'ɵɵi18nPostprocess': r3.ɵɵi18nPostprocess,\n       'ɵɵresolveWindow': r3.ɵɵresolveWindow,\n       'ɵɵresolveDocument': r3.ɵɵresolveDocument,\n       'ɵɵresolveBody': r3.ɵɵresolveBody,\n       'ɵɵsetComponentScope': r3.ɵɵsetComponentScope,\n       'ɵɵsetNgModuleScope': r3.ɵɵsetNgModuleScope,\n\n       'ɵɵsanitizeHtml': sanitization.ɵɵsanitizeHtml,\n       'ɵɵsanitizeStyle': sanitization.ɵɵsanitizeStyle,\n       'ɵɵsanitizeResourceUrl': sanitization.ɵɵsanitizeResourceUrl,\n       'ɵɵsanitizeScript': sanitization.ɵɵsanitizeScript,\n       'ɵɵsanitizeUrl': sanitization.ɵɵsanitizeUrl,\n       'ɵɵsanitizeUrlOrResourceUrl': sanitization.ɵɵsanitizeUrlOrResourceUrl,\n       'ɵɵtrustConstantHtml': sanitization.ɵɵtrustConstantHtml,\n       'ɵɵtrustConstantResourceUrl': sanitization.ɵɵtrustConstantResourceUrl,\n\n       'forwardRef': forwardRef,\n       'resolveForwardRef': resolveForwardRef,\n     }))();\n"]}

package/esm2020/src/render3/jit/partial.mjs

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { FactoryTarget, getCompilerFacade } from '../../compiler/compiler_facade';
+import { setClassMetadata } from '../metadata';
+import { angularCoreEnv } from './environment';
+/**
+ * Compiles a partial directive declaration object into a full directive definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareDirective(decl) {
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'directive', type: decl.type });
+    return compiler.compileDirectiveDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
+}
+/**
+ * Evaluates the class metadata declaration.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareClassMetadata(decl) {
+    setClassMetadata(decl.type, decl.decorators, decl.ctorParameters ?? null, decl.propDecorators ?? null);
+}
+/**
+ * Compiles a partial component declaration object into a full component definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareComponent(decl) {
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'component', type: decl.type });
+    return compiler.compileComponentDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵcmp.js`, decl);
+}
+/**
+ * Compiles a partial pipe declaration object into a full pipe definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareFactory(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* PartialDeclaration */,
+        kind: getFactoryKind(decl.target),
+        type: decl.type
+    });
+    return compiler.compileFactoryDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
+}
+function getFactoryKind(target) {
+    switch (target) {
+        case FactoryTarget.Directive:
+            return 'directive';
+        case FactoryTarget.Component:
+            return 'component';
+        case FactoryTarget.Injectable:
+            return 'injectable';
+        case FactoryTarget.Pipe:
+            return 'pipe';
+        case FactoryTarget.NgModule:
+            return 'NgModule';
+    }
+}
+/**
+ * Compiles a partial injectable declaration object into a full injectable definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareInjectable(decl) {
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'injectable', type: decl.type });
+    return compiler.compileInjectableDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵprov.js`, decl);
+}
+/**
+ * These enums are used in the partial factory declaration calls.
+ */
+export { FactoryTarget } from '../../compiler/compiler_facade';
+/**
+ * Compiles a partial injector declaration object into a full injector definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareInjector(decl) {
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'NgModule', type: decl.type });
+    return compiler.compileInjectorDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵinj.js`, decl);
+}
+/**
+ * Compiles a partial NgModule declaration object into a full NgModule definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclareNgModule(decl) {
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'NgModule', type: decl.type });
+    return compiler.compileNgModuleDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵmod.js`, decl);
+}
+/**
+ * Compiles a partial pipe declaration object into a full pipe definition object.
+ *
+ * @codeGenApi
+ */
+export function ɵɵngDeclarePipe(decl) {
+    const compiler = getCompilerFacade({ usage: 1 /* PartialDeclaration */, kind: 'pipe', type: decl.type });
+    return compiler.compilePipeDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵpipe.js`, decl);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partial.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/jit/partial.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {FactoryTarget, getCompilerFacade, JitCompilerUsage, R3DeclareComponentFacade, R3DeclareDirectiveFacade, R3DeclareFactoryFacade, R3DeclareInjectableFacade, R3DeclareInjectorFacade, R3DeclareNgModuleFacade, R3DeclarePipeFacade} from '../../compiler/compiler_facade';\nimport {Type} from '../../interface/type';\nimport {setClassMetadata} from '../metadata';\nimport {angularCoreEnv} from './environment';\n\n/**\n * Compiles a partial directive declaration object into a full directive definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareDirective(decl: R3DeclareDirectiveFacade): unknown {\n  const compiler = getCompilerFacade(\n      {usage: JitCompilerUsage.PartialDeclaration, kind: 'directive', type: decl.type});\n  return compiler.compileDirectiveDeclaration(\n      angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);\n}\n\n/**\n * Evaluates the class metadata declaration.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareClassMetadata(decl: {\n  type: Type<any>; decorators: any[];\n  ctorParameters?: () => any[];\n  propDecorators?: {[field: string]: any};\n}): void {\n  setClassMetadata(\n      decl.type, decl.decorators, decl.ctorParameters ?? null, decl.propDecorators ?? null);\n}\n\n/**\n * Compiles a partial component declaration object into a full component definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareComponent(decl: R3DeclareComponentFacade): unknown {\n  const compiler = getCompilerFacade(\n      {usage: JitCompilerUsage.PartialDeclaration, kind: 'component', type: decl.type});\n  return compiler.compileComponentDeclaration(\n      angularCoreEnv, `ng:///${decl.type.name}/ɵcmp.js`, decl);\n}\n\n/**\n * Compiles a partial pipe declaration object into a full pipe definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareFactory(decl: R3DeclareFactoryFacade): unknown {\n  const compiler = getCompilerFacade({\n    usage: JitCompilerUsage.PartialDeclaration,\n    kind: getFactoryKind(decl.target),\n    type: decl.type\n  });\n  return compiler.compileFactoryDeclaration(\n      angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);\n}\n\nfunction getFactoryKind(target: FactoryTarget) {\n  switch (target) {\n    case FactoryTarget.Directive:\n      return 'directive';\n    case FactoryTarget.Component:\n      return 'component';\n    case FactoryTarget.Injectable:\n      return 'injectable';\n    case FactoryTarget.Pipe:\n      return 'pipe';\n    case FactoryTarget.NgModule:\n      return 'NgModule';\n  }\n}\n\n/**\n * Compiles a partial injectable declaration object into a full injectable definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareInjectable(decl: R3DeclareInjectableFacade): unknown {\n  const compiler = getCompilerFacade(\n      {usage: JitCompilerUsage.PartialDeclaration, kind: 'injectable', type: decl.type});\n  return compiler.compileInjectableDeclaration(\n      angularCoreEnv, `ng:///${decl.type.name}/ɵprov.js`, decl);\n}\n\n/**\n * These enums are used in the partial factory declaration calls.\n */\nexport {FactoryTarget} from '../../compiler/compiler_facade';\n\n/**\n * Compiles a partial injector declaration object into a full injector definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareInjector(decl: R3DeclareInjectorFacade): unknown {\n  const compiler = getCompilerFacade(\n      {usage: JitCompilerUsage.PartialDeclaration, kind: 'NgModule', type: decl.type});\n  return compiler.compileInjectorDeclaration(\n      angularCoreEnv, `ng:///${decl.type.name}/ɵinj.js`, decl);\n}\n\n/**\n * Compiles a partial NgModule declaration object into a full NgModule definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclareNgModule(decl: R3DeclareNgModuleFacade): unknown {\n  const compiler = getCompilerFacade(\n      {usage: JitCompilerUsage.PartialDeclaration, kind: 'NgModule', type: decl.type});\n  return compiler.compileNgModuleDeclaration(\n      angularCoreEnv, `ng:///${decl.type.name}/ɵmod.js`, decl);\n}\n\n/**\n * Compiles a partial pipe declaration object into a full pipe definition object.\n *\n * @codeGenApi\n */\nexport function ɵɵngDeclarePipe(decl: R3DeclarePipeFacade): unknown {\n  const compiler = getCompilerFacade(\n      {usage: JitCompilerUsage.PartialDeclaration, kind: 'pipe', type: decl.type});\n  return compiler.compilePipeDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵpipe.js`, decl);\n}\n"]}

package/esm2020/src/render3/metadata.mjs

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { noSideEffects } from '../util/closure';
+/**
+ * Adds decorator, constructor, and property metadata to a given type via static metadata fields
+ * on the type.
+ *
+ * These metadata fields can later be read with Angular's `ReflectionCapabilities` API.
+ *
+ * Calls to `setClassMetadata` can be guarded by ngDevMode, resulting in the metadata assignments
+ * being tree-shaken away during production builds.
+ */
+export function setClassMetadata(type, decorators, ctorParameters, propDecorators) {
+    return noSideEffects(() => {
+        const clazz = type;
+        if (decorators !== null) {
+            if (clazz.hasOwnProperty('decorators') && clazz.decorators !== undefined) {
+                clazz.decorators.push(...decorators);
+            }
+            else {
+                clazz.decorators = decorators;
+            }
+        }
+        if (ctorParameters !== null) {
+            // Rather than merging, clobber the existing parameters. If other projects exist which
+            // use tsickle-style annotations and reflect over them in the same way, this could
+            // cause issues, but that is vanishingly unlikely.
+            clazz.ctorParameters = ctorParameters;
+        }
+        if (propDecorators !== null) {
+            // The property decorator objects are merged as it is possible different fields have
+            // different decorator types. Decorators on individual fields are not merged, as it's
+            // also incredibly unlikely that a field will be decorated both with an Angular
+            // decorator and a non-Angular decorator that's also been downleveled.
+            if (clazz.hasOwnProperty('propDecorators') && clazz.propDecorators !== undefined) {
+                clazz.propDecorators = { ...clazz.propDecorators, ...propDecorators };
+            }
+            else {
+                clazz.propDecorators = propDecorators;
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/render3/ng_module_ref.mjs

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injector } from '../di/injector';
+import { INJECTOR } from '../di/injector_token';
+import { InjectFlags } from '../di/interface/injector';
+import { createInjectorWithoutInjectorInstances } from '../di/r3_injector';
+import { ComponentFactoryResolver as viewEngine_ComponentFactoryResolver } from '../linker/component_factory_resolver';
+import { NgModuleFactory as viewEngine_NgModuleFactory, NgModuleRef as viewEngine_NgModuleRef } from '../linker/ng_module_factory';
+import { registerNgModuleType } from '../linker/ng_module_factory_registration';
+import { assertDefined } from '../util/assert';
+import { stringify } from '../util/stringify';
+import { ComponentFactoryResolver } from './component_ref';
+import { getNgLocaleIdDef, getNgModuleDef } from './definition';
+import { setLocaleId } from './i18n/i18n_locale_id';
+import { maybeUnwrapFn } from './util/misc_utils';
+export function createNgModuleRef__PRE_R3__(ngModule, parentInjector) {
+    throw new Error(`This API is Ivy-only and is not supported in ViewEngine`);
+}
+export function createNgModuleRef__POST_R3__(ngModule, parentInjector) {
+    return new NgModuleRef(ngModule, parentInjector ?? null);
+}
+/**
+ * Returns a new NgModuleRef instance based on the NgModule class and parent injector provided.
+ * @param ngModule NgModule class.
+ * @param parentInjector Optional injector instance to use as a parent for the module injector. If
+ *     not provided, `NullInjector` will be used instead.
+ * @publicApi
+ */
+export const createNgModuleRef = createNgModuleRef__POST_R3__;
+export class NgModuleRef extends viewEngine_NgModuleRef {
+    constructor(ngModuleType, _parent) {
+        super();
+        this._parent = _parent;
+        // tslint:disable-next-line:require-internal-with-underscore
+        this._bootstrapComponents = [];
+        this.injector = this;
+        this.destroyCbs = [];
+        // When bootstrapping a module we have a dependency graph that looks like this:
+        // ApplicationRef -> ComponentFactoryResolver -> NgModuleRef. The problem is that if the
+        // module being resolved tries to inject the ComponentFactoryResolver, it'll create a
+        // circular dependency which will result in a runtime error, because the injector doesn't
+        // exist yet. We work around the issue by creating the ComponentFactoryResolver ourselves
+        // and providing it, rather than letting the injector resolve it.
+        this.componentFactoryResolver = new ComponentFactoryResolver(this);
+        const ngModuleDef = getNgModuleDef(ngModuleType);
+        ngDevMode &&
+            assertDefined(ngModuleDef, `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`);
+        const ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);
+        ngLocaleIdDef && setLocaleId(ngLocaleIdDef);
+        this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
+        this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [
+            { provide: viewEngine_NgModuleRef, useValue: this }, {
+                provide: viewEngine_ComponentFactoryResolver,
+                useValue: this.componentFactoryResolver
+            }
+        ], stringify(ngModuleType));
+        // We need to resolve the injector types separately from the injector creation, because
+        // the module might be trying to use this ref in its contructor for DI which will cause a
+        // circular error that will eventually error out, because the injector isn't created yet.
+        this._r3Injector._resolveInjectorDefTypes();
+        this.instance = this.get(ngModuleType);
+    }
+    get(token, notFoundValue = Injector.THROW_IF_NOT_FOUND, injectFlags = InjectFlags.Default) {
+        if (token === Injector || token === viewEngine_NgModuleRef || token === INJECTOR) {
+            return this;
+        }
+        return this._r3Injector.get(token, notFoundValue, injectFlags);
+    }
+    destroy() {
+        ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
+        const injector = this._r3Injector;
+        !injector.destroyed && injector.destroy();
+        this.destroyCbs.forEach(fn => fn());
+        this.destroyCbs = null;
+    }
+    onDestroy(callback) {
+        ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');
+        this.destroyCbs.push(callback);
+    }
+}
+export class NgModuleFactory extends viewEngine_NgModuleFactory {
+    constructor(moduleType) {
+        super();
+        this.moduleType = moduleType;
+        const ngModuleDef = getNgModuleDef(moduleType);
+        if (ngModuleDef !== null) {
+            // Register the NgModule with Angular's module registry. The location (and hence timing) of
+            // this call is critical to ensure this works correctly (modules get registered when expected)
+            // without bloating bundles (modules are registered when otherwise not referenced).
+            //
+            // In View Engine, registration occurs in the .ngfactory.js file as a side effect. This has
+            // several practical consequences:
+            //
+            // - If an .ngfactory file is not imported from, the module won't be registered (and can be
+            //   tree shaken).
+            // - If an .ngfactory file is imported from, the module will be registered even if an instance
+            //   is not actually created (via `create` below).
+            // - Since an .ngfactory file in View Engine references the .ngfactory files of the NgModule's
+            //   imports,
+            //
+            // In Ivy, things are a bit different. .ngfactory files still exist for compatibility, but are
+            // not a required API to use - there are other ways to obtain an NgModuleFactory for a given
+            // NgModule. Thus, relying on a side effect in the .ngfactory file is not sufficient. Instead,
+            // the side effect of registration is added here, in the constructor of NgModuleFactory,
+            // ensuring no matter how a factory is created, the module is registered correctly.
+            //
+            // An alternative would be to include the registration side effect inline following the actual
+            // NgModule definition. This also has the correct timing, but breaks tree-shaking - modules
+            // will be registered and retained even if they're otherwise never referenced.
+            registerNgModuleType(moduleType);
+        }
+    }
+    create(parentInjector) {
+        return new NgModuleRef(this.moduleType, parentInjector);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_module_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/ng_module_ref.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector} from '../di/injector';\nimport {INJECTOR} from '../di/injector_token';\nimport {InjectFlags} from '../di/interface/injector';\nimport {createInjectorWithoutInjectorInstances, R3Injector} from '../di/r3_injector';\nimport {Type} from '../interface/type';\nimport {ComponentFactoryResolver as viewEngine_ComponentFactoryResolver} from '../linker/component_factory_resolver';\nimport {InternalNgModuleRef, NgModuleFactory as viewEngine_NgModuleFactory, NgModuleRef as viewEngine_NgModuleRef} from '../linker/ng_module_factory';\nimport {registerNgModuleType} from '../linker/ng_module_factory_registration';\nimport {NgModuleType} from '../metadata/ng_module_def';\nimport {assertDefined} from '../util/assert';\nimport {stringify} from '../util/stringify';\n\nimport {ComponentFactoryResolver} from './component_ref';\nimport {getNgLocaleIdDef, getNgModuleDef} from './definition';\nimport {setLocaleId} from './i18n/i18n_locale_id';\nimport {maybeUnwrapFn} from './util/misc_utils';\n\n\nexport function createNgModuleRef__PRE_R3__<T>(\n    ngModule: Type<T>, parentInjector?: Injector): NgModuleRef<T> {\n  throw new Error(`This API is Ivy-only and is not supported in ViewEngine`);\n}\n\nexport function createNgModuleRef__POST_R3__<T>(\n    ngModule: Type<T>, parentInjector?: Injector): NgModuleRef<T> {\n  return new NgModuleRef<T>(ngModule, parentInjector ?? null);\n}\n\n/**\n * Returns a new NgModuleRef instance based on the NgModule class and parent injector provided.\n * @param ngModule NgModule class.\n * @param parentInjector Optional injector instance to use as a parent for the module injector. If\n *     not provided, `NullInjector` will be used instead.\n * @publicApi\n */\nexport const createNgModuleRef: <T>(ngModule: Type<T>, parentInjector?: Injector) =>\n    viewEngine_NgModuleRef<T> = createNgModuleRef__PRE_R3__;\n\nexport class NgModuleRef<T> extends viewEngine_NgModuleRef<T> implements InternalNgModuleRef<T> {\n  // tslint:disable-next-line:require-internal-with-underscore\n  _bootstrapComponents: Type<any>[] = [];\n  // tslint:disable-next-line:require-internal-with-underscore\n  _r3Injector: R3Injector;\n  override injector: Injector = this;\n  override instance: T;\n  destroyCbs: (() => void)[]|null = [];\n\n  // When bootstrapping a module we have a dependency graph that looks like this:\n  // ApplicationRef -> ComponentFactoryResolver -> NgModuleRef. The problem is that if the\n  // module being resolved tries to inject the ComponentFactoryResolver, it'll create a\n  // circular dependency which will result in a runtime error, because the injector doesn't\n  // exist yet. We work around the issue by creating the ComponentFactoryResolver ourselves\n  // and providing it, rather than letting the injector resolve it.\n  override readonly componentFactoryResolver: ComponentFactoryResolver =\n      new ComponentFactoryResolver(this);\n\n  constructor(ngModuleType: Type<T>, public _parent: Injector|null) {\n    super();\n    const ngModuleDef = getNgModuleDef(ngModuleType);\n    ngDevMode &&\n        assertDefined(\n            ngModuleDef,\n            `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`);\n\n    const ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);\n    ngLocaleIdDef && setLocaleId(ngLocaleIdDef);\n    this._bootstrapComponents = maybeUnwrapFn(ngModuleDef!.bootstrap);\n    this._r3Injector = createInjectorWithoutInjectorInstances(\n                           ngModuleType, _parent,\n                           [\n                             {provide: viewEngine_NgModuleRef, useValue: this}, {\n                               provide: viewEngine_ComponentFactoryResolver,\n                               useValue: this.componentFactoryResolver\n                             }\n                           ],\n                           stringify(ngModuleType)) as R3Injector;\n\n    // We need to resolve the injector types separately from the injector creation, because\n    // the module might be trying to use this ref in its contructor for DI which will cause a\n    // circular error that will eventually error out, because the injector isn't created yet.\n    this._r3Injector._resolveInjectorDefTypes();\n    this.instance = this.get(ngModuleType);\n  }\n\n  get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,\n      injectFlags: InjectFlags = InjectFlags.Default): any {\n    if (token === Injector || token === viewEngine_NgModuleRef || token === INJECTOR) {\n      return this;\n    }\n    return this._r3Injector.get(token, notFoundValue, injectFlags);\n  }\n\n  override destroy(): void {\n    ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');\n    const injector = this._r3Injector;\n    !injector.destroyed && injector.destroy();\n    this.destroyCbs!.forEach(fn => fn());\n    this.destroyCbs = null;\n  }\n  override onDestroy(callback: () => void): void {\n    ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');\n    this.destroyCbs!.push(callback);\n  }\n}\n\nexport class NgModuleFactory<T> extends viewEngine_NgModuleFactory<T> {\n  constructor(public moduleType: Type<T>) {\n    super();\n\n    const ngModuleDef = getNgModuleDef(moduleType);\n    if (ngModuleDef !== null) {\n      // Register the NgModule with Angular's module registry. The location (and hence timing) of\n      // this call is critical to ensure this works correctly (modules get registered when expected)\n      // without bloating bundles (modules are registered when otherwise not referenced).\n      //\n      // In View Engine, registration occurs in the .ngfactory.js file as a side effect. This has\n      // several practical consequences:\n      //\n      // - If an .ngfactory file is not imported from, the module won't be registered (and can be\n      //   tree shaken).\n      // - If an .ngfactory file is imported from, the module will be registered even if an instance\n      //   is not actually created (via `create` below).\n      // - Since an .ngfactory file in View Engine references the .ngfactory files of the NgModule's\n      //   imports,\n      //\n      // In Ivy, things are a bit different. .ngfactory files still exist for compatibility, but are\n      // not a required API to use - there are other ways to obtain an NgModuleFactory for a given\n      // NgModule. Thus, relying on a side effect in the .ngfactory file is not sufficient. Instead,\n      // the side effect of registration is added here, in the constructor of NgModuleFactory,\n      // ensuring no matter how a factory is created, the module is registered correctly.\n      //\n      // An alternative would be to include the registration side effect inline following the actual\n      // NgModule definition. This also has the correct timing, but breaks tree-shaking - modules\n      // will be registered and retained even if they're otherwise never referenced.\n      registerNgModuleType(moduleType as NgModuleType);\n    }\n  }\n\n  override create(parentInjector: Injector|null): viewEngine_NgModuleRef<T> {\n    return new NgModuleRef(this.moduleType, parentInjector);\n  }\n}\n"]}