exports.forEach(e => {
   const basePath = stripExtension(e.from);
   const relativePath = './' + relative(dirname(entryPointBasePath), basePath);
   const exportFrom = entryPointBasePath !== basePath ? ` from '${relativePath}'` : '';
   const exportStr = `\nexport {${e.identifier}}${exportFrom};`;
   output.append(exportStr);
 });

  /**
   * Merge the input and output source-maps, replacing the source-map comment in the output file
   * with an appropriate source-map comment pointing to the merged source-map.
   */
  protected renderSourceAndMap(
      sourceFile: ts.SourceFile, input: SourceMapInfo, output: MagicString): FileInfo[] {
    const outputPath = resolve(this.targetPath, relative(this.sourcePath, sourceFile.fileName));
    const outputMapPath = `${outputPath}.map`;
    const outputMap = output.generateMap({
      source: sourceFile.fileName,
      includeContent: true,
      // hires: true // TODO: This results in accurate but huge sourcemaps. Instead we should fix
      // the merge algorithm.
    });

    // we must set this after generation as magic string does "manipulation" on the path
    outputMap.file = outputPath;

    const mergedMap =
        mergeSourceMaps(input.map && input.map.toObject(), JSON.parse(outputMap.toString()));

    const result: FileInfo[] = [];
    if (input.isInline) {
      result.push({path: outputPath, contents: `${output.toString()}\n${mergedMap.toComment()}`});
    } else {
      result.push({
        path: outputPath,
        contents: `${output.toString()}\n${generateMapFileComment(outputMapPath)}`
      });
      result.push({path: outputMapPath, contents: mergedMap.toJSON()});
    }
    return result;
  }

  renderFile(
      sourceFile: ts.SourceFile, decorationAnalysis: DecorationAnalysis|undefined,
      switchMarkerAnalysis: SwitchMarkerAnalysis|undefined, targetPath: string): FileInfo[] {
    const renderedFiles =
        super.renderFile(sourceFile, decorationAnalysis, switchMarkerAnalysis, targetPath);

    // Transform the `.d.ts` files.
    // TODO(gkalpak): What about `.d.ts` source maps? (See
    // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-9.html#new---declarationmap.)
    if (decorationAnalysis) {
      // Create a `DtsFileTransformer` for the source file and record the generated fields, which
      // will allow the corresponding `.d.ts` file to be transformed later.
      const dtsTransformer = new DtsFileTransformer(this.rewriteCoreImportsTo, IMPORT_PREFIX);
      decorationAnalysis.analyzedClasses.forEach(
          analyzedClass =>
              dtsTransformer.recordStaticField(analyzedClass.name, analyzedClass.compilation));

      // Find the corresponding `.d.ts` file.
      const sourceFileName = sourceFile.fileName;
      const originalDtsFileName = this.dtsMapper.getDtsFileNameFor(sourceFileName);
      const originalDtsContents = readFileSync(originalDtsFileName, 'utf8');

      // Transform the `.d.ts` file based on the recorded source file changes.
      const transformedDtsFileName =
          resolve(this.targetPath, relative(this.sourcePath, originalDtsFileName));
      const transformedDtsContents = dtsTransformer.transform(originalDtsContents, sourceFileName);

      // Add the transformed `.d.ts` file to the list of output files.
      renderedFiles.push({path: transformedDtsFileName, contents: transformedDtsContents});
    }

    return renderedFiles;
  }

 protected updatePackageJson(
     entryPoint: EntryPoint, formatProperty: EntryPointJsonProperty, newDir: AbsoluteFsPath) {
   const bundlePath = entryPoint.packageJson[formatProperty] !;
   const newBundlePath = relative(entryPoint.path, join(newDir, bundlePath));
   (entryPoint.packageJson as any)[formatProperty + '_ivy_ngcc'] = newBundlePath;
   writeFileSync(join(entryPoint.path, 'package.json'), JSON.stringify(entryPoint.packageJson));
 }

 bundle.src.program.getSourceFiles().forEach(sourceFile => {
   if (!sourceFile.isDeclarationFile) {
     const relativePath = relative(entryPointPath, sourceFile.fileName);
     const newFilePath = join(newDir, relativePath);
     mkdir('-p', dirname(newFilePath));
     cp(sourceFile.fileName, newFilePath);
   }
 });

 writeBundle(entryPoint: EntryPoint, bundle: EntryPointBundle, transformedFiles: FileInfo[]) {
   // The new folder is at the root of the overall package
   const relativeEntryPointPath = relative(entryPoint.package, entryPoint.path);
   const relativeNewDir = join(NGCC_DIRECTORY, relativeEntryPointPath);
   const newDir = AbsoluteFsPath.fromUnchecked(join(entryPoint.package, relativeNewDir));
   this.copyBundle(bundle, entryPoint.path, newDir);
   transformedFiles.forEach(file => this.writeFile(file, entryPoint.path, newDir));
   this.updatePackageJson(entryPoint, bundle.formatProperty, newDir);
 }

    program.getSourceFiles().map(sourceFile => {
      const decorationAnalysis = decorationAnalyses.get(sourceFile);
      const switchMarkerAnalysis = switchMarkerAnalyses.get(sourceFile);

      // Transform the source files and source maps.
      if (decorationAnalysis || switchMarkerAnalysis) {
        const targetPath = resolve(this.targetPath, relative(this.sourcePath, sourceFile.fileName));
        renderedFiles.push(
            ...this.renderFile(sourceFile, decorationAnalysis, switchMarkerAnalysis, targetPath));
      }
    });

 protected writeFile(file: FileInfo, entryPointPath: AbsoluteFsPath, newDir: AbsoluteFsPath):
     void {
   if (isDtsPath(file.path.replace(/\.map$/, ''))) {
     // This is either `.d.ts` or `.d.ts.map` file
     super.writeFileAndBackup(file);
   } else {
     const relativePath = relative(entryPointPath, file.path);
     const newFilePath = join(newDir, relativePath);
     mkdir('-p', dirname(newFilePath));
     writeFileSync(newFilePath, file.contents, 'utf8');
   }
 }

    exports.forEach(e => {
      let exportFrom = '';
      const isDtsFile = isDtsPath(entryPointBasePath);
      const from = isDtsFile ? e.dtsFrom : e.from;

      if (from) {
        const basePath = stripExtension(from);
        const relativePath = './' + relative(dirname(entryPointBasePath), basePath);
        exportFrom = entryPointBasePath !== basePath ? ` from '${relativePath}'` : '';
      }

      // aliases should only be added in dts files as these are lost when rolling up dts file.
      const exportStatement = e.alias && isDtsFile ? `${e.alias} as ${e.identifier}` : e.identifier;
      const exportStr = `\nexport {${exportStatement}}${exportFrom};`;
      output.append(exportStr);
    });

 /**
  * Given the absolute path to a source file, return the absolute path to the corresponding `.d.ts`
  * file. Assume that source files and `.d.ts` files have the same directory layout and the names
  * of the `.d.ts` files can be derived by replacing the `.js` extension of the source file with
  * `.d.ts`.
  *
  * @param sourceFileName The absolute path to the source file whose corresponding `.d.ts` file
  *     should be returned.
  *
  * @returns The absolute path to the `.d.ts` file that corresponds to the specified source file.
  */
 getDtsFileNameFor(sourceFileName: string): string {
   const relativeSourcePath = relative(this.sourceRoot, sourceFileName);
   return resolve(this.dtsRoot, relativeSourcePath).replace(/\.js$/, '.d.ts');
 }