From cdb76aa4f7b7bd7a4c2a526e57c1ea1993158d0d Mon Sep 17 00:00:00 2001
From: Domenic Denicola <d@domenic.me>
Date: Mon, 21 Dec 2015 20:08:04 -0500
Subject: [PATCH] Add <script type="module"> and module
 resolution/fetching/evaluation

This adds support for <script type="module"> for loading JavaScript modules, as well as all the infrastructure necessary for resolving, fetching, parsing, and evaluating module graphs rooted at such <script type="module">s.

Policy decisions encoded here:

- Always use the UTF-8 decoder, ignoring the charset="" attribute or the Content-Type header.
- Always use "cors" fetch mode and "omit" credentials mode, ignoring the crossorigin="" attribute. (I am not so sure on the credentials mode and crossorigin attribute parts of this.)
- Use <script defer>-like semantics: do not execute until parsing is finished, and execute in order. Ignore the async="" attribute (for now?).
- In HostResolveImportedModule:
  - Allow absolute URLs and anything starting with "./" or "../", with the latter being then interpreted as relative URLs. Everything else (e.g. bare specifiers like "jquery") fails for now, and no automatic ".js" is appended.
  - We do a URL parse instead of a basic URL parse, i.e., we allow blob URLs theoretically. (I am not sure about this and happy to change it.)
  - We throw a TypeError as the resolution error. (Honestly I could see arguments for any of EvalError, ReferenceError, SyntaxError, or URIError. Maybe we should repurpose EvalError.)
---
 source | 655 ++++++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 512 insertions(+), 143 deletions(-)

diff --git a/source b/source
index 80698373b28..9ddef6a41ec 100644
--- a/source
+++ b/source
@@ -2821,6 +2821,7 @@ a.setAttribute('href', 'http://example.com/'); // change the content attribute d
        <li><dfn data-noexport="" data-x="concept-request-mode" data-x-href="https://fetch.spec.whatwg.org/#concept-request-mode">mode</dfn>
        <li><dfn data-noexport="" data-x="concept-request-credentials-mode" data-x-href="https://fetch.spec.whatwg.org/#concept-request-credentials-mode">credentials mode</dfn>
        <li><dfn data-noexport="" data-x-href="https://fetch.spec.whatwg.org/#use-url-credentials-flag">use-URL-credentials flag</dfn>
+       <li><dfn data-noexport="" data-x-href="https://fetch.spec.whatwg.org/#unsafe-request-flag">unsafe-request flag</dfn>
        <li><dfn data-noexport="" data-x="concept-request-cache-mode" data-x-href="https://fetch.spec.whatwg.org/#concept-request-cache-mode">cache mode</dfn>
        <li><dfn data-noexport="" data-x="concept-request-redirect-mode" data-x-href="https://fetch.spec.whatwg.org/#concept-request-redirect-mode">redirect mode</dfn>
       </ul>
@@ -2951,12 +2952,15 @@ a.setAttribute('href', 'http://example.com/'); // change the content attribute d
      <li><dfn data-noexport="" data-x-href="https://tc39.github.io/ecma262/#use-strict-directive">Use Strict Directive</dfn>
      <li>The <dfn data-noexport="" data-x="js-prod-Pattern" data-x-href="https://tc39.github.io/ecma262/#prod-Pattern"><i>Pattern</i></dfn> production</li>
      <li>The <dfn data-noexport="" data-x="js-prod-FunctionBody" data-x-href="https://tc39.github.io/ecma262/#prod-FunctionBody"><i>FunctionBody</i></dfn> production</li>
+     <li>The <dfn data-noexport="" data-x-href="https://tc39.github.io/ecma262/#sec-source-text-module-records">Source Text Module Record</dfn> specification type and its <dfn data-noexport="" data-x="js-ModuleEvaluation" data-x-href="https://tc39.github.io/ecma262/#sec-moduleevaluation">ModuleEvaluation</dfn> and <dfn data-noexport="" data-x="js-ModuleDeclarationInstantiation" data-x-href="https://tc39.github.io/ecma262/#sec-moduledeclarationinstantiation">ModuleDeclarationInstantiation</dfn> methods</li>
      <li>The <dfn data-noexport="" data-x="js-EnqueueJob" data-x-href="https://tc39.github.io/ecma262/#sec-enqueuejob">EnqueueJob</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-FunctionCreate" data-x-href="https://tc39.github.io/ecma262/#sec-functioncreate">FunctionCreate</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-GetActiveScriptOrModule" data-x-href="https://tc39.github.io/ecma262/#sec-getactivescriptormodule">GetActiveScriptOrModule</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-HostPromiseRejectionTracker" data-x-href="https://tc39.github.io/ecma262/#sec-host-promise-rejection-tracker">HostPromiseRejectionTracker</dfn> abstract operation</li>
+     <li>The <dfn data-noexport="" data-x="js-HostResolveImportedModule" data-x-href="https://tc39.github.io/ecma262/#sec-hostresolveimportedmodule">HostResolveImportedModule</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-InitializeHostDefinedRealm" data-x-href="https://tc39.github.io/ecma262/#sec-initializehostdefinedrealm">InitializeHostDefinedRealm</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-NewObjectEnvironment" data-x-href="https://tc39.github.io/ecma262/#sec-newobjectenvironment">NewObjectEnvironment</dfn> abstract operation</li>
+     <li>The <dfn data-noexport="" data-x="js-ParseModule" data-x-href="https://tc39.github.io/ecma262/#sec-parsemodule">ParseModule</dfn> abstract operation
      <li>The <dfn data-noexport="" data-x="js-ParseScript" data-x-href="https://tc39.github.io/ecma262/#sec-parse-script">ParseScript</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-ScriptEvaluation" data-x-href="https://tc39.github.io/ecma262/#sec-runtime-semantics-scriptevaluation">ScriptEvaluation</dfn> abstract operation</li>
      <li>The <dfn data-noexport="" data-x="js-ToBoolean" data-x-href="https://tc39.github.io/ecma262/#sec-toboolean">ToBoolean</dfn> abstract operation</li>
@@ -59073,10 +59077,11 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
   <p>When used to include dynamic scripts, the scripts may either be embedded inline or may be
   imported from an external file using the <code data-x="attr-script-src">src</code> attribute. If
-  the language is not that described by "<code data-x="">text/javascript</code>", then the <code
-  data-x="attr-script-type">type</code> attribute must be present, as described below. Whatever
-  language is used, the contents of the <code>script</code> element must conform with the
-  requirements of that language's specification.</p>
+  the language is not that described by "<code data-x="">text/javascript</code>", or if the script
+  represents a JavaScript module, then the <code data-x="attr-script-type">type</code> attribute
+  must be present, as described below. Whatever language is used, the contents of the
+  <code>script</code> element must conform with the requirements of that language's
+  specification.</p>
 
   <p>When used to include data blocks (as opposed to scripts), the data must be embedded inline, the
   format of the data must be given using the <code data-x="attr-script-type">type</code> attribute,
@@ -59085,7 +59090,8 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
   <p>The <dfn><code data-x="attr-script-type">type</code></dfn> attribute gives the language of the
   script or format of the data. If the attribute is present, its value must be a <span>valid MIME
-  type</span>. The <code data-x="">charset</code> parameter must not be specified. The default, which
+  type</span> with no <code data-x="">charset</code> parameter, or an <span>ASCII
+  case-insensitive</span> match for the string "<code data-x="">module</code>". The default, which
   is used if the attribute is absent, is "<code data-x="">text/javascript</code>".</p>
 
   <p>The <dfn><code data-x="attr-script-src">src</code></dfn> attribute, if specified, gives the
@@ -59098,17 +59104,21 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
   <p>The <dfn><code data-x="attr-script-charset">charset</code></dfn> attribute gives the character
   encoding of the external script resource. The attribute must not be specified if the <code
-  data-x="attr-script-src">src</code> attribute is not present. If the attribute is set, its value
-  must be an <span>ASCII case-insensitive</span> match for one of the <span data-x="encoding
+  data-x="attr-script-src">src</code> attribute is not present, or if the <code
+  data-x="attr-script-type">type</code> attribute's value is "<code data-x="">module</code>".
+  (JavaScript modules are always interpreted as UTF-8.) If the attribute is set, its value must be
+  an <span>ASCII case-insensitive</span> match for one of the <span data-x="encoding
   label">labels</span> of an <span>encoding</span>, and must specify the same <span>encoding</span> as
   the <code data-x="">charset</code> parameter of the <span data-x="Content-Type">Content-Type
   metadata</span> of the external file, if any. <ref spec=ENCODING></p>
 
-  <p>The <dfn><code data-x="attr-script-async">async</code></dfn> and <dfn><code data-x="attr-script-defer">defer</code></dfn> attributes are <span data-x="boolean
+  <p>The <dfn><code data-x="attr-script-async">async</code></dfn> and <dfn><code
+  data-x="attr-script-defer">defer</code></dfn> attributes are <span data-x="boolean
   attribute">boolean attributes</span> that indicate how the script should be executed. The <code
-  data-x="attr-script-defer">defer</code> and <code data-x="attr-script-async">async</code> attributes
-  must not be specified if the <code data-x="attr-script-src">src</code> attribute is not
-  present.</p>
+  data-x="attr-script-defer">defer</code> and <code data-x="attr-script-async">async</code>
+  attributes must not be specified if the <code data-x="attr-script-src">src</code> attribute is
+  not present, or if the <code data-x="attr-script-type">type</code> attribute's value is "<code
+  data-x="">module</code>".</p>
 
   <p>There are three possible modes that can be selected using these attributes. If the <code
   data-x="attr-script-async">async</code> attribute is present, then the script will be executed
@@ -59138,8 +59148,9 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
   is the default.</p>
 
   <p>The <dfn><code data-x="attr-script-crossorigin">crossorigin</code></dfn> attribute is a
-  <span>CORS settings attribute</span>. It controls, for scripts that are obtained from other <span
-  data-x="origin">origins</span>, whether error information will be exposed.</p>
+  <span>CORS settings attribute</span>. For scripts that are not JavaScript modules, it controls
+  whether error information will be exposed, when the script is obtained from other <span
+  data-x="origin">origins</span>. JavaScript modules are TODO.</p>
 
 
   <p>The <dfn><code data-x="attr-script-nonce">nonce</code></dfn> attribute represents a
@@ -59284,19 +59295,19 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
     </ul>
 
-    <p>...let <var>the script block's type</var> for this <code>script</code> element be
+    <p>...let <var>the script block's type string</var> for this <code>script</code> element be
     "<code data-x="">text/javascript</code>".</p>
 
     <p>Otherwise, if the <code>script</code> element has a <code
-    data-x="attr-script-type">type</code> attribute, let <var>the script block's type</var> for
-    this <code>script</code> element be the value of that attribute with any leading or trailing
-    sequences of <span data-x="space character">space characters</span> removed.</p> <!--
+    data-x="attr-script-type">type</code> attribute, let <var>the script block's type string</var>
+    for this <code>script</code> element be the value of that attribute with any leading or
+    trailing sequences of <span data-x="space character">space characters</span> removed.</p> <!--
     <span>Strip leading and trailing whitespace</span> from... -->
 
     <p>Otherwise, the element has a non-empty <code data-x="attr-script-language">language</code>
-    attribute; let <var>the script block's type</var> for this <code>script</code> element be the
-    concatenation of the string "<code data-x="">text/</code>" followed by the value of the <code
-    data-x="attr-script-language">language</code> attribute.</p>
+    attribute; let <var>the script block's type string</var> for this <code>script</code> element
+    be the concatenation of the string "<code data-x="">text/</code>" followed by the value of the
+    <code data-x="attr-script-language">language</code> attribute.</p>
     <!-- user agents already support, e.g., type="text/javascript1.3", so we don't have to support
     that separately. -->
 
@@ -59304,9 +59315,22 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
     conforming, and is always ignored if there is a <code data-x="attr-script-type">type</code>
     attribute present.</p>
 
-    <p>Determine whether the <var>the script block's type</var> is an <span>ASCII
-    case-insensitive</span> match for any <span>JavaScript MIME type</span>. If this is not the
-    case, then the user agent must abort these steps at this point. No script is executed.</p>
+    <p>Determine <dfn>the script's type</dfn> as follows:</p>
+
+    <ul>
+
+     <li>If <var>the script block's type string</var> is an <span>ASCII case-insensitive</span>
+     match for any <span>JavaScript MIME type</span>, <span>the script's type</span> is "<code
+     data-x="">legacy</code>".</li>
+
+     <li>If <var>the script block's type string</var> is an <span>ASCII case-insensitive</span>
+     match for the string "<code data-x="">module</code>", <span>the script's type</span> is "<code
+     data-x="">module</code>".</li>
+
+     <li>If neither of the above conditions are true, then the user agent must abort these steps at
+     this point. No script is executed.</li>
+
+    </ul>
 
    </li>
 
@@ -59364,7 +59388,8 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
    <li id="script-processing-for">
 
     <p>If the <code>script</code> element has an <code data-x="attr-script-event">event</code>
-    attribute and a <code data-x="attr-script-for">for</code> attribute, then run these substeps:</p>
+    attribute and a <code data-x="attr-script-for">for</code> attribute, and <span>the script's
+    type</span> is "<code data-x="">legacy</code>", then run these substeps:</p>
 
     <ol>
 
@@ -59402,7 +59427,9 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
     character encoding</var> for this <code>script</code> element be the same as <span
     data-x="document's character encoding">the encoding of the document itself</span>.</p>
 
-    <p class="note">Only one of these two pieces of state is set.</p>
+    <p class="note">Only one of these two pieces of state is set. If <span>the script's type</span>
+    is "<code data-x="">module</code>", and it has a <code data-x="attr-script-src">src</code>
+    attribute, then both pieces of state will be ignored anyway.</p>
 
    </li>
 
@@ -59425,23 +59452,60 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
      <li><p>If the previous step failed, <span>queue a task</span> to <span>fire a simple
      event</span> named <code data-x="event-error">error</code> at the element, and abort these
-     steps.</p></li>
+     steps. Otherwise, let <var>url</var> be the resulting <span>absolute URL</span>.</p></li>
 
-     <li><p>Let <var>request</var> be the result of <span
-     data-x="create a potential-CORS request">creating a potential-CORS request</span> given the
-     resulting <span>absolute URL</span> and the current state of the element's
-     <code data-x="attr-script-crossorigin">crossorigin</code> content attribute.</p></li>
+     <li>
+      <p>Let <dfn>the script's response</dfn> be determined by switching on <span>the script's
+      type</span>:
 
-     <li><p>Set <var>request</var>'s <span data-x="concept-request-client">client</span> to the
-     element's <span>node document</span>'s <code>Window</code> object's <span>environment settings
-     object</span> and <span data-x="concept-request-type">type</span> to "<code
-     data-x="">script</code>".</p></li>
+      <dl class="switch">
+       <dt>"<code data-x="">legacy</code>"</dt>
+       <dd>
+        <ol>
+         <li><p>Let <var>request</var> be the result of <span
+         data-x="create a potential-CORS request">creating a potential-CORS request</span> given
+         <var>url</var> and the current state of the element's <code
+         data-x="attr-script-crossorigin">crossorigin</code> content attribute.</p></li>
+
+         <li><p>Set <var>request</var>'s <span data-x="concept-request-client">client</span> to the
+         element's <span>node document</span>'s <code>Window</code> object's <span>environment
+         settings object</span> and <span data-x="concept-request-type">type</span> to "<code
+         data-x="">script</code>".</p></li>
+
+         <!--FETCH--><li><p>Return the result of <span data-x="concept-fetch">fetching</span>
+         <var>request</var>.</p></li>
+        </ol>
+       </dd>
 
-     <li>
-      <!--FETCH--><p><span data-x="concept-fetch">Fetch</span> <var>request</var>.</p>
+       <dt>"<code data-x="">module</code>"</dt>
+       <dd>
+        <ol>
+         <li><p>Let <var>settings</var> be the element's <span>node document</span>'s
+         <code>Window</code> object's <span>environment settings object</span>.</p></li>
+
+         <li><p>If <var>settings</var>'s <span>module map</span> contains an entry with key
+         <var>url</var>, do not obtain a response.</p></li>
+
+         <li>
+          <p>Otherwise,</p>
+
+          <ol>
+           <li><p>Create an entry in <var>settings</var>'s <span>module map</span> with key
+           <var>url</var> and value "<code data-x="">fetching</code>".</p></li>
+
+           <li><p>Return the result of <span data-x="fetch a module">fetching a module</span> given
+           <var>url</var> and <var>settings</var>.</p></li>
+          </ol>
+         </li>
+        </ol>
+       </dd>
+      </dl>
 
-      <p>The resource obtained in this fashion can be either <span>CORS-same-origin</span> or
-      <span>CORS-cross-origin</span>. This only affects how error reporting happens.</p>
+      <p>When <span>the script's type</span> is "<code data-x="">legacy</code>", the <span
+      data-x="concept-response">response</span> obtained in this fashion can be either
+      <span>CORS-same-origin</span> or <span>CORS-cross-origin</span>. This only affects how error
+      reporting happens. When <span>the script's type</span> is "<code data-x="">module</code>",
+      the resource is always <span>CORS-same-origin</span>.</p>
 
       <p>For performance reasons, user agents may start fetching the script (as defined above) as
       soon as the <code data-x="attr-script-src">src</code> attribute is set, instead, in the hope
@@ -59470,7 +59534,11 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
     <dl class="switch">
 
-     <dt id="script-processing-defer">If the element has a <code data-x="attr-script-src">src</code>
+     <dt id="script-processing-module">If <span>the script's type</span> is "<code
+     data-x="">module</code>"</dt>
+
+     <dt id="script-processing-defer">If <span>the script's type</span> is "<code
+     data-x="">legacy</code>", the element has a <code data-x="attr-script-src">src</code>
      attribute, and the element has a <code data-x="attr-script-defer">defer</code> attribute, and
      the element has been flagged as <span>"parser-inserted"</span>, and the element does not have
      an <code data-x="attr-script-async">async</code> attribute</dt>
@@ -59489,10 +59557,10 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
      </dd>
 
 
-     <dt id="script-processing-parser-inserted">If the element has a <code
-     data-x="attr-script-src">src</code> attribute, and the element has been flagged as
-     <span>"parser-inserted"</span>, and the element does not have an <code
-     data-x="attr-script-async">async</code> attribute</dt>
+     <dt id="script-processing-parser-inserted">If <span>the script's type</span> is "<code
+     data-x="">legacy</code>", the element has a <code data-x="attr-script-src">src</code>
+     attribute, and the element has been flagged as <span>"parser-inserted"</span>, and the element
+     does not have an <code data-x="attr-script-async">async</code> attribute</dt>
 
      <dd>
 
@@ -59507,31 +59575,10 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
      </dd>
 
-
-     <dt id="script-processing-style-delayed">If the element does not have a <code
-     data-x="attr-script-src">src</code> attribute, and the element has been flagged as
-     <span>"parser-inserted"</span>, and either the parser that created the <code>script</code> is
-     an <span>XML parser</span> or it's an <span>HTML parser</span> whose <span>script nesting
-     level</span> is not greater than one, and the <code>Document</code> of the <span>HTML
-     parser</span> or <span>XML parser</span> that created the <code>script</code> element <span>has
-     a style sheet that is blocking scripts</span></dt>
-
-     <dd>
-
-      <p>The element is the <span>pending parsing-blocking script</span> of the
-      <code>Document</code> of the parser that created the element. (There can only be one such
-      script per <code>Document</code> at a time.)</p>
-
-      <p>Set the element's <span>"ready to be parser-executed"</span> flag. The parser will handle
-      executing the script.</p>
-
-     </dd>
-
-
-     <dt id="script-processing-src-sync">If the element has a <code
-     data-x="attr-script-src">src</code> attribute, does not have an <code
-     data-x="attr-script-async">async</code> attribute, and does not have the
-     <span>"non-blocking"</span> flag set</dt>
+     <dt id="script-processing-src-sync">If <span>the script's type</span> is "<code
+     data-x="">legacy</code>", the element has a <code data-x="attr-script-src">src</code>
+     attribute, does not have an <code data-x="attr-script-async">async</code> attribute, and does
+     not have the <span>"non-blocking"</span> flag set</dt>
 
      <dd>
 
@@ -59565,7 +59612,8 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
      </dd>
 
 
-     <dt id="script-processing-src">If the element has a <code data-x="attr-script-src">src</code>
+     <dt id="script-processing-src">If <span>the script's type</span> is "<code
+     data-x="">legacy</code>" and the element has a <code data-x="attr-script-src">src</code>
      attribute</dt>
 
      <dd>
@@ -59582,6 +59630,27 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
      </dd>
 
 
+
+     <dt id="script-processing-style-delayed">If the element does not have a <code
+     data-x="attr-script-src">src</code> attribute, and the element has been flagged as
+     <span>"parser-inserted"</span>, and either the parser that created the <code>script</code> is
+     an <span>XML parser</span> or it's an <span>HTML parser</span> whose <span>script nesting
+     level</span> is not greater than one, and the <code>Document</code> of the <span>HTML
+     parser</span> or <span>XML parser</span> that created the <code>script</code> element <span>has
+     a style sheet that is blocking scripts</span></dt>
+
+     <dd>
+
+      <p>The element is the <span>pending parsing-blocking script</span> of the
+      <code>Document</code> of the parser that created the element. (There can only be one such
+      script per <code>Document</code> at a time.)</p>
+
+      <p>Set the element's <span>"ready to be parser-executed"</span> flag. The parser will handle
+      executing the script.</p>
+
+     </dd>
+
+
      <dt id="script-processing-inline">Otherwise</dt>
 
      <dd>The user agent must <span>immediately</span> <span>execute the script block</span>, even if other
@@ -59625,8 +59694,8 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
    <li>
 
     <p>If the element is flagged as <span>"parser-inserted"</span>, but the element's
-    <span>node document</span> is not the <code>Document</code> of the parser that created the element,
-    then abort these steps.</p>
+    <span>node document</span> is not the <code>Document</code> of the parser that created the
+    element, then abort these steps.</p>
 
    </li>
 
@@ -59636,21 +59705,27 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
     <dl class="switch">
 
-     <dt>If the load resulted in an error (for example a DNS error, or an HTTP 404 error)</dt>
+     <dt>If <span>the script's response</span>'s <span
+     data-x="concept-response-status">status</span> is not an <span>ok status</span></dt>
+
+     <dt>If <span>the script's type</span> is "<code data-x="">module</code>" and <span>the
+     script's response</span>'s <span data-x="concept-response-header-list">header list</span> does
+     not contain a header whose name is `<span>Content-Type</span>` and whose value is an
+     <span>ASCII case-insensitive</span> match for any <span>JavaScript MIME type</span></dt>
 
      <dd><p>Executing the script block must just consist of <span data-x="fire a simple event">firing
      a simple event</span> named <code data-x="event-error">error</code> at the element.</p></dd>
 
-     <dt>If the load was successful</dt>
+     <dt>Otherwise</dt>
 
      <!-- SCRIPT EXEC -->
      <dd>
 
-      <p>Executing the script block must consist of running the following steps. For the purposes of
-      these steps, the script is considered to be from an <i>external file</i> if, while the
-      <span>prepare a script</span> algorithm above was running for this script, the
-      <code>script</code> element had a <code data-x="attr-script-src">src</code> attribute
-      specified.</p>
+      <p>Executing the script block must consist of running the following steps. For the purposes
+      of these steps, the script is considered to be from an <i>external file</i> if <span>the
+      script's response</span> exists, i.e. if while the <span>prepare a script</span> algorithm
+      above was running for this script, the <code>script</code> element had a <code
+      data-x="attr-script-src">src</code> attribute specified.</p>
 
       <ol>
 
@@ -59665,14 +59740,20 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
          <dd>
 
-          <p>The contents of that file, interpreted as a Unicode string, are the script source.</p>
+          <p><span>The script's response</span>'s <span data-x="concept-response-body">body</span>,
+          interpreted as a Unicode string, are the script source.</p>
 
           <p>To obtain the Unicode string, the user agent run the following steps:</p>
 
           <ol>
 
-           <li><p>If the resource's <span data-x="Content-Type">Content Type metadata</span>, if any,
-           specifies a character encoding, and the user agent supports that encoding, then let <var>character encoding</var> be that encoding, and jump to the bottom step in this
+           <li><p>If <span>the script's type</span> is "<code data-x="">module</code>", <span>UTF-8
+           decode</span> <span>the script's response</span>'s <span
+           data-x="concept-response-body">body</span> and abort these steps.</p></li>
+
+           <li><p>If the resource's <span data-x="Content-Type">Content Type metadata</span>, if
+           any, specifies a character encoding, and the user agent supports that encoding, then let
+           <var>character encoding</var> be that encoding, and jump to the bottom step in this
            series of steps.</p></li>
 
            <li><p>If the algorithm above set <var data-x="concept-script-encoding">the script
@@ -59722,10 +59803,10 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
        <li>
 
-        <p>If the script is from an external file, then increment the
-        <span>ignore-destructive-writes counter</span> of the <code>script</code> element's
-        <span>node document</span>. Let <var>neutralised doc</var> be that
-        <code>Document</code>.</p>
+        <p>If the script is from an external file, or <span>the script's type</span> is "<code
+        data-x="">module</code>", then increment the <span>ignore-destructive-writes counter</span>
+        of the <code>script</code> element's <span>node document</span>. Let <var>neutralised
+        doc</var> be that <code>Document</code>.</p>
 
        </li>
 
@@ -59749,9 +59830,9 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
        <li>
 
         <p><span>Create a script</span>, using <var data-x="concept-script-source">the script
-        block's source</var>, the <span>URL</span> from which the script was obtained, and the
-        <span>environment settings object</span> of the <code>script</code> element's <span>node
-        document</span>'s <code>Window</code> object.</p>
+        block's source</var>, the <span>URL</span> from which the script was obtained, <span>the
+        script's type</span>, and the <span>environment settings object</span> of the
+        <code>script</code> element's <span>node document</span>'s <code>Window</code> object.</p>
 
         <p>If the script came from a resource that was fetched in the steps above, and the resource
         was <span>CORS-cross-origin</span>, then pass the <var>muted errors</var> flag to the
@@ -81500,10 +81581,11 @@ State: &lt;OUTPUT NAME=I>1&lt;/OUTPUT> &lt;INPUT VALUE="Increment" TYPE=BUTTON O
 
        <li>
 
-        <p><span>Create a script</span>, using <var>script source</var> as the script
-        source, <var>address</var> as the script source URL, and the <span>environment settings
-        object</span> of the <code>Window</code> object of the <span>active document</span> of the
-        <span>browsing context</span> being navigated.</p>
+        <p><span>Create a script</span>, using <var>script source</var> as the script source,
+        <var>address</var> as the script source URL, a script type of "<code
+        data-x="">legacy</code>", and the <span>environment settings object</span> of the
+        <code>Window</code> object of the <span>active document</span> of the <span>browsing
+        context</span> being navigated.</p>
 
         <p>Let <var>result</var> be the return value of the <span>code entry-point</span>
         of this <span data-x="concept-script">script</span>. If an exception was thrown, let <var>result</var> be void instead. (The result will be void also if <span
@@ -85591,6 +85673,24 @@ interface <dfn>NavigatorOnLine</dfn> {
 
    </dd>
 
+   <dt>A <dfn data-x="script type">type</dfn></dt>
+
+   <dd>
+
+    <p>Either "<code data-x="">legacy</code>" or "<code data-x="">module</code>", indicating how
+    the <span>code entry-point</span> will be parsed and evaluated.</p>
+
+   </dd>
+
+   <dt>A <dfn data-x="script source URL">source URL</dfn></dt>
+
+   <dd>
+
+    <p>A URL from which the script was obtained, used for resolving module specifiers in
+    <span>HostResolveImportedModule</span>.</p>
+
+   </dd>
+
    <dt>Optionally, a <dfn>muted errors</dfn> flag</dt>
 
    <dd>
@@ -85624,11 +85724,23 @@ interface <dfn>NavigatorOnLine</dfn> {
 
     <p>A <span>JavaScript execution context</span> shared by all
     <span data-x="script">scripts</span> that use this settings object, i.e. all scripts in a given
-    realm. When we <span>jump to a code-entry point</span>, this execution context becomes the
-    top of the <span>JavaScript execution context stack</span>, on top of which another execution
-    context specific to the script in question is pushed. (This setup ensures <span
-    data-x="js-ParseScript">ParseScript</span> and <span
-    data-x="js-ScriptEvaluation">ScriptEvaluation</span> knows which Realm to use.)</p>
+    realm. When we <span>jump to a code entry-point</span> or <span>run a module script</span>,
+    this execution context becomes the top of the <span>JavaScript execution context stack</span>,
+    on top of which another execution context specific to the script in question is pushed. (This
+    setup ensures <span data-x="js-ScriptEvaluation">ScriptEvaluation</span> and <span
+    data-x="js-ModuleEvaluation">ModuleEvaluation</span> know which Realm to use.)</p>
+
+   </dd>
+
+   <dt>A <dfn>module map</dfn></dt>
+
+   <dd>
+
+    <p>A map of <span>URL</span>s to <span>Source Text Module Record</span>s, initially empty. It
+    is used to ensure that imported JavaScript modules are only fetched, parsed, and evaluated
+    once. Entries may contain the value "<code data-x="">fetching</code>" instead of a <span>Source
+    Text Module Record</span> as a signal that the module is being fetched.</p>
+
    </dd>
 
    <dt>A <dfn>responsible browsing context</dfn></dt>
@@ -85736,6 +85848,9 @@ interface <dfn>NavigatorOnLine</dfn> {
   <p class="note">This is typically a <code>Window</code> object or a
   <code>WorkerGlobalScope</code> object.</p>
 
+  <p>An <span>environment settings object</span>'s <dfn data-x="environment settings object's
+  Realm">Realm</dfn> is its <span>realm execution context</span>'s Realm component.</p>
+
   <p>The <dfn>relevant settings object for a global object</dfn> <var>o</var> is the
   <span>environment settings object</span> whose <span>global object</span> is <var>o</var>.
   (There is always a 1:1 mapping of global objects to environment settings objects.)</p>
@@ -85863,59 +85978,151 @@ interface <dfn>NavigatorOnLine</dfn> {
    <li><p>Assert: <var>s</var>'s <span>code entry-point</span> is a string of source text; this
    algorithm should never be reached when it is a function.</p></li>
 
-   <li><p><span>Prepare to run a callback</span> with <var>settings</var>. If this returns "do not
-   run" then abort these steps.</p></li>
+   <li><p>Assert: <var>s</var>'s <span data-x="script type">type</span> is "<code
+   data-x="">legacy</code>".
 
-   <li><p>Let <var>result</var> be <span data-x="js-ParseScript">ParseScript</span>(<var>s</var>'s
-   code entry-point, <var>s</var>).</p></li>
+   <li><p><span>Check if we can run a callback</span> with <var>settings</var>. If this returns "do
+   not run" then abort these steps.</p></li>
 
-   <li>
-    <p>If <var>result</var> is a List of errors, then:</p>
+   <li><p>Let <var>realm</var> be <var>settings</var>'s <span
+   data-x="environment settings object's Realm">Realm</span>.</p></li>
 
-    <ol>
-     <li><p>If the <var>rethrow errors</var> flag is set and <var>s</var>'s <var>muted errors</var>
-     flag is not set, rethrow the error given by the first element of <var>result</var>.</p></li>
+   <li><p><span>Prepare to run a callback</span> with <var>settings</var>.</p></li>
 
-     <li><p>If the <var>rethrow errors</var> flag is set and <var>s</var>'s <var>muted
-     errors</var> flag is set, throw a <code>NetworkError</code> exception.</p></li>
+   <li><p>Let <var>result</var> be <span
+   data-x="js-ParseScript">ParseScript</span>(<var>s</var>'s code entry-point, <var>realm</var>,
+   <var>s</var>).</p></li>
 
-     <li><p>If the <var>rethrow errors</var> flag is not set, <span>report the exception</span>
-     given by the first element in <var>result</var> for the script <var>s</var>.</p></li>
-
-     <li><p>In all cases, go to the step labeled <i>cleanup</i>.</p></li>
-    </ol>
-   </li>
+   <li><p>If <var>result</var> is a List of errors, set <var>result</var> to the first element
+   of <var>result</var> and go to the step labeled <i>error</i>.</p></li>
 
-   <li><p>Let <var>status</var> be <span
+   <li><p>Let <var>evaluationStatus</var> be <span
    data-x="js-ScriptEvaluation">ScriptEvaluation</span>(<var>result</var>).</p></li>
 
+   <li><p>If <var>evaluationStatus</var> is an abrupt completion, set <var>result</var> to
+   <var>evaluationStatus</var>.[[value]] and go to the step labeled <i>error</i>.</p></li>
+
+   <li><p>If we have reached this step, skip to the step labeled <i>cleanup</i>.</p></li>
+
    <li>
-    <p>If <var>status</var> is an abrupt completion, then:</p>
+    <p><i>Error</i>: At this point <var>result</var> must be an error object. Perform the following
+    steps:</p>
 
     <ol>
-     <li><p>If the <var>rethrow errors</var> flag is set and <var>s</var>'s <var>muted errors</var>
-     flag is not set, rethrow the error given by <var>result</var>.[[value]].</p></li>
+     <li><p>If the <var>rethrow errors</var> flag is set and <var>s</var>'s <span>muted
+     errors</span> flag is not set, rethrow <var>result</var>.</p></li>
 
-     <li><p>If the <var>rethrow errors</var> flag is set and <var>s</var>'s <var>muted
-     errors</var> flag is set, throw a <code>NetworkError</code> exception.</p></li>
+     <li><p>If the <var>rethrow errors</var> flag is set and <var>s</var>'s <span>muted
+     errors</span> flag is set, throw a <code>NetworkError</code> exception.</p></li>
 
      <li><p>If the <var>rethrow errors</var> flag is not set, <span>report the exception</span>
-     given <var>result</var>.[[value]] for the script <var>s</var>.</p></li>
+     given by <var>result</var> for the script <var>s</var>.</p></li>
     </ol>
    </li>
 
    <li><p><i>Cleanup</i>: <span>Clean up after running a callback</span> with
    <var>settings</var>.</p></li>
 
-   <li><p>If <var>result</var> exists and is not an abrupt completion, return
-   <var>result</var>.[[value]]. Otherwise, script execution was unsuccessful, either because an
-   error occurred during parsing, or an exception occurred during evaluation, or because it was
-   aborted prematurely.</p></li>
+   <li><p>If <var>evaluationStatus</var> exists and is not an abrupt completion, return
+   <var>evaluationStatus</var>.[[value]]. Otherwise, script execution was unsuccessful, either
+   because an error occurred during parsing, or an exception occurred during evaluation, or because
+   it was aborted prematurely.</p></li>
+
+  </ol>
+
+  <p>When a user agent is to <dfn>run a module script</dfn> given a <span
+  data-x="concept-script">script</span> <var>s</var>, the user agent must run the following
+  steps:</p>
+
+  <ol>
+
+   <li><p>Let <var>settings</var> be the <span>settings object</span> of <var>s</var>.</p></li>
+
+   <li><p>Assert: <var>s</var>'s <span>code entry-point</span> is a string of source text; this
+   algorithm should never be reached when it is a function.</p></li>
+
+   <li><p>Assert: <var>s</var>'s <span data-x="script type">type</span> is "<code
+   data-x="">module</code>".</p></li>
+
+   <li><p>Assert: <var>s</var>'s <span>muted errors</span> flag is not set.</p></li>
+
+   <li><p><span>Check if we can run a callback</span> with <var>settings</var>. If this returns "do
+   not run" then abort these steps.</p></li>
+
+   <li><p>Let <var>module map</var> be <var>settings</var>'s <span>module map</span> and let
+   <var>url</var> be <var>s</var>'s <span data-x="script source URL">source URL</span>.</p></li>
+
+   <li>
+    <p>If <var>module map</var> contains an entry with the key <var>url</var> whose value is not
+    "<code data-x="">fetching</code>", <span>perform module evaluation</span> given that value,
+    then abort these steps.</p>
+
+    <p class="note">This can occur if a <code>script</code> element is inserted pointing to a
+    given module that was also encountered in a JavaScript <code data-x="">import</code>
+    statement.</p>
+   </li>
+
+   <li><p>Let <var>realm</var> be <var>settings</var>'s <span
+   data-x="environment settings object's Realm">Realm</span>.</p></li>
+
+   <li><p>Let <var>result</var> be <span
+   data-x="js-ParseModule">ParseModule</span>(<var>s</var>'s code entry-point, <var>realm</var>,
+   <var>s</var>).</p></li>
+
+   <li><p>If <var>result</var> is a List of errors, <span>report the exception</span> given by the
+   first element of <var>result</var>, abort these steps.</p></li>
+
+   <li><p>Otherwise, <var>result</var> is a <span>Source Text Module Record</span>. Create an
+   entry in <var>module map</var> with key <var>url</var> and value <var>result</var>, or if an
+   entry with that key already exists, set its value to <var>result</var>.</p></li>
+
+   <li><p>Return from this algorithm and run the remainder of these steps <span>in
+   parallel</span>.</p></li>
+
+   <li>
+    <p>Let <var>instantiationStatus</var> be <var>result</var>.<span
+    data-x="js-ModuleDeclarationInstantiation">ModuleDeclarationInstantiation</span>().</p>
+
+    <p class="note">This step, via its calls out to <span>HostResolveImportedModule</span>,
+    is what recursively resolves and fetches all of the module's dependencies.</p>
+   </li>
+
+   <li>
+    <p><span>Queue a task</span> to perform the following steps:</p>
+
+    <ol>
+     <li><p>If <var>instantiationStatus</var> is an abrupt completion, <span>report the
+     exception</span> given by <var>instantiationStatus</var>.[[value]].</p></li>
 
+     <li>Otherwise, <span>perform module evaluation</span> for <var>result</var>.</li>
+    </ol>
+   </li>
   </ol>
 
-  <p>The steps to <dfn>prepare to run a callback</dfn> with an <span>environment settings object</span>
-  <var>settings</var> are as follows. They return either "run" or "do not run".</p>
+  <p>To <dfn>perform module evaluation</dfn> given a <span>Source Text Module Record</span>
+  <var>module</var>, run the following steps:</p>
+
+  <ol>
+   <li><p>Let <var>script</var> be <var>module</var>.[[HostDefined]] and let <var>settings</var> be
+   <var>s</var>'s <span>settings object</span>.</p></li>
+
+   <li><p><span>Prepare to run a callback</span> given <var>settings</var>.</p></li>
+
+   <li>
+    <p>Let <var>evaluationStatus</var> be <var>module</var>.<span
+    data-x="js-ModuleEvaluation">ModuleEvaluation</span>().</p>
+
+    <p class="note">This step will recursively evaluate all of the module's dependencies.</p>
+   </li>
+
+   <li><p>If <var>evaluationStatus</var> is an abrupt completion, <span>report the exception</span>
+   given by <var>evaluationStatus</var>.[[value]] for <var>s</var>.</p></li>
+
+   <li><p><span>Clean up after running a callback</span> with <var>settings</var>.</p></li>
+  </ol>
+
+  <p>The steps to <dfn>check if we can run a callback</dfn> with an <span>environment settings
+  object</span> <var>settings</var> are as follows. They return either "run" or "do not run".</p>
 
   <ol>
 
@@ -85927,18 +86134,25 @@ interface <dfn>NavigatorOnLine</dfn> {
    <span>responsible browsing context</span> specified by <var>settings</var>, then return "do
    not run" and abort these steps.</p>
 
+   <li><p>Return "run".</p></li>
+
+  </ol>
+
+  <p>The steps to <dfn>prepare to run a callback</dfn> with an <span>environment settings
+  object</span> <var>settings</var> are as follows:</p>
+
+  <ol>
+
    <li><p>Label <var>settings</var> as a <span>candidate entry settings object</span>.</p></li>
 
    <li><p>Push <var>settings</var>'s <span>realm execution context</span> onto the <span>JavaScript
    execution context stack</span>; it is now the <span>running JavaScript execution
    context</span>.</p></li>
 
-   <li><p>Return "run".</p></li>
-
   </ol>
 
   <p>The steps to <dfn>clean up after running a callback</dfn> with an <span>environment settings
-  object</span> <var>settings</var> are as follows. are as follows:</p>
+  object</span> <var>settings</var> are as follows:</p>
 
   <ol>
 
@@ -86056,9 +86270,9 @@ interface <dfn>NavigatorOnLine</dfn> {
   <h5 id="creating-scripts">Creating scripts</h5>
 
   <p>When the specification says that a <span data-x="concept-script">script</span> is to be <dfn
-  data-x="create a script">created</dfn>, given some script source, a script source URL, an
-  <span>environment settings object</span>, and optionally <var>muted errors</var> and <var>rethrow
-  errors</var> flag, the user agent must run the following steps:</p>
+  data-x="create a script">created</dfn>, given some script source, a script source URL, a script
+  type, an <span>environment settings object</span>, and optionally <var>muted errors</var>
+  and <var>rethrow errors</var> flags, the user agent must run the following steps:</p>
 
   <ol>
 
@@ -86072,14 +86286,31 @@ interface <dfn>NavigatorOnLine</dfn> {
    <li><p>Set <var>script</var>'s <span>code entry-point</span> to the supplied script
    source.</p></li>
 
-   <li><p>Let <var>script</var>'s <span>settings object</span> be the <span>environment
+   <li><p>Set <var>script</var>'s <span>settings object</span> to the <span>environment
    settings object</span> provided.</p></li>
 
+   <li><p>Set <var>script</var>'s <span data-x="script type">type</span> to the supplied script
+   type.</p></li>
+
+   <li><p>Set <var>script</var>'s <span data-x="script source URL">source URL</span> to the
+   supplied script source URL.</p></li>
+
    <li><p>If the <var>muted errors</var> flag was set, then set <var>script</var>'s <span>muted
    errors</span> flag.</p></li>
 
-   <li><p><span data-x="jump to a code entry-point">Jump</span> to <var>script</var>'s <span>code
-   entry-point</span>, passing the <var>rethrow errors</var> flag if it was given.</p></li>
+   <li>
+    <p>Switch on the supplied script type:</p>
+
+    <dl class="switch">
+     <dt>"<code data-x="">legacy</code>"</dt>
+     <dd><p><span data-x="jump to a code entry-point">Jump</span> to <var>script</var>'s <span>code
+     entry-point</span>, passing the <var>rethrow errors</var> flag if it was given.</p></dd>
+
+     <dt>"<code data-x="">module</code>"</dt>
+     <dd><p><span data-x="run a module script">Run the module script</span> given by
+     <var>script</var>.</p></dd>
+    </dl>
+   </li>
 
   </ol>
 
@@ -86150,15 +86381,16 @@ interface <dfn>NavigatorOnLine</dfn> {
   <ol>
    <li><p>Assert: <var>queueName</var> is <code data-x="">"PromiseJobs"</code>. (<code
    data-x="">"ScriptJobs"</code> must not be used by user agents.)</p></li>
-   <li><p>Let <var>settings</var> be the <span>settings object</span> of <span>the script
+   <li><p>Let <var>settings</var> be the <span>settings object</span> of the <span>script
    corresponding to the running execution context</span>.</p></li>
    <li>
     <p><span>Queue a microtask</span>, on <var>settings</var>'s <span>responsible event
     loop</span>, to perform the following steps:</p>
 
     <ol>
-     <li><p><span>Prepare to run a callback</span> with <var>settings</var>. If this returns "do
+     <li><p><span>Check if we can run a callback</span> with <var>settings</var>. If this returns "do
      not run" then abort these steps.</p></li>
+     <li><p><span>Prepare to run a callback</span> with <var>settings</var>.</p></li>
      <li><p>Performing the abstract operation specified by <var>job</var>, using the elements of
      <var>arguments</var> as its arguments.</p></li>
      <li><p><span>Clean up after running a callback</span> with <var>settings</var>.</p></li>
@@ -86181,6 +86413,142 @@ interface <dfn>NavigatorOnLine</dfn> {
   process of actually initiating the next job will be taken care of by the <span>event
   loop</span>.</p>
 
+  <h5>Integration with the JavaScript module system</h5>
+
+  <p>The JavaScript specification defines a syntax for modules, as well as some host-agnostic parts
+  of their processing model. This specification defines the rest of their processing model: how the
+  module system is bootstrapped, via the <code>script</code> element with <code
+  data-x="attr-script-type">type</code> attribute set to "<code data-x="">module</code>", and how
+  modules are fetched, resolved, and executed. <ref spec="ECMA262"></p>
+
+  <p class="note">Although the JavaScript specification speaks in terms of "scripts" versus
+  "modules", in general this specification speaks in terms of "legacy scripts" versus "module
+  scripts", since both of them use the <code>script</code> element.</p>
+
+  <h6><dfn>HostResolveImportedModule</dfn>(<var>referencingModule</var>, <var>specifier</var>)</h6>
+
+  <p>JavaScript contains an implementation-defined <span
+  data-x="js-HostResolveImportedModule">HostResolveImportedModule</span> abstract operation. User
+  agents must use the following implementation. <ref spec="ECMA262"></p>
+
+  <p class="note">This operation is always called either from <span>run a module script</span>, or
+  recursively. This has two important consequences. First, it is always called <span>in
+  parallel</span>, and thus the fetching (or waiting for another ongoing fetch) does not block the
+  event loop. Second, any exceptions thrown by this operation will eventually make their way back
+  to the <span>run a module script</span> algorithm, and via that to <span>report the
+  exception</span>: the "thrown" errors here are not in fact catchable.</p>
+
+  <ol>
+   <li><p>Let <var>referencing script</var> be <var>referencingModule</var>.[[HostDefined]].</p>
+
+   <li><p>Apply the <span>URL parser</span> to <var>specifier</var>. If the result is not failure,
+   let <var>url</var> be the result and go to the step labeled <i>lookup</i>.</p></li>
+
+   <li>
+    <p>If <var>specifier</var> does not start with the two-character sequence U+002E FULL STOP,
+    U+002F SOLIDUS (<code data-x="">./</code>) or the three-character sequence U+002E FULL STOP,
+    U+002E FULL STOP, U+002F SOLIDUS (<code data-x="">../</code>), throw a <code>TypeError</code>
+    exception and abort these steps.</p>
+
+    <p class="note">This restriction is in place so that in the future we can allow custom module
+    loaders to give special meaning to "bare" import specifiers, like <code
+    data-x="">import "jquery"</code> or <code data-x="">import "web/crypto"</code>. For now any
+    such imports will throw, instead of being treated as relative URLs.</p>
+   </li>
+
+   <li><p>Apply the <span>URL parser</span> to <var>specifier</var> with  <var>referencing
+   script</var>'s <span data-x="script source URL">source URL</span> as the base URL. If the result
+   is not failure, let <var>url</var> be the result. If the result is failure, throw a
+   <code>TypeError</code> exception and abort these steps.</p></li>
+
+   <li><p><i>Lookup</i>: Let <var>module map</var> be <var>referencing script</var>'s
+   <span>settings object</span>'s <span>module map</span>.</p></li>
+
+   <li>
+    <p>If <var>module map</var> does not contain an entry with key <var>url</var>:</p>
+
+    <ol>
+     <li><p>Create an entry in <var>module map</var> with key <var>url</var> and value "<code
+     data-x="">fetching</code>".</p></li>
+
+     <li><p>Let <var>response</var> be the result of <span data-x="fetch a module">fetching a
+     module</span> given <var>url</var> and <var>referencing script</var>'s <span>settings
+     object</span>.</p></li>
+
+     <li><p>If <span>response</span>'s <span data-x="concept-response-status">status</span> is not
+     an <span>ok status</span>, throw a <code>NetworkError</code> exception and abort these
+     steps.</p></li>
+
+     <li><p>If <var>response</var>'s <span data-x="concept-response-header-list">header list</span>
+     does not contain a header whose name is `<span>Content-Type</span>` and whose value is an
+     <span>ASCII case-insensitive</span> match for any <span>JavaScript MIME type</span>, throw a
+     <code>NetworkError</code> exception and abort these steps.</p></li>
+
+     <li><p>Let <var>sourceText</var> be the result of <span data-x="UTF-8 decode">UTF-8
+     decoding</span> <var>response</var>'s <span
+     data-x="concept-response-body">body</span>.</p></li>
+
+     <li><p>Let <var>script</var> be a new <span>script</span> with <span>code entry-point</span>
+     <var>sourceText</var>, <span>settings object</span> <var>settings</var>, <span
+     data-x="script type">type</span> "<code data-x="">module</code>", and <span
+     data-x="script source URL">source URL</span> <var>url</var>.</p></li>
+
+     <li><p>Let <var>realm</var> be <var>settings</var>'s <span
+     data-x="environment settings object's Realm">Realm</span>.</p></li>
+
+     <li><p>Let <var>parseResult</var> be <span
+     data-x="js-ParseModule">ParseModule</span>(<var>sourceText</var>, <var>realm</var>,
+     <var>script</var>).</p></li>
+
+     <li><p>If <var>parseResult</var> is a List of errors, rethrow the first error in the List and
+     abort these steps.</p></li>
+
+     <li><p>Set the value of the entry in <var>module map</var> with key <var>url</var> to
+     <var>parseResult</var>.</p></li>
+    </ol>
+   </li>
+
+   <li>
+    <p>If <var>module map</var> contains an entry with key <var>url</var> whose value is "<code
+    data-x="">fetching</code>", wait until the entry's value changes to a <span>Source Text Module
+    Record</span> before proceeding.</p>
+
+    <div class="note">
+     <p>Since this algorithm is always run <span>in parallel</span>, this does not block the event
+     loop.</p>
+
+     <p>It is possible the entry's value will never change from "<code data-x="">fetching</code>";
+     this will be the case if the fetching, parsing, or evaluation of the module fails. That is OK.
+     The error will already have been signaled at its original source, and this call will simply
+     never resolve.</p>
+    </div>
+   </li>
+
+   <!-- If we have got here, it must exist and be a module record. -->
+   <li><p>Return the <span>Source Text Module Record</span> given by the value of the
+   entry in <var>module map</var> with key <var>url</var>.</p></li>
+  </ol>
+
+  <h6>Supporting operations</h6>
+
+  <p>To <dfn>fetch a module</dfn>, given a <var>url</var> and a <var>client</var>, run these
+  steps:</p>
+
+  <ol>
+   <li><p>Let <var>request</var> be a new <span data-x="concept-request">request</span> whose
+   <span data-x="concept-request-url">url</span> is <var>url</var>, <span
+   data-x="concept-request-destination">destination</span> is "<code data-x="">subresource</code>",
+   <span data-x="concept-request-type">type</span> is "<code data-x="">script</code>", <span
+   data-x="concept-request-mode">mode</span> is "<code data-x="">cors</code>", <span
+   data-x="concept-request-credentials-mode">credentials mode</span> is "<code
+   data-x="">omit</code>", <span data-x="concept-request-client">client</span> is
+   <var>client</var>, whose <span>unsafe-request flag</span> is set, and whose
+   <span>use-URL-credentials flag</span> is set.</p></li>
+
+   <li><p><span>Fetch</span> <var>request</var> and return the resulting <span
+   data-x="concept-response">response</span>.</p></li>
+  </ol>
+
   </div>
 
 
@@ -88644,8 +89012,9 @@ interface <dfn>WindowTimers</dfn> {
          object</span>.</p></li>
 
          <li><p><span>Create a script</span> using <var>script source</var> as the script source,
-         the <span>URL</span> where <var>script source</var> can be found, and <var>settings
-         object</var> as the <span>environment settings object</span>.</p></li>
+         the <span>URL</span> where <var>script source</var> can be found, a script type of "<code
+         data-x="">legacy</code>", and <var>settings object</var> as the <span>environment settings
+         object</span>.</p></li>
 
         </ol>
 
@@ -95667,9 +96036,9 @@ interface <dfn>SharedWorker</dfn> : <span>EventTarget</span> {
      <li>
 
       <p><span>Create a script</span> using <var>source</var> as the script source, the
-      <span>URL</span> from which <var>source</var> was obtained, <var>settings object</var> as
-      the <span>environment settings object</span>, and passing the <var>rethrow errors</var>
-      flag.</p>
+      <span>URL</span> from which <var>source</var> was obtained, a script type of "<code
+      data-x="">legacy</code>", <var>settings object</var> as the <span>environment settings
+      object</span>, and passing the <var>rethrow errors</var> flag.</p>
 
       <p>If <var>response</var> is <span>CORS-cross-origin</span>, pass the <var>muted errors</var>
       flag to the <span>create a script</span> algorithm as well.</p>