diff --git a/docs/src/site/markdown/coreprofile/debugging_a_rest_service_with_netbeans.md b/docs/src/site/markdown/coreprofile/debugging_a_rest_service_with_netbeans.md
new file mode 100644
index 0000000000..62272ff0d0
--- /dev/null
+++ b/docs/src/site/markdown/coreprofile/debugging_a_rest_service_with_netbeans.md
@@ -0,0 +1,237 @@
+# Debugging a REST service with NetBeans
+
+If you are looking to debug a REST service with NetBeans then follow along!
+
+In 5 steps you will learn how to start debugging the REST service. They are:
+
+1. Create the Maven POM file
+1. Add the application class
+1. Add the endpoint
+1. Add the NetBeans nbactions-default.xml file
+1. Debug the application
+
+## Create the Maven POM file
+
+Create an empty directory to store your Maven project. Inside of that directory
+create the ```pom.xml``` file with the content as below.
+
+```xml
+
+
+
+ 4.0.0
+ cloud.piranha.guides.coreprofile
+ netbeans-debug
+ 1-SNAPSHOT
+ war
+ Piranha Core Profile - Debugging a REST service with NetBeans
+
+ 10.0.0
+ 17
+ 5.10.0-M1
+ 3.11.0
+ 3.0.0
+ 3.3.2
+ 23.6.0
+ UTF-8
+
+
+
+ jakarta.platform
+ jakarta.jakartaee-core-api
+ ${jakartaee.version}
+ provided
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-params
+ ${junit.version}
+ test
+
+
+
+ netbeans-debug
+
+
+ cloud.piranha.maven.plugins
+ piranha-maven-plugin
+ ${piranha.version}
+
+
+ pre-integration-test
+ pre-integration-test
+
+ start
+
+
+
+ post-integration-test
+ post-integration-test
+
+ stop
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ ${maven-compiler-plugin.version}
+
+ ${java.version}
+
+
+
+ org.apache.maven.plugins
+ maven-failsafe-plugin
+ ${maven-failsafe-plugin.version}
+
+
+
+ integration-test
+ verify
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-war-plugin
+ ${maven-war-plugin.version}
+
+ false
+
+
+
+
+
+
+ debug
+
+
+
+ cloud.piranha.maven.plugins
+ piranha-maven-plugin
+ ${piranha.version}
+
+ -Xdebug -agentlib:jdwp=transport=dt_socket,server=n,suspend=n,address=${jpda.address}
+
+
+
+
+
+
+
+```
+
+Note the POM file contains a `debug` profile in the profiles section that
+we will leverage later on to activate the NetBeans debugging.
+
+## Add the application class
+
+Add the Application class in the `src/main/java` directory, which allows you to
+set the application path using the @ApplicationPath annotation.
+
+```java
+package rest;
+
+import jakarta.ws.rs.ApplicationPath;
+import jakarta.ws.rs.core.Application;
+
+@ApplicationPath("")
+public class RestApplication extends Application {
+}
+```
+
+## Add the endpoint
+
+And we are adding a simple 'Hello World' endpoint that is listening on the
+`/helloworld` path.
+
+```java
+package rest;
+
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+
+@Path("/helloworld")
+@RequestScoped
+public class HelloWorldBean {
+
+ @GET
+ public String helloWorld() {
+ return "Hello World!";
+ }
+}
+```
+
+## Add the NetBeans nbactions-default.xml
+
+To integrate debugging into the NetBeans IDE we'll create the `nbactions-default.xml` file in the root directory of your Maven project. It should contain the content as below.
+
+```xml
+
+
+
+
+ debug
+
+ war
+ ear
+ ejb
+
+
+ package
+ pre-integration-test
+
+
+ true
+ true
+
+
+ debug
+
+
+
+```
+
+## Debug the application
+
+Open the `HelloWorldBean.java` file and set a breakpoint on the line where
+the `Hello World` response is returned.
+
+Then right click on your project node and select `Debug`.
+
+After a short while you will see NetBeans change to the debugger view and the threads of your running application will appear.
+
+Then browse to `http://localhost:8080/rest/helloworld/`.
+
+Now you'll see it hit your breakpoint.
+
+## Conclusion
+
+Setting up debugging for NetBeans requires a little bit of plumbing, but once
+the Maven profile and the NetBeans nbactions-default.xml file are in place you
+are set!
+
+## References
+
+1. [Piranha Core Profile](index.html)
+1. [Piranha Maven plugin documentation](../maven-plugin/index.html)
+
diff --git a/docs/src/site/markdown/coreprofile/debugging_a_rest_service_with_vscode.md b/docs/src/site/markdown/coreprofile/debugging_a_rest_service_with_vscode.md
new file mode 100644
index 0000000000..890e0a5d9e
--- /dev/null
+++ b/docs/src/site/markdown/coreprofile/debugging_a_rest_service_with_vscode.md
@@ -0,0 +1,256 @@
+# Debugging a REST service with VSCode
+
+If you are looking to debug a REST service with VSCode then follow along!
+
+In 6 steps you will learn how to start debugging the REST service. They are:
+
+1. Create the Maven POM file
+1. Add the application class
+1. Add the endpoint
+1. Add the VSCode tasks.json file
+1. Add the VSCode launch.json file
+1. Debug the application
+
+## Create the Maven POM file
+
+Create an empty directory to store your Maven project. Inside of that directory
+create the ```pom.xml``` file with the content as below.
+
+```xml
+
+
+
+ 4.0.0
+ cloud.piranha.guides.coreprofile
+ vscode-debug
+ 1-SNAPSHOT
+ war
+ Piranha Core Profile - Debugging a REST service with VSCode
+
+ 10.0.0
+ 17
+ 5.10.0-M1
+ 3.11.0
+ 3.0.0
+ 3.3.2
+ 23.6.0
+ UTF-8
+
+
+
+ jakarta.platform
+ jakarta.jakartaee-core-api
+ ${jakartaee.version}
+ provided
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-params
+ ${junit.version}
+ test
+
+
+
+ rest
+
+
+ cloud.piranha.maven.plugins
+ piranha-maven-plugin
+ ${piranha.version}
+
+
+ pre-integration-test
+ pre-integration-test
+
+ start
+
+
+
+ post-integration-test
+ post-integration-test
+
+ stop
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ ${maven-compiler-plugin.version}
+
+ ${java.version}
+
+
+
+ org.apache.maven.plugins
+ maven-failsafe-plugin
+ ${maven-failsafe-plugin.version}
+
+
+
+ integration-test
+ verify
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-war-plugin
+ ${maven-war-plugin.version}
+
+ false
+
+
+
+
+
+
+ debug
+
+
+
+ cloud.piranha.maven.plugins
+ piranha-maven-plugin
+ ${piranha.version}
+
+ -Xdebug -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=9009
+
+
+
+
+
+
+
+```
+
+Note the POM file contains a `debug` profile in the profiles section that
+we will leverage later on to activate the VSCode debugging.
+
+## Add the application class
+
+Add the Application class in the `src/main/java` directory, which allows you to
+set the application path using the @ApplicationPath annotation.
+
+```java
+package rest;
+
+import jakarta.ws.rs.ApplicationPath;
+import jakarta.ws.rs.core.Application;
+
+@ApplicationPath("")
+public class RestApplication extends Application {
+}
+```
+
+## Add the endpoint
+
+And we are adding a simple 'Hello World' endpoint that is listening on the
+`/helloworld` path.
+
+```java
+package rest;
+
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+
+@Path("/helloworld")
+@RequestScoped
+public class HelloWorldBean {
+
+ @GET
+ public String helloWorld() {
+ return "Hello World!";
+ }
+}
+```
+
+## Add the VSCode tasks.json file
+
+To integrate debugging into VSCode we'll need a tasks.json file that will
+trigger the proper Maven goals BEFORE we start the debugger. For that
+lets first create the `.vscode` directory in the root directory of your
+Maven project (if it does not exist). And then we will create the
+`tasks.json` file in the `.vscode` directory. It should contain the content
+as below.
+
+```json
+{
+ "version": "2.0.0",
+ "tasks": [
+ {
+ "label": "Start",
+ "type": "shell",
+ "command": "mvn -Pdebug package pre-integration-test",
+ "isBackground": true,
+ "problemMatcher": "$tsc-watch",
+ }
+ ]
+}
+```
+
+## Add the VSCode launch.json file
+
+The next step is to configure the `launch.json` file to allow it to
+attach to the REST service after it gets started by means of the
+`Start` entry in the `tasks.json` file.
+
+For that we will create the `tasks.json` file in the `.vscode` directory
+with the content as below.
+
+```json
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "type": "java",
+ "name": "Debug",
+ "preLaunchTask": "Start",
+ "request": "attach",
+ "hostName": "localhost",
+ "port": "9009"
+ }
+ ]
+}
+```
+
+## Debug the application
+
+Open the `HelloWorldBean.java` file and set a breakpoint on the line where
+the `Hello World` response is returned.
+
+Then on your left bar click on the `Debug` icon.
+
+And make sure that `Debug` is selected and click the run icon to the left of it.
+
+Then browse to `http://localhost:8080/rest/helloworld/`.
+
+Now you'll see it hit your breakpoint.
+
+## Conclusion
+
+Setting up debugging for VSCode requires a little bit of plumbing, but once
+the Maven profile, the VSCode `tasks.json` and `launch.json` files are in
+place it all comes together nicely!
+
+## References
+
+1. [Piranha Core Profile](index.html)
+1. [Piranha Maven plugin documentation](../maven-plugin/index.html)
diff --git a/docs/src/site/markdown/coreprofile/index.md b/docs/src/site/markdown/coreprofile/index.md
index 5d8d4c2fae..10e1a30683 100644
--- a/docs/src/site/markdown/coreprofile/index.md
+++ b/docs/src/site/markdown/coreprofile/index.md
@@ -18,8 +18,12 @@ The following components are available in the Piranha Core Profile distribution:
1. [Create a REST service](create_a_rest_service.html)
1. [Create a JSON REST service](create_a_json_rest_service.html)
-1. [Jakarta EE 10 Core Profile Specification](https://jakarta.ee/specifications/coreprofile/10/jakarta-coreprofile-spec-10.0.pdf)
-1. [Jakarta EE 10 Core Profile API documentation](https://jakarta.ee/specifications/coreprofile/10/apidocs/)
+1. [Debugging a REST service with NetBeans](debugging_a_rest_service_with_netbeans.html)
+1. [Debugging a REST service with VSCode](debugging_a_rest_service_with_vscode.html)
+1. [Testing with JUnit 5 and Arquillian](testing_with_junit5_and_arquillian.html)
+1. [Using Project CRaC](using_project_crac.html)
+## External documentation
-[Up](../index.html)
+1. [Jakarta EE 10 Core Profile Specification](https://jakarta.ee/specifications/coreprofile/10/jakarta-coreprofile-spec-10.0.pdf)
+1. [Jakarta EE 10 Core Profile API documentation](https://jakarta.ee/specifications/coreprofile/10/apidocs/)
diff --git a/docs/src/site/markdown/coreprofile/testing_with_junit5_and_arquillian.md b/docs/src/site/markdown/coreprofile/testing_with_junit5_and_arquillian.md
new file mode 100644
index 0000000000..d75971dc8b
--- /dev/null
+++ b/docs/src/site/markdown/coreprofile/testing_with_junit5_and_arquillian.md
@@ -0,0 +1,232 @@
+# Testing with JUnit 5 and Arquillian
+
+If you are looking to test with JUnit 5 and Arqullien then this guide is for you!
+
+In 5 steps you will learn how to do it.
+
+They are:
+
+1. Create the Maven POM file
+1. Add the application class
+1. Add the endpoint
+1. Add an integration test
+1. Test the application
+
+## Create the Maven POM file
+
+Create an empty directory to store your Maven project. Inside of that directory create the ```pom.xml``` file with the content as below.
+
+```xml
+
+
+
+ 4.0.0
+ cloud.piranha.guides.coreprofile
+ arquillian
+ 1-SNAPSHOT
+ war
+ Piranha Core Profile - Testing with JUnit 5 and Arquillian
+
+ 1.7.0.Final
+ 10.0.0
+ 17
+ 5.10.0-M1
+ 3.11.0
+ 3.0.0
+ 3.3.2
+ 23.6.0
+ UTF-8
+
+
+
+ jakarta.platform
+ jakarta.jakartaee-core-api
+ ${jakartaee.version}
+ provided
+
+
+ cloud.piranha.arquillian
+ piranha-arquillian-jarcontainer
+ ${piranha.version}
+ test
+
+
+ org.jboss.arquillian.junit5
+ arquillian-junit5-container
+ ${arquillian.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-params
+ ${junit.version}
+ test
+
+
+
+ arquillian
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ ${maven-compiler-plugin.version}
+
+ ${java.version}
+
+
+
+ org.apache.maven.plugins
+ maven-failsafe-plugin
+ ${maven-failsafe-plugin.version}
+
+
+ integration-test
+ integration-test
+
+ integration-test
+ verify
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-war-plugin
+ ${maven-war-plugin.version}
+
+ false
+
+
+
+
+
+```
+
+## Add the application class
+
+Add the Application class in the `src/main/java` directory, which allows you to set the application path using the @ApplicationPath annotation.
+
+```java
+package arquillian;
+
+import jakarta.ws.rs.ApplicationPath;
+import jakarta.ws.rs.core.Application;
+
+@ApplicationPath("")
+public class HelloArquillianApplication extends Application {
+}
+```
+
+## Add the endpoint
+
+And we are adding a simple 'Hello World' endpoint that is listening on the `/helloworld` path.
+
+```java
+package arquillian;
+
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+
+@Path("/helloarquillian")
+@RequestScoped
+public class HelloArquillianBean {
+
+ @GET
+ public String helloArquillian() {
+ return "Hello Arquillian!";
+ }
+}
+```
+
+## Add an integration test
+
+As we want to make sure the application gets tested before we release an
+integration test is added which will be executed as part of the build.
+
+We'll add the integration test to the `src/test/java` directory.
+
+```java
+package helloarquillian;
+
+import arquillian.HelloArquillianApplication;
+import arquillian.HelloArquillianBean;
+import java.net.URI;
+import java.net.URL;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.container.test.api.RunAsClient;
+import org.jboss.arquillian.junit5.ArquillianExtension;
+import org.jboss.arquillian.test.api.ArquillianResource;
+import static org.jboss.shrinkwrap.api.ShrinkWrap.create;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@ExtendWith(ArquillianExtension.class)
+public class HelloArquillianIT {
+
+ @ArquillianResource
+ private URL baseUrl;
+
+ @Deployment(testable = false)
+ public static WebArchive createDeployment() {
+ return create(WebArchive.class)
+ .addClass(HelloArquillianApplication.class)
+ .addClass(HelloArquillianBean.class);
+ }
+
+ @Test
+ @RunAsClient
+ public void testHelloArquillian() throws Exception {
+ HttpClient client = HttpClient.newHttpClient();
+ HttpRequest request = HttpRequest
+ .newBuilder(new URI(baseUrl + "helloarquillian"))
+ .build();
+ HttpResponse response = client.send(request, BodyHandlers.ofString());
+ assertTrue(response.body().contains("Hello Arquillian!"));
+ }
+}
+```
+
+## Test the application
+
+The application is now setup to use JUnit 5 and Arquillian to do the integration
+testing. So when you are building the application it will also execute an
+integration test validating the endpoint works.
+
+To build and test the application execute the following command:
+
+```bash
+ mvn install
+```
+
+## Conclusion
+
+As you can see using JUnit 5 and Arquillian is pretty straightforward!
+
+## References
+
+1. [Piranha Core Profile](index.html)
+1. [Arquillian](https://arquillian.org/)
+
+[Up](index.html)
diff --git a/docs/src/site/markdown/coreprofile/using_project_crac.md b/docs/src/site/markdown/coreprofile/using_project_crac.md
new file mode 100644
index 0000000000..8c3acc1dab
--- /dev/null
+++ b/docs/src/site/markdown/coreprofile/using_project_crac.md
@@ -0,0 +1,259 @@
+# Using Project CRaC
+
+If you are looking to get CRaC-ing with Piranha Servlet you can follow along!
+
+_Make sure you are using a CRaC enabled JDK available from
+https://github.com/CRaC/openjdk-builds/releases or from any vendor that delivers
+a CRaC capable OpenJDK distribution._
+
+In 8 steps you will learn how to deploy CRaC with Piranha Servlet. They are:
+
+1. Create the Maven POM file
+1. Add the application class
+1. Add the endpoint
+1. Add an integration test
+1. Test the application
+1. Start the application
+1. Create the checkpoint
+1. Restart the application
+
+## Create the Maven POM file
+
+Create an empty directory to store your Maven project. Inside of that directory
+create the ```pom.xml``` file with the content as below.
+
+```xml
+
+
+
+ 4.0.0
+ cloud.piranha.guides.crac
+ crac
+ 24.8.0-SNAPSHOT
+ war
+ Piranha Core Profile on Project CRaC
+
+
+ 10.0.0
+ 5.11.0-M2
+ 24.7.0
+
+ 21
+ UTF-8
+
+ 3.13.0
+ 3.3.1
+ 3.4.0
+
+
+
+ jakarta.platform
+ jakarta.jakartaee-core-api
+ ${jakartaee.version}
+ provided
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ ${junit.version}
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-params
+ ${junit.version}
+ test
+
+
+
+ crac
+
+
+ cloud.piranha.maven.plugins
+ piranha-maven-plugin
+ ${piranha.version}
+
+
+ pre-integration-test
+ pre-integration-test
+
+ start
+
+
+
+ post-integration-test
+ post-integration-test
+
+ stop
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ ${maven-compiler-plugin.version}
+
+ ${java.version}
+
+
+
+ org.apache.maven.plugins
+ maven-failsafe-plugin
+ ${maven-failsafe-plugin.version}
+
+
+
+ integration-test
+ verify
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-war-plugin
+ ${maven-war-plugin.version}
+
+ false
+
+
+
+
+
+```
+
+## Add the application class
+
+Add the Application class in the `src/main/java` directory, which allows you to set the application path using the @ApplicationPath annotation.
+
+```java
+package rest;
+
+import jakarta.ws.rs.ApplicationPath;
+import jakarta.ws.rs.core.Application;
+
+@ApplicationPath("")
+public class RestApplication extends Application {
+}
+```
+
+## Add the endpoint
+
+And we are adding a simple 'Hello World' endpoint that is listening on the `/helloworld` path.
+
+```java
+package rest;
+
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+
+@Path("/helloworld")
+@RequestScoped
+public class HelloWorldBean {
+
+ @GET
+ public String helloWorld() {
+ return "Hello World!";
+ }
+}
+```
+
+## Add an integration test
+
+As we want to make sure the application gets tested before we release an
+integration test is added which will be executed as part of the build.
+
+We'll add the integration test to the `src/test/java` directory.
+
+```java
+package rest;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+class HelloWorldIT {
+
+ @Test
+ void testHelloWorld() throws Exception {
+ HttpClient client = HttpClient.newHttpClient();
+ HttpRequest request = HttpRequest
+ .newBuilder(new URI("http://localhost:8080/crac/helloworld"))
+ .build();
+ HttpResponse response = client.send(request, BodyHandlers.ofString());
+ assertTrue(response.body().contains("Hello World!"));
+ }
+}
+
+```
+
+## Test the application
+
+The application is setup to use JUnit to do integration testing using the Piranha Maven plugin so when you are building the application it will also execute an integration test validating the endpoint works.
+
+To build and test the application execute the following command:
+
+```bash
+ mvn install
+```
+
+## Deploy the application
+
+To deploy your application you will need 2 pieces.
+
+1. The Piranha Core Profile runtime JAR.
+2. The WAR file you just produced.
+
+For the WAR file see the `target` directory. For the Piranha Core Profile
+distribution go to Maven Central. And then the following command line will
+deploy your application:
+
+```bash
+ java -XX:CRaCCheckpointTo=cr -jar piranha-dist-coreprofile.jar --enable-crac --write-pid --war-file crac.war &
+```
+
+## Create the checkpoint
+
+You have your application currently running so now it is time to create a
+checkpoint.
+
+To ask the JVM to create a checkpoint use the command line below:
+
+```bash
+ jcmd piranha-dist-coreprofile.jar JDK.checkpoint
+```
+
+The application will exit and the chechkpoint files are in the `cr` directory.
+
+## Restart the application
+
+To restart the application for the checkpoint you can use the following command
+line:
+
+```bash
+ java -XX:CRaCRestoreFrom=cr
+```
+
+## Conclusion
+
+As you can see using CRaC with Piranha Core Profile is matter of the right JDK
+and the right command line switch.
+
+## References
+
+1. [CRaC Project](https://wiki.openjdk.org/display/crac/Main)
diff --git a/docs/src/site/markdown/index.md b/docs/src/site/markdown/index.md
index 1d365a63ff..f7afbfef1d 100644
--- a/docs/src/site/markdown/index.md
+++ b/docs/src/site/markdown/index.md
@@ -28,7 +28,7 @@ distribution supports see our [Jakarta EE / Micro Profile matrix](https://piranh
## Distribution specific documentation
-* [Piranha Core Profile](https://piranha.cloud/core-profile/index.html)
+* [Piranha Core Profile](coreprofile/index.html)
* [Piranha Embedded](https://piranha.cloud/embedded/index.html)
* [Piranha Servlet](https://piranha.cloud/servlet/index.html)
* [Piranha Server](https://piranha.cloud/server/index.html)
diff --git a/docs/src/site/site.xml b/docs/src/site/site.xml
index 836d1933b3..bb5fc16f3e 100644
--- a/docs/src/site/site.xml
+++ b/docs/src/site/site.xml
@@ -1,6 +1,16 @@
-
+
-
+
+
+ Piranha
+
+
+ A cloud native extensible runtime
+
@@ -24,6 +38,9 @@
+
+
+
org.apache.maven.skins