From 9afdf405565635abc68ab8c1f7140afbcd9fa3d6 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.

Some decisions encoded here include:

- Always use the UTF-8 decoder, ignoring the charset="" attribute or the Content-Type header parameter.
- Always use the "cors" fetch mode, and use the crossorigin="" attribute to decide between "omit"/"same-origin"/"include" for the credentials mode.
- Require that the response be served with a JavaScript MIME type for ts Content-Type header.
- Use <script defer>-like semantics by default: do not execute until parsing is finished, and execute in order. The async="" attribute can be used to opt in to an "execute as soon as possible, in any order" semantic. Unlike for classic scripts, in no cases do we block further parsing or script execution until the module tree is finished loading. This applies to both inline and external scripts.
- For module resolution, allow absolute URLs and anything that starts with "./", "../", or "/", with this latter set being interpreted as relative URLs. Everything else (e.g. bare specifiers like "jquery") fails for now. No automatic ".js" is appended.
- Modules are memoized based on their request URL, whereas import specifiers inside the module are resolved based on the module's response URL.

In the course of adding this functionality, large parts of script execution, fetching, and creation were refactored, including moving around some sections and reorganizing others. Conceptually, scripts are now either "classic scripts", "module scripts", or "data blocks". The result should generally be clearer and easier to follow.
---
 images/asyncdefer.svg |  131 ++-
 source                | 1818 +++++++++++++++++++++++++++--------------
 2 files changed, 1293 insertions(+), 656 deletions(-)

diff --git a/images/asyncdefer.svg b/images/asyncdefer.svg
index 80da42c1cf5..8c22fc50bf4 100644
--- a/images/asyncdefer.svg
+++ b/images/asyncdefer.svg
@@ -1,4 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 690 115" width="690" height="115">
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 820 200" width="820" height="200">
   <style><![CDATA[
     .dividers {
       stroke: rgb(106, 148, 0);
@@ -69,12 +69,16 @@
   ]]></style>
 
   <g class="dividers">
-    <line x1="0" x2="690" y1="33.5" y2="33.5" />
-    <line x1="0" x2="690" y1="67.5" y2="67.5" />
-
-    <line x1="135.5" x2="135.5" y1="1" y2="29" />
-    <line x1="135.5" x2="135.5" y1="38" y2="63" />
-    <line x1="135.5" x2="135.5" y1="71" y2="99" />
+    <line x1="0" x2="820" y1="33.5" y2="33.5" />
+    <line x1="0" x2="820" y1="66.5" y2="66.5" />
+    <line x1="0" x2="820" y1="99.5" y2="99.5" />
+    <line x1="0" x2="820" y1="132.5" y2="132.5" />
+
+    <line x1="245.5" x2="245.5" y1="1" y2="29" />
+    <line x1="245.5" x2="245.5" y1="38" y2="62" />
+    <line x1="245.5" x2="245.5" y1="68" y2="95" />
+    <line x1="245.5" x2="245.5" y1="104" y2="128" />
+    <line x1="245.5" x2="245.5" y1="137" y2="165" />
   </g>
 
   <defs>
@@ -89,35 +93,88 @@
     </marker>
   </defs>
 
-  <text x="12" y="16.75" class="tag">&lt;script&gt;</text>
-  <text x="142" y="9" class="label">Scripting:</text>
-  <text x="142" y="24" class="label">HTML Parser:</text>
-  <line x1="399" x2="399" y1="9" y2="24" class="connector" />
-  <line x1="546" x2="546" y1="9" y2="24" class="connector" />
-  <line x1="248" x2="399" y1="24" y2="24" class="parser progress first" />
-  <line x1="399" x2="496" y1="9" y2="9" class="fetch progress" />
-  <line x1="496" x2="546" y1="9" y2="9" class="execution progress" />
-  <line x1="546" x2="674" y1="24" y2="24" class="parser progress last" />
-
-  <text x="12" y="50.25" class="tag">&lt;script defer&gt;</text>
-  <text x="142" y="42" class="label">Scripting:</text>
-  <text x="142" y="57" class="label">HTML Parser:</text>
-  <line x1="626" x2="626" y1="42" y2="57" class="connector" />
-  <line x1="248" x2="626" y1="57" y2="57" class="parser progress first" />
-  <line x1="399" x2="496" y1="42" y2="42" class="fetch progress" />
-  <line x1="626" x2="674" y1="42" y2="42" class="execution progress last" />
-
-  <text x="12" y="84.25" class="tag">&lt;script async&gt;</text>
-  <text x="142" y="76" class="label">Scripting:</text>
-  <text x="142" y="91" class="label">HTML Parser:</text>
-  <line x1="496" x2="496" y1="76" y2="91" class="connector" />
-  <line x1="546" x2="546" y1="76" y2="91" class="connector" />
-  <line x1="248" x2="496" y1="91" y2="91" class="parser progress first" />
-  <line x1="399" x2="496" y1="76" y2="76" class="fetch progress" />
-  <line x1="496" x2="546" y1="76" y2="76" class="execution progress" />
-  <line x1="546" x2="674" y1="91" y2="91" class="parser progress last" />
-
-  <g class="legend" transform="translate(247.5,105.5)">
+  <g>
+    <text x="12" y="16.75" class="tag">&lt;script&gt;</text>
+
+    <g transform="translate(252,0)">
+      <text x="0" y="9" class="label">Scripting:</text>
+      <text x="0" y="24" class="label">HTML Parser:</text>
+      <line x1="257" x2="257" y1="9" y2="24" class="connector" />
+      <line x1="404" x2="404" y1="9" y2="24" class="connector" />
+      <line x1="106" x2="257" y1="24" y2="24" class="parser progress first" />
+      <line x1="257" x2="354" y1="9" y2="9" class="fetch progress" />
+      <line x1="354" x2="404" y1="9" y2="9" class="execution progress" />
+      <line x1="404" x2="532" y1="24" y2="24" class="parser progress last" />
+    </g>
+  </g>
+
+  <g transform="translate(0,33)">
+    <text x="12" y="16.75" class="tag">&lt;script defer&gt;</text>
+
+    <g transform="translate(252,0)">
+      <text x="0" y="9" class="label">Scripting:</text>
+      <text x="0" y="24" class="label">HTML Parser:</text>
+      <line x1="484" x2="484" y1="9" y2="24" class="connector" />
+      <line x1="106" x2="484" y1="24" y2="24" class="parser progress first" />
+      <line x1="257" x2="354" y1="9" y2="9" class="fetch progress" />
+      <line x1="484" x2="532" y1="9" y2="9" class="execution progress last" />
+    </g>
+  </g>
+
+  <g transform="translate(0,66)">
+    <text x="12" y="16.75" class="tag">&lt;script async&gt;</text>
+
+    <g transform="translate(252,0)">
+      <text x="0" y="9" class="label">Scripting:</text>
+      <text x="0" y="24" class="label">HTML Parser:</text>
+      <line x1="354" x2="354" y1="9" y2="24" class="connector" />
+      <line x1="404" x2="404" y1="9" y2="24" class="connector" />
+      <line x1="106" x2="354" y1="24" y2="24" class="parser progress first" />
+      <line x1="257" x2="354" y1="9" y2="9" class="fetch progress" />
+      <line x1="354" x2="404" y1="9" y2="9" class="execution progress" />
+      <line x1="404" x2="532" y1="24" y2="24" class="parser progress last" />
+    </g>
+  </g>
+
+  <g transform="translate(0,99)">
+    <text x="12" y="16.75" class="tag">&lt;script type="module"&gt;</text>
+
+    <g transform="translate(252,0)">
+      <text x="0" y="9" class="label">Scripting:</text>
+      <text x="0" y="24" class="label">HTML Parser:</text>
+      <line x1="484" x2="484" y1="9" y2="24" class="connector" />
+      <line x1="106" x2="484" y1="24" y2="24" class="parser progress first" />
+      <line x1="257" x2="354" y1="9" y2="9" class="fetch progress" />
+      <line x1="354" x2="374" y1="9" y2="9" class="fetch progress" />
+      <line x1="354" x2="374" y1="9" y2="16.5" class="fetch progress" />
+      <line x1="374" x2="394" y1="16.5" y2="16.5" class="fetch progress" />
+      <line x1="394" x2="414" y1="16.5" y2="16.5" class="fetch progress" />
+      <line x1="394" x2="414" y1="16.5" y2="9" class="fetch progress" />
+      <line x1="484" x2="532" y1="9" y2="9" class="execution progress last" />
+    </g>
+  </g>
+
+  <g transform="translate(0,132)">
+    <text x="12" y="16.75" class="tag">&lt;script type="module" async&gt;</text>
+
+    <g transform="translate(252,0)">
+      <text x="0" y="9" class="label">Scripting:</text>
+      <text x="0" y="24" class="label">HTML Parser:</text>
+      <line x1="414" x2="414" y1="9" y2="24" class="connector" />
+      <line x1="464" x2="464" y1="9" y2="24" class="connector" />
+      <line x1="106" x2="414" y1="24" y2="24" class="parser progress first" />
+      <line x1="257" x2="354" y1="9" y2="9" class="fetch progress" />
+      <line x1="354" x2="374" y1="9" y2="9" class="fetch progress" />
+      <line x1="354" x2="374" y1="9" y2="16.5" class="fetch progress" />
+      <line x1="374" x2="394" y1="16.5" y2="16.5" class="fetch progress" />
+      <line x1="394" x2="414" y1="16.5" y2="16.5" class="fetch progress" />
+      <line x1="394" x2="414" y1="16.5" y2="9" class="fetch progress" />
+      <line x1="414" x2="464" y1="9" y2="9" class="execution progress" />
+      <line x1="464" x2="532" y1="24" y2="24" class="parser progress last" />
+    </g>
+  </g>
+
+  <g class="legend" transform="translate(357.5,172)">
     <circle cx="3" cy="3" r="3" class="parser" />
     <text x="9" y="3" class="label">parser</text>
 
@@ -128,5 +185,5 @@
     <text x="96" y="3" class="label">execution</text>
   </g>
 
-  <text x="674" y="108.5" text-anchor="end" class="label">runtime →</text>
+  <text x="782" y="175" text-anchor="end" class="label">runtime →</text>
 </svg>
diff --git a/source b/source
index 27f442a0d79..e7988d0e8b1 100644
--- a/source
+++ b/source
@@ -2784,10 +2784,14 @@ a.setAttribute('href', 'http://example.com/'); // change the content attribute d
 
     <ul class="brief">
      <li><dfn data-noexport=""><code>about:blank</code></dfn>
+     <li><dfn data-noexport="" data-x-href="https://fetch.spec.whatwg.org/#http-cors-protocol">CORS protocol</dfn>
+     <li><dfn data-noexport="" data-x-href="https://fetch.spec.whatwg.org/#concept-header-extract-mime-type">extract a MIME type</dfn>
      <li><dfn data-noexport="" data-x="concept-fetch" data-x-href="https://fetch.spec.whatwg.org/#concept-fetch">fetch</dfn>
      <li><dfn data-noexport="" data-x-href="https://fetch.spec.whatwg.org/#ok-status">ok status</dfn>
      <li>`<dfn data-noexport=""><code data-x="http-origin" data-x-href="https://fetch.spec.whatwg.org/#http-origin">Origin</code></dfn>` header
+     <li><dfn data-noexport="" data-x-href="https://fetch.spec.whatwg.org/#process-response">process response</dfn>
      <li><dfn data-noexport="" data-x="concept-header-list-set" data-x-href="https://fetch.spec.whatwg.org/#concept-header-list-set">set</dfn>
+     <li><dfn data-noexport="" data-x="concept-fetch-terminate" data-x-href="https://fetch.spec.whatwg.org/#concept-fetch-terminate">terminate</dfn>
      <li>
       <dfn data-noexport="" data-x="concept-response" data-x-href="https://fetch.spec.whatwg.org/#concept-response">response</dfn> and its associated:
       <ul class="brief">
@@ -2821,6 +2825,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>
@@ -2949,14 +2954,19 @@ a.setAttribute('href', 'http://example.com/'); // change the content attribute d
      <li><dfn data-noexport="" data-x-href="https://tc39.github.io/ecma262/#running-execution-context">running JavaScript execution context</dfn></li>
      <li><dfn data-noexport="" data-x-href="https://tc39.github.io/ecma262/#sec-code-realms">JavaScript realm</dfn>
      <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="js-prod-Module" data-x-href="https://tc39.github.io/ecma262/#prod-Module"><i>Module</i></dfn> production</li>
+     <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-Script" data-x-href="https://tc39.github.io/ecma262/#prod-Script"><i>Script</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>
@@ -59300,54 +59310,101 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
   their documents. The element does not <span data-x="represents">represent</span> content for the
   user.</p>
 
-  <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>
-
-  <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,
-  the <code data-x="attr-script-src">src</code> attribute must not be specified, and the contents of
-  the <code>script</code> element must conform to the requirements defined for the format used.</p>
-
-  <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
-  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
-  address of the external script resource to use. The value of the attribute must be a <span>valid
-  non-empty URL potentially surrounded by spaces</span> identifying a script resource of the type
-  given by the <code data-x="attr-script-type">type</code> attribute, if the attribute is present, or
-  of the type "<code data-x="">text/javascript</code>", if the attribute is absent. A resource is a
-  script resource of a given type if that type identifies a scripting language and the resource
-  conforms with the requirements of that language's specification.</p>
+  <p>The <dfn><code data-x="attr-script-type">type</code></dfn> attribute allows customization of
+  the type of script represented:</p>
+
+  <ul>
+    <li><p>Omitting the attribute, or setting it to a <span>JavaScript MIME type</span>, means that
+    the script is a <span>classic script</span>, to be interpreted according to the JavaScript <i
+    data-x="js-prod-Script">Script</i> top-level production. Classic scripts are affected by the
+    <code data-x="attr-script-charset">charset</code>, <code
+    data-x="attr-script-async">async</code>, and <code data-x="attr-script-defer">defer</code>
+    attributes. Authors should omit the attribute, instead of redundantly giving a <span>JavaScript
+    MIME type</span>.</p></li>
+
+    <li><p>Setting the attribute to an <span>ASCII case-insensitive</span> match for the string
+    "<code data-x="">module</code>" means that the script is a <span>module script</span>, to be
+    interpreted according to the JavaScript <i data-x="js-prod-Module">Module</i> top-level
+    production. Module scripts are not affected by the <code
+    data-x="attr-script-charset">charset</code> and <code data-x="attr-script-defer">defer</code>
+    attributes.</p></li>
+
+    <li><p>Setting the attribute to any other value means that the script is a <dfn>data
+    block</dfn>, which is not processed. None of the <code>script</code> attributes (except <code
+    data-x="attr-script-type">type</code> itself) have any effect on data blocks. Authors must use
+    a <span>valid MIME type</span> that is not a <span>JavaScript MIME type</span> to denote data
+    blocks.</p></li>
+  </ul>
+
+  <p class="note">The requirement that <span data-x="data block">data blocks</span> must be denoted
+  using a <span>valid MIME type</span> is in place to avoid potential future collisions. If this
+  specification ever adds additional types of <span>script</span>, they will be triggered by
+  setting the <code data-x="attr-script-type">type</code> attribute to something which is not a
+  MIME type, like how the "<code data-x="">module</code>" value denotes <span data-x="module
+  script">module scripts</span>. By using a valid MIME type now, you ensure that your data block
+  will not ever be reinterpreted as a different script type, even in future user agents.</p>
+
+  <p><span data-x="classic script">Classic scripts</span> and <span data-x="module script">module
+  scripts</span> may either be embedded inline or may be imported from an external file using the
+  <dfn><code data-x="attr-script-src">src</code></dfn> attribute, which if specified gives the
+  address of the external script resource to use. If <code data-x="attr-script-src">src</code> is
+  specified, it must be a <span>valid non-empty URL potentially surrounded by spaces</span>. The
+  contents of inline <code>script</code> elements, or the external script resource, must conform
+  with the requirements of the JavaScript specification's <i data-x="js-prod-Script">Script</i> or
+  <i data-x="js-prod-Module">Module</i> productions, for <span data-x="classic script">classic
+  scripts</span> and <span data-x="module script">module scripts</span> respectively. <ref
+  spec="ECMA262"></p>
+
+  <p>When used to include <span data-x="data block">data blocks</span>, 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, and the contents of the <code>script</code>
+  element must conform to the requirements defined for the format used. The <code
+  data-x="attr-script-src">src</code>, <code data-x="attr-script-charset">charset</code>, <code
+  data-x="attr-script-async">async</code>, <code data-x="attr-script-defer">defer</code>, <code
+  data-x="attr-script-crossorigin">crossorigin</code>, and <code
+  data-x="attr-script-nonce">nonce</code> attributes must not be specified.</p>
 
   <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
-  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
+  data-x="attr-script-src">src</code> attribute is not present, or if the script is not a
+  <span>classic script</span>. (<span data-x="module script">Module scripts</span> 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
-  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>
-
-  <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
-  as soon as it is available, but without blocking further parsing of the page. If the <code data-x="attr-script-async">async</code>
-  attribute is not present but the <code data-x="attr-script-defer">defer</code> attribute is
-  present, then the script is executed when the page has finished parsing. If neither attribute is
-  present, then the script is fetched and executed immediately, before the user agent continues
-  parsing the page. This is summarized in the following schematic diagram:</p>
-
-  <p><img src="/images/asyncdefer.svg" style="width: 80%; min-width: 690px;" alt="With &lt;script&gt;, parsing is interrupted by fetching and execution; with &lt;script defer&gt;, fetching is parallel to parsing and execution takes place after all parsing has finished; and with &lt;script async&gt;, fetching is parallel to parsing but once it finishes parsing is interrupted to execute the script."></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
+  attribute">boolean attributes</span> that indicate how the script should be evaluated. <span
+  data-x="classic script">Classic scripts</span> may specify <code
+  data-x="attr-script-defer">defer</code> or <code data-x="attr-script-async">async</code>; <span
+  data-x="module script">module scripts</span> may specify <code
+  data-x="attr-script-async">async</code>.</p>
+
+  <p>There are several possible modes that can be selected using these attributes, and depending on
+  the script's type.</p>
+
+  <p>For <span data-x="classic script">classic scripts</span>, if the <code
+  data-x="attr-script-async">async</code> attribute is present, then the classic script will be
+  fetched <span>in parallel</span> to parsing and evaluated as soon as it is available (potentially
+  before parsing completes). If the <code data-x="attr-script-async">async</code> attribute is not
+  present but the <code data-x="attr-script-defer">defer</code> attribute is present, then the
+  classic script will be fetched <span>in parallel</span> and evaluated when the page has finished
+  parsing. If neither attribute is present, then the script is fetched and evaluated immediately,
+  blocking parsing until these are both complete.</p>
+
+  <p>For <span data-x="module script">module scripts</span>, if the <code
+  data-x="attr-script-async">async</code> attribute is present, then the module script and all its
+  dependencies will be fetched <span>in parallel</span> to parsing, and the module script will
+  be evaluated as soon as it is available (potentially before parsing completes). Otherwise, the
+  module script and its dependencies will be fetched <span>in parallel</span> to parsing and
+  evaluated when the page has finished parsing. (The <code data-x="attr-script-defer">defer</code>
+  attribute has no effect on module scripts.)</p>
+
+  <p>This is all summarized in the following schematic diagram:</p>
+
+  <p><img src="/images/asyncdefer.svg" style="width: 80%; min-width: 820px;" alt="With &lt;script&gt;, parsing is interrupted by fetching and execution. With &lt;script defer&gt;, fetching is parallel to parsing and execution takes place after all parsing has finished. And with &lt;script async&gt;, fetching is parallel to parsing but once it finishes parsing is interrupted to execute the script. The story for &lt;script type=&quot;module&quot;&gt; is similar to &lt;script defer&gt;, but the dependencies will be fetched as well, and the story for &lt;script type=&quot;module&quot; async&gt; is similar to &lt;script async&gt; with the extra dependency fetching."></p>
 
   <p class="note">The exact processing details for these attributes are, for mostly historical
   reasons, somewhat non-trivial, involving a number of aspects of HTML. The implementation
@@ -59367,9 +59424,15 @@ 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 <span data-x="classic script">classic scripts</span>,
+  it controls whether error information will be exposed, when the script is obtained from other <span
+  data-x="origin">origins</span>. For <span data-x="module script">module scripts</span>, it
+  controls the <span data-x="concept-request-credentials-mode">credentials mode</span> used for
+  cross-origin requests.</p>
 
+  <p class="note">Unlike <span data-x="classic script">classic scripts</span>, <span
+  data-x="module script">module scripts</span> require the use of the <span
+  data-x="CORS protocol">CORS protocol</span> for cross-origin fetching.</p>
 
   <p>The <dfn><code data-x="attr-script-nonce">nonce</code></dfn> attribute represents a
   cryptographic nonce ("number used once") which can be used by <cite>Content Security Policy</cite>
@@ -59386,6 +59449,182 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
   <div w-nodev>
 
+  <p>The IDL attributes <dfn><code data-x="dom-script-src">src</code></dfn>, <dfn><code
+  data-x="dom-script-type">type</code></dfn>, <dfn><code
+  data-x="dom-script-charset">charset</code></dfn>, <dfn><code
+  data-x="dom-script-defer">defer</code></dfn>, and <dfn><code
+  data-x="dom-script-nonce">nonce</code></dfn>, must each <span>reflect</span> the respective
+  content attributes of the same name.</p>
+
+  <p>The <dfn><code data-x="dom-script-crossOrigin">crossOrigin</code></dfn> IDL attribute must
+  <span>reflect</span> the <code data-x="attr-script-crossorigin">crossorigin</code> content attribute.</p>
+
+  <p>The <dfn><code data-x="dom-script-async">async</code></dfn> IDL attribute controls whether the
+  element will execute asynchronously or not. If the element's <span>"non-blocking"</span> flag is
+  set, then, on getting, the <code data-x="dom-script-async">async</code> IDL attribute must return
+  true, and on setting, the <span>"non-blocking"</span> flag must first be unset, and then the
+  content attribute must be removed if the IDL attribute's new value is false, and must be set to
+  the empty string if the IDL attribute's new value is true. If the element's
+  <span>"non-blocking"</span> flag is <em>not</em> set, the IDL attribute must <span>reflect</span>
+  the <code data-x="attr-script-async">async</code> content attribute.</p>
+
+  </div>
+
+<!--TOPIC:DOM APIs-->
+  <dl class="domintro">
+
+   <dt><var>script</var> . <code subdfn data-x="dom-script-text">text</code> [ = <var>value</var> ]</dt>
+
+   <dd>
+
+    <p>Returns the contents of the element, ignoring child nodes that aren't <code>Text</code>
+    nodes.</p>
+
+    <p>Can be set, to replace the element's children with the given value.</p>
+
+   </dd>
+
+  </dl>
+
+  <div w-nodev>
+
+  <p>The IDL attribute <dfn><code data-x="dom-script-text">text</code></dfn> must return a
+  concatenation of the contents of all the <code>Text</code> nodes that are children of the
+  <code>script</code> element (ignoring any other nodes such as comments or elements), in tree
+  order. On setting, it must act the same way as the <code>textContent</code> IDL attribute.</p>
+
+  </div>
+<!--TOPIC:HTML-->
+
+  <p class="note">When inserted using the <code data-x="dom-document-write">document.write()</code>
+  method, <code>script</code> elements execute (typically blocking further script execution or HTML parsing), but when inserted using
+  <code data-x="dom-innerHTML">innerHTML</code> and <code data-x="dom-outerHTML">outerHTML</code>
+  attributes, they do not execute at all.</p>
+
+  <div class="example">
+
+   <p>In this example, two <code>script</code> elements are used. One embeds an external
+   <span>classic script</span>, and the other includes some data as a <span>data block</span>.</p>
+
+   <pre>&lt;script src="game-engine.js">&lt;/script>
+&lt;script type="text/x-game-map">
+........U.........e
+o............A....e
+.....A.....AAA....e
+.A..AAA...AAAAA...e
+&lt;/script></pre>
+
+   <p>The data in this case might be used by the script to generate the map of a video game. The
+   data doesn't have to be used that way, though; maybe the map data is actually embedded in other
+   parts of the page's markup, and the data block here is just used by the site's search engine to
+   help users who are looking for particular features in their game maps.</p>
+
+  </div>
+
+  <div class="example">
+
+   <p>The following sample shows how a <code>script</code> element can be used to define a function
+   that is then used by other parts of the document, as part of a <span>classic script</span>. It
+   also shows how a <code>script</code> element can be used to invoke script while the document is
+   being parsed, in this case to initialise the form's output.</p>
+
+   <pre>&lt;script>
+ function calculate(form) {
+   var price = 52000;
+   if (form.elements.brakes.checked)
+     price += 1000;
+   if (form.elements.radio.checked)
+     price += 2500;
+   if (form.elements.turbo.checked)
+     price += 5000;
+   if (form.elements.sticker.checked)
+     price += 250;
+   form.elements.result.value = price;
+ }
+&lt;/script>
+&lt;form name="pricecalc" onsubmit="return false" onchange="calculate(this)">
+ &lt;fieldset>
+  &lt;legend>Work out the price of your car&lt;/legend>
+  &lt;p>Base cost: &pound;52000.&lt;/p>
+  &lt;p>Select additional options:&lt;/p>
+  &lt;ul>
+   &lt;li>&lt;label>&lt;input type=checkbox name=brakes> Ceramic brakes (&pound;1000)&lt;/label>&lt;/li>
+   &lt;li>&lt;label>&lt;input type=checkbox name=radio> Satellite radio (&pound;2500)&lt;/label>&lt;/li>
+   &lt;li>&lt;label>&lt;input type=checkbox name=turbo> Turbo charger (&pound;5000)&lt;/label>&lt;/li>
+   &lt;li>&lt;label>&lt;input type=checkbox name=sticker> "XZ" sticker (&pound;250)&lt;/label>&lt;/li>
+  &lt;/ul>
+  &lt;p>Total: &pound;&lt;output name=result>&lt;/output>&lt;/p>
+ &lt;/fieldset>
+ &lt;script>
+  calculate(document.forms.pricecalc);
+ &lt;/script>
+&lt;/form></pre>
+
+  </div>
+
+  <div class="example">
+
+   <p>The following sample shows how a <code>script</code> element can be used to include an
+   external <span>module script</span>.
+
+   <pre>&lt;script type="module" src="app.js">&lt;/script></pre>
+
+   <p>This module, and all its dependencies (expressed through JavaScript <code
+   data-x="">import</code> statements in the source file), will be fetched. Once the entire
+   resulting module tree has been imported, and the document has finished parsing, the contents of
+   <code data-x="">app.js</code> will be evaluated.</p>
+
+  </div>
+
+  <div class="example">
+
+   <p>The following sample shows how a <code>script</code> element can be used to write an inline
+   <span>module script</span> that performs a number of substitutions on the document's text, in
+   order to make for a more interesting reading experience (e.g. on a news site): <ref
+   spec="XKCD1288"></p>
+
+   <pre>&lt;script type="module">
+ import { walkAllTextNodeDescendants } from "./dom-utils.js";
+
+ const substitutions = new Map([
+   ["witnesses", "these dudes I know"]
+   ["allegedly", "kinda probably"]
+   ["new study", "Tumblr post"]
+   ["rebuild", "avenge"]
+   ["space", "spaaace"]
+   ["Google glass", "Virtual Boy"]
+   ["smartphone", "Pokédex"]
+   ["electric", "atomic"]
+   ["Senator", "Elf-Lord"]
+   ["car", "cat"]
+   ["election", "eating contest"]
+   ["Congressional leaders", "river spirits"]
+   ["homeland security", "Homestar Runner"]
+   ["could not be reached for comment", "is guilty and everyone knows it"]
+ ]);
+
+ function substitute(textNode) {
+   for (const [before, after] of substitutions.entries()) {
+     textNode.data = textNode.data.replace(new RegExp(`\\b${before}\\b`, "ig"), after);
+   }
+ }
+
+ walkAllTextNodeDescendants(document.body, substitute);
+&lt;/script></pre>
+
+   <p>Some notable features gained by using a module script include the ability to import functions
+   from other JavaScript modules, strict mode by default, and how top-level declarations do not
+   introduce new properties onto the <span>global object</span>. Also note that no matter where
+   this <code>script</code> element appears in the document, it will not be evaluated until both
+   document parsing has complete and its dependency (<code data-x="">dom-utils.js</code>) has been
+   fetched and evaluated.</p>
+
+  </div>
+
+  <div w-nodev>
+
+  <h5 id="script-processing-model">Processing model</h5>
+
   <p>A <code>script</code> element has several associated pieces of state.</p>
 
   <p>The first is a flag indicating whether or not the script block has been <dfn>"already
@@ -59399,11 +59638,11 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
   parser</span> and the <span>XML parser</span> on <code>script</code> elements they insert and
   affects the processing of those elements.</p>
 
-  <p>The third is a flag indicating whether the element will <dfn>"non-blocking"</dfn>. Initially,
-  <code>script</code> elements must have this flag set. It is unset by the <span>HTML parser</span>
-  and the <span>XML parser</span> on <code>script</code> elements they insert. In addition, whenever
-  a <code>script</code> element whose <span>"non-blocking"</span> flag is set has a <code
-  data-x="attr-script-async">async</code> content attribute added, the element's
+  <p>The third is a flag indicating whether the element will be <dfn>"non-blocking"</dfn>.
+  Initially, <code>script</code> elements must have this flag set. It is unset by the <span>HTML
+  parser</span> and the <span>XML parser</span> on <code>script</code> elements they insert. In
+  addition, whenever a <code>script</code> element whose <span>"non-blocking"</span> flag is set
+  has an <code data-x="attr-script-async">async</code> content attribute added, the element's
   <span>"non-blocking"</span> flag must be unset.</p> <!-- there's no need to unset it when the
   attribute is removed since you can't have the attribute and the flag set at once. -->
 
@@ -59413,11 +59652,27 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
   that are also <span>"parser-inserted"</span>, to let the parser know when to execute the
   script.</p>
 
-  <p>The last few pieces of state are <dfn><var data-x="concept-script-encoding">the script block's
-  character encoding</var></dfn>, and <dfn><var data-x="concept-script-fallback-encoding">the
-  script block's fallback character encoding</var></dfn>. They are determined when the script is
-  prepared, based on the attributes on the element at that time, and the <code>script</code>
-  element's <span>node document</span>.</p>
+  <p>The fifth is <dfn data-x="concept-script-type">the script's type</dfn>, which is either "<code
+  data-x="">classic</code>" or "<code data-x="">module</code>". It is determined when the script is
+  <span data-x="prepare a script">prepared</span>, based on the <code
+  data-x="attr-script-type">type</code> attribute of the element at that time. Initially,
+  <code>script</code> elements must have this flag unset.</p>
+
+  <p>The sixth is a flag indicating whether or not the script is <dfn
+  data-x="concept-script-external">from an external file</dfn>. It is determined when the script is
+  <span data-x="prepare a script">prepared</span>, based on the <code
+  data-x="attr-script-src">src</code> attribute of the element at that time.</p>
+
+  <p>Finally, a <code>script</code> element has <dfn data-x="concept-script-script">the script's
+  script</dfn>, which is a <span>script</span> resulting from <span data-x="prepare a
+  script">preparing</span> the element. This is set asynchronously after the classic script or
+  module tree is fetched. Once it is set, either to a <span>script</span> in the case of success
+  or to null in the case of failure, the fetching algorithms will note that <dfn>the script is
+  ready</dfn>, which can trigger other actions. <!-- similar text in various places --> The user
+  agent must <span>delay the load event</span> of the element's <span>node document</span> until
+  <span>the script is ready</span>.</p>
+
+  <hr>
 
   <p>When a <code>script</code> element that is not marked as being <span>"parser-inserted"</span>
   experiences one of the events listed in the following list, the user agent must <span>immediately</span>
@@ -59449,7 +59704,7 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
    <li>
 
     <p>If the <code>script</code> element is marked as having <span>"already started"</span>, then
-    the user agent must abort these steps at this point. The script is not executed.</p>
+    abort these steps at this point. The script is not executed.</p>
 
    </li>
 
@@ -59483,15 +59738,15 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
    <li id="script-processing-empty">
 
     <p>If the element has no <code data-x="attr-script-src">src</code> attribute, and its child
-    nodes, if any, consist only of comment nodes and empty <code>Text</code> nodes, then the user
-    agent must abort these steps at this point. The script is not executed.</p>
+    nodes, if any, consist only of comment nodes and empty <code>Text</code> nodes, then abort
+    these steps at this point. The script is not executed.</p>
 
    </li>
 
    <li>
 
-    <p>If the element is not <span>in a <code>Document</code></span>, then the user agent must abort
-    these steps at this point. The script is not executed.</p>
+    <p>If the element is not <span>in a <code>Document</code></span>, then abort these steps at
+    this point. The script is not executed.</p>
 
    </li>
 
@@ -59513,19 +59768,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. -->
 
@@ -59533,9 +59788,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 <span data-x="concept-script-type">the script's type</span> 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 data-x="concept-script-type">the
+     script's type</span> is "<code data-x="">classic</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 data-x="concept-script-type">the
+     script's type</span> is "<code data-x="">module</code>".</li>
+
+     <li>If neither of the above conditions are true, then abort these steps at this point. No
+     script is executed.</li>
+
+    </ul>
 
    </li>
 
@@ -59549,26 +59817,22 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
    <li id="script-processing-start">
 
-    <p>The user agent must set the element's <span>"already started"</span> flag.</p>
-
-    <p class="note">The state of the element at this moment <a
-    href="#establish-script-block-source">is later used</a> to determine the script source.</p>
+    <p>Set the element's <span>"already started"</span> flag.</p>
 
    </li>
 
    <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>
 
    <li id="script-processing-noscript">
 
     <p>If <span data-x="concept-n-noscript">scripting is disabled</span> for the <code>script</code>
-    element, then the user agent must abort these steps at this point. The script is not
-    executed.</p>
+    element, then abort these steps at this point. The script is not executed.</p>
 
     <p class="note">The definition of <span data-x="concept-n-noscript">scripting is disabled</span>
     means that, amongst others, the following scripts will not execute: scripts in
@@ -59587,13 +59851,15 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
    data-x="attr-script-src">src</code> content attribute, and the <span>Should element's inline
    behavior be blocked by Content Security Policy?</span> algorithm returns "<code
    data-x="">Blocked</code>" when executed upon the <code>script</code> element and "<code
-   data-x="">script</code>", then the user agent must abort these steps. The script is not executed.
-   <ref spec="CSP"></p></li>
+   data-x="">script</code>", then abort these steps. The script is not executed. <ref
+   spec="CSP"></p></li>
 
    <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
+    data-x="concept-script-type">the script's type</span> is "<code data-x="">classic</code>", then
+    run these substeps:</p>
 
     <ol>
 
@@ -59607,13 +59873,13 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
      <var>for</var>.</p></li>
 
      <li><p>If <var>for</var> is not an <span>ASCII case-insensitive</span> match for the
-     string "<code data-x="">window</code>", then the user agent must abort these steps at this
-     point. The script is not executed.</p></li>
+     string "<code data-x="">window</code>", then abort these steps at this point. The script is
+     not executed.</p></li>
 
      <li><p>If <var>event</var> is not an <span>ASCII case-insensitive</span> match for
      either the string "<code data-x="">onload</code>" or the string "<code
-     data-x="">onload()</code>", then the user agent must abort these steps at this point. The script
-     is not executed.</p></li>
+     data-x="">onload()</code>", then abort these steps at this point. The script is not
+     executed.</p></li>
 
     </ol>
 
@@ -59622,19 +59888,25 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
    <li id="script-processing-encoding">
 
     <p>If the <code>script</code> element has a <code data-x="attr-script-charset">charset</code>
-    attribute, then let <var data-x="concept-script-encoding">the script block's character
-    encoding</var> for this <code>script</code> element be the result of <span>getting an
-    encoding</span> from the value of the <code data-x="attr-script-charset">charset</code>
-    attribute.</p>
+    attribute, then let <var>encoding</var> be the result of <span>getting an encoding</span> from
+    the value of the <code data-x="attr-script-charset">charset</code> attribute.</p>
 
-    <p>Otherwise, let <var data-x="concept-script-fallback-encoding">the script block's fallback
-    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>If the <code>script</code> element does not have a <code
+    data-x="attr-script-charset">charset</code> attribute, or if <span>getting an encoding</span>
+    failed, let <var>encoding</var> 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">If <span data-x="concept-script-type">the script's type</span> is "<code
+    data-x="">module</code>", this encoding will be ignored.</p>
 
    </li>
 
+   <li><p>Let <var>CORS setting</var> be the current state of the element's <code
+   data-x="attr-script-crossorigin">crossorigin</code> content attribute.</p></li>
+
+   <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 id="script-processing-src-prepare">
 
     <p>If the element has a <code data-x="attr-script-src">src</code> content attribute, run these
@@ -59649,32 +59921,40 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
      a simple event</span> named <code data-x="event-error">error</code> at the element, and abort
      these steps.</p></li>
 
+     <li><p>Set the element's <span data-x="concept-script-external">from an external file</span>
+     flag.</p></li>
+
      <li><p><span data-x="resolve a url">Resolve</span> <var>src</var> relative to the
      element.</p></li>
 
      <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 <span>resulting parsed 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
-     <span>resulting parsed URL</span> and the current state of the element's
-     <code data-x="attr-script-crossorigin">crossorigin</code> content attribute.</p></li>
+     <li>
+      <p>Switch on <span data-x="concept-script-type">the script's type</span>:</p>
 
-     <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="">classic</code>"</dt>
+       <dd>
+        <p><span>Fetch a classic script</span> given <var>url</var>, <var>CORS setting</var>,
+        <var>settings</var>, and <var>encoding</var>.</p>
+       </dd>
 
-     <li>
-      <!--FETCH--><p><span data-x="concept-fetch">Fetch</span> <var>request</var>.</p>
+       <dt>"<code data-x="">module</code>"</dt>
+       <dd>
+        <p><span>Fetch a module script tree</span> given <var>url</var>, <var>CORS setting</var>,
+        and <var>settings</var>.</p>
+       </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 the chosen algorithm asynchronously completes, set <span
+      data-x="concept-script-script">the script's script</span> to the result. At that time,
+      <span>the script is ready</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
-      that the element will be inserted into the document (and that the <code
+      <p>For performance reasons, user agents may start fetching the classic script or module tree
+      (as defined above) as soon as the <code data-x="attr-script-src">src</code> attribute is set,
+      instead, in the hope that the element will be inserted into the document (and that the <code
       data-x="attr-script-crossorigin">crossorigin</code> attribute won't change value in the
       meantime). Either way, once the element is <span data-x="insert an element into a
       document">inserted into the document</span>, the load must have started as described in this
@@ -59691,59 +59971,92 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
    </li>
 
-   <!-- at this point if the element is "parser-inserted" then we know it is not "non-blocking". -->
+   <li id="establish-script-block-source">
 
-   <li>
+    <p>If the element does not have a <code data-x="attr-script-src">src</code> content attribute,
+    run these substeps:</p>
 
-    <p>Then, the first of the following options that describes the situation must be followed:</p>
+    <ol>
+     <li><p>Let <var>source text</var> be the value of the <code
+     data-x="dom-script-text">text</code> IDL attribute.</p></li>
 
-    <dl class="switch">
+     <li>
+      <p>Switch on <span data-x="concept-script-type">the script's type</span>:</p>
 
-     <dt id="script-processing-defer">If 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>
+      <dl class="switch">
+       <dt>"<code data-x="">classic</code>"</dt>
+       <dd>
+        <ol>
+         <li><p>Let <var>script</var> be the result of <span>creating a classic script</span> using
+         <var>source text</var> and <var>settings</var>.</p></li>
 
-     <dd>
+         <li><p>Set <span data-x="concept-script-script">the script's script</span> to
+         <var>script</var>.</p></li>
 
-      <p>The element must be added to the end of the <dfn>list of scripts that will execute when the
-      document has finished parsing</dfn> associated with the <code>Document</code> of the parser
-      that created the element.</p>
+         <li><p><span>The script is ready</span>.</p></li>
+        </ol>
+       </dd>
 
-      <p>The <span data-x="concept-task">task</span> that the <span>networking task source</span>
-      places on the <span>task queue</span> once fetching has completed must set the element's
-      <span>"ready to be parser-executed"</span> flag. The parser will handle executing the
-      script.</p>
+       <dt>"<code data-x="">module</code>"</dt>
+       <dd>
+        <ol>
+         <li><p>Let <var>base URL</var> be the <code>script</code> element's <span>node
+         document</span>'s <span>document base URL</span>.</p></li>
 
-     </dd>
+         <li><p>Let <var>script</var> be the result of <span>creating a module script</span> using
+         <var>source text</var>, <var>settings</var>, <var>base URL</var>, and <var>CORS
+         setting</var>.</p></li>
 
+         <li><p>If this returns null, set <span data-x="concept-script-script">the script's
+         script</span> to null and abort these substeps; <span>the script is ready</span>.</p></li>
 
-     <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
+         <li><p><span data-x="fetch the descendants of a module script">Fetch the
+         descendants</span> of <var>script</var>. When this asynchronously completes, set
+         <span data-x="concept-script-script">the script's script</span> to the result. At that
+         time, <span>the script is ready</span>.</p></li>
+        </ol>
+       </dd>
+      </dl>
+     </li>
+    </ol>
+   </li>
+
+   <!-- at this point if the element is "parser-inserted" then we know it is not "non-blocking". -->
+
+   <li>
+
+    <p>Then, follow the first of the following options that describes the situation:</p>
+
+    <dl class="switch">
+
+     <dt id="script-processing-defer">If <span data-x="concept-script-type">the script's
+     type</span> is "<code data-x="">classic</code>", and 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>
 
+     <dt id="script-processing-module-noasync-parser-inserted">If <span
+     data-x="concept-script-type">the script's type</span> is "<code data-x="">module</code>", 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>
 
-      <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>Add the element to the end of the <dfn>list of scripts that will execute when the document
+      has finished parsing</dfn> associated with the <code>Document</code> of the parser that
+      created the element.</p>
 
-      <p>The <span data-x="concept-task">task</span> that the <span>networking task source</span>
-      places on the <span>task queue</span> once fetching has completed must set the element's
-      <span>"ready to be parser-executed"</span> flag. The parser will handle executing the
-      script.</p>
+      <p>When <span>the script is ready</span>, 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-style-delayed">If the element does not have a <code
+     <dt id="script-processing-parser-inserted">If <span data-x="concept-script-type">the script's
+     type</span> is "<code data-x="">classic</code>", and 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 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>
+     <span>"parser-inserted"</span>, and the element does not have an <code
+     data-x="attr-script-async">async</code> attribute</dt>
 
      <dd>
 
@@ -59751,26 +60064,29 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
       <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>
+      <p>When <span>the script is ready</span>, 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 <span data-x="concept-script-type">the script's
+     type</span> is "<code data-x="">classic</code>", and the element has a <code
+     data-x="attr-script-src">src</code> attribute, and the element does not have an <code
+     data-x="attr-script-async">async</code> attribute, and the element does not have the
+     <span>"non-blocking"</span> flag set</dt>
 
-     <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
+     <dt id="script-processing-module-noasync">If <span data-x="concept-script-type">the script's
+     type</span> is "<code data-x="">module</code>", and the element does not have an <code
+     data-x="attr-script-async">async</code> attribute, and the element does not have the
      <span>"non-blocking"</span> flag set</dt>
 
      <dd>
 
-      <p>The element must be added to the end of the <dfn>list of scripts that will execute in order
-      as soon as possible</dfn> associated with the <span>node document</span> of the <code>script</code>
+      <p>Add the element to the end of the <dfn>list of scripts that will execute in order as soon
+      as possible</dfn> associated with the <span>node document</span> of the <code>script</code>
       element at the time the <span>prepare a script</span> algorithm started.</p>
 
-      <p>The <span data-x="concept-task">task</span> that the <span>networking task source</span>
-      places on the <span>task queue</span> once fetching has completed must run the following
-      steps:</p>
+      <p>When <span>the script is ready</span>, run the following steps:</p>
 
       <ol>
 
@@ -59794,27 +60110,51 @@ 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>
-     attribute</dt>
+     <dt id="script-processing-src">If <span data-x="concept-script-type">the script's type</span>
+     is "<code data-x="">classic</code>", and the element has a <code
+     data-x="attr-script-src">src</code> attribute</dt>
+
+     <dt id="script-processing-module-async">If <span data-x="concept-script-type">the script's
+     type</span> is "<code data-x="">module</code>"</dt>
 
      <dd>
 
       <p>The element must be added to the <dfn>set of scripts that will execute as soon as
-      possible</dfn> of the <span>node document</span> of the <code>script</code> element at the time the
-      <span>prepare a script</span> algorithm started.</p>
+      possible</dfn> of the <span>node document</span> of the <code>script</code> element at the
+      time the <span>prepare a script</span> algorithm started.</p>
 
-      <p>The <span data-x="concept-task">task</span> that the <span>networking task source</span>
-      places on the <span>task queue</span> once fetching has completed must <span>execute the
-      script block</span> and then remove the element from the <span>set of scripts that will
-      execute as soon as possible</span>.</p>
+      <p>When <span>the script is ready</span>, <span>execute the script block</span> and then
+      remove the element from the <span>set of scripts that will execute as soon as
+      possible</span>.</p>
+
+     </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
-     scripts are already executing.</dd>
+     <dd><span>Immediately</span> <span>execute the script block</span>, even if other scripts are
+     already executing.</dd>
 
     </dl>
 
@@ -59822,12 +60162,6 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
   </ol>
 
-  <!-- similar text in various places -->
-  <p>Fetching an external script must <span>delay the load event</span> of the element's <span>node document</span>
-  until the <span data-x="concept-task">task</span> that is <span data-x="queue a task">queued</span>
-  by the <span>networking task source</span> once the resource has been fetched (defined above) has
-  been run.</p>
-
   <p>The <dfn>pending parsing-blocking script</dfn> of a <code>Document</code> is used by the
   <code>Document</code>'s parser(s).</p>
 
@@ -59847,7 +60181,7 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
   defined in terms of which style sheets are blocking which scripts -->
 
   <p>When the user agent is required to <dfn data-x="execute the script block">execute a script
-  block</dfn>, it must run the following steps:</p>
+  block</dfn>, it must run the following steps.</p>
 
   <ol>
 
@@ -59861,293 +60195,117 @@ dictionary <dfn>RelatedEventInit</dfn> : <span>EventInit</span> {
 
    <li>
 
-    <p>Jump to the appropriate set of steps from the list below:</p>
-
-    <dl class="switch">
-
-     <dt>If the load resulted in an error (for example a DNS error, or an HTTP 404 error)</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>
-
-     <!-- 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>
-
-      <ol>
-
-       <li id="establish-script-block-source">
-
-        <p>Initialise <dfn><var data-x="concept-script-source">the script block's source</var></dfn>
-        as follows:</p>
-
-        <dl class="switch">
-
-         <dt>If the script is from an external file</dt>
-
-         <dd>
-
-          <p>The contents of that file, 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
-           series of steps.</p></li>
-
-           <li><p>If the algorithm above set <var data-x="concept-script-encoding">the script
-           block's character encoding</var>, then let <var>character encoding</var> be
-           that encoding, and jump to the bottom step in this series of steps.</p></li>
-
-           <li><p>Let <var>character encoding</var> be <var
-           data-x="concept-script-fallback-encoding">the script block's fallback character
-           encoding</var>.</p></li>
-
-           <li>
-
-            <p><span>Decode</span> the file to Unicode, using <var>character
-            encoding</var> as the fallback encoding.</p>
-
-            <p class="note">The <span>decode</span> algorithm overrides <var>character
-            encoding</var> if the file contains a BOM.</p>
-
-           </li>
-
-          </ol>
-
-         </dd>
-
-         <dt>If the script is inline</dt>
-
-         <dd>
-
-          <p>The value of the <code data-x="dom-script-text">text</code> IDL attribute at the time
-          the element's <span>"already started"</span> flag was last set is the script source.</p>
-
-         </dd>
-
-        </dl>
-
-       </li>
-
-       <li>
-
-        <p><span>Fire a simple event</span> named <code
-        data-x="event-beforescriptexecute">beforescriptexecute</code> that bubbles and is cancelable
-        at the <code>script</code> element.</p>
-
-        <p>If the event is canceled, then abort these steps.</p>
-
-       </li>
-
-       <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>
-
-       </li>
-
-       <li>
-
-        <p>Let <var>old script element</var> be the value to which the <code>script</code>
-        element's <span>node document</span>'s <code
-        data-x="dom-document-currentScript">currentScript</code> object was most recently
-        initialised.</p>
-
-       </li>
-
-       <li>
-
-        <p>Initialise the <code>script</code> element's <span>node document</span>'s <code
-        data-x="dom-document-currentScript">currentScript</code> object to the <code>script</code>
-        element.</p>
+    <p>If <span data-x="concept-script-script">the script's script</span> is null, <span>fire a
+    simple event</span> named <code data-x="event-error">error</code> at the element, and abort
+    these steps.</p>
 
-       </li>
+   </li>
 
-       <li>
+   <!-- SCRIPT EXEC -->
 
-        <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>
+   <li>
 
-        <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
-        <span>create a script</span> algorithm as well.</p>
+    <p><span>Fire a simple event</span> named <code
+    data-x="event-beforescriptexecute">beforescriptexecute</code> that bubbles and is cancelable
+    at the <code>script</code> element.</p>
 
-        <p class="note">This is where the script is compiled and actually executed.</p>
+    <p>If the event is canceled, then abort these steps.</p>
 
-       </li>
+   </li>
 
-       <li>
+   <li>
 
-        <p>Initialise the <code>script</code> element's <span>node document</span>'s <code
-        data-x="dom-document-currentScript">currentScript</code> object to <var>old script
-        element</var>.</p>
+    <p>If the script is <span data-x="concept-script-external">from an external file</span>, or
+    <span data-x="concept-script-type">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>
+   </li>
 
-       <li>
+   <li>
 
-        <p>Decrement the <span>ignore-destructive-writes counter</span> of <var>neutralised doc</var>, if it was incremented in the earlier step.</p>
+    <p>Let <var>old script element</var> be the value to which the <code>script</code>
+    element's <span>node document</span>'s <code
+    data-x="dom-document-currentScript">currentScript</code> object was most recently
+    initialised.</p>
 
-       </li>
+   </li>
 
-       <li>
+   <li>
 
-        <p><span>Fire a simple event</span> named <code
-        data-x="event-afterscriptexecute">afterscriptexecute</code> that bubbles (but is not
-        cancelable) at the <code>script</code> element.</p>
+    <p>Initialise the <code>script</code> element's <span>node document</span>'s <code
+    data-x="dom-document-currentScript">currentScript</code> object to the <code>script</code>
+    element.</p>
 
-       </li>
+   </li>
 
-       <li>
+   <li>
 
-        <p>If the script is from an external file, <span>fire a simple event</span> named <code
-        data-x="event-load">load</code> at the <code>script</code> element.</p>
+    <p>Let <var>settings object</var> be the <span>environment settings object</span> of the
+    <code>script</code> element's <span>node document</span>'s <code>Window</code> object.</p>
 
-        <p>Otherwise, the script is internal; <span>queue a task</span> to <span>fire a simple
-        event</span> named <code data-x="event-load">load</code> at the <code>script</code>
-        element.</p>
+   </li>
 
-       </li>
+   <li>
 
-      </ol>
+    <p>Switch on <span data-x="concept-script-type">the script's type</span>:</p>
 
+    <dl class="switch">
+     <dt>"<code data-x="">classic</code>"</dt>
+     <dd>
+      <p><span data-x="run a classic script">Run the classic script</span> given by <span
+      data-x="concept-script-script">the script's script</span>.</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 <span
+      data-x="concept-script-script">the script's script</span>.</p>
+     </dd>
     </dl>
 
    </li>
 
-  </ol>
-
-  <p>The IDL attributes <dfn><code data-x="dom-script-src">src</code></dfn>, <dfn><code
-  data-x="dom-script-type">type</code></dfn>, <dfn><code
-  data-x="dom-script-charset">charset</code></dfn>, <dfn><code
-  data-x="dom-script-defer">defer</code></dfn>, and <dfn><code
-  data-x="dom-script-nonce">nonce</code></dfn>, must each <span>reflect</span> the respective
-  content attributes of the same name.</p>
-
-  <p>The <dfn><code data-x="dom-script-crossOrigin">crossOrigin</code></dfn> IDL attribute must
-  <span>reflect</span> the <code data-x="attr-script-crossorigin">crossorigin</code> content attribute.</p>
-
-  <p>The <dfn><code data-x="dom-script-async">async</code></dfn> IDL attribute controls whether the
-  element will execute asynchronously or not. If the element's <span>"non-blocking"</span> flag is
-  set, then, on getting, the <code data-x="dom-script-async">async</code> IDL attribute must return
-  true, and on setting, the <span>"non-blocking"</span> flag must first be unset, and then the
-  content attribute must be removed if the IDL attribute's new value is false, and must be set to
-  the empty string if the IDL attribute's new value is true. If the element's
-  <span>"non-blocking"</span> flag is <em>not</em> set, the IDL attribute must <span>reflect</span>
-  the <code data-x="attr-script-async">async</code> content attribute.</p>
-
-  </div>
-
-<!--TOPIC:DOM APIs-->
-  <dl class="domintro">
-
-   <dt><var>script</var> . <code subdfn data-x="dom-script-text">text</code> [ = <var>value</var> ]</dt>
-
-   <dd>
-
-    <p>Returns the contents of the element, ignoring child nodes that aren't <code>Text</code>
-    nodes.</p>
-
-    <p>Can be set, to replace the element's children with the given value.</p>
-
-   </dd>
+   <li>
 
-  </dl>
+    <p>Initialise the <code>script</code> element's <span>node document</span>'s <code
+    data-x="dom-document-currentScript">currentScript</code> object to <var>old script
+    element</var>.</p>
 
-  <div w-nodev>
+   </li>
 
-  <p>The IDL attribute <dfn><code data-x="dom-script-text">text</code></dfn> must return a
-  concatenation of the contents of all the <code>Text</code> nodes that are children of the
-  <code>script</code> element (ignoring any other nodes such as comments or elements), in tree
-  order. On setting, it must act the same way as the <code>textContent</code> IDL attribute.</p>
+   <li>
 
-  </div>
-<!--TOPIC:HTML-->
+    <p>Decrement the <span>ignore-destructive-writes counter</span> of <var>neutralised doc</var>, if it was incremented in the earlier step.</p>
 
-  <p class="note">When inserted using the <code data-x="dom-document-write">document.write()</code>
-  method, <code>script</code> elements execute (typically blocking further script execution or HTML parsing), but when inserted using
-  <code data-x="dom-innerHTML">innerHTML</code> and <code data-x="dom-outerHTML">outerHTML</code>
-  attributes, they do not execute at all.</p>
+   </li>
 
-  <div class="example">
+   <li>
 
-   <p>In this example, two <code>script</code> elements are used. One embeds an external script, and
-   the other includes some data.</p>
+    <p><span>Fire a simple event</span> named <code
+    data-x="event-afterscriptexecute">afterscriptexecute</code> that bubbles (but is not
+    cancelable) at the <code>script</code> element.</p>
 
-   <pre>&lt;script src="game-engine.js">&lt;/script>
-&lt;script type="text/x-game-map">
-........U.........e
-o............A....e
-.....A.....AAA....e
-.A..AAA...AAAAA...e
-&lt;/script></pre>
+   </li>
 
-   <p>The data in this case might be used by the script to generate the map of a video game. The
-   data doesn't have to be used that way, though; maybe the map data is actually embedded in other
-   parts of the page's markup, and the data block here is just used by the site's search engine to
-   help users who are looking for particular features in their game maps.</p>
+   <li>
 
-  </div>
+    <p>If <span>the script's type</span> is "<code data-x="">classic</code>" and the script is
+    <span data-x="concept-script-external">from an external file</span>, <span>fire a simple
+    event</span> named <code data-x="event-load">load</code> at the <code>script</code>
+    element.</p>
 
-  <div class="example">
+    <p>Otherwise <span>queue a task</span> to <span>fire a simple event</span> named <code
+    data-x="event-load">load</code> at the <code>script</code> element.</p>
 
-   <p>The following sample shows how a script element can be used to define a function that is then
-   used by other parts of the document. It also shows how a <code>script</code> element can be used
-   to invoke script while the document is being parsed, in this case to initialise the form's
-   output.</p>
+   </li>
 
-   <pre>&lt;script>
- function calculate(form) {
-   var price = 52000;
-   if (form.elements.brakes.checked)
-     price += 1000;
-   if (form.elements.radio.checked)
-     price += 2500;
-   if (form.elements.turbo.checked)
-     price += 5000;
-   if (form.elements.sticker.checked)
-     price += 250;
-   form.elements.result.value = price;
- }
-&lt;/script>
-&lt;form name="pricecalc" onsubmit="return false" onchange="calculate(this)">
- &lt;fieldset>
-  &lt;legend>Work out the price of your car&lt;/legend>
-  &lt;p>Base cost: &pound;52000.&lt;/p>
-  &lt;p>Select additional options:&lt;/p>
-  &lt;ul>
-   &lt;li>&lt;label>&lt;input type=checkbox name=brakes> Ceramic brakes (&pound;1000)&lt;/label>&lt;/li>
-   &lt;li>&lt;label>&lt;input type=checkbox name=radio> Satellite radio (&pound;2500)&lt;/label>&lt;/li>
-   &lt;li>&lt;label>&lt;input type=checkbox name=turbo> Turbo charger (&pound;5000)&lt;/label>&lt;/li>
-   &lt;li>&lt;label>&lt;input type=checkbox name=sticker> "XZ" sticker (&pound;250)&lt;/label>&lt;/li>
-  &lt;/ul>
-  &lt;p>Total: &pound;&lt;output name=result>&lt;/output>&lt;/p>
- &lt;/fieldset>
- &lt;script>
-  calculate(document.forms.pricecalc);
- &lt;/script>
-&lt;/form></pre>
+  </ol>
 
   </div>
 
 
-
   <h5 id="scriptingLanguages">Scripting languages</h5>
 
   <p>A <dfn>JavaScript MIME type</dfn> is a <span>MIME type</span> string that is one of the
@@ -60332,7 +60490,8 @@ if (player &lt; script) { ... }
 if (script > player) { ... }</pre>
 
    <p>Doing this also avoids a different pitfall as well: for related historical reasons, the string
-   "&lt;!--" in JavaScript is actually treated as a line comment start, just like "//".</p>
+   "&lt;!--" in <span data-x="classic script">classic scripts</span> is actually treated as a line
+   comment start, just like "//".</p>
 
   </div>
 
@@ -78379,6 +78538,113 @@ dictionary <dfn>DragEventInit</dfn> : <span>MouseEventInit</span> {
   </div>
 
 
+  <div w-nodev>
+
+  <h4>Script settings for browsing contexts</h4>
+
+  <p>When the user agent is required to <dfn>set up a browsing context environment settings
+  object</dfn>, given a <span>JavaScript execution context</span> <var>execution context</var>, it
+  must run the following steps:</p>
+
+  <ol>
+   <li><p>Let <var>window</var> be <var>execution context</var>'s <span data-x="execution
+   context's global object">global object</span>.</p></li>
+
+   <li><p>Let <var>url</var> be a copy of the <span data-x="the document's address">address</span>
+   of the <code>Document</code> with which <var>window</var> associated.</p></li>
+
+   <li>
+    <p>Let <var>settings object</var> be a new <span>environment settings object</span> whose
+    algorithms are defined as follows:</p>
+
+    <dl>
+
+     <dt>The <span>realm execution context</span></dt>
+     <dd>
+
+      <p>Return <var>execution context</var>.</p>
+
+     </dd>
+
+     <dt>The <span>responsible browsing context</span></dt>
+     <dd>
+
+      <p>Return the <span>browsing context</span> with which <var>window</var> is associated.</p>
+
+     </dd>
+
+     <dt>The <span>responsible event loop</span></dt>
+     <dd>
+
+      <p>Return the <span>event loop</span> that is associated with the <span>unit of related
+      similar-origin browsing contexts</span> to which <var>window</var>'s <span>browsing
+      context</span> belongs.</p>
+
+     </dd>
+
+     <dt>The <span>responsible document</span></dt>
+     <dd>
+
+      <p>Return the <code>Document</code> with which <var>window</var> is currently associated.</p>
+
+     </dd>
+
+     <dt>The <span>API URL character encoding</span></dt>
+     <dd>
+
+      <p>Return the current <span data-x="document's character encoding">character encoding</span> of
+      the <code>Document</code> with which <var>window</var> is currently associated.</p>
+
+     </dd>
+
+     <dt>The <span>API base URL</span></dt>
+     <dd>
+
+      <p>Return the current <span data-x="document base URL">base URL</span> of the
+      <code>Document</code> with which <var>window</var> is currently associated.</p>
+
+     </dd>
+
+     <dt>The <span>origin</span></dt>
+     <dd>
+
+      <p>Return the <span>origin</span> of the <code>Document</code> with which <var>window</var>
+      is currently associated.</p>
+
+     </dd>
+
+     <dt>The <span>effective script origin</span></dt>
+     <dd>
+
+      <p>Return the <span>effective script origin</span> of the <code>Document</code> with which
+      <var>window</var> is currently associated.</p>
+
+     </dd>
+
+     <dt>The <span>creation URL</span></dt>
+     <dd>
+
+      <p>Return <var>url</var>.</p>
+
+     </dd>
+
+     <dt>The <span>HTTPS state</span></dt>
+     <dd>
+
+      <p>Return the <span data-x="concept-document-https-state">HTTPS state</span> of the
+      <code>Document</code> with which <var>window</var> is currently associated.</p>
+
+     </dd>
+
+    </dl>
+   </li>
+
+   <li><p>Return <var>settings object</var>.</p></li>
+  </ol>
+
+  </div>
+
+
 
 <!--TOPIC:DOM APIs-->
   <h3>The <code>Window</code> object</h3>
@@ -81722,29 +81988,22 @@ State: &lt;OUTPUT NAME=I>1&lt;/OUTPUT> &lt;INPUT VALUE="Increment" TYPE=BUTTON O
          http://software.hixie.ch/utilities/js/live-dom-viewer/saved/2639 -> about:blank
          http://software.hixie.ch/utilities/js/live-dom-viewer/saved/2640 -> javascript:'test' in Firefox, about:blank otherwise
        -->
+
        <li><p>Let <var>address</var> be the <span data-x="the document's
        address">address</span> of the <span>active document</span> of the <span>browsing
        context</span> being navigated.</p></li>
 
-       <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>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
-        data-x="concept-bc-noscript">scripting is disabled</span>.)</p>
-
-       </li>
+       <li><p>Let <var>result</var> be the result of <span>running the classic script</span>
+       <var>script</var>. If an exception was thrown, let <var>result</var> be void instead. (The
+       result will be void also if <span data-x="concept-bc-noscript">scripting is
+       disabled</span>.)</p></li>
 
        <li>
 
-        <p><i>Process results</i>: If the result of executing the script is void (there is no return
-        value), then the result of obtaining the resource for the URL is a <span
-        data-x="concept-response">response</span> whose
-        <span data-x="concept-response-status">status</span> is <code data-x="">204</code>.</p>
+        <p><i>Process results</i>: If <var>result</var> is void (there is no return value), then
+        the result of obtaining the resource for the URL is a <span
+        data-x="concept-response">response</span> whose <span
+        data-x="concept-response-status">status</span> is <code data-x="">204</code>.</p>
 
         <p>Otherwise, the result of obtaining the resource for the URL is a <span
         data-x="concept-response">response</span> whose <span
@@ -85806,16 +86065,33 @@ interface <dfn>NavigatorOnLine</dfn> {
 
   <h5>Definitions</h5>
 
-  <p>A <dfn data-x="concept-script">script</dfn> has:</p>
+  <p>A <dfn data-x="concept-script">script</dfn> is one of two possible structures. All scripts
+  have:</p>
 
   <dl>
 
-   <dt>A <dfn>code entry-point</dfn></dt>
+   <dt>A <dfn>settings object</dfn></dt>
+
+   <dd>
+
+    <p>An <span>environment settings object</span>, containing various settings that are shared
+    with other <span data-x="concept-script">scripts</span> in the same context.</p>
+
+   </dd>
+
+  </dl>
+
+
+  <p>A <dfn>classic script</dfn> additionally has:</p>
+
+  <dl>
+
+   <dt><dfn data-x="concept-classic-script-source-text">Source text</dfn></dt>
 
    <dd>
 
-    <p>A code entry-point is either a string containing a block of executable code to be evaluated,
-    or a JavaScript function object. The latter case is used for event handlers.</p>
+    <p>A string containing a block of executable code to be evaluated as a JavaScript <i
+    data-x="js-prod-Script">Script</i>.</p>
 
    </dd>
 
@@ -85829,12 +86105,37 @@ interface <dfn>NavigatorOnLine</dfn> {
 
    </dd>
 
-   <dt>A <dfn>settings object</dfn></dt>
+  </dl>
+
+  <p>A <dfn>module script</dfn> additionally has:</p>
+
+  <dl>
+
+   <dt>A <dfn data-x="concept-module-script-module-record">module record</dfn></dt>
+
+   <dd>
+
+    <p>A <span>Source Text Module Record</span> representing the parsed module, ready to be
+    evaluated.</p>
+
+   </dd>
+
+   <dt>A <dfn data-x="concept-module-script-base-url">base URL</dfn></dt>
+
+   <dd>
+
+    <p>A base URL used for resolving module specifiers when <span data-x="resolve a module
+    specifier">resolving a module specifier</span>. This will either be the URL from which the
+    script was obtained, for external module scripts, or the <span>document base URL</span> of the
+    containing document, for inline module scripts.</p>
+
+   </dd>
+
+   <dt>A <dfn data-x="concept-module-script-cors-setting">CORS setting</dfn></dt>
 
    <dd>
 
-    <p>An <span>environment settings object</span>, various settings that are shared with other scripts in
-    the same context.</p>
+    <p>A <span>CORS settings attribute</span> state used to fetch imported modules.</p>
 
    </dd>
 
@@ -85852,11 +86153,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>run a classic script</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>absolute URL</span>s to values that are either a <span>module script</span>,
+    null, or a placeholder value "<code data-x="">fetching</code>". The map must be initially
+    empty. It is used to ensure that imported JavaScript modules are only fetched, parsed, and
+    evaluated once.</p>
+
    </dd>
 
    <dt>A <dfn>responsible browsing context</dfn></dt>
@@ -85964,186 +86277,420 @@ 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>
 
-  <p>The <dfn>relevant settings object for a script</dfn> <var>s</var> is the
-  <span>settings object</span> of <var>s</var>.</p>
-
   <p>The <dfn>script corresponding to the running execution context</dfn> is the
   <span>script</span> in the [[HostDefined]] slot of the <span>running JavaScript execution
   context</span>'s ScriptOrModule.</p>
 
 
-  <h5>Script settings for browsing contexts</h5>
 
-  <p>When the user agent is required to <dfn>set up a browsing context environment settings
-  object</dfn>, given a <span>JavaScript execution context</span> <var>execution context</var>, it
-  must run the following steps:</p>
+  <h5 id="fetching-scripts">Fetching scripts</h5>
+
+  <p>To <dfn>fetch a classic script</dfn> for a <code>script</code> element <var>element</var>,
+  given a <var>url</var>, a <var>CORS setting</var>, a <var>settings object</var>, and a
+  <var>character encoding</var>, run these steps. The algorithm will asynchronously complete with
+  either null (on failure) or a new <span>classic script</span> (on success).</p>
 
   <ol>
-   <li><p>Let <var>window</var> be <var>execution context</var>'s <span data-x="execution
-   context's global object">global object</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 <var>url</var> and <var>CORS
+   setting</var>.</p></li>
+
+   <li><p>Set <var>request</var>'s <span data-x="concept-request-client">client</span> to
+   <var>settings object</var>, and its <span data-x="concept-request-type">type</span> to "<code
+   data-x="">script</code>".</p></li>
+
+   <!--FETCH-->
+   <li><p><span data-x="concept-fetch">Fetch</span> <var>request</var>.</p></li>
 
    <li><p>Let <var>url</var> be a copy of the <span data-x="the document's address">address</span>
    of the <code>Document</code> with which <var>window</var> is associated.</p></li>
 
    <li>
-    <p>Let <var>settings object</var> be a new <span>environment settings object</span> whose
-    algorithms are defined as follows:</p>
+    <p>Return from this algorithm, and run the remaining steps as part of the fetch's
+    <span>process response</span> for the <span data-x="concept-response">response</span>
+    <var>response</var>.</p>
 
-    <dl>
+    <p class="note"><var>response</var> can be either <span>CORS-same-origin</span> or
+    <span>CORS-cross-origin</span>. This only affects how error reporting happens.</p>
+   </li>
 
-     <dt>The <span>realm execution context</span></dt>
-     <dd>
+   <li><p>If <var>response</var>'s <span data-x="concept-response-type">type</span> is "<code
+   data-x="">error</code>", or <var>response</var>'s <span
+   data-x="concept-response-status">status</span> is not an <span>ok status</span>, asynchronously
+   complete this algorithm with null, and abort these steps.</p></li>
 
-      <p>Return <var>execution context</var>.</p>
+   <li><p>If <var>response</var>'s <span data-x="Content-Type">Content Type metadata</span>, if
+   any, specifies a character encoding, and the user agent supports that encoding, then set
+   <var>character encoding</var> to that encoding (ignoring the passed-in value).</p></li>
 
-     </dd>
+   <li>
+    <p>Let <var>source text</var> be the result of <span data-x="decode">decoding</span>
+    <var>response</var>'s <span data-x="concept-response-body">body</span> to Unicode, using
+    <var>character encoding</var> as the fallback encoding.</p>
 
-     <dt>The <span>responsible browsing context</span></dt>
-     <dd>
+    <p class="note">The <span>decode</span> algorithm overrides <var>character encoding</var> if
+    the file contains a BOM.</p>
+   </li>
 
-      <p>Return the <span>browsing context</span> with which <var>window</var> is associated.</p>
+   <li>
+    <p>Let <var>script</var> be the result of <span>creating a classic script</span> using
+    <var>source text</var> and <var>settings object</var>.</p>
 
-     </dd>
+    <p>If <var>response</var> was <span>CORS-cross-origin</span>, then pass the <var>muted
+    errors</var> flag to the <span data-x="creating a classic script">create a classic
+    script</span> algorithm as well.</p>
+   </li>
 
-     <dt>The <span>responsible event loop</span></dt>
-     <dd>
+   <li>Asynchronously complete this algorithm with <var>script</var>.</li>
+  </ol>
 
-      <p>Return the <span>event loop</span> that is associated with the <span>unit of related
-      similar-origin browsing contexts</span> to which <var>window</var>'s <span>browsing
-      context</span> belongs.</p>
+  <p>To <dfn>fetch a module script tree</dfn> given a <var>url</var>, a <var>CORS setting</var>,
+  and a <var>settings object</var>, run these steps. The algorithm will asynchronously complete
+  with either null (on failure) or a new <span>module script</span> (on success).</p>
 
-     </dd>
+  <ol>
+   <li><p><span>Fetch a single module script</span> given <var>url</var>, <var>CORS setting</var>,
+   and <var>settings object</var>.</p>
 
-     <dt>The <span>responsible document</span></dt>
-     <dd>
+   <li><p>Return from this algorithm and run the following steps when <span data-x="fetch a single
+   module script">fetching a single module script</span> asynchronously completes with
+   <var>result</var>:</p></li>
 
-      <p>Return the <code>Document</code> with which <var>window</var> is currently associated.</p>
+   <li><p>If <var>result</var> is null, asynchronously complete this algorithm with null and abort
+   these steps.</p></li>
 
-     </dd>
+   <li><p>Otherwise, <var>result</var> is a <span>module script</span>. <span data-x="fetch the
+   descendants of a module script">Fetch the descendants</span> of <var>result</var>.</p></li>
 
-     <dt>The <span>API URL character encoding</span></dt>
-     <dd>
+   <li><p>When <span data-x="fetch the descendants of a module script">fetching the descendants of
+   a module script</span> asynchronously completes with <var>descendants result</var>,
+   asynchronously complete this algorithm with <var>descendants result</var>.</p></li>
+  </ol>
 
-      <p>Return the current <span data-x="document's character encoding">character encoding</span> of
-      the <code>Document</code> with which <var>window</var> is currently associated.</p>
+  <p>To <dfn>fetch the descendants of a module script</dfn> <var>module script</var>, run these
+  steps. The algorithm will asynchronously complete with either null (on failure) or with
+  <var>module script</var> (on success).</p>
 
-     </dd>
+  <ol>
+   <li><p>Let <var>record</var> be <var>module script</var>'s <span
+   data-x="concept-module-script-module-record">module record</span>.</p></li>
 
-     <dt>The <span>API base URL</span></dt>
-     <dd>
+   <li><p>If <var>record</var>.[[RequestedModules]] is empty, asynchronously complete this
+   algorithm with <var>module script</var>.</p></li>
 
-      <p>Return the current <span data-x="document base URL">base URL</span> of the
-      <code>Document</code> with which <var>window</var> is currently associated.</p>
+   <li><p>Let <var>urls</var> be a new empty list.</p></li>
 
-     </dd>
+   <li>
+    <p>For each string <var>requested</var> of <var>record</var>.[[RequestedModules]],</p>
 
-     <dt>The <span>origin</span></dt>
-     <dd>
+    <ol>
+     <li><p>Let <var>url</var> be the result of <span data-x="resolve a module specifier">resolving
+     a module specifier</span> given <var>module script</var> and <var>requested</var>.</p></li>
 
-      <p>Return the <span>origin</span> of the <code>Document</code> with which <var>window</var>
-      is currently associated.</p>
+     <li>
+      <p>If the result is error:</p>
 
-     </dd>
+      <ol>
+       <li><p>Let <var>error</var> be a new <code>TypeError</code>.</p></li>
 
-     <dt>The <span>effective script origin</span></dt>
-     <dd>
+       <li><p><span>Report the exception</span> <var>error</var> for <var>module
+       script</var>.</p></li>
 
-      <p>Return the <span>effective script origin</span> of the <code>Document</code> with which
-      <var>window</var> is currently associated.</p>
+       <li><p>Abort this algorithm, and asynchronously complete it with null.</p></li>
+      </ol>
+     </li>
 
-     </dd>
+     <li><p>Otherwise, add <var>url</var> to <var>urls</var>.</p></li>
+    </ol>
+   </li>
 
-     <dt>The <span>creation URL</span></dt>
-     <dd>
+   <li>
+    <p>For each <var>url</var> in <var>urls</var>, <span>fetch a module script tree</span> given
+    <var>url</var>, <var>module script</var>'s <span
+    data-x="concept-module-script-cors-setting">CORS setting</span>, and
+    <var>module script</var>'s <span>settings object</span>.</p>
 
-      <p>Return <var>url</var>.</p>
+    <p>If any of the <span>fetch a module script tree</span> invocations asynchronously complete
+    with null, the user agent may <span data-x="concept-fetch-terminate">terminate</span> any or
+    all of the other fetches, and must then asynchronously complete this algorithm with null.</p>
 
-     </dd>
+    <p>Once all of the <span>fetch a module script tree</span> invocations asynchronously
+    complete with a <span>module script</span>, asynchronously complete this algorithm with
+    <var>module script</var>.</p>
+   </li>
+  </ol>
 
-     <dt>The <span>HTTPS state</span></dt>
-     <dd>
+  <p>To <dfn>fetch a single module script</dfn>, given a <var>url</var>, a <var>CORS setting</var>,
+  and a <var>settings object</var>, run these steps. The algorithm will asynchronously complete
+  with either null (on failure) or a new <span>module script</span> (on success).</p>
 
-      <p>Return the <span data-x="concept-document-https-state">HTTPS state</span> of the
-      <code>Document</code> with which <var>window</var> is currently associated.</p>
+  <ol>
+   <li><p>Let <var>module map</var> be <var>settings</var>'s <span>module map</span>.</p></li>
 
-     </dd>
+   <li><p>If <var>module map</var> contains an entry with key <var>url</var> whose value is "<code
+   data-x="">fetching</code>", wait (<span>in parallel</span>) until that entry's value changes,
+   then proceed to the next step.</p></li>
+
+   <li><p>If <var>module map</var> contains an entry with key <var>url</var>, asynchronously
+   complete this algorithm with that entry's value, and abort these steps.</p></li>
+
+   <li><p>Create an entry in <var>module map</var> with key <var>url</var> and value "<code
+   data-x="">fetching</code>".</p>
+
+   <li>
+    <p>Let <var>credentials mode</var> be determined by switching on <var>CORS setting</var>:
 
+    <dl class="switch">
+     <dt><span data-x="attr-crossorigin-none">No CORS</span></dt>
+     <dd>"<code data-x="">omit</code>"</dd>
+
+     <dt><span data-x="attr-crossorigin-anonymous">Anonymous</span></dt>
+     <dd>"<code data-x="">same-origin</code>"</dd>
+
+     <dt><span data-x="attr-crossorigin-none">Use Credentials</span></dt>
+     <dd>"<code data-x="">include</code>"</dd>
     </dl>
    </li>
 
-   <li><p>Return <var>settings object</var>.</p></li>
+   <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 <var>credentials
+   mode</var>, and <span data-x="concept-request-client">client</span> is
+   <var>settings object</var>.</p></li>
+
+   <!--FETCH-->
+   <li><p><span data-x="concept-fetch">Fetch</span> <var>request</var>.</p></li>
+
+   <li>
+    <p>Return from this algorithm, and run the remaining steps as part of the fetch's
+    <span>process response</span> for the <span data-x="concept-response">response</span>
+    <var>response</var>.</p>
+
+    <p class="note"><var>response</var> is always <span>CORS-same-origin</span>.</p>
+   </li>
+
+   <li>
+    <p>If any of the following conditions are met, set the value of the entry in <var>module
+    map</var> whose key is <var>url</var> to null, asynchronously complete this algorithm with
+    null, and abort these steps:</p>
+
+    <ul class="compact">
+     <li><p><var>response</var>'s <span data-x="concept-response-type">type</span> is "<code
+     data-x="">error</code>"</p></li>
+
+     <li><p><var>response</var>'s <span data-x="concept-response-status">status</span> is not an
+     <span>ok status</span></p></li>
+
+     <li>
+      <p>The result of <span data-x="extract a MIME type">extracting a MIME type</span> from
+      <var>response</var>'s <span data-x="concept-response-header-list">header list</span>
+      (ignoring parameters) is not a <span>JavaScript MIME type</span>.</p>
+
+      <p class="note">For historical reasons, <span data-x="fetch a classic script">fetching a
+      classic script</span> does not include MIME type checking. In contrast, module scripts will
+      fail to load if they are not of a correct MIME type.</p>
+     </li>
+    </ul>
+   </li>
+
+   <li><p>Let <var>source text</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>module script</var> be the result of <span>creating a module script</span> given
+   <var>source text</var>, <var>settings object</var>, <var>response</var>'s <span
+   data-x="concept-response-url">url</span>, and <var>CORS setting</var>.</p></li>
+
+   <li>
+    <p>Set the value of the entry in <var>module map</var> whose key is <var>url</var> to
+    <var>module script</var>, and asynchronously complete this algorithm with <var>module
+    script</var>.</p>
+
+    <p class="note">It is intentional that the <span>module map</span> is keyed by the <span
+    data-x="concept-request-url">request URL</span>, whereas the <span
+    data-x="concept-module-script-base-url">base URL</span> for the <span>module script</span> is
+    set to the <span data-x="concept-response-url">response URL</span>. The former is used to
+    deduplicate fetches, while the latter is used for URL resolution.</p>
+   </li>
   </ol>
 
-  <h5>Calling scripts</h5>
+  <h5 id="creating-scripts">Creating scripts</h5>
 
-  <p>When a user agent is to <dfn>jump to a code entry-point</dfn> for a <span
-  data-x="concept-script">script</span> <var>s</var>, given an optional <var>rethrow errors</var>
-  flag, the user agent must run the following steps:</p>
+  <p>To <dfn data-x="creating a classic script">create a classic script</dfn>, given some script
+  source, an <span>environment settings object</span>, and an optional <var>muted errors</var>
+  flag:</p>
 
   <ol>
 
-   <li><p>Let <var>settings</var> be the <span>settings object</span> of <var>s</var>.</p></li>
+   <li><p>Let <var>script</var> be a new <span>classic script</span> that this algorithm will
+   subsequently initialise.</p></li>
+
+   <li><p>Set <var>script</var>'s <span>settings object</span> to the <span>environment
+   settings object</span> provided.</p></li>
+
+   <li><p>If <span data-x="concept-bc-noscript">scripting is disabled</span> for the given
+   <span>environment settings object</span>'s <span>responsible browsing context</span>, then set
+   <var>script</var>'s <span data-x="concept-classic-script-source-text">source text</span> to the
+   empty string. Otherwise, set <var>script</var>'s <span
+   data-x="concept-classic-script-source-text">source text</span> to the supplied script
+   source.</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>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>Prepare to run a callback</span> with <var>settings</var>. If this returns "do not
-   run" then abort these steps.</p></li>
+   <li><p>Return <var>script</var>.</p></li>
 
-   <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>
+  </ol>
 
-   <li>
-    <p>If <var>result</var> is a List of errors, then:</p>
+  <p>To <dfn data-x="creating a module script">create a module script</dfn>, given some script
+  source, an <span>environment settings object</span>, a script base URL, and a <span>CORS settings
+  attribute</span> state:</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 the first element of <var>result</var>.</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 set, throw a <code>NetworkError</code> exception.</p></li>
+   <li><p>Let <var>script</var> be a new <span>module script</span> that this algorithm will
+   subsequently initialise.</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>Set <var>script</var>'s <span>settings object</span> to the <span>environment
+   settings object</span> provided.</p></li>
 
-     <li><p>In all cases, go to the step labeled <i>cleanup</i>.</p></li>
-    </ol>
-   </li>
+   <li><p>Let <var>realm</var> be the provided <span>environment settings object</span>'s <span
+   data-x="environment settings object's Realm">Realm</span>.</p></li>
+
+   <li><p>If <span data-x="concept-bc-noscript">scripting is disabled</span> for the given
+   <span>environment settings object</span>'s <span>responsible browsing context</span>, then let
+   <var>script source</var> be the empty string. Otherwise, let <var>script source</var> be the
+   provided script source.</p></li>
+
+   <li><p>Let <var>result</var> be <span
+   data-x="js-ParseModule">ParseModule</span>(<var>script source</var>, <var>realm</var>,
+   <var>script</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> for <var>script</var>, return null, and abort these
+   steps.</p></li>
+
+   <li><p>Set <var>script</var>'s <span data-x="concept-module-script-module-record">module
+   record</span> to <var>result</var>.</p></li>
+
+   <li><p>Set <var>script</var>'s <span data-x="concept-module-script-base-url">base URL</span> to
+   the script base URL provided.</p></li>
+
+   <li><p>Set <var>script</var>'s <span data-x="concept-module-script-cors-setting">CORS
+   setting</span> to the <span>CORS settings attribute</span> state provided.</p></li>
+
+   <li><p>Return <var>script</var>.</p></li>
 
-   <li><p>Let <var>status</var> be <span
+  </ol>
+
+  <h5>Calling scripts</h5>
+
+  <p>To <dfn>run a classic script</dfn> given a <span>classic script</span> <var>s</var> and an
+  optional <var>rethrow errors</var> flag:</p>
+
+  <ol>
+
+   <li><p>Let <var>settings</var> be the <span>settings object</span> of <var>s</var>.</p></li>
+
+   <li><p><span>Check if we can run script</span> with <var>settings</var>. If this returns "do
+   not run" then abort these steps.</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><span>Prepare to run script</span> with <var>settings</var>.</p></li>
+
+   <li><p>Let <var>result</var> be <span
+   data-x="js-ParseScript">ParseScript</span>(<var>s</var>'s <span
+   data-x="concept-classic-script-source-text">source text</span>, <var>realm</var>,
+   <var>s</var>).</p></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>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
+   <li><p><i>Cleanup</i>: <span>Clean up after running script</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>To <dfn>run a module script</dfn> given a <span>module script</span> <var>s</var>:</p>
+
+  <ol>
+
+   <li><p>Let <var>settings</var> be the <span>settings object</span> of <var>s</var>.</p></li>
+
+   <li><p><span>Check if we can run script</span> with <var>settings</var>. If this returns "do
+   not run" then abort these steps.</p></li>
+
+   <li><p>Let <var>record</var> be <var>s</var>'s <span
+   data-x="concept-module-script-module-record">module record</span>.</p>
+
+   <li>
+    <p>Let <var>instantiationStatus</var> be <var>record</var>.<span
+    data-x="js-ModuleDeclarationInstantiation">ModuleDeclarationInstantiation</span>().</p>
+
+    <p class="note">This step will recursively instantiate all of the module's dependencies.</p>
+   </li>
+
+   <li><p>If <var>instantiationStatus</var> is an abrupt completion, <span>report the
+   exception</span> given by <var>instantiationStatus</var>.[[value]] for <var>s</var> and abort
+   these steps.</p></li>
+
+   <li><p><span>Prepare to run script</span> given <var>settings</var>.</p></li>
+
+   <li>
+    <p>Let <var>evaluationStatus</var> be <var>record</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 script</span> with <var>settings</var>.</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. They return either "run" or "do not run".</p>
+  <p>The steps to <dfn>check if we can run script</dfn> with an <span>environment settings
+  object</span> <var>settings</var> are as follows. They return either "run" or "do not run".</p>
 
   <ol>
 
@@ -86155,18 +86702,26 @@ 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 <span id="prepare-to-run-a-callback"></span><dfn>prepare to run script</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>
+  <p>The steps to <span id="clean-up-after-running-a-callback"></span><dfn>clean up after running
+  script</dfn> with an <span>environment settings object</span> <var>settings</var> are as
+  follows:</p>
 
   <ol>
 
@@ -86276,45 +86831,6 @@ interface <dfn>NavigatorOnLine</dfn> {
   perform each of the jobs in the <span>global script clean-up jobs list</span> and then empty the
   list.</p>
 
-  </div>
-
-
-  <div w-nodev>
-
-  <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>
-
-  <ol>
-
-   <li><p>Let <var>script</var> be a new <span data-x="concept-script">script</span> that
-   this algorithm will subsequently initialise.</p></li>
-
-   <li><p>If <span data-x="concept-bc-noscript">scripting is disabled</span> for <span>browsing
-   context</span> passed to this algorithm, then abort these steps, as if the script source
-   described a program that did nothing but return void.</p>
-
-   <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
-   settings object</span> provided.</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>
-
-  </ol>
-
-  </div>
-
-
-  <div w-nodev>
 
   <h5>Killing scripts</h5>
 
@@ -86378,18 +86894,19 @@ 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 script</span> with <var>settings</var>. If this returns "do
      not run" then abort these steps.</p></li>
+     <li><p><span>Prepare to run script</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>
+     <li><p><span>Clean up after running script</span> with <var>settings</var>.</p></li>
     </ol>
    </li>
   </ol>
@@ -86409,6 +86926,70 @@ 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 <span data-x="classic script">classic
+  scripts</span> versus <span data-x="module script">module scripts</span>, since both of them use
+  the <code>script</code> element.</p>
+
+  <p>To <dfn>resolve a module specifier</dfn> given a <span>module script</span> <var>script</var>
+  and a string <var>specifier</var>, perform the following steps. It will return either an
+  <span>absolute URL</span> or failure.</p>
+
+  <ol>
+   <li><p>Apply the <span>URL parser</span> to <var>specifier</var>. If the result is not failure,
+   return the result.</p></li>
+
+   <li>
+    <p>If <var>specifier</var> does not start with the character U+002F SOLIDUS (<code
+    data-x="">/</code>), 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>), return failure 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 fail, instead of being treated as relative URLs.</p>
+   </li>
+
+   <li><p>Return the result of applying the <span>URL parser</span> to <var>specifier</var> with
+   <var>script</var>'s <span data-x="concept-module-script-base-url">base URL</span> as the base
+   URL.</p></li>
+  </ol>
+
+  <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>
+
+  <ol>
+   <li><p>Let <var>referencing module script</var> be
+   <var>referencingModule</var>.[[HostDefined]].</p></li>
+
+   <li><p>Let <var>module map</var> be <var>referencing module script</var>'s <span>settings
+   object</span>'s <span>module map</span>.</p></li>
+
+   <li><p>Let <var>url</var> be the result of <span data-x="resolve a module specifier">resolving a
+   module specifier</span> given <var>referencing module script</var> and <var>specifier</var>. If
+   the result is failure, throw a <code>TypeError</code> exception and abort these steps.</p></li>
+
+   <li><p>Let <var>resolved module script</var> be the value of the entry in <var>module map</var>
+   whose key is <var>url</var>. If no such entry exists, or if the value is null or "<code
+   data-x="">fetching</code>", throw a <code>TypeError</code> exception and abort these
+   steps.</p></li>
+
+   <li><p>Return <var>resolved module script</var>'s <span
+   data-x="concept-module-script-module-record">module record</span>.</p></li>
+  </ol>
+
   </div>
 
 
@@ -87000,7 +87581,7 @@ dictionary <dfn>PromiseRejectionEventInit</dfn> : <span>EventInit</span> {
     <p><i>Run</i>: Run the selected <span data-x="concept-task">task</span>.</p>
 
     <p class="note">This might involve invoking scripted callbacks, which eventually calls the
-    <span>clean up after running a callback</span> steps, which call this <span>perform a microtask
+    <span>clean up after running script</span> steps, which call this <span>perform a microtask
     checkpoint</span> algorithm again, which is why we use the <span>performing a microtask
     checkpoint</span> flag to avoid reentrancy.</p>
 
@@ -87642,15 +88223,7 @@ typedef <span>OnBeforeUnloadEventHandlerNonNull</span>? <dfn>OnBeforeUnloadEvent
 
      </li>
 
-     <li><p>Let <var>script</var> be a new <span
-     data-x="concept-script">script</span>.</p></li>
-
-     <!-- SCRIPT EXEC -->
-     <li><p>Let <var>script</var>'s <span>code entry-point</span> be <var>function</var>.</p></li>
-
-     <li><p>Let <var>script</var>'s <span>settings object</span> be <var>script
-     settings</var>.</p></li>
-
+     <!-- SCRIPT EXEC, sorta -->
      <li><p>Set <var>H</var>'s value to <var>function</var>.</p></li>
 
     </ol>
@@ -88868,12 +89441,14 @@ interface <dfn>WindowTimers</dfn> {
 
          <li><p>Let <var>script source</var> be the first method argument.</p></li>
 
-         <li><p>Let <var>settings object</var> be <var>method context</var>'s <span>environment settings
-         object</span>.</p></li>
+         <li><p>Let <var>settings object</var> be <var>method context</var>'s <span>environment
+         settings 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>
+         <li><p>Let <var>script</var> be the result of <span>creating a classic script</span> using
+         <var>script source</var> and <var>settings object</var>.</p></li>
+
+         <li><p><span data-x="run a classic script">Run the classic script</span>
+         <var>script</var>.</p></li>
 
         </ol>
 
@@ -93849,9 +94424,9 @@ interface <dfn>MessagePort</dfn> : <span>EventTarget</span> {
   unaffected to any <span>unshipped port message queue</span>.</p>
 
   <p>When the user agent is to <dfn>create a new <code>MessagePort</code> object</dfn> with a
-  particular <span>settings object</span> as its <var>owner</var>, it must instantiate a
-  new <code>MessagePort</code> object, and let its <span data-x="concept-port-owner">owner</span> be
-  <var>owner</var>.</p>
+  particular <span>environment settings object</span> as its <var>owner</var>, it must instantiate
+  a new <code>MessagePort</code> object, and let its <span data-x="concept-port-owner">owner</span>
+  be <var>owner</var>.</p>
 
   <p>When the user agent is to <dfn>entangle</dfn> two <code>MessagePort</code> objects, it must run
   the following steps:</p>
@@ -95129,9 +95704,9 @@ interface <dfn>WorkerGlobalScope</dfn> : <span>EventTarget</span> {
   it must be removed from the list of <span>the worker's <code>Document</code>s</span> of each
   worker whose list contains that <code>Document</code>.</p>
 
-  <p>Given a <span>settings object</span> <var>o</var> when creating or obtaining a
+  <p>Given an <span>environment settings object</span> <var>o</var> when creating or obtaining a
   worker, the <dfn>list of relevant <code>Document</code> objects to add</dfn> depends on the type
-  of <span>global object</span> specified by <var>o</var>'s. If <var>o</var>
+  of <span>global object</span> specified by <var>o</var>. If <var>o</var>
   specifies a <span>global object</span> that is a <code>WorkerGlobalScope</code> object (i.e. if we
   are creating a nested worker), then the relevant <code>Document</code>s are the <span>the worker's
   <code>Document</code>s</span> of the <span>global object</span> specified by <var>o</var>. Otherwise, <var>o</var> specifies a <span>global object</span> that
@@ -95301,13 +95876,11 @@ interface <dfn>WorkerGlobalScope</dfn> : <span>EventTarget</span> {
 
    <!-- SCRIPT EXEC -->
 
-   <li><p>Let <var>script</var> be a new <span data-x="concept-script">script</span> with
-   <span>code entry-point</span> <var>source</var> and <span>settings object</span> <var>settings
-   object</var>.</p></li>
+   <li><p>Let <var>script</var> be the result of <span>creating a classic script</span> using
+   <var>source</var> and <var>settings object</var>.</p></li>
 
    <li>
-    <p><span data-x="jump to a code entry-point">Jump</span> to the <span
-    data-x="concept-script">script</span>'s <span>code entry-point</span>.</p>
+    <p><span data-x="run a classic script">Run the classic script</span> <var>script</var>.</p>
 
     <p class="note">In addition to the usual possibilities of returning a value or failing due to
     an exception, this could be prematurely aborted by the "<span>kill a worker</span>" or
@@ -95939,18 +96512,22 @@ 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>
+      <p>Let <var>script</var> be the result of <span>creating a classic script</span> using
+      <var>source</var> and <var>settings object</var>.</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>
+      flag to the <span data-x="creating a classic script">create a classic script</span> algorithm
+      as well.</p>
+
+     </li>
+
+     <li>
+      <p><span data-x="run a classic script">Run the classic script</span> <var>script</var>,
+      passing the <var>rethrow errors</var> flag.</p>
 
-      <p class="note">The newly created <span data-x="concept-script">script</span> will run until
-      it either returns, fails to parse, fails to catch an exception, or gets prematurely aborted
-      by the "<span>kill a worker</span>" or "<span>terminate a worker</span>" algorithms defined
-      above.</p>
+      <p class="note"><var>script</var> will run until it either returns, fails to parse, fails to
+      catch an exception, or gets prematurely aborted by the "<span>kill a worker</span>" or
+      "<span>terminate a worker</span>" algorithms defined above.</p>
 
       <p>If an exception was thrown or if the script was prematurely aborted, then abort all these
       steps, letting the exception or aborting continue to be processed by the calling <span
@@ -117861,6 +118438,9 @@ INSERT INTERFACES HERE
    <dt id="refsXHTMLMOD">[XHTMLMOD]</dt>
    <dd><cite><a href="http://www.w3.org/TR/xhtml-modularization">Modularization of XHTML(TM)</a></cite>, M. Altheim, F. Boumphrey, S. Dooley, S. McCarron, S. Schnitzenbaumer, T. Wugofski. W3C.</dd>
 
+   <dt id="refsXKCD1288">[XKCD1288]</dt>
+   <dd>(Non-normative) <cite><a href="https://xkcd.com/1288/">Substitutions</a></cite>, Randall Munroe. xkcd.</dd>
+
    <dt id="refsXML">[XML]</dt>
    <dd><cite><a href="http://www.w3.org/TR/xml/">Extensible Markup Language</a></cite>, T. Bray, J. Paoli, C. Sperberg-McQueen, E. Maler, F. Yergeau. W3C.</dd>