From 914e7d5cba1718a6ef1f4937cb076bf46a74c7f0 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 17 Jun 2020 16:56:31 -0700 Subject: [PATCH 01/56] Reland JSON modules Reland JSON modules by reverting a530f6fe47e1f1e09f2a0b47634693f590432b83, resolving merge conflicts, and updating the change with respect to the string changes in a9ef15d6ea4ca7db9acead6ce0111475da4a0c3e. --- source | 335 ++++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 250 insertions(+), 85 deletions(-) diff --git a/source b/source index bd7ac3fb749..11c3d2ad1aa 100644 --- a/source +++ b/source @@ -2635,6 +2635,9 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
  • converting to a sequence of Unicode scalar values
  • overload resolution algorithm
    • +
  • CreateSyntheticModule
    • +
  • SetSyntheticModuleExport
    • +
  • Synthetic Module Record
  • exposed
  • [LegacyFactoryFunction]
  • [LegacyLenientThis]
    • @@ -57042,11 +57045,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 can be embedded inline, or 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.

    + 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 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 @@ -57310,7 +57320,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>
    @@ -57321,37 +57331,37 @@ o............A....e

    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 defer 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.

    + data-x="">module    " will be fetched and evaluated (as a JavaScript module + script). Conversely, older user agents will ignore 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.

    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">
@@ -57383,12 +57393,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>
    @@ -86151,7 +86179,7 @@ interface ApplicationCache : EventTarget {
    Definitions
    -

    A script is one of two possible A script is one of three possible structs. All scripts have:

    @@ -86162,10 +86190,22 @@ interface ApplicationCache : EventTarget {
    A record
    -

    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.

      • +
    +
    A parse error
    @@ -86228,6 +86268,35 @@ interface ApplicationCache : EventTarget { data-x="concept-script">script. It has no additional items.

    +

    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:

      @@ -86795,8 +86864,8 @@ interface ApplicationCache : EventTarget { success).

        -

      1. Let script be the result of creating a module script using - source text, settings object, base URL, and +

      2. Let script be the result of creating a JavaScript module script + using source text, settings object, base URL, and options.

      3. If script is null, asynchronously complete this algorithm with null, and abort @@ -87047,8 +87116,8 @@ interface ApplicationCache : EventTarget {

      4. Let options be the descendant script fetch options for module script's fetch options.

        5. -

      5. Assert: options is not null, as module script is a module - script.

        6. +

      6. Assert: options is not null, as module script is a JavaScript + module script.

      7. For each url in urls, perform the @@ -87169,25 +87238,53 @@ interface ApplicationCache : EventTarget {

      8. response's status is not an ok status

        9. + + -
      9. -

        The result of extracting a MIME type from - response's header list is not a - JavaScript MIME type

        +
      10. +

        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.

        -
        11. - +

        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.

        -

      11. Let source text be the result of UTF-8 - decoding response's body.

        12. +
      12. +

        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.

        +
        13. + +
      13. +

        If type is a JavaScript MIME type, then:

        + +
          +

        1. Let source text be the result of UTF-8 + decoding response's body.

          2. + +

        2. Set module script to the result of creating a JavaScript module + script given source text, module map settings object, + response's url, and + options.

          3. +
        +
        14. + +
      14. +

        If type is a JSON MIME type, then:

        -

      15. Let module script be the result of creating a module script given - source text, module map settings object, response's url, and options.

        16. +
          +

        1. Let source text be the result of UTF-8 + decoding response's body.

          2. + +

        2. Set module script to the result of creating a JSON module + script given source text and module map settings object.

          3. +
        +

      16. Set moduleMap[url] to module @@ -87217,36 +87314,43 @@ interface ApplicationCache : EventTarget { then return moduleScript's parse error.

        17. -

      17. Let childSpecifiers be the value of moduleScript's record's [[RequestedModules]] internal slot.

        18. +
      18. +

        If moduleScript's record is a + Cyclic Module Record:

        -

      19. 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.)

        20. +
          +

        1. Let childSpecifiers be the value of moduleScript's record's [[RequestedModules]] internal slot.

          2. -

        2. Let childModules be the list obtained by getting each value in moduleMap whose key is given by an - item of childURLs.

          3. +

        3. 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.)

          4. -
        4. -

          For each childModule of - childModules:

          +

        5. Let childModules be the list obtained by getting each value in moduleMap whose key is given by an + item of childURLs.

          6. -
            -

          1. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module - scripts in the graph rooted at moduleScript will have successfully been - fetched.

            2. +
          2. +

            For each childModule of + childModules:

            + +
              +

            1. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module + scripts in the graph rooted at moduleScript will have successfully been + fetched.

              2. -

            2. If discoveredSet already contains - childModule, continue.

              3. +

            3. If discoveredSet already contains + childModule, continue.

              4. -

            4. Let childParseError be the result of finding the first parse - error given childModule and discoveredSet.

              5. +

            5. Let childParseError be the result of finding the first parse + error given childModule and discoveredSet.

              6. -

            6. If childParseError is not null, return childParseError.

              7. +

            7. If childParseError is not null, return childParseError.

              8. +
            +
          @@ -87309,10 +87413,10 @@ interface ApplicationCache : EventTarget {

        6. Return script.

        -

        To create a module script, given a - string source, an environment settings object - settings, a URL baseURL, and some script fetch - options options:

        +

        To create a JavaScript module script, + given a string source, an environment settings + object settings, a URL baseURL, and some script + fetch options options:

        1. If scripting is disabled for @@ -87387,6 +87491,53 @@ interface ApplicationCache : EventTarget {

        2. Return script.

        +

        To create a JSON module script, given a + string source and an environment settings object settings:

        + +
          +

        1. Let script be a new module script that this algorithm will + subsequently initialize.

          2. + +

        2. Set script's settings object to settings.

          3. + +

        3. Set script's base URL and + fetch options to null.

          4. + +

        4. Set script's parse error and + error to rethrow to null.

          5. + +
        5. +

          Let json be ? Call(%JSONParse%, undefined, + « source »).

          + +

          If this throws an exception, set script's parse error to that exception, and return + script.

          +
          6. + +

        6. Set script's record to the result + of creating a synthetic + module record with a default export of json with settings.

          7. + +

        7. Return script.

          8. +
        + +

        To create a synthetic module record with a default export of a JavaScript value + value with an environment settings object settings:

        + +
          +
        1. +

          Return CreateSyntheticModule(« "default" », the following steps, + settings's Realm, + value) with the following steps given module as an argument:

          + +
            +
          1. SetSyntheticModuleExport(module, "default", + module.[[HostDefined]]).
            2. +
          +
          2. +
        +
        Calling scripts

        To run a classic script given a classic script @@ -88491,6 +88642,9 @@ import "https://example.com/foo/../module2.mjs";

      20. Set base URL to referencing script's base URL.

        21. + +

      21. Assert: base URL is not null, as referencing script is a + classic script or a JavaScript module script.

      @@ -88564,6 +88718,10 @@ import "https://example.com/foo/../module2.mjs";

    1. Set fetch options to the descendant script fetch options for referencing script's fetch options.

      2. + +

    2. 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 @@ -88612,6 +88770,10 @@ import "https://example.com/foo/../module2.mjs";

    1. Let module script be moduleRecord.[[HostDefined]].

      2. +

    2. Assert: module script's base + URL is not null, as module script is a JavaScript module + script.

      3. +

    3. Let urlString be module script's base URL, serialized.

      4. @@ -92095,6 +92257,9 @@ enum DOMParserSupportedType {

    4. Let base URL be initiating script's base URL.

      5. +

    5. Assert: base URL is not null, as initiating script is a + classic script or a JavaScript module script.

      6. +

    6. Let fetch options be a script fetch options whose cryptographic nonce is initiating From b058240e31d99d1c1b7233a4ce01458231a74480 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 18 Jun 2020 14:06:51 -0700 Subject: [PATCH 02/56] Add import attribute type checks and initial plumbing. Update all [[RequestedModules]] references to reflect the change from string to ModuleRequest. Pass ModuleRequest instead of url to 'internal module graph fetching procedure'. Add optional ModuleRequest param to 'fetch a single module script'. Add checks in 'fetch a single module script' to fail if the type doesn't match. --- source | 109 ++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 77 insertions(+), 32 deletions(-) diff --git a/source b/source index 11c3d2ad1aa..7dc91b17412 100644 --- a/source +++ b/source @@ -2776,6 +2776,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

    7. The Source Text Module Record specification type and its Evaluate and Link methods
      8. +
    8. The ModuleRequest Record specification type
    9. The ArrayCreate abstract operation
    10. The Call abstract operation
      11. @@ -57408,7 +57409,7 @@ o............A....e a JavaScript module script:

      <script type="module">
-import peopleInSpace from "http://api.open-notify.org/astros.json";
+import peopleInSpace from "http://api.open-notify.org/astros.json" if { type: "json" };
 
 const list = document.querySelector("#people-in-space");
 for (const { craft, name } of peopleInSpace.people) {
@@ -87083,16 +87084,17 @@ interface ApplicationCache : EventTarget {
    record.[[RequestedModules]] is empty,
    asynchronously complete this algorithm with module script.
      
 
-   
    11. Let urls be a new empty list.
      12. 
+   
    12. Let moduleRequests be a new empty list.
      13. 
 
    
    13. 
-    
      For each string requested of
-    record.[[RequestedModules]],
      
+    
      For each ModuleRequest Record
+    requested of record.[[RequestedModules]],
      
 
     
        
      
      1. Let url be the result of resolving
      a module specifier given module script's base URL and requested.
        2. 
+     data-x="concept-script-base-url">base URL and requested.[[Specifier]].
        
+     
 
      
      2. Assert: url is never failure, because resolving a module specifier must have been ApplicationCache : EventTarget {
       url, then:
        
 
       
          
-       
        1. Append url to urls.
          2. 
+       
        2. Append requested to
+       moduleRequests.
          3. 
 
        
        3. Append url to visited
        set.
          4. 
@@ -87120,11 +87123,12 @@ interface ApplicationCache : EventTarget {
    module script.
          
 
    
        4. 
-    
          For each url in urls, perform the
-    internal module script graph fetching procedure given url, fetch
-    client settings object, destination, options, module
-    script's settings object, visited set, and module
-    script's base URL. If the caller of this
+    
          For each moduleRequest in
+    moduleRequests, perform the internal module script graph fetching
+    procedure given moduleRequest, fetch client settings object,
+    destination, options, module script's settings
+    object, visited set, and module script's base URL. If the caller of this
     algorithm specified custom perform the
     fetch steps, pass those along while performing the internal module script graph
     fetching procedure.
          
@@ -87143,21 +87147,30 @@ interface ApplicationCache : EventTarget {
   
        
 
   
        To perform the internal module script graph fetching procedure given a
-  url, a fetch client settings object, a destination, some
-  options, a module map settings object, a visited set, and a
+  moduleRequest, a fetch client settings object, a destination,
+  some options, a module map settings object, a visited set, and a
   referrer, perform these steps. The algorithm will asynchronously complete with either
   null (on failure) or a module script (on success).
        
 
   
          
+   
        1. Let url be the result of resolving
+   a module specifier given referrer and
+   moduleRequst.[[Specifier]].
          2. 
+
+   
        2. Assert: url is never failure, because resolving a module specifier must have been previously successful with these same two
+   arguments.
          3. 
+
    
        3. Assert: visited set contains
    url.
          4. 
 
    
        4. Fetch a single module script given url, fetch client settings
    object, destination, options, module map settings object,
-   referrer, and with the top-level module fetch flag unset. If the caller of
-   this algorithm specified custom perform the
-   fetch steps, pass those along while fetching a
-   single module script.
          
+   referrer, moduleRequest, and with the
+   top-level module fetch flag unset. If the caller of this algorithm specified custom
+   perform the fetch steps, pass those along
+   while fetching a single module script.
          
 
    
        5. Return from this algorithm, and run the following steps when fetching a single module script asynchronously completes with
@@ -87176,11 +87189,21 @@ interface ApplicationCache : EventTarget {
 
   
          To fetch a single module script, given a url, a fetch client
   settings object, a destination, some options, a module map
-  settings object, a referrer, and a top-level module fetch flag, run
-  these steps. The algorithm will asynchronously complete with either null (on failure) or a
-  module script (on success).
          
+  settings object, a referrer, an optional moduleRequest, and
+  a top-level module fetch flag, run these steps. The algorithm will asynchronously
+  complete with either null (on failure) or a module script (on success).
          
 
   
            
+   
          1. 
+    
            If moduleRequest was given and if moduleRequest.[[Attributes]]
+    has a Record entry such that entry.[[Key]] is "type", then
+    let module type be entry.[[Value]]
            
+    
            Otherwise let module type be undefined.
            
+   
            2. 
+
+   
          2. If module type is neither undefined nor "json", asynchronously complete this algorithm
+   with null, and abort these steps
            3. 
+
    
          3. Let moduleMap be module map settings object's module map.
            4. 
 
@@ -87188,9 +87211,27 @@ interface ApplicationCache : EventTarget {
    in parallel until that entry's value changes, then queue a task on
    the networking task source to proceed with running the following steps.
            
 
-   
          4. If moduleMap[url] exists,
-   asynchronously complete this algorithm with moduleMap[url], and abort
-   these steps.
            5. 
+   
          5. 
+    
            If moduleMap[url] exists, then:
            
+
+    
              
+     
            1. 
+      
              If any of the following conditions are met, asynchronously complete this algorithm
+       with moduleMap[url], and abort these steps.
              
+
+      
                
+       
              • moduleMap[url] is a JavaScript module script
+       and module type is undefined.
                • 
+
+       
              • moduleMap[url] is a JSON module script
+       and module type is "json".
                • 
+      
              
+     
              2. 
+
+     
            2. Otherwise, asynchronously complete this algorithm with null, and abort these steps
              
+     
              3. 
+    
            
+   
            6. 
 
    
          6. Set moduleMap[url] to "fetching".
            
@@ -87242,7 +87283,7 @@ interface ApplicationCache : EventTarget {
    
            7. 
 
    
          7. 
-    
            Let type be the result of extracting a
+    
            Let MIME type be the result of extracting a
     MIME type from response's header
     list.
            
 
@@ -87261,7 +87302,8 @@ interface ApplicationCache : EventTarget {
    
            8. 
 
    
          8. 
-     
            If type is a JavaScript MIME type, then:
            
+     
            If MIME type is a JavaScript MIME type and module type is
+     undefined, then:
            
 
      
              
       
            1. Let source text be the result of UTF-8
@@ -87275,7 +87317,8 @@ interface ApplicationCache : EventTarget {
    
              2. 
 
    
            2. 
-     
              If type is a JSON MIME type, then:
              
+     
              If MIME type is a JSON MIME type and module type is
+     "json", then:
              
 
      
                
       
              1. Let source text be the result of UTF-8
@@ -87319,12 +87362,13 @@ interface ApplicationCache : EventTarget {
     Cyclic Module Record:
                
 
     
                  
-     
                1. Let childSpecifiers be the value of moduleScript's 
                  Let moduleRequests be the value of moduleScript's record's [[RequestedModules]] internal slot.
                  2. 
 
      
                2. 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.
+     resolve a module specifier once for each item moduleRequest of
+     moduleRequest, given moduleScript's base URL and moduleRequest.[[Specifier]].
      (None of these will ever fail, as otherwise moduleScript would have been marked as
      itself having a parse error.)
                  3. 
 
@@ -87457,13 +87501,13 @@ interface ApplicationCache : EventTarget {
    
 
    
                3. 
-    
                  For each string requested of
-    result.[[RequestedModules]]:
                  
+    
                  For each ModuleRequest record
+    requested of result.[[RequestedModules]]:
                  
 
     
                    
      
                  1. Let url be the result of resolving
      a module specifier given script's base
-     URL and requested.
                    2. 
+     URL and requested.[[Specifier]].
                    
 
      
                  2. 
       
                    If url is failure, then:
                    
@@ -121394,6 +121438,7 @@ INSERT INTERFACES HERE
   Daniel Brumbaugh Keeney,
   Daniel Buchner,
   Daniel Cheng,
+  Daniel Clark, 
   Daniel Davis,
   Daniel Ehrenberg,
   Daniel Glazman,

From d0137f5478da1e5c9c61cd3df02fd276ecf74e0e Mon Sep 17 00:00:00 2001
From: Daniel Clark 
Date: Thu, 18 Jun 2020 16:15:15 -0700
Subject: [PATCH 03/56] Plumb through ModuleRequest instead of string for
 'fetch an import() module script graph', HostResolveImportedModule, and
 HostResolveImportedModuleDynamically.

---
 source | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/source b/source
index 7dc91b17412..39a3f657c01 100644
--- a/source
+++ b/source
@@ -86795,24 +86795,25 @@ interface ApplicationCache : EventTarget {
    result.
                    3. 
   
                  
 
-  
                  To fetch an import() module script graph given a specifier, a base
-  URL, a settings object, and some options, run these steps. The
-  algorithm will asynchronously complete with either null (on failure) or a module
+  
                  To fetch an import() module script graph given a moduleRequest, a
+  base URL, a settings object, and some options, run these steps.
+  The algorithm will asynchronously complete with either null (on failure) or a module
   script (on success).
                  
 
   
                    
    
                  1. Let url be the result of resolving a
-   module specifier given base URL and specifier.
                    2. 
+   module specifier given base URL and moduleRequest.[[Specifier]].
                    
+   
 
    
                  2. If url is failure, then asynchronously complete this algorithm with null, and
    abort these steps.
                    3. 
 
    
                  3. Fetch a single module script given url, settings
    object, "script", options, settings object,
-   "client", and with the top-level module fetch flag set. If the
-   caller of this algorithm specified custom perform
-   the fetch steps, pass those along as well. Wait until the algorithm asynchronously
-   completes with result.
                    4. 
+   "client", moduleRequest, and with the top-level module
+   fetch flag set. If the caller of this algorithm specified custom perform the fetch steps, pass those along as well.
+   Wait until the algorithm asynchronously completes with result.
                    
 
    
                  4. If result is null, asynchronously complete this algorithm with null, and abort
    these steps.
                    5. 
@@ -88662,7 +88663,7 @@ import "https://example.com/foo/../module2.mjs";
      14. HostResolveImportedModule(referencingScriptOrModule, - specifier)
      + moduleRequest)

      JavaScript contains an implementation-defined HostResolveImportedModule abstract operation. User @@ -88710,7 +88711,8 @@ import "https://example.com/foo/../module2.mjs"; data-x="concept-settings-object-module-map">module map.

    14. Let url be the result of resolving a - module specifier given base URL and specifier.

      15. + module specifier given base URL and moduleRequest.[[Specifier]].

      +

    15. Assert: url is never failure, because resolving a module specifier must have been previously successful with these @@ -88731,7 +88733,7 @@ import "https://example.com/foo/../module2.mjs";

    HostImportModuleDynamically(referencingScriptOrModule, - specifier, promiseCapability)
    + moduleRequest, promiseCapability)

    JavaScript contains an implementation-defined HostImportModuleDynamically abstract operation. @@ -88772,9 +88774,9 @@ import "https://example.com/foo/../module2.mjs"; case, referencingScriptOrModule is non-null.

    • -

  • Fetch an import() module script graph given specifier, base - URL, settings object, and fetch options. Wait until the algorithm - asynchronously completes with result.

    • +

  • Fetch an import() module script graph given moduleRequest, + base URL, settings object, and fetch options. Wait until the + algorithm asynchronously completes with result.

  • If result is null, then:

    @@ -88784,7 +88786,7 @@ import "https://example.com/foo/../module2.mjs"; TypeError, [[Target]]: empty }.

  • Perform FinishDynamicImport(referencingScriptOrModule, - specifier, promiseCapability, completion).

    • + moduleRequest, promiseCapability, completion).

  • Return.

    • @@ -88794,11 +88796,11 @@ import "https://example.com/foo/../module2.mjs"; the rethrow errors boolean set to true.

  • If running the module script throws an exception, then perform - FinishDynamicImport(referencingScriptOrModule, specifier, + FinishDynamicImport(referencingScriptOrModule, moduleRequest, promiseCapability, the thrown exception completion).

  • Otherwise, perform - FinishDynamicImport(referencingScriptOrModule, specifier, + FinishDynamicImport(referencingScriptOrModule, moduleRequest, promiseCapability, NormalCompletion(undefined)).

  • Return undefined.

    • From b2e7065117775e10dd1767bbe4466ecb7ca71e31 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 18 Jun 2020 16:47:42 -0700 Subject: [PATCH 04/56] Don't cache a null entry in the module map in the case where the MIME type is valid but doesn't match the requested type. --- source | 54 +++++++++++++++++++++++++++++++++--------------------- 1 file changed, 33 insertions(+), 21 deletions(-) diff --git a/source b/source index 39a3f657c01..c59c4290858 100644 --- a/source +++ b/source @@ -87297,37 +87297,49 @@ interface ApplicationCache : EventTarget {

  • 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.

    +
    +

    If the resource does not have a MIME type which HTML knows how to handle + as a module or if the MIME type does not match the type specified in moduleRequest, + then module script will remain null, which is interpreted as failure.

    + +

    In the former case where a non-module MIME type is received, a null entry is added to + moduleMap so that future attempts to fetch a module at url will always + fail. On the other hand for the case where the MIME type is valid but does not match the + requested module type, nothing is cached in moduleMap, meaning that + future attempts to fetch the same url in another module graph could succeed if the correct + type were specified.

    +
  • -

    If MIME type is a JavaScript MIME type and module type is - undefined, then:

    +

    If MIME type is a JavaScript MIME type, then:

    -
      -

    1. Let source text be the result of UTF-8 - decoding response's body.

      2. +
        +

      1. If module type is not undefined, asynchronously complete this algorithm with + null, and abort these steps.

        2. -

      2. Set module script to the result of creating a JavaScript module - script given source text, module map settings object, - response's url, and - options.

        3. -
      +

    2. Let source text be the result of UTF-8 + decoding response's body.

      3. + +

    3. Set module script to the result of creating a JavaScript module + script given source text, module map settings object, + response's url, and + options.

      4. +
  • -

    If MIME type is a JSON MIME type and module type is - "json", then:

    +

    If MIME type is a JSON MIME type, then:

    +
      +

    1. If module type is not "json", asynchronously complete + this algorithm with null, and abort these steps.

      2. -
        -

      1. Let source text be the result of UTF-8 - decoding response's body.

        2. +

      2. Let source text be the result of UTF-8 + decoding response's body.

        3. -

      3. Set module script to the result of creating a JSON module - script given source text and module map settings object.

        4. -
      +

    2. Set module script to the result of creating a JSON module + script given source text and module map settings object.

      3. +
  • From 0cbf597276299bee4730ff593507d6bbd517d9c2 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 19 Jun 2020 10:07:50 -0700 Subject: [PATCH 05/56] Allow modulepreload to work for all module types without needing to specify type at the point of preload. Achieve this by adding 'module type must match' flag to 'fetch a single module script', which is unset only in the case of modulepreload. --- source | 59 ++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 33 insertions(+), 26 deletions(-) diff --git a/source b/source index c59c4290858..18c0f5a1cde 100644 --- a/source +++ b/source @@ -86778,10 +86778,10 @@ interface ApplicationCache : EventTarget {

    1. Fetch a single module script given url, settings object, "script", options, settings object, - "client", and with the top-level module fetch flag set. If the - caller of this algorithm specified custom perform - the fetch steps, pass those along as well. Wait until the algorithm asynchronously - completes with result.

      2. + "client", with the module type must match flag set, and with + the top-level module fetch flag set. If the caller of this algorithm specified custom + perform the fetch steps, pass those along as + well. Wait until the algorithm asynchronously completes with result.

    2. If result is null, asynchronously complete this algorithm with null, and abort these steps.

      3. @@ -86810,10 +86810,11 @@ interface ApplicationCache : EventTarget {

    3. Fetch a single module script given url, settings object, "script", options, settings object, - "client", moduleRequest, and with the top-level module - fetch flag set. If the caller of this algorithm specified custom perform the fetch steps, pass those along as well. - Wait until the algorithm asynchronously completes with result.

      4. + "client", moduleRequest, with the module type must + match flag set, and with the top-level module fetch flag set. If the caller of + this algorithm specified custom perform the + fetch steps, pass those along as well. Wait until the algorithm asynchronously completes + with result.

    4. If result is null, asynchronously complete this algorithm with null, and abort these steps.

      5. @@ -86835,14 +86836,15 @@ interface ApplicationCache : EventTarget {

      1. Fetch a single module script given url, settings object, destination, options, settings object, "client", and with the top-level module fetch flag set. Wait until - algorithm asynchronously completes with result.

        2. + data-x="">client", with the module type must match flag unset, and with the + top-level module fetch flag set. Wait until algorithm asynchronously completes with + result.

      2. Asynchronously complete this algorithm with result, but do not abort these steps.

      3. -

        Optionally, perform the following steps:

        +

        If result is not null, optionally perform the following steps:

        1. Let visited set be « url ».

          2. @@ -86900,10 +86902,10 @@ interface ApplicationCache : EventTarget {

        2. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, - "client", and with the top-level module fetch flag set. If the - caller of this algorithm specified custom perform - the fetch steps, pass those along as well. Wait until the algorithm asynchronously - completes with result.

          3. + "client", with the module type must match flag set, and with + the top-level module fetch flag set. If the caller of this algorithm specified custom + perform the fetch steps, pass those along as + well. Wait until the algorithm asynchronously completes with result.

        3. If result is null, asynchronously complete this algorithm with null, and abort these steps.

          4. @@ -87168,10 +87170,11 @@ interface ApplicationCache : EventTarget {

        4. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, - referrer, moduleRequest, and with the - top-level module fetch flag unset. If the caller of this algorithm specified custom - perform the fetch steps, pass those along - while fetching a single module script.

          + referrer, moduleRequest, with the module type must match flag + set, and with the top-level module fetch flag unset. If the caller of this algorithm + specified custom perform the fetch steps, + pass those along while fetching a single module + script.

        5. Return from this algorithm, and run the following steps when fetching a single module script asynchronously completes with @@ -87190,9 +87193,10 @@ interface ApplicationCache : EventTarget {

          To fetch a single module script, given a url, a fetch client settings object, a destination, some options, a module map - settings object, a referrer, an optional moduleRequest, and - a top-level module fetch flag, run these steps. The algorithm will asynchronously - complete with either null (on failure) or a module script (on success).

          + settings object, a referrer, an optional moduleRequest, a + module type must match flag, and a top-level module fetch flag, run these + steps. The algorithm will asynchronously complete with either null (on failure) or a + module script (on success).

          1. @@ -87221,6 +87225,8 @@ interface ApplicationCache : EventTarget { with moduleMap[url], and abort these steps.

              +

            • The module type must match flag is unset.

              • +

            • moduleMap[url] is a JavaScript module script and module type is undefined.

              • @@ -87315,8 +87321,8 @@ interface ApplicationCache : EventTarget {

              If MIME type is a JavaScript MIME type, then:

                -

              1. If module type is not undefined, asynchronously complete this algorithm with - null, and abort these steps.

                2. +

              2. If the module type must match flag is set and module type is not + undefined, asynchronously complete this algorithm with null, and abort these steps.

              3. Let source text be the result of UTF-8 decoding response's body.

                4. @@ -87331,8 +87337,9 @@ interface ApplicationCache : EventTarget {

              4. If MIME type is a JSON MIME type, then:

                  -

                1. If module type is not "json", asynchronously complete - this algorithm with null, and abort these steps.

                  2. +

                2. If the module type must match flag is set and module type is not + "json", asynchronously complete this algorithm with null, and abort + these steps.

                3. Let source text be the result of UTF-8 decoding response's body.

                  4. From 69320747089a1c3c43e9d14077620dd1e2e823d7 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 19 Jun 2020 11:33:05 -0700 Subject: [PATCH 06/56] After rebase, fix build break from name change to JSON.Parse in https://github.com/whatwg/html/commit/b1078ae50e1b08a2ab1592efab36d417444c8313 --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 18c0f5a1cde..1b7e9f911a8 100644 --- a/source +++ b/source @@ -87571,7 +87571,7 @@ interface ApplicationCache : EventTarget { error to rethrow to null.

                4. -

                  Let json be ? Call(%JSONParse%, undefined, +

                  Let json be ? Call(%JSON.Parse%, undefined, « source »).

                  If this throws an exception, set script's Date: Mon, 22 Jun 2020 11:37:00 -0700 Subject: [PATCH 07/56] Fix typo in JSON modules example and add note on requiring JSON MIME type. --- source | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/source b/source index 1b7e9f911a8..03d4602a4fc 100644 --- a/source +++ b/source @@ -57405,7 +57405,7 @@ o............A....e

                  -

                  The following sample shows how to you can import a JSON module script from inside +

                  The following sample shows how a JSON module script can be imported from inside a JavaScript module script:

                  <script type="module">
@@ -57419,6 +57419,13 @@ for (const { craft, name } of peopleInSpace.people) {
 }
 </script>
                  +

                  MIME type checking for module scripts is strict. In order for the fetch of the + JSON module script to succeed, the HTTP reponse must have a + JSON MIME type, for example Content-Type: text/json. On the + other hand, if the if { type: "json" } part of the statement is omitted, + it is assumed that the intent is to import a JavaScript module script, and the fetch + will fail if the HTTP response has a MIME type that is not a JavaScript MIME type. +

                  @@ -87235,7 +87242,7 @@ interface ApplicationCache : EventTarget {
            2. -

          2. Otherwise, asynchronously complete this algorithm with null, and abort these steps

            +

          3. Otherwise, asynchronously complete this algorithm with null, and abort these steps.

          6. From a3621dd6a43ab0b0471c8f97cd9632fff6283795 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 22 Jun 2020 12:27:48 -0700 Subject: [PATCH 08/56] Update ModuleRequest definition to reference the import-attributes proposal spec --- source | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/source b/source index 03d4602a4fc..97420a32059 100644 --- a/source +++ b/source @@ -2776,7 +2776,6 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
        6. The Source Text Module Record specification type and its Evaluate and Link methods
          7. -
        7. The ModuleRequest Record specification type
        8. The ArrayCreate abstract operation
        9. The Call abstract operation
          10. @@ -2858,6 +2857,14 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
        10. The HostGetImportMetaProperties abstract operation
          11. +

          User agents that support JavaScript must also implement the import attributes + proposal. The following term is defined there, and used in this specification:

          + +
            +
          • The ModuleRequest Record specification type
            • +
          +

          Users agents that support JavaScript must also implement ECMAScript Internationalization API.

          @@ -120939,6 +120946,9 @@ INSERT INTERFACES HERE
          [JSERRORSTACKS]
          (Non-normative) Error Stacks. Ecma International.
          +
          [JSIMPORTATTRIBUTES]
          +
          Import Attributes. Ecma International.
          +
          [JSIMPORTMETA]
          import.meta. Ecma International.
          From 55ebd12561f803f3caff4beb6f6b992069ec7853 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 22 Jun 2020 12:31:29 -0700 Subject: [PATCH 09/56] Revert added null check in 'fetch a modulepreload module script graph'; I'll add this in a separate PR. --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 97420a32059..18a58a9c7d5 100644 --- a/source +++ b/source @@ -86858,7 +86858,7 @@ interface ApplicationCache : EventTarget { these steps.

        11. -

          If result is not null, optionally perform the following steps:

          +

          Optionally, perform the following steps:

          1. Let visited set be « url ».

            2. From af41b281a413b697296d1ee1f1c0cc036dc47509 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 22 Jun 2020 13:16:58 -0700 Subject: [PATCH 10/56] Reference ParseJSONModule from import-attributes proposal instead of defining steps in HTML spec --- source | 28 ++++------------------------ 1 file changed, 4 insertions(+), 24 deletions(-) diff --git a/source b/source index 18a58a9c7d5..ca4dd18761e 100644 --- a/source +++ b/source @@ -2635,8 +2635,6 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
          2. converting to a sequence of Unicode scalar values
          3. overload resolution algorithm
            4. -
          4. CreateSyntheticModule
            5. -
          5. SetSyntheticModuleExport
          6. Synthetic Module Record
          7. exposed
          8. [LegacyFactoryFunction]
            9. @@ -2858,11 +2856,12 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

            User agents that support JavaScript must also implement the import attributes - proposal. The following term is defined there, and used in this specification:

            • The ModuleRequest Record specification type
              • +
            • The ParseJSONModule abstract operation

            Users agents that support JavaScript must also implement ECMAScript @@ -87585,37 +87584,18 @@ interface ApplicationCache : EventTarget { error to rethrow to null.

          9. -

            Let json be ? Call(%JSON.Parse%, undefined, - « source »).

            +

            Let result be ParseJSONModule(source).

            If this throws an exception, set script's parse error to that exception, and return script.

            10. -

          10. Set script's record to the result - of creating a synthetic - module record with a default export of json with settings.

            11. +

          11. Set script's record to result.

          12. Return script.

          -

          To create a synthetic module record with a default export of a JavaScript value - value with an environment settings object settings:

          - -
            -
          1. -

            Return CreateSyntheticModule(« "default" », the following steps, - settings's Realm, - value) with the following steps given module as an argument:

            - -
              -
            1. SetSyntheticModuleExport(module, "default", - module.[[HostDefined]]).
              2. -
            -
            2. -
          -
          Calling scripts

          To run a classic script given a classic script From a2d42607ad7241e9ce4827d2e3224035305582ca Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 23 Jun 2020 10:13:45 -0700 Subject: [PATCH 11/56] Cache an entry in the module map if the fetched module was valid but does not match the type specified at the import site. --- source | 36 ++++++++++++++++++++++++------------ 1 file changed, 24 insertions(+), 12 deletions(-) diff --git a/source b/source index ca4dd18761e..b5b03d8c56e 100644 --- a/source +++ b/source @@ -87319,14 +87319,14 @@ interface ApplicationCache : EventTarget {

          If the resource does not have a MIME type which HTML knows how to handle as a module or if the MIME type does not match the type specified in moduleRequest, - then module script will remain null, which is interpreted as failure.

          + then this algorithm will complete with null, which is interpreted as failure.

          In the former case where a non-module MIME type is received, a null entry is added to moduleMap so that future attempts to fetch a module at url will always fail. On the other hand for the case where the MIME type is valid but does not match the - requested module type, nothing is cached in moduleMap, meaning that - future attempts to fetch the same url in another module graph could succeed if the correct - type were specified.

          + requested module type, module script is cached in moduleMap, + meaning that future attempts to fetch the same url in another module graph could succeed if the + correct type were specified, without triggering another network request.

          12. @@ -87334,9 +87334,6 @@ interface ApplicationCache : EventTarget {

          If MIME type is a JavaScript MIME type, then:

            -

          1. If the module type must match flag is set and module type is not - undefined, asynchronously complete this algorithm with null, and abort these steps.

            2. -

          2. Let source text be the result of UTF-8 decoding response's body.

            3. @@ -87350,10 +87347,6 @@ interface ApplicationCache : EventTarget {

          3. If MIME type is a JSON MIME type, then:

              -

            1. If the module type must match flag is set and module type is not - "json", asynchronously complete this algorithm with null, and abort - these steps.

              2. -

            2. Let source text be the result of UTF-8 decoding response's body.

              3. @@ -87364,7 +87357,7 @@ interface ApplicationCache : EventTarget {

            3. Set moduleMap[url] to module - script, and asynchronously complete this algorithm with module script.

              + script

              It is intentional that the module map is keyed by the request URL, whereas the ApplicationCache : EventTarget { set to the response URL. The former is used to deduplicate fetches, while the latter is used for URL resolution.

              4. + + +
            4. +

              If any of the following conditions are met, asynchronously complete this algorithm + with module script.

              + +
                +

              • The module type must match flag is unset.

                • + +

              • module script is a JavaScript module script + and module type is undefined.

                • + +

              • module script is a JSON module script + and module type is "json".

                • +
              + +

              Otherwise, asynchronously complete this algorithm with null.

              +
              5. +

            To find the first parse error given a root From f79c01f2a77f1ccaf9d4aa68da70b1eedac251fe Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 23 Jun 2020 11:02:38 -0700 Subject: [PATCH 12/56] Extend note to be clear that the module must have no effect until a request matches its type and it is evalutated --- source | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/source b/source index b5b03d8c56e..6c5d18e19b4 100644 --- a/source +++ b/source @@ -87326,7 +87326,10 @@ interface ApplicationCache : EventTarget { fail. On the other hand for the case where the MIME type is valid but does not match the requested module type, module script is cached in moduleMap, meaning that future attempts to fetch the same url in another module graph could succeed if the - correct type were specified, without triggering another network request.

            + requested type matched the MIME type, without triggering another network request. An important + detail of this process is that parsing a module and inserting it into the module map is + side-effect-free, so a module will have no observable effect until it is evaluated, which can + only happen after the type is matched.

            4. From 7c900a18f32788de774d043cb1f11e2af06c3d1f Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 25 Jun 2020 16:23:35 -0700 Subject: [PATCH 13/56] When a valid MIME type is received that doesn't match the requested type, cache the fetch response instead of creating and caching the module script. The module script is created only when there is a type match. This addreses concerns that parsing modules (perhaps even types of modules that don't yet exist) could have side-effects. --- source | 216 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 109 insertions(+), 107 deletions(-) diff --git a/source b/source index 6c5d18e19b4..4640f9387f1 100644 --- a/source +++ b/source @@ -86791,10 +86791,10 @@ interface ApplicationCache : EventTarget {

            1. Fetch a single module script given url, settings object, "script", options, settings object, - "client", with the module type must match flag set, and with - the top-level module fetch flag set. If the caller of this algorithm specified custom - perform the fetch steps, pass those along as - well. Wait until the algorithm asynchronously completes with result.

              2. + "client", and with the top-level module fetch flag set. If the + caller of this algorithm specified custom perform + the fetch steps, pass those along as well. Wait until the algorithm asynchronously + completes with result.

            2. If result is null, asynchronously complete this algorithm with null, and abort these steps.

              3. @@ -86823,11 +86823,10 @@ interface ApplicationCache : EventTarget {

            3. Fetch a single module script given url, settings object, "script", options, settings object, - "client", moduleRequest, with the module type must - match flag set, and with the top-level module fetch flag set. If the caller of - this algorithm specified custom perform the - fetch steps, pass those along as well. Wait until the algorithm asynchronously completes - with result.

              4. + "client", moduleRequest, and with the + top-level module fetch flag set. If the caller of this algorithm specified custom + perform the fetch steps, pass those along as + well. Wait until the algorithm asynchronously completes with result.

            4. If result is null, asynchronously complete this algorithm with null, and abort these steps.

              5. @@ -86849,9 +86848,8 @@ interface ApplicationCache : EventTarget {

              1. Fetch a single module script given url, settings object, destination, options, settings object, "client", with the module type must match flag unset, and with the - top-level module fetch flag set. Wait until algorithm asynchronously completes with - result.

                2. + data-x="">client", and with the top-level module fetch flag set. Wait until + algorithm asynchronously completes with result.

              2. Asynchronously complete this algorithm with result, but do not abort these steps.

                3. @@ -86915,10 +86913,10 @@ interface ApplicationCache : EventTarget {

              3. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, - "client", with the module type must match flag set, and with - the top-level module fetch flag set. If the caller of this algorithm specified custom - perform the fetch steps, pass those along as - well. Wait until the algorithm asynchronously completes with result.

                4. + "client", and with the top-level module fetch flag set. If the + caller of this algorithm specified custom perform + the fetch steps, pass those along as well. Wait until the algorithm asynchronously + completes with result.

              4. If result is null, asynchronously complete this algorithm with null, and abort these steps.

                5. @@ -87183,11 +87181,10 @@ interface ApplicationCache : EventTarget {

              5. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, - referrer, moduleRequest, with the module type must match flag - set, and with the top-level module fetch flag unset. If the caller of this algorithm - specified custom perform the fetch steps, - pass those along while fetching a single module - script.

                + referrer, moduleRequest, and with the + top-level module fetch flag unset. If the caller of this algorithm specified custom + perform the fetch steps, pass those along + while fetching a single module script.

              6. Return from this algorithm, and run the following steps when fetching a single module script asynchronously completes with @@ -87206,10 +87203,9 @@ interface ApplicationCache : EventTarget {

                To fetch a single module script, given a url, a fetch client settings object, a destination, some options, a module map - settings object, a referrer, an optional moduleRequest, a - module type must match flag, and a top-level module fetch flag, run these - steps. The algorithm will asynchronously complete with either null (on failure) or a - module script (on success).

                + settings object, a referrer, an optional moduleRequest, and a + top-level module fetch flag, run these steps. The algorithm will asynchronously + complete with either null (on failure) or a module script (on success).

                1. @@ -87229,29 +87225,15 @@ interface ApplicationCache : EventTarget { in parallel until that entry's value changes, then queue a task on the networking task source to proceed with running the following steps.

                  2. -
                2. -

                  If moduleMap[url] exists, then:

                  - -
                    -
                  1. -

                    If any of the following conditions are met, asynchronously complete this algorithm - with moduleMap[url], and abort these steps.

                    +

                  2. If moduleMap[url] is a fetch response, then asynchronously complete this algorithm with the + result of creating a module script + with matching type given url, requested type, + moduleMap[url], options, and module map settings + object, and abort these steps.

                    3. -
                      -

                    • The module type must match flag is unset.

                      • - -

                    • moduleMap[url] is a JavaScript module script - and module type is undefined.

                      • - -

                    • moduleMap[url] is a JSON module script - and module type is "json".

                      • -
                    - - -

                  3. Otherwise, asynchronously complete this algorithm with null, and abort these steps.

                    -
                    4. -
                  -
                  3. +

                3. If moduleMap[url] is null, asynchronously complete this algorithm + with null, and abort these steps.

                4. Set moduleMap[url] to "fetching".

                  @@ -87299,94 +87281,113 @@ interface ApplicationCache : EventTarget {

                5. response's status is not an ok status

                  6. - - -
                6. -

                  Let MIME type be the result of extracting a - MIME type from response's header - list.

                  +
                7. +

                  The result of extracting a + MIME type from response's header + list is neither a JavaScript MIME type nor a JSON 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.

                  +
                  +

                  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. If the resource does not have a MIME + type which HTML knows how to handle as a module then this algorithm will complete with null, + which is interpreted as failure, and a null entry is added to moduleMap so that + future attempts to fetch a module at url will always fail.

                  +
                  +
                  8. +
                8. -

                  Let module script be null.

                  +

                  Set moduleMap[url] to + response.

                  -

                  If the resource does not have a MIME type which HTML knows how to handle - as a module or if the MIME type does not match the type specified in moduleRequest, - then this algorithm will complete with null, which is interpreted as failure.

                  - -

                  In the former case where a non-module MIME type is received, a null entry is added to - moduleMap so that future attempts to fetch a module at url will always - fail. On the other hand for the case where the MIME type is valid but does not match the - requested module type, module script is cached in moduleMap, - meaning that future attempts to fetch the same url in another module graph could succeed if the - requested type matched the MIME type, without triggering another network request. An important - detail of this process is that parsing a module and inserting it into the module map is - side-effect-free, so a module will have no observable effect until it is evaluated, which can - only happen after the type is matched.

                  +

                  If the MIME type is valid but does not match the requested module type, then + create a module script with matching type will fail and response will + remain cached in the module map. Then, future attempts to fetch the same url in + another module graph could succeed if the requested type matched the MIME type, without + triggering another network request. Caching response instead of creating and + caching a module script at this point is done to ensure that no side-effects occur until there + is a type match.

                  + +

                  If requested type does turn out to match the MIME type then create a module + script with matching type will create a module script and overwrite this module + map entry with it.

                  9. +

                9. Asychronously complete this algorithm with the result of creating a module script with matching + type given url, requested type, response, + options, and module map settings object.

                  10. +
                + +

                To create a module script with matching type, given a url, a + requested type, a fetch response + response, some options, and module map settings object, + run these steps. The algorithm will complete with either null (on failure) or a + module script (on success).

                + +
                  +

                1. Let module script be null.

                  2. + +

                2. Let MIME type be the result of extracting a + MIME type from response's header + list.

                  3. +
                3. -

                  If MIME type is a JavaScript MIME type, then:

                  +

                  If MIME type is a JavaScript MIME type and module type is + undefined, then:

                  -
                    +

                    • Let source text be the result of UTF-8 - decoding response's body.

                      • + decoding response's body.

                      +

                    • Set module script to the result of creating a JavaScript module - script given source text, module map settings object, + script given source, module map settings object, response's url, and options.

                      • -
                  +
                4. -

                  If MIME type is a JSON MIME type, then:

                  -
                    +

                    If MIME type is a JSON MIME type and module type is + "json", then:

                    + +

                    • Let source text be the result of UTF-8 - decoding response's body.

                      • + decoding response's body.

                      +

                    • Set module script to the result of creating a JSON module script given source text and module map settings object.

                      • -
                  -
                  5. - -
                5. -

                  Set moduleMap[url] to module - script

                  - -

                  It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is - set to the response URL. The former is used to - deduplicate fetches, while the latter is used for URL resolution.

                  +
                  6. -
                6. -

                  If any of the following conditions are met, asynchronously complete this algorithm - with module script.

                  - -
                    -

                  • The module type must match flag is unset.

                    • +

                    If module script is not null, then:

                    -

                  • module script is a JavaScript module script - and module type is undefined.

                    • +
                      +

                    1. Let moduleMap be module map settings object's module map.

                      2. -

                    2. module script is a JSON module script - and module type is "json".

                      3. -
                  +

                7. Set moduleMap[url] to module script.

                  8. -

                  Otherwise, asynchronously complete this algorithm with null.

                  +

                  It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is + set to the response URL. The former is used to + deduplicate fetches, while the latter is used for URL resolution.

                  +
                7. +

              7. Return module script.

              To find the first parse error given a root @@ -88572,10 +88573,11 @@ document.querySelector("button").addEventListener("click", bound);

              A module map is a map of URL records to values that are either a module script, - null (used to represent failed fetches), or a placeholder value "fetching". Module maps are used to ensure - that imported JavaScript modules are only fetched, parsed, and evaluated once per - Document or worker.

              + null (used to represent failed fetches), a placeholder value "fetching", or a fetch response. + Module maps are used to ensure that imported JavaScript modules + are only fetched, parsed, and evaluated once per Document or worker.

              Since module maps are keyed by URL, the following code will From 55c9ed9bef7b43175624858d1e1fd0d130231789 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 26 Jun 2020 10:32:08 -0700 Subject: [PATCH 14/56] Wrap

              in

            5. so it's not directly under an
                , which the Travis CI build doesn't like. --- source | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/source b/source index 4640f9387f1..468b9b51647 100644 --- a/source +++ b/source @@ -87377,13 +87377,15 @@ interface ApplicationCache : EventTarget {

              1. Let moduleMap be module map settings object's module map.

                2. -

              2. Set moduleMap[url] to module script.

                3. +
              3. +

                Set moduleMap[url] to module script.

                -

                It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is - set to the response URL. The former is used to - deduplicate fetches, while the latter is used for URL resolution.

                +

                It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is + set to the response URL. The former is used to + deduplicate fetches, while the latter is used for URL resolution.

                +
              6. From 322808d4415dba48746c93c0030a9cab2f91baed Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 26 Jun 2020 14:37:25 -0700 Subject: [PATCH 15/56] Whitespace change: remove double spaces after sentences in notes. Hopefully unstick CI build, which seems to be stuck. --- source | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source b/source index 468b9b51647..c1ea9a27c0b 100644 --- a/source +++ b/source @@ -87293,7 +87293,7 @@ interface ApplicationCache : EventTarget { 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. If the resource does not have a MIME + fail to load if they are not of a supported MIME type. If the resource does not have a MIME type which HTML knows how to handle as a module then this algorithm will complete with null, which is interpreted as failure, and a null entry is added to moduleMap so that future attempts to fetch a module at url will always fail.

              @@ -87309,9 +87309,9 @@ interface ApplicationCache : EventTarget {

              If the MIME type is valid but does not match the requested module type, then create a module script with matching type will fail and response will - remain cached in the module map. Then, future attempts to fetch the same url in + remain cached in the module map. Then, future attempts to fetch the same url in another module graph could succeed if the requested type matched the MIME type, without - triggering another network request. Caching response instead of creating and + triggering another network request. Caching response instead of creating and caching a module script at this point is done to ensure that no side-effects occur until there is a type match.

              From 9f2ae27b45760d696faf2c73c324ea7774df783b Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 30 Jun 2020 10:35:57 -0700 Subject: [PATCH 16/56] Reword invocations of 'create a module script with matching type' to ensure they are synchronous with respect to the calling 'fetch a single module script' --- source | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/source b/source index c0232218d4f..f1b961e0853 100644 --- a/source +++ b/source @@ -88807,11 +88807,11 @@ document.querySelector("button").addEventListener("click", bound); the networking task source to proceed with running the following steps.

            6. If moduleMap[url] is a fetch response, then asynchronously complete this algorithm with the - result of creating a module script - with matching type given url, requested type, + data-x="concept-response">response, then create a module script with matching + type given url, requested type, moduleMap[url], options, and module map settings - object, and abort these steps.

              7. + object, asynchronously complete this algorithm with the result, and abort these steps.

              +

            7. If moduleMap[url] is null, asynchronously complete this algorithm with null, and abort these steps.

              8. @@ -88902,13 +88902,11 @@ document.querySelector("button").addEventListener("click", bound);
              -

            8. Asychronously complete this algorithm with the result of creating a module script with matching - type given url, requested type, response, - options, and module map settings object.

              9. +

            9. Create a module script with matching type given url, + requested type, response, options, and module map settings + object, and asychronously complete this algorithm with the result.

            -

            To create a module script with matching type, given a url, a requested type, a fetch response response, some options, and module map settings object, From e86dd65581b26f9eb7a8c40f4f449247b6f66525 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 30 Jun 2020 12:15:38 -0700 Subject: [PATCH 17/56] Change 'fetch a single module script' to fail if there are any unrecognized import attributes, and assert that there is only one of key 'type' (which should be guaranteed by Ecma262) --- source | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/source b/source index f1b961e0853..39a2d05ab51 100644 --- a/source +++ b/source @@ -88789,11 +88789,25 @@ document.querySelector("button").addEventListener("click", bound); complete with either null (on failure) or a module script (on success).

              +

            1. Let module type be undefined.

              2. +
            2. -

              If moduleRequest was given and if moduleRequest.[[Attributes]] - has a Record entry such that entry.[[Key]] is - "type", then let module type be entry.[[Value]]

              -

              Otherwise let module type be undefined.

              +

              If moduleRequest was given, then:

              + +
                +

              1. If moduleRequest.[[Attributes]] has any Record entry + such that entry.[[Key]] is not "type", then asynchronously + complete this algorithm with null, and + abort these steps.

                2. + +
              2. +

                If moduleRequest.[[Attributes]] has a Record entry such + that entry.[[Key]] is "type", then set module + type to entry.[[Value]].

                + +

                Assert: No more than one such Record exists.

                +
                3. +

            3. If module type is neither undefined nor "json", From 3318ed318a1a82f5011e0504f7526efc304375cc Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 7 Jul 2020 16:40:55 -0700 Subject: [PATCH 18/56] Instead of passing fetch response parameter to 'create a module script with matching type', retrieve it from the module map within the algorithm. --- source | 56 +++++++++++++++++++++++++++----------------------------- 1 file changed, 27 insertions(+), 29 deletions(-) diff --git a/source b/source index 39a2d05ab51..bf1f622c4e7 100644 --- a/source +++ b/source @@ -88822,10 +88822,9 @@ document.querySelector("button").addEventListener("click", bound);

            4. If moduleMap[url] is a fetch response, then create a module script with matching - type given url, requested type, - moduleMap[url], options, and module map settings - object, asynchronously complete this algorithm with the result, and abort these steps.

              -
              5. + type given url, requested type, options, and + module map settings object, asynchronously complete this algorithm with the result, + and abort these steps.

            5. If moduleMap[url] is null, asynchronously complete this algorithm with null, and abort these steps.

              6. @@ -88917,19 +88916,26 @@ document.querySelector("button").addEventListener("click", bound);

            6. Create a module script with matching type given url, - requested type, response, options, and module map settings + requested type, options, and module map settings object, and asychronously complete this algorithm with the result.

            To create a module script with matching type, given a url, a - requested type, a fetch response - response, some options, and module map settings object, + requested type, some options, and module map settings object, run these steps. The algorithm will complete with either null (on failure) or a module script (on success).

            1. Let module script be null.

              2. +

            2. Let moduleMap be module map settings object's module map.

              3. + +

            3. Let response be moduleMap[url].

              4. + +

            4. Assert: response is a fetch response.

              +

              5. +

            5. Let MIME type be the result of extracting a MIME type from response's header list.

              6. @@ -88943,10 +88949,18 @@ document.querySelector("button").addEventListener("click", bound); decoding response's body.

              -

            6. Set module script to the result of creating a JavaScript module - script given source, module map settings object, - response's url, and - options.

              7. +
            7. +

              Set module script to the result of creating a JavaScript module + script given source, module map settings object, + response's url, and + options.

              + +

              It is intentional that the module map is keyed by the request URL, whereas the base URL for the JavaScript module script + is set to the response URL. The former is used to + deduplicate fetches, while the latter is used for URL resolution.

              +
              8. @@ -88964,24 +88978,8 @@ document.querySelector("button").addEventListener("click", bound); -
            8. -

              If module script is not null, then:

              - -
                -

              1. Let moduleMap be module map settings object's module map.

                2. - -
              2. -

                Set moduleMap[url] to module script.

                - -

                It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is - set to the response URL. The former is used to - deduplicate fetches, while the latter is used for URL resolution.

                -
                3. -
              -
              9. +

            9. If module script is not null, then set moduleMap[url] to + module script

            10. Return module script.

            From 3c0dce2d2db9abdd4932f8e7e3d19c0d6f42e8b9 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 7 Jul 2020 16:56:32 -0700 Subject: [PATCH 19/56] Add assert that 'create a module script with matching type' is not running in parallel --- source | 3 +++ 1 file changed, 3 insertions(+) diff --git a/source b/source index bf1f622c4e7..2a8d738d675 100644 --- a/source +++ b/source @@ -88926,6 +88926,9 @@ document.querySelector("button").addEventListener("click", bound); module script (on success).

              +

            1. Assert: These steps are running on the event loop, not + in parallel.

              2. +

            2. Let module script be null.

            3. Let moduleMap be module map settings object's Date: Wed, 8 Jul 2020 11:20:45 -0700 Subject: [PATCH 20/56] Reword caching comment --- source | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/source b/source index 2a8d738d675..ba04d1d893f 100644 --- a/source +++ b/source @@ -88903,11 +88903,12 @@ document.querySelector("button").addEventListener("click", bound);

              If the MIME type is valid but does not match the requested module type, then create a module script with matching type will fail and response will - remain cached in the module map. Then, future attempts to fetch the same url in - another module graph could succeed if the requested type matched the MIME type, without - triggering another network request. Caching response instead of creating and - caching a module script at this point is done to ensure that no side-effects occur until there - is a type match.

              + remain cached in the module map. Future attempts to fetch the same url in another + module graph could succeed, without triggering another network request, if the requested type + matched the MIME type.

              + +

              Caching response instead of creating and caching a module script at this point is + done to ensure that no side-effects occur until there is a type match.

              If requested type does turn out to match the MIME type then create a module script with matching type will create a module script and overwrite this module From 3247e99275b9fbeb97c957a7f9b779c72fba6bf6 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 9 Jul 2020 14:10:10 -0700 Subject: [PATCH 21/56] Handle rename in TC39 proposal from import attributes to import conditions --- source | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/source b/source index ba04d1d893f..8e123402d7d 100644 --- a/source +++ b/source @@ -2869,13 +2869,13 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

            4. The HostGetImportMetaProperties abstract operation
              5. -

              User agents that support JavaScript must also implement the import attributes - proposal. The following terms are defined there, and used in this specification:

              +

              User agents that support JavaScript must also implement the import conditions + proposal. The following terms are defined there, and used in this specification:

                -
              • The ModuleRequest Record specification type
                • -
              • The ParseJSONModule abstract operation
                • +
              • The ModuleRequest Record specification type
                • +
              • The ParseJSONModule abstract operation

              Users agents that support JavaScript must also implement ECMAScript @@ -88795,13 +88795,12 @@ document.querySelector("button").addEventListener("click", bound);

              If moduleRequest was given, then:

                -

              1. If moduleRequest.[[Attributes]] has any Record entry +

              2. If moduleRequest.[[Conditions]] has any Record entry such that entry.[[Key]] is not "type", then asynchronously - complete this algorithm with null, and - abort these steps.

                3. + complete this algorithm with null, and abort these steps.

              3. -

                If moduleRequest.[[Attributes]] has a Record entry such +

                If moduleRequest.[[Conditions]] has a Record entry such that entry.[[Key]] is "type", then set module type to entry.[[Value]].

                @@ -121876,8 +121875,8 @@ INSERT INTERFACES HERE
                [JSERRORSTACKS]
                (Non-normative) Error Stacks. Ecma International.
                -
                [JSIMPORTATTRIBUTES]
                -
                Import Attributes. Ecma International.
                +
                [JSIMPORTCONDITIONS]
                +
                Import Conditions. Ecma International.
                [JSIMPORTMETA]
                import.meta. Ecma International.
                From dca376bb5aa947d032424715a61429702232cab8 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 24 Jul 2020 10:42:51 -0700 Subject: [PATCH 22/56] Update for the latest rename of the proposal from 'Import Conditions' to 'Import Assertions' --- source | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/source b/source index 8e123402d7d..a359f0af886 100644 --- a/source +++ b/source @@ -2869,13 +2869,13 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
              4. The HostGetImportMetaProperties abstract operation
                5. -

                User agents that support JavaScript must also implement the import conditions +

                User agents that support JavaScript must also implement the import assertions proposal. The following terms are defined there, and used in this specification:

                + spec=JSIMPORTASSERTIONS>

                  -
                • The ModuleRequest Record specification type
                  • -
                • The ParseJSONModule abstract operation
                  • +
                • The ModuleRequest Record specification type
                  • +
                • The ParseJSONModule abstract operation

                Users agents that support JavaScript must also implement ECMAScript @@ -88795,12 +88795,12 @@ document.querySelector("button").addEventListener("click", bound);

                If moduleRequest was given, then:

                  -

                1. If moduleRequest.[[Conditions]] has any Record entry +

                2. If moduleRequest.[[Assertions]] has any Record entry such that entry.[[Key]] is not "type", then asynchronously complete this algorithm with null, and abort these steps.

                3. -

                  If moduleRequest.[[Conditions]] has a Record entry such +

                  If moduleRequest.[[Assertions]] has a Record entry such that entry.[[Key]] is "type", then set module type to entry.[[Value]].

                  @@ -121875,8 +121875,8 @@ INSERT INTERFACES HERE
                  [JSERRORSTACKS]
                  (Non-normative) Error Stacks. Ecma International.
                  -
                  [JSIMPORTCONDITIONS]
                  -
                  Import Conditions. Ecma International.
                  +
                  [JSIMPORTASSERTIONS]
                  +
                  Import Assertions. Ecma International.
                  [JSIMPORTMETA]
                  import.meta. Ecma International.
                  From e3359b5f4d4d19993552dd577a62a2b5f125f64d Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 27 Jul 2020 10:00:12 -0700 Subject: [PATCH 23/56] Use module type as part of module map cache key instead of caching response body in the case of a failed type check. --- source | 213 ++++++++++++++++++++++----------------------------------- 1 file changed, 81 insertions(+), 132 deletions(-) diff --git a/source b/source index a359f0af886..9637fffe52e 100644 --- a/source +++ b/source @@ -2192,6 +2192,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
                4. surrogate
                5. scalar value
                6. tuple
                  7. +
                7. pair
                8. noncharacter
                9. string, code unit, @@ -88815,21 +88816,16 @@ document.querySelector("button").addEventListener("click", bound);

                10. Let moduleMap be module map settings object's module map.

                  11. -

                11. If moduleMap[url] is "fetching", wait - in parallel until that entry's value changes, then queue a task on - the networking task source to proceed with running the following steps.

                  12. +

                12. If moduleMap[url / module type] is + "fetching", wait in parallel until that entry's value + changes, then queue a task on the networking task source to proceed + with running the following steps.

                  13. -

                13. If moduleMap[url] is a fetch response, then create a module script with matching - type given url, requested type, options, and - module map settings object, asynchronously complete this algorithm with the result, - and abort these steps.

                  14. - -

                14. If moduleMap[url] is null, asynchronously complete this algorithm - with null, and abort these steps.

                  15. +

                15. If moduleMap[url / module type] is null, asynchronously + complete this algorithm with null, and abort these steps.

                  16. -

                16. Set moduleMap[url] to "fetching".

                  +

                17. Set moduleMap[url / + module type] to "fetching".

                18. Let request be a new request whose url is url,

                19. -

                  If any of the following conditions are met, set +

                  If either of the following conditions are met, set moduleMap[url] to null, asynchronously complete this algorithm with null, and abort these steps:

                  @@ -88874,117 +88870,53 @@ document.querySelector("button").addEventListener("click", bound);

                20. response's status is not an ok status

                  21. - -
                21. -

                  The result of extracting a - MIME type from response's header - list is neither a JavaScript MIME type nor a JSON 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. If the resource does not have a MIME - type which HTML knows how to handle as a module then this algorithm will complete with null, - which is interpreted as failure, and a null entry is added to moduleMap so that - future attempts to fetch a module at url will always fail.

                  -
                  -
                22. -

                  Set moduleMap[url] to - response.

                  +

                  Let MIME type be the result of extracting a + MIME type from response's header + list.

                  -

                  If the MIME type is valid but does not match the requested module type, then - create a module script with matching type will fail and response will - remain cached in the module map. Future attempts to fetch the same url in another - module graph could succeed, without triggering another network request, if the requested type - matched the MIME type.

                  - -

                  Caching response instead of creating and caching a module script at this point is - done to ensure that no side-effects occur until there is a type match.

                  - -

                  If requested type does turn out to match the MIME type then create a module - script with matching type will create a module script and overwrite this module - map entry with it.

                  +

                  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. If the resource does not have a MIME + type which HTML knows how to handle as a module then this algorithm will complete with null, + which is interpreted as failure, and a null entry is added to moduleMap so that + future attempts to fetch a module at url will always fail.

                  23. -

                23. Create a module script with matching type given url, - requested type, options, and module map settings - object, and asychronously complete this algorithm with the result.

                  24. -
                - -

                To create a module script with matching type, given a url, a - requested type, some options, and module map settings object, - run these steps. The algorithm will complete with either null (on failure) or a - module script (on success).

                - -
                  -

                1. Assert: These steps are running on the event loop, not - in parallel.

                  2. +

                2. Let source text be the result of UTF-8 + decoding response's body.

                3. Let module script be null.

                  4. -

                4. Let moduleMap be module map settings object's module map.

                  5. - -

                5. Let response be moduleMap[url].

                  6. - -

                6. Assert: response is a fetch response.

                  +

                7. If MIME type is a JavaScript MIME type and module type + is undefined, then set module script to the result of creating a JavaScript + module script given source text, module map settings object, + response's url, and options.

                  8. -

                8. Let MIME type be the result of extracting a - MIME type from response's header - list.

                  9. - -
                9. -

                  If MIME type is a JavaScript MIME type and module type is - undefined, 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, module map settings object, - response's url, and - options.

                    - -

                    It is intentional that the module map is keyed by the request URL, whereas the base URL for the JavaScript module script - is set to the response URL. The former is used to - deduplicate fetches, while the latter is used for URL resolution.

                    -
                    • -
                  -
                  10. +

                10. If MIME type is a JSON MIME type and module type is + "json", then set module script to the result of creating + a JSON module script given source text and module map settings + object.

                11. -

                  If MIME type is a JSON MIME type and module type is - "json", then:

                  - -
                    -

                  • Let source text be the result of UTF-8 - decoding response's body.

                    -
                    • +

                    Set moduleMap[url / + module type] to module script, and asynchronously complete this algorithm + with module script.

                    -

                  • Set module script to the result of creating a JSON module - script given source text and module map settings object.

                    • -
                  +

                  It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is + set to the response URL. The former is used to + deduplicate fetches, while the latter is used for URL resolution.

                  12. - -

                12. If module script is not null, then set moduleMap[url] to - module script

                  - -

                13. Return module script.

                To find the first parse error given a root @@ -89011,22 +88943,25 @@ document.querySelector("button").addEventListener("click", bound);

              5. Let moduleRequests be the value of moduleScript's record's [[RequestedModules]] internal slot.

                6. -

              6. Let childURLs be the list obtained by calling - resolve a module specifier once for each item moduleRequest of - moduleRequest, given moduleScript's base URL and moduleRequest.[[Specifier]]. - (None of these will ever fail, as otherwise moduleScript would have been marked as - itself having a parse error.)

                7. - -

              7. Let childModules be the list obtained by getting each value in moduleMap whose key is given by an - item of childURLs.

                8. -
              8. -

                For each childModule of - childModules:

                +

                For each moduleRequest of + moduleRequests:

                  +

                1. Let childURL be the result of resolving a module specifier given + moduleScript's base URL and + moduleRequest.[[Specifier]]. (This will never fail, as otherwise + moduleScript would have been marked as itself having a parse error.)

                  2. + +

                2. If moduleRequest.[[Assertions]] has a Record entry + such that entry.[[Key]] is "type", then let module + type be entry.[[Value]]. Otherwise let module type be undefined. +

                  3. + +

                3. Let childModule be moduleMap[childURL / + module type].

                  4. +

                4. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module scripts in the graph rooted at moduleScript will have successfully been @@ -89921,18 +89856,18 @@ dictionary PromiseRejectionEventInit : EventInit { -

                  A module map is a map of URL records to values that are either a module script, - null (used to represent failed fetches), a placeholder value "fetching", or a fetch response. - Module maps are used to ensure that imported JavaScript modules - are only fetched, parsed, and evaluated once per Document or worker.

                  +

                  A module map is a map keyed by + URL record / module type string pairs whose values are + either a module script, null (used to represent failed fetches), or a placeholder + value "fetching". Module maps are + used to ensure that imported JavaScript modules are only fetched, parsed, and evaluated once per + Document or worker.

                  -

                  Since module maps are keyed by URL, the following code will - create three separate entries in the module map, since it results in three different - URLs:

                  +

                  Since module maps are keyed by URL / module type, the + following code will create three separate entries in the module map, since it + results in three different URL/module type pairs (all with null type): + 

                  import "https://example.com/module.mjs";
 import "https://example.com/module.mjs#map-buster";
@@ -89957,6 +89892,15 @@ import "https://example.com/foo/../module2.mjs";

                  Note that this behavior is the same as how shared workers are keyed by their parsed constructor url.

                  + +

                  Since module type is also part of the module map key, the following code will + create two separate entries in the module map (the type is undefined for the first, + and "json" for the second): + + 

                  import "https://example.com/module.json";
+import "https://example.com/module.json" assert { type: "json" };
                  + +

                  Therefore two separate fetches and two separate module evaluations will be performed.

                  @@ -90194,8 +90138,13 @@ import "https://example.com/foo/../module2.mjs"; same two arguments (either while creating the corresponding module script, or in HostImportModuleDynamically).

                  5. -

                5. Let resolved module script be moduleMap[url]. (This entry - must exist for us to have gotten to this point.)

                  6. +

                6. If moduleRequest.[[Assertions]] has a Record entry such + that entry.[[Key]] is "type", then let module type + be entry.[[Value]]. Otherwise let module type be undefined.

                  7. + +

                7. Let resolved module script be moduleMap[url / + module type]. (This entry must exist for us to have + gotten to this point.)

                8. Assert: resolved module script is a module script (i.e., is not null or "fetching").

                  9. From aafb25692ce430cc380230f43cf085ec112afbfd Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 27 Aug 2020 14:19:32 -0700 Subject: [PATCH 24/56] Change 'abort these steps' to 'return' to match recent changes in 'fetch a single module script'. --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 4f602536fc6..6017f8f65fc 100644 --- a/source +++ b/source @@ -89627,7 +89627,7 @@ document.querySelector("button").addEventListener("click", bound);

                  1. If moduleRequest.[[Assertions]] has any Record entry such that entry.[[Key]] is not "type", then asynchronously - complete this algorithm with null, and abort these steps.

                    2. + complete this algorithm with null, and return.

                  2. If moduleRequest.[[Assertions]] has a Record entry such From 9164acf16e14c0e715f7b7269959217e76a31c91 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 28 Aug 2020 16:02:35 -0700 Subject: [PATCH 25/56] Remove JSON modules references, switch JavaScript module script references back to just 'module script' --- source | 366 +++++++++++++++++---------------------------------------- 1 file changed, 111 insertions(+), 255 deletions(-) diff --git a/source b/source index 6017f8f65fc..251697ab967 100644 --- a/source +++ b/source @@ -2657,7 +2657,6 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

                  3. converting to a sequence of Unicode scalar values
                  4. overload resolution algorithm
                    5. -
                  5. Synthetic Module Record
                  6. exposed
                  7. [LegacyFactoryFunction]
                  8. [LegacyLenientThis]
                    9. @@ -2874,12 +2873,11 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute Internationalization API.

                    User agents that support JavaScript must also implement the import assertions - proposal. The following terms are defined there, and used in this specification:

                    • The ModuleRequest Record specification type
                      • -
                    • The ParseJSONModule abstract operation
                    @@ -57386,14 +57384,11 @@ interface HTMLScriptElement : HTMLElement { redundantly setting it.

                  9. Setting the attribute to an ASCII case-insensitive match for the string - "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).

                    10. + "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).

                  10. 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 JavaScript module scripts can be embedded inline, or be imported from an external - file using the Classic scripts and 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 JavaScript module scripts respectively.

                    - -

                    The contents of the external script resource for JSON module - scripts must conform to the requirements of the JSON specification .

                    + 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.

                    When used to include data blocks, the data must be embedded inline, the format of the data must be given using the type @@ -57661,7 +57652,7 @@ o............A....e

                    The following sample shows how a script element can be used to include an - external JavaScript module script. + external module script. 

                    <script type="module" src="app.mjs"></script>
                    @@ -57672,37 +57663,37 @@ o............A....e

                    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 JavaScript module script created by the + "./app.mjs";), then the same module script created by the former script element will be imported.

                    -

                    This example shows how to include a JavaScript module script for modern user - agents, and a classic script for older user agents:

                    +

                    This example shows how to include a module script for modern user agents, and a + classic script for older user agents:

                    <script type="module" src="app.mjs"></script>
 <script nomodule defer src="classic-app-bundle.js"></script>
                    -

                    In modern user agents that support JavaScript module - scripts, the script element with the nomodule attribute will be ignored, and the +

                    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 script element with a type of "module" will be fetched and evaluated (as a JavaScript module - script). Conversely, older user agents will ignore 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.

                    + data-x="">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 - 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): 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">
@@ -57734,38 +57725,13 @@ o............A....e
  walkAllTextNodeDescendants(document.body, substitute);
 </script>
                    -

                    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 a JSON module script can be imported from inside - a JavaScript module 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.

                    - 
                    <script type="module">
-import peopleInSpace from "http://api.open-notify.org/astros.json" if { type: "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>
                    - -

                    MIME type checking for module scripts is strict. In order for the fetch of the - JSON module script to succeed, the HTTP reponse must have a - JSON MIME type, for example Content-Type: text/json. On the - other hand, if the if { type: "json" } part of the statement is omitted, - it is assumed that the intent is to import a JavaScript module script, and the fetch - will fail if the HTTP response has a MIME type that is not a JavaScript MIME type. -

                    @@ -88727,7 +88693,7 @@ document.querySelector("button").addEventListener("click", bound);
                    Scripts
                    -

                    A script is one of three possible A script is one of two possible structs. All scripts have:

                    @@ -88738,22 +88704,10 @@ document.querySelector("button").addEventListener("click", bound);
                    A record
                    -
                    -

                    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.

                      • -
                    -
                    +

                    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.

                    A parse error
                    @@ -88816,35 +88770,6 @@ document.querySelector("button").addEventListener("click", bound); data-x="concept-script">script. It has no additional items.

                    -

                    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:

                      @@ -89292,8 +89217,8 @@ document.querySelector("button").addEventListener("click", bound); success).

                        -

                      1. Let script be the result of creating a JavaScript module script - using source text, settings object, base URL, and +

                      2. Let script be the result of creating a module script using + source text, settings object, base URL, and options.

                      3. If script is null, asynchronously complete this algorithm with null, and @@ -89544,8 +89469,8 @@ document.querySelector("button").addEventListener("click", bound);

                      4. Let options be the descendant script fetch options for module script's fetch options.

                        5. -

                      5. Assert: options is not null, as module script is a JavaScript - module script.

                        6. +

                      6. Assert: options is not null, as module script is a module + script.

                      7. For each moduleRequest in @@ -89619,42 +89544,30 @@ document.querySelector("button").addEventListener("click", bound); complete with either null (on failure) or a module script (on success).

                          -

                        1. Let module type be undefined.

                          2. -
                        2. -

                          If moduleRequest was given, then:

                          - -
                            -

                          1. If moduleRequest.[[Assertions]] has any Record entry - such that entry.[[Key]] is not "type", then asynchronously - complete this algorithm with null, and return.

                            2. - -
                          2. -

                            If moduleRequest.[[Assertions]] has a Record entry such - that entry.[[Key]] is "type", then set module - type to entry.[[Value]].

                            +

                            If moduleRequest was given and moduleRequest.[[Assertions]] contains + any Records, then asynchronously complete this algorithm with null, + and return.

                            -

                            Assert: No more than one such Record exists.

                            -
                            3. -
                          +

                          Currently no import assertions are supported, so we conservatively fail + if any are present. Eventually these will be used for checks such as confirming that the + type of the module matches the type expected by the importer.

                          3. -

                        3. If module type is neither undefined nor "json", - asynchronously complete this algorithm with null, and return.

                          4. -

                        4. Let moduleMap be module map settings object's module map.

                          5. -

                        5. If moduleMap[url / module type] is +

                        6. If moduleMap[url / undefined] is "fetching", wait in parallel until that entry's value changes, then queue a task on the networking task source to proceed with running the following steps.

                          7. -

                        7. If moduleMap[url / module type] is null, asynchronously - complete this algorithm with null, and return.

                          8. +

                        8. If moduleMap[url / undefined] exists, + asynchronously complete this algorithm with moduleMap[url / undefined], and + return.

                          9. -

                        9. Set moduleMap[url / - module type] to "fetching".

                          +

                        10. Set moduleMap[url / undefined] to + "fetching".

                        11. Let request be a new request whose url is url,

                        12. -

                          If either of the following conditions are met:

                          +

                          If any of the following conditions are met:

                          • response's type is "error"; or

                          • response's status is not an - ok status,

                            • -
                          + ok status; or

                          13. -

                          then set moduleMap[url / module - type] to null, asynchronously complete this algorithm with null, and return.

                          +

                        13. the result of extracting a MIME type from + response's header list is not a + JavaScript MIME type,

                          14. + + +

                          then set moduleMap[url / undefined] to + null, asynchronously complete this algorithm with null, and return.

                        14. Let source text be the result of UTF-8 decoding response's body.

                          15. -

                        15. Let module script be null.

                          16. - -

                        16. If MIME type is a JavaScript MIME type and module type - is undefined, then set module script to the result of creating a JavaScript - module script given source text, module map settings object, - response's url, and options.

                          -
                          17. - -

                        17. If MIME type is a JSON MIME type and module type is - "json", then set module script to the result of creating - a JSON module script given source text and module map settings - object.

                          18. +

                        18. Let module script be the result of creating a module script given + source text, module map settings object, response's url, and options.

                        19. -

                          Set moduleMap[url / - module type] to module script, and asynchronously complete this algorithm - with module script.

                          +

                          Set moduleMap[url / undefined] to + module script, and asynchronously complete this algorithm with module + script.

                          It is intentional that the module map is keyed by the request URL, whereas the moduleScript's parse error.

                          20. +

                        20. Let moduleRequests be the value of moduleScript's record's [[RequestedModules]] internal slot.

                          21. +
                        21. -

                          If moduleScript's record is a - Cyclic Module Record:

                          +

                          For each moduleRequest of + moduleRequests:

                            -

                          1. Let moduleRequests be the value of moduleScript's record's [[RequestedModules]] internal slot.

                            2. - -
                          2. -

                            For each moduleRequest of - moduleRequests:

                            - -
                              -

                            1. Let childURL be the result of resolving a module specifier given - moduleScript's base URL and - moduleRequest.[[Specifier]]. (This will never fail, as otherwise - moduleScript would have been marked as itself having a parse error.)

                              2. - -

                            2. If moduleRequest.[[Assertions]] has a Record entry - such that entry.[[Key]] is "type", then let module - type be entry.[[Value]]. Otherwise let module type be undefined. -

                              3. +

                            3. Let childURL be the result of resolving a module specifier given + moduleScript's base URL and + moduleRequest.[[Specifier]]. (This will never fail, as otherwise + moduleScript would have been marked as itself having a parse error.)

                              4. -

                            4. Let childModule be moduleMap[childURL / - module type].

                              5. +

                            5. Let childModule be moduleMap[childURL / undefined]. +

                              6. -

                            6. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module - scripts in the graph rooted at moduleScript will have successfully been - fetched.

                              7. +

                            7. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module + scripts in the graph rooted at moduleScript will have successfully been + fetched.

                              8. -

                            8. If discoveredSet already contains - childModule, continue.

                              9. +

                            9. If discoveredSet already contains + childModule, continue.

                              10. -

                            10. Let childParseError be the result of finding the first parse - error given childModule and discoveredSet.

                              11. +

                            11. Let childParseError be the result of finding the first parse + error given childModule and discoveredSet.

                              12. -

                            12. If childParseError is not null, return childParseError.

                              13. -
                            -
                            3. +

                          3. If childParseError is not null, return childParseError.

                          22. @@ -89861,10 +89757,10 @@ document.querySelector("button").addEventListener("click", bound);

                        22. Return script.

                        -

                        To create a JavaScript module script, - given a string source, an environment settings - object settings, a URL baseURL, and some script - fetch options options:

                        +

                        To create a module script, given a + string source, an environment settings object + settings, a URL baseURL, and some script fetch + options options:

                        1. If scripting is disabled for @@ -89939,34 +89835,6 @@ document.querySelector("button").addEventListener("click", bound);

                        2. Return script.

                        -

                        To create a JSON module script, given a - string source and an environment settings object settings:

                        - -
                          -

                        1. Let script be a new module script that this algorithm will - subsequently initialize.

                          2. - -

                        2. Set script's settings object to settings.

                          3. - -

                        3. Set script's base URL and - fetch options to null.

                          4. - -

                        4. Set script's parse error and - error to rethrow to null.

                          5. - -
                        5. -

                          Let result be ParseJSONModule(source). - -

                          If this throws an exception, set script's parse error to that exception, and return - script.

                          -
                          6. - -

                        6. Set script's record to result. - -

                        7. Return script.

                          8. -
                        -
                        Calling scripts

                        To run a classic script given a classic script @@ -90684,7 +90552,9 @@ dictionary PromiseRejectionEventInit : EventInit { either a module script, null (used to represent failed fetches), or a placeholder value "fetching". Module maps are used to ensure that imported JavaScript modules are only fetched, parsed, and evaluated once per - Document or worker.

                        + Document or worker. Currently only JavaScript + module scripts are supported, so the module type will always + be null until additional module types are introduced.

                        Since module maps are keyed by URL / module type, the @@ -90716,14 +90586,18 @@ import "https://example.com/foo/../module2.mjs"; data-x="SharedWorker">shared workers are keyed by their parsed constructor url.

                        -

                        Since module type is also part of the module map key, the following code will - create two separate entries in the module map (the type is undefined for the first, - and "json" for the second): +

                        Once additional module types are introduced, it will be possible to have multiple map entries + for a single URL since module type is also part of the module map key. For + example, once JSON modules are introduced the following code will create two separate entries in + the module map (the type is undefined for the first, and + "json" for the second): 

                        import "https://example.com/module.json";
 import "https://example.com/module.json" assert { type: "json" };
                        -

                        Therefore two separate fetches and two separate module evaluations will be performed.

                        +

                        Therefore two separate fetches and two separate module evaluations will be performed. Note + however that least one of the imports will fail the module type check unless the server + responds with a different MIME type for each.

                        @@ -90819,10 +90693,6 @@ import "https://example.com/module.json" assert { type: "json" };

                        1. Let module script be moduleRecord.[[HostDefined]].

                          2. -

                        2. Assert: module script's base - URL is not null, as module script is a JavaScript module - script.

                          3. -

                        3. Let urlString be module script's base URL, serialized.

                          4. @@ -90862,10 +90732,6 @@ import "https://example.com/module.json" assert { type: "json" };

                        4. Set fetch options to the descendant script fetch options for referencing script's fetch options.

                          5. - -

                        5. 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 @@ -90929,9 +90795,6 @@ import "https://example.com/module.json" assert { type: "json" };

                      8. Set base URL to referencing script's base URL.

                        9. - -

                      9. Assert: base URL is not null, as referencing script is a - classic script or a JavaScript module script.

                      @@ -90961,13 +90824,9 @@ import "https://example.com/module.json" assert { type: "json" }; same two arguments (either while creating the corresponding module script, or in HostImportModuleDynamically).

                      -

                    1. If moduleRequest.[[Assertions]] has a Record entry such - that entry.[[Key]] is "type", then let module type - be entry.[[Value]]. Otherwise let module type be undefined.

                      2. - -

                    2. Let resolved module script be moduleMap[url / - module type]. (This entry must exist for us to have - gotten to this point.)

                      3. +

                    3. Let resolved module script be moduleMap[url / undefined]. + (This entry must exist for us to have gotten to this point.) +

                    4. Assert: resolved module script is a module script (i.e., is not null or "fetching").

                      5. @@ -93952,9 +93811,6 @@ enum DOMParserSupportedType {

                    5. Let base URL be initiating script's base URL.

                      6. -

                    6. Assert: base URL is not null, as initiating script is a - classic script or a JavaScript module script.

                      7. -

                    7. Let fetch options be a script fetch options whose cryptographic nonce is initiating From 9eda0e2732a537375c37f0c2f2c1aea0765ee046 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 31 Aug 2020 11:41:55 -0700 Subject: [PATCH 26/56] Properly return non-null module map entry if one already exists. --- source | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/source b/source index 6017f8f65fc..df134ff8e90 100644 --- a/source +++ b/source @@ -89650,8 +89650,9 @@ document.querySelector("button").addEventListener("click", bound); changes, then queue a task on the networking task source to proceed with running the following steps.

                      8. -

                    8. If moduleMap[url / module type] is null, asynchronously - complete this algorithm with null, and return.

                      9. +

                    9. If moduleMap[url / module type] exists, asynchronously complete this algorithm with + moduleMap[url / module type], and return.

                    10. Set moduleMap[url / module type] to "fetching".

                      From 9fbbc6d5688f5b4f6bdd856d2c2529be4722e506 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 31 Aug 2020 11:56:48 -0700 Subject: [PATCH 27/56] Update spec links to reflect split of import assertions and json modules --- source | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/source b/source index df134ff8e90..474adf68ee0 100644 --- a/source +++ b/source @@ -2874,12 +2874,19 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute Internationalization API.

                      User agents that support JavaScript must also implement the import assertions - proposal. The following terms are defined there, and used in this specification:

                      • The ModuleRequest Record specification type
                        • -
                      • The ParseJSONModule abstract operation
                        • +
                      + +

                      User agents that support JavaScript must also implement the JSON modules + proposal. The following term is defined there, and used in this specification:

                      + +
                        +
                      • The ParseJSONModule abstract operation
                      @@ -122706,6 +122713,9 @@ INSERT INTERFACES HERE
                      [JSIMPORTASSERTIONS]
                      Import Assertions. Ecma International.
                      +
                      [JSJSONMODULES]
                      +
                      JSON Modules. Ecma International.
                      +
                      [JSINTL]
                      ECMAScript Internationalization API Specification. Ecma International.
                      From 1117dc3c15bf16a747c0f0e09f1e55ed1ee6cab0 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 30 Sep 2020 15:44:56 -0700 Subject: [PATCH 28/56] Update module map dfn note to explain purpose of having module type in key, and that in practice fetches and module evalutations will only occur once per specifier --- source | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/source b/source index 8c6d956786e..80da35047e6 100644 --- a/source +++ b/source @@ -91231,10 +91231,18 @@ import "https://example.com/foo/../module2.mjs"; create two separate entries in the module map (the type is undefined for the first, and "json" for the second): - 
                      import "https://example.com/module.json";
-import "https://example.com/module.json" assert { type: "json" };
                      - -

                      Therefore two separate fetches and two separate module evaluations will be performed.

                      + 
                      import "https://example.com/module";
+import "https://example.com/module" assert { type: "json" };
                      + +

                      In theory, this means that two separate fetches and two separate module evaluations would be + performed. In practice, due to the memory cache the resource will only be fetched once. + Additionally, as long as all module types are mutually exclusive, the module type check in + fetch a single module script will fail for at least one of the imports, so at most + one module evaluation will occur.

                      + +

                      The purpose of including the type in the module map key is so that an import + with the wrong type assertion does not prevent a different import of the same specifier but with + the correct type from succeeding.

                      11. From 73f2be25d70587f550d0142e19f78e662a397736 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 30 Sep 2020 15:44:56 -0700 Subject: [PATCH 29/56] Update module map dfn note to explain purpose of having module type in key, and that in practice fetches and module evalutations will only occur once per specifier --- source | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/source b/source index 8ff86ee141a..5bc1727ae52 100644 --- a/source +++ b/source @@ -91094,12 +91094,18 @@ import "https://example.com/foo/../module2.mjs"; the module map (the type is undefined for the first, and "json" for the second): - 
                      import "https://example.com/module.json";
-import "https://example.com/module.json" assert { type: "json" };
                      - -

                      Therefore two separate fetches and two separate module evaluations will be performed. Note - however that least one of the imports will fail the module type check unless the server - responds with a different MIME type for each.

                      + 
                      import "https://example.com/module";
+import "https://example.com/module" assert { type: "json" };
                      + +

                      In theory, this means that two separate fetches and two separate module evaluations would be + performed. In practice, due to the memory cache the resource will only be fetched once. + Additionally, as long as all module types are mutually exclusive, the module type check in + fetch a single module script will fail for at least one of the imports, so at most + one module evaluation will occur.

                      + +

                      The purpose of including the type in the module map key is so that an import + with the wrong type assertion does not prevent a different import of the same specifier but with + the correct type from succeeding.

                      From eec60c588151f222d94148b5f80119cf897fefaf Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 30 Sep 2020 16:03:38 -0700 Subject: [PATCH 30/56] Ignore unknown import assertions instead of failing. Continue failing on unknown module types. --- source | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/source b/source index 80da35047e6..51785a03ef2 100644 --- a/source +++ b/source @@ -90132,20 +90132,14 @@ document.querySelector("button").addEventListener("click", bound);

                    11. Let module type be undefined.

                    12. -

                      If moduleRequest was given, then:

                      +

                      If moduleRequest was given and moduleRequest.[[Assertions]] has a + Record entry such that entry.[[Key]] is "type", then:

                        -

                      1. If moduleRequest.[[Assertions]] has any Record entry - such that entry.[[Key]] is not "type", then asynchronously - complete this algorithm with null, and return.

                        2. +

                      2. Assert: No more than one such Record exists.

                        3. -
                      3. -

                        If moduleRequest.[[Assertions]] has a Record entry such - that entry.[[Key]] is "type", then set module - type to entry.[[Value]].

                        - -

                        Assert: No more than one such Record exists.

                        -
                        4. +

                      4. Set module type to entry.[[Value]].

                      13. From 6ed447425c3b2e5f0bf46586efa74a9c9c679d91 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 30 Sep 2020 16:13:48 -0700 Subject: [PATCH 31/56] Ignore unknown import assertions instead of failing. Continue failing for unrecognized types (which is to say, any type at all). --- source | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/source b/source index 5bc1727ae52..67904f2c488 100644 --- a/source +++ b/source @@ -90047,13 +90047,18 @@ document.querySelector("button").addEventListener("click", bound);
                      1. -

                        If moduleRequest was given and moduleRequest.[[Assertions]] contains - any Records, then asynchronously complete this algorithm with null, - and return.

                        +

                        If moduleRequest was given and moduleRequest.[[Assertions]] has a + Record entry such that entry.[[Key]] is "type", then asynchronously complete this algorithm with null, and return.

                        + +
                        +

                        Currently no non-JS module types are supported, so we conservatively fail + if any type is specified. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module + matches the type expected by the importer.

                        -

                        Currently no import assertions are supported, so we conservatively fail - if any are present. Eventually these will be used for checks such as confirming that the - type of the module matches the type expected by the importer.

                        +

                        Assertions with unknown keys are ignored.

                        +

                      2. Let moduleMap be module map settings object's Date: Mon, 5 Oct 2020 14:14:18 -0700 Subject: [PATCH 32/56] Move check for unknown type assertion to 'create a module script'. --- source | 51 +++++++++++++++++++++++++++++++-------------------- 1 file changed, 31 insertions(+), 20 deletions(-) diff --git a/source b/source index 67904f2c488..fb06c2111e3 100644 --- a/source +++ b/source @@ -89661,6 +89661,21 @@ document.querySelector("button").addEventListener("click", bound);

                      3. If url is failure, then asynchronously complete this algorithm with null, and return.

                        4. +
                      4. +

                        If moduleRequest.[[Assertions]] has a Record entry such + that entry.[[Key]] is "type" then asynchronously complete this + algorithm with null, and return.

                        + +
                        +

                        Currently no non-JS module types are supported, so we conservatively fail if any type + assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module + matches the type expected by the importer.

                        + +

                        Assertions with unknown keys are ignored.

                        +
                        +
                        5. +

                      5. Fetch a single module script given url, settings object, "script", options, settings object, "client", moduleRequest, and with the @@ -90046,21 +90061,6 @@ document.querySelector("button").addEventListener("click", bound); complete with either null (on failure) or a module script (on success).

                          -
                        1. -

                          If moduleRequest was given and moduleRequest.[[Assertions]] has a - Record entry such that entry.[[Key]] is "type", then asynchronously complete this algorithm with null, and return.

                          - -
                          -

                          Currently no non-JS module types are supported, so we conservatively fail - if any type is specified. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module - matches the type expected by the importer.

                          - -

                          Assertions with unknown keys are ignored.

                          -
                          -
                          2. -

                        2. Let moduleMap be module map settings object's module map.

                          3. @@ -90317,7 +90317,9 @@ document.querySelector("button").addEventListener("click", bound); URL and requested.[[Specifier]].

                        3. -

                          If url is failure, then:

                          +

                          If url is failure, or if requested.[[Assertions]] has a + Record entry such that entry.[[Key]] is "type" then:

                          1. Let error be a new TypeError exception.

                            2. @@ -90330,10 +90332,19 @@ document.querySelector("button").addEventListener("click", bound);
                          -

                          This step is essentially validating all of the requested module specifiers. We - treat a module with unresolvable module specifiers the same as one that cannot be parsed; in - both cases, a syntactic issue makes it impossible to ever contemplate linking the module - later.

                          +
                          +

                          This step is essentially validating all of the requested module specifiers and type + assertions. We treat a module with unresolvable module specifiers or an unsupported type + assertion the same as one that cannot be parsed; in both cases, a syntactic issue makes + it impossible to ever contemplate linking the module later.

                          + +

                          Currently no non-JS module types are supported, so we conservatively fail if any type + assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module + matches the type expected by the importer.

                          + +

                          Assertions with unknown keys are ignored.

                          +

                        4. Set script's record to From 24483424121b51dbf05f62b4ed9960ecf4904b35 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 5 Oct 2020 14:14:18 -0700 Subject: [PATCH 33/56] Move check for unknown type assertion to 'create a module script'. --- source | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/source b/source index 51785a03ef2..0cda61f1357 100644 --- a/source +++ b/source @@ -89744,6 +89744,11 @@ document.querySelector("button").addEventListener("click", bound);

                        5. If url is failure, then asynchronously complete this algorithm with null, and return.

                          6. +

                        6. If moduleRequest.[[Assertions]] has a Record entry such + that entry.[[Key]] is "type" and entry.[[Value]] is + neither undefined nor "json", then asynchronously complete this + algorithm with null, and return.

                          7. +

                        7. Fetch a single module script given url, settings object, "script", options, settings object, "client", moduleRequest, and with the @@ -90143,8 +90148,11 @@ document.querySelector("button").addEventListener("click", bound);

                        6. -

                      6. If module type is neither undefined nor "json", - asynchronously complete this algorithm with null, and return.

                        7. +

                      7. Assert: module type is either undefined or "json". + Otherwise we would not have reached this point because a failure would have been raised when + inspecting moduleRequest.[[Assertions]] in create a JavaScript module script or fetch + an import() module script graph.

                      8. Let moduleMap be module map settings object's module map.

                        9. @@ -90418,8 +90426,13 @@ document.querySelector("button").addEventListener("click", bound); a module specifier given script's base URL and requested.[[Specifier]].

                        +

                      9. If requested.[[Assertions]] has a Record entry such + that entry.[[Key]] is "type", then let module type + be entry.[[Value]]. Otherwise let module type be undefined.

                        10. +
                      10. -

                        If url is failure, then:

                        +

                        If url is failure, or if module type is neither undefined nor + "json", then:

                        1. Let error be a new TypeError exception.

                          2. @@ -90432,10 +90445,14 @@ document.querySelector("button").addEventListener("click", bound);
                        -

                        This step is essentially validating all of the requested module specifiers. We - treat a module with unresolvable module specifiers the same as one that cannot be parsed; in - both cases, a syntactic issue makes it impossible to ever contemplate linking the module - later.

                        +
                        +

                        This step is essentially validating all of the requested module specifiers and type + assertions. We treat a module with unresolvable module specifiers or unsupported type + assertions the same as one that cannot be parsed; in both cases, a syntactic issue makes + it impossible to ever contemplate linking the module later.

                        + +

                        Assertions with unknown keys are ignored.

                        +

                      11. Set script's record to From 3c94b3151c45c6fdbdcd0c21ce93b899ae68f7ba Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 12 Nov 2020 14:14:13 -0800 Subject: [PATCH 34/56] Review feedback: use tuple instead of pair, improve module map definition, use 'javascript' instead of undefined, fix indents. --- source | 101 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 52 insertions(+), 49 deletions(-) diff --git a/source b/source index 17b3852611d..3c9db84e481 100644 --- a/source +++ b/source @@ -2187,7 +2187,6 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

                      12. surrogate
                      13. scalar value
                      14. tuple
                        15. -
                      15. pair
                      16. noncharacter
                      17. string, code unit, @@ -2869,7 +2868,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

                        Users agents that support JavaScript must also implement ECMAScript Internationalization API.

                        -

                        User agents that support JavaScript must also implement the import assertions +

                        User agents that support JavaScript must also implement the Import Assertions proposal. The following term is defined there, and used in this specification:

                        @@ -90191,13 +90190,13 @@ document.querySelector("button").addEventListener("click", bound);

                        1. Let url be the result of resolving - a module specifier given referrer and - moduleRequst.[[Specifier]].

                          2. + a module specifier given referrer and moduleRequest.[[Specifier]]. +

                          -

                        2. Assert: url is never failure, because resolving a module specifier must have been previously successful with these same two - arguments.

                          3. +

                        3. Assert: url is never failure, because resolving a module specifier must have been previously successful with these same two + arguments.

                        4. Assert: visited set contains url.

                          5. @@ -90234,17 +90233,17 @@ document.querySelector("button").addEventListener("click", bound);

                        5. Let moduleMap be module map settings object's module map.

                          6. -

                        6. If moduleMap[url / undefined] is +

                        7. If moduleMap[(url, "javascript")] is "fetching", wait in parallel until that entry's value changes, then queue a task on the networking task source to proceed with running the following steps.

                          8. -

                        8. If moduleMap[url / undefined] exists, - asynchronously complete this algorithm with moduleMap[url / undefined], and - return.

                          9. +

                        9. If moduleMap[(url, "javascript")] exists, asynchronously complete this algorithm with + moduleMap[(url, "javascript")], and return.

                          10. -

                        10. Set moduleMap[url / undefined] to - "fetching".

                          +

                        11. Set moduleMap[(url, "javascript")] to "fetching".

                        12. Let request be a new request whose url is url, JavaScript MIME type,

                          13. -

                          then set moduleMap[url / undefined] to - null, asynchronously complete this algorithm with null, and return.

                          +

                          then set moduleMap[(url, "javascript")] to null, asynchronously complete this algorithm with null, and + return.

                        13. Let source text be the result of UTF-8 @@ -90305,9 +90305,9 @@ document.querySelector("button").addEventListener("click", bound); data-x="concept-response-url">url, and options.

                        14. -

                          Set moduleMap[url / undefined] to - module script, and asynchronously complete this algorithm with module - script.

                          +

                          Set moduleMap[(url, "javascript")] to module script, and asynchronously complete this + algorithm with module script.

                          It is intentional that the module map is keyed by the request URL, whereas the moduleScript would have been marked as itself having a parse error.)

                          15. -

                        15. Let childModule be moduleMap[childURL / undefined]. -

                          16. +

                        16. Let childModule be moduleMap[(childURL, "javascript")].

                        17. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module @@ -91238,20 +91238,23 @@ dictionary PromiseRejectionEventInit : EventInit {

                    -

                    A module map is a map keyed by - URL record / module type string pairs whose values are - either a module script, null (used to represent failed fetches), or a placeholder - value "fetching". Module maps are - used to ensure that imported JavaScript modules are only fetched, parsed, and evaluated once per - Document or worker. Currently only JavaScript - module scripts are supported, so the module type will always - be null until additional module types are introduced.

                    +

                    A module map is a map keyed by tuples consisting of a URL record and a string. + The URL record is the request URL at which + the module was fetched, and the string indicates the type of the module (e.g. "javascript"). The module map's values are either a module + script, null (used to represent failed fetches), or a placeholder value "fetching". Module maps are used to ensure + that imported JavaScript modules are only fetched, parsed, and evaluated once per + Document or worker . Currently only JavaScript module scripts are supported, so the module type will always be + "javascript" until additional module types are introduced.

                    -

                    Since module maps are keyed by URL / module type, the +

                    Since module maps are keyed by (URL, module type), the following code will create three separate entries in the module map, since it - results in three different URL/module type pairs (all with null type): -

                    + results in three different (URL, module type) tuples (all with null + type):

                    import "https://example.com/module.mjs";
 import "https://example.com/module.mjs#map-buster";
@@ -91277,24 +91280,24 @@ import "https://example.com/foo/../module2.mjs";
                    data-x="SharedWorker">shared workers are keyed by their parsed constructor url.

                    -

                    Once additional module types are introduced, it will be possible to have multiple map entries - for a single URL since module type is also part of the module map key. For - example, once JSON modules are introduced the following code will create two separate entries in - the module map (the type is undefined for the first, and - "json" for the second): +

                    Once additional module types are introduced, it will be possible to have multiple map entries + for a single URL since module type is also part of the module map key. For + example, once JSON modules are introduced the following code will create two separate entries in + the module map (the type is "javascript" for the first, and + "json" for the second): - 

                    import "https://example.com/module";
+   
                    import "https://example.com/module";
 import "https://example.com/module" assert { type: "json" };
                    
 
-    
                    In theory, this means that two separate fetches and two separate module evaluations would be
-    performed. In practice, due to the memory cache the resource will only be fetched once.
-    Additionally, as long as all module types are mutually exclusive, the module type check in
-    fetch a single module script will fail for at least one of the imports, so at most
-    one module evaluation will occur.
                    
+   
                    In theory, this means that two separate fetches and two separate module evaluations would be
+   performed. In practice, due to the memory cache the resource will only be fetched once.
+   Additionally, as long as all module types are mutually exclusive, the module type check in
+   fetch a single module script will fail for at least one of the imports, so at most
+   one module evaluation will occur.
                    
 
-    
                    The purpose of including the type in the module map key is so that an import
-    with the wrong type assertion does not prevent a different import of the same specifier but with
-    the correct type from succeeding.
                    
+   
                    The purpose of including the type in the module map key is so that an import
+   with the wrong type assertion does not prevent a different import of the same specifier but with
+   the correct type from succeeding.
                    @@ -91536,9 +91539,9 @@ import "https://example.com/module" assert { type: "json" }; same two arguments (either while creating the corresponding module script, or in fetch an import() module script graph).

                    11. -

                  11. Let resolved module script be moduleMap[url / undefined]. - (This entry must exist for us to have gotten to this point.) -

                    12. +

                  12. Let resolved module script be moduleMap[(url, "javascript")]. (This entry must exist for us to + have gotten to this point.)

                  13. Assert: resolved module script is a module script (i.e., is not null or "fetching").

                    14. From 9da92b56819d25d2c066adc98c1c699f43108559 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 13 Nov 2020 14:28:02 -0800 Subject: [PATCH 35/56] Review feedback: Link to memory cache issue, null --> 'javascript' type, misc whitespace issues. --- source | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/source b/source index 3c9db84e481..b6bc29bb4b0 100644 --- a/source +++ b/source @@ -89761,8 +89761,7 @@ document.querySelector("button").addEventListener("click", bound);

                    1. Let url be the result of resolving a - module specifier given base URL and moduleRequest.[[Specifier]].

                      -
                      2. + module specifier given base URL and moduleRequest.[[Specifier]].

                    2. If url is failure, then asynchronously complete this algorithm with null, and return.

                      3. @@ -90129,8 +90128,7 @@ document.querySelector("button").addEventListener("click", bound);

                      1. Let url be the result of resolving - data-x="concept-script-base-url">base URL and requested.[[Specifier]].

                        -
                        2. + data-x="concept-script-base-url">base URL and requested.[[Specifier]].

                      2. Assert: url is never failure, because resolving a module specifier must have been

                        the result of extracting a MIME type from response's header list is not a JavaScript MIME type,

                        3. - +

                        then set moduleMap[(url, "javascript")] to null, asynchronously complete this algorithm with null, and @@ -91253,8 +91251,8 @@ dictionary PromiseRejectionEventInit : EventInit {

                        Since module maps are keyed by (URL, module type), the following code will create three separate entries in the module map, since it - results in three different (URL, module type) tuples (all with null - type):

                        + results in three different (URL, module type) tuples (all with "javascript" type):

                        import "https://example.com/module.mjs";
 import "https://example.com/module.mjs#map-buster";
@@ -91290,8 +91288,9 @@ import "https://example.com/foo/../module2.mjs";
                        import "https://example.com/module" assert { type: "json" };

                        In theory, this means that two separate fetches and two separate module evaluations would be - performed. In practice, due to the memory cache the resource will only be fetched once. - Additionally, as long as all module types are mutually exclusive, the module type check in + performed. In practice, due to the due to the as-yet-unspecified memory cache (see issue #6110) the resource will only be fetched + once. Additionally, as long as all module types are mutually exclusive, the module type check in fetch a single module script will fail for at least one of the imports, so at most one module evaluation will occur.

                        @@ -91531,8 +91530,7 @@ import "https://example.com/module" assert { type: "json" }; data-x="concept-settings-object-module-map">module map.

                      3. Let url be the result of resolving a - module specifier given base URL and moduleRequest.[[Specifier]].

                        -
                        4. + module specifier given base URL and moduleRequest.[[Specifier]].

                      4. Assert: url is never failure, because resolving a module specifier must have been previously successful with these @@ -91540,8 +91538,8 @@ import "https://example.com/module" assert { type: "json" }; corresponding module script, or in fetch an import() module script graph).

                      5. Let resolved module script be moduleMap[(url, "javascript")]. (This entry must exist for us to - have gotten to this point.)

                        6. + data-x="">"javascript")]. (This entry must exist for us + to have gotten to this point.)

                      6. Assert: resolved module script is a module script (i.e., is not null or "fetching").

                        7. From 26c2b813f30b404c2209f439fec219037935ffaf Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Fri, 13 Nov 2020 14:31:27 -0800 Subject: [PATCH 36/56] Remove duplicated words --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index b6bc29bb4b0..330254c2b6e 100644 --- a/source +++ b/source @@ -91288,7 +91288,7 @@ import "https://example.com/foo/../module2.mjs"; import "https://example.com/module" assert { type: "json" };

                        In theory, this means that two separate fetches and two separate module evaluations would be - performed. In practice, due to the due to the as-yet-unspecified memory cache (see issue #6110) the resource will only be fetched once. Additionally, as long as all module types are mutually exclusive, the module type check in fetch a single module script will fail for at least one of the imports, so at most From 4ad7d2d0a6a9678ec6f48fd2103427ded4f7ca13 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 16 Nov 2020 13:09:17 -0800 Subject: [PATCH 37/56] Move quotes outside of elements. --- source | 54 +++++++++++++++++++++++++++--------------------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/source b/source index 330254c2b6e..b9761f489af 100644 --- a/source +++ b/source @@ -89768,13 +89768,13 @@ document.querySelector("button").addEventListener("click", bound);

                      7. If moduleRequest.[[Assertions]] has a Record entry such - that entry.[[Key]] is "type" then asynchronously complete this + that entry.[[Key]] is "type" then asynchronously complete this algorithm with null, and return.

                        Currently no non-JS module types are supported, so we conservatively fail if any type - assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module + assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module matches the type expected by the importer.

                        Assertions with unknown keys are ignored.

                        @@ -90231,17 +90231,17 @@ document.querySelector("button").addEventListener("click", bound);

                      8. Let moduleMap be module map settings object's module map.

                        9. -

                      9. If moduleMap[(url, "javascript")] is +

                      10. If moduleMap[(url, "javascript")] is "fetching", wait in parallel until that entry's value changes, then queue a task on the networking task source to proceed with running the following steps.

                        11. -

                      11. If moduleMap[(url, "javascript")]

                        If moduleMap[(url, "javascript")] exists, asynchronously complete this algorithm with - moduleMap[(url, "javascript")], and return.

                        12. + moduleMap[(url, "javascript")], and return.

                        -

                      12. Set moduleMap[(url, "javascript")] to "fetching".

                        +

                      13. Set moduleMap[(url, "javascript")] to "fetching".

                      14. Let request be a new request whose url is url, JavaScript MIME type,

                        15. -

                        then set moduleMap[(url, "javascript")] to null, asynchronously complete this algorithm with null, and +

                        then set moduleMap[(url, "javascript")] to null, asynchronously complete this algorithm with null, and return.

                        @@ -90303,8 +90303,8 @@ document.querySelector("button").addEventListener("click", bound); data-x="concept-response-url">url, and options.

                      15. -

                        Set moduleMap[(url, "javascript")] to module script, and asynchronously complete this +

                        Set moduleMap[(url, "javascript")] to module script, and asynchronously complete this algorithm with module script.

                        It is intentional that the module map is keyed by the moduleScript would have been marked as itself having a parse error.)

                        16. -

                      16. Let childModule be moduleMap[(childURL, "javascript")].

                        17. +

                      17. Let childModule be moduleMap[(childURL, "javascript")].

                      18. Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module @@ -90487,8 +90487,8 @@ document.querySelector("button").addEventListener("click", bound);

                      19. If url is failure, or if requested.[[Assertions]] has a - Record entry such that entry.[[Key]] is "type" then:

                        + Record entry such that entry.[[Key]] is "type" then:

                        1. Let error be a new TypeError exception.

                          2. @@ -90508,8 +90508,8 @@ document.querySelector("button").addEventListener("click", bound); it impossible to ever contemplate linking the module later.

                          Currently no non-JS module types are supported, so we conservatively fail if any type - assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module + assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module matches the type expected by the importer.

                          Assertions with unknown keys are ignored.

                          @@ -91239,20 +91239,20 @@ dictionary PromiseRejectionEventInit : EventInit {

                          A module map is a map keyed by tuples consisting of a URL record and a string. The URL record is the request URL at which - the module was fetched, and the string indicates the type of the module (e.g. "javascript"). The module map's values are either a module + the module was fetched, and the string indicates the type of the module (e.g. "javascript"). The module map's values are either a module script, null (used to represent failed fetches), or a placeholder value "fetching". Module maps are used to ensure that imported JavaScript modules are only fetched, parsed, and evaluated once per Document or worker . Currently only JavaScript module scripts are supported, so the module type will always be - "javascript" until additional module types are introduced.

                          + "javascript" until additional module types are introduced.

                          Since module maps are keyed by (URL, module type), the following code will create three separate entries in the module map, since it - results in three different (URL, module type) tuples (all with "javascript" type):

                          + results in three different (URL, module type) tuples (all with "javascript" type):

                          import "https://example.com/module.mjs";
 import "https://example.com/module.mjs#map-buster";
@@ -91281,8 +91281,8 @@ import "https://example.com/foo/../module2.mjs";

                          Once additional module types are introduced, it will be possible to have multiple map entries for a single URL since module type is also part of the module map key. For example, once JSON modules are introduced the following code will create two separate entries in - the module map (the type is "javascript" for the first, and - "json" for the second): + the module map (the type is "javascript" for the first, and + "json" for the second): 

                          import "https://example.com/module";
 import "https://example.com/module" assert { type: "json" };
                          @@ -91537,8 +91537,8 @@ import "https://example.com/module" assert { type: "json" };                           same two arguments (either while creating the corresponding module script, or in fetch an import() module script graph).

                          -

                        2. Let resolved module script be moduleMap[(url, "javascript")]. (This entry must exist for us +

                        3. Let resolved module script be moduleMap[(url, "javascript")]. (This entry must exist for us to have gotten to this point.)

                        4. Assert: resolved module script is a module script (i.e., is not From 614a9f4b94dac773329b6ae9a153d35eeb7611e6 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 30 Nov 2020 13:06:55 -0800 Subject: [PATCH 38/56] Add HostGetSupportedAssertions integration --- source | 38 +++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/source b/source index b9761f489af..d4c4b71d869 100644 --- a/source +++ b/source @@ -2869,11 +2869,12 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute Internationalization API.

                          User agents that support JavaScript must also implement the Import Assertions - proposal. The following term is defined there, and used in this specification:

                          • The ModuleRequest Record specification type
                            • +
                          • The HostGetSupportedAssertions abstract operation
                          @@ -89766,19 +89767,20 @@ document.querySelector("button").addEventListener("click", bound);

                        5. If url is failure, then asynchronously complete this algorithm with null, and return.

                          6. +

                        6. Assert: moduleRequest.[[Assertions]] does not contain any Record + entry such that entry.[[Key]] is not "type", because + we only asked for "type" assertions in + HostGetSupportedAssertions.

                          7. +

                        7. If moduleRequest.[[Assertions]] has a Record entry such that entry.[[Key]] is "type" then asynchronously complete this algorithm with null, and return.

                          -
                          -

                          Currently no non-JS module types are supported, so we conservatively fail if any type - assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module - matches the type expected by the importer.

                          - -

                          Assertions with unknown keys are ignored.

                          -
                          +

                          Currently no non-JS module types are supported, so we conservatively fail if any + type assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module + matches the type expected by the importer.

                        8. Fetch a single module script given url, settings @@ -90476,6 +90478,11 @@ document.querySelector("button").addEventListener("click", bound);

                        20. +

                      20. Assert: requested.[[Assertions]] does not contain any Record + entry such that entry.[[Key]] is not "type", because + we only asked for "type" assertions in + HostGetSupportedAssertions.

                        21. +

                      21. For each ModuleRequest record requested of result.[[RequestedModules]]:

                        @@ -90511,8 +90518,6 @@ document.querySelector("button").addEventListener("click", bound); assertion is provided. When support is added for other module types, the "type" assertion will be used to check that the type of the fetched module matches the type expected by the importer.

                        - -

                        Assertions with unknown keys are ignored.

                        22. @@ -91551,6 +91556,17 @@ import "https://example.com/module" assert { type: "json" }; data-x="concept-script-record">record.

                      +
                      HostGetSupportedAssertions()
                      + +

                      The Import Assertions proposal contains an implementation-defined + HostGetSupportedAssertions abstract operation. + User agents must use the following implementation:

                      + +
                        +

                      1. Return a new List whose sole item is the string + "type".

                        2. +
                      +

                      Event loops

                      From 2fc3616a44156363f9abf7a297b60ea4dc15bd7c Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 1 Dec 2020 10:27:29 -0800 Subject: [PATCH 39/56] Fix indentation/spacing. Use short list notation. --- source | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/source b/source index d4c4b71d869..8aedda4eb68 100644 --- a/source +++ b/source @@ -91558,14 +91558,13 @@ import "https://example.com/module" assert { type: "json" };
                      HostGetSupportedAssertions()
                      -

                      The Import Assertions proposal contains an implementation-defined - HostGetSupportedAssertions abstract operation. - User agents must use the following implementation:

                      +

                      The Import Assertions proposal contains an implementation-defined + HostGetSupportedAssertions abstract operation. + User agents must use the following implementation:

                      -
                        -

                      1. Return a new List whose sole item is the string - "type".

                        2. -
                      +
                        +

                      1. Return « "type" ».

                        2. +
                      From a9eed9bc2e2ddb868eeddc7d957bb611b70229f3 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 29 Dec 2020 15:03:05 -0800 Subject: [PATCH 40/56] Use two separate scripts in example so that at least one will actually evaluate --- source | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/source b/source index 3f931e7d3c0..6dc73fef901 100644 --- a/source +++ b/source @@ -89808,8 +89808,12 @@ import "https://example.com/foo/../module2.mjs"; the module map (the type is "javascript" for the first, and "json" for the second): - 
                      import "https://example.com/module";
-import "https://example.com/module" assert { type: "json" };
                      + 
                      <script>
+  import "https://example.com/module";
+</script>
+<script>
+  import "https://example.com/module" assert { type: "json" };
+</script>

                      In theory, this means that two separate fetches and two separate module evaluations would be performed. In practice, due to the as-yet-unspecified memory cache (see issue Date: Tue, 29 Dec 2020 15:03:37 -0800 Subject: [PATCH 41/56] Add module type to visited set. --- source | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/source b/source index 6dc73fef901..a20e1649dd2 100644 --- a/source +++ b/source @@ -88278,7 +88278,8 @@ document.querySelector("button").addEventListener("click", bound);

                    3. If result is null, asynchronously complete this algorithm with null, and return.

                      4. -

                    4. Let visited set be « url ».

                      5. +

                    5. Let visited set be « (url, "javascript") + ».

                    6. Fetch the descendants of and link result given settings object, @@ -88325,7 +88326,8 @@ document.querySelector("button").addEventListener("click", bound);

                    7. If result is null, asynchronously complete this algorithm with null, and return.

                      8. -

                    8. Let visited set be « url ».

                      9. +

                    9. Let visited set be « (url, "javascript") + ».

                    10. Fetch the descendants of and link result given settings object, @@ -88352,7 +88354,8 @@ document.querySelector("button").addEventListener("click", bound);

                      If result is not null, optionally perform the following steps:

                        -

                      1. Let visited set be « url ».

                        2. +

                      2. Let visited set be « (url, "javascript") + ».

                      3. Fetch the descendants of and link result given settings object, @@ -88580,7 +88583,8 @@ document.querySelector("button").addEventListener("click", bound);

                      4. If result is null, asynchronously complete this algorithm with null, and return.

                        5. -

                      5. Let visited set be « url ».

                        6. +

                      6. Let visited set be « (url, "javascript") + ».

                      7. Fetch the descendants of and link result given fetch client settings @@ -88671,14 +88675,14 @@ document.querySelector("button").addEventListener("click", bound);

                      8. If visited set does not contain - url, then:

                        + (url, "javascript"), then:

                        1. Append requested to moduleRequests.

                          2. -

                        2. Append url to visited - set.

                          3. +

                        3. Append (url, "javascript") to visited set.

                      @@ -88731,7 +88735,7 @@ document.querySelector("button").addEventListener("click", bound); arguments.

                    11. Assert: visited set contains - url.

                      12. + (url, "javascript").

                    12. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, From cf01c6de1cd7fd0271efdac6f3643ba09ea188e8 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 29 Dec 2020 15:03:05 -0800 Subject: [PATCH 42/56] Use two separate scripts in example so that at least one will actually evaluate --- source | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/source b/source index e5b03e95f58..34bb3f37f56 100644 --- a/source +++ b/source @@ -89931,22 +89931,26 @@ import "https://example.com/foo/../module2.mjs"; data-x="SharedWorker">shared workers are keyed by their parsed constructor url.

                      -

                      Since module type is also part of the module map key, the following code will - create two separate entries in the module map (the type is undefined for the first, - and "json" for the second): - - 

                      import "https://example.com/module";
-import "https://example.com/module" assert { type: "json" };
                      - -

                      In theory, this means that two separate fetches and two separate module evaluations would be - performed. In practice, due to the memory cache the resource will only be fetched once. - Additionally, as long as all module types are mutually exclusive, the module type check in - fetch a single module script will fail for at least one of the imports, so at most - one module evaluation will occur.

                      - -

                      The purpose of including the type in the module map key is so that an import - with the wrong type assertion does not prevent a different import of the same specifier but with - the correct type from succeeding.

                      +

                      Since module type is also part of the module map key, the following code will + create two separate entries in the module map (the type is undefined for the first, + and "json" for the second): + + 

                      <script>
+  import "https://example.com/module";
+</script>
+<script>
+  import "https://example.com/module" assert { type: "json" };
+</script>
                      + +

                      In theory, this means that two separate fetches and two separate module evaluations would be + performed. In practice, due to the memory cache the resource will only be fetched once. + Additionally, as long as all module types are mutually exclusive, the module type check in + fetch a single module script will fail for at least one of the imports, so at most + one module evaluation will occur.

                      + +

                      The purpose of including the type in the module map key is so that an import + with the wrong type assertion does not prevent a different import of the same specifier but with + the correct type from succeeding.

                      From d954ad799ec2306f8fdb343741b9c4b065e8d7bf Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 29 Dec 2020 15:03:37 -0800 Subject: [PATCH 43/56] Add module type to visited set. --- source | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/source b/source index 34bb3f37f56..879fcbaa816 100644 --- a/source +++ b/source @@ -88361,7 +88361,8 @@ document.querySelector("button").addEventListener("click", bound);

                    13. If result is null, asynchronously complete this algorithm with null, and return.

                      14. -

                    14. Let visited set be « url ».

                      15. +

                    15. Let visited set be « (url, "javascript") + ».

                    16. Fetch the descendants of and link result given settings object, @@ -88398,7 +88399,8 @@ document.querySelector("button").addEventListener("click", bound);

                    17. If result is null, asynchronously complete this algorithm with null, and return.

                      18. -

                    18. Let visited set be « url ».

                      19. +

                    19. Let visited set be « (url, "javascript") + ».

                    20. Fetch the descendants of and link result given settings object, @@ -88425,7 +88427,8 @@ document.querySelector("button").addEventListener("click", bound);

                      If result is not null, optionally perform the following steps:

                        -

                      1. Let visited set be « url ».

                        2. +

                      2. Let visited set be « (url, "javascript") + ».

                      3. Fetch the descendants of and link result given settings object, @@ -88653,7 +88656,8 @@ document.querySelector("button").addEventListener("click", bound);

                      4. If result is null, asynchronously complete this algorithm with null, and return.

                        5. -

                      5. Let visited set be « url ».

                        6. +

                      6. Let visited set be « (url, "javascript") + ».

                      7. Fetch the descendants of and link result given fetch client settings @@ -88745,14 +88749,14 @@ document.querySelector("button").addEventListener("click", bound);

                      8. If visited set does not contain - url, then:

                        + (url, "javascript"), then:

                        1. Append requested to moduleRequests.

                          2. -

                        2. Append url to visited - set.

                          3. +

                        3. Append (url, "javascript") to visited set.

                      @@ -88805,7 +88809,7 @@ document.querySelector("button").addEventListener("click", bound); arguments.

                    21. Assert: visited set contains - url.

                      22. + (url, "javascript").

                    22. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, From 5bc28f6725f5af81b66ca584b5303f1c92e75b06 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 30 Nov 2020 13:06:55 -0800 Subject: [PATCH 44/56] Add HostGetSupportedAssertions integration --- source | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/source b/source index 879fcbaa816..cad3fe3e470 100644 --- a/source +++ b/source @@ -2881,6 +2881,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute

                      • The ModuleRequest Record specification type
                        • +
                      • The HostGetSupportedAssertions abstract operation

                      User agents that support JavaScript must also implement the JSON modules @@ -88384,6 +88385,11 @@ document.querySelector("button").addEventListener("click", bound);

                    23. If url is failure, then asynchronously complete this algorithm with null, and return.

                      24. +

                    24. Assert: moduleRequest.[[Assertions]] does not contain any Record + entry such that entry.[[Key]] is not "type", because + we only asked for "type" assertions in + HostGetSupportedAssertions.

                      25. +

                    25. If moduleRequest.[[Assertions]] has a Record entry such that entry.[[Key]] is "type" and entry.[[Value]] is neither undefined nor "json", then asynchronously complete this @@ -89125,6 +89131,11 @@ document.querySelector("button").addEventListener("click", bound);

                    +

                  14. Assert: requested.[[Assertions]] does not contain any Record + entry such that entry.[[Key]] is not "type", because + we only asked for "type" assertions in + HostGetSupportedAssertions.

                    15. +

                  15. For each ModuleRequest record requested of result.[[RequestedModules]]:

                    @@ -89158,8 +89169,6 @@ document.querySelector("button").addEventListener("click", bound); assertions. We treat a module with unresolvable module specifiers or unsupported type assertions the same as one that cannot be parsed; in both cases, a syntactic issue makes it impossible to ever contemplate linking the module later.

                    - -

                    Assertions with unknown keys are ignored.

                    16. @@ -90211,6 +90220,17 @@ import "https://example.com/foo/../module2.mjs"; data-x="concept-script-record">record.

                  +
                  HostGetSupportedAssertions()
                  + +

                  The Import Assertions proposal contains an implementation-defined + HostGetSupportedAssertions abstract operation. + User agents must use the following implementation:

                  + +
                    +

                  1. Return a new List whose sole item is the string + "type".

                    2. +
                  +

                  Event loops

                  From 1b4da46b23fb649938ff5f8e5453b6c8529a7bd1 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 1 Dec 2020 10:27:29 -0800 Subject: [PATCH 45/56] Fix indentation/spacing. Use short list notation. --- source | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/source b/source index cad3fe3e470..fc73d58b902 100644 --- a/source +++ b/source @@ -90222,14 +90222,13 @@ import "https://example.com/foo/../module2.mjs";
                  HostGetSupportedAssertions()
                  -

                  The Import Assertions proposal contains an implementation-defined - HostGetSupportedAssertions abstract operation. - User agents must use the following implementation:

                  +

                  The Import Assertions proposal contains an implementation-defined + HostGetSupportedAssertions abstract operation. + User agents must use the following implementation:

                  -
                    -

                  1. Return a new List whose sole item is the string - "type".

                    2. -
                  +
                    +

                  1. Return « "type" ».

                    2. +
                  From 45f6c6e6563ddd4910fb6d6eb3d5cdd2971df402 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 30 Dec 2020 16:13:48 -0800 Subject: [PATCH 46/56] Fix up some issues from merge --- source | 140 ++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 99 insertions(+), 41 deletions(-) diff --git a/source b/source index 35d4e519245..6064ad59986 100644 --- a/source +++ b/source @@ -57577,11 +57577,14 @@ interface HTMLScriptElement : HTMLElement { redundantly setting it.

                9. 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).

                  10. + "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).

                10. 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

                  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>
                  @@ -57863,37 +57866,37 @@ o............A....e

                  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 defer 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.

                  + data-x="">module" will be fetched and evaluated (as a JavaScript module + script). Conversely, older user agents will ignore 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.

                  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">
@@ -57925,12 +57928,37 @@ 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 a JSON module script can be imported from inside + a JavaScript module script:

                  + + 
                  <script type="module">
+ import peopleInSpace from "http://api.open-notify.org/astros.json" assert { type: "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>
                  + +

                  MIME type checking for module scripts is strict. In order for the fetch of the + JSON module script to succeed, the HTTP reponse must have a + JSON MIME type, for example Content-Type: text/json. On the + other hand, if the assert { type: "json" } part of the statement is omitted, + it is assumed that the intent is to import a JavaScript module script, and the fetch + will fail if the HTTP response has a MIME type that is not a JavaScript MIME type. +

                  @@ -87861,10 +87889,22 @@ document.querySelector("button").addEventListener("click", bound);
                  A record
                  -

                  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.

                    • +
                  +
                  A parse error
                  @@ -88350,7 +88390,7 @@ document.querySelector("button").addEventListener("click", bound);

                11. If moduleRequest.[[Assertions]] has a Record entry such that entry.[[Key]] is "type" and entry.[[Value]] is - neither undefined nor "json", then asynchronously complete this + neither undefined nor "json", then asynchronously complete this algorithm with null, and return.

                12. Fetch a single module script given url, settings @@ -88728,8 +88768,8 @@ document.querySelector("button").addEventListener("click", bound);

                13. Let options be the descendant script fetch options for module script's fetch options.

                  14. -

                14. Assert: options is not null, as module script is a module - script.

                  15. +

                15. Assert: options is not null, as module script is a JavaScript + module script.

                16. For each moduleRequest in @@ -88817,8 +88857,8 @@ document.querySelector("button").addEventListener("click", bound);

                9. -

              9. Assert: module type is either "javascript" or "json". Otherwise we would not have reached this point because a failure would +

              10. Assert: module type is either "javascript" or "json". Otherwise we would not have reached this point because a failure would have been raised when inspecting moduleRequest.[[Assertions]] in create a JavaScript module script or fetch an import() module script graph.

                11. @@ -88898,7 +88938,7 @@ document.querySelector("button").addEventListener("click", bound);

              11. If MIME type is a JSON MIME type and module type is - "json", then set module script to the result of creating + "json", then set module script to the result of creating a JSON module script given source text and module map settings object.

                12. @@ -89105,7 +89145,7 @@ document.querySelector("button").addEventListener("click", bound);

              12. If url is failure, or if module type is neither "javascript" nor "json", then:

                + data-x="">javascript" nor "json", then:

                1. Let error be a new TypeError exception.

                  2. @@ -89902,7 +89942,7 @@ import "https://example.com/foo/../module2.mjs";

                  Since module type is also part of the module map key, the following code will create two separate entries in the module map (the type is "javascript" for the first, - and "json" for the second): + and "json" for the second): 

                  <script>
   import "https://example.com/module";
@@ -90016,6 +90056,10 @@ import "https://example.com/foo/../module2.mjs";

                  1. Let module script be moduleRecord.[[HostDefined]].

                    2. +

                  2. Assert: module script's base + URL is not null, as module script is a JavaScript module + script.

                    3. +

                  3. Let urlString be module script's base URL, serialized.

                    4. @@ -90070,6 +90114,10 @@ import "https://example.com/foo/../module2.mjs";

                  4. Set fetch options to the descendant script fetch options for referencing script's fetch options.

                    5. + +

                  5. 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 @@ -90119,6 +90167,9 @@ import "https://example.com/foo/../module2.mjs";

                2. Set base URL to referencing script's base URL.

                  3. + +

                3. Assert: base URL is not null, as referencing script is a + classic script or a JavaScript module script.

                @@ -90147,9 +90198,13 @@ import "https://example.com/foo/../module2.mjs"; same two arguments (either while creating the corresponding module script, or in fetch an import() module script graph).

                13. -

              13. Let resolved module script be moduleMap[(url, "javascript")]. (This entry must exist for us - to have gotten to this point.)

                14. +

              14. If moduleRequest.[[Assertions]] has a Record entry such + that entry.[[Key]] is "type", then let module type + be entry.[[Value]]. Otherwise let module type be undefined.

                15. + +

              15. Let resolved module script be moduleMap[(url, module + type)]. (This entry must exist for us to have gotten to + this point.)

              16. Assert: resolved module script is a module script (i.e., is not null or "fetching").

                17. @@ -93139,6 +93194,9 @@ enum DOMParserSupportedType {

              17. Let base URL be initiating script's base URL.

                18. +

              18. Assert: base URL is not null, as initiating script is a + classic script or a JavaScript module script.

                19. +

              19. Let fetch options be a script fetch options whose cryptographic nonce is initiating From 87eec91434d85e49d7269c65123f1ab671016797 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 30 Dec 2020 16:37:03 -0800 Subject: [PATCH 47/56] Update visited set changes for json module type --- source | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/source b/source index 6064ad59986..bb6adea4ebd 100644 --- a/source +++ b/source @@ -88388,10 +88388,13 @@ document.querySelector("button").addEventListener("click", bound); we only asked for "type" assertions in HostGetSupportedAssertions.

                20. -

              20. If moduleRequest.[[Assertions]] has a Record entry such - that entry.[[Key]] is "type" and entry.[[Value]] is - neither undefined nor "json", then asynchronously complete this - algorithm with null, and return.

                21. +

              21. If moduleRequest.[[Assertions]] has a Record entry + such that entry.[[Key]] is "type", then let module + type be entry.[[Value]]. Otherwise let module type be "javascript".

                22. + +

              22. If module type is neither "javascript" nor "json", then asynchronously complete this algorithm with null, and return.

              23. Fetch a single module script given url, settings object, "script", options, settings object, @@ -88403,8 +88406,7 @@ document.querySelector("button").addEventListener("click", bound);

              24. If result is null, asynchronously complete this algorithm with null, and return.

                25. -

              25. Let visited set be « (url, "javascript") - ».

                26. +

              26. Let visited set be « (url, module type) ».

              27. Fetch the descendants of and link result given settings object, @@ -88750,16 +88752,21 @@ document.querySelector("button").addEventListener("click", bound); href="#validate-requested-module-specifiers">previously successful with these same two arguments.

                28. +

              28. If moduleRequest.[[Assertions]] has a Record entry + such that entry.[[Key]] is "type", then let module + type be entry.[[Value]]. Otherwise let module type be "javascript".

                29. +

              29. If visited set does not contain - (url, "javascript"), then:

                + (url, module type), then:

                1. Append requested to moduleRequests.

                  2. -

                2. Append (url, "javascript") to visited set.

                  3. +

                3. Append (url, module type) to + visited set.

              @@ -88811,8 +88818,13 @@ document.querySelector("button").addEventListener("click", bound); href="#validate-requested-module-specifiers">previously successful with these same two arguments.

              +

            5. If moduleRequest.[[Assertions]] has a Record entry + such that entry.[[Key]] is "type", then let module + type be entry.[[Value]]. Otherwise let module type be "javascript".

              6. +

            6. Assert: visited set contains - (url, "javascript").

              7. + (url, module type).

            7. Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, @@ -88992,7 +89004,7 @@ document.querySelector("button").addEventListener("click", bound);

            8. If moduleRequest.[[Assertions]] has a Record entry such that entry.[[Key]] is "type", then let module type be entry.[[Value]]. Otherwise let module type be "javascript".

              9. + data-x="">javascript".

            9. Let childModule be moduleMap[(childURL, module type)].

              10. From fdc08f87501360b7c1b98d5027dd3129e64f62c5 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Thu, 31 Dec 2020 13:45:25 -0800 Subject: [PATCH 48/56] Clarify that memory cache mitigating violation of import assertions spec recommendation is not a sure thing. --- source | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/source b/source index a20e1649dd2..e93294b0b65 100644 --- a/source +++ b/source @@ -89819,12 +89819,18 @@ import "https://example.com/foo/../module2.mjs"; import "https://example.com/module" assert { type: "json" }; </script> -

              In theory, this means that two separate fetches and two separate module evaluations would be - performed. In practice, due to the as-yet-unspecified memory cache (see issue #6110) the resource will only be fetched - once. Additionally, as long as all module types are mutually exclusive, the module type check in - fetch a single module script will fail for at least one of the imports, so at most - one module evaluation will occur.

              +

              This can result in two separate fetches and two separate module evaluations being performed. + This is a willful violation of a constraint recommended (but not required) by the import + assertions specification stating that each call to HostResolveImportedModule with + the same referencingScriptOrModule, moduleRequest.[[Specifier]] pair must return the + same Module Record.

              + +

              In practice, due to the as-yet-unspecified memory cache (see issue #6110) the resource may only be fetched + once in WebKit and Blink-based browsers. Additionally, as long as all module types are mutually + exclusive, the module type check in fetch a single module script will fail for at + least one of the imports, so at most one module evaluation will occur.

              The purpose of including the type in the module map key is so that an import with the wrong type assertion does not prevent a different import of the same specifier but with From 9ec7c7ea0f28ee15ceffb6820122939a026214dd Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Wed, 10 Mar 2021 17:11:47 -0800 Subject: [PATCH 49/56] Add class='XXX' to note about the memory cache --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 29c86c39aae..b76416cec1d 100644 --- a/source +++ b/source @@ -90318,7 +90318,7 @@ import "https://example.com/foo/../module2.mjs"; same Module Record.

              -

              In practice, due to the as-yet-unspecified memory cache (see issue In practice, due to the as-yet-unspecified memory cache (see issue #6110) the resource may only be fetched once in WebKit and Blink-based browsers. Additionally, as long as all module types are mutually exclusive, the module type check in fetch a single module script will fail for at From aa104e0dbac4c08378efa600613d90b89b5c860c Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 26 Jul 2021 16:32:06 -0700 Subject: [PATCH 50/56] Fix spacing --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 31911aa5406..3f8229910ae 100644 --- a/source +++ b/source @@ -58811,7 +58811,7 @@ o............A....e li.textContent = `${name} / ${craft}`; list.append(li); } - </script> +</script>

              MIME type checking for module scripts is strict. In order for the fetch of the JSON module script to succeed, the HTTP reponse must have a JSON MIME type, for From 64c523d887ad5f6af209d29d9f238124c0d71e3f Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Mon, 26 Jul 2021 16:37:04 -0700 Subject: [PATCH 51/56] Delete duplicated example --- source | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/source b/source index 3f8229910ae..9a8224c2ff1 100644 --- a/source +++ b/source @@ -92635,34 +92635,6 @@ import "https://example.com/foo/../module2.mjs";

              Note that this behavior is the same as how shared workers are keyed by their parsed constructor url.

              - -

              Since module type is also part of the module map key, the following code will - create two separate entries in the module map (the type is "javascript" for the first, - and "json" for the second): - - 

              <script>
-  import "https://example.com/module";
-</script>
-<script>
-  import "https://example.com/module" assert { type: "json" };
-</script>
              - -

              This can result in two separate fetches and two separate module evaluations being performed. - This is a willful violation of a constraint recommended (but not required) by the import - assertions specification stating that each call to HostResolveImportedModule with - the same referencingScriptOrModule, moduleRequest.[[Specifier]] pair must return the - same Module Record.

              - -

              In practice, due to the as-yet-unspecified memory cache (see issue #6110) the resource may only be fetched - once in WebKit and Blink-based browsers. Additionally, as long as all module types are mutually - exclusive, the module type check in fetch a single module script will fail for at - least one of the imports, so at most one module evaluation will occur.

              - -

              The purpose of including the type in the module map key is so that an import - with the wrong type assertion does not prevent a different import of the same specifier but with - the correct type from succeeding.

              From 54498ba305841b9bfe61372beb2b93994e591373 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 27 Jul 2021 11:26:45 -0700 Subject: [PATCH 52/56] Restore updated comments about CSS/JSON module script definition --- source | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/source b/source index 9a8224c2ff1..4774e84097d 100644 --- a/source +++ b/source @@ -90473,6 +90473,12 @@ document.querySelector("button").addEventListener("click", bound); was created via the create a CSS module script algorithm. CSS module scripts represent a parsed CSS stylesheet.

              + +

              As CSS stylesheets do not import dependent modules, and do not throw exceptions on evaluation, the fetch options and base URL of a CSS module script are @@ -90485,6 +90491,12 @@ document.querySelector("button").addEventListener("click", bound); 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 From 9de359aa44a9aad9da62c0a7814de2753cd253ba Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 27 Jul 2021 14:46:10 -0700 Subject: [PATCH 53/56] Combine some paragraphs --- source | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/source b/source index 4774e84097d..feb240c87fd 100644 --- a/source +++ b/source @@ -90390,11 +90390,8 @@ document.querySelector("button").addEventListener("click", bound);

            10. a Source Text Module Record, for JavaScript module scripts;

              11. -

            11. a Synthetic Module Record, for CSS - module scripts; or

              12. - -

            12. a Synthetic Module Record, for JSON - module scripts; or

              13. +

            13. a Synthetic Module Record, for CSS module + scripts and JSON module scripts

            14. null, representing a parsing failure.

              15. @@ -90478,11 +90475,6 @@ document.querySelector("button").addEventListener("click", bound); testing if something is a CSS module script in algorithms, instead of just referring to the concept, then we should consider adding a type item to the module script struct. --> - -

              As CSS stylesheets do not import dependent modules, and do not throw exceptions - on evaluation, the fetch options and - base URL of a CSS module script are - always null.

            15. @@ -90496,13 +90488,14 @@ document.querySelector("button").addEventListener("click", bound); testing if something is a JSON module script in algorithms, instead of just referring to the concept, then we should consider adding a type item to the module script struct. --> - -

              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.

              +

              As CSS stylesheets and JSON documents do not import dependent modules, and do not + throw exceptions on evaluation, the fetch + options and base URL of CSS module scripts and JSON module + scripts and are always null.

              +

              The active script is determined by the following algorithm:

                From d4f5bd0b35269d76fe8a364d3606746f2478e15d Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 27 Jul 2021 14:53:38 -0700 Subject: [PATCH 54/56] Add missing closing tags --- source | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source b/source index feb240c87fd..06c9674ad76 100644 --- a/source +++ b/source @@ -91772,7 +91772,7 @@ document.querySelector("button").addEventListener("click", bound); error to rethrow to null.

              1. -

                Let result be ParseJSONModule(source). +

                Let result be ParseJSONModule(source).

                If this throws an exception, set script's parse error to that exception, and return @@ -91780,7 +91780,7 @@ document.querySelector("button").addEventListener("click", bound);

              2. Set script's record to - result. + result.

              3. Return script.

              From 43526c470b1f7eea615fdc3d8cda03fc44288ae5 Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 27 Jul 2021 15:06:14 -0700 Subject: [PATCH 55/56] Use CreateDefaultExportSyntheticModule for CSS module scripts --- source | 22 ++-------------------- 1 file changed, 2 insertions(+), 20 deletions(-) diff --git a/source b/source index 06c9674ad76..bf48fc7fc79 100644 --- a/source +++ b/source @@ -2896,7 +2896,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute spec=JSJSONMODULES>

                -
              • The CreateSyntheticModule abstract operation
                • +
              • The CreateDefaultExportSyntheticModule abstract operation
              • The SetSyntheticModuleExport abstract operation
              • The Synthetic Module Record specification type
              • The ParseJSONModule abstract operation
                • @@ -91733,29 +91733,11 @@ document.querySelector("button").addEventListener("click", bound);

              • Set script's record to the result - of creating a synthetic - module record with a default export of sheet with settings.

                -
                • + of CreateDefaultExportSyntheticModule(sheet).

              • Return script.

            -

            To create a synthetic module record with a default export of a JavaScript value - value with an environment settings object settings:

            - -
              -
            1. -

              Return CreateSyntheticModule(« "default" », the following - steps, settings's Realm, - value) with the following steps given module as an argument:

              - -
                -
              1. Perform ! SetSyntheticModuleExport(module, "default", module.[[HostDefined]]).
                2. -
              -
              2. -
            -

            To create a JSON module script, given a string source and an environment settings object settings:

            From 10af46b46b1083632d1c8270fb780af0b9d1f04a Mon Sep 17 00:00:00 2001 From: Daniel Clark Date: Tue, 27 Jul 2021 15:17:01 -0700 Subject: [PATCH 56/56] Use not/or instead of neither/nor --- source | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/source b/source index bf48fc7fc79..ceca857e0cf 100644 --- a/source +++ b/source @@ -90894,8 +90894,8 @@ document.querySelector("button").addEventListener("click", bound); type be entry.[[Value]]. Otherwise let module type be "javascript".

            -

          4. If module type is neither "javascript", "css", nor "json", then asynchronously complete this +

          5. If module type is not "javascript", "css", or "json", then asynchronously complete this algorithm with null, and return.

          6. Fetch a single module script given url, settings @@ -91373,11 +91373,12 @@ document.querySelector("button").addEventListener("click", bound);

          -

        12. Assert: module type is either "javascript", "css", or "json". Otherwise we would not have reached this - point because a failure would have been raised when inspecting - moduleRequest.[[Assertions]] in create - a JavaScript module script or fetch an import() module script graph.

          13. +

        13. Assert: module type is "javascript", "css", or "json". Otherwise we would not have reached + this point because a failure would have been raised when inspecting + moduleRequest.[[Assertions]] in create a JavaScript module script or + fetch an import() module script graph.

        14. Let moduleMap be module map settings object's module map.

          15. @@ -91669,8 +91670,8 @@ document.querySelector("button").addEventListener("click", bound); data-x="">javascript".

        15. -

          If url is failure, or if module type is neither "javascript", "css", nor "json", +

          If url is failure, or if module type is not "javascript", "css", or "json", then:

          1. Let error be a new TypeError exception.