From a8048d2236f41db19df39cfaacd37a5722875805 Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 07:15:08 -0800
Subject: [PATCH 1/9] CondExprIsEmpty - set priority higher than CondCompare -
 This prevents comparing a list to an object named "empty"

---
 .../syst3ms/skriptparser/expressions/CondExprIsEmpty.java      | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java
index 4434b2ac..4556aa0d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java
@@ -28,6 +28,9 @@ public class CondExprIsEmpty extends ConditionalExpression {
             .examples("if {_list::*} is empty:",
                 "if {_string} is not empty:")
             .since("1.0.0")
+            .setPriority(1)
+            // Higher priority than CondExprContains(0)
+            // This prevents trying to compare to an object named "empty"
             .register();
     }
 

From 9918cc0bad3d48c8c9251841a37ca8f6b9dea618 Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 08:04:33 -0800
Subject: [PATCH 2/9] Improve structure registration

---
 .../skriptparser/parsing/SyntaxParser.java    |   2 +-
 .../registration/SkriptRegistration.java      | 139 +++++++++++++++++-
 .../registration/StructureInfo.java           |  23 +++
 .../registration/SyntaxManager.java           |  13 +-
 .../structures/functions/StructFunction.java  |   2 +-
 5 files changed, 172 insertions(+), 7 deletions(-)
 create mode 100644 src/main/java/io/github/syst3ms/skriptparser/registration/StructureInfo.java

diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
index d40a4fdc..70c17c41 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
@@ -701,7 +701,7 @@ private static Optional<? extends CodeSection> matchSectionInfo(FileSection sect
     public static Optional<? extends UnloadedTrigger> parseTrigger(FileSection section, SkriptLogger logger) {
         if (section.getLineContent().isEmpty())
             return Optional.empty();
-        for (var info : recentEvents.mergeWith(SyntaxManager.getEvents())) {
+        for (var info : recentEvents.mergeWith(SyntaxManager.getTriggers())) {
             var trigger = matchEventInfo(section, info, logger);
             if (trigger.isPresent()) {
                 recentEvents.acknowledge(info);
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
index dd5f3557..d4e764df 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
@@ -4,6 +4,7 @@
 import io.github.syst3ms.skriptparser.lang.CodeSection;
 import io.github.syst3ms.skriptparser.lang.Effect;
 import io.github.syst3ms.skriptparser.lang.Expression;
+import io.github.syst3ms.skriptparser.lang.Structure;
 import io.github.syst3ms.skriptparser.lang.SyntaxElement;
 import io.github.syst3ms.skriptparser.lang.TriggerContext;
 import io.github.syst3ms.skriptparser.lang.base.ContextExpression;
@@ -77,6 +78,7 @@ public class SkriptRegistration {
     private final List<ConverterInfo<?, ?>> converters = new ArrayList<>();
     private final List<TagInfo<? extends Tag>> tags = new ArrayList<>();
     private final List<SkriptEventInfo<?>> events = new ArrayList<>();
+    private final List<StructureInfo<?>> structures = new ArrayList<>();
     protected final List<Type<?>> types = new ArrayList<>();
     private final SkriptAddon registerer;
     private final SkriptLogger logger;
@@ -130,6 +132,13 @@ public List<SkriptEventInfo<?>> getEvents() {
         return events;
     }
 
+    /**
+     * @return All currently registered structures
+     */
+    public List<StructureInfo<?>> getStructures() {
+        return this.structures;
+    }
+
     /**
      * @return all currently registered types
      */
@@ -424,6 +433,18 @@ public <E extends SkriptEvent> EventRegistrar<E> newEvent(Class<E> c, String...
         return new EventRegistrar<>(c, patterns);
     }
 
+    /**
+     * Starts a registration process for a {@link Structure}
+     *
+     * @param c        the Structure's class
+     * @param patterns the Structure's patterns
+     * @param <S>      the Structure
+     * @return an {@link EventRegistrar} to continue the registration process
+     */
+    public <S extends Structure> StructureRegistrar<S> newStructure(Class<S> c, String... patterns) {
+        return new StructureRegistrar<>(c, patterns);
+    }
+
     /**
      * Registers a {@link SkriptEvent}
      *
@@ -719,7 +740,8 @@ public class TypeRegistrar<C> implements Registrar {
         private final String baseName;
         private final String pattern;
         private Function<? super C, String> toStringFunction = o -> Objects.toString(o, TypeManager.NULL_REPRESENTATION);
-        @Nullable private Function<? super C, String> toVariableNameFunction;
+        @Nullable
+        private Function<? super C, String> toVariableNameFunction;
         @Nullable
         private Function<String, ? extends C> literalParser;
         @Nullable
@@ -1069,6 +1091,121 @@ public void register() {
         }
     }
 
+    public class StructureRegistrar<T extends Structure> extends SyntaxRegistrar<T> {
+        private Set<Class<? extends TriggerContext>> handledContexts = new HashSet<>();
+        private final Documentation documentation = new Documentation();
+
+        StructureRegistrar(Class<T> c, String... patterns) {
+            super(c, patterns);
+            this.documentation.setName(c.getSimpleName()); // Dummy name if not specified
+            typeCheck();
+        }
+
+        /**
+         * Set the contexts this structure can handle
+         *
+         * @param contexts the contexts
+         * @return The registrar
+         */
+        @SafeVarargs
+        public final StructureRegistrar<T> setHandledContexts(Class<? extends TriggerContext>... contexts) {
+            this.handledContexts = Set.of(contexts);
+            return this;
+        }
+
+        /**
+         * Prevent documentation generation for this structure.
+         *
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> noDoc() {
+            this.documentation.noDoc();
+            return this;
+        }
+
+        /**
+         * Mark this structure as experimental for documentation.
+         *
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> experimental() {
+            this.documentation.experimental();
+            return this;
+        }
+
+        /**
+         * Mark this structure as experimental with a custom message for documentation.
+         *
+         * @param message The custom message
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> experimental(String message) {
+            this.documentation.experimental(message);
+            return this;
+        }
+
+        /**
+         * The name of this structure for documentation.
+         *
+         * @param name Name of the structure
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> name(String name) {
+            this.documentation.setName(name);
+            return this;
+        }
+
+        /**
+         * The description of this structure for documentation.
+         *
+         * @param description The description of the structure
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> description(String... description) {
+            this.documentation.setDescription(description);
+            return this;
+        }
+
+        /**
+         * Examples of this structure for documentation.
+         *
+         * @param examples The examples of the structure
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> examples(String... examples) {
+            this.documentation.setExamples(examples);
+            return this;
+        }
+
+        /**
+         * The version this was added in for documentation.
+         *
+         * @param since The version this was added in
+         * @return The registrar
+         */
+        public final StructureRegistrar<T> since(String since) {
+            this.documentation.setSince(since);
+            return this;
+        }
+
+        /**
+         * Adds this structure to the list of currently registered syntaxes
+         */
+        @Override
+        public void register() {
+            for (int i = 0; i < super.patterns.size(); i++) {
+                var pattern = super.patterns.get(i);
+                if (pattern.startsWith("*")) {
+                    super.patterns.set(i, pattern.substring(1));
+                } else {
+                    super.patterns.set(i, pattern);
+                }
+            }
+            structures.add(new StructureInfo<>(registerer, super.c, handledContexts, priority, parsePatterns(), this.documentation, data));
+            registerer.addHandledEvent(this.c);
+        }
+    }
+
     public class ContextValueRegistrar<C extends TriggerContext, T> implements Registrar {
         private final Class<C> context;
         private final Class<T> returnType;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/StructureInfo.java b/src/main/java/io/github/syst3ms/skriptparser/registration/StructureInfo.java
new file mode 100644
index 00000000..1151ab9c
--- /dev/null
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/StructureInfo.java
@@ -0,0 +1,23 @@
+package io.github.syst3ms.skriptparser.registration;
+
+import io.github.syst3ms.skriptparser.docs.Documentation;
+import io.github.syst3ms.skriptparser.lang.Structure;
+import io.github.syst3ms.skriptparser.lang.TriggerContext;
+import io.github.syst3ms.skriptparser.pattern.PatternElement;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A class containing info about a {@link Structure} syntax
+ *
+ * @param <E> the {@link Structure} class
+ */
+public class StructureInfo<E extends Structure> extends SkriptEventInfo<E> {
+
+    public StructureInfo(SkriptAddon registerer, Class<E> c, Set<Class<? extends TriggerContext>> handledContexts, int priority, List<PatternElement> patterns, Documentation documentation, Map<String, Object> data) {
+        super(registerer, c, handledContexts, priority, patterns, documentation, data);
+    }
+
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxManager.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxManager.java
index 377fdf83..205b0d2e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxManager.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxManager.java
@@ -11,6 +11,7 @@
 import java.util.Optional;
 
 public class SyntaxManager {
+
     /**
      * The ordering describing the order in which syntaxes should be tested during parsing
      */
@@ -32,6 +33,7 @@ static void register(SkriptRegistration reg) {
         sections.addAll(reg.getSections());
         sections.sort(INFO_COMPARATOR);
         triggers.addAll(reg.getEvents());
+        triggers.addAll(reg.getStructures());
         triggers.sort(INFO_COMPARATOR);
         for (var entry : reg.getExpressions().entrySet()) {
             var key = entry.getKey();
@@ -53,8 +55,8 @@ static void register(SkriptRegistration reg) {
 
     /**
      * @param expr the expression instance
-     * @param <E> the expression class
-     * @param <T> the expression return type
+     * @param <E>  the expression class
+     * @param <T>  the expression return type
      * @return the {@link ExpressionInfo} corresponding to the given {@link Expression} instance
      */
     @SuppressWarnings("unchecked")
@@ -83,9 +85,12 @@ public static List<SyntaxInfo<? extends Effect>> getEffects() {
     }
 
     /**
-     * @return a list of all currently registered events
+     * Get all currently registered triggers (events/structures).
+     *
+     * @return a list of all currently registered triggers (events/structures)
      */
-    public static List<SkriptEventInfo<?>> getEvents() {
+    public static List<SkriptEventInfo<?>> getTriggers() {
         return triggers;
     }
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
index 801946e8..85767da1 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
@@ -16,7 +16,7 @@ public class StructFunction extends Structure {
 
     static {
         Parser.getMainRegistration()
-            .newEvent(StructFunction.class, "*[:local[ ]] func[tion] <" + Functions.FUNCTION_NAME_REGEX + ">" +
+            .newStructure(StructFunction.class, "*[:local[ ]] func[tion] <" + Functions.FUNCTION_NAME_REGEX + ">" +
                 "\\([params:%*functionparameters%]\\)[return: \\:\\: <.+>]")
             .setHandledContexts(FunctionContext.class)
             .name("Function")

From 60a185a6f7dd13160283ab60629fd5c03c321135 Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 08:33:57 -0800
Subject: [PATCH 3/9] EffFunctionCall - fix allowing incorrect types

---
 .../structures/functions/EffFunctionCall.java  | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
index 2da64abc..bc44ac4b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
@@ -96,9 +96,27 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                         }
                     }
                 } else {
+                    FunctionParameter<?> functionParameter = functionParameters[0];
+                    Class<?> paramType = functionParameter.getType();
+                    if (!paramType.isAssignableFrom(this.parsedExpr.getReturnType())) {
+                        String typeText = TypeManager.getByClass(paramType).get().withIndefiniteArticle(false);
+                        logger.error("The type of the provided value for the '" + functionParameter.getName()
+                            + "' parameter is not " + typeText + "/couldn't be converted to "
+                            + typeText, ErrorType.SEMANTIC_ERROR);
+                        return false;
+                    }
                     paramsExprs = new Expression<?>[]{parsedExpr}; // single parameter setting it to multiple values
                 }
             } else {
+                FunctionParameter<?> functionParameter = functionParameters[0];
+                Class<?> paramType = functionParameter.getType();
+                if (!paramType.isAssignableFrom(this.parsedExpr.getReturnType())) {
+                    String typeText = TypeManager.getByClass(paramType).get().withIndefiniteArticle(false);
+                    logger.error("The type of the provided value for the '" + functionParameter.getName()
+                        + "' parameter is not " + typeText + "/couldn't be converted to "
+                        + typeText, ErrorType.SEMANTIC_ERROR);
+                    return false;
+                }
                 paramsExprs = new Expression<?>[]{parsedExpr}; //
             }
         }

From c4551fe08499c5de5f671b2b0aabed6803e8554d Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 10:15:00 -0800
Subject: [PATCH 4/9] ContextValues - revamp how they're handled - Rather than
 trying to parse, they're now their own expression

---
 .../expressions/ExprContextValue.java         | 157 ++++++++++++++++++
 .../lang/base/ContextExpression.java          |  89 ----------
 .../skriptparser/parsing/SyntaxParser.java    |  86 ----------
 .../registration/SkriptRegistration.java      |   8 +-
 4 files changed, 161 insertions(+), 179 deletions(-)
 create mode 100644 src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
 delete mode 100644 src/main/java/io/github/syst3ms/skriptparser/lang/base/ContextExpression.java

diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
new file mode 100644
index 00000000..bde1899e
--- /dev/null
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
@@ -0,0 +1,157 @@
+package io.github.syst3ms.skriptparser.expressions;
+
+import io.github.syst3ms.skriptparser.Parser;
+import io.github.syst3ms.skriptparser.lang.Expression;
+import io.github.syst3ms.skriptparser.lang.TriggerContext;
+import io.github.syst3ms.skriptparser.log.ErrorContext;
+import io.github.syst3ms.skriptparser.log.ErrorType;
+import io.github.syst3ms.skriptparser.log.SkriptLogger;
+import io.github.syst3ms.skriptparser.parsing.MatchContext;
+import io.github.syst3ms.skriptparser.parsing.ParseContext;
+import io.github.syst3ms.skriptparser.parsing.ParserState;
+import io.github.syst3ms.skriptparser.pattern.PatternElement;
+import io.github.syst3ms.skriptparser.pattern.PatternParser;
+import io.github.syst3ms.skriptparser.registration.context.ContextValue;
+import io.github.syst3ms.skriptparser.registration.context.ContextValue.State;
+import io.github.syst3ms.skriptparser.registration.context.ContextValues;
+import io.github.syst3ms.skriptparser.types.changers.ChangeMode;
+import org.jetbrains.annotations.Contract;
+
+import java.lang.reflect.Array;
+import java.util.Optional;
+
+public class ExprContextValue<T, C extends TriggerContext> implements Expression<T> {
+
+    private static final String PATTERN = "[the] [(1:(past|previous)|2:(future|next))] [ctx:(context|event)-]<.+>";
+    private static final PatternElement CONTEXT_VALUE_PATTERN = PatternParser.parsePattern(PATTERN, new SkriptLogger()).orElseThrow();
+
+    private ContextValue<C, T> info;
+    private String value;
+    private boolean alone;
+
+    static {
+        //noinspection unchecked
+        Parser.getMainRegistration().newExpression(ExprContextValue.class, Object.class, false,
+                PATTERN)
+            .name("Context/Event Value")
+            .description("Returns a value from the current context/event.")
+            .examples("set {_var} to context-player")
+            .since("1.0.0")
+            .register();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    @Contract("_, _, _ -> fail")
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        boolean alone = !parseContext.hasMark("ctx");
+        String toParse = parseContext.getMatches().getFirst().group();
+        String value = parseContext.getMatches().getFirst().group();
+        State state = switch (parseContext.getNumericMark()) {
+            case 0 -> State.PRESENT;
+            case 1 -> State.PAST;
+            case 2 -> State.FUTURE;
+            default -> throw new IllegalArgumentException("Invalid state index: " + parseContext.getNumericMark());
+        };
+
+
+        ParserState parserState = parseContext.getParserState();
+        SkriptLogger logger = parseContext.getLogger();
+
+        var matchContext = new MatchContext(CONTEXT_VALUE_PATTERN, parserState, logger);
+
+        for (Class<? extends TriggerContext> ctx : parserState.getCurrentContexts()) {
+            for (var info : ContextValues.getContextValues(ctx)) {
+                matchContext = new MatchContext(info.getPattern(), parserState, logger);
+
+                // Checking all conditions, so no false results slip through.
+                if (info.getPattern().match(value, 0, matchContext) != value.length()) {
+                    continue;
+                } else if (!info.getUsage().isCorrect(alone)) {
+                    if (alone) {
+                        logger.error(
+                            "The context value matching '" + toParse + "' cannot be used alone",
+                            ErrorType.SEMANTIC_ERROR,
+                            "Use 'context-" + toParse + "' instead of using just '" + toParse + "' alone"
+                        );
+                    } else {
+                        logger.error(
+                            "The context value matching '" + toParse + "' must be used alone",
+                            ErrorType.SEMANTIC_ERROR,
+                            "Instead of 'context-" + toParse + "', use this context value as '" + toParse + "'"
+                        );
+                    }
+                    return false;
+                } else if (state != info.getState()) {
+                    logger.error("The time state of this context value (" + state.toString().toLowerCase() + ") is incorrect", ErrorType.SEMANTIC_ERROR);
+                    return false;
+                } else if (parserState.isRestrictingExpressions() && parserState.forbidsSyntax(ExprContextValue.class)) {
+                    logger.setContext(ErrorContext.RESTRICTED_SYNTAXES);
+                    logger.error("The enclosing section does not allow the use of context expressions.", ErrorType.SEMANTIC_ERROR);
+                    return false;
+                }
+
+                this.info = (ContextValue<C, T>) info;
+                this.value = value;
+                this.alone = alone;
+                return true;
+            }
+        }
+        if (!alone) {
+            logger.error("No context value matching '" + toParse + "' was found", ErrorType.SEMANTIC_ERROR);
+        }
+        return false;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public T[] getValues(TriggerContext ctx) {
+        if (!this.info.getContext().isAssignableFrom(ctx.getClass())) {
+            return (T[]) Array.newInstance(getReturnType(), 0);
+        }
+        assert this.info.getContext().isInstance(ctx);
+        if (this.info.isSingle()) {
+            T apply = this.info.getSingleFunction().apply((C) ctx);
+            T[] array = (T[]) Array.newInstance(getReturnType(), 1);
+            array[0] = apply;
+            return array;
+        } else {
+            return this.info.getListFunction().apply((C) ctx);
+        }
+    }
+
+    @Override
+    public Optional<Class<?>[]> acceptsChange(ChangeMode mode) {
+        if (mode == ChangeMode.SET && this.info.canBeSet()) return Optional.of(new Class<?>[]{getReturnType()});
+        return Optional.empty();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void change(TriggerContext ctx, ChangeMode changeMode, Object[] changeWith) {
+        if (changeMode != ChangeMode.SET) return;
+
+        if (this.info.isSingle()) {
+            this.info.getSingleSetterFunction().accept((C) ctx, (T) changeWith[0]);
+        } else {
+            this.info.getListSetterFunction().accept((C) ctx, (T[]) changeWith);
+        }
+    }
+
+    @Override
+    public boolean isSingle() {
+        return this.info.isSingle();
+    }
+
+    @Override
+    public Class<? extends T> getReturnType() {
+        return this.info.getReturnType().getType().getTypeClass();
+    }
+
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return new String[]{"past ", "", "future "}[this.info.getState().ordinal()] +
+            (this.alone ? "" : "context-") + this.value;
+    }
+
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ContextExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ContextExpression.java
deleted file mode 100644
index 55db756d..00000000
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ContextExpression.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package io.github.syst3ms.skriptparser.lang.base;
-
-import io.github.syst3ms.skriptparser.lang.Expression;
-import io.github.syst3ms.skriptparser.lang.TriggerContext;
-import io.github.syst3ms.skriptparser.parsing.ParseContext;
-import io.github.syst3ms.skriptparser.registration.context.ContextValue;
-import io.github.syst3ms.skriptparser.types.changers.ChangeMode;
-import org.jetbrains.annotations.Contract;
-
-import java.lang.reflect.Array;
-import java.util.Optional;
-
-/**
- * An {@link Expression} that corresponds to a contextual value. Each trigger
- * can carry multiple instances of data (called 'context values'). This expression
- * holds a reference to such a value.
- *
- * @param <C> the TriggerContext class
- * @param <T> the Expression's type
- * @author Mwexim
- */
-public class ContextExpression<C extends TriggerContext, T> implements Expression<T> {
-    private final ContextValue<C, T> info;
-    private final String value;
-    private final boolean alone;
-
-    public ContextExpression(ContextValue<C, T> info, String value, boolean alone) {
-        this.info = info;
-        this.value = value;
-        this.alone = alone;
-    }
-
-    @Override
-    @Contract("_, _, _ -> fail")
-    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-        throw new UnsupportedOperationException();
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public T[] getValues(TriggerContext ctx) {
-        if (!this.info.getContext().isAssignableFrom(ctx.getClass())) {
-            return (T[]) Array.newInstance(getReturnType(), 0);
-        }
-        assert info.getContext().isInstance(ctx);
-        if (info.isSingle()) {
-            T apply = this.info.getSingleFunction().apply((C) ctx);
-            T[] array = (T[]) Array.newInstance(getReturnType(), 1);
-            array[0] = apply;
-            return array;
-        } else {
-            return info.getListFunction().apply((C) ctx);
-        }
-    }
-
-    @Override
-    public Optional<Class<?>[]> acceptsChange(ChangeMode mode) {
-        if (mode == ChangeMode.SET && this.info.canBeSet()) return Optional.of(new Class<?>[]{getReturnType()});
-        return Optional.empty();
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public void change(TriggerContext ctx, ChangeMode changeMode, Object[] changeWith) {
-        if (changeMode != ChangeMode.SET) return;
-
-        if (this.info.isSingle()) {
-            this.info.getSingleSetterFunction().accept((C) ctx, (T) changeWith[0]);
-        } else {
-            this.info.getListSetterFunction().accept((C) ctx, (T[]) changeWith);
-        }
-    }
-
-    @Override
-    public boolean isSingle() {
-        return this.info.isSingle();
-    }
-
-    @Override
-    public Class<? extends T> getReturnType() {
-        return this.info.getReturnType().getType().getTypeClass();
-    }
-
-    @Override
-    public String toString(TriggerContext ctx, boolean debug) {
-        return new String[]{"past ", "", "future "}[info.getState().ordinal()] + (alone ? "" : "context-") + value;
-    }
-
-}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
index 70c17c41..87f79135 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
@@ -15,8 +15,6 @@
 import io.github.syst3ms.skriptparser.lang.Variable;
 import io.github.syst3ms.skriptparser.lang.VariableString;
 import io.github.syst3ms.skriptparser.lang.base.ConditionalExpression;
-import io.github.syst3ms.skriptparser.lang.base.ContextExpression;
-import io.github.syst3ms.skriptparser.lang.base.ConvertedExpression;
 import io.github.syst3ms.skriptparser.lang.event.SkriptEvent;
 import io.github.syst3ms.skriptparser.log.ErrorContext;
 import io.github.syst3ms.skriptparser.log.ErrorType;
@@ -27,9 +25,6 @@
 import io.github.syst3ms.skriptparser.registration.SkriptEventInfo;
 import io.github.syst3ms.skriptparser.registration.SyntaxInfo;
 import io.github.syst3ms.skriptparser.registration.SyntaxManager;
-import io.github.syst3ms.skriptparser.registration.context.ContextValue;
-import io.github.syst3ms.skriptparser.registration.context.ContextValue.State;
-import io.github.syst3ms.skriptparser.registration.context.ContextValues;
 import io.github.syst3ms.skriptparser.types.PatternType;
 import io.github.syst3ms.skriptparser.types.Type;
 import io.github.syst3ms.skriptparser.types.TypeManager;
@@ -114,10 +109,6 @@ public class SyntaxParser {
      * All {@link ConditionalExpression conditions} that are successfully parsed during parsing, in order of last successful parsing
      */
     private static final RecentElementList<ExpressionInfo<? extends ConditionalExpression, ? extends Boolean>> recentConditions = new RecentElementList<>();
-    /**
-     * All {@link ContextValue context values} that are successfully parsed during parsing, in order of last successful parsing
-     */
-    private static final RecentElementList<ContextValue<?, ?>> recentContextValues = new RecentElementList<>();
 
     /**
      * Parses an {@link Expression} from the given {@linkplain String} and {@link PatternType expected return type}
@@ -193,18 +184,6 @@ public static <T> Optional<? extends Expression<? extends T>> parseExpression(St
             logger.forgetError();
         }
 
-        // Parsing of standalone context values
-        var contextValue = parseContextValue(s, expectedType, parserState, logger);
-        if (contextValue.isPresent()) {
-            logger.clearErrors();
-            ContextExpression<?, ? extends T> contextExpression = contextValue.get();
-            if (!expectedType.getType().getTypeClass().isAssignableFrom(contextExpression.getReturnType())) {
-                Optional<? extends ConvertedExpression<? extends T, T>> convertedExpression = ConvertedExpression.newInstance(contextExpression, expectedType.getType().getTypeClass());
-                return convertedExpression;
-            }
-            return contextValue;
-        }
-
         logger.setContext(ErrorContext.NO_MATCH);
         logger.error("No expression matching '" + s + "' was found", ErrorType.NO_MATCH);
         return Optional.empty();
@@ -293,71 +272,6 @@ public static Optional<? extends Expression<Boolean>> parseBooleanExpression(Str
         return Optional.empty();
     }
 
-    /**
-     * Parses a {@link ContextValue} from the given {@linkplain String} and {@link PatternType expected return type}
-     * @param <T> the type of the context value
-     * @param toParse the string to be parsed as a context value
-     * @param expectedType the expected return type
-     * @param parserState the current parser state
-     * @param logger the logger
-     * @return an expression that was successfully parsed, or {@literal null} if the string is empty,
-     * no match was found
-     * or for another reason detailed in an error message.
-     */
-    public static <T> Optional<? extends ContextExpression<?, ? extends T>> parseContextValue(String toParse, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
-        var matchContext = new MatchContext(CONTEXT_VALUE_PATTERN, parserState, logger);
-        CONTEXT_VALUE_PATTERN.match(toParse, 0, matchContext);
-
-        var parseContext = matchContext.toParseResult();
-        var state = State.values()[parseContext.getNumericMark()];
-        boolean alone = !parseContext.hasMark("ctx");
-        var value = parseContext.getMatches().get(0).group();
-
-        for (Class<? extends TriggerContext> ctx : parseContext.getParserState().getCurrentContexts()) {
-            for (var info : ContextValues.getContextValues(ctx)) {
-                matchContext = new MatchContext(info.getPattern(), parserState, logger);
-
-                // Checking all conditions, so no false results slip through.
-                if (info.getPattern().match(value, 0, matchContext) != value.length()) {
-                    continue;
-                } else if (!info.getUsage().isCorrect(alone)) {
-                    if (alone) {
-                        logger.error(
-                                "The context value matching '" + toParse + "' cannot be used alone",
-                                ErrorType.SEMANTIC_ERROR,
-                                "Use 'context-something' instead of using this context value alone"
-                        );
-                    } else {
-                        logger.error(
-                                "The context value matching '" + toParse + "' must be used alone",
-                                ErrorType.SEMANTIC_ERROR,
-                                "Instead of 'context-something', use this context value as 'something'"
-                        );
-                    }
-                    return Optional.empty();
-                } else if (state != info.getState()) {
-                    logger.error("The time state of this context value (" + state.toString().toLowerCase() + ") is incorrect", ErrorType.SEMANTIC_ERROR);
-                    continue;
-                } else if (expectedType.isSingle() && !info.getReturnType().isSingle()) {
-                    logger.error(
-                            "A single value was expected, but " + toParse + " represents multiple values.",
-                            ErrorType.SEMANTIC_ERROR,
-                            "Use a loop/map to divert each element of this list into single elements"
-                    );
-                    return Optional.empty();
-                } else if (parserState.isRestrictingExpressions() && parserState.forbidsSyntax(ContextExpression.class)) {
-                    logger.setContext(ErrorContext.RESTRICTED_SYNTAXES);
-                    logger.error("The enclosing section does not allow the use of context expressions.", ErrorType.SEMANTIC_ERROR);
-                    return Optional.empty();
-                }
-
-                recentContextValues.acknowledge(info);
-                return Optional.of(new ContextExpression<>((ContextValue<?, T>) info, value, alone));
-            }
-        }
-        return Optional.empty();
-    }
-
     private static <T> Optional<? extends Expression<? extends T>> matchExpressionInfo(String s, ExpressionInfo<?, ?> info, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
         var patterns = info.getPatterns();
         var infoType = info.getReturnType();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
index d4e764df..bf160ef8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
@@ -1,13 +1,13 @@
 package io.github.syst3ms.skriptparser.registration;
 
 import io.github.syst3ms.skriptparser.docs.Documentation;
+import io.github.syst3ms.skriptparser.expressions.ExprContextValue;
 import io.github.syst3ms.skriptparser.lang.CodeSection;
 import io.github.syst3ms.skriptparser.lang.Effect;
 import io.github.syst3ms.skriptparser.lang.Expression;
 import io.github.syst3ms.skriptparser.lang.Structure;
 import io.github.syst3ms.skriptparser.lang.SyntaxElement;
 import io.github.syst3ms.skriptparser.lang.TriggerContext;
-import io.github.syst3ms.skriptparser.lang.base.ContextExpression;
 import io.github.syst3ms.skriptparser.lang.base.ExecutableExpression;
 import io.github.syst3ms.skriptparser.lang.event.SkriptEvent;
 import io.github.syst3ms.skriptparser.lang.properties.ConditionalType;
@@ -469,7 +469,7 @@ public void addEvent(Class<? extends SkriptEvent> c, Class<? extends TriggerCont
     }
 
     /**
-     * Starts a registration process for a {@link ContextExpression}
+     * Starts a registration process for a {@link ExprContextValue}
      *
      * @param context    the TriggerContext class
      * @param returnType the returned type of this context value
@@ -491,7 +491,7 @@ public <C extends TriggerContext, T> ContextValueRegistrar<C, T> newContextValue
     }
 
     /**
-     * Starts a registration process for a {@link ContextExpression} with a single return value.
+     * Starts a registration process for a {@link ExprContextValue} with a single return value.
      *
      * @param context    the TriggerContext class
      * @param returnType the returned type of this context value
@@ -506,7 +506,7 @@ public <C extends TriggerContext, T> ContextValueRegistrar<C, T> newSingleContex
     }
 
     /**
-     * Starts a registration process for a {@link ContextExpression} with a list return value.
+     * Starts a registration process for a {@link ExprContextValue} with a list return value.
      *
      * @param context    the TriggerContext class
      * @param returnType the returned type of this context value

From 15360a5e5610849b01c23a1681ff19da8ef4567a Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 10:43:31 -0800
Subject: [PATCH 5/9] build.yml - add dev/** to branches

---
 .github/workflows/build.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3dfc119b..cc4bff71 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - master
+      - dev/**
   pull_request:
 
 jobs:

From 9de721a5a7175d9eba160e919490c561b1ae693c Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 10:44:02 -0800
Subject: [PATCH 6/9] Add checkstyle and reformat lots of code

---
 .editorconfig                                 |  23 +
 build.gradle.kts                              |  12 +
 config/checkstyle/checkstyle.xml              |  62 ++
 .../syst3ms/skriptparser/effects/EffExit.java |   5 +-
 .../skriptparser/effects/EffReturn.java       |   2 +-
 .../expressions/CondExprChance.java           |   4 +-
 .../expressions/CondExprCompare.java          | 272 +++--
 .../expressions/CondExprContains.java         |  38 +-
 .../expressions/CondExprIsEmpty.java          |   6 +-
 .../expressions/CondExprIsSet.java            |   2 +-
 .../expressions/CondExprMatch.java            |  20 +-
 .../expressions/ExecExprListOperators.java    | 346 +++----
 .../expressions/ExecExprReplace.java          | 206 ++--
 .../skriptparser/expressions/ExprAmount.java  | 110 +-
 .../skriptparser/expressions/ExprAnswer.java  |  10 +-
 .../expressions/ExprBooleanOperators.java     |  16 +-
 .../expressions/ExprColorFromHex.java         |  54 +-
 .../expressions/ExprColorFromRGB.java         |  70 +-
 .../expressions/ExprContextValue.java         |  10 +-
 .../expressions/ExprDateAgoLater.java         |  78 +-
 .../skriptparser/expressions/ExprDateNow.java |  50 +-
 .../expressions/ExprDateTodayAt.java          |  71 +-
 .../expressions/ExprDefaultValue.java         |   6 +-
 .../expressions/ExprDifference.java           |  52 +-
 .../skriptparser/expressions/ExprElement.java |   4 +-
 .../expressions/ExprLoopValue.java            | 248 ++---
 .../expressions/ExprMutableList.java          |  10 +-
 .../expressions/ExprPrimeNumber.java          |  63 --
 .../expressions/ExprRandomNumber.java         |   4 +-
 .../skriptparser/expressions/ExprRange.java   |  36 +-
 .../expressions/ExprStringCharAt.java         |  70 +-
 .../expressions/ExprStringChars.java          |   4 +-
 .../expressions/ExprUnaryMathFunctions.java   | 140 +--
 .../skriptparser/expressions/ExprWhether.java |   2 +-
 .../expressions/LitScriptName.java            |   4 +-
 .../expressions/LitTimeConstants.java         |   2 +-
 .../skriptparser/lang/CodeSection.java        |  62 +-
 .../syst3ms/skriptparser/lang/Expression.java | 145 +--
 .../skriptparser/lang/ExpressionList.java     |  10 +-
 .../syst3ms/skriptparser/lang/Literal.java    |   9 +-
 .../skriptparser/lang/LiteralList.java        |   1 +
 .../skriptparser/lang/SimpleCodeSection.java  |  36 +-
 .../skriptparser/lang/SimpleExpression.java   |   3 +-
 .../skriptparser/lang/SimpleLiteral.java      |   3 +-
 .../syst3ms/skriptparser/lang/Statement.java  |  75 +-
 .../skriptparser/lang/SyntaxElement.java      |  53 +-
 .../skriptparser/lang/UnloadedTrigger.java    |  36 +-
 .../syst3ms/skriptparser/lang/Variable.java   |  26 +-
 .../skriptparser/lang/VariableString.java     |  18 +-
 .../lang/base/ConditionalExpression.java      |   5 +-
 .../lang/base/ConvertedExpression.java        |  17 +-
 .../lang/base/ExecutableExpression.java       |   5 +-
 .../lang/base/RestrictedExpression.java       |  14 +-
 .../lang/base/TaggedExpression.java           |  66 +-
 .../lang/control/Continuable.java             |  24 +-
 .../skriptparser/lang/control/Finishing.java  |  38 +-
 .../lang/control/SelfReferencing.java         |  20 +-
 .../lang/entries/EntryLoader.java             |  51 +-
 .../lang/entries/LiteralLoader.java           | 116 +--
 .../lang/entries/OptionLoader.java            |  80 +-
 .../lang/entries/SectionConfiguration.java    |  12 +-
 .../lang/entries/SectionLoader.java           |  34 +-
 .../lang/lambda/ArgumentSection.java          |   2 +
 .../lang/lambda/ReturnSection.java            |   3 +
 .../lang/lambda/SectionValue.java             |  28 +-
 .../lang/properties/ConditionalType.java      |  30 +-
 .../lang/properties/PropertyConditional.java  |  67 +-
 .../lang/properties/PropertyExpression.java   |  41 +-
 .../skriptparser/parsing/ParserState.java     |   4 +-
 .../skriptparser/parsing/ScriptLoader.java    |  12 +-
 .../skriptparser/parsing/SyntaxParser.java    |  20 +-
 .../pattern/ExpressionElement.java            |   2 +-
 .../skriptparser/pattern/PatternParser.java   |   2 +-
 .../registration/DefaultRegistration.java     |   6 +-
 .../registration/ExpressionInfo.java          |   1 +
 .../registration/PatternInfos.java            |   3 +
 .../registration/SkriptAddon.java             |  21 +-
 .../registration/SkriptEventInfo.java         |   1 +
 .../registration/SkriptRegistration.java      | 117 ++-
 .../skriptparser/registration/SyntaxInfo.java |   6 +-
 .../registration/context/ContextValues.java   |   8 +-
 .../registration/tags/ContinuousTag.java      |  28 +-
 .../skriptparser/registration/tags/Tag.java   |  85 +-
 .../registration/tags/TagInfo.java            |  25 +-
 .../registration/tags/TagManager.java         |  20 +-
 .../skriptparser/sections/SecAsync.java       |   2 +-
 .../skriptparser/sections/SecCase.java        |  44 +-
 .../skriptparser/sections/SecConditional.java |  19 +-
 .../skriptparser/sections/SecFilter.java      |  23 +-
 .../skriptparser/sections/SecFlatMap.java     | 131 ++-
 .../skriptparser/sections/SecLoop.java        |  36 +-
 .../syst3ms/skriptparser/sections/SecMap.java |   5 +-
 .../skriptparser/sections/SecSwitch.java      |   8 +-
 .../skriptparser/sections/SecWhile.java       |   2 +-
 .../functions/DefaultFunctions.java           |   2 +-
 .../structures/functions/EffFunctionCall.java |  37 +-
 .../functions/ExprFunctionCall.java           |  29 +-
 .../structures/functions/Function.java        |  14 +-
 .../structures/functions/FunctionContext.java |  12 +-
 .../functions/FunctionParameter.java          |  34 +-
 .../structures/functions/Functions.java       |   5 +-
 .../structures/functions/ScriptFunction.java  |   6 +-
 .../structures/functions/StructFunction.java  |   2 +-
 .../syst3ms/skriptparser/tags/TagCase.java    |  44 +-
 .../syst3ms/skriptparser/tags/TagReset.java   |  31 +-
 .../tags/TagSpecialCharacters.java            |  83 +-
 .../skriptparser/types/PatternType.java       |  20 +-
 .../syst3ms/skriptparser/types/Type.java      |   3 +-
 .../skriptparser/types/TypeManager.java       |   9 +-
 .../types/changers/Arithmetic.java            |   1 +
 .../skriptparser/types/changers/Changer.java  |   6 +-
 .../types/changers/TypeSerializer.java        |   8 +-
 .../types/comparisons/Comparator.java         |   1 +
 .../types/comparisons/ComparatorInfo.java     |  26 +-
 .../types/comparisons/Comparators.java        |  30 +-
 .../types/comparisons/InverseComparator.java  |   1 +
 .../types/conversions/ChainedConverter.java   |   4 +-
 .../types/conversions/ConverterInfo.java      |  26 +-
 .../types/conversions/ConverterUtils.java     |  24 +-
 .../types/conversions/Converters.java         | 194 ++--
 .../skriptparser/types/ranges/RangeInfo.java  |  24 +-
 .../skriptparser/types/ranges/Ranges.java     |   4 +-
 .../syst3ms/skriptparser/util/ClassUtils.java |   2 +-
 .../skriptparser/util/CollectionUtils.java    |   7 +-
 .../skriptparser/util/DoubleOptional.java     |  71 +-
 .../skriptparser/util/DurationUtils.java      |  11 +-
 .../syst3ms/skriptparser/util/FileUtils.java  |  10 +-
 .../syst3ms/skriptparser/util/MultiMap.java   |   2 +-
 .../skriptparser/util/NumberUtils.java        |  62 +-
 .../syst3ms/skriptparser/util/Pair.java       |  20 +-
 .../skriptparser/util/RecentElementList.java  |  12 +-
 .../syst3ms/skriptparser/util/SkriptDate.java |  24 +-
 .../skriptparser/util/StringUtils.java        |  45 +-
 .../skriptparser/util/ThreadUtils.java        | 152 +--
 .../syst3ms/skriptparser/util/Time.java       |  29 +-
 .../skriptparser/util/color/Color.java        |  21 +-
 .../util/math/AsinCalculator.java             |  61 +-
 .../util/math/BigDecimalMath.java             |  28 +-
 .../skriptparser/util/math/BigRational.java   | 946 +++++++++---------
 .../skriptparser/util/math/CosCalculator.java |  67 +-
 .../skriptparser/util/math/ExpCalculator.java |  55 +-
 .../skriptparser/util/math/NumberMath.java    |  68 +-
 .../skriptparser/util/math/PowerIterator.java |  35 +-
 .../util/math/PowerNIterator.java             |  49 +-
 .../util/math/PowerTwoNIterator.java          |  49 +-
 .../util/math/PowerTwoNPlusOneIterator.java   |  49 +-
 .../util/math/SeriesCalculator.java           | 201 ++--
 .../skriptparser/util/math/SinCalculator.java |  69 +-
 .../variables/SerializedVariable.java         |  43 +-
 .../skriptparser/variables/VariableMap.java   |  12 +-
 .../variables/VariableStorage.java            |  39 +-
 .../skriptparser/variables/Variables.java     |  41 +-
 152 files changed, 3415 insertions(+), 3418 deletions(-)
 create mode 100644 .editorconfig
 create mode 100644 config/checkstyle/checkstyle.xml
 delete mode 100644 src/main/java/io/github/syst3ms/skriptparser/expressions/ExprPrimeNumber.java

diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..772fe705
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,23 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 120
+tab_width = 4
+trim_trailing_whitespace = true
+ij_continuation_indent_size = 4
+[*.java]
+ij_java_class_count_to_use_import_on_demand = 1024
+ij_java_names_count_to_use_import_on_demand = 1024
+[*.yml]
+indent_size = 2
+[*.json]
+indent_size = 2
+[*.md]
+trim_trailing_whitespace=false
+[*.sk]
+indent_style = tab
diff --git a/build.gradle.kts b/build.gradle.kts
index fd38e5a5..f2d425af 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,6 +1,7 @@
 plugins {
     id("java")
     id("maven-publish")
+    id("checkstyle")
 }
 group = "com.github.SkriptDev"
 version = "1.0.6"
@@ -56,6 +57,17 @@ tasks {
     java {
         withSourcesJar()
     }
+    checkstyle {
+        // Specify the version of the Checkstyle tool to use
+        toolVersion = "10.21.0" // Use a recent version of Checkstyle
+
+        isIgnoreFailures = false
+
+        // Point to your custom Checkstyle configuration file
+        // The default location is config/checkstyle/checkstyleMain.xml
+        configFile = file("${rootProject.projectDir}/config/checkstyle/checkstyle.xml")
+    }
+
     publishing {
         publications {
             create<MavenPublication>("maven") {
diff --git a/config/checkstyle/checkstyle.xml b/config/checkstyle/checkstyle.xml
new file mode 100644
index 00000000..22c57fb3
--- /dev/null
+++ b/config/checkstyle/checkstyle.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC
+        "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+        "https://checkstyle.org/dtds/configuration_1_3.dtd">
+
+
+
+<module name="Checker">
+    <module name="LineLength">
+        <property name="max" value="300"/>
+    </module>
+    <property name="charset" value="UTF-8"/>
+    <property name="severity" value="error"/>
+    <property name="fileExtensions" value="java, properties, xml"/>
+
+    <module name="BeforeExecutionExclusionFileFilter">
+        <property name="fileNamePattern" value="module\-info\.java$"/>
+    </module>
+
+    <module name="TreeWalker">
+        <module name="RegexpSinglelineJava">
+            <property name="format" value="\t"/>
+            <property name="message" value="Tab characters are not allowed in code."/>
+            <property name="ignoreComments" value="true"/>
+        </module>
+        <module name="SuppressWithNearbyCommentFilter">
+            <property name="commentFormat" value="OK TO COMMENT"/>
+            <property name="checkFormat" value=".*"/>
+        </module>
+        <module name="AnnotationLocation">
+            <property name="id" value="AnnotationLocationMostCases"/>
+            <property name="tokens" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF"/>
+        </module>
+
+        <module name="LeftCurly"/>
+        <module name="RightCurly"/>
+        <module name="WhitespaceAround">
+            <property name="allowEmptyConstructors" value="true"/>
+            <property name="allowEmptyMethods" value="true"/>
+            <property name="allowEmptyTypes" value="true"/>
+            <property name="allowEmptyLoops" value="true"/>
+        </module>
+
+        <module name="PackageName">
+            <property name="format" value="^[a-z]+(\.[a-z][a-z0-z0-9]*)*$"/>
+        </module>
+        <module name="TypeName"/>
+        <module name="MemberName"/>
+        <module name="ParameterName"/>
+        <module name="LocalVariableName"/>
+
+        <module name="AvoidStarImport"/>
+        <module name="UnusedImports"/>
+        <module name="RedundantImport"/>
+
+        <module name="EmptyStatement"/>
+        <module name="SimplifyBooleanExpression"/>
+        <module name="SimplifyBooleanReturn"/>
+
+        <property name="tabWidth" value="4"/>
+    </module>
+</module>
diff --git a/src/main/java/io/github/syst3ms/skriptparser/effects/EffExit.java b/src/main/java/io/github/syst3ms/skriptparser/effects/EffExit.java
index 8b0647d1..690ef6d6 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/effects/EffExit.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/effects/EffExit.java
@@ -39,7 +39,10 @@ public class EffExit extends Effect {
                 "(exit|stop) %*integer% (0:section|1:loop|2:condition[al])[s]",
                 "(exit|stop) (every|all [[of] the]) (0:section|1:loop|2:condition[al])[s]")
             .name("Exit")
-            .description("Exits the entire trigger, preventing all upcoming statements to not get triggered. There's also a possibility to only exit certain sections. If more sections are exited than the total amount of nested sections, the trigger will stop. Note that stopping loops also stops while-loops.")
+            .description("Exits the entire trigger, preventing all upcoming statements to not get triggered",
+                "There's also a possibility to only exit certain sections.",
+                "If more sections are exited than the total amount of nested sections, the trigger will stop.",
+                "Note that stopping loops also stops while-loops.")
             .since("1.0.0")
             .register();
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/effects/EffReturn.java b/src/main/java/io/github/syst3ms/skriptparser/effects/EffReturn.java
index 8a7d6f83..e50d45ab 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/effects/EffReturn.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/effects/EffReturn.java
@@ -114,7 +114,7 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
         });
         if (isInFunction) {
             FunctionContext functionContext = (FunctionContext) ctx;
-            Function<?> function = functionContext.getOwningFunction();
+            Function<?> function = functionContext.owningFunction();
             function.setReturnValue(returned.getValues(ctx));
             return Optional.empty(); // stop the trigger
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprChance.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprChance.java
index 801f0941..2540e2ac 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprChance.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprChance.java
@@ -10,6 +10,8 @@
 
 public class CondExprChance extends ConditionalExpression {
 
+    private static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();
+
     static {
         Parser.getMainRegistration().newExpression(CondExprChance.class, Boolean.class,
                 true, "chance of %number%[1:\\%]")
@@ -22,8 +24,6 @@ public class CondExprChance extends ConditionalExpression {
             .register();
     }
 
-    private static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();
-
     private Expression<Number> chance;
     private boolean percent;
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java
index f3cef0f5..cdbfde27 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java
@@ -40,14 +40,14 @@
  */
 public class CondExprCompare extends ConditionalExpression {
     public static final PatternInfos<Relation> PATTERNS = new PatternInfos<>(new Object[][]{
-            {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) (greater|more|higher|bigger|larger|above) [than] or (equal to|the same as)|\\>=) %objects% [0x10:each|0x18:respectively]", Relation.GREATER_OR_EQUAL},
-            {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) (less|smaller|below) [than] or (equal to|the same as)|\\<=) %objects% [0x10:each|0x18:respectively]", Relation.SMALLER_OR_EQUAL},
-            {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) ((greater|more|higher|bigger|larger) than|above)|\\>) %objects% [0x10:each|0x18:respectively]", Relation.GREATER},
-            {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) ((less|smaller) than|below)|\\<) %objects% [0x10:each|0x18:respectively]", Relation.SMALLER},
-            {"[1:neither] %objects% [8:each] (is|are)(2:n't [8:each]|2:[8: each] not) between %objects% and %objects% [0x10:each|0x18:respectively]", Relation.EQUAL},
-            {"[1:neither] %objects% [8:each] (is|are) [8:each] between %objects% and %objects% [0x10:each|0x18:respectively]", Relation.EQUAL},
-            {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)) [equal to]|2:!=) %objects% [0x10:each|0x18:respectively]", Relation.EQUAL},
-            {"[1:neither] %objects% [8:each] ((is|are) [8:each] [equal to|the same as]|=[=]) %objects% [0x10:each|0x18:respectively]", Relation.EQUAL}
+        {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) (greater|more|higher|bigger|larger|above) [than] or (equal to|the same as)|\\>=) %objects% [0x10:each|0x18:respectively]", Relation.GREATER_OR_EQUAL},
+        {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) (less|smaller|below) [than] or (equal to|the same as)|\\<=) %objects% [0x10:each|0x18:respectively]", Relation.SMALLER_OR_EQUAL},
+        {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) ((greater|more|higher|bigger|larger) than|above)|\\>) %objects% [0x10:each|0x18:respectively]", Relation.GREATER},
+        {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)| [8:each]) ((less|smaller) than|below)|\\<) %objects% [0x10:each|0x18:respectively]", Relation.SMALLER},
+        {"[1:neither] %objects% [8:each] (is|are)(2:n't [8:each]|2:[8: each] not) between %objects% and %objects% [0x10:each|0x18:respectively]", Relation.EQUAL},
+        {"[1:neither] %objects% [8:each] (is|are) [8:each] between %objects% and %objects% [0x10:each|0x18:respectively]", Relation.EQUAL},
+        {"[1:neither] %objects% [8:each] ((is|are)(2:(n't [8:each]|[8: each] not|4:[8: each] neither)) [equal to]|2:!=) %objects% [0x10:each|0x18:respectively]", Relation.EQUAL},
+        {"[1:neither] %objects% [8:each] ((is|are) [8:each] [equal to|the same as]|=[=]) %objects% [0x10:each|0x18:respectively]", Relation.EQUAL}
     });
 
     static {
@@ -74,6 +74,14 @@ public class CondExprCompare extends ConditionalExpression {
     private boolean firstEach;
     private boolean secondEach;
 
+    private static String errorString(Expression<?> expr, boolean debug) {
+        if (expr.getReturnType() == Object.class)
+            return expr.toString(TriggerContext.DUMMY, debug);
+        Optional<? extends Type<?>> exprType = TypeManager.getByClass(expr.getReturnType());
+        assert exprType.isPresent();
+        return StringUtils.withIndefiniteArticle(exprType.get().getBaseName(), !expr.isSingle());
+    }
+
     @SuppressWarnings("null")
     @Override
     public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext result) {
@@ -88,7 +96,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             setNegated(true);
         if ((parseMark & 1) != 0) // "neither" on the left side
             setNegated(!isNegated());
-        if ((parseMark & 4) != 0) {// "neither" on the right side
+        if ((parseMark & 4) != 0) { // "neither" on the right side
             if (second instanceof ExpressionList) {
                 second.setAndList(!second.isAndList());
             }
@@ -101,42 +109,42 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             if (firstEach && secondEach && first.isSingle() && second.isSingle() && (third == null || third.isSingle())) {
                 logger.warn("Using \"respectively\" or two \"each\" options on single values is redundant");
             } else if (firstEach
-                    && secondEach
-                    && (first.isAndList() != second.isAndList() ||
-                        first.isSingle() != second.isSingle())) {
+                && secondEach
+                && (first.isAndList() != second.isAndList() ||
+                first.isSingle() != second.isSingle())) {
                 /*
                  * Here we want to rule out some obviously impossible combinations:
                  *  - Respectively comparing a single value and a list
                  *  - Respectively comparing lists that aren't both "and" or "or"
                  */
                 logger.error(
-                        "'" +
-                                first.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                                "' and '" +
-                                second.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                                "' cannot be compared respectively",
-                        ErrorType.SEMANTIC_ERROR
+                    "'" +
+                        first.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                        "' and '" +
+                        second.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                        "' cannot be compared respectively",
+                    ErrorType.SEMANTIC_ERROR
                 );
                 return false;
             } else if (third != null
-                    && secondEach
-                    && (firstEach && first.isAndList() != second.isAndList()
-                        || second.isAndList() != third.isAndList()
-                        || firstEach && first.isSingle() != second.isSingle()
-                        || second.isSingle() != third.isSingle())) {
+                && secondEach
+                && (firstEach && first.isAndList() != second.isAndList()
+                || second.isAndList() != third.isAndList()
+                || firstEach && first.isSingle() != second.isSingle()
+                || second.isSingle() != third.isSingle())) {
                 /*
                  * What is ruled out here is using "each" when "second" and "third" don't match in number or in and/or type.
                  * Otherwise these are fundamentally the same checks as above but when "third" is present.
                  */
                 logger.error(
-                        "'" +
-                                first.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                                "' cannot be compared respectively with '" +
-                                second.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                                "' and '" +
-                                third.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                                "'",
-                        ErrorType.SEMANTIC_ERROR
+                    "'" +
+                        first.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                        "' cannot be compared respectively with '" +
+                        second.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                        "' and '" +
+                        third.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                        "'",
+                    ErrorType.SEMANTIC_ERROR
                 );
                 return false;
             } else if (firstEach && first.isSingle()) {
@@ -164,30 +172,30 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
          * two lists order-insensitively.
          */
         contentComparison = third == null
-                && relation == Relation.EQUAL
-                && !(firstEach || secondEach)
-                && !(first.isSingle() || second.isSingle());
+            && relation == Relation.EQUAL
+            && !(firstEach || secondEach)
+            && !(first.isSingle() || second.isSingle());
 
         if (!initComparator()) {
             if (third == null) {
                 logger.error(
-                        "'" +
+                    "'" +
                         first.toString(TriggerContext.DUMMY, logger.isDebug()) +
                         "' and '" +
                         second.toString(TriggerContext.DUMMY, logger.isDebug()) +
                         "' cannot be compared",
-                        ErrorType.SEMANTIC_ERROR
+                    ErrorType.SEMANTIC_ERROR
                 );
             } else {
                 logger.error(
-                        "'" +
+                    "'" +
                         first.toString(TriggerContext.DUMMY, logger.isDebug()) +
                         "' cannot be compared with '" +
                         second.toString(TriggerContext.DUMMY, logger.isDebug()) +
                         "' and '" +
                         third.toString(TriggerContext.DUMMY, logger.isDebug()) +
                         "'",
-                        ErrorType.SEMANTIC_ERROR
+                    ErrorType.SEMANTIC_ERROR
                 );
             }
             return false;
@@ -197,7 +205,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                 return relation.isEqualOrInverse() || comparator.supportsOrdering();
             } else if (!comparator.supportsOrdering()) {
                 logger.error(
-                        errorString(first, logger.isDebug()) +
+                    errorString(first, logger.isDebug()) +
                         " cannot be ordered between " +
                         errorString(second, logger.isDebug()) +
                         " and " +
@@ -212,8 +220,8 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     private boolean initComparator() {
         Class<?> f = first.getReturnType();
         Class<?> s = third == null
-                ? second.getReturnType()
-                : ClassUtils.getCommonSuperclass(second.getReturnType(), third.getReturnType());
+            ? second.getReturnType()
+            : ClassUtils.getCommonSuperclass(second.getReturnType(), third.getReturnType());
 
         if (f == Object.class || s == Object.class) {
             return true;
@@ -221,40 +229,6 @@ private boolean initComparator() {
         return (comparator = (Comparator<Object, Object>) Comparators.getComparator(f, s).orElse(null)) != null;
     }
 
-    /*
-     * # := condition (e.g. is, is less than, contains, is enchanted with, has permission, etc.)
-     * !# := not #
-     *
-     * a and b # x === a # x && b # x
-     * a or b # x === a # x || b # x
-     * a # x and y === a # x && a # y
-     * a # x or y === a # x || a # y
-     * a and b # x and y === a # x and y && b # x and y === a # x && a # y && b # x && b # y
-     * a and b # x or y === a # x or y && b # x or y
-     * a or b # x and y === a # x and y || b # x and y
-     * a or b # x or y === a # x or y || b # x or y
-     *
-     *
-     * a and b !# x === a !# x && b !# x
-     * neither a nor b # x === a !# x && b !# x		// nor = and
-     * a or b !# x === a !# x || b !# x
-     *
-     * a !# x and y === a !# x || a !# y							// e.g. "player doesn't have 2 emeralds and 5 gold ingots" == "NOT(player has 2 emeralds and 5 gold ingots)" == "player doesn't have 2 emeralds OR player doesn't have 5 gold ingots"
-     * a # neither x nor y === a !# x && a !# y		// nor = or 	// e.g. "player has neither 2 emeralds nor 5 gold ingots" == "player doesn't have 2 emeralds AND player doesn't have 5 gold ingots"
-     * a # neither x nor y === a !# x && a !# y		// nor = or 	// e.g. "player is neither the attacker nor the victim" == "player is not the attacker AND player is not the victim"
-     * a !# x or y === a !# x && a !# y								// e.g. "player doesn't have 2 emeralds or 5 gold ingots" == "NOT(player has 2 emeralds or 5 gold ingots)" == "player doesn't have 2 emeralds AND player doesn't have 5 gold ingots"
-     *
-     * a and b !# x and y === a !# x and y && b !# x and y === (a !# x || a !# y) && (b !# x || b !# y)
-     * a and b !# x or y === a !# x or y && b !# x or y
-     * a and b # neither x nor y === a # neither x nor y && b # neither x nor y
-     *
-     * a or b !# x and y === a !# x and y || b !# x and y
-     * a or b !# x or y === a !# x or y || b !# x or y
-     * a or b # neither x nor y === a # neither x nor y || b # neither x nor y
-     *
-     * neither a nor b # x and y === a !# x and y && b !# x and y		// nor = and
-     * neither a nor b # x or y === a !# x or y && b !# x or y			// nor = and
-     */
     @Override
     public boolean check(TriggerContext ctx) {
         Object[] firstValues = first.getArray(ctx);
@@ -270,8 +244,8 @@ public boolean check(TriggerContext ctx) {
                 for (int i = 0; i < firstValues.length; i++) {
                     hasElement = true;
                     boolean b = fullCompare(
-                            Arrays.copyOfRange(firstValues, i, i+1),
-                            Arrays.copyOfRange(secondValues, i, i+1)
+                        Arrays.copyOfRange(firstValues, i, i + 1),
+                        Arrays.copyOfRange(secondValues, i, i + 1)
                     );
                     if (and && !b)
                         return false;
@@ -285,17 +259,17 @@ public boolean check(TriggerContext ctx) {
                 return hasElement && and;
             } else if (firstEach) {
                 return Expression.check(
-                        firstValues,
-                        f -> fullCompare(new Object[]{f}, secondValues),
-                        false,
-                        first.isAndList()
+                    firstValues,
+                    f -> fullCompare(new Object[]{f}, secondValues),
+                    false,
+                    first.isAndList()
                 );
             } else if (secondEach) {
                 return Expression.check(
-                        secondValues,
-                        s -> fullCompare(firstValues, new Object[]{s}),
-                        false,
-                        second.isAndList()
+                    secondValues,
+                    s -> fullCompare(firstValues, new Object[]{s}),
+                    false,
+                    second.isAndList()
                 );
             } else {
                 return fullCompare(firstValues, secondValues);
@@ -309,9 +283,9 @@ public boolean check(TriggerContext ctx) {
             for (int i = 0; i < firstValues.length; i++) {
                 hasElement = true;
                 boolean b = fullCompareWithThird(
-                        Arrays.copyOfRange(firstValues, i, i+1),
-                        Arrays.copyOfRange(secondValues, i, i+1),
-                        Arrays.copyOfRange(thirdValues, i, i+1)
+                    Arrays.copyOfRange(firstValues, i, i + 1),
+                    Arrays.copyOfRange(secondValues, i, i + 1),
+                    Arrays.copyOfRange(thirdValues, i, i + 1)
                 );
                 if (and && !b)
                     return false;
@@ -321,10 +295,10 @@ public boolean check(TriggerContext ctx) {
             return hasElement && and;
         } else if (firstEach) {
             return Expression.check(
-                    firstValues,
-                    f -> fullCompareWithThird(new Object[]{f}, secondValues, thirdValues),
-                    false,
-                    first.isAndList()
+                firstValues,
+                f -> fullCompareWithThird(new Object[]{f}, secondValues, thirdValues),
+                false,
+                first.isAndList()
             );
         } else if (secondEach) {
             if (secondValues.length != thirdValues.length)
@@ -335,9 +309,9 @@ public boolean check(TriggerContext ctx) {
             for (int i = 0; i < secondValues.length; i++) {
                 hasElement = true;
                 boolean b = fullCompareWithThird(
-                        firstValues,
-                        Arrays.copyOfRange(secondValues, i, i+1),
-                        Arrays.copyOfRange(thirdValues, i, i+1)
+                    firstValues,
+                    Arrays.copyOfRange(secondValues, i, i + 1),
+                    Arrays.copyOfRange(thirdValues, i, i + 1)
                 );
                 if (and && !b)
                     return false;
@@ -353,19 +327,19 @@ public boolean check(TriggerContext ctx) {
     private boolean fullCompare(Object[] firstValues, Object[] secondValues) {
         if (!contentComparison) {
             return Expression.check(
-                    firstValues,
-                    o1 -> Expression.check(
-                            secondValues,
-                            o2 -> relation.is(
-                                    comparator != null ?
-                                            comparator.apply(o1, o2)
-                                            : Comparators.compare(o1, o2)
-                            ),
-                            false,
-                            second.isAndList()
+                firstValues,
+                o1 -> Expression.check(
+                    secondValues,
+                    o2 -> relation.is(
+                        comparator != null ?
+                            comparator.apply(o1, o2)
+                            : Comparators.compare(o1, o2)
                     ),
-                    isNegated(),
-                    first.isAndList()
+                    false,
+                    second.isAndList()
+                ),
+                isNegated(),
+                first.isAndList()
             );
         } else {
             if (firstValues.length != secondValues.length)
@@ -393,38 +367,38 @@ private boolean fullCompare(Object[] firstValues, Object[] secondValues) {
     private boolean fullCompareWithThird(Object[] firstValues, Object[] secondValues, Object[] thirdValues) {
         assert third != null;
         return Expression.check(
-                firstValues,
-                o1 -> Expression.check(
-                        secondValues,
-                        o2 -> Expression.check(
-                                thirdValues,
-                                o3 -> {
-                                    boolean isBetween;
-                                    if (comparator != null) {
-                                        isBetween =
-                                                (Relation.GREATER_OR_EQUAL.is(comparator.apply(o1, o2)) &&
-                                                        Relation.SMALLER_OR_EQUAL.is(comparator.apply(o1, o3)))
-                                                        || // Check OPPOSITE (switching o2 / o3)
-                                                        (Relation.GREATER_OR_EQUAL.is(comparator.apply(o1, o3)) &&
-                                                                Relation.SMALLER_OR_EQUAL.is(comparator.apply(o1, o2)));
-                                    } else {
-                                        isBetween =
-                                                (Relation.GREATER_OR_EQUAL.is(Comparators.compare(o1, o2)) &&
-                                                        Relation.SMALLER_OR_EQUAL.is(Comparators.compare(o1, o3)))
-                                                        || // Check OPPOSITE (switching o2 / o3)
-                                                        (Relation.GREATER_OR_EQUAL.is(Comparators.compare(o1, o3)) &&
-                                                                Relation.SMALLER_OR_EQUAL.is(Comparators.compare(o1, o2)));
-                                    }
-                                    return relation == Relation.NOT_EQUAL != isBetween;
-                                },
-                                false,
-                                third.isAndList()
-                        ),
-                        false,
-                        second.isAndList()
+            firstValues,
+            o1 -> Expression.check(
+                secondValues,
+                o2 -> Expression.check(
+                    thirdValues,
+                    o3 -> {
+                        boolean isBetween;
+                        if (comparator != null) {
+                            isBetween =
+                                (Relation.GREATER_OR_EQUAL.is(comparator.apply(o1, o2)) &&
+                                    Relation.SMALLER_OR_EQUAL.is(comparator.apply(o1, o3)))
+                                    || // Check OPPOSITE (switching o2 / o3)
+                                    (Relation.GREATER_OR_EQUAL.is(comparator.apply(o1, o3)) &&
+                                        Relation.SMALLER_OR_EQUAL.is(comparator.apply(o1, o2)));
+                        } else {
+                            isBetween =
+                                (Relation.GREATER_OR_EQUAL.is(Comparators.compare(o1, o2)) &&
+                                    Relation.SMALLER_OR_EQUAL.is(Comparators.compare(o1, o3)))
+                                    || // Check OPPOSITE (switching o2 / o3)
+                                    (Relation.GREATER_OR_EQUAL.is(Comparators.compare(o1, o3)) &&
+                                        Relation.SMALLER_OR_EQUAL.is(Comparators.compare(o1, o2)));
+                        }
+                        return relation == Relation.NOT_EQUAL != isBetween;
+                    },
+                    false,
+                    third.isAndList()
                 ),
-                isNegated(),
-                first.isAndList()
+                false,
+                second.isAndList()
+            ),
+            isNegated(),
+            first.isAndList()
         );
     }
 
@@ -434,27 +408,19 @@ public String toString(TriggerContext ctx, boolean debug) {
         Expression<?> third = this.third;
         if (third == null) {
             s = first.toString(ctx, debug) + " is " + (isNegated() ? "not " : "") + relation + " " + second.toString(
-                    ctx, debug);
+                ctx, debug);
         } else {
             s = first.toString(ctx, debug) +
-                    " is " +
-                    (isNegated() ? "not " : "") +
-                    "between " +
-                    second.toString(ctx, debug) +
-                    " and " +
-                    third.toString(ctx, debug);
+                " is " +
+                (isNegated() ? "not " : "") +
+                "between " +
+                second.toString(ctx, debug) +
+                " and " +
+                third.toString(ctx, debug);
         }
         if (debug) {
             s += " (comparator: " + comparator + ")";
         }
         return s;
     }
-
-    private static String errorString(Expression<?> expr, boolean debug) {
-        if (expr.getReturnType() == Object.class)
-            return expr.toString(TriggerContext.DUMMY, debug);
-        Optional<? extends Type<?>> exprType = TypeManager.getByClass(expr.getReturnType());
-        assert exprType.isPresent();
-        return StringUtils.withIndefiniteArticle(exprType.get().getBaseName(), !expr.isSingle());
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprContains.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprContains.java
index 0d478fb5..b8e1c06d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprContains.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprContains.java
@@ -16,12 +16,12 @@
  * See if a given list of objects contain a given element.
  * You can also check if a string contains another string.
  *
+ * @author Mwexim
  * @name Contain
  * @type CONDITION
  * @pattern %string% [does(n't| not)] contain[s] %string%
  * @pattern %objects% [do[es](n't| not)] contain[s] %objects%
  * @since ALPHA
- * @author Mwexim
  */
 public class CondExprContains extends ConditionalExpression {
     static {
@@ -52,16 +52,16 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         comparator = (Comparator<Object, Object>) Comparators.getComparator(first.getReturnType(), second.getReturnType()).orElse(null);
         // If the expressions are variables, their return type is unknown at parse time
         if (first.getReturnType() != Object.class
-                && second.getReturnType() != Object.class
-                && comparator == null) {
+            && second.getReturnType() != Object.class
+            && comparator == null) {
             var logger = parseContext.getLogger();
             logger.error(
-                    "'" +
+                "'" +
                     first.toString(TriggerContext.DUMMY, logger.isDebug()) +
                     "' can never contain '" +
                     second.toString(TriggerContext.DUMMY, logger.isDebug()) +
                     "' because their values cannot be compared",
-                    ErrorType.SEMANTIC_ERROR
+                ErrorType.SEMANTIC_ERROR
             );
             return false;
         }
@@ -70,9 +70,9 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         setNegated(parseContext.getNumericMark() == 1);
         if (!onlyString && !first.isAndList()) {
             parseContext.getLogger().error(
-                    "An or-list cannot contain any values",
-                    ErrorType.SEMANTIC_ERROR,
-                    "If you want to check if an or-list 'contains' a value, you should do an equality check instead."
+                "An or-list cannot contain any values",
+                ErrorType.SEMANTIC_ERROR,
+                "If you want to check if an or-list 'contains' a value, you should do an equality check instead."
             );
             return false;
         }
@@ -83,19 +83,19 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     public boolean check(TriggerContext ctx) {
         if (onlyString) {
             return isNegated() != DoubleOptional.ofOptional(first.getSingle(ctx), second.getSingle(ctx))
-                    .map(toCheck -> (String) toCheck, toMatch -> (String) toMatch)
-                    .mapToOptional(String::contains)
-                    .orElse(false);
+                .map(toCheck -> (String) toCheck, toMatch -> (String) toMatch)
+                .mapToOptional(String::contains)
+                .orElse(false);
         } else {
             return second.check(
-                    ctx,
-                    toMatch -> Expression.check(
-                            first.getValues(ctx),
-                            toCheck -> (comparator == null ? Comparators.compare(toCheck, toMatch) : comparator.apply(toCheck, toMatch)).is(Relation.EQUAL),
-                            false,
-                            !first.isAndList()
-                    ),
-                    isNegated()
+                ctx,
+                toMatch -> Expression.check(
+                    first.getValues(ctx),
+                    toCheck -> (comparator == null ? Comparators.compare(toCheck, toMatch) : comparator.apply(toCheck, toMatch)).is(Relation.EQUAL),
+                    false,
+                    !first.isAndList()
+                ),
+                isNegated()
             );
         }
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java
index 4556aa0d..ceef4a6c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsEmpty.java
@@ -12,11 +12,11 @@
  * If you want a string list to be checked as a list instead of all separate strings,
  * you should use the 'list' modifier at the end.
  *
+ * @author Olyno
  * @name Is Empty
  * @pattern %objects% (is|are)[( not|n't)] empty
  * @pattern %strings% (is|are)[( not|n't)] [an] empty string[s]
  * @since ALPHA
- * @author Olyno
  */
 public class CondExprIsEmpty extends ConditionalExpression {
     static {
@@ -52,8 +52,8 @@ public boolean check(TriggerContext ctx) {
         } else {
             var values = expression.getValues(ctx);
             return isNegated() != (values.length != 1
-                    ? values.length == 0
-                    : values[0] instanceof String && ((String) values[0]).isBlank());
+                ? values.length == 0
+                : values[0] instanceof String && ((String) values[0]).isBlank());
         }
     }
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsSet.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsSet.java
index 0c2e3f28..789725e3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsSet.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprIsSet.java
@@ -7,11 +7,11 @@
 /**
  * Check if a given expression is set (null on the Java side) or not.
  *
+ * @author Syst3ms
  * @name Is Set
  * @type CONDITION
  * @pattern %~objects% (is|are)[ not|n't] set
  * @since ALPHA
- * @author Syst3ms
  */
 public class CondExprIsSet extends PropertyConditional<Object> {
     static {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprMatch.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprMatch.java
index 1bd8d031..1407da66 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprMatch.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprMatch.java
@@ -11,11 +11,11 @@
 /**
  * Check if the given strings match a certain regex expression.
  *
+ * @author Mwexim
  * @name Match
  * @type CONDITION
  * @pattern %strings% [do[es](n't| not)] [part[ial]ly] match[es] %strings%
  * @since ALPHA
- * @author Mwexim
  */
 public class CondExprMatch extends ConditionalExpression {
     static {
@@ -45,21 +45,21 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     @Override
     public boolean check(TriggerContext ctx) {
         return matched.check(
+            ctx,
+            toMatch -> pattern.check(
                 ctx,
-                toMatch -> pattern.check(
-                        ctx,
-                        pattern -> partly ? Pattern.compile(pattern).matcher(toMatch).find() : toMatch.matches(pattern)
-                ),
-                isNegated()
+                pattern -> partly ? Pattern.compile(pattern).matcher(toMatch).find() : toMatch.matches(pattern)
+            ),
+            isNegated()
         );
     }
 
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
         return matched.toString(ctx, debug)
-                + (isNegated() ? " does not" : "")
-                + (partly ? " partially" : "")
-                + (isNegated() ? " match " : " matches ")
-                + pattern.toString(ctx, debug);
+            + (isNegated() ? " does not" : "")
+            + (partly ? " partially" : "")
+            + (isNegated() ? " match " : " matches ")
+            + pattern.toString(ctx, debug);
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java
index bbd0576b..e6a887c0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java
@@ -29,195 +29,195 @@
  * when a negative step function is used, the list is reversed as well as the lower and upper bounds,
  * which means the lower bound must be higher than the upper bound.
  *
+ * @author Mwexim
  * @name List Operators
  * @type EFFECT/EXPRESSION
  * @pattern extract [the] (last|first|%integer%(st|nd|rd|th)) element out [of] %objects%
  * @pattern pop %objects%
- * @pattern (shift|poll) %objects%
+ * @pattern (shift | poll) %objects%
  * @pattern splice %objects% (from %integer% to %integer%|starting (at|from) %integer%|up to %integer%) [[with] step %integer%]
- * @since ALPHA
- * @author Mwexim
  * @see ExprElement
+ * @since ALPHA
  */
 public class ExecExprListOperators extends ExecutableExpression<Object> {
-	static {
-		Parser.getMainRegistration().addExecutableExpression(
-				ExecExprListOperators.class,
-				Object.class,
-				false,
-				"extract [the] (0:last|1:first|2:%integer%(st|nd|rd|th)) element out [of] %objects%",
-				"pop %objects%",
-				"(shift|poll) %objects%",
-				"splice %objects% (0:from %integer% to %integer%|1:starting (at|from) %integer%|2:up to %integer%) [[with] step %integer%]"
-		);
-	}
+    static {
+        Parser.getMainRegistration().addExecutableExpression(
+            ExecExprListOperators.class,
+            Object.class,
+            false,
+            "extract [the] (0:last|1:first|2:%integer%(st|nd|rd|th)) element out [of] %objects%",
+            "pop %objects%",
+            "(shift|poll) %objects%",
+            "splice %objects% (0:from %integer% to %integer%|1:starting (at|from) %integer%|2:up to %integer%) [[with] step %integer%]"
+        );
+    }
 
-	// 0 = last, 1 = first, 2 = indexed, 3 = spliced
-	private int type;
-	private Expression<Object> list;
-	private Expression<Integer> index;
-	private Expression<Integer> lower;
-	private Expression<Integer> upper;
-	private Expression<Integer> step;
+    // 0 = last, 1 = first, 2 = indexed, 3 = spliced
+    private int type;
+    private Expression<Object> list;
+    private Expression<Integer> index;
+    private Expression<Integer> lower;
+    private Expression<Integer> upper;
+    private Expression<Integer> step;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		switch (matchedPattern) {
-			case 0:
-				type = parseContext.getNumericMark();
-				list = (Expression<Object>) (type == 2 ? expressions[1] : expressions[0]);
-				if (type == 2)
-					index = (Expression<Integer>) expressions[0];
-				break;
-			case 1:
-			case 2:
-				type = matchedPattern - 1;
-				list = (Expression<Object>) expressions[0];
-				break;
-			case 3:
-				type = 3;
-				list = (Expression<Object>) expressions[0];
-				switch (parseContext.getNumericMark()) {
-					case 0:
-						lower = (Expression<Integer>) expressions[1];
-						upper = (Expression<Integer>) expressions[2];
-						if (expressions.length == 4)
-							step = (Expression<Integer>) expressions[3];
-						break;
-					case 1:
-						lower = (Expression<Integer>) expressions[1];
-						if (expressions.length == 3)
-							step = (Expression<Integer>) expressions[2];
-						break;
-					case 2:
-						upper = (Expression<Integer>) expressions[1];
-						if (expressions.length == 3)
-							step = (Expression<Integer>) expressions[2];
-						break;
-					default:
-						throw new IllegalStateException();
-				}
-		}
-		var logger = parseContext.getLogger();
-		if (!list.acceptsChange(ChangeMode.SET, list.getReturnType(), false)) {
-			logger.error(
-					list.toString(TriggerContext.DUMMY, logger.isDebug())
-							+ "' cannot be set to multiple values",
-					ErrorType.SEMANTIC_ERROR
-			);
-			return false;
-		} else if (list.isSingle()) {
-			logger.error(
-					list.toString(TriggerContext.DUMMY, logger.isDebug()) + " represents a single value",
-					ErrorType.SEMANTIC_ERROR,
-					"List operators only work on multiple objects at the same time"
-			);
-			return false;
-		}
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        switch (matchedPattern) {
+            case 0:
+                type = parseContext.getNumericMark();
+                list = (Expression<Object>) (type == 2 ? expressions[1] : expressions[0]);
+                if (type == 2)
+                    index = (Expression<Integer>) expressions[0];
+                break;
+            case 1:
+            case 2:
+                type = matchedPattern - 1;
+                list = (Expression<Object>) expressions[0];
+                break;
+            case 3:
+                type = 3;
+                list = (Expression<Object>) expressions[0];
+                switch (parseContext.getNumericMark()) {
+                    case 0:
+                        lower = (Expression<Integer>) expressions[1];
+                        upper = (Expression<Integer>) expressions[2];
+                        if (expressions.length == 4)
+                            step = (Expression<Integer>) expressions[3];
+                        break;
+                    case 1:
+                        lower = (Expression<Integer>) expressions[1];
+                        if (expressions.length == 3)
+                            step = (Expression<Integer>) expressions[2];
+                        break;
+                    case 2:
+                        upper = (Expression<Integer>) expressions[1];
+                        if (expressions.length == 3)
+                            step = (Expression<Integer>) expressions[2];
+                        break;
+                    default:
+                        throw new IllegalStateException();
+                }
+        }
+        var logger = parseContext.getLogger();
+        if (!list.acceptsChange(ChangeMode.SET, list.getReturnType(), false)) {
+            logger.error(
+                list.toString(TriggerContext.DUMMY, logger.isDebug())
+                    + "' cannot be set to multiple values",
+                ErrorType.SEMANTIC_ERROR
+            );
+            return false;
+        } else if (list.isSingle()) {
+            logger.error(
+                list.toString(TriggerContext.DUMMY, logger.isDebug()) + " represents a single value",
+                ErrorType.SEMANTIC_ERROR,
+                "List operators only work on multiple objects at the same time"
+            );
+            return false;
+        }
+        return true;
+    }
 
-	@Override
-	public Object[] getValues(TriggerContext ctx, boolean isEffect) {
-		var values = list.getValues(ctx);
-		if (values.length == 0)
-			return new Object[0];
+    @Override
+    public Object[] getValues(TriggerContext ctx, boolean isEffect) {
+        var values = list.getValues(ctx);
+        if (values.length == 0)
+            return new Object[0];
 
-		switch (type) {
-			case 0:
-				if (isEffect)
-					list.change(ctx, ChangeMode.SET, Arrays.copyOfRange(values, 0, values.length - 1));
-				return new Object[] {values[values.length - 1]};
-			case 1:
-				if (isEffect)
-					list.change(ctx, ChangeMode.SET, Arrays.copyOfRange(values, 1, values.length));
-				return new Object[] {values[0]};
-			case 2:
-				int ind = index.getSingle(ctx)
-						.filter(n -> Integer.signum(n) > 0 && n.compareTo(Integer.valueOf(values.length)) <= 0)
-						.map(n -> n.intValue() - 1)
-						.orElse(-1);
-				if (ind == -1) {
-					return new Object[0];
-				}
+        switch (type) {
+            case 0:
+                if (isEffect)
+                    list.change(ctx, ChangeMode.SET, Arrays.copyOfRange(values, 0, values.length - 1));
+                return new Object[]{values[values.length - 1]};
+            case 1:
+                if (isEffect)
+                    list.change(ctx, ChangeMode.SET, Arrays.copyOfRange(values, 1, values.length));
+                return new Object[]{values[0]};
+            case 2:
+                int ind = index.getSingle(ctx)
+                    .filter(n -> Integer.signum(n) > 0 && n.compareTo(Integer.valueOf(values.length)) <= 0)
+                    .map(n -> n.intValue() - 1)
+                    .orElse(-1);
+                if (ind == -1) {
+                    return new Object[0];
+                }
 
-				// When used as an effect
-				if (isEffect) {
-					var skipped = new Object[values.length - 1];
-					for (int i = 0, k = 0; i < values.length; i++) {
-						if (i == ind) {
-							continue;
-						}
-						skipped[k++] = values[i];
-					}
-					list.change(ctx, ChangeMode.SET, skipped);
-				}
-				return new Object[] {values[ind]};
-			case 3:
-				var low = lower != null
-						? lower.getSingle(ctx).filter(n -> Integer.signum(n) > 0).map(n -> n.intValue() - 1).orElse(-1)
-						: 0;
-				var up = upper != null
-						? upper.getSingle(ctx).filter(n -> n.compareTo(Integer.valueOf(values.length)) <= 0).map(Integer::intValue).orElse(values.length)
-						: values.length;
-				var st = step != null
-						? step.getSingle(ctx).filter(n -> Integer.signum(n) != 0 && n.compareTo(Integer.valueOf(-values.length)) >= 0 && n.compareTo(Integer.valueOf(values.length)) <= 0).map(Integer::intValue).orElse(0)
-						: 1;
+                // When used as an effect
+                if (isEffect) {
+                    var skipped = new Object[values.length - 1];
+                    for (int i = 0, k = 0; i < values.length; i++) {
+                        if (i == ind) {
+                            continue;
+                        }
+                        skipped[k++] = values[i];
+                    }
+                    list.change(ctx, ChangeMode.SET, skipped);
+                }
+                return new Object[]{values[ind]};
+            case 3:
+                var low = lower != null
+                    ? lower.getSingle(ctx).filter(n -> Integer.signum(n) > 0).map(n -> n.intValue() - 1).orElse(-1)
+                    : 0;
+                var up = upper != null
+                    ? upper.getSingle(ctx).filter(n -> n.compareTo(Integer.valueOf(values.length)) <= 0).map(Integer::intValue).orElse(values.length)
+                    : values.length;
+                var st = step != null
+                    ? step.getSingle(ctx).filter(n -> Integer.signum(n) != 0 && n.compareTo(Integer.valueOf(-values.length)) >= 0 && n.compareTo(Integer.valueOf(values.length)) <= 0).map(Integer::intValue).orElse(0)
+                    : 1;
 
-				if (st < 0) {
-					CollectionUtils.reverseArray(values);
-					st = -st;
-					int temp = low;
-					low = up - 1;
-					up = temp + 1;
-				}
-				if (low == -1 || up == -1 || up == 0 || st == 0 || low > up) {
-					if (isEffect)
-						list.change(ctx, ChangeMode.SET, new Object[0]);
-					return new Object[0];
-				} else if (low == up) {
-					// Nothing to change
-					return new Object[0];
-				}
+                if (st < 0) {
+                    CollectionUtils.reverseArray(values);
+                    st = -st;
+                    int temp = low;
+                    low = up - 1;
+                    up = temp + 1;
+                }
+                if (low == -1 || up == -1 || up == 0 || st == 0 || low > up) {
+                    if (isEffect)
+                        list.change(ctx, ChangeMode.SET, new Object[0]);
+                    return new Object[0];
+                } else if (low == up) {
+                    // Nothing to change
+                    return new Object[0];
+                }
 
-				var spliced = new ArrayList<>();
-				var changed = new ArrayList<>();
-				for (int i = 0; i < values.length; i++) {
-					if (i >= low && i < up && (i - low) % st == 0) {
-						spliced.add(values[i]);
-					} else {
-						changed.add(values[i]);
-					}
-				}
+                var spliced = new ArrayList<>();
+                var changed = new ArrayList<>();
+                for (int i = 0; i < values.length; i++) {
+                    if (i >= low && i < up && (i - low) % st == 0) {
+                        spliced.add(values[i]);
+                    } else {
+                        changed.add(values[i]);
+                    }
+                }
 
-				if (isEffect)
-					list.change(ctx, ChangeMode.SET, changed.toArray());
-				return spliced.toArray(new Object[0]);
-			default:
-				throw new IllegalStateException();
-		}
-	}
+                if (isEffect)
+                    list.change(ctx, ChangeMode.SET, changed.toArray());
+                return spliced.toArray(new Object[0]);
+            default:
+                throw new IllegalStateException();
+        }
+    }
 
-	@Override
-	public boolean isSingle() {
-		return type != 3;
-	}
+    @Override
+    public boolean isSingle() {
+        return type != 3;
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		switch (type) {
-			case 0:
-				return "pop " + list.toString(ctx, debug);
-			case 1:
-				return "poll " + list.toString(ctx, debug);
-			case 2:
-				return "extract element number " + index.toString(ctx, debug) + " from " + list.toString(ctx, debug);
-			case 3:
-				return "splice " + list.toString(ctx, debug) + " from " + lower.toString(ctx, debug)
-						+ (upper != null ? upper.toString(ctx, debug) : "");
-			default:
-				throw new IllegalStateException();
-		}
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        switch (type) {
+            case 0:
+                return "pop " + list.toString(ctx, debug);
+            case 1:
+                return "poll " + list.toString(ctx, debug);
+            case 2:
+                return "extract element number " + index.toString(ctx, debug) + " from " + list.toString(ctx, debug);
+            case 3:
+                return "splice " + list.toString(ctx, debug) + " from " + lower.toString(ctx, debug)
+                    + (upper != null ? upper.toString(ctx, debug) : "");
+            default:
+                throw new IllegalStateException();
+        }
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java
index 438cbee1..c01b0440 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java
@@ -20,124 +20,124 @@
  * <br>
  * Note that indices in Skript start at one.
  *
+ * @author Mwexim
  * @name Replace
  * @type EFFECT/EXPRESSION
  * @pattern replace [(all|every|[the] first|[the] last)] [regex [pattern[s]]] %strings% in %strings% with %string%
  * @pattern replace [(all|every|[the] first|[the] last)] [regex [pattern[s]]] %strings% with %string% in %strings%
- * @since ALPHA
- * @author Mwexim
  * @see ExprElement
+ * @since ALPHA
  */
 public class ExecExprReplace extends ExecutableExpression<String> {
-	static {
-		// TODO add "new" so we can add docs
-		Parser.getMainRegistration().addExecutableExpression(ExecExprReplace.class, String.class, false,
-				"replace [(0:all|0:every|1:[the] first|2:[the] last)] [:regex [pattern[s]]] %strings% in %strings% with %string%",
-				"replace [(0:all|0:every|1:[the] first|2:[the] last)] [:regex [pattern[s]]] %strings% with %string% in %strings%"
-		);
-	}
+    static {
+        // TODO add "new" so we can add docs
+        Parser.getMainRegistration().addExecutableExpression(ExecExprReplace.class, String.class, false,
+            "replace [(0:all|0:every|1:[the] first|2:[the] last)] [:regex [pattern[s]]] %strings% in %strings% with %string%",
+            "replace [(0:all|0:every|1:[the] first|2:[the] last)] [:regex [pattern[s]]] %strings% with %string% in %strings%"
+        );
+    }
 
-	private Expression<String> toMatch;
-	private Expression<String> toReplace;
-	private Expression<String> replacement;
+    private Expression<String> toMatch;
+    private Expression<String> toReplace;
+    private Expression<String> replacement;
 
-	private int type;
-	private boolean regex;
+    private int type;
+    private boolean regex;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		type = parseContext.getNumericMark();
-		regex = parseContext.hasMark("regex");
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        type = parseContext.getNumericMark();
+        regex = parseContext.hasMark("regex");
 
-		toMatch = (Expression<String>) expressions[0];
-		toReplace = (Expression<String>) expressions[1 + matchedPattern];
-		replacement = (Expression<String>) expressions[2 - matchedPattern];
+        toMatch = (Expression<String>) expressions[0];
+        toReplace = (Expression<String>) expressions[1 + matchedPattern];
+        replacement = (Expression<String>) expressions[2 - matchedPattern];
 
-		if (!toReplace.acceptsChange(ChangeMode.SET, toReplace)) {
-			var logger = parseContext.getLogger();
-			logger.error(
-					"The expression '"
-							+ toReplace.toString(TriggerContext.DUMMY, logger.isDebug())
-							+ "' cannot be changed",
-					ErrorType.SEMANTIC_ERROR
-			);
-			return false;
-		}
-		return true;
-	}
+        if (!toReplace.acceptsChange(ChangeMode.SET, toReplace)) {
+            var logger = parseContext.getLogger();
+            logger.error(
+                "The expression '"
+                    + toReplace.toString(TriggerContext.DUMMY, logger.isDebug())
+                    + "' cannot be changed",
+                ErrorType.SEMANTIC_ERROR
+            );
+            return false;
+        }
+        return true;
+    }
 
-	@Override
-	public String[] getValues(TriggerContext ctx, boolean isEffect) {
-		String[] replacedValues = toReplace.getValues(ctx);
-		String[] matchedValues = toMatch.getValues(ctx);
-		String replacementValue = replacement.getSingle(ctx).orElse(null);
-		if (replacementValue == null) {
-			return replacedValues;
-		}
+    @Override
+    public String[] getValues(TriggerContext ctx, boolean isEffect) {
+        String[] replacedValues = toReplace.getValues(ctx);
+        String[] matchedValues = toMatch.getValues(ctx);
+        String replacementValue = replacement.getSingle(ctx).orElse(null);
+        if (replacementValue == null) {
+            return replacedValues;
+        }
 
-		for (int i = 0; i < replacedValues.length; i++) {
-			for (String match : matchedValues) {
-				String current = replacedValues[i];
-				String replaced;
-				if (regex) {
-					// The regex pattern must be valid
-					try {
-						Pattern.compile(match);
-					} catch (PatternSyntaxException ignored) {
-						continue;
-					}
-				}
-				switch (type) {
-					case 0:
-						// All occurrences
-						replaced = regex
-								? current.replaceAll(match, replacementValue)
-								: current.replace(match, replacementValue);
-						break;
-					case 1:
-						// First occurrence
-						replaced = current.replaceFirst(
-								regex ? match : Pattern.quote(match),
-								replacementValue
-						);
-						break;
-					case 2:
-						// Last occurrence
-						// This regex pattern flushes away as many characters as it can, leaving the last occurrence.
-						Matcher matcher = Pattern.compile(".*(" + match + ")").matcher(current);
-						if (regex && !matcher.matches())
-							continue;
+        for (int i = 0; i < replacedValues.length; i++) {
+            for (String match : matchedValues) {
+                String current = replacedValues[i];
+                String replaced;
+                if (regex) {
+                    // The regex pattern must be valid
+                    try {
+                        Pattern.compile(match);
+                    } catch (PatternSyntaxException ignored) {
+                        continue;
+                    }
+                }
+                switch (type) {
+                    case 0:
+                        // All occurrences
+                        replaced = regex
+                            ? current.replaceAll(match, replacementValue)
+                            : current.replace(match, replacementValue);
+                        break;
+                    case 1:
+                        // First occurrence
+                        replaced = current.replaceFirst(
+                            regex ? match : Pattern.quote(match),
+                            replacementValue
+                        );
+                        break;
+                    case 2:
+                        // Last occurrence
+                        // This regex pattern flushes away as many characters as it can, leaving the last occurrence.
+                        Matcher matcher = Pattern.compile(".*(" + match + ")").matcher(current);
+                        if (regex && !matcher.matches())
+                            continue;
 
-						int lastIndex = regex
-								? matcher.start(1)
-								: current.lastIndexOf(match);
-						if (lastIndex < 0 || lastIndex >= current.length())
-							continue;
+                        int lastIndex = regex
+                            ? matcher.start(1)
+                            : current.lastIndexOf(match);
+                        if (lastIndex < 0 || lastIndex >= current.length())
+                            continue;
 
-						int limitIndex = lastIndex + (regex
-								? matcher.group(1).length()
-								: match.length());
-						replaced = current.substring(0, lastIndex)
-								+ replacementValue
-								+ (limitIndex < current.length() ? current.substring(limitIndex) : "");
-						break;
-					default:
-						throw new IllegalStateException();
-				}
-				replacedValues[i] = replaced;
-			}
-		}
-		if (isEffect)
-			toReplace.change(ctx, ChangeMode.SET, replacedValues);
-		return replacedValues;
-	}
+                        int limitIndex = lastIndex + (regex
+                            ? matcher.group(1).length()
+                            : match.length());
+                        replaced = current.substring(0, lastIndex)
+                            + replacementValue
+                            + (limitIndex < current.length() ? current.substring(limitIndex) : "");
+                        break;
+                    default:
+                        throw new IllegalStateException();
+                }
+                replacedValues[i] = replaced;
+            }
+        }
+        if (isEffect)
+            toReplace.change(ctx, ChangeMode.SET, replacedValues);
+        return replacedValues;
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "replace "
-				+ new String[] {"all ", "first ", "last "}[type] + toMatch.toString(ctx, debug)
-				+ " in " + toReplace.toString(ctx, debug)
-				+ " with " + replacement.toString(ctx, debug);
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "replace "
+            + new String[]{"all ", "first ", "last "}[type] + toMatch.toString(ctx, debug)
+            + " in " + toReplace.toString(ctx, debug)
+            + " with " + replacement.toString(ctx, debug);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java
index 289b93f5..be72184d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java
@@ -16,72 +16,72 @@
  * Note that when getting the size of a list variable, it will only return the size of the first layer of elements.
  * If you want to get the whole list size, including nested layers in a variable, use the recursive size instead.
  *
+ * @author Olyno, Mwexim
  * @name Amount
  * @type EXPRESSION
  * @pattern [the] [recursive] (amount|number|size) of %~objects%
  * @pattern %~objects%'[s] [recursive] (amount|number|size)
  * @since ALPHA
- * @author Olyno, Mwexim
  */
 public class ExprAmount extends PropertyExpression<Object, Number> {
-	static {
-		Parser.getMainRegistration().newPropertyExpression(ExprAmount.class, Number.class,
-				"[1:recursive] (amount|number|size)", "~objects")
-			.name("Amount")
-			.description("Returns the amount of elements in a given list.")
-			.examples("set {_size} to size of {_var::*}",
-				"if size of all players > 10:")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newPropertyExpression(ExprAmount.class, Number.class,
+                "[1:recursive] (amount|number|size)", "~objects")
+            .name("Amount")
+            .description("Returns the amount of elements in a given list.")
+            .examples("set {_size} to size of {_var::*}",
+                "if size of all players > 10:")
+            .since("1.0.0")
+            .register();
+    }
 
-	private boolean recursive;
+    private boolean recursive;
 
-	@Override
-	public boolean init(Expression<?> @NotNull [] expressions, int matchedPattern, @NotNull ParseContext parseContext) {
-		super.init(expressions, matchedPattern, parseContext);
-		recursive = parseContext.getNumericMark() == 1;
-		if (recursive && !(getOwner() instanceof Variable<?>)) {
-			parseContext.getLogger().error("Getting the recursive size of an expression only applies to variables.", ErrorType.SEMANTIC_ERROR);
-			return false;
-		}
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    private static long getRecursiveSize(Map<String, ?> map) {
+        long count = 0;
+        for (Map.Entry<String, ?> entry : map.entrySet()) {
+            Object value = entry.getValue();
+            if (value instanceof Map) {
+                count += getRecursiveSize((Map<String, ?>) value);
+            } else {
+                count++;
+            }
+        }
+        return count;
+    }
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public Number[] getValues(TriggerContext ctx) {
-		if (recursive) {
-			var var = ((Variable<?>) getOwner()).getRaw(ctx);
-			if (var.isPresent())
-				return new Number[] {
-					Integer.valueOf(Math.toIntExact(getRecursiveSize((Map<String, ?>) var.get())))
-			};
-		}
-		return new Number[] {Integer.valueOf(getOwner().getValues(ctx).length)};
-	}
+    @Override
+    public boolean init(Expression<?> @NotNull [] expressions, int matchedPattern, @NotNull ParseContext parseContext) {
+        super.init(expressions, matchedPattern, parseContext);
+        recursive = parseContext.getNumericMark() == 1;
+        if (recursive && !(getOwner() instanceof Variable<?>)) {
+            parseContext.getLogger().error("Getting the recursive size of an expression only applies to variables.", ErrorType.SEMANTIC_ERROR);
+            return false;
+        }
+        return true;
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return toString(ctx, debug, (recursive ? "recursive " : "") + "size");
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public Number[] getValues(TriggerContext ctx) {
+        if (recursive) {
+            var var = ((Variable<?>) getOwner()).getRaw(ctx);
+            if (var.isPresent())
+                return new Number[]{
+                    Integer.valueOf(Math.toIntExact(getRecursiveSize((Map<String, ?>) var.get())))
+                };
+        }
+        return new Number[]{Integer.valueOf(getOwner().getValues(ctx).length)};
+    }
 
-	@Override
-	public boolean isSingle() {
-		return true;
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return toString(ctx, debug, (recursive ? "recursive " : "") + "size");
+    }
 
-	@SuppressWarnings("unchecked")
-	private static long getRecursiveSize(Map<String, ?> map) {
-		long count = 0;
-		for (Map.Entry<String, ?> entry : map.entrySet()) {
-			Object value = entry.getValue();
-			if (value instanceof Map) {
-				count += getRecursiveSize((Map<String, ?>) value);
-			} else {
-				count++;
-			}
-		}
-		return count;
-	}
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAnswer.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAnswer.java
index 55a2cd5c..31714811 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAnswer.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAnswer.java
@@ -12,14 +12,16 @@
  * Retrieve the last input of the user in a {@link EffAsk} effect.
  * This will essentially return the last line of the console.
  *
+ * @author ItsTheSky
  * @name Last Answer
  * @type EXPRESSION
  * @pattern [the] [last] (answer|response)
  * @since ALPHA
- * @author ItsTheSky
  */
 public class ExprAnswer implements Expression<String> {
 
+    private static final Map<TriggerContext, String> answers = new HashMap<>();
+
     static {
         // We won't be needing this
 //        Parser.getMainRegistration().addExpression(
@@ -30,8 +32,6 @@ public class ExprAnswer implements Expression<String> {
 //        );
     }
 
-    private static final Map<TriggerContext, String> answers = new HashMap<>();
-
     public static void addAnswer(TriggerContext ctx, String answer) {
         answers.put(ctx, answer);
     }
@@ -44,8 +44,8 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     @Override
     public String[] getValues(TriggerContext ctx) {
         return answers.containsKey(ctx)
-                ? new String[] {answers.get(ctx)}
-                : new String[0];
+            ? new String[]{answers.get(ctx)}
+            : new String[0];
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprBooleanOperators.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprBooleanOperators.java
index 67e42c07..b616312f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprBooleanOperators.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprBooleanOperators.java
@@ -11,17 +11,17 @@
 /**
  * Basic boolean operators. It is possible to use conditions inside the operators.
  *
+ * @author Syst3ms
  * @name Boolean Operators
  * @pattern not %=boolean%
  * @pattern %=boolean% (or|\|\|) %=boolean%
  * @pattern %=boolean% (and|&&) %=boolean%
  * @since ALPHA
- * @author Syst3ms
  */
 public class ExprBooleanOperators implements Expression<Boolean> {
     static {
         Parser.getMainRegistration().newExpression(
-            ExprBooleanOperators.class, Boolean.class, true,
+                ExprBooleanOperators.class, Boolean.class, true,
                 "not %=boolean%",
                 "%=boolean% (or|\\|\\|) %=boolean%",
                 "%=boolean% (and|&&) %=boolean%")
@@ -54,12 +54,12 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     public Boolean[] getValues(TriggerContext ctx) {
         assert second != null || pattern == 0;
         return first.getSingle(ctx)
-                .flatMap(f -> pattern == 0
-                        ? Optional.of(!f)
-                        : second.getSingle(ctx).map(s -> pattern == 1 ? f || s : f && s)
-                )
-                .map(val -> new Boolean[] {val})
-                .orElse(new Boolean[0]);
+            .flatMap(f -> pattern == 0
+                ? Optional.of(!f)
+                : second.getSingle(ctx).map(s -> pattern == 1 ? f || s : f && s)
+            )
+            .map(val -> new Boolean[]{val})
+            .orElse(new Boolean[0]);
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromHex.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromHex.java
index 90a38db1..c471898b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromHex.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromHex.java
@@ -15,41 +15,41 @@
  * </ul>
  * A trailing hashtag (#) at the start of the string is allowed, but not necessary.
  *
+ * @author Mwexim
  * @name Color from Hex
  * @type EXPRESSION
  * @pattern [the] color (from|of) [the] hex[adecimal] [value] %string%
  * @since ALPHA
- * @author Mwexim
  */
 public class ExprColorFromHex implements Expression<Color> {
-	static {
-		Parser.getMainRegistration().newExpression(ExprColorFromHex.class, Color.class, true,
-				"[the] color (from|of) [the] hex[adecimal] [value] %string%")
-			.name("Color from Hex")
-			.description("Creates a color from its hexadecimal value.")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newExpression(ExprColorFromHex.class, Color.class, true,
+                "[the] color (from|of) [the] hex[adecimal] [value] %string%")
+            .name("Color from Hex")
+            .description("Creates a color from its hexadecimal value.")
+            .since("1.0.0")
+            .register();
+    }
 
-	private Expression<String> hex;
+    private Expression<String> hex;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		hex = (Expression<String>) expressions[0];
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        hex = (Expression<String>) expressions[0];
+        return true;
+    }
 
-	@Override
-	public Color[] getValues(TriggerContext ctx) {
-		return hex.getSingle(ctx)
-				.flatMap(val -> Color.ofHex(val.startsWith("#") ? val.substring(1) : val))
-				.map(val -> new Color[] {val})
-				.orElse(new Color[0]);
-	}
+    @Override
+    public Color[] getValues(TriggerContext ctx) {
+        return hex.getSingle(ctx)
+            .flatMap(val -> Color.ofHex(val.startsWith("#") ? val.substring(1) : val))
+            .map(val -> new Color[]{val})
+            .orElse(new Color[0]);
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "color from hex " + hex.toString(ctx, debug);
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "color from hex " + hex.toString(ctx, debug);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromRGB.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromRGB.java
index 3b225411..e17dee45 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromRGB.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprColorFromRGB.java
@@ -13,49 +13,49 @@
  * It is also possible to add the alpha value, which corresponds to the transparency.
  * If the argument size is not exactly 3 or 4, no color will be created.
  *
+ * @author Mwexim
  * @name Color from RGB
  * @type EXPRESSION
  * @pattern [the] color (from|of) [the] rgb[a] [value] %integers%
  * @since ALPHA
- * @author Mwexim
  */
 public class ExprColorFromRGB implements Expression<Color> {
-	static {
-		Parser.getMainRegistration().newExpression(ExprColorFromRGB.class, Color.class, true,
-				"[the] color (from|of) [the] rgb[a] [value] %integers%")
-			.name("Color from RGB")
-			.description("Creates a color from its RGB values.")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newExpression(ExprColorFromRGB.class, Color.class, true,
+                "[the] color (from|of) [the] rgb[a] [value] %integers%")
+            .name("Color from RGB")
+            .description("Creates a color from its RGB values.")
+            .since("1.0.0")
+            .register();
+    }
 
-	private Expression<Integer> rgb;
+    private Expression<Integer> rgb;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		rgb = (Expression<Integer>) expressions[0];
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        rgb = (Expression<Integer>) expressions[0];
+        return true;
+    }
 
-	@Override
-	public Color[] getValues(TriggerContext ctx) {
-		var values = rgb.stream(ctx).map(Integer::intValue).toArray(Integer[]::new);
-		if (values.length == 3) {
-			return Color.of(values[0], values[1], values[2])
-					.map(val -> new Color[] {val})
-					.orElse(new Color[0]);
-		} else if (values.length == 4) {
-			return Color.of(values[0], values[1], values[2], values[3])
-					.map(val -> new Color[] {val})
-					.orElse(new Color[0]);
-		} else {
-			return new Color[0];
-		}
-	}
+    @Override
+    public Color[] getValues(TriggerContext ctx) {
+        var values = rgb.stream(ctx).map(Integer::intValue).toArray(Integer[]::new);
+        if (values.length == 3) {
+            return Color.of(values[0], values[1], values[2])
+                .map(val -> new Color[]{val})
+                .orElse(new Color[0]);
+        } else if (values.length == 4) {
+            return Color.of(values[0], values[1], values[2], values[3])
+                .map(val -> new Color[]{val})
+                .orElse(new Color[0]);
+        } else {
+            return new Color[0];
+        }
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "color from rgb " + rgb.toString(ctx, debug);
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "color from rgb " + rgb.toString(ctx, debug);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
index bde1899e..8151c05f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
@@ -25,10 +25,6 @@ public class ExprContextValue<T, C extends TriggerContext> implements Expression
     private static final String PATTERN = "[the] [(1:(past|previous)|2:(future|next))] [ctx:(context|event)-]<.+>";
     private static final PatternElement CONTEXT_VALUE_PATTERN = PatternParser.parsePattern(PATTERN, new SkriptLogger()).orElseThrow();
 
-    private ContextValue<C, T> info;
-    private String value;
-    private boolean alone;
-
     static {
         //noinspection unchecked
         Parser.getMainRegistration().newExpression(ExprContextValue.class, Object.class, false,
@@ -40,6 +36,10 @@ public class ExprContextValue<T, C extends TriggerContext> implements Expression
             .register();
     }
 
+    private ContextValue<C, T> info;
+    private String value;
+    private boolean alone;
+
     @SuppressWarnings("unchecked")
     @Override
     @Contract("_, _, _ -> fail")
@@ -145,7 +145,7 @@ public boolean isSingle() {
 
     @Override
     public Class<? extends T> getReturnType() {
-        return this.info.getReturnType().getType().getTypeClass();
+        return this.info.getReturnType().type().getTypeClass();
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateAgoLater.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateAgoLater.java
index 3332c0f3..0ccd80f7 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateAgoLater.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateAgoLater.java
@@ -14,54 +14,54 @@
 /**
  * The date that was a certain duration ago or is a certain duration in the future.
  *
+ * @author Mwexim
  * @name Ago/Later
  * @type EXPRESSION
  * @pattern %duration% (ago|in the past|before [the] [date] %date%)
  * @pattern %duration% (later|in the future|(from|after) [the] [date] %date%)
  * @since ALPHA
- * @author Mwexim
  */
 public class ExprDateAgoLater implements Expression<SkriptDate> {
-	static {
-		Parser.getMainRegistration().newExpression(
-				ExprDateAgoLater.class,
-				SkriptDate.class,
-				true,
-				"%duration% (ago|in the past|before [the] [date] %date%)",
-				"%duration% (later|in the future|(from|after) [the] [date] %date%)")
-			.name("Date Ago/Later")
-			.description("Returns the date that is a certain duration ago or in the future.")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newExpression(
+                ExprDateAgoLater.class,
+                SkriptDate.class,
+                true,
+                "%duration% (ago|in the past|before [the] [date] %date%)",
+                "%duration% (later|in the future|(from|after) [the] [date] %date%)")
+            .name("Date Ago/Later")
+            .description("Returns the date that is a certain duration ago or in the future.")
+            .since("1.0.0")
+            .register();
+    }
 
-	private Expression<Duration> duration;
-	@Nullable
-	private Expression<SkriptDate> date;
-	private boolean past;
+    private Expression<Duration> duration;
+    @Nullable
+    private Expression<SkriptDate> date;
+    private boolean past;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		past = matchedPattern == 0;
-		duration = (Expression<Duration>) expressions[0];
-		if (expressions.length == 2)
-			date = (Expression<SkriptDate>) expressions[1];
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        past = matchedPattern == 0;
+        duration = (Expression<Duration>) expressions[0];
+        if (expressions.length == 2)
+            date = (Expression<SkriptDate>) expressions[1];
+        return true;
+    }
 
-	@Override
-	public SkriptDate[] getValues(TriggerContext ctx) {
-		var actualDate = date != null ? date.getSingle(ctx) : Optional.of(SkriptDate.now());
-		return DoubleOptional.ofOptional(actualDate, duration.getSingle(ctx))
-				.mapToOptional((da, du) -> new SkriptDate[] {past ? da.minus(du) : da.plus(du)})
-				.orElse(new SkriptDate[0]);
-	}
+    @Override
+    public SkriptDate[] getValues(TriggerContext ctx) {
+        var actualDate = date != null ? date.getSingle(ctx) : Optional.of(SkriptDate.now());
+        return DoubleOptional.ofOptional(actualDate, duration.getSingle(ctx))
+            .mapToOptional((da, du) -> new SkriptDate[]{past ? da.minus(du) : da.plus(du)})
+            .orElse(new SkriptDate[0]);
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return date != null
-				? duration.toString(ctx, debug) + (past ? " before date " : " after date ") + date.toString(ctx, debug)
-				: duration.toString(ctx, debug) + (past ? " in the past" : " in the future");
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return date != null
+            ? duration.toString(ctx, debug) + (past ? " before date " : " after date ") + date.toString(ctx, debug)
+            : duration.toString(ctx, debug) + (past ? " in the past" : " in the future");
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateNow.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateNow.java
index ecef53fa..e6b47a95 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateNow.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateNow.java
@@ -11,11 +11,11 @@
 /**
  * The current date, the one from yesterday or the one from tomorrow.
  *
+ * @author Mwexim
  * @name Now
  * @type EXPRESSION
- * @pattern (yesterday|now|tomorrow)
+ * @pattern (yesterday | now | tomorrow)
  * @since ALPHA
- * @author Mwexim
  */
 public class ExprDateNow implements Expression<SkriptDate> {
     static {
@@ -30,30 +30,30 @@ public class ExprDateNow implements Expression<SkriptDate> {
             .register();
     }
 
-	private int mark;
+    private int mark;
 
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		mark = parseContext.getNumericMark();
-		return true;
-	}
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        mark = parseContext.getNumericMark();
+        return true;
+    }
 
-	@Override
-	public SkriptDate[] getValues(TriggerContext ctx) {
-		switch (mark) {
-			case 0:
-				return new SkriptDate[] {SkriptDate.now().minus(Duration.ofDays(1))};
-			case 1:
-				return new SkriptDate[] {SkriptDate.now()};
-			case 2:
-				return new SkriptDate[] {SkriptDate.now().plus(Duration.ofDays(1))};
-			default:
-				throw new IllegalStateException();
-		}
-	}
+    @Override
+    public SkriptDate[] getValues(TriggerContext ctx) {
+        switch (mark) {
+            case 0:
+                return new SkriptDate[]{SkriptDate.now().minus(Duration.ofDays(1))};
+            case 1:
+                return new SkriptDate[]{SkriptDate.now()};
+            case 2:
+                return new SkriptDate[]{SkriptDate.now().plus(Duration.ofDays(1))};
+            default:
+                throw new IllegalStateException();
+        }
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return new String[] {"yesterday", "now", "tomorrow"}[mark];
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return new String[]{"yesterday", "now", "tomorrow"}[mark];
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateTodayAt.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateTodayAt.java
index 92205576..d7312526 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateTodayAt.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateTodayAt.java
@@ -13,45 +13,46 @@
 /**
  * Today at a given time. When no time is set,
  * it will take today's date as it would be midnight.
+ * <p>
+ * + * @author Mwexim
  *
-+ * @author Mwexim
-  * @name Today At
-  * @type EXPRESSION
-  * @pattern today [at %time%]
-  * @since ALPHA
-  */
+ * @name Today At
+ * @type EXPRESSION
+ * @pattern today [at %time%]
+ * @since ALPHA
+ */
 public class ExprDateTodayAt implements Expression<SkriptDate> {
-	static {
-		Parser.getMainRegistration().newExpression(ExprDateTodayAt.class, SkriptDate.class, true,
-				"today [at %time%]")
-			.name("Today At")
-			.description("Returns the date of today at a given time. If no time is specified, it will return the date of today at midnight.")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newExpression(ExprDateTodayAt.class, SkriptDate.class, true,
+                "today [at %time%]")
+            .name("Today At")
+            .description("Returns the date of today at a given time. If no time is specified, it will return the date of today at midnight.")
+            .since("1.0.0")
+            .register();
+    }
 
-	@Nullable
-	private Expression<Time> time;
+    @Nullable
+    private Expression<Time> time;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		if (expressions.length > 0)
-			time = (Expression<Time>) expressions[0];
- 		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        if (expressions.length > 0)
+            time = (Expression<Time>) expressions[0];
+        return true;
+    }
 
-	@Override
-	public SkriptDate[] getValues(TriggerContext ctx) {
-		if (time != null)
-			return time.getSingle(ctx)
-					.map(ti -> new SkriptDate[] {SkriptDate.today().plus(Duration.ofMillis(ti.toMillis()))})
-					.orElse(new SkriptDate[0]);
-		return new SkriptDate[] {SkriptDate.today()};
-	}
+    @Override
+    public SkriptDate[] getValues(TriggerContext ctx) {
+        if (time != null)
+            return time.getSingle(ctx)
+                .map(ti -> new SkriptDate[]{SkriptDate.today().plus(Duration.ofMillis(ti.toMillis()))})
+                .orElse(new SkriptDate[0]);
+        return new SkriptDate[]{SkriptDate.today()};
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "today" + (time != null ? " at " + time.toString(ctx, debug) : "");
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "today" + (time != null ? " at " + time.toString(ctx, debug) : "");
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java
index 12d5e37e..6a5c3eb9 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java
@@ -8,10 +8,10 @@
 /**
  * A shorthand expression for giving things a default value. If the first thing isn't set, the second thing will be returned.
  *
+ * @author Olyno
  * @name Default Value
  * @pattern %objects% (otherwise|?) %objects%
  * @since ALPHA
- * @author Olyno
  */
 public class ExprDefaultValue implements Expression<Object> {
     static {
@@ -37,8 +37,8 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     @Override
     public Object[] getValues(TriggerContext ctx) {
         return firstValue.getValues(ctx).length != 0
-                ? firstValue.getValues(ctx)
-                : secondValue.getValues(ctx);
+            ? firstValue.getValues(ctx)
+            : secondValue.getValues(ctx);
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDifference.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDifference.java
index b8b0e33c..0184515c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDifference.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDifference.java
@@ -21,10 +21,10 @@
  * Note that only values that can be checked for difference are allowed
  * (this is for example numbers, dates, durations and others).
  *
+ * @author Mwexim
  * @name Difference
  * @pattern [the] difference (between|of) %object% and %object%
  * @since ALPHA
- * @author Mwexim
  */
 public class ExprDifference implements Expression<Object> {
     static {
@@ -50,7 +50,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
 
         if (first instanceof Literal<?> && second instanceof Literal<?>) {
             type = TypeManager.getByClass(
-                    ClassUtils.getCommonSuperclass(first.getReturnType(), second.getReturnType())
+                ClassUtils.getCommonSuperclass(first.getReturnType(), second.getReturnType())
             );
         } else if (first instanceof Variable<?> && second instanceof Variable<?>) {
             variablePresent = true;
@@ -80,7 +80,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                 type = TypeManager.getByClass(first.getReturnType());
             } else {
                 type = TypeManager.getByClass(
-                        ClassUtils.getCommonSuperclass(first.getReturnType(), second.getReturnType())
+                    ClassUtils.getCommonSuperclass(first.getReturnType(), second.getReturnType())
                 );
             }
         }
@@ -91,13 +91,13 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             var secondType = TypeManager.getByClass(second.getReturnType());
             assert firstType.isPresent() && secondType.isPresent();
             parseContext.getLogger().error(
-                    "Cannot compare these two values"
-                            + " (types '"
-                            + firstType.get().getBaseName()
-                            + "' and '"
-                            + secondType.get().getBaseName()
-                            + "' are inconvertible)",
-                    ErrorType.SEMANTIC_ERROR
+                "Cannot compare these two values"
+                    + " (types '"
+                    + firstType.get().getBaseName()
+                    + "' and '"
+                    + secondType.get().getBaseName()
+                    + "' are inconvertible)",
+                ErrorType.SEMANTIC_ERROR
             );
             return false;
         }
@@ -112,28 +112,28 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     @Override
     public Object[] getValues(TriggerContext ctx) {
         return DoubleOptional.ofOptional(first.getSingle(ctx), second.getSingle(ctx))
-                .mapToOptional((f, s) -> {
-                    // The arithmetic field isn't initialized here.
-                    if (variablePresent) {
-                        assert f.getClass() == s.getClass();
-                        var type = TypeManager.getByClass(f.getClass()).orElseThrow();
-                        var variableMath = type.getArithmetic();
-                        if (variableMath.isEmpty())
-                            return null;
-                        arithmetic = variableMath.get();
-                    }
+            .mapToOptional((f, s) -> {
+                // The arithmetic field isn't initialized here.
+                if (variablePresent) {
+                    assert f.getClass() == s.getClass();
+                    var type = TypeManager.getByClass(f.getClass()).orElseThrow();
+                    var variableMath = type.getArithmetic();
+                    if (variableMath.isEmpty())
+                        return null;
+                    arithmetic = variableMath.get();
+                }
 
-                    assert arithmetic != null;
-                    return new Object[] {arithmetic.difference(f, s)};
-                })
-                .orElse(new Object[0]);
+                assert arithmetic != null;
+                return new Object[]{arithmetic.difference(f, s)};
+            })
+            .orElse(new Object[0]);
     }
 
     @Override
     public Class<?> getReturnType() {
         return arithmetic != null
-                ? arithmetic.getRelativeType()
-                : ClassUtils.getCommonSuperclass(false, first.getReturnType(), second.getReturnType());
+            ? arithmetic.getRelativeType()
+            : ClassUtils.getCommonSuperclass(false, first.getReturnType(), second.getReturnType());
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java
index 9e301492..3e323815 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java
@@ -23,6 +23,8 @@
  * @since ALPHA
  */
 public class ExprElement implements Expression<Object> {
+    private static final ThreadLocalRandom random = ThreadLocalRandom.current();
+
     static {
         Parser.getMainRegistration().newExpression(ExprElement.class, Object.class, true,
                 "(0:[the] first|1:[the] last|2:[a] random|3:[the] %integer%(st|nd|rd|th)) element [out] of %objects%",
@@ -35,8 +37,6 @@ public class ExprElement implements Expression<Object> {
             .register();
     }
 
-    private static final ThreadLocalRandom random = ThreadLocalRandom.current();
-
     private Expression<Object> expr;
     private Expression<Integer> range;
     private int pattern;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java
index 687dfd40..97dd84ea 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java
@@ -25,141 +25,141 @@
 /**
  * The currently looped value.
  *
+ * @author Syst3ms
  * @name Loop Value
  * @pattern [the] loop-<.+>
  * @since ALPHA
- * @author Syst3ms
  */
 public class ExprLoopValue extends SectionValue<SecLoop, Object> {
-	static {
-		Parser.getMainRegistration().newExpression(ExprLoopValue.class, Object.class, true,
-				"[the] loop-<.+>")
-			.name("Loop Value/Index")
-			.description("The currently looped value or index.",
-				"Index will always be represented as a string.")
-			.examples("loop all players:",
-				"\tsend \"hi\" to loop-player",
-				"",
-				"loop {_var::*}",
-				"\tif loop-index = \"bob\":",
-				"\t\tadd loop-value to inventory of player")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newExpression(ExprLoopValue.class, Object.class, true,
+                "[the] loop-<.+>")
+            .name("Loop Value/Index")
+            .description("The currently looped value or index.",
+                "Index will always be represented as a string.")
+            .examples("loop all players:",
+                "\tsend \"hi\" to loop-player",
+                "",
+                "loop {_var::*}",
+                "\tif loop-index = \"bob\":",
+                "\t\tadd loop-value to inventory of player")
+            .since("1.0.0")
+            .register();
+    }
 
-	private SecLoop loop;
-	private boolean isVariableLoop;
-	private boolean isIndex;
-	@Nullable
-	private Class<?> loopedClass;
-	private String loopedString;
-	private int discriminant;
+    private SecLoop loop;
+    private boolean isVariableLoop;
+    private boolean isIndex;
+    @Nullable
+    private Class<?> loopedClass;
+    private String loopedString;
+    private int discriminant;
 
-	@Override
-	public boolean preInitialize(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		loopedString = parseContext.getMatches().get(0).group();
-		discriminant = -1;
-		final Matcher m = Pattern.compile("^(.+)-(\\d+)$").matcher(loopedString);
-		if (m.matches()) {
-			loopedString = m.group(1);
-			discriminant = Integer.parseInt(m.group(2));
-		}
-		loopedClass = TypeManager.getPatternType(loopedString)
-				.map(patternType -> patternType.getType().getTypeClass())
-				.orElse(null);
-		return true;
-	}
+    @Override
+    public boolean preInitialize(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        loopedString = parseContext.getMatches().get(0).group();
+        discriminant = -1;
+        final Matcher m = Pattern.compile("^(.+)-(\\d+)$").matcher(loopedString);
+        if (m.matches()) {
+            loopedString = m.group(1);
+            discriminant = Integer.parseInt(m.group(2));
+        }
+        loopedClass = TypeManager.getPatternType(loopedString)
+            .map(patternType -> patternType.type().getTypeClass())
+            .orElse(null);
+        return true;
+    }
 
-	@Override
-	public Function<? super List<? extends SecLoop>, Optional<? extends SecLoop>> getSelectorFunction() {
-		return sections -> {
-			int j = 1;
-			SecLoop loop = null;
-			// The closest section is first, let's reverse this behavior for convenience
-			Collections.reverse(sections);
-			for (SecLoop l : sections) {
-				Class<?> loopedType = l.getLoopedExpression().getReturnType();
-				if (loopedClass != null && (loopedClass.isAssignableFrom(loopedType) || loopedType == Object.class) ||
-						"value".equals(loopedString) ||
-						l.getLoopedExpression().isLoopOf(loopedString)) {
-					if (j < discriminant) {
-						j++;
-						continue;
-					}
-					if (loop != null) {
-						return Optional.empty();
-					}
-					loop = l;
-					if (j == discriminant)
-						break;
-				}
-			}
-			if (loop == null) {
-				return Optional.empty();
-			}
-			if (loop.getLoopedExpression() instanceof Variable) {
-				isVariableLoop = true;
-				if (((Variable<?>) loop.getLoopedExpression()).isIndexLoop(loopedString))
-					isIndex = true;
-			}
-			this.loop = loop;
-			return Optional.of(loop);
-		};
-	}
+    @Override
+    public Function<? super List<? extends SecLoop>, Optional<? extends SecLoop>> getSelectorFunction() {
+        return sections -> {
+            int j = 1;
+            SecLoop loop = null;
+            // The closest section is first, let's reverse this behavior for convenience
+            Collections.reverse(sections);
+            for (SecLoop l : sections) {
+                Class<?> loopedType = l.getLoopedExpression().getReturnType();
+                if (loopedClass != null && (loopedClass.isAssignableFrom(loopedType) || loopedType == Object.class) ||
+                    "value".equals(loopedString) ||
+                    l.getLoopedExpression().isLoopOf(loopedString)) {
+                    if (j < discriminant) {
+                        j++;
+                        continue;
+                    }
+                    if (loop != null) {
+                        return Optional.empty();
+                    }
+                    loop = l;
+                    if (j == discriminant)
+                        break;
+                }
+            }
+            if (loop == null) {
+                return Optional.empty();
+            }
+            if (loop.getLoopedExpression() instanceof Variable) {
+                isVariableLoop = true;
+                if (((Variable<?>) loop.getLoopedExpression()).isIndexLoop(loopedString))
+                    isIndex = true;
+            }
+            this.loop = loop;
+            return Optional.of(loop);
+        };
+    }
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public <R> Optional<? extends Expression<R>> convertExpression(Class<R> to) {
-		if (isVariableLoop && !isIndex) {
-			return Optional.of(ConvertedExpression.newInstance(this, (Class<R>) ClassUtils.getCommonSuperclass(to), o -> Converters.convert(o, to)));
-		} else {
-			return super.convertExpression(to);
-		}
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public <R> Optional<? extends Expression<R>> convertExpression(Class<R> to) {
+        if (isVariableLoop && !isIndex) {
+            return Optional.of(ConvertedExpression.newInstance(this, (Class<R>) ClassUtils.getCommonSuperclass(to), o -> Converters.convert(o, to)));
+        } else {
+            return super.convertExpression(to);
+        }
+    }
 
-	@Override
-	public Class<?> getReturnType() {
-		if (isIndex)
-			return String.class;
-		return loop.getLoopedExpression().getReturnType();
-	}
+    @Override
+    public Class<?> getReturnType() {
+        if (isIndex)
+            return String.class;
+        return loop.getLoopedExpression().getReturnType();
+    }
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public Object[] getSectionValues(SecLoop loop, TriggerContext ctx) {
-		Object[] one = (Object[]) Array.newInstance(getReturnType(), 1);
-		if (isVariableLoop) {
-			if (loop.getArguments() == null || loop.getArguments()[0] == null) {
-				return new Object[0];
-			}
-			var current = (Pair<String, Object>) loop.getArguments()[0];
-			if (isIndex) {
-				return new String[] {current.getFirst()};
-			}
-			one[0] = current.getSecond();
-			return one;
-		}
-		Object[] arguments = loop.getArguments();
-		if (arguments == null || arguments.length == 0) {
-			return new Object[0];
-		}
-		one[0] = loop.getArguments()[0];
-		return one;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public Object[] getSectionValues(SecLoop loop, TriggerContext ctx) {
+        Object[] one = (Object[]) Array.newInstance(getReturnType(), 1);
+        if (isVariableLoop) {
+            if (loop.getArguments() == null || loop.getArguments()[0] == null) {
+                return new Object[0];
+            }
+            var current = (Pair<String, Object>) loop.getArguments()[0];
+            if (isIndex) {
+                return new String[]{current.first()};
+            }
+            one[0] = current.second();
+            return one;
+        }
+        Object[] arguments = loop.getArguments();
+        if (arguments == null || arguments.length == 0) {
+            return new Object[0];
+        }
+        one[0] = loop.getArguments()[0];
+        return one;
+    }
 
-	@Override
-	public Class<? extends SecLoop> getSectionClass() {
-		return SecLoop.class;
-	}
+    @Override
+    public Class<? extends SecLoop> getSectionClass() {
+        return SecLoop.class;
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, final boolean debug) {
-		if (loop == null)
-			return "loop-" + loopedString;
-		if (isVariableLoop) {
-			var variable = (Variable<?>) loop.getLoopedExpression();
-			return isIndex ? "\"" + variable.getIndex(ctx) + "\"" : variable.toString(ctx, debug);
-		}
-		return loop.getLoopedExpression().toString(ctx, debug);
-	}
+    @Override
+    public String toString(TriggerContext ctx, final boolean debug) {
+        if (loop == null)
+            return "loop-" + loopedString;
+        if (isVariableLoop) {
+            var variable = (Variable<?>) loop.getLoopedExpression();
+            return isIndex ? "\"" + variable.getIndex(ctx) + "\"" : variable.toString(ctx, debug);
+        }
+        return loop.getLoopedExpression().toString(ctx, debug);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprMutableList.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprMutableList.java
index ddb3b217..369b36b3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprMutableList.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprMutableList.java
@@ -11,19 +11,19 @@
 /**
  * Reverse, shuffle or order a given list.
  *
+ * @author Olyno
  * @name Mutable List
  * @pattern reverse[d] %objects%
  * @pattern shuffle[d] %objects%
  * @pattern sort[ed] %objects%
  * @since ALPHA
- * @author Olyno
  */
 public class ExprMutableList implements Expression<Object> {
     static {
         Parser.getMainRegistration().newExpression(ExprMutableList.class, Object.class, false,
-            "reverse[d] %objects%",
-            "shuffle[d] %objects%",
-            "sort[ed] %objects%")
+                "reverse[d] %objects%",
+                "shuffle[d] %objects%",
+                "sort[ed] %objects%")
             .name("Mutable List")
             .description("Reverses, shuffles or sorts a list.")
             .since("1.0.0")
@@ -67,6 +67,6 @@ public Class<?> getReturnType() {
 
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
-        return new String[] {"reversed ", "shuffled ", "sorted "}[type] + list.toString(ctx, debug);
+        return new String[]{"reversed ", "shuffled ", "sorted "}[type] + list.toString(ctx, debug);
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprPrimeNumber.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprPrimeNumber.java
deleted file mode 100644
index 0cca05ab..00000000
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprPrimeNumber.java
+++ /dev/null
@@ -1,63 +0,0 @@
-//package io.github.syst3ms.skriptparser.expressions;
-//
-//import io.github.syst3ms.skriptparser.Parser;
-//import io.github.syst3ms.skriptparser.lang.Expression;
-//import io.github.syst3ms.skriptparser.lang.TriggerContext;
-//import io.github.syst3ms.skriptparser.parsing.ParseContext;
-//import io.github.syst3ms.skriptparser.util.math.NumberMath;
-//
-///**
-// * Returns the nth prime, where n is the given number.
-// * Note that this expression may have slow results when used with a high number.
-// *
-// * @name Prime
-// * @type EXPRESSION
-// * @pattern [the] %integer%(st|nd|rd|th) prime [number]
-// * @since ALPHA
-// * @author Mwexim
-// */
-//public class ExprPrimeNumber implements Expression<Number> {
-//	static {
-//		Parser.getMainRegistration().addExpression(
-//				ExprPrimeNumber.class,
-//				Number.class,
-//				true,
-//				"[the] %integer%(st|nd|rd|th) prime [number]"
-//		);
-//	}
-//
-//	private Expression<Integer> ordinal;
-//
-//	@SuppressWarnings("unchecked")
-//	@Override
-//	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-//		ordinal = (Expression<Integer>) expressions[0];
-//		return true;
-//	}
-//
-//	@Override
-//	public Number[] getValues(TriggerContext ctx) {
-//		return ordinal.getSingle(ctx)
-//				.filter(n -> n.compareTo(0) > 0)
-//				.map(n -> {
-//					if (NumberMath.getCachedPrimes().size() >= n.intValue()) {
-//						return new Number[] {
-//								Integer.valueOf(NumberMath.getCachedPrimes().get(n.intValue() - 1))
-//						};
-//					}
-//					int candidate, count;
-//					for (candidate = 2, count = 0; count < n.intValue(); candidate++) {
-//						if (Math.prime(candidate))
-//							count++;
-//					}
-//					return new Number[] {Integer.valueOf(candidate - 1)};
-//				})
-//				.orElse(new Number[0]);
-//
-//	}
-//
-//	@Override
-//	public String toString(TriggerContext ctx, boolean debug) {
-//		return "prime number " + ordinal.toString(ctx, debug);
-//	}
-//}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRandomNumber.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRandomNumber.java
index 43e0fe09..349dfbe2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRandomNumber.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRandomNumber.java
@@ -19,6 +19,8 @@
  */
 public class ExprRandomNumber implements Expression<Number> {
 
+    private static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();
+
     static {
         Parser.getMainRegistration().newExpression(
                 ExprRandomNumber.class,
@@ -34,8 +36,6 @@ public class ExprRandomNumber implements Expression<Number> {
             .register();
     }
 
-    private static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();
-
     private int pattern;
     private Expression<Number> lowerNumber, maxNumber;
     private boolean isInteger;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRange.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRange.java
index f975c37b..89f7df4b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRange.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprRange.java
@@ -19,10 +19,10 @@
 /**
  * Returns a range of values between two endpoints. Types supported by default are integers and characters (length 1 strings).
  *
+ * @author Syst3ms
  * @name Range
  * @pattern [the] range from %object% to %object%
  * @since ALPHA
- * @author Syst3ms
  */
 public class ExprRange implements Expression<Object> {
     static {
@@ -45,11 +45,11 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         if (range == null) {
             SkriptLogger logger = parseContext.getLogger();
             logger.error(
-                    "Cannot get a range between "
-                            + from.toString(TriggerContext.DUMMY, logger.isDebug())
-                            + " and "
-                            + to.toString(TriggerContext.DUMMY, logger.isDebug()),
-                    ErrorType.SEMANTIC_ERROR);
+                "Cannot get a range between "
+                    + from.toString(TriggerContext.DUMMY, logger.isDebug())
+                    + " and "
+                    + to.toString(TriggerContext.DUMMY, logger.isDebug()),
+                ErrorType.SEMANTIC_ERROR);
             return false;
         }
         return true;
@@ -59,22 +59,22 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     @Override
     public Object[] getValues(TriggerContext ctx) {
         return DoubleOptional.ofOptional(from.getSingle(ctx), to.getSingle(ctx))
-                .mapToOptional((f, t) -> {
-                    // This is safe... right?
-                    if (Comparators.compare(f, t) == Relation.GREATER) {
-                        return CollectionUtils.reverseArray(
-                                (Object[]) ((BiFunction<? super Object, ? super Object, ?>) this.range.getFunction()).apply(t, f)
-                        );
-                    } else {
-                        return (Object[]) ((BiFunction<? super Object, ? super Object, ?>) this.range.getFunction()).apply(f, t);
-                    }
-                })
-                .orElse(new Object[0]);
+            .mapToOptional((f, t) -> {
+                // This is safe... right?
+                if (Comparators.compare(f, t) == Relation.GREATER) {
+                    return CollectionUtils.reverseArray(
+                        (Object[]) ((BiFunction<? super Object, ? super Object, ?>) this.range.function()).apply(t, f)
+                    );
+                } else {
+                    return (Object[]) ((BiFunction<? super Object, ? super Object, ?>) this.range.function()).apply(f, t);
+                }
+            })
+            .orElse(new Object[0]);
     }
 
     @Override
     public Class<?> getReturnType() {
-        return range.getTo();
+        return range.to();
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringCharAt.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringCharAt.java
index c64c3c15..9e8a3869 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringCharAt.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringCharAt.java
@@ -8,49 +8,49 @@
 /**
  * The character at a given position in a string. Note that indices in Skript start at 1.
  *
+ * @author Olyno
  * @name Character At
  * @pattern [the] char[acter][s] at [(ind(ex[es]|ices)|pos[ition][s])] %integers% (of|in) %string%
  * @since ALPHA
- * @author Olyno
  */
 public class ExprStringCharAt implements Expression<String> {
-	static {
-		Parser.getMainRegistration().newExpression(ExprStringCharAt.class, String.class, false,
-				"[the] char[acter][s] at [(ind(ex[es]|ices)|pos[ition][s])] %integers% (of|in) %string%")
-			.name("Character At")
-			.description("Returns the character(s) at a given position(s) in a string.")
-			.since("1.0.0")
-			.register();
-	}
+    static {
+        Parser.getMainRegistration().newExpression(ExprStringCharAt.class, String.class, false,
+                "[the] char[acter][s] at [(ind(ex[es]|ices)|pos[ition][s])] %integers% (of|in) %string%")
+            .name("Character At")
+            .description("Returns the character(s) at a given position(s) in a string.")
+            .since("1.0.0")
+            .register();
+    }
 
-	private Expression<Integer> position;
-	private Expression<String> value;
+    private Expression<Integer> position;
+    private Expression<String> value;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		position = (Expression<Integer>) expressions[0];
-		value = (Expression<String>) expressions[1];
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        position = (Expression<Integer>) expressions[0];
+        value = (Expression<String>) expressions[1];
+        return true;
+    }
 
-	@Override
-	public String[] getValues(TriggerContext ctx) {
-		return value.getSingle(ctx)
-				.map(val -> position.stream(ctx)
-						.filter(pos -> Integer.signum(pos) > 0 && pos.compareTo(Integer.valueOf(val.length())) <= 0)
-						.map(pos -> String.valueOf(val.charAt(pos.intValue() - 1)))
-						.toArray(String[]::new))
-				.orElse(new String[0]);
-	}
+    @Override
+    public String[] getValues(TriggerContext ctx) {
+        return value.getSingle(ctx)
+            .map(val -> position.stream(ctx)
+                .filter(pos -> Integer.signum(pos) > 0 && pos.compareTo(Integer.valueOf(val.length())) <= 0)
+                .map(pos -> String.valueOf(val.charAt(pos.intValue() - 1)))
+                .toArray(String[]::new))
+            .orElse(new String[0]);
+    }
 
-	@Override
-	public boolean isSingle() {
-		return position.isSingle();
-	}
+    @Override
+    public boolean isSingle() {
+        return position.isSingle();
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "character at index " + position.toString(ctx, debug) + " in " + value.toString(ctx, debug);
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "character at index " + position.toString(ctx, debug) + " in " + value.toString(ctx, debug);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringChars.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringChars.java
index f3ab8a04..376129cf 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringChars.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringChars.java
@@ -40,7 +40,7 @@ public class ExprStringChars implements Expression<String> {
             .register();
     }
 
-    private final String[] CHAR_TYPES = {
+    private final String[] charTypes = {
         "upper case", "lower case", "digit", "special", "white space"
     };
 
@@ -69,6 +69,6 @@ public String[] getValues(TriggerContext ctx) {
 
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
-        return "all " + CHAR_TYPES[charType] + " characters in " + values.toString(ctx, debug);
+        return "all " + charTypes[charType] + " characters in " + values.toString(ctx, debug);
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprUnaryMathFunctions.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprUnaryMathFunctions.java
index a37b559e..39585f11 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprUnaryMathFunctions.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprUnaryMathFunctions.java
@@ -11,13 +11,14 @@
 
 /**
  * Miscellaneous math functions taking in a single argument
- * 
+ *
+ * @author Syst3ms
  * @name Unary Math Functions
  * @pattern abs %number%
  * @pattern \\|%number%\\|
  * @pattern %number%!
  * @pattern factorial of %number%
- * @pattern (sqrt|square root of) %number%
+ * @pattern (sqrt | square root of) %number%
  * @pattern floor[ed] %number%
  * @pattern ceil[ing|ed] %number%
  * @pattern round[ed] %number%
@@ -32,33 +33,32 @@
  * @pattern tanh %number%
  * @pattern ln %number%
  * @since ALPHA
- * @author Syst3ms
  */
 public class ExprUnaryMathFunctions implements Expression<Number> {
-	// TODO support brackets in the patterns
-	private static final PatternInfos<UnaryOperator<Number>> PATTERNS = new PatternInfos<>(
-		new Object[][]{
-			{"abs %number%|\\|%number%\\|", (UnaryOperator<Number>) NumberMath::abs},
-			{"%number%!", (UnaryOperator<Number>) NumberMath::factorial},
-			{"factorial of %number%", (UnaryOperator<Number>) NumberMath::factorial},
-			{"(sqrt|square root of) %number%", (UnaryOperator<Number>) NumberMath::sqrt},
-			{"floor[ed] %number%", (UnaryOperator<Number>) NumberMath::floor},
-			{"ceil[ing|ed] %number%", (UnaryOperator<Number>) NumberMath::ceil},
-			{"round[ed] %number%", (UnaryOperator<Number>) NumberMath::round},
-			{"sin %number%", (UnaryOperator<Number>) NumberMath::sin},
-			{"cos %number%", (UnaryOperator<Number>) NumberMath::cos},
-			{"tan %number%", (UnaryOperator<Number>) NumberMath::tan},
-			{"asin %number%", (UnaryOperator<Number>) NumberMath::asin},
-			{"acos %number%", (UnaryOperator<Number>) NumberMath::acos},
-			{"atan %number%", (UnaryOperator<Number>) NumberMath::atan},
-			{"sinh %number%", (UnaryOperator<Number>) NumberMath::sinh},
-			{"cosh %number%", (UnaryOperator<Number>) NumberMath::cosh},
-			{"tanh %number%", (UnaryOperator<Number>) NumberMath::tanh},
-			{"ln %number%", (UnaryOperator<Number>) NumberMath::ln}
-		}
-	);
+    // TODO support brackets in the patterns
+    private static final PatternInfos<UnaryOperator<Number>> PATTERNS = new PatternInfos<>(
+        new Object[][]{
+            {"abs %number%|\\|%number%\\|", (UnaryOperator<Number>) NumberMath::abs},
+            {"%number%!", (UnaryOperator<Number>) NumberMath::factorial},
+            {"factorial of %number%", (UnaryOperator<Number>) NumberMath::factorial},
+            {"(sqrt|square root of) %number%", (UnaryOperator<Number>) NumberMath::sqrt},
+            {"floor[ed] %number%", (UnaryOperator<Number>) NumberMath::floor},
+            {"ceil[ing|ed] %number%", (UnaryOperator<Number>) NumberMath::ceil},
+            {"round[ed] %number%", (UnaryOperator<Number>) NumberMath::round},
+            {"sin %number%", (UnaryOperator<Number>) NumberMath::sin},
+            {"cos %number%", (UnaryOperator<Number>) NumberMath::cos},
+            {"tan %number%", (UnaryOperator<Number>) NumberMath::tan},
+            {"asin %number%", (UnaryOperator<Number>) NumberMath::asin},
+            {"acos %number%", (UnaryOperator<Number>) NumberMath::acos},
+            {"atan %number%", (UnaryOperator<Number>) NumberMath::atan},
+            {"sinh %number%", (UnaryOperator<Number>) NumberMath::sinh},
+            {"cosh %number%", (UnaryOperator<Number>) NumberMath::cosh},
+            {"tanh %number%", (UnaryOperator<Number>) NumberMath::tanh},
+            {"ln %number%", (UnaryOperator<Number>) NumberMath::ln}
+        }
+    );
 
-	// TODO disable until I can remove all the "BIG" stuff
+    // TODO disable until I can remove all the "BIG" stuff
 //	static {
 //		Parser.getMainRegistration().addExpression(
 //			ExprUnaryMathFunctions.class,
@@ -68,51 +68,51 @@ public class ExprUnaryMathFunctions implements Expression<Number> {
 //		);
 //	}
 
-	private int pattern;
-	private Expression<Number> number;
+    private int pattern;
+    private Expression<Number> number;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		pattern = matchedPattern;
-		number = (Expression<Number>) expressions[0];
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        pattern = matchedPattern;
+        number = (Expression<Number>) expressions[0];
+        return true;
+    }
 
-	@Override
-	public Number[] getValues(TriggerContext ctx) {
-		return number.getSingle(ctx)
-				.map(n -> new Number[] {PATTERNS.getInfo(pattern).apply(n)})
-				.orElse(new Number[0]);
-	}
+    @Override
+    public Number[] getValues(TriggerContext ctx) {
+        return number.getSingle(ctx)
+            .map(n -> new Number[]{PATTERNS.getInfo(pattern).apply(n)})
+            .orElse(new Number[0]);
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		/*
-		 * This is dirty, but at least it's better than switching over all cases
-		 */
-		String pat = PATTERNS.getPatterns()[pattern];
-		String expr = number.toString(ctx, debug);
-		if (StringUtils.count(pat, "(", "[") == 0) {
-			return pat.replace("%number%", expr);
-		} else {
-			switch (pattern) {
-				case 0:
-					return "abs " + expr;
-				case 1:
-				case 2:
-					return "factorial of " + expr;
-				case 3:
-					return "square root of " + expr;
-				case 4:
-					return "floored " + expr;
-				case 5:
-					return "ceiled " + expr;
-				case 6:
-					return "rounded " + expr;
-				default:
-					throw new IllegalStateException();
-			}
-		}
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        /*
+         * This is dirty, but at least it's better than switching over all cases
+         */
+        String pat = PATTERNS.getPatterns()[pattern];
+        String expr = number.toString(ctx, debug);
+        if (StringUtils.count(pat, "(", "[") == 0) {
+            return pat.replace("%number%", expr);
+        } else {
+            switch (pattern) {
+                case 0:
+                    return "abs " + expr;
+                case 1:
+                case 2:
+                    return "factorial of " + expr;
+                case 3:
+                    return "square root of " + expr;
+                case 4:
+                    return "floored " + expr;
+                case 5:
+                    return "ceiled " + expr;
+                case 6:
+                    return "rounded " + expr;
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprWhether.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprWhether.java
index d4173fba..52598f34 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprWhether.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprWhether.java
@@ -8,10 +8,10 @@
 /**
  * A wrapper that turns a condition into a boolean expression than can be used anywhere.
  *
+ * @author Syst3ms
  * @name Whether
  * @pattern whether %=boolean%
  * @since ALPHA
- * @author Syst3ms
  */
 public class ExprWhether implements Expression<Boolean> {
     static {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java
index 9b8ed3de..3ae31a9c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java
@@ -11,11 +11,11 @@
 /**
  * The name of the current executed script, without the extension.
  *
+ * @author Mwexim
  * @name Script Name
  * @pattern [the] script[['s] name]
  * @pattern name of [the] script
  * @since ALPHA
- * @author Mwexim
  */
 public class LitScriptName implements Literal<String> {
     static {
@@ -38,7 +38,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
 
     @Override
     public String[] getValues() {
-        return new String[] {FileUtils.removeExtension(logger.getFileName())};
+        return new String[]{FileUtils.removeExtension(logger.getFileName())};
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/LitTimeConstants.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/LitTimeConstants.java
index cb253a96..90c44170 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/LitTimeConstants.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/LitTimeConstants.java
@@ -21,7 +21,7 @@
 public class LitTimeConstants implements Literal<Time> {
     static {
         Parser.getMainRegistration().newExpression(LitTimeConstants.class, Time.class, true,
-            "(0:noon|0:midday|1:midnight)", "%*integer% o'[ ]clock")
+                "(0:noon|0:midday|1:midnight)", "%*integer% o'[ ]clock")
             .name("Time Constants")
             .description("Midnight, noon, and midday time constants, as well as the ability to use expressions like '12 o' clock' for literal usage.")
             .since("1.0.0")
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java b/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java
index 37da4c30..94c0807b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java
@@ -21,6 +21,7 @@
 
 /**
  * Represents a section of runnable code.
+ *
  * @see SecConditional
  * @see SecLoop
  * @see SecWhile
@@ -38,10 +39,11 @@ public abstract class CodeSection extends Statement {
      * By default, this simply parses all items inside it, but this can be overridden.
      * In case an extending class just needs to do some additional operations on top of what the default implementation
      * already does, then call {@code super.loadSection(section)} before any such operations.
+     *
      * @param section the {@link FileSection} representing this {@linkplain CodeSection}
-     * @param logger the logger
+     * @param logger  the logger
      * @return {@code true} if the items inside of the section were loaded properly, {@code false} if there was a
-     *         problem
+     * problem
      */
     public boolean loadSection(FileSection section, ParserState parserState, SkriptLogger logger) {
         parserState.setSyntaxRestrictions(getAllowedSyntaxes(), isRestrictingExpressions());
@@ -61,9 +63,21 @@ public boolean run(TriggerContext ctx) {
     @Override
     public abstract Optional<? extends Statement> walk(TriggerContext ctx);
 
+    /**
+     * The items returned by this method are not representative of the execution of the code, meaning that all items
+     * in the list may not be all executed. The list should rather be considered as a flat view of all the lines inside
+     * the section. Prefer {@link Statement#runAll(Statement, TriggerContext)} to run the contents of this section
+     *
+     * @return all items inside this section
+     */
+    public List<Statement> getItems() {
+        return items;
+    }
+
     /**
      * Sets the items inside this lists, and also modifies other fields, reflected through the outputs of {@link #getFirst()},
      * {@link #getLast()} and {@link Statement#getParent()}.
+     *
      * @param items the items to set
      */
     public final void setItems(List<Statement> items) {
@@ -75,16 +89,6 @@ public final void setItems(List<Statement> items) {
         last = items.isEmpty() ? null : items.get(items.size() - 1);
     }
 
-    /**
-     * The items returned by this method are not representative of the execution of the code, meaning that all items
-     * in the list may not be all executed. The list should rather be considered as a flat view of all the lines inside
-     * the section. Prefer {@link Statement#runAll(Statement, TriggerContext)} to run the contents of this section
-     * @return all items inside this section
-     */
-    public List<Statement> getItems() {
-        return items;
-    }
-
     /**
      * @return the first item of this section, or the item after the section if it's empty, or {@code null} if there is
      * no item after this section, in the latter case
@@ -106,6 +110,7 @@ protected final Optional<? extends Statement> getLast() {
      * is to return an empty list, which equates to no restrictions. If overridden, this allows the creation of specialized,
      * DSL-like sections in which only select {@linkplain Statement statements} and other {@linkplain CodeSection sections}
      * (and potentially, but not necessarily, expressions).
+     *
      * @return a list of the classes of each syntax allowed inside this CodeSection
      * @see #isRestrictingExpressions()
      */
@@ -116,8 +121,9 @@ protected Set<Class<? extends SyntaxElement>> getAllowedSyntaxes() {
     /**
      * Whether the syntax restrictions outlined in {@link #getAllowedSyntaxes()} should also apply to expressions.
      * This is usually undesirable, so it is false by default.
-     *
+     * <p>
      * This should return true <b>if and only if</b> {@link #getAllowedSyntaxes()} contains an {@linkplain Expression} class.
+     *
      * @return whether the use of expressions is also restricted by {@link #getAllowedSyntaxes()}. False by default.
      */
     protected boolean isRestrictingExpressions() {
@@ -147,11 +153,11 @@ public boolean checkFinishing(Predicate<? super Statement> finishingTest,
                 // Otherwise, we don't wanna do anything
             } else if (statement instanceof CodeSection) {
                 finished = ((CodeSection) statement).checkFinishing(
-                        finishingTest,
-                        logger,
-                        currentSectionLine + 1,
-                        warnUnreachable,
-                        errorMessage
+                    finishingTest,
+                    logger,
+                    currentSectionLine + 1,
+                    warnUnreachable,
+                    errorMessage
                 );
             } else {
                 finished = finishingTest.test(statement);
@@ -170,11 +176,11 @@ public boolean checkFinishing(Predicate<? super Statement> finishingTest,
                                   int currentSectionLine,
                                   boolean warnUnreachable) {
         return checkFinishing(
-                finishingTest,
-                logger,
-                currentSectionLine,
-                warnUnreachable,
-                "The code inside of this section should end in a finishing statement, but it doesn't"
+            finishingTest,
+            logger,
+            currentSectionLine,
+            warnUnreachable,
+            "The code inside of this section should end in a finishing statement, but it doesn't"
         );
     }
 
@@ -182,11 +188,11 @@ public boolean checkReturns(SkriptLogger logger,
                                 int currentSectionLine,
                                 boolean warnUnreachable) {
         return checkFinishing(
-                s -> s instanceof EffReturn,
-                logger,
-                currentSectionLine,
-                warnUnreachable,
-                "The code inside of this section should return a value, but it doesn't"
+            s -> s instanceof EffReturn,
+            logger,
+            currentSectionLine,
+            warnUnreachable,
+            "The code inside of this section should return a value, but it doesn't"
         );
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java
index 2bf6deef..c043cc86 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java
@@ -22,13 +22,65 @@
 
 /**
  * An expression, i.e a {@link SyntaxElement} representing a value with some type.
+ *
  * @param <T> the type of value this expression returns
  */
 public interface Expression<T> extends SyntaxElement {
+    /**
+     * Checks an array of elements against a given predicate
+     *
+     * @param all       the array to check
+     * @param predicate the predicate
+     * @param negated   whether the result should be inverted
+     * @param and       whether all elements of the array should match the predicate, or only one
+     * @param <T>       the type of the elements to check
+     * @return whether the elements match the given predicate
+     */
+    static <T> boolean check(T[] all, Predicate<? super T> predicate, boolean negated, boolean and) {
+        boolean hasElement = false;
+        for (var t : all) {
+            if (t == null)
+                continue;
+            hasElement = true;
+            boolean b = predicate.test(t);
+            if (and && !b)
+                return negated;
+            if (!and && b)
+                return !negated;
+        }
+        if (!hasElement)
+            return negated;
+        return negated != and;
+    }
+
+    @SuppressWarnings("unchecked")
+    static <S extends CodeSection> List<? extends S> getMatchingSections(ParserState parserState,
+                                                                         Class<? extends S> sectionClass) {
+        List<S> result = new ArrayList<>();
+        for (var section : parserState.getCurrentSections()) {
+            if (sectionClass.isAssignableFrom(section.getClass())) {
+                result.add((S) section);
+            }
+        }
+        return result;
+    }
+
+    static <S extends CodeSection> Optional<? extends S> getLinkedSection(ParserState parserState,
+                                                                          Class<? extends S> sectionClass) {
+        return getLinkedSection(parserState, sectionClass, l -> l.stream().findFirst());
+    }
+
+    static <S extends CodeSection> Optional<? extends S> getLinkedSection(ParserState parserState,
+                                                                          Class<? extends S> sectionClass,
+                                                                          Function<? super List<? extends S>, Optional<? extends S>> selector) {
+        return selector.apply(getMatchingSections(parserState, sectionClass));
+    }
+
     /**
      * Retrieves all values of this Expression, accounting for possible modifiers.
      * This means that if this is an {@linkplain #isAndList() or-list}, it will choose
      * a random value to return.
+     *
      * @param ctx the event
      * @return an array of the values
      * @see #getArray(TriggerContext)
@@ -39,6 +91,7 @@ public interface Expression<T> extends SyntaxElement {
      * Retrieves all values of this Expressions, without accounting for possible modifiers.
      * This means that if this is an {@linkplain #isAndList() or-list}, it will still
      * return all possible values.
+     *
      * @param ctx the event
      * @return an array of the raw values
      */
@@ -51,6 +104,7 @@ default T[] getArray(TriggerContext ctx) {
 
     /**
      * Gets a single value out of this Expression
+     *
      * @param ctx the event
      * @return the single value of this Expression, or empty if it has no value
      * @throws SkriptRuntimeException if the expression returns more than one value
@@ -72,9 +126,9 @@ default Optional<? extends T> getSingle(TriggerContext ctx) {
      */
     default boolean isSingle() {
         return SyntaxManager.getExpressionExact(this)
-                .orElseThrow(() -> new SkriptParserException("Unregistered expression class: " + getClass().getName()))
-                .getReturnType()
-                .isSingle();
+            .orElseThrow(() -> new SkriptParserException("Unregistered expression class: " + getClass().getName()))
+            .getReturnType()
+            .single();
     }
 
     /**
@@ -82,19 +136,20 @@ default boolean isSingle() {
      */
     default Class<? extends T> getReturnType() {
         return SyntaxManager.getExpressionExact(this)
-                .orElseThrow(() -> new SkriptParserException("Unregistered expression class: " + getClass().getName()))
-                .getReturnType()
-                .getType()
-                .getTypeClass();
+            .orElseThrow(() -> new SkriptParserException("Unregistered expression class: " + getClass().getName()))
+            .getReturnType()
+            .type()
+            .getTypeClass();
     }
 
     /**
      * Determines whether this expression can be changed according to a specific {@link ChangeMode}, and what type
      * of values it can be changed with.
+     *
      * @param mode the mode this Expression would be changed with
      * @return an array of classes describing what types this Expression can be changed with, empty if it
-     *         shouldn't be changed with the given {@linkplain ChangeMode change mode}. If the change mode is
-     *         {@link ChangeMode#DELETE} or {@link ChangeMode#RESET}, then an empty array should be returned.
+     * shouldn't be changed with the given {@linkplain ChangeMode change mode}. If the change mode is
+     * {@link ChangeMode#DELETE} or {@link ChangeMode#RESET}, then an empty array should be returned.
      */
     default Optional<Class<?>[]> acceptsChange(ChangeMode mode) {
         return Optional.empty();
@@ -102,7 +157,8 @@ default Optional<Class<?>[]> acceptsChange(ChangeMode mode) {
 
     /**
      * Determines whether this expression can be changed to a specific {@link ChangeMode} and type class.
-     * @param mode the mode this Expression would be changed with
+     *
+     * @param mode       the mode this Expression would be changed with
      * @param changeWith the Expression you want to change with
      * @return whether or not this Expression should be changed with the given {@linkplain ChangeMode change mode} and class.
      */
@@ -112,8 +168,9 @@ default boolean acceptsChange(ChangeMode mode, Expression<?> changeWith) {
 
     /**
      * Determines whether this expression can be changed to a specific {@link ChangeMode} and type class.
-     * @param mode the mode this Expression would be changed with
-     * @param needle the type class of the instance this Expression would be changed with
+     *
+     * @param mode     the mode this Expression would be changed with
+     * @param needle   the type class of the instance this Expression would be changed with
      * @param isSingle whether or not the instance this Expression would be changed with is single
      * @return whether or not this Expression should be changed with the given {@linkplain ChangeMode change mode} and class.
      */
@@ -133,7 +190,8 @@ default boolean acceptsChange(ChangeMode mode, Class<?> needle, boolean isSingle
 
     /**
      * Changes this expression with the given values according to the given mode
-     * @param ctx the event
+     *
+     * @param ctx        the event
      * @param changeMode the mode of change
      * @param changeWith the values to change this Expression with
      */
@@ -162,7 +220,8 @@ default Stream<? extends T> stream(TriggerContext ctx) {
     /**
      * Converts this expression from it's current type ({@link T}) to another type, using
      * {@linkplain Converters converters}.
-     * @param to the class of the type to convert this Expression to
+     *
+     * @param to  the class of the type to convert this Expression to
      * @param <C> the type to convert this Expression to
      * @return a converted Expression, or {@code null} if it couldn't be converted
      */
@@ -173,6 +232,7 @@ default <C> Optional<? extends Expression<C>> convertExpression(Class<C> to) {
     /**
      * When this expression is looped, returns what the loop reference (as in {@literal loop-<reference>})
      * should be in order to describe each element of the values of this expression.
+     *
      * @param s the loop reference
      * @return whether the given reference describes this expression's elements. By default, returns {@code true} if
      * the parameter is {@code "value"}
@@ -195,7 +255,8 @@ default Expression<?> getSource() {
 
     /**
      * Checks this expression against the given {@link Predicate}
-     * @param ctx the event
+     *
+     * @param ctx       the event
      * @param predicate the predicate
      * @return whether the expression matches the predicate
      */
@@ -205,61 +266,13 @@ default boolean check(TriggerContext ctx, Predicate<? super T> predicate) {
 
     /**
      * Checks this expression against the given {@link Predicate}
-     * @param ctx the event
+     *
+     * @param ctx       the event
      * @param predicate the predicate
-     * @param negated whether the result should be inverted
+     * @param negated   whether the result should be inverted
      * @return whether the expression matches the predicate
      */
     default boolean check(TriggerContext ctx, Predicate<? super T> predicate, boolean negated) {
         return check(getArray(ctx), predicate, negated, isAndList());
     }
-
-    /**
-     * Checks an array of elements against a given predicate
-     * @param all the array to check
-     * @param predicate the predicate
-     * @param negated whether the result should be inverted
-     * @param and whether all elements of the array should match the predicate, or only one
-     * @param <T> the type of the elements to check
-     * @return whether the elements match the given predicate
-     */
-    static <T> boolean check(T[] all, Predicate<? super T> predicate, boolean negated, boolean and) {
-        boolean hasElement = false;
-        for (var t : all) {
-            if (t == null)
-                continue;
-            hasElement = true;
-            boolean b = predicate.test(t);
-            if (and && !b)
-                return negated;
-            if (!and && b)
-                return !negated;
-        }
-        if (!hasElement)
-            return negated;
-        return negated != and;
-    }
-
-    @SuppressWarnings("unchecked")
-    static <S extends CodeSection> List<? extends S> getMatchingSections(ParserState parserState,
-                                                                         Class<? extends S> sectionClass) {
-        List<S> result = new ArrayList<>();
-        for (var section : parserState.getCurrentSections()) {
-            if (sectionClass.isAssignableFrom(section.getClass())) {
-                result.add((S) section);
-            }
-        }
-        return result;
-    }
-
-    static <S extends CodeSection> Optional<? extends S> getLinkedSection(ParserState parserState,
-                                                                      Class<? extends S> sectionClass) {
-        return getLinkedSection(parserState, sectionClass, l -> l.stream().findFirst());
-    }
-
-    static <S extends CodeSection> Optional<? extends S> getLinkedSection(ParserState parserState,
-                                                                          Class<? extends S> sectionClass,
-                                                                          Function<? super List<? extends S>, Optional<? extends S>> selector) {
-        return selector.apply(getMatchingSections(parserState, sectionClass));
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/ExpressionList.java b/src/main/java/io/github/syst3ms/skriptparser/lang/ExpressionList.java
index 025c4991..eedb88f1 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/ExpressionList.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/ExpressionList.java
@@ -17,17 +17,17 @@
 
 /**
  * A list of expressions
+ *
  * @param <T> the common supertype of all expressions in this list
  */
 @SuppressWarnings("unchecked")
 public class ExpressionList<T> implements Expression<T> {
 
-    protected Expression<? extends T>[] expressions;
-
+    protected final boolean single;
     @Nullable
     private final ExpressionList<?> source;
     private final Class<T> returnType;
-    protected final boolean single;
+    protected Expression<? extends T>[] expressions;
     protected boolean and;
 
     public ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, boolean and) {
@@ -68,14 +68,16 @@ public T[] getValues(TriggerContext ctx) {
 
     /**
      * Retrieves all {@link Expression}s within this ExpressionList.
+     *
      * @return all {@link Expression}s relating to this ExpressionList.
      */
     public Expression<? extends T>[] getExpressions() {
-    	return expressions;
+        return expressions;
     }
 
     /**
      * Retrieves all values of this Expression using a function that will be applied to each expression.
+     *
      * @param function the function
      * @return an array of the values
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Literal.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Literal.java
index 4f034fd5..25032914 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Literal.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Literal.java
@@ -4,9 +4,14 @@
 
 /**
  * An expression whose value is known at parse time
+ *
  * @param <T> the type of the literal
  */
 public interface Literal<T> extends Expression<T> {
+    static boolean isLiteral(Expression<?> exp) {
+        return exp instanceof Literal || exp instanceof VariableString && ((VariableString) exp).isSimple();
+    }
+
     T[] getValues();
 
     default Optional<? extends T> getSingle() {
@@ -17,8 +22,4 @@ default Optional<? extends T> getSingle() {
     default T[] getValues(TriggerContext ctx) {
         return getValues();
     }
-
-    static boolean isLiteral(Expression<?> exp) {
-        return exp instanceof Literal || exp instanceof VariableString && ((VariableString) exp).isSimple();
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/LiteralList.java b/src/main/java/io/github/syst3ms/skriptparser/lang/LiteralList.java
index 961d1046..96e84613 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/LiteralList.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/LiteralList.java
@@ -6,6 +6,7 @@
 
 /**
  * A list of literals, whose values are known at parse time
+ *
  * @param <T> the common supertype of all literals in the list
  * @see Literal
  */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleCodeSection.java b/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleCodeSection.java
index 159b43c7..33445290 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleCodeSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleCodeSection.java
@@ -9,26 +9,26 @@
 import java.util.Optional;
 
 public class SimpleCodeSection extends CodeSection {
-	private final String name;
+    private final String name;
 
-	public SimpleCodeSection(FileSection section, ParserState parserState, SkriptLogger logger, String name) {
-		this.name = name;
-		loadSection(section, parserState, logger);
-	}
+    public SimpleCodeSection(FileSection section, ParserState parserState, SkriptLogger logger, String name) {
+        this.name = name;
+        loadSection(section, parserState, logger);
+    }
 
-	@Override
-	@Contract("_, _, _ -> fail")
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		throw new UnsupportedOperationException();
-	}
+    @Override
+    @Contract("_, _, _ -> fail")
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        throw new UnsupportedOperationException();
+    }
 
-	@Override
-	public Optional<? extends Statement> walk(TriggerContext ctx) {
-		return getFirst();
-	}
+    @Override
+    public Optional<? extends Statement> walk(TriggerContext ctx) {
+        return getFirst();
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return name;
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return name;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleExpression.java
index da236469..c5ccb909 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleExpression.java
@@ -9,6 +9,7 @@
 
 /**
  * A simple expression with a fixed function to retrieve its values
+ *
  * @param <T> the type of the values
  */
 public class SimpleExpression<T> implements Expression<T> {
@@ -53,7 +54,7 @@ public Class<? extends T> getReturnType() {
     public String toString(TriggerContext ctx, boolean debug) {
         // If the representation is not given, the default TypeManager#toString will be used to convert each value separately
         if (representation == null) {
-            return TypeManager.toString((Object[]) function.apply(ctx));
+            return TypeManager.toString(function.apply(ctx));
         } else {
             return representation;
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleLiteral.java b/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleLiteral.java
index ae550324..591cf372 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleLiteral.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/SimpleLiteral.java
@@ -14,14 +14,15 @@
 
 /**
  * A simple literal with a fixed set of values
+ *
  * @param <T> the type of the values
  */
 @SuppressWarnings("unchecked")
 public class SimpleLiteral<T> implements Literal<T> {
 
-    private boolean isAndList = true;
     private final Class<T> returnType;
     private final T[] values;
+    private boolean isAndList = true;
 
     public SimpleLiteral(T[] values) {
         this.values = values;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java
index 729066d8..3b43a45b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java
@@ -12,11 +12,48 @@
  * @see Effect
  */
 public abstract class Statement implements SyntaxElement {
+    public static Consumer<IllegalStateException> illegalStateRunnable;
     @Nullable
     protected CodeSection parent;
     @Nullable
     protected Statement next;
 
+    public static void setIllegalStateHandler(Consumer<IllegalStateException> consumer) {
+        Statement.illegalStateRunnable = consumer;
+    }
+
+    /**
+     * Runs all code starting at a given point sequentially.
+     * Do note this will not clear local variables after running.
+     *
+     * @param start   the Statement the method should first run
+     * @param context the context
+     * @return {@code true} if the code ran normally, and {@code false} if any exception occurred
+     */
+    public static boolean runAll(Statement start, TriggerContext context) {
+        Optional<? extends Statement> item = Optional.of(start);
+        try {
+            while (item.isPresent())
+                item = item.flatMap(i -> i.walk(context));
+            return true;
+        } catch (StackOverflowError so) {
+            System.err.println("The script repeated itself infinitely!");
+            return false;
+        } catch (IllegalStateException e) {
+            if (illegalStateRunnable != null) {
+                illegalStateRunnable.accept(e);
+            } else {
+                System.err.println("An exception occurred. Stack trace:");
+                e.printStackTrace();
+            }
+            return false;
+        } catch (Exception e) {
+            System.err.println("An exception occurred. Stack trace:");
+            e.printStackTrace();
+        }
+        return false;
+    }
+
     /**
      * Executes this Statement
      *
@@ -86,42 +123,4 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
             return Optional.empty();
         }
     }
-
-    public static Consumer<IllegalStateException> illegalStateRunnable;
-
-    public static void setIllegalStateHandler(Consumer<IllegalStateException> consumer) {
-        Statement.illegalStateRunnable = consumer;
-    }
-
-    /**
-     * Runs all code starting at a given point sequentially.
-     * Do note this will not clear local variables after running.
-     *
-     * @param start   the Statement the method should first run
-     * @param context the context
-     * @return {@code true} if the code ran normally, and {@code false} if any exception occurred
-     */
-    public static boolean runAll(Statement start, TriggerContext context) {
-        Optional<? extends Statement> item = Optional.of(start);
-        try {
-            while (item.isPresent())
-                item = item.flatMap(i -> i.walk(context));
-            return true;
-        } catch (StackOverflowError so) {
-            System.err.println("The script repeated itself infinitely!");
-            return false;
-        } catch (IllegalStateException e) {
-            if (illegalStateRunnable != null) {
-                illegalStateRunnable.accept(e);
-            } else {
-                System.err.println("An exception occurred. Stack trace:");
-                e.printStackTrace();
-            }
-            return false;
-        } catch (Exception e) {
-            System.err.println("An exception occurred. Stack trace:");
-            e.printStackTrace();
-        }
-        return false;
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/SyntaxElement.java b/src/main/java/io/github/syst3ms/skriptparser/lang/SyntaxElement.java
index 5eb010c9..e03f5aca 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/SyntaxElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/SyntaxElement.java
@@ -10,40 +10,20 @@
 
 /**
  * The base class for all elements that are described by a syntax
+ *
  * @see Statement
  * @see Expression
  * @see CodeSection
  */
 public interface SyntaxElement {
-    /**
-     * Initializes this SyntaxElement before being used. This method is always called before all the others in
-     * an extending class, the only exception being {@link CodeSection#loadSection(FileSection, ParserState, SkriptLogger)}.
-     * @param expressions an array of expressions representing all the expressions that are being passed
-     *                    to this syntax element. As opposed to Skript, elements of this array can't be {@code null}.
-     * @param matchedPattern the index of the pattern that was successfully matched. It corresponds to the order of
-     *                       the syntaxes in registration
-     * @param parseContext an object containing additional information about the parsing of this syntax element, like
-     *                    regex matches and parse marks
-     * @return {@code true} if the syntax element was initialized successfully, {@code false} otherwise.
-     * @see SkriptRegistration
-     * @see ParseContext
-     */
-    boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext);
-
-    /**
-     * @param ctx the event
-     * @param debug whether to show additional information or not
-     * @return a {@link String} that should aim to resemble what is written in the script as closely as possible
-     */
-    String toString(TriggerContext ctx, boolean debug);
-
     /**
      * Checks whether this syntax element is inside of specific given {@link CodeSection}s.
-     *
+     * <p>
      * This method shouldn't be used for {@linkplain SyntaxElement}s that should only work with specific {@link TriggerContext}s.
      * For this purpose, prefer {@link ParseContext#getParserState()} used in conjunction with {@link ParserState#getCurrentContexts()}.
-     * @param parseContext the parser context
-     * @param isStrict true if the required section has to be the one directly enclosing this SyntaxElement
+     *
+     * @param parseContext     the parser context
+     * @param isStrict         true if the required section has to be the one directly enclosing this SyntaxElement
      * @param requiredSections a list of the classes of all the {@link CodeSection}s this SyntaxElement should be restricted to
      * @return whether this Syntax element is in a given {@link CodeSection} or not
      * @see ParserState#getCurrentContexts()
@@ -61,4 +41,27 @@ static boolean checkIsInSection(ParseContext parseContext, boolean isStrict, Cla
         }
         return false;
     }
+
+    /**
+     * Initializes this SyntaxElement before being used. This method is always called before all the others in
+     * an extending class, the only exception being {@link CodeSection#loadSection(FileSection, ParserState, SkriptLogger)}.
+     *
+     * @param expressions    an array of expressions representing all the expressions that are being passed
+     *                       to this syntax element. As opposed to Skript, elements of this array can't be {@code null}.
+     * @param matchedPattern the index of the pattern that was successfully matched. It corresponds to the order of
+     *                       the syntaxes in registration
+     * @param parseContext   an object containing additional information about the parsing of this syntax element, like
+     *                       regex matches and parse marks
+     * @return {@code true} if the syntax element was initialized successfully, {@code false} otherwise.
+     * @see SkriptRegistration
+     * @see ParseContext
+     */
+    boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext);
+
+    /**
+     * @param ctx   the event
+     * @param debug whether to show additional information or not
+     * @return a {@link String} that should aim to resemble what is written in the script as closely as possible
+     */
+    String toString(TriggerContext ctx, boolean debug);
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/UnloadedTrigger.java b/src/main/java/io/github/syst3ms/skriptparser/lang/UnloadedTrigger.java
index f94e4897..ce49f441 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/UnloadedTrigger.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/UnloadedTrigger.java
@@ -9,38 +9,6 @@
  * A {@link Trigger trigger}-to-be whose contents haven't been loaded yet. It will be loaded based on its event's
  * {@link SkriptEvent#getLoadingPriority() loading priority}.
  */
-public class UnloadedTrigger {
-    private final Trigger trigger;
-    private final FileSection section;
-    private final int line;
-    private final SkriptEventInfo<?> eventInfo;
-    private final ParserState parserState;
-
-    public UnloadedTrigger(Trigger trigger, FileSection section, int line, SkriptEventInfo<?> eventInfo, ParserState parserState) {
-        this.trigger = trigger;
-        this.section = section;
-        this.line = line;
-        this.eventInfo = eventInfo;
-        this.parserState = parserState;
-    }
-
-    public Trigger getTrigger() {
-        return trigger;
-    }
-
-    public FileSection getSection() {
-        return section;
-    }
-
-    public int getLine() {
-        return line;
-    }
-
-    public ParserState getParserState() {
-        return parserState;
-    }
-
-    public SkriptEventInfo<?> getEventInfo() {
-        return eventInfo;
-    }
+public record UnloadedTrigger(Trigger trigger, FileSection section, int line, SkriptEventInfo<?> eventInfo,
+                              ParserState parserState) {
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java
index 9e0f97ed..1a4b68fb 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java
@@ -30,6 +30,7 @@
 /**
  * A reference to a variable, whose value is only known at runtime. It can be local to the event, meaning it isn't
  * defined outside of the event it was first defined in. It can also be a list of multiple values. It can also be both.
+ *
  * @param <T> the common supertype of the possibly multiple values of the variable
  */
 @SuppressWarnings("unchecked")
@@ -78,6 +79,7 @@ public String getIndex(TriggerContext ctx) {
     /**
      * Returns the raw value stored inside the variable map. This can either be the object
      * this Variable is referencing to or some sort of Map containing nested nodes.
+     *
      * @param ctx the event
      * @return the raw value
      */
@@ -86,11 +88,11 @@ public Optional<Object> getRaw(TriggerContext ctx) {
         if (n.endsWith(Variables.LIST_SEPARATOR + "*") != list) // prevents e.g. {%expr%} where "%expr%" ends with "::*" from returning a Map
             return Optional.empty();
         return Variables.getVariable(n, ctx, local)
-                .or(() -> Variables.getVariable(
-                        (local ? Variables.LOCAL_VARIABLE_TOKEN : "") + name.defaultVariableName(),
-                        ctx,
-                        false
-                ));
+            .or(() -> Variables.getVariable(
+                (local ? Variables.LOCAL_VARIABLE_TOKEN : "") + name.defaultVariableName(),
+                ctx,
+                false
+            ));
     }
 
     private Optional<? extends T> getConverted(TriggerContext ctx) {
@@ -139,7 +141,7 @@ public void setReturnType(Class<?> returnType) {
 
     @Override
     public Optional<Class<?>[]> acceptsChange(ChangeMode mode) {
-        return Optional.of(new Class[] {list ? Object[].class : Object.class});
+        return Optional.of(new Class[]{list ? Object[].class : Object.class});
     }
 
     @SuppressWarnings("rawtypes")
@@ -153,7 +155,7 @@ public void change(TriggerContext ctx, ChangeMode mode, Object[] changeWith) thr
                     if (o == null)
                         return;
                     for (var i : o.entrySet()) {
-                        if (i.getKey() != null){
+                        if (i.getKey() != null) {
                             rem.add(i.getKey());
                         }
                     }
@@ -185,8 +187,8 @@ public void change(TriggerContext ctx, ChangeMode mode, Object[] changeWith) thr
                 break;
             case RESET:
                 Optional<? extends Collection<?>> x = getRaw(ctx).map(r -> r instanceof Map
-                        ? ((Map<?, ?>) r).values()
-                        : Collections.singletonList(r)
+                    ? ((Map<?, ?>) r).values()
+                    : Collections.singletonList(r)
                 );
                 if (x.isEmpty())
                     return;
@@ -264,8 +266,8 @@ public void change(TriggerContext ctx, ChangeMode mode, Object[] changeWith) thr
                                     o = Optional.of(d);
                                 if (d instanceof Number) {
                                     o = mode == ChangeMode.REMOVE
-                                            ? Optional.of(NumberMath.negate((Number) d))
-                                            : Optional.of(d);
+                                        ? Optional.of(NumberMath.negate((Number) d))
+                                        : Optional.of(d);
                                 }
                                 changed = true;
                                 continue;
@@ -435,4 +437,4 @@ private void setIndex(TriggerContext ctx, String index, @Nullable Object value)
         assert s.endsWith("::*") : s + "; " + name;
         Variables.setVariable(s.substring(0, s.length() - 1) + index, value, ctx, local);
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/VariableString.java b/src/main/java/io/github/syst3ms/skriptparser/lang/VariableString.java
index 268b56f3..4c2072de 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/VariableString.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/VariableString.java
@@ -35,7 +35,8 @@ private VariableString(Object[] data) {
 
     /**
      * Creates a new instance of a VariableString.
-     * @param s the text to create a new instance from, with its surrounding quotes
+     *
+     * @param s      the text to create a new instance from, with its surrounding quotes
      * @param logger the logger
      * @return {@code null} if either:
      * <ul>
@@ -50,8 +51,8 @@ public static Optional<VariableString> newInstanceWithQuotes(String s, ParserSta
         if (s.startsWith("\"") && s.endsWith("\"") && StringUtils.nextSimpleCharacterIndex(s, 0) == s.length()) {
             return newInstance(s.substring(1, s.length() - 1), parserState, logger);
         } else if (s.startsWith("'") && s.endsWith("'") && StringUtils.nextSimpleCharacterIndex(s, 0) == s.length()) {
-            return Optional.of(new VariableString(new String[] {
-                    s.substring(1, s.length() - 1).replace("\\\"", "\"")
+            return Optional.of(new VariableString(new String[]{
+                s.substring(1, s.length() - 1).replace("\\\"", "\"")
             }));
         }
         return Optional.empty();
@@ -59,9 +60,10 @@ public static Optional<VariableString> newInstanceWithQuotes(String s, ParserSta
 
     /**
      * Creates a new instance of a VariableString from the text inside a string literal.
-     * @param s the content of the string literal, without quotes
+     *
+     * @param s           the content of the string literal, without quotes
      * @param parserState the current parser state
-     * @param logger the logger
+     * @param logger      the logger
      * @return a new instance of a VariableString, or {@code null} if there are unbalanced {@literal %} symbols
      */
     public static Optional<VariableString> newInstance(String s, ParserState parserState, SkriptLogger logger) {
@@ -92,7 +94,7 @@ public static Optional<VariableString> newInstance(String s, ParserState parserS
                 }
                 data.add(expression.get());
                 i += content.get().length() + 1;
-           // } else if (c == '<') {
+                // } else if (c == '<') {
 //                if (i == charArray.length - 1
 //                        || Character.isWhitespace(charArray[i + 1])) {
 //                    sb.append(c);
@@ -189,8 +191,8 @@ public String toString(TriggerContext ctx, String tagCtx) {
 
         // Filters all non-usable tags away right from the start.
         var actualData = Arrays.stream(data)
-                .filter(o -> !(o instanceof Tag) || ((Tag) o).isUsable(tagCtx))
-                .toArray();
+            .filter(o -> !(o instanceof Tag) || ((Tag) o).isUsable(tagCtx))
+            .toArray();
         var sb = new StringBuilder();
         int currentTags = 1;
         List<Tag> ongoingTags = new ArrayList<>();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConditionalExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConditionalExpression.java
index 6d34c25f..75a79ece 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConditionalExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConditionalExpression.java
@@ -17,8 +17,9 @@
  * </ol>
  * The simplest way to use a value of a conditional expression as if it were a regular boolean expression is to use
  * the {@code whether %=boolean%} expression.
- *
+ * <p>
  * Other, non-conditional boolean expressions should implement {@link Expression<Boolean>}
+ *
  * @see ExprWhether
  * @see SecConditional
  * @see SecWhile
@@ -35,6 +36,7 @@ public Boolean[] getValues(TriggerContext ctx) {
 
     /**
      * Whether a condition is negated. This is used in conjunction with {@link #setNegated(boolean)}.
+     *
      * @return whether the condition is negated
      */
     public boolean isNegated() {
@@ -44,6 +46,7 @@ public boolean isNegated() {
     /**
      * Decides whether the output of a condition should be inverted in order to create a "negated" condition.
      * This was made a built-in method because it is a very common feature of conditions.
+     *
      * @param negated whether the condition should be negated
      */
     public void setNegated(boolean negated) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConvertedExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConvertedExpression.java
index f403b8d8..aa5fdd48 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConvertedExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ConvertedExpression.java
@@ -16,6 +16,7 @@
 /**
  * An expression that has been converted to another type. Type conversion is only being done at runtime, since the values
  * of the source expression aren't known until runtime.
+ *
  * @param <F> The type of the source expression
  * @param <T> The new, converted type of this expression
  * @see Converters
@@ -33,8 +34,9 @@ private ConvertedExpression(Expression<? extends F> source, Class<T> to, Functio
 
     /**
      * Creates a new instance that converts the result by using the registered converters.
-     * @param v the source Expression
-     * @param to the Class to convert to
+     *
+     * @param v   the source Expression
+     * @param to  the Class to convert to
      * @param <F> the original return type
      * @param <T> the converted return type
      * @return an optional ConvertedExpression instance
@@ -42,16 +44,17 @@ private ConvertedExpression(Expression<? extends F> source, Class<T> to, Functio
     @SuppressWarnings("unchecked")
     public static <F, T> Optional<? extends ConvertedExpression<F, T>> newInstance(Expression<F> v, Class<T> to) {
         return Converters.getConverter(v.getReturnType(), to)
-                .map(c -> new ConvertedExpression<>(v, to, (Function<? super F, Optional<? extends T>>) c));
+            .map(c -> new ConvertedExpression<>(v, to, (Function<? super F, Optional<? extends T>>) c));
     }
 
     /**
      * Creates a new instance that converts the result by using the given converter.
-     * @param v the source Expression
-     * @param to the Class to convert to
+     *
+     * @param v         the source Expression
+     * @param to        the Class to convert to
      * @param converter the converter to use
-     * @param <F> the original return type
-     * @param <T> the converted return type
+     * @param <F>       the original return type
+     * @param <T>       the converted return type
      * @return an optional ConvertedExpression instance
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ExecutableExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ExecutableExpression.java
index 5ffa0719..91f90497 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/base/ExecutableExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/base/ExecutableExpression.java
@@ -29,7 +29,7 @@
  */
 public abstract class ExecutableExpression<T> extends Effect implements Expression<T> {
 
-	@Override
+    @Override
     protected void execute(TriggerContext ctx) {
         getValues(ctx, true);
     }
@@ -44,7 +44,8 @@ public T[] getValues(TriggerContext ctx) {
      * Otherwise, if used as an effect, performs side-effects with certain
      * {@link ExecutableExpression behaviour}. Note that when this is not the case,
      * this syntax, by convention, should not have any side-effects.
-     * @param ctx the context
+     *
+     * @param ctx      the context
      * @param isEffect whether this syntax is used as effect or as an expression
      * @return an array of the values
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/base/RestrictedExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/base/RestrictedExpression.java
index 9d6bb562..2ca30a21 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/base/RestrictedExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/base/RestrictedExpression.java
@@ -13,9 +13,10 @@
  * An expression that can only be used in select CodeSections. It is possible to make a RestrictedExpression "strict" ;
  * that is, it would be invalid to use it when not directly enclosed in one of its required sections.
  * It is possible to specify the error message that should be shown if the restrictions aren't followed.
- *
+ * <p>
  * This class shouldn't be used for expressions that should only work with specific {@link TriggerContext}s.
  * For this purpose, use {@link ParseContext#getParserState()} in conjuction with {@link ParserState#getCurrentContexts()}.
+ *
  * @param <T> the return type
  * @see ParserState#getCurrentContexts()
  */
@@ -36,10 +37,10 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         if (required == null) {
             var logger = parseContext.getLogger();
             logger.error(
-                    getSpecificErrorMessage() + " : '"
-                            + this.toString(TriggerContext.DUMMY, logger.isDebug()) + "'",
-                    ErrorType.SEMANTIC_ERROR,
-                    "This expression cannot be used everywhere. Refer to the documentation to see the correct usage of this expression");
+                getSpecificErrorMessage() + " : '"
+                    + this.toString(TriggerContext.DUMMY, logger.isDebug()) + "'",
+                ErrorType.SEMANTIC_ERROR,
+                "This expression cannot be used everywhere. Refer to the documentation to see the correct usage of this expression");
             return false;
         }
         return initialize(expressions, required, matchedPattern, parseContext);
@@ -49,18 +50,21 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
 
     /**
      * The error message that should be displayed if this expression is used outside of one of its required sections
+     *
      * @return the error message that should be displayed if this expression is used outside of one of its required sections
      */
     protected abstract String getSpecificErrorMessage();
 
     /**
      * Returns a list of the classes of all the sections inside of which this expression can be used
+     *
      * @return a list of the classes of all the sections inside of which this expression can be used
      */
     protected abstract List<Class<? extends CodeSection>> getRequiredSections();
 
     /**
      * True if the directly enclosing section must be a required one (a member of {@link #getRequiredSections()}), false otherwise.
+     *
      * @return whether the directly enclosing section must be a required one or not
      */
     protected abstract boolean isStrict();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/base/TaggedExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/base/TaggedExpression.java
index 70c45ede..19d47ec2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/base/TaggedExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/base/TaggedExpression.java
@@ -11,38 +11,40 @@
  * {@link TaggedExpression} is used.
  */
 public abstract class TaggedExpression implements Expression<String> {
-	@Override
-	public String[] getValues(TriggerContext ctx) {
-		return new String[] {toString(ctx, "default")};
-	}
+    /**
+     * Returns the string values of this expression after applying all tags.
+     * This means if the expression is a {@link TaggedExpression}
+     * or an {@link ExpressionList} containing a TaggedExpression,
+     * all the tags will be applied with the given tag context. If not, it will
+     * just return the string values of this expression.
+     *
+     * @param expr   the single expression
+     * @param ctx    the context
+     * @param tagCtx the tag context
+     * @return the strings with optional tags applied
+     */
+    @SuppressWarnings("unchecked")
+    public static String[] apply(Expression<String> expr, TriggerContext ctx, String tagCtx) {
+        if (expr instanceof TaggedExpression) {
+            return new String[]{((TaggedExpression) expr).toString(ctx, tagCtx)};
+        } else if (expr instanceof ExpressionList) {
+            return ((ExpressionList<String>) expr).getValues(val -> apply((Expression<String>) val, ctx, tagCtx));
+        } else {
+            return expr.getValues(ctx);
+        }
+    }
 
-	/**
-	 * Returns the value of this string after applying the tags according to the given tag context.
-	 * @param ctx the event
-	 * @param tagCtx the tag context
-	 * @return the applied string
-	 */
-	public abstract String toString(TriggerContext ctx, String tagCtx);
+    @Override
+    public String[] getValues(TriggerContext ctx) {
+        return new String[]{toString(ctx, "default")};
+    }
 
-	/**
-	 * Returns the string values of this expression after applying all tags.
-	 * This means if the expression is a {@link TaggedExpression}
-	 * or an {@link ExpressionList} containing a TaggedExpression,
-	 * all the tags will be applied with the given tag context. If not, it will
-	 * just return the string values of this expression.
-	 * @param expr the single expression
-	 * @param ctx the context
-	 * @param tagCtx the tag context
-	 * @return the strings with optional tags applied
-	 */
-	@SuppressWarnings("unchecked")
-	public static String[] apply(Expression<String> expr, TriggerContext ctx, String tagCtx) {
-		if (expr instanceof TaggedExpression) {
-			return new String[] {((TaggedExpression) expr).toString(ctx, tagCtx)};
-		} else if (expr instanceof ExpressionList) {
-			return ((ExpressionList<String>) expr).getValues(val -> apply((Expression<String>) val, ctx, tagCtx));
-		} else {
-			return expr.getValues(ctx);
-		}
-	}
+    /**
+     * Returns the value of this string after applying the tags according to the given tag context.
+     *
+     * @param ctx    the event
+     * @param tagCtx the tag context
+     * @return the applied string
+     */
+    public abstract String toString(TriggerContext ctx, String tagCtx);
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/control/Continuable.java b/src/main/java/io/github/syst3ms/skriptparser/lang/control/Continuable.java
index 837f3dd1..b6855d27 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/control/Continuable.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/control/Continuable.java
@@ -13,18 +13,20 @@
  * indicator to be able to continue to the next iteration instead of executing the rest of the statements.
  * <br>
  * One can easily compare this with Java's {@code continue} keyword.
+ *
  * @see EffContinue
  */
 public interface Continuable {
-	/**
-	 * This function is called on the section where the {@link EffContinue} effect will
-	 * continue to, taking all Continuable sections into account. Most of the time, this will just
-	 * return the section it is referring to, but in rare cases, one might want to change this
-	 * behaviour, hence this method.
-	 * @param ctx the context
-	 * @return the next statement
-	 * @see EffContinue
-	 * @see SecLoop SecLoop (implementation)
-	 */
-	Optional<? extends Statement> getContinued(TriggerContext ctx);
+    /**
+     * This function is called on the section where the {@link EffContinue} effect will
+     * continue to, taking all Continuable sections into account. Most of the time, this will just
+     * return the section it is referring to, but in rare cases, one might want to change this
+     * behaviour, hence this method.
+     *
+     * @param ctx the context
+     * @return the next statement
+     * @see EffContinue
+     * @see SecLoop SecLoop (implementation)
+     */
+    Optional<? extends Statement> getContinued(TriggerContext ctx);
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java b/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java
index 41080ef1..ddce45b4 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java
@@ -20,27 +20,29 @@
  * <br>
  * {@link ArgumentSection} implements this interface by default, because of their intrinsic nature of needing
  * a finishing method like this.
+ *
  * @see SecLoop
  * @see SecSwitch
  * @see SecMap
  */
 public interface Finishing {
-	/**
-	 * By convention, this method should be fired in one of the following occasions:
-	 * <ol>
-	 *     <li>The execution of the section is completely done and the (actual) next element is
-	 *     referenced to be {@linkplain Statement#walk(TriggerContext) walked} on.</li>
-	 *     <li>This method is <b>completely</b> stopped by any means whatsoever.</li>
-	 * </ol>
-	 * An example of this second occasion is {@link EffContinue} continuing over multiple loops.
-	 * If that effect continues 3 loops in one go, this means that the 2 most inner-loops need to be
-	 * completely reset, since they have the possibility to be looped over again. EffContinue therefore
-	 * calls this method on those loops.
-	 * <br>
-	 * Another example is {@link EffExit}, which finishes every section that implements this interface,
-	 * because of the same reasons specified above.
-	 * @see EffExit
-	 * @see EffContinue
-	 */
-	void finish();
+    /**
+     * By convention, this method should be fired in one of the following occasions:
+     * <ol>
+     *     <li>The execution of the section is completely done and the (actual) next element is
+     *     referenced to be {@linkplain Statement#walk(TriggerContext) walked} on.</li>
+     *     <li>This method is <b>completely</b> stopped by any means whatsoever.</li>
+     * </ol>
+     * An example of this second occasion is {@link EffContinue} continuing over multiple loops.
+     * If that effect continues 3 loops in one go, this means that the 2 most inner-loops need to be
+     * completely reset, since they have the possibility to be looped over again. EffContinue therefore
+     * calls this method on those loops.
+     * <br>
+     * Another example is {@link EffExit}, which finishes every section that implements this interface,
+     * because of the same reasons specified above.
+     *
+     * @see EffExit
+     * @see EffContinue
+     */
+    void finish();
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/control/SelfReferencing.java b/src/main/java/io/github/syst3ms/skriptparser/lang/control/SelfReferencing.java
index 707ed47a..cb6125a2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/control/SelfReferencing.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/control/SelfReferencing.java
@@ -12,17 +12,19 @@
  * <br>
  * When creating syntax, one may need to take this into account. This is mostly done by sections that
  * iterate over their respective contents multiple times.
+ *
  * @see SecWhile
  * @see SecLoop
  */
 public interface SelfReferencing {
-	/**
-	 * This statement returns itself as the next statement to run
-	 * in {@link Statement#getNext() getNext()}.
-	 * <br>
-	 * This method will return the actual statement that follows this statement.
-	 * This means, by convention, the next element that is not nested more than this statement.
-	 * @return the element that is actually after this section
-	 */
-	Optional<Statement> getActualNext();
+    /**
+     * This statement returns itself as the next statement to run
+     * in {@link Statement#getNext() getNext()}.
+     * <br>
+     * This method will return the actual statement that follows this statement.
+     * This means, by convention, the next element that is not nested more than this statement.
+     *
+     * @return the element that is actually after this section
+     */
+    Optional<Statement> getActualNext();
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/EntryLoader.java b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/EntryLoader.java
index c12cbacc..e4f9e376 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/EntryLoader.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/EntryLoader.java
@@ -5,32 +5,33 @@
 import io.github.syst3ms.skriptparser.parsing.ParserState;
 
 public abstract class EntryLoader {
-	protected final String key;
-	private final boolean optional;
+    protected final String key;
+    private final boolean optional;
 
-	public EntryLoader(String key, boolean optional) {
-		this.key = key;
-		this.optional = optional;
-	}
+    public EntryLoader(String key, boolean optional) {
+        this.key = key;
+        this.optional = optional;
+    }
 
-	/**
-	 * This {@link EntryLoader} will attempt to load the entry
-	 * using its {@linkplain FileElement}. One can use this method
-	 * to create specific error messages or to load the value correctly.
-	 * <br>
-	 * If an error occurred while executing this method, meaning {@linkplain SkriptLogger#hasError()}
-	 * is {@code true}, the parser will not loop over the other {@linkplain FileElement elements}
-	 * present. If this method returned {@code false}, but there is no error given,
-	 * a default error message {@code "The entry has not been configured."} will be used.
-	 * @param config the configuration
-	 * @param element the element
-	 * @param parserState the parser state
-	 * @param logger the logger
-	 * @return {@code true} if loaded successfully, {@code false} if an error occurred
-	 */
-	public abstract boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger);
+    /**
+     * This {@link EntryLoader} will attempt to load the entry
+     * using its {@linkplain FileElement}. One can use this method
+     * to create specific error messages or to load the value correctly.
+     * <br>
+     * If an error occurred while executing this method, meaning {@linkplain SkriptLogger#hasError()}
+     * is {@code true}, the parser will not loop over the other {@linkplain FileElement elements}
+     * present. If this method returned {@code false}, but there is no error given,
+     * a default error message {@code "The entry has not been configured."} will be used.
+     *
+     * @param config      the configuration
+     * @param element     the element
+     * @param parserState the parser state
+     * @param logger      the logger
+     * @return {@code true} if loaded successfully, {@code false} if an error occurred
+     */
+    public abstract boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger);
 
-	public boolean isOptional() {
-		return optional;
-	}
+    public boolean isOptional() {
+        return optional;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/LiteralLoader.java b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/LiteralLoader.java
index 37c5293a..f331b2cc 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/LiteralLoader.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/LiteralLoader.java
@@ -11,70 +11,70 @@
 
 public class LiteralLoader<T> extends OptionLoader {
 
-	private final Class<T> typeClass;
+    private final Class<T> typeClass;
 
-	public LiteralLoader(String key, Class<T> typeClass, boolean multiple, boolean optional) {
-		super(key, multiple, optional);
-		this.typeClass = typeClass;
-	}
+    public LiteralLoader(String key, Class<T> typeClass, boolean multiple, boolean optional) {
+        super(key, multiple, optional);
+        this.typeClass = typeClass;
+    }
 
-	@Override
-	public boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger) {
-		// We will use the loaded values later
-		if (!super.loadEntry(config, element, parserState, logger))
-			return false;
+    @Override
+    public boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger) {
+        // We will use the loaded values later
+        if (!super.loadEntry(config, element, parserState, logger))
+            return false;
 
-		var type = TypeManager.getByClassExact(typeClass);
-		if (type.isEmpty()) {
-			logger.error("Couldn't find a type corresponding to the class '" + typeClass.getName() + "'", ErrorType.NO_MATCH);
-			return false;
-		} else if (type.get().getLiteralParser().isEmpty()) {
-			logger.error("The type '" + type.get().getBaseName() + "' doesn't have a literal parser.", ErrorType.NO_MATCH);
-			return false;
-		}
-		var parser = type.get().getLiteralParser().get();
+        var type = TypeManager.getByClassExact(typeClass);
+        if (type.isEmpty()) {
+            logger.error("Couldn't find a type corresponding to the class '" + typeClass.getName() + "'", ErrorType.NO_MATCH);
+            return false;
+        } else if (type.get().getLiteralParser().isEmpty()) {
+            logger.error("The type '" + type.get().getBaseName() + "' doesn't have a literal parser.", ErrorType.NO_MATCH);
+            return false;
+        }
+        var parser = type.get().getLiteralParser().get();
 
-		logger.setLine(element.getLine() - 1);
+        logger.setLine(element.getLine() - 1);
 
-		if (isMultiple()) {
-			List<T> data = new ArrayList<>();
-			boolean successful = true;
+        if (isMultiple()) {
+            List<T> data = new ArrayList<>();
+            boolean successful = true;
 
-			var list = config.getStringList(key);
-			if (!list.isPresent()) {
-				logger.error("List at key '" + key + "' does not exist.", ErrorType.SEMANTIC_ERROR);
-				return false;
-			}
-			for (var value : list.get()) {
-				var result = parser.apply(value);
-				if (result == null) {
-					// With the logic that errors get skipped, we will allow the other values to be parsed.
-					logger.error("Couldn't parse '" + value + "' as " + type.get().withIndefiniteArticle(false), ErrorType.SEMANTIC_ERROR);
-					logger.finalizeLogs();
-					successful = false;
-					continue;
-				}
-				data.add(result);
-			}
-			config.getData().put(key, data.toArray());
-			return successful;
-		} else {
-			var value = config.getString(key);
-			if (!value.isPresent()) {
-				logger.error("Key '" + key + "' does not exist.", ErrorType.SEMANTIC_ERROR);
-				return false;
-			}
-			var result = parser.apply(value.get());
-			// We don't want this data to linger if an error occurs
-			config.getData().remove(key);
-			if (result == null) {
-				logger.error("Couldn't parse '" + config.getString(key) + "' as " + type.get().withIndefiniteArticle(false), ErrorType.SEMANTIC_ERROR);
-				return false;
-			}
-			config.getData().put(key, result);
-			return true;
-		}
+            var list = config.getStringList(key);
+            if (!list.isPresent()) {
+                logger.error("List at key '" + key + "' does not exist.", ErrorType.SEMANTIC_ERROR);
+                return false;
+            }
+            for (var value : list.get()) {
+                var result = parser.apply(value);
+                if (result == null) {
+                    // With the logic that errors get skipped, we will allow the other values to be parsed.
+                    logger.error("Couldn't parse '" + value + "' as " + type.get().withIndefiniteArticle(false), ErrorType.SEMANTIC_ERROR);
+                    logger.finalizeLogs();
+                    successful = false;
+                    continue;
+                }
+                data.add(result);
+            }
+            config.getData().put(key, data.toArray());
+            return successful;
+        } else {
+            var value = config.getString(key);
+            if (!value.isPresent()) {
+                logger.error("Key '" + key + "' does not exist.", ErrorType.SEMANTIC_ERROR);
+                return false;
+            }
+            var result = parser.apply(value.get());
+            // We don't want this data to linger if an error occurs
+            config.getData().remove(key);
+            if (result == null) {
+                logger.error("Couldn't parse '" + config.getString(key) + "' as " + type.get().withIndefiniteArticle(false), ErrorType.SEMANTIC_ERROR);
+                return false;
+            }
+            config.getData().put(key, result);
+            return true;
+        }
 
-	}
+    }
 
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/OptionLoader.java b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/OptionLoader.java
index 8a19f89b..560279b8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/OptionLoader.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/OptionLoader.java
@@ -8,49 +8,49 @@
 import io.github.syst3ms.skriptparser.parsing.ParserState;
 
 public class OptionLoader extends EntryLoader {
-	public static final String OPTION_SPLIT_PATTERN = ": ";
+    public static final String OPTION_SPLIT_PATTERN = ": ";
 
-	private final boolean multiple;
+    private final boolean multiple;
 
-	public OptionLoader(String key, boolean multiple, boolean optional) {
-		super(key, optional);
-		this.multiple = multiple;
-	}
+    public OptionLoader(String key, boolean multiple, boolean optional) {
+        super(key, optional);
+        this.multiple = multiple;
+    }
 
-	@Override
-	public boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger) {
-		var content = element.getLineContent().split(OPTION_SPLIT_PATTERN);
-		if (content.length == 0)
-			return false;
-		var key = content[0];
-		var entry = content.length > 1 ? content[1] : null;
+    @Override
+    public boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger) {
+        var content = element.getLineContent().split(OPTION_SPLIT_PATTERN);
+        if (content.length == 0)
+            return false;
+        var key = content[0];
+        var entry = content.length > 1 ? content[1] : null;
 
-		if (!key.equalsIgnoreCase(this.key))
-			return false;
-		if (element instanceof FileSection) {
-			if (!multiple) {
-				logger.error("The entry '" + key + "' does not support multiple values.", ErrorType.SEMANTIC_ERROR);
-				return false;
-			} else if (entry != null) {
-				logger.error("The entry '" + key + "' has been configured incorrectly.", ErrorType.SEMANTIC_ERROR);
-				return false;
-			}
-			config.getData().put(this.key, ((FileSection) element).getElements().stream()
-					.filter(el -> !(el instanceof VoidElement))
-					.map(FileElement::getLineContent)
-					.toArray(String[]::new)
-			);
-		} else {
-			if (entry == null) {
-				logger.error("The entry '" + key + "' has been configured incorrectly.", ErrorType.SEMANTIC_ERROR);
-				return false;
-			}
-			config.getData().put(this.key, multiple ? new String[] {entry} : entry);
-		}
-		return true;
-	}
+        if (!key.equalsIgnoreCase(this.key))
+            return false;
+        if (element instanceof FileSection) {
+            if (!multiple) {
+                logger.error("The entry '" + key + "' does not support multiple values.", ErrorType.SEMANTIC_ERROR);
+                return false;
+            } else if (entry != null) {
+                logger.error("The entry '" + key + "' has been configured incorrectly.", ErrorType.SEMANTIC_ERROR);
+                return false;
+            }
+            config.getData().put(this.key, ((FileSection) element).getElements().stream()
+                .filter(el -> !(el instanceof VoidElement))
+                .map(FileElement::getLineContent)
+                .toArray(String[]::new)
+            );
+        } else {
+            if (entry == null) {
+                logger.error("The entry '" + key + "' has been configured incorrectly.", ErrorType.SEMANTIC_ERROR);
+                return false;
+            }
+            config.getData().put(this.key, multiple ? new String[]{entry} : entry);
+        }
+        return true;
+    }
 
-	public boolean isMultiple() {
-		return multiple;
-	}
+    public boolean isMultiple() {
+        return multiple;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionConfiguration.java b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionConfiguration.java
index 15a04728..24b843ff 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionConfiguration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionConfiguration.java
@@ -53,11 +53,11 @@ private SectionConfiguration(List<EntryLoader> entries) {
      * a FileSection instance. This method should be called only once and will throw an error if attempting
      * to load the configuration multiple times. The default use-case would be to load the configuration inside
      * CodeSection's {@link CodeSection#loadSection(FileSection, ParserState, SkriptLogger) load} method.
-     * 
-     * @param parent the parent section
-     * @param section the file section
+     *
+     * @param parent      the parent section
+     * @param section     the file section
      * @param parserState the parse state
-     * @param logger the logger
+     * @param logger      the logger
      * @return whether the section was loaded successfully or errors occurred
      */
     public boolean loadConfiguration(@Nullable CodeSection parent, FileSection section, ParserState parserState, SkriptLogger logger) {
@@ -136,8 +136,8 @@ public Object getValue(String key) {
      *
      * @param key the key
      * @param cls the class to cast to
-     * @return the value cast to the given class, or an empty Optional if the key was not specified
      * @param <T> the type of the value
+     * @return the value cast to the given class, or an empty Optional if the key was not specified
      */
     @SuppressWarnings("unchecked")
     public <T> Optional<T> getValue(String key, Class<T> cls) {
@@ -151,7 +151,7 @@ public <T> Optional<T> getValue(String key, Class<T> cls) {
 
     public <T> Optional<Expression<T>> getExpression(String key, Class<T> cls) {
         Object o = this.data.get(key);
-        if (o instanceof Expression<?> expression && cls.isAssignableFrom(expression.getReturnType()))  {
+        if (o instanceof Expression<?> expression && cls.isAssignableFrom(expression.getReturnType())) {
             return (Optional<Expression<T>>) Optional.of((T) expression);
         }
         return Optional.empty();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionLoader.java b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionLoader.java
index 109b5f71..758450ea 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionLoader.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/entries/SectionLoader.java
@@ -8,22 +8,22 @@
 import io.github.syst3ms.skriptparser.parsing.ParserState;
 
 public class SectionLoader extends EntryLoader {
-	public SectionLoader(String key, boolean optional) {
-		super(key, optional);
-	}
+    public SectionLoader(String key, boolean optional) {
+        super(key, optional);
+    }
 
-	@Override
-	public boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger) {
-		if (!element.getLineContent().equalsIgnoreCase(key))
-			return false;
-		if (!(element instanceof FileSection)) {
-			logger.error("The entry '" + key + "' has been configured incorrectly.", ErrorType.SEMANTIC_ERROR);
-			return false;
-		}
-		var entry = new SimpleCodeSection((FileSection) element, parserState, logger, key);
-		if (config.getParent() != null)
-			entry.setParent(config.getParent());
-		config.getData().put(key, entry);
-		return true;
-	}
+    @Override
+    public boolean loadEntry(SectionConfiguration config, FileElement element, ParserState parserState, SkriptLogger logger) {
+        if (!element.getLineContent().equalsIgnoreCase(key))
+            return false;
+        if (!(element instanceof FileSection)) {
+            logger.error("The entry '" + key + "' has been configured incorrectly.", ErrorType.SEMANTIC_ERROR);
+            return false;
+        }
+        var entry = new SimpleCodeSection((FileSection) element, parserState, logger, key);
+        if (config.getParent() != null)
+            entry.setParent(config.getParent());
+        config.getData().put(key, entry);
+        return true;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java
index 6fed85dd..e7d804c4 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java
@@ -34,6 +34,7 @@ protected Optional<? extends Statement> start() {
      * of only when the execution has finished (see {@linkplain #finish()} for that)
      * <br>
      * By default, does nothing.
+     *
      * @param item the last statement
      * @see EffContinue
      * @see EffReturn
@@ -52,6 +53,7 @@ public Object[] getArguments() {
 
     /**
      * Sets the arguments that should be passed to the section code.
+     *
      * @param arguments this section's arguments
      */
     public void setArguments(Object... arguments) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ReturnSection.java b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ReturnSection.java
index bab373af..dd2f372d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ReturnSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ReturnSection.java
@@ -8,6 +8,7 @@
 /**
  * An {@link ArgumentSection} that can hold information about valued returned by the code inside it (typically through
  * {@link EffReturn}).
+ *
  * @param <T> the type of the return value.
  */
 public abstract class ReturnSection<T> extends ArgumentSection {
@@ -16,6 +17,7 @@ public abstract class ReturnSection<T> extends ArgumentSection {
 
     /**
      * The values being returned from inside this section.
+     *
      * @return an Optional describing the returned values, or an empty Optional if no values have been returned so far.
      */
     public Optional<T[]> getReturned() {
@@ -24,6 +26,7 @@ public Optional<T[]> getReturned() {
 
     /**
      * Sets the values returned from inside this section.
+     *
      * @param returned the returned values
      * @throws ClassCastException if the values passed aren't of the type {@link T}
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java
index dc15eec9..8f57485f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java
@@ -26,14 +26,14 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             return false;
         }
         section = Expression.getLinkedSection(parseContext.getParserState(), getSectionClass(), getSelectorFunction())
-                .orElse(null);
+            .orElse(null);
         if (section == null) {
             var logger = parseContext.getLogger();
             logger.error(
-                    "Couldn't find a section linked to the expression '" +
-                            toString(TriggerContext.DUMMY, logger.isDebug()) +
-                            "'",
-                    ErrorType.SEMANTIC_ERROR
+                "Couldn't find a section linked to the expression '" +
+                    toString(TriggerContext.DUMMY, logger.isDebug()) +
+                    "'",
+                ErrorType.SEMANTIC_ERROR
             );
             return false;
         }
@@ -49,12 +49,12 @@ public T[] getValues(TriggerContext ctx) {
      * This method is run before the section linked to this {@code SectionValue} is identified, and should be used
      * to initialize fields and other class data using the usual parameters of the {@link SyntaxElement#init} function.
      *
-     * @param expressions an array of expressions representing all the expressions that are being passed
-     *                    to this {@code SectionValue}. As opposed to Skript, elements of this array can't be {@code null}.
+     * @param expressions    an array of expressions representing all the expressions that are being passed
+     *                       to this {@code SectionValue}. As opposed to Skript, elements of this array can't be {@code null}.
      * @param matchedPattern the index of the pattern that was successfully matched. It corresponds to the order of
      *                       the syntaxes in registration
-     * @param parseContext an object containing additional information about the parsing of this {@code SectionValue},
-     *                     like regex matches and parse marks
+     * @param parseContext   an object containing additional information about the parsing of this {@code SectionValue},
+     *                       like regex matches and parse marks
      * @return {@code true} if the {@code SectionValue} was pre-initialized successfully, {@code false} otherwise.
      * @see SyntaxElement#init
      */
@@ -63,10 +63,10 @@ public T[] getValues(TriggerContext ctx) {
     /**
      * This method is run after the section linked to this {@code SectionValue} is identified, and should be used to
      * make some additional verifications/setup operations on the linked {@link ArgumentSection} that was identified.
-     *
+     * <p>
      * By default, this function always returns {@code true} with no added operations.
      *
-     * @param section the section that was identified as corresponding to this {@code SectionValue}
+     * @param section      the section that was identified as corresponding to this {@code SectionValue}
      * @param parseContext the parse context used previously
      * @return {@code true} if the {@code SectionValue} was post-initialized successfully, {@code false} otherwise.
      */
@@ -76,12 +76,12 @@ public boolean postInitialize(S section, ParseContext parseContext) {
 
     /**
      * Returns the selector function for this {@code SectionValue}.
-     *
+     * <p>
      * This function is supplied with a list of all the sections of the type described by {@link #getSectionClass()},
      * and returns an Optional describing the section that this {@code SectionValue} should be linked to, or an empty
      * Optional if no matching section was found. This is useful for targeting a specific section out of multiple
      * surrounding ones based on criteria specific to the implementation.
-     *
+     * <p>
      * By default, this always picks the first matching function (i.e the innermost one), if there is one.
      *
      * @return the selector function for this {@code SectionValue}.
@@ -95,7 +95,7 @@ public Function<? super List<? extends S>, Optional<? extends S>> getSelectorFun
      * the linked section and the {@link TriggerContext}.
      *
      * @param section the linked section
-     * @param ctx the {@link TriggerContext}
+     * @param ctx     the {@link TriggerContext}
      * @return the values of this {@code SectionValue}
      */
     public abstract T[] getSectionValues(S section, TriggerContext ctx);
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/properties/ConditionalType.java b/src/main/java/io/github/syst3ms/skriptparser/lang/properties/ConditionalType.java
index 1d097191..8d24e94b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/properties/ConditionalType.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/properties/ConditionalType.java
@@ -4,21 +4,21 @@
  * @see PropertyConditional
  */
 public enum ConditionalType {
-	/**
-	 * The property is of the form {@code something is something},
-	 * plurality and negation supported.
-	 */
-	BE,
+    /**
+     * The property is of the form {@code something is something},
+     * plurality and negation supported.
+     */
+    BE,
 
-	/**
-	 * The property is of the form {@code something can something},
-	 * plurality and negation supported.
-	 */
-	CAN,
+    /**
+     * The property is of the form {@code something can something},
+     * plurality and negation supported.
+     */
+    CAN,
 
-	/**
-	 * The property is of the form {@code something has something},
-	 * plurality and negation supported.
-	 */
-	HAVE
+    /**
+     * The property is of the form {@code something has something},
+     * plurality and negation supported.
+     */
+    HAVE
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyConditional.java b/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyConditional.java
index 0167cc47..6e125962 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyConditional.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyConditional.java
@@ -16,7 +16,7 @@
  *     <li>{@code something has something}</li>
  * </ul>
  * The plural and negated forms are also supported.
- *
+ * <p>
  * The gains of using this class:
  * <ul>
  *     <li>There is a useful {@link #toString(TriggerContext, boolean, String) toString()}
@@ -25,6 +25,7 @@
  *     <li>Registration is very straightforward.</li>
  *     <li>The performer expression is automatically checked for nullity.</li>
  * </ul>
+ *
  * @param <P> the type of the performer in this condition
  * @author Mwexim
  */
@@ -34,16 +35,40 @@ public abstract class PropertyConditional<P> extends ConditionalExpression {
 
     private Expression<P> performer;
 
+    public static String[] composePatterns(String performer, ConditionalType conditionalType, String property) {
+        var type = performer.startsWith("*") ? performer.substring(1) : "%" + performer + "%";
+        switch (conditionalType) {
+            case BE:
+                return new String[]{
+                    type + " (is|are) " + property,
+                    type + " (is|are)( not|n't) " + property,
+                };
+            case CAN:
+                return new String[]{
+                    type + " can " + property,
+                    type + " can([ ]not|'t) " + property,
+                };
+            case HAVE:
+                return new String[]{
+                    type + " (has|have) " + property,
+                    type + " does( not|n't) have " + property,
+                };
+            default:
+                throw new AssertionError();
+        }
+    }
+
     /**
      * This default {@code init()} implementation automatically properly sets the performer in this condition,
      * which can be accessed using {@link #getPerformer()}. If this implementation is overridden for one reason
      * or another, it must call {@link #setPerformer(Expression)} properly.
-     * @param expressions an array of expressions representing all the expressions that are being passed
-     *                    to this syntax element.
+     *
+     * @param expressions    an array of expressions representing all the expressions that are being passed
+     *                       to this syntax element.
      * @param matchedPattern the index of the pattern that was successfully matched. It corresponds to the order of
      *                       the syntaxes in registration
-     * @param parseContext an object containing additional information about the parsing of this syntax element, like
-     *                    regex matches and parse marks
+     * @param parseContext   an object containing additional information about the parsing of this syntax element, like
+     *                       regex matches and parse marks
      * @return whether the initialization was successful or not.
      */
     @SuppressWarnings("unchecked")
@@ -62,6 +87,7 @@ public boolean check(TriggerContext ctx) {
     /**
      * Tests this condition for each individual performer. Negated conditions are taken care of
      * automatically, so one must not account for it in here.
+     *
      * @param performer the performer
      * @return whether the conditions is true for this performer
      */
@@ -72,16 +98,16 @@ public boolean check(P performer) {
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
         var property = SyntaxManager.getExpressionExact(this)
-                .orElseThrow(() -> new SkriptParserException("Unregistered property class: " + getClass().getName()))
-                .getData(PROPERTY_IDENTIFIER, String.class);
+            .orElseThrow(() -> new SkriptParserException("Unregistered property class: " + getClass().getName()))
+            .getData(PROPERTY_IDENTIFIER, String.class);
         return toString(ctx, debug, property);
     }
 
     protected String toString(TriggerContext ctx, boolean debug, String property) {
         var performer = getPerformer();
         var conditionalType = SyntaxManager.getExpressionExact(this)
-                .orElseThrow(() -> new SkriptParserException("Unregistered property class: " + getClass().getName()))
-                .getData(CONDITIONAL_TYPE_IDENTIFIER, ConditionalType.class);
+            .orElseThrow(() -> new SkriptParserException("Unregistered property class: " + getClass().getName()))
+            .getData(CONDITIONAL_TYPE_IDENTIFIER, ConditionalType.class);
         switch (conditionalType) {
             case BE:
                 return performer.toString(ctx, debug) + (performer.isSingle() ? " is " : " are ") + (isNegated() ? "not " : "") + property;
@@ -105,27 +131,4 @@ public Expression<P> getPerformer() {
     public void setPerformer(Expression<P> performer) {
         this.performer = performer;
     }
-
-    public static String[] composePatterns(String performer, ConditionalType conditionalType, String property) {
-        var type = performer.startsWith("*") ? performer.substring(1) : "%" + performer + "%";
-        switch (conditionalType) {
-            case BE:
-                return new String[] {
-                        type + " (is|are) " + property,
-                        type + " (is|are)( not|n't) " + property,
-                };
-            case CAN:
-                return new String[] {
-                        type + " can " + property,
-                        type + " can([ ]not|'t) " + property,
-                };
-            case HAVE:
-                return new String[] {
-                        type + " (has|have) " + property,
-                        type + " does( not|n't) have " + property,
-                };
-            default:
-                throw new AssertionError();
-        }
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyExpression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyExpression.java
index 59f0dbc8..9649c2e0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyExpression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/properties/PropertyExpression.java
@@ -22,26 +22,36 @@
  * to implement them.
  * The class also provides default implementations of {@link #init(Expression[], int, ParseContext)}
  * and {@link #getValues(TriggerContext)}. Their default functionality is specified below.
+ *
  * @param <T> The returned type of this expression.
  * @param <O> The type of the owner of this expression.
  * @author Mwexim
  */
-public abstract class PropertyExpression<O,T> implements Expression<T> {
+public abstract class PropertyExpression<O, T> implements Expression<T> {
     public static final String PROPERTY_IDENTIFIER = "property";
 
     private Expression<O> owner;
     private boolean genitive;
 
+    public static String[] composePatterns(String property, String owner) {
+        var ownerType = owner.startsWith("*") ? owner.substring(1) : "%" + owner + "%";
+        return new String[]{
+            ownerType + "'[s] " + property,
+            "[the] " + property + " of " + ownerType
+        };
+    }
+
     /**
      * This default {@code init()} implementation automatically properly sets the owner of this property,
      * which can be accessed using {@link #getOwner()}. If this implementation is overridden for one reason
      * or another, it must call {@link #setOwner(Expression)} properly.
-     * @param expressions an array of expressions representing all the expressions that are being passed
-     *                    to this syntax element.
+     *
+     * @param expressions    an array of expressions representing all the expressions that are being passed
+     *                       to this syntax element.
      * @param matchedPattern the index of the pattern that was successfully matched. It corresponds to the order of
      *                       the syntaxes in registration
-     * @param parseContext an object containing additional information about the parsing of this syntax element, like
-     *                    regex matches and parse marks
+     * @param parseContext   an object containing additional information about the parsing of this syntax element, like
+     *                       regex matches and parse marks
      * @return whether the initialization was successful or not.
      */
     @SuppressWarnings("unchecked")
@@ -54,18 +64,20 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
 
     /**
      * A simple default method that will apply {@link #getProperty(Object)} on the {@link #owner} of this property.
+     *
      * @param ctx the event
      * @return the values of this property after applying the {@link #getProperty(Object)} function on the owner.
      */
     @SuppressWarnings("unchecked")
     @Override
     public T[] getValues(TriggerContext ctx) {
-        List<T> list = this.owner.stream(ctx).map( this::getProperty).filter(Objects::nonNull).toList();
+        List<T> list = this.owner.stream(ctx).map(this::getProperty).filter(Objects::nonNull).toList();
         return list.toArray((T[]) Array.newInstance(getReturnType(), list.size()));
     }
 
     /**
      * For each owner, this method will be ran individually to convert it to this particular property.
+     *
      * @param owner the owner
      * @return the property value
      */
@@ -82,15 +94,15 @@ public boolean isSingle() {
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
         var property = SyntaxManager.getExpressionExact(this)
-                .orElseThrow(() -> new SkriptParserException("Unregistered property class: " + getClass().getName()))
-                .getData(PROPERTY_IDENTIFIER, String.class);
+            .orElseThrow(() -> new SkriptParserException("Unregistered property class: " + getClass().getName()))
+            .getData(PROPERTY_IDENTIFIER, String.class);
         return toString(ctx, debug, property);
     }
 
     protected String toString(TriggerContext ctx, boolean debug, String property) {
         return genitive
-                ? owner.toString(ctx, debug) + "'s " + property
-                : property + " of " + owner.toString(ctx, debug);
+            ? owner.toString(ctx, debug) + "'s " + property
+            : property + " of " + owner.toString(ctx, debug);
     }
 
     public Expression<O> getOwner() {
@@ -108,17 +120,10 @@ public void setOwner(Expression<O> owner) {
      *     <li><b>regular:</b> book of Mwexim</li>
      * </ul>
      * One may use this method to check if the pattern used is in the genitive form.
+     *
      * @return whether the pattern is in the genitive form or not.
      */
     public boolean isGenitive() {
         return genitive;
     }
-
-    public static String[] composePatterns(String property, String owner) {
-        var ownerType = owner.startsWith("*") ? owner.substring(1) : "%" + owner + "%";
-        return new String[] {
-                ownerType + "'[s] " + property,
-                "[the] " + property + " of " + ownerType
-        };
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java
index b8388057..7c493f97 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java
@@ -131,7 +131,7 @@ public void clearSyntaxRestrictions() {
     public boolean forbidsSyntax(Class<? extends SyntaxElement> c) {
         if (isntAllowingSyntax)
             return true;
-        var allowedSyntaxes = restrictions.getLast().getFirst();
+        var allowedSyntaxes = restrictions.getLast().first();
         return !allowedSyntaxes.isEmpty() && !allowedSyntaxes.contains(c);
     }
 
@@ -139,7 +139,7 @@ public boolean forbidsSyntax(Class<? extends SyntaxElement> c) {
      * @return whether the current syntax restrictions also apply to expressions
      */
     public boolean isRestrictingExpressions() {
-        return restrictions.getLast().getSecond();
+        return restrictions.getLast().second();
     }
 
     /**
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java
index 7f5bd842..881273c1 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java
@@ -86,18 +86,18 @@ public static List<LogEntry> loadScript(Path scriptPath, SkriptLogger logger, bo
                 );
             }
         }
-        unloadedTriggers.sort((a, b) -> b.getTrigger().getEvent().getLoadingPriority() - a.getTrigger().getEvent().getLoadingPriority());
+        unloadedTriggers.sort((a, b) -> b.trigger().getEvent().getLoadingPriority() - a.trigger().getEvent().getLoadingPriority());
 
         for (var unloaded : unloadedTriggers) {
             logger.finalizeLogs();
-            logger.setLine(unloaded.getLine());
-            var loaded = unloaded.getTrigger();
-            loaded.loadSection(unloaded.getSection(), unloaded.getParserState(), logger);
+            logger.setLine(unloaded.line());
+            var loaded = unloaded.trigger();
+            loaded.loadSection(unloaded.section(), unloaded.parserState(), logger);
             //unloaded.getEventInfo().getRegisterer().handleTrigger(scriptName,loaded);
 
-            SkriptEvent event = unloaded.getTrigger().getEvent();
+            SkriptEvent event = unloaded.trigger().getEvent();
 
-            Set<Class<? extends TriggerContext>> contexts = unloaded.getEventInfo().getContexts();
+            Set<Class<? extends TriggerContext>> contexts = unloaded.eventInfo().getContexts();
             if (contexts.isEmpty()) {
                 // A dummy context will be used for this
                 TriggerMap.addTrigger(scriptName, TriggerContext.class, loaded);
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
index 87f79135..160458a0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
@@ -134,9 +134,9 @@ public static <T> Optional<? extends Expression<? extends T>> parseExpression(St
             return literal;
         }
 
-        var variable = (Optional<? extends Variable<? extends T>>) Variables.parseVariable(s, expectedType.getType().getTypeClass(), parserState, logger);
+        var variable = (Optional<? extends Variable<? extends T>>) Variables.parseVariable(s, expectedType.type().getTypeClass(), parserState, logger);
         if (variable.isPresent()) {
-            if (variable.filter(v -> !v.isSingle() && expectedType.isSingle()).isPresent()) {
+            if (variable.filter(v -> !v.isSingle() && expectedType.single()).isPresent()) {
                 logger.error(
                         "A single value was expected, but " +
                                 s +
@@ -162,7 +162,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseExpression(St
                 return booleanOperator;
             }
         }
-        if (!expectedType.isSingle()) {
+        if (!expectedType.single()) {
             var listLiteral = parseListLiteral(s, expectedType, parserState, logger);
             if (listLiteral.isPresent()) {
                 logger.clearErrors();
@@ -229,7 +229,7 @@ public static Optional<? extends Expression<Boolean>> parseBooleanExpression(Str
             }
         }
         for (var info : recentExpressions.mergeWith(SyntaxManager.getAllExpressions())) {
-            if (info.getReturnType().getType().getTypeClass() != Boolean.class)
+            if (info.getReturnType().type().getTypeClass() != Boolean.class)
                 continue;
             var expr = (Optional<? extends Expression<Boolean>>) matchExpressionInfo(s, info, BOOLEAN_PATTERN_TYPE, parserState, logger);
             if (expr.isPresent()) {
@@ -275,8 +275,8 @@ public static Optional<? extends Expression<Boolean>> parseBooleanExpression(Str
     private static <T> Optional<? extends Expression<? extends T>> matchExpressionInfo(String s, ExpressionInfo<?, ?> info, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
         var patterns = info.getPatterns();
         var infoType = info.getReturnType();
-        var infoTypeClass = infoType.getType().getTypeClass();
-        var expectedTypeClass = expectedType.getType().getTypeClass();
+        var infoTypeClass = infoType.type().getTypeClass();
+        var expectedTypeClass = expectedType.type().getTypeClass();
         if (!expectedTypeClass.isAssignableFrom(infoTypeClass) && !Converters.converterExists(infoTypeClass, expectedTypeClass))
             return Optional.empty();
         for (var i = 0; i < patterns.size(); i++) {
@@ -313,7 +313,7 @@ private static <T> Optional<? extends Expression<? extends T>> matchExpressionIn
                         }
                     }
                     if (!expression.isSingle() &&
-                            expectedType.isSingle()) {
+                            expectedType.single()) {
                         logger.error(
                                 "A single value was expected, but '" + s + "' represents multiple values.",
                                 ErrorType.SEMANTIC_ERROR,
@@ -352,7 +352,7 @@ private static <T> Optional<? extends Expression<? extends T>> matchExpressionIn
      * or for another reason detailed in an error message.
      */
     public static <T> Optional<? extends Expression<? extends T>> parseListLiteral(String s, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
-        assert !expectedType.isSingle();
+        assert !expectedType.single();
         if (!s.contains(",") && !s.contains("and") && !s.contains("nor") && !s.contains("or"))
             return Optional.empty();
         List<String> parts = new ArrayList<>();
@@ -458,7 +458,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseListLiteral(S
     public static <T> Optional<? extends Expression<? extends T>> parseLiteral(String s, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
         var classToTypeMap = TypeManager.getClassToTypeMap();
         for (var c : classToTypeMap.keySet()) {
-            Class<? extends T> expectedClass = expectedType.getType().getTypeClass();
+            Class<? extends T> expectedClass = expectedType.type().getTypeClass();
             if (expectedClass.isAssignableFrom(c) || Converters.converterExists(c, expectedClass)) {
                 Optional<? extends Function<String, ?>> literalParser = classToTypeMap.get(c).getLiteralParser();
                 if (literalParser.isPresent()) {
@@ -466,7 +466,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseLiteral(Strin
                     if (literal.isPresent() && expectedClass.isAssignableFrom(c)) {
                         return Optional.of(new SimpleLiteral<>((Class<T>) literal.get().getClass(), literal.get()));
                     } else if (literal.isPresent()) {
-                        return new SimpleLiteral<>((Class<T>) c, literal.get()).convertExpression(expectedType.getType().getTypeClass());
+                        return new SimpleLiteral<>((Class<T>) c, literal.get()).convertExpression(expectedType.type().getTypeClass());
                     }
                 } else if (expectedClass == String.class || c == String.class) {
                     var vs = VariableString.newInstanceWithQuotes(s, parserState, logger)
diff --git a/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java b/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java
index 098f1084..8eaf2613 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java
@@ -230,7 +230,7 @@ private <T> Optional<? extends Expression<? extends T>> parse(String s, PatternT
              */
             expression.ifPresent(e -> {
                 if (e instanceof Variable && types.length > 1) {
-                    var typeClasses = Arrays.stream(types).map(val -> val.getType().getTypeClass()).toArray(Class[]::new);
+                    var typeClasses = Arrays.stream(types).map(val -> val.type().getTypeClass()).toArray(Class[]::new);
                     ((Variable<?>) e).setReturnType(ClassUtils.getCommonSuperclass(typeClasses));
                 }
             });
diff --git a/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java b/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java
index 545c6852..dd6d8504 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java
@@ -240,7 +240,7 @@ private static Optional<? extends PatternElement> parsePattern(String pattern, S
                         patternTypes.add(t.get());
                     }
                     var acceptConditional = m.group(3) != null;
-                    if (acceptConditional && patternTypes.stream().noneMatch(t -> t.getType().getTypeClass() == Boolean.class)) {
+                    if (acceptConditional && patternTypes.stream().noneMatch(t -> t.type().getTypeClass() == Boolean.class)) {
                         logger.error("Can't use the '=' flag on non-boolean types (index " + initialPos + ")", ErrorType.SEMANTIC_ERROR);
                         return Optional.empty();
                     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java b/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java
index 93fe061e..3693e9c3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java
@@ -79,6 +79,7 @@ public Class<? extends Integer> getRelativeType() {
                 public JsonElement serialize(Gson gson, Integer value) {
                     return gson.toJsonTree(value, Integer.class);
                 }
+
                 @Override
                 public Integer deserialize(Gson gson, JsonElement element) {
                     return gson.fromJson(element, Integer.class);
@@ -124,6 +125,7 @@ public Class<? extends Float> getRelativeType() {
                 public JsonElement serialize(Gson gson, Float value) {
                     return gson.toJsonTree(value, Float.class);
                 }
+
                 @Override
                 public Float deserialize(Gson gson, JsonElement element) {
                     return gson.fromJson(element, Float.class);
@@ -170,6 +172,7 @@ public Class<? extends Double> getRelativeType() {
                 public JsonElement serialize(Gson gson, Double value) {
                     return gson.toJsonTree(value, Double.class);
                 }
+
                 @Override
                 public Double deserialize(Gson gson, JsonElement element) {
                     return gson.fromJson(element, Double.class);
@@ -287,7 +290,7 @@ public Boolean deserialize(Gson gson, JsonElement jsonElement) {
             .register();
 
         registration.newType(FunctionParameter.class, "functionparameter", "functionparameter@s")
-            .toStringFunction(parameter -> parameter.getName() + ": " + parameter.getType().getName())
+            .toStringFunction(parameter -> parameter.name() + ": " + parameter.type().getName())
             .noDoc()
             .register();
 
@@ -425,6 +428,7 @@ public JsonElement serialize(Gson gson, Time value) {
                     long nano = value.getTime().toNanoOfDay();
                     return gson.toJsonTree(nano, Long.class);
                 }
+
                 @Override
                 public Time deserialize(Gson gson, JsonElement element) {
                     long asInt = element.getAsLong();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/ExpressionInfo.java b/src/main/java/io/github/syst3ms/skriptparser/registration/ExpressionInfo.java
index 6230b831..bf75ae58 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/ExpressionInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/ExpressionInfo.java
@@ -12,6 +12,7 @@
 
 /**
  * A class containing info about an {@link Expression} syntax
+ *
  * @param <C> the {@link Expression} class
  * @param <T> the return type of the {@link Expression}
  */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/PatternInfos.java b/src/main/java/io/github/syst3ms/skriptparser/registration/PatternInfos.java
index 6644155c..7c1054e8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/PatternInfos.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/PatternInfos.java
@@ -8,6 +8,7 @@
 
 /**
  * An object used to retrieve depending on which pattern was matched
+ *
  * @param <T> the type of the data to be retrieved
  * @see SyntaxElement#init(Expression[], int, ParseContext)
  */
@@ -29,6 +30,7 @@ public PatternInfos(Object[][] infos) {
 
     /**
      * The data corresponding to the pattern index
+     *
      * @param pattern the pattern index
      * @return the corresponding data
      */
@@ -47,6 +49,7 @@ public String[] getPatterns() {
     /**
      * Joins all the possibilities together, forming a {@link ChoiceGroup}
      * with numeric parse marks.
+     *
      * @return a single choice group pattern
      */
     public String toChoiceGroup() {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java
index 564fa652..f47061e2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java
@@ -16,8 +16,17 @@
  */
 public abstract class SkriptAddon {
 
-    private final List<Class<? extends SkriptEvent>> handledEvents = new ArrayList<>();
     private static final Map<String, SkriptAddon> ADDONS = new HashMap<>();
+    private final List<Class<? extends SkriptEvent>> handledEvents = new ArrayList<>();
+    private final String addonName;
+
+    public SkriptAddon(String name) {
+        if (ADDONS.containsKey(name)) {
+            throw new IllegalArgumentException("An addon with the name " + name + " is already registered!");
+        }
+        this.addonName = name;
+        ADDONS.put(name, this);
+    }
 
     /**
      * Returns an unmodifiable list of all SkriptAddons that are registered globally.
@@ -38,16 +47,6 @@ public abstract class SkriptAddon {
         return ADDONS.get(name);
     }
 
-    private final String addonName;
-
-    public SkriptAddon(String name) {
-        if (ADDONS.containsKey(name)) {
-            throw new IllegalArgumentException("An addon with the name " + name + " is already registered!");
-        }
-        this.addonName = name;
-        ADDONS.put(name, this);
-    }
-
     public final String getAddonName() {
         return this.addonName;
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptEventInfo.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptEventInfo.java
index 84bdf73f..526ca7d0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptEventInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptEventInfo.java
@@ -11,6 +11,7 @@
 
 /**
  * A class containing info about an {@link SkriptEvent event} syntax
+ *
  * @param <E> the {@link SkriptEvent} class
  */
 public class SkriptEventInfo<E extends SkriptEvent> extends SyntaxInfo<E> {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
index bf160ef8..49bc9faa 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
@@ -70,6 +70,7 @@
  */
 public class SkriptRegistration {
 
+    protected final List<Type<?>> types = new ArrayList<>();
     private final MultiMap<Class<?>, ExpressionInfo<?, ?>> expressions = new MultiMap<>();
     private final List<SyntaxInfo<? extends CodeSection>> sections = new ArrayList<>();
     private final List<SyntaxInfo<? extends Effect>> effects = new ArrayList<>();
@@ -79,7 +80,6 @@ public class SkriptRegistration {
     private final List<TagInfo<? extends Tag>> tags = new ArrayList<>();
     private final List<SkriptEventInfo<?>> events = new ArrayList<>();
     private final List<StructureInfo<?>> structures = new ArrayList<>();
-    protected final List<Type<?>> types = new ArrayList<>();
     private final SkriptAddon registerer;
     private final SkriptLogger logger;
     protected boolean newTypes;
@@ -104,6 +104,39 @@ public SkriptRegistration(SkriptAddon registerer, SkriptLogger logger) {
         this.logger = logger;
     }
 
+    private static String removePrefix(String str) {
+        return str.startsWith("*") ? str.substring(1) : str;
+    }
+
+    private static int findAppropriatePriority(PatternElement el) {
+        if (el instanceof TextElement) {
+            return 5;
+        } else if (el instanceof RegexGroup) {
+            return 1;
+        } else if (el instanceof ChoiceGroup) {
+            var priority = 5;
+            for (ChoiceElement choice : ((ChoiceGroup) el).getChoices()) {
+                priority = Math.min(priority, findAppropriatePriority(choice.getElement()));
+            }
+            return priority;
+        } else if (el instanceof ExpressionElement) {
+            return 2;
+        } else {
+            assert el instanceof CompoundElement : "a single Optional group as a pattern";
+            var compound = (CompoundElement) el;
+            var elements = compound.getElements();
+            var priority = 5;
+            for (PatternElement element : elements) {
+                var e = element instanceof OptionalGroup ? ((OptionalGroup) element).getElement() : element;
+                priority = Math.min(priority, findAppropriatePriority(e));
+                if (!(element instanceof OptionalGroup || e instanceof TextElement && ((TextElement) e).getText().isBlank()))
+                    break;
+            }
+            var containsRegex = elements.stream().anyMatch(p -> p instanceof RegexGroup);
+            return containsRegex ? Math.min(priority, 3) : priority;
+        }
+    }
+
     /**
      * @return all currently registered expressions
      */
@@ -399,7 +432,6 @@ public <C extends CodeSection> SectionRegistrar<C> newSection(Class<C> c, String
         return new SectionRegistrar<>(c, patterns);
     }
 
-
     /**
      * Registers a {@link CodeSection}
      *
@@ -726,6 +758,26 @@ public List<LogEntry> register(boolean ignoreLogs) {
         }
     }
 
+    public SkriptLogger getLogger() {
+        return this.logger;
+    }
+
+    /**
+     * Add a consumer to be called when this SkriptRegistration finishes registration.
+     *
+     * @param consumer the consumer with the SkriptAddon reference.
+     */
+    public void onFinishRegistration(Consumer<SkriptAddon> consumer) {
+        finishConsumers.add(consumer);
+    }
+
+    private void typeCheck() {
+        if (newTypes) {
+            TypeManager.register(this);
+            newTypes = false;
+        }
+    }
+
     public interface Registrar {
         void register();
     }
@@ -739,6 +791,7 @@ public class TypeRegistrar<C> implements Registrar {
         private final Class<C> c;
         private final String baseName;
         private final String pattern;
+        private final Documentation documentation = new Documentation();
         private Function<? super C, String> toStringFunction = o -> Objects.toString(o, TypeManager.NULL_REPRESENTATION);
         @Nullable
         private Function<? super C, String> toVariableNameFunction;
@@ -752,7 +805,6 @@ public class TypeRegistrar<C> implements Registrar {
         private TypeSerializer<C> serializer;
         @Nullable
         private Supplier<Iterator<C>> supplier;
-        private final Documentation documentation = new Documentation();
 
         public TypeRegistrar(Class<C> c, String baseName, String pattern) {
             this.c = c;
@@ -869,9 +921,9 @@ public void register() {
     public abstract class SyntaxRegistrar<C extends SyntaxElement> implements Registrar {
         protected final Class<C> c;
         protected final List<String> patterns = new ArrayList<>();
-        protected int priority;
         protected final Map<String, Object> data = new HashMap<>();
         protected final Documentation documentation = new Documentation();
+        protected int priority;
 
         SyntaxRegistrar(Class<C> c, String... patterns) {
             this.c = c;
@@ -1017,8 +1069,8 @@ public void register() {
     }
 
     public class EventRegistrar<T extends SkriptEvent> extends SyntaxRegistrar<T> {
-        private Set<Class<? extends TriggerContext>> handledContexts = new HashSet<>();
         private final Documentation documentation = new Documentation();
+        private Set<Class<? extends TriggerContext>> handledContexts = new HashSet<>();
 
         EventRegistrar(Class<T> c, String... patterns) {
             super(c, patterns);
@@ -1092,8 +1144,8 @@ public void register() {
     }
 
     public class StructureRegistrar<T extends Structure> extends SyntaxRegistrar<T> {
-        private Set<Class<? extends TriggerContext>> handledContexts = new HashSet<>();
         private final Documentation documentation = new Documentation();
+        private Set<Class<? extends TriggerContext>> handledContexts = new HashSet<>();
 
         StructureRegistrar(Class<T> c, String... patterns) {
             super(c, patterns);
@@ -1279,57 +1331,4 @@ public void register() {
             }
         }
     }
-
-    public SkriptLogger getLogger() {
-        return this.logger;
-    }
-
-    /**
-     * Add a consumer to be called when this SkriptRegistration finishes registration.
-     *
-     * @param consumer the consumer with the SkriptAddon reference.
-     */
-    public void onFinishRegistration(Consumer<SkriptAddon> consumer) {
-        finishConsumers.add(consumer);
-    }
-
-    private void typeCheck() {
-        if (newTypes) {
-            TypeManager.register(this);
-            newTypes = false;
-        }
-    }
-
-    private static String removePrefix(String str) {
-        return str.startsWith("*") ? str.substring(1) : str;
-    }
-
-    private static int findAppropriatePriority(PatternElement el) {
-        if (el instanceof TextElement) {
-            return 5;
-        } else if (el instanceof RegexGroup) {
-            return 1;
-        } else if (el instanceof ChoiceGroup) {
-            var priority = 5;
-            for (ChoiceElement choice : ((ChoiceGroup) el).getChoices()) {
-                priority = Math.min(priority, findAppropriatePriority(choice.getElement()));
-            }
-            return priority;
-        } else if (el instanceof ExpressionElement) {
-            return 2;
-        } else {
-            assert el instanceof CompoundElement : "a single Optional group as a pattern";
-            var compound = (CompoundElement) el;
-            var elements = compound.getElements();
-            var priority = 5;
-            for (PatternElement element : elements) {
-                var e = element instanceof OptionalGroup ? ((OptionalGroup) element).getElement() : element;
-                priority = Math.min(priority, findAppropriatePriority(e));
-                if (!(element instanceof OptionalGroup || e instanceof TextElement && ((TextElement) e).getText().isBlank()))
-                    break;
-            }
-            var containsRegex = elements.stream().anyMatch(p -> p instanceof RegexGroup);
-            return containsRegex ? Math.min(priority, 3) : priority;
-        }
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxInfo.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxInfo.java
index aee42c1b..2557105c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SyntaxInfo.java
@@ -12,15 +12,16 @@
 
 /**
  * A class containing info about a {@link SyntaxElement} that isn't an {@link Expression} or an {@link SkriptEvent}
+ *
  * @param <C> the {@link SyntaxElement} class
  */
 public class SyntaxInfo<C> {
+    protected final Map<String, Object> data;
     private final Class<C> c;
     private final List<PatternElement> patterns;
     private final int priority;
     private final SkriptAddon registerer;
     private final Documentation documentation;
-    protected final Map<String, Object> data;
 
     public SyntaxInfo(SkriptAddon registerer, Class<C> c, int priority, List<PatternElement> patterns, Documentation documentation) {
         this(registerer, c, priority, patterns, documentation, new HashMap<>());
@@ -57,8 +58,9 @@ public Documentation getDocumentation() {
 
     /**
      * Retrieves a data instance by its identifier.
+     *
      * @param identifier the identifier
-     * @param type the expected data type
+     * @param type       the expected data type
      * @return the data instance
      */
     public <T> T getData(String identifier, Class<T> type) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValues.java b/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValues.java
index 3e06feff..95c36da8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValues.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValues.java
@@ -18,6 +18,7 @@ public static void register(SkriptRegistration reg) {
 
     /**
      * Returns an unmodifiable list with all the registered context values.
+     *
      * @return a list with all context values
      */
     public static List<ContextValue<?, ?>> getContextValues() {
@@ -27,13 +28,14 @@ public static void register(SkriptRegistration reg) {
     /**
      * Returns a list with all the registered context values for a given {@link TriggerContext},
      * excluding values that explicitly require it.
+     *
      * @param ctx the context class
      * @return a list with the applicable context values
      */
     public static List<ContextValue<?, ?>> getContextValues(Class<? extends TriggerContext> ctx) {
         return contextValues.stream()
-                .filter(val -> val.getContext().isAssignableFrom(ctx))
-                .filter(val -> !CollectionUtils.contains(val.getExcluded(), val.getContext()))
-                .collect(Collectors.toList());
+            .filter(val -> val.getContext().isAssignableFrom(ctx))
+            .filter(val -> !CollectionUtils.contains(val.getExcluded(), val.getContext()))
+            .collect(Collectors.toList());
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/ContinuousTag.java b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/ContinuousTag.java
index 359a480d..82ca577a 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/ContinuousTag.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/ContinuousTag.java
@@ -6,23 +6,25 @@
  * in front of it.
  * You don't want continuous tags to combine with each other, because this behavior will be repeated.
  * That's why continuous tags combine with all tags except with other continuous tags.
+ *
  * @author Mwexim
  * @see Tag
  */
 public interface ContinuousTag extends Tag {
-	@Override
-	default String getValue(String affected) {
-		return getValue() + affected;
-	}
+    @Override
+    default String getValue(String affected) {
+        return getValue() + affected;
+    }
 
-	/**
-	 * Returns the String that needs to be put in front of the affected String.
-	 * @return the applied string
-	 */
-	String getValue();
+    /**
+     * Returns the String that needs to be put in front of the affected String.
+     *
+     * @return the applied string
+     */
+    String getValue();
 
-	@Override
-	default boolean combinesWith(Class<? extends Tag> tag) {
-		return !ContinuousTag.class.isAssignableFrom(tag);
-	}
+    @Override
+    default boolean combinesWith(Class<? extends Tag> tag) {
+        return !ContinuousTag.class.isAssignableFrom(tag);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/Tag.java b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/Tag.java
index 30a9f151..2b151dce 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/Tag.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/Tag.java
@@ -10,53 +10,58 @@
  *     <li>{@code &r}: short tags, no parameters</li>
  * </ul>
  * Note that you can use a backslash ('\') to escape characters inside tags.
+ *
+ * @author Mwexim
  * @see io.github.syst3ms.skriptparser.tags.TagReset TagReset
  * @see io.github.syst3ms.skriptparser.tags.TagCase TagCase
- * @author Mwexim
  */
 public interface Tag {
 
-	/**
-	 * Initialises this Tag before being used. This method is always called before all the others in
-	 * an extending class.
-	 * @param key the key that was matched. Note that this can be a single character used in a short tag
-	 *            (like {@code &r}).
-	 * @param parameters an array of strings representing all the parameters that are being passed
-	 *                   to this syntax element. Elements of this array can't be {@code null} or {@link String#isEmpty() empty}.
-	 * @return {@code true} if the tag was initialized successfully, {@code false} otherwise.
-	 * A good practice is to check for the array length of the parameters to not interfere with other addons.
-	 */
-	boolean init(String key, String[] parameters);
+    /**
+     * Initialises this Tag before being used. This method is always called before all the others in
+     * an extending class.
+     *
+     * @param key        the key that was matched. Note that this can be a single character used in a short tag
+     *                   (like {@code &r}).
+     * @param parameters an array of strings representing all the parameters that are being passed
+     *                   to this syntax element. Elements of this array can't be {@code null} or {@link String#isEmpty() empty}.
+     * @return {@code true} if the tag was initialized successfully, {@code false} otherwise.
+     * A good practice is to check for the array length of the parameters to not interfere with other addons.
+     */
+    boolean init(String key, String[] parameters);
 
-	/**
-	 * Returns a string applied by this tag.
-	 * @param affected the string this tags affects.
-	 * @return the applied string
-	 */
-	String getValue(String affected);
+    /**
+     * Returns a string applied by this tag.
+     *
+     * @param affected the string this tags affects.
+     * @return the applied string
+     */
+    String getValue(String affected);
 
-	String toString(boolean debug);
+    String toString(boolean debug);
 
-	/**
-	 * Check if this tag is usable in a certain tag context. The default context is 'default'.
-	 * @param tagCtx the tag context
-	 * @return whether or not this tag is usable in this context, default true for every context
-	 */
-	default boolean isUsable(String tagCtx) {
-		return true;
-	}
+    /**
+     * Check if this tag is usable in a certain tag context. The default context is 'default'.
+     *
+     * @param tagCtx the tag context
+     * @return whether or not this tag is usable in this context, default true for every context
+     */
+    default boolean isUsable(String tagCtx) {
+        return true;
+    }
 
-	/**
-	 * Some tags can stack on top of each other. A perfect example would be Markdown,
-	 * where one can make a text both bold and italics at the same time.
-	 * If this tag can complement such tag, you should define it here.
-	 *
-	 * Most of the times, you want a two-way connection,
-	 * for example: bold combines with italics and vice-versa.
-	 * @param tag the tag
-	 * @return whether or not this tag can complement the given tag
-	 */
-	default boolean combinesWith(Class<? extends Tag> tag) {
-		return false;
-	}
+    /**
+     * Some tags can stack on top of each other. A perfect example would be Markdown,
+     * where one can make a text both bold and italics at the same time.
+     * If this tag can complement such tag, you should define it here.
+     * <p>
+     * Most of the times, you want a two-way connection,
+     * for example: bold combines with italics and vice-versa.
+     *
+     * @param tag the tag
+     * @return whether or not this tag can complement the given tag
+     */
+    default boolean combinesWith(Class<? extends Tag> tag) {
+        return false;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagInfo.java b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagInfo.java
index 3eda948e..25f3f0b2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagInfo.java
@@ -2,23 +2,24 @@
 
 /**
  * A class containing info about a {@link Tag}.
+ *
  * @param <C> the {@link Tag} class
  * @author Mwexim
  */
 public class TagInfo<C extends Tag> {
-	private final Class<C> c;
-	private final int priority;
+    private final Class<C> c;
+    private final int priority;
 
-	public TagInfo(Class<C> c, int priority) {
-		this.c = c;
-		this.priority = priority;
-	}
+    public TagInfo(Class<C> c, int priority) {
+        this.c = c;
+        this.priority = priority;
+    }
 
-	public Class<C> getSyntaxClass() {
-		return c;
-	}
+    public Class<C> getSyntaxClass() {
+        return c;
+    }
 
-	public int getPriority() {
-		return priority;
-	}
+    public int getPriority() {
+        return priority;
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagManager.java b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagManager.java
index 9e9c4932..79a8178d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagManager.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/tags/TagManager.java
@@ -40,14 +40,15 @@ public static List<TagInfo<?>> getTags() {
     /**
      * Parse a string as a {@link Tag}.
      * Note that this does not support angle brackets ('<>') or ampersands ('&').
+     *
      * @param toParse the string to parse
-     * @param logger the logger
+     * @param logger  the logger
      * @return the parsed tag, empty if no tag was found
      */
     public static Optional<Tag> parseTag(String toParse, SkriptLogger logger) {
         if (toParse.isEmpty()
-                || Character.isWhitespace(toParse.charAt(0))
-                || Character.isWhitespace(toParse.charAt(toParse.length() - 1)))
+            || Character.isWhitespace(toParse.charAt(0))
+            || Character.isWhitespace(toParse.charAt(toParse.length() - 1)))
             return Optional.empty();
 
         for (var recentTag : recentTags) {
@@ -81,21 +82,22 @@ private static Optional<Tag> matchTagInfo(String toCheck, TagInfo<?> info, Skrip
         assert values.length == 1 || values.length == 2;
         String key = values[0];
         String[] parameters = values.length == 2
-                // Basically splits at ',' but takes backslashes into account.
-                ? values[1].split("(?<!\\\\)(?:\\\\\\\\)*,")
-                : new String[0];
+            // Basically splits at ',' but takes backslashes into account.
+            ? values[1].split("(?<!\\\\)(?:\\\\\\\\)*,")
+            : new String[0];
         for (String s : parameters) {
             if (s.isEmpty())
                 return Optional.empty();
         }
         try {
             var tag = info.getSyntaxClass()
-                    .getDeclaredConstructor()
-                    .newInstance();
+                .getDeclaredConstructor()
+                .newInstance();
             logger.setContext(ErrorContext.INITIALIZATION);
             if (tag.init(key, parameters))
                 return Optional.of(tag);
-        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
+        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException |
+                 InvocationTargetException e) {
             logger.error("Couldn't instantiate class " + info.getSyntaxClass(), ErrorType.EXCEPTION);
         }
         return Optional.empty();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecAsync.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecAsync.java
index 45b8a471..eab819af 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecAsync.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecAsync.java
@@ -19,11 +19,11 @@
  * Only the code that is inside the section will be executed from another thread.
  * This may cause some delay. If you don't know what this is, you probably don't need it.
  *
+ * @author Mwexim
  * @name Async
  * @type SECTION
  * @pattern async[hronous[ly]]
  * @since ALPHA
- * @author Mwexim
  */
 public class SecAsync extends CodeSection {
     static {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecCase.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecCase.java
index bbb0e6d4..5a0d652c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecCase.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecCase.java
@@ -20,13 +20,13 @@
  * The default part can be used to provide actions when no match was found.
  * Note that you can only use one default statement.
  *
+ * @author Mwexim
  * @name Case
  * @type SECTION
- * @pattern (case|when) %*objects%
- * @pattern ([by] default|otherwise)
- * @since ALPHA
- * @author Mwexim
+ * @pattern (case | when) %*objects%
+ * @pattern ([by] default | otherwise)
  * @see SecSwitch
+ * @since ALPHA
  */
 @SuppressWarnings("unchecked")
 public class SecCase extends CodeSection {
@@ -67,24 +67,24 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             matchWith = (Expression<Object>) expressions[0];
             if (!matchWith.isSingle() && matchWith.isAndList()) {
                 logger.error(
-                        "Only 'or'-lists may be used, found '" + matchWith.toString(TriggerContext.DUMMY, logger.isDebug()),
-                        ErrorType.SEMANTIC_ERROR
+                    "Only 'or'-lists may be used, found '" + matchWith.toString(TriggerContext.DUMMY, logger.isDebug()),
+                    ErrorType.SEMANTIC_ERROR
                 );
                 return false;
             } else if (switchSection.getDefault().isPresent()) {
                 logger.error(
-                        "A 'case'-section cannot be placed behind a 'default'-statement.",
-                        ErrorType.SEMANTIC_ERROR,
-                        "Place this statement before the 'default'-statement to provide the same behavior."
+                    "A 'case'-section cannot be placed behind a 'default'-statement.",
+                    ErrorType.SEMANTIC_ERROR,
+                    "Place this statement before the 'default'-statement to provide the same behavior."
                 );
                 return false;
             }
             switchSection.getCases().add(this);
         } else if (switchSection.getDefault().isPresent()) {
             logger.error(
-                    "Only one 'default'-statement may be used inside a 'switch'-section",
-                    ErrorType.SEMANTIC_ERROR,
-                    "Merge this section with the other 'default'-section to provide the same behavior."
+                "Only one 'default'-statement may be used inside a 'switch'-section",
+                ErrorType.SEMANTIC_ERROR,
+                "Merge this section with the other 'default'-section to provide the same behavior."
             );
             return false;
         } else {
@@ -97,16 +97,16 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     public Optional<? extends Statement> walk(TriggerContext ctx) {
         if (isMatching) {
             return switchSection.getMatch().getSingle(ctx)
-                    .filter(toMatch -> matchWith.check(
-                            ctx,
-                            with -> Comparators.compare(toMatch, with).is(Relation.EQUAL)
-                    ))
-                    .flatMap(__ -> {
-                        switchSection.setDone(true);
-                        return getFirst();
-                    })
-                    .map(val -> (Statement) val)
-                    .or(() -> Optional.of(switchSection));
+                .filter(toMatch -> matchWith.check(
+                    ctx,
+                    with -> Comparators.compare(toMatch, with).is(Relation.EQUAL)
+                ))
+                .flatMap(__ -> {
+                    switchSection.setDone(true);
+                    return getFirst();
+                })
+                .map(val -> (Statement) val)
+                .or(() -> Optional.of(switchSection));
         } else {
             return getFirst();
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecConditional.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecConditional.java
index 4562f971..558f0cad 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecConditional.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecConditional.java
@@ -19,13 +19,13 @@
  * run, like other 'else if' and 'else' sections. If there is no such clause, it will
  * execute the next statement instead.
  *
+ * @author Mwexim, Syst3ms
  * @name Conditional
  * @type SECTION
  * @pattern if %=boolean%
  * @pattern else if %=boolean%
  * @pattern else
  * @since ALPHA
- * @author Mwexim, Syst3ms
  */
 public class SecConditional extends CodeSection {
     static {
@@ -61,8 +61,8 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         }
 
         parseContext.getLogger().error(
-                "An '" + mode + "' must be placed after an 'if' or an 'else if'",
-                ErrorType.SEMANTIC_ERROR
+            "An '" + mode + "' must be placed after an 'if' or an 'else if'",
+            ErrorType.SEMANTIC_ERROR
         );
         return false;
     }
@@ -104,12 +104,12 @@ public boolean checkFinishing(Predicate<? super Statement> finishingTest,
             return super.checkFinishing(finishingTest, logger, currentSectionLine, warnUnreachable);
         } else if (fallingClause != null) {
             return super.checkFinishing(finishingTest, logger, currentSectionLine, warnUnreachable)
-                    && fallingClause.checkFinishing(
-                            finishingTest,
-                            logger,
-                            currentSectionLine + items.size() + 1,
-                            warnUnreachable
-                    );
+                && fallingClause.checkFinishing(
+                finishingTest,
+                logger,
+                currentSectionLine + items.size() + 1,
+                warnUnreachable
+            );
         } else {
             return false;
         }
@@ -118,6 +118,7 @@ public boolean checkFinishing(Predicate<? super Statement> finishingTest,
     /**
      * Sets the Conditional object this Conditional falls back to when it's condition verifies to
      * false. Setting this to an "if" Conditional may cause unexpected/confusing behaviour.
+     *
      * @param conditional the conditional section
      */
     public void setFallingClause(SecConditional conditional) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java
index e446d7e9..c299b8ab 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java
@@ -26,11 +26,11 @@
  * or not by the returned boolean.
  * Note that the filtered expression will be changed, hence why it can't be a literal list.
  *
+ * @author Mwexim
  * @name Filter
  * @type SECTION
  * @pattern filter %~objects%
  * @since ALPHA
- * @author Mwexim
  */
 public class SecFilter extends ReturnSection<Boolean> implements SelfReferencing {
     static {
@@ -44,25 +44,24 @@ public class SecFilter extends ReturnSection<Boolean> implements SelfReferencing
             .register();
     }
 
+    private final List<Object> result = new ArrayList<>();
     private Expression<?> filtered;
-
     @Nullable
     private Statement actualNext;
     @Nullable
     private Iterator<?> iterator;
-    private final List<Object> result = new ArrayList<>();
 
     @Override
     public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
         filtered = expressions[0];
         var logger = parseContext.getLogger();
         if (!filtered.acceptsChange(ChangeMode.SET, filtered.getReturnType(), false)
-                || filtered.acceptsChange(ChangeMode.DELETE).isEmpty()) {
+            || filtered.acceptsChange(ChangeMode.DELETE).isEmpty()) {
             logger.error(
-                    "The expression '" +
-                            filtered.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                            "' cannot be changed",
-                    ErrorType.SEMANTIC_ERROR
+                "The expression '" +
+                    filtered.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                    "' cannot be changed",
+                ErrorType.SEMANTIC_ERROR
             );
             return false;
         }
@@ -82,13 +81,13 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
         boolean isVariable = filtered instanceof Variable<?>;
         if (iterator == null)
             iterator = isVariable
-                    ? ((Variable<?>) filtered).variablesIterator(ctx)
-                    : filtered.iterator(ctx);
+                ? ((Variable<?>) filtered).variablesIterator(ctx)
+                : filtered.iterator(ctx);
 
         if (iterator.hasNext()) {
             setArguments(isVariable
-                    ? ((Pair<String, Object>) iterator.next()).getSecond()
-                    : iterator.next()
+                ? ((Pair<String, Object>) iterator.next()).second()
+                : iterator.next()
             );
             return start();
         } else {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java
index 9650f459..b767008d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java
@@ -30,48 +30,47 @@
  * will all be concatenated into one list and will replace the given expression.
  * Note that the mapped expression will be changed, hence why it can't be a literal list.
  *
+ * @author Mwexim
  * @name Flat Map
  * @type SECTION
  * @pattern flat map %~objects%|map %~objects% flat
  * @since ALPHA
- * @author Mwexim
  */
 public class SecFlatMap extends ReturnSection<Object> implements SelfReferencing {
     static {
         Parser.getMainRegistration().newSection(
                 SecFlatMap.class,
                 "flat map %~objects%|map %~objects% flat")
-			.name("Flat Map")
-			.description("Maps the returned value(s) to the values of a given expression, one by one.") // TODO BETTER DOCS
-			.since("1.0.0");
+            .name("Flat Map")
+            .description("Maps the returned value(s) to the values of a given expression, one by one.") // TODO BETTER DOCS
+            .since("1.0.0");
     }
 
+    private final List<Object> result = new ArrayList<>();
     private Expression<?> flatMapped;
+    @Nullable
+    private Statement actualNext;
+    @Nullable
+    private Iterator<?> iterator;
 
-	@Nullable
-	private Statement actualNext;
-	@Nullable
-	private Iterator<?> iterator;
-	private final List<Object> result = new ArrayList<>();
-
-	@Override
-	public boolean loadSection(FileSection section, ParserState parserState, SkriptLogger logger) {
-		var currentLine = logger.getLine();
-		super.setNext(this);
-		return super.loadSection(section, parserState, logger) && checkReturns(logger, currentLine, true);
-	}
+    @Override
+    public boolean loadSection(FileSection section, ParserState parserState, SkriptLogger logger) {
+        var currentLine = logger.getLine();
+        super.setNext(this);
+        return super.loadSection(section, parserState, logger) && checkReturns(logger, currentLine, true);
+    }
 
     @Override
     public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
         flatMapped = expressions[0];
         var logger = parseContext.getLogger();
         if (!flatMapped.acceptsChange(ChangeMode.SET, flatMapped.getReturnType(), false)
-				|| flatMapped.acceptsChange(ChangeMode.DELETE).isEmpty()) {
+            || flatMapped.acceptsChange(ChangeMode.DELETE).isEmpty()) {
             logger.error(
-                    "The expression '" +
-                            flatMapped.toString(TriggerContext.DUMMY, logger.isDebug()) +
-                            "' cannot be changed",
-                    ErrorType.SEMANTIC_ERROR
+                "The expression '" +
+                    flatMapped.toString(TriggerContext.DUMMY, logger.isDebug()) +
+                    "' cannot be changed",
+                ErrorType.SEMANTIC_ERROR
             );
             return false;
         }
@@ -79,45 +78,45 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
     }
 
     @SuppressWarnings("unchecked")
-	@Override
+    @Override
     public Optional<? extends Statement> walk(TriggerContext ctx) {
-		boolean isVariable = flatMapped instanceof Variable<?>;
-		if (iterator == null)
-			iterator = isVariable
-					? ((Variable<?>) flatMapped).variablesIterator(ctx)
-					: flatMapped.iterator(ctx);
-
-		if (iterator.hasNext()) {
-			setArguments(isVariable
-					? ((Pair<String, Object>) iterator.next()).getSecond()
-					: iterator.next()
-			);
-			return start();
-		} else {
-			if (result.size() == 0) {
-				flatMapped.change(ctx, ChangeMode.DELETE, new Object[0]);
-			} else {
-				flatMapped.change(ctx, ChangeMode.SET, result.toArray());
-			}
-			finish();
-			return Optional.ofNullable(actualNext);
-		}
+        boolean isVariable = flatMapped instanceof Variable<?>;
+        if (iterator == null)
+            iterator = isVariable
+                ? ((Variable<?>) flatMapped).variablesIterator(ctx)
+                : flatMapped.iterator(ctx);
+
+        if (iterator.hasNext()) {
+            setArguments(isVariable
+                ? ((Pair<String, Object>) iterator.next()).second()
+                : iterator.next()
+            );
+            return start();
+        } else {
+            if (result.size() == 0) {
+                flatMapped.change(ctx, ChangeMode.DELETE, new Object[0]);
+            } else {
+                flatMapped.change(ctx, ChangeMode.SET, result.toArray());
+            }
+            finish();
+            return Optional.ofNullable(actualNext);
+        }
     }
 
-	@Override
-	public void step(Statement item) {
-		assert getArguments().length == 1;
-		if (getReturned().isPresent()) {
-			result.addAll(Arrays.asList(getReturned().get())); // We add the filtered argument to the result
-		}
-	}
+    @Override
+    public void step(Statement item) {
+        assert getArguments().length == 1;
+        if (getReturned().isPresent()) {
+            result.addAll(Arrays.asList(getReturned().get())); // We add the filtered argument to the result
+        }
+    }
 
-	@Override
-	public void finish() {
-		// Cache clearing
-		iterator = null;
-		result.clear();
-	}
+    @Override
+    public void finish() {
+        // Cache clearing
+        iterator = null;
+        result.clear();
+    }
 
     @Override
     public Class<?> getReturnType() {
@@ -129,18 +128,18 @@ public boolean isSingle() {
         return false;
     }
 
-	@Override
-	public Statement setNext(@Nullable Statement next) {
-		actualNext = next;
-		return this;
-	}
+    @Override
+    public Statement setNext(@Nullable Statement next) {
+        actualNext = next;
+        return this;
+    }
 
-	@Override
-	public Optional<Statement> getActualNext() {
-		return Optional.ofNullable(actualNext);
-	}
+    @Override
+    public Optional<Statement> getActualNext() {
+        return Optional.ofNullable(actualNext);
+    }
 
-	@Override
+    @Override
     public String toString(TriggerContext ctx, boolean debug) {
         return "flat map " + flatMapped.toString(ctx, debug);
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecLoop.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecLoop.java
index ea4200dc..4cbc1e16 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecLoop.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecLoop.java
@@ -59,6 +59,24 @@ public class SecLoop extends ArgumentSection implements Continuable, SelfReferen
     @Nullable
     private Iterator<?> iterator;
 
+    /**
+     * Returns a SimpleLiteral containing the numbers 1 up until a certain amount, specified
+     * by the given expression.
+     *
+     * @param ctx  the context
+     * @param size the expression
+     * @return the SimpleLiteral
+     */
+    private static Expression<Integer> rangeOf(TriggerContext ctx, Expression<Integer> size) {
+        Integer[] range = (Integer[]) size.getSingle(ctx)
+            .filter(t -> t > 0)
+            .map(t -> Ranges.getRange(Integer.class).orElseThrow()
+                .function()
+                .apply(1, t)) // Upper bound is inclusive
+            .orElse(new Integer[0]);
+        return new SimpleLiteral<>(Integer.class, range);
+    }
+
     @Override
     public boolean loadSection(FileSection section, ParserState parserState, SkriptLogger logger) {
         if (!super.loadSection(section, parserState, logger))
@@ -161,22 +179,4 @@ public Expression<?> getLoopedExpression() {
         }
         return expression;
     }
-
-    /**
-     * Returns a SimpleLiteral containing the numbers 1 up until a certain amount, specified
-     * by the given expression.
-     *
-     * @param ctx  the context
-     * @param size the expression
-     * @return the SimpleLiteral
-     */
-    private static Expression<Integer> rangeOf(TriggerContext ctx, Expression<Integer> size) {
-        Integer[] range = (Integer[]) size.getSingle(ctx)
-            .filter(t -> t > 0)
-            .map(t -> Ranges.getRange(Integer.class).orElseThrow()
-                .getFunction()
-                .apply(1, t)) // Upper bound is inclusive
-            .orElse(new Integer[0]);
-        return new SimpleLiteral<>(Integer.class, range);
-    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java
index 0631504f..f98b14a7 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java
@@ -47,13 +47,12 @@ public class SecMap extends ReturnSection<Object> implements SelfReferencing {
             .register();
     }
 
+    private final List<Object> result = new ArrayList<>();
     private Expression<?> mapped;
-
     @Nullable
     private Statement actualNext;
     @Nullable
     private Iterator<?> iterator;
-    private final List<Object> result = new ArrayList<>();
 
     @Override
     public boolean loadSection(FileSection section, ParserState parserState, SkriptLogger logger) {
@@ -90,7 +89,7 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
 
         if (iterator.hasNext()) {
             setArguments(isVariable
-                ? ((Pair<String, Object>) iterator.next()).getSecond()
+                ? ((Pair<String, Object>) iterator.next()).second()
                 : iterator.next()
             );
             return start();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java
index 5bb1d9f3..7f787c36 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java
@@ -46,12 +46,12 @@
  * </pre>
  * Note that the default part is only executed if no match was found.
  *
+ * @author Mwexim
  * @name Switch
  * @type SECTION
- * @pattern (switch|given|match) %object%
- * @since ALPHA
- * @author Mwexim
+ * @pattern (switch | given | match) %object%
  * @see SecCase
+ * @since ALPHA
  */
 @SuppressWarnings("unchecked")
 public class SecSwitch extends CodeSection implements Finishing {
@@ -72,8 +72,8 @@ public class SecSwitch extends CodeSection implements Finishing {
             .register();
     }
 
-    private Expression<Object> matched;
     private final List<SecCase> cases = new ArrayList<>();
+    private Expression<Object> matched;
     @Nullable
     private Iterator<SecCase> iterator;
     @Nullable
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecWhile.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecWhile.java
index 504797ba..552ef7a4 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecWhile.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecWhile.java
@@ -19,11 +19,11 @@
  * This section will keep executing the statements inside until the given condition
  * does not hold anymore.
  *
+ * @author Mwexim
  * @name While
  * @type SECTION
  * @pattern while %=boolean%
  * @since ALPHA
- * @author Mwexim
  */
 public class SecWhile extends CodeSection implements Continuable, SelfReferencing {
     static {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java
index efe20d3b..761e6ca3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java
@@ -7,7 +7,7 @@ public class DefaultFunctions {
 
     static {
         SkriptRegistration reg = Parser.getMainRegistration();
-        Functions.newJavaFunction(reg,new JavaFunction<>(
+        Functions.newJavaFunction(reg, new JavaFunction<>(
                 "mod",
                 new FunctionParameter[]{new FunctionParameter<>("i", Number.class, true), new FunctionParameter<>("m", Number.class, true)},
                 Number.class,
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
index bc44ac4b..3e7be300 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
@@ -37,7 +37,7 @@ protected void execute(TriggerContext ctx) {
         Object[][] params = new Object[paramsExprs.length][];
         for (int i = 0; i < paramsExprs.length; i++) {
             params[i] = paramsExprs[i].getValues(ctx);
-            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].getType());
+            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].type());
             if (converted.isEmpty()) {
                 params[i] = new Object[0];
             } else {
@@ -62,7 +62,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         String exprString = result.group(2);
         PatternType<?> objectType = TypeManager.getPatternType("objects").get();
         Optional<? extends Expression<?>> optionalExpression =
-                SyntaxParser.parseExpression(exprString, objectType, parseContext.getParserState(), logger);
+            SyntaxParser.parseExpression(exprString, objectType, parseContext.getParserState(), logger);
         if (optionalExpression.isPresent()) {
             parsedExpr = optionalExpression.get();
             if (functionParameters.length == 0) {
@@ -71,36 +71,36 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             }
             if (parsedExpr instanceof ExpressionList<?> expressionList) {
                 paramsExprs = expressionList.getExpressions();
-                if (!(functionParameters.length == 1 && !functionParameters[0].isSingle())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
+                if (!(functionParameters.length == 1 && !functionParameters[0].single())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
                     if (paramsExprs.length != functionParameters.length) {
                         logger.error("This function requires " + functionParameters.length + " parameters, but "
-                                             + paramsExprs.length + " were given.", ErrorType.SEMANTIC_ERROR);
+                            + paramsExprs.length + " were given.", ErrorType.SEMANTIC_ERROR);
                         return false;
                     }
                     for (int i = 0; i < functionParameters.length; i++) {
                         FunctionParameter<?> functionParameter = functionParameters[i];
                         Expression<?> providedParamExpr = paramsExprs[i];
-                        if (functionParameter.isSingle() && !providedParamExpr.isSingle()) {
-                            logger.error("The '" + functionParameter.getName() + "' parameter accepts a single " +
-                                                 "value, but was given more.", ErrorType.SEMANTIC_ERROR);
+                        if (functionParameter.single() && !providedParamExpr.isSingle()) {
+                            logger.error("The '" + functionParameter.name() + "' parameter accepts a single " +
+                                "value, but was given more.", ErrorType.SEMANTIC_ERROR);
                             return false;
                         }
                         // if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())) { // no converter check
-                        if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())
-                                    && !Converters.converterExists(functionParameter.getType(), providedParamExpr.getReturnType())) {
-                            String typeText = TypeManager.getByClass(functionParameter.getType()).get().withIndefiniteArticle(false);
-                            logger.error("The type of the provided value for the '" + functionParameter.getName()
-                                                 + "' parameter is not " + typeText + "/couldn't be converted to "
-                                                 + typeText, ErrorType.SEMANTIC_ERROR);
+                        if (!functionParameter.type().isAssignableFrom(providedParamExpr.getReturnType())
+                            && !Converters.converterExists(functionParameter.type(), providedParamExpr.getReturnType())) {
+                            String typeText = TypeManager.getByClass(functionParameter.type()).get().withIndefiniteArticle(false);
+                            logger.error("The type of the provided value for the '" + functionParameter.name()
+                                + "' parameter is not " + typeText + "/couldn't be converted to "
+                                + typeText, ErrorType.SEMANTIC_ERROR);
                             return false;
                         }
                     }
                 } else {
                     FunctionParameter<?> functionParameter = functionParameters[0];
-                    Class<?> paramType = functionParameter.getType();
+                    Class<?> paramType = functionParameter.type();
                     if (!paramType.isAssignableFrom(this.parsedExpr.getReturnType())) {
                         String typeText = TypeManager.getByClass(paramType).get().withIndefiniteArticle(false);
-                        logger.error("The type of the provided value for the '" + functionParameter.getName()
+                        logger.error("The type of the provided value for the '" + functionParameter.name()
                             + "' parameter is not " + typeText + "/couldn't be converted to "
                             + typeText, ErrorType.SEMANTIC_ERROR);
                         return false;
@@ -109,18 +109,17 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                 }
             } else {
                 FunctionParameter<?> functionParameter = functionParameters[0];
-                Class<?> paramType = functionParameter.getType();
+                Class<?> paramType = functionParameter.type();
                 if (!paramType.isAssignableFrom(this.parsedExpr.getReturnType())) {
                     String typeText = TypeManager.getByClass(paramType).get().withIndefiniteArticle(false);
-                    logger.error("The type of the provided value for the '" + functionParameter.getName()
+                    logger.error("The type of the provided value for the '" + functionParameter.name()
                         + "' parameter is not " + typeText + "/couldn't be converted to "
                         + typeText, ErrorType.SEMANTIC_ERROR);
                     return false;
                 }
                 paramsExprs = new Expression<?>[]{parsedExpr}; //
             }
-        }
-        else if (functionParameters.length > 0) {
+        } else if (functionParameters.length > 0) {
             logger.error("The function has more than 1 parameter, but none were provided.", ErrorType.SEMANTIC_ERROR);
             return false;
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
index 72bf073c..856cc130 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
@@ -38,7 +38,7 @@ public Object[] getValues(TriggerContext ctx) {
         Object[][] params = new Object[paramsExprs.length][];
         for (int i = 0; i < paramsExprs.length; i++) {
             params[i] = paramsExprs[i].getValues(ctx);
-            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].getType());
+            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].type());
             if (converted.isEmpty()) {
                 params[i] = new Object[0];
             } else {
@@ -64,7 +64,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
         String exprString = result.group(2);
         PatternType<?> objectType = TypeManager.getPatternType("objects").get();
         Optional<? extends Expression<?>> optionalExpression =
-                SyntaxParser.parseExpression(exprString, objectType, parseContext.getParserState(), logger);
+            SyntaxParser.parseExpression(exprString, objectType, parseContext.getParserState(), logger);
         if (optionalExpression.isPresent()) {
             parsedExpr = optionalExpression.get();
             if (functionParameters.length == 0) {
@@ -73,27 +73,27 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             }
             if (parsedExpr instanceof ExpressionList<?> expressionList) {
                 paramsExprs = expressionList.getExpressions();
-                if (!(functionParameters.length == 1 && !functionParameters[0].isSingle())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
+                if (!(functionParameters.length == 1 && !functionParameters[0].single())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
                     if (paramsExprs.length != functionParameters.length) {
                         logger.error("This function requires " + functionParameters.length + " parameters, but "
-                                             + paramsExprs.length + " were given.", ErrorType.SEMANTIC_ERROR);
+                            + paramsExprs.length + " were given.", ErrorType.SEMANTIC_ERROR);
                         return false;
                     }
                     for (int i = 0; i < functionParameters.length; i++) {
                         FunctionParameter<?> functionParameter = functionParameters[i];
                         Expression<?> providedParamExpr = paramsExprs[i];
-                        if (functionParameter.isSingle() && !providedParamExpr.isSingle()) {
-                            logger.error("The '" + functionParameter.getName() + "' parameter accepts a single " +
-                                                 "value, but was given more.", ErrorType.SEMANTIC_ERROR);
+                        if (functionParameter.single() && !providedParamExpr.isSingle()) {
+                            logger.error("The '" + functionParameter.name() + "' parameter accepts a single " +
+                                "value, but was given more.", ErrorType.SEMANTIC_ERROR);
                             return false;
                         }
                         // if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())) { // no converter check
-                        if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())
-                                    && !Converters.converterExists(functionParameter.getType(), providedParamExpr.getReturnType())) {
-                            String typeText = TypeManager.getByClass(functionParameter.getType()).get().withIndefiniteArticle(false);
-                            logger.error("The type of the provided value for the '" + functionParameter.getName()
-                                                 + "' parameter is not " + typeText + "/couldn't be converted to "
-                                                 + typeText, ErrorType.SEMANTIC_ERROR);
+                        if (!functionParameter.type().isAssignableFrom(providedParamExpr.getReturnType())
+                            && !Converters.converterExists(functionParameter.type(), providedParamExpr.getReturnType())) {
+                            String typeText = TypeManager.getByClass(functionParameter.type()).get().withIndefiniteArticle(false);
+                            logger.error("The type of the provided value for the '" + functionParameter.name()
+                                + "' parameter is not " + typeText + "/couldn't be converted to "
+                                + typeText, ErrorType.SEMANTIC_ERROR);
                             return false;
                         }
                     }
@@ -103,8 +103,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             } else {
                 paramsExprs = new Expression<?>[]{parsedExpr}; // required for function calling otherwise it can break
             }
-        }
-        else if (functionParameters.length > 0) {
+        } else if (functionParameters.length > 0) {
             logger.error("The function has more than 1 parameter, but none were provided.", ErrorType.SEMANTIC_ERROR);
             return false;
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Function.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Function.java
index 5dded660..91527c67 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Function.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Function.java
@@ -7,10 +7,8 @@
 
 public abstract sealed class Function<T> permits ScriptFunction, JavaFunction {
 
-    private final String name;
-
     protected final FunctionParameter<?>[] parameters;
-
+    private final String name;
     private final Class<? extends T> returnType;
 
     private final boolean returnSingle;
@@ -55,11 +53,11 @@ public void setReturnValue(Object[] returnValue) {
     @Override
     public String toString() {
         return "Function{" +
-                "name='" + name + '\'' +
-                ", parameters=" + Arrays.toString(parameters) +
-                ", returnType=" + returnType +
-                ", returnSingle=" + returnSingle +
-                '}';
+            "name='" + name + '\'' +
+            ", parameters=" + Arrays.toString(parameters) +
+            ", returnType=" + returnType +
+            ", returnSingle=" + returnSingle +
+            '}';
     }
 
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionContext.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionContext.java
index 27402fe3..fdd2b15f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionContext.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionContext.java
@@ -2,17 +2,7 @@
 
 import io.github.syst3ms.skriptparser.lang.TriggerContext;
 
-public class FunctionContext implements TriggerContext {
-
-    private final Function<?> owningFunction;
-
-    public FunctionContext(Function<?> owningFunction) {
-        this.owningFunction = owningFunction;
-    }
-
-    public Function<?> getOwningFunction() {
-        return owningFunction;
-    }
+public record FunctionContext(Function<?> owningFunction) implements TriggerContext {
 
     @Override
     public String getName() {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java
index 20041fab..439558fe 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java
@@ -1,42 +1,18 @@
 package io.github.syst3ms.skriptparser.structures.functions;
 
-public class FunctionParameter<T> {
-
-    private final String name;
-
-    private final Class<? extends T> type;
-
-    private final boolean single;
+public record FunctionParameter<T>(String name, Class<? extends T> type, boolean single) {
 
     public FunctionParameter(String name, Class<? extends T> type) {
         this(name, type, true);
     }
 
-    public FunctionParameter(String name, Class<? extends T> type, boolean single) {
-        this.name = name;
-        this.type = type;
-        this.single = single;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public Class<? extends T> getType() {
-        return type;
-    }
-
-    public boolean isSingle() {
-        return single;
-    }
-
     @Override
     public String toString() {
         return "FunctionParameter{" +
-                "name='" + name + '\'' +
-                ", type=" + type +
-                ", single=" + single +
-                '}';
+            "name='" + name + '\'' +
+            ", type=" + type +
+            ", single=" + single +
+            '}';
     }
 
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java
index 27ac344e..32ebc519 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java
@@ -16,13 +16,12 @@
 
 public class Functions {
 
+    static final String FUNCTION_NAME_REGEX = "^[a-zA-Z0-9_]*";
+    static final String FUNCTION_CALL_PATTERN = "<(" + Functions.FUNCTION_NAME_REGEX + ")\\((.*)\\)>";
     private static final Map<String, List<Function<?>>> functionsMap = new HashMap<>();
     private static final Map<SkriptAddon, List<Function<?>>> FUNCTIONS_BY_ADDON = new HashMap<>();
-
     private static final String JAVA_FUNCTION_NAME = "java_functions_dont_change";
-    static final String FUNCTION_NAME_REGEX = "^[a-zA-Z0-9_]*";
     private static final Pattern FUNCTION_NAME_PATTERN = Pattern.compile(FUNCTION_NAME_REGEX);
-    static final String FUNCTION_CALL_PATTERN = "<(" + Functions.FUNCTION_NAME_REGEX + ")\\((.*)\\)>";
 
     private Functions() {
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
index 9a054af4..b3675ad9 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
@@ -27,11 +27,11 @@ public T[] execute(Object[][] params, TriggerContext ctx) {
             FunctionParameter<?> p = parameters[i];
             Object[] val = params[i];
             //System.out.println(val.getClass());
-            if (p.isSingle() && val.length > 0) {
-                Variables.setVariable(p.getName(), val[0], functionContext, true);
+            if (p.single() && val.length > 0) {
+                Variables.setVariable(p.name(), val[0], functionContext, true);
             } else {
                 for (int j = 0; j < val.length; j++) {
-                    Variables.setVariable(p.getName() + "::" + (j + 1), val[j], functionContext, true);
+                    Variables.setVariable(p.name() + "::" + (j + 1), val[j], functionContext, true);
                 }
             }
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
index 85767da1..06ef0f76 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
@@ -55,7 +55,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             for (FunctionParameter<?> parameter : parameters) {
                 for (FunctionParameter<?> p : parameters) {
                     if (p == parameter) continue;
-                    if (parameter.getName().equals(p.getName())) {
+                    if (parameter.name().equals(p.name())) {
                         logger.error("Functions parameters cannot have the same name.", ErrorType.SEMANTIC_ERROR);
                         return false;
                     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/tags/TagCase.java b/src/main/java/io/github/syst3ms/skriptparser/tags/TagCase.java
index de661d43..1f6bea02 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/tags/TagCase.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/tags/TagCase.java
@@ -5,35 +5,37 @@
 
 /**
  * Applies lowercase or uppercase to the affected string.
+ *
+ * @author Mwexim
  * @name Case Tag
  * @type TAG
  * @pattern case=lower|upper
  * @since ALPHA
- * @author Mwexim
  */
 public class TagCase implements Tag {
 
-	static {
-		Parser.getMainRegistration().addTag(TagCase.class);
-	}
+    static {
+        Parser.getMainRegistration().addTag(TagCase.class);
+    }
+
+    String param;
 
-	String param;
-	public boolean init(String key, String[] parameters) {
-		if (key.equalsIgnoreCase("case")
-				&& parameters.length == 1) {
-			param = parameters[0];
-			return true;
-		}
-		return false;
-	}
+    public boolean init(String key, String[] parameters) {
+        if (key.equalsIgnoreCase("case")
+            && parameters.length == 1) {
+            param = parameters[0];
+            return true;
+        }
+        return false;
+    }
 
-	public String getValue(String affected) {
-		return param.equalsIgnoreCase("upper") ? affected.toUpperCase()
-				: param.equalsIgnoreCase("lower") ? affected.toLowerCase()
-				: affected;
-	}
+    public String getValue(String affected) {
+        return param.equalsIgnoreCase("upper") ? affected.toUpperCase()
+            : param.equalsIgnoreCase("lower") ? affected.toLowerCase()
+            : affected;
+    }
 
-	public String toString(boolean debug) {
-		return "<case=" + param + ">";
-	}
+    public String toString(boolean debug) {
+        return "<case=" + param + ">";
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/tags/TagReset.java b/src/main/java/io/github/syst3ms/skriptparser/tags/TagReset.java
index 31154fe1..d9a526ef 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/tags/TagReset.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/tags/TagReset.java
@@ -5,29 +5,30 @@
 
 /**
  * A tag that resets all currently ongoing tags.
+ *
+ * @author Mwexim
  * @name Reset Tag
  * @type TAG
  * @pattern reset, r
  * @since ALPHA
- * @author Mwexim
  */
 public class TagReset implements Tag {
 
-	static {
-		Parser.getMainRegistration().addTag(TagReset.class, 3);
-	}
+    static {
+        Parser.getMainRegistration().addTag(TagReset.class, 3);
+    }
 
-	public boolean init(String key, String[] parameters) {
-		return key.equalsIgnoreCase("reset")
-				|| key.equalsIgnoreCase("r")
-				&& parameters.length == 0;
-	}
+    public boolean init(String key, String[] parameters) {
+        return key.equalsIgnoreCase("reset")
+            || key.equalsIgnoreCase("r")
+            && parameters.length == 0;
+    }
 
-	public String getValue(String affected) {
-		return affected;
-	}
+    public String getValue(String affected) {
+        return affected;
+    }
 
-	public String toString(boolean debug) {
-		return "<reset>";
-	}
+    public String toString(boolean debug) {
+        return "<reset>";
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/tags/TagSpecialCharacters.java b/src/main/java/io/github/syst3ms/skriptparser/tags/TagSpecialCharacters.java
index dc5a15e4..532e84a4 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/tags/TagSpecialCharacters.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/tags/TagSpecialCharacters.java
@@ -5,56 +5,57 @@
 
 /**
  * Adds special characters to the string.
+ *
+ * @author Mwexim
  * @name Case Tag
  * @type TAG
  * @pattern br[eak]|tab
  * @since ALPHA
- * @author Mwexim
  */
 public class TagSpecialCharacters implements ContinuousTag {
-	static {
-		Parser.getMainRegistration().addTag(TagSpecialCharacters.class);
-	}
+    static {
+        Parser.getMainRegistration().addTag(TagSpecialCharacters.class);
+    }
 
-	private int type;
+    private int type;
 
-	public boolean init(String key, String[] parameters) {
-		if (parameters.length != 0)
-			return false;
+    public boolean init(String key, String[] parameters) {
+        if (parameters.length != 0)
+            return false;
 
-		switch (key) {
-			case "break":
-			case "br":
-				type = 0;
-				return true;
-			case "tab":
-				type = 1;
-				return true;
-			default:
-				return false;
-		}
-	}
+        switch (key) {
+            case "break":
+            case "br":
+                type = 0;
+                return true;
+            case "tab":
+                type = 1;
+                return true;
+            default:
+                return false;
+        }
+    }
 
-	@Override
-	public String getValue() {
-		switch (type) {
-			case 0:
-				return System.lineSeparator();
-			case 1:
-				return "\t";
-			default:
-				throw new IllegalStateException();
-		}
-	}
+    @Override
+    public String getValue() {
+        switch (type) {
+            case 0:
+                return System.lineSeparator();
+            case 1:
+                return "\t";
+            default:
+                throw new IllegalStateException();
+        }
+    }
 
-	public String toString(boolean debug) {
-		switch (type) {
-			case 0:
-				return "<break>";
-			case 1:
-				return "<tab>";
-			default:
-				throw new IllegalStateException();
-		}
-	}
+    public String toString(boolean debug) {
+        switch (type) {
+            case 0:
+                return "<break>";
+            case 1:
+                return "<tab>";
+            default:
+                throw new IllegalStateException();
+        }
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java b/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java
index 64416fb4..0f3a0924 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java
@@ -4,31 +4,15 @@
  * A type used in a pattern.
  * Groups a {@link Type} and a number (single or plural) together (in contrast to {@link Type})
  */
-public class PatternType<T> {
-    private final Type<T> type;
-    private final boolean single;
-
-    public PatternType(Type<T> type, boolean single) {
-        this.type = type;
-        this.single = single;
-    }
-
-    public Type<T> getType() {
-        return type;
-    }
-
-    public boolean isSingle() {
-        return single;
-    }
+public record PatternType<T>(Type<T> type, boolean single) {
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
-        if (!(obj instanceof PatternType)) {
+        if (!(obj instanceof PatternType<?> o)) {
             return false;
         } else {
-            var o = (PatternType<?>) obj;
             return type.equals(o.type) && single == o.single;
         }
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/Type.java b/src/main/java/io/github/syst3ms/skriptparser/types/Type.java
index 2c924e5c..877e8ee7 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/Type.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/Type.java
@@ -231,10 +231,9 @@ public String toString() {
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
-        if (!(obj instanceof Type)) {
+        if (!(obj instanceof Type<?> o)) {
             return false;
         } else {
-            var o = (Type<?>) obj;
             return typeClass.equals(o.typeClass) && baseName.equals(o.baseName) &&
                 Arrays.equals(pluralForms, o.pluralForms);
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/TypeManager.java b/src/main/java/io/github/syst3ms/skriptparser/types/TypeManager.java
index be59712e..756cd62b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/TypeManager.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/TypeManager.java
@@ -15,15 +15,10 @@
 @SuppressWarnings("unchecked")
 public class TypeManager {
 
-    public static enum StringMode {
-        STRING, VARIABLE
-    }
-
     /**
      * The string equivalent of null
      */
     public static final String NULL_REPRESENTATION = "<none>";
-
     /**
      * The string equivalent of an empty array
      */
@@ -151,4 +146,8 @@ public static void register(SkriptRegistration reg) {
         }
     }
 
+    public enum StringMode {
+        STRING, VARIABLE
+    }
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java b/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java
index df14d1cd..1032b1b7 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java
@@ -2,6 +2,7 @@
 
 /**
  * An interface describing arithmetic operations between two types
+ *
  * @param <A> the first type
  * @param <R> the second type
  */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/changers/Changer.java b/src/main/java/io/github/syst3ms/skriptparser/types/changers/Changer.java
index 966e1226..fd0917e3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/changers/Changer.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/changers/Changer.java
@@ -5,6 +5,7 @@
 
 /**
  * An interface for anything that can be changed
+ *
  * @param <T> the type of the thing to change
  * @see Expression#change(TriggerContext, ChangeMode, Object[])
  * @see Expression#acceptsChange(ChangeMode)
@@ -18,9 +19,10 @@ public interface Changer<T> {
 
     /**
      * Changes the implementing object
-     * @param toChange the current values
+     *
+     * @param toChange   the current values
      * @param changeWith the values to change with
-     * @param mode the change mode
+     * @param mode       the change mode
      */
     void change(T[] toChange, Object[] changeWith, ChangeMode mode);
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/changers/TypeSerializer.java b/src/main/java/io/github/syst3ms/skriptparser/types/changers/TypeSerializer.java
index 947954fc..02dbc77a 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/changers/TypeSerializer.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/changers/TypeSerializer.java
@@ -11,8 +11,8 @@ public interface TypeSerializer<T> {
     /**
      * Serialize a value to a GSON json element.
      * The Gson object is preserved from the VariableStorage.
-     * 
-     * @param gson Gson context.
+     *
+     * @param gson  Gson context.
      * @param value the value to serialize
      * @return the classes of the objects that the implementing object can be changed to
      */
@@ -21,8 +21,8 @@ public interface TypeSerializer<T> {
     /**
      * Deserialize a GSON json element to object.
      * The Gson object is preserved from the VariableStorage.
-     * 
-     * @param gson Gson context.
+     *
+     * @param gson    Gson context.
      * @param element the GSON json element.
      */
     T deserialize(Gson gson, JsonElement element);
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java
index e639a297..1db6147f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java
@@ -4,6 +4,7 @@
 
 /**
  * An interface for comparing values of two given types
+ *
  * @param <T1> the first type
  * @param <T2> the second value
  * @see Comparators
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java
index b849d08f..eee2cb0d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java
@@ -2,33 +2,13 @@
 
 /**
  * A class containing information about a {@link Comparator}
+ *
  * @param <T1> the first type
  * @param <T2> the second type
  */
-public class ComparatorInfo<T1, T2> {
-    private final Class<T1> firstClass;
-    private final Class<T2> secondClass;
-    private final Comparator<T1, T2> comparator;
-
-    public ComparatorInfo(Class<T1> firstClass, Class<T2> secondClass, Comparator<T1, T2> comparator) {
-        this.firstClass = firstClass;
-        this.secondClass = secondClass;
-        this.comparator = comparator;
-    }
+public record ComparatorInfo<T1, T2>(Class<T1> firstClass, Class<T2> secondClass, Comparator<T1, T2> comparator) {
 
     public Class<?> getType(boolean first) {
-        return first ? getFirstClass() : getSecondClass();
-    }
-
-    public Class<T1> getFirstClass() {
-        return firstClass;
-    }
-
-    public Class<T2> getSecondClass() {
-        return secondClass;
-    }
-
-    public Comparator<T1, T2> getComparator() {
-        return comparator;
+        return first ? firstClass() : secondClass();
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java
index 6181ec0e..ca509702 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java
@@ -27,12 +27,14 @@ public Relation apply(@Nullable Object o, @Nullable Object o2) {
     };
 
     private static final Collection<ComparatorInfo<?, ?>> comparators = new ArrayList<>();
+    private final static Map<Pair<Class<?>, Class<?>>, Comparator<?, ?>> comparatorsQuickAccess = new HashMap<>();
 
     /**
      * Registers a {@link Comparator}.
+     *
      * @param t1 class of first type
      * @param t2 class of second type
-     * @param c the comparator
+     * @param c  the comparator
      * @throws IllegalArgumentException if any given class is equal to <code>Object.class</code>
      */
     public static <T1, T2> void registerComparator(Class<T1> t1, Class<T2> t2, Comparator<T1, T2> c) {
@@ -46,12 +48,10 @@ public static <F, S> Relation compare(@Nullable F o1, @Nullable S o2) {
         if (o1 == null || o2 == null)
             return Relation.NOT_EQUAL;
         return getComparator((Class<F>) o1.getClass(), (Class<S>) o2.getClass())
-                .map(comp -> comp.apply(o1, o2))
-                .orElse(Relation.NOT_EQUAL);
+            .map(comp -> comp.apply(o1, o2))
+            .orElse(Relation.NOT_EQUAL);
     }
 
-    private final static Map<Pair<Class<?>, Class<?>>, Comparator<?, ?>> comparatorsQuickAccess = new HashMap<>();
-
     @SuppressWarnings("unchecked")
     public static <F, S> Optional<? extends Comparator<? super F, ? super S>> getComparator(Class<F> f, Class<S> s) {
         var p = new Pair<Class<?>, Class<?>>(f, s);
@@ -66,10 +66,10 @@ public static <F, S> Relation compare(@Nullable F o1, @Nullable S o2) {
     private static <F, S> Optional<? extends Comparator<? super F, ? super S>> getComparatorInternal(Class<F> f, Class<S> s) {
         // Perfect match
         for (var info : comparators) {
-            if (info.getFirstClass().isAssignableFrom(f) && info.getSecondClass().isAssignableFrom(s)) {
-                return Optional.of((Comparator<? super F, ? super S>) info.getComparator());
-            } else if (info.getFirstClass().isAssignableFrom(s) && info.getSecondClass().isAssignableFrom(f)) {
-                return Optional.of(new InverseComparator<>((Comparator<? super S, ? super F>) info.getComparator()));
+            if (info.firstClass().isAssignableFrom(f) && info.secondClass().isAssignableFrom(s)) {
+                return Optional.of((Comparator<? super F, ? super S>) info.comparator());
+            } else if (info.firstClass().isAssignableFrom(s) && info.secondClass().isAssignableFrom(f)) {
+                return Optional.of(new InverseComparator<>((Comparator<? super S, ? super F>) info.comparator()));
             }
         }
 
@@ -89,8 +89,8 @@ public static <F, S> Relation compare(@Nullable F o1, @Nullable S o2) {
                     c2 = (Optional<? extends Function<? super S, Optional<?>>>) Converters.getConverter(s, info.getType(!first));
                     if (c2.isPresent()) {
                         return Optional.of(first
-                                ? new ConvertedComparator<>(info.getComparator(), c2.get())
-                                : new InverseComparator<>(new ConvertedComparator<>(c2.get(), info.getComparator()))
+                            ? new ConvertedComparator<>(info.comparator(), c2.get())
+                            : new InverseComparator<>(new ConvertedComparator<>(c2.get(), info.comparator()))
                         );
                     }
                 }
@@ -98,8 +98,8 @@ public static <F, S> Relation compare(@Nullable F o1, @Nullable S o2) {
                     c1 = (Optional<? extends Function<? super F, Optional<?>>>) Converters.getConverter(f, info.getType(!first));
                     if (c1.isPresent()) {
                         return Optional.of(!first
-                                ? new ConvertedComparator<>((Comparator<? super F, ?>) c1.get(), (Function<? super S, Optional<?>>) info.getComparator())
-                                : new InverseComparator<>(new ConvertedComparator<>(info.getComparator(), c1.get()))
+                            ? new ConvertedComparator<>((Comparator<? super F, ?>) c1.get(), (Function<? super S, Optional<?>>) info.comparator())
+                            : new InverseComparator<>(new ConvertedComparator<>(info.comparator(), c1.get()))
                         );
                     }
                 }
@@ -113,8 +113,8 @@ public static <F, S> Relation compare(@Nullable F o1, @Nullable S o2) {
                 c2 = (Optional<? extends Function<? super S, Optional<?>>>) Converters.getConverter(s, info.getType(!first));
                 if (c1.isPresent() && c2.isPresent()) {
                     return Optional.of(first
-                            ? new ConvertedComparator<>(c1.get(), info.getComparator(), c2.get())
-                            : new InverseComparator<>(new ConvertedComparator<>(c2.get(), info.getComparator(), c1.get()))
+                        ? new ConvertedComparator<>(c1.get(), info.comparator(), c2.get())
+                        : new InverseComparator<>(new ConvertedComparator<>(c2.get(), info.comparator(), c1.get()))
                     );
                 }
             }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java
index 24f5bb6a..268d8fed 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java
@@ -2,6 +2,7 @@
 
 /**
  * A {@linkplain Comparator} that is the opposite of another one
+ *
  * @param <T1> the first type
  * @param <T2> the second type
  */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java
index 07e47235..0446b95f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java
@@ -8,10 +8,10 @@
 /**
  * Used to chain converters to build a single converter. This is automatically created when a new converter is added.
  *
- * @author Peter Güttinger
  * @param <F> same as Converter's <F> (from)
  * @param <M> the middle type, i.e. the type the first converter converts to and the second converter comverts from.
  * @param <T> same as Converter's <T> (to)
+ * @author Peter Güttinger
  * @see Converters#registerConverter(Class, Class, Function)
  */
 public final class ChainedConverter<F, M, T> implements Function<F, Optional<? extends T>> {
@@ -32,4 +32,4 @@ public Optional<? extends T> apply(@Nullable F f) {
         return first.apply(f).flatMap(second::apply);
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterInfo.java b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterInfo.java
index 81b5c24b..fa12bfdb 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterInfo.java
@@ -5,12 +5,8 @@
 import java.util.Optional;
 import java.util.function.Function;
 
-public final class ConverterInfo<F, T> {
-    private final Class<F> from;
-    private final Class<T> to;
-    private final Function<? super F, Optional<? extends T>> converter;
-    private final int flags;
-
+public record ConverterInfo<F, T>(Class<F> from, Class<T> to, Function<? super F, Optional<? extends T>> converter,
+                                  int flags) {
     public ConverterInfo(Class<F> from, Class<T> to, Function<? super F, Optional<? extends T>> converter) {
         this(from, to, converter, Converters.ALL_CHAINING);
     }
@@ -21,20 +17,4 @@ public ConverterInfo(Class<F> from, Class<T> to, Function<? super F, Optional<?
         this.converter = converter;
         this.flags = flags;
     }
-
-    public Class<F> getFrom() {
-        return from;
-    }
-
-    public Class<T> getTo() {
-        return to;
-    }
-
-    public Function<? super F, Optional<? extends T>> getConverter() {
-        return converter;
-    }
-
-    public int getFlags() {
-        return flags;
-    }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterUtils.java b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterUtils.java
index e75e22f4..e32eebdc 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ConverterUtils.java
@@ -10,32 +10,32 @@
 public class ConverterUtils {
 
     public static <F, T> Function<?, Optional<? extends T>> createInstanceofConverter(ConverterInfo<F, T> conv) {
-        return createInstanceofConverter(conv.getFrom(), conv.getConverter());
+        return createInstanceofConverter(conv.from(), conv.converter());
     }
 
     public static <F, T> Function<?, Optional<? extends T>> createInstanceofConverter(Class<F> from, Function<? super F, Optional<? extends T>> conv) {
         return p -> Optional.ofNullable(p)
-                .filter(from::isInstance)
-                .flatMap(f -> conv.apply((F) f));
+            .filter(from::isInstance)
+            .flatMap(f -> conv.apply((F) f));
     }
 
     public static <F, T> Function<? super F, Optional<? extends T>> createInstanceofConverter(Function<? super F, Optional<? extends T>> conv, Class<T> to) {
         return p -> conv.apply(p)
-                .filter(to::isInstance)
-                .map(to::cast);
+            .filter(to::isInstance)
+            .map(to::cast);
     }
 
     public static <F, T> Function<?, Optional<? extends T>> createDoubleInstanceofConverter(ConverterInfo<F, ?> conv, Class<T> to) {
-        Function<? super F, ?> function = conv.getConverter();
-        return createDoubleInstanceofConverter(conv.getFrom(), (Function<F, Optional<?>>) function, to);
+        Function<? super F, ?> function = conv.converter();
+        return createDoubleInstanceofConverter(conv.from(), (Function<F, Optional<?>>) function, to);
     }
 
     public static <F, T> Function<?, Optional<? extends T>> createDoubleInstanceofConverter(Class<F> from, Function<? super F, Optional<?>> conv, Class<T> to) {
         return p -> Optional.ofNullable(p)
-                .filter(from::isInstance)
-                .flatMap(f -> conv.apply((F) f))
-                .filter(to::isInstance)
-                .map(to::cast);
+            .filter(from::isInstance)
+            .flatMap(f -> conv.apply((F) f))
+            .filter(to::isInstance)
+            .map(to::cast);
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java
index b528868b..35b8dbdb 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java
@@ -36,50 +36,51 @@ public abstract class Converters {
     public static final int NO_CHAINING = NO_LEFT_CHAINING | NO_RIGHT_CHAINING;
 
     private static final List<ConverterInfo<?, ?>> converters = new ArrayList<>(50);
-
+    private final static Map<Pair<Class<?>, Class<?>>, Function<?, ?>> convertersCache = new HashMap<>();
 
     public static List<ConverterInfo<?, ?>> getConverters() {
         return Collections.unmodifiableList(converters);
     }
 
-
     @SuppressWarnings("unchecked")
     public static <F, T> void registerConverters(SkriptRegistration registration) {
         for (var info : registration.getConverters()) {
             var inf = (ConverterInfo<F, T>) info;
             registerConverter(
-                    inf.getFrom(),
-                    inf.getTo(),
-                    inf.getConverter(),
-                    inf.getFlags()
+                inf.from(),
+                inf.to(),
+                inf.converter(),
+                inf.flags()
             );
         }
     }
 
     /**
      * Registers a converter.
-     * @param from the class to convert from
-     * @param to the class to convert to
+     *
+     * @param from      the class to convert from
+     * @param to        the class to convert to
      * @param converter the converter function
      */
     public static <F, T> void registerConverter(Class<F> from, Class<T> to, Function<? super F, Optional<? extends T>> converter) {
         registerConverter(from, to, converter, 0);
     }
 
-	/**
-	 * Registers a converter
-	 * @param from the class to convert from
-	 * @param to the class to convert to
-	 * @param converter the converter function
-	 * @param options the options
-	 */
+    /**
+     * Registers a converter
+     *
+     * @param from      the class to convert from
+     * @param to        the class to convert to
+     * @param converter the converter function
+     * @param options   the options
+     */
     public static <F, T> void registerConverter(Class<F> from, Class<T> to, Function<? super F, Optional<? extends T>> converter, int options) {
         if (converterExistsSlow(from, to))
             return;
         var info = new ConverterInfo<>(from, to, converter, options);
         for (var i = 0; i < converters.size(); i++) {
             var info2 = converters.get(i);
-            if (info2.getFrom().isAssignableFrom(from) && to.isAssignableFrom(info2.getTo())) {
+            if (info2.from().isAssignableFrom(from) && to.isAssignableFrom(info2.to())) {
                 converters.add(i, info);
                 return;
             }
@@ -95,11 +96,11 @@ public static void createMissingConverters() {
             var info = converters.get(i);
             for (var j = 0; j < converters.size(); j++) { // not from j = i+1 since new converters get added during the loops
                 var info2 = converters.get(j);
-                if ((info.getFlags() & NO_RIGHT_CHAINING) == 0 && (info2.getFlags() & NO_LEFT_CHAINING) == 0
-                    && info2.getFrom().isAssignableFrom(info.getTo()) && !converterExistsSlow(info.getFrom(), info2.getTo())) {
+                if ((info.flags() & NO_RIGHT_CHAINING) == 0 && (info2.flags() & NO_LEFT_CHAINING) == 0
+                    && info2.from().isAssignableFrom(info.to()) && !converterExistsSlow(info.from(), info2.to())) {
                     converters.add(createChainedConverter(info, info2));
-                } else if ((info.getFlags() & NO_LEFT_CHAINING) == 0 && (info2.getFlags() & NO_RIGHT_CHAINING) == 0
-                    && info.getFrom().isAssignableFrom(info2.getTo()) && !converterExistsSlow(info2.getFrom(), info.getTo())) {
+                } else if ((info.flags() & NO_LEFT_CHAINING) == 0 && (info2.flags() & NO_RIGHT_CHAINING) == 0
+                    && info.from().isAssignableFrom(info2.to()) && !converterExistsSlow(info2.from(), info.to())) {
                     converters.add(createChainedConverter(info2, info));
                 }
             }
@@ -108,7 +109,7 @@ public static void createMissingConverters() {
 
     private static boolean converterExistsSlow(Class<?> from, Class<?> to) {
         for (var i : converters) {
-            if ((i.getFrom().isAssignableFrom(from) || from.isAssignableFrom(i.getFrom())) && (i.getTo().isAssignableFrom(to) || to.isAssignableFrom(i.getTo()))) {
+            if ((i.from().isAssignableFrom(from) || from.isAssignableFrom(i.from())) && (i.to().isAssignableFrom(to) || to.isAssignableFrom(i.to()))) {
                 return true;
             }
         }
@@ -120,23 +121,24 @@ private static <F, M, T> ConverterInfo<F, T> createChainedConverter(ConverterInf
         var firstInf = (ConverterInfo<F, M>) first;
         var secondInf = (ConverterInfo<M, T>) second;
         return new ConverterInfo<>(
-                firstInf.getFrom(),
-                secondInf.getTo(),
-                ChainedConverter.newInstance(
-                        firstInf.getConverter(),
-                        secondInf.getConverter()
-                ),
-                first.getFlags() | second.getFlags()
+            firstInf.from(),
+            secondInf.to(),
+            ChainedConverter.newInstance(
+                firstInf.converter(),
+                secondInf.converter()
+            ),
+            first.flags() | second.flags()
         );
     }
 
     /**
-	 * Converts the given value to the desired type. If you want to convert multiple values of the same type you should use {@link #getConverter(Class, Class)} to get a
-	 * converter to convert the values.
-	 * @param o the value to convert
-	 * @param to the class to convert to
-	 * @return the converted value or null if no converter exists or the converter returned null for the given value.
-	 */
+     * Converts the given value to the desired type. If you want to convert multiple values of the same type you should use {@link #getConverter(Class, Class)} to get a
+     * converter to convert the values.
+     *
+     * @param o  the value to convert
+     * @param to the class to convert to
+     * @return the converted value or null if no converter exists or the converter returned null for the given value.
+     */
     @SuppressWarnings("unchecked")
     public static <F, T> Optional<? extends T> convert(@Nullable F o, Class<T> to) {
         if (o == null)
@@ -144,16 +146,17 @@ public static <F, T> Optional<? extends T> convert(@Nullable F o, Class<T> to) {
         if (to.isInstance(o))
             return Optional.of((T) o);
         return getConverter((Class<F>) o.getClass(), to)
-                .flatMap(c -> c.apply(o));
+            .flatMap(c -> c.apply(o));
     }
 
     /**
-	 * Converts an object into one of the given types.
-	 * This method does not convert the object if it is already an instance of any of the given classes.
-	 * @param o the value to convert
-	 * @param to the class to convert to
-	 * @return the converted value
-	 */
+     * Converts an object into one of the given types.
+     * This method does not convert the object if it is already an instance of any of the given classes.
+     *
+     * @param o  the value to convert
+     * @param to the class to convert to
+     * @return the converted value
+     */
     @SuppressWarnings("unchecked")
     public static <F, T> Optional<? extends T> convert(@Nullable F o, Class<? extends T>[] to) {
         if (o == null)
@@ -172,12 +175,13 @@ public static <F, T> Optional<? extends T> convert(@Nullable F o, Class<? extend
     }
 
     /**
-	 * Converts all entries in the given array to the desired type, using {@link #convert(Object, Class)} to convert every single value. If you want to convert an array of values
-	 * of a known type, consider using {@link #convert(Object[], Class, Function)} for much better performance.
-	 * @param o the values to convert
-	 * @param to the class to convert to
-	 * @return a T[] array without null elements
-	 */
+     * Converts all entries in the given array to the desired type, using {@link #convert(Object, Class)} to convert every single value. If you want to convert an array of values
+     * of a known type, consider using {@link #convert(Object[], Class, Function)} for much better performance.
+     *
+     * @param o  the values to convert
+     * @param to the class to convert to
+     * @return a T[] array without null elements
+     */
     @SuppressWarnings("unchecked")
     public static <T> Optional<T[]> convertArray(@Nullable Object[] o, Class<T> to) {
         if (o == null)
@@ -192,12 +196,13 @@ public static <T> Optional<T[]> convertArray(@Nullable Object[] o, Class<T> to)
     }
 
     /**
-	 * Converts multiple objects into any of the given classes.
-	 * @param o the values to convert
-	 * @param to the class to convert to
-	 * @param superType The component type of the returned array
-	 * @return the converted array
-	 */
+     * Converts multiple objects into any of the given classes.
+     *
+     * @param o         the values to convert
+     * @param to        the class to convert to
+     * @param superType The component type of the returned array
+     * @return the converted array
+     */
     @SuppressWarnings("unchecked")
     public static <T> T[] convertArray(@Nullable Object[] o, Class<? extends T> to, Class<T> superType) {
         if (o == null)
@@ -211,24 +216,24 @@ public static <T> T[] convertArray(@Nullable Object[] o, Class<? extends T> to,
         return l.toArray((T[]) Array.newInstance(superType, l.size()));
     }
 
-    private final static Map<Pair<Class<?>, Class<?>>, Function<?, ?>> convertersCache = new HashMap<>();
-
     /**
-	 * Tests whether a converter between the given classes exists.
-	 * @param from the class to convert from
-	 * @param to the class to convert to
-	 * @return whether a converter exists
-	 */
+     * Tests whether a converter between the given classes exists.
+     *
+     * @param from the class to convert from
+     * @param to   the class to convert to
+     * @return whether a converter exists
+     */
     public static boolean converterExists(Class<?> from, Class<?> to) {
         return to.isAssignableFrom(from) || from.isAssignableFrom(to) || getConverter(from, to).isPresent();
     }
 
-	/**
-	 * Tests whether a converter between one of the given classes exists
-	 * @param from the class to convert from
-	 * @param to the class to convert to
-	 * @return whether a converter exists
-	 */
+    /**
+     * Tests whether a converter between one of the given classes exists
+     *
+     * @param from the class to convert from
+     * @param to   the class to convert to
+     * @return whether a converter exists
+     */
     public static boolean converterExists(Class<?> from, Class<?>... to) {
         for (var t : to) {
             assert t != null;
@@ -239,11 +244,12 @@ public static boolean converterExists(Class<?> from, Class<?>... to) {
     }
 
     /**
-	 * Gets a converter
-	 * @param from the class to convert from
-	 * @param to the class to convert to
-	 * @return the converter or null if none exist
-	 */
+     * Gets a converter
+     *
+     * @param from the class to convert from
+     * @param to   the class to convert to
+     * @return the converter or null if none exist
+     */
     @SuppressWarnings("unchecked")
     public static <F, T> Optional<? extends Function<? super F, Optional<? extends T>>> getConverter(Class<F> from, Class<T> to) {
         var p = new Pair<Class<?>, Class<?>>(from, to);
@@ -256,23 +262,23 @@ public static <F, T> Optional<? extends Function<? super F, Optional<? extends T
 
     @SuppressWarnings("unchecked")
     private static <F, T> Optional<Function<? super F, Optional<? extends T>>> getConverterInternal(Class<F> from, Class<T> to) {
-    	for (var conv : converters) {
-            if (conv.getFrom().isAssignableFrom(from) && to.isAssignableFrom(conv.getTo())) {
+        for (var conv : converters) {
+            if (conv.from().isAssignableFrom(from) && to.isAssignableFrom(conv.to())) {
                 var inf = (ConverterInfo<F, T>) conv;
-                return Optional.ofNullable(inf.getConverter());
+                return Optional.ofNullable(inf.converter());
             }
         }
         for (var conv : converters) {
-            if (conv.getFrom().isAssignableFrom(from) && conv.getTo().isAssignableFrom(to)) {
+            if (conv.from().isAssignableFrom(from) && conv.to().isAssignableFrom(to)) {
                 var inf = (ConverterInfo<F, T>) conv;
-                return Optional.of(ConverterUtils.createInstanceofConverter(inf.getConverter(), to));
-            } else if (from.isAssignableFrom(conv.getFrom()) && to.isAssignableFrom(conv.getTo())) {
+                return Optional.of(ConverterUtils.createInstanceofConverter(inf.converter(), to));
+            } else if (from.isAssignableFrom(conv.from()) && to.isAssignableFrom(conv.to())) {
                 var inf = (ConverterInfo<F, T>) conv;
                 return Optional.of((Function<? super F, Optional<? extends T>>) ConverterUtils.createInstanceofConverter(inf));
             }
         }
         for (var conv : converters) {
-            if (from.isAssignableFrom(conv.getFrom()) && conv.getTo().isAssignableFrom(to)) {
+            if (from.isAssignableFrom(conv.from()) && conv.to().isAssignableFrom(to)) {
                 return Optional.of((Function<? super F, Optional<? extends T>>) ConverterUtils.createDoubleInstanceofConverter(conv, to));
             }
         }
@@ -282,27 +288,29 @@ private static <F, T> Optional<Function<? super F, Optional<? extends T>>> getCo
     }
 
     /**
-	 * Converts a given array without checking the type.
-	 * @param from the values to convert
-	 * @param to the class to convert to
-	 * @param converter the converter function
-	 * @return the converted values
-	 * @throws ArrayStoreException if the given class is not a superclass of all objects returned by the converter
-	 */
+     * Converts a given array without checking the type.
+     *
+     * @param from      the values to convert
+     * @param to        the class to convert to
+     * @param converter the converter function
+     * @return the converted values
+     * @throws ArrayStoreException if the given class is not a superclass of all objects returned by the converter
+     */
     @SuppressWarnings("unchecked")
     public static <F, T> T[] convertUnsafe(F[] from, Class<?> to, Function<? super F, Optional<? extends T>> converter) {
         return convert(from, (Class<T>) to, converter);
     }
 
-	/**
-	 * Converts a given array.
-	 * @param from the values to convert
-	 * @param to the class to convert to
-	 * @param converter the converter function
-	 * @return the converted values
-	 */
+    /**
+     * Converts a given array.
+     *
+     * @param from      the values to convert
+     * @param to        the class to convert to
+     * @param converter the converter function
+     * @return the converted values
+     */
     public static <F, T> T[] convert(F[] from, Class<T> to, Function<? super F, Optional<? extends T>> converter) {
-        if (from == null) return (T[])Array.newInstance(to, 0);
+        if (from == null) return (T[]) Array.newInstance(to, 0);
         var ts = (T[]) Array.newInstance(to, from.length);
         var j = 0;
         for (var f : from) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/ranges/RangeInfo.java b/src/main/java/io/github/syst3ms/skriptparser/types/ranges/RangeInfo.java
index 7d20c017..7825c457 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/ranges/RangeInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/ranges/RangeInfo.java
@@ -4,29 +4,9 @@
 
 /**
  * Information about a range function
+ *
  * @param <B> the type of the two endpoints
  * @param <T> the type of the range that is returned
  */
-public class RangeInfo<B, T> {
-    private final Class<B> bound;
-    private final Class<T> to;
-    private final BiFunction<? super B, ? super B, T[]> function;
-
-    public RangeInfo(Class<B> bound, Class<T> to, BiFunction<? super B, ? super B, T[]> function) {
-        this.bound = bound;
-        this.to = to;
-        this.function = function;
-    }
-
-    public Class<B> getBound() {
-        return bound;
-    }
-
-    public Class<T> getTo() {
-        return to;
-    }
-
-    public BiFunction<? super B, ? super B, T[]> getFunction() {
-        return function;
-    }
+public record RangeInfo<B, T>(Class<B> bound, Class<T> to, BiFunction<? super B, ? super B, T[]> function) {
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/ranges/Ranges.java b/src/main/java/io/github/syst3ms/skriptparser/types/ranges/Ranges.java
index 8f766f1c..7e5330a6 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/ranges/Ranges.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/ranges/Ranges.java
@@ -13,8 +13,8 @@ public class Ranges {
 
     public static <B, T> void registerRange(Class<B> bound, Class<T> to, BiFunction<? super B, ? super B, T[]> function) {
         rangeMap.put(
-                bound,
-                new RangeInfo<>(bound, to, function)
+            bound,
+            new RangeInfo<>(bound, to, function)
         );
     }
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/ClassUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/ClassUtils.java
index 54dc08fb..b78a949d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/ClassUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/ClassUtils.java
@@ -13,7 +13,7 @@ public static Class<?> getCommonSuperclass(Class<?>... cs) {
     }
 
     /**
-     * @param cs the array of classes
+     * @param cs         the array of classes
      * @param interfaces whether or not to account for interfaces
      * @return the nearest common superclass of the provided classes
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/CollectionUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/CollectionUtils.java
index e0beea91..de16042f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/CollectionUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/CollectionUtils.java
@@ -37,8 +37,9 @@ public static <T> boolean contains(T[] array, T... contained) {
      * Find the index of an item, where a given predicate applies,
      * from a given class in an array, skipping over all these items
      * as long as the amount of items skipped is smaller than a given amount.
-     * @param array the array
-     * @param n the ordinal you want to get the index from
+     *
+     * @param array     the array
+     * @param n         the ordinal you want to get the index from
      * @param condition the condition
      * @return the index, {@code -1} if no index was found
      */
@@ -47,8 +48,6 @@ public static <T> int ordinalConditionalIndexOf(T[] array, int n, Predicate<T> c
         int findTimes = 0;
         if (n == 0)
             return -1;
-        if (array.length == 0)
-            return -1;
         for (T o : array) {
             if (condition.test(o))
                 findTimes++;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java b/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java
index 32b19ec4..d4c4f16f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java
@@ -14,8 +14,9 @@
 
 /**
  * A double-valued version of an {@link Optional}, containing very similar methods.
- *
+ * <p>
  * Note that the two values aren't really independent : either both are set, or both are empty.
+ *
  * @param <T1> the type of the first value
  * @param <T2> the type of the second value
  */
@@ -47,7 +48,7 @@ private DoubleOptional() {
     /**
      * Constructs a non-empty instance.
      *
-     * @param first the first value
+     * @param first  the first value
      * @param second the second value
      * @throws NullPointerException if either parameters are {@literal null}.
      */
@@ -72,10 +73,10 @@ public static <T1, T2> DoubleOptional<T1, T2> empty() {
      * Returns an {@code Optional} describing the given non-{@code null}
      * value.
      *
-     * @param first the first value to describe, which must be non-{@code null}
+     * @param first  the first value to describe, which must be non-{@code null}
      * @param second the second value to describe, which must be non-{@code null}
-     * @param <T1> the type of the first value
-     * @param <T2> the type fo the second value
+     * @param <T1>   the type of the first value
+     * @param <T2>   the type fo the second value
      * @return a {@code DoubleOptional} with the value present
      * @throws NullPointerException if either first or second are {@code null}
      */
@@ -87,12 +88,12 @@ public static <T1, T2> DoubleOptional<T1, T2> of(T1 first, T2 second) {
      * Returns a {@code DoubleOptional} describing the given values, if
      * both non-{@code null}, otherwise returns an empty {@code DoubleOptional}.
      *
-     * @param first the first possibly {@code null} value to describe
+     * @param first  the first possibly {@code null} value to describe
      * @param second the secpond possibly {@code null} value to describe
-     * @param <T1> the type of the first value
-     * @param <T2> the type of the second value
+     * @param <T1>   the type of the first value
+     * @param <T2>   the type of the second value
      * @return a {@code DoubleOptional} with both values present if the specified values
-     *         are both non-{@code null}, otherwise an empty {@code DoubleOptional}
+     * are both non-{@code null}, otherwise an empty {@code DoubleOptional}
      */
     public static <T1, T2> DoubleOptional<T1, T2> ofNullable(@Nullable T1 first, @Nullable T2 second) {
         return first == null || second == null ? empty() : new DoubleOptional<>(first, second);
@@ -102,12 +103,12 @@ public static <T1, T2> DoubleOptional<T1, T2> ofNullable(@Nullable T1 first, @Nu
      * Returns a {@code DoubleOptional} describing the values represented by two {@link Optional}s if both
      * are present, otherwise returns an empty {@code DoubleOptional}.
      *
-     * @param first a possibly empty {@link Optional} describing the first value
+     * @param first  a possibly empty {@link Optional} describing the first value
      * @param second a possibly empty {@link Optional} describing the second value
-     * @param <T1> the type of the first value
-     * @param <T2> the type of the second value
+     * @param <T1>   the type of the first value
+     * @param <T2>   the type of the second value
      * @return a {@code DoubleOptional} describing the two values described by the two {@link Optional}s,
-     *         if both are present, otherwise an empty {@code DoubleOptional}
+     * if both are present, otherwise an empty {@code DoubleOptional}
      */
     @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
     public static <T1, T2> DoubleOptional<T1, T2> ofOptional(Optional<T1> first, Optional<T2> second) {
@@ -172,7 +173,7 @@ public void ifPresent(BiConsumer<? super T1, ? super T2> action) {
     /**
      * If both values are present, does the first action using both values, otherwise does the second action.
      *
-     * @param action the action to be performed if both values are present
+     * @param action      the action to be performed if both values are present
      * @param emptyAction the action to be performed if either values are absent
      */
     public void ifPresentOrElse(BiConsumer<? super T1, ? super T2> action, Runnable emptyAction) {
@@ -189,7 +190,7 @@ public void ifPresentOrElse(BiConsumer<? super T1, ? super T2> action, Runnable
      *
      * @param predicate the predicate to test both values against, if present
      * @return a {@code DoubleOptional} describing these values, if they are present and match the given predicate,
-     *         otherwise an empty {@code DoubleOptional}
+     * otherwise an empty {@code DoubleOptional}
      */
     public DoubleOptional<T1, T2> filter(BiPredicate<? super T1, ? super T2> predicate) {
         if (isEmpty()) {
@@ -203,19 +204,19 @@ public DoubleOptional<T1, T2> filter(BiPredicate<? super T1, ? super T2> predica
      * If both values are present, returns a {@code DoubleOptional} describing the result
      * (as if by {@link #ofNullable(Object, Object)}) of applying each given mapping function
      * to its respective value, and otherwise returns an empty {@code DoubleOptional}.
-     *
+     * <p>
      * If either mapping function returns {@code null}, the result will be an empty {@code DoubleOptional}.
      *
-     * @param firstMapper the mapping function to apply to the first value, if present
+     * @param firstMapper  the mapping function to apply to the first value, if present
      * @param secondMapper the mapping function to apply to the second value, if present
-     * @param <U> the new type of the first value
-     * @param <V> the new type of the second value
+     * @param <U>          the new type of the first value
+     * @param <V>          the new type of the second value
      * @return a {@code DoubleOptional} describing the result of applying mapping functions
-     *         to each of the values if present, and an empty {@code DoubleOptional} otherwise.
+     * to each of the values if present, and an empty {@code DoubleOptional} otherwise.
      */
     public <U, V> DoubleOptional<U, V> map(
-            Function<? super T1, ? extends U> firstMapper,
-            Function<? super T2, ? extends V> secondMapper) {
+        Function<? super T1, ? extends U> firstMapper,
+        Function<? super T2, ? extends V> secondMapper) {
         if (isEmpty()) {
             return empty();
         } else {
@@ -226,13 +227,13 @@ public <U, V> DoubleOptional<U, V> map(
     /**
      * If both values are present, returns an {@link Optional} constructed from the result of the given mapping
      * function applied to both values, otherwise returns an empty {@link Optional}.
-     *
+     * <p>
      * If the mapping function returns {@code null}, an empty {@link Optional} is returned.
      *
      * @param mapper the mapping function taking both values as inputs
-     * @param <U> the type of the resulting {@link Optional}
+     * @param <U>    the type of the resulting {@link Optional}
      * @return an {@link Optional} describing the result of applying the mapping function to both values if present,
-     *         and an empty {@link Optional} otherwise
+     * and an empty {@link Optional} otherwise
      */
     public <U> Optional<U> mapToOptional(BiFunction<? super T1, ? super T2, ? extends U> mapper) {
         if (isEmpty()) {
@@ -245,15 +246,15 @@ public <U> Optional<U> mapToOptional(BiFunction<? super T1, ? super T2, ? extend
     /**
      * If both values are present, returns the result of applying the given {@code DoubleOptional}-returning
      * mapping function to both values, and otherwise returns an empty {@code DoubleOptional}.
-     *
+     * <p>
      * This is similar to {@link #map(Function, Function)}, but it doesn't wrap the result in an additional
      * {@code DoubleOptional}.
      *
      * @param mapper the mapping function taking in both values (if present) and returning a {@code DoubleOptional}
-     * @param <U> the type of the first value of the new {@code DoubleOptional}
-     * @param <V> the type of the second value of the new {@code DoubleOptional}
+     * @param <U>    the type of the first value of the new {@code DoubleOptional}
+     * @param <V>    the type of the second value of the new {@code DoubleOptional}
      * @return the result of applying the mapping function to both values if present, and an empty {@code DoubleOptional}
-     *         otherwise
+     * otherwise
      * @throws NullPointerException if the mapping function returns {@code null}
      */
     @SuppressWarnings("unchecked")
@@ -269,14 +270,14 @@ public <U, V> DoubleOptional<U, V> flatMap(BiFunction<? super T1, ? super T2, Do
     /**
      * If both values are present, returns the result of applying the given {@link Optional}-returning
      * mapping function to both values, and otherwise returns an empty {@link Optional}.
-     *
+     * <p>
      * This is similar to {@link #mapToOptional(BiFunction)}, but it doesn't wrap the result in an additional
      * {@link Optional}.
      *
      * @param mapper the mapping function taking in both values (if present) and returning an {@link Optional}
-     * @param <U> the type of the new {@link Optional}
+     * @param <U>    the type of the new {@link Optional}
      * @return the result of applying the mapping function to both values if present, and an empty {@link Optional}
-     *         otherwise
+     * otherwise
      * @throws NullPointerException if the mapping function returns {@code null}
      */
     @SuppressWarnings("unchecked")
@@ -295,7 +296,7 @@ public <U> Optional<U> flatMapToOptional(BiFunction<? super T1, ? super T2, Opti
      *
      * @param supplier the supplier producing the {@code DoubleOptional} returned if this one is empty
      * @return a {@code DoubleOptional} describing the two values if present, and otherwise the {@code DoubleOptional}
-     *         produced by the given supplier function
+     * produced by the given supplier function
      */
     @SuppressWarnings("unchecked")
     public DoubleOptional<T1, T2> or(Supplier<? extends DoubleOptional<? extends T1, ? extends T2>> supplier) {
@@ -336,7 +337,7 @@ public T2 secondOrElse(@Nullable T2 other) {
      * exception-supplying function.
      *
      * @param exceptionSupplier the function producing the exception to be thrown if the first value is not present
-     * @param <X> the type of exception that may be thrown
+     * @param <X>               the type of exception that may be thrown
      * @return the first value if present
      * @throws X if the first value is not present
      */
@@ -353,7 +354,7 @@ public <X extends Throwable> T1 firstOrElseThrow(Supplier<? extends X> exception
      * exception-supplying function.
      *
      * @param exceptionSupplier the function producing the exception to be thrown if the second value is not present
-     * @param <X> the type of exception that may be thrown
+     * @param <X>               the type of exception that may be thrown
      * @return the second value if present
      * @throws X if the second value is not present
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java
index e9a43d2a..4f679543 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java
@@ -4,12 +4,6 @@
 import java.util.Optional;
 
 public class DurationUtils {
-    /**
-     * The amount of milliseconds it takes for a tick to pass.
-     * A 'tick' is a predetermined time-unit of 50 milliseconds.
-     */
-    public static long TICK = 50;
-
     /*
      * See these arrays as one single array with triplets of information
      * about a certain time unit. Sadly, Java does not allow to create a
@@ -17,6 +11,11 @@ public class DurationUtils {
      */
     private static final String[] unitPatterns = {"years?", "weeks?", "days?", "hours?", "minutes?", "seconds?", "ticks?", "milli(second)?s?"};
     private static final String[] unitNames = {"year", "week", "day", "hour", "minute", "second", "tick", "millisecond"};
+    /**
+     * The amount of milliseconds it takes for a tick to pass.
+     * A 'tick' is a predetermined time-unit of 50 milliseconds.
+     */
+    public static long TICK = 50;
     private static long[] unitMillis = {31_536_000_000L, 604_800_000, 86_400_000, 3_600_000, 60_000, 1000, TICK, 1};
 
     public static void overrideTickLength(long nanoTick) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java
index 7a61e3b7..621791ac 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java
@@ -89,10 +89,10 @@ private static String trimMultilineIndent(String multilineText) {
         var lines = multilineText.split("\0");
         // Inspired from Kotlin's trimIndent() function
         var baseIndent = Arrays.stream(lines)
-                .skip(1) // First line's indent should be ignored
-                .mapToInt(l -> getIndentationLevel(l, true))
-                .min()
-                .orElse(0);
+            .skip(1) // First line's indent should be ignored
+            .mapToInt(l -> getIndentationLevel(l, true))
+            .min()
+            .orElse(0);
         if (baseIndent == 0)
             return multilineText.replace("\0", "");
         var pat = Pattern.compile("\\s");
@@ -154,7 +154,7 @@ public static void loadClasses(File jarFile, String rootPackage, String... subPa
                         }
                     }
                     if (load &&
-                            !path.matches(".+\\$\\d+\\.class")) { // It's of very little use to load anonymous classes
+                        !path.matches(".+\\$\\d+\\.class")) { // It's of very little use to load anonymous classes
                         final var c = path.replace('/', '.').substring(0, path.length() - ".class".length());
                         try {
                             Class.forName(c, true, FileUtils.class.getClassLoader());
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/MultiMap.java b/src/main/java/io/github/syst3ms/skriptparser/util/MultiMap.java
index ea3117e9..7cab4fb2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/MultiMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/MultiMap.java
@@ -15,7 +15,7 @@ public class MultiMap<K, V> extends HashMap<K, List<V>> {
      * Looks for a list that is mapped to the given key. If there is one, then the given value is added to that list.
      * If there isn't, then a new entry is created and has the value added to it.
      *
-     * @param key the key
+     * @param key   the key
      * @param value the value
      */
     public void putOne(@Nullable K key, @Nullable V value) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/NumberUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/NumberUtils.java
index 18ab8c8c..0fdd9e69 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/NumberUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/NumberUtils.java
@@ -5,35 +5,37 @@
  */
 public class NumberUtils {
 
-	/**
-	 * Parse a string as an integer.
-	 * Note that the parsed string is expected to be a parsable integer.
-	 * Therefore it will only take care of overflow situations.
-	 * @param str the string to parse
-	 * @return the parsed integer
-	 */
-	public static int parseInt(String str) {
-		assert str.matches("-?\\d+");
-		try {
-			return Integer.parseInt(str);
-		} catch (final NumberFormatException e) {
-			return str.startsWith("-") ? Integer.MIN_VALUE : Integer.MAX_VALUE;
-		}
-	}
+    /**
+     * Parse a string as an integer.
+     * Note that the parsed string is expected to be a parsable integer.
+     * Therefore it will only take care of overflow situations.
+     *
+     * @param str the string to parse
+     * @return the parsed integer
+     */
+    public static int parseInt(String str) {
+        assert str.matches("-?\\d+");
+        try {
+            return Integer.parseInt(str);
+        } catch (final NumberFormatException e) {
+            return str.startsWith("-") ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+        }
+    }
 
-	/**
-	 * Parse a string as a long.
-	 * Note that the parsed string is expected to be a parsable long.
-	 * Therefore it will only take care of overflow situations.
-	 * @param str the string to parse
-	 * @return the parsed integer
-	 */
-	public static long parseLong(String str) {
-		assert str.matches("-?\\d+");
-		try {
-			return Long.parseLong(str);
-		} catch (final NumberFormatException e) {
-			return str.startsWith("-") ? Long.MIN_VALUE : Long.MAX_VALUE;
-		}
-	}
+    /**
+     * Parse a string as a long.
+     * Note that the parsed string is expected to be a parsable long.
+     * Therefore it will only take care of overflow situations.
+     *
+     * @param str the string to parse
+     * @return the parsed integer
+     */
+    public static long parseLong(String str) {
+        assert str.matches("-?\\d+");
+        try {
+            return Long.parseLong(str);
+        } catch (final NumberFormatException e) {
+            return str.startsWith("-") ? Long.MIN_VALUE : Long.MAX_VALUE;
+        }
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java b/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java
index e8c5cb96..56a5af46 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java
@@ -2,31 +2,29 @@
 
 /**
  * A simple pair of two values.
+ *
  * @param <T> type of the first value
  * @param <U> type of the second value
  */
-public class Pair<T, U> {
-    private final T first;
-    private final U second;
-
-    public Pair(T first, U second) {
-        this.first = first;
-        this.second = second;
-    }
+public record Pair<T, U>(T first, U second) {
 
     /**
      * Retrieves the first element
+     *
      * @return the first element
      */
-    public T getFirst() {
+    @Override
+    public T first() {
         return first;
     }
 
     /**
      * Retrieves the second element
+     *
      * @return the second element
      */
-    public U getSecond() {
+    @Override
+    public U second() {
         return second;
     }
 
@@ -38,6 +36,6 @@ public boolean equals(Object o) {
             return false;
         var pair = (Pair<?, ?>) o;
         return first.equals(pair.first) &&
-                second.equals(pair.second);
+            second.equals(pair.second);
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java b/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java
index 4d785433..b7889696 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java
@@ -14,9 +14,10 @@
 /**
  * A simple list that is only meant to keep track of which syntaxes are used frequently, in order to preemptively check
  * them against a string that's being parsed.
- *
+ * <p>
  * To illustrate the behaviour of this class, imagine you use some syntax A 8 times, then use syntax B once. The very
  * next time the parser does the "recent syntaxes" check, it will check syntax A first, because it was used more than syntax B.
+ *
  * @param <T> the type of {@link SyntaxInfo}
  */
 public class RecentElementList<T> implements Iterable<T> {
@@ -25,7 +26,7 @@ public class RecentElementList<T> implements Iterable<T> {
      * hierarchy, and the "recent syntaxes" check works fine. But if there are many syntaxes in that list, then if one
      * wants to use a syntax one hasn't used before, it would take a lot of time to actually match the pattern against
      * it, since there's all the previously used syntaxes to check beforehand.
-     *
+     * <p>
      * Hence, the maximum number of recent elements is capped.
      */
     // Ideally this would be properly configurable. I'll let it be a constant for now.
@@ -37,11 +38,13 @@ public class RecentElementList<T> implements Iterable<T> {
     private final Map<T, Integer> backing = new HashMap<>();
     private final List<T> occurrences = new ArrayList<>();
 
-    public RecentElementList() {}
+    public RecentElementList() {
+    }
 
     /**
      * Updates a given syntax's position inside of the frequency hierarchy. This is used to acknowledge that a given{@link SyntaxInfo}
      * has been successfully parsed, and should as such be part of the "recent syntaxes" check.
+     *
      * @param element the element to update
      */
     public void acknowledge(T element) {
@@ -62,6 +65,7 @@ public void acknowledge(T element) {
      * Merges the elements of this list and the elements of the other list into a new set.
      * The elements of this list have priority over the other elements. There will be
      * no duplicate elements in the returned collection.
+     *
      * @param other the other list
      * @return a merged set with the elements of both lists
      */
@@ -74,6 +78,7 @@ public List<T> mergeWith(List<T> other) {
 
     /**
      * Removes the elements of this {@link RecentElementList} from another {@link List}, in-place.
+     *
      * @param list the list to remove from
      */
     public void removeFrom(List<T> list) {
@@ -82,6 +87,7 @@ public void removeFrom(List<T> list) {
 
     /**
      * Custom iterator sorted by frequency of use
+     *
      * @return an iterator where syntaxes appear in decreasing order of frequency of use
      */
     @NotNull
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/SkriptDate.java b/src/main/java/io/github/syst3ms/skriptparser/util/SkriptDate.java
index 4ba2a466..0611312e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/SkriptDate.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/SkriptDate.java
@@ -16,7 +16,7 @@ public class SkriptDate implements Comparable<SkriptDate> {
     public final static String DATE_FORMAT = "EEEE dd MMMM yyyy HH:mm:ss.SSS"; // Add 'zzzXXX' to display time zone as well
     public final static Locale DATE_LOCALE = Locale.US;
 
-    private static TimeZone defaultTimeZone = TimeZone.getDefault();
+    private static final TimeZone defaultTimeZone = TimeZone.getDefault();
 
     private long timestamp;
 
@@ -26,6 +26,7 @@ private SkriptDate(long timestamp) {
 
     /**
      * Creates a new {@link SkriptDate} of the current time.
+     *
      * @return the date
      */
     public static SkriptDate now() {
@@ -39,6 +40,7 @@ public static SkriptDate now() {
      * The timestamp is internally stored as a date in the UTC time zone.
      * Use {@linkplain #of(long, TimeZone) this} method if you wish to
      * take a non-default time zone into account.
+     *
      * @param timestamp the timestamp
      * @return the date
      */
@@ -51,8 +53,9 @@ public static SkriptDate of(long timestamp) {
      * Note that timestamps are expressed in milliseconds.
      * The zone offset is taken into account when calculating the
      * final timestamp.
+     *
      * @param timestamp the timestamp
-     * @param zone the time zone
+     * @param zone      the time zone
      * @return the date
      */
     public static SkriptDate of(long timestamp, TimeZone zone) {
@@ -64,15 +67,17 @@ public static SkriptDate of(long timestamp, TimeZone zone) {
      * Note that this takes the {@linkplain #defaultTimeZone default time zone}
      * into account. Use {@linkplain #today(TimeZone) this} method if you want
      * to use a non-default time zone.
+     *
      * @return the date
      */
-	public static SkriptDate today() {
-	    return today(defaultTimeZone);
-	}
+    public static SkriptDate today() {
+        return today(defaultTimeZone);
+    }
 
     /**
      * Creates a new {@link SkriptDate} of the current date at midnight
      * in a specific time zone.
+     *
      * @param zone the zone
      * @return the date
      */
@@ -99,6 +104,7 @@ public long getTimestamp() {
     /**
      * Returns the {@linkplain Duration duration} between the
      * given dates.
+     *
      * @param other the other date
      * @return the duration
      */
@@ -109,6 +115,7 @@ public Duration difference(SkriptDate other) {
     /**
      * Adds a specific {@linkplain Duration duration} to this date.
      * A negative duration will subtract instead.
+     *
      * @param duration the duration
      */
     public void add(Duration duration) {
@@ -118,6 +125,7 @@ public void add(Duration duration) {
     /**
      * Subtracts a specific {@linkplain Duration duration} from this date.
      * A negative duration will add instead.
+     *
      * @param duration the duration
      */
     public void subtract(Duration duration) {
@@ -128,6 +136,7 @@ public void subtract(Duration duration) {
      * Adds a specific {@linkplain Duration duration} to this date
      * and returns the result of this addition.
      * A negative duration will subtract instead.
+     *
      * @param duration the duration
      * @return the date
      */
@@ -139,6 +148,7 @@ public SkriptDate plus(Duration duration) {
      * Subtracts a specific {@linkplain Duration duration} from this date
      * and returns the result of this subtraction.
      * A negative duration will add instead.
+     *
      * @param duration the duration
      * @return the date
      */
@@ -148,6 +158,7 @@ public SkriptDate minus(Duration duration) {
 
     /**
      * Returns this date as a {@link LocalDate}.
+     *
      * @return the {@link LocalDate} of this date
      */
     public LocalDateTime toLocalDateTime() {
@@ -166,6 +177,7 @@ public String toString() {
 
     /**
      * Returns the string representation of this date using a certain format.
+     *
      * @param format the format
      * @return the string representation of this date
      */
@@ -181,4 +193,4 @@ public boolean equals(@Nullable Object obj) {
             return false;
         return compareTo((SkriptDate) obj) == 0;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java
index e8077918..f5cea929 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java
@@ -17,7 +17,8 @@ public class StringUtils {
 
     /**
      * Counts combined occurrences of one or more strings in another
-     * @param s the string to find occurrences in
+     *
+     * @param s      the string to find occurrences in
      * @param toFind the strings to find occurrences of
      * @return the amount of total occurrences
      */
@@ -32,10 +33,11 @@ public static int count(String s, String... toFind) {
 
     /**
      * Find where a given pair of braces closes.
+     *
      * @param pattern the string to look in
      * @param opening the opening brace
      * @param closing the closing brace
-     * @param start where the brace pair starts
+     * @param start   where the brace pair starts
      * @return the index at which the brace pair closes
      */
     public static int findClosingIndex(String pattern, char opening, char closing, int start) {
@@ -58,10 +60,11 @@ public static int findClosingIndex(String pattern, char opening, char closing, i
 
     /**
      * Similar to {@link #findClosingIndex(String, char, char, int)}, but returns the enclosed text
+     *
      * @param pattern the string to look in
      * @param opening the opening brace
      * @param closing the closing brace
-     * @param start where the brace pair starts
+     * @param start   where the brace pair starts
      * @return the enclosed text
      */
     public static Optional<String> getEnclosedText(String pattern, char opening, char closing, int start) {
@@ -75,7 +78,8 @@ public static Optional<String> getEnclosedText(String pattern, char opening, cha
 
     /**
      * Returns the next character in the string, skipping over curly braces and string literals
-     * @param s the string  to search
+     *
+     * @param s     the string  to search
      * @param index the current index
      * @return the index of the next "simple" character, or -1 if the end of the string has been reached
      * @throws StringIndexOutOfBoundsException if {@code index < 0}
@@ -114,7 +118,8 @@ public static int nextSimpleCharacterIndex(String s, int index) {
 
     /**
      * Finds the contents of an expression between %%
-     * @param s the string containing the percents
+     *
+     * @param s     the string containing the percents
      * @param start where the pair begins
      * @return the content between %%
      */
@@ -139,8 +144,9 @@ public static Optional<String> getPercentContent(String s, int start) {
 
     /**
      * Finds the contents until a closing bracket is found
-     * @param s the string containing the percents
-     * @param start where the pair begins
+     *
+     * @param s              the string containing the percents
+     * @param start          where the pair begins
      * @param closingBracket the closing bracket
      * @return the content until the closing bracket
      */
@@ -158,9 +164,10 @@ public static Optional<String> getBracketContent(String s, int start, char closi
 
     /**
      * Find the first occurrence of a string in another one, ignoring case
+     *
      * @param haystack the string to look in
-     * @param needle the string to look for
-     * @param start where to look from
+     * @param needle   the string to look for
+     * @param start    where to look from
      * @return the index of the first occurrence
      */
     public static int indexOfIgnoreCase(String haystack, String needle, int start) {
@@ -197,7 +204,8 @@ public static int indexOfIgnoreCase(String haystack, String needle, int start) {
 
     /**
      * Split a pattern at pipe characters, properly accounting for brackets and escapes
-     * @param s the string to split
+     *
+     * @param s      the string to split
      * @param logger the logger
      * @return the split string
      */
@@ -265,6 +273,7 @@ public static String[] getForms(String pluralizable) {
 
     /**
      * Trims all strings in the array
+     *
      * @param strings the strings
      * @return the array with all of its contents trimmed
      */
@@ -276,7 +285,8 @@ private static String[] stripAll(String[] strings) {
 
     /**
      * Adds a proper English indefinite article to a string
-     * @param noun the string
+     *
+     * @param noun   the string
      * @param plural whether it is plural or not
      * @return the string with its proper indefinite article
      */
@@ -303,6 +313,7 @@ else if (plural)
     /**
      * Capitalizes the first word or all words in a string.
      * A word is separated by a space character.
+     *
      * @param str the string to change
      * @return the capitalized string
      */
@@ -326,10 +337,10 @@ public static String toCamelCase(String str, boolean firstNoCase) {
             if (firstNoCase) {
                 firstNoCase = false;
                 ret.append(Character.toLowerCase(part.charAt(0)))
-                        .append(part.substring(1));
+                    .append(part.substring(1));
             } else {
                 ret.append(Character.toUpperCase(part.charAt(0)))
-                        .append(part.substring(1));
+                    .append(part.substring(1));
             }
         }
         return ret.toString();
@@ -337,7 +348,8 @@ public static String toCamelCase(String str, boolean firstNoCase) {
 
     /**
      * Converts a string into snake case.
-     * @param str the string to convert
+     *
+     * @param str  the string to convert
      * @param mode 0 for default mode, 1 for uppercase and 2 for lowercase
      * @return the converted string
      */
@@ -353,7 +365,8 @@ public static String toSnakeCase(String str, int mode) {
 
     /**
      * Converts a string into kebab case.
-     * @param str the string to convert
+     *
+     * @param str  the string to convert
      * @param mode 0 for default mode, 1 for uppercase and 2 for lowercase
      * @return the converted string
      */
@@ -369,6 +382,7 @@ public static String toKebabCase(String str, int mode) {
 
     /**
      * Replaces all uppercase characters with lower case ones and vice versa.
+     *
      * @param str the string to change
      * @return the reversed string
      */
@@ -388,6 +402,7 @@ else if (Character.isLowerCase(c))
 
     /**
      * Mirrors the string. This means the last character will be put first and vice versa.
+     *
      * @param str the string to change
      * @return the mirrored string
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/ThreadUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/ThreadUtils.java
index b262f396..6a5efb24 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/ThreadUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/ThreadUtils.java
@@ -8,83 +8,91 @@
 
 public class ThreadUtils {
 
-	/**
-	 * Run certain code once on a separate thread. The thread is shut down after the code ran.
-	 * @param code the runnable that needs to be executed
-	 */
-	public static void runAsync(Runnable code) {
-		ExecutorService executor = Executors.newCachedThreadPool();
-		executor.submit(code);
-		executor.shutdown();
-	}
+    /**
+     * Run certain code once on a separate thread. The thread is shut down after the code ran.
+     *
+     * @param code the runnable that needs to be executed
+     */
+    public static void runAsync(Runnable code) {
+        ExecutorService executor = Executors.newCachedThreadPool();
+        executor.submit(code);
+        executor.shutdown();
+    }
 
-	/**
-	 * Run certain code once after a certain delay. The thread is shut down after the code ran.
-	 * @param code the runnable that needs to be executed
-	 * @param duration the delay
-	 */
-	public static void runAfter(Runnable code, Duration duration) {
-		ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
-		executor.schedule(code, duration.toMillis(), TimeUnit.MILLISECONDS);
-		executor.shutdown();
-	}
+    /**
+     * Run certain code once after a certain delay. The thread is shut down after the code ran.
+     *
+     * @param code     the runnable that needs to be executed
+     * @param duration the delay
+     */
+    public static void runAfter(Runnable code, Duration duration) {
+        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+        executor.schedule(code, duration.toMillis(), TimeUnit.MILLISECONDS);
+        executor.shutdown();
+    }
 
-	/**
-	 * Runs certain code periodically.
-	 * @param code the runnable that needs to be executed
-	 * @param duration the delay
-	 */
-	public static void runPeriodically(Runnable code, Duration duration) {
-		runPeriodically(code, duration, duration);
-	}
+    /**
+     * Runs certain code periodically.
+     *
+     * @param code     the runnable that needs to be executed
+     * @param duration the delay
+     */
+    public static void runPeriodically(Runnable code, Duration duration) {
+        runPeriodically(code, duration, duration);
+    }
 
-	/**
-	 * Runs certain code periodically.
-	 * @param code the runnable that needs to be executed
-	 * @param initialDelay the initial delay
-	 * @param duration the delay
-	 */
-	public static void runPeriodically(Runnable code, Duration initialDelay, Duration duration) {
-		ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
-		scheduler.scheduleAtFixedRate(code, initialDelay.toMillis(), duration.toMillis(), TimeUnit.MILLISECONDS);
-	}
+    /**
+     * Runs certain code periodically.
+     *
+     * @param code         the runnable that needs to be executed
+     * @param initialDelay the initial delay
+     * @param duration     the delay
+     */
+    public static void runPeriodically(Runnable code, Duration initialDelay, Duration duration) {
+        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+        scheduler.scheduleAtFixedRate(code, initialDelay.toMillis(), duration.toMillis(), TimeUnit.MILLISECONDS);
+    }
 
-	/**
-	 * Runs certain code periodically but with a final bound.
-	 * @param code the runnable that needs to be executed
-	 * @param duration the delay
-	 * @param maxTime the duration this thread will be opened in milliseconds
-	 */
-	public static void runPeriodicallyBounded(Runnable code, Duration duration, Duration maxTime) {
-		runPeriodicallyBounded(code, duration, duration, maxTime);
-	}
+    /**
+     * Runs certain code periodically but with a final bound.
+     *
+     * @param code     the runnable that needs to be executed
+     * @param duration the delay
+     * @param maxTime  the duration this thread will be opened in milliseconds
+     */
+    public static void runPeriodicallyBounded(Runnable code, Duration duration, Duration maxTime) {
+        runPeriodicallyBounded(code, duration, duration, maxTime);
+    }
 
-	/**
-	 * Runs certain code periodically but with a final bound.
-	 * @param code the runnable that needs to be executed
-	 * @param initialDelay the initial delay
-	 * @param duration the delay
-	 * @param maxTime the duration this thread will be opened in milliseconds
-	 */
-	public static void runPeriodicallyBounded(Runnable code, Duration initialDelay, Duration duration, Duration maxTime) {
-		ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
-		scheduler.scheduleAtFixedRate(code, initialDelay.toMillis(), duration.toMillis(), TimeUnit.MILLISECONDS);
-		scheduler.schedule(scheduler::shutdownNow, maxTime.toMillis(), TimeUnit.MILLISECONDS);
-	}
+    /**
+     * Runs certain code periodically but with a final bound.
+     *
+     * @param code         the runnable that needs to be executed
+     * @param initialDelay the initial delay
+     * @param duration     the delay
+     * @param maxTime      the duration this thread will be opened in milliseconds
+     */
+    public static void runPeriodicallyBounded(Runnable code, Duration initialDelay, Duration duration, Duration maxTime) {
+        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+        scheduler.scheduleAtFixedRate(code, initialDelay.toMillis(), duration.toMillis(), TimeUnit.MILLISECONDS);
+        scheduler.schedule(scheduler::shutdownNow, maxTime.toMillis(), TimeUnit.MILLISECONDS);
+    }
 
-	/**
-	 * Builds a new thread using an {@link ExecutorService}, allowing various utility methods.
-	 * @return the created thread
-	 */
-	public static ExecutorService buildAsync() {
-		return Executors.newCachedThreadPool();
-	}
+    /**
+     * Builds a new thread using an {@link ExecutorService}, allowing various utility methods.
+     *
+     * @return the created thread
+     */
+    public static ExecutorService buildAsync() {
+        return Executors.newCachedThreadPool();
+    }
 
-	/**
-	 * Builds a new thread using an {@link ScheduledExecutorService}, allowing various utility methods.
-	 * @return the created thread
-	 */
-	public static ScheduledExecutorService buildPeriodic() {
-		return Executors.newSingleThreadScheduledExecutor();
-	}
+    /**
+     * Builds a new thread using an {@link ScheduledExecutorService}, allowing various utility methods.
+     *
+     * @return the created thread
+     */
+    public static ScheduledExecutorService buildPeriodic() {
+        return Executors.newSingleThreadScheduledExecutor();
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/Time.java b/src/main/java/io/github/syst3ms/skriptparser/util/Time.java
index 2b769c3f..40bb1d01 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/Time.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/Time.java
@@ -11,6 +11,7 @@
 
 /**
  * Represents a time, as one could see on a clock.
+ *
  * @author Mwexim
  */
 public class Time implements Comparable<Time> {
@@ -43,6 +44,7 @@ private Time(LocalTime time) {
 
     /**
      * The current time, as it would be visible on a clock.
+     *
      * @return the current time
      */
     public static Time now() {
@@ -51,10 +53,11 @@ public static Time now() {
 
     /**
      * A time instance from given values.
-     * @param hours the hours, between 0 and 23
+     *
+     * @param hours   the hours, between 0 and 23
      * @param minutes the minutes, between 0 and 59
      * @param seconds the seconds, between 0 and 59
-     * @param millis the milliseconds, between 0 and 999
+     * @param millis  the milliseconds, between 0 and 999
      * @return a new time instance
      */
     public static Time of(int hours, int minutes, int seconds, int millis) {
@@ -63,6 +66,7 @@ public static Time of(int hours, int minutes, int seconds, int millis) {
 
     /**
      * A time instance from a given LocalTime instance.
+     *
      * @param time the time
      * @return a new time instance
      */
@@ -72,16 +76,18 @@ public static Time of(LocalTime time) {
 
     /**
      * A time instance from a given date.
+     *
      * @param date the date
      * @return a new time instance
      */
     public static Time of(SkriptDate date) {
         var lcd = date.toLocalDateTime();
-        return new Time(LocalTime.of(lcd.getHour(), lcd.getMinute(), lcd.getSecond(), lcd.getNano()));
+        return new Time(lcd.toLocalTime());
     }
 
     /**
      * Parses a given string as a time, using one of the three patterns.
+     *
      * @param toParse the string to parse
      * @return an Optional describing the parsed Time instance,
      * empty if no match was found.
@@ -95,8 +101,8 @@ public static Optional<Time> parse(String toParse) {
 
         Matcher matcher;
         if (!(matcher = DEFAULT_TIME_PATTERN.matcher(toParse)).matches()
-                && !(matcher = BRITISH_TIME_PATTERN.matcher(toParse)).matches()
-                && !(matcher = DETAILED_TIME_PATTERN.matcher(toParse)).matches())
+            && !(matcher = BRITISH_TIME_PATTERN.matcher(toParse)).matches()
+            && !(matcher = DETAILED_TIME_PATTERN.matcher(toParse)).matches())
             return Optional.empty();
 
         int hours = Integer.parseInt(matcher.group(1));
@@ -112,9 +118,9 @@ public static Optional<Time> parse(String toParse) {
         int seconds = count >= 3 && matcher.group(3) != null ? Integer.parseInt(matcher.group(3)) : 0;
         int millis = count >= 4 && matcher.group(4) != null ? Integer.parseInt(matcher.group(4)) : 0;
         if (hours < 0 || 23 < hours
-                || minutes < 0 || 59 < minutes
-                || seconds < 0 || 59 < seconds
-                || millis < 0 || 999 < millis)
+            || minutes < 0 || 59 < minutes
+            || seconds < 0 || 59 < seconds
+            || millis < 0 || 999 < millis)
             return Optional.empty();
 
         return Optional.of(of(hours, minutes, seconds, millis));
@@ -151,6 +157,7 @@ public int toMillis() {
 
     /**
      * The duration between two given time instances
+     *
      * @param other the time instance to compare
      * @return the duration between the instances, or {@link Duration#ZERO ZERO} if one instance is invalid
      */
@@ -160,6 +167,7 @@ public Duration difference(Time other) {
 
     /**
      * Add a {@link Duration} to this time.
+     *
      * @param span {@link Duration} to add
      */
     public void add(Duration span) {
@@ -168,6 +176,7 @@ public void add(Duration span) {
 
     /**
      * Subtract a {@link Duration} from this time.
+     *
      * @param span {@link Duration} to subtract
      */
     public void subtract(Duration span) {
@@ -176,6 +185,7 @@ public void subtract(Duration span) {
 
     /**
      * Get a new instance of this time with the added Duration.
+     *
      * @param span {@link Duration} to add to this Time
      * @return new {@link Time} with the added Duration
      */
@@ -185,6 +195,7 @@ public Time plus(Duration span) {
 
     /**
      * Get a new instance of this time with the subtracted Duration.
+     *
      * @param span {@link Duration} to subtract from this Time
      * @return new {@link Time} with the subtracted Duration
      */
@@ -211,4 +222,4 @@ public boolean equals(Object o) {
     public String toString() {
         return time.format(DateTimeFormatter.ofPattern(TIME_FORMAT, TIME_LOCALE));
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/color/Color.java b/src/main/java/io/github/syst3ms/skriptparser/util/color/Color.java
index 570ad998..a0a39a87 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/color/Color.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/color/Color.java
@@ -8,6 +8,7 @@
 
 /**
  * Represents a color, written like #xxxxxx or with an RGB format.
+ *
  * @author Mwexim
  */
 public class Color {
@@ -45,6 +46,7 @@ private Color(int r, int g, int b, int a) {
 
     /**
      * The Color instance of given hex value.
+     *
      * @param r the red value
      * @param g the green value
      * @param b the blue value
@@ -56,6 +58,7 @@ public static Optional<Color> of(int r, int g, int b) {
 
     /**
      * The Color instance of given hex value.
+     *
      * @param r the red value
      * @param g the green value
      * @param b the blue value
@@ -64,9 +67,9 @@ public static Optional<Color> of(int r, int g, int b) {
      */
     public static Optional<Color> of(int r, int g, int b, int a) {
         if (0 <= r && r < 256
-                && 0 <= g && g < 256
-                && 0 <= b && b < 256
-                && 0 <= a && a < 256) {
+            && 0 <= g && g < 256
+            && 0 <= b && b < 256
+            && 0 <= a && a < 256) {
             return Optional.of(new Color(r, g, b, a));
         }
         return Optional.empty();
@@ -74,6 +77,7 @@ public static Optional<Color> of(int r, int g, int b, int a) {
 
     /**
      * The Color instance of given hex value.
+     *
      * @param hex the hexadecimal value
      * @return a new Color instance
      */
@@ -83,7 +87,8 @@ public static Color of(int hex) {
 
     /**
      * The Color instance of given hex value.
-     * @param hex the hexadecimal value
+     *
+     * @param hex     the hexadecimal value
      * @param isAlpha whether or not the alpha parameter is present
      * @return a new Color instance
      */
@@ -105,6 +110,7 @@ public static Color of(long hex, boolean isAlpha) {
 
     /**
      * The Color instance of given hex value.
+     *
      * @param hex the hexadecimal value in String form
      * @return a new Color instance
      * @see #COLOR_PATTERN
@@ -131,6 +137,7 @@ public static Optional<Color> ofHex(String hex) {
 
     /**
      * The Color instance of given literal.
+     *
      * @param literal the literal value, like 'yellow' or 'green'.
      * @return a new Color instance
      */
@@ -175,8 +182,8 @@ public int getAlpha() {
      */
     public String getHex() {
         return alpha == 255
-                ? String.format("%02x%02x%02x", red, green, blue)
-                : String.format("%02x%02x%02x%02x", red, green, blue, alpha);
+            ? String.format("%02x%02x%02x", red, green, blue)
+            : String.format("%02x%02x%02x%02x", red, green, blue, alpha);
     }
 
     public java.awt.Color toJavaColor() {
@@ -197,4 +204,4 @@ public boolean equals(Object o) {
     public String toString() {
         return '#' + getHex();
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/AsinCalculator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/AsinCalculator.java
index c82d2898..71cd9886 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/AsinCalculator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/AsinCalculator.java
@@ -5,42 +5,43 @@
 
 /**
  * Calculates arc sinus using the Maclaurin series.
- * 
+ *
  * <p>See <a href="https://de.wikipedia.org/wiki/Taylorreihe">Wikipedia: Taylorreihe</a></p>
- * 
+ *
  * <p>No argument checking or optimizations are done.
  * This implementation is <strong>not</strong> intended to be called directly.</p>
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class AsinCalculator extends SeriesCalculator {
 
-	public static final AsinCalculator INSTANCE = new AsinCalculator();
-	
-	private int n = 0;
-	private BigRational factorial2n = BigRational.ONE;
-	private BigRational factorialN = BigRational.ONE;
-	private BigRational fourPowerN = BigRational.ONE;
-	
-	private AsinCalculator() {
-	}
-	
-	@Override
-	protected BigRational getCurrentFactor() {
-		return factorial2n.divide(fourPowerN.multiply(factorialN).multiply(factorialN).multiply(2 * n + 1));
-	}
-	
-	@Override
-	protected void calculateNextFactor() {
-		n++;
-		factorial2n = factorial2n.multiply(2 * n - 1).multiply(2 * n);
-		factorialN = factorialN.multiply(n);
-		fourPowerN = fourPowerN.multiply(4);
-	}
-	
-	@Override
-	protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
-		return new PowerTwoNPlusOneIterator(x, mathContext);
-	}
+    public static final AsinCalculator INSTANCE = new AsinCalculator();
+
+    private int n = 0;
+    private BigRational factorial2n = BigRational.ONE;
+    private BigRational factorialN = BigRational.ONE;
+    private BigRational fourPowerN = BigRational.ONE;
+
+    private AsinCalculator() {
+    }
+
+    @Override
+    protected BigRational getCurrentFactor() {
+        return factorial2n.divide(fourPowerN.multiply(factorialN).multiply(factorialN).multiply(2 * n + 1));
+    }
+
+    @Override
+    protected void calculateNextFactor() {
+        n++;
+        factorial2n = factorial2n.multiply(2 * n - 1).multiply(2 * n);
+        factorialN = factorialN.multiply(n);
+        fourPowerN = fourPowerN.multiply(4);
+    }
+
+    @Override
+    protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
+        return new PowerTwoNPlusOneIterator(x, mathContext);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/BigDecimalMath.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/BigDecimalMath.java
index ffe99c63..85f2b309 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/BigDecimalMath.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/BigDecimalMath.java
@@ -10,13 +10,17 @@
 import java.util.List;
 import java.util.Map;
 
-import static java.math.BigDecimal.*;
+import static java.math.BigDecimal.ONE;
+import static java.math.BigDecimal.TEN;
+import static java.math.BigDecimal.ZERO;
+import static java.math.BigDecimal.valueOf;
 
 /**
  * Provides advanced functions operating on {@link BigDecimal}s.
  * Taken from <a href="github.com/eobermuhlner/big-math/blob/master/ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/BigDecimalMath.java">@obermuhlner's Github</a>
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class BigDecimalMath {
@@ -38,11 +42,11 @@ public class BigDecimalMath {
     private static final int EXPECTED_INITIAL_PRECISION = 15;
     private static final Map<Integer, List<BigDecimal>> spougeFactorialConstantsCache = new HashMap<>();
     private static final Object spougeFactorialConstantsCacheLock = new Object();
+    private static final BigDecimal[] factorialCache = new BigDecimal[100];
     private static volatile BigDecimal log2Cache;
     private static volatile BigDecimal log3Cache;
     private static volatile BigDecimal log10Cache;
     private static volatile BigDecimal piCache;
-    private static final BigDecimal[] factorialCache = new BigDecimal[100];
     private static BigDecimal eCache;
 
     static {
@@ -68,8 +72,8 @@ private BigDecimalMath() {
      */
     public static boolean isIntValue(BigDecimal value) {
         return value.compareTo(ZERO) == 0
-                || value.scale() <= 0
-                || value.stripTrailingZeros().scale() <= 0;
+            || value.scale() <= 0
+            || value.stripTrailingZeros().scale() <= 0;
     }
 
     /**
@@ -368,8 +372,8 @@ public static BigDecimal pow(BigDecimal x, BigDecimal y, MathContext mathContext
      */
     public static BigDecimal pow(BigDecimal x, long y, MathContext mathContext) {
         var mc = mathContext.getPrecision() == 0
-                ? mathContext
-                : new MathContext(mathContext.getPrecision() + 10, mathContext.getRoundingMode());
+            ? mathContext
+            : new MathContext(mathContext.getPrecision() + 10, mathContext.getRoundingMode());
 
         // TODO optimize y=0, y=1, y=10^k, y=-1, y=-10^k
 
@@ -418,7 +422,7 @@ private static BigDecimal powInteger(BigDecimal x, BigDecimal integerY, MathCont
         }
 
         var mc = new MathContext(Math.max(mathContext.getPrecision(), -integerY.scale()) + 30,
-                mathContext.getRoundingMode()
+            mathContext.getRoundingMode()
         );
 
         var result = ONE;
@@ -792,7 +796,7 @@ private static BigDecimal piChudnovski(MathContext mathContext) {
             dividendTerm2 += 2;
             dividendTerm3 += 6;
             var dividend = BigDecimal.valueOf(dividendTerm1).multiply(BigDecimal.valueOf(dividendTerm2))
-                                            .multiply(BigDecimal.valueOf(dividendTerm3));
+                .multiply(BigDecimal.valueOf(dividendTerm3));
             kPower3 = valueK.pow(3);
             var divisor = kPower3.multiply(valueDivisor, mc);
             a = a.multiply(dividend).divide(divisor, mc);
@@ -1060,9 +1064,9 @@ private static void checkMathContext(MathContext mathContext) {
 
     public static BigDecimal getBigDecimal(Number n) {
         return n instanceof BigDecimal
-                ? (BigDecimal) n : n instanceof BigInteger
-                ? new BigDecimal((BigInteger) n)
-                : new BigDecimal(n.toString());
+            ? (BigDecimal) n : n instanceof BigInteger
+            ? new BigDecimal((BigInteger) n)
+            : new BigDecimal(n.toString());
     }
 
     public static BigInteger getBigInteger(Number n) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/BigRational.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/BigRational.java
index d65a8d6d..75379c95 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/BigRational.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/BigRational.java
@@ -6,15 +6,15 @@
 
 /**
  * A rational number represented as a quotient of two values.
- * 
+ *
  * <p>Basic calculations with rational numbers (+ - * /) have no loss of precision.
  * This allows to use {@link BigRational} as a replacement for {@link BigDecimal} if absolute accuracy is desired.</p>
- * 
+ *
  * <p><a href="http://en.wikipedia.org/wiki/Rational_number">Wikipedia: Rational number</a></p>
- * 
+ *
  * <p>The values are internally stored as {@link BigDecimal} (for performance optimizations) but represented
  * as {@link BigInteger} (for mathematical correctness)
- * 
+ *
  * <p>The following basic calculations have no loss of precision:</p>
  * <ul>
  * <li>{@link #add(BigRational)}</li>
@@ -23,515 +23,513 @@
  * <li>{@link #divide(BigRational)}</li>
  * <li>{@link #pow(int)}</li>
  * </ul>
- * 
+ *
  * <p>The following calculations are special cases of the ones listed above and have no loss of precision:</p>
  * <ul>
  * <li>{@link #negate()}</li>
  * <li>{@link #reciprocal()}</li>
  * </ul>
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class BigRational implements Comparable<BigRational> {
 
-	/**
-	 * The value 0 as {@link BigRational}.
-	 */
-	public static final BigRational ZERO = new BigRational(0);
-	/**
-	 * The value 1 as {@link BigRational}.
-	 */
-	public static final BigRational ONE = new BigRational(1);
+    /**
+     * The value 0 as {@link BigRational}.
+     */
+    public static final BigRational ZERO = new BigRational(0);
+    /**
+     * The value 1 as {@link BigRational}.
+     */
+    public static final BigRational ONE = new BigRational(1);
 
     private final BigDecimal numerator;
 
-	private final BigDecimal denominator;
+    private final BigDecimal denominator;
+
+    private BigRational(int value) {
+        this(BigDecimal.valueOf(value), BigDecimal.ONE);
+    }
 
-	private BigRational(int value) {
-		this(BigDecimal.valueOf(value), BigDecimal.ONE);
-	}
+    private BigRational(BigDecimal num, BigDecimal denom) {
+        var n = num;
+        var d = denom;
 
-	private BigRational(BigDecimal num, BigDecimal denom) {
-		var n = num;
-		var d = denom;
+        if (d.signum() == 0) {
+            throw new ArithmeticException("Divide by zero");
+        }
 
-		if (d.signum() == 0) {
-			throw new ArithmeticException("Divide by zero");
-		}
+        if (d.signum() < 0) {
+            n = n.negate();
+            d = d.negate();
+        }
 
-		if (d.signum() < 0) {
-			n = n.negate();
-			d = d.negate();
-		}
+        numerator = n;
+        denominator = d;
+    }
 
-		numerator = n;
-		denominator = d;
-	}
+    private static int countDigits(BigInteger number) {
+        var factor = Math.log(2) / Math.log(10);
+        var digitCount = (int) (factor * number.bitLength() + 1);
+        if (BigInteger.TEN.pow(digitCount - 1).compareTo(number) > 0) {
+            return digitCount - 1;
+        }
+        return digitCount;
+    }
 
     /**
-	 * Returns the numerator of this rational number as BigDecimal.
-	 * 
-	 * @return the numerator as BigDecimal
-	 */
-	public BigDecimal getNumerator() {
-		return numerator;
-	}
+     * Creates a rational number of the specified int value.
+     *
+     * @param value the int value
+     * @return the rational number
+     */
+    public static BigRational valueOf(int value) {
+        if (value == 0) {
+            return ZERO;
+        }
+        if (value == 1) {
+            return ONE;
+        }
+        return new BigRational(value);
+    }
 
     /**
-	 * Returns the denominator of this rational number as BigDecimal.
-	 * 
-	 * <p>Guaranteed to not be 0.</p>
-	 * <p>Guaranteed to be positive.</p>
-	 * 
-	 * @return the denominator as BigDecimal
-	 */
-	public BigDecimal getDenominator() {
-		return denominator;
-	}
+     * Creates a rational number of the specified numerator/denominator int values.
+     *
+     * @param numerator   the numerator int value
+     * @param denominator the denominator int value (0 not allowed)
+     * @return the rational number
+     * @throws ArithmeticException if the denominator is 0 (division by zero)
+     */
+    public static BigRational valueOf(int numerator, int denominator) {
+        return of(BigDecimal.valueOf(numerator), BigDecimal.valueOf(denominator));
+    }
 
     /**
-	 * Negates this rational number (inverting the sign).
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * <p>Examples:</p>
-	 * <ul>
-	 * <li><code>BigRational.valueOf(3.5).negate()</code> returns <code>BigRational.valueOf(-3.5)</code></li>
-	 * </ul>
-	 * 
-	 * @return the negated rational number
-	 */
-	public BigRational negate() {
-		if (isZero()) {
-			return this;
-		}
-
-		return of(numerator.negate(), denominator);
-	}
-
-	/**
-	 * Calculates the reciprocal of this rational number (1/x).
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * <p>Examples:</p>
-	 * <ul>
-	 * <li><code>BigRational.valueOf(0.5).reciprocal()</code> returns <code>BigRational.valueOf(2)</code></li>
-	 * <li><code>BigRational.valueOf(-2).reciprocal()</code> returns <code>BigRational.valueOf(-0.5)</code></li>
-	 * </ul>
-	 * 
-	 * @return the reciprocal rational number
-	 * @throws ArithmeticException if this number is 0 (division by zero)
-	 */
-	public BigRational reciprocal() {
-		return of(denominator, numerator);
-	}
+     * Creates a rational number of the specified numerator/denominator BigInteger values.
+     *
+     * @param numerator   the numerator {@link BigInteger} value
+     * @param denominator the denominator {@link BigInteger} value (0 not allowed)
+     * @return the rational number
+     * @throws ArithmeticException if the denominator is 0 (division by zero)
+     */
+    public static BigRational valueOf(BigInteger numerator, BigInteger denominator) {
+        return of(new BigDecimal(numerator), new BigDecimal(denominator));
+    }
 
     /**
-	 * Calculates the addition (+) of this rational number and the specified argument.
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the rational number to add
-	 * @return the resulting rational number
-	 */
-	public BigRational add(BigRational value) {
-		if (denominator.equals(value.denominator)) {
-			return of(numerator.add(value.numerator), denominator);
-		}
-
-		var n = numerator.multiply(value.denominator).add(value.numerator.multiply(denominator));
-		var d = denominator.multiply(value.denominator);
-		return of(n, d);
-	}
-
-	private BigRational add(BigDecimal value) {
-		return of(numerator.add(value.multiply(denominator)), denominator);
-	}
-	
-	/**
-	 * Calculates the addition (+) of this rational number and the specified argument.
-	 * 
-	 * <p>This is functionally identical to
-	 * <code>this.add(BigRational.valueOf(value))</code>
-	 * but slightly faster.</p>
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the {@link BigInteger} to add
-	 * @return the resulting rational number
-	 */
-	public BigRational add(BigInteger value) {
-		if (value.equals(BigInteger.ZERO)) {
-			return this;
-		}
-		return add(new BigDecimal(value));
-	}
+     * Creates a rational number of the specified {@link BigInteger} value.
+     *
+     * @param value the {@link BigInteger} value
+     * @return the rational number
+     */
+    public static BigRational valueOf(BigInteger value) {
+        if (value.compareTo(BigInteger.ZERO) == 0) {
+            return ZERO;
+        }
+        if (value.compareTo(BigInteger.ONE) == 0) {
+            return ONE;
+        }
+        return valueOf(value, BigInteger.ONE);
+    }
 
     /**
-	 * Calculates the subtraction (-) of this rational number and the specified argument.
-	 *
-	 * <p>The result has no loss of precision.</p>
-	 *
-	 * @param value the rational number to subtract
-	 * @return the resulting rational number
-	 */
-	public BigRational subtract(BigRational value) {
-		if (denominator.equals(value.denominator)) {
-			return of(numerator.subtract(value.numerator), denominator);
-		}
-
-		var n = numerator.multiply(value.denominator).subtract(value.numerator.multiply(denominator));
-		var d = denominator.multiply(value.denominator);
-		return of(n, d);
-	}
+     * Creates a rational number of the specified {@link BigDecimal} value.
+     *
+     * @param value the double value
+     * @return the rational number
+     */
+    public static BigRational valueOf(BigDecimal value) {
+        if (value.compareTo(BigDecimal.ZERO) == 0) {
+            return ZERO;
+        }
+        if (value.compareTo(BigDecimal.ONE) == 0) {
+            return ONE;
+        }
+
+        var scale = value.scale();
+        if (scale == 0) {
+            return new BigRational(value, BigDecimal.ONE);
+        } else if (scale < 0) {
+            var n = new BigDecimal(value.unscaledValue()).multiply(BigDecimal.ONE.movePointLeft(value.scale()));
+            return new BigRational(n, BigDecimal.ONE);
+        } else {
+            var n = new BigDecimal(value.unscaledValue());
+            var d = BigDecimal.ONE.movePointRight(value.scale());
+            return new BigRational(n, d);
+        }
+    }
+
+    private static BigRational of(BigDecimal numerator, BigDecimal denominator) {
+        if (numerator.signum() == 0 && denominator.signum() != 0) {
+            return ZERO;
+        }
+        if (numerator.compareTo(BigDecimal.ONE) == 0 && denominator.compareTo(BigDecimal.ONE) == 0) {
+            return ONE;
+        }
+        return new BigRational(numerator, denominator);
+    }
 
     /**
-	 * Calculates the multiplication (*) of this rational number and the specified argument.
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the rational number to multiply
-	 * @return the resulting rational number
-	 */
-	public BigRational multiply(BigRational value) {
-		if (isZero() || value.isZero()) {
-			return ZERO;
-		}
-		if (equals(ONE)) {
-			return value;
-		}
-		if (value.equals(ONE)) {
-			return this;
-		}
-
-		return of(numerator.multiply(value.numerator), denominator.multiply(value.denominator));
-	}
-
-	// private, because we want to hide that we use BigDecimal internally
-	private BigRational multiply(BigDecimal value) {
-		return of(numerator.multiply(value), denominator);
-	}
-	
-	/**
-	 * Calculates the multiplication (*) of this rational number and the specified argument.
-	 * 
-	 * <p>This is functionally identical to
-	 * <code>this.multiply(BigRational.valueOf(value))</code>
-	 * but slightly faster.</p>
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the {@link BigInteger} to multiply
-	 * @return the resulting rational number
-	 */
-	public BigRational multiply(BigInteger value) {
-		if (isZero() || value.signum() == 0) {
-			return ZERO;
-		}
-		if (equals(ONE)) {
-			return valueOf(value);
-		}
-		if (value.equals(BigInteger.ONE)) {
-			return this;
-		}
-
-		return multiply(new BigDecimal(value));
-	}
-
-	/**
-	 * Calculates the multiplication (*) of this rational number and the specified argument.
-	 * 
-	 * <p>This is functionally identical to
-	 * <code>this.multiply(BigRational.valueOf(value))</code>
-	 * but slightly faster.</p>
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the int value to multiply
-	 * @return the resulting rational number
-	 */
-	public BigRational multiply(int value) {
-		return multiply(BigInteger.valueOf(value));
-	}
-
-	/**
-	 * Calculates the division (/) of this rational number and the specified argument.
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the rational number to divide (0 is not allowed)
-	 * @return the resulting rational number
-	 * @throws ArithmeticException if the argument is 0 (division by zero)
-	 */
-	public BigRational divide(BigRational value) {
-		if (value.equals(ONE)) {
-			return this;
-		}
-		return of(numerator.multiply(value.denominator), denominator.multiply(value.numerator));
-	}
-
-	private BigRational divide(BigDecimal value) {
-		return of(numerator, denominator.multiply(value));
-	}
-	
-	/**
-	 * Calculates the division (/) of this rational number and the specified argument.
-	 * 
-	 * <p>This is functionally identical to
-	 * <code>this.divide(BigRational.valueOf(value))</code>
-	 * but slightly faster.</p>
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the {@link BigInteger} to divide (0 is not allowed)
-	 * @return the resulting rational number
-	 * @throws ArithmeticException if the argument is 0 (division by zero)
-	 */
-	public BigRational divide(BigInteger value) {
-		if (value.equals(BigInteger.ONE)) {
-			return this;
-		}
-		return divide(new BigDecimal(value));
-	}
-
-	/**
-	 * Calculates the division (/) of this rational number and the specified argument.
-	 * 
-	 * <p>This is functionally identical to
-	 * <code>this.divide(BigRational.valueOf(value))</code>
-	 * but slightly faster.</p>
-	 * 
-	 * <p>The result has no loss of precision.</p>
-	 * 
-	 * @param value the int value to divide (0 is not allowed)
-	 * @return the resulting rational number
-	 * @throws ArithmeticException if the argument is 0 (division by zero)
-	 */
-	public BigRational divide(int value) {
-		return divide(BigInteger.valueOf(value));
-	}
-
-	/**
-	 * Returns whether this rational number is zero.
-	 * 
-	 * @return <code>true</code> if this rational number is zero (0), <code>false</code> if it is not zero
-	 */
-	public boolean isZero() {
-		return numerator.signum() == 0;
-	}
-
-	/**
-	 * Returns whether this rational number is an integer number without fraction part.
-	 *
-	 * <p>Will return <code>false</code> if this number is not reduced to the integer representation yet (e.g. 4/4 or 4/2)</p>
-	 *
-	 * @return <code>true</code> if this rational number is an integer number, <code>false</code> if it has a fraction part
-	 */
-	private boolean isIntegerInternal() {
-		return denominator.compareTo(BigDecimal.ONE) == 0;
-	}
-
-	/**
-	 * Calculates this rational number to the power (x<sup>y</sup>) of the specified argument.
-	 *
-	 * <p>The result has no loss of precision.</p>
-	 *
-	 * @param exponent exponent to which this rational number is to be raised
-	 * @return the resulting rational number
-	 */
-	public BigRational pow(int exponent) {
-		if (exponent == 0) {
-			return ONE;
-		}
-		if (exponent == 1) {
-			return this;
-		}
-
-		final BigInteger n;
-		final BigInteger d;
-		if (exponent > 0) {
-			n = numerator.toBigInteger().pow(exponent);
-			d = denominator.toBigInteger().pow(exponent);
-		}
-		else {
-			n = denominator.toBigInteger().pow(-exponent);
-			d = numerator.toBigInteger().pow(-exponent);
-		}
-		return valueOf(n, d);
-	}
+     * Returns the numerator of this rational number as BigDecimal.
+     *
+     * @return the numerator as BigDecimal
+     */
+    public BigDecimal getNumerator() {
+        return numerator;
+    }
 
-    private static int countDigits(BigInteger number) {
-		var factor = Math.log(2) / Math.log(10);
-		var digitCount = (int) (factor * number.bitLength() + 1);
-		if (BigInteger.TEN.pow(digitCount - 1).compareTo(number) > 0) {
-			return digitCount - 1;
-		}
-		return digitCount;
-	}
-
-	// TODO what is precision of a rational?
-	private int precision() {
-		return countDigits(numerator.toBigInteger()) + countDigits(denominator.toBigInteger());
-	}
+    /**
+     * Returns the denominator of this rational number as BigDecimal.
+     *
+     * <p>Guaranteed to not be 0.</p>
+     * <p>Guaranteed to be positive.</p>
+     *
+     * @return the denominator as BigDecimal
+     */
+    public BigDecimal getDenominator() {
+        return denominator;
+    }
 
     /**
-	 * Returns this rational number as a {@link BigDecimal}.
-	 *
-	 * @return the {@link BigDecimal} value
-	 */
-	public BigDecimal toBigDecimal() {
-		var precision = Math.max(precision(), MathContext.DECIMAL128.getPrecision());
-		return toBigDecimal(new MathContext(precision));
-	}
-
-	/**
-	 * Returns this rational number as a {@link BigDecimal} with the precision specified by the {@link MathContext}.
-	 *
-	 * @param mc the {@link MathContext} specifying the precision of the calculated result
-	 * @return the {@link BigDecimal}
-	 */
-	public BigDecimal toBigDecimal(MathContext mc) {
-		return numerator.divide(denominator, mc);
-	}
-
-	@Override
-	public int compareTo(BigRational other) {
-		if (this == other) {
-			return 0;
-		}
-		return numerator.multiply(other.denominator).compareTo(denominator.multiply(other.numerator));
-	}
-
-	@Override
-	public int hashCode() {
-		if (isZero()) {
-			return 0;
-		}
-		return numerator.hashCode() + denominator.hashCode();
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		if (obj == this) {
-			return true;
-		}
-
-		if (!(obj instanceof BigRational)) {
-			return false;
-		}
-
-		var other = (BigRational) obj;
-		if (!numerator.equals(other.numerator)) {
-			return false;
-		}
-		return denominator.equals(other.denominator);
-	}
-
-	@Override
-	public String toString() {
-		if (isZero()) {
-			return "0";
-		}
-		if (isIntegerInternal()) {
-			return numerator.toString();
-		}
-		return toBigDecimal().toString();
-	}
+     * Negates this rational number (inverting the sign).
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * <p>Examples:</p>
+     * <ul>
+     * <li><code>BigRational.valueOf(3.5).negate()</code> returns <code>BigRational.valueOf(-3.5)</code></li>
+     * </ul>
+     *
+     * @return the negated rational number
+     */
+    public BigRational negate() {
+        if (isZero()) {
+            return this;
+        }
+
+        return of(numerator.negate(), denominator);
+    }
 
     /**
-	 * Creates a rational number of the specified int value.
-	 * 
-	 * @param value the int value
-	 * @return the rational number
-	 */
-	public static BigRational valueOf(int value) {
-		if (value == 0) {
-			return ZERO;
-		}
-		if (value == 1) {
-			return ONE;
-		}
-		return new BigRational(value);
-	}
-
-	/**
-	 * Creates a rational number of the specified numerator/denominator int values.
-	 *
-	 * @param numerator the numerator int value
-	 * @param denominator the denominator int value (0 not allowed)
-	 * @return the rational number
-	 * @throws ArithmeticException if the denominator is 0 (division by zero)
-	 */
-	public static BigRational valueOf(int numerator, int denominator) {
-		return of(BigDecimal.valueOf(numerator), BigDecimal.valueOf(denominator));
-	}
+     * Calculates the reciprocal of this rational number (1/x).
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * <p>Examples:</p>
+     * <ul>
+     * <li><code>BigRational.valueOf(0.5).reciprocal()</code> returns <code>BigRational.valueOf(2)</code></li>
+     * <li><code>BigRational.valueOf(-2).reciprocal()</code> returns <code>BigRational.valueOf(-0.5)</code></li>
+     * </ul>
+     *
+     * @return the reciprocal rational number
+     * @throws ArithmeticException if this number is 0 (division by zero)
+     */
+    public BigRational reciprocal() {
+        return of(denominator, numerator);
+    }
 
     /**
-	 * Creates a rational number of the specified numerator/denominator BigInteger values.
-	 *
-	 * @param numerator the numerator {@link BigInteger} value
-	 * @param denominator the denominator {@link BigInteger} value (0 not allowed)
-	 * @return the rational number
-	 * @throws ArithmeticException if the denominator is 0 (division by zero)
-	 */
-	public static BigRational valueOf(BigInteger numerator, BigInteger denominator) {
-		return of(new BigDecimal(numerator), new BigDecimal(denominator));
-	}
-
-	/**
-	 * Creates a rational number of the specified {@link BigInteger} value.
-	 * 
-	 * @param value the {@link BigInteger} value
-	 * @return the rational number
-	 */
-	public static BigRational valueOf(BigInteger value) {
-		if (value.compareTo(BigInteger.ZERO) == 0) {
-			return ZERO;
-		}
-		if (value.compareTo(BigInteger.ONE) == 0) {
-			return ONE;
-		}
-		return valueOf(value, BigInteger.ONE);
-	}
+     * Calculates the addition (+) of this rational number and the specified argument.
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the rational number to add
+     * @return the resulting rational number
+     */
+    public BigRational add(BigRational value) {
+        if (denominator.equals(value.denominator)) {
+            return of(numerator.add(value.numerator), denominator);
+        }
+
+        var n = numerator.multiply(value.denominator).add(value.numerator.multiply(denominator));
+        var d = denominator.multiply(value.denominator);
+        return of(n, d);
+    }
+
+    private BigRational add(BigDecimal value) {
+        return of(numerator.add(value.multiply(denominator)), denominator);
+    }
 
     /**
-	 * Creates a rational number of the specified {@link BigDecimal} value.
-	 *
-	 * @param value the double value
-	 * @return the rational number
-	 */
-	public static BigRational valueOf(BigDecimal value) {
-		if (value.compareTo(BigDecimal.ZERO) == 0) {
-			return ZERO;
-		}
-		if (value.compareTo(BigDecimal.ONE) == 0) {
-			return ONE;
-		}
-
-		var scale = value.scale();
-		if (scale == 0) {
-			return new BigRational(value, BigDecimal.ONE);
-		} else if (scale < 0) {
-			var n = new BigDecimal(value.unscaledValue()).multiply(BigDecimal.ONE.movePointLeft(value.scale()));
-			return new BigRational(n, BigDecimal.ONE);
-		}
-		else {
-			var n = new BigDecimal(value.unscaledValue());
-			var d = BigDecimal.ONE.movePointRight(value.scale());
-			return new BigRational(n, d);
-		}
-	}
+     * Calculates the addition (+) of this rational number and the specified argument.
+     *
+     * <p>This is functionally identical to
+     * <code>this.add(BigRational.valueOf(value))</code>
+     * but slightly faster.</p>
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the {@link BigInteger} to add
+     * @return the resulting rational number
+     */
+    public BigRational add(BigInteger value) {
+        if (value.equals(BigInteger.ZERO)) {
+            return this;
+        }
+        return add(new BigDecimal(value));
+    }
 
-    private static BigRational of(BigDecimal numerator, BigDecimal denominator) {
-		if (numerator.signum() == 0 && denominator.signum() != 0) {
-			return ZERO;
-		}
-		if (numerator.compareTo(BigDecimal.ONE) == 0 && denominator.compareTo(BigDecimal.ONE) == 0) {
-			return ONE;
-		}
-		return new BigRational(numerator, denominator);
-	}
+    /**
+     * Calculates the subtraction (-) of this rational number and the specified argument.
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the rational number to subtract
+     * @return the resulting rational number
+     */
+    public BigRational subtract(BigRational value) {
+        if (denominator.equals(value.denominator)) {
+            return of(numerator.subtract(value.numerator), denominator);
+        }
+
+        var n = numerator.multiply(value.denominator).subtract(value.numerator.multiply(denominator));
+        var d = denominator.multiply(value.denominator);
+        return of(n, d);
+    }
+
+    /**
+     * Calculates the multiplication (*) of this rational number and the specified argument.
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the rational number to multiply
+     * @return the resulting rational number
+     */
+    public BigRational multiply(BigRational value) {
+        if (isZero() || value.isZero()) {
+            return ZERO;
+        }
+        if (equals(ONE)) {
+            return value;
+        }
+        if (value.equals(ONE)) {
+            return this;
+        }
+
+        return of(numerator.multiply(value.numerator), denominator.multiply(value.denominator));
+    }
+
+    // private, because we want to hide that we use BigDecimal internally
+    private BigRational multiply(BigDecimal value) {
+        return of(numerator.multiply(value), denominator);
+    }
+
+    /**
+     * Calculates the multiplication (*) of this rational number and the specified argument.
+     *
+     * <p>This is functionally identical to
+     * <code>this.multiply(BigRational.valueOf(value))</code>
+     * but slightly faster.</p>
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the {@link BigInteger} to multiply
+     * @return the resulting rational number
+     */
+    public BigRational multiply(BigInteger value) {
+        if (isZero() || value.signum() == 0) {
+            return ZERO;
+        }
+        if (equals(ONE)) {
+            return valueOf(value);
+        }
+        if (value.equals(BigInteger.ONE)) {
+            return this;
+        }
+
+        return multiply(new BigDecimal(value));
+    }
+
+    /**
+     * Calculates the multiplication (*) of this rational number and the specified argument.
+     *
+     * <p>This is functionally identical to
+     * <code>this.multiply(BigRational.valueOf(value))</code>
+     * but slightly faster.</p>
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the int value to multiply
+     * @return the resulting rational number
+     */
+    public BigRational multiply(int value) {
+        return multiply(BigInteger.valueOf(value));
+    }
+
+    /**
+     * Calculates the division (/) of this rational number and the specified argument.
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the rational number to divide (0 is not allowed)
+     * @return the resulting rational number
+     * @throws ArithmeticException if the argument is 0 (division by zero)
+     */
+    public BigRational divide(BigRational value) {
+        if (value.equals(ONE)) {
+            return this;
+        }
+        return of(numerator.multiply(value.denominator), denominator.multiply(value.numerator));
+    }
+
+    private BigRational divide(BigDecimal value) {
+        return of(numerator, denominator.multiply(value));
+    }
+
+    /**
+     * Calculates the division (/) of this rational number and the specified argument.
+     *
+     * <p>This is functionally identical to
+     * <code>this.divide(BigRational.valueOf(value))</code>
+     * but slightly faster.</p>
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the {@link BigInteger} to divide (0 is not allowed)
+     * @return the resulting rational number
+     * @throws ArithmeticException if the argument is 0 (division by zero)
+     */
+    public BigRational divide(BigInteger value) {
+        if (value.equals(BigInteger.ONE)) {
+            return this;
+        }
+        return divide(new BigDecimal(value));
+    }
+
+    /**
+     * Calculates the division (/) of this rational number and the specified argument.
+     *
+     * <p>This is functionally identical to
+     * <code>this.divide(BigRational.valueOf(value))</code>
+     * but slightly faster.</p>
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param value the int value to divide (0 is not allowed)
+     * @return the resulting rational number
+     * @throws ArithmeticException if the argument is 0 (division by zero)
+     */
+    public BigRational divide(int value) {
+        return divide(BigInteger.valueOf(value));
+    }
+
+    /**
+     * Returns whether this rational number is zero.
+     *
+     * @return <code>true</code> if this rational number is zero (0), <code>false</code> if it is not zero
+     */
+    public boolean isZero() {
+        return numerator.signum() == 0;
+    }
+
+    /**
+     * Returns whether this rational number is an integer number without fraction part.
+     *
+     * <p>Will return <code>false</code> if this number is not reduced to the integer representation yet (e.g. 4/4 or 4/2)</p>
+     *
+     * @return <code>true</code> if this rational number is an integer number, <code>false</code> if it has a fraction part
+     */
+    private boolean isIntegerInternal() {
+        return denominator.compareTo(BigDecimal.ONE) == 0;
+    }
+
+    /**
+     * Calculates this rational number to the power (x<sup>y</sup>) of the specified argument.
+     *
+     * <p>The result has no loss of precision.</p>
+     *
+     * @param exponent exponent to which this rational number is to be raised
+     * @return the resulting rational number
+     */
+    public BigRational pow(int exponent) {
+        if (exponent == 0) {
+            return ONE;
+        }
+        if (exponent == 1) {
+            return this;
+        }
+
+        final BigInteger n;
+        final BigInteger d;
+        if (exponent > 0) {
+            n = numerator.toBigInteger().pow(exponent);
+            d = denominator.toBigInteger().pow(exponent);
+        } else {
+            n = denominator.toBigInteger().pow(-exponent);
+            d = numerator.toBigInteger().pow(-exponent);
+        }
+        return valueOf(n, d);
+    }
+
+    // TODO what is precision of a rational?
+    private int precision() {
+        return countDigits(numerator.toBigInteger()) + countDigits(denominator.toBigInteger());
+    }
+
+    /**
+     * Returns this rational number as a {@link BigDecimal}.
+     *
+     * @return the {@link BigDecimal} value
+     */
+    public BigDecimal toBigDecimal() {
+        var precision = Math.max(precision(), MathContext.DECIMAL128.getPrecision());
+        return toBigDecimal(new MathContext(precision));
+    }
+
+    /**
+     * Returns this rational number as a {@link BigDecimal} with the precision specified by the {@link MathContext}.
+     *
+     * @param mc the {@link MathContext} specifying the precision of the calculated result
+     * @return the {@link BigDecimal}
+     */
+    public BigDecimal toBigDecimal(MathContext mc) {
+        return numerator.divide(denominator, mc);
+    }
+
+    @Override
+    public int compareTo(BigRational other) {
+        if (this == other) {
+            return 0;
+        }
+        return numerator.multiply(other.denominator).compareTo(denominator.multiply(other.numerator));
+    }
+
+    @Override
+    public int hashCode() {
+        if (isZero()) {
+            return 0;
+        }
+        return numerator.hashCode() + denominator.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+
+        if (!(obj instanceof BigRational other)) {
+            return false;
+        }
+
+        if (!numerator.equals(other.numerator)) {
+            return false;
+        }
+        return denominator.equals(other.denominator);
+    }
+
+    @Override
+    public String toString() {
+        if (isZero()) {
+            return "0";
+        }
+        if (isIntegerInternal()) {
+            return numerator.toString();
+        }
+        return toBigDecimal().toString();
+    }
 
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/CosCalculator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/CosCalculator.java
index b64111ce..06134a68 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/CosCalculator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/CosCalculator.java
@@ -5,45 +5,46 @@
 
 /**
  * Calculates cosinus using the Maclaurin series.
- * 
+ *
  * <p>See <a href="https://de.wikipedia.org/wiki/Taylorreihe">Wikipedia: Taylorreihe</a></p>
- * 
+ *
  * <p>No argument checking or optimizations are done.
  * This implementation is <strong>not</strong> intended to be called directly.</p>
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class CosCalculator extends SeriesCalculator {
 
-	public static final CosCalculator INSTANCE = new CosCalculator();
-	
-	private int n = 0;
-	private boolean negative = false;
-	private BigRational factorial2n = BigRational.ONE;
-	
-	private CosCalculator() {
-		super(true);
-	}
-	
-	@Override
-	protected BigRational getCurrentFactor() {
-		var factor = factorial2n.reciprocal();
-		if (negative) {
-			factor = factor.negate();
-		}
-		return factor;
-	}
-	
-	@Override
-	protected void calculateNextFactor() {
-		n++;
-		factorial2n = factorial2n.multiply(2 * n - 1).multiply(2 * n);
-		negative = !negative;
-	}
-	
-	@Override
-	protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
-		return new PowerTwoNIterator(x, mathContext);
-	}
+    public static final CosCalculator INSTANCE = new CosCalculator();
+
+    private int n = 0;
+    private boolean negative = false;
+    private BigRational factorial2n = BigRational.ONE;
+
+    private CosCalculator() {
+        super(true);
+    }
+
+    @Override
+    protected BigRational getCurrentFactor() {
+        var factor = factorial2n.reciprocal();
+        if (negative) {
+            factor = factor.negate();
+        }
+        return factor;
+    }
+
+    @Override
+    protected void calculateNextFactor() {
+        n++;
+        factorial2n = factorial2n.multiply(2 * n - 1).multiply(2 * n);
+        negative = !negative;
+    }
+
+    @Override
+    protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
+        return new PowerTwoNIterator(x, mathContext);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/ExpCalculator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/ExpCalculator.java
index 77fee09c..ff57db11 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/ExpCalculator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/ExpCalculator.java
@@ -5,39 +5,40 @@
 
 /**
  * Calculates exp using the Maclaurin series.
- * 
+ *
  * <p>See <a href="https://de.wikipedia.org/wiki/Taylorreihe">Wikipedia: Taylorreihe</a></p>
- * 
+ *
  * <p>No argument checking or optimizations are done.
  * This implementation is <strong>not</strong> intended to be called directly.</p>
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class ExpCalculator extends SeriesCalculator {
 
-	public static final ExpCalculator INSTANCE = new ExpCalculator();
-	
-	private int n = 0;
-	private BigRational oneOverFactorialOfN = BigRational.ONE;
-	
-	private ExpCalculator() {
-		// prevent instances
-	}
-
-	@Override
-	protected BigRational getCurrentFactor() {
-		return oneOverFactorialOfN;
-	}
-	
-	@Override
-	protected void calculateNextFactor() {
-		n++;
-		oneOverFactorialOfN = oneOverFactorialOfN.divide(n);
-	}
-
-	@Override
-	protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
-		return new PowerNIterator(x, mathContext);
-	}
+    public static final ExpCalculator INSTANCE = new ExpCalculator();
+
+    private int n = 0;
+    private BigRational oneOverFactorialOfN = BigRational.ONE;
+
+    private ExpCalculator() {
+        // prevent instances
+    }
+
+    @Override
+    protected BigRational getCurrentFactor() {
+        return oneOverFactorialOfN;
+    }
+
+    @Override
+    protected void calculateNextFactor() {
+        n++;
+        oneOverFactorialOfN = oneOverFactorialOfN.divide(n);
+    }
+
+    @Override
+    protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
+        return new PowerNIterator(x, mathContext);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java
index cddb546e..648f5162 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java
@@ -10,15 +10,14 @@
 
 /**
  * Utilities for various math operations using the generic {@link Number} type
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class NumberMath {
     private static final BigDecimal RADIANS_TO_DEGREES = new BigDecimal(180).divide(BigDecimalMath.pi(BigDecimalMath.DEFAULT_CONTEXT), BigDecimalMath.DEFAULT_CONTEXT);
     private static final BigDecimal DEGREES_TO_RADIANS = BigDecimalMath.pi(BigDecimalMath.DEFAULT_CONTEXT).divide(new BigDecimal(180), BigDecimalMath.DEFAULT_CONTEXT);
-    // All cached primes. Some prime numbers are cached by default.
-    private static final ArrayList<Integer> cachedPrimes = new ArrayList<>(sieveOfEratosthenes(1000));
 
     public static Number abs(Number n) {
         if (n instanceof Long) {
@@ -31,7 +30,8 @@ public static Number abs(Number n) {
             return ((BigDecimal) n).abs();
         }
         throw new IllegalArgumentException();
-    }
+    }    // All cached primes. Some prime numbers are cached by default.
+    private static final ArrayList<Integer> cachedPrimes = new ArrayList<>(sieveOfEratosthenes(1000));
 
     public static Number negate(Number n) {
         if (n instanceof Long) {
@@ -71,7 +71,7 @@ public static Number log(Number base, Number n) {
             return BigDecimalMath.log10(bd, BigDecimalMath.DEFAULT_CONTEXT);
         } else {
             return BigDecimalMath.log(bd, BigDecimalMath.DEFAULT_CONTEXT)
-                    .divide(BigDecimalMath.log(bdBase, BigDecimalMath.DEFAULT_CONTEXT), BigDecimalMath.DEFAULT_ROUNDING_MODE);
+                .divide(BigDecimalMath.log(bdBase, BigDecimalMath.DEFAULT_CONTEXT), BigDecimalMath.DEFAULT_ROUNDING_MODE);
         }
     }
 
@@ -172,8 +172,8 @@ public static Number sinh(Number n) {
             return Math.sinh(n.doubleValue());
         } else {
             return BigDecimalMath.exp(bigToBigDecimal(n), BigDecimalMath.DEFAULT_CONTEXT)
-                    .subtract(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT))
-                    .divide(BigDecimal.valueOf(2), BigDecimalMath.DEFAULT_CONTEXT);
+                .subtract(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT))
+                .divide(BigDecimal.valueOf(2), BigDecimalMath.DEFAULT_CONTEXT);
         }
     }
 
@@ -182,8 +182,8 @@ public static Number cosh(Number n) {
             return Math.cosh(n.doubleValue());
         } else {
             return BigDecimalMath.exp(bigToBigDecimal(n), BigDecimalMath.DEFAULT_CONTEXT)
-                    .add(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT))
-                    .divide(BigDecimal.valueOf(2), BigDecimalMath.DEFAULT_CONTEXT);
+                .add(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT))
+                .divide(BigDecimal.valueOf(2), BigDecimalMath.DEFAULT_CONTEXT);
         }
     }
 
@@ -192,25 +192,26 @@ public static Number tanh(Number n) {
             return Math.tanh(n.doubleValue());
         } else {
             return BigDecimalMath.exp(bigToBigDecimal(n), BigDecimalMath.DEFAULT_CONTEXT)
-                    .subtract(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT))
-                    .divide(
-                            BigDecimalMath.exp(bigToBigDecimal(n), BigDecimalMath.DEFAULT_CONTEXT)
-                                    .add(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT)),
-                            BigDecimalMath.DEFAULT_CONTEXT
-                    );
+                .subtract(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT))
+                .divide(
+                    BigDecimalMath.exp(bigToBigDecimal(n), BigDecimalMath.DEFAULT_CONTEXT)
+                        .add(BigDecimalMath.exp(bigToBigDecimal(n).negate(), BigDecimalMath.DEFAULT_CONTEXT)),
+                    BigDecimalMath.DEFAULT_CONTEXT
+                );
         }
     }
 
     /**
      * Checks if a given BigInteger is prime. The certainty of this check is always 100%
+     *
      * @param number the number to check
      * @return whether or not this number is a prime
      */
     public static boolean isPrime(BigInteger number) {
         // 1. Check if the number is of the form 6x±1 for values higher than 3.
         if (!number.subtract(BigInteger.ONE).mod(BigInteger.valueOf(6)).equals(BigInteger.ZERO)
-                && !number.add(BigInteger.ONE).mod(BigInteger.valueOf(6)).equals(BigInteger.ZERO)
-                && number.compareTo(BigInteger.valueOf(3)) > 0)
+            && !number.add(BigInteger.ONE).mod(BigInteger.valueOf(6)).equals(BigInteger.ZERO)
+            && number.compareTo(BigInteger.valueOf(3)) > 0)
             return false;
 
         // 2. Check in the cached primes.
@@ -224,13 +225,13 @@ public static boolean isPrime(BigInteger number) {
             return false;
         }
         BigInteger threshold =
-                number.intValue() - cachedPrimes.get(cachedPrimes.size() - 1) < 10_000
-                        ? BigInteger.ZERO
-                        : number.divide(BigInteger.valueOf(ln(number).intValue()))
-                                .subtract(BigInteger.valueOf(cachedPrimes.size()));
+            number.intValue() - cachedPrimes.get(cachedPrimes.size() - 1) < 10_000
+                ? BigInteger.ZERO
+                : number.divide(BigInteger.valueOf(ln(number).intValue()))
+                .subtract(BigInteger.valueOf(cachedPrimes.size()));
         // We only want to compute a maximum of 100 000 new primes at a time.
         if (number.compareTo(BigInteger.valueOf(10_000_000)) < 0
-                && threshold.compareTo(BigInteger.valueOf(10_000)) < 0) {
+            && threshold.compareTo(BigInteger.valueOf(10_000)) < 0) {
             cachedPrimes.addAll(sieveOfEratosthenes(cachedPrimes.get(cachedPrimes.size() - 1) + 1, number.intValue()));
             return cachedPrimes.contains(number.intValue());
         }
@@ -243,7 +244,7 @@ public static boolean isPrime(BigInteger number) {
             var upper = i.multiply(BigInteger.valueOf(6)).add(BigInteger.ONE);
             // Check if lower or upper is divisor of number
             if (BigInteger.ZERO.equals(number.mod(lower))
-                    || BigInteger.ZERO.equals(number.mod(upper)))
+                || BigInteger.ZERO.equals(number.mod(upper)))
                 return false;
         }
         return true;
@@ -251,7 +252,7 @@ public static boolean isPrime(BigInteger number) {
 
     /**
      * Computes a random number between the two given bounds
-     *
+     * <p>
      * The return type is related to the parameter types in the following way :
      * <ul>
      *     <li>Two bounds of the same type will return a result of the same type</li>
@@ -260,10 +261,11 @@ public static boolean isPrime(BigInteger number) {
      *     <li>If one of the bounds is a {@link BigInteger} and the other is a {@link Long}, the result will be a {@link BigInteger}</li>
      *     <li>Otherwise (i.e one of the bounds is a {@code long} and the other a {@code double}), the result will be a {@code double}</li>
      * </ul>
-     * @param lower the lower bound
-     * @param upper the upper bound
+     *
+     * @param lower     the lower bound
+     * @param upper     the upper bound
      * @param inclusive whether the bounds are exclusive or not (skript-parser defaults to true in its implementation)
-     * @param random the {@link ThreadLocalRandom} instance used
+     * @param random    the {@link ThreadLocalRandom} instance used
      * @return a random {@link Number} between the two given bounds
      */
     public static Number random(Number lower, Number upper, boolean inclusive, ThreadLocalRandom random) {
@@ -279,7 +281,7 @@ public static Number random(Number lower, Number upper, boolean inclusive, Threa
         } else if (lower instanceof BigDecimal || upper instanceof BigDecimal) {
             if (lower instanceof BigDecimal && upper instanceof BigDecimal) {
                 return randomBigDecimal((BigDecimal) lower, (BigDecimal) upper, random);
-            } else  {
+            } else {
                 return randomBigDecimal(BigDecimalMath.getBigDecimal(lower), BigDecimalMath.getBigDecimal(upper), random);
             }
         } else if (lower instanceof BigInteger || upper instanceof BigInteger) {
@@ -328,7 +330,7 @@ public static BigDecimal randomBigDecimal(BigDecimal lower, BigDecimal upper, Th
          * significant digits until after the point where "scaled" loses some precision
          */
         BigDecimal padding = BigDecimal.valueOf(random.nextDouble())
-                                       .scaleByPowerOfTen(-scaled.scale());
+            .scaleByPowerOfTen(-scaled.scale());
         // Finally, we add the padding and make sure the number of decimals is that same as before
         return scaled.add(padding).setScale(rand.scale(), BigDecimalMath.DEFAULT_ROUNDING_MODE); // Finally, we add the padding
     }
@@ -356,6 +358,7 @@ private static Number changeBoundExclusion(Number n, Number other) {
     /**
      * Java program to print all primes smaller than or equal to
      * n using Sieve of Eratosthenes.
+     *
      * @param end the end, exclusive
      * @return the primes up until the end bound
      */
@@ -366,8 +369,9 @@ private static List<Integer> sieveOfEratosthenes(int end) {
     /**
      * Java program to print all primes smaller than or equal to
      * n using Sieve of Eratosthenes.
+     *
      * @param start the start, inclusive
-     * @param end the end, inclusive
+     * @param end   the end, inclusive
      * @return the primes between the two bounds
      * @author Syst3ms
      */
@@ -381,7 +385,7 @@ private static List<Integer> sieveOfEratosthenes(int start, int end) {
 
         // We first disqualify multiples of primes that have been generated before
         if (cachedPrimes != null) {
-            for (int gen : cachedPrimes)  {
+            for (int gen : cachedPrimes) {
                 if (gen * gen > end)
                     break;
 
@@ -416,4 +420,6 @@ private static BigDecimal bigToBigDecimal(Number n) {
     public static ArrayList<Integer> getCachedPrimes() {
         return cachedPrimes;
     }
+
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java
index 5630c1e2..9628fa27 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java
@@ -4,28 +4,29 @@
 
 /**
  * Iterator over the powers of a value x.
- * 
+ *
  * <p>This API allows to efficiently calculate the various powers of x in a taylor series by storing intermediate results.</p>
  * <p>For example x<sup>n</sup> can be calculated using one multiplication by storing the previously calculated x<sup>n-1</sup> and x.</p>
- * 
+ *
  * <p>{@link #getCurrentPower()} will be called first to retrieve the initial value.</p>
- * 
+ * <p>
  * For later iterations {@link #calculateNextPower()} will be called before {@link #getCurrentPower()}.
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public interface PowerIterator {
-	
-	/**
-	 * Returns the current power.
-	 * 
-	 * @return the current power.
-	 */
-	BigDecimal getCurrentPower();
-	
-	/**
-	 * Calculates the next power.
-	 */
-	void calculateNextPower();
-}
\ No newline at end of file
+
+    /**
+     * Returns the current power.
+     *
+     * @return the current power.
+     */
+    BigDecimal getCurrentPower();
+
+    /**
+     * Calculates the next power.
+     */
+    void calculateNextPower();
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerNIterator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerNIterator.java
index 3668c28b..33c24966 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerNIterator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerNIterator.java
@@ -5,32 +5,33 @@
 
 /**
  * {@link PowerIterator} to calculate x<sup>n</sup>.
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class PowerNIterator implements PowerIterator {
 
-	private final BigDecimal x;
-
-	private final MathContext mathContext;
-
-	private BigDecimal powerOfX;
-
-	public PowerNIterator(BigDecimal x, MathContext mathContext) {
-		this.x = x;
-		this.mathContext = mathContext;
-		
-		powerOfX = BigDecimal.ONE;
-	}
-	
-	@Override
-	public BigDecimal getCurrentPower() {
-		return powerOfX;
-	}
-
-	@Override
-	public void calculateNextPower() {
-		powerOfX = powerOfX.multiply(x, mathContext);
-	}
-}
\ No newline at end of file
+    private final BigDecimal x;
+
+    private final MathContext mathContext;
+
+    private BigDecimal powerOfX;
+
+    public PowerNIterator(BigDecimal x, MathContext mathContext) {
+        this.x = x;
+        this.mathContext = mathContext;
+
+        powerOfX = BigDecimal.ONE;
+    }
+
+    @Override
+    public BigDecimal getCurrentPower() {
+        return powerOfX;
+    }
+
+    @Override
+    public void calculateNextPower() {
+        powerOfX = powerOfX.multiply(x, mathContext);
+    }
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNIterator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNIterator.java
index 61f63525..f0a47078 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNIterator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNIterator.java
@@ -5,32 +5,33 @@
 
 /**
  * {@link PowerIterator} to calculate x<sup>2*n</sup>.
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class PowerTwoNIterator implements PowerIterator {
 
-	private final MathContext mathContext;
-
-	private final BigDecimal xPowerTwo;
-
-	private BigDecimal powerOfX;
-
-	public PowerTwoNIterator(BigDecimal x, MathContext mathContext) {
-		this.mathContext = mathContext;
-		
-		xPowerTwo = x.multiply(x, mathContext);
-		powerOfX = BigDecimal.ONE;
-	}
-	
-	@Override
-	public BigDecimal getCurrentPower() {
-		return powerOfX;
-	}
-
-	@Override
-	public void calculateNextPower() {
-		powerOfX = powerOfX.multiply(xPowerTwo, mathContext);
-	}
-}
\ No newline at end of file
+    private final MathContext mathContext;
+
+    private final BigDecimal xPowerTwo;
+
+    private BigDecimal powerOfX;
+
+    public PowerTwoNIterator(BigDecimal x, MathContext mathContext) {
+        this.mathContext = mathContext;
+
+        xPowerTwo = x.multiply(x, mathContext);
+        powerOfX = BigDecimal.ONE;
+    }
+
+    @Override
+    public BigDecimal getCurrentPower() {
+        return powerOfX;
+    }
+
+    @Override
+    public void calculateNextPower() {
+        powerOfX = powerOfX.multiply(xPowerTwo, mathContext);
+    }
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNPlusOneIterator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNPlusOneIterator.java
index 6b7905dd..b9c16a24 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNPlusOneIterator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerTwoNPlusOneIterator.java
@@ -5,32 +5,33 @@
 
 /**
  * {@link PowerIterator} to calculate x<sup>2*n+1</sup>.
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class PowerTwoNPlusOneIterator implements PowerIterator {
 
-	private final MathContext mathContext;
-
-	private final BigDecimal xPowerTwo;
-
-	private BigDecimal powerOfX;
-
-	public PowerTwoNPlusOneIterator(BigDecimal x, MathContext mathContext) {
-		this.mathContext = mathContext;
-		
-		xPowerTwo = x.multiply(x, mathContext);
-		powerOfX = x;
-	}
-	
-	@Override
-	public BigDecimal getCurrentPower() {
-		return powerOfX;
-	}
-
-	@Override
-	public void calculateNextPower() {
-		powerOfX = powerOfX.multiply(xPowerTwo, mathContext);
-	}
-}
\ No newline at end of file
+    private final MathContext mathContext;
+
+    private final BigDecimal xPowerTwo;
+
+    private BigDecimal powerOfX;
+
+    public PowerTwoNPlusOneIterator(BigDecimal x, MathContext mathContext) {
+        this.mathContext = mathContext;
+
+        xPowerTwo = x.multiply(x, mathContext);
+        powerOfX = x;
+    }
+
+    @Override
+    public BigDecimal getCurrentPower() {
+        return powerOfX;
+    }
+
+    @Override
+    public void calculateNextPower() {
+        powerOfX = powerOfX.multiply(xPowerTwo, mathContext);
+    }
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java
index 0b2d6dab..1676fbf9 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java
@@ -10,110 +10,111 @@
 
 /**
  * Utility class to calculate taylor series efficiently until the maximum error (as defined by the precision in the {@link MathContext} is reached.
- * 
- * <p>Stores the factors of the taylor series terms so that future calculations will be faster.</p>
  *
+ * <p>Stores the factors of the taylor series terms so that future calculations will be faster.</p>
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public abstract class SeriesCalculator {
 
-	private final boolean calculateInPairs;
-
-	private final List<BigRational> factors = new ArrayList<>();
-	
-	/**
-	 * Constructs a {@link SeriesCalculator} that calculates single terms.
-	 */
-	protected SeriesCalculator() {
-		this(false);
-	}
-	
-	/**
-	 * Constructs a {@link SeriesCalculator} with control over whether the sum terms are calculated in pairs.
-	 * 
-	 * <p>Calculation of pairs is useful for taylor series where the terms alternate the sign.
-	 * In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.</p>
-	 * 
-	 * @param calculateInPairs <code>true</code> to calculate the terms in pairs, <code>false</code> to calculate single terms
-	 */
-	protected SeriesCalculator(boolean calculateInPairs) {
-		this.calculateInPairs = calculateInPairs;
-	}
-	
-	/**
-	 * Calculates the series for the specified value x and the precision defined in the {@link MathContext}.
-	 * 
-	 * @param x the value x
-	 * @param mathContext the {@link MathContext}
-	 * @return the calculated result
-	 */
-	public BigDecimal calculate(BigDecimal x, MathContext mathContext) {
-		var acceptableError = ONE.movePointLeft(mathContext.getPrecision() + 1);
-
-		var powerIterator = createPowerIterator(x, mathContext);
-
-		var sum = BigDecimal.ZERO;
-		BigDecimal step;
-		var i = 0;
-		do {
-			var factor = getFactor(i);
-			var xToThePower  = powerIterator.getCurrentPower();
-			powerIterator.calculateNextPower();
-			step = factor.getNumerator().multiply(xToThePower, mathContext).divide(factor.getDenominator(), mathContext);
-			i++;
-
-			if (calculateInPairs) {
-				xToThePower  = powerIterator.getCurrentPower();
-				powerIterator.calculateNextPower();
-				factor = getFactor(i);
-				var step2 = factor.getNumerator().multiply(xToThePower, mathContext).divide(factor.getDenominator(), mathContext);
-				step = step.add(step2, mathContext);
-				i++;
-			}
-
-			sum = sum.add(step, mathContext);
-			//System.out.println(sum + " " + step);
-		} while (step.abs().compareTo(acceptableError) > 0);
-		
-		return sum.round(mathContext);
-	}
-	
-	/**
-	 * Creates the {@link PowerIterator} used for this series.
-	 * 
-	 * @param x the value x
-	 * @param mathContext the {@link MathContext}
-	 * @return the {@link PowerIterator}
-	 */
-	protected abstract PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext);
-
-	/**
-	 * Returns the factor of the term with specified index.
-	 * 
-	 * @param index the index (starting with 0)
-	 * @return the factor of the specified term
-	 */
-	protected BigRational getFactor(int index) {
-		while (factors.size() <= index) {
-			var factor = getCurrentFactor();
-			factors.add(factor);
-			calculateNextFactor();
-		}
-		return factors.get(index);
-	}
-
-	/**
-	 * Returns the factor of the highest term already calculated.
-	 * <p>When called for the first time will return the factor of the first term (index 0).</p>
-	 * <p>After this call the method {@link #calculateNextFactor()} will be called to prepare for the next term.</p>
-	 * 
-	 * @return the factor of the highest term
-	 */
-	protected abstract BigRational getCurrentFactor();
-	
-	/**
-	 * Calculates the factor of the next term.
-	 */
-	protected abstract void calculateNextFactor();
+    private final boolean calculateInPairs;
+
+    private final List<BigRational> factors = new ArrayList<>();
+
+    /**
+     * Constructs a {@link SeriesCalculator} that calculates single terms.
+     */
+    protected SeriesCalculator() {
+        this(false);
+    }
+
+    /**
+     * Constructs a {@link SeriesCalculator} with control over whether the sum terms are calculated in pairs.
+     *
+     * <p>Calculation of pairs is useful for taylor series where the terms alternate the sign.
+     * In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.</p>
+     *
+     * @param calculateInPairs <code>true</code> to calculate the terms in pairs, <code>false</code> to calculate single terms
+     */
+    protected SeriesCalculator(boolean calculateInPairs) {
+        this.calculateInPairs = calculateInPairs;
+    }
+
+    /**
+     * Calculates the series for the specified value x and the precision defined in the {@link MathContext}.
+     *
+     * @param x           the value x
+     * @param mathContext the {@link MathContext}
+     * @return the calculated result
+     */
+    public BigDecimal calculate(BigDecimal x, MathContext mathContext) {
+        var acceptableError = ONE.movePointLeft(mathContext.getPrecision() + 1);
+
+        var powerIterator = createPowerIterator(x, mathContext);
+
+        var sum = BigDecimal.ZERO;
+        BigDecimal step;
+        var i = 0;
+        do {
+            var factor = getFactor(i);
+            var xToThePower = powerIterator.getCurrentPower();
+            powerIterator.calculateNextPower();
+            step = factor.getNumerator().multiply(xToThePower, mathContext).divide(factor.getDenominator(), mathContext);
+            i++;
+
+            if (calculateInPairs) {
+                xToThePower = powerIterator.getCurrentPower();
+                powerIterator.calculateNextPower();
+                factor = getFactor(i);
+                var step2 = factor.getNumerator().multiply(xToThePower, mathContext).divide(factor.getDenominator(), mathContext);
+                step = step.add(step2, mathContext);
+                i++;
+            }
+
+            sum = sum.add(step, mathContext);
+            //System.out.println(sum + " " + step);
+        } while (step.abs().compareTo(acceptableError) > 0);
+
+        return sum.round(mathContext);
+    }
+
+    /**
+     * Creates the {@link PowerIterator} used for this series.
+     *
+     * @param x           the value x
+     * @param mathContext the {@link MathContext}
+     * @return the {@link PowerIterator}
+     */
+    protected abstract PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext);
+
+    /**
+     * Returns the factor of the term with specified index.
+     *
+     * @param index the index (starting with 0)
+     * @return the factor of the specified term
+     */
+    protected BigRational getFactor(int index) {
+        while (factors.size() <= index) {
+            var factor = getCurrentFactor();
+            factors.add(factor);
+            calculateNextFactor();
+        }
+        return factors.get(index);
+    }
+
+    /**
+     * Returns the factor of the highest term already calculated.
+     * <p>When called for the first time will return the factor of the first term (index 0).</p>
+     * <p>After this call the method {@link #calculateNextFactor()} will be called to prepare for the next term.</p>
+     *
+     * @return the factor of the highest term
+     */
+    protected abstract BigRational getCurrentFactor();
+
+    /**
+     * Calculates the factor of the next term.
+     */
+    protected abstract void calculateNextFactor();
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/SinCalculator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/SinCalculator.java
index 5720394b..5c8f5b18 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/SinCalculator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/SinCalculator.java
@@ -5,46 +5,47 @@
 
 /**
  * Calculates sinus using the Maclaurin series.
- * 
+ *
  * <p>See <a href="https://de.wikipedia.org/wiki/Taylorreihe">Wikipedia: Taylorreihe</a></p>
- * 
+ *
  * <p>No argument checking or optimizations are done.
  * This implementation is <strong>not</strong> intended to be called directly.</p>
- *
+ * <p>
  * I do not claim ownership of this code, it is the intellectual property of <a href="github.com/eobermuhlner">@obermuhlner</a>.
+ *
  * @author @obermuhlner
  */
 public class SinCalculator extends SeriesCalculator {
 
-	public static final SinCalculator INSTANCE = new SinCalculator();
-	
-	private int n = 0;
-	private boolean negative = false;
-	private BigRational factorial2nPlus1 = BigRational.ONE;
-	
-	private SinCalculator() {
-		super(true);
-	}
-	
-	@Override
-	protected BigRational getCurrentFactor() {
-		var factor = factorial2nPlus1.reciprocal();
-		if (negative) {
-			factor = factor.negate();
-		}
-		return factor;
-	}
-	
-	@Override
-	protected void calculateNextFactor() {
-		n++;
-		factorial2nPlus1 = factorial2nPlus1.multiply(2 * n);
-		factorial2nPlus1 = factorial2nPlus1.multiply(2 * n + 1);
-		negative = !negative;
-	}
-	
-	@Override
-	protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
-		return new PowerTwoNPlusOneIterator(x, mathContext);
-	}
+    public static final SinCalculator INSTANCE = new SinCalculator();
+
+    private int n = 0;
+    private boolean negative = false;
+    private BigRational factorial2nPlus1 = BigRational.ONE;
+
+    private SinCalculator() {
+        super(true);
+    }
+
+    @Override
+    protected BigRational getCurrentFactor() {
+        var factor = factorial2nPlus1.reciprocal();
+        if (negative) {
+            factor = factor.negate();
+        }
+        return factor;
+    }
+
+    @Override
+    protected void calculateNextFactor() {
+        n++;
+        factorial2nPlus1 = factorial2nPlus1.multiply(2 * n);
+        factorial2nPlus1 = factorial2nPlus1.multiply(2 * n + 1);
+        negative = !negative;
+    }
+
+    @Override
+    protected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {
+        return new PowerTwoNPlusOneIterator(x, mathContext);
+    }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/variables/SerializedVariable.java b/src/main/java/io/github/syst3ms/skriptparser/variables/SerializedVariable.java
index c44737ef..9df54ff4 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/variables/SerializedVariable.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/variables/SerializedVariable.java
@@ -3,25 +3,18 @@
 import com.google.gson.JsonElement;
 import org.jetbrains.annotations.Nullable;
 
-public class SerializedVariable {
-
-    /**
-     * The name of the variable.
-     */
-    public final String name;
-
-    /**
-     * The serialized value of the variable.
-     * <p>
-     * A value of {@code null} indicates the variable will be deleted.
-     */
-    @Nullable
-    public final Value value;
+/**
+ * @param name  The name of the variable.
+ * @param value The serialized value of the variable.
+ *              <p>
+ *              A value of {@code null} indicates the variable will be deleted.
+ */
+public record SerializedVariable(String name, @Nullable Value value) {
 
     /**
      * Creates a new serialized variable with the given name and value.
      *
-     * @param name the given name.
+     * @param name  the given name.
      * @param value the given value, or {@code null} to indicate a deletion.
      */
     public SerializedVariable(String name, @Nullable Value value) {
@@ -31,27 +24,19 @@ public SerializedVariable(String name, @Nullable Value value) {
 
     /**
      * A serialized value of a variable.
+     *
+     * @param type The type of this value.
+     * @param data The serialized value data.
      */
-    public static final class Value {
-
-        /**
-         * The type of this value.
-         */
-        public final String type;
-
-        /**
-         * The serialized value data.
-         */
-        public final JsonElement data;
+    public record Value(String type, JsonElement data) {
 
         /**
          * Creates a new serialized value.
+         *
          * @param type the value type.
          * @param data the serialized value data.
          */
-        public Value(String type, JsonElement data) {
-            this.type = type;
-            this.data = data;
+        public Value {
         }
 
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/variables/VariableMap.java b/src/main/java/io/github/syst3ms/skriptparser/variables/VariableMap.java
index 945ae112..b3de1656 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/variables/VariableMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/variables/VariableMap.java
@@ -44,7 +44,7 @@ public Optional<Object> getVariable(String name) {
 
                     // We sort the indexes as best as we can
                     boolean numerical = current.keySet().stream()
-                            .allMatch(val -> val.matches("[1-9][0-9]*"));
+                        .allMatch(val -> val.matches("[1-9][0-9]*"));
                     var treeMap = new TreeMap<>(numerical ? NUMERIC_INDEX_COMPARATOR : Comparator.<String>naturalOrder());
                     treeMap.putAll(current);
 
@@ -66,11 +66,11 @@ public Optional<Object> getVariable(String name) {
     }
 
     /**
-	 * Sets a variable.
-	 *
-	 * @param name  The variable's name. Can be a "list variable::*" (<tt>value</tt> must be <tt>null</tt> in this case)
-	 * @param value The variable's value. Use <tt>null</tt> to delete the variable.
-	 */
+     * Sets a variable.
+     *
+     * @param name  The variable's name. Can be a "list variable::*" (<tt>value</tt> must be <tt>null</tt> in this case)
+     * @param value The variable's value. Use <tt>null</tt> to delete the variable.
+     */
     @SuppressWarnings("unchecked")
     public void setVariable(String name, @Nullable Object value) {
         if (!name.endsWith("*")) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java b/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java
index 1c00568d..bb9b1695 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java
@@ -36,28 +36,26 @@
  */
 public abstract class VariableStorage implements Closeable {
 
-    /**
-     * Whether this variable storage has been {@link #close() closed}.
-     */
-    protected volatile boolean closed;
-
     /**
      * The name of the database used in the configurations.
      */
     protected final String name;
-
+    protected final Gson gson;
+    protected final LinkedBlockingQueue<SerializedVariable> changesQueue = new LinkedBlockingQueue<>(1000);
+    private final SkriptLogger logger;
+    private final long errorInterval = 10;
+    /**
+     * Whether this variable storage has been {@link #close() closed}.
+     */
+    protected volatile boolean closed;
     /**
      * The pattern of the variable name this storage accepts.
      * {@code null} for '{@code .*}' or '{@code .*}'.
      */
     @Nullable
     private Pattern variableNamePattern;
-
-    private final SkriptLogger logger;
-    protected final Gson gson;
     private File file;
-
-    protected final LinkedBlockingQueue<SerializedVariable> changesQueue = new LinkedBlockingQueue<>(1000);
+    private long lastError = Long.MIN_VALUE;
 
     /**
      * Creates a new variable storage with the given name.
@@ -90,12 +88,12 @@ protected VariableStorage(SkriptLogger logger, @NotNull Gson gson, @NotNull Stri
             while (!closed) {
                 try {
                     SerializedVariable variable = changesQueue.take();
-                    SerializedVariable.Value value = variable.value;
+                    SerializedVariable.Value value = variable.value();
 
                     if (value != null) {
-                        save(variable.name, value.type, value.data);
+                        save(variable.name(), value.type(), value.data());
                     } else {
-                        save(variable.name, null, null);
+                        save(variable.name(), null, null);
                     }
                 } catch (InterruptedException ignored) {
                 }
@@ -230,12 +228,12 @@ public final boolean loadConfiguration(ConfigSection section) {
     protected abstract boolean load(ConfigSection section);
 
     protected void loadVariable(String name, SerializedVariable variable) {
-        Value value = variable.value;
+        Value value = variable.value();
         if (value == null) {
             Variables.queueVariableChange(name, null);
             return;
         }
-        loadVariable(name, value.type, value.data);
+        loadVariable(name, value.type(), value.data());
     }
 
     /**
@@ -304,10 +302,10 @@ public <T> SerializedVariable serialize(String name, @Nullable T value) {
             return new SerializedVariable(name, null);
         Type<T> type = (Type<T>) TypeManager.getByClassExact(value.getClass()).orElse(null);
         if (type == null) return null;
-            //throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' cannot be serialized. No type registered.");
+        //throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' cannot be serialized. No type registered.");
         TypeSerializer<T> serializer = type.getSerializer().orElse(null);
         if (serializer == null) return null;
-            //throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' cannot be serialized. No type serializer.");
+        //throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' cannot be serialized. No type serializer.");
         JsonElement element = serializer.serialize(gson, value);
         return new SerializedVariable(name, new Value(type.getBaseName(), element));
     }
@@ -332,9 +330,6 @@ protected Object deserialize(@NotNull String typeName, @NotNull JsonElement valu
         return serializer.deserialize(gson, value);
     }
 
-    private long lastError = Long.MIN_VALUE;
-    private long ERROR_INTERVAL = 10;
-
     /**
      * Saves the given serialized variable.
      *
@@ -342,7 +337,7 @@ protected Object deserialize(@NotNull String typeName, @NotNull JsonElement valu
      */
     final void save(SerializedVariable variable) {
         if (!changesQueue.offer(variable)) {
-            if (lastError < System.currentTimeMillis() - ERROR_INTERVAL * 1000) {
+            if (lastError < System.currentTimeMillis() - errorInterval * 1000) {
                 // Inform console about overload of variable changes
                 System.out.println("Skript cannot save any variables to the database '" + name + "'. " +
                     "The thread will hang to avoid losing variable.");
diff --git a/src/main/java/io/github/syst3ms/skriptparser/variables/Variables.java b/src/main/java/io/github/syst3ms/skriptparser/variables/Variables.java
index c9462d4f..46184665 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/variables/Variables.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/variables/Variables.java
@@ -31,16 +31,18 @@
 @SuppressWarnings("unused")
 public class Variables {
 
+    public static final Pattern REGEX_PATTERN = Pattern.compile("\\{([^{}]|%\\{|}%)+}");
+    public static final String LOCAL_VARIABLE_TOKEN = "_";
+    public static final String LIST_SEPARATOR = "::";
     static final MultiMap<Class<? extends VariableStorage>, String> AVAILABLE_STORAGES = new MultiMap<>();
     static final List<VariableStorage> STORAGES = new ArrayList<>();
-
     private static final Map<TriggerContext, VariableMap> localVariables = new HashMap<>(); // Make trigger-specific
     private static final VariableMap variableMap = new VariableMap();
     private static final ReentrantLock LOCK = new ReentrantLock();
-
-    public static final Pattern REGEX_PATTERN = Pattern.compile("\\{([^{}]|%\\{|}%)+}");
-    public static final String LOCAL_VARIABLE_TOKEN = "_";
-    public static final String LIST_SEPARATOR = "::";
+    /**
+     * Changes to variables that have not yet been performed.
+     */
+    private static final Queue<VariableChange> VARIABLE_CHANGE_QUEUE = new ConcurrentLinkedQueue<>();
 
     @SuppressWarnings("BooleanMethodIsAlwaysInverted")
     public static boolean hasStorages() {
@@ -52,9 +54,9 @@ public static ReentrantLock getLock() {
     }
 
     public static void shutdown() {
-        for (VariableStorage STORAGE : STORAGES) {
+        for (VariableStorage storage : STORAGES) {
             try {
-                STORAGE.close();
+                storage.close();
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
@@ -232,11 +234,6 @@ public static void setVariable(String name, @Nullable Object value, @Nullable Tr
         }
     }
 
-    /**
-     * Changes to variables that have not yet been performed.
-     */
-    private static final Queue<VariableChange> VARIABLE_CHANGE_QUEUE = new ConcurrentLinkedQueue<>();
-
     public static void queueVariableChange(String name, @Nullable Object value) {
         if (!hasStorages())
             return;
@@ -317,19 +314,11 @@ public static void clearLocalVariables(TriggerContext ctx) {
     /**
      * Represents a variable that is to be changed.
      * Key-value pair. Key being the variable name.
+     *
+     * @param name  The variable name of the changed variable.
+     * @param value The value of the variable change.
      */
-    private static class VariableChange {
-
-        /**
-         * The variable name of the changed variable.
-         */
-        public final String name;
-
-        /**
-         * The value of the variable change.
-         */
-        @Nullable
-        public final Object value;
+    private record VariableChange(String name, @Nullable Object value) {
 
         /**
          * Creates a new {@link VariableChange} with the given name and value.
@@ -337,9 +326,7 @@ private static class VariableChange {
          * @param name  the variable name.
          * @param value the new variable value.
          */
-        public VariableChange(String name, @Nullable Object value) {
-            this.name = name;
-            this.value = value;
+        private VariableChange {
         }
 
     }

From 5855bd5a7b430b9482ba8eed044def5a19fdcff5 Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 10:58:07 -0800
Subject: [PATCH 7/9] Test checkstyle fixes

---
 .../syst3ms/skriptparser/TestAddon.java       |   2 +-
 .../skriptparser/TestRegistration.java        |  82 ++++----
 .../skriptparser/file/FileParserTest.java     |  10 +-
 .../parsing/PatternParserTest.java            | 196 +++++++++---------
 .../parsing/SyntaxParserTest.java             | 103 +++++----
 .../skriptparser/parsing/VariablesTest.java   | 100 +++++----
 .../skriptparser/syntax/EffAssert.java        | 146 ++++++-------
 .../syst3ms/skriptparser/syntax/EffDeath.java |  60 +++---
 .../syst3ms/skriptparser/syntax/EvtTest.java  |  78 +++----
 .../syst3ms/skriptparser/syntax/SecBirth.java |  10 +-
 .../skriptparser/syntax/TestContext.java      |   3 +-
 .../skriptparser/syntax/test/SecCategory.java |  18 +-
 12 files changed, 403 insertions(+), 405 deletions(-)

diff --git a/src/test/java/io/github/syst3ms/skriptparser/TestAddon.java b/src/test/java/io/github/syst3ms/skriptparser/TestAddon.java
index de44e2a3..62977f2c 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/TestAddon.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/TestAddon.java
@@ -11,7 +11,7 @@
 import java.util.Map;
 
 public class TestAddon extends SkriptAddon {
-    private final Map<String,List<Trigger>> testTriggers = new HashMap<>();
+    private final Map<String, List<Trigger>> testTriggers = new HashMap<>();
 
     public TestAddon(String name) {
         super(name);
diff --git a/src/test/java/io/github/syst3ms/skriptparser/TestRegistration.java b/src/test/java/io/github/syst3ms/skriptparser/TestRegistration.java
index 73c64507..8ec074ea 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/TestRegistration.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/TestRegistration.java
@@ -14,47 +14,47 @@
 
 public class TestRegistration {
 
-	public static void register() {
-		try {
-			Field regField = Parser.class.getDeclaredField("registration");
-			regField.setAccessible(true);
-			String s = new Random().nextInt(10000) + "-addon";
-			regField.set(null, new SkriptRegistration(new TestAddon(s)));
-		} catch (NoSuchFieldException | IllegalAccessException e) {
-			e.printStackTrace();
-		}
-		DefaultRegistration.register();
-		try {
-			FileUtils.loadClasses(
-				Path.of("build/classes/java/main"),
-				"io.github.syst3ms.skriptparser",
-				"effects",
-				"expressions",
-				"lang",
-				"sections",
-				"tags"
-			);
-			FileUtils.loadClasses(
-				Path.of("build/classes/java/test"),
-				"io.github.syst3ms.skriptparser",
-				"syntax"
-			);
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		Parser.getMainRegistration().register();
+    public static void register() {
+        try {
+            Field regField = Parser.class.getDeclaredField("registration");
+            regField.setAccessible(true);
+            String s = new Random().nextInt(10000) + "-addon";
+            regField.set(null, new SkriptRegistration(new TestAddon(s)));
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        DefaultRegistration.register();
+        try {
+            FileUtils.loadClasses(
+                Path.of("build/classes/java/main"),
+                "io.github.syst3ms.skriptparser",
+                "effects",
+                "expressions",
+                "lang",
+                "sections",
+                "tags"
+            );
+            FileUtils.loadClasses(
+                Path.of("build/classes/java/test"),
+                "io.github.syst3ms.skriptparser",
+                "syntax"
+            );
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        Parser.getMainRegistration().register();
 
-		/*
-		 * Now, we need to change some fields to keep all tests consistent.
-		 */
+        /*
+         * Now, we need to change some fields to keep all tests consistent.
+         */
 
-		// defaultTimezone field
-		try {
-			Field timeZone = SkriptDate.class.getDeclaredField("defaultTimeZone");
-			timeZone.setAccessible(true);
-			timeZone.set(null, TimeZone.getTimeZone(ZoneOffset.UTC));
-		} catch (NoSuchFieldException | IllegalAccessException e) {
-			e.printStackTrace();
-		}
-	}
+        // defaultTimezone field
+        try {
+            Field timeZone = SkriptDate.class.getDeclaredField("defaultTimeZone");
+            timeZone.setAccessible(true);
+            timeZone.set(null, TimeZone.getTimeZone(ZoneOffset.UTC));
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java b/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java
index aa1825ae..5a55d4e8 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java
@@ -63,11 +63,11 @@ public void parseFileLines() {
         assertEquals(
             expected,
             parseLines(Arrays.asList(
-                    "nested sections",
-                    "section:",
-                    "\tother section:",
-                    "\t\telement"
-                ))
+                "nested sections",
+                "section:",
+                "\tother section:",
+                "\t\telement"
+            ))
         );
         expected = Arrays.asList(
             simpleFileLine("elements after section", 0, 1),
diff --git a/src/test/java/io/github/syst3ms/skriptparser/parsing/PatternParserTest.java b/src/test/java/io/github/syst3ms/skriptparser/parsing/PatternParserTest.java
index 83ad8fd4..4bc03a4a 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/parsing/PatternParserTest.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/parsing/PatternParserTest.java
@@ -26,7 +26,7 @@ public class PatternParserTest {
     static {
         TestRegistration.register();
     }
-    
+
     private <T> void assertEqualsOptional(T expected, Optional<? extends T> actual) {
         assertTrue(actual.filter(expected::equals).isPresent());
     }
@@ -45,142 +45,142 @@ public void testParsePattern() {
 
         // Nested optionals
         assertEqualsOptional(
-                new OptionalGroup(
-                    new CompoundElement(
-                            new TextElement("nested "),
-                            new OptionalGroup(new TextElement("optional"))
-                    )
-                ),
-                parsePattern("[nested [optional]]", logger)
+            new OptionalGroup(
+                new CompoundElement(
+                    new TextElement("nested "),
+                    new OptionalGroup(new TextElement("optional"))
+                )
+            ),
+            parsePattern("[nested [optional]]", logger)
         );
 
         // Choice groups with parse marks
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("single choice"), null)
-                ),
-                parsePattern("(single choice)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("single choice"), null)
+            ),
+            parsePattern("(single choice)", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("parse mark"), "1")
-                ),
-                parsePattern("(1:parse mark)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("parse mark"), "1")
+            ),
+            parsePattern("(1:parse mark)", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(
-                                new CompoundElement(
-                                        new TextElement("simplified "),
-                                        new OptionalGroup(
-                                                new TextElement("mark")
-                                        )
-                                ),
-                                "simplified"
+            new ChoiceGroup(
+                new ChoiceElement(
+                    new CompoundElement(
+                        new TextElement("simplified "),
+                        new OptionalGroup(
+                            new TextElement("mark")
                         )
-                ),
-                parsePattern("(:simplified [mark])", logger)
+                    ),
+                    "simplified"
+                )
+            ),
+            parsePattern("(:simplified [mark])", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("first choice"), null),
-                        new ChoiceElement(new TextElement("second choice"), null)
-                ),
-                parsePattern("(first choice|second choice)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("first choice"), null),
+                new ChoiceElement(new TextElement("second choice"), null)
+            ),
+            parsePattern("(first choice|second choice)", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("first mark"), null),
-                        new ChoiceElement(new TextElement("second mark"), "1")
-                ),
-                parsePattern("(first mark|1:second mark)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("first mark"), null),
+                new ChoiceElement(new TextElement("second mark"), "1")
+            ),
+            parsePattern("(first mark|1:second mark)", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("first choice "), "first choice"),
-                        new ChoiceElement(new TextElement("second choice"), "second choice")
-                ),
-                parsePattern(":(first choice |second choice)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("first choice "), "first choice"),
+                new ChoiceElement(new TextElement("second choice"), "second choice")
+            ),
+            parsePattern(":(first choice |second choice)", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("first mark"), null),
-                        new ChoiceElement(new TextElement("second mark"), "second mark")
-                ),
-                parsePattern("(first mark|:second mark)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("first mark"), null),
+                new ChoiceElement(new TextElement("second mark"), "second mark")
+            ),
+            parsePattern("(first mark|:second mark)", logger)
         );
         assertEqualsOptional(
-                new ChoiceGroup(
-                        new ChoiceElement(new TextElement("first mark"), null),
-                        new ChoiceElement(new TextElement("second mark"), "second mark"),
-                        new ChoiceElement(new TextElement("third custom mark"), "custom"),
-                        new ChoiceElement(new TextElement("fourth mark"), null)
-                ),
-                parsePattern("(first mark|:second mark|custom:third custom mark|fourth mark)", logger)
+            new ChoiceGroup(
+                new ChoiceElement(new TextElement("first mark"), null),
+                new ChoiceElement(new TextElement("second mark"), "second mark"),
+                new ChoiceElement(new TextElement("third custom mark"), "custom"),
+                new ChoiceElement(new TextElement("fourth mark"), null)
+            ),
+            parsePattern("(first mark|:second mark|custom:third custom mark|fourth mark)", logger)
         );
 
         // Optional choice group (syntax sugar)
         assertEqualsOptional(
-                new OptionalGroup(
-                        new ChoiceGroup(
-                                new ChoiceElement(new TextElement("one"), "one"),
-                                new ChoiceElement(new TextElement(" two"), "two"),
-                                new ChoiceElement(new TextElement("three"), "four")
-                        )
-                ),
-                parsePattern(":[one| two|four:three]", logger)
+            new OptionalGroup(
+                new ChoiceGroup(
+                    new ChoiceElement(new TextElement("one"), "one"),
+                    new ChoiceElement(new TextElement(" two"), "two"),
+                    new ChoiceElement(new TextElement("three"), "four")
+                )
+            ),
+            parsePattern(":[one| two|four:three]", logger)
         );
 
         // Optional with nested group with parse marks
         assertEqualsOptional(
-                new OptionalGroup(
-                        new ChoiceGroup(
-                                new ChoiceElement(
-                                        new CompoundElement(
-                                                new TextElement("optional "),
-                                                new ChoiceGroup(
-                                                        new ChoiceElement(new TextElement("first choice"), null),
-                                                        new ChoiceElement(new TextElement("second choice"), "second")
-                                                )
-                                        ),
-                                        "optional"
-                                )
-                        )
-                ),
-                parsePattern("[:optional (first choice|second:second choice)]", logger)
+            new OptionalGroup(
+                new ChoiceGroup(
+                    new ChoiceElement(
+                        new CompoundElement(
+                            new TextElement("optional "),
+                            new ChoiceGroup(
+                                new ChoiceElement(new TextElement("first choice"), null),
+                                new ChoiceElement(new TextElement("second choice"), "second")
+                            )
+                        ),
+                        "optional"
+                    )
+                )
+            ),
+            parsePattern("[:optional (first choice|second:second choice)]", logger)
         );
 
         // Regex group
         assertEqualsOptional(
-                new RegexGroup(Pattern.compile(".+")),
-                parsePattern("<.+>", logger)
+            new RegexGroup(Pattern.compile(".+")),
+            parsePattern("<.+>", logger)
         );
         assertEqualsOptional(
-                new RegexGroup(Pattern.compile("(\\d*1)st|(\\d*2)nd|(\\d*3)rd|(\\d*[4-90])th")),
-                parsePattern("<(\\d*1)st|(\\d*2)nd|(\\d*3)rd|(\\d*[4-90])th>", logger)
+            new RegexGroup(Pattern.compile("(\\d*1)st|(\\d*2)nd|(\\d*3)rd|(\\d*[4-90])th")),
+            parsePattern("<(\\d*1)st|(\\d*2)nd|(\\d*3)rd|(\\d*[4-90])th>", logger)
         );
 
         // Expression elements
         assertEqualsOptional(
-                new ExpressionElement(
-                        Collections.singletonList(TypeManager.getPatternType("number").orElseThrow(AssertionError::new)),
-                        ExpressionElement.Acceptance.ALL,
-                        false,
-                        false
-                ),
-                parsePattern("%number%", logger)
+            new ExpressionElement(
+                Collections.singletonList(TypeManager.getPatternType("number").orElseThrow(AssertionError::new)),
+                ExpressionElement.Acceptance.ALL,
+                false,
+                false
+            ),
+            parsePattern("%number%", logger)
         );
         assertEqualsOptional(
-                new ExpressionElement(
-                        Arrays.asList(
-                                TypeManager.getPatternType("number").orElseThrow(AssertionError::new),
-                                TypeManager.getPatternType("strings").orElseThrow(AssertionError::new)
-                        ),
-                        ExpressionElement.Acceptance.LITERALS_ONLY,
-                        true,
-                        false
+            new ExpressionElement(
+                Arrays.asList(
+                    TypeManager.getPatternType("number").orElseThrow(AssertionError::new),
+                    TypeManager.getPatternType("strings").orElseThrow(AssertionError::new)
                 ),
-                parsePattern("%*number/strings%", logger)
+                ExpressionElement.Acceptance.LITERALS_ONLY,
+                true,
+                false
+            ),
+            parsePattern("%*number/strings%", logger)
         );
 
         // Failing patterns
@@ -188,4 +188,4 @@ public void testParsePattern() {
         assertOptionalEmpty(parsePattern("%unfinished type", logger));
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/test/java/io/github/syst3ms/skriptparser/parsing/SyntaxParserTest.java b/src/test/java/io/github/syst3ms/skriptparser/parsing/SyntaxParserTest.java
index 37cd7e6c..b8b1c26d 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/parsing/SyntaxParserTest.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/parsing/SyntaxParserTest.java
@@ -25,17 +25,35 @@
 import java.util.concurrent.TimeoutException;
 
 public class SyntaxParserTest {
-    static {
-        TestRegistration.register();
-    }
-
     /**
      * Amount of milliseconds a test can take at most before failing.
      */
     private static final int TEST_TIMEOUT = 10_000;
-
     private static final List<Throwable> errorsFound = new ArrayList<>();
 
+    static {
+        TestRegistration.register();
+    }
+
+    public static void addError(Throwable err) {
+        errorsFound.add(err);
+    }
+
+    public static void removeError(Throwable err) {
+        errorsFound.remove(err);
+    }
+
+    private static File[] getResourceFolderFiles(String folder) {
+        URL url = ClassLoader.getSystemResource(folder);
+        if (url != null) {
+            var path = url.getPath();
+            var files = new File(path).listFiles();
+            if (files != null)
+                return files;
+        }
+        return new File[0];
+    }
+
     @TestFactory
     public Iterator<DynamicNode> syntaxTest() {
         String[] folders = {"effects", "expressions", "literals", "sections", "tags", "general"};
@@ -46,65 +64,46 @@ public Iterator<DynamicNode> syntaxTest() {
                 if (file.getName().startsWith("-"))
                     continue;
                 testsList.add(
-                        DynamicTest.dynamicTest("Testing '" + file.getName().replaceAll("\\..+$", "") + "'", () -> {
-                            var executor = Executors.newSingleThreadExecutor();
-                            Future<List<LogEntry>> future;
+                    DynamicTest.dynamicTest("Testing '" + file.getName().replaceAll("\\..+$", "") + "'", () -> {
+                        var executor = Executors.newSingleThreadExecutor();
+                        Future<List<LogEntry>> future;
 
-                            future = executor.submit(() -> ScriptLoader.loadScript(file.toPath(), true));
-                            List<LogEntry> logs;
-                            try {
-                                logs = future.get(TEST_TIMEOUT, TimeUnit.MILLISECONDS);
-                                logs.removeIf(log -> log.getType() != LogType.ERROR);
+                        future = executor.submit(() -> ScriptLoader.loadScript(file.toPath(), true));
+                        List<LogEntry> logs;
+                        try {
+                            logs = future.get(TEST_TIMEOUT, TimeUnit.MILLISECONDS);
+                            logs.removeIf(log -> log.getType() != LogType.ERROR);
 
-                                if (!logs.isEmpty()) {
-                                    logs.forEach(log -> errorsFound.add(new SkriptParserException(log.getMessage())));
-                                } else {
-                                    SkriptAddon.getAddons().forEach(SkriptAddon::finishedLoading);
-                                }
-                            } catch (TimeoutException ex) {
-                                errorsFound.add(new TimeoutException("Parsing of file '" + file.getName() + "' timed out!"));
-                            } catch (ExecutionException ex) {
-                                errorsFound.add(ex);
+                            if (!logs.isEmpty()) {
+                                logs.forEach(log -> errorsFound.add(new SkriptParserException(log.getMessage())));
+                            } else {
+                                SkriptAddon.getAddons().forEach(SkriptAddon::finishedLoading);
                             }
+                        } catch (TimeoutException ex) {
+                            errorsFound.add(new TimeoutException("Parsing of file '" + file.getName() + "' timed out!"));
+                        } catch (ExecutionException ex) {
+                            errorsFound.add(ex);
+                        }
 
-                            // For some weird reason some errors are duplicated
-                            var allErrors = new ArrayList<>(errorsFound);
-                            Set<String> duplicateErrors = new HashSet<>();
-                            allErrors.removeIf(val -> !duplicateErrors.add(val.getMessage()));
+                        // For some weird reason some errors are duplicated
+                        var allErrors = new ArrayList<>(errorsFound);
+                        Set<String> duplicateErrors = new HashSet<>();
+                        allErrors.removeIf(val -> !duplicateErrors.add(val.getMessage()));
 
-                            // Reset variables
-                            Variables.clearVariables();
-                            errorsFound.clear();
+                        // Reset variables
+                        Variables.clearVariables();
+                        errorsFound.clear();
 
-                            MultipleFailureException.assertEmpty(allErrors);
-                        })
+                        MultipleFailureException.assertEmpty(allErrors);
+                    })
                 );
             }
 
             containerList.add(DynamicContainer.dynamicContainer(
-                    folder,
-                    testsList
+                folder,
+                testsList
             ));
         }
         return containerList.iterator();
     }
-
-    public static void addError(Throwable err) {
-        errorsFound.add(err);
-    }
-
-    public static void removeError(Throwable err) {
-        errorsFound.remove(err);
-    }
-
-    private static File[] getResourceFolderFiles(String folder) {
-        URL url = ClassLoader.getSystemResource(folder);
-        if (url != null) {
-            var path = url.getPath();
-            var files = new File(path).listFiles();
-            if (files != null)
-            	return files;
-        }
-        return new File[0];
-    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/parsing/VariablesTest.java b/src/test/java/io/github/syst3ms/skriptparser/parsing/VariablesTest.java
index 180603c5..9480ec07 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/parsing/VariablesTest.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/parsing/VariablesTest.java
@@ -10,8 +10,6 @@
 import io.github.syst3ms.skriptparser.types.TypeManager;
 import org.junit.Test;
 
-import java.math.BigDecimal;
-import java.math.BigInteger;
 import java.util.Optional;
 
 import static io.github.syst3ms.skriptparser.lang.TriggerContext.DUMMY;
@@ -20,57 +18,57 @@
 
 @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
 public class VariablesTest {
-	static {
-		TestRegistration.register();
-	}
+    static {
+        TestRegistration.register();
+    }
 
-	public void assertExpressionEquals(Expression<?> expected, Optional<? extends Expression<?>> actual) {
-		if (actual.filter(expected::equals).isPresent())
-			return;
-		if (actual.isEmpty())
-			fail();
-		assertArrayEquals(expected.getValues(DUMMY), actual.get().getValues(DUMMY));
-	}
+    public void assertExpressionEquals(Expression<?> expected, Optional<? extends Expression<?>> actual) {
+        if (actual.filter(expected::equals).isPresent())
+            return;
+        if (actual.isEmpty())
+            fail();
+        assertArrayEquals(expected.getValues(DUMMY), actual.get().getValues(DUMMY));
+    }
 
-	private void assertExpressionTypeEquals(Class<?> expected, Optional<? extends Expression<?>> expr) {
-		if (expr.isEmpty())
-			fail("Null expression");
-		if (expr.get().getReturnType() == expected)
-			return;
-		Optional<?> value = expr.get().getSingle(DUMMY);
-		if (value.isEmpty() || value.get().getClass() != expected)
-			fail("Different return types : expected " + expected + ", got " + value.map(Object::getClass).orElse(null));
-	}
+    private void assertExpressionTypeEquals(Class<?> expected, Optional<? extends Expression<?>> expr) {
+        if (expr.isEmpty())
+            fail("Null expression");
+        if (expr.get().getReturnType() == expected)
+            return;
+        Optional<?> value = expr.get().getSingle(DUMMY);
+        if (value.isEmpty() || value.get().getClass() != expected)
+            fail("Different return types : expected " + expected + ", got " + value.map(Object::getClass).orElse(null));
+    }
 
-	private void run(Optional<? extends Effect> effect) {
-		effect.ifPresent(eff -> Statement.runAll(eff, DUMMY));
-	}
+    private void run(Optional<? extends Effect> effect) {
+        effect.ifPresent(eff -> Statement.runAll(eff, DUMMY));
+    }
 
-	@Test
-	public void testVariables() {
-		SkriptLogger logger = new SkriptLogger();
-		ParserState parserState = new ParserState();
-		run(SyntaxParser.parseEffect("set {variable} to \"test\"", parserState, logger));
-		assertExpressionEquals(
-				new SimpleLiteral<>(String.class, "test"),
-				SyntaxParser.parseExpression("{variable}", new PatternType<>(TypeManager.getByClassExact(String.class).orElseThrow(AssertionError::new), true), parserState, logger)
-		);
-		run(SyntaxParser.parseEffect("delete {variable}", parserState, logger));
-		assertExpressionEquals(
-				new SimpleLiteral<>(Object.class),
-				SyntaxParser.parseExpression("{variable}", SyntaxParser.OBJECT_PATTERN_TYPE, parserState, logger)
-		);
-		// Numbers
-		PatternType<Number> numberType = new PatternType<>(TypeManager.getByClassExact(Number.class).orElseThrow(AssertionError::new), true);
-		run(SyntaxParser.parseEffect("set {number} to 5", parserState, logger));
-		assertExpressionTypeEquals(
-				Number.class,
-				SyntaxParser.parseExpression("{number}", numberType, parserState, logger)
-		);
-		run(SyntaxParser.parseEffect("set {number} to 5.2", parserState, logger));
-		assertExpressionTypeEquals(
-			Number.class,
-				SyntaxParser.parseExpression("{number}", numberType, parserState, logger)
-		);
-	}
+    @Test
+    public void testVariables() {
+        SkriptLogger logger = new SkriptLogger();
+        ParserState parserState = new ParserState();
+        run(SyntaxParser.parseEffect("set {variable} to \"test\"", parserState, logger));
+        assertExpressionEquals(
+            new SimpleLiteral<>(String.class, "test"),
+            SyntaxParser.parseExpression("{variable}", new PatternType<>(TypeManager.getByClassExact(String.class).orElseThrow(AssertionError::new), true), parserState, logger)
+        );
+        run(SyntaxParser.parseEffect("delete {variable}", parserState, logger));
+        assertExpressionEquals(
+            new SimpleLiteral<>(Object.class),
+            SyntaxParser.parseExpression("{variable}", SyntaxParser.OBJECT_PATTERN_TYPE, parserState, logger)
+        );
+        // Numbers
+        PatternType<Number> numberType = new PatternType<>(TypeManager.getByClassExact(Number.class).orElseThrow(AssertionError::new), true);
+        run(SyntaxParser.parseEffect("set {number} to 5", parserState, logger));
+        assertExpressionTypeEquals(
+            Number.class,
+            SyntaxParser.parseExpression("{number}", numberType, parserState, logger)
+        );
+        run(SyntaxParser.parseEffect("set {number} to 5.2", parserState, logger));
+        assertExpressionTypeEquals(
+            Number.class,
+            SyntaxParser.parseExpression("{number}", numberType, parserState, logger)
+        );
+    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java
index dc18d5b6..cd2ed945 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java
@@ -14,89 +14,89 @@
  * Assert a condition. When false, this will throw an error.
  * Cannot be used outside of tests.
  *
+ * @author Mwexim
  * @name Assert
  * @pattern assert %=boolean% [with [message] %string%]
  * @since ALPHA
- * @author Mwexim
  */
 public class EffAssert extends Effect {
-	static {
-		Parser.getMainRegistration().addEffect(
-				EffAssert.class,
-				"assert %=boolean% [with [message] %string%]",
-				"(0:throws [(error|exception)]|1:compiles) <.+> [with [message] %string%]"
-		);
-	}
+    static {
+        Parser.getMainRegistration().addEffect(
+            EffAssert.class,
+            "assert %=boolean% [with [message] %string%]",
+            "(0:throws [(error|exception)]|1:compiles) <.+> [with [message] %string%]"
+        );
+    }
 
-	private Expression<Boolean> condition;
-	@Nullable
-	private Expression<String> message;
+    private Expression<Boolean> condition;
+    @Nullable
+    private Expression<String> message;
 
-	private String matched;
-	private boolean shouldThrow;
-	private boolean compiled;
+    private String matched;
+    private boolean shouldThrow;
+    private boolean compiled;
 
-	private int pattern;
-	private SkriptLogger logger;
+    private int pattern;
+    private SkriptLogger logger;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		logger = parseContext.getLogger();
-		pattern = matchedPattern;
-		if (pattern == 0) {
-			condition = (Expression<Boolean>) expressions[0];
-			if (expressions.length == 2)
-				message = (Expression<String>) expressions[1];
-		} else {
-			matched = parseContext.getMatches().get(0).group();
-			shouldThrow = parseContext.getNumericMark() == 0;
-			parseContext.getLogger().recurse();
-			compiled = SyntaxParser.parseExpression(matched, SyntaxParser.OBJECTS_PATTERN_TYPE, parseContext.getParserState(), parseContext.getLogger()).isPresent();
-			parseContext.getLogger().callback();
-			if (expressions.length == 1)
-				message = (Expression<String>) expressions[0];
-		}
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        logger = parseContext.getLogger();
+        pattern = matchedPattern;
+        if (pattern == 0) {
+            condition = (Expression<Boolean>) expressions[0];
+            if (expressions.length == 2)
+                message = (Expression<String>) expressions[1];
+        } else {
+            matched = parseContext.getMatches().get(0).group();
+            shouldThrow = parseContext.getNumericMark() == 0;
+            parseContext.getLogger().recurse();
+            compiled = SyntaxParser.parseExpression(matched, SyntaxParser.OBJECTS_PATTERN_TYPE, parseContext.getParserState(), parseContext.getLogger()).isPresent();
+            parseContext.getLogger().callback();
+            if (expressions.length == 1)
+                message = (Expression<String>) expressions[0];
+        }
+        return true;
+    }
 
-	@Override
-	public void execute(TriggerContext ctx) {
-		if (pattern == 0) {
-			condition.getSingle(ctx)
-					.filter(val -> !val.booleanValue())
-					.ifPresent(__ -> SyntaxParserTest.addError(new AssertionError(errorString(ctx))));
-		} else {
-			if (shouldThrow && compiled)
-				SyntaxParserTest.addError(new AssertionError(errorString(ctx)));
-		}
-	}
+    @Override
+    public void execute(TriggerContext ctx) {
+        if (pattern == 0) {
+            condition.getSingle(ctx)
+                .filter(val -> !val.booleanValue())
+                .ifPresent(__ -> SyntaxParserTest.addError(new AssertionError(errorString(ctx))));
+        } else {
+            if (shouldThrow && compiled)
+                SyntaxParserTest.addError(new AssertionError(errorString(ctx)));
+        }
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		var message = this.message != null ? " " + this.message.toString(ctx, debug) : "";
-		if (pattern == 0) {
-			return "assert " + condition.toString(ctx, debug) + message;
-		} else {
-			return shouldThrow ? "throws " + matched + message : "compiles " + matched + message;
-		}
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        var message = this.message != null ? " " + this.message.toString(ctx, debug) : "";
+        if (pattern == 0) {
+            return "assert " + condition.toString(ctx, debug) + message;
+        } else {
+            return shouldThrow ? "throws " + matched + message : "compiles " + matched + message;
+        }
+    }
 
-	private String errorString(TriggerContext ctx) {
-		if (this.message == null) {
-			if (pattern == 0) {
-				return "Assertion failed ('" + condition.toString(ctx, logger.isDebug()) + "', " + logger.getFileName() + ")";
-			} else {
-				if (shouldThrow) {
-					assert compiled;
-					return "Expected a non-parsable expression (" + matched + ", " + logger.getFileName() + ")";
-				} else {
-					assert !compiled;
-					return "Expected a parsable expression (" + matched + ", " + logger.getFileName() + ")";
-				}
-			}
-		} else {
-			return message.getSingle(ctx).map(String::new).orElse("No message provided") + " (" + logger.getFileName() + ")";
-		}
-	}
+    private String errorString(TriggerContext ctx) {
+        if (this.message == null) {
+            if (pattern == 0) {
+                return "Assertion failed ('" + condition.toString(ctx, logger.isDebug()) + "', " + logger.getFileName() + ")";
+            } else {
+                if (shouldThrow) {
+                    assert compiled;
+                    return "Expected a non-parsable expression (" + matched + ", " + logger.getFileName() + ")";
+                } else {
+                    assert !compiled;
+                    return "Expected a parsable expression (" + matched + ", " + logger.getFileName() + ")";
+                }
+            }
+        } else {
+            return message.getSingle(ctx).map(String::new).orElse("No message provided") + " (" + logger.getFileName() + ")";
+        }
+    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/EffDeath.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/EffDeath.java
index 269fb500..90ddf5c3 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/EffDeath.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/EffDeath.java
@@ -10,43 +10,43 @@
 /**
  * Kills a {@link SecBirth} section.
  *
+ * @author Mwexim
  * @name Death
  * @pattern death
  * @since ALPHA
- * @author Mwexim
  */
 public class EffDeath extends Effect {
-	static {
-		Parser.getMainRegistration().addEffect(
-			EffDeath.class,
-			"death"
-		);
-	}
+    static {
+        Parser.getMainRegistration().addEffect(
+            EffDeath.class,
+            "death"
+        );
+    }
 
-	private SecBirth birth;
+    private SecBirth birth;
 
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		var sections = parseContext.getParserState().getCurrentSections();
-		birth = sections.stream()
-				.filter(SecBirth.class::isInstance)
-				.map(SecBirth.class::cast)
-				.findFirst()
-				.orElse(null);
-		if (birth == null) {
-			parseContext.getLogger().error("'death'-statements cannot be used outside of a 'birth'-section", ErrorType.SEMANTIC_ERROR);
-			return false;
-		}
-		return true;
-	}
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        var sections = parseContext.getParserState().getCurrentSections();
+        birth = sections.stream()
+            .filter(SecBirth.class::isInstance)
+            .map(SecBirth.class::cast)
+            .findFirst()
+            .orElse(null);
+        if (birth == null) {
+            parseContext.getLogger().error("'death'-statements cannot be used outside of a 'birth'-section", ErrorType.SEMANTIC_ERROR);
+            return false;
+        }
+        return true;
+    }
 
-	@Override
-	public void execute(TriggerContext ctx) {
-		birth.setDead(true);
-	}
+    @Override
+    public void execute(TriggerContext ctx) {
+        birth.setDead(true);
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "death";
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "death";
+    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/EvtTest.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/EvtTest.java
index 7095051c..eeda1903 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/EvtTest.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/EvtTest.java
@@ -2,8 +2,8 @@
 
 import io.github.syst3ms.skriptparser.Parser;
 import io.github.syst3ms.skriptparser.lang.Expression;
-import io.github.syst3ms.skriptparser.lang.event.SkriptEvent;
 import io.github.syst3ms.skriptparser.lang.TriggerContext;
+import io.github.syst3ms.skriptparser.lang.event.SkriptEvent;
 import io.github.syst3ms.skriptparser.parsing.ParseContext;
 import io.github.syst3ms.skriptparser.registration.context.ContextValue;
 import io.github.syst3ms.skriptparser.registration.context.ContextValue.Usage;
@@ -15,52 +15,52 @@
  * The test event.
  * Cannot be used outside of tests.
  *
+ * @author Mwexim
  * @name Test
  * @type EVENT
  * @pattern test [[only] when %=boolean%]
  * @since ALPHA
- * @author Mwexim
  */
 public class EvtTest extends SkriptEvent {
-	static {
-		Parser.getMainRegistration()
-				.newEvent(EvtTest.class, "*test [[only] when %=boolean%]")
-				.setHandledContexts(SubTestContext.class)
-				.register();
-		Parser.getMainRegistration()
-				.newContextValue(SubTestContext.class, String.class, true, "test", __ -> new String[] {"Hello World!"})
-				.setUsage(Usage.EXPRESSION_OR_ALONE)
-				.register();
-		Parser.getMainRegistration()
-				.newContextValue(SubTestContext.class, String.class, false, "subclass", __ -> new String[] {"Hi", "Bye"})
-				.setExcluded(SubTestContext.class)
-				.register();
-		Parser.getMainRegistration()
-				.newContextValue(TestContext.class, String.class, true, "[some] pattern value", ctx -> new String[] {ctx.patternValue()})
-				.setUsage(Usage.ALONE_ONLY)
-				.setState(ContextValue.State.PAST)
-				.register();
-		Parser.getMainRegistration().addContextType(SubTestContext.class, Duration.class, SubTestContext::oneDay);
-	}
+    static {
+        Parser.getMainRegistration()
+            .newEvent(EvtTest.class, "*test [[only] when %=boolean%]")
+            .setHandledContexts(SubTestContext.class)
+            .register();
+        Parser.getMainRegistration()
+            .newContextValue(SubTestContext.class, String.class, true, "test", __ -> new String[]{"Hello World!"})
+            .setUsage(Usage.EXPRESSION_OR_ALONE)
+            .register();
+        Parser.getMainRegistration()
+            .newContextValue(SubTestContext.class, String.class, false, "subclass", __ -> new String[]{"Hi", "Bye"})
+            .setExcluded(SubTestContext.class)
+            .register();
+        Parser.getMainRegistration()
+            .newContextValue(TestContext.class, String.class, true, "[some] pattern value", ctx -> new String[]{ctx.patternValue()})
+            .setUsage(Usage.ALONE_ONLY)
+            .setState(ContextValue.State.PAST)
+            .register();
+        Parser.getMainRegistration().addContextType(SubTestContext.class, Duration.class, SubTestContext::oneDay);
+    }
 
-	private Expression<Boolean> condition;
+    private Expression<Boolean> condition;
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
-		if (expressions.length == 1)
-			condition = (Expression<Boolean>) expressions[0];
-		return true;
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
+        if (expressions.length == 1)
+            condition = (Expression<Boolean>) expressions[0];
+        return true;
+    }
 
-	@Override
-	public boolean check(TriggerContext ctx) {
-		return ctx instanceof TestContext
-			&& (condition == null || condition.getSingle(ctx).filter(Boolean::booleanValue).isPresent());
-	}
+    @Override
+    public boolean check(TriggerContext ctx) {
+        return ctx instanceof TestContext
+            && (condition == null || condition.getSingle(ctx).filter(Boolean::booleanValue).isPresent());
+    }
 
-	@Override
-	public String toString(TriggerContext ctx, boolean debug) {
-		return "test";
-	}
+    @Override
+    public String toString(TriggerContext ctx, boolean debug) {
+        return "test";
+    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java
index 96422042..aba33ed6 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java
@@ -19,11 +19,11 @@
  * Use this to make sure a script reaches a certain line of code.
  * Cannot be used outside of tests.
  *
+ * @author Mwexim
  * @name Birth
  * @type SECTION
  * @pattern birth [with [message] %string%]
  * @since ALPHA
- * @author Mwexim
  */
 public class SecBirth extends CodeSection {
     static {
@@ -60,9 +60,9 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
         }
         if (!dead) {
             SyntaxParserTest.addError(new SkriptRuntimeException(
-                    message == null
-                            ? "Birth section was not killed afterwards (" + logger.getFileName() + ")"
-                            : message.getSingle(ctx).map(s -> (String) s).orElse(TypeManager.EMPTY_REPRESENTATION) + " (" + logger.getFileName() + ")"
+                message == null
+                    ? "Birth section was not killed afterwards (" + logger.getFileName() + ")"
+                    : message.getSingle(ctx).map(s -> (String) s).orElse(TypeManager.EMPTY_REPRESENTATION) + " (" + logger.getFileName() + ")"
             ));
         }
         dead = false;
@@ -81,4 +81,4 @@ public boolean isDead() {
     public void setDead(boolean dead) {
         this.dead = dead;
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/TestContext.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/TestContext.java
index dd710bda..13f2aac2 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/TestContext.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/TestContext.java
@@ -23,5 +23,6 @@ public Duration oneDay() {
     }
 
     // We want to see if inherited methods are able to register values as well.
-    public static class SubTestContext extends TestContext { /* Nothing */ }
+    public static class SubTestContext extends TestContext { /* Nothing */
+    }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/test/SecCategory.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/test/SecCategory.java
index 081f0356..27b10c6e 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/test/SecCategory.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/test/SecCategory.java
@@ -18,19 +18,19 @@
 public class SecCategory extends CodeSection {
     static {
         Parser.getMainRegistration().addSection(
-                SecCategory.class,
-                "category [test]"
+            SecCategory.class,
+            "category [test]"
         );
     }
 
     private final SectionConfiguration config = new SectionConfiguration.Builder()
-            .addLiteral("number", BigInteger.class)
-            .addList("multiple")
-            .addList("more multiple values")
-            .addKey("unused")
-            .addOptionalKey("optional")
-            .addSection("die")
-            .build();
+        .addLiteral("number", BigInteger.class)
+        .addList("multiple")
+        .addList("more multiple values")
+        .addKey("unused")
+        .addOptionalKey("optional")
+        .addSection("die")
+        .build();
 
     @Override
     public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {

From e05767e53754c0a6848bc2b317486eb35f20e162 Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 12:07:37 -0800
Subject: [PATCH 8/9] Changes: - revert some breaking changes - add description
 to context values

---
 .../skriptparser/effects/EffEscape.java       |  2 +-
 .../expressions/CondExprCompare.java          |  2 +-
 .../expressions/ExecExprListOperators.java    | 10 +-
 .../expressions/ExecExprReplace.java          | 10 +-
 .../skriptparser/expressions/ExprAmount.java  |  2 +-
 .../expressions/ExprContextValue.java         |  2 +-
 .../expressions/ExprDateInformation.java      |  6 +-
 .../expressions/ExprDefaultValue.java         |  4 +-
 .../expressions/ExprDurationSinceUntil.java   |  4 +-
 .../skriptparser/expressions/ExprElement.java |  8 +-
 .../expressions/ExprLoopValue.java            |  8 +-
 .../expressions/ExprStringOccurrence.java     | 10 +-
 .../expressions/ExprSubstring.java            |  6 +-
 .../skriptparser/expressions/ExprTernary.java |  2 +-
 .../syst3ms/skriptparser/file/FileParser.java |  2 +-
 .../skriptparser/lang/CodeSection.java        |  2 +-
 .../syst3ms/skriptparser/lang/Expression.java |  4 +-
 .../syst3ms/skriptparser/lang/Statement.java  |  2 +-
 .../syst3ms/skriptparser/lang/Variable.java   |  2 +-
 .../skriptparser/lang/control/Finishing.java  |  2 +-
 .../skriptparser/lang/event/SkriptEvent.java  |  2 +-
 .../lang/lambda/ArgumentSection.java          |  2 +-
 .../lang/lambda/SectionValue.java             |  2 +-
 .../skriptparser/parsing/ParserState.java     |  6 +-
 .../skriptparser/parsing/SyntaxParser.java    | 22 ++---
 .../pattern/ExpressionElement.java            |  4 +-
 .../skriptparser/pattern/PatternElement.java  |  2 +-
 .../skriptparser/pattern/PatternParser.java   |  6 +-
 .../skriptparser/pattern/TextElement.java     |  2 +-
 .../registration/DefaultRegistration.java     |  2 +-
 .../registration/SkriptRegistration.java      | 13 ++-
 .../registration/context/ContextValue.java    | 30 +++---
 .../skriptparser/sections/SecFilter.java      |  2 +-
 .../skriptparser/sections/SecFlatMap.java     |  2 +-
 .../syst3ms/skriptparser/sections/SecMap.java |  2 +-
 .../skriptparser/sections/SecSwitch.java      |  2 +-
 .../functions/DefaultFunctions.java           |  2 +-
 .../structures/functions/EffFunctionCall.java | 24 ++---
 .../functions/ExprFunctionCall.java           | 16 +--
 .../functions/FunctionParameter.java          | 41 +++++++-
 .../structures/functions/ScriptFunction.java  |  6 +-
 .../structures/functions/StructFunction.java  |  2 +-
 .../skriptparser/types/PatternType.java       | 28 +++++-
 .../types/changers/Arithmetic.java            |  4 +-
 .../types/comparisons/Comparator.java         |  8 +-
 .../types/comparisons/ComparatorInfo.java     |  4 +-
 .../types/comparisons/Comparators.java        |  4 +-
 .../types/comparisons/InverseComparator.java  |  4 +-
 .../types/comparisons/Relation.java           |  8 +-
 .../types/conversions/ChainedConverter.java   |  2 +-
 .../types/conversions/Converters.java         |  4 +-
 .../skriptparser/util/DoubleOptional.java     | 98 +++++++++----------
 .../skriptparser/util/DurationUtils.java      |  2 +-
 .../syst3ms/skriptparser/util/FileUtils.java  |  2 +-
 .../syst3ms/skriptparser/util/Pair.java       | 26 ++---
 .../skriptparser/util/RecentElementList.java  |  2 +-
 .../skriptparser/util/StringUtils.java        |  8 +-
 .../skriptparser/util/math/NumberMath.java    |  2 +-
 .../skriptparser/util/math/PowerIterator.java |  2 +-
 .../util/math/SeriesCalculator.java           |  2 +-
 .../variables/VariableStorage.java            |  2 +-
 61 files changed, 288 insertions(+), 206 deletions(-)

diff --git a/src/main/java/io/github/syst3ms/skriptparser/effects/EffEscape.java b/src/main/java/io/github/syst3ms/skriptparser/effects/EffEscape.java
index b8a9d313..8dd7b33b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/effects/EffEscape.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/effects/EffEscape.java
@@ -63,7 +63,7 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
                 ? ((SelfReferencing) val).getActualNext()
                 : val.getNext());
 
-            // Because otherwise SelfReferencing sections will first reference to themselves
+            // Because otherwise SelfReferencing sections will getFirst reference to themselves
             if (current.filter(val -> val instanceof Finishing).isEmpty())
                 am--;
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java
index cdbfde27..9bf39f86 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/CondExprCompare.java
@@ -133,7 +133,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                 || firstEach && first.isSingle() != second.isSingle()
                 || second.isSingle() != third.isSingle())) {
                 /*
-                 * What is ruled out here is using "each" when "second" and "third" don't match in number or in and/or type.
+                 * What is ruled out here is using "each" when "getSecond" and "third" don't match in number or in and/or type.
                  * Otherwise these are fundamentally the same checks as above but when "third" is present.
                  */
                 logger.error(
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java
index e6a887c0..86404bc0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprListOperators.java
@@ -16,8 +16,8 @@
  * Basic list operators that return the following elements:
  * <ul>
  *      <li>{@code pop}: the last element</li>
- *      <li>{@code shift/poll}: the first element</li>
- *      <li>{@code extract}: a specific (or just the first/last) element</li>
+ *      <li>{@code shift/poll}: the getFirst element</li>
+ *      <li>{@code extract}: a specific (or just the getFirst/last) element</li>
  *      <li>{@code splice}: elements in a certain bound</li>
  * </ul>
  * However, this syntax can also be used as an effect. If this is the case, instead of returning
@@ -32,7 +32,7 @@
  * @author Mwexim
  * @name List Operators
  * @type EFFECT/EXPRESSION
- * @pattern extract [the] (last|first|%integer%(st|nd|rd|th)) element out [of] %objects%
+ * @pattern extract [the] (last|getFirst|%integer%(st|nd|rd|th)) element out [of] %objects%
  * @pattern pop %objects%
  * @pattern (shift | poll) %objects%
  * @pattern splice %objects% (from %integer% to %integer%|starting (at|from) %integer%|up to %integer%) [[with] step %integer%]
@@ -45,14 +45,14 @@ public class ExecExprListOperators extends ExecutableExpression<Object> {
             ExecExprListOperators.class,
             Object.class,
             false,
-            "extract [the] (0:last|1:first|2:%integer%(st|nd|rd|th)) element out [of] %objects%",
+            "extract [the] (0:last|1:getFirst|2:%integer%(st|nd|rd|th)) element out [of] %objects%",
             "pop %objects%",
             "(shift|poll) %objects%",
             "splice %objects% (0:from %integer% to %integer%|1:starting (at|from) %integer%|2:up to %integer%) [[with] step %integer%]"
         );
     }
 
-    // 0 = last, 1 = first, 2 = indexed, 3 = spliced
+    // 0 = last, 1 = getFirst, 2 = indexed, 3 = spliced
     private int type;
     private Expression<Object> list;
     private Expression<Integer> index;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java
index c01b0440..1d7463c0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExecExprReplace.java
@@ -23,8 +23,8 @@
  * @author Mwexim
  * @name Replace
  * @type EFFECT/EXPRESSION
- * @pattern replace [(all|every|[the] first|[the] last)] [regex [pattern[s]]] %strings% in %strings% with %string%
- * @pattern replace [(all|every|[the] first|[the] last)] [regex [pattern[s]]] %strings% with %string% in %strings%
+ * @pattern replace [(all|every|[the] getFirst|[the] last)] [regex [pattern[s]]] %strings% in %strings% with %string%
+ * @pattern replace [(all|every|[the] getFirst|[the] last)] [regex [pattern[s]]] %strings% with %string% in %strings%
  * @see ExprElement
  * @since ALPHA
  */
@@ -32,8 +32,8 @@ public class ExecExprReplace extends ExecutableExpression<String> {
     static {
         // TODO add "new" so we can add docs
         Parser.getMainRegistration().addExecutableExpression(ExecExprReplace.class, String.class, false,
-            "replace [(0:all|0:every|1:[the] first|2:[the] last)] [:regex [pattern[s]]] %strings% in %strings% with %string%",
-            "replace [(0:all|0:every|1:[the] first|2:[the] last)] [:regex [pattern[s]]] %strings% with %string% in %strings%"
+            "replace [(0:all|0:every|1:[the] getFirst|2:[the] last)] [:regex [pattern[s]]] %strings% in %strings% with %string%",
+            "replace [(0:all|0:every|1:[the] getFirst|2:[the] last)] [:regex [pattern[s]]] %strings% with %string% in %strings%"
         );
     }
 
@@ -136,7 +136,7 @@ public String[] getValues(TriggerContext ctx, boolean isEffect) {
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
         return "replace "
-            + new String[]{"all ", "first ", "last "}[type] + toMatch.toString(ctx, debug)
+            + new String[]{"all ", "getFirst ", "last "}[type] + toMatch.toString(ctx, debug)
             + " in " + toReplace.toString(ctx, debug)
             + " with " + replacement.toString(ctx, debug);
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java
index be72184d..3710bd10 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprAmount.java
@@ -13,7 +13,7 @@
 
 /**
  * The amount of elements in a given list.
- * Note that when getting the size of a list variable, it will only return the size of the first layer of elements.
+ * Note that when getting the size of a list variable, it will only return the size of the getFirst layer of elements.
  * If you want to get the whole list size, including nested layers in a variable, use the recursive size instead.
  *
  * @author Olyno, Mwexim
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
index 8151c05f..d20f5d75 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprContextValue.java
@@ -145,7 +145,7 @@ public boolean isSingle() {
 
     @Override
     public Class<? extends T> getReturnType() {
-        return this.info.getReturnType().type().getTypeClass();
+        return this.info.getReturnType().getType().getTypeClass();
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateInformation.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateInformation.java
index d940e435..ff8f362d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateInformation.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDateInformation.java
@@ -19,7 +19,7 @@
  * @author Mwexim
  * @name Date Information
  * @type EXPRESSION
- * @pattern [the] (year[s]|month[s]|day[s] (of|in) year|day[s] (of|in) month|day[s] (of|in) week|hour[s]|minute[s]|second[s]|milli[second][s]) (of|in) %date/time%
+ * @pattern [the] (year[s]|month[s]|day[s] (of|in) year|day[s] (of|in) month|day[s] (of|in) week|hour[s]|minute[s]|getSecond[s]|milli[getSecond][s]) (of|in) %date/time%
  * @pattern [the] (era|month|weekday|day [(of|in) week]) [name] (of|in) [date] %date%
  * @since ALPHA
  */
@@ -32,8 +32,8 @@ public class ExprDateInformation implements Expression<Object> {
         {"day[s] (of|in) week", (Function<LocalDateTime, Number>) val -> val.getDayOfWeek().getValue()},
         {"hour[s]", (Function<LocalDateTime, Number>) LocalDateTime::getHour},
         {"minute[s]", (Function<LocalDateTime, Number>) LocalDateTime::getMinute},
-        {"second[s]", (Function<LocalDateTime, Number>) LocalDateTime::getSecond},
-        {"milli[second][s]", (Function<LocalDateTime, Number>) val -> val.getNano() / 1_000_000}
+        {"getSecond[s]", (Function<LocalDateTime, Number>) LocalDateTime::getSecond},
+        {"milli[getSecond][s]", (Function<LocalDateTime, Number>) val -> val.getNano() / 1_000_000}
     });
 
     private static final PatternInfos<Function<LocalDateTime, String>> STRING_VALUES = new PatternInfos<>(new Object[][]{
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java
index 6a5c3eb9..1b5343ef 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDefaultValue.java
@@ -6,7 +6,7 @@
 import io.github.syst3ms.skriptparser.parsing.ParseContext;
 
 /**
- * A shorthand expression for giving things a default value. If the first thing isn't set, the second thing will be returned.
+ * A shorthand expression for giving things a default value. If the getFirst thing isn't set, the getSecond thing will be returned.
  *
  * @author Olyno
  * @name Default Value
@@ -18,7 +18,7 @@ public class ExprDefaultValue implements Expression<Object> {
         Parser.getMainRegistration().newExpression(ExprDefaultValue.class, Object.class, false,
                 "%objects% (otherwise|?) %objects%")
             .name("Default Value")
-            .description("Returns the first expression if it's set, otherwise the second expression.")
+            .description("Returns the getFirst expression if it's set, otherwise the getSecond expression.")
             .examples("set {_var} to {_otherVarIfSet} otherwise \"world\"",
                 "send {_varIfSet} ? \"ruh roh, no message\"")
             .since("1.0.0");
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDurationSinceUntil.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDurationSinceUntil.java
index 5029b174..641e4e73 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDurationSinceUntil.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprDurationSinceUntil.java
@@ -10,8 +10,8 @@
 
 /**
  * Compares the given date with the current date.
- * Note that the first pattern is to compare with the past
- * and the second one to compare with the future.
+ * Note that the getFirst pattern is to compare with the past
+ * and the getSecond one to compare with the future.
  * Note that the accuracy can be off some milliseconds.
  *
  * @author Mwexim
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java
index 3e323815..591cf455 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprElement.java
@@ -16,8 +16,8 @@
  * @author Mwexim
  * @name Element
  * @type EXPRESSION
- * @pattern ([the] first | [the] last | [a] random | [the] % integer % ( st | nd | rd | th)) element out [of] %objects%
- * @pattern [the] (first|last) %integer% elements out [of] %objects%
+ * @pattern ([the] getFirst | [the] last | [a] random | [the] % integer % ( st | nd | rd | th)) element out [of] %objects%
+ * @pattern [the] (getFirst|last) %integer% elements out [of] %objects%
  * @pattern %integer% random elements out [of] %objects%
  * @pattern %objects%\[%integer%\]
  * @since ALPHA
@@ -27,8 +27,8 @@ public class ExprElement implements Expression<Object> {
 
     static {
         Parser.getMainRegistration().newExpression(ExprElement.class, Object.class, true,
-                "(0:[the] first|1:[the] last|2:[a] random|3:[the] %integer%(st|nd|rd|th)) element [out] of %objects%",
-                "[the] (0:first|1:last) %integer% elements [out] of %objects%",
+                "(0:[the] getFirst|1:[the] last|2:[a] random|3:[the] %integer%(st|nd|rd|th)) element [out] of %objects%",
+                "[the] (0:getFirst|1:last) %integer% elements [out] of %objects%",
                 "%integer% random elements [out] of %objects%",
                 "%objects%\\[%integer%\\]")
             .name("Element")
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java
index 97dd84ea..e030067e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprLoopValue.java
@@ -65,7 +65,7 @@ public boolean preInitialize(Expression<?>[] expressions, int matchedPattern, Pa
             discriminant = Integer.parseInt(m.group(2));
         }
         loopedClass = TypeManager.getPatternType(loopedString)
-            .map(patternType -> patternType.type().getTypeClass())
+            .map(patternType -> patternType.getType().getTypeClass())
             .orElse(null);
         return true;
     }
@@ -75,7 +75,7 @@ public Function<? super List<? extends SecLoop>, Optional<? extends SecLoop>> ge
         return sections -> {
             int j = 1;
             SecLoop loop = null;
-            // The closest section is first, let's reverse this behavior for convenience
+            // The closest section is getFirst, let's reverse this behavior for convenience
             Collections.reverse(sections);
             for (SecLoop l : sections) {
                 Class<?> loopedType = l.getLoopedExpression().getReturnType();
@@ -134,9 +134,9 @@ public Object[] getSectionValues(SecLoop loop, TriggerContext ctx) {
             }
             var current = (Pair<String, Object>) loop.getArguments()[0];
             if (isIndex) {
-                return new String[]{current.first()};
+                return new String[]{current.getFirst()};
             }
-            one[0] = current.second();
+            one[0] = current.getSecond();
             return one;
         }
         Object[] arguments = loop.getArguments();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringOccurrence.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringOccurrence.java
index 09fd54d7..fbc26d21 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringOccurrence.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprStringOccurrence.java
@@ -7,21 +7,21 @@
 import io.github.syst3ms.skriptparser.util.DoubleOptional;
 
 /**
- * The index of the first or last occurrence of a given string in a string.
+ * The index of the getFirst or last occurrence of a given string in a string.
  * Note that indices in Skript start at 1.
  *
  * @author Mwexim
  * @name Occurrence
  * @type EXPRESSION
- * @pattern [the] (first|last) occurrence of %string% in %string%
+ * @pattern [the] (getFirst|last) occurrence of %string% in %string%
  * @since ALPHA
  */
 public class ExprStringOccurrence implements Expression<Number> {
     static {
         Parser.getMainRegistration().newExpression(ExprStringOccurrence.class, Number.class, true,
-                "[the] (0:first|1:last) occurrence of %string% in %string%")
+                "[the] (0:getFirst|1:last) occurrence of %string% in %string%")
             .name("Occurrence")
-            .description("Returns the index of the first or last occurrence of a given string in a string.")
+            .description("Returns the index of the getFirst or last occurrence of a given string in a string.")
             .since("1.0.0")
             .register();
     }
@@ -50,7 +50,7 @@ public Number[] getValues(TriggerContext ctx) {
 
     @Override
     public String toString(TriggerContext ctx, boolean debug) {
-        return (first ? "first" : "last") + " occurrence of " + needle.toString(ctx, debug) + " in " + haystack.toString(ctx, debug);
+        return (first ? "getFirst" : "last") + " occurrence of " + needle.toString(ctx, debug) + " in " + haystack.toString(ctx, debug);
     }
 
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprSubstring.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprSubstring.java
index 9752b2b2..0ea8a615 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprSubstring.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprSubstring.java
@@ -19,8 +19,8 @@ public class ExprSubstring implements Expression<String> {
     static {
         Parser.getMainRegistration().newExpression(ExprSubstring.class, String.class, true,
                 "[the] (part|sub[ ](text|string)) of %string% (between|from) [(ind(ex[es]|ices)|char[acter][s])] %integer% (and|to) [(index|char[acter])] %integer%",
-                "[the] (0:first|1:last) [%integer%] char[acter][s] (of|in) %string%",
-                "[the] %integer% (0:first|1:last) char[acter]s (of|in) %string%")
+                "[the] (0:getFirst|1:last) [%integer%] char[acter][s] (of|in) %string%",
+                "[the] %integer% (0:getFirst|1:last) char[acter]s (of|in) %string%")
             .name("Substring")
             .description("Extracts a part of a string.")
             .since("1.0.0")
@@ -93,7 +93,7 @@ public String toString(TriggerContext ctx, boolean debug) {
             return "substring of " + value.toString(ctx, debug)
                 + " from " + lower.toString(ctx, debug) + " to " + upper.toString(ctx, debug);
         } else {
-            return (first ? "first " : "last ") + (lower != null ? lower.toString(ctx, debug) : "")
+            return (first ? "getFirst " : "last ") + (lower != null ? lower.toString(ctx, debug) : "")
                 + " characters of " + value.toString(ctx, debug);
         }
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprTernary.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprTernary.java
index 7b419eda..d5b8f9cd 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprTernary.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/ExprTernary.java
@@ -20,7 +20,7 @@ public class ExprTernary implements Expression<Object> {
                 "%objects% if %=boolean%[,] (otherwise|else) %objects%",
                 "%=boolean% ? %objects% \\: %objects%")
             .name("Ternary")
-            .description("Returns the first object if the boolean is true, otherwise the second object.")
+            .description("Returns the getFirst object if the boolean is true, otherwise the getSecond object.")
             .since("1.0.0")
             .register();
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java b/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java
index 6e709ba2..b7b585cc 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java
@@ -22,7 +22,7 @@ public class FileParser {
      *
      * @param fileName            the name of the file the lines belong to
      * @param lines               the list of lines to parse
-     * @param expectedIndentation the indentation level the first line is expected to be at
+     * @param expectedIndentation the indentation level the getFirst line is expected to be at
      * @param lastLine            a parameter that keeps track of the line count throughout recursive calls of this method when
      *                            parsing sections
      * @param logger              the logger
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java b/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java
index 94c0807b..dce182ec 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/CodeSection.java
@@ -90,7 +90,7 @@ public final void setItems(List<Statement> items) {
     }
 
     /**
-     * @return the first item of this section, or the item after the section if it's empty, or {@code null} if there is
+     * @return the getFirst item of this section, or the item after the section if it's empty, or {@code null} if there is
      * no item after this section, in the latter case
      */
     public final Optional<? extends Statement> getFirst() {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java
index c043cc86..0a38d9d8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Expression.java
@@ -128,7 +128,7 @@ default boolean isSingle() {
         return SyntaxManager.getExpressionExact(this)
             .orElseThrow(() -> new SkriptParserException("Unregistered expression class: " + getClass().getName()))
             .getReturnType()
-            .single();
+            .isSingle();
     }
 
     /**
@@ -138,7 +138,7 @@ default Class<? extends T> getReturnType() {
         return SyntaxManager.getExpressionExact(this)
             .orElseThrow(() -> new SkriptParserException("Unregistered expression class: " + getClass().getName()))
             .getReturnType()
-            .type()
+            .getType()
             .getTypeClass();
     }
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java
index 3b43a45b..c73e26d3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Statement.java
@@ -26,7 +26,7 @@ public static void setIllegalStateHandler(Consumer<IllegalStateException> consum
      * Runs all code starting at a given point sequentially.
      * Do note this will not clear local variables after running.
      *
-     * @param start   the Statement the method should first run
+     * @param start   the Statement the method should getFirst run
      * @param context the context
      * @return {@code true} if the code ran normally, and {@code false} if any exception occurred
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java b/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java
index 1a4b68fb..b5d0974f 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/Variable.java
@@ -29,7 +29,7 @@
 
 /**
  * A reference to a variable, whose value is only known at runtime. It can be local to the event, meaning it isn't
- * defined outside of the event it was first defined in. It can also be a list of multiple values. It can also be both.
+ * defined outside of the event it was getFirst defined in. It can also be a list of multiple values. It can also be both.
  *
  * @param <T> the common supertype of the possibly multiple values of the variable
  */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java b/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java
index ddce45b4..d9caacba 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/control/Finishing.java
@@ -33,7 +33,7 @@ public interface Finishing {
      *     referenced to be {@linkplain Statement#walk(TriggerContext) walked} on.</li>
      *     <li>This method is <b>completely</b> stopped by any means whatsoever.</li>
      * </ol>
-     * An example of this second occasion is {@link EffContinue} continuing over multiple loops.
+     * An example of this getSecond occasion is {@link EffContinue} continuing over multiple loops.
      * If that effect continues 3 loops in one go, this means that the 2 most inner-loops need to be
      * completely reset, since they have the possibility to be looped over again. EffContinue therefore
      * calls this method on those loops.
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java b/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java
index cb22df74..bc918e4c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java
@@ -55,7 +55,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
      * This is undesirable if we don't want the restriction of having to declare functions before using them. This is especially
      * counter-productive if we're dealing with multiple scripts.
      * <p>
-     * To solve this problem, {@link Trigger triggers} with a higher loading priority number will be loaded first.
+     * To solve this problem, {@link Trigger triggers} with a higher loading priority number will be loaded getFirst.
      *
      * @return the loading priority number. 0 by default
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java
index e7d804c4..0d8e9a53 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/ArgumentSection.java
@@ -16,7 +16,7 @@ public abstract class ArgumentSection extends CodeSection implements Finishing {
 
     /**
      * This function is called from the section containing the code, and returns an Optional describing
-     * the first {@link Statement} that should be run in the consumer.
+     * the getFirst {@link Statement} that should be run in the consumer.
      * <br>
      * By default, returns {@link CodeSection#getFirst()}.
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java
index 8f57485f..6dda7d0d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/lambda/SectionValue.java
@@ -82,7 +82,7 @@ public boolean postInitialize(S section, ParseContext parseContext) {
      * Optional if no matching section was found. This is useful for targeting a specific section out of multiple
      * surrounding ones based on criteria specific to the implementation.
      * <p>
-     * By default, this always picks the first matching function (i.e the innermost one), if there is one.
+     * By default, this always picks the getFirst matching function (i.e the innermost one), if there is one.
      *
      * @return the selector function for this {@code SectionValue}.
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java
index 7c493f97..c07ed632 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/ParserState.java
@@ -45,7 +45,7 @@ public void setCurrentContexts(Set<Class<? extends TriggerContext>> currentConte
     }
 
     /**
-     * @return a list of all enclosing {@linkplain CodeSection}s, with the closest one first
+     * @return a list of all enclosing {@linkplain CodeSection}s, with the closest one getFirst
      */
     public LinkedList<CodeSection> getCurrentSections() {
         return new LinkedList<>(currentSections);
@@ -131,7 +131,7 @@ public void clearSyntaxRestrictions() {
     public boolean forbidsSyntax(Class<? extends SyntaxElement> c) {
         if (isntAllowingSyntax)
             return true;
-        var allowedSyntaxes = restrictions.getLast().first();
+        var allowedSyntaxes = restrictions.getLast().getFirst();
         return !allowedSyntaxes.isEmpty() && !allowedSyntaxes.contains(c);
     }
 
@@ -139,7 +139,7 @@ public boolean forbidsSyntax(Class<? extends SyntaxElement> c) {
      * @return whether the current syntax restrictions also apply to expressions
      */
     public boolean isRestrictingExpressions() {
-        return restrictions.getLast().second();
+        return restrictions.getLast().getSecond();
     }
 
     /**
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
index 160458a0..cd9b4efc 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/SyntaxParser.java
@@ -134,9 +134,9 @@ public static <T> Optional<? extends Expression<? extends T>> parseExpression(St
             return literal;
         }
 
-        var variable = (Optional<? extends Variable<? extends T>>) Variables.parseVariable(s, expectedType.type().getTypeClass(), parserState, logger);
+        var variable = (Optional<? extends Variable<? extends T>>) Variables.parseVariable(s, expectedType.getType().getTypeClass(), parserState, logger);
         if (variable.isPresent()) {
-            if (variable.filter(v -> !v.isSingle() && expectedType.single()).isPresent()) {
+            if (variable.filter(v -> !v.isSingle() && expectedType.isSingle()).isPresent()) {
                 logger.error(
                         "A single value was expected, but " +
                                 s +
@@ -154,7 +154,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseExpression(St
         if (s.toLowerCase().startsWith("list ")) {
             s = s.substring("list ".length());
         } else {
-            // We parse boolean operators first to prevent clutter while parsing.
+            // We parse boolean operators getFirst to prevent clutter while parsing.
             var booleanOperator = matchExpressionInfo(s, EXPRESSION_BOOLEAN_OPERATORS, expectedType, parserState, logger);
             if (booleanOperator.isPresent()) {
                 recentExpressions.acknowledge(EXPRESSION_BOOLEAN_OPERATORS);
@@ -162,7 +162,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseExpression(St
                 return booleanOperator;
             }
         }
-        if (!expectedType.single()) {
+        if (!expectedType.isSingle()) {
             var listLiteral = parseListLiteral(s, expectedType, parserState, logger);
             if (listLiteral.isPresent()) {
                 logger.clearErrors();
@@ -229,7 +229,7 @@ public static Optional<? extends Expression<Boolean>> parseBooleanExpression(Str
             }
         }
         for (var info : recentExpressions.mergeWith(SyntaxManager.getAllExpressions())) {
-            if (info.getReturnType().type().getTypeClass() != Boolean.class)
+            if (info.getReturnType().getType().getTypeClass() != Boolean.class)
                 continue;
             var expr = (Optional<? extends Expression<Boolean>>) matchExpressionInfo(s, info, BOOLEAN_PATTERN_TYPE, parserState, logger);
             if (expr.isPresent()) {
@@ -275,8 +275,8 @@ public static Optional<? extends Expression<Boolean>> parseBooleanExpression(Str
     private static <T> Optional<? extends Expression<? extends T>> matchExpressionInfo(String s, ExpressionInfo<?, ?> info, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
         var patterns = info.getPatterns();
         var infoType = info.getReturnType();
-        var infoTypeClass = infoType.type().getTypeClass();
-        var expectedTypeClass = expectedType.type().getTypeClass();
+        var infoTypeClass = infoType.getType().getTypeClass();
+        var expectedTypeClass = expectedType.getType().getTypeClass();
         if (!expectedTypeClass.isAssignableFrom(infoTypeClass) && !Converters.converterExists(infoTypeClass, expectedTypeClass))
             return Optional.empty();
         for (var i = 0; i < patterns.size(); i++) {
@@ -313,7 +313,7 @@ private static <T> Optional<? extends Expression<? extends T>> matchExpressionIn
                         }
                     }
                     if (!expression.isSingle() &&
-                            expectedType.single()) {
+                            expectedType.isSingle()) {
                         logger.error(
                                 "A single value was expected, but '" + s + "' represents multiple values.",
                                 ErrorType.SEMANTIC_ERROR,
@@ -352,7 +352,7 @@ private static <T> Optional<? extends Expression<? extends T>> matchExpressionIn
      * or for another reason detailed in an error message.
      */
     public static <T> Optional<? extends Expression<? extends T>> parseListLiteral(String s, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
-        assert !expectedType.single();
+        assert !expectedType.isSingle();
         if (!s.contains(",") && !s.contains("and") && !s.contains("nor") && !s.contains("or"))
             return Optional.empty();
         List<String> parts = new ArrayList<>();
@@ -458,7 +458,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseListLiteral(S
     public static <T> Optional<? extends Expression<? extends T>> parseLiteral(String s, PatternType<T> expectedType, ParserState parserState, SkriptLogger logger) {
         var classToTypeMap = TypeManager.getClassToTypeMap();
         for (var c : classToTypeMap.keySet()) {
-            Class<? extends T> expectedClass = expectedType.type().getTypeClass();
+            Class<? extends T> expectedClass = expectedType.getType().getTypeClass();
             if (expectedClass.isAssignableFrom(c) || Converters.converterExists(c, expectedClass)) {
                 Optional<? extends Function<String, ?>> literalParser = classToTypeMap.get(c).getLiteralParser();
                 if (literalParser.isPresent()) {
@@ -466,7 +466,7 @@ public static <T> Optional<? extends Expression<? extends T>> parseLiteral(Strin
                     if (literal.isPresent() && expectedClass.isAssignableFrom(c)) {
                         return Optional.of(new SimpleLiteral<>((Class<T>) literal.get().getClass(), literal.get()));
                     } else if (literal.isPresent()) {
-                        return new SimpleLiteral<>((Class<T>) c, literal.get()).convertExpression(expectedType.type().getTypeClass());
+                        return new SimpleLiteral<>((Class<T>) c, literal.get()).convertExpression(expectedType.getType().getTypeClass());
                     }
                 } else if (expectedClass == String.class || c == String.class) {
                     var vs = VariableString.newInstanceWithQuotes(s, parserState, logger)
diff --git a/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java b/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java
index 8eaf2613..636163c0 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/pattern/ExpressionElement.java
@@ -224,13 +224,13 @@ private <T> Optional<? extends Expression<? extends T>> parse(String s, PatternT
             });
             /*
              * If multiple types are possible, and a variable is matched, it will have the type
-             * of the first option, but all options should be supported.
+             * of the getFirst option, but all options should be supported.
              * We manually change the return type of the variable awaiting a major overhaul.
              * TODO create a better type system for this that supports union types
              */
             expression.ifPresent(e -> {
                 if (e instanceof Variable && types.length > 1) {
-                    var typeClasses = Arrays.stream(types).map(val -> val.type().getTypeClass()).toArray(Class[]::new);
+                    var typeClasses = Arrays.stream(types).map(val -> val.getType().getTypeClass()).toArray(Class[]::new);
                     ((Variable<?>) e).setReturnType(ClassUtils.getCommonSuperclass(typeClasses));
                 }
             });
diff --git a/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternElement.java b/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternElement.java
index b1a38177..1da32d37 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternElement.java
@@ -44,7 +44,7 @@ static List<String> getKeywords(PatternElement element) {
     }
 
     static List<PatternElement> getPossibleInputs(List<PatternElement> elements) {
-        List<PatternElement> optionalPossibilities = new ArrayList<>(); // We generally want to get the non-optional ones out of the way first
+        List<PatternElement> optionalPossibilities = new ArrayList<>(); // We generally want to get the non-optional ones out of the way getFirst
         List<PatternElement> possibilities = new ArrayList<>();
         for (var element : elements) {
             if (element instanceof TextElement || element instanceof RegexGroup) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java b/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java
index dd6d8504..4a915ba9 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/pattern/PatternParser.java
@@ -95,8 +95,8 @@ private static Optional<? extends PatternElement> parsePattern(String pattern, S
                     optionalGroup = parsePattern(matcher.group(3), logger)
                             .map(el -> {
                                 if (el instanceof ChoiceGroup && mark.isEmpty())
-                                    // Patterns like '[:(first|second)]' act differently than in the original Skript.
-                                    // Developers probably want to write ':[first|second]' instead, but the two actually
+                                    // Patterns like '[:(getFirst|getSecond)]' act differently than in the original Skript.
+                                    // Developers probably want to write ':[getFirst|getSecond]' instead, but the two actually
                                     // have different behavior.
                                     logger.warn(
                                             "The parse mark in the '"
@@ -240,7 +240,7 @@ private static Optional<? extends PatternElement> parsePattern(String pattern, S
                         patternTypes.add(t.get());
                     }
                     var acceptConditional = m.group(3) != null;
-                    if (acceptConditional && patternTypes.stream().noneMatch(t -> t.type().getTypeClass() == Boolean.class)) {
+                    if (acceptConditional && patternTypes.stream().noneMatch(t -> t.getType().getTypeClass() == Boolean.class)) {
                         logger.error("Can't use the '=' flag on non-boolean types (index " + initialPos + ")", ErrorType.SEMANTIC_ERROR);
                         return Optional.empty();
                     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/pattern/TextElement.java b/src/main/java/io/github/syst3ms/skriptparser/pattern/TextElement.java
index aa6a06cf..740f29dd 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/pattern/TextElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/pattern/TextElement.java
@@ -33,7 +33,7 @@ public int match(String s, int index, MatchContext context) {
         }
         var end = 0;
         var stripped = text.strip();
-        // We advance until we reach the first non-whitespace character in s
+        // We advance until we reach the getFirst non-whitespace character in s
         if (index + start + stripped.length() > s.length()) {
             return -1;
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java b/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java
index 3693e9c3..d96ab567 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/DefaultRegistration.java
@@ -290,7 +290,7 @@ public Boolean deserialize(Gson gson, JsonElement jsonElement) {
             .register();
 
         registration.newType(FunctionParameter.class, "functionparameter", "functionparameter@s")
-            .toStringFunction(parameter -> parameter.name() + ": " + parameter.type().getName())
+            .toStringFunction(parameter -> parameter.getName() + ": " + parameter.getType().getName())
             .noDoc()
             .register();
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
index 49bc9faa..09951b88 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java
@@ -1270,6 +1270,7 @@ public class ContextValueRegistrar<C extends TriggerContext, T> implements Regis
         private BiConsumer<C, T[]> listSetterFunction;
         private State state = State.PRESENT;
         private Usage usage = Usage.EXPRESSION_ONLY;
+        private String description;
 
         @SuppressWarnings("unchecked")
         private Class<? extends C>[] excluded = new Class[0];
@@ -1309,6 +1310,11 @@ public final ContextValueRegistrar<C, T> addListSetter(BiConsumer<C, T[]> setter
             return this;
         }
 
+        public final ContextValueRegistrar<C, T> description(String description) {
+            this.description = description;
+            return this;
+        }
+
         @Override
         public void register() {
             var pattern = PatternParser.parsePattern(this.pattern, logger);
@@ -1324,11 +1330,14 @@ public void register() {
             // Register the context value
             if (this.isSingle) {
                 assert singleFunction != null;
-                contextValues.add(ContextValue.createSingle(context, type.get(), pattern.get(), singleFunction, singleSetterFunction, state, usage, excluded));
+                contextValues.add(ContextValue.createSingle(context, type.get(), pattern.get(),
+                    singleFunction, singleSetterFunction, state, usage, description, excluded));
             } else {
                 assert listFunction != null;
-                contextValues.add(ContextValue.createList(context, type.get(), pattern.get(), listFunction, listSetterFunction, state, usage, excluded));
+                contextValues.add(ContextValue.createList(context, type.get(), pattern.get(),
+                    listFunction, listSetterFunction, state, usage, description, excluded));
             }
         }
     }
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValue.java b/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValue.java
index 6371a124..69142d22 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValue.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/context/ContextValue.java
@@ -24,18 +24,10 @@ public class ContextValue<C extends TriggerContext, T> {
     private final BiConsumer<C, T[]> listSetterFunction;
     private final State state;
     private final Usage usage;
+    private final @Nullable String description;
 
     private final Class<? extends C>[] excluded;
 
-//	@SuppressWarnings("unchecked")
-//	public ContextValue(Class<C> context,
-//						Type<T> returnType, boolean isSingle,
-//						PatternElement pattern,
-//						Function<C, T[]> function,
-//						State state, Usage usage) {
-//		this(context, returnType, isSingle, pattern, function, state, usage, new Class[0]);
-//	}
-
     public ContextValue(Class<C> context,
                         Type<T> returnType, boolean isSingle,
                         PatternElement pattern,
@@ -44,6 +36,7 @@ public ContextValue(Class<C> context,
                         @Nullable BiConsumer<C, T> singleSetterFunction,
                         @Nullable BiConsumer<C, T[]> listSetterFunction,
                         State state, Usage usage,
+                        @Nullable String description,
                         Class<? extends C>[] excluded) {
         this.context = context;
         this.returnType = new PatternType<>(returnType, isSingle);
@@ -55,6 +48,7 @@ public ContextValue(Class<C> context,
         this.listSetterFunction = listSetterFunction;
         this.state = state;
         this.usage = usage;
+        this.description = description;
         this.excluded = excluded;
     }
 
@@ -66,8 +60,10 @@ public static <C extends TriggerContext, T> ContextValue<C, T> createSingle(
         BiConsumer<C, T> singleSetterFunction,
         State state,
         Usage usage,
+        @Nullable String description,
         Class<? extends C>[] excluded) {
-        return new ContextValue<>(context, returnType, true, pattern, singleFunction, null, singleSetterFunction, null, state, usage, excluded);
+        return new ContextValue<>(context, returnType, true, pattern, singleFunction, null,
+            singleSetterFunction, null, state, usage, description, excluded);
     }
 
     public static <C extends TriggerContext, T> ContextValue<C, T> createList(
@@ -78,8 +74,10 @@ public static <C extends TriggerContext, T> ContextValue<C, T> createList(
         BiConsumer<C, T[]> listSetterFunction,
         State state,
         Usage usage,
+        @Nullable String description,
         Class<? extends C>[] excluded) {
-        return new ContextValue<>(context, returnType, false, pattern, null, listFunction, null, listSetterFunction, state, usage, excluded);
+        return new ContextValue<>(context, returnType, false, pattern, null, listFunction,
+            null, listSetterFunction, state, usage, description, excluded);
     }
 
     public Class<C> getContext() {
@@ -148,6 +146,15 @@ public Usage getUsage() {
         return usage;
     }
 
+    /**
+     * Get the description of this context value.
+     *
+     * @return Description of this context value or null if none is provided
+     */
+    public @Nullable String getDescription() {
+        return this.description;
+    }
+
     /**
      * Some subclasses don't want to inherit the context values of their parents.
      * The returned array contains all the subclasses that should be excluded when parsing
@@ -203,4 +210,5 @@ public boolean isCorrect(boolean alone) {
             return alone && this != EXPRESSION_ONLY || !alone && this != ALONE_ONLY;
         }
     }
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java
index c299b8ab..e9519ea2 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFilter.java
@@ -86,7 +86,7 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
 
         if (iterator.hasNext()) {
             setArguments(isVariable
-                ? ((Pair<String, Object>) iterator.next()).second()
+                ? ((Pair<String, Object>) iterator.next()).getSecond()
                 : iterator.next()
             );
             return start();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java
index b767008d..84c1962b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecFlatMap.java
@@ -88,7 +88,7 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
 
         if (iterator.hasNext()) {
             setArguments(isVariable
-                ? ((Pair<String, Object>) iterator.next()).second()
+                ? ((Pair<String, Object>) iterator.next()).getSecond()
                 : iterator.next()
             );
             return start();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java
index f98b14a7..9ccd526b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecMap.java
@@ -89,7 +89,7 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
 
         if (iterator.hasNext()) {
             setArguments(isVariable
-                ? ((Pair<String, Object>) iterator.next()).second()
+                ? ((Pair<String, Object>) iterator.next()).getSecond()
                 : iterator.next()
             );
             return start();
diff --git a/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java b/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java
index 7f787c36..0a7b8802 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/sections/SecSwitch.java
@@ -59,7 +59,7 @@ public class SecSwitch extends CodeSection implements Finishing {
         Parser.getMainRegistration().newSection(SecSwitch.class,
                 "(switch|given|match) %object%")
             .name("Switch")
-            .description("This section will run the code of the first matching case.")
+            .description("This section will run the code of the getFirst matching case.")
             .examples("on entity damage:",
                 "\tswitch npc type of context-victim:",
                 "\t\tcase sheep:",
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java
index 761e6ca3..44bb315a 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java
@@ -20,7 +20,7 @@ public Number[] executeSimple(Object[][] params) {
                 }
             })
             .name("Mod")
-            .description("Returns the remainder of the division of the first number by the second one.")
+            .description("Returns the remainder of the division of the getFirst number by the getSecond one.")
             .examples("set {_remainder} to mod(10, 3)",
                 "if mod({_var}, 2) = 0:")
             .since("1.0.0")
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
index 3e7be300..df67a74b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
@@ -37,7 +37,7 @@ protected void execute(TriggerContext ctx) {
         Object[][] params = new Object[paramsExprs.length][];
         for (int i = 0; i < paramsExprs.length; i++) {
             params[i] = paramsExprs[i].getValues(ctx);
-            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].type());
+            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].getType());
             if (converted.isEmpty()) {
                 params[i] = new Object[0];
             } else {
@@ -71,7 +71,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             }
             if (parsedExpr instanceof ExpressionList<?> expressionList) {
                 paramsExprs = expressionList.getExpressions();
-                if (!(functionParameters.length == 1 && !functionParameters[0].single())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
+                if (!(functionParameters.length == 1 && !functionParameters[0].isSingle())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
                     if (paramsExprs.length != functionParameters.length) {
                         logger.error("This function requires " + functionParameters.length + " parameters, but "
                             + paramsExprs.length + " were given.", ErrorType.SEMANTIC_ERROR);
@@ -80,16 +80,16 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                     for (int i = 0; i < functionParameters.length; i++) {
                         FunctionParameter<?> functionParameter = functionParameters[i];
                         Expression<?> providedParamExpr = paramsExprs[i];
-                        if (functionParameter.single() && !providedParamExpr.isSingle()) {
-                            logger.error("The '" + functionParameter.name() + "' parameter accepts a single " +
+                        if (functionParameter.isSingle() && !providedParamExpr.isSingle()) {
+                            logger.error("The '" + functionParameter.getName() + "' parameter accepts a single " +
                                 "value, but was given more.", ErrorType.SEMANTIC_ERROR);
                             return false;
                         }
                         // if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())) { // no converter check
-                        if (!functionParameter.type().isAssignableFrom(providedParamExpr.getReturnType())
-                            && !Converters.converterExists(functionParameter.type(), providedParamExpr.getReturnType())) {
-                            String typeText = TypeManager.getByClass(functionParameter.type()).get().withIndefiniteArticle(false);
-                            logger.error("The type of the provided value for the '" + functionParameter.name()
+                        if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())
+                            && !Converters.converterExists(functionParameter.getType(), providedParamExpr.getReturnType())) {
+                            String typeText = TypeManager.getByClass(functionParameter.getType()).get().withIndefiniteArticle(false);
+                            logger.error("The type of the provided value for the '" + functionParameter.getName()
                                 + "' parameter is not " + typeText + "/couldn't be converted to "
                                 + typeText, ErrorType.SEMANTIC_ERROR);
                             return false;
@@ -97,10 +97,10 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                     }
                 } else {
                     FunctionParameter<?> functionParameter = functionParameters[0];
-                    Class<?> paramType = functionParameter.type();
+                    Class<?> paramType = functionParameter.getType();
                     if (!paramType.isAssignableFrom(this.parsedExpr.getReturnType())) {
                         String typeText = TypeManager.getByClass(paramType).get().withIndefiniteArticle(false);
-                        logger.error("The type of the provided value for the '" + functionParameter.name()
+                        logger.error("The type of the provided value for the '" + functionParameter.getName()
                             + "' parameter is not " + typeText + "/couldn't be converted to "
                             + typeText, ErrorType.SEMANTIC_ERROR);
                         return false;
@@ -109,10 +109,10 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                 }
             } else {
                 FunctionParameter<?> functionParameter = functionParameters[0];
-                Class<?> paramType = functionParameter.type();
+                Class<?> paramType = functionParameter.getType();
                 if (!paramType.isAssignableFrom(this.parsedExpr.getReturnType())) {
                     String typeText = TypeManager.getByClass(paramType).get().withIndefiniteArticle(false);
-                    logger.error("The type of the provided value for the '" + functionParameter.name()
+                    logger.error("The type of the provided value for the '" + functionParameter.getName()
                         + "' parameter is not " + typeText + "/couldn't be converted to "
                         + typeText, ErrorType.SEMANTIC_ERROR);
                     return false;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
index 856cc130..ca91f92b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
@@ -38,7 +38,7 @@ public Object[] getValues(TriggerContext ctx) {
         Object[][] params = new Object[paramsExprs.length][];
         for (int i = 0; i < paramsExprs.length; i++) {
             params[i] = paramsExprs[i].getValues(ctx);
-            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].type());
+            Optional<? extends Object[]> converted = Converters.convertArray(params[i], function.getParameters()[i].getType());
             if (converted.isEmpty()) {
                 params[i] = new Object[0];
             } else {
@@ -73,7 +73,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             }
             if (parsedExpr instanceof ExpressionList<?> expressionList) {
                 paramsExprs = expressionList.getExpressions();
-                if (!(functionParameters.length == 1 && !functionParameters[0].single())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
+                if (!(functionParameters.length == 1 && !functionParameters[0].isSingle())) { // allows for function f(ints: ints) | f(1, 2, 3, 4)
                     if (paramsExprs.length != functionParameters.length) {
                         logger.error("This function requires " + functionParameters.length + " parameters, but "
                             + paramsExprs.length + " were given.", ErrorType.SEMANTIC_ERROR);
@@ -82,16 +82,16 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
                     for (int i = 0; i < functionParameters.length; i++) {
                         FunctionParameter<?> functionParameter = functionParameters[i];
                         Expression<?> providedParamExpr = paramsExprs[i];
-                        if (functionParameter.single() && !providedParamExpr.isSingle()) {
-                            logger.error("The '" + functionParameter.name() + "' parameter accepts a single " +
+                        if (functionParameter.isSingle() && !providedParamExpr.isSingle()) {
+                            logger.error("The '" + functionParameter.getName() + "' parameter accepts a single " +
                                 "value, but was given more.", ErrorType.SEMANTIC_ERROR);
                             return false;
                         }
                         // if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())) { // no converter check
-                        if (!functionParameter.type().isAssignableFrom(providedParamExpr.getReturnType())
-                            && !Converters.converterExists(functionParameter.type(), providedParamExpr.getReturnType())) {
-                            String typeText = TypeManager.getByClass(functionParameter.type()).get().withIndefiniteArticle(false);
-                            logger.error("The type of the provided value for the '" + functionParameter.name()
+                        if (!functionParameter.getType().isAssignableFrom(providedParamExpr.getReturnType())
+                            && !Converters.converterExists(functionParameter.getType(), providedParamExpr.getReturnType())) {
+                            String typeText = TypeManager.getByClass(functionParameter.getType()).get().withIndefiniteArticle(false);
+                            logger.error("The type of the provided value for the '" + functionParameter.getName()
                                 + "' parameter is not " + typeText + "/couldn't be converted to "
                                 + typeText, ErrorType.SEMANTIC_ERROR);
                             return false;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java
index 439558fe..22f02559 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/FunctionParameter.java
@@ -1,6 +1,17 @@
 package io.github.syst3ms.skriptparser.structures.functions;
 
-public record FunctionParameter<T>(String name, Class<? extends T> type, boolean single) {
+import java.util.Objects;
+
+public final class FunctionParameter<T> {
+    private final String name;
+    private final Class<? extends T> type;
+    private final boolean single;
+
+    public FunctionParameter(String name, Class<? extends T> type, boolean single) {
+        this.name = name;
+        this.type = type;
+        this.single = single;
+    }
 
     public FunctionParameter(String name, Class<? extends T> type) {
         this(name, type, true);
@@ -15,4 +26,32 @@ public String toString() {
             '}';
     }
 
+    public String getName() {
+        return name;
+    }
+
+    public Class<? extends T> getType() {
+        return type;
+    }
+
+    public boolean isSingle() {
+        return single;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (FunctionParameter) obj;
+        return Objects.equals(this.name, that.name) &&
+            Objects.equals(this.type, that.type) &&
+            this.single == that.single;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, type, single);
+    }
+
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
index b3675ad9..9a054af4 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
@@ -27,11 +27,11 @@ public T[] execute(Object[][] params, TriggerContext ctx) {
             FunctionParameter<?> p = parameters[i];
             Object[] val = params[i];
             //System.out.println(val.getClass());
-            if (p.single() && val.length > 0) {
-                Variables.setVariable(p.name(), val[0], functionContext, true);
+            if (p.isSingle() && val.length > 0) {
+                Variables.setVariable(p.getName(), val[0], functionContext, true);
             } else {
                 for (int j = 0; j < val.length; j++) {
-                    Variables.setVariable(p.name() + "::" + (j + 1), val[j], functionContext, true);
+                    Variables.setVariable(p.getName() + "::" + (j + 1), val[j], functionContext, true);
                 }
             }
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
index 06ef0f76..85767da1 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
@@ -55,7 +55,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             for (FunctionParameter<?> parameter : parameters) {
                 for (FunctionParameter<?> p : parameters) {
                     if (p == parameter) continue;
-                    if (parameter.name().equals(p.name())) {
+                    if (parameter.getName().equals(p.getName())) {
                         logger.error("Functions parameters cannot have the same name.", ErrorType.SEMANTIC_ERROR);
                         return false;
                     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java b/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java
index 0f3a0924..e54d13c8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/PatternType.java
@@ -1,10 +1,22 @@
 package io.github.syst3ms.skriptparser.types;
 
+import java.util.Objects;
+
 /**
  * A type used in a pattern.
  * Groups a {@link Type} and a number (single or plural) together (in contrast to {@link Type})
  */
-public record PatternType<T>(Type<T> type, boolean single) {
+public final class PatternType<T> {
+    private final Type<T> type;
+    private final boolean single;
+
+    /**
+     *
+     */
+    public PatternType(Type<T> type, boolean single) {
+        this.type = type;
+        this.single = single;
+    }
 
     @Override
     public boolean equals(Object obj) {
@@ -22,4 +34,18 @@ public String toString() {
         var forms = type.getPluralForms();
         return forms[single ? 0 : 1];
     }
+
+    public Type<T> getType() {
+        return type;
+    }
+
+    public boolean isSingle() {
+        return single;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(type, single);
+    }
+
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java b/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java
index 1032b1b7..420b3715 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/changers/Arithmetic.java
@@ -3,8 +3,8 @@
 /**
  * An interface describing arithmetic operations between two types
  *
- * @param <A> the first type
- * @param <R> the second type
+ * @param <A> the getFirst type
+ * @param <R> the getSecond type
  */
 public interface Arithmetic<A, R> {
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java
index 1db6147f..19d9dbb3 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparator.java
@@ -5,8 +5,8 @@
 /**
  * An interface for comparing values of two given types
  *
- * @param <T1> the first type
- * @param <T2> the second value
+ * @param <T1> the getFirst type
+ * @param <T2> the getSecond value
  * @see Comparators
  */
 public abstract class Comparator<T1, T2> implements BiFunction<T1, T2, Relation> {
@@ -17,8 +17,8 @@ public Comparator(boolean supportsOrdering) {
     }
 
     /**
-     * @param t1 the first value
-     * @param t2 the second value
+     * @param t1 the getFirst value
+     * @param t2 the getSecond value
      * @return the {@linkplain Relation relation} between the two values
      */
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java
index eee2cb0d..0eb7837e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/ComparatorInfo.java
@@ -3,8 +3,8 @@
 /**
  * A class containing information about a {@link Comparator}
  *
- * @param <T1> the first type
- * @param <T2> the second type
+ * @param <T1> the getFirst type
+ * @param <T2> the getSecond type
  */
 public record ComparatorInfo<T1, T2>(Class<T1> firstClass, Class<T2> secondClass, Comparator<T1, T2> comparator) {
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java
index ca509702..d8479f55 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Comparators.java
@@ -32,8 +32,8 @@ public Relation apply(@Nullable Object o, @Nullable Object o2) {
     /**
      * Registers a {@link Comparator}.
      *
-     * @param t1 class of first type
-     * @param t2 class of second type
+     * @param t1 class of getFirst type
+     * @param t2 class of getSecond type
      * @param c  the comparator
      * @throws IllegalArgumentException if any given class is equal to <code>Object.class</code>
      */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java
index 268d8fed..dd990073 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/InverseComparator.java
@@ -3,8 +3,8 @@
 /**
  * A {@linkplain Comparator} that is the opposite of another one
  *
- * @param <T1> the first type
- * @param <T2> the second type
+ * @param <T1> the getFirst type
+ * @param <T2> the getSecond type
  */
 public class InverseComparator<T1, T2> extends Comparator<T1, T2> {
     private final Comparator<? super T2, ? super T1> comparator;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Relation.java b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Relation.java
index e3c68242..781f044e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Relation.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/comparisons/Relation.java
@@ -13,19 +13,19 @@ public enum Relation {
      */
     NOT_EQUAL(0),
     /**
-     * The first object is greater than the other one
+     * The getFirst object is greater than the other one
      */
     GREATER(1),
     /**
-     * The first object is greater or equal to the other one
+     * The getFirst object is greater or equal to the other one
      */
     GREATER_OR_EQUAL(1),
     /**
-     * The first object is smaller than the other one
+     * The getFirst object is smaller than the other one
      */
     SMALLER(-1),
     /**
-     * The first object is smaller or equal to the other one
+     * The getFirst object is smaller or equal to the other one
      */
     SMALLER_OR_EQUAL(-1);
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java
index 0446b95f..3753cf68 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/ChainedConverter.java
@@ -9,7 +9,7 @@
  * Used to chain converters to build a single converter. This is automatically created when a new converter is added.
  *
  * @param <F> same as Converter's <F> (from)
- * @param <M> the middle type, i.e. the type the first converter converts to and the second converter comverts from.
+ * @param <M> the middle type, i.e. the type the getFirst converter converts to and the getSecond converter comverts from.
  * @param <T> same as Converter's <T> (to)
  * @author Peter Güttinger
  * @see Converters#registerConverter(Class, Class, Function)
diff --git a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java
index 35b8dbdb..8784b2ce 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/types/conversions/Converters.java
@@ -23,11 +23,11 @@ public abstract class Converters {
      */
     public static final int ALL_CHAINING = 0;
     /**
-     * A flag declaring a converter may only be the first part of a {@link ChainedConverter}
+     * A flag declaring a converter may only be the getFirst part of a {@link ChainedConverter}
      */
     public static final int NO_LEFT_CHAINING = 1;
     /**
-     * A flag declaring a converter may only be the second part of a {@link ChainedConverter}
+     * A flag declaring a converter may only be the getSecond part of a {@link ChainedConverter}
      */
     public static final int NO_RIGHT_CHAINING = 2;
     /**
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java b/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java
index d4c4f16f..23cee843 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/DoubleOptional.java
@@ -17,8 +17,8 @@
  * <p>
  * Note that the two values aren't really independent : either both are set, or both are empty.
  *
- * @param <T1> the type of the first value
- * @param <T2> the type of the second value
+ * @param <T1> the type of the getFirst value
+ * @param <T2> the type of the getSecond value
  */
 public class DoubleOptional<T1, T2> {
     /**
@@ -27,12 +27,12 @@ public class DoubleOptional<T1, T2> {
     private static final DoubleOptional<?, ?> EMPTY = new DoubleOptional<>();
 
     /**
-     * If non-null, the first value is present ; if null, it is absent.
+     * If non-null, the getFirst value is present ; if null, it is absent.
      */
     @Nullable
     private final T1 first;
     /**
-     * If non-null, the second value is present ; if null, it is absent.
+     * If non-null, the getSecond value is present ; if null, it is absent.
      */
     @Nullable
     private final T2 second;
@@ -48,8 +48,8 @@ private DoubleOptional() {
     /**
      * Constructs a non-empty instance.
      *
-     * @param first  the first value
-     * @param second the second value
+     * @param first  the getFirst value
+     * @param second the getSecond value
      * @throws NullPointerException if either parameters are {@literal null}.
      */
     private DoubleOptional(T1 first, T2 second) {
@@ -60,8 +60,8 @@ private DoubleOptional(T1 first, T2 second) {
     /**
      * Returns an empty {@code DoubleOptional} instance.
      *
-     * @param <T1> the type of the first non-existent value
-     * @param <T2> the type of the second non-existent value
+     * @param <T1> the type of the getFirst non-existent value
+     * @param <T2> the type of the getSecond non-existent value
      * @return an empty {@code DoubleOptional}
      */
     @SuppressWarnings("unchecked")
@@ -73,12 +73,12 @@ public static <T1, T2> DoubleOptional<T1, T2> empty() {
      * Returns an {@code Optional} describing the given non-{@code null}
      * value.
      *
-     * @param first  the first value to describe, which must be non-{@code null}
-     * @param second the second value to describe, which must be non-{@code null}
-     * @param <T1>   the type of the first value
-     * @param <T2>   the type fo the second value
+     * @param first  the getFirst value to describe, which must be non-{@code null}
+     * @param second the getSecond value to describe, which must be non-{@code null}
+     * @param <T1>   the type of the getFirst value
+     * @param <T2>   the type fo the getSecond value
      * @return a {@code DoubleOptional} with the value present
-     * @throws NullPointerException if either first or second are {@code null}
+     * @throws NullPointerException if either getFirst or getSecond are {@code null}
      */
     public static <T1, T2> DoubleOptional<T1, T2> of(T1 first, T2 second) {
         return new DoubleOptional<>(first, second);
@@ -88,10 +88,10 @@ public static <T1, T2> DoubleOptional<T1, T2> of(T1 first, T2 second) {
      * Returns a {@code DoubleOptional} describing the given values, if
      * both non-{@code null}, otherwise returns an empty {@code DoubleOptional}.
      *
-     * @param first  the first possibly {@code null} value to describe
+     * @param first  the getFirst possibly {@code null} value to describe
      * @param second the secpond possibly {@code null} value to describe
-     * @param <T1>   the type of the first value
-     * @param <T2>   the type of the second value
+     * @param <T1>   the type of the getFirst value
+     * @param <T2>   the type of the getSecond value
      * @return a {@code DoubleOptional} with both values present if the specified values
      * are both non-{@code null}, otherwise an empty {@code DoubleOptional}
      */
@@ -103,10 +103,10 @@ public static <T1, T2> DoubleOptional<T1, T2> ofNullable(@Nullable T1 first, @Nu
      * Returns a {@code DoubleOptional} describing the values represented by two {@link Optional}s if both
      * are present, otherwise returns an empty {@code DoubleOptional}.
      *
-     * @param first  a possibly empty {@link Optional} describing the first value
-     * @param second a possibly empty {@link Optional} describing the second value
-     * @param <T1>   the type of the first value
-     * @param <T2>   the type of the second value
+     * @param first  a possibly empty {@link Optional} describing the getFirst value
+     * @param second a possibly empty {@link Optional} describing the getSecond value
+     * @param <T1>   the type of the getFirst value
+     * @param <T2>   the type of the getSecond value
      * @return a {@code DoubleOptional} describing the two values described by the two {@link Optional}s,
      * if both are present, otherwise an empty {@code DoubleOptional}
      */
@@ -116,27 +116,27 @@ public static <T1, T2> DoubleOptional<T1, T2> ofOptional(Optional<T1> first, Opt
     }
 
     /**
-     * If the first value is present, returns the value, otherwise throws a {@link NoSuchElementException}.
+     * If the getFirst value is present, returns the value, otherwise throws a {@link NoSuchElementException}.
      *
-     * @return the non-null first value of this {@code DoubleOptional}
-     * @throws NoSuchElementException if no first value is present
+     * @return the non-null getFirst value of this {@code DoubleOptional}
+     * @throws NoSuchElementException if no getFirst value is present
      */
     public T1 getFirst() {
         if (first == null) {
-            throw new NoSuchElementException("No first value present");
+            throw new NoSuchElementException("No getFirst value present");
         }
         return first;
     }
 
     /**
-     * If the second value is present, returns the value, otherwise throws a {@link NoSuchElementException}.
+     * If the getSecond value is present, returns the value, otherwise throws a {@link NoSuchElementException}.
      *
-     * @return the non-null second value of this {@code DoubleOptional}
-     * @throws NoSuchElementException if no second value is present
+     * @return the non-null getSecond value of this {@code DoubleOptional}
+     * @throws NoSuchElementException if no getSecond value is present
      */
     public T2 getSecond() {
         if (second == null) {
-            throw new NoSuchElementException("No second value present");
+            throw new NoSuchElementException("No getSecond value present");
         }
         return second;
     }
@@ -171,7 +171,7 @@ public void ifPresent(BiConsumer<? super T1, ? super T2> action) {
     }
 
     /**
-     * If both values are present, does the first action using both values, otherwise does the second action.
+     * If both values are present, does the getFirst action using both values, otherwise does the getSecond action.
      *
      * @param action      the action to be performed if both values are present
      * @param emptyAction the action to be performed if either values are absent
@@ -207,10 +207,10 @@ public DoubleOptional<T1, T2> filter(BiPredicate<? super T1, ? super T2> predica
      * <p>
      * If either mapping function returns {@code null}, the result will be an empty {@code DoubleOptional}.
      *
-     * @param firstMapper  the mapping function to apply to the first value, if present
-     * @param secondMapper the mapping function to apply to the second value, if present
-     * @param <U>          the new type of the first value
-     * @param <V>          the new type of the second value
+     * @param firstMapper  the mapping function to apply to the getFirst value, if present
+     * @param secondMapper the mapping function to apply to the getSecond value, if present
+     * @param <U>          the new type of the getFirst value
+     * @param <V>          the new type of the getSecond value
      * @return a {@code DoubleOptional} describing the result of applying mapping functions
      * to each of the values if present, and an empty {@code DoubleOptional} otherwise.
      */
@@ -251,8 +251,8 @@ public <U> Optional<U> mapToOptional(BiFunction<? super T1, ? super T2, ? extend
      * {@code DoubleOptional}.
      *
      * @param mapper the mapping function taking in both values (if present) and returning a {@code DoubleOptional}
-     * @param <U>    the type of the first value of the new {@code DoubleOptional}
-     * @param <V>    the type of the second value of the new {@code DoubleOptional}
+     * @param <U>    the type of the getFirst value of the new {@code DoubleOptional}
+     * @param <V>    the type of the getSecond value of the new {@code DoubleOptional}
      * @return the result of applying the mapping function to both values if present, and an empty {@code DoubleOptional}
      * otherwise
      * @throws NullPointerException if the mapping function returns {@code null}
@@ -309,10 +309,10 @@ public DoubleOptional<T1, T2> or(Supplier<? extends DoubleOptional<? extends T1,
     }
 
     /**
-     * If the first value is present, returns it, otherwise returns {@code other}.
+     * If the getFirst value is present, returns it, otherwise returns {@code other}.
      *
-     * @param other the value to be returned if the first value is not present (may be {@code null})
-     * @return the first value if present, otherwise {@code other}
+     * @param other the value to be returned if the getFirst value is not present (may be {@code null})
+     * @return the getFirst value if present, otherwise {@code other}
      */
     @Contract("!null -> !null")
     @Nullable
@@ -321,10 +321,10 @@ public T1 firstOrElse(@Nullable T1 other) {
     }
 
     /**
-     * If the second value is present, returns it, otherwise returns {@code other}.
+     * If the getSecond value is present, returns it, otherwise returns {@code other}.
      *
-     * @param other the value to be returned if the second value is not present (may be {@code null})
-     * @return the second value if present, otherwise {@code other}
+     * @param other the value to be returned if the getSecond value is not present (may be {@code null})
+     * @return the getSecond value if present, otherwise {@code other}
      */
     @Contract("!null -> !null")
     @Nullable
@@ -333,13 +333,13 @@ public T2 secondOrElse(@Nullable T2 other) {
     }
 
     /**
-     * If the first value is present, returns it, otherwise throws an exception produced by the given
+     * If the getFirst value is present, returns it, otherwise throws an exception produced by the given
      * exception-supplying function.
      *
-     * @param exceptionSupplier the function producing the exception to be thrown if the first value is not present
+     * @param exceptionSupplier the function producing the exception to be thrown if the getFirst value is not present
      * @param <X>               the type of exception that may be thrown
-     * @return the first value if present
-     * @throws X if the first value is not present
+     * @return the getFirst value if present
+     * @throws X if the getFirst value is not present
      */
     public <X extends Throwable> T1 firstOrElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
         if (first != null) {
@@ -350,13 +350,13 @@ public <X extends Throwable> T1 firstOrElseThrow(Supplier<? extends X> exception
     }
 
     /**
-     * If the second value is present, returns it, otherwise throws an exception produced by the given
+     * If the getSecond value is present, returns it, otherwise throws an exception produced by the given
      * exception-supplying function.
      *
-     * @param exceptionSupplier the function producing the exception to be thrown if the second value is not present
+     * @param exceptionSupplier the function producing the exception to be thrown if the getSecond value is not present
      * @param <X>               the type of exception that may be thrown
-     * @return the second value if present
-     * @throws X if the second value is not present
+     * @return the getSecond value if present
+     * @throws X if the getSecond value is not present
      */
     public <X extends Throwable> T2 secondOrElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
         if (second != null) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java
index 4f679543..8e683728 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/DurationUtils.java
@@ -10,7 +10,7 @@ public class DurationUtils {
      * clean alternative for this.
      */
     private static final String[] unitPatterns = {"years?", "weeks?", "days?", "hours?", "minutes?", "seconds?", "ticks?", "milli(second)?s?"};
-    private static final String[] unitNames = {"year", "week", "day", "hour", "minute", "second", "tick", "millisecond"};
+    private static final String[] unitNames = {"year", "week", "day", "hour", "minute", "getSecond", "tick", "millisecond"};
     /**
      * The amount of milliseconds it takes for a tick to pass.
      * A 'tick' is a predetermined time-unit of 50 milliseconds.
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java
index 621791ac..407a99de 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/FileUtils.java
@@ -28,7 +28,7 @@ public class FileUtils {
      * before a line break to indicate to the parser that it should be considered as a single line. For example :
      * <pre>
      *     set {large_list::*} to "one long string", \
-     *                            "a second long string", \
+     *                            "a getSecond long string", \
      *                            "yet another long string" \
      *                            "an even longer string which would make reading very awkward otherwise", \
      *                            "nearing the end of the list" and \
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java b/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java
index 56a5af46..25cb6433 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/Pair.java
@@ -3,29 +3,29 @@
 /**
  * A simple pair of two values.
  *
- * @param <T> type of the first value
- * @param <U> type of the second value
+ * @param <T> type of the getFirst value
+ * @param <U> type of the getSecond value
  */
-public record Pair<T, U>(T first, U second) {
+public record Pair<T, U>(T getFirst, U getSecond) {
 
     /**
-     * Retrieves the first element
+     * Retrieves the getFirst element
      *
-     * @return the first element
+     * @return the getFirst element
      */
     @Override
-    public T first() {
-        return first;
+    public T getFirst() {
+        return getFirst;
     }
 
     /**
-     * Retrieves the second element
+     * Retrieves the getSecond element
      *
-     * @return the second element
+     * @return the getSecond element
      */
     @Override
-    public U second() {
-        return second;
+    public U getSecond() {
+        return getSecond;
     }
 
     @Override
@@ -35,7 +35,7 @@ public boolean equals(Object o) {
         if (o == null || getClass() != o.getClass())
             return false;
         var pair = (Pair<?, ?>) o;
-        return first.equals(pair.first) &&
-            second.equals(pair.second);
+        return getFirst.equals(pair.getFirst) &&
+            getSecond.equals(pair.getSecond);
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java b/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java
index b7889696..2eeb4066 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/RecentElementList.java
@@ -16,7 +16,7 @@
  * them against a string that's being parsed.
  * <p>
  * To illustrate the behaviour of this class, imagine you use some syntax A 8 times, then use syntax B once. The very
- * next time the parser does the "recent syntaxes" check, it will check syntax A first, because it was used more than syntax B.
+ * next time the parser does the "recent syntaxes" check, it will check syntax A getFirst, because it was used more than syntax B.
  *
  * @param <T> the type of {@link SyntaxInfo}
  */
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java b/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java
index f5cea929..4b04991e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/StringUtils.java
@@ -163,12 +163,12 @@ public static Optional<String> getBracketContent(String s, int start, char closi
     }
 
     /**
-     * Find the first occurrence of a string in another one, ignoring case
+     * Find the getFirst occurrence of a string in another one, ignoring case
      *
      * @param haystack the string to look in
      * @param needle   the string to look for
      * @param start    where to look from
-     * @return the index of the first occurrence
+     * @return the index of the getFirst occurrence
      */
     public static int indexOfIgnoreCase(String haystack, String needle, int start) {
         if (needle.isEmpty() || haystack.isEmpty()) {
@@ -311,7 +311,7 @@ else if (plural)
     }
 
     /**
-     * Capitalizes the first word or all words in a string.
+     * Capitalizes the getFirst word or all words in a string.
      * A word is separated by a space character.
      *
      * @param str the string to change
@@ -401,7 +401,7 @@ else if (Character.isLowerCase(c))
     }
 
     /**
-     * Mirrors the string. This means the last character will be put first and vice versa.
+     * Mirrors the string. This means the last character will be put getFirst and vice versa.
      *
      * @param str the string to change
      * @return the mirrored string
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java
index 648f5162..5c8bd73d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/NumberMath.java
@@ -383,7 +383,7 @@ private static List<Integer> sieveOfEratosthenes(int start, int end) {
         boolean[] isComposite = new boolean[size];
         List<Integer> computedPrimes = new ArrayList<>();
 
-        // We first disqualify multiples of primes that have been generated before
+        // We getFirst disqualify multiples of primes that have been generated before
         if (cachedPrimes != null) {
             for (int gen : cachedPrimes) {
                 if (gen * gen > end)
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java
index 9628fa27..b640e9ce 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/PowerIterator.java
@@ -8,7 +8,7 @@
  * <p>This API allows to efficiently calculate the various powers of x in a taylor series by storing intermediate results.</p>
  * <p>For example x<sup>n</sup> can be calculated using one multiplication by storing the previously calculated x<sup>n-1</sup> and x.</p>
  *
- * <p>{@link #getCurrentPower()} will be called first to retrieve the initial value.</p>
+ * <p>{@link #getCurrentPower()} will be called getFirst to retrieve the initial value.</p>
  * <p>
  * For later iterations {@link #calculateNextPower()} will be called before {@link #getCurrentPower()}.
  * <p>
diff --git a/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java b/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java
index 1676fbf9..6f17446c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/util/math/SeriesCalculator.java
@@ -106,7 +106,7 @@ protected BigRational getFactor(int index) {
 
     /**
      * Returns the factor of the highest term already calculated.
-     * <p>When called for the first time will return the factor of the first term (index 0).</p>
+     * <p>When called for the getFirst time will return the factor of the getFirst term (index 0).</p>
      * <p>After this call the method {@link #calculateNextFactor()} will be called to prepare for the next term.</p>
      *
      * @return the factor of the highest term
diff --git a/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java b/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java
index bb9b1695..3d219c7d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/variables/VariableStorage.java
@@ -252,7 +252,7 @@ protected void loadVariable(String name, @NotNull String type, @NotNull JsonElem
     /**
      * Called after all storages have been loaded, and variables
      * have been redistributed if settings have changed.
-     * This should commit the first transaction.
+     * This should commit the getFirst transaction.
      */
     protected abstract void allLoaded();
 

From 7046cff794b7dbb28c73a581dec4ddd0450f175e Mon Sep 17 00:00:00 2001
From: ShaneBeee <shanebolenback@me.com>
Date: Tue, 10 Feb 2026 13:36:24 -0800
Subject: [PATCH 9/9] SkriptEvent - add an option to unload

---
 .../io/github/syst3ms/skriptparser/lang/TriggerMap.java    | 3 +++
 .../syst3ms/skriptparser/lang/event/SkriptEvent.java       | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java b/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java
index 0001a2e1..c06047eb 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java
@@ -33,6 +33,9 @@ public static void addTrigger(String scriptName, Class<? extends TriggerContext>
      * @param scriptName Script name to clear triggers for
      */
     public static void clearTriggers(String scriptName) {
+        TRIGGERS.getOrDefault(scriptName, Map.of()).values().forEach(triggers -> {
+            triggers.forEach(trigger -> trigger.getEvent().unload());
+        });
         TRIGGERS.remove(scriptName);
         Functions.removeFunctions(scriptName);
     }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java b/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java
index bc918e4c..7f69c30c 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/event/SkriptEvent.java
@@ -89,4 +89,11 @@ public boolean isRestrictingExpressions() {
         return false;
     }
 
+    /**
+     * Called when this event is unloaded.
+     * This is optional to override.
+     */
+    public void unload() {
+    }
+
 }