/**
  * Given an import document with a base tag, transform all of its URLs and
  * set link and form target attributes and remove the base tag.
  */
 private _rewriteAstToEmulateBaseTag(ast: ASTNode, docUrl: ResolvedUrl) {
   const baseTag = dom5.query(ast, matchers.base);
   const p = dom5.predicates;
   // If there's no base tag, there's nothing to do.
   if (!baseTag) {
     return;
   }
   for (const baseTag of dom5.queryAll(ast, matchers.base)) {
     removeElementAndNewline(baseTag);
   }
   if (dom5.predicates.hasAttr('href')(baseTag)) {
     const baseUrl = this.bundler.analyzer.urlResolver.resolve(
         docUrl, dom5.getAttribute(baseTag, 'href')! as FileRelativeUrl);
     if (baseUrl) {
       this._rewriteAstBaseUrl(ast, baseUrl, docUrl);
     }
   }
   if (p.hasAttr('target')(baseTag)) {
     const baseTarget = dom5.getAttribute(baseTag, 'target')!;
     const tagsToTarget = dom5.queryAll(
         ast,
         p.AND(
             p.OR(p.hasTagName('a'), p.hasTagName('form')),
             p.NOT(p.hasAttr('target'))));
     for (const tag of tagsToTarget) {
       dom5.setAttribute(tag, 'target', baseTarget);
     }
   }
 }

  test('lazy imports are not moved', async () => {
    const bundler = getBundler();
    const manifest =
        await bundler.generateManifest([resolve('imports/lazy-imports.html')]);
    const {documents} = await bundler.bundle(manifest);

    // The `lazy-imports.html` file has 2 imports in the head of the
    // document.  The first is eager and should be moved.  The remaining
    // one is lazy and should not be moved.
    const entrypointBundle =
        documents.getHtmlDoc(resolve('imports/lazy-imports.html'))!.ast;
    const entrypointLazyImports = dom5.queryAll(
        entrypointBundle,
        preds.AND(preds.parentMatches(matchers.head), matchers.htmlImport));
    assert.equal(entrypointLazyImports.length, 1);
    assert.equal(dom5.getAttribute(entrypointLazyImports[0]!, 'group'), 'one');

    // The shared bundle has an inlined dom-module with an embedded
    // lazy-import via `shared-eager-import-2.html` that we are verifying
    // is preserved.
    const sharedBundle =
        documents.getHtmlDoc(resolve('shared_bundle_1.html'))!.ast;
    const sharedLazyImports = dom5.queryAll(
        sharedBundle,
        preds.AND(
            preds.parentMatches(preds.hasTagName('dom-module')),
            preds.hasTagName('link'),
            preds.hasAttrValue('rel', 'lazy-import')));
    assert.equal(sharedLazyImports.length, 1);
    assert.equal(dom5.getAttribute(sharedLazyImports[0]!, 'group'), 'deeply');
  });

 function assertContainsAndExcludes(
     doc: parse5.ASTNode,
     contains: dom5.Predicate[],
     excludes: dom5.Predicate[]) {
   for (const test of contains) {
     const found = dom5.queryAll(doc, test);
     assert.equal(found.length, 1);
   }
   for (const test of excludes) {
     const found = dom5.queryAll(doc, test);
     assert.equal(found.length, 0);
   }
 }

    test('works for elements', async () => {
      const liTags =
          dom5.queryAll(document.ast, dom5.predicates.hasTagName('li'));

      assert.equal(liTags.length, 4);

      assert.deepEqual(
          await underliner.underline(document.sourceRangeForNode(liTags[0]!)!),
          `
        <li>1
        ~~~~~
        <li>2</li>
~~~~~~~~`);

      assert.deepEqual(
          await underliner.underline(document.sourceRangeForNode(liTags[1]!)!),
          `
        <li>2</li>
        ~~~~~~~~~~`);

      assert.deepEqual(
          await underliner.underline(document.sourceRangeForNode(liTags[2]!)), `
        <li><li>
        ~~~~`);

      assert.deepEqual(
          await underliner.underline(document.sourceRangeForNode(liTags[3]!)), `
        <li><li>
            ~~~~
      </ul>
~~~~~~`);

      const pTags =
          dom5.queryAll(document.ast, dom5.predicates.hasTagName('p'));
      assert.equal(pTags.length, 2);

      assert.deepEqual(
          await underliner.underline(document.sourceRangeForNode(pTags[0]!)), `
    <p>
    ~~~
      This is a paragraph without a closing tag.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    <p>This is a paragraph with a closing tag.</p>
~~~~`);

      assert.deepEqual(
          await underliner.underline(document.sourceRangeForNode(pTags[1]!)), `
    <p>This is a paragraph with a closing tag.</p>
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`);
    });

 /**
  * Replace all external stylesheet references, in `<link rel="stylesheet">`
  * tags with `<style>` tags containing file contents, with internal URLs
  * relatively transposed as necessary.
  */
 private async _inlineStylesheetLinks(ast: ASTNode) {
   const cssLinks = dom5.queryAll(
       ast, matchers.externalStyle, undefined, dom5.childNodesIncludeTemplate);
   for (const cssLink of cssLinks) {
     await this._inlineStylesheet(cssLink);
   }
 }

  _addSharedImportsToShell(bundles: Map<string, string[]>): string {
    console.assert(this.shell != null);
    let shellDeps = bundles.get(this.shell)
        .map((d) => path.relative(path.dirname(this.shell), d));

    let file = this.analyzer.files.get(this.shell);
    console.assert(file != null);
    let contents = file.contents.toString();
    let doc = dom5.parse(contents);
    let imports = dom5.queryAll(doc, dom5.predicates.AND(
      dom5.predicates.hasTagName('link'),
      dom5.predicates.hasAttrValue('rel', 'import')
    ));

    // Remove all imports that are in the shared deps list so that we prefer
    // the ordering or shared deps. Any imports left should be independent of
    // ordering of shared deps.
    let shellDepsSet = new Set(shellDeps);
    for (let _import of imports) {
      if (shellDepsSet.has(dom5.getAttribute(_import, 'href'))) {
        dom5.remove(_import);
      }
    }

    // Append all shared imports to the end of <head>
    let head = dom5.query(doc, dom5.predicates.hasTagName('head'));
    for (let dep of shellDeps) {
      let newImport = dom5.constructors.element('link');
      dom5.setAttribute(newImport, 'rel', 'import');
      dom5.setAttribute(newImport, 'href', dep);
      dom5.append(head, newImport);
    }
    let newContents = dom5.serialize(doc);
    return newContents;
  }

 /**
  * Removes all empty hidden container divs from the AST.
  */
 private _removeEmptyHiddenDivs(ast: ASTNode) {
   for (const div of dom5.queryAll(ast, matchers.hiddenDiv)) {
     if (serialize(div).trim() === '') {
       dom5.remove(div);
     }
   }
 }