es-module-shims 2.6.0 → 2.6.2

package/README.md

@@ -14,6 +14,7 @@ The following modules features are polyfilled:
 * [Import defer](#import-defer) via syntax stripping to allow usage in modern browsers with a polyfill fallback, when enabled.
 * [TypeScript](#typescript-type-stripping) type stripping.
 * [Hot Reloading](#hot-reloading) with a Vite-style `import.meta.hot` API.
+* [Loader Hooks](#hooks) custom loader hooks for customizing module resolution and sources, including support for [virtual module sources](#source-hook).
 
 When running in shim mode, module rewriting is applied for all users and custom [resolve](#resolve-hook) and [fetch](#fetch-hook) hooks can be implemented allowing for custom resolution and streaming in-browser transform workflows.
 
@@ -30,7 +31,7 @@ Because we are still using the native module loader the edge cases work out comp
 Include ES Module Shims with a `async` attribute on the script, then include an import map and module scripts normally:
 
 ```html
-<script async src="https://ga.jspm.io/npm:es-module-shims@2.6.0/dist/es-module-shims.js"></script>
+<script async src="https://ga.jspm.io/npm:es-module-shims@2.6.2/dist/es-module-shims.js"></script>
 
 <!-- https://generator.jspm.io/#U2NhYGBkDM0rySzJSU1hKEpNTC5xMLTQM9Az0C1K1jMAAKFS5w0gAA -->
 <script type="importmap">
@@ -215,7 +216,7 @@ Shim mode is an alternative to polyfill mode and doesn't rely on native modules
 
 In shim mode, only the above `importmap-shim` and `module-shim` tags will be parsed and executed by ES Module Shims.
 
-Shim mode also provides some additional features that aren't yet natively supported such as supporting multiple import maps, [external import maps](#external-import-maps) with a `"src"` attribute, [dynamically injecting import maps](#dynamic-import-maps), and [reading current import map state](#reading-current-import-map-state), which can be useful in certain applications.
+Shim mode also provides some additional features that aren't yet natively supported such as [external import maps](#external-import-maps) with a `"src"` attribute and [reading current import map state](#reading-current-import-map-state), which can be useful in certain applications.
 
 ## Benchmarks
 
@@ -231,7 +232,7 @@ Benchmark summary:
 
 ### Browser Support
 
-Works in all browsers with [baseline ES module support](https://caniuse.com/#feat=es6-module).
+Works in all browsers with [ES module dynamic import support](https://caniuse.com/es6-module-dynamic-import).
 
 Browser Compatibility on baseline ES modules support **with** ES Module Shims:
 
@@ -252,8 +253,8 @@ Browser compatibility **without** ES Module Shims:
 | --------------------------------------------- | ------------------ | ------------------ | ------------------ |
 | [modulepreload](#modulepreload)               | 66+                | 115+               | 17.5+              |
 | [Import Maps](#import-maps)                   | 89+                | 108+               | 16.4+              |
-| [Import Map Integrity](#import-map-integrity) | 127+               | :x:                | :x:                |
-| [Multiple Import Maps](#multiple-import-maps) | 135+               | :x:                | :x:                |
+| [Import Map Integrity](#import-map-integrity) | 127+               | 138+               | 18+                |
+| [Multiple Import Maps](#multiple-import-maps) | 135+               | :x:                | 18.4+              |
 | [JSON Modules](#json-modules)                 | 123+               | :x:                | 17.2+              |
 | [CSS Modules](#css-modules)                   | 123+               | :x:                | :x:                |
 | [Wasm Modules](#wasm-modules)                 | Pending            | :x:                | :x:                |

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

@@ -1,169 +1,177 @@
-/** ES Module Shims @version 2.6.0 */
+/** ES Module Shims @version 2.6.2 */
 (function () {
 
-  let invalidate;
-  const hotReload$1 = url => invalidate(new URL(url, baseUrl).href);
-  const initHotReload = () => {
-    let _importHook = importHook,
-      _resolveHook = resolveHook,
-      _metaHook = metaHook;
-
-    let defaultResolve;
-    let hotResolveHook = (id, parent, _defaultResolve) => {
-      if (!defaultResolve) defaultResolve = _defaultResolve;
-      const originalParent = stripVersion(parent);
-      const url = stripVersion(defaultResolve(id, originalParent));
-      const hotState = getHotState(url);
-      const parents = hotState.p;
-      if (!parents.includes(originalParent)) parents.push(originalParent);
-      return toVersioned(url, hotState);
-    };
-    const hotImportHook = (url, _, __, source, sourceType) => {
-      const hotState = getHotState(url);
-      hotState.e = typeof source === 'string' ? source : true;
-      hotState.t = sourceType;
-    };
-    const hotMetaHook = (metaObj, url) => (metaObj.hot = new Hot(url));
-
-    const Hot = class Hot {
-      constructor(url) {
-        this.data = getHotState((this.url = stripVersion(url))).d;
-      }
-      accept(deps, cb) {
-        if (typeof deps === 'function') {
-          cb = deps;
-          deps = null;
-        }
-        const hotState = getHotState(this.url);
-        if (!hotState.A) return;
-        (hotState.a = hotState.a || []).push([
-          typeof deps === 'string' ? defaultResolve(deps, this.url)
-          : deps ? deps.map(d => defaultResolve(d, this.url))
-          : null,
-          cb
-        ]);
-      }
-      dispose(cb) {
-        getHotState(this.url).u = cb;
-      }
-      invalidate() {
-        const hotState = getHotState(this.url);
-        hotState.a = hotState.A = null;
-        const seen = [this.url];
-        hotState.p.forEach(p => invalidate(p, this.url, seen));
-      }
-    };
-
-    const versionedRegEx = /\?v=\d+$/;
-    const stripVersion = url => {
-      const versionMatch = url.match(versionedRegEx);
-      return versionMatch ? url.slice(0, -versionMatch[0].length) : url;
-    };
-
-    const toVersioned = (url, hotState) => {
-      const { v } = hotState;
-      return url + (v ? '?v=' + v : '');
-    };
-
-    let hotRegistry = {},
-      curInvalidationRoots = new Set(),
-      curInvalidationInterval;
-    const getHotState = url =>
-      hotRegistry[url] ||
-      (hotRegistry[url] = {
-        // version
-        v: 0,
-        // accept list ([deps, cb] pairs)
-        a: null,
-        // accepting acceptors
-        A: true,
-        // unload callback
-        u: null,
-        // entry point or inline script source
-        e: false,
-        // hot data
-        d: {},
-        // parents
-        p: [],
-        // source type
-        t: undefined
-      });
-
-    invalidate = (url, fromUrl, seen = []) => {
-      const hotState = hotRegistry[url];
-      if (!hotState || seen.includes(url)) return false;
-      seen.push(url);
-      console.info(`es-module-shims: hot reload ${url}`);
-      hotState.A = false;
-      if (
-        fromUrl &&
-        hotState.a &&
-        hotState.a.some(([d]) => d && (typeof d === 'string' ? d === fromUrl : d.includes(fromUrl)))
-      ) {
-        curInvalidationRoots.add(fromUrl);
-      } else {
-        if (hotState.e || hotState.a) curInvalidationRoots.add(url);
-        hotState.v++;
-        if (!hotState.a) hotState.p.forEach(p => invalidate(p, url, seen));
-      }
-      if (!curInvalidationInterval) curInvalidationInterval = setTimeout(handleInvalidations, hotReloadInterval);
-      return true;
-    };
-
-    const handleInvalidations = () => {
-      curInvalidationInterval = null;
-      const earlyRoots = new Set();
-      for (const root of curInvalidationRoots) {
-        const hotState = hotRegistry[root];
-        topLevelLoad(
-          toVersioned(root, hotState),
-          baseUrl,
-          defaultFetchOpts,
-          typeof hotState.e === 'string' ? hotState.e : undefined,
-          false,
-          undefined,
-          hotState.t
-        ).then(m => {
-          if (hotState.a) {
-            hotState.a.forEach(([d, c]) => d === null && !earlyRoots.has(c) && c(m));
-            // unload should be the latest unload handler from the just loaded module
-            if (hotState.u) {
-              hotState.u(hotState.d);
-              hotState.u = null;
-            }
-          }
-          hotState.p.forEach(p => {
-            const hotState = hotRegistry[p];
-            if (hotState && hotState.a)
-              hotState.a.forEach(
-                async ([d, c]) =>
-                  d &&
-                  !earlyRoots.has(c) &&
-                  (typeof d === 'string' ?
-                    d === root && c(m)
-                  : c(await Promise.all(d.map(d => (earlyRoots.push(c), importShim(toVersioned(d, getHotState(d))))))))
-              );
-          });
-        }, throwError);
-      }
-      curInvalidationRoots = new Set();
-    };
-
-    return [
-      _importHook ? chain(_importHook, hotImportHook) : hotImportHook,
-      _resolveHook ?
-        (id, parent, defaultResolve) =>
-          hotResolveHook(id, parent, (id, parent) => _resolveHook(id, parent, defaultResolve))
-      : hotResolveHook,
-      _metaHook ? chain(_metaHook, hotMetaHook) : hotMetaHook
-    ];
+  const self_ = typeof globalThis !== 'undefined' ? globalThis : self;
+
+  let invalidate;
+  const hotReload$1 = url => invalidate(new URL(url, baseUrl).href);
+  const initHotReload = (topLevelLoad, importShim) => {
+    let _importHook = importHook,
+      _resolveHook = resolveHook,
+      _metaHook = metaHook;
+
+    let defaultResolve;
+    let hotResolveHook = (id, parent, _defaultResolve) => {
+      if (!defaultResolve) defaultResolve = _defaultResolve;
+      const originalParent = stripVersion(parent);
+      const url = stripVersion(defaultResolve(id, originalParent));
+      const hotState = getHotState(url);
+      const parents = hotState.p;
+      if (!parents.includes(originalParent)) parents.push(originalParent);
+      return toVersioned(url, hotState);
+    };
+    const hotImportHook = (url, _, __, source, sourceType) => {
+      const hotState = getHotState(url);
+      hotState.e = typeof source === 'string' ? source : true;
+      hotState.t = sourceType;
+    };
+    const hotMetaHook = (metaObj, url) => (metaObj.hot = new Hot(url));
+
+    const Hot = class Hot {
+      constructor(url) {
+        this.data = getHotState((this.url = stripVersion(url))).d;
+      }
+      accept(deps, cb) {
+        if (typeof deps === 'function') {
+          cb = deps;
+          deps = null;
+        }
+        const hotState = getHotState(this.url);
+        if (!hotState.A) return;
+        (hotState.a = hotState.a || []).push([
+          typeof deps === 'string' ? defaultResolve(deps, this.url)
+          : deps ? deps.map(d => defaultResolve(d, this.url))
+          : null,
+          cb
+        ]);
+      }
+      dispose(cb) {
+        getHotState(this.url).u = cb;
+      }
+      invalidate() {
+        const hotState = getHotState(this.url);
+        hotState.a = hotState.A = null;
+        const seen = [this.url];
+        hotState.p.forEach(p => invalidate(p, this.url, seen));
+      }
+    };
+
+    const versionedRegEx = /\?v=\d+$/;
+    const stripVersion = url => {
+      const versionMatch = url.match(versionedRegEx);
+      return versionMatch ? url.slice(0, -versionMatch[0].length) : url;
+    };
+
+    const toVersioned = (url, hotState) => {
+      const { v } = hotState;
+      return url + (v ? '?v=' + v : '');
+    };
+
+    let hotRegistry = {},
+      curInvalidationRoots = new Set(),
+      curInvalidationInterval;
+    const getHotState = url =>
+      hotRegistry[url] ||
+      (hotRegistry[url] = {
+        // version
+        v: 0,
+        // accept list ([deps, cb] pairs)
+        a: null,
+        // accepting acceptors
+        A: true,
+        // unload callback
+        u: null,
+        // entry point or inline script source
+        e: false,
+        // hot data
+        d: {},
+        // parents
+        p: [],
+        // source type
+        t: undefined
+      });
+
+    invalidate = (url, fromUrl, seen = []) => {
+      const hotState = hotRegistry[url];
+      if (!hotState || seen.includes(url)) return false;
+      seen.push(url);
+      console.info(`es-module-shims: hot reload ${url}`);
+      hotState.A = false;
+      if (
+        fromUrl &&
+        hotState.a &&
+        hotState.a.some(([d]) => d && (typeof d === 'string' ? d === fromUrl : d.includes(fromUrl)))
+      ) {
+        curInvalidationRoots.add(fromUrl);
+      } else {
+        if (hotState.e || hotState.a) curInvalidationRoots.add(url);
+        hotState.v++;
+        if (!hotState.a) hotState.p.forEach(p => invalidate(p, url, seen));
+      }
+      if (!curInvalidationInterval) curInvalidationInterval = setTimeout(handleInvalidations, hotReloadInterval);
+      return true;
+    };
+
+    const handleInvalidations = () => {
+      curInvalidationInterval = null;
+      const earlyRoots = new Set();
+      for (const root of curInvalidationRoots) {
+        const hotState = hotRegistry[root];
+        topLevelLoad(
+          toVersioned(root, hotState),
+          baseUrl,
+          defaultFetchOpts,
+          typeof hotState.e === 'string' ? hotState.e : undefined,
+          false,
+          undefined,
+          hotState.t
+        ).then(m => {
+          if (hotState.a) {
+            hotState.a.forEach(([d, c]) => d === null && !earlyRoots.has(c) && c(m));
+            // unload should be the latest unload handler from the just loaded module
+            if (hotState.u) {
+              hotState.u(hotState.d);
+              hotState.u = null;
+            }
+          }
+          hotState.p.forEach(p => {
+            const hotState = hotRegistry[p];
+            if (hotState && hotState.a)
+              hotState.a.forEach(
+                async ([d, c]) =>
+                  d &&
+                  !earlyRoots.has(c) &&
+                  (typeof d === 'string' ?
+                    d === root && c(m)
+                  : c(await Promise.all(d.map(d => (earlyRoots.push(c), importShim(toVersioned(d, getHotState(d))))))))
+              );
+          });
+        }, throwError);
+      }
+      curInvalidationRoots = new Set();
+    };
+
+    setHooks(
+      _importHook ? chain(_importHook, hotImportHook) : hotImportHook,
+      _resolveHook ?
+        (id, parent, defaultResolve) =>
+          hotResolveHook(id, parent, (id, parent) => _resolveHook(id, parent, defaultResolve))
+      : hotResolveHook,
+      _metaHook ? chain(_metaHook, hotMetaHook) : hotMetaHook
+    );
   };
 
   const hasDocument = typeof document !== 'undefined';
 
   const noop = () => {};
 
-  const dynamicImport = (u, errUrl) => import(u);
+  const chain = (a, b) =>
+    function () {
+      a.apply(this, arguments);
+      b.apply(this, arguments);
+    };
+
+  const dynamicImport = (u, _errUrl) => import(u);
 
   const defineValue = (obj, prop, value) =>
     Object.defineProperty(obj, prop, { writable: false, configurable: false, value });
@@ -171,12 +179,12 @@
   const optionsScript = hasDocument ? document.querySelector('script[type=esms-options]') : undefined;
 
   const esmsInitOptions = optionsScript ? JSON.parse(optionsScript.innerHTML) : {};
-  Object.assign(esmsInitOptions, self.esmsInitOptions || {});
+  Object.assign(esmsInitOptions, self_.esmsInitOptions || {});
 
-  const version = "2.6.0";
+  const version = "2.6.2";
 
   const r$1 = esmsInitOptions.version;
-  if (self.importShim || (r$1 && r$1 !== version)) {
+  if (self_.importShim || (r$1 && r$1 !== version)) {
     console.info(
         `es-module-shims: skipping initialization as ${r$1 ? `configured for ${r$1}` : 'another instance has already registered'}`
       );
@@ -186,9 +194,11 @@
   // shim mode is determined on initialization, no late shim mode
   const shimMode =
     esmsInitOptions.shimMode ||
-    (hasDocument &&
+    (hasDocument ?
       document.querySelectorAll('script[type=module-shim],script[type=importmap-shim],link[rel=modulepreload-shim]')
-        .length > 0);
+        .length > 0
+      // Without a document, shim mode is always true as we cannot polyfill
+    : true);
 
   let importHook,
     resolveHook,
@@ -202,7 +212,7 @@
 
   const defaultFetchOpts = { credentials: 'same-origin' };
 
-  const globalHook = name => (typeof name === 'string' ? self[name] : name);
+  const globalHook = name => (typeof name === 'string' ? self_[name] : name);
 
   if (esmsInitOptions.onimport) importHook = globalHook(esmsInitOptions.onimport);
   if (esmsInitOptions.resolve) resolveHook = globalHook(esmsInitOptions.resolve);
@@ -220,7 +230,11 @@
     nativePassthrough = !hasCustomizationHooks && !hotReload
   } = esmsInitOptions;
 
-  if (hotReload) [importHook, resolveHook, metaHook] = initHotReload();
+  const setHooks = (importHook_, resolveHook_, metaHook_) => (
+    (importHook = importHook_),
+    (resolveHook = resolveHook_),
+    (metaHook = metaHook_)
+  );
 
   const mapOverrides = esmsInitOptions.mapOverrides;
 
@@ -252,13 +266,14 @@
       };
 
   const baseUrl =
-    hasDocument ?
-      document.baseURI
-    : `${location.protocol}//${location.host}${
+    hasDocument ? document.baseURI
+    : typeof location !== 'undefined' ?
+      `${location.protocol}//${location.host}${
       location.pathname.includes('/') ?
         location.pathname.slice(0, location.pathname.lastIndexOf('/') + 1)
       : location.pathname
-    }`;
+    }`
+    : 'about:blank';
 
   const createBlob = (source, type = 'text/javascript') => URL.createObjectURL(new Blob([source], { type }));
   let { skip } = esmsInitOptions;
@@ -272,10 +287,11 @@
     skip = s => skip.test(s);
   }
 
-  const dispatchError = error => self.dispatchEvent(Object.assign(new Event('error'), { error }));
+  const dispatchError = error => self_.dispatchEvent(Object.assign(new Event('error'), { error }));
 
   const throwError = err => {
-    (self.reportError || dispatchError)(err), void onerror(err);
+    (self_.reportError || dispatchError)(err);
+    onerror(err);
   };
 
   const fromParent = parent => (parent ? ` imported from ${parent}` : '');
@@ -629,7 +645,7 @@
   };
 
   // import()
-  async function importShim$1(id, opts, parentUrl) {
+  async function importShim(id, opts, parentUrl) {
     if (typeof opts === 'string') {
       parentUrl = opts;
       opts = undefined;
@@ -653,7 +669,7 @@
   // import.source()
   // (opts not currently supported as no use cases yet)
   if (shimMode || wasmSourcePhaseEnabled)
-    importShim$1.source = async (id, opts, parentUrl) => {
+    importShim.source = async (id, opts, parentUrl) => {
       if (typeof opts === 'string') {
         parentUrl = opts;
         opts = undefined;
@@ -667,18 +683,17 @@
       await importMapPromise;
       const url = resolve(id, parentUrl || baseUrl).r;
       const load = getOrCreateLoad(url, defaultFetchOpts, undefined, undefined);
-      if (firstPolyfillLoad && !shimMode && load.n && nativelyLoaded) {
-        onpolyfill();
-        firstPolyfillLoad = false;
-      }
       await load.f;
-      return importShim$1._s[load.r];
+      return importShim._s[load.r];
     };
 
   // import.defer() is just a proxy for import(), since we can't actually defer
-  if (shimMode || deferPhaseEnabled) importShim$1.defer = importShim$1;
+  if (shimMode || deferPhaseEnabled) importShim.defer = importShim;
 
-  if (hotReload) importShim$1.hotReload = hotReload$1;
+  if (hotReload) {
+    initHotReload(topLevelLoad, importShim);
+    importShim.hotReload = hotReload$1;
+  }
 
   const defaultResolve = (id, parentUrl) => {
     return (
@@ -695,24 +710,24 @@
     return resolve(id, `${parentUrl}`).r;
   };
 
-  importShim$1.resolve = (id, parentUrl) => resolve(id, parentUrl).r;
-  importShim$1.getImportMap = () => JSON.parse(JSON.stringify(composedImportMap));
-  importShim$1.addImportMap = importMapIn => {
+  importShim.resolve = (id, parentUrl) => resolve(id, parentUrl).r;
+  importShim.getImportMap = () => JSON.parse(JSON.stringify(composedImportMap));
+  importShim.addImportMap = importMapIn => {
     if (!shimMode) throw new Error('Unsupported in polyfill mode.');
     composedImportMap = resolveAndComposeImportMap(importMapIn, baseUrl, composedImportMap);
   };
-  importShim$1.version = version;
+  importShim.version = version;
 
-  const registry = (importShim$1._r = {});
+  const registry = (importShim._r = {});
   // Wasm caches
-  const sourceCache = (importShim$1._s = {});
-  (importShim$1._i = new WeakMap());
+  const sourceCache = (importShim._s = {});
+  /* const instanceCache = */ importShim._i = new WeakMap();
 
   // Ensure this version is the only version
-  defineValue(self, 'importShim', Object.freeze(importShim$1));
+  defineValue(self_, 'importShim', Object.freeze(importShim));
   const shimModeOptions = { ...esmsInitOptions, shimMode: true };
   if (optionsScript) optionsScript.innerHTML = JSON.stringify(shimModeOptions);
-  self.esmsInitOptions = shimModeOptions;
+  self_.esmsInitOptions = shimModeOptions;
 
   const loadAll = async (load, seen) => {
     seen[load.u] = 1;
@@ -815,7 +830,7 @@
   let firstPolyfillLoad = true;
   let legacyAcceptingImportMaps = true;
 
-  const topLevelLoad = async (
+  async function topLevelLoad(
     url,
     parentUrl,
     fetchOpts,
@@ -823,7 +838,7 @@
     nativelyLoaded,
     lastStaticLoadPromise,
     sourceType
-  ) => {
+  ) {
     await initPromise;
     await importMapPromise;
     url = (await resolve(url, parentUrl)).r;
@@ -873,11 +888,11 @@
     if (load.s) (await dynamicImport(load.s, load.u)).u$_(module);
     revokeObjectURLs(Object.keys(seen));
     return module;
-  };
+  }
 
   const revokeObjectURLs = registryKeys => {
     let curIdx = 0;
-    const handler = self.requestIdleCallback || self.requestAnimationFrame;
+    const handler = self_.requestIdleCallback || self_.requestAnimationFrame || (fn => setTimeout(fn, 0));
     handler(cleanup);
     function cleanup() {
       for (const key of registryKeys.slice(curIdx, (curIdx += 100))) {
@@ -944,7 +959,8 @@
 
     // once all deps have loaded we can inline the dependency resolution blobs
     // and define this blob
-    (resolvedSource = ''), (lastIndex = 0);
+    resolvedSource = '';
+    lastIndex = 0;
 
     for (const { s: start, e: end, ss: statementStart, se: statementEnd, d: dynamicImportIndex, t, a } of imports) {
       // source phase
@@ -1073,10 +1089,11 @@
 
   const doFetch = async (url, fetchOpts, parent) => {
     if (enforceIntegrity && !fetchOpts.integrity) throw Error(`No integrity for ${url}${fromParent(parent)}.`);
-    const poolQueue = pushFetchPool();
+    let res,
+      poolQueue = pushFetchPool();
     if (poolQueue) await poolQueue;
     try {
-      var res = await fetchHook(url, fetchOpts);
+      res = await fetchHook(url, fetchOpts);
     } catch (e) {
       e.message = `Unable to fetch ${url}${fromParent(parent)} - see network log for details.\n` + e.message;
       throw e;
@@ -1098,24 +1115,22 @@
     if (!esmsTsTransform) esmsTsTransform = m.transform;
   };
 
-  const contentTypeRegEx = /^(text|application)\/((x-)?javascript|wasm|json|css|typescript)(;|$)/;
   async function defaultSourceHook(url, fetchOpts, parent) {
-    const res = await doFetch(url, fetchOpts, parent);
-    let [, , t] = (res.headers.get('content-type') || '').match(contentTypeRegEx) || [];
-    if (!t) {
-      if (url.endsWith('.ts') || url.endsWith('.mts')) 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.`
-        );
+    let res = await doFetch(url, fetchOpts, parent),
+      contentType,
+      [, json, type, jsts] =
+        (contentType = res.headers.get('content-type') || '').match(
+          /^(?:[^/;]+\/(?:[^/+;]+\+)?(json)|(?:text|application)\/(?:x-)?((java|type)script|wasm|css))(?:;|$)/
+        ) || [];
+    if (!(type = json || (jsts ? jsts[0] + 's' : type || (/\.m?ts(\?|#|$)/.test(url) && 'ts')))) {
+      throw Error(
+        `Unsupported Content-Type "${contentType}" loading ${url}${fromParent(parent)}. Modules must be served with a valid MIME type like application/javascript.`
+      );
     }
     return {
       url: res.url,
-      source: t === 'wasm' ? await WebAssembly.compileStreaming(res) : await res.text(),
-      type:
-        t[0] === 'x' || (t[0] === 'j' && t[1] === 'a') ? 'js'
-        : t[0] === 't' ? 'ts'
-        : t
+      source: await (type > 'v' ? WebAssembly.compileStreaming(res) : res.text()),
+      type
     };
   }
 
@@ -1149,7 +1164,7 @@
       }
       source += `if(h)h.accept(m=>({${obj}}=m))`;
     } else if (type === 'json') {
-      source = `${hotPrefix}j=${source};export{j as default};if(h)h.accept(m=>j=m.default)`;
+      source = `${hotPrefix}j=JSON.parse(${JSON.stringify(source)});export{j as default};if(h)h.accept(m=>j=m.default)`;
     } else if (type === 'css') {
       source = `${hotPrefix}s=h&&h.data.s||new CSSStyleSheet();s.replaceSync(${JSON.stringify(
       source.replace(
@@ -1238,7 +1253,7 @@
 
   const linkLoad = (load, fetchOpts) => {
     if (load.L) return;
-    load.L = load.f.then(async () => {
+    load.L = load.f.then(() => {
       let childFetchOpts = fetchOpts;
       load.d = load.a[0]
         .map(({ n, d, t, a, se }) => {