/**
  * Inlines the contents of external module scripts and rolls-up imported
  * modules into inline scripts.
  */
 private async _rollupInlineModuleScripts(ast: ASTNode) {
   this.document = await this._reanalyze(serialize(ast));
   rewriteObject(ast, this.document.parsedDocument.ast);
   dom5.removeFakeRootElements(ast);
   const es6Rewriter =
       new Es6Rewriter(this.bundler, this.manifest, this.assignedBundle);
   const inlineModuleScripts =
       [...this.document.getFeatures({
         kind: 'js-document',
         imported: false,
         externalPackages: true,
         excludeBackreferences: true,
       })].filter(({
                    isInline,
                    parsedDocument: {parsedAsSourceType}
                  }) => isInline && parsedAsSourceType === 'module');
   for (const inlineModuleScript of inlineModuleScripts) {
     const ast = clone(inlineModuleScript.parsedDocument.ast);
     const importResolutions =
         es6Rewriter.getEs6ImportResolutions(inlineModuleScript);
     es6Rewriter.rewriteEs6SourceUrlsToResolved(ast, importResolutions);
     const serializedCode = serializeEs6(ast).code;
     const {code} = await es6Rewriter.rollup(
         this.document.parsedDocument.baseUrl,
         serializedCode,
         inlineModuleScript);
     if (inlineModuleScript.astNode &&
         inlineModuleScript.astNode.language === 'html') {
       // Second argument 'true' tells encodeString to escape the <script>
       // content.
       dom5.setTextContent(
           inlineModuleScript.astNode.node, encodeString(`\n${code}\n`, true));
     }
   }
 }

 /**
  * Inlines the contents of external module scripts and rolls-up imported
  * modules into inline scripts.
  */
 private async _inlineModuleScripts(ast: ASTNode) {
   this.document = await this._reanalyze(serialize(ast));
   rewriteObject(ast, this.document.parsedDocument.ast);
   dom5.removeFakeRootElements(ast);
   const es6Rewriter =
       new Es6Rewriter(this.bundler, this.manifest, this.assignedBundle);
   const inlineModuleScripts =
       [...this.document.getFeatures({
         kind: 'js-document',
         imported: false,
         externalPackages: true,
         excludeBackreferences: true,
       })].filter(({
                    isInline,
                    parsedDocument: {parsedAsSourceType}
                  }) => isInline && parsedAsSourceType === 'module');
   for (const inlineModuleScript of inlineModuleScripts) {
     const {code} = await es6Rewriter.rollup(
         this.document.parsedDocument.baseUrl,
         inlineModuleScript.parsedDocument.contents);
     // Second argument 'true' tells encodeString to escape the <script>
     // content.
     dom5.setTextContent(
         (inlineModuleScript.astNode as any).node,
         encodeString(`\n${code}\n`, true));
   }
 }

  private async processFile(file: File): Promise<File> {
    if (file.path !== this.entrypoint) {
      return file;
    }
    const contents = await getFileContents(file);
    const document = parse5.parse(contents);

    const babelHelpersFragment =
        parse5.parseFragment('\n\n<script></script>\n\n');
    dom5.setTextContent(
        babelHelpersFragment.childNodes![1]!,
        await fs.readFile(
            path.join(__dirname, 'babel-helpers.min.js'), 'utf-8'));

    const firstScriptOrImport = dom5.nodeWalk(document, scriptOrImport);
    if (firstScriptOrImport) {
      dom5.insertBefore(
          firstScriptOrImport.parentNode!,
          firstScriptOrImport,
          babelHelpersFragment);
    } else {
      const head =
          dom5.query(document, dom5.predicates.hasTagName('head')) || document;
      dom5.append(head, babelHelpersFragment);
    }

    const newFile = file.clone();
    newFile.contents = new Buffer(parse5.serialize(document), 'utf-8');
    return newFile;
  }

  inlineScripts.forEach((script) => {
    let content = dom5.getTextContent(script);

    const sourceMapUrlParts = content.match(sourceMappingUrlExpr);
    if (!sourceMapUrlParts) {
      return;
    }
    const sourceMapContentParts =
        sourceMapUrlParts[1].match(inlineSourceMapExpr);
    if (!sourceMapContentParts) {
      return;
    }

    const sourceRange = reparsedDoc.sourceRangeForStartTag(script)!;
    const sourceMap = base64StringToRawSourceMap(sourceMapContentParts[2]);

    const updatedMap = offsetSourceMap(
        sourceMap, sourceRange.end.line, sourceRange.end.column);

    const base64Map = rawSourceMapToBase64String(updatedMap);
    content = content.replace(
        sourceMappingUrlExpr, `${inlineSourcemapPrefix}${base64Map}\n`);

    dom5.setTextContent(script, content);
  });

export function addIndentation(
    textNode: dom5.Node, additionalIndentation = '  ') {
  if (!dom5.isTextNode(textNode)) {
    return;
  }
  const text = dom5.getTextContent(textNode);
  const indentedText =
      text.split('\n')
          .map((line) => {
            return line.length > 0 ? additionalIndentation + line : line;
          })
          .join('\n');
  dom5.setTextContent(textNode, indentedText);
}

  /**
   * Inlines the contents of the document returned by the script tag's src URL
   * into the script tag content and removes the src attribute.
   */
  private async _inlineNonModuleScript(scriptTag: ASTNode) {
    const scriptHref = dom5.getAttribute(scriptTag, 'src')!;
    const resolvedImportUrl = this.bundler.analyzer.urlResolver.resolve(
        this.assignedBundle.url, scriptHref as FileRelativeUrl);
    if (resolvedImportUrl === undefined) {
      return;
    }
    if (this.bundler.excludes.some(
            (e) => resolvedImportUrl === e ||
                resolvedImportUrl.startsWith(ensureTrailingSlash(e)))) {
      return;
    }
    const scriptImport = find(
        this.document.getFeatures(
            {kind: 'html-script', imported: true, externalPackages: true}),
        (i) =>
            i.document !== undefined && i.document.url === resolvedImportUrl);
    if (scriptImport === undefined || scriptImport.document === undefined) {
      this.assignedBundle.bundle.missingImports.add(resolvedImportUrl);
      return;
    }

    let scriptContent = scriptImport.document.parsedDocument.contents;

    if (this.bundler.sourcemaps) {
      // it's easier to calculate offsets if the external script contents
      // don't start on the same line as the script tag. Offset the map
      // appropriately.
      scriptContent = await addOrUpdateSourcemapComment(
          this.bundler.analyzer,
          resolvedImportUrl,
          '\n' + scriptContent,
          -1,
          0,
          1,
          0);
    }

    dom5.removeAttribute(scriptTag, 'src');
    // Second argument 'true' tells encodeString to escape the <script> content.
    dom5.setTextContent(scriptTag, encodeString(scriptContent, true));

    // Record that the inlining took place.
    this.assignedBundle.bundle.inlinedScripts.add(resolvedImportUrl);

    return scriptContent;
  }

 /**
  * Replace all external module script tags:
  * `<script type="module" src="..."></script>`
  * with inline script tags containing import:
  * `<script type="module">import '...';</script>`
  * And these will be subsequently rolled up by call to
  * `this._rollupInlineModuleScripts()`.
  */
 private async _rewriteExternalModuleScriptTagsAsImports(ast: ASTNode) {
   for (const scriptTag of dom5.queryAll(ast, matchers.externalModuleScript)) {
     const scriptHref = dom5.getAttribute(scriptTag, 'src')!;
     const resolvedImportUrl = this.bundler.analyzer.urlResolver.resolve(
         this.document.parsedDocument.baseUrl, scriptHref as FileRelativeUrl);
     if (resolvedImportUrl === undefined) {
       return;
     }
     // We won't inline a module script if its not supposed to be in this
     // bundle.
     if (!this.assignedBundle.bundle.files.has(resolvedImportUrl)) {
       return;
     }
     const scriptContent = `import ${JSON.stringify(resolvedImportUrl)};`;
     dom5.removeAttribute(scriptTag, 'src');
     dom5.setTextContent(scriptTag, encodeString(scriptContent, true));
   }
 }

  /**
   * Find all URLs in imported style nodes and rewrite them so they are based
   * on the relationship of the old base URL to the new base URL.
   */
  private _rewriteStyleTagsBaseUrl(
      ast: ASTNode,
      oldBaseUrl: ResolvedUrl,
      newBaseUrl: ResolvedUrl) {
    const childNodesOption = this.bundler.rewriteUrlsInTemplates ?
        dom5.childNodesIncludeTemplate :
        dom5.defaultChildNodes;

    // If `rewriteUrlsInTemplates` is `true`, include `<style>` tags that are
    // inside `<template>`.
    const styleNodes =
        dom5.queryAll(ast, matchers.styleMatcher, undefined, childNodesOption);

    // Unless rewriteUrlsInTemplates is on, if a `<style>` tag is anywhere
    // inside a `<dom-module>` tag, then it should not have its URLs
    // rewritten.
    if (!this.bundler.rewriteUrlsInTemplates) {
      for (const domModule of dom5.queryAll(
               ast, dom5.predicates.hasTagName('dom-module'))) {
        for (const styleNode of dom5.queryAll(
                 domModule,
                 matchers.styleMatcher,
                 undefined,
                 childNodesOption)) {
          const styleNodeIndex = styleNodes.indexOf(styleNode);
          if (styleNodeIndex > -1) {
            styleNodes.splice(styleNodeIndex, 1);
          }
        }
      }
    }

    for (const node of styleNodes) {
      let styleText = dom5.getTextContent(node);
      styleText =
          this._rewriteCssTextBaseUrl(styleText, oldBaseUrl, newBaseUrl);
      dom5.setTextContent(node, styleText);
    }
  }

  /**
   * Inlines the contents of the stylesheet returned by the link tag's href
   * URL into a style tag and removes the link tag.
   */
  private async _inlineStylesheet(cssLink: ASTNode) {
    const stylesheetHref = dom5.getAttribute(cssLink, 'href')!;
    const resolvedImportUrl = this.bundler.analyzer.urlResolver.resolve(
        this.assignedBundle.url, stylesheetHref as FileRelativeUrl);
    if (resolvedImportUrl === undefined) {
      return;
    }
    if (this.bundler.excludes.some(
            (e) => resolvedImportUrl === e ||
                resolvedImportUrl.startsWith(ensureTrailingSlash(e)))) {
      return;
    }
    const stylesheetImport =  // HACK(usergenic): clang-format workaround
        find(
            this.document.getFeatures(
                {kind: 'html-style', imported: true, externalPackages: true}),
            (i) => i.document !== undefined &&
                i.document.url === resolvedImportUrl) ||
        find(
            this.document.getFeatures(
                {kind: 'css-import', imported: true, externalPackages: true}),
            (i) => i.document !== undefined &&
                i.document.url === resolvedImportUrl);
    if (stylesheetImport === undefined ||
        stylesheetImport.document === undefined) {
      this.assignedBundle.bundle.missingImports.add(resolvedImportUrl);
      return;
    }
    const stylesheetContent = stylesheetImport.document.parsedDocument.contents;
    const media = dom5.getAttribute(cssLink, 'media');

    let newBaseUrl = this.assignedBundle.url;

    // If the css link we are about to inline is inside of a dom-module, the
    // new base URL must be calculated using the assetpath of the dom-module
    // if present, since Polymer will honor assetpath when resolving URLs in
    // `<style>` tags, even inside of `<template>` tags.
    const parentDomModule =
        findAncestor(cssLink, dom5.predicates.hasTagName('dom-module'));
    if (!this.bundler.rewriteUrlsInTemplates && parentDomModule &&
        dom5.hasAttribute(parentDomModule, 'assetpath')) {
      const assetPath = (dom5.getAttribute(parentDomModule, 'assetpath') ||
                         '') as FileRelativeUrl;
      if (assetPath) {
        newBaseUrl =
            this.bundler.analyzer.urlResolver.resolve(newBaseUrl, assetPath)!;
      }
    }
    const resolvedStylesheetContent = this._rewriteCssTextBaseUrl(
        stylesheetContent, resolvedImportUrl, newBaseUrl);
    const styleNode = dom5.constructors.element('style');
    if (media) {
      dom5.setAttribute(styleNode, 'media', media);
    }

    dom5.replace(cssLink, styleNode);
    dom5.setTextContent(styleNode, resolvedStylesheetContent);

    // Record that the inlining took place.
    this.assignedBundle.bundle.inlinedStyles.add(resolvedImportUrl);
    return styleNode;
  }

 .then(updatedContent => {
   dom5.setTextContent(scriptAst, encodeString(updatedContent));
 });