Exclude user guides from mkdocs documentation (#2868)

16 files changed, 56 insertions, 1278 deletions

diff --git a/mkdocs/README.md b/mkdocs/README.md
new file mode 100644
index 00000000..c8d07370
--- /dev/null
+++ b/mkdocs/README.md
@@ -0,0 +1,33 @@
+# MkDocs documentation
+
+This module contains documentation which is published to GitHub pages: 
+[kotlin.github.io/dokka](https://kotlin.github.io/dokka/).
+
+It is built using the [gradle-mkdocs-plugin](https://github.com/xvik/gradle-mkdocs-plugin).
+
+## Building
+
+You can build the documentation locally:
+
+```Bash
+./gradlew :mkdocs:mkdocsBuild
+```
+
+The output directory is `build/mkdocs`
+
+### Livereload server
+
+Alternatively, you can run a livereload server that automatically rebuilds documentation on every change:
+
+```Bash
+./gradlew :mkdocs:mkdocsServe
+```
+
+By default, it is run under [127.0.0.1:3001](http://127.0.0.1:3001/), but you can change it in 
+[mkdocs.yml](src/doc/mkdocs.yml) by setting the `dev_addr` option.
+
+## Publishing
+
+The documentation is published automatically for all changes in master and for every GitHub release.
+
+See [gh-pages.yml](../.github/workflows/gh-pages.yml) workflow configuration for more details.
diff --git a/mkdocs/src/doc/docs/community/plugins-list.md b/mkdocs/src/doc/docs/community/plugins-list.md
deleted file mode 100644
index 6ae8ce4c..00000000
--- a/mkdocs/src/doc/docs/community/plugins-list.md
+++ /dev/null
@@ -1,160 +0,0 @@
-# Dokka community plugins
-
-On this page you can find `Dokka` plugins which are supported by both `Dokka` maintainers and community members.
-
-If you want to add your plugin to this list, get in touch with maintainers via [Slack](../community/slack.md)
-or `GitHub`.
-
-If you want to learn how to develop plugins for `Dokka`, see 
-[Plugin development](../developer_guide/plugin-development/introduction.md) section.
-
-## Output Formats
-
-### Javadoc (Alpha)
-
-Javadoc plugin adds a `Javadoc` output format that looks like Java's `Javadoc`, but it's for the most part
-a lookalike, so you may experience problems if you try to use it with a tool that expects native
-`Javadoc` documentation generated by `Java`.
-
-`Javadoc` plugin does not support multiplatform projects and does not have a multi-module task.
-
-`Javadoc` plugin is shipped with `Dokka`, so you can start using it right away with one of the following tasks:
-
-* `dokkaJavadoc` - builds `Javadoc` documentation for single-module projects or for a specific module.
-* `dokkaJavadocCollector` - collects generated `Javadoc` documentation from submodules and assembles it together.
-
-`Javadoc` plugin has its own signature provider that essentially translates `Kotlin` signatures to `Java` ones.
-
-**This plugin is at its early stages**, so you may experience issues and encounter bugs. Feel free to
-[report](https://github.com/Kotlin/dokka/issues/new/choose) any errors you see.
-
-[Plugin source code on GitHub](https://github.com/Kotlin/dokka/tree/master/plugins/javadoc)
-
-### GFM (Alpha)
-
-`GFM` plugins adds the ability to generate documentation in `GitHub flavoured Markdown` format. Supports both
-multimodule and multiplatform projects, and is shipped together with `Dokka`, so you can start using it
-right away with one of the following tasks:
-
-* `dokkaGfm` - generate documentation for a non multi-module project or one specific module.
-* `dokkaGfmMultiModule` - generate documentation for a multi-module project, assemble it together and
-  generate navigation page/menu for all the modules.
-
-Example:
-
-___
-
-//[dokka-debug-kts](#gfm)/[org.jetbrains.dokka.test](#gfm)/[MyClass](#gfm)
-
-#### MyClass
-
-[jvm]
-class [MyClass](#gfm)
-
-KDoc that describes this class
-
-##### Constructors
-
-| | |
-|---|---|
-| [MyClass](#gfm) | [jvm]<br>fun [MyClass](#gfm)() |
-
-##### Functions
-
-| Name             | Summary |
-|------------------|---|
-| [function](#gfm) | [jvm]<br>fun [function](#gfm)(): [String](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html)<br>KDoc comment on top of this function |
-
-##### Properties
-
-| Name | Summary                                                                                                                                        |
-|---|------------------------------------------------------------------------------------------------------------------------------------------------|
-| [property](#gfm) | [jvm]<br>val [property](#gfm): [String](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html)<br>KDoc comment for a property |
-
-___
-
-**This plugin is at its early stages**, so you may experience issues and encounter bugs. Feel free to 
-[report](https://github.com/Kotlin/dokka/issues/new/choose) any errors you see.
-
-[Plugin source code on GitHub](https://github.com/Kotlin/dokka/tree/master/plugins/gfm)
-
-### Jekyll (Alpha)
-
-`Jekyll` plugins adds the ability to generate documentation in `Jekyll flavoured Markdown` format. Supports both
-multi-module and multiplatform projects, and is shipped together with `Dokka`, so you can start using it
-right away with one of the following tasks:
-
-* `dokkaJekyll` - generate documentation for a non multi-module project or one specific module.
-* `dokkaJekyllMultiModule` - generate documentation for a multi-module project, assemble it together and
-  generate navigation page/menu for all the modules.
-
-**This plugin is at its early stages**, so you may experience issues and encounter bugs. Feel free to
-[report](https://github.com/Kotlin/dokka/issues/new/choose) any errors you see.
-
-[Plugin source code on GitHub](https://github.com/Kotlin/dokka/tree/master/plugins/jekyll)
-
-## Extensions
-
-### Mathjax
-
-[MathJax](https://docs.mathjax.org/) allows you to include mathematics in your web pages. `MathJax` plugin
-adds the ability to render mathematics from source code comments.
-
-If `MathJax` plugin encounters `@usesMathJax` `KDoc` tag, it adds `MathJax.js` (ver. 2) with `config=TeX-AMS_SVG`
-to generated `HTML` pages.
-
-Usage example:
-```kotlin
-/**
- * Some math \(\sqrt{3x-1}+(1+x)^2\)
- * 
- * @usesMathJax
- */
-class Foo {}
-```
-
-Which results in:
-
-![Mathjax demo](../images/mathjax_demo.png){ width="400" }
-
-[Plugin source code on GitHub](https://github.com/Kotlin/dokka/tree/master/plugins/mathjax)
-
-### Mermaid
-
-[Mermaid JS](https://mermaid-js.github.io/mermaid/#/) lets you create diagrams and visualizations using text and code. 
-`Mermaid` plugin allows rendering such diagrams and visualizations found in source code documentation.
-
-Usage example:
-```kotlin
-/**
- * See the graph for more details:
- * \```mermaid
- * graph LR
- *   A[Christmas] -->|Get money| B(Go shopping)
- *   B --> C{Let me think}
- *   C -->|One| D[Laptop]
- *   C -->|Two| E[iPhone]
- *   C -->|Three| F[fa:fa-car Car]
- * \```
- */
-class CompositeSubscription
-```
-
-Which results in:
-
-![Mermaid demo](../images/mermaid_demo.png){ width="700" }
-
-For more information and examples, see 
-[Html Mermaid Dokka plugin](https://github.com/glureau/dokka-mermaid) repository on GitHub.
-
-### Kotlin as Java
-
-With `Kotlin as Java` plugin applied, all `Kotlin` signatures will be rendered as `Java` signatures. 
-
-For instance, `fun foo(bar: Bar): Baz` will be rendered as `public final Baz foo(Bar bar)`.
-
-`Kotlin as Java` plugin is published to maven central as a 
-[separate artifact](https://mvnrepository.com/artifact/org.jetbrains.dokka/kotlin-as-java-plugin): 
-`org.jetbrains.dokka:kotlin-as-java-plugin:1.7.20`. 
-
-[Plugin source code on GitHub](https://github.com/Kotlin/dokka/tree/master/plugins/kotlin-as-java)
diff --git a/mkdocs/src/doc/docs/developer_guide/architecture/extension_points/core_extensions.md b/mkdocs/src/doc/docs/developer_guide/architecture/extension_points/core_extensions.md
index 381a9596..77ebc15e 100644
--- a/mkdocs/src/doc/docs/developer_guide/architecture/extension_points/core_extensions.md
+++ b/mkdocs/src/doc/docs/developer_guide/architecture/extension_points/core_extensions.md
@@ -147,5 +147,5 @@ and `CommonmarkRenderer`.
 `PostAction` is useful for when you want to run some actions after the documentation has been generated - for instance
 if you want to move some files around.
 
-[Versioning plugin](../../../user_guide/plugins/versioning-plugin.md) utilizes `PostAction` in order to move
+[Versioning plugin](https://github.com/Kotlin/dokka/tree/master/plugins/versioning) utilizes `PostAction` in order to move
 generated documentation to versioned folders.
diff --git a/mkdocs/src/doc/docs/developer_guide/plugin-development/introduction.md b/mkdocs/src/doc/docs/developer_guide/plugin-development/introduction.md
index fbfb32ac..6a487a5e 100644
--- a/mkdocs/src/doc/docs/developer_guide/plugin-development/introduction.md
+++ b/mkdocs/src/doc/docs/developer_guide/plugin-development/introduction.md
@@ -1,5 +1,13 @@
 # Introduction to plugin development
 
+Dokka was built from the ground up to be easily extensible and highly customizable, which allows the community to 
+implement plugins for missing or very specific features that are not provided out of the box.
+
+Dokka plugins range anywhere from supporting other programming language sources to exotic output formats. You can add 
+support for your own KDoc tags or annotations, teach Dokka how to render different DSLs that are found in KDoc 
+descriptions, visually redesign Dokka's pages to be seamlessly integrated into your company's website, integrate 
+it with other tools and so much more.
+
 In order to have an easier time developing plugins, it's a good idea to go through
 [Dokka's internals](../architecture/architecture_overview.md) first to learn more about its
 [data model](../architecture/data_model/documentables.md) and 
@@ -51,7 +59,8 @@ versions of Dokka.
 You can follow the [sample plugin tutorial](sample-plugin-tutorial.md) which covers creation of a simple plugin: hide members
 annotated with your own `@Internal` annotation, that is exclude these members from generated documentation.
 
-Fore more practical examples, have a look at sources of [community plugins](../../community/plugins-list.md).
+Fore more practical examples, have a look at sources of 
+[community plugins](https://kotlinlang.org/docs/dokka-plugins.html#notable-plugins).
 
 ## Help
 
diff --git a/mkdocs/src/doc/docs/faq.md b/mkdocs/src/doc/docs/faq.md
deleted file mode 100644
index ef728ca0..00000000
--- a/mkdocs/src/doc/docs/faq.md
+++ /dev/null
@@ -1,2 +0,0 @@
-# FAQ
-If you encounter any problems, please see [FAQ](https://github.com/Kotlin/dokka/wiki/faq).
diff --git a/mkdocs/src/doc/docs/images/mathjax_demo.png b/mkdocs/src/doc/docs/images/mathjax_demo.png
deleted file mode 100644
index 9b14a704..00000000
--- a/mkdocs/src/doc/docs/images/mathjax_demo.png
+++ /dev/null
diff --git a/mkdocs/src/doc/docs/images/mermaid_demo.png b/mkdocs/src/doc/docs/images/mermaid_demo.png
deleted file mode 100644
index 0d0e27b6..00000000
--- a/mkdocs/src/doc/docs/images/mermaid_demo.png
+++ /dev/null
diff --git a/mkdocs/src/doc/docs/index.md b/mkdocs/src/doc/docs/index.md
index 0f106c04..2cedfe35 100644
--- a/mkdocs/src/doc/docs/index.md
+++ b/mkdocs/src/doc/docs/index.md
@@ -1,38 +1,9 @@
 # Dokka 
 
-`Dokka` is an API documentation engine for `Kotlin` that performs the same function as the `Javadoc` tool for `Java`,
-but it's modern and highly pluggable.
+Dokka is an API documentation engine for Kotlin.
 
-Just like `Kotlin` itself, `Dokka` supports mixed-language projects (`Kotlin`/`Java`). It understands
-[KDoc comments](https://kotlinlang.org/docs/reference/kotlin-doc.html) in `Kotlin` source files as well
-as [Javadoc comments](https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html#format) in `Java` 
-files, and can generate documentation in multiple formats including its own `HTML` format, Java's `Javadoc` lookalike
-and `Markdown`.
+If you want to learn how to use Dokka, see 
+[documentation on kotlinlang.org](https://kotlinlang.org/docs/dokka-introduction.html).
 
-Some libraries that use `Dokka` for API reference docs:
-
-* [kotlinx.coroutines](https://kotlinlang.org/api/kotlinx.coroutines/)
-* [kotlinx.serialization](https://kotlinlang.org/api/kotlinx.serialization/)
-* [Ktor](https://api.ktor.io/)
-* [Spring Framework](https://docs.spring.io/spring-framework/docs/current/kdoc-api/)
-
-___
-
-`Dokka` provides support for the following build systems:
-
-* [Gradle](user_guide/applying/gradle.md) (preferred)
-* [Maven](user_guide/applying/maven.md)
-* [Command line](user_guide/applying/cli.md)
-
-___
-
-`Dokka` is also very pluggable and comes with convenient plugin and extension point API. 
-
-You can write a plugin to support [mermaid.js](community/plugins-list.md#mermaid) diagrams,
-[mathjax](community/plugins-list.md#mathjax) formulas or even write custom processing of your own tags and annotations.
-
-For more info, see:
-
-* [Sample plugin tutorial](developer_guide/plugin-development/sample-plugin-tutorial.md)
-* [Community plugins](community/plugins-list.md)
-* [Developer guides](developer_guide/introduction.md)
+If you want to learn more about Dokka's internals and/or how to write Dokka plugins,
+see [Developer guides](developer_guide/introduction.md).
diff --git a/mkdocs/src/doc/docs/user_guide/applying/cli.md b/mkdocs/src/doc/docs/user_guide/applying/cli.md
deleted file mode 100644
index 3b02add2..00000000
--- a/mkdocs/src/doc/docs/user_guide/applying/cli.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# Using command line
-
-To run Dokka from the command line, download the [Dokka CLI runner](https://mvnrepository.com/artifact/org.jetbrains.dokka/dokka-cli).
-To generate documentation, run the following command:
-```
-java -jar dokka-cli.jar <arguments>
-```
-
-## Configuration options
-
-Dokka supports the following command line arguments:
-
-* `-outputDir` - the output directory where the documentation is generated
-* `-moduleName` - (required) - module name used as a part of source set ID when declaring dependent source sets
-* `-cacheRoot` - cache directory to enable package-list caching
-* `-pluginsClasspath` - artifacts with Dokka plugins, separated by `;`. At least `dokka-base` and all its dependencies must be added there
-* `-pluginsConfiguration` - configuration for plugins in format `fqPluginName=json^^fqPluginName=json...`
-* `-offlineMode` - do not resolve package-lists online
-* `-failOnWarning` - throw an exception instead of a warning
-* `-globalPackageOptions` - per package options added to all source sets
-* `-globalLinks` - external documentation links added to all source sets
-* `-globalSrcLink` - source links added to all source sets
-* `-noSuppressObviousFunctions` - don't suppress obvious functions like default `toString` or `equals`
-* `-suppressInheritedMembers` - suppress all inherited members that were not overriden in a given class. Eg. using it you can suppress toString or equals functions but you can't suppress componentN or copy on data class
-* `-sourceSet` - (repeatable) - configuration for a single source set. Following this argument, you can pass other arguments:
-    * `-sourceSetName` - source set name as a part of source set ID when declaring dependent source sets
-    * `-displayName` - source set name displayed in the generated documentation
-    * `-src` - list of source files or directories separated by `;`
-    * `-classpath` - list of directories or .jar files to include in the classpath (used for resolving references) separated by `;`
-    * `-samples` - list of directories containing sample code (documentation for those directories is not generated but declarations from them can be referenced using the `@sample` tag) separated by `;`
-    * `-includes` - list of files containing the documentation for the module and individual packages separated by `;`
-    * `-includeNonPublic` - **Deprecated**, prefer using `documentedVisibilities`. Include protected and private code
-    * `-documentedVisibilities` - a list of visibility modifiers (separated by `;`) that should be documented. Overrides `includeNonPublic`. Default is `PUBLIC`. Possible values: `PUBLIC`, `PRIVATE`, `PROTECTED`, `INTERNAL` (Kotlin-specific), `PACKAGE` (Java-specific package-private)
-    * `-skipDeprecated` - if set, deprecated elements are not included in the generated documentation
-    * `-reportUndocumented` - warn about undocumented members
-    * `-noSkipEmptyPackages` - create index pages for empty packages
-    * `-perPackageOptions` - list of package options in format `matchingRegex,-deprecated,-privateApi,+reportUndocumented;+visibility:PRIVATE;matchingRegex, ...`, separated by `;`
-    * `-links` - list of external documentation links in format `url^packageListUrl^^url2...`, separated by `;`
-    * `-srcLink` - mapping between a source directory and a Web site for browsing the code in format `<path>=<url>[#lineSuffix]`
-    * `-noStdlibLink` - disable linking to online kotlin-stdlib documentation
-    * `-noJdkLink` - disable linking to online JDK documentation
-    * `-jdkVersion` - version of JDK to use for linking to JDK JavaDoc
-    * `-analysisPlatform` - platform used for analysis, see the [Platforms](#platforms) section
-    * `-dependentSourceSets` - list of dependent source sets in format `moduleName/sourceSetName`, separated by `;`
-* `-loggingLevel` - one of `DEBUG`, `PROGRESS`, `INFO`, `WARN`, `ERROR`. Defaults to `DEBUG`. Please note that this argument can't be passed in JSON.
-
-
-You can also use a JSON file with Dokka configuration:
- ```
- java -jar <dokka_cli.jar> <path_to_config.json>
- ```
-
-## Applying plugins
-To apply a Dokka plugin you have to provide it and all its dependencies in the `pluginsClasspath` parameter
-
-## Base plugin
-
-Using CLI runner to generate default documentation requires providing all dependencies manually on classpath.
-For Base plugins these are:
-
-* [dokka-base.jar](https://mvnrepository.com/artifact/org.jetbrains.dokka/dokka-base)
-* [dokka-analysis.jar](https://mvnrepository.com/artifact/org.jetbrains.dokka/dokka-analysis)
-* [kotlin-analysis-compiler.jar](https://mvnrepository.com/artifact/org.jetbrains.dokka/kotlin-analysis-compiler)
-* [kotlin-analysis-intellij.jar](https://mvnrepository.com/artifact/org.jetbrains.dokka/kotlin-analysis-intellij)
-* [kotlinx-html-jvm.jar](https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-html-jvm?repo=kotlinx)
-
-All of them are published on maven central. Another dependencies of Base plugin (e.g. `kotlinx-coroutines-core` and so on) are already included in `dokka-cli.jar`.
-To get them on classpath one should add them via `pluginsClasspath` argument, e. g.
-```
-java -jar dokka-cli.jar -pluginsClasspath "dokka-base.jar;dokka-analysis.jar;kotlin-analysis-compiler.jar;kotlin-analysis-intellij.jar;kotlinx-html-jvm.jar" ...
-```
-
-## Example using JSON
-
-To run Dokka with JSON configuration:
-```
-java -jar dokka-cli.jar dokkaConfiguration.json
-```
-Option values of JSON correspond to [Gradle ones](../../gradle/usage#configuration-options).
-The content of JSON file ```dokkaConfiguration.json```:
-```json
-{
-  "moduleName": "Dokka Example",
-  "moduleVersion": null,
-  "outputDir": "build/dokka/html",
-  "cacheRoot": null,
-  "offlineMode": false,
-  "sourceSets": [
-    {
-      "displayName": "jvm",
-      "sourceSetID": {
-        "scopeId": ":dokkaHtml",
-        "sourceSetName": "main"
-      },
-      "classpath": [
-        "libs/kotlin-stdlib-1.7.20.jar",
-        "libs/kotlin-stdlib-common-1.7.20.jar"
-      ],
-      "sourceRoots": [
-        "/home/Vadim.Mishenev/dokka/examples/cli/src/main/kotlin"
-      ],
-      "dependentSourceSets": [],
-      "samples": [],
-      "includes": [
-        "Module.md"
-      ],
-      "includeNonPublic": false,
-      "documentedVisibilities": ["PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "PACKAGE"],
-      "reportUndocumented": false,
-      "skipEmptyPackages": true,
-      "skipDeprecated": false,
-      "jdkVersion": 8,
-      "sourceLinks": [
-        {
-          "localDirectory": "/home/Vadim.Mishenev/dokka/examples/cli/src/main/kotlin",
-          "remoteUrl": "https://github.com/Kotlin/dokka/tree/master/examples/gradle/dokka-gradle-example/src/main/kotlin",
-          "remoteLineSuffix": "#L"
-        }
-      ],
-      "perPackageOptions": [],
-      "externalDocumentationLinks": [
-        {
-          "url": "https://docs.oracle.com/javase/8/docs/api/",
-          "packageListUrl": "https://docs.oracle.com/javase/8/docs/api/package-list"
-        },
-        {
-          "url": "https://kotlinlang.org/api/latest/jvm/stdlib/",
-          "packageListUrl": "https://kotlinlang.org/api/latest/jvm/stdlib/package-list"
-        }
-      ],
-      "noStdlibLink": false,
-      "noJdkLink": false,
-      "suppressedFiles": [],
-      "analysisPlatform": "jvm"
-    }
-  ],
-  "pluginsClasspath": [
-    "plugins/dokka-base-1.7.20.jar",
-    "libs/kotlinx-html-jvm-0.7.3.jar",
-    "libs/dokka-analysis-1.7.20.jar",
-    "libs/kotlin-analysis-intellij-1.7.20.jar",
-    "libs/kotlin-analysis-compiler-1.7.20.jar"
-  ],
-  "pluginsConfiguration": [
-    {
-      "fqPluginName": "org.jetbrains.dokka.base.DokkaBase",
-      "serializationFormat": "JSON",
-      "values": "{\"separateInheritedMembers\":false,\"footerMessage\":\"© 2021 Copyright\"}"
-    }
-  ],
-  "modules": [],
-  "failOnWarning": false,
-  "delayTemplateSubstitution": false,
-  "suppressObviousFunctions": true,
-  "includes": [],
-  "suppressInheritedMembers": false
-}
-```
diff --git a/mkdocs/src/doc/docs/user_guide/applying/gradle.md b/mkdocs/src/doc/docs/user_guide/applying/gradle.md
deleted file mode 100644
index 60ede7b9..00000000
--- a/mkdocs/src/doc/docs/user_guide/applying/gradle.md
+++ /dev/null
@@ -1,380 +0,0 @@
-# Using the Gradle plugin
-
-!!! important
-    If you are upgrading from 0.10.x to a current release of Dokka, please have a look at our
-    [migration guide](https://github.com/Kotlin/dokka/blob/master/runners/gradle-plugin/MIGRATION.md)
-
-### Supported versions
-Dokka should work on gradle newer than 5.6
-
-### Setup
-
-The preferred way is to use `plugins` block.
-
-build.gradle.kts:
-```kotlin
-plugins {
-    id("org.jetbrains.dokka") version "1.7.20"
-}
-
-repositories {
-    mavenCentral()
-}
-```
-
-You can also use the legacy plugin application method with `buildscript` block.
-Note that by using the `buildscript` way type-safe accessors are not available in Gradle Kotlin DSL,
-eg. you'll have to use `named<DokkaTask>("dokkaHtml")` instead of `dokkaHtml`:
-
-```kotlin
-buildscript {
-    dependencies {
-        classpath("org.jetbrains.dokka:dokka-gradle-plugin:${dokka_version}")
-    }
-}
-
-apply(plugin="org.jetbrains.dokka")
-```
-
-The plugin adds `dokkaHtml`, `dokkaJavadoc`, `dokkaGfm` and `dokkaJekyll` tasks to the project.
-
-Each task corresponds to one output format, so you should run `dokkaGfm` when you want to have a documentation in `GFM` format.
-Output formats are explained in [the introduction](../introduction.md#output-formats)
-
-If you encounter any problems when migrating from older versions of Dokka, please see the [FAQ](https://github.com/Kotlin/dokka/wiki/faq).
-
-Minimal configuration (with custom output directory only):
-
-Kotlin DSL
-```kotlin
-tasks.dokkaHtml.configure {
-    outputDirectory.set(buildDir.resolve("dokka"))
-}
-```
-
-
-Groovy DSL
-```groovy
-dokkaHtml {
-    outputDirectory.set(file("${buildDir}/dokka"))
-}
-```
-
-!!! note
-    Dokka extracts the information about sourcesets from the Kotlin Gradle plugin.
-    Therefore, if you are using Dokka in a [precompiled script plugin](https://docs.gradle.org/current/userguide/custom_plugins.html#sec:precompiled_plugins),
-    you will have to add a depencency to the Kotlin Gradle Plugin as well
-    (`implementation(kotlin("gradle-plugin", "<kotlin-version>"))` resp. `implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:<kotlin-version>")`).
-
-## Configuration options
-
-Dokka documents single-platform as well as multi-platform projects.
-Most of the configuration options are set per one source set.
-The available configuration options are shown below:
-
-```kotlin
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.gradle.DokkaTask
-
-val dokkaHtml by getting(DokkaTask::class) {
-    outputDirectory.set(buildDir.resolve("dokka"))
-
-    // Set module name displayed in the final output
-    moduleName.set("moduleName")
-
-    // Use default or set to custom path to cache directory
-    // to enable package-list caching
-    // When this is set to default, caches are stored in $USER_HOME/.cache/dokka
-    cacheRoot.set(file("default"))
-
-    // Suppress obvious functions like default toString or equals. Defaults to true
-    suppressObviousFunctions.set(false)
-
-    // Suppress all inherited members that were not overriden in a given class. 
-    // Eg. using it you can suppress toString or equals functions but you can't suppress componentN or copy on data class. To do that use with suppressObviousFunctions
-    // Defaults to false
-    suppressInheritedMembers.set(true)
-
-    // Used to prevent resolving package-lists online. When this option is set to true, only local files are resolved  
-    offlineMode.set(false)
-    
-    dokkaSourceSets {
-        configureEach { // Or source set name, for single-platform the default source sets are `main` and `test`
-
-            // Used when configuring source sets manually for declaring which source sets this one depends on
-            dependsOn("otherSourceSetName")
-        
-            // Used to remove a source set from documentation, test source sets are suppressed by default  
-            suppress.set(false)
-
-            // Deprecated. Prefer using documentedVisibilities.
-            includeNonPublic.set(false)
-
-            // A set of visibility modifiers that should be documented
-            // If set by user, overrides includeNonPublic. Default is PUBLIC
-            documentedVisibilities.set(
-                setOf(
-                    DokkaConfiguration.Visibility.PUBLIC, // Same for both Kotlin and Java
-                    DokkaConfiguration.Visibility.PRIVATE, // Same for both Kotlin and Java
-                    DokkaConfiguration.Visibility.PROTECTED, // Same for both Kotlin and Java
-                    DokkaConfiguration.Visibility.INTERNAL, // Kotlin-specific internal modifier
-                    DokkaConfiguration.Visibility.PACKAGE, // Java-specific package-private visibility
-                )
-            )
-
-            // Do not output deprecated members. Applies globally, can be overridden by packageOptions
-            skipDeprecated.set(false)
-
-            // Emit warnings about not documented members. Applies globally, also can be overridden by packageOptions
-            reportUndocumented.set(true)
-
-            // Do not create index pages for empty packages
-            skipEmptyPackages.set(true)
-
-            // This name will be shown in the final output
-            displayName.set("JVM")
-
-            // Platform used for code analysis. See the "Platforms" section of this readme
-            platform.set(org.jetbrains.dokka.Platform.jvm)
-
-            // Property used for manual addition of files to the classpath
-            // This property does not override the classpath collected automatically but appends to it
-            classpath.from(file("libs/dependency.jar"))
-
-            // List of files with module and package documentation
-            // https://kotlinlang.org/docs/reference/dokka-module-and-package-docs.html
-            includes.from("packages.md", "extra.md")
-
-            // List of files or directories containing sample code (referenced with @sample tags)
-            samples.from("samples/basic.kt", "samples/advanced.kt")
-
-            // By default, sourceRoots are taken from Kotlin Plugin and kotlinTasks, following roots will be appended to them
-            // Repeat for multiple sourceRoots
-            sourceRoots.from(file("src"))
-
-            // Specifies the location of the project source code on the Web.
-            // If provided, Dokka generates "source" links for each declaration.
-            // Repeat for multiple mappings
-            sourceLink {
-                // Unix based directory relative path to the root of the project (where you execute gradle respectively). 
-                localDirectory.set(file("src/main/kotlin"))
-
-                // URL showing where the source code can be accessed through the web browser
-                remoteUrl.set(java.net.URL(
-                    "https://github.com/cy6erGn0m/vertx3-lang-kotlin/blob/master/src/main/kotlin"))
-                // Suffix which is used to append the line number to the URL. Use #L for GitHub
-                remoteLineSuffix.set("#L")
-            }
-
-            // Used for linking to JDK documentation
-            jdkVersion.set(8)
-
-            // Disable linking to online kotlin-stdlib documentation
-            noStdlibLink.set(false)
-
-            // Disable linking to online JDK documentation
-            noJdkLink.set(false)
-
-            // Disable linking to online Android documentation (only applicable for Android projects)
-            noAndroidSdkLink.set(false)
-
-            // Allows linking to documentation of the project"s dependencies (generated with Javadoc or Dokka)
-            // Repeat for multiple links
-            externalDocumentationLink {
-                // Root URL of the generated documentation to link with. The trailing slash is required!
-                url.set(URL("https://example.com/docs/"))
-
-                // If package-list file is located in non-standard location
-                // packageListUrl = URL("file:///home/user/localdocs/package-list")
-            }
-
-            // Allows to customize documentation generation options on a per-package basis
-            // Repeat for multiple packageOptions
-            // If multiple packages match the same matchingRegex, the longest matchingRegex will be used
-            perPackageOption {
-                // will match kotlin and all sub-packages of it
-                matchingRegex.set("kotlin($|\\.).*") 
-                
-                // All options are optional
-                skipDeprecated.set(false)
-                reportUndocumented.set(true) // Emit warnings about not documented members 
-                includeNonPublic.set(false) // Deprecated, prefer using documentedVisibilities
-
-                // Visibilities that should be included in the documentation
-                // If set by user, overrides includeNonPublic. Default is PUBLIC
-                documentedVisibilities.set(
-                    setOf(
-                        DokkaConfiguration.Visibility.PUBLIC, // Same for both Kotlin and Java
-                        DokkaConfiguration.Visibility.PRIVATE, // Same for both Kotlin and Java
-                        DokkaConfiguration.Visibility.PROTECTED, // Same for both Kotlin and Java
-                        DokkaConfiguration.Visibility.INTERNAL, // Kotlin-specific internal modifier
-                        DokkaConfiguration.Visibility.PACKAGE, // Java-specific package-private visibility
-                    )
-                )
-            }
-            // Suppress a package
-            perPackageOption {
-                matchingRegex.set(""".*\.internal.*""") // will match all .internal packages and sub-packages 
-                suppress.set(true)
-            }
-
-            // Include generated files in documentation
-            // By default Dokka will omit all files in folder named generated that is a child of buildDir
-            suppressGeneratedFiles.set(false)
-        }
-        // Configures a plugin separately from the global configuration
-        pluginConfiguration<PluginClass, ConfigurationClass>{
-            // values
-        }
-    }
-}
-```
-
-## Multiplatform
-Dokka supports single-platform and multi-platform projects using source sets abstraction. For most mutli-platform projects
-you should assume that Dokka's source sets correspond to Kotlin plugin's source sets. All source sets are by default registered
-and configured automatically although test source sets are suppressed
-
-Kotlin
-```kotlin
-kotlin {  // Kotlin Multiplatform plugin configuration
-    jvm()
-    js("customName")
-}
-
-tasks.withType<DokkaTask>().configureEach {
-    // custom output directory
-    outputDirectory.set(buildDir.resolve("dokka"))
-
-    dokkaSourceSets { 
-         named("customNameMain") { // The same name as in Kotlin Multiplatform plugin, so the sources are fetched automatically
-            includes.from("packages.md", "extra.md")
-            samples.from("samples/basic.kt", "samples/advanced.kt")
-        }
-
-        register("differentName") { // Different name, so source roots must be passed explicitly
-            displayName.set("JVM")
-            platform.set(org.jetbrains.dokka.Platform.jvm)
-            sourceRoots.from(kotlin.sourceSets.getByName("jvmMain").kotlin.srcDirs)
-            sourceRoots.from(kotlin.sourceSets.getByName("commonMain").kotlin.srcDirs)
-        }
-    }
-}
-```
-
-!!! note
-    If you want to share the configuration between source sets, you can use Gradle's `configureEach`
-
-## Applying plugins
-Dokka plugin creates Gradle configuration for each output format in the form of `dokka${format}Plugin` (or `dokka${format}PartialPlugin` for multi-module tasks) :
-
-```kotlin
-dependencies {
-    dokkaHtmlPlugin("org.jetbrains.dokka:kotlin-as-java-plugin:1.7.20")
-}
-``` 
-
-You can also create a custom Dokka task and add plugins directly inside:
-
-```kotlin
-val customDokkaTask by creating(DokkaTask::class) {
-    dependencies {
-        plugins("org.jetbrains.dokka:kotlin-as-java-plugin:1.7.20")
-    }
-}
-```
-
-!!! important
-    Please note that `dokkaJavadoc` task will properly document only single `jvm` source set
-
-To generate the documentation, use the appropriate `dokka${format}` Gradle task:
-