test('Base tag emulation should not leak to other imports', async () => {
      const {ast: doc} = await bundle('base.html');
      const clickMe = dom5.query(doc, preds.hasTextValue('CLICK ME'));
      assert.ok(clickMe);

      // The base target from `test/html/imports/base.html` should apply to
      // the anchor tag in it.
      assert.equal(dom5.getAttribute(clickMe!, 'target'), 'foo-frame');

      const doNotClickMe =
          dom5.query(doc, preds.hasTextValue('DO NOT CLICK ME'));
      assert.ok(doNotClickMe);

      // The base target from `test/html/imports/base.html` should NOT apply
      // to the anchor tag in `test/html/imports/base-foo/sub-base.html`
      assert.isFalse(dom5.hasAttribute(doNotClickMe!, 'target'));
    });

  /**
   * 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;
  }