# ES Module Shims Shims modern ES Modules features like import maps on top of the baseline modules support in browsers supported by [95% of users](https://caniuse.com/#feat=es6-module). When running in polyfill mode, [the 67% of users](https://caniuse.com/import-maps) with import maps entirely bypass the shim code entirely. For the remaining 30% of users, the highly performant (see [benchmarks](#benchmarks)) production and [CSP-compatible](#csp-support) shim kicks in to rewrite module specifiers driven by the [Web Assembly ES Module Lexer](https://github.com/guybedford/es-module-lexer). The following modules features are polyfilled: * [Import Maps](#import-maps) support. * Dynamic `import()` shimming when necessary in eg older Firefox versions. * `import.meta` and `import.meta.url`. * [JSON](#json-modules) and [CSS modules](#css-modules) with import assertions (when enabled). * [`` polyfill](#modulepreload) in non Chromium browsers for both shimmed and unshimmed preloading scenarios. 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. Because we are still using the native module loader the edge cases work out comprehensively, including: * Live bindings in ES modules * Dynamic import expressions (`import('src/' + varname')`) * Circular references, with the execption that live bindings are disabled for the first unexecuted circular parent. ## Usage Include ES Module Shims with a `async` attribute on the script, then include an import map and module scripts normally: ```html ``` In browsers without import maps support, a console error will be given: ``` Uncaught TypeError: Failed to resolve module specifier "app". Relative references must start with either "/", "./", or "../". at :1:15 ``` This execution failure is a feature - it avoids the polyfill causing double execution. The first import being a bare specifier in the pattern above is important to ensure this. This is because the polyfill cannot disable the native loader - instead it will only execute modules that would otherwise fail resolving or parsing to avoid duplicate fetches or executions that would cause performance and reliability issues. ### Shim Mode Shim mode is an alternative to polyfill mode and doesn't rely on native modules erroring - instead it is triggered by the existence of any ` ``` All modules are still loaded with the native browser module loader, but with their specifiers rewritten then executed as Blob URLs, so there is a relatively minimal overhead to using a polyfill approach like this. #### Multiple Import Maps Multiple import maps are not currently supported in any native implementation, Chromium support is currently being tracked in https://bugs.chromium.org/p/chromium/issues/detail?id=927119. In polyfill mode, multiple import maps are therefore not supported. In shim mode, support for multiple `importmap-shim` scripts follows the [import map extensions](https://github.com/guybedford/import-maps-extensions) proposal. #### External Import Maps External import maps (using a `"src"` attribute) are not currently supported in any native implementation. In polyfill mode, external import maps are therefore not supported. In shim mode, external import maps are fully supported. #### Dynamic Import Maps Support for dynamically injecting import maps with JavaScript via eg: ```js document.body.appendChild(Object.assign(document.createElement('script'), { type: 'importmap', innerHTML: JSON.stringify({ imports: { x: './y.js' } }), })); ``` is supported in Chromium, provided it is injected before any module loads and there is no other import map yet loaded (multiple import maps are not supported). Both modes in ES Module Shims support dynamic injection using DOM Mutation Observers. While in polyfill mode the same restrictions apply that multiple import maps, import maps with a `src` attribute, and import maps loaded after the first module load are not supported, in shim mode all of these behaviours are fully enabled for `"importmap-shim"`. #### Reading current import map state To make it easy to keep track of import map state, es-module-shims provides a `importShim.getImportMap` utility function, available only in shim mode. ```js const importMap = importShim.getImportMap() // importMap will be an object in the same shape as the json in a importmap script ``` ### Dynamic Import > Stability: Stable browser standard Dynamic `import(...)` within any modules loaded will be rewritten as `importShim(...)` automatically providing full support for all es-module-shims features through dynamic import. To load code dynamically (say from the browser console), `importShim` can be called similarly: ```js importShim('/path/to/module.js').then(x => console.log(x)); ``` ### import.meta.url > Stability: Stable browser standard `import.meta.url` provides the full URL of the current module within the context of the module execution. ### modulepreload > Stability: WhatWG Standard, Single Browser Implementer Preloading of modules can be achieved by including a `` tag in the HTML or injecting it dynamically. This tag also supports the `"integrity"`, `"crossorigin"` and `"referrerpolicy"` attributes as supported on module scripts. This tag just initiates a fetch request in the browser and thus works equally as a preload polyfill in both shimmed and unshimmed modes, with integrity validation support. Unlike the browser specification, the modulepreload polyfill does not request dependency modules by default, in order to avoid unnecessary code analysis in the polyfill scenarios. **It is recommended to preload deep imports anyway so that this feature shouldn't be necessary.** #### Preload shim When in shim mode, `` must be used to properly cache the preloaded modules. ### CSP Support By default ES Module Shims provides full support for CSP by using the asm.js ES Module Lexer build. This is absolutely identical in performance to the Wasm version in Firefox and Chrome, while in Safari the asm.js version is actually faster than Wasm making this build preferable. The CSP nonce to use for module scripts will be picked up from the first script on the page or via the [`nonce` init option](#nonce). A full example of such a CSP workflow is provided below: ```html ``` #### Wasm Build To use the Web Assembly / non-CSP build of ES Module Shims, this is available as a self-contained single file at `es-module-shims/wasm` or `es-module-shims/dist/es-module-shims.wasm.js` in the package folder. ### JSON Modules > Stability: WhatWG Standard, Single Browser Implementer In shim mode, JSON modules are always supported. In polyfill mode, JSON modules require the `polyfillEnable: ['json-modules']` [init option](#polyfill-enable-option). JSON Modules are currently supported in Chrome when using them via an import assertion: ```html ``` In addition JSON modules need to be served with a valid JSON content type. Checks for assertion failures are not currently included. ### CSS Modules > Stability: WhatWG Standard, Single Browser Implementer In shim mode, CSS modules are always supported. In polyfill mode, CSS modules require the `polyfillEnable: ['css-modules']` [init option](#polyfill-enable-option). CSS Modules are currently supported in Chrome when using them via an import assertion: ```html ``` To support the polyfill or shim of this feature, the [Constructable Stylesheets polyfill](https://github.com/calebdwilliams/construct-style-sheets#readme) must be separately included in browsers not supporting [Constructable Stylesheets](https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/CSSStyleSheet) eg via: ```html ``` For more information see the [web.dev article](https://web.dev/css-module-scripts/). In addition CSS modules need to be served with a valid CSS content type. Checks for assertion failures are not currently included. ### Resolve > Stability: No current browser standard `import.meta.resolve` provides a contextual resolver within modules. It is asynchronous, like the Node.js implementation, to support waiting on any in-flight import map loads when import maps are [loaded dynamically](#dynamic-import-map-updates). The second argument to `import.meta.resolve` permits a custom parent URL scope for the resolution, which defaults to `import.meta.url`. ```js // resolve a relative path to a module var resolvedUrl = await import.meta.resolve('./relative.js'); // resolve a dependency from a module var resolvedUrl = await import.meta.resolve('dep'); // resolve a path var resolvedUrlPath = await import.meta.resolve('dep/'); // resolve with a custom parent scope var resolvedUrl = await import.meta.resolve('dep', 'https://site.com/another/scope'); ``` This implementation is as provided experimentally in Node.js - https://nodejs.org/dist/latest-v14.x/docs/api/esm.html#esm_no_require_resolve. ## Polyfill Mode Details In polyfill mode, feature detections are performed for ES modules features. In browsers with full feature support no further processing is done. In browsers with variable feature support, sources are analyzed with module specifiers rewritten using the very fast Wasm / asm.js lexer while sharing the source network fetch cache with the native loader. #### Polyfill Features The current default native baseline for the ES module shims polyfill mode is browsers supporting import maps. If using more modern features like CSS Modules or JSON Modules, these need to be manually enabled via the [`polyfillEnable` init option](#polyfill-enable-option) to raise the native baseline to only browsers supporting these features: ```html ``` To verify when the polyfill is actively engaging as opposed to relying on the native loader, [a `polyfill` hook](#polyfill-hook) is also provided. #### Polyfill Edge Case: Dynamic Import The guarantee of the polyfill is that any module graph that would have failed will be reexecuted through the shim layer. This leaves any edge case where execution succeeds but not as expected. For example when using dynamic imports: ```html ``` The native browser loader without import maps support will execute the above module fine, but fail on the lazy dynamic import. ES Module Shims will not reexecute the above in browsers without import maps support though because it will see that the execution did complete successfully therefore it will not attempt reexecution and as a result, `"Ok"` is never logged. Other examples include dynamically injecting import maps, or using import maps with a `"src"` attribute, which aren't supported in native Chrome. This is why it is advisable to always ensure modules use syntax that will fail early to avoid non-execution. #### Polyfill Edge Case: Instance Sharing When running in polyfill mode, it can be thought of that are effectively two loaders running on the page - the ES Module Shims polyfill loader, and the native loader. Note that instances are not shared between these loaders for consistency and performance. As a result, if you have two module graphs - one native and one polyfilled, they will not share the same dependency instance, for example: ```html ``` In the above, on browsers without import maps support, the `/dep.js` instance will be loaded natively by the first module, then the second import will fail. ES Module Shims will pick up on the second import and reexecute `/dep.js`. As a result, `/dep.js` will be executed twice on the page. For this reason it is important to always ensure all modules hit the polyfill path, either by having all graphs use import maps at the top-level, or via `importShim` directly. #### Skip Polyfill Adding the `"noshim"` attribute to the script tag will also ensure that ES Module Shims skips processing this script entirely: ```html ``` ## Init Options Provide a `esmsInitOptions` on the global scope before `es-module-shims` is loaded to configure various aspects of the module loading process: * [shimMode](#shim-mode-option) * [polyfillEnable](#polyfill-enable-option) * [enforceIntegrity](#enforce-integrity) * [nonce](#nonce) * [noLoadEventRetriggers](#no-load-event-retriggers) * [skip](#skip-processing) * [onerror](#error-hook) * [onpolyfill](#polyfill-hook) * [resolve](#resolve-hook) * [fetch](#fetch-hook) * [revokeBlobURLs](#revoke-blob-urls) * [mapOverrides](#overriding-import-map-entries) ```html ``` If only setting JSON-compatible options, the ` ``` This can be convenient when using a CSP policy. Function strings correspond to global function names. See below for a detailed description of each of these options. ### Shim Mode Option [Shim Mode](#shim-mode) can be overridden using the `shimMode` option: ```html ``` For example, if lazy loading ` ``` ### Enforce Integrity When enabled, `enforceIntegrity` will ensure that all modules loaded through ES Module Shims must have integrity defined either on a `` or on a `` preload tag in shim mode. Modules without integrity will throw at fetch time. For example in the following, only the listed `app.js` and `dep.js` modules will be able to execute with the provided integrity: ```html \ ``` Strong execution guarantees are only possible in shim mode since in polyfill mode it is not possible to stop the native loader from executing code without an integrity. Future versions of this option may provide support for origin-specific allow lists. ### Nonce The `nonce` option allows setting a CSP nonce to be used with all script injections for full CSP compatibility supported by the [CSP build](#csp-build) of ES Module Shims. Alternatively, add a `blob:` URL policy with the CSP build to get CSP compatibility. ```js ``` ### No Load Event Retriggers Because of the extra processing done by ES Module Shims it is possible for static module scripts to execute after the `DOMContentLoaded` or `readystatechange` events they expect, which can cause missed attachment. In order to ensure libraries that rely on these event still behave correctly, ES Module Shims will always double trigger these events that would normally have executed before the document ready state transition to completion, once all the static module scripts in the page have been completely executed through ES module shims. In such a case, this double event firing can be disabled with the `noLoadEventRetriggers` option: ```js ``` ### Skip Processing When loading modules that you know will only use baseline modules features, it is possible to set a rule to explicitly opt-out modules from rewriting. This improves performance because those modules then do not need to be processed or transformed at all, so that only local application code is handled and not library code. This can be configured by providing a URL regular expression for the `skip` option: ```js ``` #### Polyfill hook The polyfill hook is called when running in polyfill mode and the polyfill is kicking in instead of passing through to the native loader. This can be a useful way to verify that the native passthrough is working correctly in latest browsers for performance, while also allowing eg the ability to analyze or get metrics reports of how many users are getting the polyfill actively applying to their browser application loads. ```js ``` The default hook will log a message to the console with `console.info` noting that polyfill mode is enabled and that the native error can be ignored. In the above, running in latest Chromium browsers, nothing will be logged, while running in an older browser that does not support newer features like import maps the console log will be output. #### Error hook You can provide a function to handle errors during the module loading process by providing an `onerror` option: ```js ``` #### Resolve Hook The resolve hook is supported for shim mode only and allows full customization of the resolver, while still having access to the original resolve function. ```js ``` ### Fetch Hook The fetch hook is supported for shim mode only. The ES Module Shims fetch hook can be used to implement transform plugins. For example: ```js ``` Because the dependency analysis applies by ES Module Shims takes care of ensuring all dependencies run through the same fetch hook, the above is all that is needed to implement custom plugins. Streaming support is also provided, for example here is a hook with streaming support for JSON: ```js window.esmsInitOptions = { shimMode: true, fetch: async function (url, options) { const res = await fetch(url, options); if (!res.ok || !/^application\/json($|;)/.test(res.headers.get('content-type'))) return res; const reader = res.body.getReader(); const headers = new Headers(res.headers); headers.set('Content-Type', 'application/javascript'); return new Response(new ReadableStream({ async start (controller) { let done, value; controller.enqueue(new TextEncoder.encode('export default ')); while (({ done, value } = await reader.read()) && !done) { controller.enqueue(value); } controller.close(); } }), { headers }); } } ``` ### Revoke Blob URLs When polyfilling the missing features `es-module-shims` would create in-memory blobs using `URL.createObjectURL()` for each processed module. In most cases, memory footprint of these blobs is negligible so there is no need to call `URL.revokeObjectURL()` for them, and we don't do that by default. That said, in some scenarios, e.g. when evaluating some continuously changing modules without a page reload, like in a web-based code editor, you might want to reduce the growth of memory usage by revoking those blob URLs after they were already `import`ed. You can do that by enabling the `revokeBlobURLs` init option: ```js ``` NOTE: revoking object URLs is not entirely free, while we are trying to be smart about it and make sure it doesn't cause janks, we recommend enabling this option only if you have done the measurements and identified that you really need it. ### Overriding import map entries When [dynamically injecting import maps](#dynamic-import-maps), an error will be thrown in both polyfill and shim modes if the new import map would override existing entries with a different value. It is possible to disable this behavior in shim mode by setting the `mapOverrides` option: ```js ``` This can be useful for HMR workflows. ## Implementation Details ### Import Rewriting * Sources are fetched, import specifiers are rewritten to reference exact URLs, and then executed as BlobURLs through the whole module graph. * The [lexer](https://github.com/guybedford/es-module-lexer) handles the full language grammar including nested template strings, comments, regexes and division operator ambiguity based on backtracking. * When executing a circular reference A -> B -> A, a shell module technique is used to "shim" the circular reference into an acyclic graph. As a result, live bindings for the circular parent A are not supported, and instead the bindings are captured immediately after the execution of A. ## Inspiration Huge thanks to Rich Harris for inspiring this approach with [Shimport](https://github.com/rich-harris/shimport). ## License MIT