es-module-shims 2.1.1 → 2.2.0

package/dist/es-module-shims.wasm.js

@@ -1,4 +1,4 @@
-/* ES Module Shims Wasm 2.1.1 */
+/* ES Module Shims Wasm 2.2.0 */
 (function () {
 
   const hasDocument = typeof document !== 'undefined';
@@ -49,15 +49,11 @@
 
   const enable = Array.isArray(esmsInitOptions.polyfillEnable) ? esmsInitOptions.polyfillEnable : [];
   const enableAll = esmsInitOptions.polyfillEnable === 'all' || enable.includes('all');
-  const enableLatest = esmsInitOptions.polyfillEnable === 'latest' || enable.includes('latest');
-  const cssModulesEnabled = enable.includes('css-modules') || enableAll || enableLatest;
-  const jsonModulesEnabled = enable.includes('json-modules') || enableAll || enableLatest;
   const wasmInstancePhaseEnabled =
     enable.includes('wasm-modules') || enable.includes('wasm-module-instances') || enableAll;
   const wasmSourcePhaseEnabled =
     enable.includes('wasm-modules') || enable.includes('wasm-module-sources') || enableAll;
   const deferPhaseEnabled = enable.includes('import-defer') || enableAll;
-  const typescriptEnabled = enable.includes('typescript') || enableAll;
 
   const onpolyfill =
     esmsInitOptions.onpolyfill ?
@@ -292,116 +288,114 @@
     }
   }
 
-  // support browsers without dynamic import support (eg Firefox 6x)
-  let supportsJsonType = false;
-  let supportsCssType = false;
-
-  const supports = hasDocument && HTMLScriptElement.supports;
-
-  let supportsImportMaps = supports && supports.name === 'supports' && supports('importmap');
-  let supportsWasmInstancePhase = false;
-  let supportsWasmSourcePhase = false;
-  let supportsMultipleImportMaps = false;
-
-  const wasmBytes = [0, 97, 115, 109, 1, 0, 0, 0];
-
-  let featureDetectionPromise = (async function () {
-    if (!hasDocument)
-      return Promise.all([
-        cssModulesEnabled &&
-          import(createBlob(`import"${createBlob('', 'text/css')}"with{type:"css"}`)).then(
-            () => (supportsCssType = true),
-            noop
-          ),
-        jsonModulesEnabled &&
-          import(createBlob(`import"${createBlob('{}', 'text/json')}"with{type:"json"}`)).then(
-            () => (supportsJsonType = true),
-            noop
-          ),
-        wasmInstancePhaseEnabled &&
-          import(createBlob(`import"${createBlob(new Uint8Array(wasmBytes), 'application/wasm')}"`)).then(
-            () => (supportsWasmInstancePhase = true),
-            noop
-          ),
-        wasmSourcePhaseEnabled &&
-          import(createBlob(`import source x from"${createBlob(new Uint8Array(wasmBytes), 'application/wasm')}"`)).then(
-            () => (supportsWasmSourcePhase = true),
-            noop
-          )
-      ]);
-
-    return new Promise(resolve => {
-      const iframe = document.createElement('iframe');
-      iframe.style.display = 'none';
-      iframe.setAttribute('nonce', nonce);
-      function cb({ data }) {
-        const isFeatureDetectionMessage = Array.isArray(data) && data[0] === 'esms';
-        if (!isFeatureDetectionMessage) return;
-        [
-          ,
-          supportsImportMaps,
-          supportsMultipleImportMaps,
-          supportsCssType,
-          supportsJsonType,
-          supportsWasmSourcePhase,
-          supportsWasmInstancePhase
-        ] = data;
-        resolve();
-        document.head.removeChild(iframe);
-        window.removeEventListener('message', cb, false);
-      }
-      window.addEventListener('message', cb, false);
-
-      // Feature checking with careful avoidance of unnecessary work - all gated on initial import map supports check. JSON gates on CSS feature check, Wasm instance phase gates on wasm source phase check.
-      const importMapTest = `<script nonce=${nonce || ''}>b=(s,type='text/javascript')=>URL.createObjectURL(new Blob([s],{type}));c=u=>import(u).then(()=>true,()=>false);i=innerText=>document.head.appendChild(Object.assign(document.createElement('script'),{type:'importmap',nonce:"${nonce}",innerText}));i(\`{"imports":{"x":"\${b('')}"}}\`);i(\`{"imports":{"y":"\${b('')}"}}\`);cm=${
-      supportsImportMaps && cssModulesEnabled ? `c(b(\`import"\${b('','text/css')}"with{type:"css"}\`))` : 'false'
-    };sp=${
-      supportsImportMaps && wasmSourcePhaseEnabled ?
-        `c(b(\`import source x from "\${b(new Uint8Array(${JSON.stringify(wasmBytes)}),'application/wasm')\}"\`))`
-      : 'false'
-    };Promise.all([${supportsImportMaps ? 'true' : "c('x')"},${supportsImportMaps ? "c('y')" : false},cm,${
-      supportsImportMaps && jsonModulesEnabled ?
-        `${cssModulesEnabled ? 'cm.then(s=>s?' : ''}c(b(\`import"\${b('{}','text/json')\}"with{type:"json"}\`))${cssModulesEnabled ? ':false)' : ''}`
-      : 'false'
-    },sp,${
-      supportsImportMaps && wasmInstancePhaseEnabled ?
-        `${wasmSourcePhaseEnabled ? 'sp.then(s=>s?' : ''}c(b(\`import"\${b(new Uint8Array(${JSON.stringify(wasmBytes)}),'application/wasm')\}"\`))${wasmSourcePhaseEnabled ? ':false)' : ''}`
-      : 'false'
-    }]).then(a=>parent.postMessage(['esms'].concat(a),'*'))<${''}/script>`;
-
-      // Safari will call onload eagerly on head injection, but we don't want the Wechat
-      // path to trigger before setting srcdoc, therefore we track the timing
-      let readyForOnload = false,
-        onloadCalledWhileNotReady = false;
-      function doOnload() {
-        if (!readyForOnload) {
-          onloadCalledWhileNotReady = true;
-          return;
-        }
-        // WeChat browser doesn't support setting srcdoc scripts
-        // But iframe sandboxes don't support contentDocument so we do this as a fallback
-        const doc = iframe.contentDocument;
-        if (doc && doc.head.childNodes.length === 0) {
-          const s = doc.createElement('script');
-          if (nonce) s.setAttribute('nonce', nonce);
-          s.innerHTML = importMapTest.slice(15 + (nonce ? nonce.length : 0), -9);
-          doc.head.appendChild(s);
-        }
-      }
-
-      iframe.onload = doOnload;
-      // WeChat browser requires append before setting srcdoc
-      document.head.appendChild(iframe);
-
-      // setting srcdoc is not supported in React native webviews on iOS
-      // setting src to a blob URL results in a navigation event in webviews
-      // document.write gives usability warnings
-      readyForOnload = true;
-      if ('srcdoc' in iframe) iframe.srcdoc = importMapTest;
-      else iframe.contentDocument.write(importMapTest);
-      // retrigger onload for Safari only if necessary
-      if (onloadCalledWhileNotReady) doOnload();
-    });
+  // support browsers without dynamic import support (eg Firefox 6x)
+  let supportsJsonType = false;
+  let supportsCssType = false;
+
+  const supports = hasDocument && HTMLScriptElement.supports;
+
+  let supportsImportMaps = supports && supports.name === 'supports' && supports('importmap');
+  let supportsWasmInstancePhase = false;
+  let supportsWasmSourcePhase = false;
+  let supportsMultipleImportMaps = false;
+
+  const wasmBytes = [0, 97, 115, 109, 1, 0, 0, 0];
+
+  let featureDetectionPromise = (async function () {
+    if (!hasDocument)
+      return Promise.all([
+        import(createBlob(`import"${createBlob('{}', 'text/json')}"with{type:"json"}`)).then(
+          () => (
+            (supportsJsonType = true),
+            import(createBlob(`import"${createBlob('', 'text/css')}"with{type:"css"}`)).then(
+              () => (supportsCssType = true),
+              noop
+            )
+          ),
+          noop
+        ),
+        wasmInstancePhaseEnabled &&
+          import(createBlob(`import"${createBlob(new Uint8Array(wasmBytes), 'application/wasm')}"`)).then(
+            () => (supportsWasmInstancePhase = true),
+            noop
+          ),
+        wasmSourcePhaseEnabled &&
+          import(createBlob(`import source x from"${createBlob(new Uint8Array(wasmBytes), 'application/wasm')}"`)).then(
+            () => (supportsWasmSourcePhase = true),
+            noop
+          )
+      ]);
+
+    return new Promise(resolve => {
+      const iframe = document.createElement('iframe');
+      iframe.style.display = 'none';
+      iframe.setAttribute('nonce', nonce);
+      function cb({ data }) {
+        const isFeatureDetectionMessage = Array.isArray(data) && data[0] === 'esms';
+        if (!isFeatureDetectionMessage) return;
+        [
+          ,
+          supportsImportMaps,
+          supportsMultipleImportMaps,
+          supportsJsonType,
+          supportsCssType,
+          supportsWasmSourcePhase,
+          supportsWasmInstancePhase
+        ] = data;
+        resolve();
+        document.head.removeChild(iframe);
+        window.removeEventListener('message', cb, false);
+      }
+      window.addEventListener('message', cb, false);
+
+      // Feature checking with careful avoidance of unnecessary work - all gated on initial import map supports check. CSS gates on JSON feature check, Wasm instance phase gates on wasm source phase check.
+      const importMapTest = `<script nonce=${nonce || ''}>b=(s,type='text/javascript')=>URL.createObjectURL(new Blob([s],{type}));c=u=>import(u).then(()=>true,()=>false);i=innerText=>document.head.appendChild(Object.assign(document.createElement('script'),{type:'importmap',nonce:"${nonce}",innerText}));i(\`{"imports":{"x":"\${b('')}"}}\`);i(\`{"imports":{"y":"\${b('')}"}}\`);cm=${
+      supportsImportMaps ? `c(b(\`import"\${b('{}','text/json')}"with{type:"json"}\`))` : 'false'
+    };sp=${
+      supportsImportMaps && wasmSourcePhaseEnabled ?
+        `c(b(\`import source x from "\${b(new Uint8Array(${JSON.stringify(wasmBytes)}),'application/wasm')\}"\`))`
+      : 'false'
+    };Promise.all([${supportsImportMaps ? 'true' : "c('x')"},${supportsImportMaps ? "c('y')" : false},cm,${
+      supportsImportMaps ? `cm.then(s=>s?c(b(\`import"\${b('','text/css')\}"with{type:"css"}\`)):false)` : 'false'
+    },sp,${
+      supportsImportMaps && wasmInstancePhaseEnabled ?
+        `${wasmSourcePhaseEnabled ? 'sp.then(s=>s?' : ''}c(b(\`import"\${b(new Uint8Array(${JSON.stringify(wasmBytes)}),'application/wasm')\}"\`))${wasmSourcePhaseEnabled ? ':false)' : ''}`
+      : 'false'
+    }]).then(a=>parent.postMessage(['esms'].concat(a),'*'))<${''}/script>`;
+
+      // Safari will call onload eagerly on head injection, but we don't want the Wechat
+      // path to trigger before setting srcdoc, therefore we track the timing
+      let readyForOnload = false,
+        onloadCalledWhileNotReady = false;
+      function doOnload() {
+        if (!readyForOnload) {
+          onloadCalledWhileNotReady = true;
+          return;
+        }
+        // WeChat browser doesn't support setting srcdoc scripts
+        // But iframe sandboxes don't support contentDocument so we do this as a fallback
+        const doc = iframe.contentDocument;
+        if (doc && doc.head.childNodes.length === 0) {
+          const s = doc.createElement('script');
+          if (nonce) s.setAttribute('nonce', nonce);
+          s.innerHTML = importMapTest.slice(15 + (nonce ? nonce.length : 0), -9);
+          doc.head.appendChild(s);
+        }
+      }
+
+      iframe.onload = doOnload;
+      // WeChat browser requires append before setting srcdoc
+      document.head.appendChild(iframe);
+
+      // setting srcdoc is not supported in React native webviews on iOS
+      // setting src to a blob URL results in a navigation event in webviews
+      // document.write gives usability warnings
+      readyForOnload = true;
+      if ('srcdoc' in iframe) iframe.srcdoc = importMapTest;
+      else iframe.contentDocument.write(importMapTest);
+      // retrigger onload for Safari only if necessary
+      if (onloadCalledWhileNotReady) doOnload();
+    });
   })();
 
   /* es-module-lexer 1.7.0 */
@@ -460,12 +454,16 @@
     // we mock import('./x.css', { with: { type: 'css' }}) support via an inline static reexport
     // because we can't syntactically pass through to dynamic import with a second argument
     let url = await importHandler(id, opts, parentUrl);
-    let source = null;
-    if (typeof opts === 'object' && typeof opts.with === 'object' && typeof opts.with.type === 'string') {
-      source = `export{default}from'${url}'with{type:"${opts.with.type}"}`;
-      url += '?entry';
+    let source = undefined;
+    let ts = false;
+    if (typeof opts === 'object') {
+      ts = opts.lang === 'ts';
+      if (typeof opts.with === 'object' && typeof opts.with.type === 'string') {
+        source = `export{default}from'${url}'with{type:"${opts.with.type}"}`;
+        url += '?entry';
+      }
     }
-    return topLevelLoad(url, { credentials: 'same-origin' }, source, undefined, undefined);
+    return topLevelLoad(url, { credentials: 'same-origin' }, source, undefined, undefined, ts);
   }
 
   // import.source()
@@ -477,7 +475,7 @@
         opts = undefined;
       }
       const url = await importHandler(specifier, opts, parentUrl);
-      const load = getOrCreateLoad(url, { credentials: 'same-origin' }, null, null);
+      const load = getOrCreateLoad(url, { credentials: 'same-origin' }, undefined, undefined);
       if (firstPolyfillLoad && !shimMode && load.n && nativelyLoaded) {
         onpolyfill();
         firstPolyfillLoad = false;
@@ -539,14 +537,13 @@
     baselinePassthrough =
       esmsInitOptions.polyfillEnable !== true &&
       supportsImportMaps &&
-      (!jsonModulesEnabled || supportsJsonType) &&
-      (!cssModulesEnabled || supportsCssType) &&
+      supportsJsonType &&
+      supportsCssType &&
       (!wasmInstancePhaseEnabled || supportsWasmInstancePhase) &&
       (!wasmSourcePhaseEnabled || supportsWasmSourcePhase) &&
       !deferPhaseEnabled &&
       (!multipleImportMaps || supportsMultipleImportMaps) &&
-      !importMapSrc &&
-      !typescriptEnabled;
+      !importMapSrc;
     if (
       !shimMode &&
       wasmSourcePhaseEnabled &&
@@ -630,19 +627,18 @@
   let firstPolyfillLoad = true;
   let legacyAcceptingImportMaps = true;
 
-  async function topLevelLoad(url, fetchOpts, source, nativelyLoaded, lastStaticLoadPromise) {
-    legacyAcceptingImportMaps = false;
+  async function topLevelLoad(url, fetchOpts, source, nativelyLoaded, lastStaticLoadPromise, typescript) {
     await initPromise;
     await importMapPromise;
     if (importHook) await importHook(url, typeof fetchOpts !== 'string' ? fetchOpts : {}, '');
     // early analysis opt-out - no need to even fetch if we have feature support
-    if (!shimMode && baselinePassthrough) {
+    if (!shimMode && baselinePassthrough && !typescript) {
       // for polyfill case, only dynamic import needs a return value here, and dynamic import will never pass nativelyLoaded
       if (nativelyLoaded) return null;
       await lastStaticLoadPromise;
       return dynamicImport(source ? createBlob(source) : url);
     }
-    const load = getOrCreateLoad(url, fetchOpts, null, source);
+    const load = getOrCreateLoad(url, fetchOpts, undefined, source);
     linkLoad(load, fetchOpts);
     const seen = {};
     await loadAll(load, seen);
@@ -660,12 +656,12 @@
       onpolyfill();
       firstPolyfillLoad = false;
     }
-    const module = await (!shimMode && !load.n && !load.N ? import(load.u) : dynamicImport(load.b, load.u));
+    const module = await (shimMode || load.n || load.N || (!nativelyLoaded && source) ?
+      dynamicImport(load.b, load.u)
+    : import(load.u));
     // if the top-level load is a shell, run its update function
     if (load.s) (await dynamicImport(load.s, load.u)).u$_(module);
     if (revokeBlobURLs) revokeObjectURLs(Object.keys(seen));
-    // when tla is supported, this should return the tla promise as an actual handle
-    // so readystate can still correspond to the sync subgraph exec completions
     return module;
   }
 
@@ -679,7 +675,7 @@
       if (batchStartIndex > keysLength) return;
       for (const key of registryKeys.slice(batchStartIndex, batchStartIndex + 100)) {
         const load = registry[key];
-        if (load && load.b) URL.revokeObjectURL(load.b);
+        if (load && load.b && load.b !== load.u) URL.revokeObjectURL(load.b);
       }
       batch++;
       schedule(cleanup);
@@ -741,6 +737,14 @@
       }
       // dependency source replacements
       else if (dynamicImportIndex === -1) {
+        let keepAssertion = false;
+        if (a > 0 && !shimMode) {
+          const assertion = source.slice(a, statementEnd - 1);
+          // strip assertions only when unsupported in polyfill mode
+          keepAssertion =
+            (supportsJsonType && assertion.includes('json')) || (supportsCssType && assertion.includes('css'));
+        }
+
         // defer phase stripping
         if (t === 6) {
           pushStringTo(statementStart);
@@ -768,9 +772,6 @@
           }
         }
 
-        // strip import assertions unless we support them
-        const stripAssertion = (!supportsCssType && !supportsJsonType) || !(a > 0);
-
         pushStringTo(start - 1);
         resolvedSource += `/*${source.slice(start - 1, end + 1)}*/'${blobUrl}'`;
 
@@ -779,7 +780,7 @@
           resolvedSource += `;import*as m$_${depIndex} from'${depLoad.b}';import{u$_ as u$_${depIndex}}from'${depLoad.s}';u$_${depIndex}(m$_${depIndex})`;
           depLoad.s = undefined;
         }
-        lastIndex = stripAssertion ? statementEnd : end + 1;
+        lastIndex = keepAssertion ? end + 1 : statementEnd;
       }
       // import.meta
       else if (dynamicImportIndex === -2) {
@@ -841,7 +842,6 @@
     }
 
     pushStringTo(source.length);
-    console.log(resolvedSource);
 
     if (sourceURLCommentStart === -1) resolvedSource += sourceURLCommentPrefix + load.r;
 
@@ -937,14 +937,13 @@
       )});export default s;`,
         t: 'css'
       };
-    } else if (
-      (shimMode || typescriptEnabled) &&
-      (tsContentType.test(contentType) || url.endsWith('.ts') || url.endsWith('.mts'))
-    ) {
+    } else if (tsContentType.test(contentType) || url.endsWith('.ts') || url.endsWith('.mts')) {
       const source = await res.text();
       if (!esmsTsTransform) await initTs();
       const transformed = esmsTsTransform(source, url);
-      return { r, s: transformed === undefined ? source : transformed, t: transformed !== undefined ? 'ts' : 'js' };
+      // even if the TypeScript is valid JavaScript, unless it was a top-level inline source, it wasn't served with
+      // a valid JS MIME here, so we must still polyfill it
+      return { r, s: transformed === undefined ? source : transformed, t: 'ts' };
     } else
       throw Error(
         `Unsupported Content-Type "${contentType}" loading ${url}${fromParent(parent)}. Modules must be served with a valid MIME type like application/javascript.`
@@ -952,13 +951,7 @@
   }
 
   function isUnsupportedType(type) {
-    if (
-      (type === 'css' && !cssModulesEnabled) ||
-      (type === 'json' && !jsonModulesEnabled) ||
-      (type === 'wasm' && !wasmInstancePhaseEnabled && !wasmSourcePhaseEnabled) ||
-      (type === 'ts' && !typescriptEnabled)
-    )
-      throw featErr(`${type}-modules`);
+    if (type === 'wasm' && !wasmInstancePhaseEnabled && !wasmSourcePhaseEnabled) throw featErr(`wasm-modules`);
     return (
       (type === 'css' && !supportsCssType) ||
       (type === 'json' && !supportsJsonType) ||
@@ -994,9 +987,9 @@
       b: undefined,
       // shellUrl
       s: undefined,
-      // needsShim
+      // needsShim: does it fail execution in the current native loader?
       n: false,
-      // shouldShim
+      // shouldShim: does it need to be loaded by the polyfill loader?
       N: false,
       // type
       t: null,
@@ -1004,7 +997,7 @@
       m: null
     };
     load.f = (async () => {
-      if (!load.S) {
+      if (load.S === undefined) {
         // preload fetch options override fetch options (race)
         ({ r: load.r, s: load.S, t: load.t } = await (fetchCache[url] || fetchModule(url, fetchOpts, parent)));
         if (!load.n && load.t !== 'js' && !shimMode && isUnsupportedType(load.t)) {
@@ -1032,17 +1025,25 @@
     load.L = load.f.then(async () => {
       let childFetchOpts = fetchOpts;
       load.d = load.a[0]
-        .map(({ n, d, t, a }) => {
+        .map(({ n, d, t, a, se }) => {
           const phaseImport = t >= 4;
           const sourcePhase = phaseImport && t < 6;
           if (phaseImport) {
             if (!shimMode && (sourcePhase ? !wasmSourcePhaseEnabled : !deferPhaseEnabled))
-              throw featErr(sourcePhase ? 'source-phase' : 'defer-phase');
+              throw featErr(sourcePhase ? 'wasm-module-sources' : 'import-defer');
             if (!sourcePhase || !supportsWasmSourcePhase) load.n = true;
           }
-          if (a > 0) {
-            if (!shimMode && !cssModulesEnabled && !jsonModulesEnabled) throw featErr('css-modules / json-modules');
-            if (!supportsCssType && !supportsJsonType) load.n = true;
+          let source = undefined;
+          if (a > 0 && !shimMode) {
+            const assertion = load.S.slice(a, se - 1);
+            // no need to fetch JSON/CSS if supported, since it's a leaf node, we'll just strip the assertion syntax
+            if (assertion.includes('json')) {
+              if (supportsJsonType) source = '';
+              else load.n = true;
+            } else if (assertion.includes('css')) {
+              if (supportsCssType) source = '';
+              else load.n = true;
+            }
           }
           if (d !== -1 || !n) return;
           const resolved = resolve(n, load.r || load.u);
@@ -1051,7 +1052,9 @@
           if (d !== -1) return;
           if (skip && skip(resolved.r) && !sourcePhase) return { l: { b: resolved.r }, s: false };
           if (childFetchOpts.integrity) childFetchOpts = Object.assign({}, childFetchOpts, { integrity: undefined });
-          const child = { l: getOrCreateLoad(resolved.r, childFetchOpts, load.r, null), s: sourcePhase };
+          const child = { l: getOrCreateLoad(resolved.r, childFetchOpts, load.r, source), s: sourcePhase };
+          // assertion case -> inline the CSS / JSON URL directly
+          if (source === '') child.l.b = child.l.u;
           if (!child.s) linkLoad(child.l, fetchOpts);
           // load, sourcePhase
           return child;
@@ -1158,42 +1161,48 @@
 
   function processScript(script, ready = readyStateCompleteCnt > 0) {
     if (epCheck(script, ready)) return;
-    if (script.lang === 'ts' && !script.src) {
-      const source = script.innerHTML;
-      return initTs()
+    // does this load block readystate complete
+    const isBlockingReadyScript = script.getAttribute('async') === null && readyStateCompleteCnt > 0;
+    // does this load block DOMContentLoaded
+    const isDomContentLoadedScript = domContentLoadedCnt > 0;
+    const isLoadScript = loadCnt > 0;
+    if (isLoadScript) loadCnt++;
+    if (isBlockingReadyScript) readyStateCompleteCnt++;
+    if (isDomContentLoadedScript) domContentLoadedCnt++;
+    let loadPromise;
+    const ts = script.lang === 'ts';
+    if (ts && !script.src) {
+      loadPromise = Promise.resolve(esmsTsTransform || initTs())
         .then(() => {
-          const transformed = esmsTsTransform(source, baseUrl);
+          const transformed = esmsTsTransform(script.innerHTML, baseUrl);
           if (transformed !== undefined) {
             onpolyfill();
             firstPolyfillLoad = false;
           }
           return topLevelLoad(
-            baseUrl,
+            script.src || baseUrl,
             getFetchOpts(script),
-            transformed === undefined ? source : transformed,
-            transformed === undefined,
-            undefined
+            transformed === undefined ? script.innerHTML : transformed,
+            !shimMode && transformed === undefined,
+            isBlockingReadyScript && lastStaticLoadPromise,
+            true
           );
         })
         .catch(throwError);
+    } else {
+      loadPromise = topLevelLoad(
+        script.src || baseUrl,
+        getFetchOpts(script),
+        !script.src ? script.innerHTML : undefined,
+        !shimMode,
+        isBlockingReadyScript && lastStaticLoadPromise,
+        ts
+      ).catch(throwError);
     }
-    // does this load block readystate complete
-    const isBlockingReadyScript = script.getAttribute('async') === null && readyStateCompleteCnt > 0;
-    // does this load block DOMContentLoaded
-    const isDomContentLoadedScript = domContentLoadedCnt > 0;
-    const isLoadScript = loadCnt > 0;
-    if (isLoadScript) loadCnt++;
-    if (isBlockingReadyScript) readyStateCompleteCnt++;
-    if (isDomContentLoadedScript) domContentLoadedCnt++;
-    const loadPromise = topLevelLoad(
-      script.src || baseUrl,
-      getFetchOpts(script),
-      !script.src && script.innerHTML,
-      !shimMode,
-      isBlockingReadyScript && lastStaticLoadPromise
-    ).catch(throwError);
     if (!noLoadEventRetriggers) loadPromise.then(() => script.dispatchEvent(new Event('load')));
-    if (isBlockingReadyScript) lastStaticLoadPromise = loadPromise.then(readyStateCompleteCheck);
+    if (isBlockingReadyScript && !ts) {
+      lastStaticLoadPromise = loadPromise.then(readyStateCompleteCheck);
+    }
     if (isDomContentLoadedScript) loadPromise.then(domContentLoadedCheck);
     if (isLoadScript) loadPromise.then(loadCheck);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-module-shims",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Shims for the latest ES module features",
   "main": "dist/es-module-shims.js",
   "exports": {