diff --git a/.github/workflows/archive-docs.yml b/.github/workflows/archive-docs.yml
new file mode 100644
index 00000000000..e183f748d78
--- /dev/null
+++ b/.github/workflows/archive-docs.yml
@@ -0,0 +1,45 @@
+name: Archive documentation
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  archive-docs:
+      if: "! contains(toJSON(github.event.commits.*.message), '[ci skip]')"
+      needs: release-docs
+      runs-on: ubuntu-latest
+      steps:
+          - name: Configure workflow
+            id: configuration
+            run: |
+              echo "BRANCH_NAME=${GITHUB_REF#refs/*/}" >> $GITHUB_OUTPUT
+              echo "DOCS_OUTPUT_DIR=${GITHUB_WORKSPACE}/skript-docs/docs/archives/${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+              echo "DOCS_REPO_DIR=${GITHUB_WORKSPACE}/skript-docs" >> $GITHUB_OUTPUT
+              echo "SKRIPT_REPO_DIR=${GITHUB_WORKSPACE}/skript" >> $GITHUB_OUTPUT
+          - name: Checkout Skript
+            uses: actions/checkout@v4
+            with:
+                submodules: recursive
+                path: skript
+          - name: Setup documentation environment
+            uses: ./skript/.github/workflows/docs/setup-docs
+            with:
+                docs_deploy_key: ${{ secrets.DOCS_DEPLOY_KEY }}
+                docs_output_dir: ${{ steps.configuration.outputs.DOCS_OUTPUT_DIR }}
+          - name: Generate documentation
+            uses: ./skript/.github/workflows/docs/generate-docs
+            with:
+                docs_output_dir: ${{ steps.configuration.outputs.DOCS_OUTPUT_DIR }}
+                docs_repo_dir: ${{ steps.configuration.outputs.DOCS_REPO_DIR }}
+                skript_repo_dir: ${{ steps.configuration.outputs.SKRIPT_REPO_DIR }}
+                is_release: true
+                generate_javadocs: true
+          - name: Push archive documentation
+            uses: ./skript/.github/workflows/docs/push-docs
+            with:
+                docs_repo_dir: ${{ steps.configuration.outputs.DOCS_REPO_DIR }}
+                git_name: Archive Docs Bot
+                git_email: archivedocs@skriptlang.org
+                git_commit_message: "Update ${{ steps.configuration.outputs.BRANCH_NAME }} archive docs"
diff --git a/.github/workflows/docs/generate-docs/action.yml b/.github/workflows/docs/generate-docs/action.yml
index e033996868e..2470f852450 100644
--- a/.github/workflows/docs/generate-docs/action.yml
+++ b/.github/workflows/docs/generate-docs/action.yml
@@ -69,7 +69,7 @@ runs:
                   
         cd $SKRIPT_REPO_DIR
         if [[ "${IS_RELEASE}" == "true" ]]; then
-          ./gradlew genReleaseDocs releaseJavadoc
+          ./gradlew genReleaseDocs javadoc
         elif [[ "${GENERATE_JAVADOCS}" == "true" ]]; then
           ./gradlew genNightlyDocs javadoc
         else
@@ -77,7 +77,7 @@ runs:
         fi
 
         if [ -d "${DOCS_OUTPUT_DIR}" ]; then
-          if [[ "${GENERATE_JAVADOCS}" == "true" ]]; then
+          if [[ "${GENERATE_JAVADOCS}" == "true" ]] || [[ "${IS_RELEASE}" == "true" ]] ; then
               mkdir -p "${SKRIPT_DOCS_OUTPUT_DIR}/javadocs" && cp -a "./build/docs/javadoc/." "$_"
           fi
   
diff --git a/.github/workflows/release-docs.yml b/.github/workflows/release-docs.yml
index f6f7ebc8a27..9cfe198ba93 100644
--- a/.github/workflows/release-docs.yml
+++ b/.github/workflows/release-docs.yml
@@ -3,6 +3,7 @@ name: Release documentation
 on:
   release:
     types: [published]
+  workflow_dispatch:
 
 jobs:
   release-docs:
@@ -33,6 +34,7 @@ jobs:
               docs_repo_dir: ${{ steps.configuration.outputs.DOCS_REPO_DIR }}
               skript_repo_dir: ${{ steps.configuration.outputs.SKRIPT_REPO_DIR }}
               is_release: true
+              generate_javadocs: true
               cleanup_pattern: "!(nightly|archives|templates)"
         - name: Push release documentation
           uses: ./skript/.github/workflows/docs/push-docs
@@ -41,40 +43,3 @@ jobs:
               git_name: Release Docs Bot
               git_email: releasedocs@skriptlang.org
               git_commit_message: "Update release docs to ${{ steps.configuration.outputs.BRANCH_NAME }}"
-
-  archive-docs:
-      if: "! contains(toJSON(github.event.commits.*.message), '[ci skip]')"
-      needs: release-docs
-      runs-on: ubuntu-latest
-      steps:
-          - name: Configure workflow
-            id: configuration
-            run: |
-              echo "BRANCH_NAME=${GITHUB_REF#refs/*/}" >> $GITHUB_OUTPUT
-              echo "DOCS_OUTPUT_DIR=${GITHUB_WORKSPACE}/skript-docs/docs/archives/${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-              echo "DOCS_REPO_DIR=${GITHUB_WORKSPACE}/skript-docs" >> $GITHUB_OUTPUT
-              echo "SKRIPT_REPO_DIR=${GITHUB_WORKSPACE}/skript" >> $GITHUB_OUTPUT
-          - name: Checkout Skript
-            uses: actions/checkout@v4
-            with:
-                submodules: recursive
-                path: skript
-          - name: Setup documentation environment
-            uses: ./skript/.github/workflows/docs/setup-docs
-            with:
-                docs_deploy_key: ${{ secrets.DOCS_DEPLOY_KEY }}
-                docs_output_dir: ${{ steps.configuration.outputs.DOCS_OUTPUT_DIR }}
-          - name: Generate documentation
-            uses: ./skript/.github/workflows/docs/generate-docs
-            with:
-                docs_repo_dir: ${{ steps.configuration.outputs.DOCS_REPO_DIR }}
-                docs_output_dir: ${{ steps.configuration.outputs.DOCS_OUTPUT_DIR }}
-                skript_repo_dir: ${{ steps.configuration.outputs.SKRIPT_REPO_DIR }}
-                is_release: true
-          - name: Push archive documentation
-            uses: ./skript/.github/workflows/docs/push-docs
-            with:
-                docs_repo_dir: ${{ steps.configuration.outputs.DOCS_REPO_DIR }}
-                git_name: Archive Docs Bot
-                git_email: archivedocs@skriptlang.org
-                git_commit_message: "Update ${{ steps.configuration.outputs.BRANCH_NAME }} archive docs"
diff --git a/build.gradle b/build.gradle
index fcd904d9863..161d3dd3daf 100644
--- a/build.gradle
+++ b/build.gradle
@@ -5,7 +5,6 @@ import java.time.LocalTime
 
 plugins {
 	id 'com.github.johnrengelman.shadow' version '8.1.1'
-	id 'com.github.hierynomus.license' version '0.16.1'
 	id 'maven-publish'
 	id 'java'
 }
@@ -55,7 +54,7 @@ task checkAliases {
 }
 
 task testJar(type: ShadowJar) {
-	dependsOn(compileTestJava, licenseTest)
+	dependsOn(compileTestJava)
 	archiveFileName = 'Skript-JUnit.jar'
 	from sourceSets.test.output, sourceSets.main.output, project.configurations.testShadow
 }
@@ -141,24 +140,6 @@ publishing {
 	}
 }
 
-license {
-	header file('licenseheader.txt')
-	exclude('**/Metrics.java') // Not under GPLv3
-	exclude('**/BurgerHelper.java') // Not exclusively GPLv3
-	exclude('**/*.sk') // Sample scripts and maybe aliases
-	exclude('**/*.lang') // Language files do not have headers (still under GPLv3)
-	exclude('**/*.json') // JSON files do not have headers
-}
-
-task releaseJavadoc(type: Javadoc) {
-	title = project.name + ' ' + project.property('version')
-	source = sourceSets.main.allJava
-	classpath = configurations.compileClasspath
-	options.encoding = 'UTF-8'
-	// currently our javadoc has a lot of errors, so we need to suppress the linter
-	options.addStringOption('Xdoclint:none', '-quiet')
-}
-
 // Task to check that test scripts are named correctly
 tasks.register('testNaming') {
 	doLast {
@@ -198,13 +179,12 @@ void createTestTask(String name, String desc, String environments, int javaVersi
 	if (junit) {
 		artifact += 'Skript-JUnit.jar'
 	} else if (releaseDocs) {
-		artifact += 'Skript-github.jar'
+		artifact += 'Skript-' + version + '.jar'
 	} else {
 		artifact += 'Skript-nightly.jar'
 	}
 	tasks.register(name, JavaExec) {
 		description = desc
-		dependsOn licenseTest
 		if (junit) {
 			dependsOn testJar
 		} else if (releaseDocs) {
@@ -307,7 +287,7 @@ task githubResources(type: ProcessResources) {
 		include '**'
 		version = project.property('version')
 		def channel = 'stable'
-		if (version.contains('pre'))
+		if (version.contains('-'))
 			channel = 'prerelease'
 		filter ReplaceTokens, tokens: [
 			'version'         : version,
@@ -340,7 +320,7 @@ task spigotResources(type: ProcessResources) {
 		include '**'
 		version = project.property('version')
 		def channel = 'stable'
-		if (version.contains('pre'))
+		if (version.contains('-'))
 			channel = 'prerelease'
 		filter ReplaceTokens, tokens: [
 			'version'         : version,
@@ -378,7 +358,7 @@ task nightlyResources(type: ProcessResources) {
 			'today'           : '' + LocalTime.now(),
 			'release-flavor'  : 'skriptlang-nightly', // SkriptLang build, automatically done by CI
 			'release-channel' : 'prerelease', // No update checking, but these are VERY unstable
-			'release-updater' : 'ch.njol.skript.update.NoUpdateChecker', // No autoupdates for now
+			'release-updater' : 'ch.njol.skript.update.NoUpdateChecker', // No auto updates for now
 			'release-source'  : '',
 			'release-download': 'null'
 		]
@@ -388,7 +368,7 @@ task nightlyResources(type: ProcessResources) {
 
 task nightlyRelease(type: ShadowJar) {
 	from sourceSets.main.output
-	dependsOn nightlyResources, licenseMain
+	dependsOn nightlyResources
 	archiveFileName = 'Skript-nightly.jar'
 	manifest {
 		attributes(
@@ -400,8 +380,8 @@ task nightlyRelease(type: ShadowJar) {
 }
 
 javadoc {
-	dependsOn nightlyResources
-
+	mustRunAfter(tasks.withType(ProcessResources))
+	title = 'Skript ' + project.property('version')
 	source = sourceSets.main.allJava
 
 	exclude("ch/njol/skript/conditions/**")
@@ -420,4 +400,3 @@ javadoc {
 	// currently our javadoc has a lot of errors, so we need to suppress the linter
 	options.addStringOption('Xdoclint:none', '-quiet')
 }
-
diff --git a/code-conventions.md b/code-conventions.md
index f571429ddb7..25c6d5c4417 100644
--- a/code-conventions.md
+++ b/code-conventions.md
@@ -66,6 +66,9 @@ With the exception of contacting our own resources (e.g. to check for updates) c
 Code contributed must be licensed under GPLv3, by **you**.
 We expect that any code you contribute is either owned by you or you have explicit permission to provide and license it to us.
 
+Licenses do not need to be printed in individual files (or packages) unless the licence applying to the code in
+that file (or package) deviates from the licence scope of its containing package.
+
 Third party code (under a compatible licence) _may_ be accepted in the following cases:
  - It is part of a public, freely-available library or resource.
  - It is somehow necessary to your contribution, and you have been given permission to include it.
@@ -75,34 +78,61 @@ If we receive complaints regarding the licensing of a contribution we will forwa
 
 If you have questions or complaints regarding the licensing or reproduction of a contribution you may contact us (the organisation) or the contributor of that code directly.
 
-If, in the future, we need to relicense contributed code, we will contact all contributors involved.
+If, in the future, we need to re-license contributed code, we will contact all contributors involved.
 If we need to remove or alter contributed code due to a licensing issue we will attempt to notify its contributor.
 
 
 ## Code Style
 
 ### Formatting
+* Imports should be grouped together by type (e.g. all `java.lang...` imports together)
+  * Following the style of existing imports in a class is encouraged, but not required
+  * Wildcard `*` imports are permitted (as long as they do not interfere with existing imports), e.g. `java.lang.*`.
 * Tabs, no spaces (unless in code imported from other projects)
-** No tabs/spaces in empty lines
+	- No tabs/spaces in empty lines
 * No trailing whitespace
 * At most 120 characters per line
-  - In Javadoc/multiline comments, at most 80 characters per line
-* When statements consume multiple lines, all lines but first have two tabs of additional indentation
+  	- In Javadoc/multiline comments, at most 80 characters per line
+* When statements consume multiple lines, all lines but the first have two tabs of additional indentation
+	- The exception to this is breaking up conditional statements (e.g. `if (x || y)`) where the
+    condition starts may be aligned
 * Each class begins with an empty line
 * No squeezing of multiple lines of code on a single line
 * Separate method declarations with empty lines
-  - Empty line after last method in a class is *not* required
-  - Otherwise, empty line before and after method is a good rule of thumb
+  	- Empty line after last method in a class is *not* required
+  	- Otherwise, empty line before and after method is a good rule of thumb
 * If fields have Javadoc, separate them with empty lines
 * Use empty lines liberally inside methods to improve readability
 * Use curly brackets to start and end most blocks
-  - Only when a conditional block (if or else) contains a single statement, they may be omitted
-  - When omitting brackets, still indent as if the code had brackets
-  - Avoid omitting brackets if it produces hard-to-read code
+  	- When a block contains a single statement, they may be omitted
+	    - Brackets may not be omitted in a chain of other blocks that require brackets, e.g `if ... else {}`
+  	- When omitting brackets, still indent as if the code had brackets
+  	- Avoid omitting brackets if it produces hard-to-read or ambiguous code
+* Ternaries should be avoided where it makes the code complex or difficult to read
 * Annotations for methods and classes are placed in lines before their declarations, one per line
-* When there are multiple annotations, place them in order:
-  - @Override -> @Nullable -> @SuppressWarnings
-  - For other annotations, doesn't matter; let your IDE decide
+  - Annotations for a structure go on the line before that structure
+      ```java 
+      @Override
+      @SuppressWarnings("xyz")
+      public void myMethod() {
+            // Override goes above method because method is overriding
+      }
+      ```
+    
+  - Annotations for the _value_ of a thing go before that value's type declaration
+      ```java 
+      @Override
+      public @Nullable Object myMethod() {
+          // Nullable goes before Object because Object is Nullable
+      }
+      ```
+* When there are multiple annotations, it looks nicer to place them in length order (longest last) 
+but this is not strictly required:
+	```java 
+	@Override
+	@Deprecated
+	@SuppressWarnings("xyz")
+	```
 * When splitting Strings into multiple lines the last part of the string must be (space character included) " " +
   ```java
   String string = "example string " +
@@ -111,6 +141,7 @@ If we need to remove or alter contributed code due to a licensing issue we will
   
 * When extending one of following classes: SimpleExpression, SimplePropertyExpression, Effect, Condition...
   - Put overridden methods in order
+  - Put static registration before all methods
   - SimpleExpression: init -> get/getAll -> acceptChange -> change -> setTime -> getTime -> isSingle -> getReturnType -> toString
   - SimplePropertyExpression: -> init -> convert -> acceptChange -> change -> setTime -> getTime -> getReturnType -> getPropertyName
   - Effect: init ->  execute  -> toString
@@ -130,8 +161,8 @@ If we need to remove or alter contributed code due to a licensing issue we will
 * Use prefixes only where their use has been already established (such as `ExprSomeRandomThing`)
   - Otherwise, use postfixes where necessary
   - Common occurrences include: Struct (Structure), Sec (Section), EffSec (EffectSection), Eff (Effect), Cond (Condition), Expr (Expression)
-* Ensure variable/field names are descriptive. Avoid using shorthand names like `e`, or `c`.
-  - e.g. Event should be `event`, not `e`. `e` is ambiguous and could mean a number of things.
+* Ensure variable/field names are descriptive. Avoid using shorthand names like `e`, or `c`
+  - e.g. Event should be `event`, not `e`. `e` is ambiguous and could mean a number of things
   
 ### Comments
 * Prefer to comment *why* you're doing things instead of how you're doing them
@@ -163,33 +194,79 @@ Your comments should look something like these:
 ## Language Features
 
 ### Compatibility
-* Contributions should maintain Java 8 source/binary compatibility, even though compiling Skript requires Java 21
-  - Users must not need JRE newer than version 8
+[//]: # (To be updated after feature/2.9 for Java 17)
+* Contributions should maintain Java 11 source/binary compatibility, even though compiling Skript requires Java 21
+  - Users must not need JRE newer than version 11
 * Versions up to and including Java 21 should work too
   - Please avoid using unsafe reflection
 * It is recommended to make fields final, if they are effectively final
-* Local variables and method parameters should not be declared final
+* Local variables and method parameters should not be declared final unless used in anonymous classes, lambdas
+or try-with-resources sections where their immutability is necessary
 * Methods should be declared final only where necessary
 * Use `@Override` whenever applicable
-
-### Nullness
+  - They may be omitted to prevent compilation errors when something overrides only
+  on a version-dependent basis (e.g. in Library XYZ version 2 we override `getX()` but in version 3 it's
+  gone, and we call it ourselves)
+
+### null-ness
+* We use **JetBrains** Annotations for specifying null-ness and method contracts.
+  * If editing a file using a different annotation set (e.g. Javax, Eclipse Sisu, Bukkit)
+  these should be replaced with their JetBrains equivalent.
+  * The semantics for JetBrains Annotations are strict _and should be observed!_
+    * Many IDEs have built-in compiler-level support for these, and can even be set to produce strict
+    errors when an annotation is misused; do not misuse them.
+  * **`@NotNull`**
+    * > An element annotated with NotNull claims null value is forbidden to return (for methods), 
+    pass to (parameters) and hold (local variables and fields).
+	* Something is `@NotNull` iff it is never null from its inception (new X) to its garbage collection, 
+    i.e. there is no point in time at which the value could ever be null.
+  * **`@Nullable`**
+    * > An element annotated with Nullable claims null value is perfectly valid to return (for methods), 
+	  > pass to (parameters) or hold in (local variables and fields). 
+	  > 
+	  > By convention, this annotation applied only when the value should always be checked 
+	  > against null because the developer could do nothing to prevent null from happening.
+	* Something is `@Nullable` iff there is _absolutely no way of determining_ (other than checking its 
+    value `!= null`) whether it is null.
+    * In other words, if there is another way of knowing (e.g. you set it yourself, an `isPresent` method, etc.)
+    then it should not be marked nullable.
+  * **`@Contract`**
+    * The contract annotation should be used to express other behaviour (e.g. null depending on parameters).
 * All fields, method parameters and their return values are non-null by default
-  - Exceptions: Github API JSON mappings, Metrics
-* When something is nullable, mark it as so
-* Only ignore nullness errors when a variable is effectively non-null - if in doubt: check
-  - Most common example is syntax elements, which are not initialised using a constructor
+  - Exceptions: GitHub API JSON mappings, Metrics
+* When ignoring warnings, use the no-inspection comment rather than a blanket suppression annotation
 * Use assertions liberally: if you're sure something is not null, assert so to the compiler
   - Makes finding bugs easier for developers
-* Assertions must **not** have side-effects - they may be skipped in real environments
+* Assertions must **not** have side-effects in non-test packages - they may be skipped in real environments
 * Avoid checking non-null values for nullability
   - Unless working around buggy addons, it is rarely necessary
-  - This is why ignoring nullness errors is particularly dangerous
+  - This is why ignoring null-ness errors is particularly dangerous
+* Annotations on array types **must** be placed properly:
+  * Annotations on the array itself go before the array brackets
+	```java
+	@Nullable Object @NotNull []
+	// a not-null array of nullable objects
+	```
+  * Annotations on values inside the array go before the value declaration
+	```java
+	@NotNull Object @Nullable []
+	// a nullable array of not-null objects
+	```
+  * If this is not adhered to, an IDE may provide incorrect feedback.
 
 ### Assertions
 
 Skript must run with assertations enabled; use them in your development environment. \
 The JVM flag <code>-ea</code> is used to enable them.
 
+## Code Complexity
+
+Dense, highly-complex code should be avoided to preserve readability and to help with future maintenance, 
+especially within a single method body.
+
+There are many available metrics for measuring code complexity (for different purposes); [we have our own](https://stable.skriptlang.org/Radical_Complexity.pdf).
+There are no strict limits for code complexity, but you may be encouraged (or required) to reformat or break up methods
+into smaller, more manageable chunks. If in doubt, keep things simple.
 
 ## Minecraft Features
 
diff --git a/gradle.properties b/gradle.properties
index 7753116b0ea..f78ae1766eb 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -5,7 +5,7 @@ org.gradle.parallel=true
 
 groupid=ch.njol
 name=skript
-version=2.8.5
+version=2.8.7
 jarName=Skript.jar
 testEnv=java21/paper-1.20.6
 testEnvJavaVersion=21
diff --git a/licenseheader.txt b/licenseheader.txt
deleted file mode 100644
index 15be760be16..00000000000
--- a/licenseheader.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-  This file is part of Skript.
-
- Skript is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Skript is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with Skript.  If not, see <http://www.gnu.org/licenses/>.
-
-Copyright Peter Güttinger, SkriptLang team and contributors
\ No newline at end of file
diff --git a/src/main/java/ch/njol/skript/SkriptCommand.java b/src/main/java/ch/njol/skript/SkriptCommand.java
index 62261d0e426..0bc25391267 100644
--- a/src/main/java/ch/njol/skript/SkriptCommand.java
+++ b/src/main/java/ch/njol/skript/SkriptCommand.java
@@ -62,19 +62,19 @@ public class SkriptCommand implements CommandExecutor {
 	// TODO /skript scripts show/list - lists all enabled and/or disabled scripts in the scripts folder and/or subfolders (maybe add a pattern [using * and **])
 	// TODO document this command on the website
 	private static final CommandHelp SKRIPT_COMMAND_HELP = new CommandHelp("<gray>/<gold>skript", SkriptColor.LIGHT_CYAN, CONFIG_NODE + ".help")
-		.add(new CommandHelp("reload", SkriptColor.DARK_RED)
+		.add(new CommandHelp("reload", SkriptColor.DARK_CYAN)
 			.add("all")
 			.add("config")
 			.add("aliases")
 			.add("scripts")
 			.add("<script>")
-		).add(new CommandHelp("enable", SkriptColor.DARK_RED)
+		).add(new CommandHelp("enable", SkriptColor.DARK_CYAN)
 			.add("all")
 			.add("<script>")
-		).add(new CommandHelp("disable", SkriptColor.DARK_RED)
+		).add(new CommandHelp("disable", SkriptColor.DARK_CYAN)
 			.add("all")
 			.add("<script>")
-		).add(new CommandHelp("update", SkriptColor.DARK_RED)
+		).add(new CommandHelp("update", SkriptColor.DARK_CYAN)
 			.add("check")
 			.add("changes")
 			.add("download")
diff --git a/src/main/java/ch/njol/skript/SkriptConfig.java b/src/main/java/ch/njol/skript/SkriptConfig.java
index 5d9f9254d44..5a3bb954cd4 100644
--- a/src/main/java/ch/njol/skript/SkriptConfig.java
+++ b/src/main/java/ch/njol/skript/SkriptConfig.java
@@ -105,7 +105,7 @@ public class SkriptConfig {
 						break;
 					case "stable":
 						// TODO a better option would be to check that it is not a pre-release through GH API
-						channel = new ReleaseChannel((name) -> !name.contains("pre"), t);
+						channel = new ReleaseChannel((name) -> !(name.contains("-")), t);
 						break;
 					case "none":
 						channel = new ReleaseChannel((name) -> false, t);
diff --git a/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java b/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java
index f7812d52f32..7dc7149ce4f 100644
--- a/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java
+++ b/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java
@@ -114,8 +114,8 @@ public static void lookAt(LookAnchor entityAnchor, Object target, @Nullable Floa
 				Player player = (Player) entity;
 				if (target instanceof Vector) {
 					Vector vector = (Vector) target;
-					player.lookAt(vector.getX(), vector.getY(), vector.getZ(), LookAnchor.EYES);
-					player.lookAt(vector.getX(), vector.getY(), vector.getZ(), LookAnchor.FEET);
+					player.lookAt(player.getEyeLocation().add(vector), LookAnchor.EYES);
+					player.lookAt(player.getEyeLocation().add(vector), LookAnchor.FEET);
 				} else if (target instanceof Location) {
 					player.lookAt((Location) target, LookAnchor.EYES);
 					player.lookAt((Location) target, LookAnchor.FEET);
@@ -159,7 +159,7 @@ public void tick() {
 			switch (type) {
 				case VECTOR:
 					Vector vector = ((Vector)target);
-					mob.lookAt(vector.getX(), vector.getY(), vector.getZ(), speed, maxPitch);
+					mob.lookAt(mob.getEyeLocation().add(vector), speed, maxPitch);
 					break;
 				case LOCATION:
 					mob.lookAt((Location) target, speed, maxPitch);
diff --git a/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java b/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java
index 25000a2390d..ba1a419aad0 100644
--- a/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java
+++ b/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java
@@ -38,6 +38,7 @@
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.OfflinePlayer;
+import org.bukkit.Registry;
 import org.bukkit.SoundCategory;
 import org.bukkit.World;
 import org.bukkit.World.Environment;
@@ -77,7 +78,6 @@
 import org.bukkit.potion.PotionEffectType;
 import org.bukkit.util.CachedServerIcon;
 import org.bukkit.util.Vector;
-import org.eclipse.jdt.annotation.Nullable;
 
 import ch.njol.skript.Skript;
 import ch.njol.skript.SkriptConfig;
@@ -90,6 +90,7 @@
 import ch.njol.skript.classes.EnumClassInfo;
 import ch.njol.skript.classes.Parser;
 import ch.njol.skript.classes.Serializer;
+import ch.njol.skript.classes.registry.RegistryClassInfo;
 import ch.njol.skript.entity.EntityData;
 import ch.njol.skript.expressions.ExprDamageCause;
 import ch.njol.skript.expressions.base.EventValueExpression;
@@ -104,6 +105,7 @@
 import ch.njol.util.StringUtils;
 import ch.njol.yggdrasil.Fields;
 import io.papermc.paper.world.MoonPhase;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * @author Peter Güttinger
@@ -976,8 +978,14 @@ public String toVariableNameString(final ItemStack i) {
 				.name(ClassInfo.NO_DOC)
 				.since("2.0")
 				.changer(DefaultChangers.itemChanger));
-		
-		Classes.registerClass(new EnumClassInfo<>(Biome.class, "biome", "biomes")
+
+		ClassInfo<?> biomeClassInfo;
+		if (Skript.classExists("org.bukkit.Registry") && Skript.fieldExists(Registry.class, "BIOME")) {
+			biomeClassInfo = new RegistryClassInfo<>(Biome.class, Registry.BIOME, "biome", "biomes");
+		} else {
+			biomeClassInfo = new EnumClassInfo<>(Biome.class, "biome", "biomes");
+		}
+		Classes.registerClass(biomeClassInfo
 				.user("biomes?")
 				.name("Biome")
 				.description("All possible biomes Minecraft uses to generate a world.")
diff --git a/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java b/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
index 7123ede168d..6131def1eec 100644
--- a/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
+++ b/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
@@ -18,9 +18,6 @@
  */
 package ch.njol.skript.classes.data;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -100,6 +97,7 @@
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.EntityDropItemEvent;
 import org.bukkit.event.entity.EntityEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.entity.EntityResurrectEvent;
@@ -663,34 +661,17 @@ public LivingEntity[] get(AreaEffectCloudApplyEvent event) {
 			}
 		}, EventValues.TIME_NOW);
 		EventValues.registerEventValue(AreaEffectCloudApplyEvent.class, PotionEffectType.class, new Getter<PotionEffectType, AreaEffectCloudApplyEvent>() {
-			@Nullable
-			private final MethodHandle BASE_POTION_DATA_HANDLE;
-
-			{
-				MethodHandle basePotionDataHandle = null;
-				if (Skript.methodExists(AreaEffectCloud.class, "getBasePotionData")) {
-					try {
-						basePotionDataHandle = MethodHandles.lookup().findVirtual(AreaEffectCloud.class, "getBasePotionData", MethodType.methodType(PotionData.class));
-					} catch (NoSuchMethodException | IllegalAccessException e) {
-						Skript.exception(e, "Failed to load legacy potion data support. Potions may not work as expected.");
-					}
-				}
-				BASE_POTION_DATA_HANDLE = basePotionDataHandle;
-			}
-
+			private final boolean HAS_POTION_TYPE_METHOD = Skript.methodExists(AreaEffectCloud.class, "getBasePotionType");
 			@Override
 			@Nullable
 			public PotionEffectType get(AreaEffectCloudApplyEvent e) {
-				if (BASE_POTION_DATA_HANDLE != null) {
-					try {
-						return ((PotionData) BASE_POTION_DATA_HANDLE.invoke(e.getEntity())).getType().getEffectType();
-					} catch (Throwable ex) {
-						throw Skript.exception(ex, "An error occurred while trying to invoke legacy area effect cloud potion effect support.");
-					}
-				} else {
+				// TODO needs to be reworked to support multiple values (there can be multiple potion effects)
+				if (HAS_POTION_TYPE_METHOD) {
 					PotionType base = e.getEntity().getBasePotionType();
-					if (base != null) // TODO this is deprecated... this should become a multi-value event value
+					if (base != null)
 						return base.getEffectType();
+				} else {
+					return e.getEntity().getBasePotionData().getType().getEffectType();
 				}
 				return null;
 			}
@@ -799,6 +780,19 @@ public ItemStack get(final PlayerDropItemEvent e) {
 				return e.getItemDrop().getItemStack();
 			}
 		}, 0);
+		// EntityDropItemEvent
+		EventValues.registerEventValue(EntityDropItemEvent.class, Item.class, new Getter<Item, EntityDropItemEvent>() {
+			@Override
+			public Item get(EntityDropItemEvent event) {
+				return event.getItemDrop();
+			}
+		}, EventValues.TIME_NOW);
+		EventValues.registerEventValue(EntityDropItemEvent.class, ItemStack.class, new Getter<ItemStack, EntityDropItemEvent>() {
+			@Override
+			public ItemStack get(EntityDropItemEvent event) {
+				return event.getItemDrop().getItemStack();
+			}
+		}, EventValues.TIME_NOW);
 		// PlayerPickupItemEvent
 		EventValues.registerEventValue(PlayerPickupItemEvent.class, Player.class, new Getter<Player, PlayerPickupItemEvent>() {
 			@Override
diff --git a/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java b/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java
index 495ca362eab..00f419f4901 100644
--- a/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java
+++ b/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java
@@ -151,6 +151,7 @@ public DefaultConverters() {}
 				return (InventoryHolder) s;
 			return null;
 		}, Converter.NO_RIGHT_CHAINING | Commands.CONVERTER_NO_COMMAND_ARGUMENTS);
+
 		Converters.registerConverter(InventoryHolder.class, Block.class, holder -> {
 			if (holder instanceof BlockState)
 				return new BlockInventoryHolder((BlockState) holder);
@@ -165,7 +166,19 @@ public DefaultConverters() {}
 				return (Entity) holder;
 			return null;
 		}, Converter.NO_CHAINING);
-		
+
+		// InventoryHolder - Location
+		// since the individual ones can't be trusted to chain.
+		Converters.registerConverter(InventoryHolder.class, Location.class, holder -> {
+			if (holder instanceof Entity)
+				return ((Entity) holder).getLocation();
+			if (holder instanceof Block)
+				return ((Block) holder).getLocation();
+			if (holder instanceof BlockState)
+				return BlockUtils.getLocation(((BlockState) holder).getBlock());
+			return null;
+		});
+
 		// Enchantment - EnchantmentType
 		Converters.registerConverter(Enchantment.class, EnchantmentType.class, e -> new EnchantmentType(e, -1));
 
diff --git a/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java b/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
index 39dc6447fa5..6f92502cd2a 100644
--- a/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
+++ b/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
@@ -661,6 +661,7 @@ public String toVariableNameString(final Experience xp) {
 				.usage(VisualEffects.getAllNames())
 				.since("2.1")
 				.user("(visual|particle) effects?")
+				.after("itemtype")
 				.parser(new Parser<VisualEffect>() {
 					@Override
 					@Nullable
diff --git a/src/main/java/ch/njol/skript/classes/registry/RegistryClassInfo.java b/src/main/java/ch/njol/skript/classes/registry/RegistryClassInfo.java
new file mode 100644
index 00000000000..ff82f966af8
--- /dev/null
+++ b/src/main/java/ch/njol/skript/classes/registry/RegistryClassInfo.java
@@ -0,0 +1,53 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.classes.registry;
+
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.expressions.base.EventValueExpression;
+import ch.njol.skript.lang.DefaultExpression;
+import org.bukkit.Keyed;
+import org.bukkit.Registry;
+
+/**
+ * This class can be used for easily creating ClassInfos for {@link Registry}s.
+ * It registers a language node with usage, a serializer, default expression, and a parser.
+ *
+ * @param <R> The Registry class.
+ */
+public class RegistryClassInfo<R extends Keyed> extends ClassInfo<R> {
+
+	public RegistryClassInfo(Class<R> registryClass, Registry<R> registry, String codeName, String languageNode) {
+		this(registryClass, registry, codeName, languageNode, new EventValueExpression<>(registryClass));
+	}
+
+	/**
+	 * @param registry The registry
+	 * @param codeName The name used in patterns
+	 */
+	public RegistryClassInfo(Class<R> registryClass, Registry<R> registry, String codeName, String languageNode, DefaultExpression<R> defaultExpression) {
+		super(registryClass, codeName);
+		RegistryParser<R> registryParser = new RegistryParser<>(registry, languageNode);
+		usage(registryParser.getAllNames())
+			.supplier(registry::iterator)
+			.serializer(new RegistrySerializer<R>(registry))
+			.defaultExpression(defaultExpression)
+			.parser(registryParser);
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/classes/registry/RegistryParser.java b/src/main/java/ch/njol/skript/classes/registry/RegistryParser.java
new file mode 100644
index 00000000000..51cb4637434
--- /dev/null
+++ b/src/main/java/ch/njol/skript/classes/registry/RegistryParser.java
@@ -0,0 +1,155 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.classes.registry;
+
+import ch.njol.skript.classes.Parser;
+import ch.njol.skript.lang.ParseContext;
+import ch.njol.skript.localization.Language;
+import ch.njol.skript.localization.Noun;
+import ch.njol.util.NonNullPair;
+import ch.njol.util.StringUtils;
+import org.bukkit.Keyed;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * A parser based on a {@link Registry} used to parse data from a string or turn data into a string.
+ *
+ * @param <R> Registry class
+ */
+public class RegistryParser<R extends Keyed> extends Parser<R> {
+
+	private final Registry<R> registry;
+	private final String languageNode;
+
+	private final Map<R, String> names = new HashMap<>();
+	private final Map<String, R> parseMap = new HashMap<>();
+
+	public RegistryParser(Registry<R> registry, String languageNode) {
+		assert !languageNode.isEmpty() && !languageNode.endsWith(".") : languageNode;
+		this.registry = registry;
+		this.languageNode = languageNode;
+		refresh();
+		Language.addListener(this::refresh);
+	}
+
+	private void refresh() {
+		names.clear();
+		parseMap.clear();
+		for (R registryObject : registry) {
+			NamespacedKey namespacedKey = registryObject.getKey();
+			String namespace = namespacedKey.getNamespace();
+			String key = namespacedKey.getKey();
+			String keyWithSpaces = key.replace("_", " ");
+			String languageKey = languageNode + "." + key;
+
+			// Put the full namespaced key as a pattern
+			parseMap.put(namespacedKey.toString(), registryObject);
+
+			// If the object is a vanilla Minecraft object, we'll add the key with spaces as a pattern
+			if (namespace.equalsIgnoreCase(NamespacedKey.MINECRAFT)) {
+				parseMap.put(keyWithSpaces, registryObject);
+			}
+
+			String[] options = Language.getList(languageKey);
+			// Missing/Custom registry objects
+			if (options.length == 1 && options[0].equals(languageKey.toLowerCase(Locale.ENGLISH))) {
+				if (namespace.equalsIgnoreCase(NamespacedKey.MINECRAFT)) {
+					// If the object is a vanilla Minecraft object, we'll use the key with spaces as a name
+					names.put(registryObject, keyWithSpaces);
+				} else {
+					// If the object is a custom object, we'll use the full namespaced key as a name
+					names.put(registryObject, namespacedKey.toString());
+				}
+			} else {
+				for (String option : options) {
+					option = option.toLowerCase(Locale.ENGLISH);
+
+					// Isolate the gender if one is present
+					NonNullPair<String, Integer> strippedOption = Noun.stripGender(option, languageKey);
+					String first = strippedOption.getFirst();
+					Integer second = strippedOption.getSecond();
+
+					// Add to name map if needed
+					names.putIfAbsent(registryObject, first);
+
+					parseMap.put(first, registryObject);
+					if (second != -1) { // There is a gender present
+						parseMap.put(Noun.getArticleWithSpace(second, Language.F_INDEFINITE_ARTICLE) + first, registryObject);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * This method attempts to match the string input against one of the string representations of the registry.
+	 *
+	 * @param input a string to attempt to match against one in the registry.
+	 * @param context of parsing, may not be null
+	 * @return The registry object matching the input, or null if no match could be made.
+	 */
+	@Override
+	public @Nullable R parse(String input, @NotNull ParseContext context) {
+		return parseMap.get(input.toLowerCase(Locale.ENGLISH));
+	}
+
+	/**
+	 * This method returns the string representation of a registry.
+	 *
+	 * @param object The object to represent as a string.
+	 * @param flags  not currently used
+	 * @return A string representation of the registry object.
+	 */
+	@Override
+	public @NotNull String toString(R object, int flags) {
+		return names.get(object);
+	}
+
+	/**
+	 * Returns a registry object's string representation in a variable name.
+	 *
+	 * @param object Object to represent in a variable name.
+	 * @return The given object's representation in a variable name.
+	 */
+	@Override
+	public @NotNull String toVariableNameString(R object) {
+		return toString(object, 0);
+	}
+
+	/**
+	 * @return A comma-separated string containing a list of all names representing the registry.
+	 * Note that some entries may represent the same registry object.
+	 */
+	public String getAllNames() {
+		List<String> strings = new ArrayList<>(parseMap.keySet());
+		Collections.sort(strings);
+		return StringUtils.join(strings, ", ");
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/classes/registry/RegistrySerializer.java b/src/main/java/ch/njol/skript/classes/registry/RegistrySerializer.java
new file mode 100644
index 00000000000..ddec6c3225f
--- /dev/null
+++ b/src/main/java/ch/njol/skript/classes/registry/RegistrySerializer.java
@@ -0,0 +1,83 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.classes.registry;
+
+import ch.njol.skript.classes.Serializer;
+import ch.njol.yggdrasil.Fields;
+import org.bukkit.Keyed;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+
+import java.io.StreamCorruptedException;
+
+/**
+ * Serializer for {@link RegistryClassInfo}
+ *
+ * @param <R> Registry class
+ */
+public class RegistrySerializer<R extends Keyed> extends Serializer<R> {
+
+	private final Registry<R> registry;
+
+	public RegistrySerializer(Registry<R> registry) {
+		this.registry = registry;
+	}
+
+	@Override
+	public Fields serialize(R o) {
+		Fields fields = new Fields();
+		fields.putPrimitive("name", o.getKey().toString());
+		return null;
+	}
+
+	@Override
+	protected R deserialize(Fields fields) {
+		try {
+			String name = fields.getAndRemovePrimitive("name", String.class);
+			NamespacedKey namespacedKey;
+			if (!name.contains(":")) {
+				// Old variables
+				namespacedKey = NamespacedKey.minecraft(name);
+			} else {
+				namespacedKey = NamespacedKey.fromString(name);
+			}
+			if (namespacedKey == null)
+				return null;
+			return registry.get(namespacedKey);
+		} catch (StreamCorruptedException e) {
+			return null;
+		}
+	}
+
+	@Override
+	public boolean mustSyncDeserialization() {
+		return false;
+	}
+
+	@Override
+	protected boolean canBeInstantiated() {
+		return false;
+	}
+
+	@Override
+	public void deserialize(R o, Fields f) {
+		throw new UnsupportedOperationException();
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/effects/EffReturn.java b/src/main/java/ch/njol/skript/effects/EffReturn.java
index d0b4d220514..21ce3d4d475 100644
--- a/src/main/java/ch/njol/skript/effects/EffReturn.java
+++ b/src/main/java/ch/njol/skript/effects/EffReturn.java
@@ -26,21 +26,22 @@
 import ch.njol.skript.doc.Since;
 import ch.njol.skript.lang.Effect;
 import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ReturnHandler;
+import ch.njol.skript.lang.ReturnHandler.ReturnHandlerStack;
 import ch.njol.skript.lang.SectionExitHandler;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.TriggerItem;
 import ch.njol.skript.lang.TriggerSection;
-import ch.njol.skript.lang.function.FunctionEvent;
-import ch.njol.skript.lang.function.Functions;
-import ch.njol.skript.lang.function.ScriptFunction;
+import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.skript.log.RetainingLogHandler;
 import ch.njol.skript.log.SkriptLogger;
+import ch.njol.skript.registrations.Classes;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
 import org.eclipse.jdt.annotation.Nullable;
 
 @Name("Return")
-@Description("Makes a function return a value")
+@Description("Makes a trigger (e.g. a function) return a value")
 @Examples({
 	"function double(i: number) :: number:",
 		"\treturn 2 * {_i}",
@@ -50,90 +51,89 @@
 })
 @Since("2.2, 2.8.0 (returns aliases)")
 public class EffReturn extends Effect {
-	
+
 	static {
 		Skript.registerEffect(EffReturn.class, "return %objects%");
+		ParserInstance.registerData(ReturnHandlerStack.class, ReturnHandlerStack::new);
 	}
-	
+
 	@SuppressWarnings("NotNullFieldNotInitialized")
-	private ScriptFunction<?> function;
-	
+	private ReturnHandler<?> handler;
 	@SuppressWarnings("NotNullFieldNotInitialized")
 	private Expression<?> value;
-	
-	@SuppressWarnings("unchecked")
+
 	@Override
+	@SuppressWarnings("unchecked")
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		ScriptFunction<?> f = Functions.currentFunction;
-		if (f == null) {
-			Skript.error("The return statement can only be used in a function");
+		handler = getParser().getData(ReturnHandlerStack.class).getCurrentHandler();
+		if (handler == null) {
+			Skript.error("The return statement cannot be used here");
 			return false;
 		}
-		
+
 		if (!isDelayed.isFalse()) {
 			Skript.error("A return statement after a delay is useless, as the calling trigger will resume when the delay starts (and won't get any returned value)");
 			return false;
 		}
-		
-		function = f;
-		ClassInfo<?> returnType = function.getReturnType();
+
+		Class<?> returnType = handler.returnValueType();
 		if (returnType == null) {
-			Skript.error("This function doesn't return any value. Please use 'stop' or 'exit' if you want to stop the function.");
+			Skript.error(handler + " doesn't return any value. Please use 'stop' or 'exit' if you want to stop the trigger.");
 			return false;
 		}
-		
+
 		RetainingLogHandler log = SkriptLogger.startRetainingLog();
 		Expression<?> convertedExpr;
 		try {
-			convertedExpr = exprs[0].getConvertedExpression(returnType.getC());
+			convertedExpr = exprs[0].getConvertedExpression(returnType);
 			if (convertedExpr == null) {
-				log.printErrors("This function is declared to return " + returnType.getName().withIndefiniteArticle() + ", but " + exprs[0].toString(null, false) + " is not of that type.");
+				String typeName = Classes.getSuperClassInfo(returnType).getName().withIndefiniteArticle();
+				log.printErrors(handler + " is declared to return " + typeName + ", but " + exprs[0].toString(null, false) + " is not of that type.");
 				return false;
 			}
 			log.printLog();
 		} finally {
 			log.stop();
 		}
-		
-		if (f.isSingle() && !convertedExpr.isSingle()) {
-			Skript.error("This function is defined to only return a single " + returnType.toString() + ", but this return statement can return multiple values.");
+
+		if (handler.isSingleReturnValue() && !convertedExpr.isSingle()) {
+			Skript.error(handler + " is defined to only return a single " + returnType + ", but this return statement can return multiple values.");
 			return false;
 		}
 		value = convertedExpr;
-		
+
 		return true;
 	}
-	
+
 	@Override
 	@Nullable
-	@SuppressWarnings({"unchecked", "rawtypes"})
 	protected TriggerItem walk(Event event) {
 		debug(event, false);
-		if (event instanceof FunctionEvent) {
-			((ScriptFunction) function).setReturnValue(value.getArray(event));
-		} else {
-			assert false : event;
-		}
+		//noinspection rawtypes,unchecked
+		((ReturnHandler) handler).returnValues(value.getArray(event));
 
 		TriggerSection parent = getParent();
-		while (parent != null) {
+		while (parent != null && parent != handler) {
 			if (parent instanceof SectionExitHandler)
 				((SectionExitHandler) parent).exit(event);
 
 			parent = parent.getParent();
 		}
 
+		if (handler instanceof SectionExitHandler)
+			((SectionExitHandler) handler).exit(event);
+
 		return null;
 	}
-	
+
 	@Override
 	protected void execute(Event event) {
 		assert false;
 	}
-	
+
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		return "return " + value.toString(event, debug);
 	}
-	
+
 }
diff --git a/src/main/java/ch/njol/skript/entity/DroppedItemData.java b/src/main/java/ch/njol/skript/entity/DroppedItemData.java
index 06d38d1a2fc..e9b136407c1 100644
--- a/src/main/java/ch/njol/skript/entity/DroppedItemData.java
+++ b/src/main/java/ch/njol/skript/entity/DroppedItemData.java
@@ -18,11 +18,16 @@
  */
 package ch.njol.skript.entity;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Arrays;
+import java.util.function.Consumer;
 
+import ch.njol.skript.Skript;
+import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.entity.Item;
 import org.bukkit.inventory.ItemStack;
-import org.eclipse.jdt.annotation.Nullable;
 
 import ch.njol.skript.aliases.ItemType;
 import ch.njol.skript.lang.Literal;
@@ -32,71 +37,76 @@
 import ch.njol.skript.localization.Noun;
 import ch.njol.skript.registrations.Classes;
 import ch.njol.util.coll.CollectionUtils;
+import org.jetbrains.annotations.Nullable;
 
-/**
- * @author Peter Güttinger
- */
 public class DroppedItemData extends EntityData<Item> {
+
+	private static final boolean HAS_JAVA_CONSUMER_DROP = Skript.methodExists(World.class, "dropItem", Location.class, ItemStack.class, Consumer.class);
+	private static @Nullable Method BUKKIT_CONSUMER_DROP;
+
 	static {
 		EntityData.register(DroppedItemData.class, "dropped item", Item.class, "dropped item");
+
+		try {
+			BUKKIT_CONSUMER_DROP = World.class.getDeclaredMethod("dropItem", Location.class, ItemStack.class, org.bukkit.util.Consumer.class);
+		} catch (NoSuchMethodException | SecurityException ignored) {}
 	}
 	
 	private final static Adjective m_adjective = new Adjective("entities.dropped item.adjective");
-	
-	@Nullable
-	private ItemType[] types;
+
+	private ItemType @Nullable [] types;
 	
 	public DroppedItemData() {}
 	
-	public DroppedItemData(@Nullable ItemType[] types) {
+	public DroppedItemData(ItemType @Nullable [] types) {
 		this.types = types;
 	}
 	
 	@Override
-	protected boolean init(final Literal<?>[] exprs, final int matchedPattern, final ParseResult parseResult) {
-		if (exprs.length > 0 && exprs[0] != null)
-			types = (ItemType[]) exprs[0].getAll();
+	protected boolean init(Literal<?>[] expressions, int matchedPattern, ParseResult parseResult) {
+		if (expressions.length > 0 && expressions[0] != null)
+			types = (ItemType[]) expressions[0].getAll();
 		return true;
 	}
 	
 	@Override
-	protected boolean init(final @Nullable Class<? extends Item> c, final @Nullable Item e) {
-		if (e != null) {
-			final ItemStack i = e.getItemStack();
+	protected boolean init(@Nullable Class<? extends Item> clazz, @Nullable Item itemEntity) {
+		if (itemEntity != null) {
+			final ItemStack i = itemEntity.getItemStack();
 			types = new ItemType[] {new ItemType(i)};
 		}
 		return true;
 	}
 	
 	@Override
-	protected boolean match(final Item entity) {
+	protected boolean match(Item entity) {
 		if (types != null) {
-			for (final ItemType t : types) {
+			for (ItemType t : types) {
 				if (t.isOfType(entity.getItemStack()))
 					return true;
 			}
 			return false;
-		} else {
-			return true;
 		}
+		return true;
 	}
 	
 	@Override
 	public void set(final Item entity) {
+		if (types == null)
+			return;
 		final ItemType t = CollectionUtils.getRandom(types);
 		assert t != null;
 		ItemStack stack = t.getItem().getRandom();
-		if (stack != null)
-			entity.setItemStack(stack);
+		entity.setItemStack(stack);
 	}
 	
 	@Override
-	public boolean isSupertypeOf(final EntityData<?> e) {
-		if (!(e instanceof DroppedItemData))
+	public boolean isSupertypeOf(EntityData<?> otherData) {
+		if (!(otherData instanceof DroppedItemData))
 			return false;
-		final DroppedItemData d = (DroppedItemData) e;
+		DroppedItemData otherItemData = (DroppedItemData) otherData;
 		if (types != null)
-			return d.types != null && ItemType.isSubset(types, d.types);
+			return otherItemData.types != null && ItemType.isSubset(types, otherItemData.types);
 		return true;
 	}
 	
@@ -111,36 +121,66 @@ public EntityData getSuperType() {
 	}
 	
 	@Override
-	public String toString(final int flags) {
-		final ItemType[] types = this.types;
+	public String toString(int flags) {
 		if (types == null)
 			return super.toString(flags);
-		final StringBuilder b = new StringBuilder();
-		b.append(Noun.getArticleWithSpace(types[0].getTypes().get(0).getGender(), flags));
-		b.append(m_adjective.toString(types[0].getTypes().get(0).getGender(), flags));
-		b.append(" ");
-		b.append(Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false));
-		return "" + b.toString();
+		int gender = types[0].getTypes().get(0).getGender();
+		return Noun.getArticleWithSpace(gender, flags) +
+				m_adjective.toString(gender, flags) +
+				" " +
+				Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false);
 	}
-	
-//		return ItemType.serialize(types);
+
 	@Override
 	@Deprecated
-	protected boolean deserialize(final String s) {
+	protected boolean deserialize(String s) {
 		throw new UnsupportedOperationException("old serialization is no longer supported");
-//		if (s.isEmpty())
-//			return true;
-//		types = ItemType.deserialize(s);
-//		return types != null;
 	}
 	
 	@Override
-	protected boolean equals_i(final EntityData<?> obj) {
-		if (!(obj instanceof DroppedItemData))
+	protected boolean equals_i(EntityData<?> otherData) {
+		if (!(otherData instanceof DroppedItemData))
 			return false;
-		return Arrays.equals(types, ((DroppedItemData) obj).types);
+		return Arrays.equals(types, ((DroppedItemData) otherData).types);
 	}
-	
+
+	@Override
+	public boolean canSpawn(@Nullable World world) {
+		return types != null && types.length > 0 && world != null;
+	}
+
+	@Override
+	public @Nullable Item spawn(Location location, @Nullable Consumer<Item> consumer) {
+		World world = location.getWorld();
+		if (!canSpawn(world))
+			return null;
+		assert types != null && types.length > 0;
+
+		final ItemType itemType = CollectionUtils.getRandom(types);
+		assert itemType != null;
+		ItemStack stack = itemType.getItem().getRandom();
+
+		Item item;
+		if (consumer == null) {
+			item = world.dropItem(location, stack);
+		} else if (HAS_JAVA_CONSUMER_DROP) {
+			item = world.dropItem(location, stack, consumer);
+		} else if (BUKKIT_CONSUMER_DROP != null) {
+			try {
+				// noinspection deprecation
+				item = (Item) BUKKIT_CONSUMER_DROP.invoke(world, location, stack, (org.bukkit.util.Consumer<Item>) consumer::accept);
+			} catch (InvocationTargetException | IllegalAccessException e) {
+				if (Skript.testing())
+					Skript.exception(e, "Can't spawn " + this.getName());
+				return null;
+			}
+		} else {
+			item = world.dropItem(location, stack);
+			consumer.accept(item);
+		}
+		return item;
+	}
+
 	@Override
 	protected int hashCode_i() {
 		return Arrays.hashCode(types);
diff --git a/src/main/java/ch/njol/skript/entity/FishData.java b/src/main/java/ch/njol/skript/entity/FishData.java
deleted file mode 100644
index c3694a12f6b..00000000000
--- a/src/main/java/ch/njol/skript/entity/FishData.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/**
- *   This file is part of Skript.
- *
- *  Skript is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Skript is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Copyright Peter Güttinger, SkriptLang team and contributors
- */
-package ch.njol.skript.entity;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ThreadLocalRandom;
-
-import org.bukkit.entity.Cod;
-import org.bukkit.entity.Fish;
-import org.bukkit.entity.PufferFish;
-import org.bukkit.entity.Salmon;
-import org.bukkit.entity.Tadpole;
-import org.bukkit.entity.TropicalFish;
-import org.eclipse.jdt.annotation.Nullable;
-
-import ch.njol.skript.Skript;
-import ch.njol.skript.lang.Literal;
-import ch.njol.skript.lang.SkriptParser.ParseResult;
-
-public class FishData extends EntityData<Fish> {
-
-	private static final boolean HAS_TADPOLE = Skript.classExists("org.bukkit.entity.Tadpole");
-	private static final List<String> PATTERNS;
-
-	static {
-		PATTERNS = new ArrayList<>(Arrays.asList("fish", "cod", "puffer fish", "salmon", "tropical fish"));
-		if (HAS_TADPOLE)
-			PATTERNS.add("tadpole");
-		register(FishData.class, "fish", Fish.class, 0, PATTERNS.toArray(new String[0]));
-	}
-	
-	private boolean init = true;
-	private boolean wildcard = false;
-	private int pattern = -1;
-	
-	public FishData() {}
-	
-	public FishData(int pattern) {
-		this.pattern = pattern;
-		super.matchedPattern = pattern;
-	}
-	
-	@Override
-	protected boolean init(Literal<?>[] exprs, int matchedPattern, ParseResult parseResult) {
-		if (matchedPattern == 0)
-			wildcard = true;
-		pattern = (matchedPattern == 0) ? ThreadLocalRandom.current().nextInt(1, PATTERNS.size()) : matchedPattern;
-		return true;
-	}
-
-	@Override
-	protected boolean init(@Nullable Class<? extends Fish> c, @Nullable Fish e) {
-		int matchedPattern = getInitPattern(e);
-		if (matchedPattern == 0)
-			wildcard = true;
-		pattern = (matchedPattern == 0) ? ThreadLocalRandom.current().nextInt(1, PATTERNS.size()) : matchedPattern;
-		return true;
-	}
-
-	@Override
-	public void set(Fish entity) {
-		// Setting of entity already handled by init() functions 
-	}
-
-	@Override
-	protected boolean match(Fish entity) {
-		return wildcard ? true : getPattern(entity) == pattern;
-	}
-
-	@Override
-	public Class<? extends Fish> getType() {
-		if (!init && wildcard)
-			return Fish.class;
-		init = false;
-		switch (pattern) {
-			case 1:
-				return Cod.class;
-			case 2:
-				return PufferFish.class;
-			case 3:
-				return Salmon.class;
-			case 4:
-				return TropicalFish.class;
-			case 5:
-				return Tadpole.class;
-		}
-		return Fish.class;
-	}
-
-	@Override
-	public EntityData getSuperType() {
-		return new FishData(pattern);
-	}
-
-	@Override
-	protected int hashCode_i() {
-		return wildcard ? 0 : pattern;
-	}
-
-	@Override
-	protected boolean equals_i(EntityData<?> entityData) {
-		return entityData instanceof Fish ? (wildcard ? true : getPattern((Fish) entityData) == pattern) : false;
-	}
-
-	@Override
-	public boolean isSupertypeOf(EntityData<?> entityData) {
-		return entityData instanceof Fish ? (wildcard ? true : getPattern((Fish) entityData) == pattern) : false;
-	}
-	
-	private static int getInitPattern(@Nullable Fish fish) {
-		if (fish == null)
-			return 0;
-		else if (fish instanceof Cod)
-			return 1;
-		else if (fish instanceof PufferFish)
-			return 2;
-		else if (fish instanceof Salmon)
-			return 3;
-		else if (fish instanceof TropicalFish)
-			return 4;
-		else if (HAS_TADPOLE && fish instanceof Tadpole)
-			return 5;
-		return 0;
-	}
-	
-	private int getPattern(@Nullable Fish fish) {
-		int p = getInitPattern(fish);
-		return p == 0 ? pattern : p;
-	}
-	
-}
diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java
index 93c690d6926..504c4449dc7 100644
--- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java
+++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java
@@ -23,6 +23,8 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import ch.njol.util.Kleenean;
+import org.bukkit.World;
 import org.bukkit.entity.AbstractHorse;
 import org.bukkit.entity.Allay;
 import org.bukkit.entity.Animals;
@@ -155,15 +157,13 @@ public final static class SimpleEntityDataInfo {
 		final String codeName;
 		final Class<? extends Entity> c;
 		final boolean isSupertype;
+		final Kleenean allowSpawning;
 		
-		SimpleEntityDataInfo(final String codeName, final Class<? extends Entity> c) {
-			this(codeName, c, false);
-		}
-		
-		SimpleEntityDataInfo(final String codeName, final Class<? extends Entity> c, final boolean isSupertype) {
+		SimpleEntityDataInfo(String codeName, Class<? extends Entity> c, boolean isSupertype, Kleenean allowSpawning) {
 			this.codeName = codeName;
 			this.c = c;
 			this.isSupertype = isSupertype;
+			this.allowSpawning = allowSpawning;
 		}
 		
 		@Override
@@ -191,11 +191,18 @@ public boolean equals(final @Nullable Object obj) {
 	private final static List<SimpleEntityDataInfo> types = new ArrayList<>();
 
 	private static void addSimpleEntity(String codeName, Class<? extends Entity> entityClass) {
-		types.add(new SimpleEntityDataInfo(codeName, entityClass));
+		addSimpleEntity(codeName, entityClass, Kleenean.UNKNOWN);
+	}
+
+	/**
+	 * @param allowSpawning Whether to override the default {@link #canSpawn(World)} behavior and allow this entity to be spawned.
+	 */
+	private static void addSimpleEntity(String codeName, Class<? extends Entity> entityClass, Kleenean allowSpawning) {
+		types.add(new SimpleEntityDataInfo(codeName, entityClass, false, allowSpawning));
 	}
 
 	private static void addSuperEntity(String codeName, Class<? extends Entity> entityClass) {
-		types.add(new SimpleEntityDataInfo(codeName, entityClass, true));
+		types.add(new SimpleEntityDataInfo(codeName, entityClass, true, Kleenean.UNKNOWN));
 	}
 	static {
 		// Simple Entities
@@ -238,7 +245,9 @@ private static void addSuperEntity(String codeName, Class<? extends Entity> enti
 		addSimpleEntity("witch", Witch.class);
 		addSimpleEntity("wither", Wither.class);
 		addSimpleEntity("wither skull", WitherSkull.class);
-		addSimpleEntity("firework", Firework.class);
+		// bukkit marks fireworks as not spawnable
+		// see https://hub.spigotmc.org/jira/browse/SPIGOT-7677
+		addSimpleEntity("firework", Firework.class, Kleenean.TRUE);
 		addSimpleEntity("endermite", Endermite.class);
 		addSimpleEntity("armor stand", ArmorStand.class);
 		addSimpleEntity("shulker", Shulker.class);
@@ -336,6 +345,7 @@ private static void addSuperEntity(String codeName, Class<? extends Entity> enti
 		addSuperEntity("mob", Mob.class);
 		addSuperEntity("creature", Creature.class);
 		addSuperEntity("animal", Animals.class);
+		addSuperEntity("fish", Fish.class);
 		addSuperEntity("golem", Golem.class);
 		addSuperEntity("projectile", Projectile.class);
 		addSuperEntity("living entity", LivingEntity.class);
@@ -448,7 +458,16 @@ protected boolean equals_i(final EntityData<?> obj) {
 		final SimpleEntityData other = (SimpleEntityData) obj;
 		return info.equals(other.info);
 	}
-	
+
+	@Override
+	public boolean canSpawn(@Nullable World world) {
+		if (info.allowSpawning.isUnknown()) // unspecified, refer to default behavior
+			return super.canSpawn(world);
+		if (world == null)
+			return false;
+		return info.allowSpawning.isTrue();
+	}
+
 	@Override
 	public Fields serialize() throws NotSerializableException {
 		final Fields f = super.serialize();
diff --git a/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java b/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java
index d08200c7e1a..1e0f9ec0d50 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java
@@ -20,6 +20,8 @@
 
 import java.util.List;
 
+import ch.njol.skript.classes.Changer.ChangeMode;
+import ch.njol.util.coll.CollectionUtils;
 import org.bukkit.block.Block;
 import org.bukkit.event.Event;
 import org.bukkit.event.entity.EntityExplodeEvent;
@@ -38,12 +40,27 @@
 import ch.njol.util.Kleenean;
 
 @Name("Exploded Blocks")
-@Description("Get all the blocks that were destroyed in an explode event")
-@Examples({"on explode:",
-	"\tloop exploded blocks:",
-	"\t\tadd loop-block to {exploded::blocks::*}"})
+@Description("Get all the blocks that were destroyed in an explode event. Supports add/remove/set/clear/delete blocks.")
+@Examples({
+	"on explode:",
+		"\tloop exploded blocks:",
+			"\t\tadd loop-block to {exploded::blocks::*}",
+	"",
+	"on explode:",
+		"\tloop exploded blocks:",
+			"\t\tif loop-block is grass:",
+				"\t\t\tremove loop-block from exploded blocks",
+	"",
+	"on explode:",
+		"\tclear exploded blocks",
+	"",
+	"on explode:",
+		"\tset exploded blocks to blocks in radius 10 around event-entity",
+	"",
+	"on explode:",
+		"\tadd blocks above event-entity to exploded blocks"})
 @Events("explode")
-@Since("2.5")
+@Since("2.5, 2.8.6 (modify blocks)")
 public class ExprExplodedBlocks extends SimpleExpression<Block> {
 
 	static {
@@ -68,6 +85,47 @@ protected Block[] get(Event e) {
 		List<Block> blockList = ((EntityExplodeEvent) e).blockList();
 		return blockList.toArray(new Block[blockList.size()]);
 	}
+
+	@Override
+	public @Nullable Class<?>[] acceptChange(ChangeMode mode) {
+		switch (mode) {
+			case ADD:
+			case REMOVE:
+			case SET:
+			case DELETE:
+				return CollectionUtils.array(Block[].class);
+			default:
+				return null;
+		}
+	}
+
+	@Override
+	public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
+		if (!(event instanceof EntityExplodeEvent))
+			return;
+
+		List<Block> blocks = ((EntityExplodeEvent) event).blockList();
+		switch (mode) {
+			case DELETE:
+				blocks.clear();
+				break;
+			case SET:
+				blocks.clear();
+				// Fallthrough intended
+			case ADD:
+				for (Object object : delta) {
+					if (object instanceof Block)
+						blocks.add((Block) object);
+				}
+				break;
+			case REMOVE:
+				for (Object object : delta) {
+					if (object instanceof Block)
+						blocks.remove((Block) object);
+				}
+				break;
+		}
+	}
 	
 	@Override
 	public boolean isSingle() {
diff --git a/src/main/java/ch/njol/skript/expressions/ExprStringCase.java b/src/main/java/ch/njol/skript/expressions/ExprStringCase.java
index af963a333af..7a21357dca8 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprStringCase.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprStringCase.java
@@ -153,22 +153,28 @@ public Class<? extends String> getReturnType() {
 	}
 
 	@Override
-	public String toString(@Nullable Event e, boolean debug) {
+	public String toString(@Nullable Event event, boolean debug) {
+		String mode = "";
 		switch (type) {
 			case 0: // Basic Case Change 
-				return (casemode == 1) ? "uppercase" : "lowercase";
+				mode = (casemode == 1) ? "uppercase" : "lowercase";
+				break;
 			case 1: // Proper Case 
-				return ((casemode == 3) ? "strict" : "lenient") + " proper case";
+				mode = ((casemode == 3) ? "strict" : "lenient") + " proper case";
+				break;
 			case 2: // Camel Case 
-				return ((casemode == 3) ? "strict" : "lenient") + " camel case";
+				mode = ((casemode == 3) ? "strict" : "lenient") + " camel case";
+				break;
 			case 3: // Pascal Case 
-				return ((casemode == 3) ? "strict" : "lenient") + " pascal case";
+				mode = ((casemode == 3) ? "strict" : "lenient") + " pascal case";
+				break;
 			case 4: // Snake Case 
-				return ((casemode == 0) ? "" : ((casemode == 1)) ? "upper " : "lower ") + "snake case";
+				mode = ((casemode == 0) ? "" : ((casemode == 1)) ? "upper " : "lower ") + "snake case";
+				break;
 			case 5: // Kebab Case 
-				return ((casemode == 0) ? "" : ((casemode == 1)) ? "upper " : "lower ") + "kebab case";
+				mode = ((casemode == 0) ? "" : ((casemode == 1)) ? "upper " : "lower ") + "kebab case";
 		}
-		return ""; // Shouldn't reach here anyways 
+		return mode + " " + expr.toString(event, debug);
 	}
 	
 	@SuppressWarnings("null")
diff --git a/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java b/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
index 62f2a695e85..3b1ff35b6d9 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
@@ -18,6 +18,7 @@
  */
 package ch.njol.skript.expressions;
 
+import ch.njol.util.VectorMath;
 import org.bukkit.event.Event;
 import org.bukkit.util.Vector;
 import org.eclipse.jdt.annotation.Nullable;
@@ -70,7 +71,7 @@ public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
 				//$FALL-THROUGH$
 			case ADD:
 				for (Vector vector : vectors) {
-					if (deltaLength < 0 && vector.lengthSquared() < deltaLength * deltaLength) {
+					if (VectorMath.isZero(vector) || (deltaLength < 0 && vector.lengthSquared() < deltaLength * deltaLength)) {
 						vector.zero();
 					} else {
 						double newLength = deltaLength + vector.length();
@@ -82,7 +83,7 @@ public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
 				break;
 			case SET:
 				for (Vector vector : vectors) {
-					if (deltaLength < 0) {
+					if (deltaLength < 0 || VectorMath.isZero(vector)) {
 						vector.zero();
 					} else {
 						if (!vector.isNormalized())
diff --git a/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java b/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java
index db136199bbb..94dca461a5a 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java
@@ -18,6 +18,7 @@
  */
 package ch.njol.skript.expressions;
 
+import ch.njol.util.VectorMath;
 import org.bukkit.event.Event;
 import org.bukkit.util.Vector;
 import org.eclipse.jdt.annotation.Nullable;
@@ -63,7 +64,7 @@ protected Vector[] get(Event event) {
 		if (vector == null)
 			return null;
 		vector = vector.clone();
-		if (!vector.isNormalized())
+		if (!VectorMath.isZero(vector) && !vector.isNormalized())
 			vector.normalize();
 		return CollectionUtils.array(vector);
 	}
diff --git a/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java b/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java
index 0f72b2cb87e..cffd4515c9b 100644
--- a/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java
+++ b/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java
@@ -35,6 +35,7 @@
 import ch.njol.skript.util.LiteralUtils;
 import ch.njol.skript.util.Patterns;
 import ch.njol.util.Kleenean;
+import com.google.common.collect.ImmutableSet;
 import org.bukkit.event.Event;
 import org.eclipse.jdt.annotation.Nullable;
 import org.skriptlang.skript.lang.arithmetic.Arithmetics;
@@ -44,6 +45,7 @@
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Collection;
 
 @Name("Arithmetic")
 @Description("Arithmetic expressions, e.g. 1 + 2, (health of player - 2) / 3, etc.")
@@ -108,6 +110,7 @@ public PatternInfo(Operator operator, boolean leftGrouped, boolean rightGrouped)
 	private Operator operator;
 
 	private Class<? extends T> returnType;
+	private Collection<Class<?>> knownReturnTypes;
 
 	// A chain of expressions and operators, alternating between the two. Always starts and ends with an expression.
 	private final List<Object> chain = new ArrayList<>();
@@ -250,10 +253,12 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			}
 			if (returnTypes == null) { // both are object; can't determine anything
 				returnType = (Class<? extends T>) Object.class;
+				knownReturnTypes = Arithmetics.getAllReturnTypes(operator);
 			} else if (returnTypes.length == 0) { // one of the classes is known but doesn't have any operations
 				return error(firstClass, secondClass);
 			} else {
 				returnType = (Class<? extends T>) Classes.getSuperClassInfo(returnTypes).getC();
+				knownReturnTypes = ImmutableSet.copyOf(returnTypes);
 			}
 		} else if (returnType == null) { // lookup
 			OperationInfo<L, R, T> operationInfo = (OperationInfo<L, R, T>) Arithmetics.lookupOperationInfo(operator, firstClass, secondClass);
@@ -328,6 +333,21 @@ public Class<? extends T> getReturnType() {
 		return returnType;
 	}
 
+	@Override
+	public Class<? extends T>[] possibleReturnTypes() {
+		if (returnType == Object.class)
+			//noinspection unchecked
+			return knownReturnTypes.toArray(new Class[0]);
+		return super.possibleReturnTypes();
+	}
+
+	@Override
+	public boolean canReturn(Class<?> returnType) {
+		if (this.returnType == Object.class && knownReturnTypes.contains(returnType))
+			return true;
+		return super.canReturn(returnType);
+	}
+
 	@Override
 	public boolean isSingle() {
 		return true;
diff --git a/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java b/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java
index fdec45e23b1..4274e4aef3a 100644
--- a/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java
+++ b/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java
@@ -146,5 +146,15 @@ public Expression<? extends T> simplify() {
 	public Object[] beforeChange(Expression<?> changed, @Nullable Object[] delta) {
 		return expr.beforeChange(changed, delta); // Forward to what we're wrapping
 	}
-	
+
+	@Override
+	public Class<? extends T>[] possibleReturnTypes() {
+		return expr.possibleReturnTypes();
+	}
+
+	@Override
+	public boolean canReturn(Class<?> returnType) {
+		return expr.canReturn(returnType);
+	}
+
 }
diff --git a/src/main/java/ch/njol/skript/lang/Expression.java b/src/main/java/ch/njol/skript/lang/Expression.java
index ebde53ee479..9c7439f7585 100644
--- a/src/main/java/ch/njol/skript/lang/Expression.java
+++ b/src/main/java/ch/njol/skript/lang/Expression.java
@@ -189,6 +189,31 @@ default boolean canBeSingle() {
 	 */
 	Class<? extends T> getReturnType();
 
+	/**
+	 * For expressions that might return multiple (incalculable at parse time) types,
+	 * this provides a list of all possible types.
+	 * Use cases include: expressions that depend on the return type of their input.
+	 *
+	 * @return A list of all possible types this might return
+	 */
+	default Class<? extends T>[] possibleReturnTypes() {
+		//noinspection unchecked
+		return new Class[] {this.getReturnType()};
+	}
+
+	/**
+	 * Whether this expression <b>might</b> return the following type.
+	 * @param returnType The type to test
+	 * @return true if the argument is within the bounds of the return types
+	 */
+	default boolean canReturn(Class<?> returnType) {
+		for (Class<?> type : this.possibleReturnTypes()) {
+			if (returnType.isAssignableFrom(type))
+				return true;
+		}
+		return false;
+	}
+
 	/**
 	 * Returns true if this expression returns all possible values, false if it only returns some of them.
 	 * <p>
diff --git a/src/main/java/ch/njol/skript/lang/ExpressionList.java b/src/main/java/ch/njol/skript/lang/ExpressionList.java
index 1440a84bd2e..fa6612b3422 100644
--- a/src/main/java/ch/njol/skript/lang/ExpressionList.java
+++ b/src/main/java/ch/njol/skript/lang/ExpressionList.java
@@ -43,6 +43,7 @@ public class ExpressionList<T> implements Expression<T> {
 
 	protected final Expression<? extends T>[] expressions;
 	private final Class<T> returnType;
+	private final Class<?>[] possibleReturnTypes;
 	protected boolean and;
 	private final boolean single;
 
@@ -53,10 +54,19 @@ public ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType
 		this(expressions, returnType, and, null);
 	}
 
+	public ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and) {
+		this(expressions, returnType, possibleReturnTypes, and, null);
+	}
+
 	protected ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, boolean and, @Nullable ExpressionList<?> source) {
+		this(expressions, returnType, new Class[]{returnType}, and, source);
+	}
+
+	protected ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and, @Nullable ExpressionList<?> source) {
 		assert expressions != null;
 		this.expressions = expressions;
 		this.returnType = returnType;
+		this.possibleReturnTypes = possibleReturnTypes;
 		this.and = and;
 		if (and) {
 			single = false;
@@ -178,7 +188,7 @@ public <R> Expression<? extends R> getConvertedExpression(Class<R>... to) {
 				return null;
 			returnTypes[i] = exprs[i].getReturnType();
 		}
-		return new ExpressionList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), and, this);
+		return new ExpressionList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), returnTypes, and, this);
 	}
 
 	@Override
@@ -186,6 +196,12 @@ public Class<T> getReturnType() {
 		return returnType;
 	}
 
+	@Override
+	public Class<? extends T>[] possibleReturnTypes() {
+		//noinspection unchecked
+		return (Class<? extends T>[]) possibleReturnTypes;
+	}
+
 	@Override
 	public boolean getAnd() {
 		return and;
diff --git a/src/main/java/ch/njol/skript/lang/LiteralList.java b/src/main/java/ch/njol/skript/lang/LiteralList.java
index 4c5cec551dd..f432bd1c095 100644
--- a/src/main/java/ch/njol/skript/lang/LiteralList.java
+++ b/src/main/java/ch/njol/skript/lang/LiteralList.java
@@ -26,7 +26,7 @@
 
 /**
  * A list of literals. Can contain {@link UnparsedLiteral}s.
- * 
+ *
  * @author Peter Güttinger
  */
 public class LiteralList<T> extends ExpressionList<T> implements Literal<T> {
@@ -35,10 +35,18 @@ public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, boolean
 		super(literals, returnType, and);
 	}
 
+	public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and) {
+		super(literals, returnType, possibleReturnTypes, and);
+	}
+
 	public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, boolean and, LiteralList<?> source) {
 		super(literals, returnType, and, source);
 	}
 
+	public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and, LiteralList<?> source) {
+		super(literals, returnType, possibleReturnTypes, and, source);
+	}
+
 	@Override
 	public T[] getArray() {
 		return getArray(null);
@@ -64,7 +72,7 @@ public <R> Literal<? extends R> getConvertedExpression(final Class<R>... to) {
 				return null;
 			returnTypes[i] = exprs[i].getReturnType();
 		}
-		return new LiteralList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), and, this);
+		return new LiteralList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), returnTypes, and, this);
 	}
 
 	@Override
diff --git a/src/main/java/ch/njol/skript/lang/ReturnHandler.java b/src/main/java/ch/njol/skript/lang/ReturnHandler.java
new file mode 100644
index 00000000000..f908fc68c51
--- /dev/null
+++ b/src/main/java/ch/njol/skript/lang/ReturnHandler.java
@@ -0,0 +1,194 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.lang;
+
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.SkriptAPIException;
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.lang.parser.ParserInstance;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.ApiStatus.NonExtendable;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public interface ReturnHandler<T> {
+
+	/**
+	 * Loads the code in the given {@link SectionNode} using the same logic as
+	 * {@link Section#loadCode(SectionNode)} and pushes the section onto the
+	 * return handler stack
+	 * <br>
+	 * <b>This method may only be called by a {@link Section}</b>
+	 * @throws SkriptAPIException if this return handler is not a {@link Section}
+	 */
+	@NonExtendable
+	default void loadReturnableSectionCode(SectionNode node) {
+		if (!(this instanceof Section))
+			throw new SkriptAPIException("loadReturnableSectionCode called on a non-section object");
+		ParserInstance parser = ParserInstance.get();
+		ReturnHandlerStack stack = parser.getData(ReturnHandlerStack.class);
+		stack.push(this);
+		Section section = (Section) this;
+		try {
+			section.loadCode(node);
+		} finally {
+			stack.pop();
+		}
+	}
+
+	/**
+	 * Loads the code in the given {@link SectionNode} using the same logic as
+	 * {@link Section#loadCode(SectionNode, String, Class[])} and pushes the section onto the
+	 * return handler stack
+	 * <br>
+	 * <b>This method may only be called by a {@link Section}</b>
+	 * @param node the section node
+	 * @param name the name of the event(s) being used
+	 * @param events the event(s) during the section's execution
+	 * @return a returnable trigger containing the loaded section.
+	 * This should be stored and used to run the section one or more times
+	 * @throws SkriptAPIException if this return handler is not a {@link Section}
+	 */
+	@NonExtendable
+	default ReturnableTrigger<T> loadReturnableSectionCode(SectionNode node, String name, Class<? extends Event>[] events) {
+		if (!(this instanceof Section))
+			throw new SkriptAPIException("loadReturnableSectionCode called on a non-section object");
+		ParserInstance parser = ParserInstance.get();
+		ParserInstance.Backup parserBackup = parser.backup();
+		parser.reset();
+
+		parser.setCurrentEvent(name, events);
+		SkriptEvent skriptEvent = new SectionSkriptEvent(name, (Section) this);
+		parser.setCurrentStructure(skriptEvent);
+		ReturnHandlerStack stack = parser.getData(ReturnHandlerStack.class);
+
+		try {
+			return new ReturnableTrigger<>(
+				this,
+				parser.getCurrentScript(),
+				name,
+				skriptEvent,
+				trigger -> {
+					stack.push(trigger);
+					return ScriptLoader.loadItems(node);
+				}
+			);
+		} finally {
+			stack.pop();
+			parser.restoreBackup(parserBackup);
+		}
+	}
+
+	/**
+	 * Loads the code in the given {@link SectionNode} into a {@link ReturnableTrigger}.
+	 * <br>
+	 * This is a general method to load a section node without extra logic
+	 * done to the {@link ParserInstance}.
+	 * The calling code is expected to manage the {@code ParserInstance} accordingly, which may vary depending on
+	 * where the code being loaded is located and what state the {@code ParserInstance} is in.
+	 * @param node the section node to load
+	 * @param name the name of the trigger
+	 * @param event the {@link SkriptEvent} of the trigger
+	 * @return a returnable trigger containing the loaded section node
+	 */
+	@NonExtendable
+	default ReturnableTrigger<T> loadReturnableTrigger(SectionNode node, String name, SkriptEvent event) {
+		ParserInstance parser = ParserInstance.get();
+		ReturnHandlerStack stack = parser.getData(ReturnHandlerStack.class);
+		try {
+			return new ReturnableTrigger<T>(
+				this,
+				parser.getCurrentScript(),
+				name,
+				event,
+				trigger -> {
+					stack.push(trigger);
+					return ScriptLoader.loadItems(node);
+				}
+			);
+		} finally {
+			stack.pop();
+		}
+	}
+
+	/**
+	 * @param values the values to return
+	 */
+	void returnValues(T @Nullable [] values);
+
+	/**
+	 * @return whether this return handler may accept multiple return values
+	 */
+	boolean isSingleReturnValue();
+
+	/**
+	 * The return type of this return handler, or null if it can't
+	 * accept return values in this context (e.g. a function without a return type).
+	 *
+	 * @return the return type
+	 */
+	@Nullable Class<? extends T> returnValueType();
+
+	class ReturnHandlerStack extends ParserInstance.Data {
+
+		private final Deque<ReturnHandler<?>> stack = new LinkedList<>();
+
+		public ReturnHandlerStack(ParserInstance parserInstance) {
+			super(parserInstance);
+		}
+
+		public Deque<ReturnHandler<?>> getStack() {
+			return stack;
+		}
+
+		/**
+		 * Retrieves the current {@link ReturnHandler}
+		 * @return the return data
+		 */
+		public @Nullable ReturnHandler<?> getCurrentHandler() {
+			return stack.peek();
+		}
+
+		/**
+		 * Pushes the current return handler onto the return stack.
+		 * <br>
+		 * <b>Note: After the trigger finished loading,
+		 * {@link ReturnHandlerStack#pop()} <u>MUST</u> be called</b>
+		 * @param handler the return handler
+		 * @see ReturnHandlerStack#pop()
+		 */
+		public void push(ReturnHandler<?> handler) {
+			stack.push(handler);
+		}
+
+		/**
+		 * Pops the current handler off the return stack.
+		 * Should be called after the trigger has finished loading.
+		 * @return the popped return data
+		 * @see ReturnHandlerStack#push(ReturnHandler)  
+		 */
+		public ReturnHandler<?> pop() {
+			return stack.pop();
+		}
+
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/lang/ReturnableTrigger.java b/src/main/java/ch/njol/skript/lang/ReturnableTrigger.java
new file mode 100644
index 00000000000..51c025ef70c
--- /dev/null
+++ b/src/main/java/ch/njol/skript/lang/ReturnableTrigger.java
@@ -0,0 +1,53 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.lang;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.skriptlang.skript.lang.script.Script;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+public class ReturnableTrigger<T> extends Trigger implements ReturnHandler<T> {
+
+	private final ReturnHandler<T> handler;
+
+	public ReturnableTrigger(ReturnHandler<T> handler, @Nullable Script script, String name, SkriptEvent event, Function<ReturnHandler<T>, List<TriggerItem>> loadItems) {
+		super(script, name, event, Collections.emptyList());
+		this.handler = handler;
+		setTriggerItems(loadItems.apply(this));
+	}
+
+	@Override
+	public void returnValues(T @Nullable [] values) {
+		handler.returnValues(values);
+	}
+
+	@Override
+	public boolean isSingleReturnValue() {
+		return handler.isSingleReturnValue();
+	}
+
+	@Override
+	public @Nullable Class<? extends T> returnValueType() {
+		return handler.returnValueType();
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/lang/SkriptParser.java b/src/main/java/ch/njol/skript/lang/SkriptParser.java
index 743f1abee09..3318bdb07cc 100644
--- a/src/main/java/ch/njol/skript/lang/SkriptParser.java
+++ b/src/main/java/ch/njol/skript/lang/SkriptParser.java
@@ -57,7 +57,6 @@
 
 import java.util.ArrayList;
 import java.util.Deque;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
@@ -76,7 +75,7 @@
  * Used for parsing my custom patterns.<br>
  * <br>
  * Note: All parse methods print one error at most xor any amount of warnings and lower level log messages. If the given string doesn't match any pattern then nothing is printed.
- * 
+ *
  * @author Peter Güttinger
  */
 public class SkriptParser {
@@ -102,7 +101,7 @@ public SkriptParser(String expr, int flags) {
 	 * Constructs a new SkriptParser object that can be used to parse the given expression.
 	 * <p>
 	 * A SkriptParser can be re-used indefinitely for the given expression, but to parse a new expression a new SkriptParser has to be created.
-	 * 
+	 *
 	 * @param expr The expression to parse
 	 * @param flags Some parse flags ({@link #PARSE_EXPRESSIONS}, {@link #PARSE_LITERALS})
 	 * @param context The parse context
@@ -371,7 +370,7 @@ private <T> Expression<? extends T> parseSingleExpr(boolean allowUnparsedLiteral
 				if (parsedExpression != null) { // Expression/VariableString parsing success
 					for (Class<? extends T> type : types) {
 						// Check return type against everything that expression accepts
-						if (type.isAssignableFrom(parsedExpression.getReturnType())) {
+						if (parsedExpression.canReturn(type)) {
 							log.printLog();
 							return (Expression<? extends T>) parsedExpression;
 						}
@@ -541,17 +540,13 @@ private Expression<?> parseSingleExpr(boolean allowUnparsedLiteral, @Nullable Lo
 			if ((flags & PARSE_EXPRESSIONS) != 0) {
 				Expression<?> parsedExpression = parseExpression(types, expr);
 				if (parsedExpression != null) { // Expression/VariableString parsing success
-					Class<?> returnType = parsedExpression.getReturnType(); // Sometimes getReturnType does non-trivial costly operations
-					if (returnType == null)
-						throw new SkriptAPIException("Expression '" + expr + "' returned null for method Expression#getReturnType. Null is not a valid return.");
-
 					for (int i = 0; i < types.length; i++) {
 						Class<?> type = types[i];
 						if (type == null) // Ignore invalid (null) types
 							continue;
 
 						// Check return type against everything that expression accepts
-						if (type.isAssignableFrom(returnType)) {
+						if (parsedExpression.canReturn(type)) {
 							if (!exprInfo.isPlural[i] && !parsedExpression.isSingle()) { // Wrong number of arguments
 								if (context == ParseContext.COMMAND) {
 									Skript.error(Commands.m_too_many_arguments.toString(exprInfo.classes[i].getName().getIndefiniteArticle(), exprInfo.classes[i].getName().toString()), ErrorQuality.SEMANTIC_ERROR);
@@ -752,11 +747,15 @@ private <T> Expression<? extends T> parseExpressionList(ParseLogHandler log, Cla
 			exprReturnTypes[i] = parsedExpressions.get(i).getReturnType();
 
 		if (isLiteralList) {
-			Literal<T>[] literals = parsedExpressions.toArray(new Literal[parsedExpressions.size()]);
-			return new LiteralList<>(literals, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+			//noinspection unchecked,SuspiciousToArrayCall
+			Literal<T>[] literals = parsedExpressions.toArray(new Literal[0]);
+			//noinspection unchecked
+			return new LiteralList<>(literals, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 		} else {
-			Expression<T>[] expressions = parsedExpressions.toArray(new Expression[parsedExpressions.size()]);
-			return new ExpressionList<>(expressions, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+			//noinspection unchecked
+			Expression<T>[] expressions = parsedExpressions.toArray(new Expression[0]);
+			//noinspection unchecked
+			return new ExpressionList<>(expressions, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 		}
 	}
 
@@ -885,10 +884,10 @@ public Expression<?> parseExpression(ExprInfo exprInfo) {
 
 			if (isLiteralList) {
 				Literal<?>[] literals = parsedExpressions.toArray(new Literal[parsedExpressions.size()]);
-				return new LiteralList(literals, Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+				return new LiteralList(literals, Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 			} else {
 				Expression<?>[] expressions = parsedExpressions.toArray(new Expression[parsedExpressions.size()]);
-				return new ExpressionList(expressions, Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+				return new ExpressionList(expressions, Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 
 			}
 		} finally {
@@ -1044,7 +1043,7 @@ public static ParseResult parse(String text, SkriptPattern pattern, int parseFla
 
 	/**
 	 * Finds the closing bracket of the group at <tt>start</tt> (i.e. <tt>start</tt> has to be <i>in</i> a group).
-	 * 
+	 *
 	 * @param pattern The string to search in
 	 * @param closingBracket The bracket to look for, e.g. ')'
 	 * @param openingBracket A bracket that opens another group, e.g. '('
@@ -1095,7 +1094,7 @@ private static int nextUnescaped(String pattern, char character, int from) {
 
 	/**
 	 * Counts how often the given character occurs in the given string, ignoring any escaped occurrences of the character.
-	 * 
+	 *
 	 * @param haystack The string to search in
 	 * @param needle The character to search for
 	 * @return The number of unescaped occurrences of the given character
@@ -1130,7 +1129,7 @@ static int countUnescaped(String haystack, char needle, int start, int end) {
 
 	/**
 	 * Find the next unescaped (i.e. single) double quote in the string.
-	 * 
+	 *
 	 * @param string The string to search in
 	 * @param start Index after the starting quote
 	 * @return Index of the end quote
@@ -1201,7 +1200,7 @@ public static String notOfType(ClassInfo<?>... types) {
 	 * Returns the next character in the expression, skipping strings,
 	 * variables and parentheses
 	 * (unless {@code context} is {@link ParseContext#COMMAND} or {@link ParseContext#PARSE}).
-	 * 
+	 *
 	 * @param expr The expression to traverse.
 	 * @param startIndex The index to start at.
 	 * @return The next index (can be expr.length()), or -1 if
@@ -1319,7 +1318,7 @@ private ParseResult parse_i(String pattern) {
 
 	/**
 	 * Validates a user-defined pattern (used in {@link ExprParse}).
-	 * 
+	 *
 	 * @param pattern The pattern string to validate
 	 * @return The pattern with %codenames% and a boolean array that contains whether the expressions are plural or not
 	 */
diff --git a/src/main/java/ch/njol/skript/lang/function/Functions.java b/src/main/java/ch/njol/skript/lang/function/Functions.java
index bc19f2bbf72..2eee7ea6c18 100644
--- a/src/main/java/ch/njol/skript/lang/function/Functions.java
+++ b/src/main/java/ch/njol/skript/lang/function/Functions.java
@@ -121,7 +121,7 @@ public static Function<?> loadFunction(Script script, SectionNode node, Signatur
 			Skript.debug((signature.local ? "local " : "") + "function " + name + "(" + StringUtils.join(params, ", ") + ")"
 				+ (c != null ? " :: " + (signature.isSingle() ? c.getName().getSingular() : c.getName().getPlural()) : "") + ":");
 
-		Function<?> f = new ScriptFunction<>(signature, script, node);
+		Function<?> f = new ScriptFunction<>(signature, node);
 
 		// Register the function for signature
 		namespace.addFunction(f);
diff --git a/src/main/java/ch/njol/skript/lang/function/ScriptFunction.java b/src/main/java/ch/njol/skript/lang/function/ScriptFunction.java
index 259c8bcad85..d3a1e85117c 100644
--- a/src/main/java/ch/njol/skript/lang/function/ScriptFunction.java
+++ b/src/main/java/ch/njol/skript/lang/function/ScriptFunction.java
@@ -18,58 +18,49 @@
  */
 package ch.njol.skript.lang.function;
 
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.lang.ReturnHandler;
+import org.jetbrains.annotations.ApiStatus;
 import org.skriptlang.skript.lang.script.Script;
 import org.eclipse.jdt.annotation.Nullable;
 
-import ch.njol.skript.ScriptLoader;
 import ch.njol.skript.config.SectionNode;
 import ch.njol.skript.effects.EffReturn;
 import ch.njol.skript.lang.Trigger;
 import ch.njol.skript.lang.util.SimpleEvent;
 import ch.njol.skript.variables.Variables;
 
-/**
- * @author Peter Güttinger
- */
-public class ScriptFunction<T> extends Function<T> {
-	
+public class ScriptFunction<T> extends Function<T> implements ReturnHandler<T> {
+
 	private final Trigger trigger;
-	
+
+	private boolean returnValueSet;
+	private T @Nullable [] returnValues;
+
+	/**
+	 * @deprecated use {@link ScriptFunction#ScriptFunction(Signature, SectionNode)}
+	 */
+	@Deprecated
 	public ScriptFunction(Signature<T> sign, Script script, SectionNode node) {
+		this(sign, node);
+	}
+	
+	public ScriptFunction(Signature<T> sign, SectionNode node) {
 		super(sign);
-		
+
 		Functions.currentFunction = this;
 		try {
-			trigger = new Trigger(
-				script,
-				"function " + sign.getName(),
-				new SimpleEvent(),
-				ScriptLoader.loadItems(node)
-			);
-			trigger.setLineNumber(node.getLine());
+			trigger = loadReturnableTrigger(node, "function " + sign.getName(), new SimpleEvent());
 		} finally {
 			Functions.currentFunction = null;
 		}
+		trigger.setLineNumber(node.getLine());
 	}
-	
-	private boolean returnValueSet = false;
-	@Nullable
-	private T[] returnValue = null;
-	
-	/**
-	 * Should only be called by {@link EffReturn}.
-	 */
-	public final void setReturnValue(final @Nullable T[] value) {
-		assert !returnValueSet;
-		returnValueSet = true;
-		returnValue = value;
-	}
-	
+
 	// REMIND track possible types of local variables (including undefined variables) (consider functions, commands, and EffChange) - maybe make a general interface for this purpose
 	// REM: use patterns, e.g. {_a%b%} is like "a.*", and thus subsequent {_axyz} may be set and of that type.
 	@Override
-	@Nullable
-	public T[] execute(final FunctionEvent<?> e, final Object[][] params) {
+	public T @Nullable [] execute(final FunctionEvent<?> e, final Object[][] params) {
 		Parameter<?>[] parameters = getSignature().getParameters();
 		for (int i = 0; i < parameters.length; i++) {
 			Parameter<?> p = parameters[i];
@@ -84,14 +75,42 @@ public T[] execute(final FunctionEvent<?> e, final Object[][] params) {
 		}
 		
 		trigger.execute(e);
-		return returnValue;
+		ClassInfo<T> returnType = getReturnType();
+		return returnType != null ? returnValues : null;
+	}
+
+	/**
+	 * Should only be called by {@link EffReturn}.
+	 * @deprecated Use {@link ScriptFunction#returnValues(Object[])}
+	 */
+	@Deprecated
+	@ApiStatus.Internal
+	public final void setReturnValue(@Nullable T[] values) {
+		returnValues(values);
 	}
 
 	@Override
 	public boolean resetReturnValue() {
-		returnValue = null;
 		returnValueSet = false;
+		returnValues = null;
 		return true;
 	}
 
+	@Override
+	public final void returnValues(T @Nullable [] values) {
+		assert !returnValueSet;
+		returnValueSet = true;
+		this.returnValues = values;
+	}
+
+	@Override
+	public final boolean isSingleReturnValue() {
+		return isSingle();
+	}
+
+	@Override
+	public final @Nullable Class<? extends T> returnValueType() {
+		return getReturnType() != null ? getReturnType().getC() : null;
+	}
+
 }
diff --git a/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java b/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java
index 74733cb9f2b..5fff6740da5 100644
--- a/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java
+++ b/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java
@@ -33,8 +33,13 @@
 import org.skriptlang.skript.lang.converter.ConverterInfo;
 import org.skriptlang.skript.lang.converter.Converters;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
 
 /**
  * Represents a expression converted to another type. This, and not Expression, is the required return type of {@link SimpleExpression#getConvertedExpr(Class...)} because this
@@ -43,7 +48,7 @@
  * <li>automatically lets the source expression handle everything apart from the get() methods</li>
  * <li>will never convert itself to another type, but rather request a new converted expression from the source expression.</li>
  * </ol>
- * 
+ *
  * @author Peter Güttinger
  */
 public class ConvertedExpression<F, T> implements Expression<T> {
@@ -55,28 +60,59 @@ public class ConvertedExpression<F, T> implements Expression<T> {
 	/**
 	 * Converter information.
 	 */
-	private final ConverterInfo<? super F, ? extends T> converterInfo;
+	private final Collection<ConverterInfo<? super F, ? extends T>> converterInfos;
 
 	public ConvertedExpression(Expression<? extends F> source, Class<T> to, ConverterInfo<? super F, ? extends T> info) {
 		this.source = source;
 		this.to = to;
 		this.converter = info.getConverter();
-		this.converterInfo = info;
+		this.converterInfos = Collections.singleton(info);
+	}
+
+	/**
+	 * @param source The expression to use for obtaining values
+	 * @param to The type we are converting to
+	 * @param infos A collection of converters to attempt
+	 * @param performFromCheck Whether a safety check should be performed to ensure that objects being converted
+	 *  are valid for the converter being attempted
+	 */
+	public ConvertedExpression(Expression<? extends F> source, Class<T> to, Collection<ConverterInfo<? super F, ? extends T>> infos, boolean performFromCheck) {
+		this.source = source;
+		this.to = to;
+		this.converterInfos = infos;
+		this.converter = fromObject -> {
+			for (ConverterInfo<? super F, ? extends T> info : converterInfos) {
+				if (!performFromCheck || info.getFrom().isInstance(fromObject)) { // the converter is safe to attempt
+					T converted = info.getConverter().convert(fromObject);
+					if (converted != null)
+						return converted;
+				}
+			}
+			return null;
+		};
 	}
 
 	@SafeVarargs
 	@Nullable
 	public static <F, T> ConvertedExpression<F, T> newInstance(Expression<F> from, Class<T>... to) {
 		assert !CollectionUtils.containsSuperclass(to, from.getReturnType());
+		// we track a list of converters that may work
+		List<ConverterInfo<? super F, ? extends T>> converters = new ArrayList<>();
 		for (Class<T> type : to) { // REMIND try more converters? -> also change WrapperExpression (and maybe ExprLoopValue)
 			assert type != null;
 			// casting <? super ? extends F> to <? super F> is wrong, but since the converter is only used for values returned by the expression
 			// (which are instances of "<? extends F>") this won't result in any ClassCastExceptions.
-			@SuppressWarnings("unchecked")
-			ConverterInfo<? super F, ? extends T> conv = (ConverterInfo<? super F, ? extends T>) Converters.getConverterInfo(from.getReturnType(), type);
-			if (conv == null)
-				continue;
-			return new ConvertedExpression<>(from, type, conv);
+			for (Class<? extends F> checking : from.possibleReturnTypes()) {
+				//noinspection unchecked
+				ConverterInfo<? super F, ? extends T> converter = (ConverterInfo<? super F, ? extends T>) Converters.getConverterInfo(checking, type);
+				if (converter != null)
+					converters.add(converter);
+			}
+			int size = converters.size();
+			if (size == 1) // if there is only one info, there is no need to wrap it in a list
+				return new ConvertedExpression<>(from, type, converters.get(0));
+			if (size > 1)
+				return new ConvertedExpression<>(from, type, converters, true);
 		}
 		return null;
 	}
@@ -90,7 +126,7 @@ public final boolean init(Expression<?>[] vars, int matchedPattern, Kleenean isD
 	public String toString(@Nullable Event event, boolean debug) {
 		if (debug && event == null)
 			return "(" + source.toString(event, debug) + " >> " + converter + ": "
-				+ converterInfo + ")";
+				+ converterInfos.stream().map(Object::toString).collect(Collectors.joining(", ")) + ")";
 		return source.toString(event, debug);
 	}
 
diff --git a/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java b/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java
index 9e5af263ef4..daa44c7f9f8 100644
--- a/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java
+++ b/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java
@@ -35,10 +35,13 @@
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.skriptlang.skript.lang.converter.Converter;
+import org.skriptlang.skript.lang.converter.ConverterInfo;
 
 import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
+import java.util.List;
 
 /**
  * An implementation of the {@link Expression} interface. You should usually extend this class to make a new expression.
@@ -200,8 +203,36 @@ public static <T> boolean check(@Nullable T[] values, Checker<? super T> checker
 	@Nullable
 	@SuppressWarnings("unchecked")
 	public <R> Expression<? extends R> getConvertedExpression(Class<R>... to) {
+		// check whether this expression is already of type R
 		if (CollectionUtils.containsSuperclass(to, getReturnType()))
 			return (Expression<? extends R>) this;
+
+		// we might be to cast some of the possible return types to R
+		List<ConverterInfo<? extends T, R>> infos = new ArrayList<>();
+		for (Class<? extends T> type : this.possibleReturnTypes()) {
+			if (CollectionUtils.containsSuperclass(to, type)) { // this type is of R
+				// build a converter that for casting to R
+				// safety check is present in the event that we do not get this type at runtime
+				final Class<R> toType = (Class<R>) type;
+				infos.add(new ConverterInfo<>(getReturnType(), toType, fromObject -> {
+					if (toType.isInstance(fromObject))
+						return (R) fromObject;
+					return null;
+				}, 0));
+			}
+		}
+		int size = infos.size();
+		if (size == 1) { // if there is only one info, there is no need to wrap it in a list
+			ConverterInfo<? extends T, R> info = infos.get(0);
+			//noinspection rawtypes
+			return new ConvertedExpression(this, info.getTo(), info);
+		}
+		if (size > 1) {
+			//noinspection rawtypes
+			return new ConvertedExpression(this, Utils.getSuperType(infos.stream().map(ConverterInfo::getTo).toArray(Class[]::new)), infos, false);
+		}
+
+		// attempt traditional conversion with proper converters
 		return this.getConvertedExpr(to);
 	}
 
diff --git a/src/main/java/ch/njol/skript/sections/EffSecSpawn.java b/src/main/java/ch/njol/skript/sections/EffSecSpawn.java
index 320b4d63c39..552bfb151b1 100644
--- a/src/main/java/ch/njol/skript/sections/EffSecSpawn.java
+++ b/src/main/java/ch/njol/skript/sections/EffSecSpawn.java
@@ -22,6 +22,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
+import ch.njol.skript.doc.RequiredPlugins;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.event.Event;
@@ -58,9 +59,9 @@
 	"spawn 3 creepers at the targeted block",
 	"spawn a ghast 5 meters above the player",
 	"spawn a zombie at the player:",
-	"\tset name of the zombie to \"\""
+		"\tset name of the zombie to \"\""
 })
-@Since("1.0, 2.6.1 (with section)")
+@Since("1.0, 2.6.1 (with section), 2.8.6 (dropped items)")
 public class EffSecSpawn extends EffectSection {
 
 	public static class SpawnEvent extends Event {
diff --git a/src/main/java/ch/njol/skript/structures/StructCommand.java b/src/main/java/ch/njol/skript/structures/StructCommand.java
index 12a0314b224..4348e23bb1f 100644
--- a/src/main/java/ch/njol/skript/structures/StructCommand.java
+++ b/src/main/java/ch/njol/skript/structures/StructCommand.java
@@ -81,6 +81,9 @@
 @Since("1.0")
 public class StructCommand extends Structure {
 
+	// Paper versions with the new command system need a delay before syncing commands or a CME will occur.
+	private static final boolean DELAY_COMMAND_SYNCING = Skript.classExists("io.papermc.paper.command.brigadier.Commands");
+
 	public static final Priority PRIORITY = new Priority(500);
 
 	private static final Pattern COMMAND_PATTERN = Pattern.compile("(?i)^command\\s+/?(\\S+)\\s*(\\s+(.+))?$");
@@ -318,7 +321,7 @@ public boolean load() {
 
 	@Override
 	public boolean postLoad() {
-		attemptCommandSync();
+		scheduleCommandSync();
 		return true;
 	}
 
@@ -331,20 +334,30 @@ public void unload() {
 
 	@Override
 	public void postUnload() {
-		attemptCommandSync();
+		scheduleCommandSync();
 	}
 
-	private void attemptCommandSync() {
+	private void scheduleCommandSync() {
 		if (SYNC_COMMANDS.get()) {
 			SYNC_COMMANDS.set(false);
-			if (CommandReloader.syncCommands(Bukkit.getServer())) {
-				Skript.debug("Commands synced to clients");
+			if (DELAY_COMMAND_SYNCING) {
+				// if the plugin is disabled, the server is likely closing and delaying will cause an error.
+				if (Bukkit.getPluginManager().isPluginEnabled(Skript.getInstance()))
+					Bukkit.getScheduler().runTask(Skript.getInstance(), this::forceCommandSync);
 			} else {
-				Skript.debug("Commands changed but not synced to clients (normal on 1.12 and older)");
+				forceCommandSync();
 			}
 		}
 	}
 
+	private void forceCommandSync() {
+		if (CommandReloader.syncCommands(Bukkit.getServer())) {
+			Skript.debug("Commands synced to clients");
+		} else {
+			Skript.debug("Commands changed but not synced to clients (normal on 1.12 and older)");
+		}
+	}
+
 	@Override
 	public Priority getPriority() {
 		return PRIORITY;
diff --git a/src/main/java/ch/njol/skript/test/platform/PlatformMain.java b/src/main/java/ch/njol/skript/test/platform/PlatformMain.java
index 7848180dde3..ab72df70985 100644
--- a/src/main/java/ch/njol/skript/test/platform/PlatformMain.java
+++ b/src/main/java/ch/njol/skript/test/platform/PlatformMain.java
@@ -152,9 +152,9 @@ public static void main(String... args) throws IOException, InterruptedException
 			output.append("\nFailed:");
 			for (String failed : failNames) {
 				List<NonNullPair<Environment, String>> errors = failures.get(failed);
-				output.append("  " + failed + " (on " + errors.size() + " environment" + (errors.size() == 1 ? "" : "s") + ")");
+				output.append("\n  " + failed + " (on " + errors.size() + " environment" + (errors.size() == 1 ? "" : "s") + ")");
 				for (NonNullPair<Environment, String> error : errors) {
-					output.append("    " + error.getSecond() + " (on " + error.getFirst().getName() + ")");
+					output.append("\n    " + error.getSecond() + " (on " + error.getFirst().getName() + ")");
 				}
 			}
 			output.append(String.format("%n%n%s", StringUtils.repeat("-", 60)));
diff --git a/src/main/java/ch/njol/skript/test/runner/EffObjectives.java b/src/main/java/ch/njol/skript/test/runner/EffObjectives.java
index 472abc4e7b5..0ebec184329 100644
--- a/src/main/java/ch/njol/skript/test/runner/EffObjectives.java
+++ b/src/main/java/ch/njol/skript/test/runner/EffObjectives.java
@@ -102,12 +102,13 @@ public static boolean isJUnitComplete() {
 	public static void fail() {
 		for (String test : requirements.keySet()) {
 			if (!completeness.containsKey(test)) {
-				TestTracker.JUnitTestFailed("JUnit test '" + test + "'", "didn't complete any objectives.");
+				TestTracker.JUnitTestFailed("JUnit: '" + test + "'", "didn't complete any objectives.");
 				continue;
 			}
 			List<String> failures = Lists.newArrayList(requirements.get(test));
 			failures.removeAll(completeness.get(test));
-			TestTracker.JUnitTestFailed("JUnit test '" + test + "'", "failed objectives: " + Arrays.toString(failures.toArray(new String[0])));
+			if (!failures.isEmpty())
+				TestTracker.JUnitTestFailed("JUnit: '" + test + "'", "failed objectives: " + Arrays.toString(failures.toArray(new String[0])));
 		}
 	}
 
diff --git a/src/main/java/ch/njol/skript/test/runner/SecReturnable.java b/src/main/java/ch/njol/skript/test/runner/SecReturnable.java
new file mode 100644
index 00000000000..436b6d282fb
--- /dev/null
+++ b/src/main/java/ch/njol/skript/test/runner/SecReturnable.java
@@ -0,0 +1,114 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.test.runner;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.doc.NoDoc;
+import ch.njol.skript.lang.*;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+@NoDoc
+public class SecReturnable extends Section implements ReturnHandler<Object> {
+
+	static {
+		Skript.registerSection(SecReturnable.class, "returnable [:plural] %*classinfo% section");
+	}
+
+	private ClassInfo<?> returnValueType;
+	private boolean singleReturnValue;
+	private static Object @Nullable [] returnedValues;
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, SectionNode sectionNode, List<TriggerItem> triggerItems) {
+		returnValueType = ((Literal<ClassInfo<?>>) expressions[0]).getSingle();
+		singleReturnValue = !parseResult.hasTag("plural");
+		loadReturnableSectionCode(sectionNode);
+		return true;
+	}
+
+	@Override
+	protected @Nullable TriggerItem walk(Event event) {
+		return walk(event, true);
+	}
+
+	@Override
+	public void returnValues(Object @Nullable [] values) {
+		returnedValues = values;
+	}
+
+	@Override
+	public boolean isSingleReturnValue() {
+		return singleReturnValue;
+	}
+
+	@Override
+	public @Nullable Class<?> returnValueType() {
+		return returnValueType.getC();
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "returnable " + (singleReturnValue ? "" : "plural ") + returnValueType.toString(event, debug) + " section";
+	}
+
+	@NoDoc
+	public static class ExprLastReturnValues extends SimpleExpression<Object> {
+
+		static {
+			Skript.registerExpression(ExprLastReturnValues.class, Object.class, ExpressionType.SIMPLE, "[the] last return[ed] value[s]");
+		}
+
+		@Override
+		public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+			return true;
+		}
+
+		@Override
+		public @Nullable Object[] get(Event event) {
+			Object[] returnedValues = SecReturnable.returnedValues;
+			SecReturnable.returnedValues = null;
+			return returnedValues;
+		}
+
+		@Override
+		public boolean isSingle() {
+			return false;
+		}
+
+		@Override
+		public Class<?> getReturnType() {
+			return Object.class;
+		}
+
+		@Override
+		public String toString(@Nullable Event event, boolean debug) {
+			return "last returned values";
+		}
+
+	}
+	
+}
diff --git a/src/main/java/ch/njol/skript/util/LiteralUtils.java b/src/main/java/ch/njol/skript/util/LiteralUtils.java
index 59f58b09800..e980b7bcb07 100644
--- a/src/main/java/ch/njol/skript/util/LiteralUtils.java
+++ b/src/main/java/ch/njol/skript/util/LiteralUtils.java
@@ -53,7 +53,7 @@ public static <T> Expression<T> defendExpression(Expression<?> expr) {
 				newExpressions[i] = LiteralUtils.defendExpression(oldExpressions[i]);
 				returnTypes[i] = newExpressions[i].getReturnType();
 			}
-			return new ExpressionList<>(newExpressions, (Class<T>) Classes.getSuperClassInfo(returnTypes).getC(), expr.getAnd());
+			return new ExpressionList<>(newExpressions, (Class<T>) Classes.getSuperClassInfo(returnTypes).getC(), returnTypes, expr.getAnd());
 		} else if (expr instanceof UnparsedLiteral) {
 			Literal<?> parsedLiteral = ((UnparsedLiteral) expr).getConvertedExpression(Object.class);
 			return (Expression<T>) (parsedLiteral == null ? expr : parsedLiteral);
diff --git a/src/main/java/ch/njol/skript/util/PotionEffectUtils.java b/src/main/java/ch/njol/skript/util/PotionEffectUtils.java
index bc72f768ae6..88f4bfbfe7c 100644
--- a/src/main/java/ch/njol/skript/util/PotionEffectUtils.java
+++ b/src/main/java/ch/njol/skript/util/PotionEffectUtils.java
@@ -18,9 +18,6 @@
  */
 package ch.njol.skript.util;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -346,20 +343,7 @@ else if (HAS_SUSPICIOUS_META && meta instanceof SuspiciousStewMeta)
 		itemType.setItemMeta(meta);
 	}
 
-	@Nullable
-	private static final MethodHandle BASE_POTION_DATA_HANDLE;
-
-	static {
-		MethodHandle basePotionDataHandle = null;
-		if (Skript.methodExists(PotionMeta.class, "getBasePotionData")) {
-			try {
-				basePotionDataHandle = MethodHandles.lookup().findVirtual(PotionMeta.class, "getBasePotionData", MethodType.methodType(PotionData.class));
-			} catch (NoSuchMethodException | IllegalAccessException e) {
-				Skript.exception(e, "Failed to load legacy potion data support. Potions may not work as expected.");
-			}
-		}
-		BASE_POTION_DATA_HANDLE = basePotionDataHandle;
-	}
+	private static final boolean HAS_POTION_TYPE_METHOD = Skript.methodExists(PotionMeta.class, "hasBasePotionType");
 
 	/**
 	 * Get all the PotionEffects of an ItemType
@@ -374,21 +358,22 @@ public static List<PotionEffect> getEffects(ItemType itemType) {
 		ItemMeta meta = itemType.getItemMeta();
 		if (meta instanceof PotionMeta) {
 			PotionMeta potionMeta = ((PotionMeta) meta);
-			effects.addAll(potionMeta.getCustomEffects());
-			if (BASE_POTION_DATA_HANDLE != null) {
-				try {
-					effects.addAll(PotionDataUtils.getPotionEffects((PotionData) BASE_POTION_DATA_HANDLE.invoke(meta)));
-				} catch (Throwable e) {
-					throw Skript.exception(e, "An error occurred while trying to invoke legacy potion data support.");
+			if (potionMeta.hasCustomEffects())
+				effects.addAll(potionMeta.getCustomEffects());
+			if (HAS_POTION_TYPE_METHOD) {
+				if (potionMeta.hasBasePotionType()) {
+					//noinspection ConstantConditions - checked via hasBasePotionType
+					effects.addAll(potionMeta.getBasePotionType().getPotionEffects());
+				}
+			} else { // use deprecated method
+				PotionData data = potionMeta.getBasePotionData();
+				if (data != null) {
+					effects.addAll(PotionDataUtils.getPotionEffects(data));
 				}
-			} else if (potionMeta.hasBasePotionType()) {
-				//noinspection ConstantConditions - checked via hasBasePotionType
-				effects.addAll(potionMeta.getBasePotionType().getPotionEffects());
 			}
-
 		} else if (HAS_SUSPICIOUS_META && meta instanceof SuspiciousStewMeta)
 			effects.addAll(((SuspiciousStewMeta) meta).getCustomEffects());
 		return effects;
 	}
-	
+
 }
diff --git a/src/main/java/ch/njol/util/VectorMath.java b/src/main/java/ch/njol/util/VectorMath.java
index fca9785dc6a..5db05ecc41b 100644
--- a/src/main/java/ch/njol/util/VectorMath.java
+++ b/src/main/java/ch/njol/util/VectorMath.java
@@ -198,4 +198,13 @@ public static void copyVector(Vector vector1, Vector vector2) {
 		vector1.setX(vector2.getX()).setY(vector2.getY()).setZ(vector2.getZ());
 	}
 
+	/**
+	 * Check whether or not each component of this vector is equal to 0.
+	 * <br>Replaces {@code Vector#isZero()} since that method was added in spigot 1.19.3
+	 * @return true if equal to zero, false if at least one component is non-zero
+	 */
+	public static boolean isZero(Vector vector) {
+		return (vector.getX() == 0 && vector.getY() == 0 && vector.getZ() == 0);
+	}
+
 }
diff --git a/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java b/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
index 7cc4c8b0144..27a8065e122 100644
--- a/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
+++ b/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
@@ -29,6 +29,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Collection;
+import java.util.Set;
+import java.util.HashSet;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -266,4 +269,19 @@ private static void assertIsOperationsDoneLoading() {
 			throw new SkriptAPIException("Operations cannot be retrieved until Skript has finished registrations.");
 	}
 
+	/**
+	 * All registered types that could be returned from a calculation using this operator.
+	 * This is used to fetch potential return types when unknown (variable) arguments are used in a sum.
+	 *
+	 * @param operator The operator to test
+	 * @return Every type this could return
+	 */
+	public static Collection<Class<?>> getAllReturnTypes(Operator operator) {
+		Set<Class<?>> types = new HashSet<>();
+		for (OperationInfo<?, ?, ?> info : getOperations_i(operator)) {
+			types.add(info.getReturnType());
+		}
+		return types;
+	}
+
 }
diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang
index ce3e5a38331..701cd9d07b9 100644
--- a/src/main/resources/lang/default.lang
+++ b/src/main/resources/lang/default.lang
@@ -1474,13 +1474,13 @@ visual effects:
 
 		block_marker: # added in 1.18
 			name: block marker @a
-			pattern: (barrierbm:barrier|lightbm:light|%-blockdata/itemtype% block marker)
+			pattern: (barrierbm:barrier [particle]|lightbm:light [particle]|%-blockdata/itemtype% block marker)
 		barrier:
 			name: barrier @a
-			pattern: barrier
+			pattern: barrier [particle]
 		light: # added in 1.17
 			name: light @-
-			pattern: light
+			pattern: light [particle]
 
 		bubble: # added in 1.20.5
 			name: bubble @-
@@ -1535,7 +1535,7 @@ visual effects:
 
 		dolphin: # added in 1.13
 			name: dolphin @-
-			pattern: dolphin
+			pattern: dolphin [particle]
 
 		dragon_breath: # added in 1.14
 			name: dragon breath @-
@@ -1603,10 +1603,10 @@ visual effects:
 
 		elder_guardian: # added in 1.20.5
 			name: elder guardian @-
-			pattern: (elder guardian|mob appearance|guardian ghost)
+			pattern: (elder guardian particle|mob appearance|guardian ghost)
 		mob_appearance: # for versions below 1.20.5
 			name: mob appearance @-
-			pattern: (elder guardian|mob appearance|guardian ghost)
+			pattern: (elder guardian particle|mob appearance|guardian ghost)
 
 		electric_spark:
 			name: electric spark @-
@@ -1628,7 +1628,7 @@ visual effects:
 
 		end_rod:
 			name: end rod @-
-			pattern: end rod
+			pattern: end rod [particle]
 
 		entity_effect: # added in 1.20.5
 			name: entity effect @an
@@ -1694,10 +1694,10 @@ visual effects:
 
 		firework: # added in 1.20.5
 			name: firework @-
-			pattern: (firework|firework['s] spark)
+			pattern: (firework particle|firework['s] spark)
 		fireworks_spark: # for versions below 1.20.5
 			name: firework's spark @-
-			pattern: (firework|firework['s] spark)
+			pattern: (firework particle|firework['s] spark)
 
 		fishing: # added in 1.20.5
 			name: water wake @-
@@ -1765,24 +1765,24 @@ visual effects:
 
 		item_cobweb: # added in 1.20.5 (for 1.21)
 			name: cobweb @-
-			pattern: cobweb
+			pattern: cobweb [item|particle]
 
 		item_slime: # added in 1.20.5
 			name: slime @-
-			pattern: slime
+			pattern: slime [item|particle]
 		slime: # for versions below 1.20.5
 			name: slime @-
-			pattern: slime
+			pattern: slime [item|particle]
 
 		item_snowball: # added in 1.20.5
 			name: snowball @-
-			pattern: (snowball [break]|snow shovel|snow(man| golem) spawn)
+			pattern: (snowball [item|break|particle]|snow shovel|snow(man| golem) spawn)
 		snowball: # for versions below 1.20.5
 			name: snowball break @-
 			pattern: snowball break
 		snow_shovel: # for versions below 1.20.5
 			name: snow shovel @-
-			pattern: (snowball|snow shovel|snow(man| golem) spawn)
+			pattern: (snowball [item|particle]|snow shovel|snow(man| golem) spawn)
 
 		landing_honey: # added in 1.15
 			name: landing honey @-
@@ -1809,7 +1809,7 @@ visual effects:
 
 		mycelium: # previously town_aura, changed in 1.20.5
 			name: mycelium @-
-			pattern: (mycelium|small smoke|town aura)
+			pattern: (mycelium [particle]|small smoke|town aura)
 		town_aura:
 			name: small smoke @-
 			pattern: (mycelium|small smoke|town aura)
@@ -1932,10 +1932,10 @@ visual effects:
 
 		totem_of_undying: # added in 1.20.5
 			name: totem of undying @a
-			pattern: totem [of undying]
+			pattern: totem [of undying] [particle]
 		totem: # for versions below 1.20.5
 			name: totem @a
-			pattern: totem [of undying]
+			pattern: totem [of undying] [particle]
 
 		trial omen: # added in 1.20.5 (for 1.21)
 			name: trial omen @a
@@ -1990,10 +1990,10 @@ visual effects:
 
 		witch: # added in 1.20.5
 			name: witch @a
-			pattern: (witch [magic|spell]|purple spark)
+			pattern: (witch (magic|spell|particle)|purple spark)
 		spell_witch: # for versions below 1.20.5
 			name: witch spell @a
-			pattern: (witch [magic|spell]|purple spark)
+			pattern: (witch (magic|spell|particle)|purple spark)
 
 # -- Inventory Actions --
 inventory actions:
diff --git a/src/test/skript/tests/misc/returns.sk b/src/test/skript/tests/misc/returns.sk
new file mode 100644
index 00000000000..56e2937f7c5
--- /dev/null
+++ b/src/test/skript/tests/misc/returns.sk
@@ -0,0 +1,23 @@
+test "returns":
+	returnable string section:
+		return "hello"
+	assert last return value is "hello" with "failed single return value"
+	
+	returnable plural number section:
+		return (3 and 5)
+	assert last return values is 3 and 5 with "failed multiple return values"
+
+	returnable integer section:
+		return 2.5
+	assert last return value is 2 with "failed converted return value"
+
+test "returns (parsing)":
+	parse:
+		returnable string section:
+			return 1
+	assert last parse logs is set with "skript shouldn't be able to return a different type"
+	
+	parse:
+		returnable string section:
+			return ("foo" and "bar")
+	assert last parse logs is set with "skript shouldn't be able to return multiple values for a single return trigger"
diff --git a/src/test/skript/tests/regressions/6194-vectors + push.sk b/src/test/skript/tests/regressions/6194-vectors + push.sk
new file mode 100644
index 00000000000..258b091fba6
--- /dev/null
+++ b/src/test/skript/tests/regressions/6194-vectors + push.sk	
@@ -0,0 +1,9 @@
+test "normalize zero vector":
+	set {_vector} to vector(0,0,0)
+	add 1 to vector length of {_vector}
+	assert {_vector} is vector(0,0,0) with "add to zero vector's length failed"
+
+	set vector length of {_vector} to 1
+	assert {_vector} is vector(0,0,0) with "set zero vector's length failed"
+
+	assert normalize {_vector} is vector(0,0,0) with "normalize zero vector failed"
\ No newline at end of file
diff --git a/src/test/skript/tests/regressions/6424-inventory-holder-location.sk b/src/test/skript/tests/regressions/6424-inventory-holder-location.sk
new file mode 100644
index 00000000000..ed4d9cd64ab
--- /dev/null
+++ b/src/test/skript/tests/regressions/6424-inventory-holder-location.sk
@@ -0,0 +1,16 @@
+test "inventory holder location":
+	set {_b} to the block at spawn of world "world"
+	set {_prev} to type of block at {_b}
+	broadcast {_prev}
+
+	set block at {_b} to a chest
+	set {_inv} to inventory of {_b}
+	set {_holder} to holder of {_inv}
+
+	set {_a-loc} to location of {_holder}
+	set {_b-loc} to location of {_b}
+
+	# clean up first in case assert fails
+	set block at {_b} to {_prev}
+
+	assert {_a-loc} is {_b-loc} with "holder location differs from block location"
diff --git a/src/test/skript/tests/regressions/6623-wrong parsing order for math.sk b/src/test/skript/tests/regressions/6623-wrong parsing order for math.sk
new file mode 100644
index 00000000000..e3a8a02cd07
--- /dev/null
+++ b/src/test/skript/tests/regressions/6623-wrong parsing order for math.sk	
@@ -0,0 +1,12 @@
+test "wrong parsing order for math in object expr":
+	spawn a zombie at spawn of world "world"
+	set {_e} to the last spawned zombie
+
+	set {_result} to health of {_e} + max health of {_e}
+	assert {_result} is set with "add result not calculated"
+	delete {_result}
+
+	set {_result} to health of {_e} / max health of {_e} # used to be parsed as `health of ({_e} / max health of {_e})`
+	assert {_result} is set with "divide result not calculated"
+
+	delete the last spawned zombie
diff --git a/src/test/skript/tests/regressions/6707-spawn-fish-types.sk b/src/test/skript/tests/regressions/6707-spawn-fish-types.sk
new file mode 100644
index 00000000000..2a0d0bf8112
--- /dev/null
+++ b/src/test/skript/tests/regressions/6707-spawn-fish-types.sk
@@ -0,0 +1,26 @@
+test "spawn fish types":
+	spawn a cod at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a cod with "failed to spawn a cod"
+	delete entity within {_e}
+
+	spawn a salmon at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a salmon with "failed to spawn a salmon"
+	delete entity within {_e}
+
+	spawn a puffer fish at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a puffer fish with "failed to spawn a puffer fish"
+	delete entity within {_e}
+
+	spawn a tropical fish at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a tropical fish with "failed to spawn a tropical fish"
+	delete entity within {_e}
+
+	parse if running minecraft "1.19":
+		spawn a tadpole at spawn of world "world":
+			set {_e} to entity
+		assert {_e} is a tadpole with "failed to spawn a tadpole"
+		delete entity within {_e}
diff --git a/src/test/skript/tests/regressions/6756-potion missing base type causes npe.sk b/src/test/skript/tests/regressions/6756-potion missing base type causes npe.sk
new file mode 100644
index 00000000000..8ffa025b5e6
--- /dev/null
+++ b/src/test/skript/tests/regressions/6756-potion missing base type causes npe.sk	
@@ -0,0 +1,3 @@
+test "potion missing base type":
+
+	assert potion effects of (plain potion of mundane) is not set with "it should not have any effects"
diff --git a/src/test/skript/tests/regressions/6762-cant spawn a firework.sk b/src/test/skript/tests/regressions/6762-cant spawn a firework.sk
new file mode 100644
index 00000000000..f272e0bc8e0
--- /dev/null
+++ b/src/test/skript/tests/regressions/6762-cant spawn a firework.sk	
@@ -0,0 +1,4 @@
+test "can't spawn a firework":
+
+	spawn a firework at spawn of world "world"
+	assert last spawned firework is set with "firework did not spawn"
diff --git a/src/test/skript/tests/regressions/pull-6746-spawn-dropped-item.sk b/src/test/skript/tests/regressions/pull-6746-spawn-dropped-item.sk
new file mode 100644
index 00000000000..b8910894bad
--- /dev/null
+++ b/src/test/skript/tests/regressions/pull-6746-spawn-dropped-item.sk
@@ -0,0 +1,9 @@
+test "spawn dropped item":
+	spawn dropped stone at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is set with "failed to spawn dropped stone"
+	delete entity within {_e}
+
+	spawn dropped item at spawn of world "world":
+		set {_e2} to entity
+	assert {_e2} is not set with "spawned `dropped item` despite undefined item type"
diff --git a/src/test/skript/tests/regressions/pull-6760-particle itemtype conflicts.sk b/src/test/skript/tests/regressions/pull-6760-particle itemtype conflicts.sk
new file mode 100644
index 00000000000..d4cac535c18
--- /dev/null
+++ b/src/test/skript/tests/regressions/pull-6760-particle itemtype conflicts.sk	
@@ -0,0 +1,5 @@
+test "particle itemtype conflicts":
+
+	# itemtype parsing should take priority over visual effects
+	assert totem of undying is an itemtype with "totem of undying is not an itemtype"
+	assert mycelium is an itemtype with "mycelium is not an itemtype"
diff --git a/src/test/skript/tests/syntaxes/effects/EffVisualEffect.sk b/src/test/skript/tests/syntaxes/effects/EffVisualEffect.sk
index b8631e79cf2..a4791d1752a 100644
--- a/src/test/skript/tests/syntaxes/effects/EffVisualEffect.sk
+++ b/src/test/skript/tests/syntaxes/effects/EffVisualEffect.sk
@@ -16,7 +16,7 @@ test "visual effects":
 	play dripping water at {_}
 	play white dust with size 2 at {_}
 	play effect at {_}
-	play elder guardian at {_}
+	play elder guardian particle at {_}
 	play enchant at {_}
 	play enchanted hit at {_}
 	play end rod at {_}
@@ -26,7 +26,7 @@ test "visual effects":
 	play large explosion at {_}
 	play explosion emitter at {_}
 	play falling dust of air at {_}
-	play firework at {_}
+	play firework spark at {_}
 	play fishing at {_}
 	play flame at {_}
 	play happy villager at {_}
@@ -51,7 +51,7 @@ test "visual effects":
 	play totem of undying at {_}
 	play suspended at {_}
 	play void fog at {_}
-	play witch at {_}
+	play witch particle at {_}
 	parse if running minecraft "1.14.4":
 		play campfire cosy smoke at {_}
 		play campfire signal smoke at {_}