@angular/core 7.2.0-beta.0 → 7.2.0

package/esm2015/src/render3/jit/module.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,14 +9,78 @@
  * 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 { resolveForwardRef } from '../../di/forward_ref';
+import { registerNgModuleType } from '../../linker/ng_module_factory_loader';
 import { assertDefined } from '../assert';
 import { getComponentDef, getDirectiveDef, getNgModuleDef, getPipeDef } from '../definition';
 import { NG_COMPONENT_DEF, NG_DIRECTIVE_DEF, NG_INJECTOR_DEF, NG_MODULE_DEF, NG_PIPE_DEF } from '../fields';
+import { stringify } from '../util';
 import { getCompilerFacade } from './compiler_facade';
 import { angularCoreEnv } from './environment';
 import { reflectDependencies } from './util';
 /** @type {?} */
 const EMPTY_ARRAY = [];
+/**
+ * @record
+ */
+function ModuleQueueItem() { }
+if (false) {
+    /** @type {?} */
+    ModuleQueueItem.prototype.moduleType;
+    /** @type {?} */
+    ModuleQueueItem.prototype.ngModule;
+}
+/** @type {?} */
+const moduleQueue = [];
+/**
+ * Enqueues moduleDef to be checked later to see if scope can be set on its
+ * component declarations.
+ * @param {?} moduleType
+ * @param {?} ngModule
+ * @return {?}
+ */
+function enqueueModuleForDelayedScoping(moduleType, ngModule) {
+    moduleQueue.push({ moduleType, ngModule });
+}
+/** @type {?} */
+let flushingModuleQueue = false;
+/**
+ * Loops over queued module definitions, if a given module definition has all of its
+ * declarations resolved, it dequeues that module definition and sets the scope on
+ * its declarations.
+ * @return {?}
+ */
+export function flushModuleScopingQueueAsMuchAsPossible() {
+    if (!flushingModuleQueue) {
+        flushingModuleQueue = true;
+        try {
+            for (let i = moduleQueue.length - 1; i >= 0; i--) {
+                const { moduleType, ngModule } = moduleQueue[i];
+                if (ngModule.declarations && ngModule.declarations.every(isResolvedDeclaration)) {
+                    // dequeue
+                    moduleQueue.splice(i, 1);
+                    setScopeOnDeclaredComponents(moduleType, ngModule);
+                }
+            }
+        }
+        finally {
+            flushingModuleQueue = false;
+        }
+    }
+}
+/**
+ * Returns truthy if a declaration has resolved. If the declaration happens to be
+ * an array of declarations, it will recurse to check each declaration in that array
+ * (which may also be arrays).
+ * @param {?} declaration
+ * @return {?}
+ */
+function isResolvedDeclaration(declaration) {
+    if (Array.isArray(declaration)) {
+        return declaration.every(isResolvedDeclaration);
+    }
+    return !!resolveForwardRef(declaration);
+}
 /**
  * Compiles a module in JIT mode.
  *
@@ -26,8 +90,12 @@ const EMPTY_ARRAY = [];
  * @return {?}
  */
 export function compileNgModule(moduleType, ngModule = {}) {
-    compileNgModuleDefs(moduleType, ngModule);
-    setScopeOnDeclaredComponents(moduleType, ngModule);
+    compileNgModuleDefs((/** @type {?} */ (moduleType)), ngModule);
+    // Because we don't know if all declarations have resolved yet at the moment the
+    // NgModule decorator is executing, we're enqueueing the setting of module scope
+    // on its declarations to be run at a later time when all declarations for the module,
+    // including forward refs, have resolved.
+    enqueueModuleForDelayedScoping(moduleType, ngModule);
 }
 /**
  * Compiles and adds the `ngModuleDef` and `ngInjectorDef` properties to the module class.
@@ -48,21 +116,27 @@ export function compileNgModuleDefs(moduleType, ngModule) {
             if (ngModuleDef === null) {
                 ngModuleDef = getCompilerFacade().compileNgModule(angularCoreEnv, `ng://${moduleType.name}/ngModuleDef.js`, {
                     type: moduleType,
-                    bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY),
-                    declarations: declarations,
-                    imports: flatten(ngModule.imports || EMPTY_ARRAY).map(expandModuleWithProviders),
-                    exports: flatten(ngModule.exports || EMPTY_ARRAY).map(expandModuleWithProviders),
+                    bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY, resolveForwardRef),
+                    declarations: declarations.map(resolveForwardRef),
+                    imports: flatten(ngModule.imports || EMPTY_ARRAY, resolveForwardRef)
+                        .map(expandModuleWithProviders),
+                    exports: flatten(ngModule.exports || EMPTY_ARRAY, resolveForwardRef)
+                        .map(expandModuleWithProviders),
                     emitInline: true,
                 });
             }
             return ngModuleDef;
         }
     });
+    if (ngModule.id) {
+        registerNgModuleType(ngModule.id, moduleType);
+    }
     /** @type {?} */
     /** @nocollapse */ let ngInjectorDef = null;
     Object.defineProperty(moduleType, NG_INJECTOR_DEF, {
         get: () => {
             if (ngInjectorDef === null) {
+                ngDevMode && verifySemanticsOfNgModuleDef((/** @type {?} */ ((/** @type {?} */ (moduleType)))));
                 /** @type {?} */
                 const meta = {
                     name: moduleType.name,
@@ -70,8 +144,8 @@ export function compileNgModuleDefs(moduleType, ngModule) {
                     deps: reflectDependencies(moduleType),
                     providers: ngModule.providers || EMPTY_ARRAY,
                     imports: [
-                        ngModule.imports || EMPTY_ARRAY,
-                        ngModule.exports || EMPTY_ARRAY,
+                        (ngModule.imports || EMPTY_ARRAY).map(resolveForwardRef),
+                        (ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef),
                     ],
                 };
                 ngInjectorDef = getCompilerFacade().compileInjector(angularCoreEnv, `ng://${moduleType.name}/ngInjectorDef.js`, meta);
@@ -82,6 +156,211 @@ export function compileNgModuleDefs(moduleType, ngModule) {
         configurable: !!ngDevMode,
     });
 }
+/**
+ * @param {?} moduleType
+ * @return {?}
+ */
+function verifySemanticsOfNgModuleDef(moduleType) {
+    if (verifiedNgModule.get(moduleType))
+        return;
+    verifiedNgModule.set(moduleType, true);
+    moduleType = resolveForwardRef(moduleType);
+    /** @type {?} */
+    /** @nocollapse */ const ngModuleDef = getNgModuleDef(moduleType, true);
+    /** @type {?} */
+    const errors = [];
+    ngModuleDef.declarations.forEach(verifyDeclarationsHaveDefinitions);
+    /** @type {?} */
+    const combinedDeclarations = [
+        ...ngModuleDef.declarations.map(resolveForwardRef),
+        ...flatten(ngModuleDef.imports.map(computeCombinedExports), resolveForwardRef),
+    ];
+    ngModuleDef.exports.forEach(verifyExportsAreDeclaredOrReExported);
+    ngModuleDef.declarations.forEach(verifyDeclarationIsUnique);
+    ngModuleDef.declarations.forEach(verifyComponentEntryComponentsIsPartOfNgModule);
+    /** @type {?} */
+    const ngModule = getAnnotation(moduleType, 'NgModule');
+    if (ngModule) {
+        ngModule.imports &&
+            flatten(ngModule.imports, unwrapModuleWithProvidersImports)
+                .forEach(verifySemanticsOfNgModuleDef);
+        ngModule.bootstrap && ngModule.bootstrap.forEach(verifyComponentIsPartOfNgModule);
+        ngModule.entryComponents && ngModule.entryComponents.forEach(verifyComponentIsPartOfNgModule);
+    }
+    // Throw Error if any errors were detected.
+    if (errors.length) {
+        throw new Error(errors.join('\n'));
+    }
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    /**
+     * @param {?} type
+     * @return {?}
+     */
+    function verifyDeclarationsHaveDefinitions(type) {
+        type = resolveForwardRef(type);
+        /** @type {?} */
+        const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);
+        if (!def) {
+            errors.push(`Unexpected value '${stringify(type)}' declared by the module '${stringify(moduleType)}'. Please add a @Pipe/@Directive/@Component annotation.`);
+        }
+    }
+    /**
+     * @param {?} type
+     * @return {?}
+     */
+    function verifyExportsAreDeclaredOrReExported(type) {
+        type = resolveForwardRef(type);
+        /** @type {?} */
+        const kind = getComponentDef(type) && 'component' || getDirectiveDef(type) && 'directive' ||
+            getPipeDef(type) && 'pipe';
+        if (kind) {
+            // only checked if we are declared as Component, Directive, or Pipe
+            // Modules don't need to be declared or imported.
+            if (combinedDeclarations.lastIndexOf(type) === -1) {
+                // We are exporting something which we don't explicitly declare or import.
+                errors.push(`Can't export ${kind} ${stringify(type)} from ${stringify(moduleType)} as it was neither declared nor imported!`);
+            }
+        }
+    }
+    /**
+     * @param {?} type
+     * @return {?}
+     */
+    function verifyDeclarationIsUnique(type) {
+        type = resolveForwardRef(type);
+        /** @type {?} */
+        const existingModule = ownerNgModule.get(type);
+        if (existingModule && existingModule !== moduleType) {
+            /** @type {?} */
+            const modules = [existingModule, moduleType].map(stringify).sort();
+            errors.push(`Type ${stringify(type)} is part of the declarations of 2 modules: ${modules[0]} and ${modules[1]}! ` +
+                `Please consider moving ${stringify(type)} to a higher module that imports ${modules[0]} and ${modules[1]}. ` +
+                `You can also create a new NgModule that exports and includes ${stringify(type)} then import that NgModule in ${modules[0]} and ${modules[1]}.`);
+        }
+        else {
+            // Mark type as having owner.
+            ownerNgModule.set(type, moduleType);
+        }
+    }
+    /**
+     * @param {?} type
+     * @return {?}
+     */
+    function verifyComponentIsPartOfNgModule(type) {
+        type = resolveForwardRef(type);
+        /** @type {?} */
+        const existingModule = ownerNgModule.get(type);
+        if (!existingModule) {
+            errors.push(`Component ${stringify(type)} is not part of any NgModule or the module has not been imported into your module.`);
+        }
+    }
+    /**
+     * @param {?} type
+     * @return {?}
+     */
+    function verifyComponentEntryComponentsIsPartOfNgModule(type) {
+        type = resolveForwardRef(type);
+        if (getComponentDef(type)) {
+            // We know we are component
+            /** @type {?} */
+            const component = getAnnotation(type, 'Component');
+            if (component && component.entryComponents) {
+                component.entryComponents.forEach(verifyComponentIsPartOfNgModule);
+            }
+        }
+    }
+}
+/**
+ * @param {?} typeOrWithProviders
+ * @return {?}
+ */
+function unwrapModuleWithProvidersImports(typeOrWithProviders) {
+    typeOrWithProviders = resolveForwardRef(typeOrWithProviders);
+    return ((/** @type {?} */ (typeOrWithProviders))).ngModule || typeOrWithProviders;
+}
+/**
+ * @template T
+ * @param {?} type
+ * @param {?} name
+ * @return {?}
+ */
+function getAnnotation(type, name) {
+    /** @type {?} */
+    let annotation = null;
+    collect(type.__annotations__);
+    collect(type.decorators);
+    return annotation;
+    /**
+     * @param {?} annotations
+     * @return {?}
+     */
+    function collect(annotations) {
+        if (annotations) {
+            annotations.forEach(readAnnotation);
+        }
+    }
+    /**
+     * @param {?} decorator
+     * @return {?}
+     */
+    function readAnnotation(decorator) {
+        if (!annotation) {
+            /** @type {?} */
+            const proto = Object.getPrototypeOf(decorator);
+            if (proto.ngMetadataName == name) {
+                annotation = (/** @type {?} */ (decorator));
+            }
+            else if (decorator.type) {
+                /** @type {?} */
+                const proto = Object.getPrototypeOf(decorator.type);
+                if (proto.ngMetadataName == name) {
+                    annotation = decorator.args[0];
+                }
+            }
+        }
+    }
+}
+/**
+ * Keep track of compiled components. This is needed because in tests we often want to compile the
+ * same component with more than one NgModule. This would cause an error unless we reset which
+ * NgModule the component belongs to. We keep the list of compiled components here so that the
+ * TestBed can reset it later.
+ * @type {?}
+ */
+let ownerNgModule = new Map();
+/** @type {?} */
+let verifiedNgModule = new Map();
+/**
+ * @return {?}
+ */
+export function resetCompiledComponents() {
+    ownerNgModule = new Map();
+    verifiedNgModule = new Map();
+    moduleQueue.length = 0;
+}
+/**
+ * Computes the combined declarations of explicit declarations, as well as declarations inherited
+ * by
+ * traversing the exports of imported modules.
+ * @param {?} type
+ * @return {?}
+ */
+function computeCombinedExports(type) {
+    type = resolveForwardRef(type);
+    /** @type {?} */
+    /** @nocollapse */ const ngModuleDef = getNgModuleDef(type, true);
+    return [...flatten(ngModuleDef.exports.map((type) => {
+            /** @type {?} */
+            /** @nocollapse */ const ngModuleDef = getNgModuleDef(type);
+            if (ngModuleDef) {
+                verifySemanticsOfNgModuleDef((/** @type {?} */ ((/** @type {?} */ (type)))));
+                return computeCombinedExports(type);
+            }
+            else {
+                return type;
+            }
+        }))];
+}
 /**
  * Some declared components may be compiled asynchronously, and thus may not have their
  * ngComponentDef set yet. If this is the case, then a reference to the module is written into
@@ -97,15 +376,16 @@ function setScopeOnDeclaredComponents(moduleType, ngModule) {
     const transitiveScopes = transitiveScopesFor(moduleType);
     declarations.forEach(declaration => {
         if (declaration.hasOwnProperty(NG_COMPONENT_DEF)) {
+            // An `ngComponentDef` field exists - go ahead and patch the component directly.
             /** @type {?} */
-            const component = /** @type {?} */ (declaration);
+            const component = (/** @type {?} */ (declaration));
             /** @type {?} */
-            const componentDef = /** @type {?} */ ((getComponentDef(component)));
+            const componentDef = (/** @type {?} */ (getComponentDef(component)));
             patchComponentDefWithScope(componentDef, transitiveScopes);
         }
         else if (!declaration.hasOwnProperty(NG_DIRECTIVE_DEF) && !declaration.hasOwnProperty(NG_PIPE_DEF)) {
             // Set `ngSelectorScope` for future reference when the component compilation finishes.
-            (/** @type {?} */ (declaration)).ngSelectorScope = moduleType;
+            ((/** @type {?} */ (declaration))).ngSelectorScope = moduleType;
         }
     });
 }
@@ -119,9 +399,9 @@ function setScopeOnDeclaredComponents(moduleType, ngModule) {
  */
 export function patchComponentDefWithScope(componentDef, transitiveScopes) {
     componentDef.directiveDefs = () => Array.from(transitiveScopes.compilation.directives)
-        .map(dir => getDirectiveDef(dir) || /** @type {?} */ ((getComponentDef(dir))))
+        .map(dir => getDirectiveDef(dir) || (/** @type {?} */ (getComponentDef(dir))))
         .filter(def => !!def);
-    componentDef.pipeDefs = () => Array.from(transitiveScopes.compilation.pipes).map(pipe => /** @type {?} */ ((getPipeDef(pipe))));
+    componentDef.pipeDefs = () => Array.from(transitiveScopes.compilation.pipes).map(pipe => (/** @type {?} */ (getPipeDef(pipe))));
 }
 /**
  * Compute the pair of transitive scopes (compilation scope and exported scope) for a given module.
@@ -138,7 +418,7 @@ export function transitiveScopesFor(moduleType) {
         throw new Error(`${moduleType.name} does not have an ngModuleDef`);
     }
     /** @type {?} */
-    const def = /** @type {?} */ ((getNgModuleDef(moduleType)));
+    const def = (/** @type {?} */ (getNgModuleDef(moduleType)));
     if (def.transitiveCompileScopes !== null) {
         return def.transitiveCompileScopes;
     }
@@ -155,7 +435,7 @@ export function transitiveScopesFor(moduleType) {
     };
     def.declarations.forEach(declared => {
         /** @type {?} */
-        const declaredWithDefs = /** @type {?} */ (declared);
+        const declaredWithDefs = (/** @type {?} */ (declared));
         if (getPipeDef(declaredWithDefs)) {
             scopes.compilation.pipes.add(declared);
         }
@@ -168,10 +448,12 @@ export function transitiveScopesFor(moduleType) {
     });
     def.imports.forEach((imported) => {
         /** @type {?} */
-        const importedTyped = /** @type {?} */ (imported);
+        const importedTyped = (/** @type {?} */ (imported));
         if (!isNgModule(importedTyped)) {
             throw new Error(`Importing ${importedTyped.name} which does not have an ngModuleDef`);
         }
+        // When this module imports another, the imported module's exported directives and pipes are
+        // added to the compilation scope of this module.
         /** @type {?} */
         const importedScope = transitiveScopesFor(importedTyped);
         importedScope.exported.directives.forEach(entry => scopes.compilation.directives.add(entry));
@@ -179,10 +461,12 @@ export function transitiveScopesFor(moduleType) {
     });
     def.exports.forEach((exported) => {
         /** @type {?} */
-        const exportedTyped = /** @type {?} */ (exported);
+        const exportedTyped = (/** @type {?} */ (exported));
         // Either the type is a module, a pipe, or a component/directive (which may not have an
         // ngComponentDef as it might be compiled asynchronously).
         if (isNgModule(exportedTyped)) {
+            // When this module exports another, the exported module's exported directives and pipes are
+            // added to both the compilation and exported scopes of this module.
             /** @type {?} */
             const exportedScope = transitiveScopesFor(exportedTyped);
             exportedScope.exported.directives.forEach(entry => {
@@ -194,7 +478,7 @@ export function transitiveScopesFor(moduleType) {
                 scopes.exported.pipes.add(entry);
             });
         }
-        else if (getNgModuleDef(exportedTyped)) {
+        else if (getPipeDef(exportedTyped)) {
             scopes.exported.pipes.add(exportedTyped);
         }
         else {
@@ -207,17 +491,18 @@ export function transitiveScopesFor(moduleType) {
 /**
  * @template T
  * @param {?} values
+ * @param {?=} mapFn
  * @return {?}
  */
-function flatten(values) {
+function flatten(values, mapFn) {
     /** @type {?} */
     const out = [];
     values.forEach(value => {
         if (Array.isArray(value)) {
-            out.push(...flatten(value));
+            out.push(...flatten(value, mapFn));
         }
         else {
-            out.push(value);
+            out.push(mapFn ? mapFn(value) : value);
         }
     });
     return out;
@@ -237,7 +522,7 @@ function expandModuleWithProviders(value) {
  * @return {?}
  */
 function isModuleWithProviders(value) {
-    return (/** @type {?} */ (value)).ngModule !== undefined;
+    return ((/** @type {?} */ (value))).ngModule !== undefined;
 }
 /**
  * @template T
@@ -247,5 +532,4 @@ function isModuleWithProviders(value) {
 function isNgModule(value) {
     return !!getNgModuleDef(value);
 }
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/jit/module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {ModuleWithProviders, NgModule, NgModuleDef, NgModuleTransitiveScopes} from '../../metadata/ng_module';\nimport {Type} from '../../type';\nimport {assertDefined} from '../assert';\nimport {getComponentDef, getDirectiveDef, getNgModuleDef, getPipeDef} from '../definition';\nimport {NG_COMPONENT_DEF, NG_DIRECTIVE_DEF, NG_INJECTOR_DEF, NG_MODULE_DEF, NG_PIPE_DEF} from '../fields';\nimport {ComponentDef} from '../interfaces/definition';\n\nimport {R3InjectorMetadataFacade, getCompilerFacade} from './compiler_facade';\nimport {angularCoreEnv} from './environment';\nimport {reflectDependencies} from './util';\n\nconst EMPTY_ARRAY: Type<any>[] = [];\n\n/**\n * Compiles a module in JIT mode.\n *\n * This function automatically gets called when a class has a `@NgModule` decorator.\n */\nexport function compileNgModule(moduleType: Type<any>, ngModule: NgModule = {}): void {\n  compileNgModuleDefs(moduleType, ngModule);\n  setScopeOnDeclaredComponents(moduleType, ngModule);\n}\n\n/**\n * Compiles and adds the `ngModuleDef` and `ngInjectorDef` properties to the module class.\n */\nexport function compileNgModuleDefs(moduleType: Type<any>, ngModule: NgModule): void {\n  ngDevMode && assertDefined(moduleType, 'Required value moduleType');\n  ngDevMode && assertDefined(ngModule, 'Required value ngModule');\n  const declarations: Type<any>[] = flatten(ngModule.declarations || EMPTY_ARRAY);\n\n  let ngModuleDef: any = null;\n  Object.defineProperty(moduleType, NG_MODULE_DEF, {\n    configurable: true,\n    get: () => {\n      if (ngModuleDef === null) {\n        ngModuleDef = getCompilerFacade().compileNgModule(\n            angularCoreEnv, `ng://${moduleType.name}/ngModuleDef.js`, {\n              type: moduleType,\n              bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY),\n              declarations: declarations,\n              imports: flatten(ngModule.imports || EMPTY_ARRAY).map(expandModuleWithProviders),\n              exports: flatten(ngModule.exports || EMPTY_ARRAY).map(expandModuleWithProviders),\n              emitInline: true,\n            });\n      }\n      return ngModuleDef;\n    }\n  });\n\n  let ngInjectorDef: any = null;\n  Object.defineProperty(moduleType, NG_INJECTOR_DEF, {\n    get: () => {\n      if (ngInjectorDef === null) {\n        const meta: R3InjectorMetadataFacade = {\n          name: moduleType.name,\n          type: moduleType,\n          deps: reflectDependencies(moduleType),\n          providers: ngModule.providers || EMPTY_ARRAY,\n          imports: [\n            ngModule.imports || EMPTY_ARRAY,\n            ngModule.exports || EMPTY_ARRAY,\n          ],\n        };\n        ngInjectorDef = getCompilerFacade().compileInjector(\n            angularCoreEnv, `ng://${moduleType.name}/ngInjectorDef.js`, meta);\n      }\n      return ngInjectorDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\n/**\n * Some declared components may be compiled asynchronously, and thus may not have their\n * ngComponentDef set yet. If this is the case, then a reference to the module is written into\n * the `ngSelectorScope` property of the declared type.\n */\nfunction setScopeOnDeclaredComponents(moduleType: Type<any>, ngModule: NgModule) {\n  const declarations: Type<any>[] = flatten(ngModule.declarations || EMPTY_ARRAY);\n\n  const transitiveScopes = transitiveScopesFor(moduleType);\n\n  declarations.forEach(declaration => {\n    if (declaration.hasOwnProperty(NG_COMPONENT_DEF)) {\n      // An `ngComponentDef` field exists - go ahead and patch the component directly.\n      const component = declaration as Type<any>& {ngComponentDef: ComponentDef<any>};\n      const componentDef = getComponentDef(component) !;\n      patchComponentDefWithScope(componentDef, transitiveScopes);\n    } else if (\n        !declaration.hasOwnProperty(NG_DIRECTIVE_DEF) && !declaration.hasOwnProperty(NG_PIPE_DEF)) {\n      // Set `ngSelectorScope` for future reference when the component compilation finishes.\n      (declaration as Type<any>& {ngSelectorScope?: any}).ngSelectorScope = moduleType;\n    }\n  });\n}\n\n/**\n * Patch the definition of a component with directives and pipes from the compilation scope of\n * a given module.\n */\nexport function patchComponentDefWithScope<C>(\n    componentDef: ComponentDef<C>, transitiveScopes: NgModuleTransitiveScopes) {\n  componentDef.directiveDefs = () => Array.from(transitiveScopes.compilation.directives)\n                                         .map(dir => getDirectiveDef(dir) || getComponentDef(dir) !)\n                                         .filter(def => !!def);\n  componentDef.pipeDefs = () =>\n      Array.from(transitiveScopes.compilation.pipes).map(pipe => getPipeDef(pipe) !);\n}\n\n/**\n * Compute the pair of transitive scopes (compilation scope and exported scope) for a given module.\n *\n * This operation is memoized and the result is cached on the module's definition. It can be called\n * on modules with components that have not fully compiled yet, but the result should not be used\n * until they have.\n */\nexport function transitiveScopesFor<T>(moduleType: Type<T>): NgModuleTransitiveScopes {\n  if (!isNgModule(moduleType)) {\n    throw new Error(`${moduleType.name} does not have an ngModuleDef`);\n  }\n  const def = getNgModuleDef(moduleType) !;\n\n  if (def.transitiveCompileScopes !== null) {\n    return def.transitiveCompileScopes;\n  }\n\n  const scopes: NgModuleTransitiveScopes = {\n    compilation: {\n      directives: new Set<any>(),\n      pipes: new Set<any>(),\n    },\n    exported: {\n      directives: new Set<any>(),\n      pipes: new Set<any>(),\n    },\n  };\n\n  def.declarations.forEach(declared => {\n    const declaredWithDefs = declared as Type<any>& { ngPipeDef?: any; };\n\n    if (getPipeDef(declaredWithDefs)) {\n      scopes.compilation.pipes.add(declared);\n    } else {\n      // Either declared has an ngComponentDef or ngDirectiveDef, or it's a component which hasn't\n      // had its template compiled yet. In either case, it gets added to the compilation's\n      // directives.\n      scopes.compilation.directives.add(declared);\n    }\n  });\n\n  def.imports.forEach(<I>(imported: Type<I>) => {\n    const importedTyped = imported as Type<I>& {\n      // If imported is an @NgModule:\n      ngModuleDef?: NgModuleDef<I>;\n    };\n\n    if (!isNgModule<I>(importedTyped)) {\n      throw new Error(`Importing ${importedTyped.name} which does not have an ngModuleDef`);\n    }\n\n    // When this module imports another, the imported module's exported directives and pipes are\n    // added to the compilation scope of this module.\n    const importedScope = transitiveScopesFor(importedTyped);\n    importedScope.exported.directives.forEach(entry => scopes.compilation.directives.add(entry));\n    importedScope.exported.pipes.forEach(entry => scopes.compilation.pipes.add(entry));\n  });\n\n  def.exports.forEach(<E>(exported: Type<E>) => {\n    const exportedTyped = exported as Type<E>& {\n      // Components, Directives, NgModules, and Pipes can all be exported.\n      ngComponentDef?: any;\n      ngDirectiveDef?: any;\n      ngModuleDef?: NgModuleDef<E>;\n      ngPipeDef?: any;\n    };\n\n    // Either the type is a module, a pipe, or a component/directive (which may not have an\n    // ngComponentDef as it might be compiled asynchronously).\n    if (isNgModule(exportedTyped)) {\n      // When this module exports another, the exported module's exported directives and pipes are\n      // added to both the compilation and exported scopes of this module.\n      const exportedScope = transitiveScopesFor(exportedTyped);\n      exportedScope.exported.directives.forEach(entry => {\n        scopes.compilation.directives.add(entry);\n        scopes.exported.directives.add(entry);\n      });\n      exportedScope.exported.pipes.forEach(entry => {\n        scopes.compilation.pipes.add(entry);\n        scopes.exported.pipes.add(entry);\n      });\n    } else if (getNgModuleDef(exportedTyped)) {\n      scopes.exported.pipes.add(exportedTyped);\n    } else {\n      scopes.exported.directives.add(exportedTyped);\n    }\n  });\n\n  def.transitiveCompileScopes = scopes;\n  return scopes;\n}\n\nfunction flatten<T>(values: any[]): T[] {\n  const out: T[] = [];\n  values.forEach(value => {\n    if (Array.isArray(value)) {\n      out.push(...flatten<T>(value));\n    } else {\n      out.push(value);\n    }\n  });\n  return out;\n}\n\nfunction expandModuleWithProviders(value: Type<any>| ModuleWithProviders<{}>): Type<any> {\n  if (isModuleWithProviders(value)) {\n    return value.ngModule;\n  }\n  return value;\n}\n\nfunction isModuleWithProviders(value: any): value is ModuleWithProviders<{}> {\n  return (value as{ngModule?: any}).ngModule !== undefined;\n}\n\nfunction isNgModule<T>(value: Type<T>): value is Type<T>&{ngModuleDef: NgModuleDef<T>} {\n  return !!getNgModuleDef(value);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module.js","sourceRoot":"../../","sources":["packages/core/src/render3/jit/module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {resolveForwardRef} from '../../di/forward_ref';\nimport {registerNgModuleType} from '../../linker/ng_module_factory_loader';\nimport {Component} from '../../metadata';\nimport {ModuleWithProviders, NgModule, NgModuleDef, NgModuleTransitiveScopes} from '../../metadata/ng_module';\nimport {Type} from '../../type';\nimport {assertDefined} from '../assert';\nimport {getComponentDef, getDirectiveDef, getNgModuleDef, getPipeDef} from '../definition';\nimport {NG_COMPONENT_DEF, NG_DIRECTIVE_DEF, NG_INJECTOR_DEF, NG_MODULE_DEF, NG_PIPE_DEF} from '../fields';\nimport {ComponentDef} from '../interfaces/definition';\nimport {NgModuleType} from '../ng_module_ref';\nimport {stringify} from '../util';\n\nimport {R3InjectorMetadataFacade, getCompilerFacade} from './compiler_facade';\nimport {angularCoreEnv} from './environment';\nimport {reflectDependencies} from './util';\n\nconst EMPTY_ARRAY: Type<any>[] = [];\n\ninterface ModuleQueueItem {\n  moduleType: Type<any>;\n  ngModule: NgModule;\n}\n\nconst moduleQueue: ModuleQueueItem[] = [];\n\n/**\n * Enqueues moduleDef to be checked later to see if scope can be set on its\n * component declarations.\n */\nfunction enqueueModuleForDelayedScoping(moduleType: Type<any>, ngModule: NgModule) {\n  moduleQueue.push({moduleType, ngModule});\n}\n\nlet flushingModuleQueue = false;\n/**\n * Loops over queued module definitions, if a given module definition has all of its\n * declarations resolved, it dequeues that module definition and sets the scope on\n * its declarations.\n */\nexport function flushModuleScopingQueueAsMuchAsPossible() {\n  if (!flushingModuleQueue) {\n    flushingModuleQueue = true;\n    try {\n      for (let i = moduleQueue.length - 1; i >= 0; i--) {\n        const {moduleType, ngModule} = moduleQueue[i];\n\n        if (ngModule.declarations && ngModule.declarations.every(isResolvedDeclaration)) {\n          // dequeue\n          moduleQueue.splice(i, 1);\n          setScopeOnDeclaredComponents(moduleType, ngModule);\n        }\n      }\n    } finally {\n      flushingModuleQueue = false;\n    }\n  }\n}\n\n/**\n * Returns truthy if a declaration has resolved. If the declaration happens to be\n * an array of declarations, it will recurse to check each declaration in that array\n * (which may also be arrays).\n */\nfunction isResolvedDeclaration(declaration: any[] | Type<any>): boolean {\n  if (Array.isArray(declaration)) {\n    return declaration.every(isResolvedDeclaration);\n  }\n  return !!resolveForwardRef(declaration);\n}\n\n/**\n * Compiles a module in JIT mode.\n *\n * This function automatically gets called when a class has a `@NgModule` decorator.\n */\nexport function compileNgModule(moduleType: Type<any>, ngModule: NgModule = {}): void {\n  compileNgModuleDefs(moduleType as NgModuleType, ngModule);\n\n  // Because we don't know if all declarations have resolved yet at the moment the\n  // NgModule decorator is executing, we're enqueueing the setting of module scope\n  // on its declarations to be run at a later time when all declarations for the module,\n  // including forward refs, have resolved.\n  enqueueModuleForDelayedScoping(moduleType, ngModule);\n}\n\n/**\n * Compiles and adds the `ngModuleDef` and `ngInjectorDef` properties to the module class.\n */\nexport function compileNgModuleDefs(moduleType: NgModuleType, ngModule: NgModule): void {\n  ngDevMode && assertDefined(moduleType, 'Required value moduleType');\n  ngDevMode && assertDefined(ngModule, 'Required value ngModule');\n  const declarations: Type<any>[] = flatten(ngModule.declarations || EMPTY_ARRAY);\n\n  let ngModuleDef: any = null;\n  Object.defineProperty(moduleType, NG_MODULE_DEF, {\n    configurable: true,\n    get: () => {\n      if (ngModuleDef === null) {\n        ngModuleDef = getCompilerFacade().compileNgModule(\n            angularCoreEnv, `ng://${moduleType.name}/ngModuleDef.js`, {\n              type: moduleType,\n              bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY, resolveForwardRef),\n              declarations: declarations.map(resolveForwardRef),\n              imports: flatten(ngModule.imports || EMPTY_ARRAY, resolveForwardRef)\n                           .map(expandModuleWithProviders),\n              exports: flatten(ngModule.exports || EMPTY_ARRAY, resolveForwardRef)\n                           .map(expandModuleWithProviders),\n              emitInline: true,\n            });\n      }\n      return ngModuleDef;\n    }\n  });\n  if (ngModule.id) {\n    registerNgModuleType(ngModule.id, moduleType);\n  }\n\n  let ngInjectorDef: any = null;\n  Object.defineProperty(moduleType, NG_INJECTOR_DEF, {\n    get: () => {\n      if (ngInjectorDef === null) {\n        ngDevMode && verifySemanticsOfNgModuleDef(moduleType as any as NgModuleType);\n        const meta: R3InjectorMetadataFacade = {\n          name: moduleType.name,\n          type: moduleType,\n          deps: reflectDependencies(moduleType),\n          providers: ngModule.providers || EMPTY_ARRAY,\n          imports: [\n            (ngModule.imports || EMPTY_ARRAY).map(resolveForwardRef),\n            (ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef),\n          ],\n        };\n        ngInjectorDef = getCompilerFacade().compileInjector(\n            angularCoreEnv, `ng://${moduleType.name}/ngInjectorDef.js`, meta);\n      }\n      return ngInjectorDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\nfunction verifySemanticsOfNgModuleDef(moduleType: NgModuleType): void {\n  if (verifiedNgModule.get(moduleType)) return;\n  verifiedNgModule.set(moduleType, true);\n  moduleType = resolveForwardRef(moduleType);\n  const ngModuleDef = getNgModuleDef(moduleType, true);\n  const errors: string[] = [];\n  ngModuleDef.declarations.forEach(verifyDeclarationsHaveDefinitions);\n  const combinedDeclarations: Type<any>[] = [\n    ...ngModuleDef.declarations.map(resolveForwardRef),  //\n    ...flatten(ngModuleDef.imports.map(computeCombinedExports), resolveForwardRef),\n  ];\n  ngModuleDef.exports.forEach(verifyExportsAreDeclaredOrReExported);\n  ngModuleDef.declarations.forEach(verifyDeclarationIsUnique);\n  ngModuleDef.declarations.forEach(verifyComponentEntryComponentsIsPartOfNgModule);\n\n  const ngModule = getAnnotation<NgModule>(moduleType, 'NgModule');\n  if (ngModule) {\n    ngModule.imports &&\n        flatten(ngModule.imports, unwrapModuleWithProvidersImports)\n            .forEach(verifySemanticsOfNgModuleDef);\n    ngModule.bootstrap && ngModule.bootstrap.forEach(verifyComponentIsPartOfNgModule);\n    ngModule.entryComponents && ngModule.entryComponents.forEach(verifyComponentIsPartOfNgModule);\n  }\n\n  // Throw Error if any errors were detected.\n  if (errors.length) {\n    throw new Error(errors.join('\\n'));\n  }\n  ////////////////////////////////////////////////////////////////////////////////////////////////\n  function verifyDeclarationsHaveDefinitions(type: Type<any>): void {\n    type = resolveForwardRef(type);\n    const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);\n    if (!def) {\n      errors.push(\n          `Unexpected value '${stringify(type)}' declared by the module '${stringify(moduleType)}'. Please add a @Pipe/@Directive/@Component annotation.`);\n    }\n  }\n\n  function verifyExportsAreDeclaredOrReExported(type: Type<any>) {\n    type = resolveForwardRef(type);\n    const kind = getComponentDef(type) && 'component' || getDirectiveDef(type) && 'directive' ||\n        getPipeDef(type) && 'pipe';\n    if (kind) {\n      // only checked if we are declared as Component, Directive, or Pipe\n      // Modules don't need to be declared or imported.\n      if (combinedDeclarations.lastIndexOf(type) === -1) {\n        // We are exporting something which we don't explicitly declare or import.\n        errors.push(\n            `Can't export ${kind} ${stringify(type)} from ${stringify(moduleType)} as it was neither declared nor imported!`);\n      }\n    }\n  }\n\n  function verifyDeclarationIsUnique(type: Type<any>) {\n    type = resolveForwardRef(type);\n    const existingModule = ownerNgModule.get(type);\n    if (existingModule && existingModule !== moduleType) {\n      const modules = [existingModule, moduleType].map(stringify).sort();\n      errors.push(\n          `Type ${stringify(type)} is part of the declarations of 2 modules: ${modules[0]} and ${modules[1]}! ` +\n          `Please consider moving ${stringify(type)} to a higher module that imports ${modules[0]} and ${modules[1]}. ` +\n          `You can also create a new NgModule that exports and includes ${stringify(type)} then import that NgModule in ${modules[0]} and ${modules[1]}.`);\n    } else {\n      // Mark type as having owner.\n      ownerNgModule.set(type, moduleType);\n    }\n  }\n\n  function verifyComponentIsPartOfNgModule(type: Type<any>) {\n    type = resolveForwardRef(type);\n    const existingModule = ownerNgModule.get(type);\n    if (!existingModule) {\n      errors.push(\n          `Component ${stringify(type)} is not part of any NgModule or the module has not been imported into your module.`);\n    }\n  }\n\n  function verifyComponentEntryComponentsIsPartOfNgModule(type: Type<any>) {\n    type = resolveForwardRef(type);\n    if (getComponentDef(type)) {\n      // We know we are component\n      const component = getAnnotation<Component>(type, 'Component');\n      if (component && component.entryComponents) {\n        component.entryComponents.forEach(verifyComponentIsPartOfNgModule);\n      }\n    }\n  }\n}\n\nfunction unwrapModuleWithProvidersImports(\n    typeOrWithProviders: NgModuleType<any>| {ngModule: NgModuleType<any>}): NgModuleType<any> {\n  typeOrWithProviders = resolveForwardRef(typeOrWithProviders);\n  return (typeOrWithProviders as any).ngModule || typeOrWithProviders;\n}\n\nfunction getAnnotation<T>(type: any, name: string): T|null {\n  let annotation: T|null = null;\n  collect(type.__annotations__);\n  collect(type.decorators);\n  return annotation;\n\n  function collect(annotations: any[] | null) {\n    if (annotations) {\n      annotations.forEach(readAnnotation);\n    }\n  }\n\n  function readAnnotation(\n      decorator: {type: {prototype: {ngMetadataName: string}, args: any[]}, args: any}): void {\n    if (!annotation) {\n      const proto = Object.getPrototypeOf(decorator);\n      if (proto.ngMetadataName == name) {\n        annotation = decorator as any;\n      } else if (decorator.type) {\n        const proto = Object.getPrototypeOf(decorator.type);\n        if (proto.ngMetadataName == name) {\n          annotation = decorator.args[0];\n        }\n      }\n    }\n  }\n}\n\n/**\n * Keep track of compiled components. This is needed because in tests we often want to compile the\n * same component with more than one NgModule. This would cause an error unless we reset which\n * NgModule the component belongs to. We keep the list of compiled components here so that the\n * TestBed can reset it later.\n */\nlet ownerNgModule = new Map<Type<any>, NgModuleType<any>>();\nlet verifiedNgModule = new Map<NgModuleType<any>, boolean>();\n\nexport function resetCompiledComponents(): void {\n  ownerNgModule = new Map<Type<any>, NgModuleType<any>>();\n  verifiedNgModule = new Map<NgModuleType<any>, boolean>();\n  moduleQueue.length = 0;\n}\n\n/**\n * Computes the combined declarations of explicit declarations, as well as declarations inherited\n * by\n * traversing the exports of imported modules.\n * @param type\n */\nfunction computeCombinedExports(type: Type<any>): Type<any>[] {\n  type = resolveForwardRef(type);\n  const ngModuleDef = getNgModuleDef(type, true);\n  return [...flatten(ngModuleDef.exports.map((type) => {\n    const ngModuleDef = getNgModuleDef(type);\n    if (ngModuleDef) {\n      verifySemanticsOfNgModuleDef(type as any as NgModuleType);\n      return computeCombinedExports(type);\n    } else {\n      return type;\n    }\n  }))];\n}\n\n/**\n * Some declared components may be compiled asynchronously, and thus may not have their\n * ngComponentDef set yet. If this is the case, then a reference to the module is written into\n * the `ngSelectorScope` property of the declared type.\n */\nfunction setScopeOnDeclaredComponents(moduleType: Type<any>, ngModule: NgModule) {\n  const declarations: Type<any>[] = flatten(ngModule.declarations || EMPTY_ARRAY);\n\n  const transitiveScopes = transitiveScopesFor(moduleType);\n\n  declarations.forEach(declaration => {\n    if (declaration.hasOwnProperty(NG_COMPONENT_DEF)) {\n      // An `ngComponentDef` field exists - go ahead and patch the component directly.\n      const component = declaration as Type<any>& {ngComponentDef: ComponentDef<any>};\n      const componentDef = getComponentDef(component) !;\n      patchComponentDefWithScope(componentDef, transitiveScopes);\n    } else if (\n        !declaration.hasOwnProperty(NG_DIRECTIVE_DEF) && !declaration.hasOwnProperty(NG_PIPE_DEF)) {\n      // Set `ngSelectorScope` for future reference when the component compilation finishes.\n      (declaration as Type<any>& {ngSelectorScope?: any}).ngSelectorScope = moduleType;\n    }\n  });\n}\n\n/**\n * Patch the definition of a component with directives and pipes from the compilation scope of\n * a given module.\n */\nexport function patchComponentDefWithScope<C>(\n    componentDef: ComponentDef<C>, transitiveScopes: NgModuleTransitiveScopes) {\n  componentDef.directiveDefs = () => Array.from(transitiveScopes.compilation.directives)\n                                         .map(dir => getDirectiveDef(dir) || getComponentDef(dir) !)\n                                         .filter(def => !!def);\n  componentDef.pipeDefs = () =>\n      Array.from(transitiveScopes.compilation.pipes).map(pipe => getPipeDef(pipe) !);\n}\n\n/**\n * Compute the pair of transitive scopes (compilation scope and exported scope) for a given module.\n *\n * This operation is memoized and the result is cached on the module's definition. It can be called\n * on modules with components that have not fully compiled yet, but the result should not be used\n * until they have.\n */\nexport function transitiveScopesFor<T>(moduleType: Type<T>): NgModuleTransitiveScopes {\n  if (!isNgModule(moduleType)) {\n    throw new Error(`${moduleType.name} does not have an ngModuleDef`);\n  }\n  const def = getNgModuleDef(moduleType) !;\n\n  if (def.transitiveCompileScopes !== null) {\n    return def.transitiveCompileScopes;\n  }\n\n  const scopes: NgModuleTransitiveScopes = {\n    compilation: {\n      directives: new Set<any>(),\n      pipes: new Set<any>(),\n    },\n    exported: {\n      directives: new Set<any>(),\n      pipes: new Set<any>(),\n    },\n  };\n\n  def.declarations.forEach(declared => {\n    const declaredWithDefs = declared as Type<any>& { ngPipeDef?: any; };\n\n    if (getPipeDef(declaredWithDefs)) {\n      scopes.compilation.pipes.add(declared);\n    } else {\n      // Either declared has an ngComponentDef or ngDirectiveDef, or it's a component which hasn't\n      // had its template compiled yet. In either case, it gets added to the compilation's\n      // directives.\n      scopes.compilation.directives.add(declared);\n    }\n  });\n\n  def.imports.forEach(<I>(imported: Type<I>) => {\n    const importedTyped = imported as Type<I>& {\n      // If imported is an @NgModule:\n      ngModuleDef?: NgModuleDef<I>;\n    };\n\n    if (!isNgModule<I>(importedTyped)) {\n      throw new Error(`Importing ${importedTyped.name} which does not have an ngModuleDef`);\n    }\n\n    // When this module imports another, the imported module's exported directives and pipes are\n    // added to the compilation scope of this module.\n    const importedScope = transitiveScopesFor(importedTyped);\n    importedScope.exported.directives.forEach(entry => scopes.compilation.directives.add(entry));\n    importedScope.exported.pipes.forEach(entry => scopes.compilation.pipes.add(entry));\n  });\n\n  def.exports.forEach(<E>(exported: Type<E>) => {\n    const exportedTyped = exported as Type<E>& {\n      // Components, Directives, NgModules, and Pipes can all be exported.\n      ngComponentDef?: any;\n      ngDirectiveDef?: any;\n      ngModuleDef?: NgModuleDef<E>;\n      ngPipeDef?: any;\n    };\n\n    // Either the type is a module, a pipe, or a component/directive (which may not have an\n    // ngComponentDef as it might be compiled asynchronously).\n    if (isNgModule(exportedTyped)) {\n      // When this module exports another, the exported module's exported directives and pipes are\n      // added to both the compilation and exported scopes of this module.\n      const exportedScope = transitiveScopesFor(exportedTyped);\n      exportedScope.exported.directives.forEach(entry => {\n        scopes.compilation.directives.add(entry);\n        scopes.exported.directives.add(entry);\n      });\n      exportedScope.exported.pipes.forEach(entry => {\n        scopes.compilation.pipes.add(entry);\n        scopes.exported.pipes.add(entry);\n      });\n    } else if (getPipeDef(exportedTyped)) {\n      scopes.exported.pipes.add(exportedTyped);\n    } else {\n      scopes.exported.directives.add(exportedTyped);\n    }\n  });\n\n  def.transitiveCompileScopes = scopes;\n  return scopes;\n}\n\nfunction flatten<T>(values: any[], mapFn?: (value: T) => any): Type<T>[] {\n  const out: Type<T>[] = [];\n  values.forEach(value => {\n    if (Array.isArray(value)) {\n      out.push(...flatten<T>(value, mapFn));\n    } else {\n      out.push(mapFn ? mapFn(value) : value);\n    }\n  });\n  return out;\n}\n\nfunction expandModuleWithProviders(value: Type<any>| ModuleWithProviders<{}>): Type<any> {\n  if (isModuleWithProviders(value)) {\n    return value.ngModule;\n  }\n  return value;\n}\n\nfunction isModuleWithProviders(value: any): value is ModuleWithProviders<{}> {\n  return (value as{ngModule?: any}).ngModule !== undefined;\n}\n\nfunction isNgModule<T>(value: Type<T>): value is Type<T>&{ngModuleDef: NgModuleDef<T>} {\n  return !!getNgModuleDef(value);\n}\n"]}

package/esm2015/src/render3/jit/pipe.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -39,5 +39,4 @@ export function compilePipe(type, meta) {
         configurable: !!ngDevMode,
     });
 }
-
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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