/manifold-util-2024.1.29.jar
->```
-
-* Download [Manifold : _Core_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold&v=RELEASE)
-
-
-
-* Download [Manifold : _GraphQL_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-graphql&v=RELEASE)
-* Download [Manifold : _XML_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-xml&v=RELEASE)
-* Download [Manifold : _JSON_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-json&v=RELEASE)
-* Download [Manifold : _CSV_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-csv&v=RELEASE)
-* Download [Manifold : _YAML_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-yaml&v=RELEASE)
-* Download [Manifold : _Properties_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-properties&v=RELEASE)
-* Download [Manifold : _Image_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-image&v=RELEASE)
-* Download [Manifold : _Dark Java_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-darkj&v=RELEASE)
-* Download [Manifold : _JavaScript_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-js&v=RELEASE)
-
-
-
-* Download [Manifold : _Java Extension_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-ext&v=RELEASE)
-
-
-
-* Download [Manifold : _Java Properties_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-props&v=RELEASE)
-
-
-
-* Download [Manifold : _Templates_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-templates&v=RELEASE)
-
-
-
-* Download [Manifold : _String Templates_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-strings&v=RELEASE)
-* Download [Manifold : _[Un]checked_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-exceptions&v=RELEASE)
-
-
-
-* Download [Manifold : _Preprocessor_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-preprocessor&v=RELEASE)
-
-
-
-* Download [Manifold : _Science_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-science&v=RELEASE)
-
-
-
-* Download [Manifold : _Collections_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-collections&v=RELEASE)
-* Download [Manifold : _I/0_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-io&v=RELEASE)
-* Download [Manifold : _Text_](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-text&v=RELEASE)
-
-
-
-* Download [Manifold : Util](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=systems.manifold&a=manifold-util&v=RELEASE)
-
-# License
-
-Manifold is open source and licensed under the [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0) license.
-
-# Author
-
-* [Scott McKinney](mailto:scott@manifold.systems)
-
-# Forum
-Join our [Discord server](https://discord.gg/VYUpzA64) to start
-a discussion, ask questions, provide feedback, etc. Someone is usually there to help.
diff --git a/docs/licenses.md b/docs/licenses.md
deleted file mode 100644
index 865b64b60..000000000
--- a/docs/licenses.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-layout: default
----
-
-
-
-# Licenses
-
-Manifold is open source and licensed under the [Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0) license.
-
-## Plugin for IntelliJ IDEA and Android Studio
-
-The [Manifold Plugin](https://plugins.jetbrains.com/plugin/10057-manifold) is available separately via
-the [JetBrains Marketplace](https://plugins.jetbrains.com/).
\ No newline at end of file
diff --git a/docs/manifold-js.md b/docs/manifold-js.md
deleted file mode 100644
index 1127236d1..000000000
--- a/docs/manifold-js.md
+++ /dev/null
@@ -1,357 +0,0 @@
----
-layout: default
----
-# The Javascript Manifold
-
-The Javascript Manifold (Manifold.js) is a [Manifold](http://manifold.systems/) extension library that allows for seamless interaction with javascript
-resources from Java using the [Rhino](https://github.com/mozilla/rhino) project.
-
-The library supports the use of javascript programs from Java, the use of ES6-flavored javascript classes from
-java, the use of Java classes from javascript, as well as the creation of type-safe javascript expressions for
-use in Java as a scripting layer.
-
-## Javascript Program Support
-
-Manifold.js makes standard ES5-style Javascript programs available as types in Java.
-
-The entire javascript program is evaluated when the type is first accessed. Top level functions
-are accessible as static methods on the program type.
-
-### Functions
-
-Here is an example top-level function found in `ExampleProgram.js`:
-
-```javascript
- function hello(name) {
- return "Hello " + name;
- }
-```
-
-This function could be invoked from Java like so:
-
-```java
- System.out.println( ExampleProgram.hello("Java Programmers") )
-```
-
-### Parameter & Return Types
-
-The parameters and the return type of javascript functions are all of type `Object`.
-
-### Variables
-
-Top level variables in javascript programs are treated as global variables and will retain their values
-between evaluation. Given this function:
-
-```javascript
- var i = 0;
-
- function nextNum() {
- return i++;
- }
-```
-
-The following code
-
-```javascript
- System.out.println( ExampleProgram.nextNum() )
- System.out.println( ExampleProgram.nextNum() )
-```
-
-will print
-
- 0.0
- 1.0
-
-### Typescript-Style Typing (Parameters & Return Types)
-
-In order to allow for greater control and readability in Java, Manifold.js allows you to specify the types parameters and return
-types using Typescript syntax.
-
-Javascript:
-
-```javascript
- import java.util.ArrayList;
- class Sample {
- constructor(a : String) {
- this.foo = a;
- }
-
- foo (bar: String, baz : Integer) : ArrayList {
- var arrlist = new ArrayList();
- for(var i = 0 ; i < baz ; i ++) {
- arrlist.add(bar);
- }
- return arrlist;
- }
- }
-```
-
-Java:
-
-```java
- Sample sample = new Sample();
- System.out.println(foo("Hello", 5)) // ["Hello","Hello","Hello","Hello","Hello"]
-```
-
-### ES6-style Arrow Functions
-
-Manifold.js supports the use of ES6 Arrow Functions inside any Javascript program or class.
-
-Javascript:
-
-```javascript
- //Arrow function expression
- function filterEvens(list) {
- return list.filter( a => a % 2 == 0);
- }
-
- //Arrow function statements
- function incrementList(list) {
- return list.map( a => {return a + 1});
- }
-```
-
-## Experimental Features
-
-The following features are experimental.
-
-### Javascript Class Support
-
-Javascript classes are exposed as regular classes in Java. They have the same functionality as Java classes,
-including constructors, methods, static methods, and properties.
-
-Javascript: foo.js
-
-```javascript
- class Foo {
-
- //Constructor
- constructor(a) {
- this.foo = a;
- this._bars = 5;
- }
-
- //Methods
- function bar() {
- return this.foo * 2;
- }
-
- function baz(a,b) {
- return a+b + this.foo;
- }
-
- //Static Methods
- static hello() {
- return "hello";
- }
-
- //Properties
- get bars() {
- return this._bars*2;
- }
-
- set bars(a) {
- this._bars = a;
- }
-
- }
-```
-
-#### Constructor
-The constructor is called when a new object is created. It initializes the properties within the object.
-
-Javascript:
-
-```javascript
- class Foo {
- constructor(a) {
- this.bar = a;
- }
- }
-```
-
-Java:
-
-```java
- Foo foo = new Foo(5); // Creates new Foo object and sets this.bar to a
-```
-
-#### Methods
-
-Methods are functions that are assigned to classes. They can interact with properties of the class and call other
-internal methods.
-
-Javascript:
-
-```javascript
- class Foo {
-
- constructor(a) {
- this.foo = a;
- }
-
- function bar() {
- return this.foo * 2;
- }
- }
-```
-
-Java:
-
-```java
- Foo foo = new Foo(21);
- System.out.println(foo.bar); // prints 42
-```
-#### Static Methods
-
-Javascript:
-
-```javascript
- class Foo {
- constructor(a) {
- this.foo = a;
- this._bars = 5;
- }
-
- static function staticFoo() {
- return 42;
- }
- }
-```
-
-Java:
-
-```java
- System.out.println(Foo.staticFoo()); // Prints 42
-```
-
-#### Properties
-Classes can have getter and setter properties which abstract the properties held within the class.
-
-Javascript:
-
-```javascript
- class Foo {
- constructor(a) {
- this.foo = a;
- this._bars = 5;
- }
- get bars() {
- return this._bars*2;
- }
-
- set bars(a) {
- this._bars = a;
- }
- }
-```
-
-Java:
-
-```javascript
- Foo foo = new Foo();
- foo.setBars(21);
- System.out.println(foo.getBars()) // Prints 42
-```
-
-### Javascript Template Support
-
-Javascript templates are supported as first class citizens. A Javascript String Template is a file that ends
-in the .jst extension.
-
-Javascript Template: SampleJSTemplate.jst
-
- <%@ params(names) %>
-
- All Names: <%for (var i = 0; i < names.length; i++) { %>
- ${names[i]}
- <% } %>
-
-The template declares the parameters using the `<%@ params() %>` directive, and can import Java classes using
-the <%@ import %> directive.
-
-Javascript statements can be added between the `<%` and `%>` punctuators, which are evaluated as Javascript but
-added directly to the generated string.
-
-Javascript expressions can be added either between the `${` and `}` punctuators or the `<%=` and `%>` punctuators,
-and are evaluated and added to the generated string.
-
-Javascript templates can then be rendered from Java like so:
-
-Java:
-
-```java
-
- String str = SampleJSTemplate.renderToString({"Carson", "Kyle", "Lucca"});
- System.out.println(str)
-
-```
-
-### Accessing Javascript Classes from Java
-
-Javascript classes can be accessed using the same syntax as Java classes.
-
-Java:
-
-```java
- Foo foo = new Foo(10);
- System.out.println(foo.bar()); // 20
- System.out.println(foo.getBars()); // 5
-
- foo.setBars(20);
- System.out.println(foo.getBars()) // 40
- System.out.println(Foo.hello()) // Hello
-```
-
-#### Accessing Java Classes from Javascript
-
-The (non-standard javascript) import statement is used to extend Java classes with javascript methods.
-
-Here is some example javascript: hello.js
-
-```javascript
- import java.util.ArrayList;
-
- function hello() {
- var arrlist = new ArrayList();
- arrlist.add(1);
- arrlist.add(2);
- arrlist.add(3);
- System.out.println(arrlist.toArray(new Integer[arrlist.size()]));
- }
-```
-
-This can be invoked from Java like so:
-
-```java
- hello.hello(); //prints [1,2,3]
-```
-
-NB: The import statement in Manifold.js acts like the java import statement, not the (unsupported) javascript version.
-
-#### Extending Java Classes from Javascript
-
-Java classes can be extended using javascript, allowing for the creation of modified classes. One
-known limitation is that the constructor of the superclass cannot be overwritten.
-
-Javascript:
-
-```javascript
- import java.util.ArrayList;
-
- class SizePrints extends ArrayList {
- printSize() {
- System.out.println(super.size());
- }
- }
-```
-
-Java:
-
-```java
- SizePrints demo = new sizePrints();
- demo.add(1);
- demo.add(2);
- demo.add(3);
- demo.printSize(); // Prints 3
-```
diff --git a/docs/manifold-templates.md b/docs/manifold-templates.md
deleted file mode 100644
index ebb85d39a..000000000
--- a/docs/manifold-templates.md
+++ /dev/null
@@ -1,682 +0,0 @@
----
-layout: default
----
-
-# ManTL (Manifold Template Language)
-
-ManTL is a lightweight & *type-safe* template engine directly integrated with the Java compiler using [Manifold](http://manifold.systems/).
-It supports the full Java language, type-safe arguments to templates, type-safe inclusion of other templates,
-shared layouts for templates and custom base classes for application-specific logic, among other features.
-
-Templates compile directly in your build as if Java source files _without a separate code generation build step_, therefore
-your Java source code can reference and use your template files by name directly as _Java classes_. This level of
-integration and type-safety promotes higher levels of integrity and performance. It also enables tooling like the [Manifold IntelliJ plugin](https://plugins.jetbrains.com/plugin/10057-manifold)
-to provide deterministic code completion, navigation, usage searching, and refactoring. Additionally the IntelliJ plugin
-enables incremental compilation and hot swap debugging, allowing you to make template changes in a running application.
-
-> Clone the [Manifold sample Web App project](https://github.com/manifold-systems/manifold-sample-web-app) to quickly
-begin experimenting with ManTL templates using the Manifold IntelliJ plugin.
-
-## Table of Contents
-* [Installing](#installing)
-* [Usage](#usage)
-* [Syntax](#basic-syntax)
- * [Statements](#statements)
- * [Expressions](#expressions)
- * [Comments](#comments)
- * [Directives](#directives)
- * [`import`](#-import-)
- * [`extends`](#-extends-)
- * [`params`](#-params-)
- * [`include`](#-include-)
- * [`section`](#-section-)
- * [`layout`](#-layout-)
- * [`content`](#-layout-)
-* [Whitespace](#whitespace)
-* [**Spark** Java Support](#spark)
- * [Hello World!](#spark-hello-world)
- * [Tracing](#tracing)
- * [Template Base Class](#spark-template)
- * [Sample Application](#demo)
-
-
-
-# Installing
-
-Use ManTL in your project simply by adding the `manifold-template` dependency.
-
-Maven:
-```xml
-
- systems.manifold
- manifold-templates
-
- 0.71-alpha
-
-```
-
-Gradle:
-```groovy
- compile group: 'systems.manifold', name: 'manifold-templates', version: 'RELEASE'
-```
-
-> Note [prebuilt binaries](http://manifold.systems/docs.html#binaries) are also available for non-Maven/Gradle projects.
-
-# Usage
-
-Once you have installed ManTL, you can begin using it by placing a new file with the `mtl` extension in your _resources_
-directory (nb: not in your source directory). The file can have any sort of string content, as well as [dynamic content](#basic-syntax)
-and [directives](#directives) that change how the template behaves.
-
-> Note it is helpful, but not required, to include the file extension of the target content in the template file name.
-For instance, a template that produces HTML as output is named *MyTemplate.html.mtl*
-
-Consider the following template named `HelloWorld.txt.mtl`, located in the `resources/templates` directory:
-
-```jsp
-Hello World!
-```
-This template can be used directly from your Java code:
-
-```java
-import templates.HelloWorld;
-public class Demo {
- public static void main(String[] args) {
- System.out.println(HelloWorld.render());
- }
-}
-```
-
-This prints `Hello World` to your console.
-
-If you want to add a parameter to the template, you can change the template to use the [`params`](#-params-) directive:
-
-```jsp
-<%@ params(String name) %>
-Hello ${name}!
-```
-
->Note you can make changes to your templates in IntelliJ while debugging your application. The Manifold plugin for
-IntelliJ hot swaps incremental compilation changes into your running application.
-
-You can call this parameterized template with a `String` argument:
-
-```java
-import templates.HelloWorld;
-public class Demo {
- public static void main(String[] args) {
- System.out.println(HelloWorld.render("ManTL"));
- }
-}
-```
-
-Which prints `Hello ManTL!` to your console.
-
-If you do not wish to materialize the template as a string, you can use the `renderInto()` method to render templates
-into any `Appendable` object. The `renderInto()` method is similar to `render()` but defines an additional `Appendable`
-parameter and returns `void`.
-
-
-
-# Syntax
-
-As with most template languages, a ManTL template consists of regular textual content interspersed with language
-constructs such as statements, expressions, comments, and directives.
-
-
-
-## Statements
-
-ManTL lets you control output of a template with Java language statements. You inline statements or statement fragments
-in a template using this syntax:
-
-```jsp
-<% java-statement-parts %>
-```
-
-ManTL supports all Java language statements including variable and method declarations and control structures. For
-example, the `if` statement:
-
-```jsp
-<% if(total >= 90) { %>
-Grade: A
-<% } %>
-```
-results in the following output if `total` is `90` or greater:
-```text
-Grade: A
-```
-otherwise, the statement has no effect on the output.
-
-Notice the statement is fragmented between two sets of `<% %>` delimiters. You can leverage many of Java's
-statements in this way to control the output, including `if-else`, `switch`, `for`, `while`, and `do-while`.
-
-This example demonstrates how a simple `for` statement can repeat a section of the template's content:
-```jsp
-<% for(String brand: Arrays.asList("Maserati", "Alfa Romeo", "Abarth") { %>
- Fiat brand: ${brand}
-<% } %>
-```
-Renders as:
-```text
- Fiat brand: Maserati
- Fiat brand: Alfa Romeo
- Fiat brand: Abarth
-```
-
-You can achieve the same result using a Java lambda expression:
-```jsp
-<% Arrays.asList("Maserati", "Alfa Romeo", "Abarth").forEach(brand -> { %>
- Fiat brand: ${brand}
-<% }); %>
-```
-
-
-
-## Expressions
-
-A ManTL expression contains a Java language expression, it is evaluated, coerced to a `String`, and
-inserted where the expression appears in the ManTL file.
-
-Use expressions with this syntax:
-```jsp
-<%= java-expression %>
-```
-
-Additionally, the following shorthand syntax is also valid:
-```jsp
-${ java-expression }
-```
-
-For example, this template:
-```jsp
-
- Expression Example
-
- <% int y = 10; %>
- The font size of this paragraph is ${y}.
-
-
-```
-
-generates the following HTML:
-
-```html
-
- Expression Example
-
- The font size of this paragraph is 10.
-
-
-```
-
-Note the statement declaring the `y` variable does not directly contribute to the resulting content. This is because a
-statement does not produce a value to display, instead a statement *controls* what displays. By contrast an expression
-produces a value, thus it directly renders as part of the template's resulting content, hence both `${y}` expressions
-render `10` in the output.
-
-
-
-## Comments
-Comments are blocks that delimit areas of the template the compiler ignores; they do not contribute to the template's
-output. Use them to make comments and to temporarily mask off sections of a template as you like.
-
->Note template comments in no way affect the generated Java code, they are exclusively template file comments.
-
-The syntax of a comment is as follows:
-```jsp
-<%-- This is a comment --%>
-```
-
-
-
-## Directives
-
-Directives are commands you use to control the compilation and resulting structure of a template.
-
-Directives have the following syntax:
-
-```jsp
-<%@ directive-name [options] %>
-```
-
-Here is a summary of all the ManTL directives. More detailed descriptions follow.
-
-| Directive | Syntax | Description |
-|----------------|---------------------------------------------|-------------------------------------------------------------------------------------|
-| import | `<%@ import type-name %>` | Imports Java types for use in template directives, statements, and expressions |
-| extends | `<%@ extends class-name %>` | Extends a base class having features suitable for the template file |
-| params | `<%@ params(parameter-list) %>` | Parameters for the template, arguments passed via the `render(arg-list)`method |
-| include | `<%@ include template-name[(parameter-list)] [if ]%>` | Include a separate template in the template |
-| section | `<%@ section section-name(parameter-list) %>` | Creates a sub-template within the template, that can be called from other templates |
-| layout | `<%@ layout template-name %>` | Specifies the template in which the declaring template nests its content |
-| content | `<%@ content %>` | Used in a `layout` template, denotes where the content of a nested template renders |
-
-
-
-
-### `import`
-Use the `import` directive as you would a Java `import` statement so you can use Java classes without
-having to qualify them with package names.
-
-The syntax of the `import` directive:
-```jsp
-<%@ import type-name %>
-```
-
-This example imports the `java.util.HashSet` class and uses it to declare the `myHashSet` variable:
-```jsp
-
-<%@ import java.util.HashSet %>
- Import Example
-
- <% int y = 10;
- HashSet myHashSet = new HashSet<>();
- myHashSet.add(y);
- myHashSet.add(15);
- for(Integer a: myHashSet) { %>
- myHashSet contains ${a}.
- <% } %>
-
-
-```
-The above template produces the following HTML:
-```html
-
- Import Example
-
- myHashSet contains 10.
- myHashSet contains 15.
-
-
-```
-
->Note `import` directives must precede all other directives in your template.
-
-
-
-### `extends`
-Use the `extends` directive to make a template extend a custom base class, which you can use to provide
-additional application specific functionality e.g., `Request` and `Response` objects in a web application.
-
-A practical example of the `extends` directive:
-```java
-package demo;
-
-import model.Contact;
-import manifold.templates.rt.runtime.BaseTemplate;
-
-public class ExampleTemplate extends BaseTemplate {
-
- public String displayContact(Contact c) {
- if(c.hasName()) {
- return c.getName();
- } else {
- return c.getEmail();
- }
- }
-
-}
-```
-
-This allows the developer to render a clean template:
-
-```jsp
-<%@ import model.Contact %>
-<%@ extends demo.ExampleTemplate %>
-<%@ params(Contact c)%>
-
-
-
- Contact
-
-
- ${displayContact(c)}
-
-
Your name is: ${myName}
-```
-
-You can then include it in another template as follows:
-
-```jsp
-
- PARAMS Example
-
- <%@ include NameDisplay("Robert") %>
- <%@ include NameDisplay("Scott") %>
-
-
-```
-
-Then, the following HTML will be generated:
-```html
-
- PARAMS Example
-
- Your name is: Robert
- Your name is: Scott
-
-
-```
-
-
-
-### `include`
-
-The `include` directive allows users to insert other templates inside of the given template in a type
-safe manner.
-
-The syntax looks like this:
-```jsp
-<%@ include [template-name] %>
-```
-
-For example, consider the following template, `MyTemplate.html.mtl`:
-```jsp
-<% int fontSize = 0; %>
-
- WHILE LOOP Example
-
- <% while (fontSize <= 3) { %>
-
- ManTL Tutorial
-
- <%fontSize++;%>
- <%}%>
-
-
-```
-We can then include it from another template as such:
-```jsp
-<%@ include MyTemplate %>
-```
-
-Both statements will result in the following HTML code:
-```html
-
- WHILE LOOP Example
-
-
- ManTL Tutorial
- <
-
- ManTL Tutorial
-
-
- ManTL Tutorial
-
-
- ManTL Tutorial
-
-
-
-```
-
-#### Conditional Include
-ManTL supports shorthand for conditional inclusion of templates. The following syntax:
-```jsp
-<% if (condition) { %>
- <%@ include MyTemplate %>
-<% } %>
-```
-Can be condensed to the following:
-```jsp
-<%@ include MyTemplate if(condition) %>
-```
-(Note: In the above, parentheses are optional.)
-
-
-
-
-### `section`
-
-The `section` directive creates a subsection of the current template that can be added using the `include` directive in
-other templates.
-
-The syntax of a `section` block:
-```jsp
-<%@ section section-name[(symbols-used-in-section)] %>
- SECTION CONTENT HERE
-<%@ end section %>
-```
-Note the corresponding `<%@ end section %>` directive must be used to complete the section, otherwise
-a compile error results.
-
-For example, you can create the template `NestedImport.html.mtl` as the following:
-```jsp
-<%@ import java.util.* %>
-Defines a section
-<%@ section mySection %>
- <% HashSet myHashSet = new HashSet<>();
- myHashSet.add(1);
- myHashSet.add(2);
- myHashSet.add(3);
- for(Integer a: myHashSet) { %>
- Font size: ${a}
- <% } %>
-<%@ end section %>
- The End
-```
-
-The above code will generate the following HTML:
-```html
- Defines a section
- Font size: 1
- Font size: 2
- Font size: 3
- The End
-```
-
-Then, you can include `mySection` in a separate template:
-```jsp
- <%@ include NestedImport.mySection %>
-```
-
-Which will result in the following HTML:
-```html
- Font size: 1
- Font size: 2
- Font size: 3
-```
-
-
-
-
-### `layout`
-
-Layouts can be made and used with the `content` and `layout` directives respectively.
-
-The `content` directive splits the current template into the header and footer of a layout.
-
-The `layout` directive makes the header and footer of the layout frame the current template.
-The current template renders at the location of the `content` directive.
-
-Both the `content` directive and `layout` directive are only valid in the outermost class
-(not within sections) and can only appear once in a template.
-
-The `params` directive is not yet supported for a template that contains the `content` directive.
-
-The syntax of a layout template is as follows:
-```jsp
-HEADER CONTENT HERE
-<%@ content %>
-FOOTER CONTENT HERE
-```
-
-For example, you can create the template `LayoutEx.html.mtl`:
-```jsp
-