@angular/compiler-cli 7.2.0-beta.0 → 7.2.0

package/src/ngtsc/shims/src/factory_generator.js

@@ -36,8 +36,13 @@
             enumerable: true,
             configurable: true
         });
-        FactoryGenerator.prototype.getOriginalSourceOfShim = function (fileName) { return this.map.get(fileName) || null; };
-        FactoryGenerator.prototype.generate = function (original, genFilePath) {
+        FactoryGenerator.prototype.recognize = function (fileName) { return this.map.has(fileName); };
+        FactoryGenerator.prototype.generate = function (genFilePath, readFile) {
+            var originalPath = this.map.get(genFilePath);
+            var original = readFile(originalPath);
+            if (original === null) {
+                return null;
+            }
             var relativePathToSource = './' + path.posix.basename(original.fileName).replace(TS_DTS_SUFFIX, '');
             // Collect a list of classes that need to have factory types emitted for them. This list is
             // overly broad as at this point the ts.TypeChecker hasn't been created, and can't be used to
@@ -53,19 +58,30 @@
                 decl.name !== undefined; })
                 // Grab the symbol name.
                 .map(function (decl) { return decl.name.text; });
-            // For each symbol name, generate a constant export of the corresponding NgFactory.
-            // This will encompass a lot of symbols which don't need factories, but that's okay
-            // because it won't miss any that do.
-            var varLines = symbolNames.map(function (name) { return "export const " + name + "NgFactory = new i0.\u0275NgModuleFactory(" + name + ");"; });
-            var sourceText = tslib_1.__spread([
-                // This might be incorrect if the current package being compiled is Angular core, but it's
-                // okay to leave in at type checking time. TypeScript can handle this reference via its path
-                // mapping, but downstream bundlers can't. If the current package is core itself, this will be
-                // replaced in the factory transformer before emit.
-                "import * as i0 from '@angular/core';",
-                "import {" + symbolNames.join(', ') + "} from '" + relativePathToSource + "';"
-            ], varLines).join('\n');
-            return ts.createSourceFile(genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);
+            var sourceText = '';
+            if (symbolNames.length > 0) {
+                // For each symbol name, generate a constant export of the corresponding NgFactory.
+                // This will encompass a lot of symbols which don't need factories, but that's okay
+                // because it won't miss any that do.
+                var varLines = symbolNames.map(function (name) { return "export const " + name + "NgFactory = new i0.\u0275NgModuleFactory(" + name + ");"; });
+                sourceText = tslib_1.__spread([
+                    // This might be incorrect if the current package being compiled is Angular core, but it's
+                    // okay to leave in at type checking time. TypeScript can handle this reference via its path
+                    // mapping, but downstream bundlers can't. If the current package is core itself, this will
+                    // be replaced in the factory transformer before emit.
+                    "import * as i0 from '@angular/core';",
+                    "import {" + symbolNames.join(', ') + "} from '" + relativePathToSource + "';"
+                ], varLines).join('\n');
+            }
+            // Add an extra export to ensure this module has at least one. It'll be removed later in the
+            // factory transformer if it ends up not being needed.
+            sourceText += '\nexport const ɵNonEmptyModule = true;';
+            var genFile = ts.createSourceFile(genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);
+            if (original.moduleName !== undefined) {
+                genFile.moduleName =
+                    util_1.generatedModuleName(original.moduleName, original.fileName, '.ngfactory');
+            }
+            return genFile;
         };
         FactoryGenerator.forRootFiles = function (files) {
             var map = new Map();
@@ -89,46 +105,83 @@
     }
     exports.generatedFactoryTransform = generatedFactoryTransform;
     function transformFactorySourceFile(factoryMap, context, coreImportsFrom, file) {
+        var e_1, _a;
         // If this is not a generated file, it won't have factory info associated with it.
         if (!factoryMap.has(file.fileName)) {
             // Don't transform non-generated code.
             return file;
         }
-        var _a = factoryMap.get(file.fileName), moduleSymbolNames = _a.moduleSymbolNames, sourceFilePath = _a.sourceFilePath;
+        var _b = factoryMap.get(file.fileName), moduleSymbolNames = _b.moduleSymbolNames, sourceFilePath = _b.sourceFilePath;
         var clone = ts.getMutableClone(file);
-        var transformedStatements = file.statements.map(function (stmt) {
-            if (coreImportsFrom !== null && ts.isImportDeclaration(stmt) &&
-                ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === '@angular/core') {
-                var path_2 = path_1.relativePathBetween(sourceFilePath, coreImportsFrom.fileName);
-                if (path_2 !== null) {
-                    return ts.updateImportDeclaration(stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts.createStringLiteral(path_2));
-                }
-                else {
-                    return ts.createNotEmittedStatement(stmt);
+        // Not every exported factory statement is valid. They were generated before the program was
+        // analyzed, and before ngtsc knew which symbols were actually NgModules. factoryMap contains
+        // that knowledge now, so this transform filters the statement list and removes exported factories
+        // that aren't actually factories.
+        //
+        // This could leave the generated factory file empty. To prevent this (it causes issues with
+        // closure compiler) a 'ɵNonEmptyModule' export was added when the factory shim was created.
+        // Preserve that export if needed, and remove it otherwise.
+        //
+        // Additionally, an import to @angular/core is generated, but the current compilation unit could
+        // actually be @angular/core, in which case such an import is invalid and should be replaced with
+        // the proper path to access Ivy symbols in core.
+        // The filtered set of statements.
+        var transformedStatements = [];
+        // The statement identified as the ɵNonEmptyModule export.
+        var nonEmptyExport = null;
+        try {
+            // Consider all the statements.
+            for (var _c = tslib_1.__values(file.statements), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var stmt = _d.value;
+                // Look for imports to @angular/core.
+                if (coreImportsFrom !== null && ts.isImportDeclaration(stmt) &&
+                    ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === '@angular/core') {
+                    // Update the import path to point to the correct file (coreImportsFrom).
+                    var path_2 = path_1.relativePathBetween(sourceFilePath, coreImportsFrom.fileName);
+                    if (path_2 !== null) {
+                        transformedStatements.push(ts.updateImportDeclaration(stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts.createStringLiteral(path_2)));
+                    }
                 }
-            }
-            else if (ts.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {
-                var decl = stmt.declarationList.declarations[0];
-                if (ts.isIdentifier(decl.name)) {
-                    var match = STRIP_NG_FACTORY.exec(decl.name.text);
-                    if (match === null || !moduleSymbolNames.has(match[1])) {
-                        // Remove the given factory as it wasn't actually for an NgModule.
-                        return ts.createNotEmittedStatement(stmt);
+                else if (ts.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {
+                    var decl = stmt.declarationList.declarations[0];
+                    // If this is the ɵNonEmptyModule export, then save it for later.
+                    if (ts.isIdentifier(decl.name)) {
+                        if (decl.name.text === 'ɵNonEmptyModule') {
+                            nonEmptyExport = stmt;
+                            continue;
+                        }
+                        // Otherwise, check if this export is a factory for a known NgModule, and retain it if so.
+                        var match = STRIP_NG_FACTORY.exec(decl.name.text);
+                        if (match !== null && moduleSymbolNames.has(match[1])) {
+                            transformedStatements.push(stmt);
+                        }
                     }
+                    else {
+                        // Leave the statement alone, as it can't be understood.
+                        transformedStatements.push(stmt);
+                    }
+                }
+                else {
+                    // Include non-variable statements (imports, etc).
+                    transformedStatements.push(stmt);
                 }
-                return stmt;
             }
-            else {
-                return stmt;
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-        });
-        if (!transformedStatements.some(ts.isVariableStatement)) {
+            finally { if (e_1) throw e_1.error; }
+        }
+        // Check whether the empty module export is still needed.
+        if (!transformedStatements.some(ts.isVariableStatement) && nonEmptyExport !== null) {
             // If the resulting file has no factories, include an empty export to
             // satisfy closure compiler.
-            transformedStatements.push(ts.createVariableStatement([ts.createModifier(ts.SyntaxKind.ExportKeyword)], ts.createVariableDeclarationList([ts.createVariableDeclaration('ɵNonEmptyModule', undefined, ts.createTrue())], ts.NodeFlags.Const)));
+            transformedStatements.push(nonEmptyExport);
         }
         clone.statements = ts.createNodeArray(transformedStatements);
         return clone;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory_generator.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/shims/src/factory_generator.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 * as path from 'path';\nimport * as ts from 'typescript';\n\nimport {relativePathBetween} from '../../util/src/path';\n\nimport {ShimGenerator} from './host';\nimport {isNonDeclarationTsFile} from './util';\n\nconst TS_DTS_SUFFIX = /(\\.d)?\\.ts$/;\nconst STRIP_NG_FACTORY = /(.*)NgFactory$/;\n\n/**\n * Generates ts.SourceFiles which contain variable declarations for NgFactories for every exported\n * class of an input ts.SourceFile.\n */\nexport class FactoryGenerator implements ShimGenerator {\n  private constructor(private map: Map<string, string>) {}\n\n  get factoryFileMap(): Map<string, string> { return this.map; }\n\n  getOriginalSourceOfShim(fileName: string): string|null { return this.map.get(fileName) || null; }\n\n  generate(original: ts.SourceFile, genFilePath: string): ts.SourceFile {\n    const relativePathToSource =\n        './' + path.posix.basename(original.fileName).replace(TS_DTS_SUFFIX, '');\n    // Collect a list of classes that need to have factory types emitted for them. This list is\n    // overly broad as at this point the ts.TypeChecker hasn't been created, and can't be used to\n    // semantically understand which decorated types are actually decorated with Angular decorators.\n    //\n    // The exports generated here are pruned in the factory transform during emit.\n    const symbolNames = original\n                            .statements\n                            // Pick out top level class declarations...\n                            .filter(ts.isClassDeclaration)\n                            // which are named, exported, and have decorators.\n                            .filter(\n                                decl => isExported(decl) && decl.decorators !== undefined &&\n                                    decl.name !== undefined)\n                            // Grab the symbol name.\n                            .map(decl => decl.name !.text);\n\n    // For each symbol name, generate a constant export of the corresponding NgFactory.\n    // This will encompass a lot of symbols which don't need factories, but that's okay\n    // because it won't miss any that do.\n    const varLines = symbolNames.map(\n        name => `export const ${name}NgFactory = new i0.ɵNgModuleFactory(${name});`);\n    const sourceText = [\n      // This might be incorrect if the current package being compiled is Angular core, but it's\n      // okay to leave in at type checking time. TypeScript can handle this reference via its path\n      // mapping, but downstream bundlers can't. If the current package is core itself, this will be\n      // replaced in the factory transformer before emit.\n      `import * as i0 from '@angular/core';`,\n      `import {${symbolNames.join(', ')}} from '${relativePathToSource}';`,\n      ...varLines,\n    ].join('\\n');\n    return ts.createSourceFile(\n        genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);\n  }\n\n  static forRootFiles(files: ReadonlyArray<string>): FactoryGenerator {\n    const map = new Map<string, string>();\n    files.filter(sourceFile => isNonDeclarationTsFile(sourceFile))\n        .forEach(sourceFile => map.set(sourceFile.replace(/\\.ts$/, '.ngfactory.ts'), sourceFile));\n    return new FactoryGenerator(map);\n  }\n}\n\nfunction isExported(decl: ts.Declaration): boolean {\n  return decl.modifiers !== undefined &&\n      decl.modifiers.some(mod => mod.kind == ts.SyntaxKind.ExportKeyword);\n}\n\nexport interface FactoryInfo {\n  sourceFilePath: string;\n  moduleSymbolNames: Set<string>;\n}\n\nexport function generatedFactoryTransform(\n    factoryMap: Map<string, FactoryInfo>,\n    coreImportsFrom: ts.SourceFile | null): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {\n    return (file: ts.SourceFile): ts.SourceFile => {\n      return transformFactorySourceFile(factoryMap, context, coreImportsFrom, file);\n    };\n  };\n}\n\nfunction transformFactorySourceFile(\n    factoryMap: Map<string, FactoryInfo>, context: ts.TransformationContext,\n    coreImportsFrom: ts.SourceFile | null, file: ts.SourceFile): ts.SourceFile {\n  // If this is not a generated file, it won't have factory info associated with it.\n  if (!factoryMap.has(file.fileName)) {\n    // Don't transform non-generated code.\n    return file;\n  }\n\n  const {moduleSymbolNames, sourceFilePath} = factoryMap.get(file.fileName) !;\n\n  const clone = ts.getMutableClone(file);\n\n  const transformedStatements = file.statements.map(stmt => {\n    if (coreImportsFrom !== null && ts.isImportDeclaration(stmt) &&\n        ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === '@angular/core') {\n      const path = relativePathBetween(sourceFilePath, coreImportsFrom.fileName);\n      if (path !== null) {\n        return ts.updateImportDeclaration(\n            stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts.createStringLiteral(path));\n      } else {\n        return ts.createNotEmittedStatement(stmt);\n      }\n    } else if (ts.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {\n      const decl = stmt.declarationList.declarations[0];\n      if (ts.isIdentifier(decl.name)) {\n        const match = STRIP_NG_FACTORY.exec(decl.name.text);\n        if (match === null || !moduleSymbolNames.has(match[1])) {\n          // Remove the given factory as it wasn't actually for an NgModule.\n          return ts.createNotEmittedStatement(stmt);\n        }\n      }\n      return stmt;\n    } else {\n      return stmt;\n    }\n  });\n  if (!transformedStatements.some(ts.isVariableStatement)) {\n    // If the resulting file has no factories, include an empty export to\n    // satisfy closure compiler.\n    transformedStatements.push(ts.createVariableStatement(\n        [ts.createModifier(ts.SyntaxKind.ExportKeyword)],\n        ts.createVariableDeclarationList(\n            [ts.createVariableDeclaration('ɵNonEmptyModule', undefined, ts.createTrue())],\n            ts.NodeFlags.Const)));\n  }\n  clone.statements = ts.createNodeArray(transformedStatements);\n  return clone;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory_generator.js","sourceRoot":"../../../../../","sources":["packages/compiler-cli/src/ngtsc/shims/src/factory_generator.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 * as path from 'path';\nimport * as ts from 'typescript';\n\nimport {relativePathBetween} from '../../util/src/path';\n\nimport {ShimGenerator} from './host';\nimport {generatedModuleName, isNonDeclarationTsFile} from './util';\n\nconst TS_DTS_SUFFIX = /(\\.d)?\\.ts$/;\nconst STRIP_NG_FACTORY = /(.*)NgFactory$/;\n\n/**\n * Generates ts.SourceFiles which contain variable declarations for NgFactories for every exported\n * class of an input ts.SourceFile.\n */\nexport class FactoryGenerator implements ShimGenerator {\n  private constructor(private map: Map<string, string>) {}\n\n  get factoryFileMap(): Map<string, string> { return this.map; }\n\n  recognize(fileName: string): boolean { return this.map.has(fileName); }\n\n  generate(genFilePath: string, readFile: (fileName: string) => ts.SourceFile | null): ts.SourceFile\n      |null {\n    const originalPath = this.map.get(genFilePath) !;\n    const original = readFile(originalPath);\n    if (original === null) {\n      return null;\n    }\n\n    const relativePathToSource =\n        './' + path.posix.basename(original.fileName).replace(TS_DTS_SUFFIX, '');\n    // Collect a list of classes that need to have factory types emitted for them. This list is\n    // overly broad as at this point the ts.TypeChecker hasn't been created, and can't be used to\n    // semantically understand which decorated types are actually decorated with Angular decorators.\n    //\n    // The exports generated here are pruned in the factory transform during emit.\n    const symbolNames = original\n                            .statements\n                            // Pick out top level class declarations...\n                            .filter(ts.isClassDeclaration)\n                            // which are named, exported, and have decorators.\n                            .filter(\n                                decl => isExported(decl) && decl.decorators !== undefined &&\n                                    decl.name !== undefined)\n                            // Grab the symbol name.\n                            .map(decl => decl.name !.text);\n\n    let sourceText = '';\n    if (symbolNames.length > 0) {\n      // For each symbol name, generate a constant export of the corresponding NgFactory.\n      // This will encompass a lot of symbols which don't need factories, but that's okay\n      // because it won't miss any that do.\n      const varLines = symbolNames.map(\n          name => `export const ${name}NgFactory = new i0.ɵNgModuleFactory(${name});`);\n      sourceText = [\n        // This might be incorrect if the current package being compiled is Angular core, but it's\n        // okay to leave in at type checking time. TypeScript can handle this reference via its path\n        // mapping, but downstream bundlers can't. If the current package is core itself, this will\n        // be replaced in the factory transformer before emit.\n        `import * as i0 from '@angular/core';`,\n        `import {${symbolNames.join(', ')}} from '${relativePathToSource}';`,\n        ...varLines,\n      ].join('\\n');\n    }\n\n    // Add an extra export to ensure this module has at least one. It'll be removed later in the\n    // factory transformer if it ends up not being needed.\n    sourceText += '\\nexport const ɵNonEmptyModule = true;';\n\n    const genFile = ts.createSourceFile(\n        genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);\n    if (original.moduleName !== undefined) {\n      genFile.moduleName =\n          generatedModuleName(original.moduleName, original.fileName, '.ngfactory');\n    }\n    return genFile;\n  }\n\n  static forRootFiles(files: ReadonlyArray<string>): FactoryGenerator {\n    const map = new Map<string, string>();\n    files.filter(sourceFile => isNonDeclarationTsFile(sourceFile))\n        .forEach(sourceFile => map.set(sourceFile.replace(/\\.ts$/, '.ngfactory.ts'), sourceFile));\n    return new FactoryGenerator(map);\n  }\n}\n\nfunction isExported(decl: ts.Declaration): boolean {\n  return decl.modifiers !== undefined &&\n      decl.modifiers.some(mod => mod.kind == ts.SyntaxKind.ExportKeyword);\n}\n\nexport interface FactoryInfo {\n  sourceFilePath: string;\n  moduleSymbolNames: Set<string>;\n}\n\nexport function generatedFactoryTransform(\n    factoryMap: Map<string, FactoryInfo>,\n    coreImportsFrom: ts.SourceFile | null): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {\n    return (file: ts.SourceFile): ts.SourceFile => {\n      return transformFactorySourceFile(factoryMap, context, coreImportsFrom, file);\n    };\n  };\n}\n\nfunction transformFactorySourceFile(\n    factoryMap: Map<string, FactoryInfo>, context: ts.TransformationContext,\n    coreImportsFrom: ts.SourceFile | null, file: ts.SourceFile): ts.SourceFile {\n  // If this is not a generated file, it won't have factory info associated with it.\n  if (!factoryMap.has(file.fileName)) {\n    // Don't transform non-generated code.\n    return file;\n  }\n\n  const {moduleSymbolNames, sourceFilePath} = factoryMap.get(file.fileName) !;\n\n  const clone = ts.getMutableClone(file);\n\n  // Not every exported factory statement is valid. They were generated before the program was\n  // analyzed, and before ngtsc knew which symbols were actually NgModules. factoryMap contains\n  // that knowledge now, so this transform filters the statement list and removes exported factories\n  // that aren't actually factories.\n  //\n  // This could leave the generated factory file empty. To prevent this (it causes issues with\n  // closure compiler) a 'ɵNonEmptyModule' export was added when the factory shim was created.\n  // Preserve that export if needed, and remove it otherwise.\n  //\n  // Additionally, an import to @angular/core is generated, but the current compilation unit could\n  // actually be @angular/core, in which case such an import is invalid and should be replaced with\n  // the proper path to access Ivy symbols in core.\n\n  // The filtered set of statements.\n  const transformedStatements: ts.Statement[] = [];\n\n  // The statement identified as the ɵNonEmptyModule export.\n  let nonEmptyExport: ts.Statement|null = null;\n\n  // Consider all the statements.\n  for (const stmt of file.statements) {\n    // Look for imports to @angular/core.\n    if (coreImportsFrom !== null && ts.isImportDeclaration(stmt) &&\n        ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === '@angular/core') {\n      // Update the import path to point to the correct file (coreImportsFrom).\n      const path = relativePathBetween(sourceFilePath, coreImportsFrom.fileName);\n      if (path !== null) {\n        transformedStatements.push(ts.updateImportDeclaration(\n            stmt, stmt.decorators, stmt.modifiers, stmt.importClause,\n            ts.createStringLiteral(path)));\n      }\n    } else if (ts.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {\n      const decl = stmt.declarationList.declarations[0];\n\n      // If this is the ɵNonEmptyModule export, then save it for later.\n      if (ts.isIdentifier(decl.name)) {\n        if (decl.name.text === 'ɵNonEmptyModule') {\n          nonEmptyExport = stmt;\n          continue;\n        }\n\n        // Otherwise, check if this export is a factory for a known NgModule, and retain it if so.\n        const match = STRIP_NG_FACTORY.exec(decl.name.text);\n        if (match !== null && moduleSymbolNames.has(match[1])) {\n          transformedStatements.push(stmt);\n        }\n      } else {\n        // Leave the statement alone, as it can't be understood.\n        transformedStatements.push(stmt);\n      }\n    } else {\n      // Include non-variable statements (imports, etc).\n      transformedStatements.push(stmt);\n    }\n  }\n\n  // Check whether the empty module export is still needed.\n  if (!transformedStatements.some(ts.isVariableStatement) && nonEmptyExport !== null) {\n    // If the resulting file has no factories, include an empty export to\n    // satisfy closure compiler.\n    transformedStatements.push(nonEmptyExport);\n  }\n  clone.statements = ts.createNodeArray(transformedStatements);\n  return clone;\n}\n"]}

package/src/ngtsc/shims/src/flat_index_generator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/shims/src/flat_index_generator" />
+import * as ts from 'typescript';
+import { ShimGenerator } from './host';
+export declare class FlatIndexGenerator implements ShimGenerator {
+    readonly entryPoint: string;
+    readonly moduleName: string | null;
+    readonly flatIndexPath: string;
+    private constructor();
+    static forRootFiles(flatIndexPath: string, files: ReadonlyArray<string>, moduleName: string | null): FlatIndexGenerator | null;
+    recognize(fileName: string): boolean;
+    generate(): ts.SourceFile;
+}

package/src/ngtsc/shims/src/flat_index_generator.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/shims/src/flat_index_generator", ["require", "exports", "tslib", "path", "typescript", "@angular/compiler-cli/src/ngtsc/shims/src/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var path = require("path");
+    var ts = require("typescript");
+    var util_1 = require("@angular/compiler-cli/src/ngtsc/shims/src/util");
+    var FlatIndexGenerator = /** @class */ (function () {
+        function FlatIndexGenerator(relativeFlatIndexPath, entryPoint, moduleName) {
+            this.entryPoint = entryPoint;
+            this.moduleName = moduleName;
+            this.flatIndexPath = path.posix.join(path.posix.dirname(entryPoint), relativeFlatIndexPath)
+                .replace(/\.js$/, '') +
+                '.ts';
+        }
+        FlatIndexGenerator.forRootFiles = function (flatIndexPath, files, moduleName) {
+            var e_1, _a;
+            // If there's only one .ts file in the program, it's the entry. Otherwise, look for the shortest
+            // (in terms of characters in the filename) file that ends in /index.ts. The second behavior is
+            // deprecated; users should always explicitly specify a single .ts entrypoint.
+            var tsFiles = files.filter(util_1.isNonDeclarationTsFile);
+            if (tsFiles.length === 1) {
+                return new FlatIndexGenerator(flatIndexPath, tsFiles[0], moduleName);
+            }
+            else {
+                var indexFile = null;
+                try {
+                    for (var tsFiles_1 = tslib_1.__values(tsFiles), tsFiles_1_1 = tsFiles_1.next(); !tsFiles_1_1.done; tsFiles_1_1 = tsFiles_1.next()) {
+                        var tsFile = tsFiles_1_1.value;
+                        if (tsFile.endsWith('/index.ts') &&
+                            (indexFile === null || tsFile.length <= indexFile.length)) {
+                            indexFile = tsFile;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (tsFiles_1_1 && !tsFiles_1_1.done && (_a = tsFiles_1.return)) _a.call(tsFiles_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (indexFile !== null) {
+                    return new FlatIndexGenerator(flatIndexPath, indexFile, moduleName);
+                }
+                else {
+                    return null;
+                }
+            }
+        };
+        FlatIndexGenerator.prototype.recognize = function (fileName) { return fileName === this.flatIndexPath; };
+        FlatIndexGenerator.prototype.generate = function () {
+            var relativeEntryPoint = './' +
+                path.posix.relative(path.posix.dirname(this.flatIndexPath), this.entryPoint)
+                    .replace(/\.tsx?$/, '');
+            var contents = "/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from '" + relativeEntryPoint + "';\n";
+            var genFile = ts.createSourceFile(this.flatIndexPath, contents, ts.ScriptTarget.ES2015, true, ts.ScriptKind.TS);
+            if (this.moduleName !== null) {
+                genFile.moduleName = this.moduleName;
+            }
+            return genFile;
+        };
+        return FlatIndexGenerator;
+    }());
+    exports.FlatIndexGenerator = FlatIndexGenerator;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/shims/src/host.d.ts

@@ -9,16 +9,18 @@
 import * as ts from 'typescript';
 export interface ShimGenerator {
     /**
-     * Get the original source file for the given shim path, the contents of which determine the
-     * contents of the shim file.
-     *
-     * If this returns `null` then the given file was not a shim file handled by this generator.
+     * Returns `true` if this generator is intended to handle the given file.
      */
-    getOriginalSourceOfShim(fileName: string): string | null;
+    recognize(fileName: string): boolean;
     /**
      * Generate a shim's `ts.SourceFile` for the given original file.
+     *
+     * `readFile` is a function which allows the generator to look up the contents of existing source
+     * files. It returns null if the requested file doesn't exist.
+     *
+     * If `generate` returns null, then the shim generator declines to generate the file after all.
      */
-    generate(original: ts.SourceFile, genFileName: string): ts.SourceFile;
+    generate(genFileName: string, readFile: (fileName: string) => ts.SourceFile | null): ts.SourceFile | null;
 }
 /**
  * A wrapper around a `ts.CompilerHost` which supports generated files.
@@ -28,6 +30,7 @@ export declare class GeneratedShimsHostWrapper implements ts.CompilerHost {
     private shimGenerators;
     constructor(delegate: ts.CompilerHost, shimGenerators: ShimGenerator[]);
     resolveTypeReferenceDirectives?: (names: string[], containingFile: string) => ts.ResolvedTypeReferenceDirective[];
+    directoryExists?: (directoryName: string) => boolean;
     getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined): ts.SourceFile | undefined;
     getDefaultLibFileName(options: ts.CompilerOptions): string;
     writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError: ((message: string) => void) | undefined, sourceFiles: ReadonlyArray<ts.SourceFile>): void;

package/src/ngtsc/shims/src/host.js

@@ -28,21 +28,20 @@
                     return delegate.resolveTypeReferenceDirectives(names, containingFile);
                 };
             }
+            if (delegate.directoryExists !== undefined) {
+                this.directoryExists = function (directoryName) { return delegate.directoryExists(directoryName); };
+            }
         }
         GeneratedShimsHostWrapper.prototype.getSourceFile = function (fileName, languageVersion, onError, shouldCreateNewSourceFile) {
-            var canonical = this.getCanonicalFileName(fileName);
+            var _this = this;
             for (var i = 0; i < this.shimGenerators.length; i++) {
                 var generator = this.shimGenerators[i];
-                var originalFile = generator.getOriginalSourceOfShim(canonical);
-                if (originalFile !== null) {
-                    // This shim generator has recognized the filename being requested, and is now responsible
-                    // for generating its contents, based on the contents of the original file it has requested.
-                    var originalSource = this.delegate.getSourceFile(originalFile, languageVersion, onError, shouldCreateNewSourceFile);
-                    if (originalSource === undefined) {
-                        // The original requested file doesn't exist, so the shim cannot exist either.
-                        return undefined;
-                    }
-                    return generator.generate(originalSource, fileName);
+                if (generator.recognize(fileName)) {
+                    var readFile = function (originalFile) {
+                        return _this.delegate.getSourceFile(originalFile, languageVersion, onError, shouldCreateNewSourceFile) ||
+                            null;
+                    };
+                    return generator.generate(fileName, readFile) || undefined;
                 }
             }
             return this.delegate.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
@@ -65,11 +64,11 @@
             // Consider the file as existing whenever 1) it really does exist in the delegate host, or
             // 2) at least one of the shim generators recognizes it.
             return this.delegate.fileExists(fileName) ||
-                this.shimGenerators.some(function (gen) { return gen.getOriginalSourceOfShim(canonical) !== null; });
+                this.shimGenerators.some(function (gen) { return gen.recognize(canonical); });
         };
         GeneratedShimsHostWrapper.prototype.readFile = function (fileName) { return this.delegate.readFile(fileName); };
         return GeneratedShimsHostWrapper;
     }());
     exports.GeneratedShimsHostWrapper = GeneratedShimsHostWrapper;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/shims/src/host.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 * as path from 'path';\nimport * as ts from 'typescript';\n\nexport interface ShimGenerator {\n  /**\n   * Get the original source file for the given shim path, the contents of which determine the\n   * contents of the shim file.\n   *\n   * If this returns `null` then the given file was not a shim file handled by this generator.\n   */\n  getOriginalSourceOfShim(fileName: string): string|null;\n\n  /**\n   * Generate a shim's `ts.SourceFile` for the given original file.\n   */\n  generate(original: ts.SourceFile, genFileName: string): ts.SourceFile;\n}\n\n/**\n * A wrapper around a `ts.CompilerHost` which supports generated files.\n */\nexport class GeneratedShimsHostWrapper implements ts.CompilerHost {\n  constructor(private delegate: ts.CompilerHost, private shimGenerators: ShimGenerator[]) {\n    if (delegate.resolveTypeReferenceDirectives) {\n      // Backward compatibility with TypeScript 2.9 and older since return\n      // type has changed from (ts.ResolvedTypeReferenceDirective | undefined)[]\n      // to ts.ResolvedTypeReferenceDirective[] in Typescript 3.0\n      type ts3ResolveTypeReferenceDirectives = (names: string[], containingFile: string) =>\n          ts.ResolvedTypeReferenceDirective[];\n      this.resolveTypeReferenceDirectives = (names: string[], containingFile: string) =>\n          (delegate.resolveTypeReferenceDirectives as ts3ResolveTypeReferenceDirectives) !(\n              names, containingFile);\n    }\n  }\n\n  resolveTypeReferenceDirectives?:\n      (names: string[], containingFile: string) => ts.ResolvedTypeReferenceDirective[];\n\n  getSourceFile(\n      fileName: string, languageVersion: ts.ScriptTarget,\n      onError?: ((message: string) => void)|undefined,\n      shouldCreateNewSourceFile?: boolean|undefined): ts.SourceFile|undefined {\n    const canonical = this.getCanonicalFileName(fileName);\n    for (let i = 0; i < this.shimGenerators.length; i++) {\n      const generator = this.shimGenerators[i];\n      const originalFile = generator.getOriginalSourceOfShim(canonical);\n      if (originalFile !== null) {\n        // This shim generator has recognized the filename being requested, and is now responsible\n        // for generating its contents, based on the contents of the original file it has requested.\n        const originalSource = this.delegate.getSourceFile(\n            originalFile, languageVersion, onError, shouldCreateNewSourceFile);\n        if (originalSource === undefined) {\n          // The original requested file doesn't exist, so the shim cannot exist either.\n          return undefined;\n        }\n        return generator.generate(originalSource, fileName);\n      }\n    }\n    return this.delegate.getSourceFile(\n        fileName, languageVersion, onError, shouldCreateNewSourceFile);\n  }\n\n  getDefaultLibFileName(options: ts.CompilerOptions): string {\n    return this.delegate.getDefaultLibFileName(options);\n  }\n\n  writeFile(\n      fileName: string, data: string, writeByteOrderMark: boolean,\n      onError: ((message: string) => void)|undefined,\n      sourceFiles: ReadonlyArray<ts.SourceFile>): void {\n    return this.delegate.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles);\n  }\n\n  getCurrentDirectory(): string { return this.delegate.getCurrentDirectory(); }\n\n  getDirectories(path: string): string[] { return this.delegate.getDirectories(path); }\n\n  getCanonicalFileName(fileName: string): string {\n    return this.delegate.getCanonicalFileName(fileName);\n  }\n\n  useCaseSensitiveFileNames(): boolean { return this.delegate.useCaseSensitiveFileNames(); }\n\n  getNewLine(): string { return this.delegate.getNewLine(); }\n\n  fileExists(fileName: string): boolean {\n    const canonical = this.getCanonicalFileName(fileName);\n    // Consider the file as existing whenever 1) it really does exist in the delegate host, or\n    // 2) at least one of the shim generators recognizes it.\n    return this.delegate.fileExists(fileName) ||\n        this.shimGenerators.some(gen => gen.getOriginalSourceOfShim(canonical) !== null);\n  }\n\n  readFile(fileName: string): string|undefined { return this.delegate.readFile(fileName); }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host.js","sourceRoot":"../../../../../","sources":["packages/compiler-cli/src/ngtsc/shims/src/host.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 * as path from 'path';\nimport * as ts from 'typescript';\n\nexport interface ShimGenerator {\n  /**\n   * Returns `true` if this generator is intended to handle the given file.\n   */\n  recognize(fileName: string): boolean;\n\n  /**\n   * Generate a shim's `ts.SourceFile` for the given original file.\n   *\n   * `readFile` is a function which allows the generator to look up the contents of existing source\n   * files. It returns null if the requested file doesn't exist.\n   *\n   * If `generate` returns null, then the shim generator declines to generate the file after all.\n   */\n  generate(genFileName: string, readFile: (fileName: string) => ts.SourceFile | null): ts.SourceFile\n      |null;\n}\n\n/**\n * A wrapper around a `ts.CompilerHost` which supports generated files.\n */\nexport class GeneratedShimsHostWrapper implements ts.CompilerHost {\n  constructor(private delegate: ts.CompilerHost, private shimGenerators: ShimGenerator[]) {\n    if (delegate.resolveTypeReferenceDirectives) {\n      // Backward compatibility with TypeScript 2.9 and older since return\n      // type has changed from (ts.ResolvedTypeReferenceDirective | undefined)[]\n      // to ts.ResolvedTypeReferenceDirective[] in Typescript 3.0\n      type ts3ResolveTypeReferenceDirectives = (names: string[], containingFile: string) =>\n          ts.ResolvedTypeReferenceDirective[];\n      this.resolveTypeReferenceDirectives = (names: string[], containingFile: string) =>\n          (delegate.resolveTypeReferenceDirectives as ts3ResolveTypeReferenceDirectives) !(\n              names, containingFile);\n    }\n    if (delegate.directoryExists !== undefined) {\n      this.directoryExists = (directoryName: string) => delegate.directoryExists !(directoryName);\n    }\n  }\n\n  resolveTypeReferenceDirectives?:\n      (names: string[], containingFile: string) => ts.ResolvedTypeReferenceDirective[];\n\n  directoryExists?: (directoryName: string) => boolean;\n\n  getSourceFile(\n      fileName: string, languageVersion: ts.ScriptTarget,\n      onError?: ((message: string) => void)|undefined,\n      shouldCreateNewSourceFile?: boolean|undefined): ts.SourceFile|undefined {\n    for (let i = 0; i < this.shimGenerators.length; i++) {\n      const generator = this.shimGenerators[i];\n      if (generator.recognize(fileName)) {\n        const readFile = (originalFile: string) => {\n          return this.delegate.getSourceFile(\n                     originalFile, languageVersion, onError, shouldCreateNewSourceFile) ||\n              null;\n        };\n\n        return generator.generate(fileName, readFile) || undefined;\n      }\n    }\n    return this.delegate.getSourceFile(\n        fileName, languageVersion, onError, shouldCreateNewSourceFile);\n  }\n\n  getDefaultLibFileName(options: ts.CompilerOptions): string {\n    return this.delegate.getDefaultLibFileName(options);\n  }\n\n  writeFile(\n      fileName: string, data: string, writeByteOrderMark: boolean,\n      onError: ((message: string) => void)|undefined,\n      sourceFiles: ReadonlyArray<ts.SourceFile>): void {\n    return this.delegate.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles);\n  }\n\n  getCurrentDirectory(): string { return this.delegate.getCurrentDirectory(); }\n\n  getDirectories(path: string): string[] { return this.delegate.getDirectories(path); }\n\n  getCanonicalFileName(fileName: string): string {\n    return this.delegate.getCanonicalFileName(fileName);\n  }\n\n  useCaseSensitiveFileNames(): boolean { return this.delegate.useCaseSensitiveFileNames(); }\n\n  getNewLine(): string { return this.delegate.getNewLine(); }\n\n  fileExists(fileName: string): boolean {\n    const canonical = this.getCanonicalFileName(fileName);\n    // Consider the file as existing whenever 1) it really does exist in the delegate host, or\n    // 2) at least one of the shim generators recognizes it.\n    return this.delegate.fileExists(fileName) ||\n        this.shimGenerators.some(gen => gen.recognize(canonical));\n  }\n\n  readFile(fileName: string): string|undefined { return this.delegate.readFile(fileName); }\n}\n"]}

package/src/ngtsc/shims/src/summary_generator.d.ts

@@ -12,7 +12,7 @@ export declare class SummaryGenerator implements ShimGenerator {
     private map;
     private constructor();
     getSummaryFileNames(): string[];
-    getOriginalSourceOfShim(fileName: string): string | null;
-    generate(original: ts.SourceFile, genFilePath: string): ts.SourceFile;
+    recognize(fileName: string): boolean;
+    generate(genFilePath: string, readFile: (fileName: string) => ts.SourceFile | null): ts.SourceFile | null;
     static forRootFiles(files: ReadonlyArray<string>): SummaryGenerator;
 }

package/src/ngtsc/shims/src/summary_generator.js

@@ -23,8 +23,13 @@
             this.map = map;
         }
         SummaryGenerator.prototype.getSummaryFileNames = function () { return Array.from(this.map.keys()); };
-        SummaryGenerator.prototype.getOriginalSourceOfShim = function (fileName) { return this.map.get(fileName) || null; };
-        SummaryGenerator.prototype.generate = function (original, genFilePath) {
+        SummaryGenerator.prototype.recognize = function (fileName) { return this.map.has(fileName); };
+        SummaryGenerator.prototype.generate = function (genFilePath, readFile) {
+            var originalPath = this.map.get(genFilePath);
+            var original = readFile(originalPath);
+            if (original === null) {
+                return null;
+            }
             // Collect a list of classes that need to have factory types emitted for them. This list is
             // overly broad as at this point the ts.TypeChecker has not been created and so it can't be used
             // to semantically understand which decorators are Angular decorators. It's okay to output an
@@ -46,7 +51,12 @@
                 varLines.push("export const \u0275empty = null;");
             }
             var sourceText = varLines.join('\n');
-            return ts.createSourceFile(genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);
+            var genFile = ts.createSourceFile(genFilePath, sourceText, original.languageVersion, true, ts.ScriptKind.TS);
+            if (original.moduleName !== undefined) {
+                genFile.moduleName =
+                    util_1.generatedModuleName(original.moduleName, original.fileName, '.ngsummary');
+            }
+            return genFile;
         };
         SummaryGenerator.forRootFiles = function (files) {
             var map = new Map();
@@ -62,4 +72,4 @@
             decl.modifiers.some(function (mod) { return mod.kind == ts.SyntaxKind.ExportKeyword; });
     }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/shims/src/util.d.ts

@@ -7,3 +7,4 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/shims/src/util" />
 export declare function isNonDeclarationTsFile(file: string): boolean;
+export declare function generatedModuleName(originalModuleName: string, originalFileName: string, genSuffix: string): string;

package/src/ngtsc/shims/src/util.js

@@ -22,5 +22,16 @@
         return TS_FILE.exec(file) !== null && D_TS_FILE.exec(file) === null;
     }
     exports.isNonDeclarationTsFile = isNonDeclarationTsFile;
+    function generatedModuleName(originalModuleName, originalFileName, genSuffix) {
+        var moduleName;
+        if (originalFileName.endsWith('/index.ts')) {
+            moduleName = originalModuleName + '/index' + genSuffix;
+        }
+        else {
+            moduleName = originalModuleName + genSuffix;
+        }
+        return moduleName;
+    }
+    exports.generatedModuleName = generatedModuleName;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2Mvc2hpbXMvc3JjL3V0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFFSCxJQUFNLE9BQU8sR0FBRyxTQUFTLENBQUM7SUFDMUIsSUFBTSxTQUFTLEdBQUcsVUFBVSxDQUFDO0lBRTdCLFNBQWdCLHNCQUFzQixDQUFDLElBQVk7UUFDakQsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksSUFBSSxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksQ0FBQztJQUN0RSxDQUFDO0lBRkQsd0RBRUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmNvbnN0IFRTX0ZJTEUgPSAvXFwudHN4PyQvO1xuY29uc3QgRF9UU19GSUxFID0gL1xcLmRcXC50cyQvO1xuXG5leHBvcnQgZnVuY3Rpb24gaXNOb25EZWNsYXJhdGlvblRzRmlsZShmaWxlOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgcmV0dXJuIFRTX0ZJTEUuZXhlYyhmaWxlKSAhPT0gbnVsbCAmJiBEX1RTX0ZJTEUuZXhlYyhmaWxlKSA9PT0gbnVsbDtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/switch/index.js

@@ -19,4 +19,4 @@
     var switch_1 = require("@angular/compiler-cli/src/ngtsc/switch/src/switch");
     exports.ivySwitchTransform = switch_1.ivySwitchTransform;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3N3aXRjaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUVILDRFQUFnRDtJQUF4QyxzQ0FBQSxrQkFBa0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtpdnlTd2l0Y2hUcmFuc2Zvcm19IGZyb20gJy4vc3JjL3N3aXRjaCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vIiwic291cmNlcyI6WyJwYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3N3aXRjaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUVILDRFQUFnRDtJQUF4QyxzQ0FBQSxrQkFBa0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtpdnlTd2l0Y2hUcmFuc2Zvcm19IGZyb20gJy4vc3JjL3N3aXRjaCc7XG4iXX0=