@twin.org/core 0.0.1-next.9 → 0.0.2-next.10

package/dist/esm/index.mjs

@@ -1,5 +1,5 @@
-import { IntlMessageFormat } from 'intl-messageformat';
 import { createPatch, applyPatch } from 'rfc6902';
+import { IntlMessageFormat } from 'intl-messageformat';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -111,7 +111,12 @@ class Is {
         }
         try {
             const json = JSON.parse(value);
-            return typeof json === "object";
+            return (Is.object(json) ||
+                Is.array(json) ||
+                Is.string(json) ||
+                Is.number(json) ||
+                Is.boolean(json) ||
+                Is.null(json));
         }
         catch {
             return false;
@@ -135,7 +140,17 @@ class Is {
     static stringBase64Url(value) {
         return (Is.stringValue(value) &&
             // eslint-disable-next-line unicorn/better-regex
-            /^(?:[A-Za-z0-9-_]{4})*(?:[A-Za-z0-9-_]{2}==|[A-Za-z0-9-_]{3}=)?$/.test(value));
+            /^([A-Za-z0-9-_])*$/.test(value));
+    }
+    /**
+     * Is the value a base58 string.
+     * @param value The value to test.
+     * @returns True if the value is a base58 string.
+     */
+    static stringBase58(value) {
+        return (Is.stringValue(value) &&
+            // eslint-disable-next-line unicorn/better-regex
+            /^[A-HJ-NP-Za-km-z1-9]*$/.test(value));
     }
     /**
      * Is the value a hex string.
@@ -349,6 +364,27 @@ class Is {
     static promise(value) {
         return value instanceof Promise;
     }
+    /**
+     * Is the value a regexp.
+     * @param value The value to test.
+     * @returns True if the value is a regexp.
+     */
+    static regexp(value) {
+        return value instanceof RegExp;
+    }
+    /**
+     * Is the provided object a class constructor.
+     * @param obj The object to check.
+     * @returns True if the object is a class, false otherwise.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static class(obj) {
+        if (typeof obj !== "function") {
+            return false;
+        }
+        const str = Function.prototype.toString.call(obj);
+        return /^class\s/.test(str);
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -606,31 +642,33 @@ class BaseError extends Error {
      */
     properties;
     /**
-     * The inner error if there was one.
+     * The cause of the error.
      */
-    inner;
+    cause;
     /**
      * Create a new instance of BaseError.
      * @param name The name of the error.
      * @param source The source of the error.
      * @param message The message as a code.
      * @param properties Any additional information for the error.
-     * @param inner The inner error if we have wrapped another error.
+     * @param cause The cause of error if we have wrapped another error.
      */
-    constructor(name, source, message, properties, inner) {
+    constructor(name, source, message, properties, cause) {
         super(message);
         this.name = name;
         this.source = source;
+        this.cause = Is.notEmpty(cause) ? BaseError.fromError(cause).toJsonObject(true) : undefined;
+        this.properties = properties;
         // If the message is camel case but has no namespace then prefix it
-        // with the source name in camel case
+        // with the source name in camel case.
         if (Is.stringValue(source) &&
             Is.stringValue(message) &&
             !message.includes(".") &&
+            // This comparison checks that it is most likely a camel case name
+            // and not a free text error with a dot in it
             StringHelper.camelCase(message) === message) {
             this.message = `${StringHelper.camelCase(source)}.${message}`;
         }
-        this.properties = properties;
-        this.inner = inner ? BaseError.fromError(inner).toJsonObject() : undefined;
     }
     /**
      * Construct an error from an existing one.
@@ -642,9 +680,12 @@ class BaseError extends Error {
         let message;
         let source;
         let properties;
-        let inner;
+        let cause;
         let stack;
-        if (Is.object(err)) {
+        if (Is.object(err) && Is.stringValue(err.error)) {
+            message = err.error;
+        }
+        else if (Is.object(err)) {
             if (Is.stringValue(err.name)) {
                 name = err.name;
             }
@@ -657,23 +698,24 @@ class BaseError extends Error {
             if (Is.notEmpty(err.properties)) {
                 properties = err.properties;
             }
-            if (Is.notEmpty(err.inner)) {
-                inner = err.inner;
+            if (BaseError.isAggregateError(err)) {
+                properties ??= {};
+                properties.errors = err.errors;
+            }
+            if (Is.notEmpty(err.cause)) {
+                cause = err.cause;
             }
             if (Is.notEmpty(err.stack)) {
                 stack = err.stack;
             }
         }
-        else if (Is.object(err) && Is.stringValue(err.error)) {
-            message = err.error;
-        }
         else if (Is.stringValue(err)) {
             message = err;
         }
         else {
             message = JSON.stringify(err);
         }
-        const baseError = new BaseError(name, source ?? "", message ?? "", properties, inner);
+        const baseError = new BaseError(name, source ?? "", message ?? "", properties, cause);
         baseError.stack = stack;
         return baseError;
     }
@@ -684,12 +726,12 @@ class BaseError extends Error {
      */
     static flatten(err) {
         const flattened = [];
-        let e = BaseError.fromError(err).toJsonObject();
+        let e = BaseError.fromError(err).toJsonObject(true);
         while (e) {
-            const inner = e.inner;
-            e.inner = undefined;
+            const cause = e.cause;
+            e.cause = undefined;
             flattened.push(e);
-            e = inner;
+            e = cause;
         }
         return flattened;
     }
@@ -704,8 +746,8 @@ class BaseError extends Error {
             first = errors[0];
             let current = first;
             for (let i = 1; i < errors.length; i++) {
-                current.inner = errors[i];
-                current = current.inner;
+                current.cause = errors[i];
+                current = current.cause;
             }
         }
         return first;
@@ -778,11 +820,43 @@ class BaseError extends Error {
     static someErrorCode(error, code) {
         return BaseError.flatten(error).some(e => BaseError.isErrorCode(e, code));
     }
+    /**
+     * Is the error empty, i.e. does it have no message, source, properties, or cause?
+     * @param err The error to check for being empty.
+     * @returns True if the error is empty.
+     */
+    static isEmpty(err) {
+        return (!Is.stringValue(err.message) &&
+            !Is.stringValue(err.source) &&
+            !Is.objectValue(err.properties) &&
+            Is.empty(err.cause));
+    }
+    /**
+     * Is the error an aggregate error.
+     * @param err The error to check for being an aggregate error.
+     * @returns True if the error is an aggregate error.
+     */
+    static isAggregateError(err) {
+        return err instanceof AggregateError;
+    }
+    /**
+     * Convert the aggregate error to an array of errors.
+     * @param err The error to convert.
+     * @param includeStackTrace Whether to include the error stack in the model, defaults to false.
+     * @returns The array of errors.
+     */
+    static fromAggregate(err, includeStackTrace) {
+        if (BaseError.isAggregateError(err)) {
+            return err.errors.map(e => BaseError.fromError(e).toJsonObject(includeStackTrace));
+        }
+        return [BaseError.fromError(err).toJsonObject(includeStackTrace)];
+    }
     /**
      * Serialize the error to the error model.
+     * @param includeStackTrace Whether to include the error stack in the model, defaults to false.
      * @returns The error model.
      */
-    toJsonObject() {
+    toJsonObject(includeStackTrace) {
         const err = {};
         if (Is.stringValue(this.name)) {
             err.name = this.name;
@@ -796,11 +870,11 @@ class BaseError extends Error {
         if (Is.object(this.properties)) {
             err.properties = this.properties;
         }
-        if (Is.stringValue(this.stack)) {
+        if ((includeStackTrace ?? false) && Is.stringValue(this.stack)) {
             err.stack = this.stack;
         }
-        if (Is.notEmpty(this.inner)) {
-            err.inner = BaseError.fromError(this.inner).toJsonObject();
+        if (Is.notEmpty(this.cause)) {
+            err.cause = BaseError.fromError(this.cause).toJsonObject(includeStackTrace);
         }
         return err;
     }
@@ -819,176 +893,614 @@ class GeneralError extends BaseError {
      * @param source The source of the error.
      * @param message The message as a code.
      * @param properties Any additional information for the error.
-     * @param inner The inner error if we have wrapped another error.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    constructor(source, message, properties, inner) {
-        super(GeneralError.CLASS_NAME, source, message, properties, inner);
+    constructor(source, message, properties, cause) {
+        super(GeneralError.CLASS_NAME, source, message, properties, cause);
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
 /**
- * Class to help with base63 Encoding/Decoding.
+ * Class to handle errors which are triggered by data guards.
  */
-class Base32 {
+class GuardError extends BaseError {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Base32";
+    static CLASS_NAME = "GuardError";
     /**
-     * Alphabet table for encoding.
-     * @internal
+     * Create a new instance of GuardError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param propertyName The property which triggered the guard error for the item.
+     * @param propertyValue The property value which triggered the guard error for the item.
+     * @param propertyOptions The property options which might be allowed.
      */
-    static _ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    constructor(source, message, propertyName, propertyValue, propertyOptions) {
+        super(GuardError.CLASS_NAME, source, message, {
+            property: propertyName ?? "property",
+            value: Is.undefined(propertyValue) ? "undefined" : propertyValue,
+            options: propertyOptions
+        });
+    }
+}
+
+/**
+ * Class to help with arrays.
+ */
+class ArrayHelper {
     /**
-     * Convert the base 32 string to a byte array.
-     * @param base32 The base32 string to convert.
-     * @returns The byte array.
-     * @throws If the input string contains a character not in the Base32 alphabet.
+     * Do the two arrays match.
+     * @param arr1 The first array.
+     * @param arr2 The second array.
+     * @returns True if both arrays are empty of have the same values.
      */
-    static decode(base32) {
-        let bits = 0;
-        let value = 0;
-        base32 = base32.replace(/=+$/, "");
-        let index = 0;
-        const output = new Uint8Array(Math.trunc((base32.length * 5) / 8));
-        for (let i = 0; i < base32.length; i++) {
-            const idx = Base32._ALPHABET.indexOf(base32[i]);
-            if (idx === -1) {
-                throw new GeneralError(Base32._CLASS_NAME, "invalidCharacter", {
-                    invalidCharacter: base32[i]
-                });
-            }
-            value = (value << 5) | idx;
-            bits += 5;
-            if (bits >= 8) {
-                output[index++] = (value >>> (bits - 8)) & 255;
-                bits -= 8;
+    static matches(arr1, arr2) {
+        if (Is.empty(arr1) && Is.empty(arr2)) {
+            return true;
+        }
+        if (!((Is.array(arr1) && Is.array(arr2)) || (Is.typedArray(arr1) && Is.typedArray(arr2)))) {
+            return false;
+        }
+        if (arr1.length !== arr2.length) {
+            return false;
+        }
+        for (let i = 0; i < arr1.length; i++) {
+            if (arr1[i] !== arr2[i]) {
+                return false;
             }
         }
-        return output;
+        return true;
     }
     /**
-     * Convert a byte array to base 32.
-     * @param bytes The byte array to convert.
-     * @returns The data as base32 string.
+     * Convert an object or array to an array.
+     * @param value The object or array to convert.
+     * @returns The array.
      */
-    static encode(bytes) {
-        let bits = 0;
-        let value = 0;
-        let output = "";
-        for (let i = 0; i < bytes.byteLength; i++) {
-            value = (value << 8) | bytes[i];
-            bits += 8;
-            while (bits >= 5) {
-                output += Base32._ALPHABET[(value >>> (bits - 5)) & 31];
-                bits -= 5;
-            }
-        }
-        if (bits > 0) {
-            output += Base32._ALPHABET[(value << (5 - bits)) & 31];
+    static fromObjectOrArray(value) {
+        if (Is.empty(value)) {
+            return undefined;
         }
-        while (output.length % 8 !== 0) {
-            output += "=";
+        if (Is.array(value)) {
+            return value;
         }
-        return output;
+        return [value];
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
- * Class to help with base58 Encoding/Decoding.
+ * Class to handle guard operations for parameters.
  */
-class Base58 {
-    /**
-     * Runtime name for the class.
-     * @internal
-     */
-    static _CLASS_NAME = "Base58";
+class Guards {
     /**
-     * Alphabet table for encoding.
-     * @internal
+     * Is the property defined.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static _ALPHABET = 
-    // cspell:disable-next-line
-    "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    static defined(source, property, value) {
+        if (Is.undefined(value)) {
+            throw new GuardError(source, "guard.undefined", property, value);
+        }
+    }
     /**
-     * Reverse map for decoding.
-     * @internal
+     * Is the property a string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static _ALPHABET_REVERSE = [
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -1, -1, -1, -1, -1, -1, -1, 9, 10, 11, 12, 13, 14, 15, 16, -1,
-        17, 18, 19, 20, 21, -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, 33,
-        34, 35, 36, 37, 38, 39, 40, 41, 42, 43, -1, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
-        57, -1, -1, -1, -1, -1
-    ];
+    static string(source, property, value) {
+        if (!Is.string(value)) {
+            throw new GuardError(source, "guard.string", property, value);
+        }
+    }
     /**
-     * Convert the base 58 string to a byte array.
-     * @param base58 The base58 string to convert.
-     * @returns The byte array.
-     * @throws If the input string contains a character not in the Base58 alphabet.
+     * Is the property a string with a value.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static decode(base58) {
-        let zeroes = 0;
-        for (let i = 0; i < base58.length; i++) {
-            if (base58[i] !== "1") {
-                break;
-            }
-            zeroes += 1;
-        }
-        const size = Math.trunc((base58.length * 733) / 1000) + 1;
-        const b256 = new Uint8Array(size).fill(0);
-        let length = 0;
-        for (let i = zeroes; i < base58.length; i++) {
-            const ch = base58.charCodeAt(i);
-            if (ch & 0xff80) {
-                throw new GeneralError(Base58._CLASS_NAME, "invalidCharacter", { invalidCharacter: ch });
-            }
-            const val = Base58._ALPHABET_REVERSE[ch];
-            if (val === -1) {
-                throw new GeneralError(Base58._CLASS_NAME, "invalidCharacter", { invalidCharacter: ch });
-            }
-            let carry = val;
-            let j = 0;
-            for (let k = size - 1; k >= 0; k--, j++) {
-                if (carry === 0 && j >= length) {
-                    break;
-                }
-                carry += b256[k] * 58;
-                b256[k] = carry;
-                carry >>>= 8;
-            }
-            length = j;
+    static stringValue(source, property, value) {
+        if (!Is.string(value)) {
+            throw new GuardError(source, "guard.string", property, value);
         }
-        const out = new Uint8Array(zeroes + length);
-        let j;
-        for (j = 0; j < zeroes; j++) {
-            out[j] = 0;
+        if (value.length === 0) {
+            throw new GuardError(source, "guard.stringEmpty", property, value);
         }
-        let i = size - length;
-        while (i < size) {
-            out[j++] = b256[i++];
+    }
+    /**
+     * Is the property a JSON value.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static json(source, property, value) {
+        if (!Is.json(value)) {
+            throw new GuardError(source, "guard.stringJson", property, value);
         }
-        return out;
     }
     /**
-     * Convert a byte array to base 58.
-     * @param bytes The byte array to encode.
-     * @returns The data as base58 string.
+     * Is the property a base64 string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static encode(bytes) {
-        let zeroes = 0;
-        for (let i = 0; i < bytes.length; i++) {
-            if (bytes[i] !== 0) {
-                break;
-            }
-            zeroes += 1;
+    static stringBase64(source, property, value) {
+        if (!Is.stringBase64(value)) {
+            throw new GuardError(source, "guard.base64", property, value);
         }
-        const size = Math.trunc(((bytes.length - zeroes) * 138) / 100) + 1;
+    }
+    /**
+     * Is the property a base64 url string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringBase64Url(source, property, value) {
+        if (!Is.stringBase64Url(value)) {
+            throw new GuardError(source, "guard.base64Url", property, value);
+        }
+    }
+    /**
+     * Is the property a base58 string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringBase58(source, property, value) {
+        if (!Is.stringBase58(value)) {
+            throw new GuardError(source, "guard.base58", property, value);
+        }
+    }
+    /**
+     * Is the property a string with a hex value.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param allowPrefix Allow the hex to have the 0x prefix.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringHex(source, property, value, allowPrefix = false) {
+        Guards.stringValue(source, property, value);
+        if (!HexHelper.isHex(value, allowPrefix)) {
+            throw new GuardError(source, "guard.stringHex", property, value);
+        }
+    }
+    /**
+     * Is the property a string with a hex value with fixed length.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param length The length of the string to match.
+     * @param allowPrefix Allow the hex to have the 0x prefix.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringHexLength(source, property, value, length, allowPrefix = false) {
+        Guards.stringHex(source, property, value, allowPrefix);
+        if (HexHelper.stripPrefix(value).length !== length) {
+            throw new GuardError(source, "guard.stringHexLength", property, value.length, length.toString());
+        }
+    }
+    /**
+     * Is the property a number.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static number(source, property, value) {
+        if (!Is.number(value)) {
+            throw new GuardError(source, "guard.number", property, value);
+        }
+    }
+    /**
+     * Is the property an integer.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static integer(source, property, value) {
+        if (!Is.integer(value)) {
+            throw new GuardError(source, "guard.integer", property, value);
+        }
+    }
+    /**
+     * Is the property a bigint.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static bigint(source, property, value) {
+        if (!Is.bigint(value)) {
+            throw new GuardError(source, "guard.bigint", property, value);
+        }
+    }
+    /**
+     * Is the property a boolean.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static boolean(source, property, value) {
+        if (!Is.boolean(value)) {
+            throw new GuardError(source, "guard.boolean", property, value);
+        }
+    }
+    /**
+     * Is the property a date.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static date(source, property, value) {
+        if (!Is.date(value)) {
+            throw new GuardError(source, "guard.date", property, value);
+        }
+    }
+    /**
+     * Is the property a timestamp in milliseconds.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static timestampMilliseconds(source, property, value) {
+        if (!Is.timestampMilliseconds(value)) {
+            throw new GuardError(source, "guard.timestampMilliseconds", property, value);
+        }
+    }
+    /**
+     * Is the property a timestamp in seconds.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static timestampSeconds(source, property, value) {
+        if (!Is.timestampSeconds(value)) {
+            throw new GuardError(source, "guard.timestampSeconds", property, value);
+        }
+    }
+    /**
+     * Is the property an object.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static object(source, property, value) {
+        if (Is.undefined(value)) {
+            throw new GuardError(source, "guard.objectUndefined", property, value);
+        }
+        if (!Is.object(value)) {
+            throw new GuardError(source, "guard.object", property, value);
+        }
+    }
+    /**
+     * Is the property is an object with at least one property.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static objectValue(source, property, value) {
+        if (Is.undefined(value)) {
+            throw new GuardError(source, "guard.objectUndefined", property, value);
+        }
+        if (!Is.object(value)) {
+            throw new GuardError(source, "guard.object", property, value);
+        }
+        if (Object.keys(value || {}).length === 0) {
+            throw new GuardError(source, "guard.objectValue", property, value);
+        }
+    }
+    /**
+     * Is the property is an array.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static array(source, property, value) {
+        if (!Is.array(value)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+    }
+    /**
+     * Is the property is an array with at least one item.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static arrayValue(source, property, value) {
+        if (!Is.array(value)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+        if (value.length === 0) {
+            throw new GuardError(source, "guard.arrayValue", property, value);
+        }
+    }
+    /**
+     * Is the property one of a list of items.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param options The options the value must be one of.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static arrayOneOf(source, property, value, options) {
+        if (!Is.array(options)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+        if (!options.includes(value)) {
+            throw new GuardError(source, "guard.arrayOneOf", property, value, options.join(", "));
+        }
+    }
+    /**
+     * Does the array start with the specified data.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param startValues The values that must start the array.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static arrayStartsWith(source, property, value, startValues) {
+        if (!Is.arrayValue(value)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+        const startValuesArray = ArrayHelper.fromObjectOrArray(startValues);
+        if (!Is.arrayValue(startValuesArray)) {
+            throw new GuardError(source, "guard.array", property, startValuesArray);
+        }
+        for (let i = 0; i < startValuesArray.length; i++) {
+            if (value[i] !== startValuesArray[i]) {
+                throw new GuardError(source, "guard.arrayStartsWith", property, value, startValuesArray.join(", "));
+            }
+        }
+    }
+    /**
+     * Does the array end with the specified data.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param endValues The values that must end the array.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static arrayEndsWith(source, property, value, endValues) {
+        if (!Is.arrayValue(value)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+        const endValuesArray = ArrayHelper.fromObjectOrArray(endValues);
+        if (!Is.arrayValue(endValuesArray)) {
+            throw new GuardError(source, "guard.array", property, endValuesArray);
+        }
+        for (let i = 0; i < endValuesArray.length; i++) {
+            if (value[value.length - i - 1] !== endValuesArray[endValuesArray.length - i - 1]) {
+                throw new GuardError(source, "guard.arrayEndsWith", property, value, endValuesArray.join(", "));
+            }
+        }
+    }
+    /**
+     * Is the property a Uint8Array.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static uint8Array(source, property, value) {
+        if (!Is.uint8Array(value)) {
+            throw new GuardError(source, "guard.uint8Array", property, value);
+        }
+    }
+    /**
+     * Is the property a function.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @returns True if the value is a function.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static function(source, property, value) {
+        if (!Is.function(value)) {
+            throw new GuardError(source, "guard.function", property, value);
+        }
+        return true;
+    }
+    /**
+     * Is the property a string formatted as an email address.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static email(source, property, value) {
+        if (!Is.email(value)) {
+            throw new GuardError(source, "guard.email", property, value);
+        }
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
+/**
+ * Class to help with base63 Encoding/Decoding.
+ */
+class Base32 {
+    /**
+     * Runtime name for the class.
+     * @internal
+     */
+    static _CLASS_NAME = "Base32";
+    /**
+     * Alphabet table for encoding.
+     * @internal
+     */
+    static _ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    /**
+     * Convert the base 32 string to a byte array.
+     * @param base32 The base32 string to convert.
+     * @returns The byte array.
+     * @throws If the input string contains a character not in the Base32 alphabet.
+     */
+    static decode(base32) {
+        Guards.string(Base32._CLASS_NAME, "base32", base32);
+        let bits = 0;
+        let value = 0;
+        base32 = base32.replace(/=+$/, "");
+        let index = 0;
+        const output = new Uint8Array(Math.trunc((base32.length * 5) / 8));
+        for (let i = 0; i < base32.length; i++) {
+            const idx = Base32._ALPHABET.indexOf(base32[i]);
+            if (idx === -1) {
+                throw new GeneralError(Base32._CLASS_NAME, "invalidCharacter", {
+                    invalidCharacter: base32[i]
+                });
+            }
+            value = (value << 5) | idx;
+            bits += 5;
+            if (bits >= 8) {
+                output[index++] = (value >>> (bits - 8)) & 255;
+                bits -= 8;
+            }
+        }
+        return output;
+    }
+    /**
+     * Convert a byte array to base 32.
+     * @param bytes The byte array to convert.
+     * @returns The data as base32 string.
+     */
+    static encode(bytes) {
+        Guards.uint8Array(Base32._CLASS_NAME, "bytes", bytes);
+        let bits = 0;
+        let value = 0;
+        let output = "";
+        for (let i = 0; i < bytes.byteLength; i++) {
+            value = (value << 8) | bytes[i];
+            bits += 8;
+            while (bits >= 5) {
+                output += Base32._ALPHABET[(value >>> (bits - 5)) & 31];
+                bits -= 5;
+            }
+        }
+        if (bits > 0) {
+            output += Base32._ALPHABET[(value << (5 - bits)) & 31];
+        }
+        while (output.length % 8 !== 0) {
+            output += "=";
+        }
+        return output;
+    }
+}
+
+/**
+ * Class to help with base58 Encoding/Decoding.
+ */
+class Base58 {
+    /**
+     * Runtime name for the class.
+     * @internal
+     */
+    static _CLASS_NAME = "Base58";
+    /**
+     * Alphabet table for encoding.
+     * @internal
+     */
+    static _ALPHABET = 
+    // cspell:disable-next-line
+    "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    /**
+     * Reverse map for decoding.
+     * @internal
+     */
+    static _ALPHABET_REVERSE = [
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -1, -1, -1, -1, -1, -1, -1, 9, 10, 11, 12, 13, 14, 15, 16, -1,
+        17, 18, 19, 20, 21, -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, 33,
+        34, 35, 36, 37, 38, 39, 40, 41, 42, 43, -1, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+        57, -1, -1, -1, -1, -1
+    ];
+    /**
+     * Convert the base 58 string to a byte array.
+     * @param base58 The base58 string to convert.
+     * @returns The byte array.
+     * @throws If the input string contains a character not in the Base58 alphabet.
+     */
+    static decode(base58) {
+        Guards.string(Base58._CLASS_NAME, "base58", base58);
+        let zeroes = 0;
+        for (let i = 0; i < base58.length; i++) {
+            if (base58[i] !== "1") {
+                break;
+            }
+            zeroes += 1;
+        }
+        const size = Math.trunc((base58.length * 733) / 1000) + 1;
+        const b256 = new Uint8Array(size).fill(0);
+        let length = 0;
+        for (let i = zeroes; i < base58.length; i++) {
+            const ch = base58.charCodeAt(i);
+            if (ch & 0xff80) {
+                throw new GeneralError(Base58._CLASS_NAME, "invalidCharacter", { invalidCharacter: ch });
+            }
+            const val = Base58._ALPHABET_REVERSE[ch];
+            if (val === -1) {
+                throw new GeneralError(Base58._CLASS_NAME, "invalidCharacter", { invalidCharacter: ch });
+            }
+            let carry = val;
+            let j = 0;
+            for (let k = size - 1; k >= 0; k--, j++) {
+                if (carry === 0 && j >= length) {
+                    break;
+                }
+                carry += b256[k] * 58;
+                b256[k] = carry;
+                carry >>>= 8;
+            }
+            length = j;
+        }
+        const out = new Uint8Array(zeroes + length);
+        let j;
+        for (j = 0; j < zeroes; j++) {
+            out[j] = 0;
+        }
+        let i = size - length;
+        while (i < size) {
+            out[j++] = b256[i++];
+        }
+        return out;
+    }
+    /**
+     * Convert a byte array to base 58.
+     * @param bytes The byte array to encode.
+     * @returns The data as base58 string.
+     */
+    static encode(bytes) {
+        Guards.uint8Array(Base58._CLASS_NAME, "bytes", bytes);
+        let zeroes = 0;
+        for (let i = 0; i < bytes.length; i++) {
+            if (bytes[i] !== 0) {
+                break;
+            }
+            zeroes += 1;
+        }
+        const size = Math.trunc(((bytes.length - zeroes) * 138) / 100) + 1;
         const b58 = new Uint8Array(size).fill(0);
         let length = 0;
         for (let i = zeroes; i < bytes.length; i++) {
@@ -1125,6 +1637,7 @@ class Base64 {
      * @returns The byte array.
      */
     static decode(base64) {
+        Guards.string(Base64._CLASS_NAME, "base64", base64);
         let tmp;
         const lens = Base64.getLengths(base64);
         const validLen = lens[0];
@@ -1166,6 +1679,7 @@ class Base64 {
      * @returns The data as base64 string.
      */
     static encode(bytes) {
+        Guards.uint8Array(Base64._CLASS_NAME, "bytes", bytes);
         let tmp;
         const len = bytes.length;
         const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
@@ -1173,7 +1687,7 @@ class Base64 {
         const maxChunkLength = 16383; // must be multiple of 3
         // go through the array every three bytes, we'll deal with trailing stuff later
         for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-            parts.push(Base64.encodeChunk(bytes, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+            parts.push(Base64.encodeChunk(bytes, i, Math.min(i + maxChunkLength, len2)));
         }
         // pad the end with zeros, but make sure to not forget the extra bytes
         if (extraBytes === 1) {
@@ -1247,522 +1761,251 @@ class Base64 {
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * Class to help with base64 URL Encoding/Decoding.
  * https://www.rfc-editor.org/rfc/rfc4648#section-5.
  */
 class Base64Url {
-    /**
-     * Convert the base 64 string to a byte array.
-     * @param base64Url The base64 url string to convert.
-     * @returns The byte array.
-     */
-    static decode(base64Url) {
-        let base64 = base64Url;
-        // Base 64 url can have padding removed, so add it back if it is missing.
-        if (base64.length > 0 && !base64.endsWith("=")) {
-            const placeHoldersLen = 4 - (base64.length % 4);
-            if (placeHoldersLen > 0 && placeHoldersLen < 4) {
-                base64 = base64.padEnd(base64.length + placeHoldersLen, "=");
-            }
-        }
-        base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
-        return Base64.decode(base64);
-    }
-    /**
-     * Convert a byte array to base 64 url.
-     * @param bytes The byte array to convert.
-     * @returns The data as base64 url string.
-     */
-    static encode(bytes) {
-        const base64 = Base64.encode(bytes);
-        // Base 64 url can have padding removed, so remove it.
-        return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-    }
-}
-
-/**
- * Class to handle errors which are triggered by data already existing.
- */
-class AlreadyExistsError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "AlreadyExistsError";
-    /**
-     * Create a new instance of AlreadyExistsError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param existingId The id for the item.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, existingId, inner) {
-        super(AlreadyExistsError.CLASS_NAME, source, message, { existingId }, inner);
-    }
-}
-
-/**
- * Class to handle errors which are triggered by conflicting data.
- */
-class ConflictError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "ConflictError";
-    /**
-     * Create a new instance of ConflictError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param conflictId The id that has conflicts.
-     * @param conflicts The conflicts that occurred.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, conflictId, conflicts, inner) {
-        super(ConflictError.CLASS_NAME, source, message, { conflictId, conflicts }, inner);
-    }
-}
-
-/**
- * Class to handle errors which are triggered by data guards.
- */
-class GuardError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "GuardError";
-    /**
-     * Create a new instance of GuardError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param propertyName The property which triggered the guard error for the item.
-     * @param propertyValue The property value which triggered the guard error for the item.
-     * @param propertyOptions The property options which might be allowed.
-     */
-    constructor(source, message, propertyName, propertyValue, propertyOptions) {
-        super(GuardError.CLASS_NAME, source, message, {
-            property: propertyName ?? "property",
-            value: Is.undefined(propertyValue) ? "undefined" : propertyValue,
-            options: propertyOptions
-        });
-    }
-}
-
-/**
- * Class to handle errors which are triggered by data not being found.
- */
-class NotFoundError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "NotFoundError";
-    /**
-     * Create a new instance of NotFoundError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param notFoundId The id for the item.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, notFoundId, inner) {
-        super(NotFoundError.CLASS_NAME, source, message, { notFoundId }, inner);
-    }
-}
-
-/**
- * Class to handle errors.
- */
-class NotImplementedError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "NotImplementedError";
-    /**
-     * Create a new instance of NotImplementedError.
-     * @param source The source of the error.
-     * @param method The method for the error.
-     */
-    constructor(source, method) {
-        super(NotImplementedError.CLASS_NAME, source, "common.notImplementedMethod", {
-            method
-        });
-    }
-}
-
-/**
- * Class to handle errors when a feature is unsupported.
- */
-class NotSupportedError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "NotSupportedError";
-    /**
-     * Create a new instance of NotSupportedError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, inner) {
-        super(NotSupportedError.CLASS_NAME, source, message, undefined, inner);
-    }
-}
-
-/**
- * Class to handle errors which are triggered by access not being unauthorized.
- */
-class UnauthorizedError extends BaseError {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "UnauthorizedError";
-    /**
-     * Create a new instance of UnauthorizedError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, inner) {
-        super(UnauthorizedError.CLASS_NAME, source, message, undefined, inner);
-    }
-}
-
-/**
- * Class to handle errors when some data can not be processed.
- */
-class UnprocessableError extends BaseError {
     /**
      * Runtime name for the class.
+     * @internal
      */
-    static CLASS_NAME = "UnprocessableError";
-    /**
-     * Create a new instance of UnprocessableError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param properties Any additional information for the error.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, properties, inner) {
-        super(UnprocessableError.CLASS_NAME, source, message, properties, inner);
-    }
-}
-
-/**
- * Class to handle errors which are triggered by entity validation.
- */
-class ValidationError extends BaseError {
-    /**
-     * Runtime name for the class.s
-     */
-    static CLASS_NAME = "ValidationError";
-    /**
-     * Create a new instance of ValidationError.
-     * @param source The source of the error.
-     * @param validationObject The object that failed validation.
-     * @param validationFailures The validation failures.
-     */
-    constructor(source, validationObject, validationFailures) {
-        super(ValidationError.CLASS_NAME, source, "common.validation", {
-            validationObject,
-            validationFailures
-        });
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to handle guard operations for parameters.
- */
-class Guards {
-    /**
-     * Is the property defined.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
-     */
-    static defined(source, property, value) {
-        if (Is.undefined(value)) {
-            throw new GuardError(source, "guard.undefined", property, value);
-        }
-    }
-    /**
-     * Is the property a string.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
-     */
-    static string(source, property, value) {
-        if (!Is.string(value)) {
-            throw new GuardError(source, "guard.string", property, value);
-        }
-    }
-    /**
-     * Is the property a string with a value.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
-     */
-    static stringValue(source, property, value) {
-        if (!Is.string(value)) {
-            throw new GuardError(source, "guard.string", property, value);
-        }
-        if (value.length === 0) {
-            throw new GuardError(source, "guard.stringEmpty", property, value);
-        }
-    }
+    static _CLASS_NAME = "Base64";
     /**
-     * Is the property a base64 string.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert the base 64 string to a byte array.
+     * @param base64Url The base64 url string to convert.
+     * @returns The byte array.
      */
-    static stringBase64(source, property, value) {
-        if (!Is.stringBase64(value)) {
-            throw new GuardError(source, "guard.base64", property, value);
+    static decode(base64Url) {
+        Guards.string(Base64Url._CLASS_NAME, "base64Url", base64Url);
+        let base64 = base64Url;
+        // Base 64 url can have padding removed, so add it back if it is missing.
+        if (base64.length > 0 && !base64.endsWith("=")) {
+            const placeHoldersLen = 4 - (base64.length % 4);
+            if (placeHoldersLen > 0 && placeHoldersLen < 4) {
+                base64 = base64.padEnd(base64.length + placeHoldersLen, "=");
+            }
         }
+        base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+        return Base64.decode(base64);
     }
     /**
-     * Is the property a base64 url string.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert a byte array to base 64 url.
+     * @param bytes The byte array to convert.
+     * @returns The data as base64 url string.
      */
-    static stringBase64Url(source, property, value) {
-        if (!Is.stringBase64Url(value)) {
-            throw new GuardError(source, "guard.base64Url", property, value);
-        }
+    static encode(bytes) {
+        Guards.uint8Array(Base64Url._CLASS_NAME, "bytes", bytes);
+        const base64 = Base64.encode(bytes);
+        // Base 64 url can have padding removed, so remove it.
+        return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
     }
+}
+
+/**
+ * Class to handle errors which are triggered by data already existing.
+ */
+class AlreadyExistsError extends BaseError {
     /**
-     * Is the property a string with a hex value.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param allowPrefix Allow the hex to have the 0x prefix.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static stringHex(source, property, value, allowPrefix = false) {
-        Guards.stringValue(source, property, value);
-        if (!HexHelper.isHex(value, allowPrefix)) {
-            throw new GuardError(source, "guard.stringHex", property, value);
-        }
-    }
+    static CLASS_NAME = "AlreadyExistsError";
     /**
-     * Is the property a string with a hex value with fixed length.
+     * Create a new instance of AlreadyExistsError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param length The length of the string to match.
-     * @param allowPrefix Allow the hex to have the 0x prefix.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param existingId The id for the item.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static stringHexLength(source, property, value, length, allowPrefix = false) {
-        Guards.stringHex(source, property, value, allowPrefix);
-        if (HexHelper.stripPrefix(value).length !== length) {
-            throw new GuardError(source, "guard.stringHexLength", property, value.length, length.toString());
-        }
+    constructor(source, message, existingId, cause) {
+        super(AlreadyExistsError.CLASS_NAME, source, message, { existingId });
     }
+}
+
+/**
+ * Class to handle errors which are triggered by conflicting data.
+ */
+class ConflictError extends BaseError {
     /**
-     * Is the property a number.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static number(source, property, value) {
-        if (!Is.number(value)) {
-            throw new GuardError(source, "guard.number", property, value);
-        }
-    }
+    static CLASS_NAME = "ConflictError";
     /**
-     * Is the property an integer.
+     * Create a new instance of ConflictError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param conflictId The id that has conflicts.
+     * @param conflicts The conflicts that occurred.
+     * @param cause The cause or the error if we have wrapped another error.
      */
-    static integer(source, property, value) {
-        if (!Is.integer(value)) {
-            throw new GuardError(source, "guard.integer", property, value);
-        }
+    constructor(source, message, conflictId, conflicts, cause) {
+        super(ConflictError.CLASS_NAME, source, message, { conflictId, conflicts }, cause);
     }
+}
+
+/**
+ * Class to handle errors which are triggered by data not being found.
+ */
+class NotFoundError extends BaseError {
     /**
-     * Is the property a bigint.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static bigint(source, property, value) {
-        if (!Is.bigint(value)) {
-            throw new GuardError(source, "guard.bigint", property, value);
-        }
-    }
+    static CLASS_NAME = "NotFoundError";
     /**
-     * Is the property a boolean.
+     * Create a new instance of NotFoundError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param notFoundId The id for the item.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static boolean(source, property, value) {
-        if (!Is.boolean(value)) {
-            throw new GuardError(source, "guard.boolean", property, value);
-        }
+    constructor(source, message, notFoundId, cause) {
+        super(NotFoundError.CLASS_NAME, source, message, { notFoundId }, cause);
     }
+}
+
+/**
+ * Class to handle errors.
+ */
+class NotImplementedError extends BaseError {
     /**
-     * Is the property a date.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static date(source, property, value) {
-        if (!Is.date(value)) {
-            throw new GuardError(source, "guard.date", property, value);
-        }
-    }
+    static CLASS_NAME = "NotImplementedError";
     /**
-     * Is the property a timestamp in milliseconds.
+     * Create a new instance of NotImplementedError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param method The method for the error.
      */
-    static timestampMilliseconds(source, property, value) {
-        if (!Is.timestampMilliseconds(value)) {
-            throw new GuardError(source, "guard.timestampMilliseconds", property, value);
-        }
+    constructor(source, method) {
+        super(NotImplementedError.CLASS_NAME, source, "common.notImplementedMethod", {
+            method
+        });
     }
+}
+
+/**
+ * Class to handle errors when a feature is unsupported.
+ */
+class NotSupportedError extends BaseError {
     /**
-     * Is the property a timestamp in seconds.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static timestampSeconds(source, property, value) {
-        if (!Is.timestampSeconds(value)) {
-            throw new GuardError(source, "guard.timestampSeconds", property, value);
-        }
-    }
+    static CLASS_NAME = "NotSupportedError";
     /**
-     * Is the property an object.
+     * Create a new instance of NotSupportedError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static object(source, property, value) {
-        if (Is.undefined(value)) {
-            throw new GuardError(source, "guard.objectUndefined", property, value);
-        }
-        if (!Is.object(value)) {
-            throw new GuardError(source, "guard.object", property, value);
-        }
+    constructor(source, message, cause) {
+        super(NotSupportedError.CLASS_NAME, source, message, undefined, cause);
     }
+}
+
+/**
+ * Class to handle errors which are triggered by access not being unauthorized.
+ */
+class UnauthorizedError extends BaseError {
     /**
-     * Is the property is an object with at least one property.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static objectValue(source, property, value) {
-        if (Is.undefined(value)) {
-            throw new GuardError(source, "guard.objectUndefined", property, value);
-        }
-        if (!Is.object(value)) {
-            throw new GuardError(source, "guard.object", property, value);
-        }
-        if (Object.keys(value || {}).length === 0) {
-            throw new GuardError(source, "guard.objectValue", property, value);
-        }
-    }
+    static CLASS_NAME = "UnauthorizedError";
     /**
-     * Is the property is an array.
+     * Create a new instance of UnauthorizedError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static array(source, property, value) {
-        if (!Is.array(value)) {
-            throw new GuardError(source, "guard.array", property, value);
-        }
+    constructor(source, message, cause) {
+        super(UnauthorizedError.CLASS_NAME, source, message, undefined, cause);
     }
+}
+
+/**
+ * Class to handle errors when some data can not be processed.
+ */
+class UnprocessableError extends BaseError {
     /**
-     * Is the property is an array with at least one item.
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "UnprocessableError";
+    /**
+     * Create a new instance of UnprocessableError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param properties Any additional information for the error.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static arrayValue(source, property, value) {
-        if (!Is.array(value)) {
-            throw new GuardError(source, "guard.array", property, value);
-        }
-        if (value.length === 0) {
-            throw new GuardError(source, "guard.arrayValue", property, value);
-        }
+    constructor(source, message, properties, cause) {
+        super(UnprocessableError.CLASS_NAME, source, message, properties, cause);
     }
+}
+
+/**
+ * Class to handle errors which are triggered by entity validation.
+ */
+class ValidationError extends BaseError {
     /**
-     * Is the property one of a list of items.
+     * Runtime name for the class.s
+     */
+    static CLASS_NAME = "ValidationError";
+    /**
+     * Create a new instance of ValidationError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param options The options the value must be one of.
-     * @throws GuardError If the value does not match the assertion.
+     * @param validationObject The object that failed validation.
+     * @param validationFailures The validation failures.
      */
-    static arrayOneOf(source, property, value, options) {
-        if (!Is.array(options)) {
-            throw new GuardError(source, "guard.array", property, value);
-        }
-        if (!options.includes(value)) {
-            throw new GuardError(source, "guard.arrayOneOf", property, value, options.join(", "));
-        }
+    constructor(source, validationObject, validationFailures) {
+        super(ValidationError.CLASS_NAME, source, "common.validation", {
+            validationObject,
+            validationFailures
+        });
     }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Provide a store for shared objects which can be accesses through multiple
+ * instance loads of a packages.
+ */
+class SharedStore {
     /**
-     * Is the property a Uint8Array.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Get a property from the shared store.
+     * @param prop The name of the property to get.
+     * @returns The property if it exists.
      */
-    static uint8Array(source, property, value) {
-        if (!Is.uint8Array(value)) {
-            throw new GuardError(source, "guard.uint8Array", property, value);
+    static get(prop) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const shared = globalThis.__TWIN_SHARED__;
+        if (Is.undefined(shared)) {
+            return;
         }
+        return shared[prop];
     }
     /**
-     * Is the property a function.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @returns True if the value is a function.
-     * @throws GuardError If the value does not match the assertion.
+     * Set the property in the shared store.
+     * @param prop The name of the property to set.
+     * @param value The value to set.
      */
-    static function(source, property, value) {
-        if (!Is.function(value)) {
-            throw new GuardError(source, "guard.function", property, value);
+    static set(prop, value) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (Is.undefined(globalThis.__TWIN_SHARED__)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis.__TWIN_SHARED__ = {};
         }
-        return true;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis.__TWIN_SHARED__[prop] = value;
     }
     /**
-     * Is the property a string formatted as an email address.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Remove a property from the shared store.
+     * @param prop The name of the property to remove.
      */
-    static email(source, property, value) {
-        if (!Is.email(value)) {
-            throw new GuardError(source, "guard.email", property, value);
+    static remove(prop) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const shared = globalThis.__TWIN_SHARED__;
+        if (!Is.undefined(shared)) {
+            delete shared[prop];
         }
     }
 }
@@ -1776,11 +2019,6 @@ class Factory {
      * @internal
      */
     static _CLASS_NAME = "Factory";
-    /**
-     * Store all the created factories.
-     * @internal
-     */
-    static _factories = {};
     /**
      * Type name for the instances.
      * @internal
@@ -1834,10 +2072,41 @@ class Factory {
      * @returns The factory instance.
      */
     static createFactory(typeName, autoInstance = false, matcher) {
-        if (Is.undefined(Factory._factories[typeName])) {
-            Factory._factories[typeName] = new Factory(typeName, autoInstance, matcher);
+        const factories = Factory.getFactories();
+        if (Is.undefined(factories[typeName])) {
+            factories[typeName] = new Factory(typeName, autoInstance, matcher);
+        }
+        return factories[typeName];
+    }
+    /**
+     * Get all the factories.
+     * @returns All the factories.
+     */
+    static getFactories() {
+        let factories = SharedStore.get("factories");
+        if (Is.undefined(factories)) {
+            factories = {};
+            SharedStore.set("factories", factories);
+        }
+        return factories;
+    }
+    /**
+     * Reset all the factories, which removes any created instances, but not the registrations.
+     */
+    static resetFactories() {
+        const factories = Factory.getFactories();
+        for (const typeName in factories) {
+            factories[typeName].reset();
+        }
+    }
+    /**
+     * Clear all the factories, which removes anything registered with the factories.
+     */
+    static clearFactories() {
+        const factories = Factory.getFactories();
+        for (const typeName in factories) {
+            factories[typeName].clear();
         }
-        return Factory._factories[typeName];
     }
     /**
      * Register a new generator.
@@ -1883,6 +2152,7 @@ class Factory {
      * @throws GeneralError if no item exists to get.
      */
     get(name) {
+        Guards.stringValue(Factory._CLASS_NAME, "name", name);
         const instance = this.getIfExists(name);
         if (!instance) {
             throw new GeneralError(Factory._CLASS_NAME, "noGet", {
@@ -1898,6 +2168,9 @@ class Factory {
      * @returns An instance of the item or undefined if it does not exist.
      */
     getIfExists(name) {
+        if (Is.empty(name)) {
+            return;
+        }
         Guards.stringValue(Factory._CLASS_NAME, "name", name);
         const matchName = this._matcher(Object.keys(this._generators), name);
         if (Is.stringValue(matchName) && this._generators[matchName]) {
@@ -1910,7 +2183,7 @@ class Factory {
         }
     }
     /**
-     * Reset all the instances.
+     * Remove all the instances and leave the generators intact.
      */
     reset() {
         for (const name in this._generators) {
@@ -1918,6 +2191,14 @@ class Factory {
         }
         this._instances = {};
     }
+    /**
+     * Remove all the instances and the generators.
+     */
+    clear() {
+        this._instances = {};
+        this._generators = {};
+        this._orderCounter = 0;
+    }
     /**
      * Get all the instances as a map.
      * @returns The instances as a map.
@@ -1951,1060 +2232,1402 @@ class Factory {
                 order: this._generators[generator].order
             });
         }
-        return orderedNames.sort((a, b) => a.order - b.order).map(o => o.name);
+        return orderedNames.sort((a, b) => a.order - b.order).map(o => o.name);
+    }
+    /**
+     * Does the factory contain the name.
+     * @param name The name of the instance to find.
+     * @returns True if the factory has a matching name.
+     */
+    hasName(name) {
+        Guards.stringValue(Factory._CLASS_NAME, "name", name);
+        return Is.stringValue(this._matcher(Object.keys(this._generators), name));
+    }
+    /**
+     * Remove any instances of the given name.
+     * @param name The name of the instances to remove.
+     * @internal
+     */
+    removeInstance(name) {
+        delete this._instances[name];
+    }
+    /**
+     * Match the requested name to the generator name.
+     * @param names The list of names for all the generators.
+     * @param name The name to match.
+     * @returns The matched name or undefined if no match.
+     * @internal
+     */
+    defaultMatcher(names, name) {
+        return this._generators[name] ? name : undefined;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Factory for creating implementation of component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const ComponentFactory = Factory.createFactory("component");
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
+/**
+ * Convert arrays to and from different formats.
+ */
+class Converter {
+    /**
+     * Lookup table for encoding.
+     * @internal
+     */
+    static _ENCODE_LOOKUP;
+    /**
+     * Lookup table for decoding.
+     * @internal
+     */
+    static _DECODE_LOOKUP;
+    /**
+     * Encode a raw array to UTF8 string.
+     * @param array The bytes to encode.
+     * @param startIndex The index to start in the bytes.
+     * @param length The length of bytes to read.
+     * @returns The array formatted as UTF8.
+     */
+    static bytesToUtf8(array, startIndex, length) {
+        const start = startIndex ?? 0;
+        const len = length ?? array.length;
+        let str = "";
+        for (let i = start; i < start + len; i++) {
+            const value = array[i];
+            if (value < 0x80) {
+                str += String.fromCharCode(value);
+            }
+            else if (value > 0xbf && value < 0xe0) {
+                str += String.fromCharCode(((value & 0x1f) << 6) | (array[i + 1] & 0x3f));
+                i += 1;
+            }
+            else if (value > 0xdf && value < 0xf0) {
+                str += String.fromCharCode(((value & 0x0f) << 12) | ((array[i + 1] & 0x3f) << 6) | (array[i + 2] & 0x3f));
+                i += 2;
+            }
+            else {
+                // surrogate pair
+                const charCode = (((value & 0x07) << 18) |
+                    ((array[i + 1] & 0x3f) << 12) |
+                    ((array[i + 2] & 0x3f) << 6) |
+                    (array[i + 3] & 0x3f)) -
+                    0x010000;
+                str += String.fromCharCode((charCode >> 10) | 0xd800, (charCode & 0x03ff) | 0xdc00);
+                i += 3;
+            }
+        }
+        return str;
+    }
+    /**
+     * Convert a UTF8 string to raw array.
+     * @param utf8 The text to decode.
+     * @returns The array.
+     */
+    static utf8ToBytes(utf8) {
+        const bytes = [];
+        for (let i = 0; i < utf8.length; i++) {
+            let charCode = utf8.charCodeAt(i);
+            if (charCode < 0x80) {
+                bytes.push(charCode);
+            }
+            else if (charCode < 0x800) {
+                bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));
+            }
+            else if (charCode < 0xd800 || charCode >= 0xe000) {
+                bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+            }
+            else {
+                // surrogate pair
+                i++;
+                // UTF-16 encodes 0x10000-0x10FFFF by
+                // subtracting 0x10000 and splitting the
+                // 20 bits of 0x0-0xFFFFF into two halves
+                charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (utf8.charCodeAt(i) & 0x3ff));
+                bytes.push(0xf0 | (charCode >> 18), 0x80 | ((charCode >> 12) & 0x3f), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+            }
+        }
+        return Uint8Array.from(bytes);
+    }
+    /**
+     * Encode a raw array to hex string.
+     * @param array The bytes to encode.
+     * @param includePrefix Include the 0x prefix on the returned hex.
+     * @param startIndex The index to start in the bytes.
+     * @param length The length of bytes to read.
+     * @param reverse Reverse the combine direction.
+     * @returns The array formatted as hex.
+     */
+    static bytesToHex(array, includePrefix = false, startIndex, length, reverse) {
+        let hex = "";
+        this.buildHexLookups();
+        if (Converter._ENCODE_LOOKUP) {
+            const len = length ?? array.length;
+            const start = startIndex ?? 0;
+            if (reverse) {
+                for (let i = 0; i < len; i++) {
+                    hex = Converter._ENCODE_LOOKUP[array[start + i]] + hex;
+                }
+            }
+            else {
+                for (let i = 0; i < len; i++) {
+                    hex += Converter._ENCODE_LOOKUP[array[start + i]];
+                }
+            }
+        }
+        return includePrefix ? HexHelper.addPrefix(hex) : hex;
+    }
+    /**
+     * Decode a hex string to raw array.
+     * @param hex The hex to decode.
+     * @param reverse Store the characters in reverse.
+     * @returns The array.
+     */
+    static hexToBytes(hex, reverse) {
+        const strippedHex = HexHelper.stripPrefix(hex);
+        const sizeof = strippedHex.length >> 1;
+        const length = sizeof << 1;
+        const array = new Uint8Array(sizeof);
+        this.buildHexLookups();
+        if (Converter._DECODE_LOOKUP) {
+            let i = 0;
+            let n = 0;
+            while (i < length) {
+                array[n++] =
+                    (Converter._DECODE_LOOKUP[strippedHex.charCodeAt(i++)] << 4) |
+                        Converter._DECODE_LOOKUP[strippedHex.charCodeAt(i++)];
+            }
+            if (reverse) {
+                array.reverse();
+            }
+        }
+        return array;
     }
     /**
-     * Does the factory contain the name.
-     * @param name The name of the instance to find.
-     * @returns True if the factory has a matching name.
+     * Convert the UTF8 to hex.
+     * @param utf8 The text to convert.
+     * @param includePrefix Include the 0x prefix on the returned hex.
+     * @returns The hex version of the bytes.
      */
-    hasName(name) {
-        Guards.stringValue(Factory._CLASS_NAME, "name", name);
-        return Is.stringValue(this._matcher(Object.keys(this._generators), name));
+    static utf8ToHex(utf8, includePrefix = false) {
+        const hex = Converter.bytesToHex(Converter.utf8ToBytes(utf8));
+        return includePrefix ? HexHelper.addPrefix(hex) : hex;
     }
     /**
-     * Remove any instances of the given name.
-     * @param name The name of the instances to remove.
-     * @internal
+     * Convert the hex text to text.
+     * @param hex The hex to convert.
+     * @returns The UTF8 version of the bytes.
      */
-    removeInstance(name) {
-        delete this._instances[name];
+    static hexToUtf8(hex) {
+        return Converter.bytesToUtf8(Converter.hexToBytes(HexHelper.stripPrefix(hex)));
     }
     /**
-     * Match the requested name to the generator name.
-     * @param names The list of names for all the generators.
-     * @param name The name to match.
-     * @returns The matched name or undefined if no match.
-     * @internal
+     * Convert bytes to binary string.
+     * @param bytes The bytes to convert.
+     * @returns A binary string of the bytes.
      */
-    defaultMatcher(names, name) {
-        return this._generators[name] ? name : undefined;
+    static bytesToBinary(bytes) {
+        const b = [];
+        for (let i = 0; i < bytes.length; i++) {
+            b.push(bytes[i].toString(2).padStart(8, "0"));
+        }
+        return b.join("");
     }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Factory for creating implementation of component types.
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-const ComponentFactory = Factory.createFactory("component");
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to help with arrays.
- */
-class ArrayHelper {
     /**
-     * Do the two arrays match.
-     * @param arr1 The first array.
-     * @param arr2 The second array.
-     * @returns True if both arrays are empty of have the same values.
+     * Convert a binary string to bytes.
+     * @param binary The binary string.
+     * @returns The bytes.
      */
-    static matches(arr1, arr2) {
-        if (Is.empty(arr1) && Is.empty(arr2)) {
-            return true;
-        }
-        if (!((Is.array(arr1) && Is.array(arr2)) || (Is.typedArray(arr1) && Is.typedArray(arr2)))) {
-            return false;
-        }
-        if (arr1.length !== arr2.length) {
-            return false;
-        }
-        for (let i = 0; i < arr1.length; i++) {
-            if (arr1[i] !== arr2[i]) {
-                return false;
-            }
+    static binaryToBytes(binary) {
+        const bytes = new Uint8Array(Math.ceil(binary.length / 8));
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = Number.parseInt(binary.slice(i * 8, (i + 1) * 8), 2);
         }
-        return true;
+        return bytes;
     }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to perform internationalization.
- */
-class I18n {
-    /**
-     * The default translation.
-     */
-    static DEFAULT_LOCALE = "en";
-    /**
-     * Dictionaries for lookups.
-     * @internal
-     */
-    static _localeDictionaries = {};
-    /**
-     * The current locale.
-     * @internal
-     */
-    static _currentLocale = I18n.DEFAULT_LOCALE;
-    /**
-     * Change handler for the locale being updated.
-     * @internal
-     */
-    static _localeChangedHandlers = {};
     /**
-     * Change handler for the dictionaries being updated.
-     * @internal
+     * Convert bytes to base64 string.
+     * @param bytes The bytes to convert.
+     * @returns A base64 string of the bytes.
      */
-    static _dictionaryChangedHandlers = {};
+    static bytesToBase64(bytes) {
+        return Base64.encode(bytes);
+    }
     /**
-     * Set the locale.
-     * @param locale The new locale.
+     * Convert a base64 string to bytes.
+     * @param base64 The base64 string.
+     * @returns The bytes.
      */
-    static setLocale(locale) {
-        I18n._currentLocale = locale;
-        for (const callback in I18n._localeChangedHandlers) {
-            I18n._localeChangedHandlers[callback](I18n._currentLocale);
-        }
+    static base64ToBytes(base64) {
+        return Base64.decode(base64);
     }
     /**
-     * Get the locale.
-     * @returns The current locale.
+     * Convert bytes to base64 url string.
+     * @param bytes The bytes to convert.
+     * @returns A base64 url string of the bytes.
      */
-    static getLocale() {
-        return I18n._currentLocale;
+    static bytesToBase64Url(bytes) {
+        return Base64Url.encode(bytes);
     }
     /**
-     * Add a locale dictionary.
-     * @param locale The locale.
-     * @param dictionary The dictionary to add.
+     * Convert a base64 url string to bytes.
+     * @param base64Url The base64 url string.
+     * @returns The bytes.
      */
-    static addDictionary(locale, dictionary) {
-        const mergedKeys = {};
-        I18n.flattenTranslationKeys(dictionary, "", mergedKeys);
-        I18n._localeDictionaries[locale] = mergedKeys;
-        for (const callback in I18n._dictionaryChangedHandlers) {
-            I18n._dictionaryChangedHandlers[callback](I18n._currentLocale);
-        }
+    static base64UrlToBytes(base64Url) {
+        return Base64Url.decode(base64Url);
     }
     /**
-     * Get a locale dictionary.
-     * @param locale The locale.
-     * @returns The dictionary of undefined if it does not exist.
+     * Convert bytes to base58 string.
+     * @param bytes The bytes to convert.
+     * @returns A base58 string of the bytes.
      */
-    static getDictionary(locale) {
-        return I18n._localeDictionaries[locale];
+    static bytesToBase58(bytes) {
+        return Base58.encode(bytes);
     }
     /**
-     * Get all the locale dictionaries.
-     * @returns The dictionaries.
+     * Convert a base58 string to bytes.
+     * @param base58 The base58 string.
+     * @returns The bytes.
      */
-    static getAllDictionaries() {
-        return I18n._localeDictionaries;
+    static base58ToBytes(base58) {
+        return Base58.decode(base58);
     }
     /**
-     * Add a locale changed handler.
-     * @param id The id of the handler.
-     * @param handler The handler to add.
+     * Build the static lookup tables.
+     * @internal
      */
-    static addLocaleHandler(id, handler) {
-        I18n._localeChangedHandlers[id] = handler;
+    static buildHexLookups() {
+        if (!Converter._ENCODE_LOOKUP || !Converter._DECODE_LOOKUP) {
+            const alphabet = "0123456789abcdef";
+            Converter._ENCODE_LOOKUP = [];
+            Converter._DECODE_LOOKUP = [];
+            for (let i = 0; i < 256; i++) {
+                Converter._ENCODE_LOOKUP[i] = alphabet[(i >> 4) & 0xf] + alphabet[i & 0xf];
+                if (i < 16) {
+                    if (i < 10) {
+                        Converter._DECODE_LOOKUP[0x30 + i] = i;
+                    }
+                    else {
+                        Converter._DECODE_LOOKUP[0x61 - 10 + i] = i;
+                    }
+                }
+            }
+        }
     }
+}
+
+/**
+ * Helpers methods for JSON objects.
+ */
+class JsonHelper {
     /**
-     * Remove a locale changed handler.
-     * @param id The id of the handler.
+     * Runtime name for the class.
+     * @internal
      */
-    static removeLocaleHandler(id) {
-        delete I18n._localeChangedHandlers[id];
-    }
+    static _CLASS_NAME = "JsonHelper";
     /**
-     * Add a dictionary changed handler.
-     * @param id The id of the handler.
-     * @param handler The handler to add.
+     * Serializes in canonical format.
+     * Based on https://www.rfc-editor.org/rfc/rfc8785.
+     * @param object The object to be serialized.
+     * @returns The serialized object.
      */
-    static addDictionaryHandler(id, handler) {
-        I18n._dictionaryChangedHandlers[id] = handler;
+    static canonicalize(object) {
+        const buffer = [];
+        if (object === null ||
+            typeof object !== "object" ||
+            ("toJSON" in object && object.toJSON instanceof Function)) {
+            // Primitive data type
+            buffer.push(JSON.stringify(object));
+        }
+        else if (Array.isArray(object)) {
+            // Array maintain element order
+            const parts = [];
+            for (const element of object) {
+                if (element === undefined) {
+                    parts.push("null");
+                }
+                else {
+                    parts.push(JsonHelper.canonicalize(element));
+                }
+            }
+            buffer.push(`[${parts.join(",")}]`);
+        }
+        else {
+            // Object sort properties
+            const props = [];
+            const keys = Object.keys(object).sort();
+            const o = object;
+            for (const key of keys) {
+                if (o[key] !== undefined) {
+                    props.push(`${JSON.stringify(key)}:${JsonHelper.canonicalize(o[key])}`);
+                }
+            }
+            buffer.push(`{${props.join(",")}}`);
+        }
+        return buffer.join("");
     }
     /**
-     * Remove a dictionary changed handler.
-     * @param id The id of the handler.
+     * Creates a RFC 6902 diff set.
+     * Based on https://www.rfc-editor.org/rfc/rfc6902.
+     * @param object1 The first object.
+     * @param object2 The second object.
+     * @returns The list of patches.
      */
-    static removeDictionaryHandler(id) {
-        delete I18n._dictionaryChangedHandlers[id];
+    static diff(object1, object2) {
+        const operations = createPatch(object1, object2);
+        return operations;
     }
     /**
-     * Format a message.
-     * @param key The key of the message to format.
-     * @param values The values to substitute into the message.
-     * @param overrideLocale Override the locale.
-     * @returns The formatted string.
+     * Applies a RFC 6902 diff set to an object.
+     * Based on https://www.rfc-editor.org/rfc/rfc6902.
+     * @param object The object to patch.
+     * @param patches The second object.
+     * @returns The updated object.
+     * @throws GeneralError if the patch fails.
      */
-    static formatMessage(key, values, overrideLocale) {
-        let cl = overrideLocale ?? I18n._currentLocale;
-        if (cl.startsWith("debug-")) {
-            cl = I18n.DEFAULT_LOCALE;
-        }
-        if (!I18n._localeDictionaries[cl]) {
-            return `!!Missing ${cl}`;
-        }
-        if (!I18n._localeDictionaries[cl][key]) {
-            return `!!Missing ${cl}.${key}`;
-        }
-        if (I18n._currentLocale === "debug-k") {
-            return key;
-        }
-        let ret = new IntlMessageFormat(I18n._localeDictionaries[cl][key], cl).format(values);
-        if (I18n._currentLocale === "debug-x") {
-            ret = ret.replace(/[a-z]/g, "x").replace(/[A-Z]/g, "x").replace(/\d/g, "n");
+    static patch(object, patches) {
+        const clone = ObjectHelper.clone(object);
+        const result = applyPatch(clone, patches);
+        for (let i = 0; i < result.length; i++) {
+            if (!Is.empty(result[i])) {
+                throw new GeneralError(JsonHelper._CLASS_NAME, "failedPatch", { index: i }, result[i]);
+            }
         }
-        return ret;
+        return clone;
     }
     /**
-     * Check if the dictionaries have a message for the given key.
-     * @param key The key to check for existence.
-     * @returns True if the key exists.
+     * Stringify the JSON with support for extended data types date/bigint/uint8array.
+     * @param object The object to stringify.
+     * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+     * @returns The stringified object.
      */
-    static hasMessage(key) {
-        return Is.string(I18n._localeDictionaries[I18n._currentLocale]?.[key]);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static stringifyEx(object, space) {
+        // We want to keep the 'this' intact for the replacer
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        return JSON.stringify(object, JsonHelper.stringifyExReplacer, space);
     }
     /**
-     * Flatten the translation property paths for faster lookup.
-     * @param translation The translation to merge.
-     * @param propertyPath The current root path.
-     * @param mergedKeys The merged keys dictionary to populate.
-     * @internal
+     * Parse the JSON string with support for extended data types date/bigint/uint8array.
+     * @param json The object to pause.
+     * @returns The object.
      */
-    static flattenTranslationKeys(translation, propertyPath, mergedKeys) {
-        for (const key in translation) {
-            const val = translation[key];
-            const mergedPath = propertyPath.length > 0 ? `${propertyPath}.${key}` : key;
-            if (Is.string(val)) {
-                mergedKeys[mergedPath] = val;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static parseEx(json) {
+        // We want to keep the 'this' intact for the reviver
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        return JSON.parse(json, JsonHelper.parseExReviver);
+    }
+    /**
+     * Replacer function to handle extended data types.
+     * @param this The object.
+     * @param key The key.
+     * @param value The value.
+     * @returns The value.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static stringifyExReplacer(key, value) {
+        const rawValue = this[key];
+        if (Is.bigint(rawValue)) {
+            return {
+                "@ext": "bigint",
+                value: rawValue.toString()
+            };
+        }
+        else if (Is.date(rawValue)) {
+            return {
+                "@ext": "date",
+                value: rawValue.getTime()
+            };
+        }
+        else if (Is.uint8Array(rawValue)) {
+            return {
+                "@ext": "uint8array",
+                value: Converter.bytesToBase64(rawValue)
+            };
+        }
+        return value;
+    }
+    /**
+     * Reviver function to handle extended data types.
+     * @param this The object.
+     * @param key The key.
+     * @param value The value.
+     * @returns The value.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static parseExReviver(key, value) {
+        if (Is.object(value)) {
+            if (value["@ext"] === "bigint") {
+                return BigInt(value.value);
             }
-            else if (Is.object(val)) {
-                I18n.flattenTranslationKeys(val, mergedPath, mergedKeys);
+            else if (value["@ext"] === "date") {
+                return new Date(value.value);
+            }
+            else if (value["@ext"] === "uint8array") {
+                return Converter.base64ToBytes(value.value);
             }
         }
+        return value;
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
- * Error helper functions.
+ * Class to help with objects.
  */
-class ErrorHelper {
+class ObjectHelper {
     /**
-     * Format Errors and returns just their messages.
-     * @param error The error to format.
-     * @returns The error formatted including any inner errors.
+     * Runtime name for the class.
+     * @internal
      */
-    static formatErrors(error) {
-        return ErrorHelper.localizeErrors(error).map(e => e.message);
-    }
+    static _CLASS_NAME = "ObjectHelper";
     /**
-     * Localize the content of an error and any inner errors.
-     * @param error The error to format.
-     * @returns The localized version of the errors flattened.
+     * Convert an object to bytes.
+     * @param obj The object to convert.
+     * @param format Format the JSON content.
+     * @returns The object as bytes.
      */
-    static localizeErrors(error) {
-        const formattedErrors = [];
-        if (Is.notEmpty(error)) {
-            const errors = BaseError.flatten(error);
-            for (const err of errors) {
-                const errorNameKey = `errorNames.${StringHelper.camelCase(err.name)}`;
-                const errorMessageKey = `error.${err.message}`;
-                // If there is no error message then it is probably
-                // from a 3rd party lib, so don't format it just display
-                const hasErrorName = I18n.hasMessage(errorNameKey);
-                const hasErrorMessage = I18n.hasMessage(errorMessageKey);
-                const localizedError = {
-                    name: I18n.formatMessage(hasErrorName ? errorNameKey : "errorNames.error"),
-                    message: hasErrorMessage
-                        ? I18n.formatMessage(errorMessageKey, err.properties)
-                        : err.message
-                };
-                if (Is.stringValue(err.source)) {
-                    localizedError.source = err.source;
-                }
-                if (Is.stringValue(err.stack)) {
-                    // Remove the first line from the stack traces as they
-                    // just have the error type and message duplicated
-                    const lines = err.stack.split("\n");
-                    lines.shift();
-                    localizedError.stack = lines.join("\n");
-                }
-                const additional = ErrorHelper.formatValidationErrors(err);
-                if (Is.stringValue(additional)) {
-                    localizedError.additional = additional;
-                }
-                formattedErrors.push(localizedError);
-            }
+    static toBytes(obj, format = false) {
+        if (obj === undefined) {
+            return new Uint8Array();
         }
-        return formattedErrors;
+        const json = format ? JSON.stringify(obj, undefined, "\t") : JSON.stringify(obj);
+        return Converter.utf8ToBytes(json);
     }
     /**
-     * Localize the content of an error and any inner errors.
-     * @param error The error to format.
-     * @returns The localized version of the errors flattened.
+     * Convert a bytes to an object.
+     * @param bytes The bytes to convert to an object.
+     * @returns The object.
+     * @throws GeneralError if there was an error parsing the JSON.
      */
-    static formatValidationErrors(error) {
-        if (Is.object(error.properties) &&
-            Object.keys(error.properties).length > 0 &&
-            Is.object(error.properties) &&
-            Is.arrayValue(error.properties.validationFailures)) {
-            const validationErrors = [];
-            for (const validationFailure of error.properties.validationFailures) {
-                const errorI18n = `error.${validationFailure.reason}`;
-                const errorMessage = I18n.hasMessage(errorI18n)
-                    ? I18n.formatMessage(errorI18n, validationFailure.properties)
-                    : errorI18n;
-                let v = `${validationFailure.property}: ${errorMessage}`;
-                if (Is.object(validationFailure.properties) &&
-                    Is.notEmpty(validationFailure.properties.value)) {
-                    v += ` = ${JSON.stringify(validationFailure.properties.value)}`;
-                }
-                validationErrors.push(v);
-            }
-            return validationErrors.join("\n");
+    static fromBytes(bytes) {
+        if (Is.empty(bytes) || bytes.length === 0) {
+            return undefined;
+        }
+        try {
+            const utf8 = Converter.bytesToUtf8(bytes);
+            return JSON.parse(utf8);
+        }
+        catch (err) {
+            throw new GeneralError(ObjectHelper._CLASS_NAME, "failedBytesToJSON", undefined, err);
         }
     }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Coerce an object from one type to another.
- */
-class Coerce {
     /**
-     * Coerce the value to a string.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Make a deep clone of an object.
+     * @param obj The object to clone.
+     * @returns The objects clone.
      */
-    static string(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.string(value)) {
-            return value;
+    static clone(obj) {
+        if (Is.undefined(obj)) {
+            return undefined;
         }
-        if (Is.number(value)) {
-            return value.toString();
+        return structuredClone(obj);
+    }
+    /**
+     * Deep merge objects.
+     * @param obj1 The first object to merge.
+     * @param obj2 The second object to merge.
+     * @returns The combined deep merge of the objects.
+     */
+    static merge(obj1, obj2) {
+        if (Is.empty(obj1)) {
+            return ObjectHelper.clone(obj2);
         }
-        if (Is.boolean(value)) {
-            return value ? "true" : "false";
+        if (Is.empty(obj2)) {
+            return ObjectHelper.clone(obj1);
         }
-        if (Is.date(value)) {
-            return value.toISOString();
+        const obj1Clone = ObjectHelper.clone(obj1);
+        if (Is.object(obj1Clone) && Is.object(obj2)) {
+            const keys = Object.keys(obj2);
+            for (const key of keys) {
+                if (Is.object(obj1Clone[key]) && Is.object(obj2[key])) {
+                    ObjectHelper.propertySet(obj1Clone, key, ObjectHelper.merge(obj1Clone[key], obj2[key]));
+                }
+                else {
+                    ObjectHelper.propertySet(obj1Clone, key, obj2[key]);
+                }
+            }
         }
+        return obj1Clone;
     }
     /**
-     * Coerce the value to a number.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Does one object equal another.
+     * @param obj1 The first object to compare.
+     * @param obj2 The second object to compare.
+     * @param strictPropertyOrder Should the properties be in the same order, defaults to true.
+     * @returns True is the objects are equal.
      */
-    static number(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            return value;
+    static equal(obj1, obj2, strictPropertyOrder) {
+        if (strictPropertyOrder ?? true) {
+            return JSON.stringify(obj1) === JSON.stringify(obj2);
         }
-        if (Is.string(value)) {
-            const parsed = Number.parseFloat(value);
-            if (Is.number(parsed)) {
-                return parsed;
+        return JsonHelper.canonicalize(obj1) === JsonHelper.canonicalize(obj2);
+    }
+    /**
+     * Get the property of an unknown object.
+     * @param obj The object to get the property from.
+     * @param property The property to get, can be separated by dots for nested path.
+     * @returns The property.
+     */
+    static propertyGet(obj, property) {
+        const pathParts = property.split(".");
+        let pathValue = obj;
+        for (const pathPart of pathParts) {
+            // Is the path part numeric i.e. an array index.
+            const arrayMatch = /^(\d+)$/.exec(pathPart);
+            if (arrayMatch) {
+                const arrayIndex = Number.parseInt(arrayMatch[1], 10);
+                if (Is.arrayValue(pathValue) && arrayIndex < pathValue.length) {
+                    // There is no prop name so this is a direct array index on the current object
+                    pathValue = pathValue[arrayIndex];
+                }
+                else {
+                    // Array index for non array object so return
+                    return undefined;
+                }
+            }
+            else if (Is.object(pathValue)) {
+                // No array part in path so assume object sub property
+                pathValue = pathValue[pathPart];
+            }
+            else {
+                return undefined;
             }
         }
-        if (Is.boolean(value)) {
-            return value ? 1 : 0;
+        return pathValue;
+    }
+    /**
+     * Set the property of an unknown object.
+     * @param obj The object to set the property from.
+     * @param property The property to set.
+     * @param value The value to set.
+     * @throws GeneralError if the property target is not an object.
+     */
+    static propertySet(obj, property, value) {
+        const pathParts = property.split(".");
+        let pathValue = obj;
+        let parentObj;
+        for (let i = 0; i < pathParts.length; i++) {
+            const pathPart = pathParts[i];
+            // Is the path part numeric i.e. an array index.
+            const arrayMatch = /^(\d+)$/.exec(pathPart);
+            const arrayIndex = arrayMatch ? Number.parseInt(arrayMatch[1], 10) : -1;
+            if (i === pathParts.length - 1) {
+                // Last part of path so set the value
+                if (arrayIndex >= 0) {
+                    if (Is.array(pathValue)) {
+                        pathValue[arrayIndex] = value;
+                    }
+                    else if (Is.object(pathValue)) {
+                        pathValue[arrayIndex] = value;
+                    }
+                    else {
+                        throw new GeneralError(ObjectHelper._CLASS_NAME, "cannotSetArrayIndex", {
+                            property,
+                            index: arrayIndex
+                        });
+                    }
+                }
+                else if (Is.object(pathValue)) {
+                    pathValue[pathPart] = value;
+                }
+                else {
+                    throw new GeneralError(ObjectHelper._CLASS_NAME, "cannotSetProperty", { property });
+                }
+            }
+            else {
+                parentObj = pathValue;
+                if (Is.object(pathValue)) {
+                    pathValue = pathValue[pathPart];
+                }
+                else if (Is.array(pathValue)) {
+                    pathValue = pathValue[arrayIndex];
+                }
+                if (Is.empty(pathValue)) {
+                    const nextArrayMatch = /^(\d+)$/.exec(pathParts[i + 1]);
+                    const nextArrayIndex = nextArrayMatch ? Number.parseInt(nextArrayMatch[1], 10) : -1;
+                    if (nextArrayIndex >= 0) {
+                        pathValue = [];
+                    }
+                    else {
+                        pathValue = {};
+                    }
+                    if (Is.object(parentObj)) {
+                        parentObj[pathPart] = pathValue;
+                    }
+                    else if (Is.array(parentObj)) {
+                        parentObj[arrayIndex] = pathValue;
+                    }
+                }
+            }
         }
-        if (Is.date(value)) {
-            return value.getTime();
+    }
+    /**
+     * Delete the property of an unknown object.
+     * @param obj The object to set the property from.
+     * @param property The property to set
+     */
+    static propertyDelete(obj, property) {
+        if (Is.object(obj)) {
+            delete obj[property];
         }
     }
     /**
-     * Coerce the value to a bigint.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Extract a property from the object, providing alternative names.
+     * @param obj The object to extract from.
+     * @param propertyNames The possible names for the property.
+     * @param removeProperties Remove the properties from the object, defaults to true.
+     * @returns The property if available.
      */
-    static bigint(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.bigint(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            return BigInt(value);
-        }
-        if (Is.string(value)) {
-            const parsed = Number.parseFloat(value);
-            if (Is.integer(parsed)) {
-                return BigInt(parsed);
+    static extractProperty(obj, propertyNames, removeProperties = true) {
+        let retVal;
+        if (Is.object(obj)) {
+            const names = Is.string(propertyNames) ? [propertyNames] : propertyNames;
+            for (const prop of names) {
+                retVal ??= ObjectHelper.propertyGet(obj, prop);
+                if (removeProperties) {
+                    ObjectHelper.propertyDelete(obj, prop);
+                }
             }
         }
-        if (Is.boolean(value)) {
-            return value ? 1n : 0n;
-        }
+        return retVal;
     }
     /**
-     * Coerce the value to a boolean.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Pick a subset of properties from an object.
+     * @param obj The object to pick the properties from.
+     * @param keys The property keys to pick.
+     * @returns The partial object.
      */
-    static boolean(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.boolean(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            // eslint-disable-next-line no-unneeded-ternary
-            return value ? true : false;
-        }
-        if (Is.string(value)) {
-            if (/true/i.test(value)) {
-                return true;
-            }
-            if (/false/i.test(value)) {
-                return false;
+    static pick(obj, keys) {
+        if (Is.object(obj) && Is.arrayValue(keys)) {
+            const result = {};
+            for (const key of keys) {
+                result[key] = obj[key];
             }
+            return result;
         }
+        return obj;
     }
     /**
-     * Coerce the value to a date.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Omit a subset of properties from an object.
+     * @param obj The object to omit the properties from.
+     * @param keys The property keys to omit.
+     * @returns The partial object.
      */
-    static date(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.date(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            return new Date(value);
-        }
-        if (Is.string(value)) {
-            const dt = new Date(value);
-            if (!Number.isNaN(dt.getTime())) {
-                const utc = Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate());
-                return new Date(utc);
+    static omit(obj, keys) {
+        if (Is.object(obj) && Is.arrayValue(keys)) {
+            const result = { ...obj };
+            for (const key of keys) {
+                delete result[key];
             }
+            return result;
         }
+        return obj;
     }
     /**
-     * Coerce the value to a date/time.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Converter the non JSON primitives to extended types.
+     * @param obj The object to convert.
+     * @returns The object with extended properties.
      */
-    static dateTime(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.date(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            return new Date(value);
-        }
-        if (Is.string(value)) {
-            const dt = new Date(value);
-            if (!Number.isNaN(dt.getTime())) {
-                const utc = Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(), dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds());
-                return new Date(utc);
-            }
-        }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static toExtended(obj) {
+        const jsonExtended = JsonHelper.stringifyEx(obj);
+        return JSON.parse(jsonExtended);
     }
     /**
-     * Coerce the value to a time.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Converter the extended types to non JSON primitives.
+     * @param obj The object to convert.
+     * @returns The object with regular properties.
      */
-    static time(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.date(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            const dt = new Date(value);
-            dt.setFullYear(1970, 0, 1);
-            return dt;
-        }
-        if (Is.string(value)) {
-            const dt = new Date(value);
-            if (!Number.isNaN(dt.getTime())) {
-                const utc = Date.UTC(1970, 0, 1, dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds());
-                return new Date(utc);
-            }
-        }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromExtended(obj) {
+        const jsonExtended = JsonHelper.stringifyEx(obj);
+        return JsonHelper.parseEx(jsonExtended);
     }
     /**
-     * Coerce the value to an object.
-     * @param value The value to coerce.
-     * @throws TypeError If the value can not be coerced.
-     * @returns The value if it can be coerced.
+     * Remove empty properties from an object.
+     * @param obj The object to remove the empty properties from.
+     * @param options The options for the removal.
+     * @param options.removeUndefined Remove undefined properties, defaults to true.
+     * @param options.removeNull Remove null properties, defaults to false.
+     * @returns The object with empty properties removed.
      */
-    static object(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.object(value)) {
-            return value;
+    static removeEmptyProperties(obj, options) {
+        if (Is.object(obj)) {
+            const removeUndefined = options?.removeUndefined ?? true;
+            const removeNull = options?.removeNull ?? false;
+            const newObj = {};
+            const keys = Object.keys(obj);
+            for (const key of keys) {
+                if (!((removeUndefined && Is.undefined(obj[key])) || (removeNull && Is.null(obj[key])))) {
+                    newObj[key] = ObjectHelper.removeEmptyProperties(obj[key], options);
+                }
+            }
+            return newObj;
         }
-        if (Is.stringValue(value)) {
-            try {
-                return JSON.parse(value);
+        else if (Is.array(obj)) {
+            const arr = [];
+            for (const element of obj) {
+                arr.push(ObjectHelper.removeEmptyProperties(element, options));
             }
-            catch { }
+            return arr;
         }
+        return obj;
     }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Class to help with filenames.
+ * Environment variable helper.
  */
-class FilenameHelper {
-    /**
-     * Replaces any unsafe characters in the filename.
-     * @param filename The filename to make safe.
-     * @returns The safe filename.
-     */
-    static safeFilename(filename) {
-        let safe = Coerce.string(filename);
-        if (Is.empty(safe)) {
-            return "";
+class EnvHelper {
+    /**
+     * Get the environment variable as an object with camel cased names.
+     * @param envVars The environment variables.
+     * @param prefix The prefix of the environment variables, if not provided gets all.
+     * @returns The object with camel cased names.
+     */
+    static envToJson(envVars, prefix) {
+        const result = {};
+        if (!Is.empty(envVars)) {
+            if (Is.empty(prefix)) {
+                for (const envVar in envVars) {
+                    if (Is.stringValue(envVars[envVar])) {
+                        const camelCaseName = StringHelper.camelCase(envVar.toLowerCase());
+                        ObjectHelper.propertySet(result, camelCaseName, envVars[envVar]);
+                    }
+                }
+            }
+            else {
+                for (const envVar in envVars) {
+                    if (envVar.startsWith(prefix) && Is.stringValue(envVars[envVar])) {
+                        const camelCaseName = StringHelper.camelCase(envVar.replace(prefix, "").toLowerCase());
+                        ObjectHelper.propertySet(result, camelCaseName, envVars[envVar]);
+                    }
+                }
+            }
         }
-        // Common non filename characters
-        safe = safe.replace(/["*/:<>?\\|]/g, "_");
-        // Windows non filename characters
-        safe = safe.replace(/^(con|prn|aux|nul|com\d|lpt\d)$/i, "_");
-        // Control characters
-        safe = safe.replace(/[\u0000-\u001F\u0080-\u009F]/g, "_");
-        // Relative paths
-        safe = safe.replace(/^\.+/, "_");
-        // Trailing periods
-        safe = safe.replace(/\.+$/, "");
-        return safe;
+        return result;
     }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Helpers methods for JSON objects.
+ * Class to perform internationalization.
  */
-class JsonHelper {
+class I18n {
     /**
-     * Serializes in canonical format.
-     * Based on https://www.rfc-editor.org/rfc/rfc8785.
-     * @param object The object to be serialized.
-     * @returns The serialized object.
+     * The default translation.
      */
-    static canonicalize(object) {
-        const buffer = [];
-        if (object === null ||
-            typeof object !== "object" ||
-            ("toJSON" in object && object.toJSON instanceof Function)) {
-            // Primitive data type
-            buffer.push(JSON.stringify(object));
-        }
-        else if (Array.isArray(object)) {
-            // Array maintain element order
-            const parts = [];
-            for (const element of object) {
-                if (element === undefined) {
-                    parts.push("null");
-                }
-                else {
-                    parts.push(JsonHelper.canonicalize(element));
-                }
-            }
-            buffer.push(`[${parts.join(",")}]`);
+    static DEFAULT_LOCALE = "en";
+    /**
+     * Set the locale.
+     * @param locale The new locale.
+     */
+    static setLocale(locale) {
+        const i18nShared = I18n.getI18nShared();
+        i18nShared.currentLocale = locale;
+        for (const callback in i18nShared.localeChangedHandlers) {
+            i18nShared.localeChangedHandlers[callback](i18nShared.currentLocale);
         }
-        else {
-            // Object sort properties
-            const props = [];
-            const keys = Object.keys(object).sort();
-            const o = object;
-            for (const key of keys) {
-                if (o[key] !== undefined) {
-                    props.push(`${JSON.stringify(key)}:${JsonHelper.canonicalize(o[key])}`);
-                }
-            }
-            buffer.push(`{${props.join(",")}}`);
+    }
+    /**
+     * Get the locale.
+     * @returns The current locale.
+     */
+    static getLocale() {
+        const i18nShared = I18n.getI18nShared();
+        return i18nShared.currentLocale;
+    }
+    /**
+     * Add a locale dictionary.
+     * @param locale The locale.
+     * @param dictionary The dictionary to add.
+     */
+    static addDictionary(locale, dictionary) {
+        const i18nShared = I18n.getI18nShared();
+        const mergedKeys = {};
+        I18n.flattenTranslationKeys(dictionary, "", mergedKeys);
+        i18nShared.localeDictionaries[locale] = mergedKeys;
+        for (const callback in i18nShared.dictionaryChangedHandlers) {
+            i18nShared.dictionaryChangedHandlers[callback](i18nShared.currentLocale);
         }
-        return buffer.join("");
     }
     /**
-     * Creates a RFC 6902 diff set.
-     * Based on https://www.rfc-editor.org/rfc/rfc6902.
-     * @param object1 The first object.
-     * @param object2 The second object.
-     * @returns The list of patches.
+     * Get a locale dictionary.
+     * @param locale The locale.
+     * @returns The dictionary of undefined if it does not exist.
      */
-    static diff(object1, object2) {
-        const operations = createPatch(object1, object2);
-        return operations;
+    static getDictionary(locale) {
+        const i18nShared = I18n.getI18nShared();
+        return i18nShared.localeDictionaries[locale];
     }
     /**
-     * Applies a RFC 6902 diff set to an object.
-     * Based on https://www.rfc-editor.org/rfc/rfc6902.
-     * @param object The object to patch.
-     * @param patches The second object.
-     * @returns The updated object.
+     * Get all the locale dictionaries.
+     * @returns The dictionaries.
      */
-    static patch(object, patches) {
-        return applyPatch(object, patches);
+    static getAllDictionaries() {
+        const i18nShared = I18n.getI18nShared();
+        return i18nShared.localeDictionaries;
     }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
-/**
- * Convert arrays to and from different formats.
- */
-class Converter {
     /**
-     * Lookup table for encoding.
-     * @internal
+     * Add a locale changed handler.
+     * @param id The id of the handler.
+     * @param handler The handler to add.
      */
-    static _ENCODE_LOOKUP;
+    static addLocaleHandler(id, handler) {
+        const i18nShared = I18n.getI18nShared();
+        i18nShared.localeChangedHandlers[id] = handler;
+    }
     /**
-     * Lookup table for decoding.
-     * @internal
+     * Remove a locale changed handler.
+     * @param id The id of the handler.
      */
-    static _DECODE_LOOKUP;
+    static removeLocaleHandler(id) {
+        const i18nShared = I18n.getI18nShared();
+        delete i18nShared.localeChangedHandlers[id];
+    }
     /**
-     * Encode a raw array to UTF8 string.
-     * @param array The bytes to encode.
-     * @param startIndex The index to start in the bytes.
-     * @param length The length of bytes to read.
-     * @returns The array formatted as UTF8.
+     * Add a dictionary changed handler.
+     * @param id The id of the handler.
+     * @param handler The handler to add.
      */
-    static bytesToUtf8(array, startIndex, length) {
-        const start = startIndex ?? 0;
-        const len = length ?? array.length;
-        let str = "";
-        for (let i = start; i < start + len; i++) {
-            const value = array[i];
-            if (value < 0x80) {
-                str += String.fromCharCode(value);
-            }
-            else if (value > 0xbf && value < 0xe0) {
-                str += String.fromCharCode(((value & 0x1f) << 6) | (array[i + 1] & 0x3f));
-                i += 1;
-            }
-            else if (value > 0xdf && value < 0xf0) {
-                str += String.fromCharCode(((value & 0x0f) << 12) | ((array[i + 1] & 0x3f) << 6) | (array[i + 2] & 0x3f));
-                i += 2;
-            }
-            else {
-                // surrogate pair
-                const charCode = (((value & 0x07) << 18) |
-                    ((array[i + 1] & 0x3f) << 12) |
-                    ((array[i + 2] & 0x3f) << 6) |
-                    (array[i + 3] & 0x3f)) -
-                    0x010000;
-                str += String.fromCharCode((charCode >> 10) | 0xd800, (charCode & 0x03ff) | 0xdc00);
-                i += 3;
-            }
+    static addDictionaryHandler(id, handler) {
+        const i18nShared = I18n.getI18nShared();
+        i18nShared.dictionaryChangedHandlers[id] = handler;
+    }
+    /**
+     * Remove a dictionary changed handler.
+     * @param id The id of the handler.
+     */
+    static removeDictionaryHandler(id) {
+        const i18nShared = I18n.getI18nShared();
+        delete i18nShared.dictionaryChangedHandlers[id];
+    }
+    /**
+     * Format a message.
+     * @param key The key of the message to format.
+     * @param values The values to substitute into the message.
+     * @param overrideLocale Override the locale.
+     * @returns The formatted string.
+     */
+    static formatMessage(key, values, overrideLocale) {
+        const i18nShared = I18n.getI18nShared();
+        let cl = overrideLocale ?? i18nShared.currentLocale;
+        if (cl.startsWith("debug-")) {
+            cl = I18n.DEFAULT_LOCALE;
         }
-        return str;
+        if (!i18nShared.localeDictionaries[cl]) {
+            return `!!Missing ${cl}`;
+        }
+        if (!i18nShared.localeDictionaries[cl][key]) {
+            return `!!Missing ${cl}.${key}`;
+        }
+        if (i18nShared.currentLocale === "debug-k") {
+            return key;
+        }
+        let ret = new IntlMessageFormat(i18nShared.localeDictionaries[cl][key], cl).format(values);
+        if (i18nShared.currentLocale === "debug-x") {
+            ret = ret.replace(/[a-z]/g, "x").replace(/[A-Z]/g, "x").replace(/\d/g, "n");
+        }
+        return ret;
     }
     /**
-     * Convert a UTF8 string to raw array.
-     * @param utf8 The text to decode.
-     * @returns The array.
+     * Check if the dictionaries have a message for the given key.
+     * @param key The key to check for existence.
+     * @returns True if the key exists.
      */
-    static utf8ToBytes(utf8) {
-        const bytes = [];
-        for (let i = 0; i < utf8.length; i++) {
-            let charCode = utf8.charCodeAt(i);
-            if (charCode < 0x80) {
-                bytes.push(charCode);
-            }
-            else if (charCode < 0x800) {
-                bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));
-            }
-            else if (charCode < 0xd800 || charCode >= 0xe000) {
-                bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+    static hasMessage(key) {
+        const i18nShared = I18n.getI18nShared();
+        return Is.string(i18nShared.localeDictionaries[i18nShared.currentLocale]?.[key]);
+    }
+    /**
+     * Flatten the translation property paths for faster lookup.
+     * @param translation The translation to merge.
+     * @param propertyPath The current root path.
+     * @param mergedKeys The merged keys dictionary to populate.
+     * @internal
+     */
+    static flattenTranslationKeys(translation, propertyPath, mergedKeys) {
+        for (const key in translation) {
+            const val = translation[key];
+            const mergedPath = propertyPath.length > 0 ? `${propertyPath}.${key}` : key;
+            if (Is.string(val)) {
+                mergedKeys[mergedPath] = val;
             }
-            else {
-                // surrogate pair
-                i++;
-                // UTF-16 encodes 0x10000-0x10FFFF by
-                // subtracting 0x10000 and splitting the
-                // 20 bits of 0x0-0xFFFFF into two halves
-                charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (utf8.charCodeAt(i) & 0x3ff));
-                bytes.push(0xf0 | (charCode >> 18), 0x80 | ((charCode >> 12) & 0x3f), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+            else if (Is.object(val)) {
+                I18n.flattenTranslationKeys(val, mergedPath, mergedKeys);
             }
         }
-        return Uint8Array.from(bytes);
     }
     /**
-     * Encode a raw array to hex string.
-     * @param array The bytes to encode.
-     * @param includePrefix Include the 0x prefix on the returned hex.
-     * @param startIndex The index to start in the bytes.
-     * @param length The length of bytes to read.
-     * @param reverse Reverse the combine direction.
-     * @returns The array formatted as hex.
+     * Get the I18n shared data.
+     * @returns The I18n shared data.
+     * @internal
      */
-    static bytesToHex(array, includePrefix = false, startIndex, length, reverse) {
-        let hex = "";
-        this.buildHexLookups();
-        if (Converter._ENCODE_LOOKUP) {
-            const len = length ?? array.length;
-            const start = startIndex ?? 0;
-            if (reverse) {
-                for (let i = 0; i < len; i++) {
-                    hex = Converter._ENCODE_LOOKUP[array[start + i]] + hex;
+    static getI18nShared() {
+        let i18nShared = SharedStore.get("i18n");
+        if (Is.undefined(i18nShared)) {
+            i18nShared = {
+                localeDictionaries: {},
+                currentLocale: I18n.DEFAULT_LOCALE,
+                localeChangedHandlers: {},
+                dictionaryChangedHandlers: {}
+            };
+            SharedStore.set("i18n", i18nShared);
+        }
+        return i18nShared;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Error helper functions.
+ */
+class ErrorHelper {
+    /**
+     * Format Errors and returns just their messages.
+     * @param error The error to format.
+     * @param includeDetails Whether to include error details, defaults to false.
+     * @returns The error formatted including any causes errors.
+     */
+    static formatErrors(error, includeDetails) {
+        const localizedErrors = ErrorHelper.localizeErrors(error);
+        if (includeDetails ?? false) {
+            const output = [];
+            for (const err of localizedErrors) {
+                let detailedError = err.message;
+                if (Is.stringValue(err.stack)) {
+                    detailedError += `\n${err.stack}`;
                 }
+                output.push(detailedError);
             }
-            else {
-                for (let i = 0; i < len; i++) {
-                    hex += Converter._ENCODE_LOOKUP[array[start + i]];
+            return output;
+        }
+        return localizedErrors.map(e => e.message);
+    }
+    /**
+     * Localize the content of an error and any causes.
+     * @param error The error to format.
+     * @returns The localized version of the errors flattened.
+     */
+    static localizeErrors(error) {
+        const formattedErrors = [];
+        if (Is.notEmpty(error)) {
+            const errors = BaseError.flatten(error);
+            for (const err of errors) {
+                const errorNameKey = `errorNames.${StringHelper.camelCase(err.name)}`;
+                const errorMessageKey = `error.${err.message}`;
+                // If there is no error message then it is probably
+                // from a 3rd party lib, so don't format it just display
+                const hasErrorName = I18n.hasMessage(errorNameKey);
+                const hasErrorMessage = I18n.hasMessage(errorMessageKey);
+                const localizedError = {
+                    name: I18n.formatMessage(hasErrorName ? errorNameKey : "errorNames.error"),
+                    message: hasErrorMessage
+                        ? I18n.formatMessage(errorMessageKey, err.properties)
+                        : err.message
+                };
+                if (Is.stringValue(err.source)) {
+                    localizedError.source = err.source;
+                }
+                if (Is.stringValue(err.stack)) {
+                    // Remove the first line from the stack traces as they
+                    // just have the error type and message duplicated
+                    const lines = err.stack.split("\n");
+                    lines.shift();
+                    localizedError.stack = lines.join("\n");
+                }
+                const additional = ErrorHelper.formatValidationErrors(err);
+                if (Is.stringValue(additional)) {
+                    localizedError.additional = additional;
                 }
+                formattedErrors.push(localizedError);
             }
         }
-        return includePrefix ? HexHelper.addPrefix(hex) : hex;
+        return formattedErrors;
     }
     /**
-     * Decode a hex string to raw array.
-     * @param hex The hex to decode.
-     * @param reverse Store the characters in reverse.
-     * @returns The array.
+     * Localize the content of an error and any causes.
+     * @param error The error to format.
+     * @returns The localized version of the errors flattened.
      */
-    static hexToBytes(hex, reverse) {
-        const strippedHex = HexHelper.stripPrefix(hex);
-        const sizeof = strippedHex.length >> 1;
-        const length = sizeof << 1;
-        const array = new Uint8Array(sizeof);
-        this.buildHexLookups();
-        if (Converter._DECODE_LOOKUP) {
-            let i = 0;
-            let n = 0;
-            while (i < length) {
-                array[n++] =
-                    (Converter._DECODE_LOOKUP[strippedHex.charCodeAt(i++)] << 4) |
-                        Converter._DECODE_LOOKUP[strippedHex.charCodeAt(i++)];
-            }
-            if (reverse) {
-                array.reverse();
+    static formatValidationErrors(error) {
+        if (Is.object(error.properties) &&
+            Object.keys(error.properties).length > 0 &&
+            Is.object(error.properties) &&
+            Is.arrayValue(error.properties.validationFailures)) {
+            const validationErrors = [];
+            for (const validationFailure of error.properties.validationFailures) {
+                const errorI18n = `error.${validationFailure.reason}`;
+                const errorMessage = I18n.hasMessage(errorI18n)
+                    ? I18n.formatMessage(errorI18n, validationFailure.properties)
+                    : errorI18n;
+                let v = `${validationFailure.property}: ${errorMessage}`;
+                if (Is.object(validationFailure.properties) &&
+                    Is.notEmpty(validationFailure.properties.value)) {
+                    v += ` = ${JSON.stringify(validationFailure.properties.value)}`;
+                }
+                validationErrors.push(v);
             }
+            return validationErrors.join("\n");
         }
-        return array;
-    }
-    /**
-     * Convert the UTF8 to hex.
-     * @param utf8 The text to convert.
-     * @param includePrefix Include the 0x prefix on the returned hex.
-     * @returns The hex version of the bytes.
-     */
-    static utf8ToHex(utf8, includePrefix = false) {
-        const hex = Converter.bytesToHex(Converter.utf8ToBytes(utf8));
-        return includePrefix ? HexHelper.addPrefix(hex) : hex;
     }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * The types the extracted data can be coerced to.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const CoerceType = {
     /**
-     * Convert the hex text to text.
-     * @param hex The hex to convert.
-     * @returns The UTF8 version of the bytes.
+     * String.
      */
-    static hexToUtf8(hex) {
-        return Converter.bytesToUtf8(Converter.hexToBytes(HexHelper.stripPrefix(hex)));
-    }
+    String: "string",
     /**
-     * Convert bytes to binary string.
-     * @param bytes The bytes to convert.
-     * @returns A binary string of the bytes.
+     * Number.
      */
-    static bytesToBinary(bytes) {
-        const b = [];
-        for (let i = 0; i < bytes.length; i++) {
-            b.push(bytes[i].toString(2).padStart(8, "0"));
-        }
-        return b.join("");
-    }
+    Number: "number",
     /**
-     * Convert a binary string to bytes.
-     * @param binary The binary string.
-     * @returns The bytes.
+     * Integer.
      */
-    static binaryToBytes(binary) {
-        const bytes = new Uint8Array(Math.ceil(binary.length / 8));
-        for (let i = 0; i < bytes.length; i++) {
-            bytes[i] = Number.parseInt(binary.slice(i * 8, (i + 1) * 8), 2);
-        }
-        return bytes;
-    }
+    Integer: "integer",
     /**
-     * Convert bytes to base64 string.
-     * @param bytes The bytes to convert.
-     * @returns A base64 string of the bytes.
+     * Boolean.
      */
-    static bytesToBase64(bytes) {
-        return Base64.encode(bytes);
-    }
+    Boolean: "boolean",
     /**
-     * Convert a base64 string to bytes.
-     * @param base64 The base64 string.
-     * @returns The bytes.
+     * Big Integer.
      */
-    static base64ToBytes(base64) {
-        return Base64.decode(base64);
-    }
+    BigInt: "bigint",
     /**
-     * Convert bytes to base64 url string.
-     * @param bytes The bytes to convert.
-     * @returns A base64 url string of the bytes.
+     * Date.
      */
-    static bytesToBase64Url(bytes) {
-        return Base64Url.encode(bytes);
-    }
+    Date: "date",
     /**
-     * Convert a base64 url string to bytes.
-     * @param base64Url The base64 url string.
-     * @returns The bytes.
+     * Date Time.
      */
-    static base64UrlToBytes(base64Url) {
-        return Base64Url.decode(base64Url);
-    }
+    DateTime: "datetime",
     /**
-     * Convert bytes to base58 string.
-     * @param bytes The bytes to convert.
-     * @returns A base58 string of the bytes.
+     * Time.
      */
-    static bytesToBase58(bytes) {
-        return Base58.encode(bytes);
-    }
+    Time: "time",
     /**
-     * Convert a base58 string to bytes.
-     * @param base58 The base58 string.
-     * @returns The bytes.
+     * Object.
      */
-    static base58ToBytes(base58) {
-        return Base58.decode(base58);
-    }
+    Object: "object",
     /**
-     * Build the static lookup tables.
-     * @internal
+     * Uint8Array.
      */
-    static buildHexLookups() {
-        if (!Converter._ENCODE_LOOKUP || !Converter._DECODE_LOOKUP) {
-            const alphabet = "0123456789abcdef";
-            Converter._ENCODE_LOOKUP = [];
-            Converter._DECODE_LOOKUP = [];
-            for (let i = 0; i < 256; i++) {
-                Converter._ENCODE_LOOKUP[i] = alphabet[(i >> 4) & 0xf] + alphabet[i & 0xf];
-                if (i < 16) {
-                    if (i < 10) {
-                        Converter._DECODE_LOOKUP[0x30 + i] = i;
-                    }
-                    else {
-                        Converter._DECODE_LOOKUP[0x61 - 10 + i] = i;
-                    }
-                }
-            }
-        }
-    }
-}
+    Uint8Array: "uint8array"
+};
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
- * Class to help with objects.
+ * Coerce an object from one type to another.
  */
-class ObjectHelper {
-    /**
-     * Runtime name for the class.
-     * @internal
-     */
-    static _CLASS_NAME = "ObjectHelper";
+class Coerce {
     /**
-     * Convert an object to bytes.
-     * @param obj The object to convert.
-     * @param format Format the JSON content.
-     * @returns The object as bytes.
+     * Coerce the value to a string.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static toBytes(obj, format = false) {
-        if (obj === undefined) {
-            return new Uint8Array();
+    static string(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.string(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            return value.toString();
+        }
+        if (Is.boolean(value)) {
+            return value ? "true" : "false";
+        }
+        if (Is.date(value)) {
+            return value.toISOString();
         }
-        const json = format ? JSON.stringify(obj, undefined, "\t") : JSON.stringify(obj);
-        return Converter.utf8ToBytes(json);
     }
     /**
-     * Convert a bytes to an object.
-     * @param bytes The bytes to convert to an object.
-     * @returns The object.
-     * @throws GeneralError if there was an error parsing the JSON.
+     * Coerce the value to a number.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static fromBytes(bytes) {
-        if (Is.empty(bytes) || bytes.length === 0) {
-            return undefined;
+    static number(value) {
+        if (Is.undefined(value)) {
+            return value;
         }
-        try {
-            const utf8 = Converter.bytesToUtf8(bytes);
-            return JSON.parse(utf8);
+        if (Is.number(value)) {
+            return value;
         }
-        catch (err) {
-            throw new GeneralError(ObjectHelper._CLASS_NAME, "failedBytesToJSON", undefined, err);
+        if (Is.string(value)) {
+            const parsed = Number.parseFloat(value);
+            if (Is.number(parsed)) {
+                return parsed;
+            }
+        }
+        if (Is.boolean(value)) {
+            return value ? 1 : 0;
+        }
+        if (Is.date(value)) {
+            return value.getTime();
         }
     }
     /**
-     * Make a deep clone of an object.
-     * @param obj The object to clone.
-     * @returns The objects clone.
+     * Coerce the value to an integer.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static clone(obj) {
-        if (Is.undefined(obj)) {
-            return undefined;
+    static integer(value) {
+        const num = Coerce.number(value);
+        if (!Is.undefined(num)) {
+            return Math.trunc(num);
         }
-        return structuredClone(obj);
     }
     /**
-     * Deep merge objects.
-     * @param obj1 The first object to merge.
-     * @param obj2 The second object to merge.
-     * @returns The combined deep merge of the objects.
+     * Coerce the value to a bigint.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static merge(obj1, obj2) {
-        if (Is.empty(obj1)) {
-            return ObjectHelper.clone(obj2);
+    static bigint(value) {
+        if (Is.undefined(value)) {
+            return value;
         }
-        if (Is.empty(obj2)) {
-            return ObjectHelper.clone(obj1);
+        if (Is.bigint(value)) {
+            return value;
         }
-        const obj1Clone = ObjectHelper.clone(obj1);
-        if (Is.object(obj1Clone) && Is.object(obj2)) {
-            const keys = Object.keys(obj2);
-            for (const key of keys) {
-                if (Is.object(obj1Clone[key]) && Is.object(obj2[key])) {
-                    ObjectHelper.propertySet(obj1Clone, key, ObjectHelper.merge(obj1Clone[key], obj2[key]));
-                }
-                else {
-                    ObjectHelper.propertySet(obj1Clone, key, obj2[key]);
-                }
+        if (Is.number(value)) {
+            return BigInt(value);
+        }
+        if (Is.string(value)) {
+            const parsed = Number.parseFloat(value);
+            if (Is.integer(parsed)) {
+                return BigInt(parsed);
+            }
+        }
+        if (Is.boolean(value)) {
+            return value ? 1n : 0n;
+        }
+    }
+    /**
+     * Coerce the value to a boolean.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
+     */
+    static boolean(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.boolean(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            // eslint-disable-next-line no-unneeded-ternary
+            return value ? true : false;
+        }
+        if (Is.string(value)) {
+            if (/true/i.test(value)) {
+                return true;
+            }
+            if (/false/i.test(value)) {
+                return false;
             }
         }
-        return obj1Clone;
     }
     /**
-     * Does one object equal another.
-     * @param obj1 The first object to compare.
-     * @param obj2 The second object to compare.
-     * @param strictPropertyOrder Should the properties be in the same order, defaults to true.
-     * @returns True is the objects are equal.
+     * Coerce the value to a date.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static equal(obj1, obj2, strictPropertyOrder) {
-        if (strictPropertyOrder ?? true) {
-            return JSON.stringify(obj1) === JSON.stringify(obj2);
+    static date(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.date(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            return new Date(value);
+        }
+        if (Is.string(value)) {
+            const dt = new Date(value);
+            if (!Number.isNaN(dt.getTime())) {
+                const utc = Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate());
+                return new Date(utc);
+            }
         }
-        return JsonHelper.canonicalize(obj1) === JsonHelper.canonicalize(obj2);
     }
     /**
-     * Get the property of an unknown object.
-     * @param obj The object to get the property from.
-     * @param property The property to get, can be separated by dots for nested path.
-     * @returns The property.
+     * Coerce the value to a date/time.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static propertyGet(obj, property) {
-        if (property.includes(".")) {
-            const parts = property.split(".");
-            let value = obj;
-            for (const part of parts) {
-                if (Is.object(value)) {
-                    value = value[part];
-                }
-                else {
-                    return undefined;
-                }
-            }
+    static dateTime(value) {
+        if (Is.undefined(value)) {
             return value;
         }
-        return Is.object(obj) ? obj[property] : undefined;
+        if (Is.date(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            return new Date(value);
+        }
+        if (Is.string(value)) {
+            const dt = new Date(value);
+            if (!Number.isNaN(dt.getTime())) {
+                const utc = Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(), dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds());
+                return new Date(utc);
+            }
+        }
     }
     /**
-     * Set the property of an unknown object.
-     * @param obj The object to set the property from.
-     * @param property The property to set.
-     * @param value The value to set.
+     * Coerce the value to a time.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static propertySet(obj, property, value) {
-        if (Is.object(obj)) {
-            obj[property] = value;
+    static time(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.date(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            const dt = new Date(value);
+            dt.setFullYear(1970, 0, 1);
+            return dt;
+        }
+        if (Is.string(value)) {
+            const dt = new Date(value);
+            if (!Number.isNaN(dt.getTime())) {
+                const utc = Date.UTC(1970, 0, 1, dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds());
+                return new Date(utc);
+            }
         }
     }
     /**
-     * Delete the property of an unknown object.
-     * @param obj The object to set the property from.
-     * @param property The property to set
+     * Coerce the value to an object.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static propertyDelete(obj, property) {
-        if (Is.object(obj)) {
-            delete obj[property];
+    static object(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.object(value)) {
+            return value;
+        }
+        if (Is.stringValue(value)) {
+            try {
+                return JSON.parse(value);
+            }
+            catch { }
         }
     }
     /**
-     * Extract a property from the object, providing alternative names.
-     * @param obj The object to extract from.
-     * @param propertyNames The possible names for the property.
-     * @param removeProperties Remove the properties from the object, defaults to true.
-     * @returns The property if available.
+     * Coerce the value to a Uint8Array.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static extractProperty(obj, propertyNames, removeProperties = true) {
-        let retVal;
-        if (Is.object(obj)) {
-            const names = Is.string(propertyNames) ? [propertyNames] : propertyNames;
-            for (const prop of names) {
-                retVal ??= ObjectHelper.propertyGet(obj, prop);
-                if (removeProperties) {
-                    ObjectHelper.propertyDelete(obj, prop);
-                }
+    static uint8Array(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.string(value)) {
+            if (Is.stringHex(value.toLowerCase(), true)) {
+                return Converter.hexToBytes(value.toLowerCase());
+            }
+            if (Is.stringBase64(value)) {
+                return Converter.base64ToBytes(value);
             }
         }
-        return retVal;
     }
     /**
-     * Pick a subset of properties from an object.
-     * @param obj The object to pick the properties from.
-     * @param keys The property keys to pick.
-     * @returns The partial object.
-     */
-    static pick(obj, keys) {
-        if (Is.object(obj) && Is.arrayValue(keys)) {
-            const result = {};
-            for (const key of keys) {
-                result[key] = obj[key];
-            }
-            return result;
+     * Coerces a value based on the coercion type.
+     * @param value The value to coerce.
+     * @param type The coercion type to perform.
+     * @returns The coerced value.
+     */
+    static byType(value, type) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (type) {
+            case CoerceType.String:
+                return Coerce.string(value);
+            case CoerceType.Number:
+                return Coerce.number(value);
+            case CoerceType.Integer:
+                return Coerce.integer(value);
+            case CoerceType.BigInt:
+                return Coerce.bigint(value);
+            case CoerceType.Boolean:
+                return Coerce.boolean(value);
+            case CoerceType.Date:
+                return Coerce.date(value);
+            case CoerceType.DateTime:
+                return Coerce.dateTime(value);
+            case CoerceType.Time:
+                return Coerce.time(value);
+            case CoerceType.Object:
+                return Coerce.object(value);
+            case CoerceType.Uint8Array:
+                return Coerce.uint8Array(value);
+            default:
+                return value;
         }
-        return obj;
     }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class to help with filenames.
+ */
+class FilenameHelper {
     /**
-     * Omit a subset of properties from an object.
-     * @param obj The object to omit the properties from.
-     * @param keys The property keys to omit.
-     * @returns The partial object.
+     * Replaces any unsafe characters in the filename.
+     * @param filename The filename to make safe.
+     * @returns The safe filename.
      */
-    static omit(obj, keys) {
-        if (Is.object(obj) && Is.arrayValue(keys)) {
-            const result = { ...obj };
-            for (const key of keys) {
-                delete result[key];
-            }
-            return result;
+    static safeFilename(filename) {
+        let safe = Coerce.string(filename);
+        if (Is.empty(safe)) {
+            return "";
         }
-        return obj;
+        // Common non filename characters
+        safe = safe.replace(/["*/:<>?\\|]/g, "_");
+        // Windows non filename characters
+        safe = safe.replace(/^(con|prn|aux|nul|com\d|lpt\d)$/i, "_");
+        // Control characters
+        safe = safe.replace(/[\u0000-\u001F\u0080-\u009F]/g, "_");
+        // Relative paths
+        safe = safe.replace(/^\.+/, "_");
+        // Trailing periods
+        safe = safe.replace(/\.+$/, "");
+        return safe;
     }
 }
 
@@ -3026,6 +3649,32 @@ class RandomHelper {
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class to help with uint8 arrays.
+ */
+class Uint8ArrayHelper {
+    /**
+     * Concatenate multiple arrays.
+     * @param arrays The array to concatenate.
+     * @returns The combined array.
+     */
+    static concat(arrays) {
+        let totalLength = 0;
+        for (const array of arrays) {
+            totalLength += array.length;
+        }
+        const concatBytes = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const array of arrays) {
+            concatBytes.set(array, offset);
+            offset += array.length;
+        }
+        return concatBytes;
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -3038,7 +3687,7 @@ const CompressionType = {
      */
     Gzip: "gzip",
     /**
-     * deflate.
+     * Deflate.
      */
     Deflate: "deflate"
 };
@@ -3489,29 +4138,93 @@ class Urn {
  * Cache the results from asynchronous requests.
  */
 class AsyncCache {
-    /**
-     * Cache for the fetch requests.
-     * @internal
-     */
-    static _cache = {};
     /**
      * Execute an async request and cache the result.
      * @param key The key for the entry in the cache.
      * @param ttlMs The TTL of the entry in the cache.
      * @param requestMethod The method to call if not cached.
+     * @param cacheFailures Cache failure results, defaults to false.
      * @returns The response.
      */
-    static exec(key, ttlMs, requestMethod) {
+    static exec(key, ttlMs, requestMethod, cacheFailures) {
         const cacheEnabled = Is.integer(ttlMs) && ttlMs >= 0;
         if (cacheEnabled) {
             AsyncCache.cleanupExpired();
-            if (!this._cache[key]) {
-                this._cache[key] = {
-                    response: requestMethod(),
-                    expires: ttlMs === 0 ? 0 : Date.now() + ttlMs
-                };
+            const cache = AsyncCache.getSharedCache();
+            // Do we have a cache entry for the key
+            if (cache[key]) {
+                if (!Is.empty(cache[key].result)) {
+                    // If the cache has already resulted in a value, resolve it
+                    return Promise.resolve(cache[key].result);
+                }
+                else if (!Is.empty(cache[key].error)) {
+                    // If the cache has already resulted in an error, reject it
+                    return Promise.reject(cache[key].error);
+                }
+                // Otherwise create a promise to return and store the resolver
+                // and rejector in the cache entry, so that we can call then
+                // when the request is done
+                let storedResolve;
+                let storedReject;
+                const wait = new Promise((resolve, reject) => {
+                    storedResolve = resolve;
+                    storedReject = reject;
+                });
+                if (!Is.empty(storedResolve) && !Is.empty(storedReject)) {
+                    cache[key].promiseQueue.push({
+                        requestMethod,
+                        resolve: storedResolve,
+                        reject: storedReject
+                    });
+                }
+                return wait;
             }
-            return this._cache[key].response;
+            // If we don't have a cache entry, create a new one
+            cache[key] = {
+                promiseQueue: [],
+                expires: ttlMs === 0 ? 0 : Date.now() + ttlMs
+            };
+            // Return a promise that wraps the original request method
+            // so that we can store any results or errors in the cache
+            return new Promise((resolve, reject) => {
+                // Call the request method and store the result
+                requestMethod()
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    .then(res => {
+                    // If the request was successful, store the result
+                    cache[key].result = res;
+                    // and resolve both this promise and all the waiters
+                    resolve(res);
+                    for (const wait of cache[key].promiseQueue) {
+                        wait.resolve(res);
+                    }
+                    return res;
+                })
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    .catch((err) => {
+                    // Reject the promise
+                    reject(err);
+                    // Handle the waiters based on the cacheFailures flag
+                    if (cacheFailures ?? false) {
+                        // If we are caching failures, store the error and reject the waiters
+                        cache[key].error = err;
+                        for (const wait of cache[key].promiseQueue) {
+                            wait.reject(err);
+                        }
+                        // Clear the waiters so we don't call them again
+                        cache[key].promiseQueue = [];
+                    }
+                    else {
+                        // If not caching failures for any queued requests we
+                        // have no value to either resolve or reject, so we
+                        // just resolve with the original request method
+                        for (const wait of cache[key].promiseQueue) {
+                            wait.resolve(wait.requestMethod());
+                        }
+                        delete cache[key];
+                    }
+                });
+            });
         }
     }
     /**
@@ -3520,41 +4233,80 @@ class AsyncCache {
      * @returns The item from the cache if it exists.
      */
     static async get(key) {
-        return AsyncCache._cache[key]?.response;
+        const cache = AsyncCache.getSharedCache();
+        if (!Is.empty(cache[key].result)) {
+            // If the cache has already resulted in a value, resolve it
+            return cache[key].result;
+        }
+        else if (!Is.empty(cache[key].error)) {
+            // If the cache has already resulted in an error, reject it
+            throw cache[key].error;
+        }
+    }
+    /**
+     * Set an entry into the cache.
+     * @param key The key to set in the cache.
+     * @param value The value to set in the cache.
+     * @param ttlMs The TTL of the entry in the cache in ms, defaults to 1s.
+     * @returns Nothing.
+     */
+    static async set(key, value, ttlMs) {
+        const cache = AsyncCache.getSharedCache();
+        cache[key] = {
+            result: value,
+            promiseQueue: [],
+            expires: Date.now() + (ttlMs ?? 1000)
+        };
     }
     /**
      * Remove an entry from the cache.
      * @param key The key to remove from the cache.
      */
     static remove(key) {
-        delete AsyncCache._cache[key];
+        const cache = AsyncCache.getSharedCache();
+        delete cache[key];
     }
     /**
      * Clear the cache.
      * @param prefix Optional prefix to clear only entries with that prefix.
      */
     static clearCache(prefix) {
+        const cache = AsyncCache.getSharedCache();
         if (Is.stringValue(prefix)) {
-            for (const entry in this._cache) {
+            for (const entry in cache) {
                 if (entry.startsWith(prefix)) {
-                    delete this._cache[entry];
+                    delete cache[entry];
                 }
             }
         }
         else {
-            AsyncCache._cache = {};
+            SharedStore.set("asyncCache", {});
         }
     }
     /**
      * Perform a cleanup of the expired entries in the cache.
      */
     static cleanupExpired() {
-        for (const entry in this._cache) {
-            if (AsyncCache._cache[entry].expires > 0 && AsyncCache._cache[entry].expires < Date.now()) {
-                delete this._cache[entry];
+        const cache = AsyncCache.getSharedCache();
+        for (const entry in cache) {
+            if (cache[entry].expires > 0 && cache[entry].expires < Date.now()) {
+                delete cache[entry];
             }
         }
     }
+    /**
+     * Get the shared cache.
+     * @returns The shared cache.
+     * @internal
+     */
+    static getSharedCache() {
+        let sharedCache = SharedStore.get("asyncCache");
+        if (Is.undefined(sharedCache)) {
+            sharedCache = {};
+            SharedStore.set("asyncCache", sharedCache);
+        }
+        return sharedCache;
+    }
 }
 
 /**
@@ -3575,16 +4327,15 @@ class Compression {
     static async compress(bytes, type) {
         Guards.uint8Array(Compression._CLASS_NAME, "bytes", bytes);
         Guards.arrayOneOf(Compression._CLASS_NAME, "type", type, Object.values(CompressionType));
-        const blob = new Blob([bytes]);
-        const ds = new CompressionStream(type);
-        const compressedStream = blob.stream().pipeThrough(ds);
-        const compressedBlob = await new Response(compressedStream).blob();
-        const ab = await compressedBlob.arrayBuffer();
-        const compressedBytes = new Uint8Array(ab);
+        const blob = new Blob([new Uint8Array(bytes)]);
+        const compressionStream = new CompressionStream(type);
+        const compressionPipe = blob.stream().pipeThrough(compressionStream);
+        const compressedBlob = await new Response(compressionPipe).blob();
+        const compressedBytes = new Uint8Array(await compressedBlob.arrayBuffer());
         // GZIP header contains a byte which specifies the OS the
         // compression was performed on. We set this to 3 (Unix) to ensure
         // that we produce consistent results.
-        if (type === "gzip" && compressedBytes.length >= 10) {
+        if (type === CompressionType.Gzip && compressedBytes.length >= 10) {
             compressedBytes[9] = 3;
         }
         return compressedBytes;
@@ -3598,12 +4349,11 @@ class Compression {
     static async decompress(compressedBytes, type) {
         Guards.uint8Array(Compression._CLASS_NAME, "compressedBytes", compressedBytes);
         Guards.arrayOneOf(Compression._CLASS_NAME, "type", type, Object.values(CompressionType));
-        const blob = new Blob([compressedBytes]);
-        const ds = new DecompressionStream(type);
-        const decompressedStream = blob.stream().pipeThrough(ds);
-        const decompressedBlob = await new Response(decompressedStream).blob();
-        const ab = await decompressedBlob.arrayBuffer();
-        return new Uint8Array(ab);
+        const blob = new Blob([new Uint8Array(compressedBytes)]);
+        const decompressionStream = new DecompressionStream(type);
+        const decompressionPipe = blob.stream().pipeThrough(decompressionStream);
+        const decompressedBlob = await new Response(decompressionPipe).blob();
+        return new Uint8Array(await decompressedBlob.bytes());
     }
 }
 
@@ -3661,6 +4411,7 @@ class Validation {
      * @param options Additional options for the validation.
      * @param options.minLength The minimum length of the string.
      * @param options.maxLength The maximum length of the string.
+     * @param options.format Specific format to check.
      * @returns True if the value is a valid string.
      */
     static string(property, value, failures, fieldNameResource, options) {
@@ -3679,6 +4430,47 @@ class Validation {
             const maxLimitDefined = Is.integer(maxLength);
             const belowMin = minLimitDefined && value.length < minLength;
             const aboveMax = maxLimitDefined && value.length > maxLength;
+            if (options?.format === "base58" && !Is.stringBase58(value)) {
+                failures.push({
+                    property,
+                    reason: "validation.beTextBase58",
+                    properties: {
+                        fieldName: fieldNameResource ?? "validation.defaultFieldName",
+                        value
+                    }
+                });
+            }
+            else if (options?.format === "base64" && !Is.stringBase64(value)) {
+                failures.push({
+                    property,
+                    reason: "validation.beTextBase64",
+                    properties: {
+                        fieldName: fieldNameResource ?? "validation.defaultFieldName",
+                        value
+                    }
+                });
+            }
+            else if (options?.format === "hex" && !Is.stringHex(value)) {
+                failures.push({
+                    property,
+                    reason: "validation.beTextHex",
+                    properties: {
+                        fieldName: fieldNameResource ?? "validation.defaultFieldName",
+                        value
+                    }
+                });
+            }
+            else if (Is.regexp(options?.format) && !options.format.test(value)) {
+                failures.push({
+                    property,
+                    reason: "validation.beTextRegExp",
+                    properties: {
+                        fieldName: fieldNameResource ?? "validation.defaultFieldName",
+                        value,
+                        format: options?.format
+                    }
+                });
+            }
             if (minLimitDefined && maxLimitDefined && (belowMin || aboveMax)) {
                 failures.push({
                     property,
@@ -4338,4 +5130,4 @@ class Validation {
     }
 }
 
-export { AlreadyExistsError, ArrayHelper, AsyncCache, Base32, Base58, Base64, Base64Url, BaseError, BitString, Coerce, ComponentFactory, Compression, CompressionType, ConflictError, Converter, ErrorHelper, Factory, FilenameHelper, GeneralError, GuardError, Guards, HexHelper, I18n, Is, JsonHelper, NotFoundError, NotImplementedError, NotSupportedError, ObjectHelper, RandomHelper, StringHelper, UnauthorizedError, UnprocessableError, Url, Urn, Validation, ValidationError };
+export { AlreadyExistsError, ArrayHelper, AsyncCache, Base32, Base58, Base64, Base64Url, BaseError, BitString, Coerce, CoerceType, ComponentFactory, Compression, CompressionType, ConflictError, Converter, EnvHelper, ErrorHelper, Factory, FilenameHelper, GeneralError, GuardError, Guards, HexHelper, I18n, Is, JsonHelper, NotFoundError, NotImplementedError, NotSupportedError, ObjectHelper, RandomHelper, SharedStore, StringHelper, Uint8ArrayHelper, UnauthorizedError, UnprocessableError, Url, Urn, Validation, ValidationError };