The Web IDL specification also defines the following types that are used in Web IDL fragments @@ -3017,7 +3020,8 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute @@toPrimitive, and @@toStringTag
User agents that support JavaScript must also implement the BigInt proposal.
+ @@ -58008,11 +58014,14 @@ interface HTMLScriptElement : HTMLElement { redundantly setting it.Setting the attribute to an ASCII case-insensitive match for the string
- "module" means that the script is a module script, to be
- interpreted according to the JavaScript Module top-level
- production. Module scripts are not affected by the defer
- attribute, but are affected by the async attribute
- (regardless of the state of the src attribute).
module" means that the script is a module script. If it has
+ a JavaScript MIME type, or if the script is embedded inline, then it will be
+ interpreted as a JavaScript module script according to the JavaScript Module top-level production; if it has a JSON MIME
+ type, then it will be interpreted as a JSON module script. Module scripts
+ are not affected by the defer attribute, but are
+ affected by the async attribute (regardless of the state
+ of the src attribute).
Setting the attribute to any other value means that the script is a data
block, which is not processed. None of the script attributes (except HTMLScriptElement : HTMLElement {
scripts. By using a valid MIME type string now, you ensure that your data block will not
ever be reinterpreted as a different script type, even in future user agents.
Classic scripts and module
- scripts may either be embedded inline or may be imported from an external file using the
- Classic scripts and JavaScript module scripts can be embedded inline, or be imported from an external
+ file using the src attribute, which if specified gives the URL
of the external script resource to use. If src is specified,
- it must be a valid non-empty URL potentially surrounded by spaces. The contents of
- inline script elements, or the external script resource, must conform with the
- requirements of the JavaScript specification's Script or Module productions, for classic
- scripts and module scripts respectively.
The contents of inline script elements, or the external script resource, must
+ conform with the requirements of the JavaScript specification's Script or Module productions, for classic scripts and JavaScript module scripts respectively.
The contents of the external script resource for JSON module + scripts must conform to the requirements of the JSON specification .
When used to include data blocks, the data must be embedded
inline, the format of the data must be given using the type
@@ -58280,7 +58293,7 @@ o............A....e
The following sample shows how a script element can be used to include an
- external module script.
+ external JavaScript module script.
<script type="module" src="app.mjs"></script>Additionally, if code from another script element in the same Window
imports the module from app.mjs (e.g. via import
- "./app.mjs";), then the same module script created by the
+ "./app.mjs";), then the same JavaScript module script created by the
former script element will be imported.
This example shows how to include a module script for modern user agents, and a - classic script for older user agents:
+This example shows how to include a JavaScript module script for modern user + agents, and a classic script for older user agents:
<script type="module" src="app.mjs"></script>
<script nomodule src="classic-app-bundle.js"></script>In modern user agents that support module scripts, the
- script element with the nomodule attribute
- will be ignored, and the script element with a type of "module" will be fetched and
- evaluated (as a module script). Conversely, older user agents will ignore the
+
In modern user agents that support JavaScript module
+ scripts, the script element with the nomodule attribute will be ignored, and the
script element with a type of "module", as that is an unknown script type for them — but they will have no
- problem fetching and evaluating the other script element (as a classic
- script), since they do not implement the nomodule attribute.
script element with a
+ type of "module", as that is an
+ unknown script type for them — but they will have no problem fetching and evaluating the other
+ script element (as a classic script), since they do not implement the
+ nomodule attribute.
The following sample shows how a script element can be used to write an inline
- module script 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): JavaScript module script 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):
<script type="module">
@@ -58353,12 +58366,30 @@ o............A....e
walkAllTextNodeDescendants(document.body, substitute);
</script>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 global object. Also note that no matter where
- this script element appears in the document, it will not be evaluated until both
- document parsing has complete and its dependency (dom-utils.mjs) has been
- fetched and evaluated.
Some notable features gained by using a JavaScript 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 global object. Also note that no matter
+ where this script element appears in the document, it will not be evaluated until
+ both document parsing has complete and its dependency (dom-utils.mjs) has
+ been fetched and evaluated.
The following sample shows how to you can import a JSON module script from inside + a JavaScript module script:
+ +<script type="module">
+import peopleInSpace from "http://api.open-notify.org/astros.json";
+
+const list = document.querySelector("#people-in-space");
+for (const { craft, name } of peopleInSpace.people) {
+ const li = document.createElement("li");
+ li.textContent = `${name} / ${craft}`;
+ list.append(li);
+}
+</script>module"Let script be the result of creating a module script using - source text, settings object, base URL, and - options.
Let script be the result of creating a JavaScript module + script using source text, settings object, base + URL, and options.
If this returns null, set the script's script to null and return; the script is ready.
A script is one of two possible A script is one of three possible structs. All scripts have:
Either a Script Record, for classic - scripts; a Source Text Module Record, for module scripts; or null. In the former two cases, it represents a parsed script; - null represents a failure parsing.
One of the following:
+ +a script record, for classic + scripts;
a Source Text Module Record, for JavaScript module scripts;
a Synthetic Module Record, for JSON + module scripts; or
null, representing a parsing failure.
Module scripts can be classified into two types:
+ +A module script is a JavaScript module script if + its record is a Source Text Module + Record.
A module script is a JSON module script if its record is a Synthetic Module Record, and it + was created via the create a JSON module + script algorithm. JSON module scripts represent a parsed JSON document.
+ + +As JSON documents do not import dependent modules, and do not throw exceptions + on evaluation, the fetch options and + base URL of a JSON module script are + always null.
+The active script is determined by the following algorithm:
response's status is not an ok status
The result of extracting a MIME type from - response's header list is not a - JavaScript MIME type
+Let type be the result of extracting a + MIME type from response's header + list.
-For historical reasons, fetching a - classic script does not include MIME type checking. In contrast, module scripts will - fail to load if they are not of a correct MIME type.
-For historical reasons, fetching a + classic script does not include MIME type checking. In contrast, module scripts' + interpretation is driven by their MIME type, and they will fail to load if they are not of + a supported MIME type.
-Let source text be the result of UTF-8 - decoding response's body.
Let module script be null.
+ +If the resource does not have a MIME type which HTML knows how to handle + as a module, then module script will remain null, which is interpreted as + failure.
+Let module script be the result of creating a module script given - source text, module map settings object, response's url, and options.
If type is a JavaScript MIME type, then:
+ +Let source text be the result of UTF-8 + decoding response's body.
Set module script to the result of creating a JavaScript module + script given source text, module map settings object, + response's url, and + options.
If type is a JSON MIME type, then:
+ +Let source text be the result of UTF-8 + decoding response's body.
Set module script to the result of creating a JSON module + script given source text and module map settings object.
Set moduleMap[url] to module
@@ -88220,7 +88320,8 @@ interface ApplicationCache : EventTarget {
Let record be module script's record. If record.[[RequestedModules]] is empty,
+ If record is not a Cyclic Module Record, or if
+ record.[[RequestedModules]] is empty,
asynchronously complete this algorithm with module script. Let urls be a new empty list. Let options be the descendant script fetch options for module
script's fetch options. Assert: options is not null, as module script is a JavaScript
+ module script. For each url in urls, perform the
internal module script graph fetching procedure given url,
@@ -88347,36 +88451,43 @@ interface ApplicationCache : EventTarget {
then return moduleScript's parse
error. Let childSpecifiers be the value of moduleScript's record's [[RequestedModules]] internal slot. If moduleScript's record is a
+ Cyclic Module Record: Let childURLs be the list obtained by calling
- resolve a module specifier once for each item of childSpecifiers, given
- moduleScript's base URL and that item.
- (None of these will ever fail, as otherwise moduleScript would have been marked as
- itself having a parse error.) Let childSpecifiers be the value of moduleScript's record's [[RequestedModules]] internal slot. Let childModules be the list obtained by getting each value in moduleMap whose key is given by an
- item of childURLs. Let childURLs be the list obtained by calling
+ resolve a module specifier once for each item of childSpecifiers, given
+ moduleScript's base URL and that item.
+ (None of these will ever fail, as otherwise moduleScript would have been marked as
+ itself having a parse error.) For each childModule of
- childModules: Let childModules be the list obtained by getting each value in moduleMap whose key is given by an
+ item of childURLs. Assert: childModule is a module script (i.e., it is not " For each childModule of
+ childModules: If discoveredSet already contains
- childModule, continue. Assert: childModule is a module script (i.e., it is not " Let childParseError be the result of finding the first parse
- error given childModule and discoveredSet. If discoveredSet already contains
+ childModule, continue. If childParseError is not null, return childParseError. Let childParseError be the result of finding the first parse
+ error given childModule and discoveredSet. If childParseError is not null, return childParseError.
+
-
fetching" or null); by now all module
- scripts in the graph rooted at moduleScript will have successfully been
- fetched.
+
+ fetching" or null); by now all module
+ scripts in the graph rooted at moduleScript will have successfully been
+ fetched.
Return script.
To create a module script, given a - JavaScript string source, an environment settings object - settings, a URL baseURL, and some script fetch - options options:
+To create a JavaScript module script, + given a JavaScript string source, an environment settings + object settings, a URL baseURL, and some script + fetch options options:
If scripting is disabled for @@ -88519,6 +88630,53 @@ interface ApplicationCache : EventTarget {
Return script.
To create a JSON module script, given a + string source and an environment settings object settings:
+ +Let script be a new module script that this algorithm will + subsequently initialize.
Set script's settings object to settings.
Set script's base URL and + fetch options to null.
Set script's parse error and + error to rethrow to null.
Let json be ? Call(%JSONParse%, undefined, + « source »).
+ +If this throws an exception, set script's parse error to that exception, and return + script.
+Set script's record to the result + of creating a synthetic + module record with a default export of json with settings.
Return script.
To create a synthetic module record with a default export of a JavaScript value + value with an environment settings object settings:
+ +Return CreateSyntheticModule(« "default" », the following steps, + settings's Realm, + value) with the following steps given module as an argument:
+ +To run a classic script given a classic script @@ -89631,6 +89789,9 @@ import "https://example.com/foo/../module2.mjs";
Set base URL to referencing script's base URL.
Assert: base URL is not null, as referencing script is a + classic script or a JavaScript module script.
Set fetch options to the descendant script fetch options for referencing script's fetch options.
Assert: Neither base URL nor fetch options is null, as + referencing script is a classic script or a JavaScript module + script.
As explained above for HostResolveImportedModule, in the common @@ -89769,6 +89934,10 @@ import "https://example.com/foo/../module2.mjs";
Let module script be moduleRecord.[[HostDefined]].
Assert: module script's base + URL is not null, as module script is a JavaScript module + script.
Let urlString be module script's base URL, serialized.
Let base URL be initiating script's base URL.
Assert: base URL is not null, as initiating script is a + classic script or a JavaScript module script.
Let fetch options be a script fetch options whose cryptographic nonce is initiating @@ -123371,7 +123543,6 @@ INSERT INTERFACES HERE Cyrille Tuzi, Daksh Shah, Dan Callahan, - Dan Ehrenberg, Dan Yoder, Dane Foster, Daniel Barclay, @@ -123381,6 +123552,7 @@ INSERT INTERFACES HERE Daniel Buchner, Daniel Cheng, Daniel Davis, + Daniel Ehrenberg, Daniel Glazman, Daniel Holbert, Daniel Peng, @@ -123856,6 +124028,7 @@ INSERT INTERFACES HERE 邱慕安 (Mu-An Chiou), Mukilan Thiyagarajan, Mustaq Ahmed, + Myles Borins, Nadia Heninger, NARUSE Yui, Navid Zolghadr,