 -----
 Doxia Formats
 -----
 Hervé Boutemy
 -----
 2015-12-20
 -----

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Doxia Formats

  See {{{http://maven.apache.org/doxia/references/index.html} Doxia Markup Languages References}} for a list of
  Markup Languages that support Doxia Parser.

  By default, only the following are integrated into maven-site-plugin:

*--------------------*-------------------------------------------------------*-----------------------------------*
|| Format            || plain                                                || macro                            ||
*--------------------+-------------------------------------------------------+-----------------------------------+
| Apt                | {{{./index.html} <<<apt/*.apt>>>}}                    | {{{./apt-macro.html} macro}}      |
*--------------------+-------------------------------------------------------+-----------------------------------+
| FML                | {{{./faq.html} <<<fml/*.fml>>>}}                      | {{{./faq-macro.html} macro}}      |
*--------------------+-------------------------------------------------------+-----------------------------------+
| Markdown           | {{{./markdown.html} <<<markdown/*.md>>>}}             | {{{./markdown-macro.html} macro}} |
|                    | {{{./markdown2.html} <<<markdown/*.markdown>>>}}      | {{{./markdown2-macro.html} macro}}|
*--------------------+-------------------------------------------------------+-----------------------------------+
| Xdoc               | {{{./xdoc.html} <<<xdoc/*.xml>>>}}                    | {{{./xdoc-macro.html} macro}}     |
*--------------------+-------------------------------------------------------+-----------------------------------+
| XHTML              | {{{./xhtml.html} <<<xhtml/*.xhtml>>>}}                | {{{./xhtml-macro.html} macro}}    |
*--------------------+-------------------------------------------------------+-----------------------------------+

  Other formats, either provided by Doxia itself (Confluence, Simplified DocBook, TWiki)
  or tierce parties ({{{http://asciidoctor.org/docs/asciidoctor-maven-plugin/#maven-site-integration} AsciiDoc}}),
  require to explicitely add a dependency to maven-site-plugin when using it.

Velocity

  See {{{./velocity-context.html} Doxia Site Renderer Velocity Context demo}}.

  See also {{{./velocity-include-parse.html} Velocity #parse and #include demo}}.

Reference output

  <<<Monospaced>>>

+--------+
code block
Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Maven home: D:\apache-maven-3.6.3\apache-maven\bin\..
Java version: 1.8.0_232, vendor: AdoptOpenJDK, runtime: C:\Program Files\AdoptOpenJDK\jdk-8.0.232.09-hotspot\jre
Default locale: en_US, platform encoding: Cp1250
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"
+--------+