SystemJS




SystemJS is a hookable, standards-based module loader. It provides a workflow where code written for production workflows of native ES modules in browsers (
like Rollup code-splitting builds), can be transpiled to the
System.register module format to work in older browsers that don't support native modules, running
almost-native module speeds while supporting top-level await, dynamic import, circular references and live bindings, import.meta.url, module types, import maps, integrity and Content Security Policy with compatibility in older browsers back to IE11.
Sponsors
>
Support SystemJS by becoming a sponsor. Your logo will show up here with a link to your website.
Backers
Thank you to all our backers! 🙏
[Become a backer]
$3
#### 1. s.js minimal production loader
The minimal
2.8KB s.js production loader includes the following features:
* Loads
System.register modules, the CSP-compatible
SystemJS module format.
* Support for loading bare specifier names with
import maps via
.
* Supports
hooks for loader customization.
#### 2. system.js loader
The
4.2KB system.js loader adds the following features in addition to the
s.js features above:
*
Tracing hooks and
registry deletion API for reloading workflows.
* Supports loading Wasm, CSS and JSON
module types.
* Includes the
global loading extra for loading global scripts, useful for loading library dependencies traditionally loaded with script tags.
#### 3. system-node.cjs loader
The
system-node.cjs loader is a version of SystemJS build designed to run in Node.js, typically for workflows where System modules need to be executed on the server like SSR. It has the following features:
* Loading System modules from disk (via
file:// urls) or the network, with included caching that respects the Content-Type header.
* Import Maps (via the
applyImportMap api).
*
Tracing hooks and
registry deletion API for reloading workflows.
* Loading global modules with the included
global loading extra.
_Loading CommonJS modules is not currently supported in this loader and likely won't be. If you find you need them it is more advisable to use
Node.js native module support where possible instead of the SystemJS Node.js loader._
#### Extras
The following
pluggable extras can be dropped in with either the s.js or system.js loader:
*
AMD loading support (through
Window.define which is created).
*
Named register supports
System.register('name', ...) named bundles which can then be imported as
System.import('name') (as well as AMD named define support)
*
Dynamic import maps support. This is currently a _potential_ new standard
feature.
The following extras are included in system.js loader by default, and can be added to the s.js loader for a smaller tailored footprint:
*
Global loading support for loading global scripts and detecting the defined global as the default export. Useful for loading common library scripts from CDN like
System.import('//unpkg.com/lodash').
*
Module Types .css,
.wasm,
.json module type loading support in line with the existing modules specifications.
Since all loader features are hookable, custom extensions can be easily made following the same approach as the bundled extras. See the
hooks documentation for more information.
SystemJS Babel
To support easy loading of TypeScript or ES modules in development SystemJS workflows, see the
SystemJS Babel Extension.
SystemJS does not support direct integration with the native ES module browser loader because there is no way to share dependencies between the module systems. For extending the functionality of the native module loader in browsers, see
ES module Shims, which like SystemJS, provides workflows for import maps and other modules features, but on top of base-level modules support in browsers, which it does using a fast Wasm-based source rewriting to remap module specifiers.
Performance
SystemJS is designed for production modules performance roughly only around a factor of 1.5 times the speed of native ES modules, as seen in the following performance benchmark, which was run by loading 426 javascript modules (all of
@babel/core) on a Macbook pro with fast wifi internet connection. Each test was the average of five page loads in Chrome 80.
| Tool | Uncached | Cached |
| ---- | -------- | ------ |
| Native modules | 1668ms | 49ms |
| SystemJS | 2334ms | 81ms |
Getting Started
Introduction video.
The
systemjs-examples repo contains a variety of examples demonstrating how to use SystemJS.
Installation
``
npm install systemjs
`
Documentation
* Import Maps
* API
* System.register
* Loader Hooks
* Module Types
Example Usage
$3
You can load System.register modules with a script element in your HTML:
`
html
`
$3
You can also dynamically load modules at any time with System.import()
:
`
js
System.import('/js/main.js');
`
where main.js
is a module available in the System.register module format.
$3
For an example of a bundling workflow, see the Rollup Code Splitting starter project - https://github.com/rollup/rollup-starter-code-splitting.
Note that when building System modules you typically want to ensure anonymous System.register statements like:
`
js
System.register([], function () { ... });
`
are emitted, as these can be loaded in a way that behaves the same as normal ES modules, and not named register statements like:
`
js
System.register('name', [], function () { ... });
`
While these can be supported with the named register extension, this approach is typically not recommended for modern modules workflows.
$3
Say main.js
depends on loading 'lodash'
, then we can define an import map:
`
html
`
$3
IE11 continues to be fully supported, provided the relevant polyfills are available.
The main required polyfill is a Promise
polyfill. If using import maps a fetch
polyfill is also needed.
Both of these can be loaded conditionally using for example using Bluebird Promises and the GitHub Fetch Polyfill over Unpkg:
`
html
`
located _before_ the SystemJS script itself. The above will ensure these polyfills are only fetched for older browsers without Promise
and fetch
support.
#### Note on Import Maps Support in IE11
When using external import maps (those with src=""
attributes), there is an IE11-specific workaround that might need to be used. Browsers should not make a network request when they see during parsing of the initial HTML page. However, IE11 does so. Codesandbox demonstration
Normally this is not an issue, as SystemJS will make an additional request via fetch/xhr for the import map. However, a problem can occur when the file is cached after the first request, since the first request caused by IE11 does not send the Origin request header by default. If the request requires CORS, the lack of an Origin request header causes many web servers (including AWS Cloudfront) to omit the response CORS headers. This can result in the resource being cached without CORS headers, which causes the later SystemJS fetch() to fail because of CORS checks.
This can be worked around by adding crossorigin="anonymous"
as an attribute to the