diff --git a/gradle.properties b/gradle.properties
index f6647e60f22..8008d0748ff 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -5,7 +5,7 @@ org.gradle.parallel=true
 
 groupid=ch.njol
 name=skript
-version=2.9.4
+version=2.9.5
 jarName=Skript.jar
 testEnv=java21/paper-1.21.3
 testEnvJavaVersion=21
diff --git a/src/main/java/ch/njol/skript/ScriptLoader.java b/src/main/java/ch/njol/skript/ScriptLoader.java
index 9d246d9565e..04de09b2b86 100644
--- a/src/main/java/ch/njol/skript/ScriptLoader.java
+++ b/src/main/java/ch/njol/skript/ScriptLoader.java
@@ -1,21 +1,3 @@
-/**
- *   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;
 
 import ch.njol.skript.config.Config;
@@ -28,11 +10,9 @@
 import ch.njol.skript.lang.Statement;
 import ch.njol.skript.lang.TriggerItem;
 import ch.njol.skript.lang.TriggerSection;
+import ch.njol.skript.lang.function.EffFunctionCall;
 import ch.njol.skript.lang.parser.ParserInstance;
-import ch.njol.skript.log.CountingLogHandler;
-import ch.njol.skript.log.LogEntry;
-import ch.njol.skript.log.RetainingLogHandler;
-import ch.njol.skript.log.SkriptLogger;
+import ch.njol.skript.log.*;
 import ch.njol.skript.sections.SecLoop;
 import ch.njol.skript.structures.StructOptions.OptionsData;
 import ch.njol.skript.util.ExceptionUtils;
@@ -58,17 +38,7 @@
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
@@ -85,7 +55,7 @@ public class ScriptLoader {
 
 	public static final String DISABLED_SCRIPT_PREFIX = "-";
 	public static final int DISABLED_SCRIPT_PREFIX_LENGTH = DISABLED_SCRIPT_PREFIX.length();
-	
+
 	/**
 	 * A class for keeping track of the general content of a script:
 	 * <ul>
@@ -99,12 +69,12 @@ public static class ScriptInfo {
 		public ScriptInfo() {
 
 		}
-		
+
 		public ScriptInfo(int numFiles, int numStructures) {
 			files = numFiles;
 			structures = numStructures;
 		}
-		
+
 		/**
 		 * Copy constructor.
 		 * @param other ScriptInfo to copy from
@@ -113,30 +83,30 @@ public ScriptInfo(ScriptInfo other) {
 			files = other.files;
 			structures = other.structures;
 		}
-		
+
 		public void add(ScriptInfo other) {
 			files += other.files;
 			structures += other.structures;
 		}
-		
+
 		public void subtract(ScriptInfo other) {
 			files -= other.files;
 			structures -= other.structures;
 		}
-		
+
 		@Override
 		public String toString() {
 			return "ScriptInfo{files=" + files + ",structures=" + structures + "}";
 		}
 	}
-	
+
 	/**
 	 * @see ParserInstance#get()
 	 */
 	private static ParserInstance getParser() {
 		return ParserInstance.get();
 	}
-	
+
 	/*
 	 * Enabled/disabled script tracking
 	 */
@@ -175,7 +145,7 @@ private boolean isSubDir(File directory, File subDir) {
 			return false;
 		}
 	}));
-	
+
 	/**
 	 * Filter for loaded scripts and folders.
 	 */
@@ -235,7 +205,7 @@ public static Set<Script> getScripts(File directory) {
 		f -> f != null
 			&& (f.isDirectory() && !f.getName().startsWith(".") || !f.isDirectory() && StringUtils.endsWithIgnoreCase(f.getName(), ".sk"))
 			&& f.getName().startsWith(DISABLED_SCRIPT_PREFIX) && !f.isHidden();
-	
+
 	/**
 	 * Reevaluates {@link #disabledScripts}.
 	 * @param path the scripts folder to use for the reevaluation.
@@ -251,8 +221,8 @@ static void updateDisabledScripts(Path path) {
 			Skript.exception(e, "An error occurred while trying to update the list of disabled scripts!");
 		}
 	}
-	
-	
+
+
 	/*
 	 * Async loading
 	 */
@@ -285,7 +255,7 @@ static void updateDisabledScripts(Path path) {
 	 * This condition might be false during the execution of {@link #setAsyncLoaderSize(int)}.
 	 */
 	private static int asyncLoaderSize;
-	
+
 	/**
 	 * Checks if scripts are loaded in separate thread. If true,
 	 * following behavior should be expected:
@@ -302,7 +272,7 @@ static void updateDisabledScripts(Path path) {
 	public static boolean isAsync() {
 		return asyncLoaderSize > 0;
 	}
-	
+
 	/**
 	 * Checks if scripts are loaded in multiple threads instead of one thread.
 	 * If true, {@link #isAsync()} will also be true.
@@ -311,7 +281,7 @@ public static boolean isAsync() {
 	public static boolean isParallel() {
 		return asyncLoaderSize > 1;
 	}
-	
+
 	/**
 	 * Sets the amount of async loaders, by updating
 	 * {@link #asyncLoaderSize} and {@link #loaderThreads}.
@@ -331,7 +301,7 @@ public static void setAsyncLoaderSize(int size) throws IllegalStateException {
 				thread.cancelExecution();
 			return;
 		}
-		
+
 		// Remove threads
 		while (loaderThreads.size() > size) {
 			AsyncLoaderThread thread = loaderThreads.remove(loaderThreads.size() - 1);
@@ -341,18 +311,18 @@ public static void setAsyncLoaderSize(int size) throws IllegalStateException {
 		while (loaderThreads.size() < size) {
 			loaderThreads.add(AsyncLoaderThread.create());
 		}
-		
+
 		if (loaderThreads.size() != size)
 			throw new IllegalStateException();
 	}
-	
+
 	/**
 	 * This thread takes and executes tasks from the {@link #loadQueue}.
 	 * Instances of this class must be created with {@link AsyncLoaderThread#create()},
 	 * and created threads will always be part of the {@link #asyncLoaderThreadGroup}.
 	 */
 	private static class AsyncLoaderThread extends Thread {
-		
+
 		/**
 		 * @see AsyncLoaderThread
 		 */
@@ -361,13 +331,13 @@ public static AsyncLoaderThread create() {
 			thread.start();
 			return thread;
 		}
-		
+
 		private AsyncLoaderThread() {
 			super(asyncLoaderThreadGroup, (Runnable) null);
 		}
-		
+
 		private boolean shouldRun = true;
-		
+
 		@Override
 		public void run() {
 			while (shouldRun) {
@@ -381,7 +351,7 @@ public void run() {
 				}
 			}
 		}
-		
+
 		/**
 		 * Tell the loader it should stop taking tasks.
 		 * <br>
@@ -393,9 +363,9 @@ public void run() {
 		public void cancelExecution() {
 			shouldRun = false;
 		}
-		
+
 	}
-	
+
 	/**
 	 * Creates a {@link CompletableFuture} using a {@link Supplier} and an {@link OpenCloseable}.
 	 * <br>
@@ -428,7 +398,7 @@ private static <T> CompletableFuture<T> makeFuture(Supplier<T> supplier, OpenClo
 				} finally {
 					openCloseable.close();
 				}
-				
+
 				future.complete(t);
 			} catch (Throwable t) {
 				future.completeExceptionally(t);
@@ -436,7 +406,7 @@ private static <T> CompletableFuture<T> makeFuture(Supplier<T> supplier, OpenClo
 				Skript.exception(t);
 			}
 		};
-		
+
 		if (isAsync() && Bukkit.isPrimaryThread()) {
 			loadQueue.add(task);
 		} else {
@@ -445,8 +415,8 @@ private static <T> CompletableFuture<T> makeFuture(Supplier<T> supplier, OpenClo
 		}
 		return future;
 	}
-	
-	
+
+
 	/*
 	 * Script Loading Methods
 	 */
@@ -476,7 +446,7 @@ public static CompletableFuture<ScriptInfo> loadScripts(Set<File> files, OpenClo
 			.flatMap(List::stream)
 			.collect(Collectors.toList()), openCloseable);
 	}
-	
+
 	/**
 	 * Loads the specified scripts.
 	 *
@@ -495,7 +465,7 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 				.forEach(event -> event.onPreInit(configs));
 		//noinspection deprecation - we still need to call it
 		Bukkit.getPluginManager().callEvent(new PreScriptLoadEvent(configs));
-		
+
 		ScriptInfo scriptInfo = new ScriptInfo();
 
 		List<LoadingScriptInfo> scripts = new ArrayList<>();
@@ -504,17 +474,17 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 		for (Config config : configs) {
 			if (config == null)
 				throw new NullPointerException();
-			
+
 			CompletableFuture<Void> future = makeFuture(() -> {
 				LoadingScriptInfo info = loadScript(config);
 				scripts.add(info);
 				scriptInfo.add(new ScriptInfo(1, info.structures.size()));
 				return null;
 			}, openCloseable);
-			
+
 			scriptInfoFutures.add(future);
 		}
-		
+
 		return CompletableFuture.allOf(scriptInfoFutures.toArray(new CompletableFuture[0]))
 			.thenApply(unused -> {
 				// TODO in the future this won't work when parallel loading is fixed
@@ -672,7 +642,7 @@ private static LoadingScriptInfo loadScript(Config config) {
 		try {
 			if (SkriptConfig.keepConfigsLoaded.value())
 				SkriptConfig.configs.add(config);
-			
+
 			try (CountingLogHandler ignored = new CountingLogHandler(SkriptLogger.SEVERE).start()) {
 				for (Node node : config.getMainNode()) {
 					if (!(node instanceof SimpleNode) && !(node instanceof SectionNode)) {
@@ -700,7 +670,7 @@ private static LoadingScriptInfo loadScript(Config config) {
 					structures.add(structure);
 					nodeMap.put(structure, node);
 				}
-				
+
 				if (Skript.logHigh()) {
 					int count = structures.size();
 					Skript.info("loaded " + count + " structure" + (count == 1 ? "" : "s") + " from '" + config.getFileName() + "'");
@@ -712,7 +682,7 @@ private static LoadingScriptInfo loadScript(Config config) {
 		} finally {
 			parser.setInactive();
 		}
-		
+
 		// In always sync task, enable stuff
 		Callable<Void> callable = () -> {
 			// Remove the script from the disabled scripts list
@@ -746,7 +716,7 @@ private static LoadingScriptInfo loadScript(Config config) {
 	/*
 	 * Script Structure Loading Methods
 	 */
-	
+
 	/**
 	 * Creates a script structure for every file contained within the provided directory.
 	 * If a directory is not actually provided, the file itself will be used.
@@ -767,11 +737,11 @@ private static List<Config> loadStructures(File directory) {
 			Skript.exception(e, "An exception occurred while trying to get the canonical file of: " + directory);
 			return new ArrayList<>();
 		}
-		
+
 		File[] files = directory.listFiles(loadedScriptFilter);
 		assert files != null;
 		Arrays.sort(files);
-		
+
 		List<Config> loadedDirectories = new ArrayList<>(files.length);
 		List<Config> loadedFiles = new ArrayList<>(files.length);
 		for (File file : files) {
@@ -787,7 +757,7 @@ private static List<Config> loadStructures(File directory) {
 		loadedDirectories.addAll(loadedFiles);
 		return loadedDirectories;
 	}
-	
+
 	/**
 	 * Creates a script structure from the provided file.
 	 * This must be done before actually loading a script.
@@ -810,7 +780,7 @@ private static Config loadStructure(File file) {
 				unloadScript(script); // ... it might be good idea to unload it now
 			return null;
 		}
-		
+
 		try {
 			String name = Skript.getInstance().getDataFolder().toPath().toAbsolutePath()
 					.resolve(Skript.SCRIPTSFOLDER).relativize(file.toPath().toAbsolutePath()).toString();
@@ -818,10 +788,10 @@ private static Config loadStructure(File file) {
 		} catch (IOException e) {
 			Skript.error("Could not load " + file.getName() + ": " + ExceptionUtils.toString(e));
 		}
-		
+
 		return null;
 	}
-	
+
 	/**
 	 * Creates a script structure from the provided source.
 	 * This must be done before actually loading a script.
@@ -843,7 +813,7 @@ private static Config loadStructure(InputStream source, String name) {
 		} catch (IOException e) {
 			Skript.error("Could not load " + name + ": " + ExceptionUtils.toString(e));
 		}
-		
+
 		return null;
 	}
 
@@ -906,7 +876,7 @@ public static ScriptInfo unloadScripts(Set<Script> scripts) {
 
 		return info;
 	}
-	
+
 	/**
 	 * Unloads the provided script.
 	 * @param script The script to unload.
@@ -915,7 +885,7 @@ public static ScriptInfo unloadScripts(Set<Script> scripts) {
 	public static ScriptInfo unloadScript(Script script) {
 		return unloadScripts(Collections.singleton(script));
 	}
-	
+
 	/*
 	 * Script Reloading Methods
 	 */
@@ -950,7 +920,7 @@ public static CompletableFuture<ScriptInfo> reloadScripts(Set<Script> scripts, O
 
 		return loadScripts(configs, openCloseable);
 	}
-	
+
 	/*
 	 * Code Loading Methods
 	 */
@@ -970,7 +940,7 @@ public static String replaceOptions(String string) {
 			return string;
 		return optionsData.replaceOptions(string);
 	}
-	
+
 	/**
 	 * Loads a section by converting it to {@link TriggerItem}s.
 	 */
@@ -1016,9 +986,37 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 			} else if (subNode instanceof SectionNode) {
 				TypeHints.enterScope(); // Begin conditional type hints
 
-				item = Section.parse(expr, "Can't understand this section: " + expr, (SectionNode) subNode, items);
-				if (item == null)
+				RetainingLogHandler handler = SkriptLogger.startRetainingLog();
+				find_section:
+				try {
+					item = Section.parse(expr, "Can't understand this section: " + expr, (SectionNode) subNode, items);
+					if (item != null)
+						break find_section;
+
+					// back up the failure log
+					RetainingLogHandler backup = handler.backup();
+					handler.clear();
+
+					item = Statement.parse(expr, "Can't understand this effect: " + expr, (SectionNode) subNode, items);
+
+					if (item != null)
+						break find_section;
+					Collection<LogEntry> errors = handler.getErrors();
+
+					// restore the failure log
+					if (errors.isEmpty()) {
+						handler.restore(backup);
+					} else { // We specifically want these two errors in preference to the section error!
+						String firstError = errors.iterator().next().getMessage();
+						if (!firstError.contains("is a valid statement but cannot function as a section (:)")
+							&& !firstError.contains("You cannot have two section-starters in the same line"))
+							handler.restore(backup);
+					}
 					continue;
+				} finally {
+					handler.printLog();
+					handler.close();
+				}
 
 				if (Skript.debug() || subNode.debug())
 					Skript.debug(SkriptColor.replaceColorChar(parser.getIndentation() + item.toString(null, true)));
diff --git a/src/main/java/ch/njol/skript/Skript.java b/src/main/java/ch/njol/skript/Skript.java
index 5178cbeedc3..edb683ceb37 100644
--- a/src/main/java/ch/njol/skript/Skript.java
+++ b/src/main/java/ch/njol/skript/Skript.java
@@ -97,6 +97,7 @@
 import org.skriptlang.skript.bukkit.tags.TagModule;
 import org.skriptlang.skript.bukkit.breeding.BreedingModule;
 import org.skriptlang.skript.bukkit.displays.DisplayModule;
+import org.skriptlang.skript.bukkit.input.InputModule;
 import org.skriptlang.skript.lang.comparator.Comparator;
 import org.skriptlang.skript.lang.comparator.Comparators;
 import org.skriptlang.skript.lang.converter.Converter;
@@ -132,6 +133,7 @@
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
@@ -262,17 +264,6 @@ public static ServerPlatform getServerPlatform() {
 		}
 	}
 
-	/**
-	 * Returns true if the underlying installed Java/JVM is 32-bit, false otherwise.
-	 * Note that this depends on a internal system property and these can always be overridden by user using -D JVM options,
-	 * more specifically, this method will return false on non OracleJDK/OpenJDK based JVMs, that don't include bit information in java.vm.name system property.
-	 * @return Whether the installed Java/JVM is 32-bit or not.
-	 */
-	private static boolean using32BitJava() {
-		// Property returned should either be "Java HotSpot(TM) 32-Bit Server VM" or "OpenJDK 32-Bit Server VM" if 32-bit and using OracleJDK/OpenJDK
-		return System.getProperty("java.vm.name").contains("32");
-	}
-
 	/**
 	 * Checks if server software and Minecraft version are supported.
 	 * Prints errors or warnings to console if something is wrong.
@@ -503,6 +494,8 @@ public void onEnable() {
 		// ... but also before platform check, because there is a config option to ignore some errors
 		SkriptConfig.load();
 
+		CompletableFuture<Boolean> aliases = Aliases.loadAsync();
+
 		// Now override the verbosity if test mode is enabled
 		if (TestMode.VERBOSITY != null)
 			SkriptLogger.setVerbosity(Verbosity.valueOf(TestMode.VERBOSITY));
@@ -515,20 +508,6 @@ public void onEnable() {
 			updater.updateCheck(console);
 		}
 
-		try {
-			Aliases.load(); // Loaded before anything that might use them
-		} catch (StackOverflowError e) {
-			if (using32BitJava()) {
-				Skript.error("");
-				Skript.error("There was a StackOverflowError that occured while loading aliases.");
-				Skript.error("As you are currently using 32-bit Java, please update to 64-bit Java to resolve the error.");
-				Skript.error("Please report this issue to our GitHub only if updating to 64-bit Java does not fix the issue.");
-				Skript.error("");
-			} else {
-				throw e; // Uh oh, this shouldn't happen. Re-throw the error.
-			}
-		}
-
 		// If loading can continue (platform ok), check for potentially thrown error
 		if (classLoadError != null) {
 			exception(classLoadError);
@@ -556,9 +535,10 @@ public void onEnable() {
 				"conditions", "effects", "events", "expressions", "entity", "sections", "structures");
 			getAddonInstance().loadClasses("org.skriptlang.skript.bukkit", "misc");
 			// todo: become proper module once registry api is merged
+			BreedingModule.load();
 			DisplayModule.load();
+			InputModule.load();
 			TagModule.load();
-			BreedingModule.load();
 		} catch (final Exception e) {
 			exception(e, "Could not load required .class files: " + e.getLocalizedMessage());
 			setEnabled(false);
@@ -605,6 +585,12 @@ public void run() {
 				}
 				finishedLoadingHooks = true;
 
+				try {
+					aliases.get(); // wait for aliases to load
+				} catch (InterruptedException | ExecutionException e) {
+					exception(e, "Could not load aliases concurrently");
+				}
+
 				if (TestMode.ENABLED) {
 					info("Preparing Skript for testing...");
 					tainted = true;
diff --git a/src/main/java/ch/njol/skript/SkriptCommand.java b/src/main/java/ch/njol/skript/SkriptCommand.java
index 16050ef8e14..51962e6ad46 100644
--- a/src/main/java/ch/njol/skript/SkriptCommand.java
+++ b/src/main/java/ch/njol/skript/SkriptCommand.java
@@ -159,15 +159,15 @@ public boolean onCommand(CommandSender sender, Command command, String label, St
 					reloading(sender, "config, aliases and scripts", logHandler);
 					SkriptConfig.load();
 					Aliases.clear();
-					Aliases.load();
-
-					ScriptLoader.unloadScripts(ScriptLoader.getLoadedScripts());
-					ScriptLoader.loadScripts(Skript.getInstance().getScriptsFolder(), OpenCloseable.combine(logHandler, timingLogHandler))
-						.thenAccept(info -> {
-							if (info.files == 0)
-								Skript.warning(Skript.m_no_scripts.toString());
-							reloaded(sender, logHandler, timingLogHandler, "config, aliases and scripts");
-						});
+					Aliases.loadAsync().thenRun(() -> {
+						ScriptLoader.unloadScripts(ScriptLoader.getLoadedScripts());
+						ScriptLoader.loadScripts(Skript.getInstance().getScriptsFolder(), OpenCloseable.combine(logHandler, timingLogHandler))
+							.thenAccept(info -> {
+								if (info.files == 0)
+									Skript.warning(Skript.m_no_scripts.toString());
+								reloaded(sender, logHandler, timingLogHandler, "config, aliases and scripts");
+							});
+					});
 				} else if (args[1].equalsIgnoreCase("scripts")) {
 					reloading(sender, "scripts", logHandler);
 
@@ -185,8 +185,7 @@ public boolean onCommand(CommandSender sender, Command command, String label, St
 				} else if (args[1].equalsIgnoreCase("aliases")) {
 					reloading(sender, "aliases", logHandler);
 					Aliases.clear();
-					Aliases.load();
-					reloaded(sender, logHandler, timingLogHandler, "aliases");
+					Aliases.loadAsync().thenRun(() -> reloaded(sender, logHandler, timingLogHandler, "aliases"));
 				} else { // Reloading an individual Script or folder
 					File scriptFile = getScriptFromArgs(sender, args);
 					if (scriptFile == null)
diff --git a/src/main/java/ch/njol/skript/aliases/Aliases.java b/src/main/java/ch/njol/skript/aliases/Aliases.java
index b92a4196f84..ad41fdb8508 100644
--- a/src/main/java/ch/njol/skript/aliases/Aliases.java
+++ b/src/main/java/ch/njol/skript/aliases/Aliases.java
@@ -8,34 +8,29 @@
 import ch.njol.skript.config.SectionNode;
 import ch.njol.skript.entity.EntityData;
 import ch.njol.skript.lang.parser.ParserInstance;
-import ch.njol.skript.localization.ArgsMessage;
-import ch.njol.skript.localization.Language;
-import ch.njol.skript.localization.Message;
-import ch.njol.skript.localization.Noun;
-import ch.njol.skript.localization.RegexMessage;
+import ch.njol.skript.localization.*;
 import ch.njol.skript.log.BlockingLogHandler;
 import ch.njol.skript.util.EnchantmentType;
 import ch.njol.skript.util.Utils;
 import ch.njol.skript.util.Version;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.script.Script;
+
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.nio.file.FileSystem;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.nio.file.*;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.jetbrains.annotations.Nullable;
-import org.skriptlang.skript.lang.script.Script;
 
 public abstract class Aliases {
 	static final boolean USING_ITEM_COMPONENTS = Skript.isRunningMinecraft(1, 20, 5);
@@ -371,7 +366,10 @@ public static void clear() {
 	/**
 	 * Loads aliases from Skript's standard locations.
 	 * Exceptions will be logged, but not thrown.
+	 *
+	 * @deprecated Freezes server on call. Use {@link #loadAsync()} instead.
 	 */
+	@Deprecated
 	public static void load() {
 		try {
 			long start = System.currentTimeMillis();
@@ -382,6 +380,44 @@ public static void load() {
 		}
 	}
 
+	/**
+	 * Loads aliases from Skript's standard locations asynchronously.
+	 * Exceptions will be logged, but not thrown.
+	 *
+	 * @return A future that completes when the aliases are loaded.
+	 * The returned value is true if the loading was successful, false otherwise.
+	 */
+	public static CompletableFuture<Boolean> loadAsync() {
+		return CompletableFuture.supplyAsync(() -> {
+			try {
+				long start = System.currentTimeMillis();
+				loadInternal();
+				Skript.info("Loaded " + provider.getAliasCount() + " aliases in " + (System.currentTimeMillis() - start) + "ms");
+				return true;
+			} catch (StackOverflowError e) {
+				/*
+				 * Returns true if the underlying installed Java/JVM is 32-bit, false otherwise.
+				 * Note that this depends on a internal system property and these can always be overridden by user using -D JVM options,
+				 * more specifically, this method will return false on non OracleJDK/OpenJDK based JVMs, that don't include bit information in java.vm.name system property
+				 */
+				if (System.getProperty("java.vm.name").contains("32")) {
+					Skript.error("");
+					Skript.error("There was a StackOverflowError that occurred while loading aliases.");
+					Skript.error("As you are currently using 32-bit Java, please update to 64-bit Java to resolve the error.");
+					Skript.error("Please report this issue to our GitHub only if updating to 64-bit Java does not fix the issue.");
+					Skript.error("");
+				} else {
+					Skript.exception(e);
+					Bukkit.getPluginManager().disablePlugin(Skript.getInstance());
+				}
+				return false;
+			} catch (IOException e) {
+				Skript.exception(e);
+				return false;
+			}
+		});
+	}
+
 	/**
 	 * Temporarily create an alias for materials which do not have aliases yet.
 	 */
diff --git a/src/main/java/ch/njol/skript/bukkitutil/ItemUtils.java b/src/main/java/ch/njol/skript/bukkitutil/ItemUtils.java
index a74a604664d..2af432ce6d3 100644
--- a/src/main/java/ch/njol/skript/bukkitutil/ItemUtils.java
+++ b/src/main/java/ch/njol/skript/bukkitutil/ItemUtils.java
@@ -21,6 +21,7 @@
 import ch.njol.skript.Skript;
 import ch.njol.skript.aliases.ItemType;
 import ch.njol.skript.util.slot.Slot;
+import com.destroystokyo.paper.profile.PlayerProfile;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.OfflinePlayer;
@@ -49,6 +50,8 @@ public class ItemUtils {
 	// Introduced in Paper 1.21
 	public static final boolean HAS_RESET = Skript.methodExists(Damageable.class, "resetDamage");
 	public static final boolean CAN_CREATE_PLAYER_PROFILE = Skript.methodExists(Bukkit.class, "createPlayerProfile", UUID.class, String.class);
+	// paper does not do texture lookups by default
+	public static final boolean REQUIRES_TEXTURE_LOOKUP = Skript.classExists("com.destroystokyo.paper.profile.PlayerProfile") && Skript.isRunningMinecraft(1, 19, 4);
 
 	/**
 	 * Gets damage/durability of an item, or 0 if it does not have damage.
@@ -165,7 +168,12 @@ public static void setHeadOwner(ItemType skull, OfflinePlayer player) {
 
 		SkullMeta skullMeta = (SkullMeta) meta;
 
-		if (player.getName() != null) {
+		if (REQUIRES_TEXTURE_LOOKUP) {
+			PlayerProfile profile = player.getPlayerProfile();
+			if (!profile.hasTextures())
+				profile.complete(true); // BLOCKING MOJANG API CALL
+			skullMeta.setPlayerProfile(profile);
+		} else if (player.getName() != null) {
 			skullMeta.setOwningPlayer(player);
 		} else if (CAN_CREATE_PLAYER_PROFILE) {
 			//noinspection deprecation
@@ -304,6 +312,16 @@ public static boolean isAir(Material type) {
 		// cherry
 		if (Skript.isRunningMinecraft(1, 19, 4))
 			TREE_TO_SAPLING_MAP.put(TreeType.CHERRY, Material.CHERRY_SAPLING);
+
+		// mega pine (2x2 spruce tree with minimal leaves at top)
+		if (Skript.isRunningMinecraft(1, 20, 5))
+			TREE_TO_SAPLING_MAP.put(TreeType.MEGA_PINE, Material.SPRUCE_SAPLING);
+
+		// pale oak
+		if (Skript.isRunningMinecraft(1, 21, 3)) {
+			TREE_TO_SAPLING_MAP.put(TreeType.PALE_OAK, Material.PALE_OAK_SAPLING);
+			TREE_TO_SAPLING_MAP.put(TreeType.PALE_OAK_CREAKING, Material.PALE_OAK_SAPLING);
+		}
 	}
 
 	public static Material getTreeSapling(TreeType treeType) {
diff --git a/src/main/java/ch/njol/skript/classes/data/DefaultOperations.java b/src/main/java/ch/njol/skript/classes/data/DefaultOperations.java
index 1588d31ece8..48bf82939fd 100644
--- a/src/main/java/ch/njol/skript/classes/data/DefaultOperations.java
+++ b/src/main/java/ch/njol/skript/classes/data/DefaultOperations.java
@@ -32,26 +32,53 @@ public class DefaultOperations {
 	static {
 		// Number - Number
 		Arithmetics.registerOperation(Operator.ADDITION, Number.class, (left, right) -> {
-			if (Utils.isInteger(left, right))
-				return left.longValue() + right.longValue();
+			if (Utils.isInteger(left, right)) {
+				long result = left.longValue() + right.longValue();
+				// catches overflow, from Math.addExact(long, long)
+				if (((left.longValue() ^ result) & (right.longValue() ^ result)) >= 0)
+					return result;
+			}
 			return left.doubleValue() + right.doubleValue();
 		});
 		Arithmetics.registerOperation(Operator.SUBTRACTION, Number.class, (left, right) -> {
-			if (Utils.isInteger(left, right))
-				return left.longValue() - right.longValue();
+			if (Utils.isInteger(left, right)) {
+				long result = left.longValue() - right.longValue();
+				// catches overflow, from Math.addExact(long, long)
+				if (((left.longValue() ^ result) & (right.longValue() ^ result)) >= 0)
+					return result;
+			}
 			return left.doubleValue() - right.doubleValue();
 		});
 		Arithmetics.registerOperation(Operator.MULTIPLICATION, Number.class, (left, right) -> {
-			if (Utils.isInteger(left, right))
-				return left.longValue() * right.longValue();
-			return left.doubleValue() * right.doubleValue();
+			if (!Utils.isInteger(left, right))
+				return left.doubleValue() * right.doubleValue();
+
+			// catch overflow, from Math.multiplyExact(long, long)
+			long longLeft = left.longValue();
+			long longRight = right.longValue();
+			long ax = Math.abs(longLeft);
+			long ay = Math.abs(longRight);
+
+			long result = left.longValue() * right.longValue();
+
+			if (((ax | ay) >>> 31 != 0)) {
+				// Some bits greater than 2^31 that might cause overflow
+				// Check the result using the divide operator
+				// and check for the special case of Long.MIN_VALUE * -1
+				if (((longRight != 0) && (result / longRight != longLeft)) ||
+					(longLeft == Long.MIN_VALUE && longRight == -1)) {
+					return left.doubleValue() * right.doubleValue();
+				}
+			}
+			return result;
 		});
 		Arithmetics.registerOperation(Operator.DIVISION, Number.class, (left, right) -> left.doubleValue() / right.doubleValue());
 		Arithmetics.registerOperation(Operator.EXPONENTIATION, Number.class, (left, right) -> Math.pow(left.doubleValue(), right.doubleValue()));
 		Arithmetics.registerDifference(Number.class, (left, right) -> {
-			if (Utils.isInteger(left, right))
-				return Math.abs(left.longValue() - right.longValue());
-			return Math.abs(left.doubleValue() - right.doubleValue());
+			double result = Math.abs(left.doubleValue() - right.doubleValue());
+			if (Utils.isInteger(left, right) && result < Long.MAX_VALUE && result > Long.MIN_VALUE)
+				return (long) result;
+			return result;
 		});
 		Arithmetics.registerDefaultValue(Number.class, () -> 0L);
 
diff --git a/src/main/java/ch/njol/skript/effects/EffContinue.java b/src/main/java/ch/njol/skript/effects/EffContinue.java
index 9dddbc96a16..b83fefec4f2 100644
--- a/src/main/java/ch/njol/skript/effects/EffContinue.java
+++ b/src/main/java/ch/njol/skript/effects/EffContinue.java
@@ -73,10 +73,6 @@ public class EffContinue extends Effect {
 
 	@Override
     public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		level = matchedPattern == 0 ? 1 : Integer.parseInt(parseResult.regexes.get(0).group());
-		if (level < 1)
-			return false;
-
 		ParserInstance parser = getParser();
 		int loops = parser.getCurrentSections(LoopSection.class).size();
 		if (loops == 0) {
@@ -84,8 +80,12 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			return false;
 		}
 
-		// Section.getSections counts from the innermost section, so we need to invert the level 
-		int levels = level == -1 ? 1 : loops - level + 1;
+		level = matchedPattern == 0 ? loops : Integer.parseInt(parseResult.regexes.get(0).group());
+		if (level < 1)
+			return false;
+
+		// ParserInstance#getSections counts from the innermost section, so we need to invert the level 
+		int levels = loops - level + 1;
 		if (levels <= 0) {
 			Skript.error("Can't continue the " + StringUtils.fancyOrderNumber(level) + " loop as there " +
 				(loops == 1 ? "is only 1 loop" : "are only " + loops + " loops") + " present");
diff --git a/src/main/java/ch/njol/skript/effects/EffEnchant.java b/src/main/java/ch/njol/skript/effects/EffEnchant.java
index 016b8c66be8..0e83dfcfefb 100644
--- a/src/main/java/ch/njol/skript/effects/EffEnchant.java
+++ b/src/main/java/ch/njol/skript/effects/EffEnchant.java
@@ -18,11 +18,6 @@
  */
 package ch.njol.skript.effects;
 
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.event.Event;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.Nullable;
-
 import ch.njol.skript.Skript;
 import ch.njol.skript.aliases.ItemType;
 import ch.njol.skript.classes.Changer.ChangeMode;
@@ -36,6 +31,11 @@
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.util.EnchantmentType;
 import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
 
 /**
  * @author Peter Güttinger
@@ -72,29 +72,26 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 	
 	@Override
 	protected void execute(Event event) {
-		ItemType[] items = this.items.getArray(event);
-		if (items.length == 0) // short circuit
-			return;
+		Function<ItemType, ItemType> changeFunction;
 
 		if (enchantments != null) {
 			EnchantmentType[] types = enchantments.getArray(event);
 			if (types.length == 0)
 				return;
-			for (ItemType item : items) {
-				for (EnchantmentType type : types) {
-					Enchantment enchantment = type.getType();
-					assert enchantment != null;
-					item.addEnchantments(new EnchantmentType(enchantment, type.getLevel()));
-				}
-			}
+			changeFunction = item -> {
+				item.addEnchantments(types);
+				return item;
+			};
 		} else {
-			for (ItemType item : items) {
+			changeFunction = item -> {
 				item.clearEnchantments();
-			}
+				return item;
+			};
 		}
-		this.items.change(event, items.clone(), ChangeMode.SET);
+
+		this.items.changeInPlace(event, changeFunction);
 	}
-	
+
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		return enchantments == null ? "disenchant " + items.toString(event, debug) : "enchant " + items.toString(event, debug) + " with " + enchantments;
diff --git a/src/main/java/ch/njol/skript/effects/EffReplace.java b/src/main/java/ch/njol/skript/effects/EffReplace.java
index ef2faf44282..84d6dd47bb3 100644
--- a/src/main/java/ch/njol/skript/effects/EffReplace.java
+++ b/src/main/java/ch/njol/skript/effects/EffReplace.java
@@ -37,9 +37,11 @@
 import org.bukkit.event.Event;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
+import java.util.function.Function;
 import java.util.regex.Matcher;
 
 @Name("Replace")
@@ -107,20 +109,9 @@ private void replace(Event event, Object[] needles, Expression<?> haystackExpr)
 		if (replacement == null || haystack == null || haystack.length == 0 || needles == null || needles.length == 0)
 			return;
 		if (replaceString) {
-			if (replaceFirst) {
-				for (int x = 0; x < haystack.length; x++)
-					for (Object n : needles) {
-						assert n != null;
-						haystack[x] = StringUtils.replaceFirst((String)haystack[x], (String)n, Matcher.quoteReplacement((String)replacement), caseSensitive);
-					}
-			} else {
-				for (int x = 0; x < haystack.length; x++)
-					for (Object n : needles) {
-						assert n != null;
-						haystack[x] = StringUtils.replace((String) haystack[x], (String) n, (String) replacement, caseSensitive);
-					}
-			}
-			haystackExpr.change(event, haystack, ChangeMode.SET);
+			Function<String, String> replaceFunction = getReplaceFunction(needles, (String) replacement);
+			//noinspection unchecked
+			((Expression<String>) haystackExpr).changeInPlace(event, replaceFunction);
 		} else {
 			for (Inventory inv : (Inventory[]) haystack)
 				for (ItemType needle : (ItemType[]) needles)
@@ -138,14 +129,36 @@ private void replace(Event event, Object[] needles, Expression<?> haystackExpr)
 					}
 		}
 	}
-	
+
+	private @NotNull Function<String, String> getReplaceFunction(Object[] needles, String replacement) {
+		Function<String, String> replaceFunction;
+		if (replaceFirst) {
+			replaceFunction = haystackString -> {
+				for (Object needle : needles) {
+					assert needle != null;
+					haystackString = StringUtils.replaceFirst(haystackString, (String) needle, Matcher.quoteReplacement(replacement), caseSensitive);
+				}
+				return haystackString;
+			};
+		} else {
+			replaceFunction = haystackString -> {
+				for (Object needle : needles) {
+					assert needle != null;
+					haystackString = StringUtils.replace(haystackString, (String) needle, replacement, caseSensitive);
+				}
+				return haystackString;
+			};
+		}
+		return replaceFunction;
+	}
+
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
 
 		builder.append("replace");
 		if (replaceFirst)
-			builder.append("the first");
+			builder.append("first");
 		builder.append(needles, "in", haystack, "with", replacement);
 		if (caseSensitive)
 			builder.append("with case sensitivity");
diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java
index 2892d24c156..8423c380297 100644
--- a/src/main/java/ch/njol/skript/entity/EntityData.java
+++ b/src/main/java/ch/njol/skript/entity/EntityData.java
@@ -18,29 +18,6 @@
  */
 package ch.njol.skript.entity;
 
-import java.io.NotSerializableException;
-import java.io.StreamCorruptedException;
-import java.lang.reflect.Array;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.Location;
-import org.bukkit.RegionAccessor;
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.Nullable;
-
 import ch.njol.skript.Skript;
 import ch.njol.skript.SkriptAPIException;
 import ch.njol.skript.bukkitutil.EntityUtils;
@@ -67,6 +44,27 @@
 import ch.njol.util.coll.iterator.SingleItemIterator;
 import ch.njol.yggdrasil.Fields;
 import ch.njol.yggdrasil.YggdrasilSerializable.YggdrasilExtendedSerializable;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.RegionAccessor;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.NotSerializableException;
+import java.io.StreamCorruptedException;
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 @SuppressWarnings("rawtypes")
 public abstract class EntityData<E extends Entity> implements SyntaxElement, YggdrasilExtendedSerializable {// TODO extended horse support, zombie villagers // REMIND unit
@@ -105,8 +103,6 @@ public abstract class EntityData<E extends Entity> implements SyntaxElement, Ygg
 	// must be here to be initialised before 'new SimpleLiteral' is called in the register block below
 	private final static List<EntityDataInfo<EntityData<?>>> infos = new ArrayList<>();
 
-	private static final Pattern REGEX_PATTERN = Pattern.compile("[a-zA-Z -]+");
-
 	private static final List<EntityData> ALL_ENTITY_DATAS = new ArrayList<>();
 
 	public static Serializer<EntityData> serializer = new Serializer<EntityData>() {
@@ -435,8 +431,6 @@ public static EntityDataInfo<?> getInfo(final String codeName) {
 	@SuppressWarnings("null")
 	@Nullable
 	public static EntityData<?> parse(String s) {
-		if (!REGEX_PATTERN.matcher(s).matches())
-			return null;
 		Iterator<EntityDataInfo<EntityData<?>>> it = infos.iterator();
 		return SkriptParser.parseStatic(Noun.stripIndefiniteArticle(s), it, null);
 	}
@@ -449,8 +443,6 @@ public static EntityData<?> parse(String s) {
 	 */
 	@Nullable
 	public static EntityData<?> parseWithoutIndefiniteArticle(String s) {
-		if (!REGEX_PATTERN.matcher(s).matches())
-			return null;
 		Iterator<EntityDataInfo<EntityData<?>>> it = infos.iterator();
 		return SkriptParser.parseStatic(s, it, null);
 	}
diff --git a/src/main/java/ch/njol/skript/events/SimpleEvents.java b/src/main/java/ch/njol/skript/events/SimpleEvents.java
index 65d2c4eb4d4..5bf1ad37ad3 100644
--- a/src/main/java/ch/njol/skript/events/SimpleEvents.java
+++ b/src/main/java/ch/njol/skript/events/SimpleEvents.java
@@ -343,13 +343,10 @@ public class SimpleEvents {
 				.requiredPlugins("Minecraft 1.14+ (event-entity support)")
 				.since("1.0, 2.5.3 (event-entity support)");
 		Skript.registerEvent("Projectile Hit", SimpleEvent.class, ProjectileHitEvent.class, "projectile hit")
-				.description("Called when a projectile hits an entity or a block.",
-						"Use the <a href='#damage'>damage event</a> with a <a href='conditions.html#CondIsSet'>check</a> for a <a href='expressions.html#ExprEntity'>projectile</a> " +
-								"to be able to use the <a href='expressions.html#ExprAttacked'>entity that got hit</a> in the case when the projectile hit a living entity.",
-						"A damage event will even be fired if the damage is 0, e.g. when throwing snowballs at non-nether mobs.")
+				.description("Called when a projectile hits an entity or a block.")
 				.examples("on projectile hit:",
-						"\tevent-projectile is arrow",
-						"\tdelete event-projectile")
+						"\tif victim's health <= 3:",
+						"\t\tdelete event-projectile")
 				.since("1.0");
 		
 		if(Skript.classExists("com.destroystokyo.paper.event.entity.ProjectileCollideEvent"))
diff --git a/src/main/java/ch/njol/skript/expressions/ExprARGB.java b/src/main/java/ch/njol/skript/expressions/ExprARGB.java
new file mode 100644
index 00000000000..6731171cdad
--- /dev/null
+++ b/src/main/java/ch/njol/skript/expressions/ExprARGB.java
@@ -0,0 +1,78 @@
+package ch.njol.skript.expressions;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Keywords;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.expressions.base.SimplePropertyExpression;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.util.Color;
+import ch.njol.util.Kleenean;
+
+import java.util.Locale;
+import java.util.function.Function;
+
+@Name("Alpha/Red/Green/Blue Color Value")
+@Description({
+	"The alpha, red, green, or blue value of colors. Ranges from 0 to 255.",
+	"Alpha represents opacity."
+})
+@Examples({
+	"broadcast red value of rgb(100, 0, 50) # sends '100'",
+	"set {_red} to red's red value + 10"
+})
+@Keywords({"ARGB", "RGB", "color", "colour"})
+@Since("INSERT VERSION")
+public class ExprARGB extends SimplePropertyExpression<Color, Integer> {
+
+	static {
+		register(ExprARGB.class, Integer.class, "(:alpha|:red|:green|:blue) (value|component)", "colors");
+	}
+
+	private RGB color;
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		color = RGB.valueOf(parseResult.tags.get(0).toUpperCase(Locale.ENGLISH));
+		return super.init(expressions, matchedPattern, isDelayed, parseResult);
+	}
+
+	@Override
+	public Integer convert(Color from) {
+		return color.getValue(from);
+	}
+
+	@Override
+	public Class<? extends Integer> getReturnType() {
+		return Integer.class;
+	}
+
+	@Override
+	protected String getPropertyName() {
+		return color.name().toLowerCase(Locale.ENGLISH);
+	}
+
+	/**
+	 * helper enum for getting argb values of {@link Color}s.
+	 */
+	private enum RGB {
+		ALPHA(Color::getAlpha),
+		RED(Color::getRed),
+		GREEN(Color::getGreen),
+		BLUE(Color::getBlue);
+
+		private final Function<Color, Integer> get;
+
+		RGB(Function<Color, Integer> get) {
+			this.get = get;
+		}
+
+		public int getValue(Color from) {
+			return get.apply(from);
+		}
+
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/expressions/ExprBlocks.java b/src/main/java/ch/njol/skript/expressions/ExprBlocks.java
index a6cae9350a3..fbc9683db1e 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprBlocks.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprBlocks.java
@@ -56,9 +56,11 @@
 @Since("1.0, 2.5.1 (within/cuboid/chunk)")
 public class ExprBlocks extends SimpleExpression<Block> {
 
+	private static final boolean SUPPORTS_WORLD_LOADED = Skript.methodExists(Location.class, "isWorldLoaded");
+
 	static {
 		Skript.registerExpression(ExprBlocks.class, Block.class, ExpressionType.COMBINED,
-				"[(all [[of] the]|the)] blocks %direction% [%locations%]", // TODO doesn't loop all blocks?
+				"[(all [[of] the]|the)] blocks %direction% [%locations%]",
 				"[(all [[of] the]|the)] blocks from %location% [on] %direction%",
 				"[(all [[of] the]|the)] blocks from %location% to %location%",
 				"[(all [[of] the]|the)] blocks between %location% and %location%",
@@ -116,7 +118,11 @@ protected Block[] get(Event event) {
 			return from.stream(event)
 					.filter(Location.class::isInstance)
 					.map(Location.class::cast)
-				    .filter(Location::isWorldLoaded)
+				    .filter(location -> {
+						if (SUPPORTS_WORLD_LOADED)
+							return location.isWorldLoaded();
+						return location.getChunk().isLoaded();
+					})
 					.map(direction::getRelative)
 					.map(Location::getBlock)
 					.toArray(Block[]::new);
diff --git a/src/main/java/ch/njol/skript/expressions/ExprColorOf.java b/src/main/java/ch/njol/skript/expressions/ExprColorOf.java
index e46cfa1fc33..b1698656dbe 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprColorOf.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprColorOf.java
@@ -85,7 +85,7 @@ protected Color[] get(Event event, Object[] source) {
 			List<Color> colors = new ArrayList<>();
 			for (FireworkEffect effect : (FireworkEffect[]) source) {
 				effect.getColors().stream()
-					.map(SkriptColor::fromBukkitColor)
+					.map(ColorRGB::fromBukkitColor)
 					.forEach(colors::add);
 			}
 			return colors.toArray(new Color[0]);
diff --git a/src/main/java/ch/njol/skript/expressions/ExprJoinSplit.java b/src/main/java/ch/njol/skript/expressions/ExprJoinSplit.java
index 8b9274c70cd..75ad70a0ddd 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprJoinSplit.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprJoinSplit.java
@@ -1,13 +1,15 @@
 package ch.njol.skript.expressions;
 
 import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
 
 import ch.njol.skript.SkriptConfig;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SyntaxStringBuilder;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 
 import ch.njol.skript.Skript;
-import ch.njol.skript.SkriptConfig;
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
 import ch.njol.skript.doc.Name;
@@ -18,11 +20,6 @@
 import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.util.Kleenean;
 import ch.njol.util.StringUtils;
-import org.bukkit.event.Event;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.UnknownNullability;
-
-import java.util.regex.Pattern;
 
 @Name("Join & Split")
 @Description("Joins several texts with a common delimiter (e.g. \", \"), or splits a text into multiple texts at a given delimiter.")
@@ -47,41 +44,51 @@ public class ExprJoinSplit extends SimpleExpression<String> {
 	private boolean caseSensitivity;
 	private boolean removeTrailing;
 
-	@UnknownNullability
 	private Expression<String> strings;
-	@UnknownNullability
-	private Expression<String> delimiter;
+	private @Nullable Expression<String> delimiter;
+
+	private @Nullable Pattern pattern;
 
 	@Override
-	@SuppressWarnings("unchecked")
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
 		join = matchedPattern == 0;
 		regex = matchedPattern >= 3;
 		caseSensitivity = SkriptConfig.caseSensitive.value() || parseResult.hasTag("case");
 		removeTrailing = parseResult.hasTag("trailing");
-
+		//noinspection unchecked
 		strings = (Expression<String>) exprs[0];
+		//noinspection unchecked
 		delimiter = (Expression<String>) exprs[1];
+		if (!join && delimiter instanceof Literal<String> literal) {
+			String stringPattern = literal.getSingle();
+			try {
+				this.pattern = compilePattern(stringPattern);
+			} catch (PatternSyntaxException e) {
+				Skript.error("'" + stringPattern + "' is not a valid regular expression");
+				return false;
+			}
+		}
 		return true;
 	}
 
 	@Override
-	@Nullable
-	protected String[] get(Event event) {
+	protected String @Nullable [] get(Event event) {
 		String[] strings = this.strings.getArray(event);
 		String delimiter = this.delimiter != null ? this.delimiter.getSingle(event) : "";
 
 		if (strings.length == 0 || delimiter == null)
 			return new String[0];
 
-		if (join) {
-			return new String[]{StringUtils.join(strings, delimiter)};
-		} else {
-			if (!regex) {
-				delimiter = (caseSensitivity ? "" : "(?i)") + Pattern.quote(delimiter);
-			}
-
-			return strings[0].split(delimiter, removeTrailing ? 0 : -1);
+		if (join)
+			return new String[] {StringUtils.join(strings, delimiter)};
+
+		try {
+			Pattern pattern = this.pattern;
+			if (pattern == null)
+				pattern = compilePattern(delimiter);
+			return pattern.split(strings[0], removeTrailing ? 0 : -1);
+		} catch (PatternSyntaxException e) {
+			return new String[0];
 		}
 	}
 
@@ -97,14 +104,27 @@ public Class<? extends String> getReturnType() {
 
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
-		if (join)
-			return "join " + strings.toString(event, debug) +
-				(delimiter != null ? " with " + delimiter.toString(event, debug) : "");
-		return (regex ? "regex " : "") +
-			"split " + strings.toString(event, debug) +
-			(delimiter != null ? " at " + delimiter.toString(event, debug) : "") +
-			(regex ? "" : "(case sensitive: " + caseSensitivity + ")") +
-			(removeTrailing ? " without trailing string" : "");
+		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
+		if (join) {
+			builder.append("join", strings);
+			if (delimiter != null)
+				builder.append("with", delimiter);
+			return builder.toString();
+		}
+
+        assert delimiter != null;
+		if (regex)
+			builder.append("regex");
+        builder.append("split", strings, "at", delimiter);
+		if (removeTrailing)
+			builder.append("without trailing text");
+		if (!regex)
+			builder.append("(case sensitive:", caseSensitivity + ")");
+		return builder.toString();
+	}
+
+	private Pattern compilePattern(String delimiter) {
+		return Pattern.compile(regex ? delimiter : (caseSensitivity ? "" : "(?i)") + Pattern.quote(delimiter));
 	}
 
 }
diff --git a/src/main/java/ch/njol/skript/expressions/ExprMaxStack.java b/src/main/java/ch/njol/skript/expressions/ExprMaxStack.java
index 77b65fa5191..56744bcddff 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprMaxStack.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprMaxStack.java
@@ -1,57 +1,102 @@
-/**
- *   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.expressions;
 
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.event.Event;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.Nullable;
+
+import ch.njol.skript.Skript;
 import ch.njol.skript.aliases.ItemType;
+import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
 import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.RequiredPlugins;
 import ch.njol.skript.doc.Since;
 import ch.njol.skript.expressions.base.SimplePropertyExpression;
-import org.bukkit.Material;
-import org.bukkit.inventory.ItemStack;
+import ch.njol.util.Math2;
+import ch.njol.util.coll.CollectionUtils;
 
-/**
- * @author joeuguce99
- */
 @Name("Maximum Stack Size")
-@Description("The maximum stack size of the specified material, e.g. 64 for torches, 16 for buckets, and 1 for swords.")
-@Examples("send \"You can only pick up %max stack size of player's tool% of %type of (player's tool)%\" to player")
-@Since("2.1")
-public class ExprMaxStack extends SimplePropertyExpression<ItemType, Long> {
+@Description({
+	"The maximum stack size of an item (e.g. 64 for torches, 16 for buckets, 1 for swords, etc.) or inventory.",
+	"In 1.20.5+, the maximum stack size of items can be changed to any integer from 1 to 99, and stacked up to the maximum stack size of the inventory they're in."
+})
+@Examples({
+	"send \"You can hold %max stack size of player's tool% of %type of player's tool% in a slot.\" to player",
+	"set the maximum stack size of inventory of all players to 16",
+	"add 8 to the maximum stack size of player's tool",
+	"reset the maximum stack size of {_gui}"
+})
+@Since("2.1, INSERT VERSION (changeable, inventories)")
+@RequiredPlugins("Spigot 1.20.5+ (changeable)")
+public class ExprMaxStack extends SimplePropertyExpression<Object, Integer> {
 
 	static {
-		register(ExprMaxStack.class, Long.class, "max[imum] stack[[ ]size]", "itemtype");
+		register(ExprMaxStack.class, Integer.class, "max[imum] stack[[ ]size]", "itemtypes/inventories");
 	}
-	
-	@SuppressWarnings("null")
+
+	private static final boolean CHANGEABLE_ITEM_STACK_SIZE = Skript.methodExists(ItemMeta.class, "setMaxStackSize", Integer.class);
+
 	@Override
-	public Long convert(ItemType itemType) {
-		Object random = itemType.getRandomStackOrMaterial();
-		if (random instanceof Material)
-			return (long) ((Material) random).getMaxStackSize();
-		return (long) ((ItemStack) random).getMaxStackSize();
+	public @Nullable Integer convert(Object from) {
+		if (from instanceof ItemType itemType)
+			return getMaxStackSize(itemType);
+		if (from instanceof Inventory inventory)
+			return inventory.getMaxStackSize();
+		return null;
 	}
 
 	@Override
-	public Class<? extends Long> getReturnType() {
-		return Long.class;
+	public @Nullable Class<?>[] acceptChange(ChangeMode mode) {
+        return switch (mode) {
+            case ADD, REMOVE, RESET, SET -> {
+                if (!CHANGEABLE_ITEM_STACK_SIZE && ItemType.class.isAssignableFrom(getExpr().getReturnType())) {
+                    Skript.error("Changing the maximum stack size of items requires Minecraft 1.20.5 or newer!");
+                    yield null;
+                }
+                yield CollectionUtils.array(Integer.class);
+            }
+            default -> null;
+        };
+	}
+
+	@Override
+	public void change(Event event, Object @Nullable [] delta, ChangeMode mode) {
+		int change = delta == null ? 0 : ((Number) delta[0]).intValue();
+		for (Object source : getExpr().getArray(event)) {
+			if (source instanceof ItemType itemType) {
+				if (!CHANGEABLE_ITEM_STACK_SIZE)
+					continue;
+				int size = getMaxStackSize(itemType);
+                switch (mode) {
+                    case ADD -> size += change;
+                    case SET -> size = change;
+                    case REMOVE -> size -= change;
+                }
+				ItemMeta meta = itemType.getItemMeta();
+				// Minecraft only accepts stack size from 1 to 99
+				meta.setMaxStackSize(mode != ChangeMode.RESET ? Math2.fit(1, size, 99) : null);
+				itemType.setItemMeta(meta);
+			} else if (source instanceof Inventory inventory) {
+                int size = inventory.getMaxStackSize();
+				switch (mode) {
+					case ADD -> size += change;
+					case SET -> size = change;
+					case REMOVE -> size -= change;
+					case RESET -> size = Bukkit.createInventory(null, inventory.getType()).getMaxStackSize();
+				}
+				inventory.setMaxStackSize(size);
+			}
+		}
+	}
+
+	@Override
+	public Class<? extends Integer> getReturnType() {
+		return Integer.class;
 	}
 
 	@Override
@@ -59,4 +104,13 @@ protected String getPropertyName() {
 		return "maximum stack size";
 	}
 
+	private static int getMaxStackSize(ItemType itemType) {
+		Object item = itemType.getRandomStackOrMaterial();
+		if (item instanceof ItemStack stack)
+			return stack.getMaxStackSize();
+		if (item instanceof Material material)
+			return material.getMaxStackSize();
+		throw new UnsupportedOperationException();
+	}
+
 }
diff --git a/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java b/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
index 6e0af7d63cc..62e5696e098 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
@@ -18,18 +18,20 @@
  */
 package ch.njol.skript.expressions;
 
-import ch.njol.util.VectorMath;
-import org.bukkit.event.Event;
-import org.bukkit.util.Vector;
-import org.jetbrains.annotations.Nullable;
-
 import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
 import ch.njol.skript.doc.Name;
 import ch.njol.skript.doc.Since;
 import ch.njol.skript.expressions.base.SimplePropertyExpression;
+import ch.njol.skript.lang.Expression;
+import ch.njol.util.VectorMath;
 import ch.njol.util.coll.CollectionUtils;
+import org.bukkit.event.Event;
+import org.bukkit.util.Vector;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
 
 @Name("Vectors - Length")
 @Description("Gets or sets the length of a vector.")
@@ -61,39 +63,49 @@ public Class<?>[] acceptChange(ChangeMode mode) {
 	}
 
 	@Override
-	public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
+	public void change(Event event, Object @Nullable [] delta, ChangeMode mode) {
 		assert delta != null;
-		final Vector[] vectors = getExpr().getArray(event);
 		double deltaLength = ((Number) delta[0]).doubleValue();
+
+		Function<Vector, Vector> changeFunction;
 		switch (mode) {
 			case REMOVE:
 				deltaLength = -deltaLength;
 				//$FALL-THROUGH$
 			case ADD:
-				for (Vector vector : vectors) {
-					if (VectorMath.isZero(vector) || (deltaLength < 0 && vector.lengthSquared() < deltaLength * deltaLength)) {
+				final double finalDeltaLength = deltaLength;
+				final double finalDeltaLengthSquared = deltaLength * deltaLength;
+				changeFunction = vector -> {
+					if (VectorMath.isZero(vector) || (finalDeltaLength < 0 && vector.lengthSquared() < finalDeltaLengthSquared)) {
 						vector.zero();
 					} else {
-						double newLength = deltaLength + vector.length();
+						double newLength = finalDeltaLength + vector.length();
 						if (!vector.isNormalized())
 							vector.normalize();
 						vector.multiply(newLength);
 					}
-				}
+					return vector;
+				};
 				break;
 			case SET:
-				for (Vector vector : vectors) {
-					if (deltaLength < 0 || VectorMath.isZero(vector)) {
+				final double finalDeltaLength1 = deltaLength;
+				changeFunction = vector -> {
+					if (finalDeltaLength1 < 0 || VectorMath.isZero(vector)) {
 						vector.zero();
 					} else {
 						if (!vector.isNormalized())
 							vector.normalize();
-						vector.multiply(deltaLength);
+						vector.multiply(finalDeltaLength1);
 					}
-				}
+					return vector;
+				};
 				break;
+			default:
+				return;
 		}
-		getExpr().change(event, vectors, ChangeMode.SET);
+
+		//noinspection unchecked,DataFlowIssue
+		((Expression<Vector>) getExpr()).changeInPlace(event, changeFunction);
 	}
 
 	@Override
diff --git a/src/main/java/ch/njol/skript/expressions/ExprXYZComponent.java b/src/main/java/ch/njol/skript/expressions/ExprXYZComponent.java
index a6db3c7e92e..7ef773bada0 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprXYZComponent.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprXYZComponent.java
@@ -3,6 +3,7 @@
 import ch.njol.skript.Skript;
 import ch.njol.skript.classes.Changer;
 import ch.njol.skript.classes.Changer.ChangeMode;
+import ch.njol.skript.classes.Changer.ChangerUtils;
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
 import ch.njol.skript.doc.Name;
@@ -89,9 +90,9 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 		if ((mode == ChangeMode.ADD || mode == ChangeMode.REMOVE || mode == ChangeMode.SET)) {
 			boolean acceptsChange;
 			if (IS_RUNNING_1194) {
-				acceptsChange = Changer.ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Vector.class, Quaternionf.class);
+				acceptsChange = ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Vector.class, Quaternionf.class);
 			} else {
-				acceptsChange = Changer.ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Vector.class);
+				acceptsChange = ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Vector.class);
 			}
 			if (acceptsChange)
 				return CollectionUtils.array(Number.class);
@@ -102,35 +103,20 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 	@Override
 	public void change(Event event, Object @Nullable [] delta, ChangeMode mode) {
 		assert delta != null; // reset/delete not supported
-		Object[] objects = getExpr().getArray(event);
-		double value = ((Number) delta[0]).doubleValue();
+		final double value = ((Number) delta[0]).doubleValue();
 
-		boolean hasVectors = false;
-		boolean hasQuaternions = false;
-		boolean hasInvalidInput = false;
+		// for covering the edge cases such as an expression that returns a Vector but can only be set to a Quaternions
+		boolean acceptsVectors = ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Vector.class);
+		boolean acceptsQuaternions = ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Quaternionf.class);
 
-		for (Object object : objects) {
-			if (object instanceof Vector vector) {
+		getExpr().changeInPlace(event, object -> {
+			if (acceptsVectors && object instanceof Vector vector) {
 				changeVector(vector, axis, value, mode);
-				hasVectors = true;
-			} else if (object instanceof Quaternionf quaternion) {
+			} else if (acceptsQuaternions && object instanceof Quaternionf quaternion) {
 				changeQuaternion(quaternion, axis, (float) value, mode);
-				hasQuaternions = true;
-			} else {
-				hasInvalidInput = true;
 			}
-		}
-
-		// don't SET the expression if there were invalid inputs
-		if (hasInvalidInput)
-			return;
-
-		// covers the edge case where an expression can be set to Vector but returns Quaternions, or similar.
-		if (hasVectors && !Changer.ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Vector.class))
-			return;
-		if (hasQuaternions && !Changer.ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, Quaternionf.class))
-			return;
-		getExpr().change(event, objects, ChangeMode.SET);
+			return object;
+		});
 	}
 
 	/**
diff --git a/src/main/java/ch/njol/skript/expressions/base/SectionExpression.java b/src/main/java/ch/njol/skript/expressions/base/SectionExpression.java
new file mode 100644
index 00000000000..ab38dc86324
--- /dev/null
+++ b/src/main/java/ch/njol/skript/expressions/base/SectionExpression.java
@@ -0,0 +1,166 @@
+package ch.njol.skript.expressions.base;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.lang.*;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.parser.ParserInstance;
+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;
+
+/**
+ * An implementation of the {@link Expression} interface that is allowed to start a section.
+ * <pre>{@code
+ * 	set {var} to (my section expression):
+ *      this is inside a section
+ *      this section can be 'managed' by (my section expression)
+ * }</pre>
+ * <br/>
+ * <br/>
+ * A section expression can be used in any expression slot, provided that:
+ * <ol>
+ *     <li>The line itself is not already a {@link Section} or an {@link EffectSection}.</li>
+ *     <li>The line does not already contain another {@link SectionExpression}.</li>
+ * </ol>
+ * <br/>
+ * <br/>
+ * The intended purpose of section expressions is to make features like the below possible,
+ * without the need to modify individual effect classes:
+ * <pre>{@code
+ * 	set {var} to a new lambda:
+ *      broadcast "hello"
+ *      # this section is managed by `a new lambda` rather than EffChange
+ * }</pre>
+ * <br/>
+ * <br/>
+ * Please note that section expressions will not be given a {@link SectionNode} during `init`
+ * if they are used in a line <b>that does not start a section</b>!
+ * It is up to the implementation to check whether this is provided.
+ * <p>
+ * Section node provided:
+ * <pre>{@code
+ * 	set {var} to a new lambda:
+ *      broadcast "hello"
+ * }</pre>
+ * <p>
+ * Section node not provided:
+ * <pre>{@code
+ * 	set {var} to a new lambda
+ * }</pre>
+ * <br/>
+ * <br/>
+ * Please also note that expressions are not 'executed' individually as effects/sections are,
+ * and so some behaviour (such as trigger items, orders, etc.) may be different from a regular section.
+ *
+ * @see Skript#registerExpression(Class, Class, ExpressionType, String...)
+ * @see Section
+ * @see SimpleExpression
+ */
+public abstract class SectionExpression<Value> extends SimpleExpression<Value> {
+
+	protected final ExpressionSection section = new ExpressionSection(this);
+
+	/**
+	 * Called just after the constructor.
+	 *
+	 * @param expressions all %expr%s included in the matching pattern in the order they appear in the pattern. If an optional value was left out, it will still be included in this list
+	 *            holding the default value of the desired type, which usually depends on the event
+	 * @param pattern The index of the pattern which matched
+	 * @param delayed Whether this expression is used after a delay or not (i.e. if the event has already passed when this expression will be called)
+	 * @param result Additional information about the match
+	 * @param node The section node representing the un-handled code in the body of the approaching section. If this expression does not start a section, the node will be null.
+	 * @param triggerItems A list of preceding trigger nodes before this line
+	 *
+	 * @return Whether this expression was initialised successfully. An error should be printed prior to returning false to specify the cause.
+	 */
+	public abstract boolean init(Expression<?>[] expressions,
+								 int pattern,
+								 Kleenean delayed,
+								 ParseResult result,
+								 @Nullable SectionNode node,
+								 @Nullable List<TriggerItem> triggerItems);
+
+	@Override
+	public final boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed,
+                              ParseResult parseResult) {
+		return section.init(expressions, matchedPattern, isDelayed, parseResult);
+	}
+
+	/**
+	 * @return A dummy trigger item representing the section belonging to this
+	 */
+	public final Section getAsSection() {
+		return section;
+	}
+
+	/**
+	 * Loads the code in the given {@link SectionNode},
+	 * appropriately modifying {@link ParserInstance#getCurrentSections()}.
+	 * <br>
+	 * This method differs from {@link #loadCode(SectionNode)} in that it
+	 * is meant for code that will be executed at another time and potentially with different context.
+	 * The section's contents are parsed with the understanding that they have no relation
+	 *  to the section itself, along with any other code that may come before and after the section.
+	 * The {@link ParserInstance} is modified to reflect that understanding.
+	 *
+	 * @param sectionNode The section node to load.
+	 * @param name The name of the event(s) being used.
+	 * @param afterLoading A Runnable to execute after the SectionNode has been loaded.
+	 * This occurs before {@link ParserInstance} states are reset.
+	 * @param events The event(s) during the section's execution.
+	 * @return A trigger containing the loaded section. This should be stored and used
+	 * to run the section one or more times.
+	 */
+	protected Trigger loadCode(SectionNode sectionNode, String name,
+							   @Nullable Runnable afterLoading, Class<? extends Event>... events) {
+		return section.loadCodeTask(sectionNode, name, afterLoading, events);
+	}
+
+	/**
+	 * Loads the code in the given {@link SectionNode},
+	 * appropriately modifying {@link ParserInstance#getCurrentSections()}.
+	 * <br>
+	 * This method itself does not modify {@link ParserInstance#getHasDelayBefore()}
+	 * (although the loaded code may change it), the calling code must deal with this.
+	 */
+	protected void loadCode(SectionNode sectionNode) {
+		this.section.loadCode(sectionNode);
+	}
+
+	/**
+	 * Loads the code using {@link #loadCode(SectionNode)}.
+	 * <br>
+	 * This method also adjusts {@link ParserInstance#getHasDelayBefore()} to expect the code
+	 * to be called zero or more times. This is done by setting {@code hasDelayBefore} to {@link Kleenean#UNKNOWN}
+	 * if the loaded section has a possible or definite delay in it.
+	 */
+	protected void loadOptionalCode(SectionNode sectionNode) {
+		this.section.loadOptionalCode(sectionNode);
+	}
+
+	/**
+	 * Establishes the {@link TriggerItem} tree of this section
+	 *  without modifying {@link ParserInstance#getCurrentSections()}.
+	 */
+	protected void setTriggerItems(List<TriggerItem> items) {
+		this.section.setTriggerItems(items);
+	}
+
+	/**
+	 * Executes the code within the section associated with this expression.
+	 * Before calling this method, the section must have been loaded through:
+	 * {@link #loadCode(SectionNode)},
+	 * {@link #loadOptionalCode(SectionNode)},
+	 * or {@link #setTriggerItems(List)}.
+	 * @param event The event to pass as context.
+	 * @return False if an exception occurred while executing the section.
+	 */
+	protected boolean runSection(Event event) {
+		return this.section.runSection(event);
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/lang/Expression.java b/src/main/java/ch/njol/skript/lang/Expression.java
index 2c1e78d6b87..8dea5655be5 100644
--- a/src/main/java/ch/njol/skript/lang/Expression.java
+++ b/src/main/java/ch/njol/skript/lang/Expression.java
@@ -35,11 +35,14 @@
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.converter.Converter;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Spliterators;
+import java.util.function.Function;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
@@ -341,6 +344,54 @@ default Map<ChangeMode, Class<?>[]> getAcceptedChangeModes() {
 	 */
 	void change(Event event, Object @Nullable [] delta, ChangeMode mode);
 
+	/**
+	 * Changes the contents of an expression using the given {@link Function}.
+	 * Intended for changes that change properties of the values of the expression, rather than completely
+	 * changing the expression. For example, {@code set vector length of {_v} to 1}, rather than
+	 * {@code set {_v} to vector(0,1,0)}.
+	 * <br>
+	 * This is a 1 to 1 transformation and should not add or remove elements.
+	 * For {@link Variable}s, this will retain indices. For non-{@link Variable}s, it will
+	 * evaluate {@link #getArray(Event)}, apply the change function on each, and call
+	 * {@link #change(Event, Object[], ChangeMode)} with the modified values and {@link ChangeMode#SET}.
+	 *
+	 * @param event The event to use for local variables and evaluation
+	 * @param changeFunction A 1-to-1 function that transforms a single input to a single output.
+	 * @param <R> The output type of the change function. Must be a type returned
+	 *              by {{@link #acceptChange(ChangeMode)}} for {@link ChangeMode#SET}.
+	 */
+	default <R> void changeInPlace(Event event, Function<T, R> changeFunction) {
+		changeInPlace(event, changeFunction, false);
+	}
+
+	/**
+	 * Changes the contents of an expression using the given {@link Function}.
+	 * Intended for changes that change properties of the values of the expression, rather than completely
+	 * changing the expression. For example, {@code set vector length of {_v} to 1}, rather than
+	 * {@code set {_v} to vector(0,1,0)}.
+	 * <br>
+	 * This is a 1 to 1 transformation and should not add or remove elements.
+	 * For {@link Variable}s, this will retain indices. For non-{@link Variable}s, it will
+	 * evaluate the expression, apply the change function on each value, and call
+	 * {@link #change(Event, Object[], ChangeMode)} with the modified values and {@link ChangeMode#SET}.
+	 *
+	 * @param event The event to use for local variables and evaluation
+	 * @param changeFunction A 1-to-1 function that transforms a single input to a single output.
+	 * @param getAll Whether to evaluate with {@link #getAll(Event)} or {@link #getArray(Event)}.
+	 * @param <R> The output type of the change function. Must be a type returned
+	 *              by {{@link #acceptChange(ChangeMode)}} for {@link ChangeMode#SET}.
+	 */
+	default <R> void changeInPlace(Event event, Function<T, R> changeFunction, boolean getAll) {
+		T[] values = getAll ? getAll(event) : getArray(event);
+		if (values.length == 0)
+			return;
+		List<R> newValues = new ArrayList<>();
+		for (T value : values) {
+			newValues.add(changeFunction.apply(value));
+		}
+		change(event, newValues.toArray(), ChangeMode.SET);
+	}
+
 	/**
 	 * This method is called before this expression is set to another one.
 	 * The return value is what will be used for change. You can use modified
diff --git a/src/main/java/ch/njol/skript/lang/ExpressionList.java b/src/main/java/ch/njol/skript/lang/ExpressionList.java
index e4b68bd880c..a99a1b21662 100644
--- a/src/main/java/ch/njol/skript/lang/ExpressionList.java
+++ b/src/main/java/ch/njol/skript/lang/ExpressionList.java
@@ -155,15 +155,7 @@ public boolean isSingle() {
 
 	@Override
 	public boolean check(Event event, Checker<? super T> checker, boolean negated) {
-		for (Expression<? extends T> expr : expressions) {
-			boolean result = expr.check(event, checker) ^ negated;
-			// exit early if we find a FALSE and we're ANDing, or a TRUE and we're ORing
-			if (and && !result)
-				return false;
-			if (!and && result)
-				return true;
-		}
-		return and;
+		return CollectionUtils.check(expressions, expr -> expr.check(event, checker) ^ negated, and);
 	}
 
 	@Override
diff --git a/src/main/java/ch/njol/skript/lang/ExpressionSection.java b/src/main/java/ch/njol/skript/lang/ExpressionSection.java
new file mode 100644
index 00000000000..ae992d9ead0
--- /dev/null
+++ b/src/main/java/ch/njol/skript/lang/ExpressionSection.java
@@ -0,0 +1,83 @@
+package ch.njol.skript.lang;
+
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.expressions.base.SectionExpression;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * A dummy trigger item representing the 'section' aspect of a {@link SectionExpression}.
+ * This is not a parsed or registered syntax in itself, and can be used for getting access to the parse-time features
+ * of a section syntax (e.g. loading body code).
+ * <p>
+ * This is not safe to be used during runtime, since it is not a part of the trigger item tree.
+ *
+ * @see SectionExpression
+ * @see Section
+ * @see EffectSectionEffect
+ */
+@ApiStatus.Internal
+public class ExpressionSection extends Section {
+
+	protected final SectionExpression<?> expression;
+
+	public ExpressionSection(SectionExpression<?> expression) {
+		this.expression = expression;
+	}
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+		SectionContext context = getParser().getData(SectionContext.class);
+		return this.init(expressions, matchedPattern, isDelayed, parseResult, context.sectionNode, context.triggerItems)
+			&& context.claim(expression);
+	}
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed,
+						SkriptParser.ParseResult parseResult,
+						@Nullable SectionNode sectionNode, List<TriggerItem> triggerItems) {
+		return expression.init(expressions, matchedPattern, isDelayed, parseResult, sectionNode, triggerItems);
+	}
+
+	@Override
+	protected @Nullable TriggerItem walk(Event event) {
+		return super.walk(event, false);
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return expression.toString(event, debug);
+	}
+
+	public SectionExpression<?> getAsExpression() {
+		return expression;
+	}
+
+	@Override
+	public void loadCode(SectionNode sectionNode) {
+		super.loadCode(sectionNode);
+	}
+
+	@Override
+	public void loadOptionalCode(SectionNode sectionNode) {
+		super.loadOptionalCode(sectionNode);
+	}
+
+	public boolean runSection(Event event) {
+		return TriggerItem.walk(this.first, event);
+	}
+
+	@Override
+	public void setTriggerItems(List<TriggerItem> items) {
+		super.setTriggerItems(items);
+	}
+
+	public Trigger loadCodeTask(SectionNode sectionNode, String name, @Nullable Runnable afterLoading, Class<? extends Event>... events) {
+		return super.loadCode(sectionNode, name, afterLoading, events);
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/lang/Section.java b/src/main/java/ch/njol/skript/lang/Section.java
index 6c4445c2634..17401f559c7 100644
--- a/src/main/java/ch/njol/skript/lang/Section.java
+++ b/src/main/java/ch/njol/skript/lang/Section.java
@@ -25,6 +25,7 @@
 import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -64,7 +65,8 @@ public abstract class Section extends TriggerSection implements SyntaxElement {
 	@Override
 	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
 		SectionContext sectionContext = getParser().getData(SectionContext.class);
-		return init(expressions, matchedPattern, isDelayed, parseResult, sectionContext.sectionNode, sectionContext.triggerItems);
+		return init(expressions, matchedPattern, isDelayed, parseResult, sectionContext.sectionNode, sectionContext.triggerItems)
+			&& sectionContext.claim(this);
 	}
 
 	public abstract boolean init(Expression<?>[] expressions,
@@ -188,6 +190,7 @@ protected static class SectionContext extends ParserInstance.Data {
 
 		protected SectionNode sectionNode;
 		protected List<TriggerItem> triggerItems;
+		protected @Nullable Debuggable owner;
 
 		public SectionContext(ParserInstance parserInstance) {
 			super(parserInstance);
@@ -205,18 +208,59 @@ public SectionContext(ParserInstance parserInstance) {
 		protected <T> T modify(SectionNode sectionNode, List<TriggerItem> triggerItems, Supplier<T> supplier) {
 			SectionNode prevSectionNode = this.sectionNode;
 			List<TriggerItem> prevTriggerItems = this.triggerItems;
+			Debuggable owner = this.owner;
 
 			this.sectionNode = sectionNode;
 			this.triggerItems = triggerItems;
+			this.owner = null;
 
 			T result = supplier.get();
 
 			this.sectionNode = prevSectionNode;
 			this.triggerItems = prevTriggerItems;
+			this.owner = owner;
 
 			return result;
 		}
 
+		/**
+		 * Marks the section this context represents as having been 'claimed' by the current syntax.
+		 * Once a syntax has claimed a section, another syntax may not claim it.
+		 *
+		 * @param syntax The syntax that wants to own this section
+		 * @return True if this was successfully claimed, false if it was already owned
+		 */
+		@ApiStatus.Internal
+		public <Syntax extends SyntaxElement & Debuggable> boolean claim(Syntax syntax) {
+			if (sectionNode == null)
+				return true;
+			if (this.claimed()) {
+				if (owner == syntax)
+					return true;
+				assert owner != null;
+				Skript.error("The syntax '" + syntax.toString(null, false)
+					+ "' tried to claim the current section, but it was already claimed by '"
+					+ this.owner.toString(null, false)
+					+ "'. You cannot have two section-starters in the same line.");
+				return false;
+			}
+			this.owner = syntax;
+			return true;
+		}
+
+		/**
+		 * Used to keep track of whether a syntax is managing the current section.
+		 * Every section needs exactly one manager. This is used to detect errors such as:
+		 * <ol>
+		 *     <li>Two syntax both want to manage the section (e.g. an effectsection and an expression or two expressions).</li>
+		 *     <li>No syntax wants to manage the section.</li>
+		 * </ol>
+		 * @return Whether a syntax is already managing this section context
+		 */
+		public boolean claimed() {
+			return owner != null;
+		}
+
 	}
 
 }
diff --git a/src/main/java/ch/njol/skript/lang/SkriptParser.java b/src/main/java/ch/njol/skript/lang/SkriptParser.java
index c56f56e81e4..e713edeb750 100644
--- a/src/main/java/ch/njol/skript/lang/SkriptParser.java
+++ b/src/main/java/ch/njol/skript/lang/SkriptParser.java
@@ -302,6 +302,10 @@ public boolean hasTag(String tag) {
 	}
 
 	private static @Nullable Expression<?> parseExpression(Class<?>[] types, String expr) {;
+		if (expr.startsWith("“") || expr.startsWith("”") || expr.endsWith("”") || expr.endsWith("“")) {
+			Skript.error("Pretty quotes are not allowed, change to regular quotes (\")");
+			return null;
+		}
 		if (expr.startsWith("\"") && expr.length() != 1 && nextQuote(expr, 1) == expr.length() - 1) {
 			return VariableString.newInstance("" + expr.substring(1, expr.length() - 1));
 		} else {
diff --git a/src/main/java/ch/njol/skript/lang/Statement.java b/src/main/java/ch/njol/skript/lang/Statement.java
index b19689f1bc2..ef7115961b4 100644
--- a/src/main/java/ch/njol/skript/lang/Statement.java
+++ b/src/main/java/ch/njol/skript/lang/Statement.java
@@ -1,25 +1,9 @@
-/**
- *   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.Skript;
+import ch.njol.skript.config.SectionNode;
 import ch.njol.skript.lang.function.EffFunctionCall;
+import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.skript.log.ParseLogHandler;
 import ch.njol.skript.log.SkriptLogger;
 import org.jetbrains.annotations.Nullable;
@@ -41,6 +25,10 @@ public abstract class Statement extends TriggerItem implements SyntaxElement {
 	}
 
 	public static @Nullable Statement parse(String input, @Nullable List<TriggerItem> items, String defaultError) {
+		return parse(input, defaultError, null, items);
+	}
+
+	public static @Nullable Statement parse(String input, @Nullable String defaultError, @Nullable SectionNode node, @Nullable List<TriggerItem> items) {
 		try (ParseLogHandler log = SkriptLogger.startParseLogHandler()) {
 			EffFunctionCall functionCall = EffFunctionCall.parse(input);
 			if (functionCall != null) {
@@ -59,8 +47,23 @@ public abstract class Statement extends TriggerItem implements SyntaxElement {
 			}
 			log.clear();
 
-			//noinspection unchecked,rawtypes
-			Statement statement = (Statement) SkriptParser.parse(input, (Iterator) Skript.getStatements().iterator(), defaultError);
+			Statement statement;
+			if (node != null) {
+				Section.SectionContext sectionContext = ParserInstance.get().getData(Section.SectionContext.class);
+				statement = sectionContext.modify(node, items, () -> {
+						//noinspection unchecked,rawtypes
+						Statement parsed = (Statement) SkriptParser.parse(input, (Iterator) Skript.getStatements().iterator(), defaultError);
+						if (parsed != null && !sectionContext.claimed()) {
+							Skript.error("The line '" + input + "' is a valid statement but cannot function as a section (:) because there is no syntax in the line to manage it.");
+							return null;
+						}
+						return parsed;
+				});
+			} else {
+				//noinspection unchecked,rawtypes
+				statement = (Statement) SkriptParser.parse(input, (Iterator) Skript.getStatements().iterator(), defaultError);
+			}
+
 			if (statement != null) {
 				log.printLog();
 				return statement;
diff --git a/src/main/java/ch/njol/skript/lang/Variable.java b/src/main/java/ch/njol/skript/lang/Variable.java
index 5ce5cc4a1c0..4d499b814c1 100644
--- a/src/main/java/ch/njol/skript/lang/Variable.java
+++ b/src/main/java/ch/njol/skript/lang/Variable.java
@@ -64,6 +64,7 @@
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
 import java.util.TreeMap;
+import java.util.function.Function;
 
 public class Variable<T> implements Expression<T> {
 
@@ -614,6 +615,25 @@ public void change(Event event, Object @Nullable [] delta, ChangeMode mode) thro
 		}
 	}
 
+	@Override
+	public <R> void changeInPlace(Event event, Function<T, R> changeFunction) {
+		if (!list) {
+			T value = getSingle(event);
+			if (value == null)
+				return;
+			set(event, changeFunction.apply(value));
+			return;
+		}
+		variablesIterator(event).forEachRemaining(pair -> {
+			String index = pair.getKey();
+			T value = Converters.convert(pair.getValue(), types);
+			if (value == null)
+				return;
+			Object newValue = changeFunction.apply(value);
+			setIndex(event, index, newValue);
+		});
+	}
+
 	@Override
 	public @Nullable T getSingle(Event event) {
 		if (list)
diff --git a/src/main/java/ch/njol/skript/log/LogEntry.java b/src/main/java/ch/njol/skript/log/LogEntry.java
index 47f40847c24..074af5a7bec 100644
--- a/src/main/java/ch/njol/skript/log/LogEntry.java
+++ b/src/main/java/ch/njol/skript/log/LogEntry.java
@@ -125,11 +125,6 @@ void logged() {
 			SkriptLogger.LOGGER.warning(" # LogEntry '" + message + "'" + from + " logged" + findCaller());
 	}
 
-	@Override
-	protected void finalize() {
-		assert used : message + from;
-	}
-
 	@Override
 	public String toString() {
 		if (node == null || level.intValue() < Level.WARNING.intValue())
diff --git a/src/main/java/ch/njol/skript/log/RetainingLogHandler.java b/src/main/java/ch/njol/skript/log/RetainingLogHandler.java
index ea685f0113c..ddc7c4b4ff9 100644
--- a/src/main/java/ch/njol/skript/log/RetainingLogHandler.java
+++ b/src/main/java/ch/njol/skript/log/RetainingLogHandler.java
@@ -25,22 +25,47 @@
 import java.util.LinkedList;
 import java.util.logging.Level;
 
-import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.Nullable;
 
 import ch.njol.skript.Skript;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
 
 /**
  * @author Peter Güttinger
  */
 public class RetainingLogHandler extends LogHandler {
-	
+
 	private final Deque<LogEntry> log = new LinkedList<>();
 	private int numErrors = 0;
-	
+
 	boolean printedErrorOrLog = false;
-	
+
+	/**
+	 * Internal method for creating a backup of this log.
+	 * @return A new RetainingLogHandler containing the contents of this RetainingLogHandler.
+	 */
+	@ApiStatus.Internal
+	@Contract("-> new")
+	public RetainingLogHandler backup() {
+		RetainingLogHandler copy = new RetainingLogHandler();
+		copy.numErrors = this.numErrors;
+		copy.printedErrorOrLog = this.printedErrorOrLog;
+		copy.log.addAll(this.log);
+		return copy;
+	}
+
+	/**
+	 * Internal method for restoring a backup of this log.
+	 */
+	@ApiStatus.Internal
+	public void restore(RetainingLogHandler copy) {
+		this.numErrors = copy.numErrors;
+		this.log.clear();
+		this.log.addAll(copy.log);
+	}
+
 	@Override
 	public LogResult log(LogEntry entry) {
 		log.add(entry);
@@ -49,40 +74,40 @@ public LogResult log(LogEntry entry) {
 		printedErrorOrLog = false;
 		return LogResult.CACHED;
 	}
-	
+
 	@Override
 	public void onStop() {
 		if (!printedErrorOrLog && Skript.testing())
 			SkriptLogger.LOGGER.warning("Retaining log wasn't instructed to print anything at " + SkriptLogger.getCaller());
 	}
-	
+
 	@Override
 	public RetainingLogHandler start() {
 		SkriptLogger.startLogHandler(this);
 		return this;
 	}
-	
+
 	public final boolean printErrors() {
 		return printErrors(null);
 	}
-	
+
 	/**
 	 * Prints all retained errors or the given one if no errors were retained.
 	 * <p>
 	 * This handler is stopped if not already done.
-	 * 
+	 *
 	 * @param def Error to print if no errors were logged, can be null to not print any error if there are none
 	 * @return Whether there were any errors
 	 */
 	public final boolean printErrors(@Nullable String def) {
 		return printErrors(def, ErrorQuality.SEMANTIC_ERROR);
 	}
-	
+
 	public final boolean printErrors(@Nullable String def, ErrorQuality quality) {
 		assert !printedErrorOrLog;
 		printedErrorOrLog = true;
 		stop();
-		
+
 		boolean hasError = false;
 		for (LogEntry e : log) {
 			if (e.getLevel().intValue() >= Level.SEVERE.intValue()) {
@@ -92,18 +117,18 @@ public final boolean printErrors(@Nullable String def, ErrorQuality quality) {
 				e.discarded("not printed");
 			}
 		}
-		
+
 		if (!hasError && def != null)
 			SkriptLogger.log(SkriptLogger.SEVERE, def);
-		
+
 		return hasError;
 	}
-	
+
 	/**
 	 * Sends all retained error messages to the given recipient.
 	 * <p>
 	 * This handler is stopped if not already done.
-	 * 
+	 *
 	 * @param recipient
 	 * @param def Error to send if no errors were logged, can be null to not print any error if there are none
 	 * @return Whether there were any errors to send
@@ -123,13 +148,13 @@ public final boolean printErrors(CommandSender recipient, @Nullable String def)
 				e.discarded("not printed");
 			}
 		}
-		
+
 		if (!hasError && def != null) {
 			SkriptLogger.sendFormatted(recipient, def);
 		}
 		return hasError;
 	}
-	
+
 	/**
 	 * Prints all retained log messages.
 	 * <p>
@@ -141,11 +166,11 @@ public final void printLog() {
 		stop();
 		SkriptLogger.logAll(log);
 	}
-	
+
 	public boolean hasErrors() {
 		return numErrors != 0;
 	}
-	
+
 	@Nullable
 	public LogEntry getFirstError() {
 		for (LogEntry e : log) {
@@ -154,7 +179,7 @@ public LogEntry getFirstError() {
 		}
 		return null;
 	}
-	
+
 	public LogEntry getFirstError(String def) {
 		for (LogEntry e : log) {
 			if (e.getLevel().intValue() >= Level.SEVERE.intValue())
@@ -162,7 +187,7 @@ public LogEntry getFirstError(String def) {
 		}
 		return new LogEntry(SkriptLogger.SEVERE, def);
 	}
-	
+
 	/**
 	 * Clears the list of retained log messages.
 	 */
@@ -172,18 +197,18 @@ public void clear() {
 		log.clear();
 		numErrors = 0;
 	}
-	
+
 	public int size() {
 		return log.size();
 	}
-	
+
 	@SuppressWarnings("null")
 	public Collection<LogEntry> getLog() {
 		// if something is grabbing the log entries, they're probably handling them manually
 		printedErrorOrLog = true;
 		return Collections.unmodifiableCollection(log);
 	}
-	
+
 	public Collection<LogEntry> getErrors() {
 		Collection<LogEntry> r = new ArrayList<>();
 		for (LogEntry e : log) {
@@ -192,9 +217,9 @@ public Collection<LogEntry> getErrors() {
 		}
 		return r;
 	}
-	
+
 	public int getNumErrors() {
 		return numErrors;
 	}
-	
+
 }
diff --git a/src/main/java/ch/njol/skript/test/runner/EffRunRunnable.java b/src/main/java/ch/njol/skript/test/runner/EffRunRunnable.java
new file mode 100644
index 00000000000..551271f5943
--- /dev/null
+++ b/src/main/java/ch/njol/skript/test/runner/EffRunRunnable.java
@@ -0,0 +1,44 @@
+package ch.njol.skript.test.runner;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.NoDoc;
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.util.LiteralUtils;
+import ch.njol.util.Kleenean;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+
+@NoDoc
+public class EffRunRunnable extends Effect {
+
+	static {
+		if (TestMode.ENABLED)
+			Skript.registerEffect(EffRunRunnable.class, "run %object%");
+	}
+
+	private Expression<?> task;
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int pattern, Kleenean delayed, ParseResult result) {
+		this.task = LiteralUtils.defendExpression(expressions[0]);
+		return LiteralUtils.canInitSafely(task);
+	}
+
+	@Override
+	protected void execute(Event event) {
+		Object single = this.task.getSingle(event);
+		if (single instanceof Runnable runnable) {
+			runnable.run();
+		} else {
+			Bukkit.getLogger().severe("Tried to run a non-runnable " + single);
+		}
+	}
+
+	@Override
+	public String toString(Event event, boolean debug) {
+		return "run " + task.toString(event, debug);
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/test/runner/ExprSecRunnable.java b/src/main/java/ch/njol/skript/test/runner/ExprSecRunnable.java
new file mode 100644
index 00000000000..017d40d39af
--- /dev/null
+++ b/src/main/java/ch/njol/skript/test/runner/ExprSecRunnable.java
@@ -0,0 +1,79 @@
+package ch.njol.skript.test.runner;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.doc.NoDoc;
+import ch.njol.skript.expressions.base.SectionExpression;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.Trigger;
+import ch.njol.skript.lang.TriggerItem;
+import ch.njol.skript.variables.Variables;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+@NoDoc
+public class ExprSecRunnable extends SectionExpression<Object> {
+
+	public static class RunnableEvent extends Event {
+
+		@Override
+		@NotNull
+		public HandlerList getHandlers() {
+			throw new IllegalStateException();
+		}
+
+	}
+
+	static {
+		if (TestMode.ENABLED)
+			Skript.registerExpression(ExprSecRunnable.class, Object.class, ExpressionType.SIMPLE, "[a] new runnable");
+	}
+
+	private Trigger trigger;
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public boolean init(Expression<?>[] expressions,
+						int pattern,
+						Kleenean delayed,
+						ParseResult result,
+						@Nullable SectionNode node,
+						@Nullable List<TriggerItem> triggerItems) {
+		if (node == null) {
+			Skript.error("Runnable expression needs a section!");
+			return false;
+		}
+		loadCode(node);
+		return true;
+	}
+
+	@Override
+	protected Object @Nullable [] get(Event event) {
+		return new Runnable[] {
+			() -> runSection(event)
+		};
+	}
+
+	@Override
+	public boolean isSingle() {
+		return true;
+	}
+
+	@Override
+	public Class<?> getReturnType() {
+		return Runnable.class;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "a new runnable";
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/util/BlockLineIterator.java b/src/main/java/ch/njol/skript/util/BlockLineIterator.java
index e67fbd02b0f..201f031cc4d 100644
--- a/src/main/java/ch/njol/skript/util/BlockLineIterator.java
+++ b/src/main/java/ch/njol/skript/util/BlockLineIterator.java
@@ -1,31 +1,13 @@
-/**
- *   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.util;
 
+import ch.njol.skript.bukkitutil.WorldUtils;
+import ch.njol.util.Math2;
 import org.bukkit.Location;
 import org.bukkit.block.Block;
 import org.bukkit.util.BlockIterator;
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
 
-import ch.njol.skript.bukkitutil.WorldUtils;
-import ch.njol.util.Math2;
 import ch.njol.util.NullableChecker;
 import ch.njol.util.coll.iterator.StoppableIterator;
 
@@ -37,8 +19,10 @@ public class BlockLineIterator extends StoppableIterator<Block> {
 	 * @throws IllegalStateException randomly (Bukkit bug)
 	 */
 	public BlockLineIterator(Block start, Block end) throws IllegalStateException {
-		super(new BlockIterator(start.getWorld(), fitInWorld(start.getLocation().add(0.5, 0.5, 0.5), end.getLocation().subtract(start.getLocation()).toVector()),
-				end.equals(start) ? new Vector(1, 0, 0) : end.getLocation().subtract(start.getLocation()).toVector(), 0, 0), // should prevent an error if start = end
+		super(new BlockIterator(start.getWorld(), start.getLocation().toVector(),
+				end.equals(start) ? new Vector(1, 0, 0) : end.getLocation().subtract(start.getLocation()).toVector(), // should prevent an error if start = end
+				0, 0
+			),
 		new NullableChecker<Block>() {
 			private final double overshotSq = Math.pow(start.getLocation().distance(end.getLocation()) + 2, 2);
 			
@@ -59,7 +43,7 @@ public boolean check(@Nullable Block block) {
 	 * @throws IllegalStateException randomly (Bukkit bug)
 	 */
 	public BlockLineIterator(Location start, Vector direction, double distance) throws IllegalStateException {
-		super(new BlockIterator(start.getWorld(), fitInWorld(start, direction), direction, 0, 0), new NullableChecker<Block>() {
+		super(new BlockIterator(start.getWorld(), start.toVector(), direction, 0, 0), new NullableChecker<Block>() {
 			private final double distSq = distance * distance;
 			
 			@Override
diff --git a/src/main/java/ch/njol/skript/util/Color.java b/src/main/java/ch/njol/skript/util/Color.java
index 1c5671aea0a..127e809652f 100644
--- a/src/main/java/ch/njol/skript/util/Color.java
+++ b/src/main/java/ch/njol/skript/util/Color.java
@@ -18,30 +18,48 @@
  */
 package ch.njol.skript.util;
 
+import ch.njol.yggdrasil.YggdrasilSerializable.YggdrasilExtendedSerializable;
 import org.bukkit.DyeColor;
 import org.jetbrains.annotations.Nullable;
 
-import ch.njol.yggdrasil.YggdrasilSerializable.YggdrasilExtendedSerializable;
-
 public interface Color extends YggdrasilExtendedSerializable {
-	
+
 	/**
 	 * Gets Bukkit color representing this color.
 	 * @return Bukkit color.
 	 */
 	org.bukkit.Color asBukkitColor();
-	
-	
+
+	/**
+	 * @return The alpha component of this color.
+	 */
+	int getAlpha();
+
+	/**
+	 * @return The red component of this color.
+	 */
+	int getRed();
+
+	/**
+	 * @return The green component of this color.
+	 */
+	int getGreen();
+
+	/**
+	 * @return The blue component of this color.
+	 */
+	int getBlue();
+
 	/**
 	 * Gets Bukkit dye color representing this color, if one exists.
 	 * @return Dye color or null.
 	 */
 	@Nullable
 	DyeColor asDyeColor();
-	
+
 	/**
 	 * @return Name of the color.
 	 */
 	String getName();
-	
+
 }
diff --git a/src/main/java/ch/njol/skript/util/ColorRGB.java b/src/main/java/ch/njol/skript/util/ColorRGB.java
index 141f753f701..180b26e7c81 100644
--- a/src/main/java/ch/njol/skript/util/ColorRGB.java
+++ b/src/main/java/ch/njol/skript/util/ColorRGB.java
@@ -1,6 +1,5 @@
 package ch.njol.skript.util;
 
-import ch.njol.skript.Skript;
 import ch.njol.skript.variables.Variables;
 import ch.njol.util.Math2;
 import ch.njol.yggdrasil.Fields;
@@ -18,7 +17,6 @@
 
 public class ColorRGB implements Color {
 
-	private static final boolean HAS_ARGB = Skript.methodExists(org.bukkit.Color.class, "getAlpha");
 	private static final Pattern RGB_PATTERN = Pattern.compile("(?>rgb|RGB) (\\d+), (\\d+), (\\d+)");
 
 	private org.bukkit.Color bukkit;
@@ -60,13 +58,7 @@ public ColorRGB(org.bukkit.Color bukkit) {
 	 */
 	@Contract("_,_,_,_ -> new")
 	public static @NotNull ColorRGB fromRGBA(int red, int green, int blue, int alpha) {
-		org.bukkit.Color bukkit;
-		if (HAS_ARGB) {
-			bukkit = org.bukkit.Color.fromARGB(alpha, red, green, blue);
-		} else {
-			bukkit = org.bukkit.Color.fromRGB(red, green, blue);
-		}
-		return new ColorRGB(bukkit);
+		return new ColorRGB(org.bukkit.Color.fromARGB(alpha, red, green, blue));
 	}
 
 	/**
@@ -93,6 +85,26 @@ public ColorRGB(org.bukkit.Color bukkit) {
 		return new ColorRGB(bukkit);
 	}
 
+	@Override
+	public int getAlpha() {
+		return bukkit.getAlpha();
+	}
+
+	@Override
+	public int getRed() {
+		return bukkit.getRed();
+	}
+
+	@Override
+	public int getGreen() {
+		return bukkit.getGreen();
+	}
+
+	@Override
+	public int getBlue() {
+		return bukkit.getBlue();
+	}
+
 	@Override
 	public org.bukkit.Color asBukkitColor() {
 		return bukkit;
@@ -106,7 +118,7 @@ public org.bukkit.Color asBukkitColor() {
 	@Override
 	public String getName() {
 		String rgb = bukkit.getRed() + ", " + bukkit.getGreen() + ", " + bukkit.getBlue();
-		if (HAS_ARGB && bukkit.getAlpha() != 255)
+		if (bukkit.getAlpha() != 255)
 			return "argb " + bukkit.getAlpha() + ", " + rgb;
 		return "rgb " + rgb;
 	}
diff --git a/src/main/java/ch/njol/skript/util/SkriptColor.java b/src/main/java/ch/njol/skript/util/SkriptColor.java
index 7d03b13ed81..598fc66b6fa 100644
--- a/src/main/java/ch/njol/skript/util/SkriptColor.java
+++ b/src/main/java/ch/njol/skript/util/SkriptColor.java
@@ -18,6 +18,15 @@
  */
 package ch.njol.skript.util;
 
+import ch.njol.skript.localization.Adjective;
+import ch.njol.skript.localization.Language;
+import ch.njol.skript.variables.Variables;
+import ch.njol.yggdrasil.Fields;
+import org.bukkit.ChatColor;
+import org.bukkit.DyeColor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
 import java.io.NotSerializableException;
 import java.io.StreamCorruptedException;
 import java.util.Arrays;
@@ -26,18 +35,6 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
-import java.util.regex.Pattern;
-
-import org.bukkit.ChatColor;
-import org.bukkit.DyeColor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import ch.njol.skript.Skript;
-import ch.njol.skript.localization.Adjective;
-import ch.njol.skript.localization.Language;
-import ch.njol.skript.variables.Variables;
-import ch.njol.yggdrasil.Fields;
 
 @SuppressWarnings("null")
 public enum SkriptColor implements Color {
@@ -96,7 +93,27 @@ public enum SkriptColor implements Color {
 	public org.bukkit.Color asBukkitColor() {
 		return dye.getColor();
 	}
-	
+
+	@Override
+	public int getAlpha() {
+		return dye.getColor().getAlpha();
+	}
+
+	@Override
+	public int getRed() {
+		return dye.getColor().getRed();
+	}
+
+	@Override
+	public int getGreen() {
+		return dye.getColor().getGreen();
+	}
+
+	@Override
+	public int getBlue() {
+		return dye.getColor().getBlue();
+	}
+
 	@Override
 	public DyeColor asDyeColor() {
 		return dye;
diff --git a/src/main/java/ch/njol/util/coll/CollectionUtils.java b/src/main/java/ch/njol/util/coll/CollectionUtils.java
index 8b48a505662..ecda9c0294f 100644
--- a/src/main/java/ch/njol/util/coll/CollectionUtils.java
+++ b/src/main/java/ch/njol/util/coll/CollectionUtils.java
@@ -19,20 +19,13 @@
 package ch.njol.util.coll;
 
 import ch.njol.util.Pair;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnknownNullability;
 
 import java.lang.reflect.Array;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Random;
-import java.util.Set;
+import java.util.function.Predicate;
 
 /**
  * Utils for collections and arrays. All methods will not print any errors for <tt>null</tt> collections/arrays, but will return false/-1/etc.
@@ -102,7 +95,30 @@ public static <T> boolean containsAll(final @Nullable T[] array, final @Nullable
 		}
 		return true;
 	}
-	
+
+	/**
+	 * Checks the elements of an array against a given predicate.
+	 *
+	 * @param array the array to check, can be null
+	 * @param predicate the predicate to test the elements against
+	 * @param and if true, all elements must satisfy the predicate; if false, any element satisfying the predicate is enough
+	 * @param <T> the type of elements in the array
+	 * @return true if the condition is met based on the value of the 'and' parameter, false otherwise
+	 */
+	public static <T> boolean check(T @Nullable [] array, Predicate<T> predicate, boolean and) {
+		if (array == null)
+			return false;
+		for (T value : array) {
+			boolean result = predicate.test(value);
+			// exit early if we find a FALSE and we're ANDing, or a TRUE and we're ORing
+			if (and && !result)
+				return false;
+			if (!and && result)
+				return true;
+		}
+		return and;
+	}
+
 	public static int indexOf(final @Nullable int[] array, final int num) {
 		if (array == null)
 			return -1;
diff --git a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayModule.java b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayModule.java
index 024552f3219..7d9e51b28e2 100644
--- a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayModule.java
+++ b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayModule.java
@@ -7,8 +7,11 @@
 import ch.njol.skript.expressions.base.EventValueExpression;
 import ch.njol.skript.registrations.Classes;
 import org.bukkit.entity.Display;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.ItemDisplay;
 import org.bukkit.entity.TextDisplay;
+import org.skriptlang.skript.lang.converter.Converter;
+import org.skriptlang.skript.lang.converter.Converters;
 
 import java.io.IOException;
 
@@ -49,6 +52,10 @@ public static void load() throws IOException {
 			.name("Item Display Transforms")
 			.description("Represents the transform setting of an item display.")
 			.since("INSERT VERSION"));
+
+		Converters.registerConverter(Entity.class, Display.class,
+				entity -> entity instanceof Display display ? display : null,
+				Converter.NO_RIGHT_CHAINING);
 	}
 
 }
diff --git a/src/main/java/org/skriptlang/skript/bukkit/input/InputKey.java b/src/main/java/org/skriptlang/skript/bukkit/input/InputKey.java
new file mode 100644
index 00000000000..eef0e870b50
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/bukkit/input/InputKey.java
@@ -0,0 +1,55 @@
+package org.skriptlang.skript.bukkit.input;
+
+import org.bukkit.Input;
+
+import java.util.EnumSet;
+import java.util.Set;
+
+/**
+ * Enum representing different movement input keys.
+ * @see Input
+ */
+public enum InputKey {
+
+	FORWARD,
+	BACKWARD,
+	RIGHT,
+	LEFT,
+	JUMP,
+	SNEAK,
+	SPRINT;
+
+	/**
+	 * Checks if the given {@link Input} is pressing this {@link InputKey}.
+	 *
+	 * @param input the input to check
+	 * @return true if the {@link Input} is pressing this {@link InputKey}, false otherwise
+	 */
+	public boolean check(Input input) {
+		return switch (this) {
+			case FORWARD -> input.isForward();
+			case BACKWARD -> input.isBackward();
+			case RIGHT -> input.isRight();
+			case LEFT -> input.isLeft();
+			case JUMP -> input.isJump();
+			case SNEAK -> input.isSneak();
+			case SPRINT -> input.isSprint();
+		};
+	}
+
+	/**
+	 * Returns a set of {@link InputKey}s that match the given {@link Input}.
+	 *
+	 * @param input the input to check
+	 * @return a set of {@link InputKey}s that match the given {@link Input}
+	 */
+	public static Set<InputKey> fromInput(Input input) {
+		Set<InputKey> keys = EnumSet.noneOf(InputKey.class);
+		for (InputKey key : values()) {
+			if (key.check(input))
+				keys.add(key);
+		}
+		return keys;
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/bukkit/input/InputModule.java b/src/main/java/org/skriptlang/skript/bukkit/input/InputModule.java
new file mode 100644
index 00000000000..862c08fc3d8
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/bukkit/input/InputModule.java
@@ -0,0 +1,42 @@
+package org.skriptlang.skript.bukkit.input;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.classes.EnumClassInfo;
+import ch.njol.skript.registrations.Classes;
+import ch.njol.skript.registrations.EventValues;
+import ch.njol.skript.util.Getter;
+import org.bukkit.event.player.PlayerInputEvent;
+
+import java.io.IOException;
+
+public class InputModule {
+
+	public static void load() throws IOException {
+		if (!Skript.classExists("org.bukkit.Input"))
+			return;
+
+		Skript.getAddonInstance().loadClasses("org.skriptlang.skript.bukkit.input.elements");
+
+		Classes.registerClass(new EnumClassInfo<>(InputKey.class, "inputkey", "input keys")
+			.user("input ?keys?")
+			.name("Input Key")
+			.description("Represents a movement input key that is pressed by a player.")
+			.since("INSERT VERSION")
+			.requiredPlugins("Minecraft 1.21.3+"));
+
+		EventValues.registerEventValue(PlayerInputEvent.class, InputKey[].class, new Getter<>() {
+			@Override
+			public InputKey[] get(PlayerInputEvent event) {
+				return InputKey.fromInput(event.getInput()).toArray(new InputKey[0]);
+			}
+		}, EventValues.TIME_NOW);
+
+		EventValues.registerEventValue(PlayerInputEvent.class, InputKey[].class, new Getter<>() {
+			@Override
+			public InputKey[] get(PlayerInputEvent event) {
+				return InputKey.fromInput(event.getPlayer().getCurrentInput()).toArray(new InputKey[0]);
+			}
+		}, EventValues.TIME_PAST);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/bukkit/input/elements/conditions/CondIsPressingKey.java b/src/main/java/org/skriptlang/skript/bukkit/input/elements/conditions/CondIsPressingKey.java
new file mode 100644
index 00000000000..5842b0447f5
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/bukkit/input/elements/conditions/CondIsPressingKey.java
@@ -0,0 +1,96 @@
+package org.skriptlang.skript.bukkit.input.elements.conditions;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.*;
+import ch.njol.skript.lang.Condition;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.SyntaxStringBuilder;
+import ch.njol.util.Kleenean;
+import ch.njol.util.coll.CollectionUtils;
+import org.bukkit.Input;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.player.PlayerInputEvent;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.input.InputKey;
+
+@Name("Is Pressing Key")
+@Description("Checks if a player is pressing a certain input key.")
+@Examples({
+	"on player input:",
+	"\tif player is pressing forward movement key:",
+		"\t\tsend \"You are moving forward!\""
+})
+@Since("INSERT VERSION")
+@Keywords({"press", "input"})
+@RequiredPlugins("Minecraft 1.21.2+")
+public class CondIsPressingKey extends Condition {
+
+	static {
+		if (Skript.classExists("org.bukkit.event.player.PlayerInputEvent")) {
+			Skript.registerCondition(CondIsPressingKey.class,
+				"%players% (is|are) pressing %inputkeys%",
+				"%players% (isn't|is not|aren't|are not) pressing %inputkeys%",
+				"%players% (was|were) pressing %inputkeys%",
+				"%players% (wasn't|was not|weren't|were not) pressing %inputkeys%"
+			);
+		} else {
+			Skript.registerCondition(CondIsPressingKey.class,
+				"%players% (is|are) pressing %inputkeys%",
+				"%players% (isn't|is not|aren't|are not) pressing %inputkeys%"
+			);
+		}
+	}
+
+	private Expression<Player> players;
+	private Expression<InputKey> inputKeys;
+	private boolean past;
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		//noinspection unchecked
+		players = (Expression<Player>) expressions[0];
+		//noinspection unchecked
+		inputKeys = (Expression<InputKey>) expressions[1];
+		past = matchedPattern > 1;
+		if (past && !getParser().isCurrentEvent(PlayerInputEvent.class))
+			Skript.warning("Checking the past state of a player's input outside the 'player input' event has no effect.");
+		setNegated(matchedPattern == 1 || matchedPattern == 3);
+		return true;
+	}
+
+	@Override
+	public boolean check(Event event) {
+		Player eventPlayer = event instanceof PlayerInputEvent inputEvent ? inputEvent.getPlayer() : null;
+		InputKey[] inputKeys = this.inputKeys.getAll(event);
+		boolean and = this.inputKeys.getAnd();
+		return players.check(event, player -> {
+			Input input;
+			// If we want to get the new input of the event-player, we must get it from the event
+			if (!past && player.equals(eventPlayer)) {
+				input = ((PlayerInputEvent) event).getInput();
+			} else { // Otherwise, we get the current (or past in case of an event-player) input
+				input = player.getCurrentInput();
+			}
+			return CollectionUtils.check(inputKeys, inputKey -> inputKey.check(input), and);
+		}, isNegated());
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
+		builder.append(players);
+		if (past) {
+			builder.append(players.isSingle() ? "was" : "were");
+		} else {
+			builder.append(players.isSingle() ? "is" : "are");
+		}
+		if (isNegated())
+			builder.append("not");
+		builder.append("pressing");
+		builder.append(inputKeys);
+		return builder.toString();
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/bukkit/input/elements/events/EvtPlayerInput.java b/src/main/java/org/skriptlang/skript/bukkit/input/elements/events/EvtPlayerInput.java
new file mode 100644
index 00000000000..6decbb27207
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/bukkit/input/elements/events/EvtPlayerInput.java
@@ -0,0 +1,124 @@
+package org.skriptlang.skript.bukkit.input.elements.events;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptEvent;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.SyntaxStringBuilder;
+import org.bukkit.event.Event;
+import org.bukkit.event.player.PlayerInputEvent;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.input.InputKey;
+
+import java.util.Set;
+
+public class EvtPlayerInput extends SkriptEvent {
+
+	static {
+		if (Skript.classExists("org.bukkit.event.player.PlayerInputEvent")) {
+			Skript.registerEvent("Player Input", EvtPlayerInput.class, PlayerInputEvent.class,
+					"[player] (toggle|toggling|1:press[ing]|2:release|2:releasing) of (%-inputkeys%|(an|any) input key)",
+					"([player] %-inputkeys%|[an|any [player]] input key) (toggle|toggling|1:press[ing]|2:release|2:releasing)")
+				.description("Called when a player sends an updated input to the server.",
+					"Note: The input keys event value is the set of keys the player is currently pressing, not the keys that were pressed or released.")
+				.examples("on any input key press:",
+					"\tsend \"You are pressing: %event-inputkeys%\" to player")
+				.since("INSERT VERSION")
+				.requiredPlugins("Minecraft 1.21.3+");
+		}
+	}
+
+	private @Nullable Literal<InputKey> keysToCheck;
+	private InputType type;
+
+	@Override
+	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult) {
+		//noinspection unchecked
+		keysToCheck = (Literal<InputKey>) args[0];
+		type = InputType.values()[parseResult.mark];
+		return true;
+	}
+
+	@Override
+	public boolean check(Event event) {
+		PlayerInputEvent inputEvent = (PlayerInputEvent) event;
+		Set<InputKey> previousKeys = InputKey.fromInput(inputEvent.getPlayer().getCurrentInput());
+		Set<InputKey> currentKeys = InputKey.fromInput(inputEvent.getInput());
+		Set<InputKey> keysToCheck = this.keysToCheck != null ? Set.of(this.keysToCheck.getAll()) : null;
+		boolean and = this.keysToCheck != null && this.keysToCheck.getAnd();
+		return type.checkInputKeys(previousKeys, currentKeys, keysToCheck, and);
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
+		builder.append("player");
+		builder.append(type.name().toLowerCase());
+		builder.append(keysToCheck == null ? "any input key" : keysToCheck);
+		return builder.toString();
+	}
+
+	private enum InputType {
+
+		TOGGLE {
+			@Override
+			public boolean checkKeyState(boolean inPrevious, boolean inCurrent) {
+				return inPrevious != inCurrent;
+			}
+		},
+		PRESS {
+			@Override
+			public boolean checkKeyState(boolean inPrevious, boolean inCurrent) {
+				return !inPrevious && inCurrent;
+			}
+		},
+		RELEASE {
+			@Override
+			public boolean checkKeyState(boolean inPrevious, boolean inCurrent) {
+				return inPrevious && !inCurrent;
+			}
+		};
+
+		/**
+		 * Checks the state of a key based on its presence in the previous and current sets of keys.
+		 *
+		 * @param inPrevious true if the key was present in the previous set of keys, false otherwise
+		 * @param inCurrent true if the key is present in the current set of keys, false otherwise
+		 * @return true if the key state matches the condition defined by the input type, false otherwise
+		 */
+		public abstract boolean checkKeyState(boolean inPrevious, boolean inCurrent);
+
+		/**
+		 * Checks the input keys based on the previous and current sets of keys.
+		 * <br>
+		 * {@code previous} and {@code current} are never the same.
+		 *
+		 * @param previous the set of keys before the input change
+		 * @param current the set of keys after the input change
+		 * @param keysToCheck the set of keys to check against, can be null
+		 * @param and true if the keys to check must all be present, false if any key is enough
+		 * @return true if the condition is met based on the input type, false otherwise
+		 */
+		public boolean checkInputKeys(Set<InputKey> previous, Set<InputKey> current, @Nullable Set<InputKey> keysToCheck, boolean and) {
+			if (keysToCheck == null) {
+				return switch (this) {
+					case TOGGLE -> true;
+					case PRESS -> previous.size() <= current.size();
+					case RELEASE -> previous.size() >= current.size();
+				};
+			}
+			for (InputKey key : keysToCheck) {
+				boolean inPrevious = previous.contains(key);
+				boolean inCurrent = current.contains(key);
+				if (and && !checkKeyState(inPrevious, inCurrent)) {
+					return false;
+				} else if (!and && checkKeyState(inPrevious, inCurrent)) {
+					return true;
+				}
+			}
+			return and;
+		}
+
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/bukkit/input/elements/expressions/ExprCurrentInputKeys.java b/src/main/java/org/skriptlang/skript/bukkit/input/elements/expressions/ExprCurrentInputKeys.java
new file mode 100644
index 00000000000..ddc4372215c
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/bukkit/input/elements/expressions/ExprCurrentInputKeys.java
@@ -0,0 +1,77 @@
+package org.skriptlang.skript.bukkit.input.elements.expressions;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.*;
+import ch.njol.skript.expressions.base.PropertyExpression;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.registrations.EventValues;
+import ch.njol.util.Kleenean;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.player.PlayerInputEvent;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.input.InputKey;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Name("Player Input Keys")
+@Description("Get the current input keys of a player.")
+@Examples("broadcast \"%player% is pressing %current input keys of player%\"")
+@Since("INSERT VERSION")
+@RequiredPlugins("Minecraft 1.21.2+")
+public class ExprCurrentInputKeys extends PropertyExpression<Player, InputKey> {
+
+	private static final boolean SUPPORTS_TIME_STATES = Skript.classExists("org.bukkit.event.player.PlayerInputEvent");
+
+	static {
+		register(ExprCurrentInputKeys.class, InputKey.class, "[current] (inputs|input keys)", "players");
+	}
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		setExpr((Expression<? extends Player>) expressions[0]);
+		return true;
+	}
+
+	@Override
+	protected InputKey[] get(Event event, Player[] source) {
+		Player eventPlayer = null;
+		if (SUPPORTS_TIME_STATES && getTime() == EventValues.TIME_NOW && event instanceof PlayerInputEvent inputEvent)
+			eventPlayer = inputEvent.getPlayer();
+
+		List<InputKey> inputKeys = new ArrayList<>();
+		for (Player player : source) {
+			if (player.equals(eventPlayer)) {
+				inputKeys.addAll(InputKey.fromInput(((PlayerInputEvent) event).getInput()));
+			} else {
+				inputKeys.addAll(InputKey.fromInput(player.getCurrentInput()));
+			}
+		}
+		return inputKeys.toArray(new InputKey[0]);
+	}
+
+	@Override
+	public boolean isSingle() {
+		return false;
+	}
+
+	@Override
+	public Class<? extends InputKey> getReturnType() {
+		return InputKey.class;
+	}
+
+	@Override
+	public boolean setTime(int time) {
+		if (!SUPPORTS_TIME_STATES)
+			return super.setTime(time);
+		return time != EventValues.TIME_FUTURE && setTime(time, PlayerInputEvent.class);
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "the current input keys of " + getExpr().toString(event, debug);
+	}
+
+}
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 27a8065e122..10563db0b68 100644
--- a/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
+++ b/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
@@ -72,7 +72,7 @@ public static <L, R, T> void registerOperation(Operator operator, Class<L> leftC
 		getOperations_i(operator).add(new OperationInfo<>(leftClass, rightClass, returnType, operation));
 	}
 
-	private static boolean exactOperationExists(Operator operator, Class<?> leftClass, Class<?> rightClass) {
+	public static boolean exactOperationExists(Operator operator, Class<?> leftClass, Class<?> rightClass) {
 		for (OperationInfo<?, ?, ?> info : getOperations_i(operator)) {
 			if (info.getLeft() == leftClass && info.getRight() == rightClass)
 				return true;
@@ -188,7 +188,7 @@ public static <T, R> void registerDifference(Class<T> type, Class<R> returnType,
 		differences.put(type, new DifferenceInfo<>(type, returnType, operation));
 	}
 
-	private static boolean exactDifferenceExists(Class<?> type) {
+	public static boolean exactDifferenceExists(Class<?> type) {
 		return differences.containsKey(type);
 	}
 
diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang
index b628e5bb30e..7c0105e19f8 100644
--- a/src/main/resources/lang/default.lang
+++ b/src/main/resources/lang/default.lang
@@ -2418,6 +2418,16 @@ experience cooldown change reasons:
 	plugin: plugin
 	pickup_orb: orb pickup, pickup orb
 
+# -- Input Keys --
+input keys:
+	forward: forward movement key, forward key
+	backward: backward movement key, backward key
+	left: left movement key, left key
+	right: right movement key, right key
+	jump: jump key, jumping key
+	sneak: sneak key, sneaking key
+	sprint: sprint key, sprinting key
+
 # -- Boolean --
 boolean:
 	true:
@@ -2505,6 +2515,7 @@ types:
 	itemdisplaytransform: item display transform¦s @an
 	minecrafttag: minecraft tag¦s @a
 	experiencecooldownchangereason: experience cooldown change reason¦s @a
+	inputkey: input key¦s @an
 
 	# Skript
 	weathertype: weather type¦s @a
diff --git a/src/main/resources/lang/turkish.lang b/src/main/resources/lang/turkish.lang
index fc2ffdcaaca..4946c6f5d9e 100644
--- a/src/main/resources/lang/turkish.lang
+++ b/src/main/resources/lang/turkish.lang
@@ -47,7 +47,7 @@ skript command:
 		test: Skript'in dahili testleri için kullanılır.
 
 	invalid script: <grey>'<gold>%s<grey>'<red> adlı script scripts klasöründe bulunamadı!
-  invalid folder: <grey>'<gold>%s<grey>'<red> adlı klasör scripts klasöründe bulunamadı!
+	invalid folder: <grey>'<gold>%s<grey>'<red> adlı klasör scripts klasöründe bulunamadı!
 	reload:
 		warning line info: <gold><bold>Satır %s:<gray> (%s)<reset>\n
 		error line info: <light red><bold>Satır %s:<gray> (%s)<reset>\n
@@ -165,7 +165,7 @@ aliases:
 	unknown variation: %s varyasyonu daha önce tanımlanmadı.
 	missing aliases: Bu Minecraft ID'lerinin herhangi bir alias'ı yoktur:
 	empty alias: Alias'ın tanımlı bir Minecraft ID'si veya tag'i yok.
-  invalid minecraft id: Minecraft ID %s geçerli değil
+	invalid minecraft id: Minecraft ID %s geçerli değil
 	useless variation: Varyasyonun Minecraft ID'si veya tag'i yok, bu yüzden gereksiz.
 	invalid tags: Belirtilen tagler geçerli JSON'da tanımlı değil.
 	unexpected section: Section'lara burada izin verilmiyor.
diff --git a/src/test/java/org/skriptlang/skript/test/tests/regression/MissingTreeSaplingMapEntriesTest.java b/src/test/java/org/skriptlang/skript/test/tests/regression/MissingTreeSaplingMapEntriesTest.java
new file mode 100644
index 00000000000..371c03a48ba
--- /dev/null
+++ b/src/test/java/org/skriptlang/skript/test/tests/regression/MissingTreeSaplingMapEntriesTest.java
@@ -0,0 +1,17 @@
+package org.skriptlang.skript.test.tests.regression;
+
+import ch.njol.skript.bukkitutil.ItemUtils;
+import org.bukkit.TreeType;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MissingTreeSaplingMapEntriesTest {
+
+	@Test
+	public void test() {
+		for (TreeType type : TreeType.values()) {
+			Assert.assertNotNull("Tree type " + type + " has no mapped sapling in ItemUtils#getTreeSapling().", ItemUtils.getTreeSapling(type));
+		}
+	}
+
+}
diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/conditions/CondIsPressingKeyTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/conditions/CondIsPressingKeyTest.java
new file mode 100644
index 00000000000..8461d01954d
--- /dev/null
+++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/conditions/CondIsPressingKeyTest.java
@@ -0,0 +1,74 @@
+package org.skriptlang.skript.test.tests.syntaxes.conditions;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Condition;
+import ch.njol.skript.lang.util.ContextlessEvent;
+import ch.njol.skript.test.runner.SkriptJUnitTest;
+import ch.njol.skript.variables.Variables;
+import org.bukkit.entity.Player;
+import org.easymock.EasyMock;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.skriptlang.skript.bukkit.input.InputKey;
+import org.skriptlang.skript.test.utils.InputHelper;
+
+public class CondIsPressingKeyTest extends SkriptJUnitTest {
+
+	private static final boolean SUPPORTS_INPUT = Skript.classExists("org.bukkit.Input");
+
+	static {
+		setShutdownDelay(1);
+	}
+
+	private Player testPlayer;
+	private InputKey[] testInputKeys;
+	private Condition isPressingKeyCondition;
+
+	@Before
+	public void setup() {
+		if (!SUPPORTS_INPUT)
+			return;
+		testPlayer = EasyMock.niceMock(Player.class);
+		testInputKeys = new InputKey[]{InputKey.FORWARD, InputKey.JUMP};
+		isPressingKeyCondition = Condition.parse("{_player} is pressing {_input-keys::*}", null);
+	}
+
+	@Test
+	public void test() {
+		if (!SUPPORTS_INPUT)
+			return;
+		if (isPressingKeyCondition == null)
+			Assert.fail("Is pressing key condition is null");
+
+		ContextlessEvent event = ContextlessEvent.get();
+		Variables.setVariable("player", testPlayer, event, true);
+		Variables.setVariable("input-keys::1", testInputKeys[0], event, true);
+
+		EasyMock.expect(testPlayer.getCurrentInput()).andReturn(InputHelper.fromKeys(testInputKeys));
+		EasyMock.replay(testPlayer);
+		assert isPressingKeyCondition.check(event);
+		EasyMock.verify(testPlayer);
+
+		EasyMock.resetToNice(testPlayer);
+		EasyMock.expect(testPlayer.getCurrentInput()).andReturn(InputHelper.fromKeys(testInputKeys[1]));
+		EasyMock.replay(testPlayer);
+		assert !isPressingKeyCondition.check(event);
+		EasyMock.verify(testPlayer);
+
+		EasyMock.resetToNice(testPlayer);
+		Variables.setVariable("input-keys::2", testInputKeys[1], event, true);
+		EasyMock.expect(testPlayer.getCurrentInput()).andReturn(InputHelper.fromKeys(testInputKeys));
+		EasyMock.replay(testPlayer);
+		assert isPressingKeyCondition.check(event);
+		EasyMock.verify(testPlayer);
+
+		EasyMock.resetToNice(testPlayer);
+		Variables.setVariable("input-keys::3", InputKey.SNEAK, event, true);
+		EasyMock.expect(testPlayer.getCurrentInput()).andReturn(InputHelper.fromKeys(testInputKeys));
+		EasyMock.replay(testPlayer);
+		assert !isPressingKeyCondition.check(event);
+		EasyMock.verify(testPlayer);
+	}
+
+}
diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/events/EvtPlayerInputTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/events/EvtPlayerInputTest.java
new file mode 100644
index 00000000000..782b29f8ae0
--- /dev/null
+++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/events/EvtPlayerInputTest.java
@@ -0,0 +1,40 @@
+package org.skriptlang.skript.test.tests.syntaxes.events;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.test.runner.SkriptJUnitTest;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.easymock.EasyMock;
+import org.junit.Before;
+import org.junit.Test;
+import org.skriptlang.skript.bukkit.input.InputKey;
+import org.skriptlang.skript.test.utils.InputHelper;
+
+public class EvtPlayerInputTest extends SkriptJUnitTest {
+
+	private static final boolean SUPPORTS_INPUT_EVENT = Skript.classExists("org.bukkit.event.player.PlayerInputEvent");
+
+	static {
+		setShutdownDelay(1);
+	}
+
+	private Player player;
+
+	@Before
+	public void setup() {
+		if (!SUPPORTS_INPUT_EVENT)
+			return;
+		player = EasyMock.niceMock(Player.class);
+	}
+
+	@Test
+	public void test() {
+		if (!SUPPORTS_INPUT_EVENT)
+			return;
+		EasyMock.expect(player.getCurrentInput()).andStubReturn(InputHelper.fromKeys(InputKey.FORWARD));
+		EasyMock.replay(player);
+		Bukkit.getPluginManager().callEvent(InputHelper.createPlayerInputEvent(player, InputKey.FORWARD, InputKey.JUMP));
+		EasyMock.verify(player);
+	}
+
+}
diff --git a/src/test/java/org/skriptlang/skript/test/tests/syntaxes/expressions/ExprCurrentInputKeysTest.java b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/expressions/ExprCurrentInputKeysTest.java
new file mode 100644
index 00000000000..06f57ca0ee3
--- /dev/null
+++ b/src/test/java/org/skriptlang/skript/test/tests/syntaxes/expressions/ExprCurrentInputKeysTest.java
@@ -0,0 +1,54 @@
+package org.skriptlang.skript.test.tests.syntaxes.expressions;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.util.ContextlessEvent;
+import ch.njol.skript.test.runner.SkriptJUnitTest;
+import ch.njol.skript.variables.Variables;
+import org.bukkit.entity.Player;
+import org.easymock.EasyMock;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.skriptlang.skript.bukkit.input.InputKey;
+import org.skriptlang.skript.test.utils.InputHelper;
+
+public class ExprCurrentInputKeysTest extends SkriptJUnitTest {
+
+	private static final boolean SUPPORTS_INPUT = Skript.classExists("org.bukkit.Input");
+
+	static {
+		setShutdownDelay(1);
+	}
+
+	private Player player;
+	private Expression<? extends InputKey> inputKeyExpression;
+
+	@Before
+	public void setup() {
+		if (!SUPPORTS_INPUT)
+			return;
+		player = EasyMock.niceMock(Player.class);
+		//noinspection unchecked
+		inputKeyExpression = new SkriptParser("input keys of {_player}").parseExpression(InputKey.class);
+	}
+
+	@Test
+	public void test() {
+		if (!SUPPORTS_INPUT)
+			return;
+		if (inputKeyExpression == null)
+			Assert.fail("Input keys expression is null");
+
+		ContextlessEvent event = ContextlessEvent.get();
+		Variables.setVariable("player", player, event, true);
+
+		EasyMock.expect(player.getCurrentInput()).andReturn(InputHelper.fromKeys(InputKey.FORWARD, InputKey.JUMP));
+		EasyMock.replay(player);
+		InputKey[] keys = inputKeyExpression.getArray(event);
+		Assert.assertArrayEquals(keys, new InputKey[]{InputKey.FORWARD, InputKey.JUMP});
+		EasyMock.verify(player);
+	}
+
+}
diff --git a/src/test/java/org/skriptlang/skript/test/utils/InputHelper.java b/src/test/java/org/skriptlang/skript/test/utils/InputHelper.java
new file mode 100644
index 00000000000..b3ba4112a1b
--- /dev/null
+++ b/src/test/java/org/skriptlang/skript/test/utils/InputHelper.java
@@ -0,0 +1,33 @@
+package org.skriptlang.skript.test.utils;
+
+import org.bukkit.Input;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerEvent;
+import org.bukkit.event.player.PlayerInputEvent;
+import org.easymock.EasyMock;
+import org.skriptlang.skript.bukkit.input.InputKey;
+
+public class InputHelper {
+
+	public static PlayerEvent createPlayerInputEvent(Player player, InputKey... keys) {
+		return new PlayerInputEvent(player, fromKeys(keys));
+	}
+
+	public static Input fromKeys(InputKey... keys) {
+		Input input = EasyMock.niceMock(Input.class);
+		for (InputKey key : keys) {
+			switch (key) {
+				case FORWARD -> EasyMock.expect(input.isForward()).andStubReturn(true);
+				case BACKWARD -> EasyMock.expect(input.isBackward()).andStubReturn(true);
+				case RIGHT -> EasyMock.expect(input.isRight()).andStubReturn(true);
+				case LEFT -> EasyMock.expect(input.isLeft()).andStubReturn(true);
+				case JUMP -> EasyMock.expect(input.isJump()).andStubReturn(true);
+				case SNEAK -> EasyMock.expect(input.isSneak()).andStubReturn(true);
+				case SPRINT -> EasyMock.expect(input.isSprint()).andStubReturn(true);
+			}
+		}
+		EasyMock.replay(input);
+		return input;
+	}
+
+}
diff --git a/src/test/skript/junit/EvtPlayerInput.sk b/src/test/skript/junit/EvtPlayerInput.sk
new file mode 100644
index 00000000000..87c8822ec93
--- /dev/null
+++ b/src/test/skript/junit/EvtPlayerInput.sk
@@ -0,0 +1,62 @@
+test "EvtPlayerInputJUnit" when running JUnit:
+	running minecraft "1.21.3"
+	set {_tests::1} to "player is pressing event-inputkeys"
+	set {_tests::2} to "inputs of player is event-inputkeys"
+	set {_tests::3} to "past inputs of player is past event-inputkeys"
+	set {_tests::4} to "player is pressing forward key"
+	set {_tests::5} to "player is pressing jump key"
+	set {_tests::6} to "player is pressing forward key and jump key"
+	set {_tests::7} to "player is pressing forward key, sneak key, or backward key"
+	set {_tests::8} to "player is not pressing sneak key"
+	set {_tests::9} to "player is not pressing forward key and sneak key"
+	set {_tests::10} to "player was pressing forward key"
+	set {_tests::11} to "player was not pressing jump key"
+
+	ensure junit test "org.skriptlang.skript.test.tests.syntaxes.events.EvtPlayerInputTest" completes {_tests::*}
+
+parse:
+	results: {EvtPlayerInput::parse::*}
+	code:
+		on toggle of any input key:
+			set {_test} to "org.skriptlang.skript.test.tests.syntaxes.events.EvtPlayerInputTest"
+			junit test is {_test}
+
+			if player is pressing event-inputkeys:
+				complete objective "player is pressing event-inputkeys" for {_test}
+
+			if inputs of player is event-inputkeys:
+				complete objective "inputs of player is event-inputkeys" for {_test}
+
+			if past inputs of player is past event-inputkeys:
+				complete objective "past inputs of player is past event-inputkeys" for {_test}
+
+			if player is pressing forward key:
+				complete objective "player is pressing forward key" for {_test}
+
+			if player is pressing jump key:
+				complete objective "player is pressing jump key" for {_test}
+
+			if player is pressing forward key and jump key:
+				complete objective "player is pressing forward key and jump key" for {_test}
+
+			if player is pressing forward key, sneak key, or backward key:
+				complete objective "player is pressing forward key, sneak key, or backward key" for {_test}
+
+			if player is not pressing sneak key:
+				complete objective "player is not pressing sneak key" for {_test}
+
+			if player is not pressing forward key and sneak key:
+				complete objective "player is not pressing forward key and sneak key" for {_test}
+
+			if player was pressing forward key:
+				complete objective "player was pressing forward key" for {_test}
+
+			if player was not pressing jump key:
+				complete objective "player was not pressing jump key" for {_test}
+
+test "EvtPlayerInput":
+	if running minecraft "1.21.3":
+		assert {EvtPlayerInput::parse::*} is not set with "Player input event failed to parse in 1.21.3 and above"
+	else:
+		assert {EvtPlayerInput::parse::*} is set with "Player input event successfully parsed in 1.21.2 and below"
+
diff --git a/src/test/skript/tests/misc/expression sections.sk b/src/test/skript/tests/misc/expression sections.sk
new file mode 100644
index 00000000000..b94f54262f6
--- /dev/null
+++ b/src/test/skript/tests/misc/expression sections.sk	
@@ -0,0 +1,46 @@
+test "expression sections":
+	set {_var} to false
+	set {_runnable} to a new runnable:
+		set {_var} to true
+
+	assert {_var} is false with "expression section ran too early!"
+
+	run {_runnable}
+	assert {_var} is true with "expression section didn't run!"
+
+	# try it again in case it stops working for some reason
+	set {_var} to false
+	run {_runnable}
+	assert {_var} is true with "expression section didn't run again!"
+
+	# section in a section!
+	set {_runnable} to a new runnable:
+		set {_runnable2} to a new runnable:
+			set {_var} to true
+		run {_runnable2}
+	set {_var} to false
+	run {_runnable}
+	assert {_var} is true with "expression section in expression section didn't run"
+
+
+test "expression sections that don't work":
+	# Section with no section expression!
+	set {_expected} to "The line 'set {_var} to true' is a valid statement but cannot function as a section (:) because there is no syntax in the line to manage it."
+	parse:
+		set {_var} to true:
+			broadcast "NO BAD"
+	assert last parse logs contain {_expected} with "section was allowed with no header syntax"
+
+	# Multiple section expressions in one line!
+	set {_expected} to "The syntax 'a new runnable' tried to claim the current section, but it was already claimed by 'a new runnable'. You cannot have two section-starters in the same line."
+	parse:
+		set {_list::*} to a new runnable, a new runnable and a new runnable:
+			broadcast "NO BAD"
+	assert last parse logs contain {_expected} with "section was allowed with multiple headers"
+
+	# Regular section and a section expression in one line!
+	set {_expected} to "The syntax 'if {_var} is equal to a new runnable' tried to claim the current section, but it was already claimed by 'a new runnable'. You cannot have two section-starters in the same line."
+	parse:
+		if {_var} is a new runnable:
+			broadcast "NO BAD"
+	assert last parse logs contain {_expected} with "section was allowed with multiple headers"
diff --git a/src/test/skript/tests/misc/pull-7129-pretty-quotes.sk b/src/test/skript/tests/misc/pull-7129-pretty-quotes.sk
new file mode 100644
index 00000000000..7bf6da5b3e5
--- /dev/null
+++ b/src/test/skript/tests/misc/pull-7129-pretty-quotes.sk
@@ -0,0 +1,30 @@
+
+command /prettyquotecommandtest “prettyquoteliteral” <text>:
+	trigger:
+		set {PrettyQuoteArg} to arg
+
+test "pretty quote usage":
+	set {_error} to "Pretty quotes are not allowed, change to regular quotes"
+	parse:
+		set {_test} to "“Embedded Pretty Quotes”"
+	assert last parse logs does not contain {_error} with "Pretty quotes should work inside strings"
+
+	parse:
+		set {_test} to "" #“Pretty Quote Comment”
+	assert last parse logs does not contain {_error} with "Pretty quotes should work in comments"
+
+	parse:
+		set {_test“”} to ""
+	assert last parse logs does not contain {_error} with "Pretty quotes should work in var names"
+
+	parse:
+		set {_test} to “Pretty Quotes”
+	assert last parse logs contain {_error} with "Pretty quote string usage did not produce expected error"
+
+	parse:
+		set {_test} to "test%“test”%"
+	assert last parse logs contain {_error} with "Pretty quote %%string%% usage did not produce expected error"
+
+	execute command "prettyquotecommandtest “prettyquoteliteral” “prettyquotearg”"
+	assert {PrettyQuoteArg} is "“prettyquotearg”" with "Pretty quotes should work in command args"
+	clear {PrettyQuoteArg}
diff --git a/src/test/skript/tests/regressions/7159-regex exceptions not handled.sk b/src/test/skript/tests/regressions/7159-regex exceptions not handled.sk
new file mode 100644
index 00000000000..691fe8e0da8
--- /dev/null
+++ b/src/test/skript/tests/regressions/7159-regex exceptions not handled.sk	
@@ -0,0 +1,12 @@
+test "regex exceptions not handled":
+	parse:
+		set {_split::*} to regex split "test" at "\b{_name}\b"
+	assert last parse logs is "'\b{_name}\b' is not a valid regular expression" with "regex split did not error with invalid regex literal"
+
+	set {_pattern} to "\b{_name}\b"
+	set {_split::*} to regex split "test" at {_pattern}
+	assert {_split::*} is not set with "regex split returned a value with invalid regex expression"
+
+	assert regex split "apple,banana;cherry" at "[,;]" is "apple", "banana" and "cherry" with "regex split did not split correctly with literal"
+	set {_pattern} to "[,;]"
+	assert regex split "apple,banana;cherry" at {_pattern} is "apple", "banana" and "cherry" with "regex split did not split correctly with expression"
diff --git a/src/test/skript/tests/regressions/7187-display entities conversion.sk b/src/test/skript/tests/regressions/7187-display entities conversion.sk
new file mode 100644
index 00000000000..3c5f27b23e7
--- /dev/null
+++ b/src/test/skript/tests/regressions/7187-display entities conversion.sk	
@@ -0,0 +1,7 @@
+test "display entities conversion":
+	parse:
+		spawn block display of minecraft:stone at test-location
+		set transformation translation of last spawned block display to vector(-0.5,-0.5,-0.5)
+		assert transformation translation of last spawned block display is vector(-0.5,-0.5,-0.5) with "failed to convert block display"
+		delete last spawned block display
+	assert parse logs is not set with "failed to convert block display"
diff --git a/src/test/skript/tests/regressions/7209-long overflow.sk b/src/test/skript/tests/regressions/7209-long overflow.sk
new file mode 100644
index 00000000000..bff56f0f57f
--- /dev/null
+++ b/src/test/skript/tests/regressions/7209-long overflow.sk	
@@ -0,0 +1,34 @@
+test "long overflow, addition":
+	set {_double-const} to 9000000000000000000.0
+	set {_long-const} to 9000000000000000000
+
+	loop 100 times:
+		set {_double} to {_double} + {_double-const}
+		set {_long} to {_long} + {_long-const}
+		assert {_double} is {_long} with "long value did not overflow to a double"
+
+	assert {_long} is 9000000000000000000 * 100.0 with "wrong final value"
+
+test "long underflow, subtraction":
+	set {_double-const} to 9000000000000000000.0
+	set {_long-const} to 9000000000000000000
+
+	loop 100 times:
+		set {_double} to {_double} - {_double-const}
+		set {_long} to {_long} - {_long-const}
+		assert {_double} is {_long} with "long value did not overflow to a double"
+
+	assert {_long} is 9000000000000000000 * -100.0 with "wrong final value"
+
+test "long overflow, multiplication":
+	set {_double} to 10.0
+	set {_long} to 10
+
+	loop 100 times:
+		set {_double} to {_double} * 10
+		set {_long} to {_long} * 10
+		assert {_double} is {_long} with "long value did not overflow to a double"
+
+	# the 6 is due to floating point error
+	assert {_long} is 100000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000 with "wrong final value"
+
diff --git a/src/test/skript/tests/regressions/pull-7120-changes overwriting indices.sk b/src/test/skript/tests/regressions/pull-7120-changes overwriting indices.sk
new file mode 100644
index 00000000000..47b02990e7a
--- /dev/null
+++ b/src/test/skript/tests/regressions/pull-7120-changes overwriting indices.sk	
@@ -0,0 +1,31 @@
+test "EffEnchant overwriting var indices":
+	set {_test::1} to diamond sword
+	set {_test::a} to gold sword
+	set {_test::hello world} to block at spawn of world "world"
+	enchant {_test::*} with sharpness 1
+	assert {_test::*} is diamond sword of sharpness 1, gold sword of sharpness 1, and block at spawn of world "world" with "failed to enchant items"
+	assert indices of {_test::*} is "1", "a", and "hello world" with "enchanting modified indices"
+
+test "EffReplace overwriting var indices":
+	set {_test::1} to "abc"
+	set {_test::a} to "cde"
+	set {_test::hello world} to block at spawn of world "world"
+	replace all "c" in {_test::*} with "z"
+	assert {_test::*} is "abz", "zde", and block at spawn of world "world" with "failed to replace strings"
+	assert indices of {_test::*} is "1", "a", and "hello world" with "replacing modified indices"
+
+test "ExprVectorLength overwriting var indices":
+	set {_test::1} to vector(0,3,0)
+	set {_test::a} to vector(0,0,4)
+	set {_test::hello world} to "abc"
+	set vector length of {_test::*} to 1
+	assert {_test::*} is vector(0,1,0), vector(0,0,1), and "abc" with "failed to change vector length"
+	assert indices of {_test::*} is "1", "a", and "hello world" with "changing vector length modified indices"
+
+test "ExprVectorXYZ overwriting var indices":
+	set {_test::1} to vector(0,3,0)
+	set {_test::a} to vector(0,0,4)
+	set {_test::hello world} to "abc"
+	set x component of {_test::*} to 1
+	assert {_test::*} is vector(1,3,0), vector(1,0,4), and "abc" with "failed to change vector x"
+	assert indices of {_test::*} is "1", "a", and "hello world" with "changing vector x modified indices"
diff --git a/src/test/skript/tests/syntaxes/effects/EffContinue.sk b/src/test/skript/tests/syntaxes/effects/EffContinue.sk
index b63bc3c8603..366dd051522 100644
--- a/src/test/skript/tests/syntaxes/effects/EffContinue.sk
+++ b/src/test/skript/tests/syntaxes/effects/EffContinue.sk
@@ -19,3 +19,10 @@ test "continue effect":
 			assert loop-value-2 is not 15 with "leveled continue failed #2"
 			continue 1st loop if loop-value-1 is 10
 		assert loop-value is not 10 with "leveled continue failed #3"
+
+	set {_ran} to false
+	loop 10 times:
+		loop 10 times:
+			continue
+		set {_ran} to true
+	assert {_ran} is true with "continue in nested loop continued outermost loop"
diff --git a/src/test/skript/tests/syntaxes/expressions/ExprARGB.sk b/src/test/skript/tests/syntaxes/expressions/ExprARGB.sk
new file mode 100644
index 00000000000..854fddf55ee
--- /dev/null
+++ b/src/test/skript/tests/syntaxes/expressions/ExprARGB.sk
@@ -0,0 +1,20 @@
+test "argb":
+
+	set {_colour} to rgb(0, 0, 0, 0)
+	assert {_colour}'s red value is 0 with "failed to get red"
+	assert {_colour}'s green value is 0 with "failed to get green"
+	assert blue value of {_colour} is 0 with "failed to get blue"
+	assert alpha value of {_colour} is 0 with "failed to get alpha"
+
+	set {_colour} to rgb(9, 102, 55, 10)
+	assert {_colour}'s red value is 9 with "failed to get red"
+	assert {_colour}'s green value is 102 with "failed to get green"
+	assert blue value of {_colour} is 55 with "failed to get blue"
+	assert alpha value of {_colour} is 10 with "failed to get alpha"
+
+	set {_colour} to red
+	assert {_colour}'s red value is 176 with "failed to get red"
+	assert {_colour}'s green value is 46 with "failed to get green"
+	assert blue value of {_colour} is 38 with "failed to get blue"
+	assert alpha value of {_colour} is 255 with "failed to get alpha"
+
diff --git a/src/test/skript/tests/syntaxes/expressions/ExprBlocks.sk b/src/test/skript/tests/syntaxes/expressions/ExprBlocks.sk
new file mode 100644
index 00000000000..0b954dc9a0b
--- /dev/null
+++ b/src/test/skript/tests/syntaxes/expressions/ExprBlocks.sk
@@ -0,0 +1,18 @@
+test "blocks void":
+	set {_loc} to location(0.5, 320.5, 0.5)
+	set {_blocks::*} to blocks between {_loc} and ({_loc} ~ vector(10,0,0))
+	assert size of {_blocks::*} is 11 with "Blocks between loc and (loc~vector(10,0,0)) is not 11"
+	assert blocks at {_blocks::*} is void air with "Blocks can be set in the void?"
+	set blocks at {_blocks::*} to stone
+	assert blocks at {_blocks::*} is void air with "Blocks can be set in the void?"
+
+test "blocks vector direction":
+	set {_loc} to location(0.5, 20.5, 0.5)
+	set {_blocks::*} to blocks vector(1,0,0) {_loc}
+	assert size of {_blocks::*} is 100 with "Blocks vector(1,0,0) loc is not 100"
+	set blocks at {_blocks::*} to stone
+	assert blocks at {_blocks::*} is stone with "1 or more blocks were not set to stone"
+	set blocks at {_blocks::*} to air
+	assert blocks at {_blocks::*} is air with "1 or more blocks were not set to air"
+	loop {_blocks::*}:
+		set block at loop-value to loop-value
diff --git a/src/test/skript/tests/syntaxes/expressions/ExprMaxStack.sk b/src/test/skript/tests/syntaxes/expressions/ExprMaxStack.sk
index 73694e0d5c2..1ec4235a2f9 100644
--- a/src/test/skript/tests/syntaxes/expressions/ExprMaxStack.sk
+++ b/src/test/skript/tests/syntaxes/expressions/ExprMaxStack.sk
@@ -1,4 +1,64 @@
-test "max stack":
+test "max stack - itemtype":
 	assert max stack size of diamond sword is 1 with "diamond sword max stack size failed"
 	assert max stack size of bucket is 16 with "bucket max stack size failed"
 	assert max stack size of dirt is 64 with "dirt max stack size failed"
+
+	# edge case
+	assert max stack size of {_null} is not set with "max stack size of non itemtype expected to fail ##1"
+	assert max stack size of {_null} is 0 to fail with "max stack size of non itemtype expected to fail ##2"
+	assert max stack size of diamond and diamond sword is 64 and 1 with "max stack size of itemtypes 'and' case failed"
+	assert max stack size of diamond or diamond sword is 64 or 1 with "max stack size of itemtypes 'or' case failed"
+	loop any log and any wool:
+		assert max stack size of loop-value is 64 with "max stack size of category itemtypes (%loop-value%) failed"
+
+test "max stack override - itemtype" when running minecraft "1.20.5":
+	set {_item} to diamond
+	set max stack size of {_item} to 32
+	assert max stack size of {_item} is 32 with "diamond should have max stack size of 32"
+	add 2 to max stack size of {_item}
+	assert max stack size of {_item} is 34 with "diamond should have max stack size of 34"
+	remove 4 from max stack size of {_item}
+	assert max stack size of {_item} is 30 with "diamond should have max stack size of 30"
+	reset max stack size of {_item}
+	assert max stack size of {_item} is 64 with "diamond should have max stack size of 64"
+
+	set {_item} to bucket
+	set max stack size of {_item} to 24
+	assert max stack size of {_item} is 24 with "bucket should have max stack size of 24"
+	add 2 to max stack size of {_item}
+	assert max stack size of {_item} is 26 with "bucket should have max stack size of 26"
+	remove 4 from max stack size of {_item}
+	assert max stack size of {_item} is 22 with "bucket should have max stack size of 22"
+	reset max stack size of {_item}
+	assert max stack size of {_item} is 16 with "bucket should have max stack size of 16"
+
+	set {_item} to diamond sword
+	set max stack size of {_item} to 16
+	assert max stack size of {_item} is 16 with "diamond sword should have max stack size of 16"
+	add 2 to max stack size of {_item}
+	assert max stack size of {_item} is 18 with "diamond sword should have max stack size of 18"
+	remove 4 from max stack size of {_item}
+	assert max stack size of {_item} is 14 with "diamond sword should have max stack size of 14"
+	reset max stack size of {_item}
+	assert max stack size of {_item} is 1 with "diamond sword should have max stack size of 1"
+
+	# edge case
+	loop any log and any wool:
+		set {_edge} to loop-value
+		set max stack size of {_edge} to 1
+		assert max stack size of {_edge} is 1 with "max stack size override of category itemtypes (%{_edge}%) failed"
+
+test "max stack override - inventory":
+	set {_default} to 99 # 1.20.5 and newer
+	if running below minecraft "1.20.5":
+		set {_default} to 64
+	set {_inv} to a new chest inventory with 1 rows
+	assert max stack size of {_inv} is {_default} with "inventory should have max stack size of %{_default}%"
+	set max stack size of {_inv} to 32
+	assert max stack size of {_inv} is 32 with "inventory should have max stack size of 32"
+	add 2 to max stack size of {_inv}
+	assert max stack size of {_inv} is 34 with "inventory should have max stack size of 34"
+	remove 4 from max stack size of {_inv}
+	assert max stack size of {_inv} is 30 with "inventory should have max stack size of 30"
+	reset max stack size of {_inv}
+	assert max stack size of {_inv} is {_default} with "inventory should have factory max stack size of %{_default}%"