Skip to content

feat: load on-demand chunks without compiling JavaScript - #26813

Merged
mcollovati merged 16 commits into
mainfrom
feat/load-chunks-without-string-js
Nov 3, 2026
Merged

mcollovati merged 16 commits into
mainfrom
feat/load-chunks-without-string-js

Conversation

@totally-not-ai

@totally-not-ai totally-not-ai Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Review risk: two-way door — changes how every route's chunk is loaded on the client (wire form of DYNAMIC_IMPORT for Flow's own chunks); string addDynamicImport calls are unchanged.

Fixes #26150

Summary

Opening a route whose JavaScript is in a lazily loaded chunk made the browser compile a string sent by the server, which a Content Security Policy without unsafe-eval blocks. Chunk loading now uses a function declared in the bundle (as added in #26729), so nothing is compiled in the browser. Applications get the same option through a new Page.addDynamicImport(JsFunction) overload. The blocking behaviour is unchanged: no later change is applied until the chunk promise resolves.

What changed

  • UIInternals declares the chunk loader as a @JsDefinition snippet (ChunkJs.loadChunk(chunkId)) and passes it to Page.addDynamicImport(JsFunction) instead of building the loadOnDemand('<id>') expression string. In strict CSP mode, navigating to a route no longer throws.
  • Added Page.addDynamicImport(JsFunction); the String overload's Javadoc points to it as the CSP-safe alternative.
  • Dependency gets an internal constructor that takes a JsFunction. Its url, which de-duplicates dependencies, is the JSON of the encoded function and the only place the function is kept, so the same function with the same captures loads once and a copy made from type and url (as DependencyList and dependency filters make) still loads the function. The internal getEncodedDynamicImport() reads it back from the url; no JavaScript expression starts like that JSON, as it would not compile as a function body.
  • UidlWriter sends such a dependency with the encoded @v-fn value in url instead of a string. The message shape is otherwise the same.
  • Client: DependencyLoader decodes an object url of a DYNAMIC_IMPORT with ClientJsonCodec and passes the function to ResourceLoader.loadDynamicImport, which calls it instead of new Function. String expressions keep the old path. Waiting, listeners and error reporting are unchanged; a function missing from the bundle fails the import through the existing error path.
  • Behaviour note: the url of a chunk-loading dependency in the UIDL JSON is now an object, not a string. A custom DependencyFilter sees a Dependency whose getUrl() is that JSON string.
  • A function that captures an element or a component, attached or not, is rejected with IllegalArgumentException when it is added: the browser loads dependencies before it applies the changes of the same round trip, and a detached element is encoded as null, so it cannot be referenced. The check looks at the Java captures, including collections, maps, arrays and nested functions, and at the encoded JSON for an attached element inside a bean. On the client the function is decoded when the import is loaded, so a value that cannot be decoded fails only that import through its listener instead of the whole message.
  • Chunk dependencies are created once per chunk and reused, instead of once per response that attaches a component of that chunk.

Use case

A reporting view has an "Advanced editing" mode backed by a large <report-editor> web component that most users never open. Its module is kept out of the initial bundle and loaded only on first use; because the import blocks the rest of the round trip, the element is already defined when Flow attaches it, and nothing is compiled from a string, so it works under a CSP without unsafe-eval:

@JsDefinition
public interface ReportEditorJs extends Serializable {
    @JsExpression("return import('Frontend/report-editor/report-editor.js');")
    JsFunction loadEditor();
}

private static final ReportEditorJs EDITOR_JS = JsSnippets.of(ReportEditorJs.class);

advancedButton.addClickListener(e -> {
    getUI().ifPresent(ui -> ui.getPage().addDynamicImport(EDITOR_JS.loadEditor()));
    layout.add(new ReportEditor()); // @Tag("report-editor"), no @JsModule
});

ReportEditor must not also carry @JsModule for the same file, or the module ends up in the main bundle. The path has to be a literal for the bundler to split it.

Test summary

  • Server: chunk-loading tests now check that each chunk is sent as the declared loader function with the chunk id as its capture; a strict CSP test checks that loading a route's chunk no longer throws (it failed with the old string expression).
  • Server: adding the same function twice gives one dependency, and different captures give two with exactly those captures; a function dependency is a lazy DYNAMIC_IMPORT whose copy from type and url still carries the function; a function capturing an element is rejected, whether the element is attached, detached, a component, or inside a list or a nested function.
  • Client: a dynamic import sent as @v-fn is decoded from the snippet registry and called; a function that cannot be decoded fails only that import; loadDynamicImport calls a given function without compiling the expression.
  • Ran JsFunctionIT end to end in a browser (passes), and checked that the generated vaadin-js-definitions.js contains the chunk loader.

API Changes

// com.vaadin.flow.component.page.Page — Added
public void addDynamicImport(JsFunction dynamicImport)

// com.vaadin.flow.shared.ui.Dependency — Added (internal use only)
public Dependency(JsFunction dynamicImport)
public JsonNode getEncodedDynamicImport()

// com.vaadin.flow.component.internal.UIInternals — Added (internal use only)
@JsDefinition public interface ChunkJs extends Serializable
JsFunction loadChunk(String chunkId)

Working on behalf of @mcollovati

Chunk loading sent "return window.Vaadin.Flow.loadOnDemand('<id>');"
as a dynamic import expression, which the client compiled with
new Function, so a route with a lazily loaded chunk could not be
opened under a Content Security Policy without 'unsafe-eval'.

A dynamic import can now carry a JsFunction. Flow declares the chunk
loader as a bundled snippet, the server sends it as a @v-fn value in
the dependency url, and the client decodes and calls it instead of
compiling a string. Page.addDynamicImport(JsFunction) gives
applications the same CSP-safe option.

Fixes #26150
@totally-not-ai
totally-not-ai Bot requested a review from mcollovati November 2, 2026 11:05
@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Memory footprint

Compared with the base commit cda10ef.

Scenario Metric Base Head Change
Empty UI Heap retained per UI 7,880 B 7,512 B $\color{green}\textbf{−368 B}$ (−4.7%)
Empty UI Serialized session with one UI 21,864 B 21,976 B $\color{red}\textbf{+112 B}$ (+0.5%)
UI with 200 component rows Heap retained per UI 691,472 B 691,104 B $\color{green}\textbf{−368 B}$ (−0.1%)
UI with 200 component rows Serialized session with one UI 438,481 B 438,593 B $\color{red}\textbf{+112 B}$ (+0.0%)
UI with 200 form rows added in the latest round trip Heap retained per UI 1,863,544 B 1,863,176 B $\color{green}\textbf{−368 B}$ (−0.0%)
UI with 200 form rows added in the latest round trip Serialized session with one UI 1,394,989 B 1,395,102 B $\color{red}\textbf{+113 B}$ (+0.0%)
UI with 200 form rows Heap retained per UI 1,818,592 B 1,818,224 B $\color{green}\textbf{−368 B}$ (−0.0%)
UI with 200 form rows Serialized session with one UI 1,350,019 B 1,350,131 B $\color{red}\textbf{+112 B}$ (+0.0%)
Empty UI: Heap retained per UI by class
Class Instances Bytes
[B −2 −256
com.vaadin.flow.shared.ui.Dependency −2 −64
java.lang.String −2 −48
UI with 200 component rows: Heap retained per UI by class
Class Instances Bytes
[B −2 −256
com.vaadin.flow.shared.ui.Dependency −2 −64
java.lang.String −2 −48
UI with 200 form rows added in the latest round trip: Heap retained per UI by class
Class Instances Bytes
[B −2 −256
com.vaadin.flow.shared.ui.Dependency −2 −64
java.lang.String −2 −48
UI with 200 form rows: Heap retained per UI by class
Class Instances Bytes
[B −2 −256
com.vaadin.flow.shared.ui.Dependency −2 −64
java.lang.String −2 −48
Scenarios
  • Empty UI (empty-ui): A UI with no components, which is the cost of every UI.
  • UI with 200 component rows (ui-with-200-component-rows): A UI with 200 rows, each a div with a class name and a style, holding a span, an input with a value change listener and a button with a click listener.
  • UI with 200 form rows added in the latest round trip (ui-with-200-form-rows-added-in-latest-round-trip): The UI with 200 form rows, with the rows added in the latest round trip, as when navigating to a view, so that the response kept for resending holds all of them.
  • UI with 200 form rows (ui-with-200-form-rows): A UI with 200 rows, each a layout with a theme and several styles, holding a text field and a combo box bound to a bean with a binder and a button with a click listener. The fields are web components with several properties and a synchronized value, and the combo box has client callable methods, as Vaadin components that load data do.

Measured by UIMemoryFootprintTest. Differences under 10 B are ignored.

@github-actions github-actions Bot added the +0.1.0 label Nov 2, 2026
Decode a dynamic import function when it is loaded, so a capture the
client cannot resolve yet fails that import through its listener
instead of dropping the whole message. Document that captures cannot
refer to elements attached in the same round trip, and that a
dependency filter has to return a function-backed dynamic import as
the same instance. Add tests for de-duplication and serialization of
function-backed dynamic imports.
@totally-not-ai

totally-not-ai Bot commented Nov 2, 2026

Copy link
Copy Markdown
Contributor Author

Fixed the three issues: Dependency.id and UidlWriter.ResolveContext.service are now final, since they are only assigned in constructors, and the dependency list in UIInternals.warnForUnavailableBundledDependencies uses Stream.toList(). That covers the flagged line and the identical one next to it. The result is only copied with addAll, so an unmodifiable list is fine there.

@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Test Results

 1 675 files  ± 0   1 761 suites  ±0   2h 11m 30s ⏱️ - 5m 9s
13 191 tests +20  13 123 ✅ +20  68 💤 ±0  0 ❌ ±0 
13 825 runs  +20  13 757 ✅ +20  68 💤 ±0  0 ❌ ±0 

Results for commit eb003c0. ± Comparison against base commit cda10ef.

♻️ This comment has been updated with latest results.


Collection<Dependency> dependencies = ui.getInternals()
.getDependencyList().getPendingSendToClient();
assertEquals(2, dependencies.size());

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The test verifies that only two dependencies will be sent but does not actually check if they are exactly a and b.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mcollovati The test now reads the captures of the pending dependencies and asserts they are exactly a and b, in that order.

this.dynamicImport = Objects.requireNonNull(dynamicImport,
"dynamicImport cannot be null");
this.url = JacksonUtils.getMapper().writeValueAsString(
JacksonCodec.encodeWithTypeInfo(dynamicImport));

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Do we really need to keep both the JsFunction and its JSON representation in url?
Can we make the encoded JSON in url the only source of truth?

This should avoid the need to "Return a {@link Dependency.Type#DYNAMIC_IMPORT} dependency as the same instance rather than as a copy" in DependencyFilter.
Also, DependencyList makes a copy of Dependency using a constructor that is not aware of the JsFunction, so it might create a potentially incorrect copy.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mcollovati Agreed. Dependency no longer stores the JsFunction: the encoded JSON in url is the only source of truth, and getEncodedDynamicImport() reads it back from the url when the type is DYNAMIC_IMPORT and the url starts with {"@v-fn":. No JavaScript expression can start like that, because it does not compile as a function body, so a string expression is never mistaken for a function. A copy made from type and url, such as the one DependencyList makes for a load mode conflict or one a filter makes, now still loads the function, so I removed the DependencyFilter note. DependencyTest covers the copy.

* A function that is added again with the same captured values is loaded
* only once. The function is created when the dependencies are processed in
* the browser, before the changes of the same round trip are applied, so it
* cannot capture an element that is attached in that round trip.

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

If there is such a limitation with element capture, it would be better to immediately reject them throwing an exception.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mcollovati Done. new Dependency(JsFunction), and so Page.addDynamicImport(JsFunction), now throws IllegalArgumentException if a capture encodes an element (@v-node at any depth). The check runs on the encoding the constructor already does, and the Javadoc documents the @throws. Detached elements already encode as null, so the check only rejects attached ones, which the browser cannot resolve yet when it loads dependencies.

Comment on lines +1465 to +1466
chunkIds.forEach(chunkId -> ui.getPage()
.addDynamicImport(CHUNK_JS.loadChunk(chunkId)));

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Using the JsFunction to load import has an additional cost of a proxy call plus JSON encode.
Probably, this is not so relevant in terms of performance, but it would be worth to check.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mcollovati I measured it with a quick JVM loop. Creating the chunk dependency through the snippet took about 0.7 µs, against about 15 ns for the old string concatenation. Chunk loading runs for each component class on every response that attaches components, so UIInternals now creates the dependency once per chunk id, in a static map. The map holds only strings and is bounded by the number of chunks, and the dependency is immutable, so it is safe to share. With the cache, a repeated add costs about 60 ns, against about 95 ns for building the string each time. Reading the function back for the UIDL is a JSON parse of about 0.6 µs, once per chunk sent to a UI.

The encoded function in the url is now the only source of truth, so a
copy of the dependency made from its type and url, as DependencyList
and dependency filters make, still loads the function. A function that
captures an element is rejected when it is added, as the browser loads
dependencies before it creates the elements of the same round trip.
Chunk dependencies are created once per chunk instead of once per
response that attaches a component.

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Is it so that this test class is missing tests for the DYNAMIC_IMPORT JSON encoding?

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mcollovati Yes, it only covered the chunk case, through getChunkIds. I added dynamicImports_expressionSentAsString_functionSentAsValue. It adds one string expression and one JsFunction through Page.addDynamicImport, then asserts that the LAZY dependencies of the response carry exactly the expression as a JSON string and the function as its @v-fn encoding, in that order.

@mcollovati
mcollovati marked this pull request as ready for review November 2, 2026 15:21
@github-actions

github-actions Bot commented Nov 2, 2026

Copy link
Copy Markdown
Contributor

Chunk loading now sends a function value instead of a string expression

flowchart LR
    subgraph Before
        direction TB
        B1["UIInternals.triggerChunkLoading builds loadOnDemand(id) string"] -->|"new Dependency(Type, String)"| B2["Dependency stores expression as url"]
        B2 -->|"UidlWriter writes url"| B3["UIDL url is the expression string"]
        B3 -->|"DependencyLoader reads url"| B4["ResourceLoader.loadDynamicImport"]
        B4 -->|"new Function(expression)"| B5["browser compiles and runs string"]
    end
    subgraph After
        direction TB
        A1["UIInternals.triggerChunkLoading calls ChunkJs.loadChunk(chunkId)"]:::changed -->|"new Dependency(JsFunction)"| A2["JacksonCodec.encodeWithTypeInfo(function)"]:::changed
        A2 -->|"UidlWriter writes url"| A3["UIDL url is the encoded function JSON"]:::changed
        A3 -->|"DependencyLoader decodes url"| A4["ClientJsonCodec.decodeWithTypeInfo"]:::changed
        A4 -->|"ResourceLoader.loadDynamicImport(load)"| A5["given function runs, nothing compiled"]:::changed
    end
    Before ~~~ After
    classDef changed stroke:#c9a227,stroke-width:3px
Loading

UIInternals.triggerChunkLoading now calls ChunkJs.loadChunk(chunkId) instead of concatenating a loadOnDemand string, and Dependency(JsFunction) encodes that function with JacksonCodec.encodeWithTypeInfo rather than keeping a JS expression as the URL. UidlWriter writes that encoding as the url field, so the client's DependencyLoader decodes it through ClientJsonCodec and ResourceLoader.loadDynamicImport calls the resulting function directly, never passing it through new Function. Per the pull request description and the linked issue, this is what lets a route's on-demand chunk load under a strict CSP without unsafe-eval.

Diagram Bot draws the mechanism this pull request touches; it does not review the change. Verify it against the diff.

Generated by Diagram Bot for #26813 · agent · 57.8 AIC · ⊞ 6.1K · ◷

@vaadin-review-bot vaadin-review-bot left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Reviewed the changes — left 2 comments.

Finding
🧪 The @v-node guard on the encoded JSON has no test
📝 The documented IllegalArgumentException does not cover a detached element inside a bean

JsonNode encoded = JacksonCodec.encodeWithTypeInfo(dynamicImport);
// How JacksonCodec references an attached element, such as one in a
// bean property, which capturesElement does not look into
if (encoded.findValue("@v-node") != null) {

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧪 The @v-node guard on the encoded JSON has no test

All five rejection cases in PageTest (element, detached element, component, element in a list, element in a nested function) are already caught by capturesElement before encoding happens. Nothing captures an attached element reached only through a bean property, which is the single case this second check exists for — delete it and the suite still passes.

Dependency.java:219 · tests

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Added addDynamicImportFunction_attachedElementInBean_throws. It captures a record that holds an attached element, which capturesElement does not look into, so only the check on the encoded @v-node rejects it. I confirmed that the test fails with that check disabled.

* @param dynamicImport
* the function that returns a Promise, not {@code null}
* @throws IllegalArgumentException
* if the function captures an element or a component

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

📝 The documented IllegalArgumentException does not cover a detached element inside a bean

capturesElement walks captures, collections, maps, arrays and nested functions, but not bean properties, and NodeSerializer writes a detached node as null, so neither check fires. The capture is accepted and silently arrives as null on the client. Either qualify the wording in both Page.addDynamicImport(JsFunction) and Dependency(JsFunction), or make the check see into beans.

Page.java:483 · documentation

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I qualified the wording rather than walking bean properties. Walking them would duplicate what Jackson already does to serialize the bean, and other values sent to the browser treat a detached element in a bean the same way. Page.addDynamicImport(JsFunction) now says the check covers a capture itself and what a collection, map, array or captured function holds. It also says bean properties are only checked for attached elements, and that a detached one in a bean is sent as null, as it is for any other value sent to the browser. The @throws of Dependency(JsFunction) lists the same cases.

@totally-not-ai

totally-not-ai Bot commented Nov 2, 2026

Copy link
Copy Markdown
Contributor Author

Fixed the java:S1166 issue in Dependency.getEncodedDynamicImport(). A parse failure there is expected: it means the URL is a JavaScript expression that starts with {, not an encoded function. So the code still falls back to loading it as an expression, and the exception is now logged at DEBUG together with the URL instead of being dropped silently.


private static final ChunkJs CHUNK_JS = JsSnippets.of(ChunkJs.class);

// Bounded by the number of chunks, and holds only strings

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
// Bounded by the number of chunks, and holds only strings
// One entry per chunk id, which is per component class name in development
// mode.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mcollovati Applied the suggested comment.

@mcollovati
mcollovati enabled auto-merge November 3, 2026 16:53
@sonarqubecloud

sonarqubecloud Bot commented Nov 3, 2026

Copy link
Copy Markdown

@mcollovati
mcollovati added this pull request to the merge queue Nov 3, 2026
Merged via the queue into main with commit 3bfba6a Nov 3, 2026
53 checks passed
@mcollovati
mcollovati deleted the feat/load-chunks-without-string-js branch November 3, 2026 17:32
vaadin-bot added a commit to vaadin/docs that referenced this pull request Nov 3, 2026
Document Page.addDynamicImport(JsFunction) for CSP-safe lazy loading of
JavaScript modules, and note that loading a route's on-demand chunk no
longer needs the Function-override workaround on the strict CSP page.

Documents vaadin/flow#26813 (`eb003c0838d5063b1e4a5d607da59bd6fc536c60`).
@github-actions

github-actions Bot commented Nov 3, 2026

Copy link
Copy Markdown
Contributor

Pull request created: #6554

Generated by Documentation Bot · agent · 126.7 AIC · ⊞ 11.7K

@github-actions

github-actions Bot commented Nov 3, 2026

Copy link
Copy Markdown
Contributor

Documentation Bot: Draft documentation pull request for this change: vaadin/docs#6554

Files updated:

  • articles/flow/advanced/loading-resources.adoc
  • articles/flow/security/advanced-topics/strict-csp.adoc

It was written from the state of this pull request as you see it now. Please review it and mark it ready for review.

Generated by Documentation Bot for #26813 · agent · 126.7 AIC · ⊞ 11.7K · ◷

@vaadin-bot

Copy link
Copy Markdown
Collaborator

This ticket/PR has been released with Vaadin 25.4.0-alpha5.

heruan pushed a commit to vaadin/docs that referenced this pull request Nov 19, 2026
…ct CSP (#6554)

Documentation for vaadin/flow#26813 by `@totally-not-ai`[bot].

> [!NOTE]
> The source pull request is merged, so this documentation describes the
final
> shape of the change. Please review it and mark it ready for review.

**Change categories:** NEW_FEATURE, API_CHANGE, BEHAVIOR_CHANGE

| File | Change |
|------|--------|
| `articles/flow/advanced/loading-resources.adoc` | Added a "Dynamic
Imports" subsection documenting the new
`Page.addDynamicImport(JsFunction)` overload: how to declare the import,
the bundler-splitting requirement, the element-capture restriction, and
how it relates to the existing `addDynamicImport(String)` overload. |
| `articles/flow/security/protections/content-security-policy.adoc` |
Removed "chunk loading" from the list of things the nonce-only example
doesn't handle, added a sentence noting that a route's on-demand chunk
no longer needs the Function-override workaround, and removed the
now-dead `loadOnDemand` string-matching branch from the override code
sample. |

Auto-generated by the Documentation Bot — review before merging.

> Generated by [Documentation
Bot](https://github.com/vaadin/flow/actions/runs/41685202669) for #26813
· agent · 126.7 AIC · ⊞ 11.7K ·
[◷](https://github.com/search?q=repo%3Avaadin%2Fdocs+%22gh-aw-workflow-id%3A+doc-bot%22&type=pullrequests)
> - [x] expires <!-- gh-aw-expires: 2026-12-03T17:41:02.724Z --> on Dec
3, 2026, 5:41 PM UTC

<!-- gh-aw-agentic-workflow: Documentation Bot, engine: claude, model:
agent, id: 41685202669, workflow_id: doc-bot, run:
https://github.com/vaadin/flow/actions/runs/41685202669 -->

<!-- gh-aw-expires-type: pull-request -->

<!-- gh-aw-workflow-id: doc-bot -->
<!-- gh-aw-workflow-call-id: vaadin/flow/doc-bot -->

---------

Co-authored-by: totally-not-ai[bot] <290682512+totally-not-ai[bot]@users.noreply.github.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Load on-demand chunks without compiling JavaScript in the browser

4 participants