function transformEsModuleToAmd(
    script: dom5.Node, idx: number, jsOptions: JsTransformOptions|undefined) {
  // We're not a module anymore.
  dom5.removeAttribute(script, 'type');

  if (scriptWasSplitByHtmlSplitter(script)) {
    // Nothing else to do here. If we're using HtmlSplitter, the JsTransformer
    // is responsible for doing this transformation.
    return;
  }

  const isExternal = dom5.hasAttribute(script, 'src');
  if (isExternal) {
    const src = dom5.getAttribute(script, 'src');
    dom5.removeAttribute(script, 'src');
    dom5.setTextContent(script, `define(['${src}']);`);

  } else {
    // Transform inline scripts with the AMD Babel plugin transformer.
    const newJs = jsTransform(dom5.getTextContent(script), {
      ...jsOptions,
      transformModulesToAmd: true,
      moduleScriptIdx: idx,
    });
    dom5.setTextContent(script, newJs);
  }
}

function transformEsModuleToAmd(
    script: dom5.Node, idx: number, jsOptions: JsTransformOptions|undefined) {
  // We're not a module anymore.
  dom5.removeAttribute(script, 'type');

  if (scriptWasSplitByHtmlSplitter(script)) {
    // Nothing else to do here. If we're using HtmlSplitter, the JsTransformer
    // is responsible for doing this transformation.
    return;
  }

  // Module scripts execute in order. AMD modules don't necessarily preserve
  // this ordering. To emulate the ordering, we construct an artificial
  // dependency chain between all module scripts on the page.
  const generatedModule = generateModuleName(idx);
  const previousGeneratedModule =
      idx === 0 ? undefined : generateModuleName(idx - 1);

  const isExternal = dom5.hasAttribute(script, 'src');
  if (isExternal) {
    const deps = [];
    if (previousGeneratedModule !== undefined) {
      deps.push(previousGeneratedModule);
    }
    const externalSrc = dom5.getAttribute(script, 'src');
    deps.push(externalSrc);
    const depsStr = deps.map((dep) => `'${dep}'`).join(', ');
    dom5.removeAttribute(script, 'src');
    dom5.setTextContent(script, `define('${generatedModule}', [${depsStr}]);`);

  } else {
    // Transform inline scripts with the AMD Babel plugin transformer.
    const newJs = jsTransform(dom5.getTextContent(script), {
      ...jsOptions,
      transformModulesToAmd: true,
      moduleScriptIdx: idx,
    });
    dom5.setTextContent(script, newJs);
  }
}

 !allScripts.some((node) => dom5.hasAttribute(node, 'nomodule'));

export function htmlTransform(
    html: string, options: HtmlTransformOptions): string {
  if (options.js && options.js.moduleResolution === 'node' &&
      !options.js.filePath) {
    throw new Error('Cannot perform node module resolution without filePath.');
  }

  const document = parse5.parse(html, {
    locationInfo: true,  // Required for removeFakeNodes.
  });
  removeFakeNodes(document);
  const allScripts = [...dom5.queryAll(document, isJsScript)];

  const shouldTransformEsModuleToAmd = options.js &&
      options.js.transformModulesToAmd &&
      // Assume that if this document has a nomodule script, the author is
      // already handling browsers that don't support modules, and we don't
      // need to transform them (even if the configuration was set).
      // TODO(aomarks) Check this for HtmlSplitter case too.
      !allScripts.some((node) => dom5.hasAttribute(node, 'nomodule'));

  let wctScript, firstModuleScript, finalModuleScript;
  let moduleScriptIdx = 0;

  for (const script of allScripts) {
    const isModule = dom5.getAttribute(script, 'type') === 'module';
    if (isModule) {
      if (firstModuleScript === undefined) {
        firstModuleScript = script;
      }
      finalModuleScript = script;
      if (shouldTransformEsModuleToAmd) {
        transformEsModuleToAmd(script, moduleScriptIdx++, options.js);
        continue;  // Bypass the standard jsTransform below.
      }
    }

    const isInline = !dom5.hasAttribute(script, 'src');
    if (isInline) {
      // Note that scripts split by HtmlSplitter are always external, so we
      // don't have to check for that case here.
      const newJs = jsTransform(
          dom5.getTextContent(script),
          {...options.js, transformModulesToAmd: false});
      dom5.setTextContent(script, newJs);

    } else if (wctScript === undefined) {
      const src = dom5.getAttribute(script, 'src') || '';
      if (src.includes('web-component-tester/browser.js') ||
          src.includes('wct-browser-legacy/browser.js')) {
        wctScript = script;
      }
    }
  }

  if (shouldTransformEsModuleToAmd && finalModuleScript !== undefined) {
    // We've defined a bunch of modules and chained them together. Now we need
    // to initiate loading the chain by requiring the final one.
    const finalModuleName = generateModuleName(moduleScriptIdx - 1);
    const fragment = parse5.parseFragment(
        `<script>require(['${finalModuleName}']);</script>`);
    dom5.insertAfter(
        finalModuleScript.parentNode!, finalModuleScript, fragment);
  }

  if (options.injectAmdLoader && shouldTransformEsModuleToAmd &&
      firstModuleScript !== undefined) {
    const fragment = parse5.parseFragment('<script></script>\n');
    dom5.setTextContent(fragment.childNodes![0], getMinifiedRequireJs());
    const requireJsScript = fragment.childNodes![0];

    // Inject as late as possible (just before the first module is declared, if
    // there is one) because there may be some UMD dependencies that we want to
    // continue to load in global mode instead of AMD mode (which is detected by
    // the presence of the `require` global).
    dom5.insertBefore(
        firstModuleScript.parentNode!, firstModuleScript, fragment);

    if (wctScript !== undefined) {
      addWctTimingHack(wctScript, requireJsScript);
    }
  }

  if (options.injectBabelHelpers) {
    const fragment = parse5.parseFragment('<script></script>\n');
    dom5.setTextContent(fragment.childNodes![0], getMinifiedBabelHelpers());

    const firstJsScriptOrHtmlImport =
        dom5.query(document, isJsScriptOrHtmlImport);
    if (firstJsScriptOrHtmlImport) {
      dom5.insertBefore(
          firstJsScriptOrHtmlImport.parentNode!,
          firstJsScriptOrHtmlImport,
          fragment);

    } else {
      const headOrDocument =
          dom5.query(document, dom5.predicates.hasTagName('head')) || document;
      dom5.append(headOrDocument, fragment);
    }
//.........这里部分代码省略.........

export function htmlTransform(
    html: string, options: HtmlTransformOptions): string {
  if (options.js && options.js.moduleResolution === 'node' &&
      !options.js.filePath) {
    throw new Error('Cannot perform node module resolution without filePath.');
  }

  const document = parse5.parse(html, {
    locationInfo: true,  // Required for removeFakeNodes.
  });
  removeFakeNodes(document);
  const allScripts = [...dom5.queryAll(document, isJsScript)];

  const shouldTransformEsModuleToAmd = options.js &&
      options.js.transformModulesToAmd &&
      // Assume that if this document has a nomodule script, the author is
      // already handling browsers that don't support modules, and we don't
      // need to transform them (even if the configuration was set).
      // TODO(aomarks) Check this for HtmlSplitter case too.
      !allScripts.some((node) => dom5.hasAttribute(node, 'nomodule'));

  let wctScript, firstModuleScript;

  for (const script of allScripts) {
    const isModule = dom5.getAttribute(script, 'type') === 'module';
    if (isModule) {
      if (firstModuleScript === undefined) {
        firstModuleScript = script;
      }
      if (shouldTransformEsModuleToAmd) {
        transformEsModuleToAmd(script, options.js);
        continue;  // Bypass the standard jsTransform below.
      }
    }

    const isInline = !dom5.hasAttribute(script, 'src');
    if (isInline) {
      // Note that scripts split by HtmlSplitter are always external, so we
      // don't have to check for that case here.
      const newJs = jsTransform(
          dom5.getTextContent(script),
          {...options.js, transformModulesToAmd: false});
      dom5.setTextContent(script, newJs);

    } else if (wctScript === undefined) {
      const src = dom5.getAttribute(script, 'src') || '';
      if (src.includes('web-component-tester/browser.js') ||
          src.includes('wct-browser-legacy/browser.js') ||
          src.includes('wct-mocha/wct-mocha.js')) {
        wctScript = script;
      }
    }
  }

  if (options.injectAmdLoader && shouldTransformEsModuleToAmd &&
      firstModuleScript !== undefined) {
    const fragment = parse5.parseFragment('<script></script>\n');
    dom5.setTextContent(fragment.childNodes![0], externalJs.getAmdLoader());
    const amdLoaderScript = fragment.childNodes![0];

    // Inject as late as possible (just before the first module is declared, if
    // there is one) because there may be some UMD dependencies that we want to
    // continue to load in global mode instead of AMD mode (which is detected by
    // the presence of the `require` global).
    // TODO(aomarks) If we don't define require, we can inject earlier.
    dom5.insertBefore(
        firstModuleScript.parentNode!, firstModuleScript, fragment);

    if (wctScript !== undefined) {
      addWctTimingHack(wctScript, amdLoaderScript);
    }
  }

  const injectScript = (js: string) => {
    const fragment = parse5.parseFragment('<script></script>\n');
    dom5.setTextContent(fragment.childNodes![0], js);

    const firstJsScriptOrHtmlImport =
        dom5.query(document, isJsScriptOrHtmlImport);
    if (firstJsScriptOrHtmlImport) {
      dom5.insertBefore(
          firstJsScriptOrHtmlImport.parentNode!,
          firstJsScriptOrHtmlImport,
          fragment);

    } else {
      const headOrDocument =
          dom5.query(document, dom5.predicates.hasTagName('head')) || document;
      dom5.append(headOrDocument, fragment);
    }
  };

  let babelHelpers;
  switch (options.injectBabelHelpers) {
    case undefined:
    case 'none':
      break;
    case 'full':
      babelHelpers = externalJs.getBabelHelpersFull();
      break;
//.........这里部分代码省略.........