Fix markdownlint issues

CommandAPI · DerEchtePilz · Jul 12, 2023 · Jun 8, 2023 · Jun 8, 2023 · Jun 8, 2023
commit 9fe5879d991dbc1f9b8cd5c2bc79f7f36fa8a5b2
diff --git a/docssrc/src/commandarguments.md b/docssrc/src/commandarguments.md
@@ -19,13 +19,14 @@ While the argument array just gives the possibility to access the arguments via
   - [Access arguments by node name](#access-arguments-by-node-name-1)
   - [Access arguments by index](#access-arguments-by-index-1)
 
-
 ATTENTION!!!!! Every executable and generated documentation has to be deleted before committing anything!
 
 -----
 
 ## Access the inner structure directly
+
 To provide arguments, the `CommandArguments` class stores:
+
 - a `Object[]` of parsed arguments
 - a `Map<String, Object>` of parsed arguments mapped to their node names
 - a `String[]` of raw arguments
@@ -53,9 +54,11 @@ While these methods can be used to access arguments, it may be safer to use the
 -----
 
 ## What terms are used?
+
 Throughout this page, multiple terms are used that may need an explanation.
 
 ### `nodeName`
+
 The `nodeName` is set when initializing an argument. For example:
 
 ```java
@@ -65,6 +68,7 @@ new StringArgument("string")
 The `nodeName` here would be `string`.
 
 ### `raw argument`
+
 A "raw argument" is the `String` form of an argument as written in a command. For example:
 
 A user defines a command `/mycommand` that accepts a `double` as the first argument and an entity selector as the second argument. It could be executed with the values `15.3` as the `double` value and `@e` as the entity selector:
@@ -78,18 +82,21 @@ When [accessing the raw arguments](#access-raw-arguments) of this command there
 However, when [accessing the arguments](#access-arguments) of this command there is `15.3` available as `double` and `@e` available as `Collection<Entity>`.
 
 ### `unsafe argument`
+
 When [accessing arguments](#access-arguments) you need to cast the `Object` returned by these methods to the type the argument returns. More about casting arguments [here](./arguments.md#argument-casting).
 
 However, the `CommandArguments` class provides a way to remove the need to cast the arguments which is referred to as `unsafe arguments` in this page.
 
 -----
 
 ## Access arguments
+
 The `CommandArguments` class provides its arguments in a way similar to how a `List` or `Map` let you access their contents. When using these methods, you need to cast the arguments to their respective type. The `CommandArguments` class also provides a way to [access unsafe arguments](#access-unsafe-arguments).
 
 You can choose to access arguments by their node name or by their index.
 
 ### Access arguments by node name
+
 Accessing arguments by their node name is the recommended way of accessing arguments.
 
 There are two methods you can use to access arguments by their node name:
@@ -102,6 +109,7 @@ Optional<Object> getOptional(String nodeName);
 There is no downside of using one method over the other but the `CommandArguments#getOptional(String)` method is especially great when you have optional arguments in your command.
 
 ### Access arguments by index
+
 Accessing arguments by their index is the original way of accessing arguments. However, we recommend to [access arguments by node name](#access-arguments-by-node-name).
 
 Similar to the two methods of accessing arguments by their node name, there also are two methods you can use to access arguments by their index:
@@ -120,9 +128,11 @@ Optional<Object> getOptional(int index);
 -----
 
 ## Access raw arguments
+
 Raw arguments are accessed basically the same way you would [access arguments](#access-arguments). You can access them by their node name and their index in the argument array.
 
 ### Access raw arguments by node name
+
 Accessing raw arguments by their node name is the recommended way of doing it.
 
 To access raw arguments by their node name, you can use these methods:
@@ -133,6 +143,7 @@ Optional<String> getRawOptional(String nodeName);
 ```
 
 ### Access raw arguments by index
+
 Of course, if you don't want to access raw arguments by their node name, we also provide the option to access them by index with these methods:
 
 ```java
@@ -149,6 +160,7 @@ Optional<String> getRawOptional(int index);
 -----
 
 ## Access unsafe arguments
+
 Accessing unsafe arguments is a nice way to shorten your code as you do not need to cast the argument to its corresponding type.
 
 Here, you might notice the usage of several `getOrDefaultUnchecked` methods and not the `getOptionalUnchecked` methods you might have expected.
@@ -158,6 +170,7 @@ That is not a problem when [accessing arguments](#access-arguments) because here
 Unsafe arguments can also be accessed by their node names and their indices.
 
 ### Access arguments by node name
+
 Unsafe arguments can also be accessed by node name which, again, is the recommended way of doing it.
 
 In the case of unsafe arguments, the CommandAPI doesn't provide two but instead three methods to access them:
@@ -169,6 +182,7 @@ T getOrDefaultUnchecked(String nodeName, Supplier<T> defaultValue);
 ```
 
 ### Access arguments by index
+
 If you want to access unsafe arguments by index, you can do that by using these methods:
 
 ```java