commit ac2255d24d7dd39ac91fa50d3a7aa71ce0a92188
Author: flashwave <me@flash.moe>
Date:   Tue Sep 13 15:13:11 2022 +0200

    Imported into new repository.

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..b6d2ecb
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,5 @@
+* text=auto
+*.sh text eol=lf
+*.php text eol=lf
+*.bat text eol=crlf
+VERSION text eol=lf
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e8a26c2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,9 @@
+[Tt]humbs.db
+[Dd]esktop.ini
+.DS_Store
+.vscode/
+.vs/
+.idea/
+docs/html/
+.phpdoc*
+.phpunit*
diff --git a/LICENCE b/LICENCE
new file mode 100644
index 0000000..691d03b
--- /dev/null
+++ b/LICENCE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2021-2022, flashwave <me@flash.moe>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d7a5162
--- /dev/null
+++ b/README.md
@@ -0,0 +1,39 @@
+# Index
+
+Index is a common library for my PHP projects.
+
+It provides a number of components that I would otherwise copy between projects (and thus become out-of-sync) as well as a number of quality of life things on top of standard PHP stdlib functionality such as abstractions of arrays and strings as objects inspired by .NET's standard library.
+
+
+## Requirements and Dependencies
+
+Index currently targets **PHP 8.1**. (also list extensions!!!!!!!!!)
+
+### `Index\Data\MariaDB`
+
+Requires the `mysqli` extension. `mysqlnd` is recommended as the underlying driver, but `libmysql` should work without a hitch. This driver also works for MySQL as the dependencies would suggest, but you should consider using MariaDB instead of possible.
+
+### `Index\Data\SQLite`
+
+Requires the `sqlite3` extension.
+
+
+## Versioning
+
+Index versioning will mostly follow the [Semantic Versioning specification v2.0.0](https://semver.org/spec/v2.0.0.html), counting dropped support for a minor PHP version (e.g. 7.1 -> 7.2 or 7.4 -> 8.0) as a reason to increment the major version.
+Previous major versions may be supported for a time with backports depending on what projects of mine still target older versions of PHP.
+
+The version is stored in the root of the repository in a file called `VERSION` and can be read out within Index using `Index\Environment::getIndexVersion()`.
+
+
+## Contribution
+
+By submitting code for inclusion in the main Index source tree you agree to transfer ownership of the code to the project owner.
+The contributor will still be attributed for the contributed code, unless they ask for this attribution to be removed.
+This is to avoid intellectual property rights traps and drama that could lead to blackmail situations.
+If you do not agree with these terms, you are free to fork off.
+
+
+## Licencing
+
+Index is available under the BSD 2-Clause License, a full version of which is enclosed in the LICENCE file.
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..8d8ffca
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,37 @@
+# TODO
+
+## High Prio
+
+  - Create tests for everything testable.
+
+  - Draw out a plan for the templating backend.
+    - Will probably just construct using the HTML abstraction stuff, would make AJAX'ing page updates trivial also.
+    - Reinvestigate the semi-isolated PHP script template system I used in some other project, I forgot which.
+
+  - Determine structure for markup parsing abstraction.
+    - Writing a bbcode and markdown parser outside of Index, will implement a structure when done.
+
+  - Create HTML construction utilities.
+
+  - Create similarly address GD2/Imagick wrappers.
+
+  - Review CSRF code, Something about it has me constantly wondering if its too Complex.
+
+  - Figure out the SQL Query builder.
+    - Might make sense to just have a predicate builder and selector builder.
+
+  - Create a URL formatter.
+
+  - Add RSS/Atom feed construction utilities.
+
+  - Probably get rid of StringBuilder, PHP strings aren't entirely immutable so that whole issue doesn't even exist.
+    I have a number of possible fixes in my head for this. The primary reason for A/W/IString was to have a consistent API between
+     normal strings and mbstrings. I'm not sure yet but part of me wants to keep IString but move a lot of functionality into XString and make that the go-to. WString could remain, maybe in a reduced form? Having the encoding of the string associated with it is very convenient.
+
+## Low Prio
+
+  - Get guides working on phpdoc.
+
+  - Create phpdoc template.
+
+  - Review all constructors and see which one should be marked @internal.
diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000..f8dfde8
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+0.2202.281831
diff --git a/bench/_init.php b/bench/_init.php
new file mode 100644
index 0000000..630940d
--- /dev/null
+++ b/bench/_init.php
@@ -0,0 +1,17 @@
+<?php
+require_once __DIR__ . '/../index.php';
+
+function bench(string $name, int $times, callable $body): void {
+    printf('Running "%s" %d times%s', $name, $times, PHP_EOL);
+
+    $sw = \Index\Performance\Stopwatch::startNew();
+
+    while(--$times > 0)
+        $body();
+
+    $sw->stop();
+
+    printf('Took: %Fms %s', $sw->getElapsedTime(), PHP_EOL);
+
+    echo PHP_EOL;
+}
diff --git a/bench/example.php b/bench/example.php
new file mode 100644
index 0000000..360d84e
--- /dev/null
+++ b/bench/example.php
@@ -0,0 +1,7 @@
+<?php
+require_once __DIR__ . '/_init.php';
+
+bench('Example name', 100000, function() {
+    // run something here
+    $i = 1 + 1;
+});
diff --git a/docs/index.rst b/docs/index.rst
new file mode 100644
index 0000000..948743f
--- /dev/null
+++ b/docs/index.rst
@@ -0,0 +1,11 @@
+.. meta::
+    :layout: landingpage
+    :tada: true
+
+Index Documentation
+===================
+
+No Markdown!
+------------
+
+test RST file because phpdoc doesn't into markdown
diff --git a/index.php b/index.php
new file mode 100644
index 0000000..fc3864d
--- /dev/null
+++ b/index.php
@@ -0,0 +1,24 @@
+<?php
+// index.php
+// Created: 2021-04-26
+// Updated: 2021-05-04
+
+namespace Index;
+
+define('NDX_ROOT', __DIR__);
+define('NDX_DIR_SRC', NDX_ROOT . DIRECTORY_SEPARATOR . 'src');
+
+require_once NDX_DIR_SRC . DIRECTORY_SEPARATOR . 'Autoloader.php';
+
+Autoloader::addNamespace(__NAMESPACE__, NDX_DIR_SRC);
+Autoloader::register();
+
+// currently phpstan sucks and relies on error suppression, luckily it leaves a constant!
+if(!defined('__PHPSTAN_RUNNING__')) {
+    // defining this WILL cause issues, never do it unless you HAVE to
+    if(!defined('NDX_LEAVE_ERRORS'))
+        Exceptions::convertErrors();
+
+    if(!defined('NDX_LEAVE_EXCEPTIONS'))
+        Exceptions::handleExceptions();
+}
diff --git a/phpdoc.xml b/phpdoc.xml
new file mode 100644
index 0000000..6607fcd
--- /dev/null
+++ b/phpdoc.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<phpdocumentor configVersion="3.0"
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xmlns="https://www.phpdoc.org"
+               xsi:noNamespaceSchemaLocation="data/xsd/phpdoc.xsd">
+    <title>Index Documentation</title>
+    <template name="default"/>
+    <paths>
+        <output>docs/html</output>
+    </paths>
+    <version number="0.1">
+        <folder>latest</folder>
+        <api format="php">
+            <output>api</output>
+            <visibility>public</visibility>
+            <default-package-name>Index</default-package-name>
+            <source dsn=".">
+                <path>src</path>
+            </source>
+            <extensions>
+                <extension>php</extension>
+            </extensions>
+            <ignore hidden="true" symlinks="true">
+                <path>tests/**/*</path>
+            </ignore>
+            <ignore-tags>
+                <ignore-tag>template</ignore-tag>
+                <ignore-tag>template-extends</ignore-tag>
+                <ignore-tag>template-implements</ignore-tag>
+                <ignore-tag>extends</ignore-tag>
+                <ignore-tag>implements</ignore-tag>
+            </ignore-tags>
+        </api>
+        <guide format="rst">
+            <source dsn=".">
+                <path>docs</path>
+            </source>
+            <output>guide</output>
+        </guide>
+    </version>
+</phpdocumentor>
diff --git a/phpstan.neon b/phpstan.neon
new file mode 100644
index 0000000..55a7aed
--- /dev/null
+++ b/phpstan.neon
@@ -0,0 +1,6 @@
+parameters:
+  level: 5 # Raise this eventually
+  paths:
+    - src
+  bootstrapFiles:
+    - index.php
diff --git a/phpunit.xml b/phpunit.xml
new file mode 100644
index 0000000..50a04ed
--- /dev/null
+++ b/phpunit.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.5/phpunit.xsd"
+         bootstrap="index.php"
+         colors="true"
+         cacheResultFile=".phpunit.cache/test-results"
+         executionOrder="depends,defects"
+         forceCoversAnnotation="true"
+         beStrictAboutCoversAnnotation="true"
+         beStrictAboutOutputDuringTests="true"
+         beStrictAboutTodoAnnotatedTests="true"
+         failOnRisky="true"
+         failOnWarning="true"
+         verbose="true">
+    <testsuites>
+        <testsuite name="default">
+            <directory suffix="Test.php">tests</directory>
+        </testsuite>
+    </testsuites>
+
+    <coverage cacheDirectory=".phpunit.cache/code-coverage"
+              processUncoveredFiles="true">
+        <include>
+            <directory suffix=".php">src</directory>
+        </include>
+    </coverage>
+</phpunit>
diff --git a/src/AString.php b/src/AString.php
new file mode 100644
index 0000000..1b83c4d
--- /dev/null
+++ b/src/AString.php
@@ -0,0 +1,274 @@
+<?php
+// AString.php
+// Created: 2021-04-26
+// Updated: 2022-02-27
+
+namespace Index;
+
+use Traversable;
+use InvalidArgumentException;
+
+/**
+ * Provides an immutable ASCII string with arrow methods.
+ *
+ * Normal PHP strings should be used for buffers/byte arrays.
+ */
+final class AString implements IString {
+    use XStringTrait;
+
+    private string $value;
+
+    /**
+     * Create an AString instance.
+     *
+     * @param string $value PHP string to inherit.
+     * @return AString New instance of AString.
+     */
+    public function __construct(string $value) {
+        $this->value = $value;
+    }
+
+    public function getLength(): int {
+        return strlen($this->value);
+    }
+
+    public function isEmpty(): bool {
+        return $this->value === '';
+    }
+
+    public function __toString(): string {
+        return $this->value;
+    }
+
+    /**
+     * Checks if an offset exists in the string.
+     *
+     * You should call isset($string[$offset]) instead of $string->offsetExists($offset).
+     *
+     * @see https://www.php.net/manual/en/arrayaccess.offsetexists.php
+     * @param int $offset Character offset.
+     * @return bool true if it exists, false if not.
+     */
+    public function offsetExists(mixed $offset): bool {
+        return isset($this->value[$offset]);
+    }
+
+    /**
+     * Gets an offset from the string.
+     *
+     * You should do $string[$offset] instead of $string->offsetGet($offset).
+     *
+     * @see https://www.php.net/manual/en/arrayaccess.offsetget.php
+     * @param int $offset Character offset.
+     * @return string Character at that offset.
+     */
+    public function offsetGet(mixed $offset): mixed {
+        return $this->value[$offset];
+    }
+
+    /**
+     * Gets an iterator object for this string.
+     *
+     * @return StringIterator An iterator for this string.
+     */
+    public function getIterator(): Traversable {
+        return new StringIterator($this);
+    }
+
+    /**
+     * Returns the data which should be serialized as json.
+     *
+     * @see https://www.php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return mixed Data to be passed to json_encode.
+     */
+    public function jsonSerialize(): mixed {
+        return $this->value;
+    }
+
+    public function bencodeSerialise(): mixed {
+        return $this->value;
+    }
+
+    /**
+     * Gets a serialized representation of this object.
+     *
+     * @return array Serialized data.
+     */
+    public function __serialize(): array {
+        return [$this->value];
+    }
+
+    /**
+     * Reconstructs an object from a serialized string.
+     *
+     * @param array $serialized Serialized data.
+     */
+    public function __unserialize(array $serialized): void {
+        $this->value = $serialized[0];
+    }
+
+    /**
+     * Checks whether this string is identical to another.
+     *
+     * @param mixed $other An instance of AString or a PHP string.
+     * @return bool true if the strings have the same value, false if not.
+     */
+    public function equals(mixed $other): bool {
+        return $this->compare($other) === 0;
+    }
+
+    /**
+     * Compares whether this string is identical to another.
+     *
+     * @param mixed $other An instance of IString or a PHP string.
+     */
+    public function compare(mixed $other): int {
+        return strcmp($this->value, (string)$other);
+    }
+
+    /**
+     * Creates a new identical AString instance.
+     *
+     * This method is somewhat pointless, given the immutable nature of this object,
+     *  but rather people calling this instead of calling ->substring(0);
+     *
+     * @return AString A new identical instance of AString.
+     */
+    public function clone(): mixed {
+        return new AString($this->value);
+    }
+
+    public function indexOf(IString|string $text, int $offset = 0): int {
+        $pos = strpos($this->value, (string)$text, $offset);
+        if($pos === false)
+            return -1;
+        return $pos;
+    }
+
+    public function contains(IString|string $text): bool {
+        return str_contains($this->value, (string)$text);
+    }
+
+    public function substring(int $offset, int|null $length = null): IString {
+        return new AString(substr($this->value, $offset, $length));
+    }
+
+    public function replace(IString|string $search, IString|string $replace): IString {
+        return new AString(str_replace((string)$search, (string)$replace, $this->value));
+    }
+
+    public function append(IString|string $string): IString {
+        return new AString($this->value . (string)$string);
+    }
+
+    public function prepend(IString|string $string): IString {
+        return new AString(((string)$string) . $this->value);
+    }
+
+    public function split(IString|string $separator, int $limit = PHP_INT_MAX): array {
+        $separator = (string)$separator;
+        if(empty($separator))
+            throw new InvalidArgumentException('$separator may not be empty.');
+        return XArray::select(
+            explode($separator, $this->value, $limit),
+            fn($str) => new AString($str)
+        );
+    }
+
+    public function chunk(int $chunkSize): array {
+        return XArray::select(
+            str_split($this->value, $chunkSize),
+            fn($str) => new AString($str)
+        );
+    }
+
+    public function trim(IString|string $characters = IString::TRIM_CHARS): IString {
+        return new AString(trim($this->value, (string)$characters));
+    }
+
+    public function trimStart(IString|string $characters = IString::TRIM_CHARS): IString {
+        return new AString(ltrim($this->value, (string)$characters));
+    }
+
+    public function trimEnd(IString|string $characters = IString::TRIM_CHARS): IString {
+        return new AString(rtrim($this->value, (string)$characters));
+    }
+
+    public function toLower(): IString {
+        return new AString(strtolower($this->value));
+    }
+
+    public function toUpper(): IString {
+        return new AString(strtoupper($this->value));
+    }
+
+    public function reverse(): IString {
+        return new AString(strrev($this->value));
+    }
+
+    public function startsWith(IString|string $text): bool {
+        return str_starts_with($this->value, (string)$text);
+    }
+
+    public function endsWith(IString|string $text): bool {
+        return str_ends_with($this->value, (string)$text);
+    }
+
+    /**
+     * Casts this AString to a WString.
+     *
+     * @param ?string $encoding Intended encoding, null for the Index-level default.
+     * @param bool $convert true to convert the string to the target encoding, false to leave the bytes as-is.
+     * @return WString A WString of the provided encoding with the value of this AString.
+     */
+    public function toWString(?string $encoding = null, bool $convert = true): WString {
+        $value = $this->value;
+        $encoding ??= WString::getDefaultEncoding();
+        if($convert)
+            $value = mb_convert_encoding($value, $encoding, 'ascii');
+        return new WString($value, $encoding);
+    }
+
+    /**
+     * Joins an iterable object together with a separator to create a string.
+     *
+     * @param iterable $source Source object.
+     * @param IString|string $separator Separator to use as glue.
+     * @return AString Resulting string.
+     */
+    public static function join(iterable $source, IString|string $separator = ''): AString {
+        if(!is_array($source)) {
+            $parts = [];
+            foreach($source as $value)
+                $parts[] = $value;
+            $source = $parts;
+        }
+
+        return new AString(implode((string)$separator, $source));
+    }
+
+    /**
+     * Returns a reusable empty string instance.
+     *
+     * @return AString An empty string.
+     */
+    public static function empty(): AString {
+        static $empty = null;
+        $empty ??= new AString('');
+        return $empty;
+    }
+
+    /**
+     * Converts a value to AString.
+     *
+     * @param mixed $value Source value.
+     * @return AString An AString representing the given value.
+     */
+    public static function cast(mixed $value): AString {
+        if($value instanceof AString)
+            return $value;
+        if($value instanceof WString)
+            return $value->toAString();
+        return new AString(strval($value));
+    }
+}
diff --git a/src/Autoloader.php b/src/Autoloader.php
new file mode 100644
index 0000000..9530dd2
--- /dev/null
+++ b/src/Autoloader.php
@@ -0,0 +1,108 @@
+<?php
+// Autoloader.php
+// Created: 2021-05-04
+// Updated: 2021-05-12
+
+namespace Index;
+
+use InvalidArgumentException;
+
+/**
+ * Provides a simple PSR-4 style autoloader.
+ *
+ * Only basic types should be used in this class because this is the first file included
+ *  and obviously can't autoload things before it has been set up.
+ */
+final class Autoloader {
+    private const EXTENSION = '.php';
+
+    private static array $namespaces = [];
+
+    /**
+     * Registers this autoloader with PHP.
+     */
+    public static function register(): void {
+        spl_autoload_register([self::class, 'autoloader']);
+    }
+
+    /**
+     * Unregistered this autoloader with PHP.
+     */
+    public static function unregister(): void {
+        spl_autoload_unregister([self::class, 'autoloader']);
+    }
+
+    /**
+     * Cleans a PHP class path for file system look up.
+     *
+     * @param string $name A PHP class path.
+     * @return string A cleaned PHP class path.
+     */
+    public static function cleanName(string $name): string {
+        return trim($name, '\\');
+    }
+
+    /**
+     * Tries to find a class in the registered namespaces directories.
+     *
+     * Only supports the .php extension, others are silly and only add overhead.
+     *
+     * @param string $className Target class path.
+     */
+    public static function autoloader(string $className): void {
+        $classPath = explode('\\', self::cleanName($className));
+
+        for($i = 0; $i < count($classPath); ++$i) {
+            $rootSpace = implode('\\', array_slice($classPath, 0, $i + 1));
+
+            if(isset(self::$namespaces[$rootSpace])) {
+                $path = self::$namespaces[$rootSpace]
+                    . DIRECTORY_SEPARATOR
+                    . implode(DIRECTORY_SEPARATOR, array_slice($classPath, $i + 1))
+                    . self::EXTENSION;
+
+                if(is_file($path)) {
+                    require_once $path;
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * Registers a directory with a namespace. Projects making use of Index may use this.
+     *
+     * @param string $namespace Target namespace.
+     * @param string $directory Directory containing the classes of this namespace.
+     * @throws InvalidArgumentException if $namespace is an empty string.
+     * @throws InvalidArgumentException if $directory is a non-existent directory.
+     * @throws InvalidArgumentException if $namespace is already registered.
+     */
+    public static function addNamespace(string $namespace, string $directory): void {
+        if(empty($namespace))
+            throw new InvalidArgumentException('$namespace may not be an empty string.');
+        if(!is_dir($directory))
+            throw new InvalidArgumentException('$directory must point to an existing directory.');
+
+        $namespace = self::cleanName($namespace);
+        $directory = rtrim(realpath($directory), DIRECTORY_SEPARATOR);
+
+        if(isset(self::$namespaces[$namespace]))
+            throw new InvalidArgumentException("{$namespace} is already a registered namespace.");
+
+        self::$namespaces[$namespace] = $directory;
+    }
+
+    /**
+     * Removes a registered namespace.
+     *
+     * Attempts to unregister Index are ignored.
+     *
+     * @param string $namespace Namespace to be removed.
+     */
+    public static function removeNamespace(string $namespace): void {
+        $namespace = self::cleanName($namespace);
+        if($namespace !== 'Index')
+            unset(self::$namespaces[$namespace]);
+    }
+}
diff --git a/src/Collections/ArrayIterator.php b/src/Collections/ArrayIterator.php
new file mode 100644
index 0000000..dc15d58
--- /dev/null
+++ b/src/Collections/ArrayIterator.php
@@ -0,0 +1,37 @@
+<?php
+// ArrayIterator.php
+// Created: 2022-02-03
+// Updated: 2022-02-03
+
+namespace Index\Collections;
+
+use Iterator;
+
+class ArrayIterator implements Iterator {
+    private array $array;
+    private bool $wasValid = true;
+
+    public function __construct(array $array) {
+        $this->array = $array;
+    }
+
+    public function current(): mixed {
+        return current($this->array);
+    }
+
+    public function key(): mixed {
+        return key($this->array);
+    }
+
+    public function next(): void {
+        $this->wasValid = next($this->array) !== false;
+    }
+
+    public function rewind(): void {
+        $this->wasValid = reset($this->array) !== false;
+    }
+
+    public function valid(): bool {
+        return $this->wasValid;
+    }
+}
diff --git a/src/Collections/IArrayable.php b/src/Collections/IArrayable.php
new file mode 100644
index 0000000..1a9aa87
--- /dev/null
+++ b/src/Collections/IArrayable.php
@@ -0,0 +1,10 @@
+<?php
+// IArrayable.php
+// Created: 2022-02-03
+// Updated: 2022-02-03
+
+namespace Index\Collections;
+
+interface IArrayable {
+    function toArray(): array;
+}
diff --git a/src/Colour.php b/src/Colour.php
new file mode 100644
index 0000000..59644c7
--- /dev/null
+++ b/src/Colour.php
@@ -0,0 +1,17 @@
+<?php
+// Colour.php
+// Created: 2021-09-09
+// Updated: 2022-02-02
+
+namespace Index;
+
+abstract class Colour extends XObject {
+    abstract public function getRaw(): int;
+    abstract public function getRed(): int;
+    abstract public function getGreen(): int;
+    abstract public function getBlue(): int;
+
+    public function getAlpha(): float {
+        return 1.0;
+    }
+}
diff --git a/src/ColourARGB.php b/src/ColourARGB.php
new file mode 100644
index 0000000..6c0f46d
--- /dev/null
+++ b/src/ColourARGB.php
@@ -0,0 +1,26 @@
+<?php
+// ColourARGB.php
+// Created: 2021-09-08
+// Updated: 2022-01-03
+
+namespace Index;
+
+class ColourARGB extends ColourRGB {
+    public function getAlphaRaw(): int {
+        return ($this->raw >> 24) & 0xFF;
+    }
+
+    public function getAlpha(): float {
+        return ((float)$this->getAlphaRaw() / 0xFF);
+    }
+
+    public function toString(): IString {
+        return new AString(sprintf(
+            'rgba(%d,%d,%d,%F)',
+            $this->getRed(),
+            $this->getGreen(),
+            $this->getBlue(),
+            round($this->getAlpha(), 3)
+        ));
+    }
+}
diff --git a/src/ColourLegacy.php b/src/ColourLegacy.php
new file mode 100644
index 0000000..4015021
--- /dev/null
+++ b/src/ColourLegacy.php
@@ -0,0 +1,25 @@
+<?php
+// ColourLegacy.php
+// Created: 2021-09-09
+// Updated: 2022-01-20
+
+namespace Index;
+
+class ColourLegacy extends ColourRGB {
+    private const INHERIT = 0x40000000;
+
+    public function shouldInherit(): bool {
+        return ($this->raw & self::INHERIT) > 0;
+    }
+
+    public function toString(): IString {
+        if($this->shouldInherit()) {
+            static $inherit = null;
+            if($inherit === null)
+                $inherit = new AString('inherit');
+            return $inherit;
+        }
+
+        return parent::toString();
+    }
+}
diff --git a/src/ColourRGB.php b/src/ColourRGB.php
new file mode 100644
index 0000000..63bd87d
--- /dev/null
+++ b/src/ColourRGB.php
@@ -0,0 +1,34 @@
+<?php
+// ColourRGB.php
+// Created: 2021-09-09
+// Updated: 2021-09-09
+
+namespace Index;
+
+class ColourRGB extends Colour {
+    protected int $raw;
+
+    public function __construct(int $raw) {
+        $this->raw = $raw;
+    }
+
+    public function getRaw(): int {
+        return $this->raw;
+    }
+
+    public function getRed(): int {
+        return ($this->raw >> 16) & 0xFF;
+    }
+
+    public function getGreen(): int {
+        return ($this->raw >> 8) & 0xFF;
+    }
+
+    public function getBlue(): int {
+        return $this->raw & 0xFF;
+    }
+
+    public function toString(): IString {
+        return new AString('#' . str_pad(dechex($this->raw & 0xFFFFFF), 6, '0', STR_PAD_LEFT));
+    }
+}
diff --git a/src/Data/BeginTransactionFailedException.php b/src/Data/BeginTransactionFailedException.php
new file mode 100644
index 0000000..7caa967
--- /dev/null
+++ b/src/Data/BeginTransactionFailedException.php
@@ -0,0 +1,11 @@
+<?php
+// BeginTransactionFailedException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when transaction start fails.
+ */
+class BeginTransactionFailedException extends TransactionException {}
diff --git a/src/Data/CommitFailedException.php b/src/Data/CommitFailedException.php
new file mode 100644
index 0000000..60d44c6
--- /dev/null
+++ b/src/Data/CommitFailedException.php
@@ -0,0 +1,11 @@
+<?php
+// CommitFailedException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when a transaction commit fails.
+ */
+class CommitFailedException extends TransactionException {}
diff --git a/src/Data/ConnectionFailedException.php b/src/Data/ConnectionFailedException.php
new file mode 100644
index 0000000..eeccfc7
--- /dev/null
+++ b/src/Data/ConnectionFailedException.php
@@ -0,0 +1,11 @@
+<?php
+// ConnectionFailedException.php
+// Created: 2022-01-29
+// Updated: 2022-02-02
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when a connection fails.
+ */
+class ConnectionFailedException extends DataException {}
diff --git a/src/Data/DataException.php b/src/Data/DataException.php
new file mode 100644
index 0000000..017c0ac
--- /dev/null
+++ b/src/Data/DataException.php
@@ -0,0 +1,13 @@
+<?php
+// DataException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+use RuntimeException;
+
+/**
+ * Exception type of the Index\Data namespace.
+ */
+class DataException extends RuntimeException {}
diff --git a/src/Data/DbTools.php b/src/Data/DbTools.php
new file mode 100644
index 0000000..5b0e98a
--- /dev/null
+++ b/src/Data/DbTools.php
@@ -0,0 +1,101 @@
+<?php
+// DbTools.php
+// Created: 2021-05-02
+// Updated: 2022-02-28
+
+namespace Index\Data;
+
+use InvalidArgumentException;
+use Index\Type;
+
+/**
+ * Common database actions.
+ */
+final class DbTools {
+    private const DB_PROTOS = [
+        'null' => NullDb\NullDbBackend::class,
+        'mariadb' => MariaDB\MariaDBBackend::class,
+        'mysql' => MariaDB\MariaDBBackend::class,
+        'sqlite' => SQLite\SQLiteBackend::class,
+        'sqlite3' => SQLite\SQLiteBackend::class,
+    ];
+
+    public static function create(string $dsn): IDbConnection {
+        static $backends = [];
+
+        $uri = parse_url($dsn);
+        if($uri === false)
+            throw new InvalidArgumentException('$dsn is not a valid uri.');
+
+        $scheme = $uri['scheme'];
+
+        if(in_array($scheme, $backends))
+            $backend = $backends[$scheme];
+        else {
+            $backend = null;
+
+            if(array_key_exists($scheme, self::DB_PROTOS))
+                $name = self::DB_PROTOS[$scheme];
+            else
+                $name = str_replace('-', '\\', $scheme);
+
+            if(class_exists($name) && is_subclass_of($name, IDbBackend::class)) {
+                $backend = new $name;
+                $name = get_class($backend);
+            }
+
+            if($backend === null)
+                throw new DataException('No implementation is available for the specified scheme.');
+            if(!$backend->isAvailable())
+                throw new DataException('Requested database backend is not available, likely due to missing dependencies.');
+
+            $backends[$name] = $backend;
+        }
+
+        return $backend->createConnection(
+            $backend->parseDsn($uri)
+        );
+    }
+
+    /**
+     * Transaction wrapper.
+     *
+     * Takes a database connection with transaction support and a callable that may return a boolean based on the success of the actions.
+     * If the callable returns nothing, nothing will happen.
+     * If the callable returns true, commit will be called.
+     * If the callable returns false, rollback will be called.
+     *
+     * @param IDbTransactions $connection A database connection with transaction support.
+     * @param callable $callable A callable that handles the transaction, may return a bool.
+     */
+    public static function transaction(IDbTransactions $connection, callable $callable): void {
+        $connection->beginTransaction();
+        $result = $callable($connection) ?? null;
+        if(is_bool($result)) {
+            if($result)
+                $connection->commit();
+            else
+                $connection->rollback();
+        }
+    }
+
+    /**
+     * Detects the DbType of the passed argument. Should be used for DbType::AUTO.
+     *
+     * @param mixed $value A value of unknown type.
+     * @return int DbType of the value passed in the argument.
+     */
+    public static function detectType(mixed $value): int {
+        if(is_null($value))
+            return DbType::NULL;
+        if(is_float($value))
+            return DbType::FLOAT;
+        if(is_int($value))
+            return DbType::INTEGER;
+        // ┌ should probably also check for Stringable, length should also be taken into consideration
+        // ↓ though maybe with that it's better to assume that when an object is passed it'll always be Massive
+        if(is_string($value))
+            return DbType::STRING;
+        return DbType::BLOB;
+    }
+}
diff --git a/src/Data/DbType.php b/src/Data/DbType.php
new file mode 100644
index 0000000..ef02e28
--- /dev/null
+++ b/src/Data/DbType.php
@@ -0,0 +1,53 @@
+<?php
+// DbType.php
+// Created: 2021-05-02
+// Updated: 2021-05-04
+
+namespace Index\Data;
+
+/**
+ * Map of common database types.
+ */
+final class DbType {
+    /**
+     * Automatically detect the type. Should be used in combination with DbTools::detectType.
+     *
+     * @var int
+     */
+    public const AUTO = 0;
+
+    /**
+     * Represents a NULL value. If this type is specified, the value it was associated with should be overriden with NULL.
+     *
+     * @var int
+     */
+    public const NULL = 1;
+
+    /**
+     * An integer type.
+     *
+     * @var int
+     */
+    public const INTEGER = 2;
+
+    /**
+     * A double precision floating point.
+     *
+     * @var int
+     */
+    public const FLOAT = 3;
+
+    /**
+     * A textual string.
+     *
+     * @var int
+     */
+    public const STRING = 4;
+
+    /**
+     * Binary blob data.
+     *
+     * @var int
+     */
+    public const BLOB = 5;
+}
diff --git a/src/Data/IDbBackend.php b/src/Data/IDbBackend.php
new file mode 100644
index 0000000..559e7ae
--- /dev/null
+++ b/src/Data/IDbBackend.php
@@ -0,0 +1,35 @@
+<?php
+// IDbBackend.php
+// Created: 2021-04-30
+// Updated: 2022-02-28
+
+namespace Index\Data;
+
+/**
+ * Information about a database layer. Should not have any external dependencies.
+ */
+interface IDbBackend {
+    /**
+     * Checks whether the driver is available and a connection can be made.
+     *
+     * @return bool If true a connection can be made, if false a required extension is missing.
+     */
+    function isAvailable(): bool;
+
+    /**
+     * Creates a connection with the database described in the argument.
+     *
+     * @param IDbConnectionInfo $connectionInfo Object that describes the desired connection.
+     * @throws \InvalidArgumentException An invalid implementation of IDbConnectionInfo was provided.
+     * @return IDbConnection A connection described in the connection info.
+     */
+    function createConnection(IDbConnectionInfo $connectionInfo): IDbConnection;
+
+    /**
+     * Constructs a connection info instance from a dsn.
+     *
+     * @param string|array $dsn DSN with connection information.
+     * @return IDbConnectionInfo Connection info based on the dsn.
+     */
+    function parseDsn(string|array $dsn): IDbConnectionInfo;
+}
diff --git a/src/Data/IDbConnection.php b/src/Data/IDbConnection.php
new file mode 100644
index 0000000..b72e15f
--- /dev/null
+++ b/src/Data/IDbConnection.php
@@ -0,0 +1,49 @@
+<?php
+// IDbConnection.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\Data;
+
+use Index\ICloseable;
+
+/**
+ * Represents a connection to a database service.
+ */
+interface IDbConnection extends ICloseable {
+    /**
+     * Returns the ID of the last inserted row.
+     *
+     * @return int|string Last inserted ID.
+     */
+    function getLastInsertId(): int|string;
+
+    /**
+     * Prepares a statement for execution and returns a database statement instance.
+     *
+     * The statement should use question mark (?) parameters.
+     *
+     * @param string $query SQL query to prepare.
+     * @return IDbStatement An instance of an implementation of IDbStatement.
+     */
+    function prepare(string $query): IDbStatement;
+
+    /**
+     * Executes a statement and returns a database result instance.
+     *
+     * @param string $query SQL query to execute.
+     * @return IDbResult An instance of an implementation of IDbResult
+     */
+    function query(string $query): IDbResult;
+
+    /**
+     * Executes a statement and returns how many rows are affected.
+     *
+     * Does not request results back from the database and thus should have better
+     *  performance if the consumer doesn't care about them.
+     *
+     * @param string $query SQL query to execute.
+     * @return int|string Number of rows affected by the query.
+     */
+    function execute(string $query): int|string;
+}
diff --git a/src/Data/IDbConnectionInfo.php b/src/Data/IDbConnectionInfo.php
new file mode 100644
index 0000000..29b3b15
--- /dev/null
+++ b/src/Data/IDbConnectionInfo.php
@@ -0,0 +1,13 @@
+<?php
+// IDbConnectionInfo.php
+// Created: 2021-04-30
+// Updated: 2022-02-16
+
+namespace Index\Data;
+
+/**
+ * Base type for database connection info.
+ *
+ * Any database backend should have its own implementation of this, there are no baseline requirements.
+ */
+interface IDbConnectionInfo {}
diff --git a/src/Data/IDbResult.php b/src/Data/IDbResult.php
new file mode 100644
index 0000000..4c49bc4
--- /dev/null
+++ b/src/Data/IDbResult.php
@@ -0,0 +1,88 @@
+<?php
+// IDbResult.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data;
+
+use Index\AString;
+use Index\ICloseable;
+use Index\WString;
+use Index\IO\Stream;
+
+/**
+ * Represents a database result set.
+ */
+interface IDbResult extends ICloseable {
+    /**
+     * Fetches the next result set.
+     *
+     * @return bool true if the result set was loaded, false if no more results are available.
+     */
+    function next(): bool;
+
+    /**
+     * Checks if a given index has a NULL value.
+     *
+     * @param int|string $index Target index.
+     * @return bool true if the value is null, false if not.
+     */
+    function isNull(int|string $index): bool;
+
+    /**
+     * Gets the value from the target index without any additional casting.
+     *
+     * @param int|string $index Target index.
+     * @return mixed Target value.
+     */
+    function getValue(int|string $index): mixed;
+
+    /**
+     * Gets the value from the target index cast as a native string.
+     *
+     * @param int|string $index Target index.
+     * @return string Returns a string of the value.
+     */
+    function getString(int|string $index): string;
+
+    /**
+     * Gets the value from the target index cast as an ASCII string.
+     *
+     * @param int|string $index Target index.
+     * @return AString Returns an AString of the value.
+     */
+    function getAString(int|string $index): AString;
+
+    /**
+     * Gets the value from the target index cast as a multi-byte string.
+     *
+     * @param int|string $index Target index.
+     * @param string $encoding Encoding of the string.
+     * @return WString Returns an WString of the value.
+     */
+    function getWString(int|string $index, string $encoding): WString;
+
+    /**
+     * Gets the value from the target index cast as an integer.
+     *
+     * @param int|string $index Target index.
+     * @return int Returns the value cast to an integer.
+     */
+    function getInteger(int|string $index): int;
+
+    /**
+     * Gets the value from the target index cast as a floating point number.
+     *
+     * @param int|string $index Target index.
+     * @return float Returns the value cast to a floating point number.
+     */
+    function getFloat(int|string $index): float;
+
+    /**
+     * Gets the value from the target index as a Stream.
+     *
+     * @param int|string $index Target index.
+     * @return ?Stream A Stream if data is available, null if not.
+     */
+    function getStream(int|string $index): ?Stream;
+}
diff --git a/src/Data/IDbStatement.php b/src/Data/IDbStatement.php
new file mode 100644
index 0000000..a536ab6
--- /dev/null
+++ b/src/Data/IDbStatement.php
@@ -0,0 +1,53 @@
+<?php
+// IDbStatement.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data;
+
+use Index\ICloseable;
+
+/**
+ * Represents a prepared database statement.
+ */
+interface IDbStatement extends ICloseable {
+    /**
+     * Returns how many parameters there are.
+     *
+     * @return int Number of parameters.
+     */
+    function getParameterCount(): int;
+
+    /**
+     * Assigns a value to a parameter.
+     *
+     * @param int $ordinal Index of the target parameter.
+     * @param mixed $value Value to assign to the parameter.
+     * @param int $type Type of the value, if left to DbType::AUTO DbTools::detectType will be used on $value.
+     */
+    function addParameter(int $ordinal, mixed $value, int $type = DbType::AUTO): void;
+
+    /**
+     * Gets the result after execution.
+     *
+     * @return IDbResult Instance of an implementation of IDbResult.
+     */
+    function getResult(): IDbResult;
+
+    /**
+     * Returns the ID of the last inserted row.
+     *
+     * @return int|string Last inserted ID.
+     */
+    function getLastInsertId(): int|string;
+
+    /**
+     * Executes this statement.
+     */
+    function execute(): void;
+
+    /**
+     * Resets this statement for reuse.
+     */
+    function reset(): void;
+}
diff --git a/src/Data/IDbTransactions.php b/src/Data/IDbTransactions.php
new file mode 100644
index 0000000..9f114ed
--- /dev/null
+++ b/src/Data/IDbTransactions.php
@@ -0,0 +1,57 @@
+<?php
+// IDbTransactions.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data;
+
+/**
+ * Indicates supports for transactions in a database connection.
+ */
+interface IDbTransactions extends IDbConnection {
+    /**
+     * Sets whether changes should be applied immediately or whether commit should always be called first.
+     *
+     * @param bool $state true if things should automatically be committed, false if not.
+     */
+    function setAutoCommit(bool $state): void;
+
+    /**
+     * Enters a transaction.
+     *
+     * @throws BeginTransactionFailedException If the creation of the transaction failed.
+     */
+    function beginTransaction(): void;
+
+    /**
+     * Commits the actions done during a transaction and ends the transaction.
+     * A new transaction will be started if auto-commit is disabled.
+     *
+     * @throws CommitFailedException If the commit failed.
+     */
+    function commit(): void;
+
+    /**
+     * Rolls back to the state before a transaction start or to a specified save point.
+     *
+     * @param ?string $name Name of the save point, null for the entire transaction.
+     * @throws RollbackFailedException If rollback failed.
+     */
+    function rollback(?string $name = null): void;
+
+    /**
+     * Creates a save point in the transaction that can be rolled back to.
+     *
+     * @param string $name Name for the save point.
+     * @throws SavePointFailedException If save point creation failed.
+     */
+    function savePoint(string $name): void;
+
+    /**
+     * Releases a save point.
+     *
+     * @param string $name Name of the save point.
+     * @throws ReleaseSavePointFailedException If releasing the save point failed.
+     */
+    function releaseSavePoint(string $name): void;
+}
diff --git a/src/Data/MariaDB/MariaDBBackend.php b/src/Data/MariaDB/MariaDBBackend.php
new file mode 100644
index 0000000..0c097cb
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBBackend.php
@@ -0,0 +1,122 @@
+<?php
+// MariaDBBackend.php
+// Created: 2021-04-30
+// Updated: 2022-02-28
+
+namespace Index\Data\MariaDB;
+
+use InvalidArgumentException;
+use Index\Version;
+use Index\Data\IDbBackend;
+use Index\Data\IDbConnection;
+use Index\Data\IDbConnectionInfo;
+use Index\Net\EndPoint;
+use Index\Net\UnixEndPoint;
+
+/**
+ * Information about the MariaDB/MySQL database layer.
+ */
+class MariaDBBackend implements IDbBackend {
+    public function isAvailable(): bool {
+        return extension_loaded('mysqli');
+    }
+
+    /**
+     * @internal
+     */
+    public static function intToVersion(int $version): Version {
+        $sub = $version % 100;
+        $version = floor($version / 100);
+        $minor = $version % 100;
+        $version = floor($version / 100);
+        $major = $version % 100;
+        return new Version($major, $minor, $sub);
+    }
+
+    /**
+     * Gets the version of the underlying client library.
+     *
+     * @return Version Version of the client library.
+     */
+    public function getClientVersion(): Version {
+        return self::intToVersion(mysqli_get_client_version());
+    }
+
+    /**
+     * Creates a connection with a MariaDB or MySQL server.
+     *
+     * @param MariaDBConnectionInfo $connectionInfo Object that describes the desired connection.
+     * @return MariaDBConnection A connection with a MariaDB or MySQL server.
+     */
+    public function createConnection(IDbConnectionInfo $connectionInfo): IDbConnection {
+        if(!($connectionInfo instanceof MariaDBConnectionInfo))
+            throw new InvalidArgumentException('$connectionInfo must by of type MariaDBConnectionInfo');
+
+        return new MariaDBConnection($connectionInfo);
+    }
+
+    /**
+     * @return MariaDBConnectionInfo MariaDB connection info.
+     */
+    public function parseDsn(string|array $dsn): IDbConnectionInfo {
+        if(is_string($dsn)) {
+            $dsn = parse_url($dsn);
+            if($dsn === false)
+                throw new InvalidArgumentException('$dsn is not a valid uri.');
+        }
+
+        if(!isset($dsn['host']))
+            throw new InvalidArgumentException('Host is missing from DSN.');
+        if(!isset($dsn['path']))
+            throw new InvalidArgumentException('Path is missing from DSN.');
+
+        $host = $dsn['host'];
+        $needsUnix = $host === ':unix';
+
+        if(!$needsUnix && isset($dsn['port']))
+            $host .= ':' . $dsn['port'];
+
+        $user = $dsn['user'] ?? '';
+        $pass = $dsn['pass'] ?? '';
+        $endPoint = $needsUnix ? null : EndPoint::parse($host);
+        $dbName = str_replace('/', '_', trim($dsn['path'], '/')); // cute for table prefixes i think
+
+        if(!isset($dsn['query'])) {
+            $charSet = null;
+            $initCommand = null;
+            $keyPath = null;
+            $certPath = null;
+            $certAuthPath = null;
+            $trustedCertsPath = null;
+            $cipherAlgos = null;
+            $verifyCert = false;
+            $useCompression = false;
+        } else {
+            parse_str(str_replace('+', '%2B', $dsn['query']), $query);
+
+            $unixPath = $query['socket'] ?? null;
+            $charSet = $query['charset'] ?? null;
+            $initCommand = $query['init'] ?? null;
+            $keyPath = $query['enc_key'] ?? null;
+            $certPath = $query['enc_cert'] ?? null;
+            $certAuthPath = $query['enc_authority'] ?? null;
+            $trustedCertsPath = $query['enc_trusted_certs'] ?? null;
+            $cipherAlgos = $query['enc_ciphers'] ?? null;
+            $verifyCert = !empty($query['enc_verify']);
+            $useCompression = !empty($query['compress']);
+        }
+
+        if($needsUnix) {
+            if($unixPath === null)
+                throw new InvalidArgumentException('Unix socket path is missing from DSN.');
+            $endPoint = new UnixEndPoint($unixPath);
+        }
+
+        return new MariaDBConnectionInfo(
+            $endPoint, $user, $pass, $dbName,
+            $charSet, $initCommand, $keyPath, $certPath,
+            $certAuthPath, $trustedCertsPath, $cipherAlgos,
+            $verifyCert, $useCompression
+        );
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBCharacterSetInfo.php b/src/Data/MariaDB/MariaDBCharacterSetInfo.php
new file mode 100644
index 0000000..73709b3
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBCharacterSetInfo.php
@@ -0,0 +1,93 @@
+<?php
+// MariaDBCharacterSetInfo.php
+// Created: 2021-05-02
+// Updated: 2022-02-02
+
+namespace Index\Data\MariaDB;
+
+use stdClass;
+
+/**
+ * Contains information about the character set.
+ *
+ * @see https://www.php.net/manual/en/mysqli.get-charset
+ */
+class MariaDBCharacterSetInfo {
+    private stdClass $charSet;
+
+    /**
+     * Creates a new character set info instance.
+     *
+     * @param stdClass $charSet Anonymous object containing the information.
+     * @return MariaDBCharacterSetInfo Character set information class.
+     */
+    public function __construct(stdClass $charSet) {
+        $this->charSet = $charSet;
+    }
+
+    /**
+     * Returns the name of the current character set.
+     *
+     * @return string Character set name.
+     */
+    public function getCharacterSet(): string {
+        return $this->charSet->charset;
+    }
+
+    /**
+     * Returns the name of the default collation.
+     *
+     * @return string Default collation name.
+     */
+    public function getDefaultCollation(): string {
+        return $this->charSet->collation;
+    }
+
+    /**
+     * Returns the path to the directory the charcter was read from.
+     * May be empty for built-in character sets.
+     *
+     * @return string Source directory.
+     */
+    public function getDirectory(): string {
+        return $this->charSet->dir;
+    }
+
+    /**
+     * Returns the minimum character width in bytes for this character set.
+     *
+     * @return int Minimum character width in bytes.
+     */
+    public function getMinimumWidth(): int {
+        return $this->charSet->min_length;
+    }
+
+    /**
+     * Returns the maximum character width in bytes for this character set.
+     *
+     * @return int Maximum character width in bytes.
+     */
+    public function getMaximumWidth(): int {
+        return $this->charSet->max_length;
+    }
+
+    /**
+     * Returns the internal numeric identifier for this character set.
+     *
+     * @return int Character set identifier.
+     */
+    public function getId(): int {
+        return $this->charSet->number;
+    }
+
+    /**
+     * Returns the character set status.
+     *
+     * Whatever that means. Given the (?) in the official documentation, not even they know.
+     *
+     * @return int Character set status.
+     */
+    public function getState(): int {
+        return $this->charSet->state;
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBConnection.php b/src/Data/MariaDB/MariaDBConnection.php
new file mode 100644
index 0000000..15c25e2
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBConnection.php
@@ -0,0 +1,401 @@
+<?php
+// MariaDBConnection.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\Data\MariaDB;
+
+use mysqli;
+use mysqli_sql_exception;
+use InvalidArgumentException;
+use RuntimeException;
+use Index\AString;
+use Index\Version;
+use Index\Data\BeginTransactionFailedException;
+use Index\Data\DataException;
+use Index\Data\IDbConnection;
+use Index\Data\IDbTransactions;
+use Index\Data\CommitFailedException;
+use Index\Data\ConnectionFailedException;
+use Index\Data\ReleaseSavePointFailedException;
+use Index\Data\RollbackFailedException;
+use Index\Data\SavePointFailedException;
+use Index\Data\QueryExecuteException;
+
+/**
+ * Represents a connection with a MariaDB or MySQL database server.
+ */
+class MariaDBConnection implements IDbConnection, IDbTransactions {
+    /**
+     * Refresh grant tables.
+     *
+     * @var int
+     */
+    public const REFRESH_GRANT = MYSQLI_REFRESH_GRANT;
+
+    /**
+     * Flushes logs, like the FLUSH LOGS; statement.
+     *
+     * @var int
+     */
+    public const REFRESH_LOG = MYSQLI_REFRESH_LOG;
+
+    /**
+     * Refresh tables, like the FLUSH TABLES; statement.
+     *
+     * @var int
+     */
+    public const REFRESH_TABLES = MYSQLI_REFRESH_TABLES;
+
+    /**
+     * Refreshes the hosts cache, like the FLUSH HOSTS; statement.
+     *
+     * @var int
+     */
+    public const REFRESH_HOSTS = MYSQLI_REFRESH_HOSTS;
+
+    /**
+     * Refresh the status variables, like the FLUSH STATUS; statement.
+     *
+     * @var int
+     */
+    public const REFRESH_STATUS = MYSQLI_REFRESH_STATUS;
+
+    /**
+     * Flushes the thread cache.
+     *
+     * @var int
+     */
+    public const REFRESH_THREADS = MYSQLI_REFRESH_THREADS;
+
+    /**
+     * Resets information about the master server and restarts on slave replication servers,
+     *  like the RESET SLAVE; statement.
+     *
+     * @var int
+     */
+    public const REFRESH_SLAVE = MYSQLI_REFRESH_SLAVE;
+
+    /**
+     * Removes binary log files listed in the binary log index and truncates the index file
+     *  on master replication servers, like the RESET MASTER; statement.
+     */
+    public const REFRESH_MASTER = MYSQLI_REFRESH_MASTER;
+
+    private mysqli $connection;
+
+    /**
+     * Creates a new instance of MariaDBConnection.
+     *
+     * @param MariaDBConnectionInfo $connectionInfo Information about the connection.
+     * @return MariaDBConnection A new instance of MariaDBConnection.
+     */
+    public function __construct(MariaDBConnectionInfo $connectionInfo) {
+        mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);
+
+        // I'm not sure if calling "new mysqli" without arguments is equivalent to this
+        //  the documentation would suggest it's not and that it just pulls from the config
+        //  nothing suggests otherwise too.
+        // The output of mysqli_init is just an object anyway so we can safely use it instead
+        //  but continue to use it as an object.
+        $this->connection = mysqli_init();
+        $this->connection->options(MYSQLI_OPT_LOCAL_INFILE, 0);
+
+        if($connectionInfo->hasCharacterSet())
+            $this->connection->options(MYSQLI_SET_CHARSET_NAME, $connectionInfo->getCharacterSet());
+
+        if($connectionInfo->hasInitCommand())
+            $this->connection->options(MYSQLI_INIT_COMMAND, $connectionInfo->getInitCommand());
+
+        $flags = $connectionInfo->shouldUseCompression() ? MYSQLI_CLIENT_COMPRESS : 0;
+
+        if($connectionInfo->isSecure()) {
+            $flags |= MYSQLI_CLIENT_SSL;
+
+            if($connectionInfo->shouldVerifyCertificate())
+                $this->connection->options(MYSQLI_OPT_SSL_VERIFY_SERVER_CERT, 1);
+            else
+                $flags |= MYSQLI_CLIENT_SSL_DONT_VERIFY_SERVER_CERT;
+
+            $this->connection->ssl_set(
+                $connectionInfo->getKeyPath(),
+                $connectionInfo->getCertificatePath(),
+                $connectionInfo->getCertificateAuthorityPath(),
+                $connectionInfo->getTrustedCertificatesPath(),
+                $connectionInfo->getCipherAlgorithms()
+            );
+        }
+
+        try {
+            if($connectionInfo->isUnixSocket())
+                $this->connection->real_connect(
+                    '',
+                    $connectionInfo->getUserName(),
+                    $connectionInfo->getPassword(),
+                    $connectionInfo->getDatabaseName(),
+                    -1,
+                    $connectionInfo->getSocketPath(),
+                    $flags
+                );
+            else
+                $this->connection->real_connect(
+                    $connectionInfo->getHost(),
+                    $connectionInfo->getUserName(),
+                    $connectionInfo->getPassword(),
+                    $connectionInfo->getDatabaseName(),
+                    $connectionInfo->getPort(),
+                    '',
+                    $flags
+                );
+        } catch(mysqli_sql_exception $ex) {
+            throw new ConnectionFailedException($ex->getMessage(), $ex->getCode(), $ex);
+        }
+    }
+
+    /**
+     * Gets the number of rows affected by the last operation.
+     *
+     * @return int|string Number of rows affected by the last operation.
+     */
+    public function getAffectedRows(): int|string {
+        return $this->connection->affected_rows;
+    }
+
+    /**
+     * Gets the name of the currently active character set.
+     *
+     * @return string Name of the character set.
+     */
+    public function getCharacterSet(): string {
+        return $this->connection->character_set_name();
+    }
+
+    /**
+     * Switch to a different character set.
+     *
+     * @param string $charSet Name of the new character set.
+     * @throws InvalidArgumentException Switching to new character set failed.
+     */
+    public function setCharacterSet(string $charSet): void {
+        if(!$this->connection->set_charset($charSet))
+            throw new InvalidArgumentException('$charSet is not a supported character set.');
+    }
+
+    /**
+     * Returns info about the currently character set and collation.
+     *
+     * @return MariaDBCharacterSetInfo Information about the character set.
+     */
+    public function getCharacterSetInfo(): MariaDBCharacterSetInfo {
+        return new MariaDBCharacterSetInfo($this->connection->get_charset());
+    }
+
+    /**
+     * Switches the connection to a different user and default database.
+     *
+     * @param string $userName New user name.
+     * @param string $password New password.
+     * @param string|null $database New default database.
+     * @throws DataException If the user switch action failed.
+     */
+    public function switchUser(string $userName, string $password, string|null $database = null): void {
+        if(!$this->connection->change_user($userName, $password, $database === null ? null : $database))
+            throw new DataException($this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    /**
+     * Switches the default database for this connection.
+     *
+     * @param string $database New default database.
+     * @throws DataException If the database switch failed.
+     */
+    public function switchDatabase(string $database): void {
+        if(!$this->connection->select_db($database))
+            throw new DataException($this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    /**
+     * Gets the version of the server.
+     *
+     * @return Version Version of the server.
+     */
+    public function getServerVersion(): Version {
+        return MariaDBBackend::intToVersion($this->connection->server_version);
+    }
+
+    /**
+     * Gets the last error code.
+     *
+     * @return int Last error code.
+     */
+    public function getLastErrorCode(): int {
+        return $this->connection->errno;
+    }
+
+    /**
+     * Gets the last error string.
+     *
+     * @return string Last error string.
+     */
+    public function getLastErrorString(): string {
+        return $this->connection->error;
+    }
+
+    /**
+     * Gets the current SQL State of the connection.
+     *
+     * @return string Current SQL State.
+     */
+    public function getSQLState(): string {
+        return $this->connection->sqlstate;
+    }
+
+    /**
+     * Gets a list of errors from the last command.
+     *
+     * @return array List of last errors.
+     */
+    public function getLastErrors(): array {
+        return MariaDBWarning::fromLastErrors($this->connection->error_list);
+    }
+
+    /**
+     * Gets the number of columns for the last query.
+     *
+     * @return int
+     */
+    public function getLastFieldCount(): int {
+        return $this->connection->field_count;
+    }
+
+    /**
+     * Gets list of warnings.
+     *
+     * The result of SHOW WARNINGS;
+     *
+     * @return array List of warnings.
+     */
+    public function getWarnings(): array {
+        return MariaDBWarning::fromGetWarnings($this->connection->get_warnings());
+    }
+
+    /**
+     * Returns the number of warnings for the last query.
+     *
+     * @return int Amount of warnings.
+     */
+    public function getWarningCount(): int {
+        return $this->connection->warning_count;
+    }
+
+    public function getLastInsertId(): int|string {
+        return $this->connection->insert_id;
+    }
+
+    /**
+     * Sends a keep alive request to the server, or tries to reconnect if it has gone down.
+     *
+     * @return bool true if the keep alive was successful, false if the server is Gone.
+     */
+    public function ping(): bool {
+        return $this->connection->ping();
+    }
+
+    /**
+     * Runs various refresh operations, see the REFRESH_ constants for the flags.
+     *
+     * @param int $flags A bitset of REFRESH_ flags.
+     */
+    public function refresh(int $flags): void {
+        $this->connection->refresh($flags);
+    }
+
+    public function setAutoCommit(bool $state): void {
+        $this->connection->autocommit($state);
+    }
+
+    public function beginTransaction(): void {
+        if(!$this->connection->begin_transaction())
+            throw new BeginTransactionFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function commit(): void {
+        if(!$this->connection->commit())
+            throw new CommitFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function rollback(?string $name = null): void {
+        if(!$this->connection->rollback(0, $name))
+            throw new RollbackFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function savePoint(string $name): void {
+        if(!$this->connection->savepoint($name))
+            throw new SavePointFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function releaseSavePoint(string $name): void {
+        if(!$this->connection->release_savepoint($name))
+            throw new ReleaseSavePointFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    /**
+     * Gets the thread ID for the current connection.
+     *
+     * @return int Thread ID.
+     */
+    public function getThreadId(): int {
+        return $this->connection->thread_id;
+    }
+
+    /**
+     * Asks the server to kill a thread.
+     *
+     * @param int $threadId ID of the thread that should be killed.
+     * @return bool true if the thread was killed, false if not.
+     */
+    public function killThread(int $threadId): bool {
+        return $this->connection->kill($threadId);
+    }
+
+    /**
+     * @return MariaDBStatement A database statement.
+     */
+    public function prepare(string $query): MariaDBStatement {
+        $statement = $this->connection->prepare($query);
+        if($statement === false)
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+        return new MariaDBStatement($statement);
+    }
+
+    /**
+     * @return MariaDBResult A database result.
+     */
+    public function query(string $query): MariaDBResult {
+        $result = $this->connection->query($query, MYSQLI_STORE_RESULT);
+        if($result === false)
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+        // Yes, this always uses Native, for some reason the stupid limitation in libmysql only applies to preparing
+        return new MariaDBResultNative($result);
+    }
+
+    public function execute(string $query): int|string {
+        if(!$this->connection->real_query($query))
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+        return $this->connection->affected_rows;
+    }
+
+    /**
+     * Closes the connection and associated resources.
+     */
+    public function close(): void {
+        $this->connection->close();
+    }
+
+    /**
+     * Closes the connection and associated resources.
+     */
+    public function __destruct() {
+        $this->close();
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBConnectionInfo.php b/src/Data/MariaDB/MariaDBConnectionInfo.php
new file mode 100644
index 0000000..169e9ec
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBConnectionInfo.php
@@ -0,0 +1,438 @@
+<?php
+// MariaDBConnectionInfo.php
+// Created: 2021-04-30
+// Updated: 2022-02-28
+
+namespace Index\Data\MariaDB;
+
+use InvalidArgumentException;
+use Index\Data\IDbConnectionInfo;
+use Index\Net\EndPoint;
+use Index\Net\DnsEndPoint;
+use Index\Net\IPAddress;
+use Index\Net\IPEndPoint;
+use Index\Net\UnixEndPoint;
+
+/**
+ * Describes a MariaDB or MySQL connection.
+ */
+class MariaDBConnectionInfo implements IDbConnectionInfo {
+    private EndPoint $endPoint;
+    private string $userName;
+    private string $password;
+    private string $dbName;
+    private ?string $charSet;
+    private ?string $initCommand;
+    private ?string $keyPath;
+    private ?string $certPath;
+    private ?string $certAuthPath;
+    private ?string $trustedCertsPath;
+    private ?string $cipherAlgos;
+    private bool $verifyCert;
+    private bool $useCompression;
+
+    /**
+     * Creates an instance of MariaDBConnectionInfo.
+     *
+     * @param EndPoint $endPoint End point at which the server can be found.
+     * @param string $userName User name to use for the connection.
+     * @param string $password Password with which the user authenticates.
+     * @param string $dbName Default database name.
+     * @param string|null $charSet Default character set.
+     * @param string|null $initCommand Command to execute on connect.
+     * @param string|null $keyPath Path at which to find the private key for SSL.
+     * @param string|null $certPath Path at which to find the certificate file for SSL.
+     * @param string|null $certAuthPath Path at which to find the certificate authority file for SSL.
+     * @param string|null $trustedCertsPath Path at which to find the trusted SSL CA certificates for SSL in PEM format.
+     * @param string|null $cipherAlgos List of SSL encryption cipher that are allowed.
+     * @param bool $verifyCert true if the client should verify the server's SSL certificate, false if not.
+     * @param bool $useCompression true if compression should be used, false if not.
+     * @return MariaDBConnectionInfo A connection info instance representing the given information.
+     */
+    public function __construct(
+        EndPoint $endPoint,
+        string $userName,
+        string $password,
+        string $dbName,
+        string|null $charSet,
+        string|null $initCommand,
+        string|null $keyPath,
+        string|null $certPath,
+        string|null $certAuthPath,
+        string|null $trustedCertsPath,
+        string|null $cipherAlgos,
+        bool $verifyCert,
+        bool $useCompression
+    ) {
+        if(!($endPoint instanceof IPEndPoint)
+            && !($endPoint instanceof DnsEndPoint)
+            && !($endPoint instanceof UnixEndPoint))
+            throw new InvalidArgumentException('$endPoint must be of type IPEndPoint, DnsEndPoint or UnixEndPoint.');
+        $this->endPoint         = $endPoint;
+        $this->userName         = $userName;
+        $this->password         = $password;
+        $this->dbName           = $dbName;
+        $this->charSet          = empty($charSet)          ? null : $charSet;
+        $this->initCommand      = empty($initCommand)      ? null : $initCommand;
+        $this->keyPath          = empty($keyPath)          ? null : $keyPath;
+        $this->certPath         = empty($certPath)         ? null : $certPath;
+        $this->certAuthPath     = empty($certAuthPath)     ? null : $certAuthPath;
+        $this->trustedCertsPath = empty($trustedCertsPath) ? null : $trustedCertsPath;
+        $this->cipherAlgos      = empty($cipherAlgos)      ? null : $cipherAlgos;
+        $this->verifyCert       = $verifyCert;
+        $this->useCompression   = $useCompression;
+    }
+
+    /**
+     * Gets the end point value.
+     *
+     * @return EndPoint An instance of EndPoint.
+     */
+    public function getEndPoint(): EndPoint {
+        return $this->endPoint;
+    }
+
+    /**
+     * Returns whether the end point is a unix socket path.
+     *
+     * @return bool true if the end point is a unix socket, false if not.
+     */
+    public function isUnixSocket(): bool {
+        return $this->endPoint instanceof UnixEndPoint;
+    }
+
+    /**
+     * Gets the host value of the end point.
+     *
+     * Will return an empty string if the end point is a unix socket path.
+     *
+     * @return string Target host name.
+     */
+    public function getHost(): string {
+        if($this->endPoint instanceof DnsEndPoint)
+            return $this->endPoint->getHost();
+        if($this->endPoint instanceof IPEndPoint)
+            return $this->endPoint->getAddress()->getCleanAddress();
+        return '';
+    }
+
+    /**
+     * Gets the port value of the end point.
+     *
+     * Will return -1 if the end point is a unix socket path.
+     *
+     * @return int Target port number.
+     */
+    public function getPort(): int {
+        if(($this->endPoint instanceof DnsEndPoint) || ($this->endPoint instanceof IPEndPoint)) {
+            $port = $this->endPoint->getPort();
+            return $port < 1 ? 3306 : $port;
+        }
+
+        return -1;
+    }
+
+    /**
+     * Gets the unix socket path.
+     *
+     * Will return an empty string if the end point is not a unix socket path.
+     *
+     * @return string Target unix socket path.
+     */
+    public function getSocketPath(): string {
+        if($this->endPoint instanceof UnixEndPoint)
+            return $this->endPoint->getPath();
+        return '';
+    }
+
+    /**
+     * Returns the connection user name.
+     *
+     * @return string Connection user name.
+     */
+    public function getUserName(): string {
+        return $this->userName;
+    }
+
+    /**
+     * Returns the connection user password.
+     *
+     * @return string Connection user password.
+     */
+    public function getPassword(): string {
+        return $this->password;
+    }
+
+    /**
+     * Returns the connection default database name.
+     *
+     * @return string Default database name.
+     */
+    public function getDatabaseName(): string {
+        return $this->dbName;
+    }
+
+    /**
+     * Whether this connection info carries a default character set name.
+     *
+     * @return bool true if it has a character set name, false if not.
+     */
+    public function hasCharacterSet(): bool {
+        return $this->charSet !== null;
+    }
+
+    /**
+     * Returns the default character set name.
+     *
+     * @return ?string Default character set name.
+     */
+    public function getCharacterSet(): ?string {
+        return $this->charSet;
+    }
+
+    /**
+     * Whether this connection info carries an initialisation command.
+     *
+     * @return bool true if it has an initialisation command, false if not.
+     */
+    public function hasInitCommand(): bool {
+        return $this->initCommand !== null;
+    }
+
+    /**
+     * Returns the initialisation command.
+     *
+     * @return ?string Initialisation command.
+     */
+    public function getInitCommand(): ?string {
+        return $this->initCommand;
+    }
+
+    /**
+     * Whether SSL is to be used with the connection.
+     *
+     * @return bool true if SSL should be used, false if not.
+     */
+    public function isSecure(): bool {
+        return $this->keyPath !== null;
+    }
+
+    /**
+     * Returns the path to the private key to use for this connection.
+     *
+     * @return ?string Private key path.
+     */
+    public function getKeyPath(): ?string {
+        return $this->keyPath;
+    }
+
+    /**
+     * Returns the path to the certificate to use for this connection.
+     *
+     * @return ?string Certificate path.
+     */
+    public function getCertificatePath(): ?string {
+        return $this->certPath;
+    }
+
+    /**
+     * Returns the path to the certificate authority file to use for this connection.
+     *
+     * @return ?string Certificate authority file path.
+     */
+    public function getCertificateAuthorityPath(): ?string {
+        return $this->certAuthPath;
+    }
+
+    /**
+     * Returns the path to the trusted CA certificates directory for this connection.
+     *
+     * @return ?string Trusted CA certificates directory path.
+     */
+    public function getTrustedCertificatesPath(): ?string {
+        return $this->trustedCertsPath;
+    }
+
+    /**
+     * Returns the list of allowed SSL cipher algorithms.
+     *
+     * @return ?string Allowed SSL cipher algorithms.
+     */
+    public function getCipherAlgorithms(): ?string {
+        return $this->cipherAlgos;
+    }
+
+    /**
+     * Whether the client should verify the validity of the server's certificate.
+     *
+     * @return bool true if the certificate should be verified, false if not.
+     */
+    public function shouldVerifyCertificate(): bool {
+        return $this->verifyCert;
+    }
+
+    /**
+     * Whether compression should be applied on the connection.
+     *
+     * Only makes sense for remote connections, don't use this locally...
+     *
+     * @return bool true if compression should be used, false if not.
+     */
+    public function shouldUseCompression(): bool {
+        return $this->useCompression;
+    }
+
+    /**
+     * Creates a connection info instance with a hostname and port number.
+     *
+     * @param string $host Server host name.
+     * @param int $port Server port.
+     * @param string $userName User name to use for the connection.
+     * @param string $password Password with which the user authenticates.
+     * @param string $dbName Default database name.
+     * @param string|null $charSet Default character set.
+     * @param string|null $initCommand Command to execute on connect.
+     * @param string|null $keyPath Path at which to find the private key for SSL.
+     * @param string|null $certPath Path at which to find the certificate file for SSL.
+     * @param string|null $certAuthPath Path at which to find the certificate authority file for SSL.
+     * @param string|null $trustedCertsPath Path at which to find the trusted SSL CA certificates for SSL in PEM format.
+     * @param string|null $cipherAlgos List of SSL encryption cipher that are allowed.
+     * @param bool $verifyCert true if the client should verify the server's SSL certificate, false if not.
+     * @param bool $useCompression true if compression should be used, false if not.
+     * @return MariaDBConnectionInfo A connection info instance representing the given information.
+     */
+    public static function createHost(
+        string $host,
+        int $port,
+        string $userName,
+        string $password,
+        string $dbName = '',
+        string|null $charSet = null,
+        string|null $initCommand = null,
+        string|null $keyPath = null,
+        string|null $certPath = null,
+        string|null $certAuthPath = null,
+        string|null $trustedCertsPath = null,
+        string|null $cipherAlgos = null,
+        bool $verifyCert = false,
+        bool $useCompression = false
+    ): MariaDBConnectionInfo {
+        return new MariaDBConnectionInfo(
+            new DnsEndPoint($host, $port),
+            $userName,
+            $password,
+            $dbName,
+            $charSet,
+            $initCommand,
+            $keyPath,
+            $certPath,
+            $certAuthPath,
+            $trustedCertsPath,
+            $cipherAlgos,
+            $verifyCert,
+            $useCompression
+        );
+    }
+
+    /**
+     * Creates a connection info instance with a unix socket path.
+     *
+     * @param string $path Path to the unix socket.
+     * @param string $userName User name to use for the connection.
+     * @param string $password Password with which the user authenticates.
+     * @param string $dbName Default database name.
+     * @param string|null $charSet Default character set.
+     * @param string|null $initCommand Command to execute on connect.
+     * @param string|null $keyPath Path at which to find the private key for SSL.
+     * @param string|null $certPath Path at which to find the certificate file for SSL.
+     * @param string|null $certAuthPath Path at which to find the certificate authority file for SSL.
+     * @param string|null $trustedCertsPath Path at which to find the trusted SSL CA certificates for SSL in PEM format.
+     * @param string|null $cipherAlgos List of SSL encryption cipher that are allowed.
+     * @param bool $verifyCert true if the client should verify the server's SSL certificate, false if not.
+     * @param bool $useCompression true if compression should be used, false if not.
+     * @return MariaDBConnectionInfo A connection info instance representing the given information.
+     */
+    public static function createUnix(
+        string $path,
+        string $userName,
+        string $password,
+        string $dbName = '',
+        string|null $charSet = null,
+        string|null $initCommand = null,
+        string|null $keyPath = null,
+        string|null $certPath = null,
+        string|null $certAuthPath = null,
+        string|null $trustedCertsPath = null,
+        string|null $cipherAlgos = null,
+        bool $verifyCert = false,
+        bool $useCompression = false
+    ): MariaDBConnectionInfo {
+        return new MariaDBConnectionInfo(
+            UnixEndPoint::parse($path),
+            $userName,
+            $password,
+            $dbName,
+            $charSet,
+            $initCommand,
+            $keyPath,
+            $certPath,
+            $certAuthPath,
+            $trustedCertsPath,
+            $cipherAlgos,
+            $verifyCert,
+            $useCompression
+        );
+    }
+
+    /**
+     * Tries to parse an end point string and creates a connection info instance using it..
+     *
+     * Supports IPv4, IPv6 and DNS hostnames with and without a port number and Unix socket paths prefixed with unix://
+     *
+     * @param string $endPoint End point string.
+     * @param string $userName User name to use for the connection.
+     * @param string $password Password with which the user authenticates.
+     * @param string $dbName Default database name.
+     * @param string|null $charSet Default character set.
+     * @param string|null $initCommand Command to execute on connect.
+     * @param string|null $keyPath Path at which to find the private key for SSL.
+     * @param string|null $certPath Path at which to find the certificate file for SSL.
+     * @param string|null $certAuthPath Path at which to find the certificate authority file for SSL.
+     * @param string|null $trustedCertsPath Path at which to find the trusted SSL CA certificates for SSL in PEM format.
+     * @param string|null $cipherAlgos List of SSL encryption cipher that are allowed.
+     * @param bool $verifyCert true if the client should verify the server's SSL certificate, false if not.
+     * @param bool $useCompression true if compression should be used, false if not.
+     * @return MariaDBConnectionInfo A connection info instance representing the given information.
+     */
+    public static function create(
+        string $endPoint,
+        string $userName,
+        string $password,
+        string $dbName = '',
+        string|null $charSet = null,
+        string|null $initCommand = null,
+        string|null $keyPath = null,
+        string|null $certPath = null,
+        string|null $certAuthPath = null,
+        string|null $trustedCertsPath = null,
+        string|null $cipherAlgos = null,
+        bool $verifyCert = false,
+        bool $useCompression = false
+    ): MariaDBConnectionInfo {
+        return new MariaDBConnectionInfo(
+            EndPoint::parse($endPoint),
+            $userName,
+            $password,
+            $dbName,
+            $charSet,
+            $initCommand,
+            $keyPath,
+            $certPath,
+            $certAuthPath,
+            $trustedCertsPath,
+            $cipherAlgos,
+            $verifyCert,
+            $useCompression
+        );
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBParameter.php b/src/Data/MariaDB/MariaDBParameter.php
new file mode 100644
index 0000000..06e1978
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBParameter.php
@@ -0,0 +1,81 @@
+<?php
+// MariaDBParameter.php
+// Created: 2021-05-02
+// Updated: 2022-02-02
+
+namespace Index\Data\MariaDB;
+
+use Index\Data\DbTools;
+use Index\Data\DbType;
+
+/**
+ * Represents a bound parameter.
+ */
+class MariaDBParameter {
+    private int $ordinal;
+    private int $type;
+    private mixed $value;
+
+    /**
+     * Create a new MariaDBParameter.
+     *
+     * @param int $ordinal Parameter number.
+     * @param int $type DbType number.
+     * @param mixed $value Value to bind.
+     * @return MariaDBParameter A new parameter instance.
+     */
+    public function __construct(int $ordinal, int $type, mixed $value) {
+        $this->ordinal = $ordinal;
+
+        if($type == DbType::AUTO)
+            $type = DbTools::detectType($value);
+
+        $this->type = $type;
+        $this->value = $type === DbType::NULL ? null : $value;
+    }
+
+    /**
+     * Gets the parameter number.
+     *
+     * @return int Parameter number.
+     */
+    public function getOrdinal(): int {
+        return $this->ordinal;
+    }
+
+    /**
+     * Gets the DbType of for the parameter.
+     *
+     * @return int DbType.
+     */
+    public function getDbType(): int {
+        return $this->type;
+    }
+
+    /**
+     * Gets the type character for the mysqli bind.
+     *
+     * @return string Type character.
+     */
+    public function getBindType(): string {
+        switch($this->type) {
+            case DbType::INTEGER:
+                return 'i';
+            case DbType::FLOAT:
+                return 'd';
+            case DbType::BLOB:
+                return 'b';
+            default:
+                return 's';
+        }
+    }
+
+    /**
+     * Gets the value for the parameter.
+     *
+     * @return mixed Value.
+     */
+    public function getValue(): mixed {
+        return $this->value;
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBResult.php b/src/Data/MariaDB/MariaDBResult.php
new file mode 100644
index 0000000..a8f0a61
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBResult.php
@@ -0,0 +1,103 @@
+<?php
+// MariaDBResult.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data\MariaDB;
+
+use mysqli_result;
+use mysqli_stmt;
+use InvalidArgumentException;
+use Index\AString;
+use Index\WString;
+use Index\Data\IDbResult;
+use Index\IO\Stream;
+use Index\IO\TempFileStream;
+
+/**
+ * Represents a MariaDB/MySQL database result.
+ */
+abstract class MariaDBResult implements IDbResult {
+    protected mysqli_stmt|mysqli_result $result;
+    protected array $currentRow = [];
+
+    /**
+     * Creates a new MariaDBResult instance.
+     *
+     * @param mysqli_stmt|mysqli_result $result A result to work with.
+     * @return MariaDBResult A result instance.
+     */
+    public function __construct(mysqli_stmt|mysqli_result $result) {
+        $this->result = $result;
+    }
+
+    /**
+     * Gets the number of available rows in this result.
+     *
+     * @return int|string Number of available rows.
+     */
+    public function getRowCount(): int|string {
+        return $this->result->num_rows;
+    }
+
+    /**
+     * Gets the number of fields in the result per row.
+     *
+     * @return int Number of fields.
+     */
+    public function getFieldCount(): int {
+        return $this->result->field_count;
+    }
+
+    /**
+     * Seek to a specific row.
+     *
+     * @param int $offset Offset of the row.
+     */
+    public function seekRow(int $offset): void {
+        if(!$this->result->data_seek($offset))
+            throw new InvalidArgumentException('$offset is not a valid row offset.');
+    }
+
+    abstract public function next(): bool;
+
+    public function isNull(int|string $index): bool {
+        return array_key_exists($index, $this->currentRow) && $this->currentRow[$index] === null;
+    }
+
+    public function getValue(int|string $index): mixed {
+        return $this->currentRow[$index] ?? null;
+    }
+
+    public function getString(int|string $index): string {
+        return strval($this->getValue($index));
+    }
+
+    public function getAString(int|string $index): AString {
+        return new AString($this->getString($index));
+    }
+
+    public function getWString(int|string $index, string $encoding): WString {
+        return new WString($this->getString($index), $encoding);
+    }
+
+    public function getInteger(int|string $index): int {
+        return intval($this->getValue($index));
+    }
+
+    public function getFloat(int|string $index): float {
+        return floatval($this->getValue($index));
+    }
+
+    public function getStream(int|string $index): ?Stream {
+        if($this->isNull($index))
+            return null;
+        return new TempFileStream($this->getValue($index));
+    }
+
+    abstract function close(): void;
+
+    public function __destruct() {
+        $this->close();
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBResultLib.php b/src/Data/MariaDB/MariaDBResultLib.php
new file mode 100644
index 0000000..2e14b3b
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBResultLib.php
@@ -0,0 +1,53 @@
+<?php
+// MariaDBResultLib.php
+// Created: 2021-05-02
+// Updated: 2021-05-04
+
+namespace Index\Data\MariaDB;
+
+use mysqli_stmt;
+use Index\Data\QueryExecuteException;
+
+/**
+ * Implementation of MariaDBResult for libmysql.
+ *
+ * @internal
+ */
+class MariaDBResultLib extends MariaDBResult {
+    private array $fields = [];
+    private array $data = [];
+
+    public function __construct(mysqli_stmt $statement) {
+        parent::__construct($statement);
+
+        if(!$statement->store_result())
+            throw new QueryExecuteException($statement->error, $statement->errno);
+
+        $metadata = $statement->result_metadata();
+        while($field = $metadata->fetch_field())
+            $this->fields[] = &$this->data[$field->name];
+
+        call_user_func_array([$statement, 'bind_result'], $this->fields);
+    }
+
+    public function next(): bool {
+        $result = $this->result->fetch();
+        if($result === false)
+            throw new QueryExecuteException($this->result->error, $this->result->errno);
+        if($result === null)
+            return false;
+
+        $i = 0;
+        $this->currentRow = [];
+        foreach($this->data as $key => $value) {
+            $this->currentRow[$i++] = $value;
+            $this->currentRow[$key] = $value;
+        }
+
+        return true;
+    }
+
+    public function close(): void {
+        $this->result->free_result();
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBResultNative.php b/src/Data/MariaDB/MariaDBResultNative.php
new file mode 100644
index 0000000..61c77ba
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBResultNative.php
@@ -0,0 +1,40 @@
+<?php
+// MariaDBResultNative.php
+// Created: 2021-05-02
+// Updated: 2021-05-04
+
+namespace Index\Data\MariaDB;
+
+use mysqli_result;
+use mysqli_stmt;
+use Index\Data\QueryExecuteException;
+
+/**
+ * Implementation of MariaDBResult for mysqlnd.
+ *
+ * @internal
+ */
+class MariaDBResultNative extends MariaDBResult {
+    public function __construct(mysqli_stmt|mysqli_result $result) {
+        if($result instanceof mysqli_stmt) {
+            $_result = $result->get_result();
+            if($_result === false)
+                throw new QueryExecuteException($result->error, $result->errno);
+            $result = $_result;
+        }
+
+        parent::__construct($result);
+    }
+
+    public function next(): bool {
+        $result = $this->result->fetch_array(MYSQLI_BOTH);
+        if($result === null)
+            return false;
+        $this->currentRow = $result;
+        return true;
+    }
+
+    public function close(): void {
+        $this->result->close();
+    }
+}
diff --git a/src/Data/MariaDB/MariaDBStatement.php b/src/Data/MariaDB/MariaDBStatement.php
new file mode 100644
index 0000000..8d0cb33
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBStatement.php
@@ -0,0 +1,165 @@
+<?php
+// MariaDBStatement.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+namespace Index\Data\MariaDB;
+
+use mysqli_stmt;
+use InvalidArgumentException;
+use RuntimeException;
+use Index\Data\DbType;
+use Index\Data\QueryExecuteException;
+use Index\Data\IDbStatement;
+use Index\IO\Stream;
+
+/**
+ * Represents a MariaDB/MySQL prepared statement.
+ */
+class MariaDBStatement implements IDbStatement {
+    private mysqli_stmt $statement;
+    private array $params = [];
+
+    /**
+     * Creates a MariaDBStatement.
+     *
+     * @param mysqli_stmt $statement Underlying statement object.
+     * @return MariaDBStatement A new statement instance.
+     */
+    public function __construct(mysqli_stmt $statement) {
+        $this->statement = $statement;
+    }
+
+    private static bool $constructed = false;
+    private static string $resultImplementation;
+
+    /**
+     * Determines which MariaDBResult implementation should be used.
+     *
+     * @internal
+     */
+    public static function construct(): void {
+        if(self::$constructed !== false)
+            throw new RuntimeException('Static constructor was already called.');
+        self::$constructed = true;
+        self::$resultImplementation = function_exists('mysqli_stmt_get_result')
+            ? MariaDBResultNative::class
+            : MariaDBResultLib::class;
+    }
+
+    public function getParameterCount(): int {
+        return $this->statement->param_count;
+    }
+
+    public function addParameter(int $ordinal, mixed $value, int $type = DbType::AUTO): void {
+        if($ordinal < 1 || $ordinal > $this->getParameterCount())
+            throw new InvalidArgumentException('$ordinal is not a valid parameter number.');
+        $this->params[$ordinal - 1] = new MariaDBParameter($ordinal, $type, $value);
+    }
+
+    /**
+     * Gets the last error code.
+     *
+     * @return int Last error code.
+     */
+    public function getLastErrorCode(): int {
+        return $this->statement->errno;
+    }
+
+    /**
+     * Gets the last error string.
+     *
+     * @return string Last error string.
+     */
+    public function getLastErrorString(): string {
+        return $this->statement->error;
+    }
+
+    /**
+     * Gets the current SQL State of this statement.
+     *
+     * @return string Current SQL State.
+     */
+    public function getSQLState(): string {
+        return $this->statement->sqlstate;
+    }
+
+    /**
+     * Gets a list of errors from the last command.
+     *
+     * @return array List of last errors.
+     */
+    public function getLastErrors(): array {
+        return MariaDBWarning::fromLastErrors($this->statement->error_list);
+    }
+
+    /**
+     * Gets list of warnings.
+     *
+     * The result of SHOW WARNINGS;
+     *
+     * @return array List of warnings.
+     */
+    public function getWarnings(): array {
+        return MariaDBWarning::fromGetWarnings($this->statement->get_warnings());
+    }
+
+    public function getResult(): MariaDBResult {
+        return new self::$resultImplementation($this->statement);
+    }
+
+    public function getLastInsertId(): int|string {
+        return $this->statement->insert_id;
+    }
+
+    public function execute(): void {
+        $args = [''];
+
+        foreach($this->params as $key => $param) {
+            $args[0] .= $param->getBindType();
+            $type = $param->getDbType();
+            $value = $param->getValue();
+
+            if($type === DbType::NULL)
+                $value = null;
+            elseif($type === DbType::BLOB) {
+                if($value instanceof Stream) {
+                    while(($data = $value->read(8192)) !== null)
+                        $this->statement->send_long_data($key, $data);
+                } elseif(is_resource($value)) {
+                    while($data = fread($value, 8192))
+                        $this->statement->send_long_data($key, $data);
+                } else
+                    $this->statement->send_long_data($key, strval($value));
+
+                $value = null;
+            }
+
+
+            ${"value{$key}"} = $value;
+            $args[] = &${"value{$key}"};
+        }
+
+        if(!empty($args[0]))
+            call_user_func_array([$this->statement, 'bind_param'], $args);
+
+        if(!$this->statement->execute())
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function reset(): void {
+        $this->params = [];
+        if(!$this->statement->reset())
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function close(): void {
+        $this->statement->close();
+    }
+
+    public function __destruct() {
+        $this->close();
+    }
+}
+
+MariaDBStatement::construct();
diff --git a/src/Data/MariaDB/MariaDBWarning.php b/src/Data/MariaDB/MariaDBWarning.php
new file mode 100644
index 0000000..0d273a8
--- /dev/null
+++ b/src/Data/MariaDB/MariaDBWarning.php
@@ -0,0 +1,95 @@
+<?php
+// MariaDBWarning.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+namespace Index\Data\MariaDB;
+
+use mysqli_warning;
+use Stringable;
+use Index\XArray;
+
+/**
+ * Represents a MariaDB/MySQL warning.
+ */
+class MariaDBWarning implements Stringable {
+    private string $message;
+    private string $sqlState;
+    private int $code;
+
+    /**
+     * Creates a new MariaDBWarning object.
+     *
+     * @param string $message Warning message string.
+     * @param string $sqlState SQL State of the warning.
+     * @param int $code Error code of the warning.
+     * @return MariaDBWarning A new warning instance.
+     */
+    public function __construct(string $message, string $sqlState, int $code) {
+        $this->message = $message;
+        $this->sqlState = $sqlState;
+        $this->code = $code;
+    }
+
+    /**
+     * Gets the warning message string.
+     *
+     * @return string Warning message string.
+     */
+    public function getMessage(): string {
+        return $this->message;
+    }
+
+    /**
+     * Gets the warning SQL State.
+     *
+     * @return string SQL State.
+     */
+    public function getSQLState(): string {
+        return $this->sqlState;
+    }
+
+    /**
+     * Gets the warning error code.
+     *
+     * @return int Warning error code.
+     */
+    public function getCode(): int {
+        return $this->code;
+    }
+
+    public function __toString(): string {
+        return sprintf('[%s] %d: %s', $this->sqlState, $this->code, $this->message);
+    }
+
+    /**
+     * Creates an array of warning objects from the output of $last_errors.
+     *
+     * @param array $errors Array of warning arrays.
+     * @return array Array of warnings objects.
+     */
+    public static function fromLastErrors(array $errors): array {
+        return XArray::select($errors, fn($error) => new MariaDBWarning($error['error'], $error['sqlstate'], $error['errno']));
+    }
+
+    /**
+     * Creates an array of warning objects from a mysqli_warning instance.
+     *
+     * @param mysqli_warning|false $warnings Warning object.
+     * @return array Array of warning objects.
+     */
+    public static function fromGetWarnings(mysqli_warning|false $warnings): array {
+        $array = [];
+
+        if($warnings !== false)
+            do {
+                $array[] = new MariaDBWarning(
+                    $warnings->message,
+                    $warnings->sqlstate,
+                    $warnings->errno
+                );
+            } while($warnings->next());
+
+        return $array;
+    }
+}
diff --git a/src/Data/NullDb/NullDbBackend.php b/src/Data/NullDb/NullDbBackend.php
new file mode 100644
index 0000000..20106c1
--- /dev/null
+++ b/src/Data/NullDb/NullDbBackend.php
@@ -0,0 +1,36 @@
+<?php
+// NullDbBackend.php
+// Created: 2021-05-02
+// Updated: 2022-02-28
+
+namespace Index\Data\NullDb;
+
+use Index\Data\IDbBackend;
+use Index\Data\IDbConnection;
+use Index\Data\IDbConnectionInfo;
+
+/**
+ * Information about the dummy database layer.
+ */
+class NullDbBackend implements IDbBackend {
+    public function isAvailable(): bool {
+        return true;
+    }
+
+    /**
+     * Creates a dummy database connection.
+     *
+     * @param NullDbConnectionInfo $connectionInfo Dummy connection info.
+     * @return NullDbConnection Dummy connection instance.
+     */
+    public function createConnection(IDbConnectionInfo $connectionInfo): IDbConnection {
+        return new NullDbConnection;
+    }
+
+    /**
+     * @return NullDbConnectionInfo Dummy connection info instance.
+     */
+    public function parseDsn(string|array $dsn): IDbConnectionInfo {
+        return new NullDbConnectionInfo;
+    }
+}
diff --git a/src/Data/NullDb/NullDbConnection.php b/src/Data/NullDb/NullDbConnection.php
new file mode 100644
index 0000000..80be6ca
--- /dev/null
+++ b/src/Data/NullDb/NullDbConnection.php
@@ -0,0 +1,33 @@
+<?php
+// NullDbConnection.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+namespace Index\Data\NullDb;
+
+use Index\Data\IDbConnection;
+use Index\Data\IDbStatement;
+use Index\Data\IDbResult;
+
+/**
+ * Represents a dummy database connection.
+ */
+class NullDbConnection implements IDbConnection {
+    public function getLastInsertId(): int|string {
+        return 0;
+    }
+
+    public function prepare(string $query): IDbStatement {
+        return new NullDbStatement;
+    }
+
+    public function query(string $query): IDbResult {
+        return new NullDbResult;
+    }
+
+    public function execute(string $query): int|string {
+        return 0;
+    }
+
+    public function close(): void {}
+}
diff --git a/src/Data/NullDb/NullDbConnectionInfo.php b/src/Data/NullDb/NullDbConnectionInfo.php
new file mode 100644
index 0000000..83ac4db
--- /dev/null
+++ b/src/Data/NullDb/NullDbConnectionInfo.php
@@ -0,0 +1,13 @@
+<?php
+// NullDbConnectionInfo.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data\NullDb;
+
+use Index\Data\IDbConnectionInfo;
+
+/**
+ * Represents dummy connection info.
+ */
+class NullDbConnectionInfo implements IDbConnectionInfo {}
diff --git a/src/Data/NullDb/NullDbResult.php b/src/Data/NullDb/NullDbResult.php
new file mode 100644
index 0000000..75c14cd
--- /dev/null
+++ b/src/Data/NullDb/NullDbResult.php
@@ -0,0 +1,54 @@
+<?php
+// NullDbResult.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data\NullDb;
+
+use Index\AString;
+use Index\WString;
+use Index\Data\IDbResult;
+use Index\IO\Stream;
+
+/**
+ * Represents a dummy database result.
+ */
+class NullDbResult implements IDbResult {
+    public function next(): bool {
+        return false;
+    }
+
+    public function isNull(int|string $index): bool {
+        return true;
+    }
+
+    public function getValue(int|string $index): mixed {
+        return null;
+    }
+
+    public function getString(int|string $index): string {
+        return '';
+    }
+
+    public function getAString(int|string $index): AString {
+        return AString::empty();
+    }
+
+    public function getWString(int|string $index, string $encoding): WString {
+        return WString::empty();
+    }
+
+    public function getInteger(int|string $index): int {
+        return 0;
+    }
+
+    public function getFloat(int|string $index): float {
+        return 0.0;
+    }
+
+    public function getStream(int|string $index): ?Stream {
+        return null;
+    }
+
+    public function close(): void {}
+}
diff --git a/src/Data/NullDb/NullDbStatement.php b/src/Data/NullDb/NullDbStatement.php
new file mode 100644
index 0000000..c74fe1b
--- /dev/null
+++ b/src/Data/NullDb/NullDbStatement.php
@@ -0,0 +1,35 @@
+<?php
+// NullDbStatement.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data\NullDb;
+
+use Index\Data\DbType;
+use Index\Data\IDbResult;
+use Index\Data\IDbStatement;
+
+/**
+ * Represents a dummy database statement.
+ */
+class NullDbStatement implements IDbStatement {
+    public function getParameterCount(): int {
+        return 0;
+    }
+
+    public function addParameter(int $ordinal, mixed $value, int $type = DbType::AUTO): void {}
+
+    public function getResult(): IDbResult {
+        return new NullDbResult;
+    }
+
+    public function getLastInsertId(): int|string {
+        return 0;
+    }
+
+    public function execute(): void {}
+
+    public function reset(): void {}
+
+    public function close(): void {}
+}
diff --git a/src/Data/QueryExecuteException.php b/src/Data/QueryExecuteException.php
new file mode 100644
index 0000000..e6c69ca
--- /dev/null
+++ b/src/Data/QueryExecuteException.php
@@ -0,0 +1,11 @@
+<?php
+// QueryExecuteException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when query execution fails.
+ */
+class QueryExecuteException extends DataException {}
diff --git a/src/Data/ReleaseSavePointFailedException.php b/src/Data/ReleaseSavePointFailedException.php
new file mode 100644
index 0000000..98c402d
--- /dev/null
+++ b/src/Data/ReleaseSavePointFailedException.php
@@ -0,0 +1,11 @@
+<?php
+// ReleaseSavePointFailedException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when save point release fails.
+ */
+class ReleaseSavePointFailedException extends TransactionException {}
diff --git a/src/Data/RollbackFailedException.php b/src/Data/RollbackFailedException.php
new file mode 100644
index 0000000..7f92939
--- /dev/null
+++ b/src/Data/RollbackFailedException.php
@@ -0,0 +1,11 @@
+<?php
+// RollbackFailedException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when transaction rollback fails.
+ */
+class RollbackFailedException extends TransactionException {}
diff --git a/src/Data/SQLite/SQLiteBackend.php b/src/Data/SQLite/SQLiteBackend.php
new file mode 100644
index 0000000..6b7b2f7
--- /dev/null
+++ b/src/Data/SQLite/SQLiteBackend.php
@@ -0,0 +1,74 @@
+<?php
+// SQLiteBackend.php
+// Created: 2021-05-02
+// Updated: 2022-02-28
+
+namespace Index\Data\SQLite;
+
+use SQLite3;
+use InvalidArgumentException;
+use Index\Version;
+use Index\Data\IDbBackend;
+use Index\Data\IDbConnection;
+use Index\Data\IDbConnectionInfo;
+
+/**
+ * Information about the SQLite 3 database layer.
+ */
+class SQLiteBackend implements IDbBackend {
+    public function isAvailable(): bool {
+        return extension_loaded('sqlite3');
+    }
+
+    /**
+     * Gets the version of the underlying library.
+     *
+     * @return Version Version of the library.
+     */
+    public function getVersion(): Version {
+        return Version::parse(SQLite3::version()['versionString']);
+    }
+
+    /**
+     * Creates a new SQLite client.
+     *
+     * @param SQLiteConnectionInfo $connectionInfo Object that describes the desired connection.
+     * @return SQLiteConnection A client for an SQLite database.
+     */
+    public function createConnection(IDbConnectionInfo $connectionInfo): IDbConnection {
+        if(!($connectionInfo instanceof SQLiteConnectionInfo))
+            throw new InvalidArgumentException('$connectionInfo must by of type SQLiteConnectionInfo');
+
+        return new SQLiteConnection($connectionInfo);
+    }
+
+    /**
+     * @return SQLiteConnectionInfo SQLite connection info.
+     */
+    public function parseDsn(string|array $dsn): IDbConnectionInfo {
+        if(is_string($dsn)) {
+            $dsn = parse_url($dsn);
+            if($dsn === false)
+                throw new InvalidArgumentException('$dsn is not a valid uri.');
+        }
+
+        $path = $dsn['path'] ?? '';
+
+        if($path === 'memory:')
+            $path = ':memory:';
+
+        if(!isset($dsn['query'])) {
+            $encKey = '';
+            $readOnly = false;
+            $create = true;
+        } else {
+            parse_str(str_replace('+', '%2B', $dsn['query']), $query);
+
+            $encKey = $query['key'] ?? '';
+            $readOnly = !empty($query['readOnly']);
+            $create = empty($query['openOnly']);
+        }
+
+        return new SQLiteConnectionInfo($path, $encKey, $readOnly, $create);
+    }
+}
diff --git a/src/Data/SQLite/SQLiteConnection.php b/src/Data/SQLite/SQLiteConnection.php
new file mode 100644
index 0000000..51ed326
--- /dev/null
+++ b/src/Data/SQLite/SQLiteConnection.php
@@ -0,0 +1,569 @@
+<?php
+// SQLiteConnection.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+namespace Index\Data\SQLite;
+
+use SQLite3;
+use Index\Data\BeginTransactionFailedException;
+use Index\Data\DataException;
+use Index\Data\IDbConnection;
+use Index\Data\IDbTransactions;
+use Index\Data\IDbStatement;
+use Index\Data\IDbResult;
+use Index\Data\CommitFailedException;
+use Index\Data\ReleaseSavePointFailedException;
+use Index\Data\RollbackFailedException;
+use Index\Data\SavePointFailedException;
+use Index\Data\QueryExecuteException;
+use Index\IO\GenericStream;
+use Index\IO\Stream;
+
+/**
+ * Represents a client for an SQLite database.
+ */
+class SQLiteConnection implements IDbConnection, IDbTransactions {
+    /**
+     * CREATE INDEX authorizer.
+     *
+     * Second parameter will be the name of the index.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const CREATE_INDEX = SQLite3::CREATE_INDEX;
+
+    /**
+     * CREATE TABLE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const CREATE_TABLE = SQLite3::CREATE_TABLE;
+
+    /**
+     * CREATE TEMP INDEX authorizer.
+     *
+     * Second parameter will be the name of the index.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const CREATE_TEMP_INDEX = SQLite3::CREATE_TEMP_INDEX;
+
+    /**
+     * CREATE TEMP TABLE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const CREATE_TEMP_TABLE = SQLite3::CREATE_TEMP_TABLE;
+
+    /**
+     * CREATE TEMP TRIGGER authorizer.
+     *
+     * Second parameter will be the name of the trigger.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const CREATE_TEMP_TRIGGER = SQLite3::CREATE_TEMP_TRIGGER;
+
+    /**
+     * CREATE TEMP VIEW authorizer.
+     *
+     * Second parameter will be the name of the view.
+     *
+     * @var int
+     */
+    public const CREATE_TEMP_VIEW = SQLite3::CREATE_TEMP_VIEW;
+
+    /**
+     * CREATE TRIGGER authorizer.
+     *
+     * Second parameter will be the name of the trigger.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const CREATE_TRIGGER = SQLite3::CREATE_TRIGGER;
+
+    /**
+     * CREATE VIEW authorizer.
+     *
+     * Second parameter will be the name of the view.
+     *
+     * @var int
+     */
+    public const CREATE_VIEW = SQLite3::CREATE_VIEW;
+
+    /**
+     * DELETE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DELETE = SQLite3::DELETE;
+
+    /**
+     * DROP INDEX authorizer.
+     *
+     * Second parameter will be the name of the index.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DROP_INDEX = SQLite3::DROP_INDEX;
+
+    /**
+     * DROP TABLE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DROP_TABLE = SQLite3::DROP_TABLE;
+
+    /**
+     * DROP TEMP INDEX authorizer.
+     *
+     * Second parameter will be the name of the index.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DROP_TEMP_INDEX = SQLite3::DROP_TEMP_INDEX;
+
+    /**
+     * DROP TEMP TABLE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DROP_TEMP_TABLE = SQLite3::DROP_TEMP_TABLE;
+
+    /**
+     * DROP TEMP TRIGGER authorizer.
+     *
+     * Second parameter will be the name of the trigger.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DROP_TEMP_TRIGGER = SQLite3::DROP_TEMP_TRIGGER;
+
+    /**
+     * DROP TEMP VIEW authorizer.
+     *
+     * Second parameter will be the name of the view.
+     *
+     * @var int
+     */
+    public const DROP_TEMP_VIEW = SQLite3::DROP_TEMP_VIEW;
+
+    /**
+     * DROP TRIGGER authorizer.
+     *
+     * Second parameter will be the name of the trigger.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const DROP_TRIGGER = SQLite3::DROP_TRIGGER;
+
+    /**
+     * DROP VIEW authorizer.
+     *
+     * Second parameter will be the name of the view.
+     *
+     * @var int
+     */
+    public const DROP_VIEW = SQLite3::DROP_VIEW;
+
+    /**
+     * INSERT authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const INSERT = SQLite3::INSERT;
+
+    /**
+     * PRAGMA authorizer.
+     *
+     * Second parameter will be the name of the pragma.
+     * Third parameter may be the first argument passed to the pragma.
+     *
+     * @var int
+     */
+    public const PRAGMA = SQLite3::PRAGMA;
+
+    /**
+     * READ authorizer.
+     *
+     * Second parameter will be the name of the table.
+     * Third parameter will be the name of the column.
+     *
+     * @var int
+     */
+    public const READ = SQLite3::READ;
+
+    /**
+     * SELECT authorizer.
+     *
+     * @var int
+     */
+    public const SELECT = SQLite3::SELECT;
+
+    /**
+     * TRANSACTION authorizer.
+     *
+     * Second parameter will be the operation.
+     *
+     * @var int
+     */
+    public const TRANSACTION = SQLite3::TRANSACTION;
+
+    /**
+     * UPDATE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     * Third parameter will be the name of the column.
+     *
+     * @var int
+     */
+    public const UPDATE = SQLite3::UPDATE;
+
+    /**
+     * ATTACH authorizer.
+     *
+     * Second parameter will be the filename.
+     *
+     * @var int
+     */
+    public const ATTACH = SQLite3::ATTACH;
+
+    /**
+     * DETACH authorizer.
+     *
+     * Second parameter will be the name of the database.
+     *
+     * @var int
+     */
+    public const DETACH = SQLite3::DETACH;
+
+    /**
+     * ALTER TABLE authorizer.
+     *
+     * Second parameter will be the name of the database.
+     * Third parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const ALTER_TABLE = SQLite3::ALTER_TABLE;
+
+    /**
+     * REINDEX authorizer.
+     *
+     * Second parameter will be the name of the index.
+     *
+     * @var int
+     */
+    public const REINDEX = SQLite3::REINDEX;
+
+    /**
+     * ANALYZE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     *
+     * @var int
+     */
+    public const ANALYZE = SQLite3::ANALYZE;
+
+    /**
+     * CREATE VTABLE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     * Third parameter will be the name of the module.
+     *
+     * @var int
+     */
+    public const CREATE_VTABLE = SQLite3::CREATE_VTABLE;
+
+    /**
+     * DROP VTABLE authorizer.
+     *
+     * Second parameter will be the name of the table.
+     * Third parameter will be the name of the module.
+     *
+     * @var int
+     */
+    public const DROP_VTABLE = SQLite3::DROP_VTABLE;
+
+    /**
+     * FUNCTION authorizer.
+     *
+     * Third parameter will be the name of the function.
+     *
+     * @var int
+     */
+    public const FUNCTION = SQLite3::FUNCTION;
+
+    /**
+     * SAVEPOINT authorizer.
+     *
+     * Second parameter will be the operation.
+     * Third parameter will be the name of the savepoint.
+     *
+     * @var int
+     */
+    public const SAVEPOINT = SQLite3::SAVEPOINT;
+
+    /**
+     * RECURSIVE authorizer.
+     *
+     * @var int
+     */
+    public const RECURSIVE = SQLite3::RECURSIVE;
+
+    /**
+     * DETERMINISTIC flag for SQLite registered functions.
+     *
+     * When specified the function will always return the same result given the same inputs within a single SQL statement.
+     *
+     * @var int
+     */
+    public const DETERMINISTIC = SQLITE3_DETERMINISTIC;
+
+    /**
+     * OK authorization status.
+     *
+     * @var int
+     */
+    public const OK = SQLite3::OK;
+
+    /**
+     * DENY authorization status.
+     *
+     * @var int
+     */
+    public const DENY = SQLite3::DENY;
+
+    /**
+     * IGNORE authorization status.
+     *
+     * @var int
+     */
+    public const IGNORE = SQLite3::IGNORE;
+
+    private SQLite3 $connection;
+    private bool $autoCommit = true;
+
+    /**
+     * Creates a new SQLite client.
+     *
+     * @param SQLiteConnectionInfo $connectionInfo Information about the client.
+     * @return SQLiteConnection A new SQLite client.
+     */
+    public function __construct(SQLiteConnectionInfo $connectionInfo) {
+        $flags = 0;
+        if($connectionInfo->shouldReadOnly())
+            $flags |= SQLITE3_OPEN_READONLY;
+        else
+            $flags |= SQLITE3_OPEN_READWRITE;
+
+        if($connectionInfo->shouldCreate())
+            $flags |= SQLITE3_OPEN_CREATE;
+
+        $this->connection = new SQLite3(
+            $connectionInfo->getFileName(),
+            $flags,
+            $connectionInfo->getEncryptionKey()
+        );
+        $this->connection->enableExceptions(true);
+    }
+
+    /**
+     * Gets the number of rows affected by the last operation.
+     *
+     * @return int|string Number of rows affected by the last operation.
+     */
+    public function getAffectedRows(): int|string {
+        return $this->connection->changes();
+    }
+
+    /**
+     * Registers a PHP function for use as an SQL aggregate function.
+     *
+     * @see https://www.php.net/manual/en/sqlite3.createaggregate.php
+     * @param string $name Name of the SQL aggregate.
+     * @param callable $stepCallback Callback function to be called for each row of the result set.
+     *                               Definition: step(mixed $context, int $rowNumber, mixed $value, mixed ...$values): mixed
+     * @param callable $finalCallback Callback function to be called to finalize the aggregate operation and return the value.
+     *                                Definition: fini(mixed $content, int $rowNumber): mixed
+     * @param int $argCount Number of arguments this aggregate function takes, -1 for any amount.
+     * @return bool true if the aggregate function was created successfully, false if not.
+     */
+    public function createAggregate(string $name, callable $stepCallback, callable $finalCallback, int $argCount = -1): bool {
+        return $this->connection->createAggregate($name, $stepCallback, $finalCallback, $argCount);
+    }
+
+    /**
+     * Registers a PHP function for use as an SQL collating function.
+     *
+     * @see https://www.php.net/manual/en/sqlite3.createcollation.php
+     * @param string $name Name of the SQL collating function.
+     * @param callable $callback Callback function that returns -1, 0 or 1 to indicate sort order.
+     *                           Definition: collation(mixed $value1, mixed $value2): int
+     * @return bool true if the collating function was registered, false if not.
+     */
+    public function createCollation(string $name, callable $callback): bool {
+        return $this->connection->createCollation($name, $callback);
+    }
+
+    /**
+     * Register a PHP function for use as an SQL scalar function.
+     *
+     * @see https://www.php.net/manual/en/sqlite3.createfunction.php
+     * @param string $name Name of the SQL function.
+     * @param callable $callback Callback function to register.
+     *                           Definition: callback(mixed $value, mixed ...$values): mixed
+     * @param int $argCount Number of arguments this aggregate function takes, -1 for any amount.
+     * @param int $flags A bitset of flags.
+     */
+    public function createFunction(string $name, callable $callback, int $argCount = -1, int $flags = 0): bool {
+        return $this->connection->createFunction($name, $callback, $argCount, $flags);
+    }
+
+    /**
+     * Sets a callback to be used as an authorizer to limit what statements can do.
+     *
+     * @param callable|null $callback An authorizer callback or null to remove the previous authorizer.
+     *                                Definition: authorizer(int $actionCode, mixed $param2, mixed $param3, string $database, mixed $trigger): int
+     *                                $param2 and $param3 differ based on $actionCode.
+     *                                Must return one of the OK, DENY or IGNORE constants.
+     * @return bool true if the action was successful, false if not.
+     */
+    public function setAuthorizer(callable|null $callback): bool {
+        return $this->connection->setAuthorizer($callback);
+    }
+
+    /**
+     * Gets the last error string.
+     *
+     * @return string Last error string.
+     */
+    public function getLastErrorString(): string {
+        return $this->connection->lastErrorMsg();
+    }
+
+    /**
+     * Gets the last error code.
+     *
+     * @return int Last error code.
+     */
+    public function getLastErrorCode(): int {
+        return $this->connection->lastErrorCode();
+    }
+
+    /**
+     * Opens a BLOB field as a Stream.
+     *
+     * To be used instead of getStream on SQLiteResult.
+     *
+     * @param string $table Name of the source table.
+     * @param string $column Name of the source column.
+     * @param int $rowId ID of the source row.
+     * @throws DataException If opening the BLOB failed.
+     * @return Stream BLOB field as a Stream.
+     */
+    public function getBlobStream(string $table, string $column, int $rowId): Stream {
+        $handle = $this->connection->openBlob($table, $column, $rowId);
+        if(!is_resource($handle))
+            throw new DataException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+        return new GenericStream($this->connection->openBlob($table, $column, $rowId));
+    }
+
+    public function getLastInsertId(): int|string {
+        return $this->connection->lastInsertRowID();
+    }
+
+    public function prepare(string $query): IDbStatement {
+        $statement = $this->connection->prepare($query);
+        if($statement === false)
+            throw new QueryExecuteException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+        return new SQLiteStatement($this, $statement);
+    }
+
+    public function query(string $query): IDbResult {
+        $result = $this->connection->query($query);
+        if($result === false)
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+        return new SQLiteResult($result);
+    }
+
+    public function execute(string $query): int|string {
+        if(!$this->connection->exec($query))
+            throw new QueryExecuteException($this->getLastErrorString(), $this->getLastErrorCode());
+        return $this->connection->changes();
+    }
+
+    public function setAutoCommit(bool $state): void {
+        // there's not really a completely reliable way to set a persistent auto commit disable state
+        if($state === $this->autoCommit)
+            return;
+        $this->autoCommit = $state;
+
+        if($state) {
+            $this->commit();
+        } else {
+            $this->beginTransaction();
+        }
+    }
+
+    public function beginTransaction(): void {
+        if(!$this->connection->exec('BEGIN;'))
+            throw new BeginTransactionFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function commit(): void {
+        if(!$this->connection->exec('COMMIT;'))
+            throw new CommitFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+        if(!$this->autoCommit)
+            $this->beginTransaction();
+    }
+
+    public function rollback(?string $name = null): void {
+        if(!$this->connection->exec(empty($name) ? 'ROLLBACK;' : "ROLLBACK TO {$name};"))
+            throw new CommitFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+        if(!$this->autoCommit)
+            $this->beginTransaction();
+    }
+
+    public function savePoint(string $name): void {
+        if(!$this->connection->exec("SAVEPOINT {$name};"))
+            throw new SavePointFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function releaseSavePoint(string $name): void {
+        if(!$this->connection->exec("RELEASE SAVEPOINT {$name};"))
+            throw new ReleaseSavePointFailedException((string)$this->getLastErrorString(), $this->getLastErrorCode());
+    }
+
+    public function close(): void {
+        $this->connection->close();
+    }
+
+    /**
+     * Closes the connection and associated resources.
+     */
+    public function __destruct() {
+        $this->close();
+    }
+}
diff --git a/src/Data/SQLite/SQLiteConnectionInfo.php b/src/Data/SQLite/SQLiteConnectionInfo.php
new file mode 100644
index 0000000..f4edb50
--- /dev/null
+++ b/src/Data/SQLite/SQLiteConnectionInfo.php
@@ -0,0 +1,116 @@
+<?php
+// SQLiteConnectionInfo.php
+// Created: 2021-05-02
+// Updated: 2022-02-28
+
+namespace Index\Data\SQLite;
+
+use Index\Data\IDbConnectionInfo;
+
+/**
+ * Represents information about a SQLite Client.
+ */
+class SQLiteConnectionInfo implements IDbConnectionInfo {
+    private string $fileName;
+    private bool $readOnly;
+    private bool $create;
+    private string $encryptionKey;
+
+    /**
+     * Creates a new SQLiteConnectionInfo instance.
+     *
+     * @param string $fileName Path to the SQLite database.
+     * @param string $encryptionKey Key to encrypt the database with.
+     * @param bool $readOnly Set to true if the database should be opened read-only.
+     * @param bool $create Set to true to create the database if it does not exist.
+     * @return SQLiteConnectionInfo Information to create an SQLite database client.
+     */
+    public function __construct(
+        string $fileName,
+        string $encryptionKey,
+        bool $readOnly,
+        bool $create
+    ) {
+        $this->fileName = $fileName;
+        $this->encryptionKey = $encryptionKey;
+        $this->readOnly = $readOnly;
+        $this->create = $create;
+    }
+
+    /**
+     * Gets the path of the SQLite database.
+     */
+    public function getFileName(): string {
+        return $this->fileName;
+    }
+
+    /**
+     * Returns the key to use for encryption of the database.
+     *
+     * @return string Encryption key.
+     */
+    public function getEncryptionKey(): string {
+        return $this->encryptionKey;
+    }
+
+    /**
+     * Returns whether the SQLite database should be opened read-only.
+     *
+     * @return bool true if the database should be opened read-only, false if not.
+     */
+    public function shouldReadOnly(): bool {
+        return $this->readOnly;
+    }
+
+    /**
+     * Returns whether the SQLite database should be created if it does not exist.
+     *
+     * @return bool true if the database should be created, false if not.
+     */
+    public function shouldCreate(): bool {
+        return $this->create;
+    }
+
+    /**
+     * Creates a connection info instance with a path.
+     *
+     * @param string $path Path to the SQLite database.
+     * @param string $encryptionKey Key to encrypt the database with.
+     * @param bool $readOnly Set to true if the database should be opened read-only.
+     * @param bool $create Set to true to create the database if it does not exist.
+     * @return SQLiteConnectionInfo Information to create an SQLite database client.
+     */
+    public static function createPath(
+        string $path,
+        string $encryptionKey = '',
+        bool $readOnly = false,
+        bool $create = true
+    ): SQLiteConnectionInfo {
+        return new SQLiteConnectionInfo(
+            $path,
+            $encryptionKey,
+            $readOnly,
+            $create
+        );
+    }
+
+    /**
+     * Creates a connection info instance for an in-memory database.
+     *
+     * @param string $encryptionKey Key to encrypt the database with.
+     * @return SQLiteConnectionInfo Information to create an SQLite database client.
+     */
+    public static function createMemory(string $encryptionKey = ''): SQLiteConnectionInfo {
+        return new SQLiteConnectionInfo(':memory:', $encryptionKey, false, true);
+    }
+
+    /**
+     * Creates a connection info instance for a database stored in a temporary file.
+     *
+     * @param string $encryptionKey Key to encrypt the database with.
+     * @return SQLiteConnectionInfo Information to create an SQLite database client.
+     */
+    public static function createTemp(string $encryptionKey = ''): SQLiteConnectionInfo {
+        return new SQLiteConnectionInfo('', $encryptionKey, false, true);
+    }
+}
diff --git a/src/Data/SQLite/SQLiteResult.php b/src/Data/SQLite/SQLiteResult.php
new file mode 100644
index 0000000..2704544
--- /dev/null
+++ b/src/Data/SQLite/SQLiteResult.php
@@ -0,0 +1,89 @@
+<?php
+// SQLiteResult.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data\SQLite;
+
+use SQLite3Result;
+use InvalidArgumentException;
+use Index\AString;
+use Index\WString;
+use Index\Data\IDbResult;
+use Index\IO\Stream;
+use Index\IO\TempFileStream;
+
+/**
+ * Represents an SQLite result set.
+ */
+class SQLiteResult implements IDbResult {
+    private SQLite3Result $result;
+    private array $currentRow = [];
+
+    /**
+     * Creates a new instance of SQLiteResult.
+     *
+     * @param SQLite3Result $result Raw underlying result class.
+     * @return SQLiteResult A new SQLiteResult instance.
+     */
+    public function __construct(SQLite3Result $result) {
+        $this->result = $result;
+    }
+
+    /**
+     * Gets the number of columns per row in the result.
+     *
+     * @return int|string Number of columns in a row.
+     */
+    public function getFieldCount(): int|string {
+        return $this->result->numColumns();
+    }
+
+    public function next(): bool {
+        $result = $this->result->fetchArray(SQLITE3_BOTH);
+        if($result === false)
+            return false;
+        $this->currentRow = $result;
+        return true;
+    }
+
+    public function isNull(int|string $index): bool {
+        return array_key_exists($index, $this->currentRow) && $this->currentRow[$index] === null;
+    }
+
+    public function getValue(int|string $index): mixed {
+        return $this->currentRow[$index] ?? null;
+    }
+
+    public function getString(int|string $index): string {
+        return strval($this->getValue($index));
+    }
+
+    public function getAString(int|string $index): AString {
+        return new AString($this->getString($index));
+    }
+
+    public function getWString(int|string $index, string $encoding): WString {
+        return new WString($this->getString($index), $encoding);
+    }
+
+    public function getInteger(int|string $index): int {
+        return intval($this->getValue($index));
+    }
+
+    public function getFloat(int|string $index): float {
+        return floatval($this->getValue($index));
+    }
+
+    /**
+     * Gets the value from the target index as a Stream.
+     * If you're aware that you're using SQLite it may make more sense to use SQLiteConnection::getBlobStream instead.
+     */
+    public function getStream(int|string $index): ?Stream {
+        if($this->isNull($index))
+            return null;
+        return new TempFileStream($this->getValue($index));
+    }
+
+    public function close(): void {}
+}
diff --git a/src/Data/SQLite/SQLiteStatement.php b/src/Data/SQLite/SQLiteStatement.php
new file mode 100644
index 0000000..f132efc
--- /dev/null
+++ b/src/Data/SQLite/SQLiteStatement.php
@@ -0,0 +1,100 @@
+<?php
+// SQLiteStatement.php
+// Created: 2021-05-02
+// Updated: 2022-02-16
+
+namespace Index\Data\SQLite;
+
+use SQLite3Result;
+use SQLite3Stmt;
+use InvalidArgumentException;
+use RuntimeException;
+use Index\Data\DbTools;
+use Index\Data\DbType;
+use Index\Data\QueryExecuteException;
+use Index\Data\IDbStatement;
+use Index\Data\IDbResult;
+use Index\IO\Stream;
+
+/**
+ * Represents a prepared SQLite SQL statement.
+ */
+class SQLiteStatement implements IDbStatement {
+    private SQLiteConnection $connection;
+    private SQLite3Stmt $statement;
+    private ?SQLite3Result $result = null;
+
+    /**
+     * Creates a new SQLiteStatement instance.
+     *
+     * @param SQLiteConnection $connection A reference to the connection which creates this statement.
+     * @param SQLite3Stmt $statement The raw statement instance.
+     * @return SQLiteStatement A new statement instance.
+     */
+    public function __construct(SQLiteConnection $connection, SQLite3Stmt $statement) {
+        $this->connection = $connection;
+        $this->statement = $statement;
+    }
+
+    public function getParameterCount(): int {
+        return $this->statement->paramCount();
+    }
+
+    public function addParameter(int $ordinal, mixed $value, int $type = DbType::AUTO): void {
+        if($ordinal < 1 || $ordinal > $this->getParameterCount())
+            throw new InvalidArgumentException('$ordinal is not a valid parameter number.');
+        if($type === DbType::AUTO)
+            $type = DbTools::detectType($value);
+
+        switch($type) {
+            case DbType::NULL:
+                $value = null;
+                $type = SQLITE3_NULL;
+                break;
+            case DbType::INTEGER:
+                $type = SQLITE3_INTEGER;
+                break;
+            case DbType::FLOAT:
+                $type = SQLITE3_FLOAT;
+                break;
+            case DbType::STRING:
+                $type = SQLITE3_TEXT;
+                break;
+            case DbType::BLOB:
+                $type = SQLITE3_BLOB;
+                break;
+            default:
+                throw new InvalidArgumentException('$type is not a supported type.');
+        }
+
+        if(!$this->statement->bindValue($ordinal, $value, $type))
+            throw new QueryExecuteException((string)$this->connection->getLastErrorString(), $this->connection->getLastErrorCode());
+    }
+
+    public function getResult(): IDbResult {
+        if($this->result === null)
+            throw new RuntimeException('No result is available.');
+        return new SQLiteResult($this->result);
+    }
+
+    public function getLastInsertId(): int|string {
+        return $this->connection->getLastInsertId();
+    }
+
+    public function execute(): void {
+        $result = $this->statement->execute();
+        if($result === false)
+            throw new QueryExecuteException((string)$this->connection->getLastErrorString(), $this->connection->getLastErrorCode());
+        $this->result = $result;
+    }
+
+    public function reset(): void {
+        $this->result = null;
+        if(!$this->statement->clear())
+            throw new QueryExecuteException((string)$this->connection->getLastErrorString(), $this->connection->getLastErrorCode());
+        if(!$this->statement->reset())
+            throw new QueryExecuteException((string)$this->connection->getLastErrorString(), $this->connection->getLastErrorCode());
+    }
+
+    public function close(): void {}
+}
diff --git a/src/Data/SavePointFailedException.php b/src/Data/SavePointFailedException.php
new file mode 100644
index 0000000..5b6b630
--- /dev/null
+++ b/src/Data/SavePointFailedException.php
@@ -0,0 +1,11 @@
+<?php
+// SavePointFailedException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception to be thrown when save point creation fails.
+ */
+class SavePointFailedException extends TransactionException {}
diff --git a/src/Data/TransactionException.php b/src/Data/TransactionException.php
new file mode 100644
index 0000000..6cd2da1
--- /dev/null
+++ b/src/Data/TransactionException.php
@@ -0,0 +1,11 @@
+<?php
+// TransactionException.php
+// Created: 2021-05-02
+// Updated: 2021-05-12
+
+namespace Index\Data;
+
+/**
+ * Exception for errors during transactions.
+ */
+class TransactionException extends DataException {}
diff --git a/src/DateTime.php b/src/DateTime.php
new file mode 100644
index 0000000..bfb7c75
--- /dev/null
+++ b/src/DateTime.php
@@ -0,0 +1,667 @@
+<?php
+// DateTime.php
+// Created: 2021-06-11
+// Updated: 2022-02-27
+
+namespace Index;
+
+use DateInterval;
+use DateTimeImmutable;
+use DateTimeInterface;
+use DateTimeZone;
+use InvalidArgumentException;
+use JsonSerializable;
+use RuntimeException;
+use Stringable;
+
+/**
+ * Represents a date and time
+ */
+class DateTime extends DateTimeImmutable implements JsonSerializable, Stringable, IComparable, IEquatable {
+    /**
+     * Represents Sunday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const SUNDAY = 0;
+
+    /**
+     * Represents Monday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const MONDAY = 1;
+
+    /**
+     * Represents Tuesday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const TUESDAY = 2;
+
+    /**
+     * Represents Wednesday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const WEDNESDAY = 3;
+
+    /**
+     * Represents Thursday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const THURSDAY = 4;
+
+    /**
+     * Represents Friday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const FRIDAY = 5;
+
+    /**
+     * Represents Saturday for getDayOfWeek.
+     *
+     * @var int
+     */
+    public const SATURDAY = 6;
+
+    private const COMPARE = 'YmdHisu';
+
+    /**
+     * Creates a new DateTime object.
+     *
+     * @see https://www.php.net/manual/en/datetime.formats.php
+     * @param string $dateTime A date/time string.
+     * @param DateTimeZone|null $timeZone An object representing the desired time zone.
+     * @return DateTime A new DateTime instance.
+     */
+    public function __construct(string $dateTime = 'now', DateTimeZone|null $timeZone = null) {
+        parent::__construct($dateTime, $timeZone);
+    }
+
+    /**
+     * Gets the date component of this instance.
+     *
+     * @return DateTime New instance with the same date but the time set to 00:00:00.
+     */
+    public function getDate(): DateTime {
+        return self::create($this->getYear(), $this->getMonth(), $this->getDay(), 0, 0, 0, 0, $this->getTimezone());
+    }
+
+    /**
+     * Gets the year component of this instance.
+     *
+     * @return int Year component.
+     */
+    public function getYear(): int {
+        return (int)$this->format('Y');
+    }
+
+    /**
+     * Gets the month component of this instance.
+     *
+     * @return int Month component, ranging from 1 to 12.
+     */
+    public function getMonth(): int {
+        return (int)$this->format('n');
+    }
+
+    /**
+     * Gets the day component of this instance.
+     *
+     * @return int Day component, ranging from 1 to 31.
+     */
+    public function getDay(): int {
+        return (int)$this->format('j');
+    }
+
+    /**
+     * Gets the day of the week represented by this instance.
+     *
+     * See the SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY and SATURDAY constants for the possible return values of this function.
+     *
+     * @return int Integer between 0 and 6 representing the day of the week.
+     */
+    public function getDayOfWeek(): int {
+        return (int)$this->format('w');
+    }
+
+    /**
+     * Gets the day of the year represented by this instance.
+     *
+     * @return int Day of the year, ranging from 1-366.
+     */
+    public function getDayOfYear(): int {
+        return ((int)$this->format('z')) + 1;
+    }
+
+    /**
+     * Gets the ISO8601 week number of this instance.
+     *
+     * @return int Integer representing the current week number.
+     */
+    public function getWeek(): int {
+        return (int)$this->format('W');
+    }
+
+    /**
+     * Gets the time of day for this instance.
+     *
+     * @return TimeSpan A TimeSpan representing the amount of time elapsed since midnight.
+     */
+    public function getTimeOfDay(): TimeSpan {
+        return TimeSpan::create(0, $this->getHour(), $this->getMinute(), $this->getSecond(), $this->getMicrosecond());
+    }
+
+    /**
+     * Gets the hour component of this instance.
+     *
+     * @return int Hour component, ranging from 0 to 23.
+     */
+    public function getHour(): int {
+        return (int)$this->format('G');
+    }
+
+    /**
+     * Gets the minute component of this instance.
+     *
+     * @return int Minute component, ranging from 0 to 59.
+     */
+    public function getMinute(): int {
+        return (int)$this->format('i');
+    }
+
+    /**
+     * Gets the second component of this instance.
+     *
+     * @return int Second component, ranging from 0 to 59.
+     */
+    public function getSecond(): int {
+        return (int)$this->format('s');
+    }
+
+    /**
+     * Gets the millisecond component of this instance.
+     *
+     * @return int Millisecond component, ranging from 0 to 999.
+     */
+    public function getMillisecond(): int {
+        return (int)$this->format('v');
+    }
+
+    /**
+     * Gets the microsecond component of this instance.
+     *
+     * @return int Microsecond component, ranging from 0 to 999999.
+     */
+    public function getMicrosecond(): int {
+        return (int)$this->format('u');
+    }
+
+    /**
+     * Gets the number of seconds that have elapsed since midnight January 1st, 1970 UTC for this instance.
+     *
+     * @return int Number of seconds.
+     */
+    public function getUnixTimeSeconds(): int {
+        return (int)$this->format('U');
+    }
+
+    /**
+     * Gets the number of milliseconds that have elapsed since midnight January 1st, 1970 UTC for this instance.
+     *
+     * @return float Number of milliseconds.
+     */
+    public function getUnixTimeMilliseconds(): float {
+        return (float)$this->format('Uv');
+    }
+
+    /**
+     * Gets whether Daylight Savings is in effect during the time this instance represents.
+     *
+     * @return bool true if DST is in effect, false if not.
+     */
+    public function isDaylightSavingTime(): bool {
+        return $this->format('I') !== '0';
+    }
+
+    /**
+     * Gets whether the year this instance represents is a leap year.
+     *
+     * @return bool true if the year is a leap year, false if not.
+     */
+    public function isLeapYear(): bool {
+        return $this->format('L') !== '0';
+    }
+
+    /**
+     * Gets whether this DateTime uses UTC date/time.
+     *
+     * @return bool true if UTC, false if not.
+     */
+    public function isUTC(): bool {
+        return $this->getTimezone()->equals(TimeZoneInfo::utc());
+    }
+
+    /**
+     * Gets the time zone for this instance.
+     *
+     * @return TimeZoneInfo Time zone for this instance.
+     */
+    public function getTimezone(): TimeZoneInfo {
+        return TimeZoneInfo::cast(parent::getTimezone());
+    }
+
+    /**
+     * Adds a period of time to this date time object.
+     *
+     * @param DateInterval $timeSpan Time period to add to this DateTime.
+     * @return DateTime A DateTime instance which is the sum of this instance and the provided period.
+     */
+    public function add(DateInterval $timeSpan): DateTime {
+        return self::cast(parent::add($timeSpan));
+    }
+
+    /**
+     * Adds a number of years to this instance.
+     *
+     * @param float $years Number of years to add.
+     * @return DateTime New DateTime instance with the years added.
+     */
+    public function addYears(float $years): DateTime {
+        return $this->add(TimeSpan::fromDays(365 * $years));
+    }
+
+    /**
+     * Adds a number of months to this instance.
+     *
+     * @param float $months Number of months to add.
+     * @return DateTime New DateTime instance with the months added.
+     */
+    public function addMonths(float $months): DateTime {
+        return $this->add(TimeSpan::fromDays(365 * 31 * $months));
+    }
+
+    /**
+     * Adds a number of days to this instance.
+     *
+     * @param float $days Number of days to add.
+     * @return DateTime New DateTime instance with the days added.
+     */
+    public function addDays(float $days): DateTime {
+        return $this->add(TimeSpan::fromDays($days));
+    }
+
+    /**
+     * Adds a number of hours to this instance.
+     *
+     * @param float $hours Number of hours to add.
+     * @return DateTime New DateTime instance with the hours added.
+     */
+    public function addHours(float $hours): DateTime {
+        return $this->add(TimeSpan::fromHours($hours));
+    }
+
+    /**
+     * Adds a number of minutes to this instance.
+     *
+     * @param float $minutes Number of minutes to add.
+     * @return DateTime New DateTime instance with the minutes added.
+     */
+    public function addMinutes(float $minutes): DateTime {
+        return $this->add(TimeSpan::fromMinutes($minutes));
+    }
+
+    /**
+     * Adds a number of seconds to this instance.
+     *
+     * @param float $seconds Number of seconds to add.
+     * @return DateTime New DateTime instance with the seconds added.
+     */
+    public function addSeconds(float $seconds): DateTime {
+        return $this->add(TimeSpan::fromSeconds($seconds));
+    }
+
+    /**
+     * Adds a number of milliseconds to this instance.
+     *
+     * @param float $millis Number of milliseconds to add.
+     * @return DateTime New DateTime instance with the milliseconds added.
+     */
+    public function addMilliseconds(float $millis): DateTime {
+        return $this->add(TimeSpan::fromMilliseconds($millis));
+    }
+
+    /**
+     * Adds a number of microseconds to this instance.
+     *
+     * @param float $micros Number of microseconds to add.
+     * @return DateTime New DateTime instance with the microseconds added.
+     */
+    public function addMicroseconds(float $micros): DateTime {
+        return $this->add(TimeSpan::fromMicroseconds($micros));
+    }
+
+    /**
+     * Alias for subtract, must exist because of the DateTimeImmutable inheritance but I don't like short names.
+     *
+     * @internal
+     */
+    public function sub(DateInterval $interval): DateTime {
+        return $this->subtract($interval);
+    }
+
+    /**
+     * Subtracts a time period from this DateTime.
+     *
+     * @param DateInterval $timeSpan Time period to be subtracted.
+     * @return DateTime A new DateTime instance which is this instance minus the given time period.
+     */
+    public function subtract(DateInterval $timeSpan): DateTime {
+        return self::cast(parent::sub($timeSpan));
+    }
+
+    /**
+     * Alias for difference, must exist because of the DateTimeImmutable inheritance but I don't like short names.
+     *
+     * @internal
+     */
+    public function diff(DateTimeInterface $dateTime, bool $absolute = false): TimeSpan {
+        return $this->difference($dateTime, $absolute);
+    }
+
+    /**
+     * Subtracts another Date/Time from this DateTime.
+     *
+     * @param DateTimeInterface $dateTime Date/time to subtract.
+     * @return TimeSpan Difference between this DateTime and the provided one.
+     */
+    public function difference(DateTimeInterface $dateTime, bool $absolute = false): TimeSpan {
+        return TimeSpan::cast(parent::diff($dateTime, $absolute));
+    }
+
+    /**
+     * Applies a modifier on this instance and returns the result as a new instance.
+     *
+     * @see https://www.php.net/manual/en/datetime.formats.php
+     * @param string $modifier A date/time format.
+     * @return DateTime The modified date/time.
+     */
+    public function modify(string $modifier): DateTime {
+        return self::cast(parent::modify($modifier));
+    }
+
+    /**
+     * Creates a new DateTime with the given date component.
+     *
+     * @param int $year Desired year component.
+     * @param int $month Desired month component.
+     * @param int $day Desired day component.
+     * @return DateTime A new DateTime instance with the given date component.
+     */
+    public function setDate(int $year, int $month, int $day): DateTime {
+        return self::cast(parent::setDate($year, $month, $day));
+    }
+
+    /**
+     * Creates a new DateTime with the given ISO date for the date component.
+     *
+     * @param int $year Year of the date.
+     * @param int $week Week of the date.
+     * @param int $dayOfWeek Offset from the first of the week.
+     * @return DateTime A new DateTime instance with the given date component.
+     */
+    public function setISODate(int $year, int $week, int $dayOfWeek = 1): DateTime {
+        return self::cast(parent::setISODate($year, $week, $dayOfWeek));
+    }
+
+    /**
+     * Creates a new DateTime with the given time component.
+     *
+     * @param int $hour Desired hour component.
+     * @param int $minute Desired minute component.
+     * @param int $second Desired second component.
+     * @param int $microsecond Desired microsecond component.
+     * @return DateTime A new DateTime instance with the given time component.
+     */
+    public function setTime(int $hour, int $minute, int $second = 0, int $microsecond = 0): DateTime {
+        return self::cast(parent::setTime($hour, $minute, $second, $microsecond));
+    }
+
+    /**
+     * Creates a new DateTime with the date and time components based on a Unix timestamp.
+     *
+     * @param int $timestamp Unix timestamp representing the date.
+     * @return DateTime A new DateTime instance with the given date and time.
+     */
+    public function setTimestamp(int $timestamp): DateTime {
+        return self::cast(parent::setTimestamp($timestamp));
+    }
+
+    /**
+     * Creates a new DateTime with the given time zone.
+     *
+     * @param DateTimeZone $timeZone An object representing the desired time zone.
+     * @return DateTime A new DateTime with the given time zone.
+     */
+    public function setTimezone(DateTimeZone $timeZone): DateTime {
+        return self::cast(parent::setTimezone($timeZone));
+    }
+
+    public function compare(mixed $other): int {
+        if($other instanceof DateTimeInterface)
+            return strcmp($this->format(self::COMPARE), $other->format(self::COMPARE));
+        return -1;
+    }
+
+    public function equals(mixed $other): bool {
+        if($other instanceof DateTimeInterface)
+            return $this->format(self::COMPARE) === $other->format(self::COMPARE);
+        return false;
+    }
+
+    public function isLessThan(DateTimeInterface $other): bool {
+        return $this->compare($other) < 0;
+    }
+
+    public function isLessThanOrEqual(DateTimeInterface $other): bool {
+        return $this->compare($other) <= 0;
+    }
+
+    public function isMoreThan(DateTimeInterface $other): bool {
+        return $this->compare($other) > 0;
+    }
+
+    public function isMoreThanOrEqual(DateTimeInterface $other): bool {
+        return $this->compare($other) >= 0;
+    }
+
+    /**
+     * Formats this DateTime as an ISO8601 date/time string.
+     *
+     * @return string This object represented as an ISO8601 date/time string.
+     */
+    public function toISO8601String(): string {
+        return $this->format(DateTimeInterface::ATOM);
+    }
+
+    /**
+     * Formats this DateTime as a Cookie date/time string.
+     *
+     * @return string This object represented as a Cookie date/time string.
+     */
+    public function toCookieString(): string {
+        return $this->format(DateTimeInterface::COOKIE);
+    }
+
+    /**
+     * Formats this DateTime as an RFC 822 date/time string.
+     *
+     * @return string This object represented as an RFC 822 date/time string.
+     */
+    public function toRFC822String(): string {
+        return $this->format(DateTimeInterface::RFC822);
+    }
+
+    /**
+     * Creates a string representation of this object.
+     *
+     * @return string Representation of this object.
+     */
+    public function __toString(): string {
+        return $this->format(DateTimeInterface::ATOM);
+    }
+
+    /**
+     * Returns the data which should be serialized as json.
+     *
+     * @see https://www.php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return mixed Data to be passed to json_encode.
+     */
+    public function jsonSerialize(): mixed {
+        return (string)$this;
+    }
+
+    /**
+     * Converts this immutable \Index\DateTime type to a mutable \DateTime type.
+     *
+     * @return \DateTime A new mutable \DateTime instance.
+     */
+    public function toNative(): \DateTime {
+        return \DateTime::createFromImmutable($this);
+    }
+
+    /**
+     * Creates a DateTime object that is set to the current date and time, expressed in the provided time zone.
+     *
+     * @param DateTimeZone $timeZone Desired time zone, null for the current default time zone.
+     * @return DateTime An instance representing now.
+     */
+    public static function now(?DateTimeZone $timeZone = null): DateTime {
+        return new DateTime('now', $timeZone);
+    }
+
+    /**
+     * Creates a DateTime object that is set to the current date and time, expressed in UTC.
+     *
+     * @return DateTime An instance representing now in UTC.
+     */
+    public static function utcNow(): DateTime {
+        return self::now(TimeZoneInfo::utc());
+    }
+
+    /**
+     * Converts Unix time seconds to a DateTime object.
+     *
+     * @param int $seconds Unix time seconds.
+     * @return DateTime A DateTime instance representing the Unix time.
+     */
+    public static function fromUnixTimeSeconds(int $seconds): DateTime {
+        return new DateTime('@' . $seconds);
+    }
+
+    /**
+     * Converts Unix time milliseconds to a DateTime object.
+     *
+     * @param float $millis Unix time milliseconds.
+     * @return DateTime A DateTime instance representing the Unix time.
+     */
+    public static function fromUnixTimeMilliseconds(float $millis): DateTime {
+        return new DateTime('@' . ($millis / 1000));
+    }
+
+    /**
+     * Creates a new DateTime instance with the given components.
+     *
+     * @param int $year Desired year component.
+     * @param int $month Desired month component.
+     * @param int $day Desired day component.
+     * @param int $hour Desired hour component.
+     * @param int $minute Desired minute component.
+     * @param int $second Desired second component.
+     * @param int $micros Desired microsecond component.
+     * @param ?DateTimeZone $timeZone Desired time zone.
+     */
+    public static function create(int $year, int $month = 1, int $day = 1, int $hour = 0, int $minute = 0, int $second = 0, int $micros = 0, ?DateTimeZone $timeZone = null): DateTime {
+        if($year < 1 || $year > 9999)
+            throw new InvalidArgumentException('$year may not be less than 1 or more than 9999.');
+        if($month < 1 || $month > 12)
+            throw new InvalidArgumentException('$month may not be less than 1 or more than 12.');
+        if($day < 1 || $day > 31)
+            throw new InvalidArgumentException('$day may not be less than 1 or more than 31.');
+        if($hour < 0 || $hour > 23)
+            throw new InvalidArgumentException('$hour may not be less than 0 or more than 23.');
+        if($minute < 0 || $minute > 59)
+            throw new InvalidArgumentException('$minute may not be less than 0 or more than 59.');
+        if($second < 0 || $second > 59)
+            throw new InvalidArgumentException('$second may not be less than 0 or more than 59.');
+        if($micros < 0 || $micros > 999999)
+            throw new InvalidArgumentException('$micros may not be less than 0 or more than 999999.');
+
+        return new DateTime(
+            sprintf(
+                '%04d-%02d-%02dT%02d:%02d:%02d.%06d',
+                $year, $month, $day, $hour, $minute, $second, $micros
+            ),
+            $timeZone
+        );
+    }
+
+    /**
+     * Parses a time string and creates a DateTime using it.
+     *
+     * @see https://www.php.net/manual/en/datetime.createfromformat
+     * @param string $format Format that the passed string should be in.
+     * @param string $dateTime String representing the time.
+     * @param ?DateTimeZone $timeZone Desired time zone.
+     * @return DateTime|false A DateTime instance, or false on failure.
+     */
+    public static function createFromFormat(string $format, string $dateTime, ?DateTimeZone $timeZone = null): DateTime|false {
+        $instance = parent::createFromFormat($format, $dateTime, $timeZone);
+        if($instance === false)
+            return false;
+        return self::cast($instance);
+    }
+
+    /**
+     * Creates a new DateTime instance from an interface implementation.
+     *
+     * @param DateTimeInterface $object Object that should be sourced.
+     * @return DateTime A new DateTime instance.
+     */
+    public static function createFromInterface(DateTimeInterface $object): DateTime {
+        return self::cast($object);
+    }
+
+    /**
+     * Creates a new immutable DateTime instance from a mutable instance.
+     *
+     * @param \DateTime $object Mutable object that should be sourced.
+     * @return DateTime New immutable DateTime representing the same value.
+     */
+    public static function createFromMutable(\DateTime $object): DateTime {
+        return self::cast($object);
+    }
+
+    /**
+     * @internal
+     */
+    public static function __set_state(array $array): DateTime {
+        return self::cast(parent::__set_state($array));
+    }
+
+    /**
+     * Makes sure a DateTimeInterface implementing object is a DateTime instance.
+     *
+     * @param DateTimeInterface $dateTime Input object.
+     * @return DateTime If the input was a DateTime, the same instance will be returned.
+     *                  If the input was something else, a new DateTime instance will be returned based on the input.
+     */
+    public static function cast(DateTimeInterface $dateTime): DateTime {
+        if($dateTime instanceof DateTime)
+            return $dateTime;
+        return new DateTime($dateTime->format('@U.u'), $dateTime->getTimezone());
+    }
+}
diff --git a/src/Environment.php b/src/Environment.php
new file mode 100644
index 0000000..ed07b27
--- /dev/null
+++ b/src/Environment.php
@@ -0,0 +1,340 @@
+<?php
+// Environment.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index;
+
+use RuntimeException;
+
+/**
+ * Provides information about the current runtime environment.
+ */
+final class Environment {
+    /**
+     * Contains the end-of-line sequence for the current platform.
+     *
+     * @var string
+     */
+    public const NEWLINE = PHP_EOL;
+
+    /**
+     * Contains the amount of bytes in an integer for this system.
+     *
+     * @var int
+     */
+    public const INT_SIZE = PHP_INT_SIZE;
+
+    private static ?Version $indexVersion = null;
+    private static ?Version $phpVersion = null;
+    private static array $phpVersions = [];
+
+    /**
+     * Checks whether the current PHP environment is running in debug mode.
+     *
+     * Essentially checks if any sort of error reporting is enabled. It shouldn't be in prod.
+     *
+     * @return bool true if the environment is in debug mode, false is not.
+     */
+    public static function isDebug(): bool {
+        return error_reporting() !== 0;
+    }
+
+    /**
+     * Toggles debug mode.
+     *
+     * Essentially turns all error reporting on or off.
+     *
+     * @param bool $debug true if debug mode should be enabled, false if it should be disabled.
+     */
+    public static function setDebug(bool $debug = false): void {
+        if($debug) {
+            ini_set('display_errors', 'on');
+            error_reporting(-1);
+        } else {
+            ini_set('display_errors', 'off');
+            error_reporting(0);
+        }
+    }
+
+    /**
+     * Reads an environment variable.
+     *
+     * @param string $name Name of the environment variable.
+     * @param bool $localOnly true if only variables local to the application should be read,
+     *                        false if greater level operating system variables should be included.
+     * @return ?string null if the variable doesn't exist, otherwise a string of the value.
+     */
+    public static function getVariable(string $name, bool $localOnly = true): ?string {
+        return ($value = getenv($name, $localOnly)) === false ? null : $value;
+    }
+
+    /**
+     * Writes an application-local environment variable.
+     *
+     * @param string $name Name of the environment variable.
+     * @param mixed $value Value that should be assigned to the environment variable. Will be cast to a string.
+     */
+    public static function setVariable(string $name, mixed $value): void {
+        putenv($name . '=' . ((string)$value));
+    }
+
+    /**
+     * Removes an application-local environment variable.
+     *
+     * @param string $name Name of the environment variable.
+     */
+    public static function removeVariable(string $name): void {
+        putenv($name);
+    }
+
+    /**
+     * Gets the current version of the Index library.
+     *
+     * Parses the VERSION in the root of the Index directory.
+     *
+     * @return Version A Version instance representing the version of the Index Library.
+     */
+    public static function getIndexVersion(): Version {
+        if(self::$indexVersion === null)
+            self::$indexVersion = Version::parse(trim(file_get_contents(NDX_ROOT . DIRECTORY_SEPARATOR . 'VERSION')));
+        return self::$indexVersion;
+    }
+
+    /**
+     * Gets the version of the PHP installation Index is running on.
+     *
+     * @return Version A Version instance representing the version of PHP.
+     */
+    public static function getPHPVersion(): Version {
+        if(self::$phpVersion === null)
+            self::$phpVersion = new Version(PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION);
+        return self::$phpVersion;
+    }
+
+    /**
+     * Gets the version of a PHP extension.
+     *
+     * @param string $extension Name of the extension.
+     * @return ?Version null if the extension is not installed, otherwise an instance of Version representing the version of the extension.
+     */
+    public static function getPHPExtensionVersion(string $extension): ?Version {
+        if(!isset(self::$phpVersions[$extension])) {
+            $rawVersion = phpversion($extension);
+            self::$phpVersions[$extension] = empty($rawVersion) ? Version::empty() : Version::parse($rawVersion);
+        }
+        return self::$phpVersions[$extension];
+    }
+
+    /**
+     * Gets the name of the Operating System PHP is running on.
+     *
+     * @return string Name of the Operating System.
+     */
+    public static function getOSName(): string {
+        static $value = null;
+        $value ??= php_uname('s');
+        return $value;
+    }
+
+    /**
+     * Checks if we're running on Windows.
+     *
+     * @return bool true if we're running on Windows, otherwise false.
+     */
+    public static function isWindows(): bool {
+        return self::isWindowsNT()
+            || self::getOSName() === 'Windows';
+    }
+
+    /**
+     * Checks if we're running on Windows NT.
+     *
+     * @return bool true if we're running on Windows NT, otherwise false.
+     */
+    public static function isWindowsNT(): bool {
+        return ($os = self::getOSName()) === 'Windows NT'
+            || $os === 'Windows_NT'
+            || $os === 'WindowsNT';
+    }
+
+    /**
+     * Checks if we're running on a Unix-like Operating System.
+     *
+     * @return bool true if we're running on a Unix-like Operating System, otherwise false.
+     */
+    public static function isUnixLike(): bool {
+        return self::isLinux()
+            || self::isBSD()
+            || self::isMacOS()
+            || self::isSolaris();
+    }
+
+    /**
+     * Checks if we're running on a BSD derivative.
+     *
+     * @return bool true if we're running on a BSD derivative, otherwise false.
+     */
+    public static function isBSD(): bool {
+        return self::isOpenBSD()
+            || self::isFreeBSD()
+            || self::isNetBSD()
+            || self::isDragonFlyBSD()
+            || self::getOSName() === 'BSD';
+    }
+
+    /**
+     * Checks if we're running on OpenBSD.
+     *
+     * @return bool true if we're running on OpenBSD, otherwise false.
+     */
+    public static function isOpenBSD(): bool {
+        return self::getOSName() === 'OpenBSD';
+    }
+
+    /**
+     * Checks if we're running on FreeBSD.
+     *
+     * @return bool true if we're running on FreeBSD, otherwise false.
+     */
+    public static function isFreeBSD(): bool {
+        return self::getOSName() === 'FreeBSD';
+    }
+
+    /**
+     * Checks if we're running on NetBSD.
+     *
+     * @return bool true if we're running on NetBSD, otherwise false.
+     */
+    public static function isNetBSD(): bool {
+        return self::getOSName() === 'NetBSD';
+    }
+
+    /**
+     * Checks if we're running on DragonFly BSD.
+     *
+     * @return bool true if we're running on DragonFly BSD, otherwise false.
+     */
+    public static function isDragonFlyBSD(): bool {
+        return self::getOSName() === 'DragonFly';
+    }
+
+    /**
+     * Checks if we're running on macOS.
+     *
+     * @return bool true if we're running on macOS, otherwise false.
+     */
+    public static function isMacOS(): bool {
+        return self::getOSName() === 'Darwin';
+    }
+
+    /**
+     * Checks if we're running on Solaris.
+     *
+     * @return bool true if we're running on Solaris, otherwise false.
+     */
+    public static function isSolaris(): bool {
+        return self::getOSName() === 'SunOS';
+    }
+
+    /**
+     * Checks if we're running on Linux.
+     *
+     * @return bool true if we're running on Linux, otherwise false.
+     */
+    public static function isLinux(): bool {
+        return self::getOSName() === 'Linux';
+    }
+
+    /**
+     * Returns the name of the SAPI PHP is currently running through.
+     *
+     * @return string Name of the SAPI.
+     */
+    public static function getSAPIName(): string {
+        static $sapi = null;
+        $sapi ??= php_sapi_name();
+        return $sapi;
+    }
+
+    /**
+     * Checks if we're running through Apache2Handler.
+     *
+     * @return bool true if we're running through Apache2Handler, otherwise false.
+     */
+    public static function isApache2(): bool {
+        return ($sapi = self::getSAPIName()) === 'apache' || $sapi === 'apache2handler';
+    }
+
+    /**
+     * Checks if we're running through CGI.
+     *
+     * @return bool true if we're running through CGI, otherwise false.
+     */
+    public static function isCGI(): bool {
+        return self::getSAPIName() === 'cgi';
+    }
+
+    /**
+     * Checks if we're running through FastCGI (and/or php-fpm).
+     *
+     * @return bool true if we're running through FastCGI, otherwise false.
+     */
+    public static function isFastCGI(): bool {
+        return ($sapi = self::getSAPIName()) === 'cgi-fcgi' || $sapi === 'fpm-fcgi';
+    }
+
+    /**
+     * Checks if we're running through console.
+     *
+     * @return bool true if we're running through console, otherwise false.
+     */
+    public static function isConsole(): bool {
+        return self::getSAPIName() === 'cli';
+    }
+
+    /**
+     * Checks if we're running through the built-in development server.
+     *
+     * @return bool true if we're running through the built-in development server, otherwise false.
+     */
+    public static function isDebugServer(): bool {
+        return self::getSAPIName() === 'cli-server';
+    }
+
+    /**
+     * Checks if we're running through LiteSpeed.
+     *
+     * @return bool true if we're running through LiteSpeed, otherwise false.
+     */
+    public static function isLiteSpeed(): bool {
+        return self::getSAPIName() === 'litespeed';
+    }
+
+    /**
+     * Checks if we're running through PHPDBG.
+     *
+     * @return bool true if we're running through PHPDBG, otherwise false.
+     */
+    public static function isPHPDebugger(): bool {
+        return self::getSAPIName() === 'phpdbg';
+    }
+
+    /**
+     * Checks if we're running on a 32-bit system.
+     *
+     * @return bool true if we're on 32-bit, false if not.
+     */
+    public static function is32Bit(): bool {
+        return PHP_INT_SIZE === 4;
+    }
+
+    /**
+     * Checks if we're running on a 64-bit system.
+     *
+     * @return bool true if we're on 64-bit, false if not.
+     */
+    public static function is64Bit(): bool {
+        return PHP_INT_SIZE === 8;
+    }
+}
diff --git a/src/Exceptions.php b/src/Exceptions.php
new file mode 100644
index 0000000..c05c14d
--- /dev/null
+++ b/src/Exceptions.php
@@ -0,0 +1,79 @@
+<?php
+// Exceptions.php
+// Created: 2021-04-30
+// Updated: 2021-05-12
+
+namespace Index;
+
+use ErrorException;
+use Throwable;
+
+/**
+ * Provides handling for uncaught exceptions and errors.
+ */
+final class Exceptions {
+    /**
+     * Convert errors to ErrorExceptions.
+     *
+     * Automatically invoked by inclusion of index.php into your project unless the constant <code>NDX_LEAVE_ERRORS</code> is defined beforehand.
+     * This is not recommended as it may cause undefined behaviour in some classes.
+     * This will also make error suppression not work, luckily you've not been using that since PHP 5. Right? Right?!
+     * Besides, this makes it possible to try..catch errors.
+     */
+    public static function convertErrors(): void {
+        self::restoreErrors();
+        set_error_handler([self::class, 'handleError'], -1);
+    }
+
+    /**
+     * Restores error handling to the default PHP state.
+     */
+    public static function restoreErrors(): void {
+        restore_error_handler();
+    }
+
+    /**
+     * Handle uncaught exceptions.
+     *
+     * Automatically invoked by inclusion of index.php into your project unless the constant <code>NDX_LEAVE_EXCEPTIONS</code> is defined.
+     */
+    public static function handleExceptions(): void {
+        self::restoreExceptions();
+        //set_exception_handler([self::class, 'handleException']);
+    }
+
+    /**
+     * Restores uncaught exception handling to the default PHP state.
+     */
+    public static function restoreExceptions(): void {
+        restore_exception_handler();
+    }
+
+    /**
+     * Converts errors to ErrorExceptions.
+     *
+     * Paramater documentation is copied from the set_error_handler page on php.net
+     *
+     * @see https://www.php.net/manual/en/function.set-error-handler.php
+     * @param int $errno The first parameter, errno, will be passed the level of the error raised, as an integer.
+     * @param string $errstr The second parameter, errstr, will be passed the error message, as a string.
+     * @param string $errfile If the callback accepts a third parameter, errfile, it will be passed the filename that the error was raised in, as a string.
+     * @param int $errline If the callback accepts a fourth parameter, errline, it will be passed the line number where the error was raised, as an integer.
+     * @throws ErrorException An ErrorException with the provided parameters.
+     * @return bool if this were false the PHP error handler would continue, but returning is never reached.
+     */
+    public static function handleError(int $errno, string $errstr, string $errfile, int $errline): bool {
+        throw new ErrorException($errstr, 0, $errno, $errfile, $errline);
+    }
+
+    /**
+     * Handles uncaught exceptions.
+     *
+     * @see https://www.php.net/manual/en/function.set-exception-handler.php
+     * @param ?Throwable $ex Uncaught Throwable to handle. May be null to reset state(?) apparently.
+     */
+    public static function handleException(?Throwable $ex): void {
+        if($ex === null)
+            return;
+    }
+}
diff --git a/src/Http/Content/BencodedContent.php b/src/Http/Content/BencodedContent.php
new file mode 100644
index 0000000..52dfa44
--- /dev/null
+++ b/src/Http/Content/BencodedContent.php
@@ -0,0 +1,48 @@
+<?php
+// BencodedContent.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index\Http\Content;
+
+use Stringable;
+use Index\IO\Stream;
+use Index\IO\FileStream;
+use Index\Serialisation\Serialiser;
+use Index\Serialisation\IBencodeSerialisable;
+
+class BencodedContent implements Stringable, IHttpContent, IBencodeSerialisable {
+    private mixed $content;
+
+    public function __construct(mixed $content) {
+        $this->content = $content;
+    }
+
+    public function getContent(): mixed {
+        return $this->content;
+    }
+
+    public function bencodeSerialise(): mixed {
+        return $this->content;
+    }
+
+    public function encode(): string {
+        return Serialiser::bencode()->serialise($this->content);
+    }
+
+    public function __toString(): string {
+        return $this->encode();
+    }
+
+    public static function fromEncoded(Stream|string $encoded): BencodedContent {
+        return new BencodedContent(Serialiser::bencode()->deserialise($encoded));
+    }
+
+    public static function fromFile(string $path): BencodedContent {
+        return self::fromEncoded(FileStream::openRead($path));
+    }
+
+    public static function fromRequest(): BencodedContent {
+        return self::fromFile('php://input');
+    }
+}
diff --git a/src/Http/Content/FormContent.php b/src/Http/Content/FormContent.php
new file mode 100644
index 0000000..3305180
--- /dev/null
+++ b/src/Http/Content/FormContent.php
@@ -0,0 +1,54 @@
+<?php
+// FormContent.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index\Http\Content;
+
+use RuntimeException;
+use Index\Http\HttpUploadedFile;
+
+class FormContent implements IHttpContent {
+    private array $postFields;
+    private array $uploadedFiles;
+
+    public function __construct(array $postFields, array $uploadedFiles) {
+        $this->postFields = $postFields;
+        $this->uploadedFiles = $uploadedFiles;
+    }
+
+    public function getParam(string $name, int $filter = FILTER_DEFAULT, array|int $options = 0): mixed {
+        if(!isset($this->postFields[$name]))
+            return null;
+        return filter_var($this->postFields[$name] ?? null, $filter, $options);
+    }
+
+    public function hasParam(string $name): bool {
+        return isset($this->postFields[$name]);
+    }
+
+    public function getParams(): array {
+        return $this->postFields;
+    }
+
+    public function getUploadedFile(string $name): HttpUploadedFile {
+        if(!isset($this->uploadedFiles[$name]))
+            throw new RuntimeException('No file with name $name present.');
+        return $this->uploadedFiles[$name];
+    }
+
+    public static function fromRaw(array $post, array $files): FormContent {
+        return new FormContent(
+            $post,
+            HttpUploadedFile::createFromFILES($files)
+        );
+    }
+
+    public static function fromRequest(): FormContent {
+        return self::fromRaw($_POST, $_FILES);
+    }
+
+    public function __toString(): string {
+        return '';
+    }
+}
diff --git a/src/Http/Content/IHttpContent.php b/src/Http/Content/IHttpContent.php
new file mode 100644
index 0000000..c48cd8a
--- /dev/null
+++ b/src/Http/Content/IHttpContent.php
@@ -0,0 +1,11 @@
+<?php
+// IHttpContent.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http\Content;
+
+use Stringable;
+
+interface IHttpContent extends Stringable {
+}
diff --git a/src/Http/Content/JsonContent.php b/src/Http/Content/JsonContent.php
new file mode 100644
index 0000000..e2658f7
--- /dev/null
+++ b/src/Http/Content/JsonContent.php
@@ -0,0 +1,48 @@
+<?php
+// JsonContent.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index\Http\Content;
+
+use JsonSerializable;
+use Stringable;
+use Index\IO\Stream;
+use Index\IO\FileStream;
+use Index\Serialisation\Serialiser;
+
+class JsonContent implements Stringable, IHttpContent, JsonSerializable {
+    private mixed $content;
+
+    public function __construct(mixed $content) {
+        $this->content = $content;
+    }
+
+    public function getContent(): mixed {
+        return $this->content;
+    }
+
+    public function jsonSerialize(): mixed {
+        return $this->content;
+    }
+
+    public function encode(): string {
+        return Serialiser::json()->serialise($this->content);
+    }
+
+    public function __toString(): string {
+        return $this->encode();
+    }
+
+    public static function fromEncoded(Stream|string $encoded): JsonContent {
+        return new JsonContent(Serialiser::json()->deserialise($encoded));
+    }
+
+    public static function fromFile(string $path): JsonContent {
+        return self::fromEncoded(FileStream::openRead($path));
+    }
+
+    public static function fromRequest(): JsonContent {
+        return self::fromFile('php://input');
+    }
+}
diff --git a/src/Http/Content/StreamContent.php b/src/Http/Content/StreamContent.php
new file mode 100644
index 0000000..2dff0fe
--- /dev/null
+++ b/src/Http/Content/StreamContent.php
@@ -0,0 +1,36 @@
+<?php
+// StreamContent.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index\Http\Content;
+
+use Stringable;
+use Index\IO\Stream;
+use Index\IO\FileStream;
+
+class StreamContent implements Stringable, IHttpContent {
+    private Stream $stream;
+
+    public function __construct(Stream $stream) {
+        $this->stream = $stream;
+    }
+
+    public function getStream(): Stream {
+        return $this->stream;
+    }
+
+    public function __toString(): string {
+        return (string)$this->stream;
+    }
+
+    public static function fromFile(string $path): StreamContent {
+        return new StreamContent(
+            FileStream::openRead($path)
+        );
+    }
+
+    public static function fromRequest(): StreamContent {
+        return self::fromFile('php://input');
+    }
+}
diff --git a/src/Http/Content/StringContent.php b/src/Http/Content/StringContent.php
new file mode 100644
index 0000000..aed1bcf
--- /dev/null
+++ b/src/Http/Content/StringContent.php
@@ -0,0 +1,36 @@
+<?php
+// StringContent.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index\Http\Content;
+
+use Stringable;
+
+class StringContent implements Stringable, IHttpContent {
+    private string $string;
+
+    public function __construct(string $string) {
+        $this->string = $string;
+    }
+
+    public function getString(): string {
+        return $this->string;
+    }
+
+    public function __toString(): string {
+        return $this->string;
+    }
+
+    public static function fromObject(string $string): StringContent {
+        return new StringContent($string);
+    }
+
+    public static function fromFile(string $path): StringContent {
+        return new StringContent(file_get_contents($path));
+    }
+
+    public static function fromRequest(): StringContent {
+        return self::fromFile('php://input');
+    }
+}
diff --git a/src/Http/Headers/AcceptEncodingHeader.php b/src/Http/Headers/AcceptEncodingHeader.php
new file mode 100644
index 0000000..d879de3
--- /dev/null
+++ b/src/Http/Headers/AcceptEncodingHeader.php
@@ -0,0 +1,71 @@
+<?php
+// AcceptEncodingHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use stdClass;
+use InvalidArgumentException;
+
+class AcceptEncodingHeader {
+    private array $encodings;
+    private array $rejects;
+
+    public function __construct(array $encodings, array $rejects) {
+        $this->encodings = $encodings;
+        $this->rejects = $rejects;
+    }
+
+    public function getEncodings(): array {
+        return $this->encodings;
+    }
+
+    public function getRejects(): array {
+        return $this->rejects;
+    }
+
+    public function accepts(string $algoName): int {
+        $algoName = strtolower($algoName);
+        foreach($this->encodings as $algo)
+            if($algo->quality !== 0 && ($algo->name === $algoName || $algo->name === '*'))
+                return $algo->quality;
+
+        return 0;
+    }
+
+    public function rejects(string $locale): bool {
+        return in_array(strtolower($locale), $this->rejects)
+            || in_array('*', $this->rejects);
+    }
+
+    public static function parse(array $lines): AcceptEncodingHeader {
+        $parts = explode(',', (string)$lines[0]);
+        $algos = [];
+        $rejects = [];
+
+        foreach($parts as $part)
+            try {
+                $part = explode(';', $part);
+                $algo = new stdClass;
+                $algo->name = strtolower(trim(array_shift($part)));
+                $algo->quality = 1;
+
+                foreach($part as $param) {
+                    if(substr($param, 0, 2) === 'q=') {
+                        $algo->quality = min(0, max(1, floatval(substr($param, 2))));
+                        break;
+                    }
+                }
+
+                $algos[] = $algo;
+                if($algo->quality === 0)
+                    $rejects[] = $algo->name;
+            } catch(InvalidArgumentException $ex) {}
+
+        if(empty($algos))
+            throw new InvalidArgumentException('Failed to parse Accept-Encoding header.');
+
+        return new AcceptEncodingHeader($algos, $rejects);
+    }
+}
diff --git a/src/Http/Headers/AcceptHeader.php b/src/Http/Headers/AcceptHeader.php
new file mode 100644
index 0000000..9cadc49
--- /dev/null
+++ b/src/Http/Headers/AcceptHeader.php
@@ -0,0 +1,63 @@
+<?php
+// AcceptHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use InvalidArgumentException;
+use Index\MediaType;
+use Index\Http\HttpHeader;
+
+class AcceptHeader {
+    private array $types;
+    private array $rejects;
+
+    public function __construct(array $types, array $rejects) {
+        $this->types = $types;
+        $this->rejects = $rejects;
+    }
+
+    public function getTypes(): array {
+        return $this->types;
+    }
+
+    public function getRejects(): array {
+        return $this->rejects;
+    }
+
+    public function accepts(MediaType|string $mediaType): ?MediaType {
+        foreach($this->types as $type)
+            if($type->getQuality() < 0.1 && $type->equals($mediaType))
+                return $type;
+
+        return null;
+    }
+
+    public function rejects(MediaType|string $mediaType): bool {
+        foreach($this->rejects as $reject)
+            if($reject->equals($mediaType))
+                return true;
+
+        return false;
+    }
+
+    public static function parse(HttpHeader $header): AcceptHeader {
+        $parts = explode(',', $header->getFirstLine());
+        $types = [];
+        $rejects = [];
+
+        foreach($parts as $part)
+            try {
+                $types[] = $type = MediaType::parse(trim($part));
+
+                if($type->getQuality() < 0.1)
+                    $rejects[] = $type;
+            } catch(InvalidArgumentException $ex) {}
+
+        if(empty($types))
+            throw new InvalidArgumentException('Failed to parse Accept header.');
+
+        return new AcceptHeader($types, $rejects);
+    }
+}
diff --git a/src/Http/Headers/AcceptLanguageHeader.php b/src/Http/Headers/AcceptLanguageHeader.php
new file mode 100644
index 0000000..868bf93
--- /dev/null
+++ b/src/Http/Headers/AcceptLanguageHeader.php
@@ -0,0 +1,72 @@
+<?php
+// AcceptLanguageHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use stdClass;
+use InvalidArgumentException;
+use Index\Http\HttpHeader;
+
+class AcceptLanguageHeader {
+    private array $langs;
+    private array $rejects;
+
+    public function __construct(array $langs, array $rejects) {
+        $this->langs = $langs;
+        $this->rejects = $rejects;
+    }
+
+    public function getLanguages(): array {
+        return $this->langs;
+    }
+
+    public function getRejects(): array {
+        return $this->rejects;
+    }
+
+    public function accepts(string $locale): int {
+        $locale = strtolower($locale);
+        foreach($this->langs as $lang)
+            if($lang->quality !== 0 && ($lang->name === $locale || $lang->name === '*'))
+                return $lang->quality;
+
+        return 0;
+    }
+
+    public function rejects(string $locale): bool {
+        return in_array(strtolower($locale), $this->rejects)
+            || in_array('*', $this->rejects);
+    }
+
+    public static function parse(HttpHeader $header): AcceptLanguageHeader {
+        $parts = explode(',', $header->getFirstLine());
+        $langs = [];
+        $rejects = [];
+
+        foreach($parts as $part)
+            try {
+                $part = explode(';', $part);
+                $lang = new stdClass;
+                $lang->name = strtolower(trim(array_shift($part)));
+                $lang->quality = 1;
+
+                foreach($part as $param) {
+                    if(substr($param, 0, 2) === 'q=') {
+                        $lang->quality = min(0, max(1, floatval(substr($param, 2))));
+                        break;
+                    }
+                }
+
+                $langs[] = $lang;
+                if($lang->quality === 0)
+                    $rejects[] = $lang->name;
+            } catch(InvalidArgumentException $ex) {}
+
+        if(empty($langs))
+            throw new InvalidArgumentException('Failed to parse Accept-Language header.');
+
+        return new AcceptLanguageHeader($langs, $rejects);
+    }
+}
diff --git a/src/Http/Headers/AcceptTransferEncodingHeader.php b/src/Http/Headers/AcceptTransferEncodingHeader.php
new file mode 100644
index 0000000..aa933d1
--- /dev/null
+++ b/src/Http/Headers/AcceptTransferEncodingHeader.php
@@ -0,0 +1,71 @@
+<?php
+// AcceptTransferEncodingHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use stdClass;
+use InvalidArgumentException;
+
+class AcceptTransferEncodingHeader {
+    private array $encodings;
+    private array $rejects;
+
+    public function __construct(array $encodings, array $rejects) {
+        $this->encodings = $encodings;
+        $this->rejects = $rejects;
+    }
+
+    public function getEncodings(): array {
+        return $this->encodings;
+    }
+
+    public function getRejects(): array {
+        return $this->rejects;
+    }
+
+    public function accepts(string $algoName): int {
+        $algoName = strtolower($algoName);
+        foreach($this->encodings as $algo)
+            if($algo->quality !== 0 && ($algo->name === $algoName || $algo->name === '*'))
+                return $algo->quality;
+
+        return 0;
+    }
+
+    public function rejects(string $locale): bool {
+        return in_array(strtolower($locale), $this->rejects)
+            || in_array('*', $this->rejects);
+    }
+
+    public static function parse(array $lines): AcceptTransferEncodingHeader {
+        $parts = explode(',', (string)$lines[0]);
+        $algos = [];
+        $rejects = [];
+
+        foreach($parts as $part)
+            try {
+                $part = explode(';', $part);
+                $algo = new stdClass;
+                $algo->name = strtolower(trim(array_shift($part)));
+                $algo->quality = 1;
+
+                foreach($part as $param) {
+                    if(substr($param, 0, 2) === 'q=') {
+                        $algo->quality = min(0, max(1, floatval(substr($param, 2))));
+                        break;
+                    }
+                }
+
+                $algos[] = $algo;
+                if($algo->quality === 0)
+                    $rejects[] = $algo->name;
+            } catch(InvalidArgumentException $ex) {}
+
+        if(empty($algos))
+            throw new InvalidArgumentException('Failed to parse TE header.');
+
+        return new AcceptTransferEncodingHeader($algos, $rejects);
+    }
+}
diff --git a/src/Http/Headers/AccessControlRequestHeadersHeader.php b/src/Http/Headers/AccessControlRequestHeadersHeader.php
new file mode 100644
index 0000000..a573e92
--- /dev/null
+++ b/src/Http/Headers/AccessControlRequestHeadersHeader.php
@@ -0,0 +1,34 @@
+<?php
+// AccessControlRequestHeadersHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class AccessControlRequestHeadersHeader {
+    private array $headers;
+
+    public function __construct(array $headers) {
+        $this->headers = $headers;
+    }
+
+    public function getHeaders(): array {
+        return $this->headers;
+    }
+
+    public function isAllowed(string $header): bool {
+        return in_array(strtolower($header), $this->headers);
+    }
+
+    public static function parse(HttpHeader $header): AccessControlRequestHeadersHeader {
+        $raw = explode(',', $header->getFirstLine());
+        $headers = [];
+
+        foreach($raw as $header)
+            $headers[] = strtolower(trim($header));
+
+        return new AccessControlRequestHeadersHeader(array_unique($headers));
+    }
+}
diff --git a/src/Http/Headers/AccessControlRequestMethodHeader.php b/src/Http/Headers/AccessControlRequestMethodHeader.php
new file mode 100644
index 0000000..b6d0c77
--- /dev/null
+++ b/src/Http/Headers/AccessControlRequestMethodHeader.php
@@ -0,0 +1,28 @@
+<?php
+// AccessControlRequestMethodHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class AccessControlRequestMethodHeader {
+    private string $method;
+
+    public function __construct(string $method) {
+        $this->method = $method;
+    }
+
+    public function getMethod(): string {
+        return $this->method;
+    }
+
+    public function isMethod(string $method): bool {
+        return $this->method === strtolower($method);
+    }
+
+    public static function parse(HttpHeader $header): AccessControlRequestMethodHeader {
+        return new AccessControlRequestMethodHeader(strtolower(trim($header->getFirstLine())));
+    }
+}
diff --git a/src/Http/Headers/AuthorizationHeader.php b/src/Http/Headers/AuthorizationHeader.php
new file mode 100644
index 0000000..63b0197
--- /dev/null
+++ b/src/Http/Headers/AuthorizationHeader.php
@@ -0,0 +1,35 @@
+<?php
+// AuthorizationHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class AuthorizationHeader {
+    private string $method;
+    private string $params;
+
+    public function __construct(string $method, string $params) {
+        $this->method = $method;
+        $this->params = $params;
+    }
+
+    public function getMethod(): string {
+        return $this->method;
+    }
+
+    public function isMethod(string $method): bool {
+        return $this->method === strtolower($method);
+    }
+
+    public function getParams(): string {
+        return $this->params;
+    }
+
+    public static function parse(HttpHeader $header): AuthorizationHeader {
+        $parts = explode(' ', trim($header->getFirstLine()), 2);
+        return new AuthorizationHeader($parts[0], $parts[1] ?? '');
+    }
+}
diff --git a/src/Http/Headers/CacheControlHeader.php b/src/Http/Headers/CacheControlHeader.php
new file mode 100644
index 0000000..9f2aaa6
--- /dev/null
+++ b/src/Http/Headers/CacheControlHeader.php
@@ -0,0 +1,47 @@
+<?php
+// CacheControlHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class CacheControlHeader {
+    private array $params;
+
+    public function __construct(array $params) {
+        $this->params = $params;
+    }
+
+    public function getParams(): array {
+        return $this->params;
+    }
+
+    public function hasParam(string $name): bool {
+        return isset($this->params[strtolower($name)]);
+    }
+
+    public function getParam(string $name, int $filter = FILTER_DEFAULT, array|int $options = 0): mixed {
+        $name = strtolower($name);
+        if(!isset($this->params[$name]))
+            return null;
+        return filter_var($this->params[$name] ?? null, $filter, $options);
+    }
+
+    public static function parse(HttpHeader $header): CacheControlHeader {
+        $raw = explode(',', strtolower($header->getFirstLine()));
+        $params = [];
+
+        foreach($raw as $param) {
+            $parts = explode('=', $param, 2);
+            $name = trim($parts[0]);
+            $value = trim($parts[1] ?? '');
+            if($value === '')
+                $value = true;
+            $params[$name] = $value;
+        }
+
+        return new CacheControlHeader($params);
+    }
+}
diff --git a/src/Http/Headers/ConnectionHeader.php b/src/Http/Headers/ConnectionHeader.php
new file mode 100644
index 0000000..0605b4d
--- /dev/null
+++ b/src/Http/Headers/ConnectionHeader.php
@@ -0,0 +1,35 @@
+<?php
+// ConnectionHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ConnectionHeader {
+    private array $params;
+
+    public function __construct(array $params) {
+        $this->params = $params;
+    }
+
+    public function getParams(): array {
+        return $this->params;
+    }
+
+    public function hasParam(string $directive): bool {
+        return in_array($directive, $this->params);
+    }
+
+    public static function parse(HttpHeader $header): ConnectionHeader {
+        return new ConnectionHeader(
+            array_unique(
+                array_map(
+                    fn($directive) => trim($directive),
+                    explode(',', strtolower($header->getFirstLine()))
+                )
+            )
+        );
+    }
+}
diff --git a/src/Http/Headers/ContentEncodingHeader.php b/src/Http/Headers/ContentEncodingHeader.php
new file mode 100644
index 0000000..a9f4222
--- /dev/null
+++ b/src/Http/Headers/ContentEncodingHeader.php
@@ -0,0 +1,29 @@
+<?php
+// ContentEncodingHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ContentEncodingHeader {
+    private array $encodings;
+
+    public function __construct(array $encodings) {
+        $this->encodings = $encodings;
+    }
+
+    public function getEncodings(): array {
+        return $this->encodings;
+    }
+
+    public static function parse(HttpHeader $header): ContentEncodingHeader {
+        return new ContentEncodingHeader(
+            array_map(
+                fn($directive) => trim($directive),
+                explode(',', strtolower($header->getFirstLine()))
+            )
+        );
+    }
+}
diff --git a/src/Http/Headers/ContentLanguageHeader.php b/src/Http/Headers/ContentLanguageHeader.php
new file mode 100644
index 0000000..026aab9
--- /dev/null
+++ b/src/Http/Headers/ContentLanguageHeader.php
@@ -0,0 +1,35 @@
+<?php
+// ContentLanguageHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ContentLanguageHeader {
+    private array $langs;
+
+    public function __construct(array $langs) {
+        $this->langs = $langs;
+    }
+
+    public function getLanguages(): array {
+        return $this->langs;
+    }
+
+    public function hasLanguage(string $lang): bool {
+        return in_array(strtolower($lang), $this->langs);
+    }
+
+    public static function parse(HttpHeader $header): ContentLanguageHeader {
+        return new ContentLanguageHeader(
+            array_unique(
+                array_map(
+                    fn($directive) => trim($directive),
+                    explode(',', strtolower($header->getFirstLine()))
+                )
+            )
+        );
+    }
+}
diff --git a/src/Http/Headers/ContentLengthHeader.php b/src/Http/Headers/ContentLengthHeader.php
new file mode 100644
index 0000000..e24df96
--- /dev/null
+++ b/src/Http/Headers/ContentLengthHeader.php
@@ -0,0 +1,24 @@
+<?php
+// ContentLengthHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ContentLengthHeader {
+    private int $length;
+
+    public function __construct(int $length) {
+        $this->length = $length;
+    }
+
+    public function getLength(): int {
+        return $this->length;
+    }
+
+    public static function parse(HttpHeader $header): ContentLengthHeader {
+        return new ContentLengthHeader(intval($header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/ContentLocationHeader.php b/src/Http/Headers/ContentLocationHeader.php
new file mode 100644
index 0000000..1e74a98
--- /dev/null
+++ b/src/Http/Headers/ContentLocationHeader.php
@@ -0,0 +1,24 @@
+<?php
+// ContentLocationHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ContentLocationHeader {
+    private string $location;
+
+    public function __construct(string $location) {
+        $this->location = $location;
+    }
+
+    public function getLocation(): string {
+        return $this->location;
+    }
+
+    public static function parse(HttpHeader $header): ContentLocationHeader {
+        return new ContentLocationHeader(trim($header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/ContentRangeHeader.php b/src/Http/Headers/ContentRangeHeader.php
new file mode 100644
index 0000000..e909c1d
--- /dev/null
+++ b/src/Http/Headers/ContentRangeHeader.php
@@ -0,0 +1,74 @@
+<?php
+// ContentRangeHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ContentRangeHeader {
+    private string $unit;
+    private int $rangeStart = -1;
+    private int $rangeEnd = -1;
+    private int $size = -1;
+
+    public function __construct(string $unit, int $rangeStart, int $rangeEnd, int $size) {
+        $this->unit = $unit;
+        $this->rangeStart = $rangeStart;
+        $this->rangeEnd = $rangeEnd;
+        $this->size = $size;
+    }
+
+    public function getUnit(): string {
+        return $this->unit;
+    }
+
+    public function isBytes(): bool {
+        return $this->unit === 'bytes';
+    }
+
+    public function getSize(): int {
+        return $this->size;
+    }
+
+    public function isUnknownSize(): bool {
+        return $this->size < 0;
+    }
+
+    public function isUnspecifiedRange(): bool {
+        return $this->rangeStart < 0 || $this->rangeEnd < 0;
+    }
+
+    public function getRangeStart(): int {
+        return $this->rangeStart;
+    }
+
+    public function getRangeEnd(): int {
+        return $this->rangeEnd;
+    }
+
+    public static function parse(HttpHeader $header): ContentRangeHeader {
+        $parts = explode(' ', trim($header->getFirstLine()), 2);
+        $unit = array_shift($parts);
+
+        $parts = explode('/', $parts[1] ?? '', 2);
+
+        $size = trim($parts[1] ?? '*');
+        if($size !== '*')
+            $size = max(0, intval($size));
+        else
+            $size = -1;
+
+        $range = trim($parts[0]);
+
+        if($range !== '*') {
+            $parts = explode('-', $range, 2);
+            $rangeStart = intval(trim($parts[0]));
+            $rangeEnd = intval(trim($parts[1] ?? '0'));
+        } else
+            $rangeStart = $rangeEnd = -1;
+
+        return new ContentRangeHeader($unit, $rangeStart, $rangeEnd, $size);
+    }
+}
diff --git a/src/Http/Headers/ContentTypeHeader.php b/src/Http/Headers/ContentTypeHeader.php
new file mode 100644
index 0000000..09173b3
--- /dev/null
+++ b/src/Http/Headers/ContentTypeHeader.php
@@ -0,0 +1,25 @@
+<?php
+// ContentTypeHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\MediaType;
+use Index\Http\HttpHeader;
+
+class ContentTypeHeader {
+    private MediaType $mediaType;
+
+    public function __construct(MediaType $mediaType) {
+        $this->mediaType = $mediaType;
+    }
+
+    public function getMediaType(): MediaType {
+        return $this->mediaType;
+    }
+
+    public static function parse(HttpHeader $header): ContentTypeHeader {
+        return new ContentTypeHeader(MediaType::parse($header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/CookieHeader.php b/src/Http/Headers/CookieHeader.php
new file mode 100644
index 0000000..c2ac2fb
--- /dev/null
+++ b/src/Http/Headers/CookieHeader.php
@@ -0,0 +1,47 @@
+<?php
+// CookieHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\UrlEncoding;
+use Index\Http\HttpHeader;
+
+class CookieHeader {
+    private array $cookies;
+
+    public function __construct(array $cookies) {
+        $this->cookies = $cookies;
+    }
+
+    public function getCookies(): array {
+        return $this->cookies;
+    }
+
+    public function hasCookie(string $name): bool {
+        return isset($this->cookies[$name]);
+    }
+
+    public function getCookie(string $name, int $filter = FILTER_DEFAULT, array|int $options = 0): mixed {
+        if(!isset($this->cookies[$name]))
+            return null;
+        return filter_var($this->cookies[$name] ?? null, $filter, $options);
+    }
+
+    public static function parse(HttpHeader $header): CookieHeader {
+        $cookies = [];
+        $lines = $header->getLines();
+
+        foreach($lines as $line) {
+            $parts = explode(';', $line);
+
+            foreach($parts as $part) {
+                $kvp = explode('=', $part, 2);
+                $cookies[rawurldecode($kvp[0])] = rawurldecode($kvp[1] ?? '');
+            }
+        }
+
+        return new CookieHeader($cookies);
+    }
+}
diff --git a/src/Http/Headers/DNTHeader.php b/src/Http/Headers/DNTHeader.php
new file mode 100644
index 0000000..f186751
--- /dev/null
+++ b/src/Http/Headers/DNTHeader.php
@@ -0,0 +1,33 @@
+<?php
+// DNTHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class DNTHeader {
+    private ?bool $state;
+
+    public function __construct(?bool $state) {
+        $this->state = $state;
+    }
+
+    public function getState(): ?bool {
+        return $this->state;
+    }
+
+    public function hasNoPreference(): bool {
+        return $this->state === null;
+    }
+
+    public function allowsTracking(): bool {
+        return $this->state !== false;
+    }
+
+    public static function parse(HttpHeader $header): DNTHeader {
+        $value = $header->getFirstLine();
+        return new DNTHeader($value === 'null' ? null : ($value === '1'));
+    }
+}
diff --git a/src/Http/Headers/DateHeader.php b/src/Http/Headers/DateHeader.php
new file mode 100644
index 0000000..31f347f
--- /dev/null
+++ b/src/Http/Headers/DateHeader.php
@@ -0,0 +1,25 @@
+<?php
+// DateHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\DateTime;
+use Index\Http\HttpHeader;
+
+class DateHeader {
+    private DateTime $dateTime;
+
+    public function __construct(DateTime $dateTime) {
+        $this->dateTime = $dateTime;
+    }
+
+    public function getDateTime(): DateTime {
+        return $this->dateTime;
+    }
+
+    public static function parse(HttpHeader $header): DateHeader {
+        return new DateHeader(DateTime::createFromFormat(\DateTimeInterface::RFC7231, $header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/ExpectHeader.php b/src/Http/Headers/ExpectHeader.php
new file mode 100644
index 0000000..ca48e0d
--- /dev/null
+++ b/src/Http/Headers/ExpectHeader.php
@@ -0,0 +1,31 @@
+<?php
+// ExpectHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ExpectHeader {
+    private int $statusCode;
+    private string $statusText;
+
+    public function __construct(int $statusCode, string $statusText) {
+        $this->statusCode = $statusCode;
+        $this->statusText = $statusText;
+    }
+
+    public function getStatusCode(): int {
+        return $this->statusCode;
+    }
+
+    public function getStatusText(): string {
+        return $this->statusText;
+    }
+
+    public static function parse(HttpHeader $header): ExpectHeader {
+        $value = explode('-', $header->getFirstLine(), 2);
+        return new ExpectHeader(intval($value[0]), $value[1] ?? '');
+    }
+}
diff --git a/src/Http/Headers/FromHeader.php b/src/Http/Headers/FromHeader.php
new file mode 100644
index 0000000..2f75edb
--- /dev/null
+++ b/src/Http/Headers/FromHeader.php
@@ -0,0 +1,24 @@
+<?php
+// FromHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class FromHeader {
+    private string $email;
+
+    public function __construct(string $email) {
+        $this->email = $email;
+    }
+
+    public function getEMailAddress(): string {
+        return $this->email;
+    }
+
+    public static function parse(HttpHeader $header): FromHeader {
+        return new FromHeader($header->getFirstLine());
+    }
+}
diff --git a/src/Http/Headers/HostHeader.php b/src/Http/Headers/HostHeader.php
new file mode 100644
index 0000000..f50422c
--- /dev/null
+++ b/src/Http/Headers/HostHeader.php
@@ -0,0 +1,35 @@
+<?php
+// HostHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class HostHeader {
+    private string $host;
+    private int $port;
+
+    public function __construct(string $host, int $port) {
+        $this->host = $host;
+        $this->port = $port;
+    }
+
+    public function getHost(): string {
+        return $this->host;
+    }
+
+    public function hasPort(): bool {
+        return $this->port > 0;
+    }
+
+    public function getPort(): int {
+        return $this->port;
+    }
+
+    public static function parse(HttpHeader $header): HostHeader {
+        $parts = explode(':', $header->getFirstLine(), 2);
+        return new HostHeader($parts[0], intval($parts[1] ?? '-1'));
+    }
+}
diff --git a/src/Http/Headers/IfMatchHeader.php b/src/Http/Headers/IfMatchHeader.php
new file mode 100644
index 0000000..814f657
--- /dev/null
+++ b/src/Http/Headers/IfMatchHeader.php
@@ -0,0 +1,46 @@
+<?php
+// IfMatchHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class IfMatchHeader {
+    private array $tags;
+    private int $count;
+
+    public function __construct(array $tags) {
+        $this->tags = $tags;
+        $this->count = count($tags);
+    }
+
+    public function getTags(): array {
+        return $this->tags;
+    }
+
+    public function hasTag(string $tag): bool {
+        if($this->count === 1 && $this->tags[0] === '*')
+            return true;
+        return in_array((string)$tag, $this->tags);
+    }
+
+    public static function parse(HttpHeader $header): IfMatchHeader {
+        $tags = [];
+        $rawTags = array_unique(
+            array_map(
+                fn($directive) => trim($directive),
+                explode(',', strtolower($header->getFirstLine()))
+            )
+        );
+
+        foreach($rawTags as $raw) {
+            if(substr($raw, 0, 3) === 'W/"')
+                continue;
+            $tags[] = trim($raw, '"');
+        }
+
+        return new IfMatchHeader($tags);
+    }
+}
diff --git a/src/Http/Headers/IfModifiedSinceHeader.php b/src/Http/Headers/IfModifiedSinceHeader.php
new file mode 100644
index 0000000..94224e3
--- /dev/null
+++ b/src/Http/Headers/IfModifiedSinceHeader.php
@@ -0,0 +1,30 @@
+<?php
+// IfModifiedSinceHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use DateTimeInterface;
+use Index\DateTime;
+use Index\Http\HttpHeader;
+
+class IfModifiedSinceHeader {
+    private DateTime $dateTime;
+
+    public function __construct(DateTime $dateTime) {
+        $this->dateTime = $dateTime;
+    }
+
+    public function getDateTime(): DateTime {
+        return $this->dateTime;
+    }
+
+    public function isLessThanOrEqual(DateTimeInterface $dateTime): bool {
+        return $this->dateTime->isLessThanOrEqual($dateTime);
+    }
+
+    public static function parse(HttpHeader $header): IfModifiedSinceHeader {
+        return new IfModifiedSinceHeader(DateTime::createFromFormat(\DateTimeInterface::RFC7231, $header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/IfNoneMatchHeader.php b/src/Http/Headers/IfNoneMatchHeader.php
new file mode 100644
index 0000000..1a0bbe4
--- /dev/null
+++ b/src/Http/Headers/IfNoneMatchHeader.php
@@ -0,0 +1,46 @@
+<?php
+// IfNoneMatchHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class IfNoneMatchHeader {
+    private array $tags;
+    private int $count;
+
+    public function __construct(array $tags) {
+        $this->tags = $tags;
+        $this->count = count($tags);
+    }
+
+    public function getTags(): array {
+        return $this->tags;
+    }
+
+    public function hasTag(string $tag): bool {
+        if($this->count === 1 && $this->tags[0] === '*')
+            return true;
+        return in_array($tag, $this->tags);
+    }
+
+    public static function parse(HttpHeader $header): IfNoneMatchHeader {
+        $tags = [];
+        $rawTags = array_unique(
+            array_map(
+                fn($directive) => trim($directive),
+                explode(',', strtolower($header->getFirstLine()))
+            )
+        );
+
+        foreach($rawTags as $raw) {
+            if(str_starts_with($raw, 'W/"'))
+                $raw = substr($raw, 2);
+            $tags[] = trim($raw, '"');
+        }
+
+        return new IfNoneMatchHeader($tags);
+    }
+}
diff --git a/src/Http/Headers/IfRangeHeader.php b/src/Http/Headers/IfRangeHeader.php
new file mode 100644
index 0000000..17051f6
--- /dev/null
+++ b/src/Http/Headers/IfRangeHeader.php
@@ -0,0 +1,58 @@
+<?php
+// IfRangeHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use DateTimeInterface;
+use Index\DateTime;
+use Index\Http\HttpHeader;
+
+class IfRangeHeader {
+    private ?string $tag;
+    private ?DateTime $dateTime;
+
+    public function __construct(?string $tag, ?DateTime $dateTime) {
+        $this->tag = $tag;
+        $this->dateTime = $dateTime;
+    }
+
+    public function hasTag(): bool {
+        return $this->tag !== null;
+    }
+
+    public function getTag(): string {
+        return $this->tag;
+    }
+
+    public function hasDateTime(): bool {
+        return $this->dateTime !== null;
+    }
+
+    public function getDateTime(): DateTime {
+        return $this->dateTime;
+    }
+
+    public function matches(string|DateTimeInterface $other): bool {
+        if($this->hasTag() && is_string($other)) {
+            if(str_starts_with($other, 'W/"'))
+                return false;
+            return $this->tag === $other;
+        }
+
+        if($this->hasDateTime() && $other instanceof DateTimeInterface)
+            return $this->dateTime->isLessThanOrEqual($other);
+
+        return false;
+    }
+
+    public static function parse(HttpHeader $header): IfRangeHeader {
+        $line = $header->getFirstLine();
+
+        if($line[0] !== '"' && !str_starts_with($line, 'W/"'))
+            return new IfRangeHeader(null, DateTime::createFromFormat(\DateTimeInterface::RFC7231, $line));
+
+        return new IfRangeHeader($line, null);
+    }
+}
diff --git a/src/Http/Headers/IfUnmodifiedSinceHeader.php b/src/Http/Headers/IfUnmodifiedSinceHeader.php
new file mode 100644
index 0000000..92245a5
--- /dev/null
+++ b/src/Http/Headers/IfUnmodifiedSinceHeader.php
@@ -0,0 +1,30 @@
+<?php
+// IfUnmodifiedSinceHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use DateTimeInterface;
+use Index\DateTime;
+use Index\Http\HttpHeader;
+
+class IfUnmodifiedSinceHeader {
+    private DateTime $dateTime;
+
+    public function __construct(DateTime $dateTime) {
+        $this->dateTime = $dateTime;
+    }
+
+    public function getDateTime(): DateTime {
+        return $this->dateTime;
+    }
+
+    public function isMoreThan(DateTimeInterface $dateTime): bool {
+        return $this->dateTime->isMoreThan($dateTime);
+    }
+
+    public static function parse(HttpHeader $header): IfUnmodifiedSinceHeader {
+        return new IfUnmodifiedSinceHeader(DateTime::createFromFormat(\DateTimeInterface::RFC7231, $header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/KeepAliveHeader.php b/src/Http/Headers/KeepAliveHeader.php
new file mode 100644
index 0000000..a40217f
--- /dev/null
+++ b/src/Http/Headers/KeepAliveHeader.php
@@ -0,0 +1,43 @@
+<?php
+// KeepAliveHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-15
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class KeepAliveHeader {
+    private int $timeOut;
+    private int $max;
+
+    public function __construct(int $timeOut, int $max) {
+        $this->timeOut = $timeOut;
+        $this->max = $max;
+    }
+
+    public function getTimeOut(): int {
+        return $this->timeOut;
+    }
+
+    public function getMax(): int {
+        return $this->max;
+    }
+
+    public static function parse(HttpHeader $header): KeepAliveHeader {
+        $params = explode(',', $header->getFirstLine());
+        $timeOut = -1;
+        $max = -1;
+
+        foreach($params as $param) {
+            if(str_starts_with($param, 'timeout='))
+                $timeOut = intval(substr($param, 8));
+            elseif(str_starts_with($param, 'max='))
+                $max = intval(substr($param, 4));
+            if($timeOut >= 0 && $max >= 0)
+                break;
+        }
+
+        return new KeepAliveHeader($timeOut, $max);
+    }
+}
diff --git a/src/Http/Headers/LastModifiedHeader.php b/src/Http/Headers/LastModifiedHeader.php
new file mode 100644
index 0000000..4874fce
--- /dev/null
+++ b/src/Http/Headers/LastModifiedHeader.php
@@ -0,0 +1,25 @@
+<?php
+// LastModifiedHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\DateTime;
+use Index\Http\HttpHeader;
+
+class LastModifiedHeader {
+    private DateTime $dateTime;
+
+    public function __construct(DateTime $dateTime) {
+        $this->dateTime = $dateTime;
+    }
+
+    public function getDateTime(): DateTime {
+        return $this->dateTime;
+    }
+
+    public static function parse(HttpHeader $header): LastModifiedHeader {
+        return new LastModifiedHeader(DateTime::createFromFormat(\DateTimeInterface::RFC7231, $header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/OriginHeader.php b/src/Http/Headers/OriginHeader.php
new file mode 100644
index 0000000..601e27f
--- /dev/null
+++ b/src/Http/Headers/OriginHeader.php
@@ -0,0 +1,61 @@
+<?php
+// OriginHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\DateTime;
+use Index\Http\HttpHeader;
+
+class OriginHeader {
+    private bool $isNull;
+    private string $scheme;
+    private string $host;
+    private int $port;
+
+    public function __construct(bool $isNull, string $scheme, string $host, int $port) {
+        $this->isNull = $isNull;
+        $this->scheme = $scheme;
+        $this->host = $host;
+        $this->port = $port;
+    }
+
+    public function isNull(): bool {
+        return $this->isNull;
+    }
+
+    public function isValid(): bool {
+        return $this->isNull || ($this->scheme !== '' && $this->host !== '');
+    }
+
+    public function getScheme(): string {
+        return $this->scheme;
+    }
+
+    public function getHost(): string {
+        return $this->host;
+    }
+
+    public function hasPort(): bool {
+        return $this->port > 0;
+    }
+
+    public function getPort(): int {
+        return $this->port;
+    }
+
+    public static function parse(HttpHeader $header): OriginHeader {
+        $line = $header->getFirstLine();
+
+        if($line === 'null')
+            return new OriginHeader(true, '', '', -1);
+
+        return new OriginHeader(
+            false,
+            parse_url($line, PHP_URL_SCHEME) ?? '',
+            parse_url($line, PHP_URL_HOST) ?? '',
+            parse_url($line, PHP_URL_PORT) ?? -1
+        );
+    }
+}
diff --git a/src/Http/Headers/PragmaHeader.php b/src/Http/Headers/PragmaHeader.php
new file mode 100644
index 0000000..c9172d9
--- /dev/null
+++ b/src/Http/Headers/PragmaHeader.php
@@ -0,0 +1,24 @@
+<?php
+// PragmaHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class PragmaHeader {
+    private bool $noCache;
+
+    public function __construct(bool $noCache) {
+        $this->noCache = $noCache;
+    }
+
+    public function shouldByPassCache(): bool {
+        return $this->noCache;
+    }
+
+    public static function parse(HttpHeader $header): PragmaHeader {
+        return new PragmaHeader($header->getFirstLine() === 'no-cache');
+    }
+}
diff --git a/src/Http/Headers/ProxyAuthorizationHeader.php b/src/Http/Headers/ProxyAuthorizationHeader.php
new file mode 100644
index 0000000..3ae6961
--- /dev/null
+++ b/src/Http/Headers/ProxyAuthorizationHeader.php
@@ -0,0 +1,35 @@
+<?php
+// ProxyAuthorizationHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class ProxyAuthorizationHeader {
+    private string $method;
+    private string $params;
+
+    public function __construct(string $method, string $params) {
+        $this->method = $method;
+        $this->params = $params;
+    }
+
+    public function getMethod(): string {
+        return $this->method;
+    }
+
+    public function isMethod(string $method): bool {
+        return $this->method === strtolower($method);
+    }
+
+    public function getParams(): string {
+        return $this->params;
+    }
+
+    public static function parse(HttpHeader $header): ProxyAuthorizationHeader {
+        $parts = explode(' ', trim($header->getFirstLine()), 2);
+        return new ProxyAuthorizationHeader($parts[0], $parts[1] ?? '');
+    }
+}
diff --git a/src/Http/Headers/RangeHeader.php b/src/Http/Headers/RangeHeader.php
new file mode 100644
index 0000000..d3feb8e
--- /dev/null
+++ b/src/Http/Headers/RangeHeader.php
@@ -0,0 +1,61 @@
+<?php
+// RangeHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use stdClass;
+use Index\Http\HttpHeader;
+
+class RangeHeader {
+    private string $unit;
+    private array $ranges;
+
+    public function __construct(string $unit, array $ranges) {
+        $this->unit = $unit;
+        $this->ranges = $ranges;
+    }
+
+    public function getUnit(): string {
+        return $this->unit;
+    }
+
+    public function isBytes(): bool {
+        return $this->unit === 'bytes';
+    }
+
+    public function getRanges(): array {
+        return $this->ranges;
+    }
+
+    public static function parse(HttpHeader $header): RangeHeader {
+        $parts = explode('=', trim($header->getFirstLine()), 2);
+        $unit = trim($parts[0]);
+
+        $ranges = [];
+        $rawRanges = explode(',', $parts[1] ?? '', 2);
+
+        foreach($rawRanges as $raw) {
+            $raw = explode('-', trim($raw), 2);
+            $start = trim($raw[0]);
+            $end = trim($raw[1] ?? '');
+
+            $ranges[] = $range = new stdClass;
+
+            if($start === '' && is_numeric($end)) {
+                $range->type = 'suffix-length';
+                $range->length = intval($end);
+            } elseif(is_numeric($start) && $end === '') {
+                $range->type = 'start';
+                $range->start = intval($start);
+            } else {
+                $range->type = 'range';
+                $range->start = intval($start);
+                $range->end = intval($end);
+            }
+        }
+
+        return new RangeHeader($unit, $ranges);
+    }
+}
diff --git a/src/Http/Headers/RefererHeader.php b/src/Http/Headers/RefererHeader.php
new file mode 100644
index 0000000..82c7031
--- /dev/null
+++ b/src/Http/Headers/RefererHeader.php
@@ -0,0 +1,24 @@
+<?php
+// RefererHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class RefererHeader {
+    private string $url;
+
+    public function __construct(string $url) {
+        $this->url = $url;
+    }
+
+    public function getSource(): string {
+        return $this->url;
+    }
+
+    public static function parse(HttpHeader $header): RefererHeader {
+        return new RefererHeader(trim($header->getFirstLine()));
+    }
+}
diff --git a/src/Http/Headers/SaveDataHeader.php b/src/Http/Headers/SaveDataHeader.php
new file mode 100644
index 0000000..73002d4
--- /dev/null
+++ b/src/Http/Headers/SaveDataHeader.php
@@ -0,0 +1,24 @@
+<?php
+// SaveDataHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class SaveDataHeader {
+    private bool $saveData;
+
+    public function __construct(bool $saveData) {
+        $this->saveData = $saveData;
+    }
+
+    public function shouldReduceData(): bool {
+        return $this->saveData;
+    }
+
+    public static function parse(HttpHeader $header): SaveDataHeader {
+        return new SaveDataHeader($header->getFirstLine() === 'yes');
+    }
+}
diff --git a/src/Http/Headers/TrailerHeader.php b/src/Http/Headers/TrailerHeader.php
new file mode 100644
index 0000000..8f76a51
--- /dev/null
+++ b/src/Http/Headers/TrailerHeader.php
@@ -0,0 +1,34 @@
+<?php
+// TrailerHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class TrailerHeader {
+    private array $headers;
+
+    public function __construct(array $headers) {
+        $this->headers = $headers;
+    }
+
+    public function getHeaders(): array {
+        return $this->headers;
+    }
+
+    public function isTrailer(string $header): bool {
+        return in_array(strtolower($header), $this->headers);
+    }
+
+    public static function parse(HttpHeader $header): TrailerHeader {
+        $raw = explode(',', $header->getFirstLine());
+        $headers = [];
+
+        foreach($raw as $header)
+            $headers[] = strtolower(trim($header));
+
+        return new TrailerHeader(array_unique($headers));
+    }
+}
diff --git a/src/Http/Headers/TransferEncodingHeader.php b/src/Http/Headers/TransferEncodingHeader.php
new file mode 100644
index 0000000..506c7de
--- /dev/null
+++ b/src/Http/Headers/TransferEncodingHeader.php
@@ -0,0 +1,29 @@
+<?php
+// TransferEncodingHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class TransferEncodingHeader {
+    private array $encodings;
+
+    public function __construct(array $encodings) {
+        $this->encodings = $encodings;
+    }
+
+    public function getEncodings(): array {
+        return $this->encodings;
+    }
+
+    public static function parse(HttpHeader $header): TransferEncodingHeader {
+        return new TransferEncodingHeader(
+            array_map(
+                fn($directive) => trim($directive),
+                explode(',', strtolower($header->getFirstLine()))
+            )
+        );
+    }
+}
diff --git a/src/Http/Headers/UpgradeHeader.php b/src/Http/Headers/UpgradeHeader.php
new file mode 100644
index 0000000..3d272f5
--- /dev/null
+++ b/src/Http/Headers/UpgradeHeader.php
@@ -0,0 +1,33 @@
+<?php
+// UpgradeHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class UpgradeHeader {
+    private array $protocols;
+
+    public function __construct(array $protocols) {
+        $this->protocols = $protocols;
+    }
+
+    public function getProtocols(): array {
+        return $this->protocols;
+    }
+
+    public function isAccepted(string $protocol): bool {
+        return in_array(strtolower($protocol), $this->protocols);
+    }
+
+    public static function parse(HttpHeader $header): UpgradeHeader {
+        return new UpgradeHeader(
+            array_map(
+                fn($directive) => trim($directive),
+                explode(',', strtolower($header->getFirstLine()))
+            )
+        );
+    }
+}
diff --git a/src/Http/Headers/UpgradeInsecureRequestsHeader.php b/src/Http/Headers/UpgradeInsecureRequestsHeader.php
new file mode 100644
index 0000000..9e66b3b
--- /dev/null
+++ b/src/Http/Headers/UpgradeInsecureRequestsHeader.php
@@ -0,0 +1,24 @@
+<?php
+// UpgradeInsecureRequestsHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-14
+
+namespace Index\Http\Headers;
+
+use Index\Http\HttpHeader;
+
+class UpgradeInsecureRequestsHeader {
+    private bool $upgrade;
+
+    public function __construct(bool $upgrade) {
+        $this->upgrade = $upgrade;
+    }
+
+    public function shouldUpgrade(): bool {
+        return $this->upgrade;
+    }
+
+    public static function parse(HttpHeader $header): UpgradeInsecureRequestsHeader {
+        return new UpgradeInsecureRequestsHeader($header->getFirstLine() === '1');
+    }
+}
diff --git a/src/Http/Headers/UserAgentHeader.php b/src/Http/Headers/UserAgentHeader.php
new file mode 100644
index 0000000..3db70d3
--- /dev/null
+++ b/src/Http/Headers/UserAgentHeader.php
@@ -0,0 +1,29 @@
+<?php
+// UserAgentHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http\Headers;
+
+use Stringable;
+use Index\Http\HttpHeader;
+
+class UserAgentHeader implements Stringable {
+    private string $userAgent;
+
+    public function __construct(string $userAgent) {
+        $this->userAgent = $userAgent;
+    }
+
+    public function getUserAgent(): string {
+        return $this->userAgent;
+    }
+
+    public function __toString(): string {
+        return $this->userAgent;
+    }
+
+    public static function parse(HttpHeader $header): UserAgentHeader {
+        return new UserAgentHeader(trim($header->getFirstLine()));
+    }
+}
diff --git a/src/Http/HttpFx.php b/src/Http/HttpFx.php
new file mode 100644
index 0000000..7ea25a3
--- /dev/null
+++ b/src/Http/HttpFx.php
@@ -0,0 +1,288 @@
+<?php
+// HttpFx.php
+// Created: 2022-02-15
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use stdClass;
+use Exception;
+use JsonSerializable;
+use Index\Environment;
+use Index\IString;
+use Index\WString;
+use Index\IO\Stream;
+use Index\Http\Content\BencodedContent;
+use Index\Http\Content\JsonContent;
+use Index\Http\Content\StreamContent;
+use Index\Http\Content\StringContent;
+use Index\Routing\Router;
+use Index\Routing\RoutePathNotFoundException;
+use Index\Routing\RouteMethodNotSupportedException;
+use Index\Serialisation\IBencodeSerialisable;
+
+class HttpFx {
+    private Router $router;
+    private array $objectHandlers = [];
+    private array $errorHandlers = [];
+    private $defaultErrorHandler; // callable
+
+    public function __construct(?Router $router = null) {
+        self::restoreDefaultErrorHandler();
+        $this->router = $router ?? new Router;
+
+        $this->addObjectHandler(
+            fn(object $object) => $object instanceof Stream,
+            function(HttpResponseBuilder $responseBuilder, object $object) {
+                if(!$responseBuilder->hasContentType())
+                    $responseBuilder->setTypeStream();
+                $responseBuilder->setContent(new StreamContent($object));
+            }
+        );
+
+        $this->addObjectHandler(
+            fn(object $object) => $object instanceof JsonSerializable || $object instanceof stdClass,
+            function(HttpResponseBuilder $responseBuilder, object $object) {
+                if(!$responseBuilder->hasContentType())
+                    $responseBuilder->setTypeJson();
+                $responseBuilder->setContent(new JsonContent($object));
+            }
+        );
+
+        $this->addObjectHandler(
+            fn(object $object) => $object instanceof IBencodeSerialisable,
+            function(HttpResponseBuilder $responseBuilder, object $object) {
+                if(!$responseBuilder->hasContentType())
+                    $responseBuilder->setTypePlain();
+                $responseBuilder->setContent(new BencodedContent($object));
+            }
+        );
+    }
+
+    public function getRouter(): Router {
+        return $this->router;
+    }
+
+    public function addObjectHandler(callable $match, callable $handler): void {
+        $this->objectHandlers[] = [$match, $handler];
+    }
+
+    public function addErrorHandler(int $code, callable $handler): void {
+        $this->errorHandlers[$code] = $handler;
+    }
+
+    public function setDefaultErrorHandler(callable $handler): void {
+        $this->defaultErrorHandler = $handler;
+    }
+
+    public function restoreDefaultErrorHandler(): void {
+        $this->defaultErrorHandler = [self::class, 'defaultErrorHandler'];
+    }
+
+    public function dispatch(?HttpRequest $request = null, array $args = []): void {
+        $request ??= HttpRequest::fromRequest();
+        $responseBuilder = new HttpResponseBuilder;
+        $handlers = null;
+
+        try {
+            $handlers = $this->router->resolve($request->getMethod(), $request->getPath(), array_merge([
+                $responseBuilder, $request,
+            ], $args));
+        } catch(RoutePathNotFoundException $ex) {
+            $statusCode = 404;
+        } catch(RouteMethodNotSupportedException $ex) {
+            $statusCode = 405;
+        } catch(Exception $ex) {
+            if(Environment::isDebug())
+                throw $ex;
+        }
+
+        if($handlers === null) {
+            $this->errorPage($responseBuilder, $request, $statusCode ?? 500);
+        } else {
+            $result = $handlers->run();
+
+            if(is_int($result)) {
+                if(!$responseBuilder->hasStatusCode() && $result >= 100 && $result < 600) {
+                    $this->errorPage($responseBuilder, $request, $result);
+                } elseif(!$responseBuilder->hasContent()) {
+                    $responseBuilder->setContent(new StringContent((string)$result));
+                }
+            } elseif(!$responseBuilder->hasContent()) {
+                if(is_array($result)) {
+                    if(!$responseBuilder->hasContentType())
+                        $responseBuilder->setTypeJson();
+                    $responseBuilder->setContent(new JsonContent($result));
+                } elseif(is_object($result) && !($result instanceof IString)) {
+                    foreach($this->objectHandlers as $info)
+                        if($info[0]($result)) {
+                            $info[1]($responseBuilder, $result);
+                            break;
+                        }
+                }
+
+                if(!$responseBuilder->hasContent() && $result !== null) {
+                    $charset = ($result instanceof WString) ? $result->getEncoding() : null;
+                    $result = (string)$result;
+                    $responseBuilder->setContent(new StringContent($result));
+
+                    if(!$responseBuilder->hasContentType()) {
+                        if(strtolower(substr($result, 0, 5)) === '<?xml')
+                            $responseBuilder->setTypeXML($charset ?? WString::getDefaultEncoding());
+                        elseif(strtolower(substr($result, 0, 14)) === '<!doctype html')
+                            $responseBuilder->setTypeHTML($charset ?? WString::getDefaultEncoding());
+                        else
+                            $responseBuilder->setTypePlain($charset ?? 'us-ascii');
+                    }
+                }
+            }
+        }
+
+        self::output($responseBuilder->toResponse());
+    }
+
+    public static function defaultErrorHandler(
+        HttpResponseBuilder $responseBuilder,
+        HttpRequest $request,
+        int $code,
+        string $message
+    ): void {
+        $responseBuilder->setTypeHTML();
+        $responseBuilder->setContent(new StringContent(sprintf(
+            '<!doctype html><html><head><meta charset="%3$s"/><title>%1$03d %2$s</title></head><body><center><h1>%1$03d %2$s</h1></center><hr/><center>Index</center></body></html>',
+            $code,
+            $message,
+            WString::getDefaultEncoding()
+        )));
+    }
+
+    public function errorPage(
+        HttpResponseBuilder $responseBuilder,
+        HttpRequest $request,
+        int $statusCode
+    ): void {
+        $responseBuilder->setStatusCode($statusCode);
+        $responseBuilder->clearStatusText();
+        if(!$responseBuilder->hasContent())
+            ($this->errorHandlers[$statusCode] ?? $this->defaultErrorHandler)(
+                $responseBuilder,
+                $request,
+                $responseBuilder->getStatusCode(),
+                $responseBuilder->getStatusText()
+            );
+    }
+
+    public static function output(HttpResponse $response): void {
+        $version = $response->getHttpVersion();
+        header(sprintf(
+            'HTTP/%d.%d %03d %s',
+            $version->getMajor(),
+            $version->getMinor(),
+            $response->getStatusCode(),
+            $response->getStatusText()
+        ));
+
+        $headers = $response->getHeaders();
+        foreach($headers as $header) {
+            $name = (string)$header->getName();
+            $lines = $header->getLines();
+
+            foreach($lines as $line)
+                header(sprintf('%s: %s', $name, (string)$line));
+        }
+
+        if($response->hasContent())
+            echo (string)$response->getContent();
+    }
+
+    /**
+     * Apply middleware functions to a path.
+     *
+     * @param string $path Path to apply the middleware to.
+     * @param callable $handler Middleware function.
+     */
+    public function use(string $path, callable $handler): void {
+        $this->router->use($path, $handler);
+    }
+
+    /**
+     * Merges another router with this one with possibility of changing its root.
+     *
+     * @param string $path Base path to use.
+     * @param Router $router Router object to inherit from.
+     */
+    public function merge(string $path, Router $router): void {
+        $this->router->merge($path, $router);
+    }
+
+    /**
+     * Adds a new route.
+     *
+     * @param string $method Request method.
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function add(string $method, string $path, callable $handler): void {
+        $this->router->add($method, $path, $handler);
+    }
+
+    /**
+     * Adds a new GET route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function get(string $path, callable $handler): void {
+        $this->router->add('get', $path, $handler);
+    }
+
+    /**
+     * Adds a new POST route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function post(string $path, callable $handler): void {
+        $this->router->add('post', $path, $handler);
+    }
+
+    /**
+     * Adds a new DELETE route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function delete(string $path, callable $handler): void {
+        $this->router->add('delete', $path, $handler);
+    }
+
+    /**
+     * Adds a new PATCH route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function patch(string $path, callable $handler): void {
+        $this->router->add('patch', $path, $handler);
+    }
+
+    /**
+     * Adds a new PUT route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function put(string $path, callable $handler): void {
+        $this->router->add('put', $path, $handler);
+    }
+
+    /**
+     * Adds a new OPTIONS route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function options(string $path, callable $handler): void {
+        $this->router->add('options', $path, $handler);
+    }
+}
diff --git a/src/Http/HttpHeader.php b/src/Http/HttpHeader.php
new file mode 100644
index 0000000..68873a4
--- /dev/null
+++ b/src/Http/HttpHeader.php
@@ -0,0 +1,34 @@
+<?php
+// HttpHeader.php
+// Created: 2022-02-14
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use Stringable;
+
+class HttpHeader implements Stringable {
+    private string $name;
+    private array $lines;
+
+    public function __construct(string $name, string ...$lines) {
+        $this->name = $name;
+        $this->lines = $lines;
+    }
+
+    public function getName(): string {
+        return $this->name;
+    }
+
+    public function getLines(): array {
+        return $this->lines;
+    }
+
+    public function getFirstLine(): string {
+        return $this->lines[0];
+    }
+
+    public function __toString(): string {
+        return implode(', ', $this->lines);
+    }
+}
diff --git a/src/Http/HttpHeaders.php b/src/Http/HttpHeaders.php
new file mode 100644
index 0000000..391450b
--- /dev/null
+++ b/src/Http/HttpHeaders.php
@@ -0,0 +1,56 @@
+<?php
+// HttpHeaders.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use RuntimeException;
+
+class HttpHeaders {
+    private array $headers;
+
+    public function __construct(array $headers) {
+        $real = [];
+
+        foreach($headers as $header)
+            if($header instanceof HttpHeader)
+                $real[strtolower((string)$header->getName())] = $header;
+
+        $this->headers = $real;
+    }
+
+    public function hasHeader(string $name): bool {
+        return isset($this->headers[strtolower($name)]);
+    }
+
+    public function getHeaders(): array {
+        return array_values($this->headers);
+    }
+
+    public function getHeader(string $name): HttpHeader {
+        $name = strtolower($name);
+        if(!isset($this->headers[$name]))
+            throw new RuntimeException('No header with that name is present.');
+
+        return $this->headers[$name];
+    }
+
+    public function getHeaderLine(string $name): string {
+        if(!$this->hasHeader($name))
+            return '';
+        return (string)$this->getHeader($name);
+    }
+
+    public function getHeaderLines(string $name): array {
+        if(!$this->hasHeader($name))
+            return [];
+        return $this->getHeader($name)->getLines();
+    }
+
+    public function getHeaderFirstLine(string $name): string {
+        if(!$this->hasHeader($name))
+            return '';
+        return $this->getHeader($name)->getFirstLine();
+    }
+}
diff --git a/src/Http/HttpHeadersBuilder.php b/src/Http/HttpHeadersBuilder.php
new file mode 100644
index 0000000..ec85c19
--- /dev/null
+++ b/src/Http/HttpHeadersBuilder.php
@@ -0,0 +1,40 @@
+<?php
+// HttpHeadersBuilder.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use InvalidArgumentException;
+
+class HttpHeadersBuilder {
+    private array $headers = [];
+
+    public function addHeader(string $name, mixed $value): void {
+        $nameLower = strtolower($name);
+        if(!isset($this->headers[$nameLower]))
+            $this->headers[$nameLower] = [$name];
+        $this->headers[$nameLower][] = $value;
+    }
+
+    public function setHeader(string $name, mixed $value): void {
+        $this->headers[strtolower($name)] = [$name, $value];
+    }
+
+    public function removeHeader(string $name): void {
+        unset($this->headers[strtolower($name)]);
+    }
+
+    public function hasHeader(string $name): bool {
+        return isset($this->headers[strtolower($name)]);
+    }
+
+    public function toHeaders(): HttpHeaders {
+        $headers = [];
+
+        foreach($this->headers as $index => $lines)
+            $headers[] = new HttpHeader(array_shift($lines), ...$lines);
+
+        return new HttpHeaders($headers);
+    }
+}
diff --git a/src/Http/HttpMessage.php b/src/Http/HttpMessage.php
new file mode 100644
index 0000000..1ee8c0e
--- /dev/null
+++ b/src/Http/HttpMessage.php
@@ -0,0 +1,83 @@
+<?php
+// HttpMessage.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use Index\Version;
+use Index\IO\Stream;
+use Index\Http\Content\IHttpContent;
+use Index\Http\Content\BencodedContent;
+use Index\Http\Content\FormContent;
+use Index\Http\Content\JsonContent;
+use Index\Http\Content\StreamContent;
+use Index\Http\Content\StringContent;
+
+abstract class HttpMessage {
+    private Version $version;
+    private HttpHeaders $headers;
+    private ?IHttpContent $content;
+
+    public function __construct(Version $version, HttpHeaders $headers, ?IHttpContent $content) {
+        $this->version = $version;
+        $this->headers = $headers;
+        $this->content = $content;
+    }
+
+    public function getHttpVersion(): Version {
+        return $this->version;
+    }
+
+    public function getHeaders(): array {
+        return $this->headers->getHeaders();
+    }
+
+    public function hasHeader(string $name): bool {
+        return $this->headers->hasHeader($name);
+    }
+
+    public function getHeader(string $name): HttpHeader {
+        return $this->headers->getHeader($name);
+    }
+
+    public function getHeaderLine(string $name): string {
+        return $this->headers->getHeaderLine($name);
+    }
+
+    public function getHeaderLines(string $name): array {
+        return $this->headers->getHeaderLines($name);
+    }
+
+    public function getHeaderFirstLine(string $name): string {
+        return $this->headers->getHeaderFirstLine($name);
+    }
+
+    public function hasContent(): bool {
+        return $this->content !== null;
+    }
+
+    public function getContent(): ?IHttpContent {
+        return $this->content;
+    }
+
+    public function isJsonContent(): bool {
+        return $this->content instanceof JsonContent;
+    }
+
+    public function isFormContent(): bool {
+        return $this->content instanceof FormContent;
+    }
+
+    public function isStreamContent(): bool {
+        return $this->content instanceof StreamContent;
+    }
+
+    public function isStringContent(): bool {
+        return $this->content instanceof StringContent;
+    }
+
+    public function isBencodedContent(): bool {
+        return $this->content instanceof BencodedContent;
+    }
+}
diff --git a/src/Http/HttpMessageBuilder.php b/src/Http/HttpMessageBuilder.php
new file mode 100644
index 0000000..3a58dba
--- /dev/null
+++ b/src/Http/HttpMessageBuilder.php
@@ -0,0 +1,70 @@
+<?php
+// HttpMessageBuilder.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use Index\Version;
+use Index\IO\Stream;
+use Index\Http\Content\IHttpContent;
+use Index\Http\Content\StreamContent;
+use Index\Http\Content\StringContent;
+
+class HttpMessageBuilder {
+    private ?Version $version = null;
+    private HttpHeadersBuilder $headers;
+    private ?IHttpContent $content = null;
+
+    public function __construct() {
+        $this->headers = new HttpHeadersBuilder;
+    }
+
+    protected function getHttpVersion(): Version {
+        return $this->version ?? new Version(1, 1);
+    }
+
+    public function setHttpVersion(Version $version): void {
+        $this->version = $version;
+    }
+
+    protected function getHeaders(): HttpHeaders {
+        return $this->headers->toHeaders();
+    }
+
+    public function getHeadersBuilder(): HttpHeadersBuilder {
+        return $this->headers;
+    }
+
+    public function addHeader(string $name, mixed $value): void {
+        $this->headers->addHeader($name, $value);
+    }
+
+    public function setHeader(string $name, mixed $value): void {
+        $this->headers->setHeader($name, $value);
+    }
+
+    public function removeHeader(string $name): void {
+        $this->headers->removeHeader($name);
+    }
+
+    public function hasHeader(string $name): bool {
+        return $this->headers->hasHeader($name);
+    }
+
+    protected function getContent(): ?IHttpContent {
+        return $this->content;
+    }
+
+    public function hasContent(): bool {
+        return $this->content !== null;
+    }
+
+    public function setContent(IHttpContent|Stream|string|null $content): void {
+        if($content instanceof Stream)
+            $content = new StreamContent($content);
+        elseif(is_string($content))
+            $content = new StringContent($content);
+        $this->content = $content;
+    }
+}
diff --git a/src/Http/HttpRequest.php b/src/Http/HttpRequest.php
new file mode 100644
index 0000000..3ec2283
--- /dev/null
+++ b/src/Http/HttpRequest.php
@@ -0,0 +1,142 @@
+<?php
+// HttpRequest.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use InvalidArgumentException;
+use Index\Version;
+use Index\MediaType;
+use Index\Http\Content\IHttpContent;
+use Index\Http\Content\JsonContent;
+use Index\Http\Content\StreamContent;
+use Index\Http\Content\FormContent;
+
+class HttpRequest extends HttpMessage {
+    private string $method;
+    private string $path;
+    private array $params;
+    private array $cookies;
+
+    public function __construct(
+        Version $version,
+        string $method,
+        string $path,
+        array $params,
+        array $cookies,
+        HttpHeaders $headers,
+        ?IHttpContent $content
+    ) {
+        $this->method = $method;
+        $this->path = $path;
+        $this->params = $params;
+        $this->cookies = $cookies;
+
+        parent::__construct($version, $headers, $content);
+    }
+
+    public function getMethod(): string {
+        return $this->method;
+    }
+
+    public function getPath(): string {
+        return $this->path;
+    }
+
+    public function getParamString(): string {
+        return http_build_query($this->params);
+    }
+
+    public function getParams(): array {
+        return $this->params;
+    }
+
+    public function getParam(string $name, int $filter = FILTER_DEFAULT, array|int $options = 0): mixed {
+        if(!isset($this->params[$name]))
+            return null;
+        return filter_var($this->params[$name] ?? null, $filter, $options);
+    }
+
+    public function hasParam(string $name): bool {
+        return isset($this->params[$name]);
+    }
+
+    public function getCookies(): array {
+        return $this->cookies;
+    }
+
+    public function getCookie(string $name, int $filter = FILTER_DEFAULT, array|int $options = 0): mixed {
+        if(!isset($this->cookies[$name]))
+            return null;
+        return filter_var($this->cookies[$name] ?? null, $filter, $options);
+    }
+
+    public static function fromRequest(): HttpRequest {
+        $build = new HttpRequestBuilder;
+        $build->setHttpVersion(new Version(...array_map('intval', explode('.', substr($_SERVER['SERVER_PROTOCOL'], 5)))));
+        $build->setMethod($_SERVER['REQUEST_METHOD']);
+        $build->setPath('/' . trim(parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH), '/'));
+        $build->setParams($_GET);
+        $build->setCookies($_COOKIE);
+
+        $contentType = null;
+        $contentLength = 0;
+
+        $headers = self::getRawRequestHeaders();
+        foreach($headers as $name => $value) {
+            $nameLower = strtolower($name);
+            if($nameLower === 'content-type')
+                try {
+                    $contentType = MediaType::parse($value);
+                } catch(InvalidArgumentException $ex) {
+                    $contentType = null;
+                }
+            elseif($nameLower === 'content-length')
+                $contentLength = intval($value);
+
+            $build->setHeader($name, $value);
+        }
+
+        if($contentType !== null
+            && ($contentType->equals('application/json') || $contentType->equals('application/x-json')))
+            $build->setContent(JsonContent::fromRequest());
+        elseif($contentType !== null
+            && ($contentType->equals('application/x-www-form-urlencoded') || $contentType->equals('multipart/form-data')))
+            $build->setContent(FormContent::fromRequest());
+        elseif($contentLength > 0)
+            $build->setContent(StreamContent::fromRequest());
+
+        return $build->toRequest();
+    }
+
+    private static function getRawRequestHeaders(): array {
+        if(function_exists('getallheaders'))
+            return getallheaders();
+
+        $headers = [];
+
+        foreach($_SERVER as $key => $value) {
+            if(substr($key, 0, 5) === 'HTTP_') {
+                $key = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($key, 5)))));
+                $headers[$key] = $value;
+            } elseif($key === 'CONTENT_TYPE') {
+                $headers['Content-Type'] = $value;
+            } elseif($key === 'CONTENT_LENGTH') {
+                $headers['Content-Length'] = $value;
+            }
+        }
+
+        if(!isset($headers['Authorization'])) {
+            if(isset($_SERVER['REDIRECT_HTTP_AUTHORIZATION'])) {
+                $headers['Authorization'] = $_SERVER['REDIRECT_HTTP_AUTHORIZATION'];
+            } elseif(isset($_SERVER['PHP_AUTH_USER'])) {
+                $headers['Authorization'] = 'Basic ' . base64_encode($_SERVER['PHP_AUTH_USER'] . ':' . ($_SERVER['PHP_AUTH_PW'] ?? ''));
+            } elseif(isset($_SERVER['PHP_AUTH_DIGEST'])) {
+                $headers['Authorization'] = $_SERVER['PHP_AUTH_DIGEST'];
+            }
+        }
+
+        return $headers;
+    }
+}
diff --git a/src/Http/HttpRequestBuilder.php b/src/Http/HttpRequestBuilder.php
new file mode 100644
index 0000000..be0b3bb
--- /dev/null
+++ b/src/Http/HttpRequestBuilder.php
@@ -0,0 +1,73 @@
+<?php
+// HttpRequestBuilder.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+class HttpRequestBuilder extends HttpMessageBuilder {
+    private string $method = 'GET';
+    private string $path = '/';
+    private array $params = [];
+    private array $cookies = [];
+
+    protected function getMethod(): string {
+        return $this->method;
+    }
+
+    public function setMethod(string $method): void {
+        $this->method = $method;
+    }
+
+    protected function getPath(): string {
+        return $this->path;
+    }
+
+    public function setPath(string $path): void {
+        $this->path = $path;
+    }
+
+    protected function getParams(): array {
+        return $this->params;
+    }
+
+    public function setParams(array $params): void {
+        $this->params = $params;
+    }
+
+    public function setParam(string $name, mixed $value): void {
+        $this->params[$name] = $value;
+    }
+
+    public function removeParam(string $name): void {
+        unset($this->params[$name]);
+    }
+
+    protected function getCookies(): array {
+        return $this->cookies;
+    }
+
+    public function setCookies(array $cookies): void {
+        $this->cookies = $cookies;
+    }
+
+    public function setCookie(string $name, mixed $value): void {
+        $this->cookies[$name] = $value;
+    }
+
+    public function removeCookie(string $name): void {
+        unset($this->cookies[$name]);
+    }
+
+    public function toRequest(): HttpRequest {
+        return new HttpRequest(
+            $this->getHttpVersion(),
+            $this->getMethod(),
+            $this->getPath(),
+            $this->getParams(),
+            $this->getCookies(),
+            $this->getHeaders(),
+            $this->getContent()
+        );
+    }
+}
diff --git a/src/Http/HttpResponse.php b/src/Http/HttpResponse.php
new file mode 100644
index 0000000..360f289
--- /dev/null
+++ b/src/Http/HttpResponse.php
@@ -0,0 +1,35 @@
+<?php
+// HttpResponse.php
+// Created: 2022-02-08
+// Updated: 2022-02-10
+
+namespace Index\Http;
+
+use Index\Version;
+use Index\Http\Content\IHttpContent;
+
+class HttpResponse extends HttpMessage {
+    private int $statusCode;
+    private string $statusText;
+
+    public function __construct(
+        Version $version,
+        int $statusCode,
+        string $statusText,
+        HttpHeaders $headers,
+        ?IHttpContent $content
+    ) {
+        $this->statusCode = $statusCode;
+        $this->statusText = $statusText;
+
+        parent::__construct($version, $headers, $content);
+    }
+
+    public function getStatusCode(): int {
+        return $this->statusCode;
+    }
+
+    public function getStatusText(): string {
+        return $this->statusText;
+    }
+}
diff --git a/src/Http/HttpResponseBuilder.php b/src/Http/HttpResponseBuilder.php
new file mode 100644
index 0000000..b98159f
--- /dev/null
+++ b/src/Http/HttpResponseBuilder.php
@@ -0,0 +1,263 @@
+<?php
+// HttpResponseBuilder.php
+// Created: 2022-02-08
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use DateTimeInterface;
+use Index\DateTime;
+use Index\UrlEncoding;
+use Index\MediaType;
+use Index\Performance\Timings;
+
+class HttpResponseBuilder extends HttpMessageBuilder {
+    private int $statusCode = -1;
+    private ?string $statusText;
+    private array $vary = [];
+
+    public function getStatusCode(): int {
+        return $this->statusCode < 0 ? 200 : $this->statusCode;
+    }
+
+    public function setStatusCode(int $statusCode): void {
+        $this->statusCode = $statusCode;
+    }
+
+    public function hasStatusCode(): bool {
+        return $this->statusCode >= 100;
+    }
+
+    public function getStatusText(): string {
+        return $this->statusText ?? self::STATUS[$this->getStatusCode()] ?? 'Unknown Status';
+    }
+
+    public function setStatusText(string $statusText): void {
+        $this->statusText = (string)$statusText;
+    }
+
+    public function clearStatusText(): void {
+        $this->statusText = null;
+    }
+
+    public function addCookie(
+        string $name,
+        mixed $value,
+        DateTimeInterface|int|null $expires = null,
+        string $path = '',
+        string $domain = '',
+        bool $secure = false,
+        bool $httpOnly = false,
+        bool $sameSiteStrict = false
+    ): void {
+        $cookie = rawurlencode($name) . '=' . rawurlencode($value)
+            . '; SameSite=' . ($sameSiteStrict ? 'Strict' : 'Lax');
+
+        if($expires !== null) {
+            if(!($expires instanceof DateTime)) {
+                if(is_int($expires))
+                    $expires = DateTime::fromUnixTimeSeconds($expires);
+                else
+                    $expires = DateTime::createFromInterface($expires);
+            }
+
+            $maxAge = $expires->difference(DateTime::now())->totalSeconds();
+            $expires = $expires->toCookieString();
+            $cookie .= '; Expires=' . $expires . '; Max-Age=' . $maxAge;
+        }
+
+        if(!empty($domain))
+            $cookie .= '; Domain=' . $domain;
+
+        if(!empty($path))
+            $cookie .= '; Path=' . $path;
+
+        if($secure)
+            $cookie .= '; Secure';
+
+        if($httpOnly)
+            $cookie .= '; HttpOnly';
+
+        $this->addHeader('Set-Cookie', $cookie);
+    }
+
+    public function redirect(string $to, bool $permanent = false): void {
+        $this->setStatusCode($permanent ? 301 : 302);
+        $this->setHeader('Location', $to);
+    }
+
+    public function addVary(string|array $headers): void {
+        if(!is_array($headers))
+            $headers = [$headers];
+
+        foreach($headers as $header) {
+            $header = $header;
+            if(!in_array($header, $this->vary))
+                $this->vary[] = $header;
+        }
+
+        $this->setHeader('Vary', implode(', ', $this->vary));
+    }
+
+    public function setPoweredBy(string $poweredBy): void {
+        $this->setHeader('X-Powered-By', $poweredBy);
+    }
+
+    public function setEntityTag(string $eTag, bool $weak = false): void {
+        $eTag = '"' . $eTag . '"';
+
+        if($weak)
+            $eTag = 'W/' . $eTag;
+
+        $this->setHeader('ETag', $eTag);
+    }
+
+    public function setServerTiming(Timings $timings): void {
+        $laps = $timings->getLaps();
+        $timings = [];
+
+        foreach($laps as $lap) {
+            $timing = $lap->getName();
+            if($lap->hasComment())
+                $timing .= ';desc="' . strtr($lap->getComment(), ['"' => '\\"']) . '"';
+
+            $timing .= ';dur=' . round($lap->getDurationTime(), 5);
+            $timings[] = $timing;
+        }
+
+        $this->setHeader('Server-Timing', implode(', ', $timings));
+    }
+
+    public function hasContentType(): bool {
+        return $this->hasHeader('Content-Type');
+    }
+
+    public function setContentType(MediaType|string $mediaType): void {
+        $this->setHeader('Content-Type', (string)$mediaType);
+    }
+
+    public function setTypeStream(): void {
+        $this->setContentType('application/octet-stream');
+    }
+
+    public function setTypePlain(string $charset = 'us-ascii'): void {
+        $this->setContentType('text/plain; charset=' . $charset);
+    }
+
+    public function setTypeHTML(string $charset = 'utf-8'): void {
+        $this->setContentType('text/html; charset=' . $charset);
+    }
+
+    public function setTypeJson(string $charset = 'utf-8'): void {
+        $this->setContentType('application/json; charset=' . $charset);
+    }
+
+    public function setTypeXML(string $charset = 'utf-8'): void {
+        $this->setContentType('application/xml; charset=' . $charset);
+    }
+
+    public function setTypeCSS(string $charset = 'utf-8'): void {
+        $this->setContentType('text/css; charset=' . $charset);
+    }
+
+    public function setTypeJS(string $charset = 'utf-8'): void {
+        $this->setContentType('application/javascript; charset=' . $charset);
+    }
+
+    public function sendFile(string $absolutePath): void {
+        $this->setHeader('X-Sendfile', $absolutePath);
+    }
+
+    public function accelRedirect(string $uri): void {
+        $this->setHeader('X-Accel-Redirect', $uri);
+    }
+
+    public function setFileName(string $fileName, bool $attachment = false): void {
+        $this->setHeader(
+            'Content-Disposition',
+            sprintf(
+                '%s; filename="%s"',
+                ($attachment ? 'attachment' : 'inline'),
+                $fileName
+            )
+        );
+    }
+
+    public function clearSiteData(string ...$directives): void {
+        $this->setHeader(
+            'Clear-Site-Data',
+            implode(', ', array_map(fn($directive) => sprintf('"%s"', $directive), $directives))
+        );
+    }
+
+    public function setCacheControl(string ...$directives): void {
+        $this->setHeader('Cache-Control', implode(', ', $directives));
+    }
+
+    public function toResponse(): HttpResponse {
+        return new HttpResponse(
+            $this->getHttpVersion(),
+            $this->getStatusCode(),
+            $this->getStatusText(),
+            $this->getHeaders(),
+            $this->getContent()
+        );
+    }
+
+    private const STATUS = [
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        103 => 'Early Hints',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        307 => 'Temporary Redirect',
+        308 => 'Permanent Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Required',
+        413 => 'Payload Too Large',
+        414 => 'URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        418 => 'I\'m a teapot',
+        422 => 'Unprocessable Entity',
+        425 => 'Too Early',
+        426 => 'Upgrade Required',
+        428 => 'Precondition Required',
+        429 => 'Too Many Requests',
+        431 => 'Request Header Fields Too Large',
+        451 => 'Unavailable For Legal Reasons',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        506 => 'Variant Also Negotiates',
+        507 => 'Insufficient Storage',
+        508 => 'Loop Detected',
+        510 => 'Not Extended',
+        511 => 'Network Authentication Required',
+    ];
+}
diff --git a/src/Http/HttpUploadedFile.php b/src/Http/HttpUploadedFile.php
new file mode 100644
index 0000000..aa7a35c
--- /dev/null
+++ b/src/Http/HttpUploadedFile.php
@@ -0,0 +1,188 @@
+<?php
+// HttpUploadedFile.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index\Http;
+
+use Index\MediaType;
+use Index\ICloseable;
+use Index\IO\Stream;
+use Index\IO\FileStream;
+use InvalidArgumentException;
+use RuntimeException;
+
+class HttpUploadedFile implements ICloseable {
+    private int $errorCode;
+    private int $size;
+    private string $localFileName;
+    private string $suggestedFileName;
+    private MediaType $suggestedMediaType;
+    private bool $hasMoved = false;
+    private ?Stream $stream = null;
+
+    public function __construct(
+        int $errorCode,
+        int $size,
+        string $localFileName,
+        string $suggestedFileName,
+        MediaType|string $suggestedMediaType
+    ) {
+        if(!($suggestedMediaType instanceof MediaType))
+            $suggestedMediaType = MediaType::parse($suggestedMediaType);
+
+        $this->errorCode = $errorCode;
+        $this->size = $size;
+        $this->localFileName = $localFileName;
+        $this->suggestedFileName = $suggestedFileName;
+        $this->suggestedMediaType = $suggestedMediaType;
+    }
+
+    public function getErrorCode(): int {
+        return $this->errorCode;
+    }
+
+    public function getSize(): int {
+        return $this->size;
+    }
+
+    public function getLocalFileName(): ?string {
+        return $this->localFileName;
+    }
+
+    public function getLocalMediaType(): ?MediaType {
+        return MediaType::fromPath($this->localFileName);
+    }
+
+    public function getSuggestedFileName(): string {
+        return $this->suggestedFileName;
+    }
+
+    public function getSuggestedMediaType(): MediaType {
+        return $this->suggestedMediaType;
+    }
+
+    public function hasMoved(): bool {
+        return $this->hasMoved;
+    }
+
+    public function getStream(): Stream {
+        if($this->stream === null) {
+            if($this->errorCode !== UPLOAD_ERR_OK)
+                throw new RuntimeException('Can\'t open stream because of an upload error.');
+            if($this->hasMoved)
+                throw new RuntimeException('Can\'t open stream because file has already been moved.');
+
+            $this->stream = FileStream::openRead($this->localFileName);
+        }
+
+        return $this->stream;
+    }
+
+    public function moveTo(string $path): void {
+        if($this->hasMoved)
+            throw new RuntimeException('This uploaded file has already been moved.');
+        if($this->errorCode !== UPLOAD_ERR_OK)
+            throw new RuntimeException('Can\'t move file because of an upload error.');
+
+        if(empty($path))
+            throw new InvalidArgumentException('$path is not a valid path.');
+
+        if($this->stream !== null)
+            $this->stream->close();
+
+        $this->hasMoved = PHP_SAPI === 'CLI'
+            ? rename($this->localFileName, $path)
+            : move_uploaded_file($this->localFileName, $path);
+
+        if(!$this->hasMoved)
+            throw new RuntimeException('Failed to move file to ' . $path);
+
+        $this->localFileName = $path;
+    }
+
+    public function close(): void {
+        if($this->stream !== null)
+            $this->stream->close();
+    }
+
+    public function __destruct() {
+        $this->close();
+    }
+
+    public static function createFromFILE(array $file): self {
+        return new HttpUploadedFile(
+            $file['error'] ?? UPLOAD_ERR_NO_FILE,
+            $file['size'] ?? -1,
+            $file['tmp_name'] ?? '',
+            $file['name'] ?? '',
+            $file['type'] ?? ''
+        );
+    }
+
+    public static function createFromFILES(array $files): array {
+        if(empty($files))
+            return [];
+
+        return self::createObjectInstances(self::normalizeFILES($files));
+    }
+
+    private static function traverseFILES(array $files, string $keyName): array {
+        $arr = [];
+
+        foreach($files as $key => $val) {
+            $key = "_{$key}";
+
+            if(is_array($val)) {
+                $arr[$key] = self::traverseFILES($val, $keyName);
+            } else {
+                $arr[$key][$keyName] = $val;
+            }
+        }
+
+        return $arr;
+    }
+
+    private static function normalizeFILES(array $files): array {
+        $out = [];
+
+        foreach($files as $key => $arr) {
+            if(empty($arr))
+                continue;
+
+            $key = '_' . $key;
+
+            if(is_int($arr['error'])) {
+                $out[$key] = $arr;
+                continue;
+            }
+
+            if(is_array($arr['error'])) {
+                $keys = array_keys($arr);
+
+                foreach($keys as $keyName) {
+                    $out[$key] = array_merge_recursive($out[$key] ?? [], self::traverseFILES($arr[$keyName], $keyName));
+                }
+                continue;
+            }
+        }
+
+        return $out;
+    }
+
+    private static function createObjectInstances(array $files): array {
+        $coll = [];
+
+        foreach($files as $key => $val) {
+            $key = substr($key, 1);
+
+            if(isset($val['error'])) {
+                $coll[$key] = self::createFromFILE($val);
+            } else {
+                $coll[$key] = self::createObjectInstances($val);
+            }
+        }
+
+        return $coll;
+    }
+}
diff --git a/src/ICloneable.php b/src/ICloneable.php
new file mode 100644
index 0000000..5011995
--- /dev/null
+++ b/src/ICloneable.php
@@ -0,0 +1,18 @@
+<?php
+// ICloneable.php
+// Created: 2021-04-26
+// Updated: 2021-05-12
+
+namespace Index;
+
+/**
+ * Provides an interface for creating a clone of an object in a controlled manner.
+ */
+interface ICloneable {
+    /**
+     * Create a new object that is a copy of the current instance.
+     *
+     * @return mixed A copy of the current instance.
+     */
+    function clone(): mixed;
+}
diff --git a/src/ICloseable.php b/src/ICloseable.php
new file mode 100644
index 0000000..fcf91ef
--- /dev/null
+++ b/src/ICloseable.php
@@ -0,0 +1,30 @@
+<?php
+// ICloseable.php
+// Created: 2021-04-30
+// Updated: 2021-05-12
+
+namespace Index;
+
+/**
+ * Provides an interface for releasing unmanaged resources.
+ *
+ * If ICloseable is implemented __destruct() should also be added to the class and should call close in it:
+ *
+ * <code>
+ * public function close(): void {
+ *     fclose($this->resource);
+ * }
+ *
+ * public function __destruct() {
+ *     $this->close();
+ * }
+ * </code>
+ *
+ * However if close() is only implemented because a parent interface requires it, the __destruct() implementation may be omitted.
+ */
+interface ICloseable {
+    /**
+     * Free, release or reset unmanaged resources.
+     */
+    function close(): void;
+}
diff --git a/src/IComparable.php b/src/IComparable.php
new file mode 100644
index 0000000..41d1ad9
--- /dev/null
+++ b/src/IComparable.php
@@ -0,0 +1,20 @@
+<?php
+// IComparable.php
+// Created: 2021-04-30
+// Updated: 2021-05-12
+
+namespace Index;
+
+/**
+ * Provides an interface for comparison between objects. Allows for order/sorting instances.
+ */
+interface IComparable {
+    /**
+     * Compares the current instance with another and returns an integer that indicates whether
+     *  the current object comes before or after or the same position and the other object.
+     *
+     * @return int A value that indicates the relative order of the objects being compared.
+     *             Less than zero for before, zero for same position, greater than zero for after.
+     */
+    function compare(mixed $other): int;
+}
diff --git a/src/IEquatable.php b/src/IEquatable.php
new file mode 100644
index 0000000..14f02b9
--- /dev/null
+++ b/src/IEquatable.php
@@ -0,0 +1,18 @@
+<?php
+// IEquatable.php
+// Created: 2021-04-26
+// Updated: 2021-05-12
+
+namespace Index;
+
+/**
+ * Provides an interface for determining the value-equality of two objects.
+ */
+interface IEquatable {
+    /**
+     * Checks whether the current object is equal to another.
+     *
+     * @return bool true if the objects are equals, false if not.
+     */
+    function equals(mixed $other): bool;
+}
diff --git a/src/IO/FileStream.php b/src/IO/FileStream.php
new file mode 100644
index 0000000..ae807fa
--- /dev/null
+++ b/src/IO/FileStream.php
@@ -0,0 +1,85 @@
+<?php
+// FileStream.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\IO;
+
+use ErrorException;
+
+class FileStream extends GenericStream {
+    public const OPEN_READ                  = 'rb';  // O  R   E  // Open file for reading, throw if not exists
+    public const OPEN_READ_WRITE            = 'r+b'; // O  RW  E  // Open file for reading and writing, throw if not exist
+    public const NEW_WRITE                  = 'wb';  //  C  W   T // Create file for writing, truncate if exist
+    public const NEW_READ_WRITE             = 'w+b'; //  C RW   T // Create file for reading and writing, truncate if exist
+    public const APPEND_WRITE               = 'ab';  // OC   A    // Open file for appending, create if not exist
+    public const APPEND_READ_WRITE          = 'a+b'; // OC R A    // Open file for reading and appending, create if not exist
+    public const CREATE_WRITE               = 'xb';  //  C  W   T // Create file for writing, throw if exist
+    public const CREATE_READ_WRITE          = 'x+b'; //  C RW   T // Create file for reading and writing, throw if exist
+    public const OPEN_OR_CREATE_WRITE       = 'cb';  // OC  W     // Opens or creates a file for writing
+    public const OPEN_OR_CREATE_READ_WRITE  = 'c+b'; // OC RW     // Opens or creates a file for reading and writing
+
+    public const LOCK_NONE         = 0;
+    public const LOCK_READ         = LOCK_SH;
+    public const LOCK_WRITE        = LOCK_EX;
+    public const LOCK_NON_BLOCKING = LOCK_NB;
+
+    private int $lock;
+
+    public function __construct(string $path, string $mode, int $lock) {
+        $this->lock = $lock;
+
+        try {
+            $stream = fopen($path, $mode);
+        } catch(ErrorException $ex) {
+            throw new IOException('An error occurred while trying to open a file.', $ex->getCode(), $ex);
+        }
+
+        if($stream === false)
+            throw new IOException('An unhandled error occurred while trying to open a file. Exceptions::convertErrors() has probably not been called.');
+
+        parent::__construct($stream);
+
+        if($this->lock & self::LOCK_WRITE)
+            flock($this->stream, LOCK_EX);
+        elseif($this->lock & self::LOCK_READ)
+            flock($this->stream, LOCK_SH);
+    }
+
+    public function close(): void {
+        if($this->lock !== self::LOCK_NONE)
+            flock($this->stream, LOCK_UN);
+        parent::close();
+    }
+
+    public static function openRead(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::OPEN_READ, $lock);
+    }
+    public static function openReadWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::OPEN_READ_WRITE, $lock);
+    }
+    public static function newWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::NEW_WRITE, $lock);
+    }
+    public static function newReadWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::NEW_READ_WRITE, $lock);
+    }
+    public static function appendWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::APPEND_WRITE, $lock);
+    }
+    public static function appendReadWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::APPEND_READ_WRITE, $lock);
+    }
+    public static function createWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::CREATE_WRITE, $lock);
+    }
+    public static function createReadWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::CREATE_READ_WRITE, $lock);
+    }
+    public static function openOrCreateWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::OPEN_OR_CREATE_WRITE, $lock);
+    }
+    public static function openOrCreateReadWrite(string $path, int $lock = self::LOCK_NONE): FileStream {
+        return new FileStream($path, self::OPEN_OR_CREATE_READ_WRITE, $lock);
+    }
+}
diff --git a/src/IO/GenericStream.php b/src/IO/GenericStream.php
new file mode 100644
index 0000000..051c67a
--- /dev/null
+++ b/src/IO/GenericStream.php
@@ -0,0 +1,133 @@
+<?php
+// GenericStream.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\IO;
+
+use InvalidArgumentException;
+
+class GenericStream extends Stream {
+    public const READABLE = [
+        'r',  'rb',  'r+', 'r+b', 'w+', 'w+b',
+        'a+', 'a+b', 'x+', 'x+b', 'c+', 'c+b',
+    ];
+    public const WRITEABLE = [
+        'r+', 'r+b', 'w',  'wb',  'w+', 'w+b',
+        'a',  'ab',  'a+', 'a+b', 'x',  'xb',
+        'x+', 'x+b', 'c',  'cb',  'c+', 'c+b',
+    ];
+
+    protected $stream; // resource
+
+    private bool $canRead;
+    private bool $canWrite;
+    private bool $canSeek;
+
+    public function __construct($stream) {
+        if(!is_resource($stream) || get_resource_type($stream) !== 'stream')
+            throw new InvalidArgumentException('$stream is not a valid stream resource.');
+        $this->stream = $stream;
+
+        $metaData = $this->metaData();
+        $this->canRead = in_array($metaData['mode'], self::READABLE);
+        $this->canWrite = in_array($metaData['mode'], self::WRITEABLE);
+        $this->canSeek = $metaData['seekable'];
+    }
+
+    public function getResource() {
+        return $this->stream;
+    }
+
+    private function stat(): array {
+        return fstat($this->stream);
+    }
+
+    public function getPosition(): int {
+        return ftell($this->stream);
+    }
+
+    public function getLength(): int {
+        if(!$this->canSeek())
+            return -1;
+        return $this->stat()['size'];
+    }
+    public function setLength(int $length): void {
+        ftruncate($this->stream, $length);
+    }
+
+    private function metaData(): array {
+        return stream_get_meta_data($this->stream);
+    }
+    public function canRead(): bool {
+        return $this->canRead;
+    }
+    public function canWrite(): bool {
+        return $this->canWrite;
+    }
+    public function canSeek(): bool {
+        return $this->canSeek;
+    }
+    public function hasTimedOut(): bool {
+        return $this->metaData()['timed_out'];
+    }
+    public function isBlocking(): bool {
+        return $this->metaData()['blocked'];
+    }
+
+    public function isEnded(): bool {
+        return feof($this->stream);
+    }
+
+    public function readChar(): ?string {
+        $char = fgetc($this->stream);
+        if($char === false)
+            return null;
+        return $char;
+    }
+
+    public function readLine(): ?string {
+        return ($line = fgets($this->stream)) === false
+            ? null : $line;
+    }
+
+    public function read(int $length): ?string {
+        $buffer = fread($this->stream, $length);
+        if($buffer === false)
+            return null;
+        return $buffer;
+    }
+
+    public function seek(int $offset, int $origin = Stream::START): int {
+        return fseek($this->stream, $offset, $origin);
+    }
+
+    public function write(string $buffer, int $length = -1): void {
+        if($length >= 0)
+            fwrite($this->stream, $buffer, $length);
+        else
+            fwrite($this->stream, $buffer);
+    }
+
+    public function writeChar(string $char): void {
+        fwrite($this->stream, $char, 1);
+    }
+
+    public function flush(): void {
+        fflush($this->stream);
+    }
+
+    public function close(): void {
+        fclose($this->stream);
+    }
+
+    public function copyTo(Stream $other): void {
+        if($other instanceof GenericStream) {
+            stream_copy_to_stream($this->stream, $other->stream);
+        } else parent::copyTo($other);
+    }
+
+    public function __toString(): string {
+        return stream_get_contents($this->stream);
+    }
+}
diff --git a/src/IO/IOException.php b/src/IO/IOException.php
new file mode 100644
index 0000000..212a07f
--- /dev/null
+++ b/src/IO/IOException.php
@@ -0,0 +1,10 @@
+<?php
+// IOException.php
+// Created: 2021-04-30
+// Updated: 2021-04-30
+
+namespace Index\IO;
+
+use RuntimeException;
+
+class IOException extends RuntimeException {}
diff --git a/src/IO/MemoryStream.php b/src/IO/MemoryStream.php
new file mode 100644
index 0000000..06340af
--- /dev/null
+++ b/src/IO/MemoryStream.php
@@ -0,0 +1,18 @@
+<?php
+// MemoryStream.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+namespace Index\IO;
+
+class MemoryStream extends GenericStream {
+    public function __construct() {
+        parent::__construct(fopen('php://memory', 'r+b'));
+    }
+
+    public static function fromString(string $string): MemoryStream {
+        $stream = new MemoryStream;
+        $stream->write($string);
+        return $stream;
+    }
+}
diff --git a/src/IO/NetworkStream.php b/src/IO/NetworkStream.php
new file mode 100644
index 0000000..abc7fd2
--- /dev/null
+++ b/src/IO/NetworkStream.php
@@ -0,0 +1,63 @@
+<?php
+// NetworkStream.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\IO;
+
+use ErrorException;
+use Index\Net\IPAddress;
+use Index\Net\EndPoint;
+
+class NetworkStream extends GenericStream {
+    public function __construct(string $hostname, int $port, float|null $timeout) {
+        try {
+            $stream = fsockopen($hostname, $port, $errcode, $errmsg, $timeout);
+        } catch(ErrorException $ex) {
+            throw new IOException('An error occurred while trying to connect.', $ex->getCode(), $ex);
+        }
+
+        if($stream === false)
+            throw new IOException('An unhandled error occurred while trying to connect. Exceptions::convertErrors() has probably not been called.');
+
+        parent::__construct($stream);
+    }
+
+    public function setBlocking(bool $blocking): void {
+        stream_set_blocking($this->stream, $blocking);
+    }
+
+    public static function openEndPoint(EndPoint $endPoint, float|null $timeout = null): NetworkStream {
+        return new NetworkStream((string)$endPoint, -1, $timeout);
+    }
+    public static function openEndPointSSL(EndPoint $endPoint, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('ssl://' . ((string)$endPoint), -1, $timeout);
+    }
+    public static function openEndPointTLS(EndPoint $endPoint, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('tls://' . ((string)$endPoint), -1, $timeout);
+    }
+
+    public static function openHost(string $hostname, int $port, float|null $timeout = null): NetworkStream {
+        return new NetworkStream($hostname, $port, $timeout);
+    }
+    public static function openHostSSL(string $hostname, int $port, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('ssl://' . ((string)$hostname), $port, $timeout);
+    }
+    public static function openHostTLS(string $hostname, int $port, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('tls://' . ((string)$hostname), $port, $timeout);
+    }
+
+    public static function openAddress(IPAddress $address, int $port, float|null $timeout = null): NetworkStream {
+        return new NetworkStream($address->getAddress(), $port, $timeout);
+    }
+    public static function openAddressSSL(IPAddress $address, int $port, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('ssl://' . $address->getAddress(), $port, $timeout);
+    }
+    public static function openAddressTLS(IPAddress $address, int $port, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('tls://' . $address->getAddress(), $port, $timeout);
+    }
+
+    public static function openUnix(string $path, float|null $timeout = null): NetworkStream {
+        return new NetworkStream('unix://' . ((string)$path), -1, $timeout);
+    }
+}
diff --git a/src/IO/Stream.php b/src/IO/Stream.php
new file mode 100644
index 0000000..0383372
--- /dev/null
+++ b/src/IO/Stream.php
@@ -0,0 +1,88 @@
+<?php
+// Stream.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\IO;
+
+use Stringable;
+use Index\Environment;
+use Index\ICloseable;
+
+abstract class Stream implements Stringable, ICloseable {
+    public const START = SEEK_SET;
+    public const CURRENT = SEEK_CUR;
+    public const END = SEEK_END;
+
+    abstract public function getPosition(): int;
+
+    abstract public function getLength(): int;
+    abstract public function setLength(int $length): void;
+
+    abstract public function canRead(): bool;
+
+    abstract public function canWrite(): bool;
+
+    abstract public function canSeek(): bool;
+
+    abstract public function hasTimedOut(): bool;
+
+    abstract public function isBlocking(): bool;
+
+    abstract public function isEnded(): bool;
+
+    abstract public function readChar(): ?string;
+
+    public function readByte(): int {
+        $char = $this->readChar();
+        if($char === null)
+            return -1;
+        return ord($char);
+    }
+
+    abstract public function readLine(): ?string;
+
+    abstract public function read(int $length): ?string;
+
+    abstract public function seek(int $offset, int $origin = self::START): int;
+
+    abstract public function write(string $buffer, int $length = -1): void;
+
+    public function writeLine(string $line): void {
+        $this->write($line);
+        $this->write(Environment::NEWLINE);
+    }
+
+    abstract public function writeChar(string $char): void;
+
+    public function writeByte(int $byte): void {
+        $this->writeChar(chr($byte & 0xFF));
+    }
+
+    public function copyTo(Stream $other): void {
+        if($this->canSeek())
+            $this->seek(0);
+
+        while(!$this->isEnded())
+            $other->write($this->read(8192));
+    }
+
+    abstract public function flush(): void;
+
+    abstract public function close(): void;
+
+    public function __toString(): string {
+        if($this->canSeek())
+            $this->seek(0);
+
+        $string = '';
+        while(!$this->isEnded())
+            $string .= $this->read(8192);
+
+        return $string;
+    }
+
+    public function __destruct() {
+        $this->close();
+    }
+}
diff --git a/src/IO/TempFileStream.php b/src/IO/TempFileStream.php
new file mode 100644
index 0000000..0431191
--- /dev/null
+++ b/src/IO/TempFileStream.php
@@ -0,0 +1,23 @@
+<?php
+// TempFileStream.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+namespace Index\IO;
+
+class TempFileStream extends GenericStream {
+    public const MAX_MEMORY = 2 * 1024 * 1024;
+
+    public function __construct(?string $body = null, int $maxMemory = self::MAX_MEMORY) {
+        parent::__construct(fopen("php://temp/maxmemory:{$maxMemory}", 'r+b'));
+
+        if($body !== null) {
+            $this->write($body);
+            $this->flush();
+        }
+    }
+
+    public static function fromString(string $string): TempFileStream {
+        return new TempFileStream($string);
+    }
+}
diff --git a/src/IString.php b/src/IString.php
new file mode 100644
index 0000000..193b3ec
--- /dev/null
+++ b/src/IString.php
@@ -0,0 +1,188 @@
+<?php
+// IString.php
+// Created: 2021-06-20
+// Updated: 2022-02-27
+
+namespace Index;
+
+use ArrayAccess;
+use Countable;
+use IteratorAggregate;
+use JsonSerializable;
+use Stringable;
+use Index\Serialisation\IBencodeSerialisable;
+
+interface IString extends ArrayAccess, Countable, IteratorAggregate, JsonSerializable, Stringable, IComparable, ICloneable, IEquatable, IBencodeSerialisable {
+    /**
+     * Default trim characters.
+     *
+     * @var string
+     */
+    const TRIM_CHARS = " \n\r\t\v\0";
+
+    /**
+     * Gets the length of the string.
+     *
+     * @return int Length of the string.
+     */
+    function getLength(): int;
+
+    /**
+     * Returns whether the string is empty.
+     *
+     * @return bool true if the string is empty, false if not.
+     */
+    function isEmpty(): bool;
+
+    /**
+     * Returns the index of a substring.
+     *
+     * @see https://www.php.net/manual/en/function.strpos
+     * @param IString|string $text Substring to look for.
+     * @param int $offset Offset from which to start looking.
+     * @return int Offset at which the substring can be found, -1 if the substring can't be found.
+     */
+    function indexOf(IString|string $text, int $offset = 0): int;
+
+    /**
+     * Checks whether the string contains a substring.
+     *
+     * @see https://www.php.net/manual/en/function.str-contains
+     * @param IString|string $text Substring to look for.
+     * @return bool true if it could be found, false if not.
+     */
+    function contains(IString|string $text): bool;
+
+    /**
+     * Returns a ranged substring.
+     *
+     * @see https://www.php.net/manual/en/function.substr
+     * @param int $offset Offset from which to start.
+     * @param int|null $length Amount of character to copy, null for the remainder of the string.
+     * @return IString An instance of IString containing the substring.
+     */
+    function substring(int $offset, int|null $length = null): IString;
+
+    /**
+     * Checks if a string starts with a given substring.
+     *
+     * @see https://www.php.net/manual/en/function.str-starts-with
+     * @param IString|string $text The substring to check for.
+     * @return bool true if the substring was found, false if not.
+     */
+    function startsWith(IString|string $text): bool;
+
+    /**
+     * Checks if a string ends with a given substring.
+     *
+     * @see https://www.php.net/manual/en/function.str-ends-with
+     * @param IString|string $text The substring to check for.
+     * @return bool true if the substring was found, false if not.
+     */
+    function endsWith(IString|string $text): bool;
+
+    /**
+     * Replace a substring with another substring.
+     *
+     * @see https://www.php.net/manual/en/function.str-replace
+     * @param IString|string $search Substring that should be replaced.
+     * @param IString|string $replace Replacement values for what was found with search.
+     * @return IString A new IString instance with the replaced values.
+     */
+    function replace(IString|string $search, IString|string $replace): IString;
+
+    /**
+     * Concatenates two strings with this one in the first position.
+     *
+     * @param IString|string $string String that should be appended.
+     * @return IString A new IString instance with the combined value.
+     */
+    function append(IString|string $string): IString;
+
+    /**
+     * Concatenates two strings with this one in the last position.
+     *
+     * @param IString|string $string String that should be prepended.
+     * @return IString A new IString instance with the combined value.
+     */
+    function prepend(IString|string $string): IString;
+
+    /**
+     * Split a string by a separator string into an array.
+     *
+     * Calling split with an empty string will not work, use ->chunk(1) instead.
+     *
+     * @see https://www.php.net/manual/en/function.explode
+     * @param IString|string $separator The boundary string.
+     * @param int $limit Maximum number of elements expected in the array.
+     * @return array The resulting array of substrings.
+     */
+    function split(IString|string $separator, int $limit = PHP_INT_MAX): array;
+
+    /**
+     * Splits a string in substring chunks of a given length.
+     *
+     * @see https://www.php.net/manual/en/function.str-split.php
+     * @param int $chunkSize Maximum length of a chunk.
+     * @return array The resulting array of substrings.
+     */
+    function chunk(int $chunkSize): array;
+
+    /**
+     * Strip whitespace or other characters from the beginning and end of a string.
+     *
+     * @see https://www.php.net/manual/en/function.trim
+     * @param IString|string $characters Characters to strip.
+     * @return IString A new instance of IString with the characters removed.
+     */
+    function trim(IString|string $characters = self::TRIM_CHARS): IString;
+
+    /**
+     * Strip whitespace or other characters from the beginning of a string.
+     *
+     * @see https://www.php.net/manual/en/function.ltrim.php
+     * @param IString|string $characters Characters to strip.
+     * @return IString A new instance of IString with the characters removed.
+     */
+    function trimStart(IString|string $characters = self::TRIM_CHARS): IString;
+
+    /**
+     * Strip whitespace or other characters from the end of a string.
+     *
+     * @see https://www.php.net/manual/en/function.rtrim.php
+     * @param IString|string $characters Characters to strip.
+     * @return IString A new instance of IString with the characters removed.
+     */
+    function trimEnd(IString|string $characters = self::TRIM_CHARS): IString;
+
+    /**
+     * Convert string to lowercase.
+     *
+     * @see https://www.php.net/manual/en/function.strtolower.php
+     * @return IString A new IString instance with all lowercase characters.
+     */
+    function toLower(): IString;
+
+    /**
+     * Convert string to uppercase.
+     *
+     * @see https://www.php.net/manual/en/function.strtoupper.php
+     * @return IString A new IString instance with all uppercase characters.
+     */
+    function toUpper(): IString;
+
+    /**
+     * Reverses a string.
+     *
+     * @see https://www.php.net/manual/en/function.strrev
+     * @return IString A new IString instance containing the reversed string.
+     */
+    function reverse(): IString;
+
+    /**
+     * Returns a copy of the standard PHP string.
+     *
+     * @return string PHP string.
+     */
+    function __toString(): string;
+}
diff --git a/src/MediaType.php b/src/MediaType.php
new file mode 100644
index 0000000..852d760
--- /dev/null
+++ b/src/MediaType.php
@@ -0,0 +1,163 @@
+<?php
+// MediaType.php
+// Created: 2022-02-10
+// Updated: 2022-02-27
+
+namespace Index;
+
+use InvalidArgumentException;
+use Stringable;
+
+class MediaType implements Stringable, IComparable, IEquatable {
+    private string $category = '';
+    private string $kind = '';
+    private string $suffix = '';
+    private array $params = [];
+
+    public function __construct(string $category, string $kind, string $suffix, array $params) {
+        $this->category = $category;
+        $this->kind = $kind;
+        $this->suffix = $suffix;
+        $this->params = $params;
+    }
+
+    public function getCategory(): string {
+        return $this->category;
+    }
+
+    public function getKind(): string {
+        return $this->kind;
+    }
+
+    public function getSuffix(): string {
+        return $this->suffix;
+    }
+
+    public function getParams(): array {
+        return $this->params;
+    }
+
+    public function hasParam(string $name): bool {
+        return isset($this->params[$name]);
+    }
+
+    public function getParam(string $name, int $filter = FILTER_DEFAULT, $options = null) {
+        if(!isset($this->params[$name]))
+            return null;
+        return filter_var($this->params[$name], $filter, $options);
+    }
+
+    public function getCharset(): string {
+        return $this->getParam('charset', FILTER_DEFAULT, FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH) ?? 'utf-8';
+    }
+
+    public function getQuality(): float {
+        return max(min(round($this->getParam('q', FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION) ?? 1, 2), 1), 0);
+    }
+
+    public function compareCategory(string $category): int {
+        return ($this->category === '*' || $category === '*')
+            ? 0 : strcmp($this->category, $category);
+    }
+
+    public function matchCategory(string $category): bool {
+        return $this->category === '*' || $category === '*' || $this->category === $category;
+    }
+
+    public function compareKind(string $kind): int {
+        return ($this->kind === '*' || $kind === '*')
+            ? 0 : strcmp($this->kind, $kind);
+    }
+
+    public function matchKind(string $kind): bool {
+        return $this->kind === '*' || $kind === '*' || $this->kind === $kind;
+    }
+
+    public function compareSuffix(string $suffix): int {
+        return strcmp($this->suffix, $suffix);
+    }
+
+    public function matchSuffix(string $suffix): bool {
+        return $this->suffix === $suffix;
+    }
+
+    public function compare(mixed $other): int {
+        if(!($other instanceof MediaType)) {
+            try {
+                $other = self::parse((string)$other);
+            } catch(InvalidArgumentException $ex) {
+                return -1;
+            }
+        }
+
+        if(($match = self::compareCategory($other->category)) !== 0)
+            return $match;
+        if(($match = self::compareKind($other->kind)) !== 0)
+            return $match;
+
+        return 0;
+    }
+
+    public function equals(mixed $other): bool {
+        if(!($other instanceof MediaType)) {
+            try {
+                $other = self::parse((string)$other);
+            } catch(InvalidArgumentException $ex) {
+                return false;
+            }
+        }
+
+        if(!$this->matchCategory($other->category))
+            return false;
+        if(!$this->matchKind($other->kind))
+            return false;
+
+        return true;
+    }
+
+    public function __toString(): string {
+        $string = $this->category . '/' . $this->kind;
+
+        if(!empty($this->suffix))
+            $string .= '+' . $this->suffix;
+
+        if(!empty($this->params))
+            foreach($this->params as $key => $value) {
+                $string .= ';';
+                if(is_string($key))
+                    $string .= $key . '=';
+                $string .= $value;
+            }
+
+        return $string;
+    }
+
+    public static function parse(string $mediaTypeStr): MediaType {
+        if(preg_match('#^([A-Za-z0-9\!\#\$%&\'\*\+\.\-_\{\}\|]+)/([A-Za-z0-9\!\#\$%&\'\*\+\.\-_\{\}\|]+)(?: ?; ?([A-Za-z0-9\!\#\$%&\'\*\+\.\-_\{\}\|\=; ]+))?$#', $mediaTypeStr, $matches) !== 1)
+            throw new InvalidArgumentException('Invalid media type supplied.');
+
+        $category = $matches[1];
+
+        $kindSplit = explode('+', $matches[2], 2);
+        $kind = $kindSplit[0];
+        $suffix = $kindSplit[1] ?? '';
+
+        $params = [];
+
+        if(isset($matches[3])) {
+            $rawParams = explode(';', $matches[3]);
+            foreach($rawParams as $param) {
+                $parts = explode('=', trim($param), 2);
+                if(!isset($parts[1]))
+                    continue;
+                $params[$parts[0]] = $parts[1];
+            }
+        }
+
+        return new MediaType($category, $kind, $suffix, $params);
+    }
+
+    public static function fromPath(string $path): MediaType {
+        return self::parse(mime_content_type($path));
+    }
+}
diff --git a/src/Net/DnsEndPoint.php b/src/Net/DnsEndPoint.php
new file mode 100644
index 0000000..bbfd310
--- /dev/null
+++ b/src/Net/DnsEndPoint.php
@@ -0,0 +1,60 @@
+<?php
+// DnsEndPoint.php
+// Created: 2021-05-02
+// Updated: 2022-02-28
+
+namespace Index\Net;
+
+use InvalidArgumentException;
+use Stringable;
+
+class DnsEndPoint extends EndPoint implements Stringable {
+    private string $host;
+    private int $port;
+
+    public function __construct(string $host, int $port) {
+        if($port < 0 || $port > 0xFFFF)
+            throw new InvalidArgumentException('$port is not a valid port number.');
+        $this->host = $host;
+        $this->port = $port;
+    }
+
+    public function getHost(): string {
+        return $this->host;
+    }
+
+    public function hasPort(): bool {
+        return $this->port > 0;
+    }
+
+    public function getPort(): int {
+        return $this->port;
+    }
+
+    public function __serialize(): array {
+        return [$this->host, $this->port];
+    }
+    public function __unserialize(array $serialized): void {
+        $this->host = $serialized[0];
+        $this->port = $serialized[1];
+    }
+
+    public function equals(mixed $other): bool {
+        return $other instanceof DnsEndPoint
+            && $this->port === $other->port
+            && $this->host === $other->host;
+    }
+
+    public static function parse(string $string): EndPoint {
+        $parts = explode(':', $string);
+        if(count($parts) < 2)
+            throw new InvalidArgumentException('$string is not a valid host and port combo.');
+        return new DnsEndPoint($parts[0], intval($parts[1]));
+    }
+
+    public function __toString(): string {
+        if($this->port < 1)
+            return $this->host;
+        return $this->host . ':' . $this->port;
+    }
+}
diff --git a/src/Net/EndPoint.php b/src/Net/EndPoint.php
new file mode 100644
index 0000000..ff751b6
--- /dev/null
+++ b/src/Net/EndPoint.php
@@ -0,0 +1,48 @@
+<?php
+// EndPoint.php
+// Created: 2021-04-30
+// Updated: 2022-02-28
+
+namespace Index\Net;
+
+use InvalidArgumentException;
+use JsonSerializable;
+use Stringable;
+use Index\IEquatable;
+
+abstract class EndPoint implements JsonSerializable, Stringable, IEquatable {
+    abstract public function equals(mixed $other): bool;
+    abstract public function __toString(): string;
+
+    public function jsonSerialize(): mixed {
+        return (string)$this;
+    }
+
+    public static function parse(string $endPoint): EndPoint {
+        if($endPoint === '')
+            throw new InvalidArgumentException('$endPoint is not a valid endpoint string.');
+
+        $firstChar = $endPoint[0];
+
+        if($firstChar === '/' || str_starts_with($endPoint, 'unix:'))
+            $endPoint = UnixEndPoint::parse($endPoint);
+        elseif($firstChar === '[') { // IPv6
+            if(str_contains($endPoint, ']:'))
+                $endPoint = IPEndPoint::parse($endPoint);
+            else
+                $endPoint = new IPEndPoint(IPAddress::parse(trim($endPoint, '[]')), 0);
+        } elseif(is_numeric($firstChar)) { // IPv4
+            if(str_contains($endPoint, ':'))
+                $endPoint = IPEndPoint::parse($endPoint);
+            else
+                $endPoint = new IPEndPoint(IPAddress::parse($endPoint), 0);
+        } else { // DNS
+            if(str_contains($endPoint, ':'))
+                $endPoint = DnsEndPoint::parse($endPoint);
+            else
+                $endPoint = new DnsEndPoint($endPoint, 0);
+        }
+
+        return $endPoint;
+    }
+}
diff --git a/src/Net/IPAddress.php b/src/Net/IPAddress.php
new file mode 100644
index 0000000..7396d3a
--- /dev/null
+++ b/src/Net/IPAddress.php
@@ -0,0 +1,81 @@
+<?php
+// IPAddress.php
+// Created: 2021-04-26
+// Updated: 2022-02-27
+
+namespace Index\Net;
+
+use InvalidArgumentException;
+use JsonSerializable;
+use Stringable;
+use Index\IEquatable;
+
+final class IPAddress implements JsonSerializable, Stringable, IEquatable {
+    public const UNKNOWN = 0;
+    public const V4 = 4;
+    public const V6 = 6;
+
+    private string $raw;
+    private int $width;
+
+    public function __construct(string $raw) {
+        $this->raw = $raw;
+        $this->width = strlen($raw);
+    }
+
+    public function getRaw(): string {
+        return $this->raw;
+    }
+    public function getWidth(): int {
+        return $this->width;
+    }
+
+    public function getAddress(): string {
+        return sprintf($this->isV6() ? '[%s]' : '%s', inet_ntop($this->raw));
+    }
+    public function getCleanAddress(): string {
+        return inet_ntop($this->raw);
+    }
+
+    public function getVersion(): int {
+        if($this->isV4())
+            return self::V4;
+        if($this->isV6())
+            return self::V6;
+        return self::UNKNOWN;
+    }
+
+    public function isV4(): bool {
+        return $this->width === 4;
+    }
+    public function isV6(): bool {
+        return $this->width === 16;
+    }
+
+    public function __toString(): string {
+        return inet_ntop($this->raw);
+    }
+
+    public function equals(mixed $other): bool {
+        return $other instanceof IPAddress && $this->getRaw() === $other->getRaw();
+    }
+
+    public function jsonSerialize(): mixed {
+        return inet_ntop($this->raw);
+    }
+
+    public function __serialize(): array {
+        return [$this->raw];
+    }
+    public function __unserialize(array $serialized): void {
+        $this->raw = $serialized[0];
+        $this->width = strlen($this->raw);
+    }
+
+    public static function parse(string $address): self {
+        $parsed = inet_pton($address);
+        if($parsed === false)
+            throw new InvalidArgumentException('$address is not a valid IP address.');
+        return new static($parsed);
+    }
+}
diff --git a/src/Net/IPAddressRange.php b/src/Net/IPAddressRange.php
new file mode 100644
index 0000000..84fa27f
--- /dev/null
+++ b/src/Net/IPAddressRange.php
@@ -0,0 +1,97 @@
+<?php
+// IPAddressRange.php
+// Created: 2021-04-26
+// Updated: 2022-02-27
+
+namespace Index\Net;
+
+use InvalidArgumentException;
+use JsonSerializable;
+use Stringable;
+use Index\IEquatable;
+
+final class IPAddressRange implements JsonSerializable, Stringable, IEquatable {
+    private IPAddress $base;
+    private int $mask;
+
+    public function __construct(IPAddress $base, int $mask) {
+        $this->base = $base;
+        $this->mask = $mask;
+    }
+
+    public function getBaseAddress(): IPAddress {
+        return $this->base;
+    }
+
+    public function getMask(): int {
+        return $this->mask;
+    }
+
+    public function getCIDR(): string {
+        return ((string)$this->base) . '/' . $this->getMask();
+    }
+
+    public function __toString(): string {
+        return $this->getCIDR();
+    }
+
+    public function equals(mixed $other): bool {
+        return $other instanceof IPAddressRange
+            && $this->mask === $other->mask
+            && $this->base->equals($other->base);
+    }
+
+    public function match(IPAddress $address): bool {
+        $width = $this->base->getWidth();
+        if($address->getWidth() !== $width)
+            return false;
+
+        if($this->mask < 1)
+            return true;
+
+        $base = $this->base->getRaw();
+        $match = $address->getRaw();
+        $remaining = $this->mask;
+
+        for($i = 0; $i < $width && $remaining > 0; ++$i) {
+            $b = ord($base[$i]);
+            $m = ord($match[$i]);
+
+            $remainingMod = $remaining % 8;
+            if($remainingMod) {
+                $mask = 0xFF << (8 - $remainingMod);
+                $b &= $mask;
+                $m &= $mask;
+            }
+
+            if($b !== $m)
+                return false;
+
+            $remaining -= 8;
+        }
+
+        return true;
+    }
+
+    public function jsonSerialize(): mixed {
+        return $this->getCIDR();
+    }
+
+    public function __serialize(): array {
+        return [
+            'b' => $this->base->getRaw(),
+            'm' => $this->mask,
+        ];
+    }
+    public function __unserialize(array $serialized): void {
+        $this->base = new IPAddress($serialized['b']);
+        $this->mask = $serialized['m'];
+    }
+
+    public static function parse(string $cidr): IPAddressRange {
+        $parts = explode('/', $cidr, 2);
+        if(empty($parts[0]) || empty($parts[1]))
+            throw new InvalidArgumentException('$cidr is not a valid CIDR range.');
+        return new static(IPAddress::parse($parts[0]), intval($parts[1]));
+    }
+}
diff --git a/src/Net/IPEndPoint.php b/src/Net/IPEndPoint.php
new file mode 100644
index 0000000..a6ab445
--- /dev/null
+++ b/src/Net/IPEndPoint.php
@@ -0,0 +1,71 @@
+<?php
+// IPEndPoint.php
+// Created: 2021-04-30
+// Updated: 2022-02-28
+
+namespace Index\Net;
+
+use InvalidArgumentException;
+use Index\XString;
+
+class IPEndPoint extends EndPoint {
+    private IPAddress $address;
+    private int $port;
+
+    public function __construct(IPAddress $address, int $port) {
+        if($port < 0 || $port > 0xFFFF)
+            throw new InvalidArgumentException('$port is not a valid port number.');
+        $this->address = $address;
+        $this->port = $port;
+    }
+
+    public function getAddress(): IPAddress {
+        return $this->address;
+    }
+
+    public function hasPort(): bool {
+        return $this->port > 0;
+    }
+
+    public function getPort(): int {
+        return $this->port;
+    }
+
+    public function __serialize(): array {
+        return [$this->address, $this->port];
+    }
+    public function __unserialize(array $serialized): void {
+        $this->address = $serialized[0];
+        $this->port = $serialized[1];
+    }
+
+    public function equals(mixed $other): bool {
+        return $other instanceof IPEndPoint
+            && $this->port === $other->port
+            && $this->address->equals($other->address);
+    }
+
+    public static function parse(string $string): EndPoint {
+        if(str_starts_with($string, '[')) { // IPv6
+            $closing = strpos($string, ']');
+            if($closing === false)
+                throw new InvalidArgumentException('$string is not a valid IP end point.');
+            $ip = substr($string, 1, $closing - 1);
+            $port = intval(substr($string, $closing + 2));
+        } else { // IPv4
+            $parts = explode(':', $string, 2);
+            if(count($parts) < 2)
+                throw new InvalidArgumentException('$string is not a valid IP end point.');
+            $ip = $parts[0];
+            $port = intval($parts[1]);
+        }
+
+        return new IPEndPoint(IPAddress::parse($ip), $port);
+    }
+
+    public function __toString(): string {
+        if($this->port < 1)
+            return $this->address->getAddress();
+        return $this->address->getAddress() . ':' . $this->port;
+    }
+}
diff --git a/src/Net/UnixEndPoint.php b/src/Net/UnixEndPoint.php
new file mode 100644
index 0000000..8da0e13
--- /dev/null
+++ b/src/Net/UnixEndPoint.php
@@ -0,0 +1,43 @@
+<?php
+// UnixEndPoint.php
+// Created: 2021-04-30
+// Updated: 2022-02-27
+
+namespace Index\Net;
+
+class UnixEndPoint extends EndPoint {
+    private string $path;
+
+    public function __construct(string $socketPath) {
+        $this->path = $socketPath;
+    }
+
+    public function getPath(): string {
+        return $this->path;
+    }
+
+    public function __serialize(): array {
+        return [$this->path];
+    }
+    public function __unserialize(array $serialized): void {
+        $this->path = $serialized[0];
+    }
+
+    public function equals(mixed $other): bool {
+        return $other instanceof UnixEndPoint
+            && $this->path === $other->path;
+    }
+
+    public static function parse(string $socketPath): UnixEndPoint {
+        if(str_starts_with($socketPath, 'unix:')) {
+            $uri = parse_url($socketPath);
+            $socketPath = $uri['path'] ?? '';
+        }
+
+        return new UnixEndPoint($socketPath);
+    }
+
+    public function __toString(): string {
+        return $this->path;
+    }
+}
diff --git a/src/Performance/PerformanceCounter.php b/src/Performance/PerformanceCounter.php
new file mode 100644
index 0000000..4a40a29
--- /dev/null
+++ b/src/Performance/PerformanceCounter.php
@@ -0,0 +1,20 @@
+<?php
+// PerformanceCounter.php
+// Created: 2022-02-16
+// Updated: 2022-02-28
+
+namespace Index\Performance;
+
+final class PerformanceCounter {
+    public static function getFrequency(): int|float {
+        return 1000000;
+    }
+
+    public static function getTicks(): int|float {
+        return hrtime(true);
+    }
+
+    public static function getTicksSince(int|float $since): int|float {
+        return self::getTicks() - $since;
+    }
+}
diff --git a/src/Performance/Stopwatch.php b/src/Performance/Stopwatch.php
new file mode 100644
index 0000000..b84387e
--- /dev/null
+++ b/src/Performance/Stopwatch.php
@@ -0,0 +1,72 @@
+<?php
+// Stopwatch.php
+// Created: 2021-04-26
+// Updated: 2022-02-16
+
+namespace Index\Performance;
+
+/**
+ * Provides a means to measure elapsed time at a high resolution.
+ */
+class Stopwatch {
+    private int|float $start = -1;
+    private int|float $elapsed = 0;
+    private int|float $frequency;
+
+    public function __construct() {
+        $this->frequency = PerformanceCounter::getFrequency();
+    }
+
+    public function start(): void {
+        if($this->start < 0)
+            $this->start = PerformanceCounter::getTicks();
+    }
+
+    public function stop(): void {
+        if($this->start < 0)
+            return;
+        $this->elapsed += PerformanceCounter::getTicksSince($this->start);
+        $this->start = -1;
+    }
+
+    /**
+     * Checks whether the Stopwatch is currently running.
+     *
+     * @return bool true if the Stopwatch is running, false if not.
+     */
+    public function isRunning(): bool {
+        return $this->start >= 0;
+    }
+
+    /**
+     * Gets the number of ticks that have elapsed.
+     *
+     * @return int|float Number of ticks.
+     */
+    public function getElapsedTicks(): int|float {
+        $elapsed = $this->elapsed;
+        if($this->start >= 0)
+            $elapsed += PerformanceCounter::getTicksSince($this->start);
+        return $elapsed;
+    }
+
+    /**
+     * Gets the number of elapsed milliseconds.
+     *
+     * @return float Number of elapsed milliseconds.
+     */
+    public function getElapsedTime(): float {
+        return $this->getElapsedTicks() / $this->frequency;
+    }
+
+    /**
+     * Creates a new Stopwatch instance and starts measuring time.
+     *
+     * @return Stopwatch Newly created running Stopwatch.
+     */
+    public static function startNew(): Stopwatch {
+        $sw = new Stopwatch;
+        $sw->start();
+        return $sw;
+    }
+}
diff --git a/src/Performance/TimingPoint.php b/src/Performance/TimingPoint.php
new file mode 100644
index 0000000..f98ab36
--- /dev/null
+++ b/src/Performance/TimingPoint.php
@@ -0,0 +1,49 @@
+<?php
+// TimingPoint.php
+// Created: 2022-02-16
+// Updated: 2022-02-28
+
+namespace Index\Performance;
+
+class TimingPoint {
+    private int|float $timePoint;
+    private int|float $duration;
+    private string $name;
+    private string $comment;
+
+    public function __construct(
+        int|float $timePoint,
+        int|float $duration,
+        string $name,
+        string $comment
+    ) {
+        $this->timePoint = $timePoint;
+        $this->duration = $duration;
+        $this->name = $name;
+        $this->comment = $comment;
+    }
+
+    public function getTimePointTicks(): int|float {
+        return $this->timePoint;
+    }
+
+    public function getDurationTicks(): int|float {
+        return $this->duration;
+    }
+
+    public function getDurationTime(): float {
+        return $this->duration / PerformanceCounter::getFrequency();
+    }
+
+    public function getName(): string {
+        return $this->name;
+    }
+
+    public function hasComment(): bool {
+        return $this->comment !== '';
+    }
+
+    public function getComment(): string {
+        return $this->comment;
+    }
+}
diff --git a/src/Performance/Timings.php b/src/Performance/Timings.php
new file mode 100644
index 0000000..4709d43
--- /dev/null
+++ b/src/Performance/Timings.php
@@ -0,0 +1,55 @@
+<?php
+// Timings.php
+// Created: 2022-02-16
+// Updated: 2022-02-16
+
+namespace Index\Performance;
+
+use InvalidArgumentException;
+
+class Timings {
+    private Stopwatch $sw;
+    private int|float $lastLapTicks;
+    private array $laps;
+
+    public function __construct(?Stopwatch $sw = null) {
+        $this->sw = $sw ?? Stopwatch::startNew();
+        $this->lastLapTicks = $this->sw->getElapsedTicks();
+    }
+
+    public function getStopwatch(): Stopwatch {
+        return $this->sw;
+    }
+
+    public function getLaps(): array {
+        return $this->laps;
+    }
+
+    public function start(): void {
+        $this->sw->start();
+    }
+
+    public function stop(): void {
+        $this->sw->stop();
+    }
+
+    public function isRunning(): bool {
+        return $this->sw->isRunning();
+    }
+
+    public function lap(string $name, string $comment = ''): void {
+        if(!ctype_alnum($name))
+            throw new InvalidArgumentException('$name must be alpha-numeric.');
+
+        $lapTicks = $this->sw->getElapsedTicks();
+        $elapsed = $lapTicks - $this->lastLapTicks;
+        $this->lastLapTicks = $lapTicks;
+
+        $this->laps[] = new TimingPoint(
+            $lapTicks,
+            $elapsed,
+            $name,
+            $comment
+        );
+    }
+}
diff --git a/src/Routing/RouteCallable.php b/src/Routing/RouteCallable.php
new file mode 100644
index 0000000..dcbe073
--- /dev/null
+++ b/src/Routing/RouteCallable.php
@@ -0,0 +1,72 @@
+<?php
+// RouteCallable.php
+// Created: 2022-01-20
+// Updated: 2022-02-02
+
+namespace Index\Routing;
+
+/**
+ * Stack of callables and arguments for route responses.
+ */
+class RouteCallable {
+    private array $callables;
+    private array $args;
+
+    /**
+     * @internal
+     */
+    public function __construct(array $callables, array $args) {
+        $this->callables = $callables;
+        $this->args = $args;
+    }
+
+    /**
+     * Callables in order that they should be executed.
+     *
+     * @return array Sequential list of callables.
+     */
+    public function getCallables(): array {
+        return $this->callables;
+    }
+
+    /**
+     * Arguments to be sent to each callable.
+     *
+     * @return array Sequential argument list for the callables.
+     */
+    public function getArguments(): array {
+        return $this->args;
+    }
+
+    /**
+     * Runs all callables and returns their returns as an array.
+     *
+     * @return array Results from the callables.
+     */
+    public function runAll(): array {
+        $results = [];
+
+        foreach($this->callables as $callable) {
+            $result = $callable(...$this->args);
+            if($result !== null)
+                $results[] = $result;
+        }
+
+        return $results;
+    }
+
+    /**
+     * Runs all callables unless one returns something.
+     *
+     * @return mixed Result from the returning callable.
+     */
+    public function run(): mixed {
+        foreach($this->callables as $callable) {
+            $result = $callable(...$this->args);
+            if($result !== null)
+                return $result;
+        }
+
+        return null;
+    }
+}
diff --git a/src/Routing/RouteInfo.php b/src/Routing/RouteInfo.php
new file mode 100644
index 0000000..4f7dc41
--- /dev/null
+++ b/src/Routing/RouteInfo.php
@@ -0,0 +1,125 @@
+<?php
+// RouteInfo.php
+// Created: 2022-01-20
+// Updated: 2022-02-27
+
+namespace Index\Routing;
+
+use InvalidArgumentException;
+use UnexpectedValueException;
+
+/**
+ * Represents a node in the router structure.
+ *
+ * @internal
+ */
+class RouteInfo {
+    private array $children = [];
+    private array $methods = [];
+    private array $middlewares = [];
+    private ?RouteInfo $dynamicChild = null;
+
+    private function getChild(string $path, ?string &$next = null): RouteInfo {
+        $parts = explode('/', $path, 2);
+        $name = '_' . $parts[0];
+
+        if(str_starts_with($parts[0], ':'))
+            $child = $this->dynamicChild ?? ($this->dynamicChild = new RouteInfo);
+        else
+            $child = $this->children[$name] ?? ($this->children[$name] = new RouteInfo);
+
+        $next = $parts[1] ?? '';
+
+        return $child;
+    }
+
+    /**
+     * @internal
+     */
+    public function mergeRoute(string $path, RouteInfo $route): void {
+        if($path === '') {
+            $this->children = array_merge($this->children, $route->children);
+            $this->methods = array_merge($this->methods, $route->methods);
+            $this->middlewares = array_merge($this->middlewares, $route->middlewares);
+            if($this->dynamicChild === null)
+                $this->dynamicChild = $route->dynamicChild;
+            return;
+        }
+
+        $this->getChild($path, $next)->mergeRoute($next, $route);
+    }
+
+    /**
+     * @internal
+     */
+    public function addMiddleware(string $path, callable $handler): void {
+        if($path === '') {
+            $this->middlewares[] = $handler;
+            return;
+        }
+
+        $this->getChild($path, $next)->addMiddleware($next, $handler);
+    }
+
+    /**
+     * @internal
+     */
+    public function addMethod(string $method, string $path, callable $handler): void {
+        if($path === '') {
+            $this->methods[strtolower($method)] = $handler;
+            return;
+        }
+
+        $this->getChild($path, $next)->addMethod($method, $next, $handler);
+    }
+
+    /**
+     * @internal
+     */
+    public function resolve(string $method, string $path, array $args = [], array $callables = []): RouteCallable {
+        if($path === '') {
+            $method = strtolower($method);
+            $handlers = [];
+
+            if(isset($this->methods[$method])) {
+                $handlers[] = $this->methods[$method];
+            } else {
+                if($method !== 'options') {
+                    if(empty($this->methods))
+                        throw new RoutePathNotFoundException;
+                    throw new RouteMethodNotSupportedException;
+                }
+            }
+
+            return new RouteCallable(
+                array_merge($callables, $this->middlewares, $handlers),
+                $args
+            );
+        }
+
+        $parts = explode('/', $path, 2);
+        $name = $parts[0];
+        $mName = '_' . $name;
+
+        foreach($this->children as $cName => $cObj)
+            if($cName === $mName) {
+                $child = $cObj;
+                break;
+            }
+
+        if(!isset($child)) {
+            $args[] = $name;
+            $child = $this->dynamicChild;
+        }
+
+        if($child === null)
+            throw new RoutePathNotFoundException;
+
+        return $child->resolve(
+            $method,
+            $parts[1] ?? '',
+            $args,
+            array_merge($callables, $this->middlewares)
+        );
+    }
+}
diff --git a/src/Routing/RouteMethodNotSupportedException.php b/src/Routing/RouteMethodNotSupportedException.php
new file mode 100644
index 0000000..c9a6c61
--- /dev/null
+++ b/src/Routing/RouteMethodNotSupportedException.php
@@ -0,0 +1,13 @@
+<?php
+// RouteMethodNotSupportedException.php
+// Created: 2022-01-20
+// Updated: 2022-01-20
+
+namespace Index\Routing;
+
+use RuntimeException;
+
+/**
+ * Exception thrown when an unsupported request method is invoked. (HTTP 405)
+ */
+class RouteMethodNotSupportedException extends RuntimeException {}
diff --git a/src/Routing/RoutePathNotFoundException.php b/src/Routing/RoutePathNotFoundException.php
new file mode 100644
index 0000000..d5c7815
--- /dev/null
+++ b/src/Routing/RoutePathNotFoundException.php
@@ -0,0 +1,13 @@
+<?php
+// RoutePathNotFoundException.php
+// Created: 2022-01-20
+// Updated: 2022-01-20
+
+namespace Index\Routing;
+
+use RuntimeException;
+
+/**
+ * Exception thrown when a path does not resolve to a route. (HTTP 404)
+ */
+class RoutePathNotFoundException extends RuntimeException {}
diff --git a/src/Routing/Router.php b/src/Routing/Router.php
new file mode 100644
index 0000000..f5d89ef
--- /dev/null
+++ b/src/Routing/Router.php
@@ -0,0 +1,132 @@
+<?php
+// Router.php
+// Created: 2022-01-18
+// Updated: 2022-02-27
+
+namespace Index\Routing;
+
+use InvalidArgumentException;
+
+/**
+ * Provides an application router.
+ */
+class Router {
+    private RouteInfo $route;
+
+    /**
+     * Constructs a Router object.
+     */
+    public function __construct() {
+        $this->route = new RouteInfo;
+    }
+
+    /**
+     * Resolves a request method and uri.
+     *
+     * @param string $method Request method.
+     * @param string $path Request path.
+     * @param array $args Arguments to be passed on to the callables.
+     * @return RouteCallable A collection of callables representing the route.
+     */
+    public function resolve(string $method, string $path, array $args = []): RouteCallable {
+        $method = strtolower($method);
+        if($method === 'head')
+            $method = 'get';
+
+        return $this->route->resolve($method, trim($path, '/'), $args);
+    }
+
+    /**
+     * Apply middleware functions to a path.
+     *
+     * @param string $path Path to apply the middleware to.
+     * @param callable $handler Middleware function.
+     */
+    public function use(string $path, callable $handler): void {
+        $this->route->addMiddleware(trim($path, '/'), $handler);
+    }
+
+    /**
+     * Merges another router with this one with possibility of changing its root.
+     *
+     * @param string $path Base path to use.
+     * @param Router $router Router object to inherit from.
+     */
+    public function merge(string $path, Router $router): void {
+        $this->route->mergeRoute(trim($path, '/'), $router->route);
+    }
+
+    /**
+     * Adds a new route.
+     *
+     * @param string $method Request method.
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function add(string $method, string $path, callable $handler): void {
+        if(empty($method))
+            throw new InvalidArgumentException('$method may not be empty.');
+
+        $this->route->addMethod($method, trim($path, '/'), $handler);
+    }
+
+    /**
+     * Adds a new GET route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function get(string $path, callable $handler): void {
+        $this->add('get', $path, $handler);
+    }
+
+    /**
+     * Adds a new POST route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function post(string $path, callable $handler): void {
+        $this->add('post', $path, $handler);
+    }
+
+    /**
+     * Adds a new DELETE route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function delete(string $path, callable $handler): void {
+        $this->add('delete', $path, $handler);
+    }
+
+    /**
+     * Adds a new PATCH route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function patch(string $path, callable $handler): void {
+        $this->add('patch', $path, $handler);
+    }
+
+    /**
+     * Adds a new PUT route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function put(string $path, callable $handler): void {
+        $this->add('put', $path, $handler);
+    }
+
+    /**
+     * Adds a new OPTIONS route.
+     *
+     * @param string $path Request path.
+     * @param callable $handler Request handler.
+     */
+    public function options(string $path, callable $handler): void {
+        $this->add('options', $path, $handler);
+    }
+}
diff --git a/src/Security/CSRFP.php b/src/Security/CSRFP.php
new file mode 100644
index 0000000..82c1c7e
--- /dev/null
+++ b/src/Security/CSRFP.php
@@ -0,0 +1,104 @@
+<?php
+// CSRFP.php
+// Created: 2021-06-11
+// Updated: 2022-02-27
+
+namespace Index\Security;
+
+/**
+ * Contains info shared between sessions as well as shorthand methods.
+ */
+class CSRFP {
+    private const TOLERANCE = 30 * 60;
+    private const EPOCH = 1619956800;
+    private const HASH_ALGO = 'sha1';
+
+    private string $secretKey;
+    private int $tolerance;
+    private int $epoch;
+    private string $hashAlgo;
+
+    private array $identities = [];
+
+    /**
+     * Creates a new CSRFP instance.
+     *
+     * @param string $secretKey Secret key for HMAC hashes.
+     * @param int $tolerance Amount of time a token should remain valid for.
+     * @param int $epoch First possible date and time.
+     * @param string $hashAlgo Hashing algorithm to use for HMAC.
+     * @return CSRFP New CSRFP instance.
+     */
+    public function __construct(
+        string $secretKey,
+        int $tolerance = self::TOLERANCE,
+        int $epoch = self::EPOCH,
+        string $hashAlgo = self::HASH_ALGO
+    ) {
+        $this->secretKey = $secretKey;
+        $this->tolerance = $tolerance;
+        $this->epoch = $epoch;
+        $this->hashAlgo = $hashAlgo;
+    }
+
+    /**
+     * Gets the amount of time a token should remain valid for.
+     *
+     * @return int Token expiry tolerance.
+     */
+    public function getTolerance(): int {
+        return $this->tolerance;
+    }
+
+    /**
+     * Gets an identity instance.
+     *
+     * @param string $identity String that represents the identity.
+     * @return CSRFPIdentity An identity instance representing the given string.
+     */
+    public function getIdentity(string $identity): CSRFPIdentity {
+        return $this->identities[$identity] ?? ($this->identities[$identity] = new CSRFPIdentity($this, $identity));
+    }
+
+    /**
+     * Returns the time with the offset applied.
+     *
+     * @return int Current time, with offset.
+     */
+    public function time(): int {
+        return time() - $this->epoch;
+    }
+
+    /**
+     * Creates a hash with the given arguments.
+     *
+     * @param string $identity Identity string to verify for.
+     * @param int $timestamp Timestamp to verify.
+     * @param int $tolerance Tolerance to verify.
+     * @return string Hash representing the given arguments.
+     */
+    public function createHash(string $identity, int $timestamp, int $tolerance): string {
+        return hash_hmac($this->hashAlgo, "{$identity}!{$timestamp}!{$tolerance}", $this->secretKey, true);
+    }
+
+    /**
+     * Creates a token string using a given identity string.
+     *
+     * @param string $identity Identity to create token for.
+     * @return string Token string.
+     */
+    public function createToken(string $identity): string {
+        return $this->getIdentity($identity)->createToken();
+    }
+
+    /**
+     * Verifies a token string using a given identity string.
+     *
+     * @param string $identity Identity to test the token with.
+     * @param string $token Token to test.
+     * @return bool true if the token is valid, false if not.
+     */
+    public function verifyToken(string $identity, string $token): bool {
+        return $this->getIdentity($identity)->verifyToken(CSRFPToken::decode($token));
+    }
+}
diff --git a/src/Security/CSRFPIdentity.php b/src/Security/CSRFPIdentity.php
new file mode 100644
index 0000000..551e642
--- /dev/null
+++ b/src/Security/CSRFPIdentity.php
@@ -0,0 +1,79 @@
+<?php
+// CSRFPIdentity.php
+// Created: 2021-06-11
+// Updated: 2022-02-02
+
+namespace Index\Security;
+
+/**
+ * Represents a CSRF prevention identity.
+ */
+class CSRFPIdentity {
+    private CSRFP $owner;
+    private string $identity;
+
+    /**
+     * Construct a new instance of CSRFPIdentity.
+     *
+     * @param CSRFP $owner Owner CSRFP instance.
+     * @param string $identity Identity string.
+     * @return CSRFPIdentity Instance representing the identity.
+     */
+    public function __construct(CSRFP $owner, string $identity) {
+        $this->owner = $owner;
+        $this->identity = $identity;
+    }
+
+    /**
+     * Gets a reference to the owner CSRFP object.
+     *
+     * @return CSRFP Owner object.
+     */
+    public function getOwner(): CSRFP {
+        return $this->owner;
+    }
+
+    /**
+     * Gets the string for this identity.
+     */
+    public function getIdentity(): string {
+        return $this->identity;
+    }
+
+    /**
+     * Creates a new token using this identity.
+     *
+     * @return CSRFPToken Newly created token.
+     */
+    public function createToken(): CSRFPToken {
+        $timestamp = $this->owner->time();
+        $tolerance = $this->owner->getTolerance();
+        $hash = $this->owner->createHash($this->identity, $timestamp, $tolerance);
+        return new CSRFPToken($timestamp, $tolerance, $hash);
+    }
+
+    /**
+     * Verifies a token using this identity.
+     *
+     * @param CSRFPToken $token Token to verify.
+     * @return bool true if the token is valid, false if not.
+     */
+    public function verifyToken(CSRFPToken $token): bool {
+        $timestamp = $token->getTimestamp();
+        $tolerance = $token->getTolerance();
+        $tHash = $token->getHash();
+
+        // invalid for sure, defaults for decode failure
+        if($timestamp < 0 || $tolerance < 1 || empty($tHash))
+            return false;
+
+        $currentTime = $this->owner->time();
+        if($currentTime < $timestamp
+            || $currentTime > ($timestamp + $tolerance))
+            return false;
+
+        $rHash = $this->owner->createHash($this->identity, $timestamp, $tolerance);
+
+        return hash_equals($rHash, $tHash);
+    }
+}
diff --git a/src/Security/CSRFPToken.php b/src/Security/CSRFPToken.php
new file mode 100644
index 0000000..4300636
--- /dev/null
+++ b/src/Security/CSRFPToken.php
@@ -0,0 +1,101 @@
+<?php
+// CSRFPToken.php
+// Created: 2021-06-11
+// Updated: 2022-02-27
+
+namespace Index\Security;
+
+use ErrorException;
+use InvalidArgumentException;
+use Stringable;
+use Index\Serialisation\Serialiser;
+
+/**
+ * Represents a CSRF prevention token.
+ */
+class CSRFPToken implements Stringable {
+    private int $timestamp;
+    private int $tolerance;
+    private string $hash;
+
+    /**
+     * Construct a CSRFPToken instance.
+     *
+     * @param int $timestamp Timestamp at which the token was generated.
+     * @param int $tolerance Period for how long this token is valid.
+     * @param string $hash A HMAC hash to prevent tampering.
+     * @return CSRFPToken A new instance of CSRFPToken.
+     */
+    public function __construct(
+        int $timestamp,
+        int $tolerance,
+        string $hash
+    ) {
+        $this->timestamp = $timestamp;
+        $this->tolerance = $tolerance;
+        $this->hash = $hash;
+    }
+
+    /**
+     * Gets the timestamp value of this token.
+     *
+     * @return int Timestamp for this token.
+     */
+    public function getTimestamp(): int {
+        return $this->timestamp;
+    }
+
+    /**
+     * Gets the tolerance value of this token.
+     *
+     * @return int Tolerance for this token.
+     */
+    public function getTolerance(): int {
+        return $this->tolerance;
+    }
+
+    /**
+     * Gets the hash of this token.
+     *
+     * @return string Hash for this token.
+     */
+    public function getHash(): string {
+        return $this->hash;
+    }
+
+    /**
+     * Encodes the CSRFPToken instance as a token string.
+     *
+     * @return string CSRF prevention token string.
+     */
+    public function encode(): string {
+        return Serialiser::uriBase64()->serialise(pack('Vv', $this->timestamp, $this->tolerance) . $this->hash);
+    }
+
+    /**
+     * Decodes a token string to a CSRFPToken instance.
+     *
+     * If an invalid token is provided, no exception will be thrown.
+     *
+     * @param string $token Input token string.
+     * @return CSRFPToken Instance representing the provided token.
+     */
+    public static function decode(string $token): CSRFPToken {
+        $token = Serialiser::uriBase64()->deserialise($token);
+        try {
+            $decode = unpack('Vtimestamp/vtolerance', $token);
+        } catch(ErrorException $ex) {
+            $decode = [
+                'timestamp' => -1,
+                'tolerance' => 0,
+            ];
+        }
+        // arbitrary length
+        $hash = substr($token, 6, 128);
+        return new CSRFPToken($decode['timestamp'], $decode['tolerance'], $hash);
+    }
+
+    public function __toString(): string {
+        return $this->encode();
+    }
+}
diff --git a/src/Security/HashAlgorithm.php b/src/Security/HashAlgorithm.php
new file mode 100644
index 0000000..a73ace1
--- /dev/null
+++ b/src/Security/HashAlgorithm.php
@@ -0,0 +1,67 @@
+<?php
+// HashAlgorithm.php
+// Created: 2021-06-16
+// Updated: 2022-02-27
+
+namespace Index\Security;
+
+use HashContext;
+use InvalidArgumentException;
+use RuntimeException;
+use Index\ICloneable;
+use Index\IO\GenericStream;
+
+class HashAlgorithm implements ICloneable {
+    private HashAlgorithmInfo $info;
+    private HashContext $context;
+
+    public function __construct(HashAlgorithmInfo $info, ?HashContext $context = null) {
+        $this->info = $info;
+        if($context === null)
+            $this->reset();
+        else
+            $this->context = $context;
+    }
+
+    public function reset(): void {
+        $this->context = hash_init($this->info->getName(), $this->info->isHMAC() ? HASH_HMAC : 0, $this->info->getKey());
+    }
+
+    public function update(string $data): void {
+        hash_update($this->context, $data);
+    }
+
+    public function updateStream(mixed $stream, int $length = -1): int {
+        if($stream instanceof GenericStream)
+            $stream = $stream->getResource();
+        if(!is_resource($stream))
+            throw new InvalidArgumentException('$stream must be a resource or an instance of Index\IO\GenericStream.');
+        return hash_update_stream($this->context, $stream, $length);
+    }
+
+    public function updateFile(string $fileName, mixed $streamContext = null): void {
+        if($streamContext !== null && !is_resource($streamContext))
+            throw new InvalidArgumentException('$streamContext must be null or a resource.');
+        if(!hash_update_file($this->context, $fileName, $streamContext))
+            throw new RuntimeException('File hash failed.');
+    }
+
+    public function finalise(bool $hex = false): string {
+        return hash_final($this->context, !$hex);
+    }
+
+    public function clone(): mixed {
+        return new HashAlgorithm($this->info, hash_copy($this->context));
+    }
+
+    public static function equals(
+        HashAlgorithm|string $trusted,
+        HashAlgorithm|string $foreign
+    ): bool {
+        if($trusted instanceof HashAlgorithm)
+            $trusted = $trusted->finalise(false);
+        if($foreign instanceof HashAlgorithm)
+            $foreign = $foreign->finalise(false);
+        return hash_equals($trusted, $foreign);
+    }
+}
diff --git a/src/Security/HashAlgorithmInfo.php b/src/Security/HashAlgorithmInfo.php
new file mode 100644
index 0000000..b5588c1
--- /dev/null
+++ b/src/Security/HashAlgorithmInfo.php
@@ -0,0 +1,120 @@
+<?php
+// HashAlgorithmInfo.php
+// Created: 2021-06-16
+// Updated: 2022-02-27
+
+namespace Index\Security;
+
+use RuntimeException;
+
+class HashAlgorithmInfo {
+    private string $name;
+    private bool $hmac;
+    private ?string $key;
+
+    public function __construct(string $algorithm, ?string $key = null) {
+        $this->name = $algorithm;
+        $this->hmac = $key === null;
+        $this->key = $key;
+    }
+
+    private static bool $constructed = false;
+    private static HashAlgorithmInfo $md5;
+    private static HashAlgorithmInfo $sha1;
+    private static HashAlgorithmInfo $sha2_256;
+    private static HashAlgorithmInfo $sha2_512;
+    private static HashAlgorithmInfo $sha3_256;
+    private static HashAlgorithmInfo $sha3_512;
+    private static HashAlgorithmInfo $crc32;
+    private static HashAlgorithmInfo $crc32b;
+    private static HashAlgorithmInfo $crc32c;
+
+    public static function construct(): void {
+        if(self::$constructed)
+            throw new RuntimeException('Static constructor was already called.');
+        self::$constructed = true;
+        self::$md5 = new HashAlgorithmInfo('md5');
+        self::$sha1 = new HashAlgorithmInfo('sha1');
+        self::$sha2_256 = new HashAlgorithmInfo('sha256');
+        self::$sha2_512 = new HashAlgorithmInfo('sha512');
+        self::$sha3_256 = new HashAlgorithmInfo('sha3-256');
+        self::$sha3_512 = new HashAlgorithmInfo('sha3-512');
+        self::$crc32 = new HashAlgorithmInfo('crc32');
+        self::$crc32b = new HashAlgorithmInfo('crc32b');
+        self::$crc32c = new HashAlgorithmInfo('crc32c');
+    }
+
+    public function getName(): string {
+        return $this->name;
+    }
+
+    public function isHMAC(): bool {
+        return $this->hmac;
+    }
+
+    public function getKey(): string {
+        return $this->key;
+    }
+
+    public function create(): HashAlgorithm {
+        return new HashAlgorithm($this);
+    }
+
+    public static function hashAlgos(): array {
+        return hash_algos();
+    }
+
+    public static function hmacAlgos(): array {
+        return hash_hmac_algos();
+    }
+
+    public static function md5(?string $key = null): HashAlgorithmInfo {
+        if($key === null)
+            return new HashAlgorithmInfo('md5', $key);
+        return self::$md5;
+    }
+
+    public static function sha1(?string $key = null): HashAlgorithmInfo {
+        if($key === null)
+            return new HashAlgorithmInfo('sha1', $key);
+        return self::$sha1;
+    }
+
+    public static function sha2_256(?string $key = null): HashAlgorithmInfo {
+        if($key === null)
+            return new HashAlgorithmInfo('sha256', $key);
+        return self::$sha2_256;
+    }
+
+    public static function sha2_512(?string $key = null): HashAlgorithmInfo {
+        if($key === null)
+            return new HashAlgorithmInfo('sha512', $key);
+        return self::$sha2_512;
+    }
+
+    public static function sha3_256(?string $key = null): HashAlgorithmInfo {
+        if($key === null)
+            return new HashAlgorithmInfo('sha3-256', $key);
+        return self::$sha3_256;
+    }
+
+    public static function sha3_512(?string $key = null): HashAlgorithmInfo {
+        if($key === null)
+            return new HashAlgorithmInfo('sha3-512', $key);
+        return self::$sha3_512;
+    }
+
+    public static function crc32(): HashAlgorithmInfo {
+        return self::$crc32;
+    }
+
+    public static function crc32b(): HashAlgorithmInfo {
+        return self::$crc32b;
+    }
+
+    public static function crc32c(): HashAlgorithmInfo {
+        return self::$crc32c;
+    }
+}
+
+HashAlgorithmInfo::construct();
diff --git a/src/Serialisation/Base32Serialiser.php b/src/Serialisation/Base32Serialiser.php
new file mode 100644
index 0000000..f9d433d
--- /dev/null
+++ b/src/Serialisation/Base32Serialiser.php
@@ -0,0 +1,62 @@
+<?php
+// Base32Serialiser.php
+// Created: 2022-01-13
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use Index\IO\Stream;
+
+/**
+ * Provides a Base32 serialiser.
+ */
+class Base32Serialiser extends Serialiser {
+    private const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+
+    /**
+     * Encodes binary data as a Base32 string.
+     *
+     * @param mixed $input Input binary data.
+     * @return string Base32 string representing the binary data.
+     */
+    public function serialise(mixed $input): string {
+        $input = (string)$input;
+        $length = strlen($input);
+        $bin = '';
+        $output = '';
+
+        for($i = 0; $i < $length; $i++)
+            $bin .= sprintf('%08b', ord($input[$i]));
+
+        $bin = str_split($bin, 5);
+        $last = array_pop($bin);
+        $bin[] = str_pad($last, 5, '0', STR_PAD_RIGHT);
+
+        foreach($bin as $part)
+            $output .= self::CHARS[bindec($part)];
+
+        return $output;
+    }
+
+    /**
+     * Decodes a Base32 string back to binary data.
+     *
+     * @param Stream|string $input Input Base32 string.
+     * @return string Binary data.
+     */
+    public function deserialise(Stream|string $input): mixed {
+        $input = (string)$input;
+        $length = strlen($input);
+        $char = $shift = 0;
+        $output = '';
+
+        for($i = 0; $i < $length; $i++) {
+            $char <<= 5;
+            $char += stripos(self::CHARS, $input[$i]);
+            $shift = ($shift + 5) % 8;
+            $output .= $shift < 5 ? chr(($char & (0xFF << $shift)) >> $shift) : '';
+        }
+
+        return $output;
+    }
+}
diff --git a/src/Serialisation/Base62Serialiser.php b/src/Serialisation/Base62Serialiser.php
new file mode 100644
index 0000000..0825631
--- /dev/null
+++ b/src/Serialisation/Base62Serialiser.php
@@ -0,0 +1,51 @@
+<?php
+// Base62Serialiser.php
+// Created: 2022-01-28
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use Index\IO\Stream;
+
+/**
+ * Provides a Base62 serialiser.
+ */
+class Base62Serialiser extends Serialiser {
+    private const CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+    /**
+     * Encodes an integer as a Base62 string.
+     *
+     * @param int $input Integer.
+     * @return string Base64 string representing the integer.
+     */
+    public function serialise(mixed $input): string {
+        $input = intval($input);
+        $output = '';
+
+        for($i = floor(log10($input) / log10(62)); $i >= 0; --$i) {
+            $index = (int)floor($input / (62 ** $i));
+            $output .= substr(self::CHARS, $index, 1);
+            $input -= $index * (62 ** $i);
+        }
+
+        return $output;
+    }
+
+    /**
+     * Decodes a Base62 string back to an integer.
+     *
+     * @param Stream|string $input Input Base62 string.
+     * @return int Integer.
+     */
+    public function deserialise(Stream|string $input): mixed {
+        $input = (string)$input;
+        $output = 0;
+        $length = strlen($input) - 1;
+
+        for($i = 0; $i <= $length; ++$i)
+            $output += strpos(self::CHARS, $input[$i]) * (62 ** ($length - $i));
+
+        return $output;
+    }
+}
diff --git a/src/Serialisation/Base64Serialiser.php b/src/Serialisation/Base64Serialiser.php
new file mode 100644
index 0000000..6e8cc39
--- /dev/null
+++ b/src/Serialisation/Base64Serialiser.php
@@ -0,0 +1,33 @@
+<?php
+// Base64Serialiser.php
+// Created: 2022-01-13
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use Index\IO\Stream;
+
+/**
+ * Provides a Base64 serialiser.
+ */
+class Base64Serialiser extends Serialiser {
+    /**
+     * Encodes binary data as a Base64 string.
+     *
+     * @param mixed $input Input binary data.
+     * @return string Base64 string representing the binary data.
+     */
+    public function serialise(mixed $input): string {
+        return base64_encode((string)$input);
+    }
+
+    /**
+     * Decodes a Base64 string back to binary data.
+     *
+     * @param Stream|string $input Input Base64 string.
+     * @return string Binary data.
+     */
+    public function deserialise(Stream|string $input): mixed {
+        return base64_decode((string)$input);
+    }
+}
diff --git a/src/Serialisation/BencodeSerialiser.php b/src/Serialisation/BencodeSerialiser.php
new file mode 100644
index 0000000..823d83d
--- /dev/null
+++ b/src/Serialisation/BencodeSerialiser.php
@@ -0,0 +1,171 @@
+<?php
+// BencodeSerialiser.php
+// Created: 2022-01-13
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use RuntimeException;
+use Index\IO\Stream;
+use Index\IO\TempFileStream;
+
+/**
+ * Provides a Bencode serialiser.
+ */
+class BencodeSerialiser extends Serialiser {
+    private BencodeSerialiserSettings $settings;
+
+    /**
+     * Creates a new Bencode serialiser.
+     *
+     * @param BencodeSerialiserSettings|null $settings Settings for the serialisation behaviour.
+     */
+    public function __construct(?BencodeSerialiserSettings $settings = null) {
+        $this->settings = $settings ?? new BencodeSerialiserSettings;
+    }
+
+    public function serialise(mixed $input): string {
+        return self::encode((string)$input, $this->settings->getMaxDepth());
+    }
+
+    public function deserialise(Stream|string $input): mixed {
+        if(!($input instanceof Stream))
+            $input = TempFileStream::fromString($input);
+        return $this->decode($input, $this->settings->getMaxDepth());
+    }
+
+    private static function encode(mixed $input, int $depth): string {
+        if($depth < 1)
+            throw new RuntimeException('Maximum depth reached, structure is too dense.');
+
+        switch(gettype($input)) {
+            case 'string':
+                return sprintf('%d:%s', strlen($input), $input);
+
+            case 'integer':
+                return sprintf('i%de', $input);
+
+            case 'array':
+                if(array_is_list($input)) {
+                    $output = 'l';
+                    foreach($input as $item)
+                        $output .= self::encode($item, $depth - 1);
+                } else {
+                    $output = 'd';
+                    foreach($input as $key => $value) {
+                        $output .= self::encode(strval($key), $depth - 1);
+                        $output .= self::encode($value, $depth - 1);
+                    }
+                }
+
+                return $output . 'e';
+
+            case 'object':
+                if($input instanceof IBencodeSerialisable)
+                    return self::encode($input->bencodeSerialise(), $depth - 1);
+
+                $input = get_object_vars($input);
+                $output = 'd';
+
+                foreach($input as $key => $value) {
+                    $output .= self::encode(strval($key), $depth - 1);
+                    $output .= self::encode($value, $depth - 1);
+                }
+
+                return $output . 'e';
+
+            default:
+                return '';
+        }
+    }
+
+    private function decode(Stream $input, int $depth): mixed {
+        if($depth < 1)
+            throw new RuntimeException('Maximum depth reached, structure is too dense.');
+
+        $char = $input->readChar();
+        if($char === null)
+            throw new RuntimeException('Unexpected end of stream in $input.');
+
+        switch($char) {
+            case 'i':
+                $number = '';
+
+                for(;;) {
+                    $char = $input->readChar();
+                    if($char === null)
+                        throw new RuntimeException('Unexpected end of stream while parsing integer.');
+                    if($char === 'e')
+                        break;
+                    if($char === '-' && $number !== '')
+                        throw new RuntimeException('Unexpected - (minus) while parsing integer.');
+                    if($char === '0' && $number === '-')
+                        throw new RuntimeException('Negative integer zero.');
+                    if($char === '0' && $number === '0')
+                        throw new RuntimeException('Integer double zero.');
+                    if(!ctype_digit($char))
+                        throw new RuntimeException('Unexpected character while parsing integer.');
+                    $number .= $char;
+                }
+
+                return intval($number);
+
+            case 'l':
+                $list = [];
+
+                for(;;) {
+                    $char = $input->readChar();
+                    if($char === null)
+                        throw new RuntimeException('Unexpected end of stream while parsing list.');
+                    if($char === 'e')
+                        break;
+                    $input->seek(-1, Stream::CURRENT);
+                    $list[] = $this->decode($input, $depth - 1);
+                }
+
+                return $list;
+
+            case 'd':
+                $dict = [];
+
+                for(;;) {
+                    $char = $input->readChar();
+                    if($char === null)
+                        throw new RuntimeException('Unexpected end of stream while parsing dictionary');
+                    if($char === 'e')
+                        break;
+                    if(!ctype_digit($char))
+                        throw new RuntimeException('Unexpected dictionary key type, expected a string.');
+                    $input->seek(-1, Stream::CURRENT);
+                    $dict[$this->decode($input, $depth - 1)] = $this->decode($input, $depth - 1);
+                }
+
+                if($this->settings->shouldDecodeDictAsObject())
+                    $dict = (object)$dict;
+
+                return $dict;
+
+            default:
+                if(!ctype_digit($char))
+                    throw new RuntimeException('Unexpected character while parsing string.');
+
+                $length = $char;
+
+                for(;;) {
+                    $char = $input->readChar();
+                    if($char === null)
+                        throw new RuntimeException('Unexpected end of character while parsing string length.');
+                    if($char === ':')
+                        break;
+                    if($char === '0' && $length === '0')
+                        throw new RuntimeException('Integer double zero while parsing string length.');
+                    if(!ctype_digit($char))
+                        throw new RuntimeException('Unexpected character while parsing string length.');
+
+                    $length .= $char;
+                }
+
+                return $input->read(intval($length));
+        }
+    }
+}
diff --git a/src/Serialisation/BencodeSerialiserSettings.php b/src/Serialisation/BencodeSerialiserSettings.php
new file mode 100644
index 0000000..2051f0d
--- /dev/null
+++ b/src/Serialisation/BencodeSerialiserSettings.php
@@ -0,0 +1,48 @@
+<?php
+// BencodeSerialiserSettings.php
+// Created: 2022-01-13
+// Updated: 2022-02-02
+
+namespace Index\Serialisation;
+
+/**
+ * Provides settings for Bencode serialisation.
+ */
+class BencodeSerialiserSettings {
+    public const DEFAULT_DEPTH = 512;
+
+    private int $maxDepth;
+    private bool $dictAsObject;
+
+    /**
+     * Creates a new BencodeSerialiserSettings instance.
+     *
+     * @param int $maxDepth Maximum parsing depth before the serialisation/deserialisation should stop.
+     * @param bool $dictAsObject Whether Dictionaries should be decoded as stdClass instances rather than associative arrays.
+     */
+    public function __construct(
+        int $maxDepth = self::DEFAULT_DEPTH,
+        bool $dictAsObject = false
+    ) {
+        $this->maxDepth = $maxDepth;
+        $this->dictAsObject = $dictAsObject;
+    }
+
+    /**
+     * Gets the maximum recursion depth.
+     *
+     * @return int Maximum recursion depth.
+     */
+    public function getMaxDepth(): int {
+        return $this->maxDepth;
+    }
+
+    /**
+     * Gets whether dictionaries should be decoded as objects (instances of stdClass).
+     *
+     * @return bool True if dictionaries should be objects, false if they should be associative arrays.
+     */
+    public function shouldDecodeDictAsObject(): bool {
+        return $this->dictAsObject;
+    }
+}
diff --git a/src/Serialisation/IBencodeSerialisable.php b/src/Serialisation/IBencodeSerialisable.php
new file mode 100644
index 0000000..9f4d3c3
--- /dev/null
+++ b/src/Serialisation/IBencodeSerialisable.php
@@ -0,0 +1,18 @@
+<?php
+// IBencodeSerialisable.php
+// Created: 2022-01-13
+// Updated: 2022-02-02
+
+namespace Index\Serialisation;
+
+/**
+ * Provides an interface for serialising objects for bencoding in a controlled manner.
+ */
+interface IBencodeSerialisable {
+    /**
+     * Gets the data that should represent this object in a Bencode structure.
+     *
+     * @return mixed Representative data.
+     */
+    function bencodeSerialise(): mixed;
+}
diff --git a/src/Serialisation/JsonSerialiser.php b/src/Serialisation/JsonSerialiser.php
new file mode 100644
index 0000000..b9b2d90
--- /dev/null
+++ b/src/Serialisation/JsonSerialiser.php
@@ -0,0 +1,38 @@
+<?php
+// JsonSerialiser.php
+// Created: 2022-01-13
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use Index\WString;
+use Index\IO\Stream;
+
+/**
+ * Provides a JSON serialiser.
+ */
+class JsonSerialiser extends Serialiser {
+    private JsonSerialiserSettings $settings;
+
+    /**
+     * Creates a new JSON serialiser instance.
+     *
+     * @param JsonSerialiserSettings|null $settings Settings to be used with this serialiser.
+     */
+    public function __construct(?JsonSerialiserSettings $settings = null) {
+        $this->settings = $settings ?? new JsonSerialiserSettings;
+    }
+
+    public function serialise(mixed $input): string {
+        $output = json_encode($input, $this->settings->getFlags(), $this->settings->getMaxDepth());
+        if($output === false)
+            $output = '';
+        return $output;
+    }
+
+    public function deserialise(Stream|string $input): mixed {
+        //if($input instanceof WString)
+        //    $input = $input->convertEncoding('utf-8');
+        return json_decode((string)$input, false, $this->settings->getMaxDepth(), $this->settings->getFlags());
+    }
+}
diff --git a/src/Serialisation/JsonSerialiserSettings.php b/src/Serialisation/JsonSerialiserSettings.php
new file mode 100644
index 0000000..81ef08d
--- /dev/null
+++ b/src/Serialisation/JsonSerialiserSettings.php
@@ -0,0 +1,116 @@
+<?php
+// JsonSerialiserSettings.php
+// Created: 2022-01-13
+// Updated: 2022-02-02
+
+namespace Index\Serialisation;
+
+/**
+ * Provides settings for altering JSON serialisation behaviour.
+ */
+class JsonSerialiserSettings {
+    public const DEFAULT_DEPTH = 512;
+
+    private int $flags;
+    private int $maxDepth;
+
+    /**
+     * Creates a new instance of JsonSerialiserSettings.
+     *
+     * @param int $maxDepth Maximum parsing depth before the serialisation/deserialisation should stop.
+     * @param bool $throwOnError Whether the serialiser should throw an exeception upon errors.
+     * @param bool $preserveZeroFraction Ensure that float values are never encoded as integers.
+     * @param bool $prettyPrint Whether the output should be formatted.
+     * @param bool $forceObject Output an object (stdClass instance) instead of an associative array.
+     * @param bool $encodeQuotes Converts " to \u0022.
+     * @param bool $convertTags Converts < and > to \u003C and \u003E respectively.
+     * @param bool $convertAmpersand Converts & to \u0026.
+     * @param bool $convertApostrophe Converts ' to \u0027.
+     * @param bool $ignoreInvalidUtf8 Ignores invalid UTF-8 characters.
+     * @param bool $substituteInvalidUtf8 Converts invalid UTF-8 characters to \0xfffd (Unicode Character 'REPLACEMENT CHARACTER').
+     * @param bool $numericCheck Encodes numeric strings as numbers.
+     * @param bool $partialOutputOnError Substitute some unencodable values instead of failing.
+     * @param bool $unescapedLineTerminators The line terminators are kept unescaped when $unescapedUnicode is true.
+     * @param bool $unescapedSlashes Don't escape /.
+     * @param bool $unescapedUnicode Encode multibyte Unicode characters literally (default is to escape as \uXXXX).
+     * @param bool $bigIntAsString Decodes large integers as their original string value.
+     * @param bool $objectAsArray Decodes JSON objects as PHP array.
+     */
+    public function __construct(
+        int $maxDepth = self::DEFAULT_DEPTH,
+        bool $throwOnError = true,
+        bool $preserveZeroFraction = true,
+        bool $prettyPrint = false,
+        bool $forceObject = false,
+        bool $encodeQuotes = false,
+        bool $convertTags = false,
+        bool $convertAmpersand = false,
+        bool $convertApostrophe = false,
+        bool $ignoreInvalidUtf8 = false,
+        bool $substituteInvalidUtf8 = false,
+        bool $numericCheck = false,
+        bool $partialOutputOnError = false,
+        bool $unescapedLineTerminators = false,
+        bool $unescapedSlashes = false,
+        bool $unescapedUnicode = false,
+        bool $bigIntAsString = false,
+        bool $objectAsArray = false
+    ) {
+        $this->maxDepth = $maxDepth;
+
+        $flags = 0;
+        if($throwOnError)
+            $flags |= JSON_THROW_ON_ERROR;
+        if($preserveZeroFraction)
+            $flags |= JSON_PRESERVE_ZERO_FRACTION;
+        if($prettyPrint)
+            $flags |= JSON_PRETTY_PRINT;
+        if($forceObject)
+            $flags |= JSON_FORCE_OBJECT;
+        if($encodeQuotes)
+            $flags |= JSON_HEX_QUOT;
+        if($convertTags)
+            $flags |= JSON_HEX_TAG;
+        if($convertAmpersand)
+            $flags |= JSON_HEX_AMP;
+        if($convertApostrophe)
+            $flags |= JSON_HEX_APOS;
+        if($ignoreInvalidUtf8)
+            $flags |= JSON_INVALID_UTF8_IGNORE;
+        if($substituteInvalidUtf8)
+            $flags |= JSON_INVALID_UTF8_SUBSTITUTE;
+        if($numericCheck)
+            $flags |= JSON_NUMERIC_CHECK;
+        if($partialOutputOnError)
+            $flags |= JSON_PARTIAL_OUTPUT_ON_ERROR;
+        if($unescapedLineTerminators)
+            $flags |= JSON_UNESCAPED_LINE_TERMINATORS;
+        if($unescapedSlashes)
+            $flags |= JSON_UNESCAPED_SLASHES;
+        if($unescapedUnicode)
+            $flags |= JSON_UNESCAPED_UNICODE;
+        if($bigIntAsString)
+            $flags |= JSON_BIGINT_AS_STRING;
+        if($objectAsArray)
+            $flags |= JSON_OBJECT_AS_ARRAY;
+        $this->flags = $flags;
+    }
+
+    /**
+     * Gets the maximum recursion depth.
+     *
+     * @return int Maximum recursion depth.
+     */
+    public function getMaxDepth(): int {
+        return $this->maxDepth;
+    }
+
+    /**
+     * Gets the flagset constructed by the constructor arguments.
+     *
+     * @return int JSON flagset.
+     */
+    public function getFlags(): int {
+        return $this->flags;
+    }
+}
diff --git a/src/Serialisation/Serialiser.php b/src/Serialisation/Serialiser.php
new file mode 100644
index 0000000..922b9dd
--- /dev/null
+++ b/src/Serialisation/Serialiser.php
@@ -0,0 +1,111 @@
+<?php
+// Serialiser.php
+// Created: 2022-01-13
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use Index\IO\Stream;
+
+/**
+ * Base class for Serialisers.
+ */
+abstract class Serialiser {
+    /**
+     * Returns a global Base32Serialiser instance with default settings.
+     *
+     * @return Base32Serialiser
+     */
+    public static function base32(): Base32Serialiser {
+        static $instance = null;
+        if($instance === null)
+            $instance = new Base32Serialiser;
+        return $instance;
+    }
+
+    /**
+     * Returns a global Base62Serialiser instance with default settings.
+     *
+     * @return Base62Serialiser
+     */
+    public static function base62(): Base62Serialiser {
+        static $instance = null;
+        if($instance === null)
+            $instance = new Base62Serialiser;
+        return $instance;
+    }
+
+    /**
+     * Returns a global Base64Serialiser instance with default settings.
+     *
+     * @return Base64Serialiser
+     */
+    public static function base64(): Base64Serialiser {
+        static $instance = null;
+        if($instance === null)
+            $instance = new Base64Serialiser;
+        return $instance;
+    }
+
+    /**
+     * Returns a global UriBase64Serialiser instance with default settings.
+     *
+     * @return UriBase64Serialiser
+     */
+    public static function uriBase64(): UriBase64Serialiser {
+        static $instance = null;
+        if($instance === null)
+            $instance = new UriBase64Serialiser;
+        return $instance;
+    }
+
+    /**
+     * Returns a global JsonSerialiser instance with default settings.
+     *
+     * @return JsonSerialiser
+     */
+    public static function json(): JsonSerialiser {
+        static $instance = null;
+        if($instance === null)
+            $instance = new JsonSerialiser;
+        return $instance;
+    }
+
+    /**
+     * Returns a global BencodeSerialiser instance with default settings.
+     *
+     * @return BencodeSerialiser
+     */
+    public static function bencode(): BencodeSerialiser {
+        static $instance = null;
+        if($instance === null)
+            $instance = new BencodeSerialiser;
+        return $instance;
+    }
+
+    /**
+     * Serialises data to a stringable format.
+     *
+     * @param mixed $input Data to be serialised.
+     * @return string Serialised representation of the input data.
+     */
+    abstract public function serialise(mixed $input): string;
+
+    /**
+     * Deserialises a stringable format into data.
+     *
+     * @param Stream|string $input String or stream to be deserialised.
+     * @return mixed Deserialised data of the input string.
+     */
+    abstract public function deserialise(Stream|string $input): mixed;
+
+    /**
+     * Serialises data to a stringable format into stream.
+     *
+     * @param mixed $input Data to be serialised.
+     * @param Stream $output Target stream.
+     */
+    public function serialiseToStream(mixed $input, Stream $output): void {
+        $output->write($this->serialise($input));
+    }
+}
diff --git a/src/Serialisation/UriBase64Serialiser.php b/src/Serialisation/UriBase64Serialiser.php
new file mode 100644
index 0000000..190c465
--- /dev/null
+++ b/src/Serialisation/UriBase64Serialiser.php
@@ -0,0 +1,34 @@
+<?php
+// UriBase64Serialiser.php
+// Created: 2022-01-13
+// Updated: 2022-02-27
+
+namespace Index\Serialisation;
+
+use Index\IO\Stream;
+
+/**
+ * Provides URL-safe Base64 encoding.
+ */
+class UriBase64Serialiser extends Serialiser {
+    /**
+     * Encodes binary data as a Base64 string.
+     *
+     * @param string $input Input binary data.
+     * @return string Base64 string representing the binary data.
+     */
+    public function serialise(mixed $input): string {
+        return rtrim(strtr(base64_encode((string)$input), '+/', '-_'), '=');
+    }
+
+    /**
+     * Decodes a Base64 string back to binary data.
+     *
+     * @param Stream|string $input Input Base64 string.
+     * @return string Binary data.
+     */
+    public function deserialise(Stream|string $input): mixed {
+        $input = (string)$input;
+        return base64_decode(str_pad(strtr($input, '-_', '+/'), strlen($input) % 4, '=', STR_PAD_RIGHT));
+    }
+}
diff --git a/src/StringIterator.php b/src/StringIterator.php
new file mode 100644
index 0000000..f06973d
--- /dev/null
+++ b/src/StringIterator.php
@@ -0,0 +1,81 @@
+<?php
+// StringIterator.php
+// Created: 2022-02-02
+// Updated: 2022-02-02
+
+namespace Index;
+
+use Iterator;
+
+/**
+ * Provides an iterator for IString types.
+ */
+class StringIterator implements Iterator {
+    private IString $value;
+    private int $length;
+    private int $index = 0;
+    private bool $wasValid = false;
+
+    /**
+     * Creates the iterator.
+     *
+     * @param IString $string String to iterate.
+     */
+    public function __construct(IString $string) {
+        $this->value = $string;
+        $this->length = $string->getLength();
+    }
+
+    /**
+     * Returns the current character.
+     *
+     * @see https://www.php.net/manual/en/iterator.current.php
+     * @return mixed Current character.
+     */
+    public function current(): mixed {
+        return $this->value[$this->index];
+    }
+
+    /**
+     * Returns the index of the current character.
+     *
+     * @see https://www.php.net/manual/en/iterator.key.php
+     * @return int Index of the current character.
+     */
+    public function key(): mixed {
+        return $this->index;
+    }
+
+    /**
+     * Move forward to the next character.
+     *
+     * @see https://www.php.net/manual/en/iterator.next.php
+     */
+    public function next(): void {
+        $next = $this->index + 1;
+        $this->wasValid = $next < $this->length;
+
+        if($this->wasValid)
+            $this->index = $next;
+    }
+
+    /**
+     * Rewind to the first character.
+     *
+     * @see https://www.php.net/manual/en/iterator.rewind.php
+     */
+    public function rewind(): void {
+        $this->index = 0;
+        $this->wasValid = true;
+    }
+
+    /**
+     * Checks if the current index is valid.
+     *
+     * @see https://www.php.net/manual/en/iterator.rewind.php
+     * @return bool Whether the current index is valid.
+     */
+    public function valid(): bool {
+        return $this->wasValid;
+    }
+}
diff --git a/src/TimeSpan.php b/src/TimeSpan.php
new file mode 100644
index 0000000..83b6648
--- /dev/null
+++ b/src/TimeSpan.php
@@ -0,0 +1,526 @@
+<?php
+// TimeSpan.php
+// Created: 2021-06-11
+// Updated: 2022-02-27
+
+namespace Index;
+
+use DateInterval;
+use JsonSerializable;
+use Stringable;
+
+/**
+ * Represents a duration of time.
+ */
+class TimeSpan extends DateInterval implements JsonSerializable, Stringable, IComparable, IEquatable {
+    private const HOURS_IN_DAY = 24;
+    private const MINS_IN_HOUR = 60;
+    private const SECS_IN_MIN = 60;
+    private const MILLIS_IN_SEC = 1000;
+    private const MINS_IN_DAY = 1440;
+    private const SECS_IN_HOUR = 3600;
+    private const MILLIS_IN_MIN = 60000;
+    private const SECS_IN_DAY = 86400;
+    private const MICROS_IN_SEC = 1000000;
+    private const MILLIS_IN_HOUR = 3600000;
+    private const MICROS_IN_MIN = 60000000;
+    private const MILLIS_IN_DAY = 86400000;
+    private const MICROS_IN_HOUR = 3600000000;
+    private const MICROS_IN_DAY = 86400000000;
+
+    private int $realDays = -1;
+
+    /**
+     * Creates a new instance of TimeSpan.
+     *
+     * @param string $duration An ISO8601 duration string.
+     * @return TimeSpan A TimeSpan instance representing the given duration.
+     */
+    public function __construct(string $duration = 'PT0S') {
+        parent::__construct($duration);
+        $this->realDays = $this->days === false ? $this->calculateRealDays() : $this->days;
+    }
+
+    private function calculateRealDays(): int {
+        return ($this->y * 365)
+             + ($this->m * 31)
+             +  $this->d;
+    }
+
+    /**
+     * Gets the amount of days this TimeSpan represents.
+     *
+     * @return int Amount of days.
+     */
+    public function getDays(): int {
+        return $this->realDays;
+    }
+
+    /**
+     * Gets the amount of hours this TimeSpan represents.
+     *
+     * @retunr int Amount of hours.
+     */
+    public function getHours(): int {
+        return $this->h;
+    }
+
+    /**
+     * Gets the amount of minutes this TimeSpan represents.
+     *
+     * @return int Amount of minutes.
+     */
+    public function getMinutes(): int {
+        return $this->i;
+    }
+
+    /**
+     * Gets the amount of seconds this TimeSpan represents.
+     *
+     * @return int Amount of seconds.
+     */
+    public function getSeconds(): int {
+        return $this->s;
+    }
+
+    /**
+     * Gets the amount of milliseconds this TimeSpan represents.
+     *
+     * @return int Amount of milliseconds.
+     */
+    public function getMilliseconds(): int {
+        return (int)($this->f * 1000);
+    }
+
+    /**
+     * Gets the amount of microseconds this TimeSpan represents.
+     *
+     * @return int Amount of microseconds.
+     */
+    public function getMicroseconds(): int {
+        return (int)($this->f * 1000000);
+    }
+
+    /**
+     * Gets whether this TimeSpan represents a negative amount of time.
+     *
+     * @return bool true if negative, false if positive.
+     */
+    public function isNegative(): bool {
+        return $this->invert !== 0;
+    }
+
+    /**
+     * Counts the total amount of days this TimeSpan contains.
+     *
+     * @return float Total amount of days.
+     */
+    public function totalDays(): float {
+        $days  = $this->getDays();
+        $days += $this->getHours() / self::HOURS_IN_DAY;
+        $days += $this->getMinutes() / self::MINS_IN_DAY;
+        $days += $this->getSeconds() / self::SECS_IN_DAY;
+        $days += $this->getMicroseconds() / self::MICROS_IN_DAY;
+        return $days;
+    }
+
+    /**
+     * Counts the total amount of hours this TimeSpan contains.
+     *
+     * @return float Total amount of hours.
+     */
+    public function totalHours(): float {
+        $hours  = $this->getDays() * self::HOURS_IN_DAY;
+        $hours += $this->getHours();
+        $hours += $this->getMinutes() / self::MINS_IN_HOUR;
+        $hours += $this->getSeconds() / self::SECS_IN_HOUR;
+        $hours += $this->getMicroseconds() / self::MICROS_IN_HOUR;
+        return $hours;
+    }
+
+    /**
+     * Counts the total amount of minutes this TimeSpan contains.
+     *
+     * @return float Total amount of minutes.
+     */
+    public function totalMinutes(): float {
+        $mins  = $this->getDays() * self::MINS_IN_DAY;
+        $mins += $this->getHours() * self::MINS_IN_HOUR;
+        $mins += $this->getMinutes();
+        $mins += $this->getSeconds() / self::SECS_IN_MIN;
+        $mins += $this->getMicroseconds() / self::MICROS_IN_MIN;
+        return $mins;
+    }
+
+    /**
+     * Counts the total amount of seconds this TimeSpan contains.
+     *
+     * @return float Total amount of seconds.
+     */
+    public function totalSeconds(): float {
+        $secs  = $this->getDays() * self::SECS_IN_DAY;
+        $secs += $this->getHours() * self::SECS_IN_HOUR;
+        $secs += $this->getMinutes() * self::SECS_IN_MIN;
+        $secs += $this->getSeconds();
+        $secs += $this->getMicroseconds() * self::MICROS_IN_SEC;
+        return $secs;
+    }
+
+    /**
+     * Counts the total amount of milliseconds this TimeSpan contains.
+     *
+     * @return float Total amount of milliseconds.
+     */
+    public function totalMilliseconds(): float {
+        $millis  = $this->getDays() * self::MILLIS_IN_DAY;
+        $millis += $this->getHours() * self::MILLIS_IN_HOUR;
+        $millis += $this->getMinutes() * self::MILLIS_IN_MIN;
+        $millis += $this->getSeconds() * self::MILLIS_IN_SEC;
+        $millis += $this->getMilliseconds();
+        return $millis;
+    }
+
+    /**
+     * Counts the total amount of microseconds this TimeSpan contains.
+     *
+     * @return float Total amount of microseconds.
+     */
+    public function totalMicroseconds(): float {
+        $micros  = $this->getDays() * self::MICROS_IN_DAY;
+        $micros += $this->getHours() * self::MICROS_IN_HOUR;
+        $micros += $this->getMinutes() * self::MICROS_IN_MIN;
+        $micros += $this->getSeconds() * self::MICROS_IN_SEC;
+        $micros += $this->getMicroseconds();
+        return $micros;
+    }
+
+    /**
+     * Returns a new TimeSpan whose value is the sum of this instance and the provided instance.
+     *
+     * @param DateInterval $timeSpan Interval to add.
+     * @return TimeSpan Instance that represents this instance plus the value of $timeSpan.
+     */
+    public function add(DateInterval $timeSpan): TimeSpan {
+        $timeSpan = self::cast($timeSpan);
+
+        $days1 = $this->totalDays();
+        if($this->isNegative())
+            $days1 *= -1;
+
+        $days2 = $timeSpan->totalDays();
+        if($timeSpan->isNegative())
+            $days2 *= -1;
+
+        return self::fromDays($days1 + $days2);
+    }
+
+    /**
+     * Returns a new TimeSpan whose value is the difference of this instance and the provided instance.
+     *
+     * @param DateInterval $timeSpan Interval to subtract.
+     * @return TimeSpan Instance that represents this instance minus the value of $timeSpan.
+     */
+    public function subtract(DateInterval $timeSpan): TimeSpan {
+        $timeSpan = self::cast($timeSpan);
+
+        $days1 = $this->totalDays();
+        if($this->isNegative())
+            $days1 *= -1;
+
+        $days2 = $timeSpan->totalDays();
+        if($timeSpan->isNegative())
+            $days2 *= -1;
+
+        return self::fromDays($days1 - $days2);
+    }
+
+    /**
+     * Returns the result of a division of this instance and the provided instance.
+     *
+     * @param DateInterval $timeSpan Interval to be divided by.
+     * @return float $timeSpan Number that represents this instance divided by the value of $timeSpan.
+     */
+    public function divideTimeSpan(DateInterval $timeSpan): float {
+        $timeSpan = self::cast($timeSpan);
+
+        $days1 = $this->totalDays();
+        if($this->isNegative())
+            $days1 *= -1;
+
+        $days2 = $timeSpan->totalDays();
+        if($timeSpan->isNegative())
+            $days2 *= -1;
+
+        if($days2 === 0.0)
+            return 0.0;
+
+        return $days1 / $days2;
+    }
+
+    /**
+     * Returns the result of a division of this instance and the provided divisor.
+     *
+     * @param float $divisor Value to divide by.
+     * @return TimeSpan Instance that represents this instance divided by the value of $divisor.
+     */
+    public function divideFloat(float $divisor): TimeSpan {
+        $totalDays = $this->totalDays();
+        if($this->isNegative())
+            $totalDays *= -1;
+        $totalDays /= $divisor;
+        return self::fromDays($totalDays);
+    }
+
+    /**
+     * Returns a new TimeSpan whose alue is the result of a multiplication of this oinstance and the provided factor.
+     *
+     * @param float $factor Value to multiply with.
+     * @return TimeSpan Instance that represents this instance multiplied by the value of $factor.
+     */
+    public function multiply(float $factor): TimeSpan {
+        $totalDays = $this->totalDays();
+        if($this->isNegative())
+            $totalDays *= -1;
+        $totalDays *= $factor;
+        return self::fromDays($totalDays);
+    }
+
+    /**
+     * Return a new TimeSpan whose value is the negated value of this instance.
+     *
+     * @return TimeSpan Negated copy of this instance.
+     */
+    public function negate(): TimeSpan {
+        return self::create(
+            $this->getDays(),
+            $this->getHours(),
+            $this->getMinutes(),
+            $this->getSeconds(),
+            $this->getMicroseconds(),
+            !$this->isNegative()
+        );
+    }
+
+    public function compare(mixed $other): int {
+        if(!($other instanceof DateInterval))
+            return -1;
+        $other = self::cast($other);
+
+        $diff = $this->getDays() <=> $other->getDays();
+        if($diff) return $diff;
+
+        $diff = $this->getHours() <=> $other->getHours();
+        if($diff) return $diff;
+
+        $diff = $this->getMinutes() <=> $other->getMinutes();
+        if($diff) return $diff;
+
+        $diff = $this->getSeconds() <=> $other->getSeconds();
+        if($diff) return $diff;
+
+        $diff = $this->getMicroseconds() <=> $other->getMicroseconds();
+        if($diff) return $diff;
+
+        $diff = $this->isNegative() <=> $other->isNegative();
+        if($diff) return $diff;
+
+        return 0;
+    }
+
+    public function equals(mixed $other): bool {
+        if(!($other instanceof DateInterval))
+            return false;
+        $other = self::cast($other);
+        return $this->getDays() === $other->getDays()
+            && $this->getHours() === $other->getHours()
+            && $this->getMinutes() === $other->getMinutes()
+            && $this->getSeconds() === $other->getSeconds()
+            && $this->getMicroseconds() === $other->getMicroseconds()
+            && $this->isNegative() === $other->isNegative();
+    }
+
+    /**
+     * Returns the data which should be serialized as json.
+     *
+     * @see https://www.php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return mixed Data to be passed to json_encode.
+     */
+    public function jsonSerialize(): mixed {
+        return (string)$this;
+    }
+
+    /**
+     * Creates a string representation of this object.
+     *
+     * @return string Representation of this object.
+     */
+    public function __toString(): string {
+        $string = $this->isNegative() ? '-' : '';
+        return sprintf(
+            '%sP%dY%dM%dDT%dH%dM%d.%dS',
+            $this->isNegative() ? '-' : '',
+            $this->y,
+            $this->m,
+            $this->d,
+            $this->getHours(),
+            $this->getMinutes(),
+            $this->getSeconds(),
+            $this->getMicroseconds()
+        );
+    }
+
+    /**
+     * Creates a new TimeSpan instance that represents the specified number of days.
+     *
+     * @param float $days Number of days.
+     * @return TimeSpan Instance representing the provided number of days.
+     */
+    public static function fromDays(float $days): TimeSpan {
+        $abs = abs($days);
+        $round = (int)floor($abs);
+        $hours = ($abs - $round) * self::HOURS_IN_DAY;
+        $hoursRound = (int)floor($hours);
+        $minutes = ($hours - $hoursRound) * self::MINS_IN_HOUR;
+        $minsRound = (int)floor($minutes);
+        $seconds = ($minutes - $minsRound) * self::SECS_IN_MIN;
+        $secsRound = (int)floor($seconds);
+        $micros = (int)floor(($seconds - $secsRound) * self::MICROS_IN_SEC);
+        return self::create($round, $hoursRound, $minsRound, $secsRound, $micros, $days < 0);
+    }
+
+    /**
+     * Creates a new TimeSpan instance that represents the specified number of hours.
+     *
+     * @param float $hours Number of hours.
+     * @return TimeSpan Instance representing the provided number of hours.
+     */
+    public static function fromHours(float $hours): TimeSpan {
+        $abs = abs($hours);
+        $round = (int)floor($abs);
+        $minutes = ($abs - $round) * self::MINS_IN_HOUR;
+        $minsRound = (int)floor($minutes);
+        $seconds = ($minutes - $minsRound) * self::SECS_IN_MIN;
+        $secsRound = (int)floor($seconds);
+        $micros = (int)floor(($seconds - $secsRound) * self::MICROS_IN_SEC);
+        return self::create(0, $round, $minsRound, $secsRound, $micros, $hours < 0);
+    }
+
+    /**
+     * Creates a new TimeSpan instance that represents the specified number of minutes.
+     *
+     * @param float $minutes Number of minutes.
+     * @return TimeSpan Instance representing the provided number of minutes.
+     */
+    public static function fromMinutes(float $minutes): TimeSpan {
+        $abs = abs($minutes);
+        $round = (int)floor($abs);
+        $seconds = ($abs - $round) * self::SECS_IN_MIN;
+        $secsRound = (int)floor($seconds);
+        $micros = (int)floor(($seconds - $secsRound) * self::MICROS_IN_SEC);
+        return self::create(0, 0, $round, $secsRound, $micros, $minutes < 0);
+    }
+
+    /**
+     * Creates a new TimeSpan instance that represents the specified number of seconds.
+     *
+     * @param float $seconds Number of seconds.
+     * @return TimeSpan Instance representing the provided number of seconds.
+     */
+    public static function fromSeconds(float $seconds): TimeSpan {
+        $abs = abs($seconds);
+        $round = (int)floor($abs);
+        $micros = (int)floor(($abs - $round) * self::MICROS_IN_SEC);
+        return self::create(0, 0, 0, $round, $micros, $seconds < 0);
+    }
+
+    /**
+     * Creates a new TimeSpan instance that represents the specified number of milliseconds.
+     *
+     * @param float $millis Number of milliseconds.
+     * @return TimeSpan Instance representing the provided number of milliseconds.
+     */
+    public static function fromMilliseconds(float $millis): TimeSpan {
+        return self::fromMicroseconds($millis * 1000);
+    }
+
+    /**
+     * Creates a new TimeSpan instance that represents the specified number of microseconds.
+     *
+     * @param float $micros Number of microseconds.
+     * @return TimeSpan Instance representing the provided number of microseconds.
+     */
+    public static function fromMicroseconds(float $micros): TimeSpan {
+        return self::create(0, 0, 0, 0, (int)floor(abs($micros)), $micros < 0);
+    }
+
+    /**
+     * Creates a new TimeSpan using the given parameters.
+     *
+     * @param int $days Number of days.
+     * @param int $hours Number of hours.
+     * @param int $minutes Number of minutes.
+     * @param int $seconds Number of seconds.
+     * @param int $micros Number of microseconds.
+     * @param bool $negative true for a negative TimeSpan, false for positive.
+     * @return TimeSpan A new TimeSpan from the provided parameters.
+     */
+    public static function create(int $days, int $hours, int $minutes, int $seconds, int $micros = 0, bool $negative = false): TimeSpan {
+        $ts = new TimeSpan;
+        $ts->realDays = $days = max(0, $days);
+        $ts->h = max(0, min(23, $hours));
+        $ts->i = max(0, min(59, $minutes));
+        $ts->s = max(0, min(59, $seconds));
+        $ts->f = $micros / self::MICROS_IN_SEC;
+        $ts->invert = $negative ? 1 : 0;
+
+        // this may still be stupid
+        if($days > 0) {
+            $days /= 365;
+            $ts->y = (int)$days;
+            $days -= $ts->y;
+            $days *= 12;
+            $ts->m = (int)$days;
+            $days -= $ts->m;
+            $days *= 31;
+            $ts->d = (int)$days;
+        }
+
+        return $ts;
+    }
+
+    /**
+     * Creates a TimeSpan from the relative parts of a string.
+     *
+     * Uses the same parser as strtotime and the DateTime constructor internally.
+     *
+     * @param string $dateTime A date with relative parts.
+     * @return TimeSpan A TimeSpan representing the given
+     */
+    public static function createFromDateString(string $dateTime): TimeSpan {
+        return self::cast(parent::createFromDateString($dateTime));
+    }
+
+    /**
+     * Makes sure a DateInterval inheriting object is a TimeSpan instance.
+     *
+     * @param DateInterval $dateInterval Input object.
+     * @return TimeSpan If the input was a TimeSpan, the same instance will be returned.
+     *                  If the input was something else, a new TimeSpan instance will be returned based on the input.
+     */
+    public static function cast(DateInterval $dateInterval): TimeSpan {
+        if($dateInterval instanceof TimeSpan)
+            return $dateInterval;
+
+        $timeSpan = new TimeSpan;
+        $timeSpan->y = $dateInterval->y;
+        $timeSpan->m = $dateInterval->m;
+        $timeSpan->d = $dateInterval->d;
+        $timeSpan->h = $dateInterval->h;
+        $timeSpan->i = $dateInterval->i;
+        $timeSpan->s = $dateInterval->s;
+        $timeSpan->f = $dateInterval->f;
+        $timeSpan->invert = $dateInterval->invert;
+        $timeSpan->realDays = $timeSpan->calculateRealDays();
+        return $timeSpan;
+    }
+}
diff --git a/src/TimeZoneInfo.php b/src/TimeZoneInfo.php
new file mode 100644
index 0000000..5467cf0
--- /dev/null
+++ b/src/TimeZoneInfo.php
@@ -0,0 +1,213 @@
+<?php
+// TimeZoneInfo.php
+// Created: 2021-06-12
+// Updated: 2022-02-27
+
+namespace Index;
+
+use DateTimeInterface;
+use DateTimeZone;
+use JsonSerializable;
+use RuntimeException;
+use Stringable;
+
+/**
+ * Represents a time zone.
+ */
+class TimeZoneInfo extends DateTimeZone implements JsonSerializable, Stringable, IComparable, IEquatable {
+    private array|null $location = null;
+
+    private static bool $constructed = false;
+    private static TimeZoneInfo $utc;
+
+    /**
+     * Constructs a new TimeZoneInfo object.
+     *
+     * @param string $timeZone Time zone identifier.,
+     * @return TimeZoneInfo New instance of TimeZoneInfo.
+     */
+    public function __construct(string $timeZone) {
+        parent::__construct($timeZone);
+    }
+
+    /**
+     * @internal
+     */
+    public static function construct(): void {
+        if(self::$constructed)
+            throw new RuntimeException('Static constructor was already called.');
+        self::$constructed = true;
+        self::$utc = new TimeZoneInfo('UTC');
+    }
+
+    /**
+     * Gets a TimeZoneInfo instance representing the UTC (+00:00) time zone.
+     *
+     * @return TimeZoneInfo Instance representing UTC.
+     */
+    public static function utc(): TimeZoneInfo {
+        return self::$utc;
+    }
+
+    /**
+     * Gets the current default time zone.
+     *
+     * Uses date_default_timezone_get internally.
+     *
+     * @return TimeZoneInfo Instance representing the default time zone.
+     */
+    public static function default(): TimeZoneInfo {
+        return new TimeZoneInfo(date_default_timezone_get());
+    }
+
+    /**
+     * Sets the current default time zone.
+     *
+     * Uses date_default_timezone_set internally.
+     *
+     * @param DateTimeZone|string $timeZone Desired default time zone.
+     * @throws RuntimeException If an invalid time zone was supplied.
+     */
+    public static function setDefault(DateTimeZone|string $timeZone): void {
+        if($timeZone instanceof DateTimeZone)
+            $timeZone = $timeZone->getName();
+
+        if(!date_default_timezone_set($timeZone))
+            throw new RuntimeException('Invalid default time zone specified.');
+    }
+
+    /**
+     * Gets location info for a time zone.
+     *
+     * It makes more sense to use getCountryCode, getLatitude, getLongitude and getComments, if you can.
+     *
+     * @return array Location information.
+     */
+    public function getLocation(): array {
+        if($this->location === null)
+            $this->location = parent::getLocation();
+        return $this->location;
+    }
+
+    /**
+     * Gets the country code of the country which this time zone falls in.
+     *
+     * @return string Country code for this time zone.
+     */
+    public function getCountryCode(): string {
+        return $this->getLocation()['country_code'];
+    }
+
+    /**
+     * Gets the latitude of this time zone.
+     *
+     * @return float Latitude of this time zone.
+     */
+    public function getLatitude(): float {
+        return $this->getLocation()['latitude'];
+    }
+
+    /**
+     * Gets the longitude of this time zone.
+     *
+     * @return float Longitude of this time zone.
+     */
+    public function getLongitude(): float {
+        return $this->getLocation()['longitude'];
+    }
+
+    /**
+     * Gets location comments for this time zone.
+     *
+     * @return string Location comments.
+     */
+    public function getComments(): string {
+        return $this->getLocation()['comments'];
+    }
+
+    /**
+     * Gets the offset of this timezone relative to a given date/time instance.
+     *
+     * @param DateTimeInterface|null $dateTime Date/time to use as a base, null for UTC Now.
+     * @return int Offset relative to given date/time.
+     */
+    public function getOffset(DateTimeInterface|null $dateTime = null): int {
+        return parent::getOffset($dateTime ?? new DateTime('now', self::$utc));
+    }
+
+    /**
+     * Creates a string representation of this object.
+     *
+     * @return string Representation of this object.
+     */
+    public function __toString(): string {
+        $offset = $this->getOffset();
+        return sprintf(
+            '(UTC%s%s) %s',
+            $offset < 0 ? '-' : '+',
+            date('H:i', abs($offset)),
+            $this->getName()
+        );
+    }
+
+    /**
+     * Returns the data which should be serialized as json.
+     *
+     * @see https://www.php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return mixed Data to be passed to json_encode.
+     */
+    public function jsonSerialize(): mixed {
+        return $this->getName();
+    }
+
+    public function compare(mixed $other): int {
+        if(!($other instanceof DateTimeZone))
+            return -1;
+        $other = self::cast($other);
+
+        $diff = $this->getOffset() <=> $other->getOffset();
+        if($diff) return $diff;
+
+        return strcmp($this->getName(), $other->getName());
+    }
+
+    public function equals(mixed $other): bool {
+        if(!($other instanceof DateTimeZone))
+            return false;
+        return $this->getName() === $other->getName()
+            || $this->getOffset() === self::cast($other)->getOffset();
+    }
+
+    /**
+     * Gets a list of all time zones.
+     *
+     * @param bool $ordered true if the list should be ordered, false if not.
+     * @param int $timeZoneGroup ID of a group to filter the generated list.
+     * @param string|null $countryCode Country to filter the generated list by.
+     * @return array Array containing the time zones.
+     */
+    public static function all(bool $ordered = false, int $timeZoneGroup = DateTimeZone::ALL, string|null $countryCode = null): array {
+        $timeZones = self::listIdentifiers($timeZoneGroup, $countryCode === null ? null : $countryCode);
+        $timeZones = XArray::select($timeZones, fn($id) => new TimeZoneInfo($id));
+
+        if($ordered)
+            $timeZones = XArray::sort($timeZones, fn($a, $b) => $a->compare($b));
+
+        return $timeZones;
+    }
+
+    /**
+     * Makes sure a DateTimeZone inheriting object is a TimeZoneInfo instance.
+     *
+     * @param DateTimeZone $timeZone Input object.
+     * @return TimeZoneInfo If the input was a TimeZoneInfo, the same instance will be returned.
+     *                      If the input was something else, a new TimeZoneInfo instance will be returned based on the input.
+     */
+    public static function cast(DateTimeZone $timeZone): TimeZoneInfo {
+        if($timeZone instanceof TimeZoneInfo)
+            return $timeZone;
+        return new TimeZoneInfo($timeZone->getName());
+    }
+}
+
+TimeZoneInfo::construct();
diff --git a/src/Type.php b/src/Type.php
new file mode 100644
index 0000000..aee236b
--- /dev/null
+++ b/src/Type.php
@@ -0,0 +1,126 @@
+<?php
+// Type.php
+// Created: 2021-04-26
+// Updated: 2022-02-28
+
+namespace Index;
+
+use ReflectionClass;
+use RuntimeException;
+
+final class Type {
+    /**
+     * Boolean type id.
+     *
+     * @var string
+     */
+    public const BOOL = 'boolean';
+
+    /**
+     * Integer type id.
+     *
+     * @var string
+     */
+    public const INTEGER = 'integer';
+
+    /**
+     * Floating point type id.
+     *
+     * @var string
+     */
+    public const FLOAT = 'double';
+
+    /**
+     * String type id.
+     *
+     * @var string
+     */
+    public const STRING = 'string';
+
+    /**
+     * Array type id.
+     *
+     * @var string
+     */
+    public const ARRAY = 'array';
+
+    /**
+     * Object type id.
+     *
+     * @var string
+     */
+    public const OBJECT = 'object';
+
+    /**
+     * Resource type id.
+     *
+     * @var string
+     */
+    public const RESOURCE = 'resource';
+
+    /**
+     * Closed resource type id.
+     *
+     * @var string
+     */
+    public const CLOSED_RESOURCE = 'resource (closed)';
+
+    /**
+     * NULL type id.
+     *
+     * @var string
+     */
+    public const NULL = 'NULL';
+
+    /**
+     * Unknown type id.
+     *
+     * @var string
+     */
+    public const UNKNOWN = 'unknown type';
+
+    /**
+     * Gets the default value for this type.
+     *
+     * @return mixed Default value for the given base type.
+     */
+    public static function default(string $type): mixed {
+        switch($type) {
+            case self::BOOL:
+                return false;
+            case self::INTEGER:
+                return 0;
+            case self::FLOAT:
+                return 0.0;
+            case self::STRING:
+                return '';
+            case self::ARRAY:
+                return [];
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Gets a list of all class names this Type inherits.
+     *
+     * @param string|object $target Target object.
+     * @return array Array containing the names.
+     */
+    public static function classTree(string|object $target): array {
+        if(is_object($target))
+            $target = get_class($target);
+
+        $tree = [];
+        $classInfo = new ReflectionClass($target);
+
+        foreach($classInfo->getInterfaceNames() as $interface)
+            $tree[] = $interface;
+
+        do {
+            $tree[] = $classInfo->getName();
+        } while(($classInfo = $classInfo->getParentClass()) !== false);
+
+        return $tree;
+    }
+}
diff --git a/src/Version.php b/src/Version.php
new file mode 100644
index 0000000..62c2cda
--- /dev/null
+++ b/src/Version.php
@@ -0,0 +1,239 @@
+<?php
+// Version.php
+// Created: 2021-04-29
+// Updated: 2022-02-27
+
+namespace Index;
+
+use InvalidArgumentException;
+use Stringable;
+
+/**
+ * A Semantic Versioning implementation. Following version 2.0.0 of the specification.
+ *
+ * @see https://semver.org/spec/v2.0.0.html
+ */
+class Version implements Stringable, IComparable, IEquatable {
+    private int $major;
+    private int $minor;
+    private int $patch;
+    private array $prerelease;
+    private array $build;
+
+    private ?string $versionString = null;
+
+    private static ?Version $empty = null;
+
+    /**
+     * Constructor for Version.
+     *
+     * @param int $major A positive integer indicating the major version.
+     * @param int $minor A positive integer indicating the minor version.
+     * @param int $patch A positive integer indicating the patch version.
+     * @param string $prerelease A dot separated string indicating prerelease information.
+     * @param string $build A dot separated string indicating build information.
+     * @throws InvalidArgumentException A negative integer was provided.
+     * @return Version
+     */
+    public function __construct(int $major, int $minor = 0, int $patch = 0, string $prerelease = '', string $build = '') {
+        if($major < 0 || $minor < 0 || $patch < 0)
+            throw new InvalidArgumentException('$major, $minor and $patch should be positive integers.');
+
+        $this->major      = $major;
+        $this->minor      = $minor;
+        $this->patch      = $patch;
+        $this->prerelease = empty($prerelease) ? [] : explode('.', $prerelease);
+        $this->build      = empty($build)      ? [] : explode('.', $build);
+    }
+
+    /**
+     * Gets the value of the major version component.
+     *
+     * @return int Major version component.
+     */
+    public function getMajor(): int {
+        return $this->major;
+    }
+
+    /**
+     * Gets the value of the minor version component.
+     *
+     * @return int Minor version component.
+     */
+    public function getMinor(): int {
+        return $this->minor;
+    }
+
+    /**
+     * Gets the value of the patch version component.
+     *
+     * @return int Patch version component.
+     */
+    public function getPatch(): int {
+        return $this->patch;
+    }
+
+    /**
+     * Gets the split value of the prerelease component.
+     *
+     * @return array array containing the prerelease parts.
+     */
+    public function getPrerelease(): array {
+        return $this->prerelease;
+    }
+
+    /**
+     * Gets the split value of the build component.
+     *
+     * @return array array contains the build parts.
+     */
+    public function getBuild(): array {
+        return $this->build;
+    }
+
+    /**
+     * Tests if this Version instance represents a prerelease according to the SemVer spec.
+     *
+     * @return bool true if the version indicates a prerelease, false if not.
+     */
+    public function isPrerelease(): bool {
+        return $this->major < 1 || !empty($this->prerelease);
+    }
+
+    /**
+     * Creates a new instance of Version with the major component incremented.
+     *
+     * This will implicitly drop prerelease and build info and reset the minor and patch component.
+     *
+     * @return Version the newly created instance of Version.
+     */
+    public function incrementMajor(): Version {
+        return new Version($this->major + 1, 0, 0);
+    }
+
+    /**
+     * Creates a new instance of Version with the minor component incremented.
+     *
+     * This will implicitly drop the prerelease and build info and reset the patch component.
+     *
+     * @return Version the newly created instance of Version.
+     */
+    public function incrementMinor(): Version {
+        return new Version($this->major, $this->minor + 1, 0);
+    }
+
+    /**
+     * Creates a new instance of Version with the patch component incremented.
+     *
+     * This will implicitly drop the prerelease and build info.
+     *
+     * @return Version the newly created instance of Version.
+     */
+    public function incrementPatch(): Version {
+        return new Version($this->major, $this->minor, $this->patch + 1);
+    }
+
+    /**
+     * Checks this instance of Version with another for equality.
+     *
+     * The build component is ignored, as per the SemVer spec.
+     *
+     * @param mixed $other Another instance of Version.
+     * @return bool true if the instances are equal, false if not.
+     */
+    public function equals(mixed $other): bool {
+        return $other instanceof Version
+            && $other->major === $this->major
+            && $other->minor === $this->minor
+            && $other->patch === $this->patch
+            && XArray::sequenceEquals($this->prerelease, $other->prerelease);
+    }
+
+    /**
+     * Compares this instance of Version with another.
+     *
+     * The build component is ignored and prerelease component is compared as per the SemVer spec.
+     *
+     * @param mixed $other Another instance of Version.
+     */
+    public function compare(mixed $other): int {
+        if(!($other instanceof Version))
+            return PHP_INT_MIN;
+
+        $diff = $this->major <=> $other->major;
+        if($diff) return $diff;
+
+        $diff = $this->minor <=> $other->minor;
+        if($diff) return $diff;
+
+        $diff = $this->patch <=> $other->patch;
+        if($diff) return $diff;
+
+        $tpi = XArray::extractIterator($this->prerelease);
+        $opi = XArray::extractIterator($other->prerelease);
+
+        $tpi->rewind();
+        $opi->rewind();
+        $valid = $tpi->valid();
+        $diff = $opi->valid() <=> $valid;
+        if($diff) return $diff;
+
+        while($valid) {
+            $diff = $opi->current()->compare($tpi->current());
+            if($diff) return $diff;
+
+            $tpi->next();
+            $opi->next();
+            $valid = $tpi->valid();
+            $diff = $opi->valid() <=> $valid;
+            if($diff) return $diff;
+        }
+
+        return 0;
+    }
+
+    public function __toString(): string {
+        if($this->versionString === null) {
+            $string = $this->major . '.' . $this->minor . '.' . $this->patch;
+
+            if(!empty($this->prerelease))
+                $string .= '-' . implode('.', $this->prerelease);
+
+            if(!empty($this->build))
+                $string .= '+' . implode('.', $this->build);
+
+            $this->versionString = $string;
+        }
+
+        return $this->versionString;
+    }
+
+    /**
+     * Returns an empty Version instance.
+     *
+     * @return Version Instance of Version with all values set to 0.
+     */
+    public static function empty(): Version {
+        if(self::$empty === null)
+            self::$empty = new Version(0);
+        return self::$empty;
+    }
+
+    /**
+     * Parses a version string.
+     *
+     * Parses a version string with a regex adapted from SemVer's documentation. Modified to allow an optional v prefix.
+     *
+     * @see https://semver.org/spec/v2.0.0.html#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+     * @param string $versionString String containing a version number.
+     * @throws InvalidArgumentException Provided string does not represent a valid version.
+     * @return Version An instance of Version representing the provided version string.
+     */
+    public static function parse(string $versionString): Version {
+        // Regex adapted from https://semver.org/spec/v2.0.0.html#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+        if(!preg_match('#^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<build>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$#', $versionString, $matches))
+            throw new InvalidArgumentException('$versionString is not a valid version string.');
+
+        return new Version($matches['major'], $matches['minor'], $matches['patch'], $matches['prerelease'] ?? '', $matches['build'] ?? '');
+    }
+}
diff --git a/src/WString.php b/src/WString.php
new file mode 100644
index 0000000..72968b5
--- /dev/null
+++ b/src/WString.php
@@ -0,0 +1,382 @@
+<?php
+// WString.php
+// Created: 2021-06-22
+// Updated: 2022-02-27
+
+namespace Index;
+
+use Traversable;
+use InvalidArgumentException;
+use ValueError;
+
+/**
+ * Provides an immutable multi-byte string with arrow methods.
+ */
+final class WString implements IString {
+    use XStringTrait;
+
+    public const DEFAULT_ENCODING = 'utf-8';
+
+    private static $defaultEncoding = self::DEFAULT_ENCODING;
+
+    private string $value;
+    private string $encoding;
+
+    public function __construct(string $value = '', ?string $encoding = null) {
+        $encoding ??= self::$defaultEncoding;
+
+        if(!mb_check_encoding($value, $encoding))
+            throw new InvalidArgumentException('$value is not a valid value for the selected encoding.');
+
+        $this->value = $value;
+        $this->encoding = mb_preferred_mime_name($encoding);
+    }
+
+    public function getLength(): int {
+        return mb_strlen($this->value, $this->encoding);
+    }
+
+    /**
+     * Returns the amount of bytes the string contains.
+     *
+     * @return int Amount of raw bytes.
+     */
+    public function getByteCount(): int {
+        return strlen($this->value);
+    }
+
+    public function isEmpty(): bool {
+        // an empty string is an empty string so this should be fine regardless of encoding
+        return $this->value === '';
+    }
+
+    public function indexOf(IString|string $text, int $offset = 0): int {
+        $text = (string)self::castEncoding($text, $this->encoding);
+        $pos = mb_strpos($this->value, $text, $offset, $this->encoding);
+        if($pos === false)
+            return -1;
+        return $pos;
+    }
+
+    public function contains(IString|string $text): bool {
+        return str_contains($this->value, (string)$text);
+    }
+
+    public function substring(int $offset, int|null $length = null): IString {
+        return new WString(mb_substr($this->value, $offset, $length, $this->encoding), $this->encoding);
+    }
+
+    public function startsWith(IString|string $text): bool {
+        $text = self::castEncoding($text, $this->encoding);
+        return $this->substring(0, $text->getLength())->equals($text);
+    }
+
+    public function endsWith(IString|string $text): bool {
+        $text = self::castEncoding($text, $this->encoding);
+        return $this->substring(0 - $text->getLength())->equals($text);
+    }
+
+    public function replace(IString|string $search, IString|string $replace): IString {
+        $search = (string)self::castEncoding($search, $this->encoding);
+        $replace = (string)self::castEncoding($replace, $this->encoding);
+        $parts = self::doRegex(fn() => mb_split(preg_quote($search), $this->value));
+        $subject = implode($replace, $parts);
+        return new WString($subject, $this->encoding);
+    }
+
+    public function append(IString|string $string): IString {
+        $string = self::castEncoding($string, $this->encoding);
+        return new WString($this->value . $string->value, $this->encoding);
+    }
+
+    public function prepend(IString|string $string): IString {
+        $string = self::castEncoding($string, $this->encoding);
+        return new WString($string->value . $this->value, $this->encoding);
+    }
+
+    public function split(IString|string $separator, int $limit = PHP_INT_MAX): array {
+        return XArray::select(
+            self::doRegex(fn() => mb_split(preg_quote((string)$separator), $this->value, $limit)),
+            fn($str) => new WString($str, $this->encoding)
+        );
+    }
+
+    public function chunk(int $chunkSize): array {
+        return XArray::select(
+            mb_str_split($this->value, $chunkSize, $this->encoding),
+            fn($str) => new WString($str, $this->encoding)
+        );
+    }
+
+    private function trimInternal(IString|string $characters, int $flags): IString {
+        if($flags & 0x01) {
+            if($characters instanceof WString)
+                $characters = (string)$characters->convertEncoding($this->encoding);
+            else
+                $characters = mb_convert_encoding((string)$characters, $this->encoding, 'ascii');
+        } else
+            $characters = (string)$characters;
+
+        $start = 0;
+        $end = $this->getLength() - 1;
+
+        if($flags & 0x02)
+            for(; $start < $this->getLength(); ++$start)
+                if(mb_strpos($characters, $this[$start], 0, $this->encoding) === false)
+                    break;
+
+        if($flags & 0x04)
+            for(; $end > 0; --$end)
+                if(mb_strpos($characters, $this[$end], 0, $this->encoding) === false)
+                    break;
+
+        return $this->substring($start, $end - $start + 1);
+    }
+
+    public function trim(IString|string $characters = IString::TRIM_CHARS, bool $convertChars = true): IString {
+        $flags = 0x06;
+        if($convertChars) $flags |= 0x01;
+        return $this->trimInternal($characters, $flags);
+    }
+
+    public function trimStart(IString|string $characters = IString::TRIM_CHARS, bool $convertChars = true): IString {
+        $flags = 0x02;
+        if($convertChars) $flags |= 0x01;
+        return $this->trimInternal($characters, $flags);
+    }
+
+    public function trimEnd(IString|string $characters = IString::TRIM_CHARS, bool $convertChars = true): IString {
+        $flags = 0x04;
+        if($convertChars) $flags |= 0x01;
+        return $this->trimInternal($characters, $flags);
+    }
+
+    public function toLower(): IString {
+        return new WString(mb_strtolower($this->value, $this->encoding), $this->encoding);
+    }
+
+    public function toUpper(): IString {
+        return new WString(mb_strtoupper($this->value, $this->encoding), $this->encoding);
+    }
+
+    public function reverse(): IString {
+        $chars = [];
+        foreach($this as $char)
+            $chars[] = $char;
+        return new WString(implode(array_reverse($chars)), $this->encoding);
+    }
+
+    public function __toString(): string {
+        return $this->value;
+    }
+
+    public function toAString(bool $convert = true): AString {
+        $value = $this->value;
+        if($convert && self::sameEncoding('ascii', $this->encoding))
+            $value = mb_convert_encoding($value, 'ascii', $this->encoding);
+        return new AString($value);
+    }
+
+    public function getEncoding(): string {
+        return $this->encoding;
+    }
+
+    public function convertEncoding(string $encoding): WString {
+        if(self::sameEncoding($encoding, $this->encoding))
+            return $this;
+        $value = mb_convert_encoding($this->value, $encoding, $this->encoding);
+        return new WString($value, $encoding);
+    }
+
+    /**
+     * Checks if an offset exists in the string.
+     *
+     * You should call isset($string[$offset]) instead of $string->offsetExists($offset).
+     *
+     * @see https://www.php.net/manual/en/arrayaccess.offsetexists.php
+     * @param int $offset Character offset.
+     * @return bool true if it exists, false if not.
+     */
+    public function offsetExists(mixed $offset): bool {
+        $offset = (int)$offset;
+        return $offset >= 0 && $offset < $this->getLength();
+    }
+
+    /**
+     * Gets an offset from the string.
+     *
+     * You should do $string[$offset] instead of $string->offsetGet($offset).
+     *
+     * @see https://www.php.net/manual/en/arrayaccess.offsetget.php
+     * @param int $offset Character offset.
+     * @return string Character at that offset.
+     */
+    public function offsetGet(mixed $offset): mixed {
+        return mb_substr($this->value, (int)$offset, 1, $this->encoding);
+    }
+
+    /**
+     * Gets an iterator object for this string.
+     *
+     * @return StringIterator An iterator for this string.
+     */
+    public function getIterator(): Traversable {
+        return new StringIterator($this);
+    }
+
+    /**
+     * Returns the data which should be serialized as json.
+     *
+     * @see https://www.php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return mixed Data to be passed to json_encode.
+     */
+    public function jsonSerialize(): mixed {
+        return $this->value;
+    }
+
+    public function bencodeSerialise(): mixed {
+        return $this->value;
+    }
+
+    /**
+     * Gets a serialized representation of this object.
+     *
+     * @return array Serialized data.
+     */
+    public function __serialize(): array {
+        return [$this->encoding, $this->value];
+    }
+
+    /**
+     * Reconstructs an object from a serialized string.
+     *
+     * @param array $serialized Serialized data.
+     */
+    public function __unserialize(array $serialized): void {
+        [$this->encoding, $this->value] = $serialized;
+    }
+
+    /**
+     * Checks whether this string is identical to another.
+     *
+     * @param mixed $other An instance of IString or a PHP string.
+     * @return bool true if the strings have the same value, false if not.
+     */
+    public function equals(mixed $other): bool {
+        return $this->compare($other) === 0;
+    }
+
+    /**
+     * Compares whether this string is identical to another.
+     *
+     * @param mixed $other An instance of IString or a PHP string.
+     */
+    public function compare(mixed $other): int {
+        $other = self::castEncoding($other, $this->encoding);
+        return strcmp($this->value, (string)$other);
+    }
+
+    /**
+     * Creates a new identical WString instance.
+     *
+     * This method is somewhat pointless, given the immutable nature of this object,
+     *  but rather people calling this instead of calling ->substring(0);
+     *
+     * @return WString A new identical instance of WString.
+     */
+    public function clone(): mixed {
+        return new WString($this->value, $this->encoding);
+    }
+
+    private function doRegex(callable $callback): mixed {
+        $encoding = self::getRegexEncoding();
+        self::setRegexEncoding($this->encoding);
+        $result = $callback();
+        self::setRegexEncoding($encoding);
+        return $result;
+    }
+
+    private static function sameEncoding(string $name1, string $name2): bool {
+        return mb_preferred_mime_name($name1) === mb_preferred_mime_name($name2);
+    }
+
+    /**
+     * Joins an iterable object together with a separator to create a string.
+     *
+     * @param iterable $source Source object.
+     * @param IString|string $separator Separator to use as glue.
+     * @param ?string $encoding Desired encoding, null for Index default.
+     * @return WString Resulting string.
+     */
+    public static function join(iterable $source, IString|string $separator = '', ?string $encoding = null): WString {
+        // func probably doesn't work entirely as intended
+        $encoding ??= self::getDefaultEncoding();
+        $separator = self::castEncoding($separator, $encoding);
+        if(!is_array($source)) {
+            $parts = [];
+            foreach($source as $value)
+                $parts[] = $value;
+            $source = $parts;
+        }
+
+        return new WString(implode((string)$separator, $source), $encoding);
+    }
+
+    public static function getDefaultEncoding(): string {
+        return self::$defaultEncoding;
+    }
+
+    public static function setDefaultEncoding(string $encoding = ''): void {
+        if(empty($encoding))
+            self::$defaultEncoding = self::DEFAULT_ENCODING;
+        else {
+            try {
+                if(mb_encoding_aliases($encoding) !== false)
+                    self::$defaultEncoding = $encoding;
+            } catch(ValueError $ex) {}
+        }
+    }
+
+    public static function getInternalEncoding(): string {
+        return mb_internal_encoding();
+    }
+
+    public static function setInternalEncoding(string $encoding): void {
+        mb_internal_encoding($encoding);
+    }
+
+    public static function getRegexEncoding(): string {
+        return mb_regex_encoding();
+    }
+
+    public static function setRegexEncoding(string $encoding): void {
+        mb_regex_encoding($encoding);
+    }
+
+    public static function fromRequest(string $raw): WString {
+        return new WString($raw, self::getInternalEncoding());
+    }
+
+    /**
+     * Returns a reusable empty string instance.
+     *
+     * @return WString An empty string.
+     */
+    public static function empty(): WString {
+        static $empty = null;
+        $empty ??= new WString('');
+        return $empty;
+    }
+
+    public static function cast(mixed $string): WString {
+        if($string instanceof WString)
+            return $string;
+        if($string instanceof AString)
+            return $string->toWString('ascii', false);
+        return new WString((string)$string, 'ascii');
+    }
+
+    public static function castEncoding(mixed $string, string $encoding): WString {
+        return self::cast($string)->convertEncoding($encoding);
+    }
+}
diff --git a/src/XArray.php b/src/XArray.php
new file mode 100644
index 0000000..c900288
--- /dev/null
+++ b/src/XArray.php
@@ -0,0 +1,489 @@
+<?php
+// XArray.php
+// Created: 2022-02-02
+// Updated: 2022-02-14
+
+namespace Index;
+
+use stdClass;
+use InvalidArgumentException;
+use Countable;
+use Iterator;
+use IteratorAggregate;
+use Index\Collections\IArrayable;
+use Index\Collections\ArrayIterator;
+
+/**
+ * Provides various helper methods for collections.
+ */
+final class XArray {
+    /**
+     * Compare items normally without type casting for uniqueness.
+     *
+     * @var int
+     */
+    const UNIQUE_VALUE = SORT_REGULAR;
+
+    /**
+     * Compare items items as numbers.
+     *
+     * @var int
+     */
+    const UNIQUE_NUMBER = SORT_NUMERIC;
+
+    /**
+     * Compare items as strings.
+     *
+     * @var int
+     */
+    const UNIQUE_STRING = SORT_STRING;
+
+    /**
+     * Retrieves the amount of items in a collection.
+     *
+     * @return int
+     */
+    public static function count(iterable $iterable): int {
+        if(is_array($iterable) || $iterable instanceof Countable)
+            return count($iterable);
+
+        $count = 0;
+
+        foreach($iterable as $item)
+            ++$count;
+
+        return $count;
+    }
+
+    /**
+     * Checks if a collection has no items.
+     *
+     * @return bool
+     */
+    public static function empty(iterable $iterable): bool {
+        if(is_array($iterable))
+            return empty($iterable);
+        if($iterable instanceof Countable)
+            return $iterable->count() < 1;
+
+        $iterator = self::extractIterator($iterable);
+        $iterator->rewind();
+
+        return !$iterator->valid();
+    }
+
+    /**
+     * Checks if an item occurs in a collection
+     *
+     * @param iterable $iterable
+     * @param mixed $value
+     * @param bool $strict
+     * @return bool
+     */
+    public static function contains(iterable $iterable, mixed $value, bool $strict = false): bool {
+        if(is_array($iterable))
+            return in_array($value, $iterable, $strict);
+
+        if($strict) {
+            foreach($iterable as $item)
+                if($item === $value)
+                    return true;
+        } else {
+            foreach($iterable as $item)
+                if($item == $value)
+                    return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if a key occurs in a collection.
+     *
+     * @param iterable $iterable
+     * @param mixed $key
+     * @return bool
+     */
+    public static function containsKey(iterable $iterable, mixed $key): bool {
+        if(is_array($iterable))
+            return array_key_exists($key, $iterable);
+
+        foreach($iterable as $k => $_)
+            if($k === $key)
+                return true;
+
+        return false;
+    }
+
+    /**
+     * Retrieves the first key in a collection.
+     *
+     * @param iterable $iterable
+     * @return int|string|null
+     */
+    public static function firstKey(iterable $iterable): int|string|null {
+        if(is_array($iterable))
+            return array_key_first($iterable);
+
+        foreach($iterable as $key => $_)
+            return $key;
+
+        return null;
+    }
+
+    /**
+     * Retrieves the last key in a collection.
+     *
+     * @param iterable $iterable
+     * @return int|string|null
+     */
+    public static function lastKey(iterable $iterable): int|string|null {
+        if(is_array($iterable))
+            return array_key_last($iterable);
+
+        $key = null;
+        foreach($iterable as $key => $_);
+
+        return $key;
+    }
+
+    /**
+     * Gets the index of a value in a collection.
+     *
+     * @param iterable $iterable
+     * @param mixed $value
+     * @param bool $strict
+     * @return int|string|false
+     */
+    public static function indexOf(
+        iterable $iterable,
+        mixed $value,
+        bool $strict = false
+    ): int|string|false {
+        if(is_array($iterable))
+            return array_search($value, $iterable, $strict);
+
+        if($strict) {
+            foreach($iterable as $key => $item)
+                if($item === $value)
+                    return $key;
+        } else {
+            foreach($iterable as $key => $item)
+                if($item == $value)
+                    return $key;
+        }
+
+        return false;
+    }
+
+    /**
+     * Extracts unique values from a collection.
+     *
+     * @param iterable $iterable
+     * @param int $type
+     * @return array
+     */
+    public static function unique(iterable $iterable, int $type = self::UNIQUE_VALUE): array {
+        if(is_array($iterable))
+            return array_unique($iterable, $type);
+
+        // can probably be replicated better than this
+        $items = [];
+
+        foreach($iterable as $key => $item)
+            $items[$key] = $item;
+
+        return array_unique($items, $type);
+    }
+
+    /**
+     * Takes values from a collection and discards the keys.
+     *
+     * @param iterable $iterable
+     * @return array
+     */
+    public static function reflow(iterable $iterable): array {
+        if(is_array($iterable))
+            return array_values($iterable);
+
+        $items = [];
+
+        foreach($iterable as $item)
+            $items[] = $item;
+
+        return $items;
+    }
+
+    /**
+     * Puts a collection in reverse order.
+     *
+     * @param iterable $iterable
+     * @return array
+     */
+    public static function reverse(iterable $iterable): array {
+        if(is_array($iterable))
+            return array_reverse($iterable);
+
+        $items = [];
+
+        foreach($iterable as $key => $item)
+            $items[$key] = $item;
+
+        return array_reverse($items);
+    }
+
+    /**
+     * Merges two collections.
+     *
+     * @param iterable $iterable1
+     * @param iterable $iterable2
+     * @return array
+     */
+    public static function merge(iterable $iterable1, iterable $iterable2): array {
+        return array_merge(self::toArray($iterable1), self::toArray($iterable2));
+    }
+
+    /**
+     * Sorts a collection according to a comparer.
+     *
+     * @param iterable $iterable
+     * @param callable $comparer
+     * @return array
+     */
+    public static function sort(iterable $iterable, callable $comparer): array {
+        if(is_array($iterable)) {
+            usort($iterable, $comparer);
+            return $iterable;
+        }
+
+        $items = [];
+
+        foreach($iterable as $key => $item)
+            $items[$key] = $item;
+
+        usort($items, $comparer);
+
+        return $items;
+    }
+
+    /**
+     * Takes a subsection of a collection.
+     *
+     * @param iterable $iterable
+     * @param int $offset
+     * @param int|null $length
+     * @return array
+     */
+    public static function slice(iterable $iterable, int $offset, int|null $length = null): array {
+        if(is_array($iterable))
+            return array_slice($iterable, $offset, $length);
+
+        $items = [];
+
+        foreach($iterable as $key => $item)
+            $items[$key] = $item;
+
+        return array_slice($items, $offset, $length);
+    }
+
+    public static function toArray(iterable $iterable): array {
+        if(is_array($iterable))
+            return $iterable;
+        if($iterable instanceof IArrayable)
+            return $iterable->toArray();
+
+        $items = [];
+
+        foreach($iterable as $key => $item)
+            $items[$key] = $item;
+
+        return $items;
+    }
+
+    /**
+     * Checks if any value in the collection matches a given predicate.
+     *
+     * @param iterable $iterable
+     * @param callable $predicate
+     * @return bool
+     */
+    public static function any(iterable $iterable, callable $predicate): bool {
+        foreach($iterable as $value)
+            if($predicate($value))
+                return true;
+
+        return false;
+    }
+
+    /**
+     * Checks if all values in the collection match a given predicate.
+     *
+     * @param iterable $iterable
+     * @param callable $predicate
+     * @return bool
+     */
+    public static function all(iterable $iterable, callable $predicate): bool {
+        foreach($iterable as $value)
+            if(!$predicate($value))
+                return false;
+
+        return true;
+    }
+
+    /**
+     * Gets a subset of a collection based on a given predicate.
+     *
+     * @param iterable $iterable
+     * @param callable $predicate
+     * @return array
+     */
+    public static function where(iterable $iterable, callable $predicate): array {
+        $array = [];
+
+        foreach($iterable as $value)
+            if($predicate($value))
+                $array[] = $value;
+
+        return $array;
+    }
+
+    /**
+     * Gets the first item in a collection that matches a given predicate.
+     *
+     * @param iterable $iterable
+     * @param callable|null $predicate
+     * @return mixed
+     */
+    public static function first(iterable $iterable, ?callable $predicate = null): mixed {
+        if($predicate === null) {
+            if(is_array($iterable)) {
+                if(empty($iterable))
+                    return null;
+
+                return $iterable[array_key_first($iterable)];
+            }
+
+            foreach($iterable as $value)
+                return $value;
+
+            return null;
+        }
+
+        foreach($iterable as $value)
+            if($predicate($value))
+                return $value;
+
+        return null;
+    }
+
+    /**
+     * Gets the last item in a collection that matches a given predicate.
+     *
+     * @param iterable $iterable
+     * @param callable|null $predicate
+     * @return mixed
+     */
+    public static function last(iterable $iterable, ?callable $predicate = null): mixed {
+        if($predicate === null) {
+            if(is_array($iterable)) {
+                if(empty($iterable))
+                    return null;
+
+                return $iterable[array_key_last($iterable)];
+            }
+
+            $value = null;
+
+            foreach($iterable as $value);
+
+            return $value;
+        }
+
+        $iterable = self::reverse($iterable);
+        foreach($iterable as $value)
+            if($predicate($value))
+                return $value;
+
+        return null;
+    }
+
+    /**
+     * Applies a modifier on a collection.
+     *
+     * @param iterable $iterable
+     * @param callable $selector
+     * @return array
+     */
+    public static function select(iterable $iterable, callable $selector): array {
+        if(is_array($iterable))
+            return array_map($selector, $iterable);
+
+        $array = [];
+
+        foreach($iterable as $key => $value)
+            $array[] = $selector($value, $key);
+
+        return $array;
+    }
+
+    /**
+     * Tries to extract an instance of Iterator from any iterable type.
+     *
+     * @param iterable $iterable
+     * @return Iterator
+     */
+    public static function extractIterator(iterable &$iterable): Iterator {
+        if($iterable instanceof Iterator)
+            return $iterable;
+        if($iterable instanceof IteratorAggregate)
+            return $iterable->getIterator(); // @phpstan-ignore-line
+        if(is_array($iterable))
+            return new ArrayIterator($iterable);
+
+        throw new InvalidArgumentException('$iterable wasn\'t Iterator, IteratorAggregate or array.');
+    }
+
+    /**
+     * Checks if two collections are equal in both keys and values.
+     *
+     * @param iterable $iterable1
+     * @param iterable $iterable2
+     * @return bool
+     */
+    public static function sequenceEquals(iterable $iterable1, iterable $iterable2): bool {
+        if(count($iterable1) !== count($iterable2))
+            return false;
+
+        $iterator1 = self::extractIterator($iterable1);
+        $iterator2 = self::extractIterator($iterable2);
+
+        $iterator1->rewind();
+        $iterator2->rewind();
+        if(($valid = $iterator1->valid()) !== $iterator2->valid())
+            return false;
+
+        while($valid) {
+            if($iterator1->key() !== $iterator2->key())
+                return false;
+
+            $c1 = $iterator1->current();
+            $c2 = $iterator2->current();
+
+            if($c1 instanceof IEquatable) {
+                if(!$c1->equals($c2))
+                    return false;
+            } elseif($c2 instanceof IEquatable) {
+                if(!$c2->equals($c1))
+                    return false;
+            } elseif($c1 !== $c2)
+                return false;
+
+            $iterator1->next();
+            $iterator2->next();
+            if(($valid = $iterator1->valid()) !== $iterator2->valid())
+                return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/XString.php b/src/XString.php
new file mode 100644
index 0000000..a55e67f
--- /dev/null
+++ b/src/XString.php
@@ -0,0 +1,58 @@
+<?php
+// XString.php
+// Created: 2022-02-03
+// Updated: 2022-02-27
+
+namespace Index;
+
+/**
+ * Provides various helper methods for strings.
+ */
+final class XString {
+    public static function toBool(string $value): bool {
+        return boolval($value);
+    }
+
+    public static function toInt(string $value, int $base = 10): int {
+        return intval($value, $base);
+    }
+
+    public static function toFloat(string $value): float {
+        return floatval($value);
+    }
+
+    public static function escape(
+        string $value,
+        int $flags = ENT_COMPAT | ENT_HTML5,
+        ?string $encoding = null,
+        bool $doubleEncoding = true
+    ): string {
+        return htmlspecialchars($value, $flags, $encoding, $doubleEncoding);
+    }
+
+    /**
+     * Check if a string is null or empty.
+     *
+     * @param IString|string|null $string String ot check for emptiness.
+     * @return bool true if the string is empty, false if not.
+     */
+    public static function nullOrEmpty(IString|string|null $string): bool {
+        if($string === null)
+            return true;
+        if($string instanceof IString)
+            return $string->isEmpty();
+        return empty($string);
+    }
+
+    /**
+     * Check if a string is null or whitespace.
+     *
+     * @param IString|string|null $string String to check for whitespace.
+     * @return bool true if the string is whitespace, false if not.
+     */
+    public static function nullOrWhitespace(IString|string|null $string): bool {
+        if($string === null)
+            return true;
+        return empty(trim((string)$string));
+    }
+}
diff --git a/src/XStringTrait.php b/src/XStringTrait.php
new file mode 100644
index 0000000..8a61453
--- /dev/null
+++ b/src/XStringTrait.php
@@ -0,0 +1,64 @@
+<?php
+// XStringTrait.php
+// Created: 2021-06-22
+// Updated: 2022-02-27
+
+namespace Index;
+
+use BadMethodCallException;
+
+/**
+ * Provides method implementations that are common between all string types.
+ * @internal
+ */
+trait XStringTrait {
+    /**
+     * Gets the length of the string.
+     *
+     * For compliance with the Countable interface.
+     *
+     * @see https://www.php.net/manual/en/class.countable.php
+     * @return int Length of the string.
+     */
+    public function count(): int {
+        return $this->getLength();
+    }
+
+    /**
+     * Necessary to comply with the ArrayAccess interface.
+     *
+     * @internal
+     */
+    public function offsetSet(mixed $offset, mixed $value): void {
+        throw new BadMethodCallException('Strings are immutable.');
+    }
+
+    /**
+     * Necessary to comply with the ArrayAccess interface.
+     *
+     * @internal
+     */
+    public function offsetUnset(mixed $offset): void {
+        throw new BadMethodCallException('Strings are immutable.');
+    }
+
+    public function toBool(): bool {
+        return XString::toBool($this);
+    }
+
+    public function toInt(int $base = 10): int {
+        return XString::toInt($this, $base);
+    }
+
+    public function toFloat(): float {
+        return XString::toFloat($this);
+    }
+
+    public function escape(
+        int $flags = ENT_COMPAT | ENT_HTML5,
+        ?string $encoding = null,
+        bool $doubleEncoding = true
+    ): IString {
+        return new AString(XString::escape($this, $flags, $encoding, $doubleEncoding));
+    }
+}
diff --git a/tests/Base32Test.php b/tests/Base32Test.php
new file mode 100644
index 0000000..64c0d78
--- /dev/null
+++ b/tests/Base32Test.php
@@ -0,0 +1,32 @@
+<?php
+// Base32Test.php
+// Created: 2021-04-28
+// Updated: 2021-04-28
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Serialisation\Serialiser;
+
+/**
+ * @covers Base32
+ */
+final class Base32Test extends TestCase {
+    public const TESTS = [
+        'A' => '',
+        'JVUXGYLLMEQE22LLN52G6' => 'Misaka Mikoto',
+        'IFQUCYKBMFAWCQLBIFQUCYKBME' => 'AaAaAaAaAaAaAaAa',
+        'JEQGC3JAM5XWS3THEB2G6IDHN4QHI3ZAORUGKIDTN52XAIDTORXXEZJAORXSAYTVPEQGG3DPORUGK4ZO' => 'I am going to go to the soup store to buy clothes.',
+        'EFACGJBFLYTCUKBJ' => '!@#$%^&*()',
+    ];
+
+    public function testDecode(): void {
+        foreach(self::TESTS as $value => $expected)
+            $this->assertEquals($expected, (string)Serialiser::base32()->deserialise($value));
+    }
+
+    public function testEncode(): void {
+        foreach(self::TESTS as $expected => $value)
+            $this->assertEquals($expected, (string)Serialiser::base32()->serialise($value));
+    }
+}
diff --git a/tests/Base62Test.php b/tests/Base62Test.php
new file mode 100644
index 0000000..1916191
--- /dev/null
+++ b/tests/Base62Test.php
@@ -0,0 +1,36 @@
+<?php
+// Base62Test.php
+// Created: 2022-01-28
+// Updated: 2022-02-03
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Serialisation\Serialiser;
+
+/**
+ * @covers Base62Serialiser
+ */
+final class Base62Test extends TestCase {
+    public const TESTS = [
+        ['aaaaaa', 9311514030],
+        ['Soap', 12962613],
+        ['', 0],
+        ['1', 1],
+        ['kPH', 80085],
+        ['UC', 3510],
+        ['p', 25],
+        ['6zi', 25252],
+        ['1ly7vk', 1234567890],
+    ];
+
+    public function testDecode(): void {
+        foreach(self::TESTS as $test)
+            $this->assertEquals($test[1], Serialiser::base62()->deserialise($test[0]));
+    }
+
+    public function testEncode(): void {
+        foreach(self::TESTS as $test)
+            $this->assertEquals($test[0], (string)Serialiser::base62()->serialise($test[1]));
+    }
+}
diff --git a/tests/CSRFPTest.php b/tests/CSRFPTest.php
new file mode 100644
index 0000000..94ff606
--- /dev/null
+++ b/tests/CSRFPTest.php
@@ -0,0 +1,79 @@
+<?php
+// CSRFPTest.php
+// Created: 2021-06-11
+// Updated: 2022-02-03
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Security\CSRFP;
+use Index\Security\CSRFPIdentity;
+use Index\Security\CSRFPToken;
+
+/**
+ * @covers CSRFP
+ * @covers CSRFPIdentity
+ * @covers CSRFPToken
+ */
+final class CSRFPTest extends TestCase {
+    private const SECRET_1 = 'pli4v2MgGI1DHP66hIBGEXyt6iCahANp';
+    private const SECRET_2 = 'WRp3MEWpb2vbcNBsx50184PXCg7tfH4D';
+
+    public function testCSRFP(): void {
+        $csrfp1 = new CSRFP(self::SECRET_1);
+        $csrfp2 = new CSRFP(self::SECRET_2);
+
+        $this->assertEquals(bin2hex($csrfp1->createHash('test', 1234, 12)), '965582c3bd762c22c18f99a5733cf9922166dbd2');
+        $this->assertEquals(bin2hex($csrfp2->createHash('test', 1234, 12)), '539b4e89e7313b91c66d5d18cc6e9ff6826cc7a2');
+
+        $token1 = $csrfp1->createToken('identity');
+        $token2 = $csrfp2->createToken('identity');
+        $token3 = $csrfp1->createToken('other');
+        $token4 = $csrfp2->createToken('other');
+
+        $this->assertTrue($csrfp1->verifyToken('identity', $token1));
+        $this->assertTrue($csrfp2->verifyToken('identity', $token2));
+        $this->assertTrue($csrfp1->verifyToken('other', $token3));
+        $this->assertTrue($csrfp2->verifyToken('other', $token4));
+
+        $this->assertFalse($csrfp2->verifyToken('identity', $token1));
+        $this->assertFalse($csrfp1->verifyToken('identity', $token2));
+        $this->assertFalse($csrfp2->verifyToken('other', $token3));
+        $this->assertFalse($csrfp1->verifyToken('other', $token4));
+
+        $this->assertFalse($csrfp1->verifyToken('other', $token1));
+        $this->assertFalse($csrfp2->verifyToken('other', $token2));
+        $this->assertFalse($csrfp1->verifyToken('identity', $token3));
+        $this->assertFalse($csrfp2->verifyToken('identity', $token4));
+    }
+
+    public function testTokenDecode(): void {
+        $token1 = CSRFPToken::decode('zCM1AAgHjTdDYLEcRgg5g0NHVsu69PTKurg'); // valid
+        $token2 = CSRFPToken::decode('AyQ1AAgHirhWJJJnQIwYKhWaF6zfv5NkhQ0'); // valid
+        $token3 = CSRFPToken::decode('KJFfkd39rrkf9Gs9g90sg90g3fdskfdsk34'); // random characters
+        $token4 = CSRFPToken::decode('zCM1AAgHjTdDY'); // incomplete data
+        $token5 = CSRFPToken::decode('AyQ'); // incomplete data
+        $token6 = CSRFPToken::decode(''); // empty
+
+        $this->assertEquals(bin2hex($token1->getHash()), '8d374360b11c46083983434756cbbaf4f4cabab8');
+        $this->assertEquals(bin2hex($token2->getHash()), '8ab856249267408c182a159a17acdfbf9364850d');
+        $this->assertEquals(bin2hex($token3->getHash()), 'aeb91ff46b3d83dd2c83dd20ddf76c91f76c937e');
+        $this->assertEquals(bin2hex($token4->getHash()), '8d3743'); // data may be incomplete, but there's still something
+        $this->assertEquals($token5->getHash(), '');
+        $this->assertEquals($token6->getHash(), '');
+
+        $this->assertEquals($token1->getTimestamp(), 3482572);
+        $this->assertEquals($token2->getTimestamp(), 3482627);
+        $this->assertEquals($token3->getTimestamp(), 2438959400);
+        $this->assertEquals($token4->getTimestamp(), 3482572);
+        $this->assertEquals($token5->getTimestamp(), -1);
+        $this->assertEquals($token6->getTimestamp(), -1);
+
+        $this->assertEquals($token1->getTolerance(), 1800);
+        $this->assertEquals($token2->getTolerance(), 1800);
+        $this->assertEquals($token3->getTolerance(), 64989);
+        $this->assertEquals($token4->getTolerance(), 1800);
+        $this->assertEquals($token5->getTolerance(), 0);
+        $this->assertEquals($token6->getTolerance(), 0);
+    }
+}
diff --git a/tests/DateTimeTest.php b/tests/DateTimeTest.php
new file mode 100644
index 0000000..d0b04a3
--- /dev/null
+++ b/tests/DateTimeTest.php
@@ -0,0 +1,387 @@
+<?php
+// DateTimeTest.php
+// Created: 2021-06-14
+// Updated: 2022-02-27
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\DateTime;
+use Index\TimeSpan;
+use Index\TimeZoneInfo;
+
+/**
+ * @covers DateTime
+ * @covers TimeSpan
+ * @covers TimeZoneInfo
+ */
+final class DateTimeTest extends TestCase {
+    public function testAttributes(): void {
+        $index = new DateTime('2021-06-14T21:07:14.359324 CEST');
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 21);
+        $this->assertEquals($index->getMinute(), 7);
+        $this->assertEquals($index->getSecond(), 14);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+        $this->assertEquals($index->getDayOfWeek(), DateTime::MONDAY);
+        $this->assertEquals($index->getDayOfYear(), 165);
+        $this->assertEquals($index->getWeek(), 24);
+        $this->assertTrue($index->isDaylightSavingTime());
+        $this->assertFalse($index->isLeapYear());
+        $this->assertFalse($index->isUTC());
+
+        $indexDate = $index->getDate();
+        $this->assertEquals($indexDate->getYear(), 2021);
+        $this->assertEquals($indexDate->getMonth(), 6);
+        $this->assertEquals($indexDate->getDay(), 14);
+        $this->assertEquals($indexDate->getHour(), 0);
+        $this->assertEquals($indexDate->getMinute(), 0);
+        $this->assertEquals($indexDate->getSecond(), 0);
+        $this->assertEquals($indexDate->getMillisecond(), 0);
+        $this->assertEquals($indexDate->getMicrosecond(), 0);
+        $this->assertEquals($indexDate->getDayOfWeek(), DateTime::MONDAY);
+        $this->assertEquals($indexDate->getDayOfYear(), 165);
+        $this->assertEquals($indexDate->getWeek(), 24);
+
+        $indexTime = $index->getTimeOfDay();
+        $this->assertEquals($indexTime->getHours(), 21);
+        $this->assertEquals($indexTime->getMinutes(), 7);
+        $this->assertEquals($indexTime->getSeconds(), 14);
+        $this->assertEquals($indexTime->getMilliseconds(), 359);
+        $this->assertEquals($indexTime->getMicroseconds(), 359324);
+    }
+
+    public function testTimeZone(): void {
+        $index1 = DateTime::utcNow();
+        $index2 = DateTime::now(new TimeZoneInfo('Australia/Melbourne'));
+        $this->assertEquals($index1->getUnixTimeSeconds(), $index2->getUnixTimeSeconds());
+    }
+
+    public function testSetters(): void {
+        $index = new DateTime('2021-06-14T21:07:14.359324 CEST');
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 21);
+        $this->assertEquals($index->getMinute(), 7);
+        $this->assertEquals($index->getSecond(), 14);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+
+        $index = $index->setDate(2005, 3, 9);
+        $this->assertEquals($index->getYear(), 2005);
+        $this->assertEquals($index->getMonth(), 3);
+        $this->assertEquals($index->getDay(), 9);
+        $this->assertEquals($index->getHour(), 21);
+        $this->assertEquals($index->getMinute(), 7);
+        $this->assertEquals($index->getSecond(), 14);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+
+        $index = $index->setISODate(2011, 20, 5);
+        $this->assertEquals($index->getYear(), 2011);
+        $this->assertEquals($index->getMonth(), 5);
+        $this->assertEquals($index->getDay(), 20);
+        $this->assertEquals($index->getHour(), 21);
+        $this->assertEquals($index->getMinute(), 7);
+        $this->assertEquals($index->getSecond(), 14);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+
+        $index = $index->setTime(10, 46, 50, 987654);
+        $this->assertEquals($index->getYear(), 2011);
+        $this->assertEquals($index->getMonth(), 5);
+        $this->assertEquals($index->getDay(), 20);
+        $this->assertEquals($index->getHour(), 10);
+        $this->assertEquals($index->getMinute(), 46);
+        $this->assertEquals($index->getSecond(), 50);
+        $this->assertEquals($index->getMillisecond(), 987);
+        $this->assertEquals($index->getMicrosecond(), 987654);
+
+        $index = $index->setTimestamp(1623702634);
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 22);
+        $this->assertEquals($index->getMinute(), 30);
+        $this->assertEquals($index->getSecond(), 34);
+        $this->assertEquals($index->getMillisecond(), 0);
+        $this->assertEquals($index->getMicrosecond(), 0);
+        $this->assertFalse($index->isUTC());
+    }
+
+    public function testUnixTimestamp(): void {
+        $index = DateTime::fromUnixTimeSeconds(1623696039);
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 18);
+        $this->assertEquals($index->getMinute(), 40);
+        $this->assertEquals($index->getSecond(), 39);
+        $this->assertEquals($index->getMillisecond(), 0);
+        $this->assertEquals($index->getMicrosecond(), 0);
+        $this->assertEquals($index->getUnixTimeSeconds(), 1623696039);
+        $this->assertEquals($index->getUnixTimeMilliseconds(), 1623696039000);
+        $this->assertTrue($index->isUTC());
+
+        $index = DateTime::fromUnixTimeMilliseconds(1623696422656);
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 18);
+        $this->assertEquals($index->getMinute(), 47);
+        $this->assertEquals($index->getSecond(), 2);
+        $this->assertEquals($index->getMillisecond(), 656);
+        $this->assertEquals($index->getMicrosecond(), 656000);
+        $this->assertEquals($index->getUnixTimeSeconds(), 1623696422);
+        $this->assertEquals($index->getUnixTimeMilliseconds(), 1623696422656);
+        $this->assertTrue($index->isUTC());
+    }
+
+    // verify the results of this at some point
+    public function testAdding(): void {
+        $index = new DateTime('2021-06-14T21:07:14.359324Z');
+
+        // Confirm initial state
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 21);
+        $this->assertEquals($index->getMinute(), 7);
+        $this->assertEquals($index->getSecond(), 14);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+
+        // Add
+        $index = $index->add(TimeSpan::create(1, 0, 10, 0));
+        $this->assertEquals($index->getDay(), 15);
+        $this->assertEquals($index->getMinute(), 17);
+
+        // Add years
+        $index = $index->addYears(1);
+        $this->assertEquals($index->getYear(), 2022);
+        $this->assertEquals($index->getMonth(), 6);
+        $index  = $index->addYears(1.5);
+        $this->assertEquals($index->getYear(), 2023);
+        $this->assertEquals($index->getMonth(), 12);
+
+        // Add months
+        $index = $index->addMonths(1);
+        $this->assertEquals($index->getMonth(), 12);
+        $this->assertEquals($index->getDay(), 16);
+        $index = $index->addMonths(1.5);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 15);
+
+        // Add days
+        $index = $index->addDays(1);
+        $this->assertEquals($index->getDay(), 16);
+        $this->assertEquals($index->getHour(), 21);
+        $index = $index->addDays(1.5);
+        $this->assertEquals($index->getDay(), 18);
+        $this->assertEquals($index->getHour(), 9);
+
+        // Add hours
+        $index = $index->addHours(1);
+        $this->assertEquals($index->getHour(), 10);
+        $this->assertEquals($index->getMinute(), 17);
+        $index = $index->addHours(1.5);
+        $this->assertEquals($index->getHour(), 11);
+        $this->assertEquals($index->getMinute(), 47);
+
+        // Add minutes
+        $index = $index->addMinutes(1);
+        $this->assertEquals($index->getMinute(), 48);
+        $this->assertEquals($index->getSecond(), 14);
+        $index = $index->addMinutes(1.5);
+        $this->assertEquals($index->getMinute(), 49);
+        $this->assertEquals($index->getSecond(), 44);
+
+        // Add seconds
+        $index = $index->addSeconds(1);
+        $this->assertEquals($index->getSecond(), 45);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+        $index = $index->addSeconds(1.5);
+        $this->assertEquals($index->getSecond(), 46);
+        $this->assertEquals($index->getMillisecond(), 859);
+        $this->assertEquals($index->getMicrosecond(), 859324);
+
+        // Add milliseconds
+        $index = $index->addMilliseconds(1);
+        $this->assertEquals($index->getMillisecond(), 860);
+        $this->assertEquals($index->getMicrosecond(), 860324);
+        $index = $index->addMilliseconds(1.5);
+        $this->assertEquals($index->getMillisecond(), 861);
+        $this->assertEquals($index->getMicrosecond(), 861824);
+
+        // Add microseconds
+        $index = $index->addMicroseconds(1);
+        $this->assertEquals($index->getMicrosecond(), 861825);
+        $index = $index->addMicroseconds(1.5);
+        $this->assertEquals($index->getMicrosecond(), 861826);
+    }
+
+    public function testSubtract(): void {
+        $index = new DateTime('2021-06-14T21:07:14.359324Z');
+
+        // Confirm initial state
+        $this->assertEquals($index->getYear(), 2021);
+        $this->assertEquals($index->getMonth(), 6);
+        $this->assertEquals($index->getDay(), 14);
+        $this->assertEquals($index->getHour(), 21);
+        $this->assertEquals($index->getMinute(), 7);
+        $this->assertEquals($index->getSecond(), 14);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+
+        // Subtract
+        $index = $index->subtract(TimeSpan::fromDays(400.12));
+        $this->assertEquals($index->getYear(), 2020);
+        $this->assertEquals($index->getMonth(), 5);
+        $this->assertEquals($index->getDay(), 10);
+        $this->assertEquals($index->getHour(), 18);
+        $this->assertEquals($index->getMinute(), 14);
+        $this->assertEquals($index->getSecond(), 26);
+        $this->assertEquals($index->getMillisecond(), 359);
+        $this->assertEquals($index->getMicrosecond(), 359324);
+    }
+
+    public function testDifference(): void {
+        $index1 = new DateTime('2021-06-14T21:07:14Z');
+        $index2 = DateTime::create(2013, 1, 27, 23, 14, 44, 0, new TimeZoneInfo('Europe/Amsterdam'));
+        $diff = $index1->difference($index2);
+
+        $this->assertEquals($diff->getDays(), 3061);
+        $this->assertEquals($diff->getHours(), 22);
+        $this->assertEquals($diff->getMinutes(), 52);
+        $this->assertEquals($diff->getSeconds(), 30);
+        $this->assertTrue($diff->isNegative());
+
+        $this->assertEquals($diff->totalDays(), 3061.953125);
+        $this->assertEquals($diff->totalHours(), 73486.875);
+        $this->assertEquals($diff->totalMinutes(), 4409212.5);
+        $this->assertEquals($diff->totalSeconds(), 264552750);
+        $this->assertEquals($diff->totalMilliseconds(), 264552750000);
+        $this->assertEquals($diff->totalMicroseconds(), 264552750000000);
+
+        $negated = $diff->negate();
+        $this->assertEquals($negated->getDays(), 3061);
+        $this->assertEquals($negated->getHours(), 22);
+        $this->assertEquals($negated->getMinutes(), 52);
+        $this->assertEquals($negated->getSeconds(), 30);
+        $this->assertFalse($negated->isNegative());
+    }
+
+    public function testModify(): void {
+        $index = new DateTime('2021-06-14T21:07:14Z');
+        $this->assertEquals($index->getMonth(), 6);
+
+        $index = $index->modify('+1 month');
+        $this->assertEquals($index->getMonth(), 7);
+    }
+
+    public function testCreate(): void {
+        $index = DateTime::create(2013, 1, 27, 23, 14, 44, 0, new TimeZoneInfo('Europe/Amsterdam'));
+        $this->assertEquals($index->getYear(), 2013);
+        $this->assertEquals($index->getMonth(), 1);
+        $this->assertEquals($index->getDay(), 27);
+        $this->assertEquals($index->getHour(), 23);
+        $this->assertEquals($index->getMinute(), 14);
+        $this->assertEquals($index->getSecond(), 44);
+
+        $index = $index->setTimezone(new TimeZoneInfo('UTC'));
+        $this->assertEquals($index->getHour(), 22);
+
+        $index = $index->setTimezone(new TimeZoneInfo('Asia/Tokyo'));
+        $this->assertEquals($index->getDay(), 28);
+        $this->assertEquals($index->getHour(), 7);
+
+        $index = $index->setTimezone(new TimeZoneInfo('America/New_York'));
+        $this->assertEquals($index->getDay(), 27);
+        $this->assertEquals($index->getHour(), 17);
+
+        $index = DateTime::createFromFormat('Y-m-d H:i:s', '2012-05-20 10:14:28');
+        $this->assertEquals($index->format('Y-m-d H:i:s'), '2012-05-20 10:14:28');
+
+        $this->assertFalse(DateTime::createFromFormat('Y-m-d H:i:s', 'mewow'));
+
+        $mutable = new \DateTime('2021-06-14T20:20:46Z');
+
+        $index = DateTime::createFromInterface($mutable);
+        $this->assertEquals($index->getUnixTimeMilliseconds(), (float)$mutable->format('Uv'));
+        $this->assertEquals($index->getTimezone()->getName(), '+00:00');
+
+        $index = DateTime::createFromMutable($mutable);
+        $this->assertEquals($index->getUnixTimeMilliseconds(), (float)$mutable->format('Uv'));
+    }
+
+    public function testToString(): void {
+        $dateTime = DateTime::create(2013, 1, 27, 23, 14, 44, 0, new TimeZoneInfo('Europe/Amsterdam'));
+        $this->assertEquals((string)$dateTime, '2013-01-27T23:14:44+01:00');
+        $this->assertEquals(json_encode($dateTime), '"2013-01-27T23:14:44+01:00"');
+        $this->assertEquals((string)$dateTime->toISO8601String(), '2013-01-27T23:14:44+01:00');
+        $this->assertEquals((string)$dateTime->toCookieString(), 'Sunday, 27-Jan-2013 23:14:44 CET');
+        $this->assertEquals((string)$dateTime->toRFC822String(), 'Sun, 27 Jan 13 23:14:44 +0100');
+
+        $dateTime = $dateTime->setTimezone(TimeZoneInfo::utc());
+        $this->assertEquals((string)$dateTime, '2013-01-27T22:14:44+00:00');
+        $this->assertEquals(json_encode($dateTime), '"2013-01-27T22:14:44+00:00"');
+        $this->assertEquals((string)$dateTime->toISO8601String(), '2013-01-27T22:14:44+00:00');
+        $this->assertEquals((string)$dateTime->toCookieString(), 'Sunday, 27-Jan-2013 22:14:44 UTC');
+        $this->assertEquals((string)$dateTime->toRFC822String(), 'Sun, 27 Jan 13 22:14:44 +0000');
+    }
+
+    public function testCompare(): void {
+        $index1 = new DateTime('2021-06-14T21:07:14Z');
+        $index2 = DateTime::create(2013, 1, 27, 23, 14, 44, 0, new TimeZoneInfo('Europe/Amsterdam'));
+
+        $this->assertGreaterThan(0, $index1->compare($index2));
+        $this->assertLessThan(0, $index2->compare($index1));
+        $this->assertEquals(0, $index1->compare($index1));
+    }
+
+    public function testEquals(): void {
+        $index1 = new DateTime('2021-06-14T21:07:14Z');
+        $index2 = DateTime::create(2013, 1, 27, 23, 14, 44, 0, new TimeZoneInfo('Europe/Amsterdam'));
+
+        $this->assertFalse($index1->equals($index2));
+        $this->assertFalse($index2->equals($index1));
+        $this->assertTrue($index1->equals($index1));
+    }
+
+    public function testCasting(): void {
+        $nativeDT = new \DateTime;
+        $this->assertInstanceOf(DateTime::class, $nativeDTCast = DateTime::cast($nativeDT));
+        $this->assertNotSame($nativeDT, $nativeDTCast);
+
+        $indexDT = new DateTime;
+        $this->assertInstanceOf(DateTime::class, $indexDTCast = DateTime::cast($indexDT));
+        $this->assertSame($indexDT, $indexDTCast);
+    }
+
+    public function testTimeZoneOrder(): void {
+        $all = TimeZoneInfo::all(true);
+        $lastOffset = null;
+        $lastString = null;
+
+        foreach($all as $timeZone) {
+            $offset = $timeZone->getOffset();
+            $string = $timeZone->getName();
+
+            if($lastOffset !== null) {
+                $diff = $lastOffset <=> $offset;
+                $this->assertLessThanOrEqual(0, $diff);
+
+                if($diff === 0)
+                    $this->assertLessThanOrEqual(0, $lastString <=> $string);
+            }
+
+            $lastOffset = $offset;
+            $lastString = $string;
+        }
+    }
+}
diff --git a/tests/DbToolsTest.php b/tests/DbToolsTest.php
new file mode 100644
index 0000000..3a076c1
--- /dev/null
+++ b/tests/DbToolsTest.php
@@ -0,0 +1,128 @@
+<?php
+// DbToolsTest.php
+// Created: 2021-04-28
+// Updated: 2022-02-28
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Data\DbTools;
+use Index\Data\DbType;
+use Index\Data\MariaDB\MariaDBBackend;
+use Index\Data\NullDb\NullDbConnection;
+use Index\Data\SQLite\SQLiteBackend;
+use Index\IO\MemoryStream;
+use Index\Net\UnixEndPoint;
+
+/**
+ * @covers DbTools
+ */
+final class DbToolsTest extends TestCase {
+    public function testDetectType(): void {
+        $this->assertEquals(DbType::NULL, DbTools::detectType(null));
+        $this->assertEquals(DbType::INTEGER, DbTools::detectType(12345));
+        $this->assertEquals(DbType::FLOAT, DbTools::detectType(123.45));
+        $this->assertEquals(DbType::STRING, DbTools::detectType('This is a string.'));
+        $this->assertEquals(DbType::BLOB, DbTools::detectType(MemoryStream::fromString('This is a string inside a memory stream.')));
+    }
+
+    public function testDSN(): void {
+        $nullDbConn1 = DbTools::create('null:');
+        $this->assertInstanceOf(NullDbConnection::class, $nullDbConn1);
+
+        $nullDbConn2 = DbTools::create('Index-Data-NullDb-NullDbBackend:');
+        $this->assertInstanceOf(NullDbConnection::class, $nullDbConn2);
+
+        $maria = new MariaDBBackend;
+        $sqlite = new SQLiteBackend;
+
+        // flashii style misuzu connections details
+        $mci1 = $maria->parseDsn('mariadb://flashii:TiFGzCTxzx0n2HYzmNZpa98j255X7W4B@:unix:/flashii/misuzu?socket=/var/run/mysqld/mysqld.sock&charset=utf8mb4&init=SET SESSION time_zone = \'+00:00\', sql_mode = \'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION\'');
+
+        $this->assertTrue($mci1->isUnixSocket());
+        $this->assertEquals('/var/run/mysqld/mysqld.sock', (string)$mci1->getEndPoint());
+        $this->assertEquals('', $mci1->getHost());
+        $this->assertEquals(-1, $mci1->getPort());
+        $this->assertEquals('/var/run/mysqld/mysqld.sock', $mci1->getSocketPath());
+        $this->assertEquals('flashii', $mci1->getUserName());
+        $this->assertEquals('TiFGzCTxzx0n2HYzmNZpa98j255X7W4B', $mci1->getPassword());
+        $this->assertEquals('flashii_misuzu', $mci1->getDatabaseName());
+        $this->assertTrue($mci1->hasCharacterSet());
+        $this->assertEquals('utf8mb4', $mci1->getCharacterSet());
+        $this->assertTrue($mci1->hasInitCommand());
+        $this->assertEquals('SET SESSION time_zone = \'+00:00\', sql_mode = \'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION\'', $mci1->getInitCommand());
+        $this->assertFalse($mci1->isSecure());
+        $this->assertNull($mci1->getKeyPath());
+        $this->assertNull($mci1->getCertificatePath());
+        $this->assertNull($mci1->getCertificateAuthorityPath());
+        $this->assertNull($mci1->getTrustedCertificatesPath());
+        $this->assertNull($mci1->getCipherAlgorithms());
+        $this->assertFalse($mci1->shouldVerifyCertificate());
+        $this->assertFalse($mci1->shouldUseCompression());
+
+        // generic ipv4
+        $mci2 = $maria->parseDsn('mariadb://username:password@127.0.0.1/database');
+        $this->assertEquals('127.0.0.1', (string)$mci2->getEndPoint());
+        $this->assertEquals('127.0.0.1', $mci2->getHost());
+        $this->assertEquals(3306, $mci2->getPort());
+        $this->assertEquals('', $mci2->getSocketPath());
+        $this->assertEquals('username', $mci2->getUserName());
+        $this->assertEquals('password', $mci2->getPassword());
+        $this->assertEquals('database', $mci2->getDatabaseName());
+        $this->assertFalse($mci2->hasCharacterSet());
+        $this->assertNull($mci2->getCharacterSet());
+        $this->assertFalse($mci2->hasInitCommand());
+        $this->assertNull($mci2->getInitCommand());
+        $this->assertFalse($mci2->isSecure());
+        $this->assertNull($mci2->getKeyPath());
+        $this->assertNull($mci2->getCertificatePath());
+        $this->assertNull($mci2->getCertificateAuthorityPath());
+        $this->assertNull($mci2->getTrustedCertificatesPath());
+        $this->assertNull($mci2->getCipherAlgorithms());
+        $this->assertFalse($mci2->shouldVerifyCertificate());
+        $this->assertFalse($mci2->shouldUseCompression());
+
+        // generic ipv6 with port
+        $mci3 = $maria->parseDsn('mysql://username:password@[::1]:9001/database');
+        $this->assertEquals('[::1]:9001', (string)$mci3->getEndPoint());
+        $this->assertEquals('::1', $mci3->getHost());
+        $this->assertEquals(9001, $mci3->getPort());
+        $this->assertEquals('', $mci3->getSocketPath());
+        $this->assertEquals('username', $mci3->getUserName());
+        $this->assertEquals('password', $mci3->getPassword());
+        $this->assertEquals('database', $mci3->getDatabaseName());
+        $this->assertFalse($mci3->hasCharacterSet());
+        $this->assertNull($mci3->getCharacterSet());
+        $this->assertFalse($mci3->hasInitCommand());
+        $this->assertNull($mci3->getInitCommand());
+        $this->assertFalse($mci3->isSecure());
+        $this->assertNull($mci3->getKeyPath());
+        $this->assertNull($mci3->getCertificatePath());
+        $this->assertNull($mci3->getCertificateAuthorityPath());
+        $this->assertNull($mci3->getTrustedCertificatesPath());
+        $this->assertNull($mci3->getCipherAlgorithms());
+        $this->assertFalse($mci3->shouldVerifyCertificate());
+        $this->assertFalse($mci3->shouldUseCompression());
+
+        // sqlite normal
+        $sql1 = $sqlite->parseDsn('sqlite:/path/to/database.db?key=ebwOKzGkLYIxDGXk&readOnly=0&openOnly=1');
+        $this->assertEquals('/path/to/database.db', $sql1->getFileName());
+        $this->assertEquals('ebwOKzGkLYIxDGXk', $sql1->getEncryptionKey());
+        $this->assertFalse($sql1->shouldReadOnly());
+        $this->assertFalse($sql1->shouldCreate());
+
+        // sqlite temp file
+        $sql1 = $sqlite->parseDsn('sqlite:?key=Y63vrCttK8bEdPUIXVCOiLQKIgdbUn8V');
+        $this->assertEquals('', $sql1->getFileName());
+        $this->assertEquals('Y63vrCttK8bEdPUIXVCOiLQKIgdbUn8V', $sql1->getEncryptionKey());
+        $this->assertFalse($sql1->shouldReadOnly());
+        $this->assertTrue($sql1->shouldCreate());
+
+        // sqlite memory
+        $sql1 = $sqlite->parseDsn('sqlite::memory:');
+        $this->assertEquals(':memory:', $sql1->getFileName());
+        $this->assertEquals('', $sql1->getEncryptionKey());
+        $this->assertFalse($sql1->shouldReadOnly());
+        $this->assertTrue($sql1->shouldCreate());
+    }
+}
diff --git a/tests/EnvironmentTest.php b/tests/EnvironmentTest.php
new file mode 100644
index 0000000..77132ed
--- /dev/null
+++ b/tests/EnvironmentTest.php
@@ -0,0 +1,52 @@
+<?php
+// EnvironmentTest.php
+// Created: 2021-05-02
+// Updated: 2022-02-27
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\AString;
+use Index\Environment;
+use Index\Version;
+
+/**
+ * @covers Environment
+ */
+final class EnvironmentTest extends TestCase {
+    public function testEnvVars(): void {
+        $varName = 'NDX_TEST_VAR_DO_NOT_DEFINE';
+
+        $this->assertEmpty(Environment::getVariable($varName));
+
+        Environment::setVariable($varName, 'the');
+        $varValue = Environment::getVariable($varName);
+        $this->assertEquals('the', $varValue);
+
+        Environment::removeVariable($varName);
+        $this->assertEmpty(Environment::getVariable($varName));
+    }
+
+    public function testIndexVersion(): void {
+        $strVersion = trim(file_get_contents(__DIR__ . '/../VERSION'));
+        $rawVersion = explode('.', $strVersion);
+        $version = Environment::getIndexVersion();
+
+        $this->assertEquals(intval($rawVersion[0]), $version->getMajor());
+        $this->assertEquals(intval($rawVersion[1]), $version->getMinor());
+        $this->assertEquals(intval($rawVersion[2]), $version->getPatch());
+        $this->assertEquals($strVersion, (string)$version);
+    }
+
+    public function testPHPAndExtVersion(): void {
+        $version = Environment::getPHPVersion();
+        $extVersion = Environment::getPHPExtensionVersion('Core');
+
+        $this->assertEquals(PHP_MAJOR_VERSION, $version->getMajor());
+        $this->assertEquals(PHP_MINOR_VERSION, $version->getMinor());
+        $this->assertEquals(PHP_RELEASE_VERSION, $version->getPatch());
+        $this->assertTrue($version->equals($extVersion));
+    }
+
+    // not really sure how you would test the platform and sapi functions, so i won't
+}
diff --git a/tests/IPAddressRangeTest.php b/tests/IPAddressRangeTest.php
new file mode 100644
index 0000000..11a4ee5
--- /dev/null
+++ b/tests/IPAddressRangeTest.php
@@ -0,0 +1,61 @@
+<?php
+// IPAddressRangeTest.php
+// Created: 2021-04-27
+// Updated: 2022-02-03
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Net\IPAddress;
+use Index\Net\IPAddressRange;
+
+/**
+ * @covers IPAddressRange
+ */
+final class IPAddressRangeTest extends TestCase {
+    public function testParsing(): void {
+        $v4 = IPAddressRange::parse('127.0.0.1/23');
+        $v6 = IPAddressRange::parse('::1/128');
+
+        $this->expectException(InvalidArgumentException::class);
+        $v0 = IPAddressRange::parse('12.4:424::1/128');
+    }
+
+    public function testToString(): void {
+        $v4 = IPAddressRange::parse('53.64.123.86/18');
+        $this->assertEquals('53.64.123.86/18', (string)$v4);
+
+        $v6 = IPAddressRange::parse('abcd:1234::43:211a/86');
+        $this->assertEquals('abcd:1234::43:211a/86', (string)$v6);
+    }
+
+    public function testMatch(): void {
+        $v41 = IPAddress::parse('53.64.123.86');
+        $v42 = IPAddress::parse('53.64.130.86');
+        $v61 = IPAddress::parse('abcd:1234::43:211a');
+        $v62 = IPAddress::parse('bbce:1535::73:212a');
+
+        $r4 = IPAddressRange::parse('53.64.123.0/22');
+        $r6 = IPAddressRange::parse('abcd:1234::43:211a/86');
+
+        $this->assertTrue($r4->match($v41));
+        $this->assertFalse($r4->match($v42));
+
+        $this->assertTrue($r6->match($v61));
+        $this->assertFalse($r6->match($v62));
+    }
+
+    public function testSerializable(): void {
+        $cidrs = [
+            '53.64.123.0/22',
+            'abcd:1234::43:211a/86',
+        ];
+
+        foreach($cidrs as $cidr) {
+            $obj = IPAddressRange::parse($cidr);
+            $ser = serialize($obj);
+            $unser = unserialize($ser);
+            $this->assertTrue($obj->equals($unser));
+        }
+    }
+}
diff --git a/tests/IPAddressTest.php b/tests/IPAddressTest.php
new file mode 100644
index 0000000..d12aa72
--- /dev/null
+++ b/tests/IPAddressTest.php
@@ -0,0 +1,86 @@
+<?php
+// IPAddressTest.php
+// Created: 2021-04-26
+// Updated: 2022-02-03
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Net\IPAddress;
+
+/**
+ * @covers IPAddress
+ */
+final class IPAddressTest extends TestCase {
+    public function testParsing(): void {
+        $v4 = IPAddress::parse('127.0.0.1');
+        $this->assertEquals('127.0.0.1', $v4->getAddress());
+        $v6 = IPAddress::parse('::1');
+        $this->assertEquals('[::1]', $v6->getAddress());
+
+        $this->expectException(InvalidArgumentException::class);
+        $v0 = IPAddress::parse('12.4:424');
+    }
+
+    public function testVersion(): void {
+        $v4 = IPAddress::parse('123.53.65.34');
+        $this->assertEquals(4, $v4->getVersion());
+        $this->assertEquals(4, $v4->getWidth());
+        $this->assertTrue($v4->isV4());
+        $this->assertFalse($v4->isV6());
+
+        $v6 = IPAddress::parse('23cd::43c4:2342:acde');
+        $this->assertEquals(6, $v6->getVersion());
+        $this->assertEquals(16, $v6->getWidth());
+        $this->assertTrue($v6->isV6());
+        $this->assertFalse($v6->isV4());
+    }
+
+    public function testToString(): void {
+        $v4 = IPAddress::parse('53.64.123.86');
+        $this->assertEquals('53.64.123.86', (string)$v4);
+
+        $v6 = IPAddress::parse('abcd:1234::43:211a');
+        $this->assertEquals('abcd:1234::43:211a', (string)$v6);
+    }
+
+    public function testEquals(): void {
+        $v41 = IPAddress::parse('53.64.123.86');
+        $v42 = IPAddress::parse('123.53.65.34');
+        $v61 = IPAddress::parse('abcd:1234::43:211a');
+        $v62 = IPAddress::parse('23cd::43c4:2342:acde');
+
+        $this->assertTrue($v41->equals($v41));
+        $this->assertFalse($v42->equals($v41));
+        $this->assertFalse($v61->equals($v42));
+        $this->assertTrue($v62->equals($v62));
+    }
+
+    public function testJsonSerialize(): void {
+        $addrs = [
+            '53.64.123.86',
+            '123.53.65.34',
+            'abcd:1234::43:211a',
+            '23cd::43c4:2342:acde',
+        ];
+
+        foreach($addrs as $addr)
+            $this->assertEquals(json_encode($addr), json_encode(IPAddress::parse($addr)));
+    }
+
+    public function testSerializable(): void {
+        $addrs = [
+            '53.64.123.86',
+            '123.53.65.34',
+            'abcd:1234::43:211a',
+            '23cd::43c4:2342:acde',
+        ];
+
+        foreach($addrs as $addr) {
+            $obj = IPAddress::parse($addr);
+            $ser = serialize($obj);
+            $unser = unserialize($ser);
+            $this->assertTrue($obj->equals($unser));
+        }
+    }
+}
diff --git a/tests/RouterTest.php b/tests/RouterTest.php
new file mode 100644
index 0000000..dd1961f
--- /dev/null
+++ b/tests/RouterTest.php
@@ -0,0 +1,114 @@
+<?php
+// RouterTest.php
+// Created: 2022-01-20
+// Updated: 2022-02-05
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Routing\Router;
+
+/**
+ * @covers Router
+ */
+final class RouterTest extends TestCase {
+    public function testRouter(): void {
+        $router1 = new Router;
+
+        $router1->get('/', function() {
+            return 'get';
+        });
+        $router1->post('/', function() {
+            return 'post';
+        });
+        $router1->delete('/', function() {
+            return 'delete';
+        });
+        $router1->patch('/', function() {
+            return 'patch';
+        });
+        $router1->put('/', function() {
+            return 'put';
+        });
+        $router1->add('custom', '/', function() {
+            return 'wacky';
+        });
+
+        $this->assertEquals(['get'], $router1->resolve('GET', '/')->runAll());
+        $this->assertEquals(['wacky'], $router1->resolve('CUSTOM', '/')->runAll());
+
+        $router1->use('/', function() {
+            return 'warioware';
+        });
+        $router1->use('/deep', function() {
+            return 'deep';
+        });
+
+        $this->assertEquals(['warioware', 'post'], $router1->resolve('POST', '/')->runAll());
+
+        $router1->use('/user/:user/below', function(string $user) {
+            return 'warioware below ' . $user;
+        });
+
+        $router1->get('/user/static', function() {
+            return 'the static one';
+        });
+        $router1->get('/user/static/below', function() {
+            return 'below the static one';
+        });
+        $router1->get('/user/:user', function(string $user) {
+            return $user;
+        });
+        $router1->get('/user/:user/below', function(string $user) {
+            return 'below ' . $user;
+        });
+
+        $this->assertEquals(
+            ['warioware', 'below the static one'],
+            $router1->resolve('GET', '/user/static/below')->runAll()
+        );
+        $this->assertEquals(
+            ['warioware', 'warioware below flashwave', 'below flashwave'],
+            $router1->resolve('GET', '/user/flashwave/below')->runAll()
+        );
+
+        $router2 = new Router;
+        $router2->use('/', function() {
+            return 'meow';
+        });
+        $router2->get('/rules', function() {
+            return 'rules page';
+        });
+        $router2->get('/contact', function() {
+            return 'contact page';
+        });
+        $router2->get('/25252', function() {
+            return 'numeric test';
+        });
+
+        $this->assertEquals(['meow', 'rules page'], $router2->resolve('GET', '/rules')->runAll());
+
+        $router1->merge('/info', $router2);
+
+        $this->assertEquals(['warioware', 'meow', 'rules page'], $router1->resolve('GET', '/info/rules')->runAll());
+
+        $this->assertEquals(['meow', 'numeric test'], $router2->resolve('GET', '/25252')->runAll());
+
+        $router3 = new Router;
+        $router3->get('/static', function() {
+            return 'wrong';
+        });
+        $router3->get('/static/0', function() {
+            return 'correct';
+        });
+        $router3->get('/variable', function() {
+            return 'wrong';
+        });
+        $router3->get('/variable/:num', function(string $num) {
+            return $num === '0' ? 'correct' : 'VERY wrong';
+        });
+
+        $this->assertEquals('correct', $router3->resolve('GET', '/static/0')->run());
+        $this->assertEquals('correct', $router3->resolve('GET', '/variable/0')->run());
+    }
+}
diff --git a/tests/StringTest.php b/tests/StringTest.php
new file mode 100644
index 0000000..187b152
--- /dev/null
+++ b/tests/StringTest.php
@@ -0,0 +1,281 @@
+<?php
+// StringTest.php
+// Created: 2021-04-26
+// Updated: 2022-02-27
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\XArray;
+use Index\AString;
+use Index\WString;
+use Index\XString;
+
+/**
+ * @covers AString
+ * @covers WString
+ * @covers XString
+ */
+final class StringTest extends TestCase {
+    public function testLength(): void {
+        $ascii = new AString('soup');
+        $this->assertEquals(4, $ascii->getLength());
+        $this->assertEquals(4, count($ascii));
+        $this->assertFalse($ascii->isEmpty());
+
+        $utf8 = new WString('ßóúþ', 'utf-8');
+        $this->assertEquals(4, $utf8->getLength());
+        $this->assertEquals(4, count($utf8));
+        $this->assertEquals(8, $utf8->getByteCount());
+        $this->assertFalse($utf8->isEmpty());
+
+        $utf16be = new WString("\x00\xDF\x00\xF3\x00\xFA\x00\xFE", 'UTF-16BE');
+        $this->assertEquals(4, $utf16be->getLength());
+        $this->assertEquals(4, count($utf16be));
+        $this->assertEquals(8, $utf16be->getByteCount());
+        $this->assertFalse($utf16be->isEmpty());
+
+        $utf32le = new WString("\xDF\x00\x00\x00\xF3\x00\x00\x00\xFA\x00\x00\x00\xFE\x00\x00\x00", 'UTF-32LE');
+        $this->assertEquals(4, $utf32le->getLength());
+        $this->assertEquals(4, count($utf32le));
+        $this->assertEquals(16, $utf32le->getByteCount());
+        $this->assertFalse($utf32le->isEmpty());
+
+        $this->assertTrue($utf8->equals($utf16be));
+        $this->assertTrue($utf16be->equals($utf32le));
+        $this->assertTrue($utf32le->equals($utf8));
+    }
+
+    public function testToString(): void {
+        $ascii = new AString('Windows XP');
+        $this->assertEquals('Windows XP', (string)$ascii);
+
+        $utf16be = new WString("\x00\xDF\x00\xF3\x00\xFA\x00\xFE", 'UTF-16BE');
+        $this->assertEquals("\x00\xDF\x00\xF3\x00\xFA\x00\xFE", (string)$utf16be);
+
+        $utf32le = $utf16be->convertEncoding('utf-32le');
+        $this->assertEquals("\xDF\x00\x00\x00\xF3\x00\x00\x00\xFA\x00\x00\x00\xFE\x00\x00\x00", (string)$utf32le);
+    }
+
+    public function testArrayAccess(): void {
+        $ascii = new AString('Akai Haato');
+
+        $this->assertEquals('a', $ascii[2]);
+        $this->assertEquals('H', $ascii[5]);
+
+        $this->assertTrue(isset($ascii[6]));
+        $this->assertFalse(isset($ascii[23]));
+
+        $this->expectException(\BadMethodCallException::class);
+        $ascii[4] = '_';
+
+        $this->expectException(\BadMethodCallException::class);
+        unset($ascii[7]);
+
+        $utf16le = $ascii->toWString('utf-16le');
+
+        $this->assertEquals('a', $utf16le[2]);
+        $this->assertEquals('H', $utf16le[5]);
+
+        $this->assertTrue(isset($utf16le[6]));
+        $this->assertFalse(isset($utf16le[23]));
+
+        $this->expectException(\BadMethodCallException::class);
+        $utf16le[4] = '_';
+
+        $this->expectException(\BadMethodCallException::class);
+        unset($utf16le[7]);
+    }
+
+    public function testJsonSerialize(): void {
+        $ascii = new AString('Mewow');
+        $this->assertEquals('Mewow', json_decode(json_encode($ascii)));
+        $this->assertEquals('Mewow', json_decode(json_encode($ascii->toWString('Shift_JIS'))));
+    }
+
+    public function testSerializable(): void {
+        $ascii = new AString('Futami Mami');
+        $asciiSerialised = serialize($ascii);
+
+        $sjis = new WString("\x91\x6F\x8A\x43\x90\x5E\x94\xFC", 'Shift_JIS');
+        $sjisSerialised = serialize($sjis);
+
+        $asciiUnserialised = unserialize($asciiSerialised);
+        $this->assertTrue($ascii->equals($asciiUnserialised));
+        $this->assertTrue($asciiUnserialised->equals('Futami Mami'));
+
+        $sjisUnserialised = unserialize($sjisSerialised);
+        $this->assertTrue($sjis->equals($sjisUnserialised));
+        $this->assertTrue($sjisUnserialised->equals(new WString('双海真美', 'utf-8')));
+    }
+
+    public function testEquals(): void {
+        $ascii = new AString('Misaka Mikoto');
+        $this->assertTrue($ascii->equals($ascii));
+        $this->assertTrue($ascii->equals('Misaka Mikoto'));
+        $this->assertTrue($ascii->equals(new AString('Misaka Mikoto')));
+        $this->assertFalse($ascii->equals('Mewow'));
+        $this->assertFalse($ascii->equals(new AString('Ndx Mewow')));
+    }
+
+    public function testConcat(): void {
+        $ndxString1 = new AString('Akai ');
+        $ndxString2 = $ndxString1->append('Haato');
+        $ndxString3 = $ndxString1->append(new AString('Haato'));
+        $ndxString4 = (new AString('Haato'))->prepend($ndxString1);
+
+        $this->assertEquals('Akai Haato', (string)$ndxString2);
+        $this->assertEquals('Akai Haato', (string)$ndxString3);
+        $this->assertEquals('Akai Haato', (string)$ndxString4);
+    }
+
+    public function testSplit(): void {
+        $ascii = new AString('Kasane Teto');
+        $asciiArr = ['Kasane', 'Teto'];
+        $this->assertTrue(XArray::sequenceEquals($asciiArr, $ascii->split(' ')));
+
+        $utf16le = new WString("\x42\x30\x02\x30\x44\x30\x02\x30\x46\x30\x02\x30\x48\x30\x02\x30\x4A\x30\x02\x30", 'utf-16le');
+        $utf16leArr = [
+            new WString("\x42\x30", 'utf-16le'),
+            new WString("\x44\x30", 'utf-16le'),
+            new WString("\x46\x30", 'utf-16le'),
+            new WString("\x48\x30", 'utf-16le'),
+            new WString("\x4A\x30", 'utf-16le'),
+            new WString("", 'utf-16le'),
+        ];
+        $this->assertTrue(XArray::sequenceEquals($utf16leArr, $utf16le->split(new WString("\x02\x30", 'utf-16le'))));
+
+        $utf8 = new WString('あ。い。う。え。お。', 'utf-8');
+        $utf8Arr = [
+            new Wstring('あ', 'utf-8'),
+            new Wstring('い', 'utf-8'),
+            new Wstring('う', 'utf-8'),
+            new Wstring('え', 'utf-8'),
+            new Wstring('お', 'utf-8'),
+            new Wstring('', 'utf-8'),
+        ];
+        $this->assertTrue(XArray::sequenceEquals($utf8Arr, $utf8->split(new WString('。', 'utf-8'))));
+    }
+
+    public function testChunk(): void {
+        $ndxString = new AString('abcdefghijklmnopqrstuvwxyz');
+        $ndxArray1 = ['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr', 'stu', 'vwx', 'yz'];
+        $ndxArray2 = ['ab', 'cd', 'ef', 'gh', 'ij', 'kl', 'mn', 'op', 'qr', 'st', 'uv', 'wx', 'yz'];
+        $ndxArray3 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
+
+        $this->assertTrue(XArray::sequenceEquals($ndxString->chunk(3), $ndxArray1));
+        $this->assertTrue(XArray::sequenceEquals($ndxString->chunk(2), $ndxArray2));
+        $this->assertTrue(XArray::sequenceEquals($ndxString->chunk(1), $ndxArray3));
+
+        $utf8 = new WString('君は実にばかだな', 'utf-8');
+        $ndxArray4 = [
+            new WString('君は実', 'utf-8'),
+            new WString('にばか', 'utf-8'),
+            new WString('だな', 'utf-8'),
+        ];
+        $ndxArray5 = [
+            new WString('君は', 'utf-8'),
+            new WString('実に', 'utf-8'),
+            new WString('ばか', 'utf-8'),
+            new WString('だな', 'utf-8'),
+        ];
+        $ndxArray6 = [
+            new WString('君', 'utf-8'),
+            new WString('は', 'utf-8'),
+            new WString('実', 'utf-8'),
+            new WString('に', 'utf-8'),
+            new WString('ば', 'utf-8'),
+            new WString('か', 'utf-8'),
+            new WString('だ', 'utf-8'),
+            new WString('な', 'utf-8'),
+        ];
+
+        $this->assertTrue(XArray::sequenceEquals($utf8->chunk(3), $ndxArray4));
+        $this->assertTrue(XArray::sequenceEquals($utf8->chunk(2), $ndxArray5));
+        $this->assertTrue(XArray::sequenceEquals($utf8->chunk(1), $ndxArray6));
+    }
+
+    public function testTrim(): void {
+        $ascii = new AString('    meow     ');
+        $this->assertTrue($ascii->trim()->equals('meow'));
+        $this->assertTrue($ascii->trimStart()->equals('meow     '));
+        $this->assertTrue($ascii->trimEnd()->equals('    meow'));
+
+        $utf16be = $ascii->toWString('utf-16be');
+        $this->assertTrue($utf16be->trim()->equals('meow'));
+        $this->assertTrue($utf16be->trimStart()->equals('meow     '));
+        $this->assertTrue($utf16be->trimEnd()->equals('    meow'));
+
+        $utf8 = new WString('    にゃ     ', 'utf-8');
+        $this->assertTrue($utf8->trim()->equals(new WString('にゃ', 'utf-8')));
+        $this->assertTrue($utf8->trimStart()->equals(new WString('にゃ     ', 'utf-8')));
+        $this->assertTrue($utf8->trimEnd()->equals(new WString('    にゃ', 'utf-8')));
+    }
+
+    public function testCaseChange(): void {
+        $stringMixed = new AString('Sometimes');
+        $stringUpper = new AString('SOMETIMES');
+        $stringLower = new AString('sometimes');
+
+        $this->assertTrue($stringMixed->toUpper()->equals($stringUpper));
+        $this->assertTrue($stringMixed->toLower()->equals($stringLower));
+    }
+
+    public function testEscape(): void {
+        $stringDirty = new AString('<img onerror="alert(\'xss\')">');
+        $stringClean = new AString('&lt;img onerror=&quot;alert(\'xss\')&quot;&gt;');
+
+        $this->assertTrue($stringDirty->escape()->equals($stringClean));
+    }
+
+    public function testJoin(): void {
+        $ndxString1 = AString::join(['flash', 'wave']);
+        $ndxString2 = AString::join(['Misaka', 'Mikoto'], new AString(' '));
+
+        $this->assertEquals('flashwave', (string)$ndxString1);
+        $this->assertEquals('Misaka Mikoto', (string)$ndxString2);
+    }
+
+    public function testEmpty(): void {
+        $this->assertTrue(XString::nullOrEmpty(null));
+        $this->assertTrue(XString::nullOrEmpty(''));
+        $this->assertTrue(XString::nullOrEmpty(new AString('')));
+        $this->assertFalse(XString::nullOrEmpty('soap'));
+        $this->assertFalse(XString::nullOrEmpty(new AString('boat')));
+        $this->assertTrue(XString::nullOrWhitespace(''));
+        $this->assertTrue(XString::nullOrWhitespace('  '));
+        $this->assertTrue(XString::nullOrWhitespace(new AString('   ')));
+    }
+
+    public function testReverse(): void {
+        $ascii = new AString('Futami Mami');
+        $sjis = new WString("\x91\x6F\x8A\x43\x90\x5E\x94\xFC", 'Shift_JIS');
+
+        $asciiRev = $ascii->reverse();
+        $sjisRev = $sjis->reverse();
+
+        $this->assertEquals('imaM imatuF', (string)$asciiRev);
+        $this->assertEquals("\x94\xFC\x90\x5E\x8A\x43\x91\x6F", (string)$sjisRev);
+    }
+
+    public function testReplace(): void {
+        $ascii = new AString('aiueo');
+        $sjis = new WString("\x82\xA0\x82\xA2\x82\xA4\x82\xA6\x82\xA8", 'sjis');
+
+        $this->assertEquals('aikeo', $ascii->replace('u', 'k'));
+        $this->assertEquals('aeoeo', $ascii->replace('iu', 'eo'));
+
+        $this->assertTrue(
+            $sjis->replace(
+                new WString("\x46\x30", 'utf-16le'),
+                new WString("\xE3\x81\x8B", 'utf-8')
+            )->equals(new WString("\x82\xA0\x82\xA2\x82\xA9\x82\xA6\x82\xA8", 'sjis'))
+        );
+        $this->assertTrue(
+            $sjis->replace(
+                new WString("\xE3\x81\x84\xE3\x81\x86", 'utf-8'),
+                new WString("\x48\x30\x4A\x30", 'utf-16le')
+            )->equals(new WString("\x82\xA0\x82\xA6\x82\xA8\x82\xA6\x82\xA8", 'sjis'))
+        );
+    }
+}
diff --git a/tests/TypeTest.php b/tests/TypeTest.php
new file mode 100644
index 0000000..7a4453c
--- /dev/null
+++ b/tests/TypeTest.php
@@ -0,0 +1,49 @@
+<?php
+// TypeTest.php
+// Created: 2021-04-27
+// Updated: 2022-02-28
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\AString;
+use Index\Type;
+use Index\XArray;
+
+/**
+ * @covers Type
+ */
+final class TypeTest extends TestCase {
+    public function testDefaults(): void {
+        $this->assertEquals(Type::default(Type::BOOL), false);
+        $this->assertEquals(Type::default(Type::INTEGER), 0);
+        $this->assertEquals(Type::default(Type::FLOAT), 0.0);
+        $this->assertEquals(Type::default(Type::STRING), '');
+        $this->assertEquals(Type::default(Type::ARRAY), []);
+        $this->assertEquals(Type::default(Type::OBJECT), null);
+        $this->assertEquals(Type::default(Type::RESOURCE), null);
+        $this->assertEquals(Type::default(Type::CLOSED_RESOURCE), null);
+        $this->assertEquals(Type::default(Type::NULL), null);
+        $this->assertEquals(Type::default(Type::UNKNOWN), null);
+    }
+
+    public function testClassTree(): void {
+        $array1 = Type::classTree(new AString('the'));
+        $array2 = [
+            'Index\\IString',
+            'Stringable',
+            'Traversable',
+            'Index\\Serialisation\\IBencodeSerialisable',
+            'Index\\IEquatable',
+            'Index\\ICloneable',
+            'Index\\IComparable',
+            'JsonSerializable',
+            'IteratorAggregate',
+            'Countable',
+            'ArrayAccess',
+            'Index\\AString',
+        ];
+
+        $this->assertTrue(XArray::sequenceEquals($array1, $array2));
+    }
+}
diff --git a/tests/VersionTest.php b/tests/VersionTest.php
new file mode 100644
index 0000000..f05d8c9
--- /dev/null
+++ b/tests/VersionTest.php
@@ -0,0 +1,77 @@
+<?php
+// VersionTest.php
+// Created: 2021-04-30
+// Updated: 2022-02-03
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\Version;
+use Index\XArray;
+
+/**
+ * @covers Version
+ */
+final class VersionTest extends TestCase {
+    public function testParse(): void {
+        $tests = [
+            '1.0.0',
+            'v2.4.2',
+            '1.0.0-alpha',
+            '1.0.0-alpha.1',
+            '1.0.0-0.3.7',
+            '1.0.0-0.3.7',
+            'v1.0.0-alpha+001',
+            '1.0.0-beta+exp.sha.5114f85',
+            'v1.0.0+21AF26D3--117B344092BD',
+        ];
+
+        foreach($tests as $test) {
+            $version = Version::parse($test);
+            $this->assertEquals($test, (string)$test);
+        }
+
+        $build = Version::parse('v1.0.0+21AF26D3--117B344092BD');
+        $pre = Version::parse('1.0.0-alpha');
+        $both = Version::parse('1.0.0-beta+exp.sha.5114f85');
+
+        $this->assertFalse($build->isPrerelease());
+        $this->assertTrue($pre->isPrerelease());
+        $this->assertTrue($both->isPrerelease());
+
+        $this->assertTrue(XArray::sequenceEquals($build->getBuild(), ['21AF26D3--117B344092BD']));
+        $this->assertTrue(XArray::sequenceEquals($pre->getPrerelease(), ['alpha']));
+        $this->assertTrue(XArray::sequenceEquals($both->getPrerelease(), ['beta']));
+        $this->assertTrue(XArray::sequenceEquals($both->getBuild(), ['exp', 'sha', '5114f85']));
+    }
+
+    public function testCompare(): void {
+        $v1_0_0_alpha = Version::parse('v1.0.0-alpha');
+        $v1_0_0 = Version::parse('1.0.0');
+        $v1_0_0_build = Version::parse('1.0.0+build');
+        $v2_0_0 = Version::parse('v2.0.0');
+        $v2_1_0 = new Version(2, 1);
+        $v2_1_1 = new Version(2, 1, 1);
+
+        $this->assertEquals(0, $v1_0_0->compare($v1_0_0_build));
+        $this->assertEquals(-1, $v2_0_0->compare($v2_1_0));
+        $this->assertEquals(-1, $v2_0_0->compare($v2_1_0));
+        $this->assertEquals(-1, $v1_0_0->compare($v2_0_0));
+        $this->assertEquals(-1, $v1_0_0_alpha->compare($v1_0_0));
+    }
+
+    public function testEquals(): void {
+        $v1_0_0_alpha = Version::parse('v1.0.0-alpha');
+        $v1_0_0 = Version::parse('1.0.0');
+        $v1_0_0_build = Version::parse('1.0.0+build');
+        $v2_0_0 = Version::parse('v2.0.0');
+        $v2_1_0 = new Version(2, 1);
+        $v2_1_1 = new Version(2, 1, 1);
+
+        $this->assertTrue($v1_0_0->equals($v1_0_0_build));
+        $this->assertFalse($v2_0_0->equals($v2_1_0));
+        $this->assertFalse($v2_0_0->equals($v2_1_0));
+        $this->assertFalse($v1_0_0->equals($v2_0_0));
+        $this->assertFalse($v1_0_0_alpha->equals($v1_0_0));
+    }
+}
diff --git a/tests/XArrayTest.php b/tests/XArrayTest.php
new file mode 100644
index 0000000..bb83882
--- /dev/null
+++ b/tests/XArrayTest.php
@@ -0,0 +1,147 @@
+<?php
+// XArrayTest.php
+// Created: 2021-04-26
+// Updated: 2022-02-03
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Index\AString;
+use Index\XArray;
+
+/**
+ * @covers XArray
+ */
+final class XArrayTest extends TestCase {
+    public function testCountEmpty(): void {
+        $array = [];
+        $this->assertEquals(0, XArray::count($array));
+        $this->assertTrue(XArray::empty($array));
+
+        $array[] = 'the';
+        $array[] = 'the';
+        $array[] = 'the';
+        $array[] = 'the';
+
+        $this->assertEquals(4, XArray::count($array));
+        $this->assertFalse(XArray::empty($array));
+    }
+
+    public function testExtractIterator(): void {
+        $array1 = [1, 2, 3, 4, 5];
+        $array2 = ['a', 'b', 'c', 'd', 'e'];
+        $array3 = [1 => 'a', 2 => 'b', 3 => 'c', 4 => 'd', 5 => 'e'];
+        $array4 = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5];
+
+        foreach(XArray::extractIterator($array1) as $key => $value)
+            $this->assertEquals($value, $array1[$key]);
+        foreach(XArray::extractIterator($array2) as $key => $value)
+            $this->assertEquals($value, $array2[$key]);
+        foreach(XArray::extractIterator($array3) as $key => $value)
+            $this->assertEquals($value, $array3[$key]);
+        foreach(XArray::extractIterator($array4) as $key => $value)
+            $this->assertEquals($value, $array4[$key]);
+    }
+
+    public function testEquals(): void {
+        $array1 = [1, 2, 3, 4, 5];
+        $array2 = ['a', 'b', 'c', 'd', 'e'];
+        $array3 = [1, 2, 3, 4, 5];
+
+        $this->assertTrue(XArray::sequenceEquals($array1, $array3));
+        $this->assertFalse(XArray::sequenceEquals($array2, $array3));
+    }
+
+    public function testContains(): void {
+        $array = ['test' => 'meow'];
+
+        $this->assertTrue(XArray::contains($array, 'meow'));
+        $this->assertTrue(XArray::containsKey($array, 'test'));
+        $this->assertFalse(XArray::containsKey($array, 'meow'));
+        $this->assertFalse(XArray::contains($array, 'test'));
+    }
+
+    public function testFirstLastKey(): void {
+        $array = ['test' => 'meow', 'windows' => 'xp', 'mewow' => 'vista'];
+
+        $this->assertEquals('test', XArray::firstKey($array));
+        $this->assertEquals('mewow', XArray::lastKey($array));
+    }
+
+    public function testReverse(): void {
+        $array1 = [1, 2, 3, 4, 5];
+        $array2 = XArray::reverse([5, 4, 3, 2, 1]);
+
+        $this->assertTrue(XArray::sequenceEquals($array1, $array2));
+    }
+
+    public function testConcat(): void {
+        $ndxString1 = new AString('abcde');
+        $ndxString2 = new AString('a_b_c_d_e');
+        $array = ['a', 'b', 'c', 'd', 'e'];
+
+        $this->assertTrue(AString::join($array)->equals($ndxString1));
+        $this->assertFalse(AString::join($array)->equals($ndxString2));
+        $this->assertFalse(AString::join($array, '_')->equals($ndxString1));
+        $this->assertTrue(AString::join($array, '_')->equals($ndxString2));
+    }
+
+    public function testMerge(): void {
+        $array1 = [0, 1, 2, 3, 4, 5, 6, 7];
+        $array2 = [0, 1, 2, 3];
+        $array3 = [4, 5, 6, 7];
+        $array4 = XArray::merge($array2, $array3);
+
+        $this->assertTrue(XArray::sequenceEquals($array1, $array4));
+        $this->assertTrue(XArray::sequenceEquals($array4, $array1));
+        $this->assertFalse(XArray::sequenceEquals($array2, $array1));
+        $this->assertFalse(XArray::sequenceEquals($array3, $array4));
+    }
+
+    public function testIndexOf(): void {
+        $array = ['a', 'd', 'b', 'c', 'd',  'c', 'e', 'poop' => 'meow'];
+
+        $this->assertEquals(3, XArray::indexOf($array, 'c'));
+        $this->assertEquals(1, XArray::indexOf($array, 'd'));
+        $this->assertEquals('poop', XArray::indexOf($array, 'meow'));
+        $this->assertFalse(XArray::indexOf($array, 'z'));
+    }
+
+    public function testUniqueAndReflow(): void {
+        $array1 = ['a', 'd', 'b', 'c', 'd',  'c', 'e'];
+        $array2 = ['a', 'd', 'b', 'c', 'e'];
+
+        $this->assertFalse(XArray::sequenceEquals($array2, $array1));
+
+        // keys should differ
+        $this->assertFalse(XArray::sequenceEquals($array2, XArray::unique($array1)));
+        $this->assertTrue(XArray::sequenceEquals($array2, XArray::reflow(XArray::unique($array1))));
+    }
+
+    public function testWhere(): void {
+        $array1 = ['Windows', 'Flashwave', 'Misaka Mikoto', 'Misuzu', 'Index', 'Kasane Teto', 'Some garbage'];
+        $array2 = ['Misaka Mikoto', 'Kasane Teto', 'Some garbage'];
+
+        $this->assertTrue(XArray::sequenceEquals(XArray::where($array1, fn($value) => strpos($value, ' ') !== false), $array2));
+    }
+
+    public function testFirst(): void {
+        $array = ['Windows', 'Flashwave', 'Misaka Mikoto', 'Misuzu', 'Index', 'Kasane Teto', 'Some garbage'];
+
+        $this->assertEquals(XArray::first($array, fn($value) => strpos($value, 't') !== false), 'Misaka Mikoto');
+    }
+
+    public function testSelect(): void {
+        $array1 = ['Windows', 'Flashwave', 'Misaka Mikoto', 'Misuzu', 'Index', 'Kasane Teto', 'Some garbage'];
+        $array2 = ['WINDOWS', 'FLASHWAVE', 'MISAKA MIKOTO', 'MISUZU', 'INDEX', 'KASANE TETO', 'SOME GARBAGE'];
+
+        $this->assertTrue(XArray::sequenceEquals(XArray::select($array1, fn(string $input) => strtoupper($input)), $array2));
+    }
+
+    public function testSlice(): void {
+        $array1 = ['Windows', 'Flashwave', 'Misaka Mikoto', 'Misuzu', 'Index', 'Kasane Teto', 'Some garbage'];
+        $array2 = ['Misaka Mikoto', 'Misuzu', 'Index', 'Kasane Teto'];
+
+        $this->assertTrue(XArray::sequenceEquals(XArray::slice($array1, 2, 4), $array2));
+    }
+}
diff --git a/tools/fatphpstan.bat b/tools/fatphpstan.bat
new file mode 100644
index 0000000..8a990b5
--- /dev/null
+++ b/tools/fatphpstan.bat
@@ -0,0 +1,3 @@
+@echo off
+
+phpstan --memory-limit=2G
diff --git a/tools/precommit.bat b/tools/precommit.bat
new file mode 100644
index 0000000..f1c0693
--- /dev/null
+++ b/tools/precommit.bat
@@ -0,0 +1,9 @@
+@echo off
+
+pushd .
+cd %~dp0
+
+php update-headers.php
+php update-version.php
+
+popd
diff --git a/tools/precommit.sh b/tools/precommit.sh
new file mode 100644
index 0000000..fc1e59e
--- /dev/null
+++ b/tools/precommit.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+pushd .
+cd $(dirname "$0")
+
+php update-headers.php
+php update-version.php
+
+popd
diff --git a/tools/update-headers.php b/tools/update-headers.php
new file mode 100644
index 0000000..dec1d28
--- /dev/null
+++ b/tools/update-headers.php
@@ -0,0 +1,173 @@
+<?php
+// this file sucks, screw up the header if incomplete
+// successfully corrects filenames though
+// fix this if you ever feel like it, or don't
+
+date_default_timezone_set('utc');
+
+function git_changes(): array {
+    $files = [];
+
+    $dir = getcwd();
+    try {
+        chdir(__DIR__ . '/..');
+
+        $output = explode("\n", trim(shell_exec('git status --short --porcelain=v1 --untracked-files=all --no-column')));
+
+        foreach($output as $line) {
+            $line = trim($line);
+            $file = realpath(explode(' ', $line)[1]);
+            $files[] = $file;
+        }
+
+    } finally {
+        chdir($dir);
+    }
+
+    return $files;
+}
+
+function collect_files(string $directory): array {
+    $files = [];
+    $dir = glob(realpath($directory) . DIRECTORY_SEPARATOR . '*');
+
+    foreach($dir as $file) {
+        if(is_dir($file)) {
+            $files = array_merge($files, collect_files($file));
+            continue;
+        }
+
+        $files[] = $file;
+    }
+
+    return $files;
+}
+
+echo 'Indexing changed files according to git...' . PHP_EOL;
+
+$changed = git_changes();
+
+echo 'Collecting files...' . PHP_EOL;
+
+$sources = collect_files(__DIR__ . '/../src');
+$tests = collect_files(__DIR__ . '/../tests');
+
+$files = array_merge($sources, $tests);
+
+$topDir = dirname(__DIR__) . DIRECTORY_SEPARATOR;
+
+$now = date('Y-m-d');
+
+foreach($files as $file) {
+    echo 'Scanning ' . str_replace($topDir, '', $file) . '...' . PHP_EOL;
+
+    try {
+        $handle = fopen($file, 'rb');
+
+        $checkPHP = trim(fgets($handle)) === '<?php';
+        if(!$checkPHP) {
+            echo 'File is not PHP.' . PHP_EOL;
+            continue;
+        }
+
+        $headerLines = [];
+
+        $expectLine = '// ' . basename($file);
+        $nameLine = trim(fgets($handle));
+        if($nameLine !== $expectLine) {
+            echo '  File name is missing or invalid, queuing update...' . PHP_EOL;
+            $headerLines['name'] = $expectLine;
+        }
+
+        $createdPrefix = '// Created: ';
+        $createdLine = trim(fgets($handle));
+        if(strpos($createdLine, $createdPrefix) !== 0) {
+            echo '  Creation date is missing, queuing update...' . PHP_EOL;
+            $headerLines['created'] = $createdPrefix . $now;
+        }
+
+        $updatedPrefix = '// Updated: ';
+        $updatedLine = trim(fgets($handle));
+        $updatedDate = substr($updatedLine, strlen($updatedPrefix));
+        if(strpos($updatedLine, $updatedPrefix) !== 0 || (in_array($file, $changed) && $updatedDate !== $now)) {
+            echo '  Updated date is inaccurate, queuing update...' . PHP_EOL;
+            $headerLines['updated'] = $updatedPrefix . $now;
+        }
+
+        $blankLine = trim(fgets($handle));
+        if(!empty($blankLine)) {
+            echo '  Trailing newline missing, queuing update...' . PHP_EOL;
+            $headerLines['blank'] = '';
+        }
+
+        if(!empty($headerLines)) {
+            fclose($handle);
+
+            try {
+                $tmpName = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'ndx-uh-' . bin2hex(random_bytes(8)) . '.tmp';
+                copy($file, $tmpName);
+
+                $read = fopen($tmpName, 'rb');
+                $handle = fopen($file, 'wb');
+
+                fwrite($handle, fgets($read));
+
+                $insertAfter = [];
+
+                if(empty($headerLines['name']))
+                    fwrite($handle, fgets($read));
+                else {
+                    $line = fgets($read);
+                    if(strpos($line, '// ') !== 0)
+                        $insertAfter[] = $line;
+
+                    fwrite($handle, $headerLines['name'] . "\n");
+                }
+
+                if(empty($headerLines['created']))
+                    fwrite($handle, fgets($read));
+                else {
+                    $line = fgets($read);
+                    if(strpos($line, '// Created: ') !== 0)
+                        $insertAfter[] = $line;
+
+                    fwrite($handle, $headerLines['created'] . "\n");
+                }
+
+                if(empty($headerLines['updated']))
+                    fwrite($handle, fgets($read));
+                else {
+                    $line = fgets($read);
+                    if(strpos($line, '// Updated: ') !== 0)
+                        $insertAfter[] = $line;
+
+                    fwrite($handle, $headerLines['updated'] . "\n");
+                }
+
+                if(!isset($headerLines['blank']))
+                    fwrite($handle, fgets($read));
+                else {
+                    $line = fgets($read);
+                    if(!empty($line)) {
+                        $insertAfter[] = $line;
+                        fwrite($handle, "\n");
+                    }
+                }
+
+                foreach($insertAfter as $line)
+                    fwrite($handle, $line);
+
+                while(($line = fgets($read)) !== false)
+                    fwrite($handle, $line);
+            } finally {
+                if(is_resource($read))
+                    fclose($read);
+
+                if(is_file($tmpName))
+                    unlink($tmpName);
+            }
+        }
+    } finally {
+        fclose($handle);
+    }
+}
diff --git a/tools/update-version.php b/tools/update-version.php
new file mode 100644
index 0000000..0a1acbc
--- /dev/null
+++ b/tools/update-version.php
@@ -0,0 +1,10 @@
+<?php
+// Updates the VERSION file (prerelease stage only, remove this when 1.0.0)
+
+date_default_timezone_set('utc');
+
+$version = date('0.ym.jHi');
+
+echo 'Updating VERSION file to ' . $version . PHP_EOL;
+
+file_put_contents(__DIR__ . '/../VERSION', "{$version}\n");