@twin.org/core 0.0.1-next.6 → 0.0.1-next.60

package/dist/cjs/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var intlMessageformat = require('intl-messageformat');
 var rfc6902 = require('rfc6902');
+var intlMessageformat = require('intl-messageformat');
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -113,7 +113,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;
@@ -137,7 +142,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.
@@ -351,6 +366,14 @@ 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;
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -686,7 +709,7 @@ 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;
@@ -782,9 +805,10 @@ class BaseError extends Error {
     }
     /**
      * 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;
@@ -798,11 +822,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();
+            err.inner = BaseError.fromError(this.inner).toJsonObject(includeStackTrace);
         }
         return err;
     }
@@ -900,6 +924,127 @@ class Base32 {
     }
 }
 
+/**
+ * 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) {
+        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) {
+        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++) {
+            let carry = bytes[i];
+            let j = 0;
+            for (let k = size - 1; k >= 0; k--, j++) {
+                if (carry === 0 && j >= length) {
+                    break;
+                }
+                carry += b58[k] * 256;
+                b58[k] = carry % 58;
+                carry = Math.trunc(carry / 58);
+            }
+            length = j;
+        }
+        let i = size - length;
+        while (i < size && b58[i] === 0) {
+            i += 1;
+        }
+        let str = "";
+        for (let j = 0; j < zeroes; j++) {
+            str += "1";
+        }
+        while (i < size) {
+            str += Base58._ALPHABET[b58[i++]];
+        }
+        return str;
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /* eslint-disable no-bitwise */
@@ -1054,7 +1199,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) {
@@ -1350,6 +1495,49 @@ class ValidationError extends BaseError {
     }
 }
 
+/**
+ * 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.
+     */
+    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 true;
+    }
+    /**
+     * Convert an object or array to an array.
+     * @param value The object or array to convert.
+     * @returns The array.
+     */
+    static fromObjectOrArray(value) {
+        if (Is.empty(value)) {
+            return undefined;
+        }
+        if (Is.array(value)) {
+            return value;
+        }
+        return [value];
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -1395,6 +1583,18 @@ class Guards {
             throw new GuardError(source, "guard.stringEmpty", property, value);
         }
     }
+    /**
+     * 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);
+        }
+    }
     /**
      * Is the property a base64 string.
      * @param source The source of the error.
@@ -1419,6 +1619,18 @@ class Guards {
             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.
@@ -1608,6 +1820,50 @@ class Guards {
             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.
@@ -1648,6 +1904,53 @@ class Guards {
     }
 }
 
+// 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 {
+    /**
+     * Get a property from the shared store.
+     * @param prop The name of the property to get.
+     * @returns The property if it exists.
+     */
+    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];
+    }
+    /**
+     * Set the property in the shared store.
+     * @param prop The name of the property to set.
+     * @param value The value to set.
+     */
+    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__ = {};
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis.__TWIN_SHARED__[prop] = value;
+    }
+    /**
+     * Remove a property from the shared store.
+     * @param prop The name of the property to remove.
+     */
+    static remove(prop) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const shared = globalThis.__TWIN_SHARED__;
+        if (!Is.undefined(shared)) {
+            delete shared[prop];
+        }
+    }
+}
+
 /**
  * Factory for creating implementation of generic types.
  */
@@ -1657,11 +1960,6 @@ class Factory {
      * @internal
      */
     static _CLASS_NAME = "Factory";
-    /**
-     * Store all the created factories.
-     * @internal
-     */
-    static _factories = {};
     /**
      * Type name for the instances.
      * @internal
@@ -1715,10 +2013,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.
@@ -1791,7 +2120,7 @@ class Factory {
         }
     }
     /**
-     * Reset all the instances.
+     * Remove all the instances and leave the generators intact.
      */
     reset() {
         for (const name in this._generators) {
@@ -1799,6 +2128,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.
@@ -1873,983 +2210,1357 @@ const ComponentFactory = Factory.createFactory("component");
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
 /**
- * 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.
-     */
-    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 true;
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to perform internationalization.
+ * Convert arrays to and from different formats.
  */
-class I18n {
-    /**
-     * The default translation.
-     */
-    static DEFAULT_LOCALE = "en";
+class Converter {
     /**
-     * Dictionaries for lookups.
+     * Lookup table for encoding.
      * @internal
      */
-    static _localeDictionaries = {};
+    static _ENCODE_LOOKUP;
     /**
-     * The current locale.
+     * Lookup table for decoding.
      * @internal
      */
-    static _currentLocale = I18n.DEFAULT_LOCALE;
+    static _DECODE_LOOKUP;
     /**
-     * Change handler for the locale being updated.
-     * @internal
+     * 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 _localeChangedHandlers = {};
+    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;
+    }
     /**
-     * Change handler for the dictionaries being updated.
-     * @internal
+     * Convert a UTF8 string to raw array.
+     * @param utf8 The text to decode.
+     * @returns The array.
      */
-    static _dictionaryChangedHandlers = {};
-    /**
-     * Set the locale.
-     * @param locale The new locale.
-     */
-    static setLocale(locale) {
-        I18n._currentLocale = locale;
-        for (const callback in I18n._localeChangedHandlers) {
-            I18n._localeChangedHandlers[callback](I18n._currentLocale);
+    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);
     }
     /**
-     * Get the locale.
-     * @returns The current locale.
+     * 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 getLocale() {
-        return I18n._currentLocale;
+    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;
     }
     /**
-     * Add a locale dictionary.
-     * @param locale The locale.
-     * @param dictionary The dictionary to add.
+     * Decode a hex string to raw array.
+     * @param hex The hex to decode.
+     * @param reverse Store the characters in reverse.
+     * @returns The array.
      */
-    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 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;
     }
     /**
-     * Get a locale dictionary.
-     * @param locale The locale.
-     * @returns The dictionary of undefined if it does not exist.
+     * 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 getDictionary(locale) {
-        return I18n._localeDictionaries[locale];
+    static utf8ToHex(utf8, includePrefix = false) {
+        const hex = Converter.bytesToHex(Converter.utf8ToBytes(utf8));
+        return includePrefix ? HexHelper.addPrefix(hex) : hex;
     }
     /**
-     * Get all the locale dictionaries.
-     * @returns The dictionaries.
+     * Convert the hex text to text.
+     * @param hex The hex to convert.
+     * @returns The UTF8 version of the bytes.
      */
-    static getAllDictionaries() {
-        return I18n._localeDictionaries;
+    static hexToUtf8(hex) {
+        return Converter.bytesToUtf8(Converter.hexToBytes(HexHelper.stripPrefix(hex)));
     }
     /**
-     * Add a locale changed handler.
-     * @param id The id of the handler.
-     * @param handler The handler to add.
+     * Convert bytes to binary string.
+     * @param bytes The bytes to convert.
+     * @returns A binary string of the bytes.
      */
-    static addLocaleHandler(id, handler) {
-        I18n._localeChangedHandlers[id] = handler;
+    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("");
     }
     /**
-     * Remove a locale changed handler.
-     * @param id The id of the handler.
+     * Convert a binary string to bytes.
+     * @param binary The binary string.
+     * @returns The bytes.
      */
-    static removeLocaleHandler(id) {
-        delete I18n._localeChangedHandlers[id];
+    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;
     }
     /**
-     * Add a dictionary changed handler.
-     * @param id The id of the handler.
-     * @param handler The handler to add.
+     * Convert bytes to base64 string.
+     * @param bytes The bytes to convert.
+     * @returns A base64 string of the bytes.
      */
-    static addDictionaryHandler(id, handler) {
-        I18n._dictionaryChangedHandlers[id] = handler;
+    static bytesToBase64(bytes) {
+        return Base64.encode(bytes);
     }
     /**
-     * Remove a dictionary changed handler.
-     * @param id The id of the handler.
+     * Convert a base64 string to bytes.
+     * @param base64 The base64 string.
+     * @returns The bytes.
      */
-    static removeDictionaryHandler(id) {
-        delete I18n._dictionaryChangedHandlers[id];
+    static base64ToBytes(base64) {
+        return Base64.decode(base64);
     }
     /**
-     * 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.
+     * Convert bytes to base64 url string.
+     * @param bytes The bytes to convert.
+     * @returns A base64 url string of the bytes.
      */
-    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.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");
-        }
-        return ret;
+    static bytesToBase64Url(bytes) {
+        return Base64Url.encode(bytes);
     }
     /**
-     * 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.
+     * Convert a base64 url string to bytes.
+     * @param base64Url The base64 url string.
+     * @returns The bytes.
      */
-    static hasMessage(key) {
-        return Is.string(I18n._localeDictionaries[I18n._currentLocale]?.[key]);
+    static base64UrlToBytes(base64Url) {
+        return Base64Url.decode(base64Url);
     }
     /**
-     * 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.
+     * Convert bytes to base58 string.
+     * @param bytes The bytes to convert.
+     * @returns A base58 string of the bytes.
+     */
+    static bytesToBase58(bytes) {
+        return Base58.encode(bytes);
+    }
+    /**
+     * Convert a base58 string to bytes.
+     * @param base58 The base58 string.
+     * @returns The bytes.
+     */
+    static base58ToBytes(base58) {
+        return Base58.decode(base58);
+    }
+    /**
+     * Build the static lookup tables.
      * @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 if (Is.object(val)) {
-                I18n.flattenTranslationKeys(val, mergedPath, mergedKeys);
+    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;
+                    }
+                }
             }
         }
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
- * Error helper functions.
+ * Helpers methods for JSON objects.
  */
-class ErrorHelper {
+class JsonHelper {
     /**
-     * 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 = "JsonHelper";
     /**
-     * Localize the content of an error and any inner errors.
-     * @param error The error to format.
-     * @returns The localized version of the errors flattened.
+     * 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 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");
+    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");
                 }
-                const additional = ErrorHelper.formatValidationErrors(err);
-                if (Is.stringValue(additional)) {
-                    localizedError.additional = additional;
+                else {
+                    parts.push(JsonHelper.canonicalize(element));
                 }
-                formattedErrors.push(localizedError);
             }
+            buffer.push(`[${parts.join(",")}]`);
         }
-        return formattedErrors;
+        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("");
     }
     /**
-     * Localize the content of an error and any inner errors.
-     * @param error The error to format.
-     * @returns The localized version of the errors flattened.
+     * 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 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);
+    static diff(object1, object2) {
+        const operations = rfc6902.createPatch(object1, object2);
+        return operations;
+    }
+    /**
+     * 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 patch(object, patches) {
+        const clone = ObjectHelper.clone(object);
+        const result = rfc6902.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 clone;
+    }
+    /**
+     * 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.
+     */
+    // 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);
+    }
+    /**
+     * Parse the JSON string with support for extended data types date/bigint/uint8array.
+     * @param json The object to pause.
+     * @returns The object.
+     */
+    // 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 (value["@ext"] === "date") {
+                return new Date(value.value);
+            }
+            else if (value["@ext"] === "uint8array") {
+                return Converter.base64ToBytes(value.value);
             }
-            return validationErrors.join("\n");
         }
+        return value;
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
- * Coerce an object from one type to another.
+ * Class to help with objects.
  */
-class Coerce {
+class ObjectHelper {
     /**
-     * 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.
+     * Runtime name for the class.
+     * @internal
      */
-    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();
+    static _CLASS_NAME = "ObjectHelper";
+    /**
+     * Convert an object to bytes.
+     * @param obj The object to convert.
+     * @param format Format the JSON content.
+     * @returns The object as bytes.
+     */
+    static toBytes(obj, format = false) {
+        if (obj === undefined) {
+            return new Uint8Array();
         }
+        const json = format ? JSON.stringify(obj, undefined, "\t") : JSON.stringify(obj);
+        return Converter.utf8ToBytes(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.
+     * 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 number(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            return value;
-        }
-        if (Is.string(value)) {
-            const parsed = Number.parseFloat(value);
-            if (Is.number(parsed)) {
-                return parsed;
-            }
+    static fromBytes(bytes) {
+        if (Is.empty(bytes) || bytes.length === 0) {
+            return undefined;
         }
-        if (Is.boolean(value)) {
-            return value ? 1 : 0;
+        try {
+            const utf8 = Converter.bytesToUtf8(bytes);
+            return JSON.parse(utf8);
         }
-        if (Is.date(value)) {
-            return value.getTime();
+        catch (err) {
+            throw new GeneralError(ObjectHelper._CLASS_NAME, "failedBytesToJSON", undefined, err);
         }
     }
     /**
-     * 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.
+     * Make a deep clone of an object.
+     * @param obj The object to clone.
+     * @returns The objects clone.
      */
-    static bigint(value) {
-        if (Is.undefined(value)) {
-            return value;
+    static clone(obj) {
+        if (Is.undefined(obj)) {
+            return undefined;
         }
-        if (Is.bigint(value)) {
-            return value;
+        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.number(value)) {
-            return BigInt(value);
+        if (Is.empty(obj2)) {
+            return ObjectHelper.clone(obj1);
         }
-        if (Is.string(value)) {
-            const parsed = Number.parseFloat(value);
-            if (Is.integer(parsed)) {
-                return BigInt(parsed);
+        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.boolean(value)) {
-            return value ? 1n : 0n;
-        }
+        return obj1Clone;
     }
     /**
-     * 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.
+     * 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 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;
+    static equal(obj1, obj2, strictPropertyOrder) {
+        if (strictPropertyOrder ?? true) {
+            return JSON.stringify(obj1) === JSON.stringify(obj2);
         }
-        if (Is.string(value)) {
-            if (/true/i.test(value)) {
-                return true;
+        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;
+                }
             }
-            if (/false/i.test(value)) {
-                return false;
+            else if (Is.object(pathValue)) {
+                // No array part in path so assume object sub property
+                pathValue = pathValue[pathPart];
+            }
+            else {
+                return undefined;
             }
         }
+        return pathValue;
     }
     /**
-     * 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.
+     * 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 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 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 {
+                        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;
+                    }
+                }
             }
         }
     }
     /**
-     * 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.
+     * Delete the property of an unknown object.
+     * @param obj The object to set the property from.
+     * @param property The property to set
      */
-    static dateTime(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.date(value)) {
-            return value;
-        }
-        if (Is.number(value)) {
-            return new Date(value);
+    static propertyDelete(obj, property) {
+        if (Is.object(obj)) {
+            delete obj[property];
         }
-        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);
+    }
+    /**
+     * 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 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);
+                }
             }
         }
+        return retVal;
     }
     /**
-     * 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.
+     * 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 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);
+    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 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.
+     * 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 object(value) {
-        if (Is.undefined(value)) {
-            return value;
+    static omit(obj, keys) {
+        if (Is.object(obj) && Is.arrayValue(keys)) {
+            const result = { ...obj };
+            for (const key of keys) {
+                delete result[key];
+            }
+            return result;
         }
-        if (Is.object(value)) {
-            return value;
+        return obj;
+    }
+    /**
+     * Converter the non JSON primitives to extended types.
+     * @param obj The object to convert.
+     * @returns The object with extended properties.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static toExtended(obj) {
+        const jsonExtended = JsonHelper.stringifyEx(obj);
+        return JSON.parse(jsonExtended);
+    }
+    /**
+     * Converter the extended types to non JSON primitives.
+     * @param obj The object to convert.
+     * @returns The object with regular properties.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromExtended(obj) {
+        const jsonExtended = JsonHelper.stringifyEx(obj);
+        return JsonHelper.parseEx(jsonExtended);
+    }
+    /**
+     * 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 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 = rfc6902.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 rfc6902.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.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));
+    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 if (charCode < 0xd800 || charCode >= 0xe000) {
-                bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+            else if (Is.object(val)) {
+                I18n.flattenTranslationKeys(val, mergedPath, mergedKeys);
             }
-            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));
+        }
+    }
+    /**
+     * Get the I18n shared data.
+     * @returns The I18n shared data.
+     * @internal
+     */
+    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 inner 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);
             }
+            return output;
         }
-        return Uint8Array.from(bytes);
+        return localizedErrors.map(e => e.message);
     }
     /**
-     * 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.
+     * Localize the content of an error and any inner errors.
+     * @param error The error to format.
+     * @returns The localized version of the errors flattened.
      */
-    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 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);
             }
-            else {
-                for (let i = 0; i < len; i++) {
-                    hex += Converter._ENCODE_LOOKUP[array[start + i]];
+        }
+        return formattedErrors;
+    }
+    /**
+     * Localize the content of an error and any inner errors.
+     * @param error The error to format.
+     * @returns The localized version of the errors flattened.
+     */
+    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 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 = {
     /**
-     * Decode a hex string to raw array.
-     * @param hex The hex to decode.
-     * @param reverse Store the characters in reverse.
-     * @returns The array.
+     * String.
      */
-    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;
-    }
+    String: "string",
     /**
-     * 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.
+     * Number.
      */
-    static utf8ToHex(utf8, includePrefix = false) {
-        const hex = Converter.bytesToHex(Converter.utf8ToBytes(utf8));
-        return includePrefix ? HexHelper.addPrefix(hex) : hex;
-    }
+    Number: "number",
     /**
-     * Convert the hex text to text.
-     * @param hex The hex to convert.
-     * @returns The UTF8 version of the bytes.
+     * Integer.
      */
-    static hexToUtf8(hex) {
-        return Converter.bytesToUtf8(Converter.hexToBytes(HexHelper.stripPrefix(hex)));
-    }
+    Integer: "integer",
     /**
-     * Convert bytes to binary string.
-     * @param bytes The bytes to convert.
-     * @returns A binary string of the bytes.
+     * Boolean.
      */
-    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("");
-    }
+    Boolean: "boolean",
     /**
-     * Convert a binary string to bytes.
-     * @param binary The binary string.
-     * @returns The bytes.
+     * Big 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;
-    }
+    BigInt: "bigint",
     /**
-     * Convert bytes to base64 string.
-     * @param bytes The bytes to convert.
-     * @returns A base64 string of the bytes.
+     * Date.
      */
-    static bytesToBase64(bytes) {
-        return Base64.encode(bytes);
-    }
+    Date: "date",
     /**
-     * Convert a base64 string to bytes.
-     * @param base64 The base64 string.
-     * @returns The bytes.
+     * Date Time.
      */
-    static base64ToBytes(base64) {
-        return Base64.decode(base64);
-    }
+    DateTime: "datetime",
     /**
-     * Convert bytes to base64 url string.
-     * @param bytes The bytes to convert.
-     * @returns A base64 url string of the bytes.
+     * Time.
      */
-    static bytesToBase64Url(bytes) {
-        return Base64Url.encode(bytes);
-    }
+    Time: "time",
     /**
-     * Convert a base64 url string to bytes.
-     * @param base64Url The base64 url string.
-     * @returns The bytes.
+     * Object.
      */
-    static base64UrlToBytes(base64Url) {
-        return Base64Url.decode(base64Url);
-    }
+    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 {
+class Coerce {
     /**
-     * Runtime name for the class.
-     * @internal
+     * 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 _CLASS_NAME = "ObjectHelper";
+    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();
+        }
+    }
     /**
-     * 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 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 toBytes(obj, format = false) {
-        if (obj === undefined) {
-            return new Uint8Array();
+    static number(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            return value;
+        }
+        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();
         }
-        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 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 fromBytes(bytes) {
-        if (Is.empty(bytes) || bytes.length === 0) {
-            return undefined;
+    static integer(value) {
+        const num = Coerce.number(value);
+        if (!Is.undefined(num)) {
+            return Math.trunc(num);
         }
-        try {
-            const utf8 = Converter.bytesToUtf8(bytes);
-            return JSON.parse(utf8);
+    }
+    /**
+     * 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 bigint(value) {
+        if (Is.undefined(value)) {
+            return value;
         }
-        catch (err) {
-            throw new GeneralError(ObjectHelper._CLASS_NAME, "failedBytesToJSON", undefined, err);
+        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);
+            }
+        }
+        if (Is.boolean(value)) {
+            return value ? 1n : 0n;
         }
     }
     /**
-     * Make a deep clone of an object.
-     * @param obj The object to clone.
-     * @returns The objects clone.
+     * 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 clone(obj) {
-        if (Is.undefined(obj)) {
-            return undefined;
+    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 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 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 merge(obj1, obj2) {
-        if (Is.empty(obj1)) {
-            return ObjectHelper.clone(obj2);
+    static date(value) {
+        if (Is.undefined(value)) {
+            return value;
         }
-        if (Is.empty(obj2)) {
-            return ObjectHelper.clone(obj1);
+        if (Is.date(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 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 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/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 equal(obj1, obj2, strictPropertyOrder) {
-        if (strictPropertyOrder ?? true) {
-            return JSON.stringify(obj1) === JSON.stringify(obj2);
+    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);
+            }
         }
-        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 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 time(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.date(value)) {
             return value;
         }
-        return Is.object(obj) ? obj[property] : undefined;
+        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);
+            }
+        }
     }
     /**
-     * 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 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 propertySet(obj, property, value) {
-        if (Is.object(obj)) {
-            obj[property] = value;
+    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 { }
         }
     }
     /**
-     * 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 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 propertyDelete(obj, property) {
-        if (Is.object(obj)) {
-            delete obj[property];
+    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);
+            }
         }
     }
     /**
-     * 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) {
+        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;
     }
 }
 
@@ -2871,6 +3582,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.
 /**
@@ -2883,7 +3620,7 @@ const CompressionType = {
      */
     Gzip: "gzip",
     /**
-     * deflate.
+     * Deflate.
      */
     Deflate: "deflate"
 };
@@ -3334,29 +4071,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];
+                    }
+                });
+            });
         }
     }
     /**
@@ -3365,41 +4166,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;
+    }
 }
 
 /**
@@ -3421,11 +4261,10 @@ class Compression {
         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 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.
@@ -3444,11 +4283,10 @@ class Compression {
         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 decompressionStream = new DecompressionStream(type);
+        const decompressionPipe = blob.stream().pipeThrough(decompressionStream);
+        const decompressedBlob = await new Response(decompressionPipe).blob();
+        return new Uint8Array(await decompressedBlob.bytes());
     }
 }
 
@@ -3506,6 +4344,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) {
@@ -3524,6 +4363,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,
@@ -4187,16 +5067,19 @@ exports.AlreadyExistsError = AlreadyExistsError;
 exports.ArrayHelper = ArrayHelper;
 exports.AsyncCache = AsyncCache;
 exports.Base32 = Base32;
+exports.Base58 = Base58;
 exports.Base64 = Base64;
 exports.Base64Url = Base64Url;
 exports.BaseError = BaseError;
 exports.BitString = BitString;
 exports.Coerce = Coerce;
+exports.CoerceType = CoerceType;
 exports.ComponentFactory = ComponentFactory;
 exports.Compression = Compression;
 exports.CompressionType = CompressionType;
 exports.ConflictError = ConflictError;
 exports.Converter = Converter;
+exports.EnvHelper = EnvHelper;
 exports.ErrorHelper = ErrorHelper;
 exports.Factory = Factory;
 exports.FilenameHelper = FilenameHelper;
@@ -4212,7 +5095,9 @@ exports.NotImplementedError = NotImplementedError;
 exports.NotSupportedError = NotSupportedError;
 exports.ObjectHelper = ObjectHelper;
 exports.RandomHelper = RandomHelper;
+exports.SharedStore = SharedStore;
 exports.StringHelper = StringHelper;
+exports.Uint8ArrayHelper = Uint8ArrayHelper;
 exports.UnauthorizedError = UnauthorizedError;
 exports.UnprocessableError = UnprocessableError;
 exports.Url = Url;