-
+Thank you to all the people who have already contributed to rollup!
### Backers
@@ -49,20 +154,10 @@ Thank you to all our backers! [[Become a backer](https://opencollective.com/roll
-
### Sponsors
Thank you to all our sponsors! (please ask your company to also support this open source project by [becoming a sponsor](https://opencollective.com/rollup#sponsor))
-
-
-
-
-
-
-
-
-
-
+
diff --git a/FUNDING.json b/FUNDING.json
new file mode 100644
index 00000000000..fcb4f353de3
--- /dev/null
+++ b/FUNDING.json
@@ -0,0 +1,7 @@
+{
+ "drips": {
+ "ethereum": {
+ "ownedBy": "0x3FF19163842E027ab536172B10123af20e3e4648"
+ }
+ }
+}
diff --git a/LICENSE-CORE.md b/LICENSE-CORE.md
index 355c03e926f..14852a2d22a 100644
--- a/LICENSE-CORE.md
+++ b/LICENSE-CORE.md
@@ -2,20 +2,8 @@ The MIT License (MIT)
Copyright (c) 2017 [these people](https://github.com/rollup/rollup/graphs/contributors)
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/LICENSE.md b/LICENSE.md
index 3a03706b1d2..7b806824370 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -5,91 +5,23 @@ The MIT License (MIT)
Copyright (c) 2017 [these people](https://github.com/rollup/rollup/graphs/contributors)
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
# Licenses of bundled dependencies
The published Rollup artifact additionally contains code with the following licenses:
-MIT, ISC
+MIT, ISC, 0BSD
# Bundled dependencies:
-## acorn
-License: MIT
-By: Marijn Haverbeke, Ingvar Stepanyan, Adrian Heine
-Repository: https://github.com/acornjs/acorn.git
-
-> MIT License
->
-> Copyright (C) 2012-2020 by various contributors (see AUTHORS)
->
-> Permission is hereby granted, free of charge, to any person obtaining a copy
-> of this software and associated documentation files (the "Software"), to deal
-> in the Software without restriction, including without limitation the rights
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-> copies of the Software, and to permit persons to whom the Software is
-> furnished to do so, subject to the following conditions:
->
-> The above copyright notice and this permission notice shall be included in
-> all copies or substantial portions of the Software.
->
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-> THE SOFTWARE.
-
----------------------------------------
-
-## acorn-class-fields
-License: MIT
-By: Adrian Heine
-Repository: https://github.com/acornjs/acorn-class-fields
-
-> Copyright (C) 2017-2018 by Adrian Heine
->
-> Permission is hereby granted, free of charge, to any person obtaining a copy
-> of this software and associated documentation files (the "Software"), to deal
-> in the Software without restriction, including without limitation the rights
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-> copies of the Software, and to permit persons to whom the Software is
-> furnished to do so, subject to the following conditions:
->
-> The above copyright notice and this permission notice shall be included in
-> all copies or substantial portions of the Software.
->
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-> THE SOFTWARE.
-
----------------------------------------
-
-## acorn-private-class-elements
+## @jridgewell/sourcemap-codec
License: MIT
-By: Adrian Heine
-Repository: https://github.com/acornjs/acorn-private-class-elements
+By: Justin Ridgewell
+Repository: git+https://github.com/jridgewell/sourcemaps.git
-> Copyright (C) 2017-2018 by Adrian Heine
+> Copyright 2024 Justin Ridgewell
+ 
+
+
+ 
+
@@ -11,7 +16,7 @@
- 
+
@@ -19,14 +24,12 @@
-
- 
-
Rollup
## Overview @@ -34,7 +37,7 @@ Rollup is a module bundler for JavaScript which compiles small pieces of code in ## Quick Start Guide -Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://rollupjs.org/#command-line-reference) with an optional configuration file, or else through its [JavaScript API](https://rollupjs.org/guide/en/#javascript-api). Run `rollup --help` to see the available options and parameters. The starter project templates, [rollup-starter-lib](https://github.com/rollup/rollup-starter-lib) and [rollup-starter-app](https://github.com/rollup/rollup-starter-app), demonstrate common configuration options, and more detailed instructions are available throughout the [user guide](https://rollupjs.org/). +Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://rollupjs.org/command-line-interface/) with an optional configuration file or else through its [JavaScript API](https://rollupjs.org/javascript-api/). Run `rollup --help` to see the available options and parameters. The starter project templates, [rollup-starter-lib](https://github.com/rollup/rollup-starter-lib) and [rollup-starter-app](https://github.com/rollup/rollup-starter-app), demonstrate common configuration options, and more detailed instructions are available throughout the [user guide](https://rollupjs.org/introduction/). ### Commands @@ -65,30 +68,31 @@ rollup main.js --format umd --name "myBundle" --file bundle.js Developing software is usually easier if you break your project into smaller separate pieces, since that often removes unexpected interactions and dramatically reduces the complexity of the problems you'll need to solve, and simply writing smaller projects in the first place [isn't necessarily the answer](https://medium.com/@Rich_Harris/small-modules-it-s-not-quite-that-simple-3ca532d65de4). Unfortunately, JavaScript has not historically included this capability as a core feature in the language. -This finally changed with ES modules support in JavaScript, which provides a syntax for importing and exporting functions and data so they can be shared between separate scripts. Most browsers and Node.js support ES modules. However, Node.js releases before 12.17 support ES modules only behind the `--experimental-modules` flag, and older browsers like Internet Explorer do not support ES modules at all. Rollup allows you to write your code using ES modules, and run your application even in environments that do not support ES modules natively. For environments that support them, Rollup can output optimized ES modules; for environments that don't, Rollup can compile your code to other formats such as CommonJS modules, AMD modules, and IIFE-style scripts. This means that you get to *write future-proof code*, and you also get the tremendous benefits of... +This finally changed with ES modules support in JavaScript, which provides a syntax for importing and exporting functions and data so they can be shared between separate scripts. Most browsers and Node.js support ES modules. However, Node.js releases before 12.17 support ES modules only behind the `--experimental-modules` flag, and older browsers like Internet Explorer do not support ES modules at all. Rollup allows you to write your code using ES modules, and run your application even in environments that do not support ES modules natively. For environments that support them, Rollup can output optimized ES modules; for environments that don't, Rollup can compile your code to other formats such as CommonJS modules, AMD modules, and IIFE-style scripts. This means that you get to _write future-proof code_, and you also get the tremendous benefits of... ## Tree Shaking In addition to enabling the use of ES modules, Rollup also statically analyzes and optimizes the code you are importing, and will exclude anything that isn't actually used. This allows you to build on top of existing tools and modules without adding extra dependencies or bloating the size of your project. -For example, with CommonJS, the *entire tool or library must be imported*. +For example, with CommonJS, the _entire tool or library must be imported_. ```js // import the entire utils object with CommonJS -var utils = require( 'utils' ); +var utils = require('node:utils'); var query = 'Rollup'; // use the ajax method of the utils object -utils.ajax( 'https://api.example.com?search=' + query ).then( handleResponse ); +utils.ajax('https://api.example.com?search=' + query).then(handleResponse); ``` But with ES modules, instead of importing the whole `utils` object, we can just import the one `ajax` function we need: ```js // import the ajax function with an ES import statement -import { ajax } from 'utils'; +import { ajax } from 'node:utils'; + var query = 'Rollup'; // call the ajax function -ajax( 'https://api.example.com?search=' + query ).then( handleResponse ); +ajax('https://api.example.com?search=' + query).then(handleResponse); ``` Because Rollup includes the bare minimum, it results in lighter, faster, and less complicated libraries and applications. Since this approach is based on explicit `import` and `export` statements, it is vastly more effective than simply running an automated minifier to detect unused variables in the compiled output code. @@ -105,9 +109,7 @@ To make sure your ES modules are immediately usable by tools that work with Comm ## Contributors -This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]. -
-
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]. . If you want to contribute yourself, head over to the [contribution guidelines](CONTRIBUTING.md).
## Backers
@@ -115,23 +117,17 @@ Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com
-
## Sponsors
Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/rollup#sponsor)]
-
-
-
-
-
-
-
-
-
-
+ 
+
+## Special Sponsor
+
+TNG has been supporting the work of [Lukas Taegert-Atkinson](https://github.com/lukastaegert) on Rollup since 2017.
## License
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000000..938d5598bb4
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,5 @@
+# Reporting a Vulnerability
+
+To report a vulnerability, please open a private vulnerability report at https://github.com/rollup/rollup/security.
+
+While the discovery of new vulnerabilities is rare, we also recommend always using the latest versions of Rollup and its official plugins to ensure your application remains as secure as possible.
diff --git a/audit-resolve.json b/audit-resolve.json
new file mode 100644
index 00000000000..da8434db1dd
--- /dev/null
+++ b/audit-resolve.json
@@ -0,0 +1,46 @@
+{
+ "decisions": {
+ "1112255|wasm-pack>binary-install>tar": {
+ "decision": "ignore",
+ "madeAt": 1768632226326,
+ "expiresAt": 1771224205911
+ },
+ "1112329|wasm-pack>binary-install>tar": {
+ "decision": "ignore",
+ "madeAt": 1768971958748,
+ "expiresAt": 1771563932286
+ },
+ "1112453|@chevrotain/cst-dts-gen>@chevrotain/gast>lodash-es": {
+ "decision": "ignore",
+ "madeAt": 1769058929105,
+ "expiresAt": 1771650881209
+ },
+ "1112453|@chevrotain/gast>lodash-es": {
+ "decision": "ignore",
+ "madeAt": 1769058929105,
+ "expiresAt": 1771650881209
+ },
+ "1112453|@mermaid-js/mermaid-cli>mermaid>@mermaid-js/parser>langium>chevrotain>@chevrotain/cst-dts-gen>@chevrotain/gast>lodash-es": {
+ "decision": "ignore",
+ "madeAt": 1769058929105,
+ "expiresAt": 1771650881209
+ },
+ "1112453|chevrotain-allstar>chevrotain>@chevrotain/cst-dts-gen>@chevrotain/gast>lodash-es": {
+ "decision": "ignore",
+ "madeAt": 1769058929105,
+ "expiresAt": 1771650881209
+ },
+ "1112455|lodash": {
+ "decision": "ignore",
+ "madeAt": 1769058974064,
+ "expiresAt": 1771650881209
+ },
+ "1112432|mocha>diff": {
+ "decision": "ignore",
+ "madeAt": 1769058983758,
+ "expiresAt": 1771650881209
+ }
+ },
+ "rules": {},
+ "version": 1
+}
diff --git a/browser/LICENSE.md b/browser/LICENSE.md
new file mode 100644
index 00000000000..82cd357f8fb
--- /dev/null
+++ b/browser/LICENSE.md
@@ -0,0 +1,163 @@
+# Rollup core license
+Rollup is released under the MIT license:
+
+The MIT License (MIT)
+
+Copyright (c) 2017 [these people](https://github.com/rollup/rollup/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Licenses of bundled dependencies
+The published Rollup artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled dependencies:
+## @jridgewell/sourcemap-codec
+License: MIT
+By: Justin Ridgewell
+Repository: git+https://github.com/jridgewell/sourcemaps.git
+
+> Copyright 2024 Justin Ridgewell
+
+
+```mermaid
+flowchart TB
+ classDef default fill:transparent, color:#000;
+ classDef hook-parallel fill:#ffb3b3,stroke:#000;
+ classDef hook-sequential fill:#ffd2b3,stroke:#000;
+ classDef hook-first fill:#fff2b3,stroke:#000;
+ classDef hook-sequential-sync fill:#ffd2b3,stroke:#f00;
+ classDef hook-first-sync fill:#fff2b3,stroke:#f00;
+
+ watchchange("watchChange"):::hook-parallel
+ click watchchange "#watchchange" _parent
+
+ closewatcher("closeWatcher"):::hook-parallel
+ click closewatcher "#closewatcher" _parent
+
+ buildend("buildEnd"):::hook-parallel
+ click buildend "#buildend" _parent
+
+ buildstart("buildStart"):::hook-parallel
+ click buildstart "#buildstart" _parent
+
+ load("load"):::hook-first
+ click load "#load" _parent
+
+ moduleparsed("moduleParsed"):::hook-parallel
+ click moduleparsed "#moduleparsed" _parent
+
+ options("options"):::hook-sequential
+ click options "#options" _parent
+
+ resolvedynamicimport("resolveDynamicImport"):::hook-first
+ click resolvedynamicimport "#resolvedynamicimport" _parent
+
+ resolveid("resolveId"):::hook-first
+ click resolveid "#resolveid" _parent
+
+ shouldtransformcachedmodule("shouldTransformCachedModule"):::hook-first
+ click shouldtransformcachedmodule "#shouldtransformcachedmodule" _parent
+
+ transform("transform"):::hook-sequential
+ click transform "#transform" _parent
+
+ options
+ --> buildstart
+ --> |each entry|resolveid
+ .-> |external|buildend
+
+ resolveid
+ --> |non-external|load
+ --> |not cached|transform
+ --> moduleparsed
+ .-> |no imports|buildend
+
+ load
+ --> |cached|shouldtransformcachedmodule
+ --> |false|moduleparsed
+
+ shouldtransformcachedmodule
+ --> |true|transform
+
+ moduleparsed
+ --> |"each import()"|resolvedynamicimport
+ --> |non-external|load
+
+ moduleparsed
+ --> |"each import\n(cached)"|load
+
+ moduleparsed
+ --> |"each import\n(not cached)"|resolveid
+
+ resolvedynamicimport
+ .-> |external|buildend
+
+ resolvedynamicimport
+ --> |unresolved|resolveid
+```
+
+Additionally, in watch mode the [`watchChange`](#watchchange) hook can be triggered at any time to notify a new run will be triggered once the current run has generated its outputs. Also, when watcher closes, the [`closeWatcher`](#closewatcher) hook will be triggered.
+
+See [Output Generation Hooks](#output-generation-hooks) for hooks that run during the output generation phase to modify the generated output.
+
+### buildEnd
+
+| | |
+| --: | :-- |
+| Type: | `(error?: Error) => void` |
+| Kind: | async, parallel |
+| Previous: | [`moduleParsed`](#moduleparsed), [`resolveId`](#resolveid) or [`resolveDynamicImport`](#resolvedynamicimport) |
+| Next: | [`outputOptions`](#outputoptions) in the output generation phase as this is the last hook of the build phase |
+
+Called when Rollup has finished bundling, but before `generate` or `write` is called; you can also return a Promise. If an error occurred during the build, it is passed on to this hook.
+
+### buildStart
+
+| | |
+| --: | :-- |
+| Type: | `(options: InputOptions) => void` |
+| Kind: | async, parallel |
+| Previous: | [`options`](#options) |
+| Next: | [`resolveId`](#resolveid) to resolve each entry point in parallel |
+
+Called on each `rollup.rollup` build. This is the recommended hook to use when you need access to the options passed to `rollup.rollup()` as it takes the transformations by all [`options`](#options) hooks into account and also contains the right default values for unset options.
+
+### closeWatcher
+
+| | |
+| --: | :-- |
+| Type: | `() => void` |
+| Kind: | async, parallel |
+| Previous/Next: | This hook can be triggered at any time both during the build and the output generation phases. If that is the case, the current build will still proceed but no new [`watchChange`](#watchchange) events will be triggered ever |
+
+Notifies a plugin when the watcher process will close so that all open resources can be closed too. If a Promise is returned, Rollup will wait for the Promise to resolve before closing the process. This hook cannot be used by output plugins.
+
+### load
+
+| | |
+| --: | :-- |
+| Type: | `(id: string) => LoadResult` |
+| Kind: | async, first |
+| Previous: | [`resolveId`](#resolveid) or [`resolveDynamicImport`](#resolvedynamicimport) where the loaded id was resolved. Additionally, this hook can be triggered at any time from plugin hooks by calling [`this.load`](#this-load) to preload the module corresponding to an id |
+| Next: | [`transform`](#transform) to transform the loaded file if no cache was used, or there was no cached copy with the same `code`, otherwise [`shouldTransformCachedModule`](#shouldtransformcachedmodule) |
+
+```typescript
+type LoadResult = string | null | SourceDescription;
+
+interface SourceDescription {
+ code: string;
+ map?: string | SourceMap;
+ ast?: ESTree.Program;
+ attributes?: { [key: string]: string } | null;
+ meta?: { [plugin: string]: any } | null;
+ moduleSideEffects?: boolean | 'no-treeshake' | null;
+ syntheticNamedExports?: boolean | string | null;
+}
+```
+
+Defines a custom loader. Returning `null` defers to other `load` functions (and eventually the default behavior of loading from the file system). To prevent additional parsing overhead in case e.g. this hook already used [`this.parse`](#this-parse) to generate an AST for some reason, this hook can optionally return a `{ code, ast, map }` object. The `ast` must be a standard ESTree AST with `start` and `end` properties for each node. If the transformation does not move code, you can preserve existing sourcemaps by setting `map` to `null`. Otherwise, you might need to generate the source map. See the section on [source code transformations](#source-code-transformations).
+
+If `false` is returned for `moduleSideEffects` and no other module imports anything from this module, then this module will not be included in the bundle even if the module would have side effects. If `true` is returned, Rollup will use its default algorithm to include all statements in the module that have side effects (such as modifying a global or exported variable). If `"no-treeshake"` is returned, treeshaking will be turned off for this module and it will also be included in one of the generated chunks even if it is empty. If `null` is returned or the flag is omitted, then `moduleSideEffects` will be determined by the first `resolveId` hook that resolved this module, the [`treeshake.moduleSideEffects`](../configuration-options/index.md#treeshake-modulesideeffects) option, or eventually default to `true`. The `transform` hook can override this.
+
+`attributes` contain the import attributes that were used when this module was imported. At the moment, they do not influence rendering for bundled modules but rather serve documentation purposes. If `null` is returned or the flag is omitted, then `attributes` will be determined by the first `resolveId` hook that resolved this module, or the attributes present in the first import of this module. The `transform` hook can override this.
+
+See [synthetic named exports](#synthetic-named-exports) for the effect of the `syntheticNamedExports` option. If `null` is returned or the flag is omitted, then `syntheticNamedExports` will be determined by the first `resolveId` hook that resolved this module or eventually default to `false`. The `transform` hook can override this.
+
+See [custom module meta-data](#custom-module-meta-data) for how to use the `meta` option. If a `meta` object is returned by this hook, it will be merged shallowly with any `meta` object returned by the resolveId hook. If no hook returns a `meta` object it will default to an empty object. The `transform` hook can further add or replace properties of this object.
+
+You can use [`this.getModuleInfo`](#this-getmoduleinfo) to find out the previous values of `attributes`, `meta`, `moduleSideEffects` and `syntheticNamedExports` inside this hook.
+
+### moduleParsed
+
+| | |
+| --: | :-- |
+| Type: | `(moduleInfo: ModuleInfo) => void` |
+| Kind: | async, parallel |
+| Previous: | [`transform`](#transform) where the currently handled file was transformed |
+| Next: | [`resolveId`](#resolveid) and [`resolveDynamicImport`](#resolvedynamicimport) to resolve all discovered static and dynamic imports in parallel if present, otherwise [`buildEnd`](#buildend) |
+
+This hook is called each time a module has been fully parsed by Rollup. See [`this.getModuleInfo`](#this-getmoduleinfo) for what information is passed to this hook.
+
+In contrast to the [`transform`](#transform) hook, this hook is never cached and can be used to get information about both cached and other modules, including the final shape of the `meta` property, the `code` and the `ast`.
+
+This hook will wait until all imports are resolved so that the information in `moduleInfo.importedIds`, `moduleInfo.dynamicallyImportedIds`, `moduleInfo.importedIdResolutions`, and `moduleInfo.dynamicallyImportedIdResolutions` is complete and accurate. Note however that information about importing modules may be incomplete as additional importers could be discovered later. If you need this information, use the [`buildEnd`](#buildend) hook.
+
+### onLog
+
+| | |
+| -------------: | :----------------------------------------------------- |
+| Type: | `(level: LogLevel, log: RollupLog) => boolean \| null` |
+| Kind: | sync, sequential |
+| Previous/Next: | This hook can be triggered at any time. |
+
+See the [`onLog`](../configuration-options/index.md#onlog) option for the available `Loglevel` values and the `RollupLog` type.
+
+A function that receives and filters logs and warnings generated by Rollup and plugins before they are passed to the [`onLog`](../configuration-options/index.md#onlog) option or printed to the console.
+
+If `false` is returned from this hook, the log will be filtered. Otherwise, the log will be handed to the `onLog` hook of the next plugin, the `onLog` option, or printed to the console. Plugins can also change the log level of a log or turn a log into an error by passing the log to [`this.error`](#this-error), [`this.warn`](#this-warn), [`this.info`](#this-info) or [`this.debug`](#this-debug) and returning `false`. Note that unlike other plugin hooks that add e.g. the plugin name to the log, those functions will not add or change properties of the log. Additionally, logs generated by an `onLog` hook will not be passed back to the `onLog` hook of the same plugin. If another plugin generates a log in response to such a log in its own `onLog` hook, this log will not be passed to the original `onLog` hook, either.
+
+```js twoslash
+// ---cut-start---
+/** @returns {import('rollup').Plugin} */
+// ---cut-end---
+function plugin1() {
+ return {
+ name: 'plugin1',
+ buildStart() {
+ this.info({ message: 'Hey', pluginCode: 'SPECIAL_CODE' });
+ },
+ onLog(level, log) {
+ if (log.plugin === 'plugin1' && log.pluginCode === 'SPECIAL_CODE') {
+ // We turn logs into warnings based on their code. This warnings
+ // will not be passed back to the same plugin to avoid an
+ // infinite loop, but other plugins will still receive it.
+ this.warn(log);
+ return false;
+ }
+ }
+ };
+}
+
+// ---cut-start---
+/** @returns {import('rollup').Plugin} */
+// ---cut-end---
+function plugin2() {
+ return {
+ name: 'plugin2',
+ onLog(level, log) {
+ if (log.plugin === 'plugin1' && log.pluginCode === 'SPECIAL_CODE') {
+ // You can modify logs in this hooks as well
+ log.meta = 'processed by plugin 2';
+ // This turns the log back to "info". If this happens in
+ // response to the first plugin, it will not be passed back to
+ // either plugin to avoid an infinite loop. If both plugins are
+ // active, the log will be an info log if the second plugin is
+ // placed after the first one
+ this.info(log);
+ return false;
+ }
+ }
+ };
+}
+```
+
+Like the [`options`](#options) hook, this hook does not have access to most [plugin context](#plugin-context) utility functions as it may be run before Rollup is fully configured. The only supported properties are [`this.meta`](#this-meta) as well as [`this.error`](#this-error), [`this.warn`](#this-warn), [`this.info`](#this-info) and [`this.debug`](#this-debug) for logging and errors.
+
+### options
+
+| | |
+| --------: | :------------------------------------------------ |
+| Type: | `(options: InputOptions) => InputOptions \| null` |
+| Kind: | async, sequential |
+| Previous: | This is the first hook of the build phase |
+| Next: | [`buildStart`](#buildstart) |
+
+Replaces or manipulates the options object passed to `rollup.rollup`. Returning `null` does not replace anything. If you just need to read the options, it is recommended to use the [`buildStart`](#buildstart) hook as that hook has access to the options after the transformations from all `options` hooks have been taken into account.
+
+Like the [`onLog`](#onlog) hook, this hook does not have access to most [plugin context](#plugin-context) utility functions as it is run before Rollup is fully configured. The only supported properties are [`this.meta`](#this-meta) as well as [`this.error`](#this-error), [`this.warn`](#this-warn), [`this.info`](#this-info) and [`this.debug`](#this-debug) for logging and errors.
+
+### resolveDynamicImport
+
+| | |
+| --: | :-- |
+| Type: | `ResolveDynamicImportHook` |
+| Kind: | async, first |
+| Previous: | [`moduleParsed`](#moduleparsed) for the importing file |
+| Next: | [`load`](#load) if the hook resolved with an id that has not yet been loaded, [`resolveId`](#resolveid) if the dynamic import contains a string and was not resolved by the hook, otherwise [`buildEnd`](#buildend) |
+
+```typescript
+type ResolveDynamicImportHook = (
+ specifier: string | AstNode,
+ importer: string,
+ options: { attributes: Record
+ parallel
+
+
+ sequential
+
+
+ first
+
+
+ async
+
+
+ sync
+
+
+
+
+```mermaid
+flowchart TB
+ classDef default fill:transparent, color:#000;
+ classDef hook-parallel fill:#ffb3b3,stroke:#000;
+ classDef hook-sequential fill:#ffd2b3,stroke:#000;
+ classDef hook-first fill:#fff2b3,stroke:#000;
+ classDef hook-sequential-sync fill:#ffd2b3,stroke:#f00;
+ classDef hook-first-sync fill:#fff2b3,stroke:#f00;
+
+ augmentchunkhash("augmentChunkHash"):::hook-sequential-sync
+ click augmentchunkhash "#augmentchunkhash" _parent
+
+ banner("banner"):::hook-sequential
+ click banner "#banner" _parent
+
+ closebundle("closeBundle"):::hook-parallel
+ click closebundle "#closebundle" _parent
+
+ footer("footer"):::hook-sequential
+ click footer "#footer" _parent
+
+ generatebundle("generateBundle"):::hook-sequential
+ click generatebundle "#generatebundle" _parent
+
+ intro("intro"):::hook-sequential
+ click intro "#intro" _parent
+
+ outputoptions("outputOptions"):::hook-sequential-sync
+ click outputoptions "#outputoptions" _parent
+
+ outro("outro"):::hook-sequential
+ click outro "#outro" _parent
+
+ renderchunk("renderChunk"):::hook-sequential
+ click renderchunk "#renderchunk" _parent
+
+ renderdynamicimport("renderDynamicImport"):::hook-first-sync
+ click renderdynamicimport "#renderdynamicimport" _parent
+
+ rendererror("renderError"):::hook-parallel
+ click rendererror "#rendererror" _parent
+
+ renderstart("renderStart"):::hook-parallel
+ click renderstart "#renderstart" _parent
+
+ resolvefileurl("resolveFileUrl"):::hook-first-sync
+ click resolvefileurl "#resolvefileurl" _parent
+
+ resolveimportmeta("resolveImportMeta"):::hook-first-sync
+ click resolveimportmeta "#resolveimportmeta" _parent
+
+ writebundle("writeBundle"):::hook-parallel
+ click writebundle "#writebundle" _parent
+
+
+ outputoptions
+ --> renderstart
+ --> |each chunk|beforerenderdynamicimport
+
+ afteraddons
+ --> |each chunk|renderchunk
+
+ augmentchunkhash
+ --> generatebundle
+ --> writebundle
+ .-> closebundle
+
+ subgraph generateChunks [" "]
+ direction TB
+ beforerenderdynamicimport(( ))
+ ---> beforeresolveimportmeta(( ))
+ ----> beforereaddons(( ))
+ --> banner & footer & intro & outro
+ --> afteraddons(( ))
+ .-> |next chunk|beforerenderdynamicimport
+
+ beforerenderdynamicimport
+ --> |"each import()"|renderdynamicimport
+ --> beforerenderdynamicimport
+
+ beforeresolveimportmeta
+ --> |each import.meta.*|beforeimportmeta(( ))
+ --> |import.meta.url|resolvefileurl
+ --> afterresolveimportmeta(( ))
+
+ beforeimportmeta
+ --> |other|resolveimportmeta
+ --> afterresolveimportmeta
+
+ afterresolveimportmeta
+ --> beforeresolveimportmeta
+ end
+
+ renderchunk
+ --> augmentchunkhash
+ .-> |next chunk|renderchunk
+
+ style generateChunks stroke-width:0px;
+
+ rendererror
+ .-> closebundle
+```
+
+Additionally, [`closeBundle`](#closebundle) can be called as the very last hook, but it is the responsibility of the User to manually call [`bundle.close()`](../javascript-api/index.md#rollup-rollup) to trigger this. The CLI will always make sure this is the case.
+
+### augmentChunkHash
+
+| | |
+| --: | :-- |
+| Type: | `(chunkInfo: RenderedChunk) => string` |
+| Kind: | sync, sequential |
+| Previous: | [`renderChunk`](#renderchunk) |
+| Next: | [`renderChunk`](#renderchunk) if there are other chunks that still need to be processed, otherwise [`generateBundle`](#generatebundle) |
+
+See the [`renderChunk`](../plugin-development/index.md#renderchunk) hook for the `RenderedChunk` type.
+
+Can be used to augment the hash of individual chunks. Called for each Rollup output chunk. Returning a falsy value will not modify the hash. Truthy values will be passed to [`hash.update`](https://nodejs.org/dist/latest-v12.x/docs/api/crypto.html#crypto_hash_update_data_inputencoding). The `RenderedChunk` type is a reduced version of the `OutputChunk` type in [`generateBundle`](#generatebundle) without `code` and `map` and using placeholders for hashes in file names.
+
+The following plugin will invalidate the hash of chunk `foo` with the current timestamp:
+
+```js twoslash
+// ---cut-start---
+/** @returns {import('rollup').Plugin} */
+// ---cut-end---
+function augmentWithDatePlugin() {
+ return {
+ name: 'augment-with-date',
+ augmentChunkHash(chunkInfo) {
+ if (chunkInfo.name === 'foo') {
+ return Date.now().toString();
+ }
+ }
+ };
+}
+```
+
+### banner
+
+| | |
+| --: | :-- |
+| Type: | `string \| ((chunk: RenderedChunk) => string)` |
+| Kind: | async, sequential |
+| Previous: | [`resolveFileUrl`](#resolvefileurl) for each use of `import.meta.ROLLUP_FILE_URL_referenceId` and [`resolveImportMeta`](#resolveimportmeta) for all other accesses to `import.meta` in the current chunk |
+| Next: | [`renderDynamicImport`](#renderdynamicimport) for each dynamic import expression in the next chunk if there is another one, otherwise [`renderChunk`](#renderchunk) for the first chunk |
+
+Cf. [`output.banner/output.footer`](../configuration-options/index.md#output-banner-output-footer).
+
+### closeBundle
+
+| | |
+| --: | :-- |
+| Type: | `closeBundle: (error?: Error) => Promise
+ parallel
+
+
+ sequential
+
+
+ first
+
+
+ async
+
+
+ sync
+
+color: ${color}, size: ${size}
`; + +// worklet.js +import { color, size } from './config.js'; +registerPaint( + 'vertical-lines', + class { + paint(ctx, geom) { + for (let x = 0; x < geom.width / size; x++) { + ctx.beginPath(); + ctx.fillStyle = color; + ctx.rect(x * size, 0, 2, geom.height); + ctx.fill(); + } + } + } +); + +// config.js +export const color = 'greenyellow'; +export const size = 6; +``` + +If you build this code, both the main chunk and the worklet will share the code from `config.js` via a shared chunk. This enables us to make use of the browser cache to reduce transmitted data and speed up loading the worklet. + +You can also use `import.meta.ROLLUP_FILE_URL_OBJ_referenceId` to get a URL object directly instead of a string. This is more efficient when you need the URL object itself, as it avoids creating the object twice: + +```js +// Using ROLLUP_FILE_URL (returns string, requires wrapping in new URL()) +const urlString = import.meta.ROLLUP_FILE_URL_referenceId; +const urlObject = new URL(urlString); + +// Using ROLLUP_FILE_URL_OBJ (returns URL object directly) +const urlObject = import.meta.ROLLUP_FILE_URL_OBJ_referenceId; +``` + +## Transformers + +Transformer plugins (i.e. those that return a `transform` function for e.g. transpiling non-JS files) should support `options.include` and `options.exclude`, both of which can be a minimatch pattern or an array of minimatch patterns. If `options.include` is omitted or of zero length, files should be included by default; otherwise they should only be included if the ID matches one of the patterns. + +The `transform` hook, if returning an object, can also include an `ast` property. Only use this feature if you know what you're doing. Note that only the last AST in a chain of transforms will be used (and if there are transforms, any ASTs generated by the `load` hook will be discarded for the transformed modules.) + +### Example Transformer + +(Use [@rollup/pluginutils](https://github.com/rollup/plugins/tree/master/packages/pluginutils) for commonly needed functions, and to implement a transformer in the recommended manner.) + +```js twoslash +import { createFilter } from '@rollup/pluginutils'; + +// ---cut-start--- +/** @returns {import('rollup').Plugin} */ +// ---cut-end--- +function transformCodePlugin(options = {}) { + const filter = createFilter(options.include, options.exclude); + + return { + name: 'transform-code', + transform(code, id) { + if (!filter(id)) return; + + // proceed with the transformation... + return { + code: generatedCode, + map: generatedSourceMap + }; + } + }; +} +``` + +### Source Code Transformations + +If a plugin transforms source code, it should generate a sourcemap automatically, unless there's a specific `sourceMap: false` option. Rollup only cares about the `mappings` property (everything else is handled automatically). [magic-string](https://github.com/Rich-Harris/magic-string) provides a simple way to generate such a map for elementary transformations like adding or removing code snippets. + +If it doesn't make sense to generate a sourcemap, (e.g. [rollup-plugin-string](https://github.com/TrySound/rollup-plugin-string)), return an empty sourcemap: + +```js +return { + code: transformedCode, + map: { mappings: '' } +}; +``` + +If the transformation does not move code, you can preserve existing sourcemaps by returning `null`: + +```js +return { + code: transformedCode, + map: null +}; +``` + +If you create a plugin that you think would be useful to others, please publish it to NPM and add submit it to [github.com/rollup/awesome](https://github.com/rollup/awesome)! + +## Synthetic named exports + +It is possible to designate a fallback export for missing exports by setting the `syntheticNamedExports` option for a module in the [`resolveId`](#resolveid), [`load`](#load) or [`transform`](#transform) hook. If a string value is used for `syntheticNamedExports`, this module will fallback the resolution of any missing named exports to properties of the named export of the given name: + +**dep.js: (`{syntheticNamedExports: '__synthetic'}`)** + +```js +export const foo = 'explicit'; +export const __synthetic = { + foo: 'foo', + bar: 'bar' +}; +``` + +**main.js:** + +```js +import { foo, bar, baz, __synthetic } from './dep.js'; + +// logs "explicit" as non-synthetic exports take precedence +console.log(foo); + +// logs "bar", picking the property from __synthetic +console.log(bar); + +// logs "undefined" +console.log(baz); + +// logs "{foo:'foo',bar:'bar'}" +console.log(__synthetic); +``` + +When used as an entry point, only explicit exports will be exposed. The synthetic fallback export, i.e. `__synthetic` in the example, will not be exposed for string values of `syntheticNamedExports`. However, if the value is `true`, the default export will be exposed. This is the only notable difference between `syntheticNamedExports: true` and `syntheticNamedExports: 'default'`. + +## Inter-plugin communication + +At some point when using many dedicated plugins, there may be the need for unrelated plugins to be able to exchange information during the build. There are several mechanisms through which Rollup makes this possible. + +### Custom resolver options + +Assume you have a plugin that should resolve an import to different ids depending on how the import was generated by another plugin. One way to achieve this would be to rewrite the import to use special proxy ids, e.g. a transpiled import via `require("foo")` in a CommonJS file could become a regular import with a special id `import "foo?require=true"` so that a resolver plugin knows this. + +The problem here, however, is that this proxy id may or may not cause unintended side effects when passed to other resolvers because it does not really correspond to a file. Moreover, if the id is created by plugin `A` and the resolution happens in plugin `B`, it creates a dependency between these plugins so that `A` is not usable without `B`. + +Custom resolver option offer a solution here by allowing to pass additional options for plugins when manually resolving a module via `this resolve`. This happens without changing the id and thus without impairing the ability for other plugins to resolve the module correctly if the intended target plugin is not present. + +```js twoslash +// ---cut-start--- +/** @returns {import('rollup').Plugin} */ +// ---cut-end--- +function requestingPlugin() { + return { + name: 'requesting', + async buildStart() { + const resolution = await this.resolve('foo', undefined, { + custom: { resolving: { specialResolution: true } } + }); + console.log(resolution.id); // "special" + } + }; +} + +// ---cut-start--- +/** @returns {import('rollup').Plugin} */ +// ---cut-end--- +function resolvingPlugin() { + return { + name: 'resolving', + resolveId(id, importer, { custom }) { + if (custom.resolving?.specialResolution) { + return 'special'; + } + return null; + } + }; +} +``` + +Note the convention that custom options should be added using a property corresponding to the plugin name of the resolving plugin. It is responsibility of the resolving plugin to specify which options it respects. + +### Custom module meta-data + +Plugins can annotate modules with custom meta-data which can be set by themselves and other plugins via the [`resolveId`](#resolveid), [`load`](#load), and [`transform`](#transform) hooks and accessed via [`this.getModuleInfo`](#this-getmoduleinfo), [`this.load`](#this-load) and the [`moduleParsed`](#moduleparsed) hook. This meta-data should always be JSON.stringifyable and will be persisted in the cache e.g. in watch mode. + +```js twoslash +// ---cut-start--- +/** @returns {import('rollup').Plugin} */ +// ---cut-end--- +function annotatingPlugin() { + return { + name: 'annotating', + transform(code, id) { + if (thisModuleIsSpecial(code, id)) { + return { meta: { annotating: { special: true } } }; + } + } + }; +} + +// ---cut-start--- +/** @returns {import('rollup').Plugin} */ +// ---cut-end--- +function readingPlugin() { + let parentApi; + return { + name: 'reading', + buildEnd() { + const specialModules = Array.from(this.getModuleIds()).filter( + id => this.getModuleInfo(id).meta.annotating?.special + ); + // do something with this list + } + }; +} +``` + +Note the convention that plugins that add or modify data should use a property corresponding to the plugin name, in this case `annotating`. On the other hand, any plugin can read all meta-data from other plugins via `this.getModuleInfo`. + +If several plugins add meta-data or meta-data is added in different hooks, then these `meta` objects will be merged shallowly. That means if plugin `first` adds `{meta: {first: {resolved: "first"}}}` in the resolveId hook and `{meta: {first: {loaded: "first"}}}` in the load hook while plugin `second` adds `{meta: {second: {transformed: "second"}}}` in the `transform` hook, then the resulting `meta` object will be `{first: {loaded: "first"}, second: {transformed: "second"}}`. Here the result of the `resolveId` hook will be overwritten by the result of the `load` hook as the plugin was both storing them under its `first` top-level property. The `transform` data of the other plugin on the other hand will be placed next to it. + +The `meta` object of a module is created as soon as Rollup starts loading a module and is updated for each lifecycle hook of the module. If you store a reference to this object, you can also update it manually. To access the meta object of a module that has not been loaded yet, you can trigger its creation and loading the module via [`this.load`](#this-load): + +```js twoslash +// ---cut-start--- +/** @returns {import('rollup').Plugin} */ +// ---cut-end--- +function plugin() { + return { + name: 'test', + buildStart() { + // trigger loading a module. We could also pass an initial + // "meta" object here, but it would be ignored if the module + // was already loaded via other means + this.load({ id: 'my-id' }); + // the module info is now available, we do not need to await + // this.load + const meta = this.getModuleInfo('my-id').meta; + // we can also modify meta manually now + meta.test = { some: 'data' }; + } + }; +} +``` + +### Direct plugin communication + +For any other kind of inter-plugin communication, we recommend the pattern below. Note that `api` will never conflict with any upcoming plugin hooks. + + +```js twoslash +/** @typedef {{ doSomething(...args: any[]): void }} ParentPluginApi */ + +/** @returns {import('rollup').Plugin
+
+
+ Loading Rollup...
+
+
+
+
+
+
+
diff --git a/docs/repl/components/ReplEditor.vue b/docs/repl/components/ReplEditor.vue
new file mode 100644
index 00000000000..ed06515569d
--- /dev/null
+++ b/docs/repl/components/ReplEditor.vue
@@ -0,0 +1,88 @@
+
+
+
+
+
+
+
diff --git a/docs/repl/components/ReplInput.vue b/docs/repl/components/ReplInput.vue
new file mode 100644
index 00000000000..9d8a0f1071e
--- /dev/null
+++ b/docs/repl/components/ReplInput.vue
@@ -0,0 +1,75 @@
+
+ -
+
-
+
+
+
-
+
-
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/repl/components/ReplMain.vue b/docs/repl/components/ReplMain.vue
new file mode 100644
index 00000000000..9320d2fdbac
--- /dev/null
+++ b/docs/repl/components/ReplMain.vue
@@ -0,0 +1,181 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/repl/components/ReplModule.vue b/docs/repl/components/ReplModule.vue
new file mode 100644
index 00000000000..c39d9d6d63c
--- /dev/null
+++ b/docs/repl/components/ReplModule.vue
@@ -0,0 +1,204 @@
+
+
+
+
+ ES6 modules go in...
+
+
+
+
+ + ... + {{ rollupOutputStore.output.output.length > 1 ? 'chunks come' : 'bundle comes' }} + out +
+
+
+
+
+
+
+
diff --git a/docs/repl/components/RollupVersion.vue b/docs/repl/components/RollupVersion.vue
new file mode 100644
index 00000000000..4aae784072d
--- /dev/null
+++ b/docs/repl/components/RollupVersion.vue
@@ -0,0 +1,51 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/repl/components/SelectOption.vue b/docs/repl/components/SelectOption.vue
new file mode 100644
index 00000000000..6ba47665c2d
--- /dev/null
+++ b/docs/repl/components/SelectOption.vue
@@ -0,0 +1,47 @@
+
+
+
+
+
+
+
+
+
diff --git a/docs/repl/components/StatusMessage.vue b/docs/repl/components/StatusMessage.vue
new file mode 100644
index 00000000000..615eb0481ad
--- /dev/null
+++ b/docs/repl/components/StatusMessage.vue
@@ -0,0 +1,67 @@
+
+
+ {{ frame }}Hello world!
'); diff --git a/docs/repl/examples/06/example.json b/docs/repl/examples/06/example.json new file mode 100644 index 00000000000..0ee4fdecdc9 --- /dev/null +++ b/docs/repl/examples/06/example.json @@ -0,0 +1,8 @@ +{ + "title": "Dynamic imports", + "options": { + "output": { + "inlineDynamicImports": false + } + } +} diff --git a/docs/repl/examples/06/modules/main.js b/docs/repl/examples/06/modules/main.js new file mode 100644 index 00000000000..4b203614fa4 --- /dev/null +++ b/docs/repl/examples/06/modules/main.js @@ -0,0 +1,14 @@ +// DYNAMIC IMPORTS +// Rollup supports automatic chunking and lazy-loading +// via dynamic imports utilizing the import mechanism +// of the host system. +import square from './square.js'; + +// Directly use some math +console.log(square(2)); + +// Dynamically import the rest +import('./maths.js').then(maths => { + console.log(maths.square(5)); + console.log(maths.cube(5)); +}); diff --git a/docs/repl/examples/06/modules/maths.js b/docs/repl/examples/06/modules/maths.js new file mode 100644 index 00000000000..f2197ae0d34 --- /dev/null +++ b/docs/repl/examples/06/modules/maths.js @@ -0,0 +1,5 @@ +import square from './square.js'; + +export { default as square } from './square.js'; + +export const cube = x => square(x) * x; diff --git a/docs/repl/examples/06/modules/square.js b/docs/repl/examples/06/modules/square.js new file mode 100644 index 00000000000..8818ad256d3 --- /dev/null +++ b/docs/repl/examples/06/modules/square.js @@ -0,0 +1,3 @@ +// Modules shared between the entry chunk and the +// dynamic chunk are merged into the entry chunk. +export default x => x * x; diff --git a/docs/repl/examples/07/example.json b/docs/repl/examples/07/example.json new file mode 100644 index 00000000000..2e559572a75 --- /dev/null +++ b/docs/repl/examples/07/example.json @@ -0,0 +1,10 @@ +{ + "title": "Multiple Entry Modules", + "entryModules": ["main.js", "otherEntry.js"], + "options": { + "output": { + "minifyInternalExports": false, + "preserveModules": false + } + } +} diff --git a/docs/repl/examples/07/modules/cube.js b/docs/repl/examples/07/modules/cube.js new file mode 100644 index 00000000000..fab93feba86 --- /dev/null +++ b/docs/repl/examples/07/modules/cube.js @@ -0,0 +1,8 @@ +import square from './square.js'; + +// Everything used by both entry modules will become +// a separate chunk that is imported by both entry +// chunks to avoid code duplication +export default function cube(x) { + return square(x) * x; +} diff --git a/docs/repl/examples/07/modules/hyperCube.js b/docs/repl/examples/07/modules/hyperCube.js new file mode 100644 index 00000000000..6b1f4ce7a18 --- /dev/null +++ b/docs/repl/examples/07/modules/hyperCube.js @@ -0,0 +1,7 @@ +import cube from './cube.js'; + +// This is only imported by one entry module and +// shares a chunk with that module +export default function hyperCube(x) { + return cube(x) * x; +} diff --git a/docs/repl/examples/07/modules/main.js b/docs/repl/examples/07/modules/main.js new file mode 100644 index 00000000000..3bb2bad9628 --- /dev/null +++ b/docs/repl/examples/07/modules/main.js @@ -0,0 +1,4 @@ +// MULTIPLE ENTRY MODULES +import hyperCube from './hyperCube.js'; + +console.log(hyperCube(5)); diff --git a/docs/repl/examples/07/modules/otherEntry.js b/docs/repl/examples/07/modules/otherEntry.js new file mode 100644 index 00000000000..e89a0a7c494 --- /dev/null +++ b/docs/repl/examples/07/modules/otherEntry.js @@ -0,0 +1,4 @@ +// Additional entry modules create new chunks +import cube from './cube.js'; + +console.log(cube(5)); diff --git a/docs/repl/examples/07/modules/square.js b/docs/repl/examples/07/modules/square.js new file mode 100644 index 00000000000..2f879d490ba --- /dev/null +++ b/docs/repl/examples/07/modules/square.js @@ -0,0 +1,4 @@ +// This is also shared between the entry chunks +export default function square(x) { + return x * x; +} diff --git a/docs/repl/examples/08/example.json b/docs/repl/examples/08/example.json new file mode 100644 index 00000000000..f085d76c5cd --- /dev/null +++ b/docs/repl/examples/08/example.json @@ -0,0 +1,8 @@ +{ + "title": "JSX", + "options": { + "jsx": { + "mode": "preserve" + } + } +} diff --git a/docs/repl/examples/08/modules/main.js b/docs/repl/examples/08/modules/main.js new file mode 100644 index 00000000000..e9744cbb67b --- /dev/null +++ b/docs/repl/examples/08/modules/main.js @@ -0,0 +1,6 @@ +// JSX SUPPORT +// Try different jsx.mode and see how it is transformed +import './other.js'; +const Foo = ({ world }) =>Hello {world}!
;
+
+console.log(This is deconflicted!
;
+console.log(