@twin.org/core 0.0.1-next.2 → 0.0.1-next.20

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.
@@ -139,6 +139,16 @@ class Is {
             // eslint-disable-next-line unicorn/better-regex
             /^(?:[A-Za-z0-9-_]{4})*(?:[A-Za-z0-9-_]{2}==|[A-Za-z0-9-_]{3}=)?$/.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.
      * @param value The value to test.
@@ -351,6 +361,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.
@@ -900,6 +918,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 +1193,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) {
@@ -1419,6 +1558,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.
@@ -1720,6 +1871,29 @@ class Factory {
         }
         return Factory._factories[typeName];
     }
+    /**
+     * Get all the factories.
+     * @returns All the factories.
+     */
+    static getFactories() {
+        return Factory._factories;
+    }
+    /**
+     * Reset all the factories, which removes any created instances, but not the registrations.
+     */
+    static resetFactories() {
+        for (const typeName in Factory._factories) {
+            Factory._factories[typeName].reset();
+        }
+    }
+    /**
+     * Clear all the factories, which removes anything registered with the factories.
+     */
+    static clearFactories() {
+        for (const typeName in Factory._factories) {
+            Factory._factories[typeName].clear();
+        }
+    }
     /**
      * Register a new generator.
      * @param name The name of the generator.
@@ -1791,7 +1965,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 +1973,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.
@@ -1905,951 +2087,1023 @@ class ArrayHelper {
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Class to perform internationalization.
+ * Helpers methods for JSON objects.
  */
-class I18n {
+class JsonHelper {
     /**
-     * The default translation.
+     * 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 DEFAULT_LOCALE = "en";
+    static canonicalize(object) {
+        const buffer = [];
+        if (object === null ||
+            typeof object !== "object" ||
+            ("toJSON" in object && object.toJSON instanceof Function)) {
+            // Primitive data type
+            buffer.push(JSON.stringify(object));
+        }
+        else if (Array.isArray(object)) {
+            // Array maintain element order
+            const parts = [];
+            for (const element of object) {
+                if (element === undefined) {
+                    parts.push("null");
+                }
+                else {
+                    parts.push(JsonHelper.canonicalize(element));
+                }
+            }
+            buffer.push(`[${parts.join(",")}]`);
+        }
+        else {
+            // Object sort properties
+            const props = [];
+            const keys = Object.keys(object).sort();
+            const o = object;
+            for (const key of keys) {
+                if (o[key] !== undefined) {
+                    props.push(`${JSON.stringify(key)}:${JsonHelper.canonicalize(o[key])}`);
+                }
+            }
+            buffer.push(`{${props.join(",")}}`);
+        }
+        return buffer.join("");
+    }
     /**
-     * Dictionaries for lookups.
-     * @internal
+     * 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 _localeDictionaries = {};
+    static diff(object1, object2) {
+        const operations = rfc6902.createPatch(object1, object2);
+        return operations;
+    }
     /**
-     * The current locale.
-     * @internal
+     * 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.
      */
-    static _currentLocale = I18n.DEFAULT_LOCALE;
+    static patch(object, patches) {
+        return rfc6902.applyPatch(object, patches);
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
+/**
+ * Convert arrays to and from different formats.
+ */
+class Converter {
     /**
-     * Change handler for the locale being updated.
+     * Lookup table for encoding.
      * @internal
      */
-    static _localeChangedHandlers = {};
+    static _ENCODE_LOOKUP;
     /**
-     * Change handler for the dictionaries being updated.
+     * Lookup table for decoding.
      * @internal
      */
-    static _dictionaryChangedHandlers = {};
+    static _DECODE_LOOKUP;
     /**
-     * Set the locale.
-     * @param locale The new locale.
+     * 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 setLocale(locale) {
-        I18n._currentLocale = locale;
-        for (const callback in I18n._localeChangedHandlers) {
-            I18n._localeChangedHandlers[callback](I18n._currentLocale);
+    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;
     }
     /**
-     * Get the locale.
-     * @returns The current locale.
-     */
-    static getLocale() {
-        return I18n._currentLocale;
-    }
-    /**
-     * Add a locale dictionary.
-     * @param locale The locale.
-     * @param dictionary The dictionary to add.
+     * Convert a UTF8 string to raw array.
+     * @param utf8 The text to decode.
+     * @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 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 a locale dictionary.
-     * @param locale The locale.
-     * @returns The dictionary of undefined if it does not exist.
+     * 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 getDictionary(locale) {
-        return I18n._localeDictionaries[locale];
-    }
+    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;
+    }
     /**
-     * Get all the locale dictionaries.
-     * @returns The dictionaries.
+     * Decode a hex string to raw array.
+     * @param hex The hex to decode.
+     * @param reverse Store the characters in reverse.
+     * @returns The array.
      */
-    static getAllDictionaries() {
-        return I18n._localeDictionaries;
+    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;
     }
     /**
-     * Add a locale changed handler.
-     * @param id The id of the handler.
-     * @param handler The handler to add.
+     * 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 addLocaleHandler(id, handler) {
-        I18n._localeChangedHandlers[id] = handler;
+    static utf8ToHex(utf8, includePrefix = false) {
+        const hex = Converter.bytesToHex(Converter.utf8ToBytes(utf8));
+        return includePrefix ? HexHelper.addPrefix(hex) : hex;
     }
     /**
-     * Remove a locale changed handler.
-     * @param id The id of the handler.
+     * Convert the hex text to text.
+     * @param hex The hex to convert.
+     * @returns The UTF8 version of the bytes.
      */
-    static removeLocaleHandler(id) {
-        delete I18n._localeChangedHandlers[id];
+    static hexToUtf8(hex) {
+        return Converter.bytesToUtf8(Converter.hexToBytes(HexHelper.stripPrefix(hex)));
     }
     /**
-     * Add a dictionary 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 addDictionaryHandler(id, handler) {
-        I18n._dictionaryChangedHandlers[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 dictionary changed handler.
-     * @param id The id of the handler.
+     * Convert a binary string to bytes.
+     * @param binary The binary string.
+     * @returns The bytes.
      */
-    static removeDictionaryHandler(id) {
-        delete I18n._dictionaryChangedHandlers[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;
     }
     /**
-     * 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 string.
+     * @param bytes The bytes to convert.
+     * @returns A base64 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 bytesToBase64(bytes) {
+        return Base64.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 string to bytes.
+     * @param base64 The base64 string.
+     * @returns The bytes.
      */
-    static hasMessage(key) {
-        return Is.string(I18n._localeDictionaries[I18n._currentLocale]?.[key]);
+    static base64ToBytes(base64) {
+        return Base64.decode(base64);
     }
     /**
-     * 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
+     * Convert bytes to base64 url string.
+     * @param bytes The bytes to convert.
+     * @returns A base64 url string of the bytes.
      */
-    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 bytesToBase64Url(bytes) {
+        return Base64Url.encode(bytes);
     }
-}
-
-// 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.
-     * @returns The error formatted including any inner errors.
+     * Convert a base64 url string to bytes.
+     * @param base64Url The base64 url string.
+     * @returns The bytes.
      */
-    static formatErrors(error) {
-        return ErrorHelper.localizeErrors(error).map(e => e.message);
+    static base64UrlToBytes(base64Url) {
+        return Base64Url.decode(base64Url);
     }
     /**
-     * Localize the content of an error and any inner errors.
-     * @param error The error to format.
-     * @returns The localized version of the errors flattened.
+     * Convert bytes to base58 string.
+     * @param bytes The bytes to convert.
+     * @returns A base58 string of the bytes.
      */
-    static localizeErrors(error) {
-        const formattedErrors = [];
-        if (Is.notEmpty(error)) {
-            const errors = BaseError.flatten(error);
-            for (const err of errors) {
-                const errorNameKey = `errorNames.${StringHelper.camelCase(err.name)}`;
-                const errorMessageKey = `error.${err.message}`;
-                // If there is no error message then it is probably
-                // from a 3rd party lib, so don't format it just display
-                const hasErrorName = I18n.hasMessage(errorNameKey);
-                const hasErrorMessage = I18n.hasMessage(errorMessageKey);
-                const localizedError = {
-                    name: I18n.formatMessage(hasErrorName ? errorNameKey : "errorNames.error"),
-                    message: hasErrorMessage
-                        ? I18n.formatMessage(errorMessageKey, err.properties)
-                        : err.message
-                };
-                if (Is.stringValue(err.source)) {
-                    localizedError.source = err.source;
-                }
-                if (Is.stringValue(err.stack)) {
-                    // Remove the first line from the stack traces as they
-                    // just have the error type and message duplicated
-                    const lines = err.stack.split("\n");
-                    lines.shift();
-                    localizedError.stack = lines.join("\n");
-                }
-                const additional = ErrorHelper.formatValidationErrors(err);
-                if (Is.stringValue(additional)) {
-                    localizedError.additional = additional;
-                }
-                formattedErrors.push(localizedError);
-            }
-        }
-        return formattedErrors;
+    static bytesToBase58(bytes) {
+        return Base58.encode(bytes);
     }
     /**
-     * Localize the content of an error and any inner errors.
-     * @param error The error to format.
-     * @returns The localized version of the errors flattened.
+     * Convert a base58 string to bytes.
+     * @param base58 The base58 string.
+     * @returns The bytes.
      */
-    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)}`;
+    static base58ToBytes(base58) {
+        return Base58.decode(base58);
+    }
+    /**
+     * Build the static lookup tables.
+     * @internal
+     */
+    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;
+                    }
                 }
-                validationErrors.push(v);
             }
-            return validationErrors.join("\n");
         }
     }
 }
 
-// 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;
-        }
-        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;
+    static clone(obj) {
+        if (Is.undefined(obj)) {
+            return undefined;
         }
+        return structuredClone(obj);
     }
     /**
-     * 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.
+     * 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 boolean(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.boolean(value)) {
-            return value;
+    static merge(obj1, obj2) {
+        if (Is.empty(obj1)) {
+            return ObjectHelper.clone(obj2);
         }
-        if (Is.number(value)) {
-            // eslint-disable-next-line no-unneeded-ternary
-            return value ? true : false;
+        if (Is.empty(obj2)) {
+            return ObjectHelper.clone(obj1);
         }
-        if (Is.string(value)) {
-            if (/true/i.test(value)) {
-                return true;
-            }
-            if (/false/i.test(value)) {
-                return false;
+        const obj1Clone = ObjectHelper.clone(obj1);
+        if (Is.object(obj1Clone) && Is.object(obj2)) {
+            const keys = Object.keys(obj2);
+            for (const key of keys) {
+                if (Is.object(obj1Clone[key]) && Is.object(obj2[key])) {
+                    ObjectHelper.propertySet(obj1Clone, key, ObjectHelper.merge(obj1Clone[key], obj2[key]));
+                }
+                else {
+                    ObjectHelper.propertySet(obj1Clone, key, obj2[key]);
+                }
             }
         }
+        return obj1Clone;
     }
     /**
-     * Coerce the value to a date.
-     * @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 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 equal(obj1, obj2, strictPropertyOrder) {
+        if (strictPropertyOrder ?? true) {
+            return JSON.stringify(obj1) === JSON.stringify(obj2);
         }
+        return JsonHelper.canonicalize(obj1) === JsonHelper.canonicalize(obj2);
     }
     /**
-     * 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.
+     * 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 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);
+    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;
+                }
             }
+            return value;
         }
+        return Is.object(obj) ? obj[property] : undefined;
     }
     /**
-     * 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.
+     * 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.
      */
-    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 propertySet(obj, property, value) {
+        if (Is.object(obj)) {
+            obj[property] = value;
         }
     }
     /**
-     * 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.
+     * Delete the property of an unknown object.
+     * @param obj The object to set the property from.
+     * @param property The property to set
      */
-    static object(value) {
-        if (Is.undefined(value)) {
-            return value;
-        }
-        if (Is.object(value)) {
-            return value;
+    static propertyDelete(obj, property) {
+        if (Is.object(obj)) {
+            delete obj[property];
         }
-        if (Is.stringValue(value)) {
-            try {
-                return JSON.parse(value);
+    }
+    /**
+     * 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);
+                }
             }
-            catch { }
         }
+        return retVal;
     }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to help with filenames.
- */
-class FilenameHelper {
     /**
-     * Replaces any unsafe characters in the filename.
-     * @param filename The filename to make safe.
-     * @returns The safe filename.
+     * 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 safeFilename(filename) {
-        let safe = Coerce.string(filename);
-        if (Is.empty(safe)) {
-            return "";
+    static pick(obj, keys) {
+        if (Is.object(obj) && Is.arrayValue(keys)) {
+            const result = {};
+            for (const key of keys) {
+                result[key] = obj[key];
+            }
+            return result;
         }
-        // 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 obj;
+    }
+    /**
+     * 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 omit(obj, keys) {
+        if (Is.object(obj) && Is.arrayValue(keys)) {
+            const result = { ...obj };
+            for (const key of keys) {
+                delete result[key];
+            }
+            return result;
+        }
+        return obj;
     }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Helpers methods for JSON objects.
+ * Environment variable helper.
  */
-class JsonHelper {
-    /**
-     * 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 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));
+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]);
+                    }
                 }
             }
-            buffer.push(`[${parts.join(",")}]`);
-        }
-        else {
-            // Object sort properties
-            const props = [];
-            const keys = Object.keys(object).sort();
-            const o = object;
-            for (const key of keys) {
-                if (o[key] !== undefined) {
-                    props.push(`${JSON.stringify(key)}:${JsonHelper.canonicalize(o[key])}`);
+            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]);
+                    }
                 }
             }
-            buffer.push(`{${props.join(",")}}`);
         }
-        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.
-     */
-    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.
-     */
-    static patch(object, patches) {
-        return rfc6902.applyPatch(object, patches);
+        return result;
     }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
 /**
- * Convert arrays to and from different formats.
+ * Class to perform internationalization.
  */
-class Converter {
+class I18n {
     /**
-     * Lookup table for encoding.
+     * The default translation.
+     */
+    static DEFAULT_LOCALE = "en";
+    /**
+     * Dictionaries for lookups.
      * @internal
      */
-    static _ENCODE_LOOKUP;
+    static _localeDictionaries = {};
     /**
-     * Lookup table for decoding.
+     * The current locale.
      * @internal
      */
-    static _DECODE_LOOKUP;
+    static _currentLocale = I18n.DEFAULT_LOCALE;
     /**
-     * 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.
+     * Change handler for the locale being updated.
+     * @internal
      */
-    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;
-    }
+    static _localeChangedHandlers = {};
     /**
-     * Convert a UTF8 string to raw array.
-     * @param utf8 The text to decode.
-     * @returns The array.
+     * Change handler for the dictionaries being updated.
+     * @internal
      */
-    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));
-            }
+    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);
         }
-        return Uint8Array.from(bytes);
     }
     /**
-     * Encode a raw array to hex string.
-     * @param array The bytes to encode.
-     * @param includePrefix Include the 0x prefix on the returned hex.
-     * @param startIndex The index to start in the bytes.
-     * @param length The length of bytes to read.
-     * @param reverse Reverse the combine direction.
-     * @returns The array formatted as hex.
+     * Get the locale.
+     * @returns The current locale.
      */
-    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;
+    static getLocale() {
+        return I18n._currentLocale;
     }
     /**
-     * Decode a hex string to raw array.
-     * @param hex The hex to decode.
-     * @param reverse Store the characters in reverse.
-     * @returns The array.
+     * Add a locale dictionary.
+     * @param locale The locale.
+     * @param dictionary The dictionary to add.
      */
-    static hexToBytes(hex, reverse) {
-        const strippedHex = HexHelper.stripPrefix(hex);
-        const sizeof = strippedHex.length >> 1;
-        const length = sizeof << 1;
-        const array = new Uint8Array(sizeof);
-        this.buildHexLookups();
-        if (Converter._DECODE_LOOKUP) {
-            let i = 0;
-            let n = 0;
-            while (i < length) {
-                array[n++] =
-                    (Converter._DECODE_LOOKUP[strippedHex.charCodeAt(i++)] << 4) |
-                        Converter._DECODE_LOOKUP[strippedHex.charCodeAt(i++)];
-            }
-            if (reverse) {
-                array.reverse();
-            }
+    static addDictionary(locale, dictionary) {
+        const mergedKeys = {};
+        I18n.flattenTranslationKeys(dictionary, "", mergedKeys);
+        I18n._localeDictionaries[locale] = mergedKeys;
+        for (const callback in I18n._dictionaryChangedHandlers) {
+            I18n._dictionaryChangedHandlers[callback](I18n._currentLocale);
         }
-        return array;
     }
     /**
-     * Convert the UTF8 to hex.
-     * @param utf8 The text to convert.
-     * @param includePrefix Include the 0x prefix on the returned hex.
-     * @returns The hex version of the bytes.
+     * Get a locale dictionary.
+     * @param locale The locale.
+     * @returns The dictionary of undefined if it does not exist.
      */
-    static utf8ToHex(utf8, includePrefix = false) {
-        const hex = Converter.bytesToHex(Converter.utf8ToBytes(utf8));
-        return includePrefix ? HexHelper.addPrefix(hex) : hex;
+    static getDictionary(locale) {
+        return I18n._localeDictionaries[locale];
     }
     /**
-     * Convert the hex text to text.
-     * @param hex The hex to convert.
-     * @returns The UTF8 version of the bytes.
+     * Get all the locale dictionaries.
+     * @returns The dictionaries.
      */
-    static hexToUtf8(hex) {
-        return Converter.bytesToUtf8(Converter.hexToBytes(HexHelper.stripPrefix(hex)));
+    static getAllDictionaries() {
+        return I18n._localeDictionaries;
     }
     /**
-     * Convert bytes to binary string.
-     * @param bytes The bytes to convert.
-     * @returns A binary string of the bytes.
-     */
-    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("");
+     * Add a locale changed handler.
+     * @param id The id of the handler.
+     * @param handler The handler to add.
+     */
+    static addLocaleHandler(id, handler) {
+        I18n._localeChangedHandlers[id] = handler;
     }
     /**
-     * Convert a binary string to bytes.
-     * @param binary The binary string.
-     * @returns The bytes.
+     * Remove a locale changed handler.
+     * @param id The id of the handler.
      */
-    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;
+    static removeLocaleHandler(id) {
+        delete I18n._localeChangedHandlers[id];
     }
     /**
-     * Convert bytes to base64 string.
-     * @param bytes The bytes to convert.
-     * @returns A base64 string of the bytes.
+     * Add a dictionary changed handler.
+     * @param id The id of the handler.
+     * @param handler The handler to add.
      */
-    static bytesToBase64(bytes) {
-        return Base64.encode(bytes);
+    static addDictionaryHandler(id, handler) {
+        I18n._dictionaryChangedHandlers[id] = handler;
     }
     /**
-     * Convert a base64 string to bytes.
-     * @param base64 The base64 string.
-     * @returns The bytes.
+     * Remove a dictionary changed handler.
+     * @param id The id of the handler.
      */
-    static base64ToBytes(base64) {
-        return Base64.decode(base64);
+    static removeDictionaryHandler(id) {
+        delete I18n._dictionaryChangedHandlers[id];
     }
     /**
-     * Convert bytes to base64 url string.
-     * @param bytes The bytes to convert.
-     * @returns A base64 url string of the bytes.
+     * 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 bytesToBase64Url(bytes) {
-        return Base64Url.encode(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;
     }
     /**
-     * Convert a base64 url string to bytes.
-     * @param base64Url The base64 url string.
-     * @returns The 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.
      */
-    static base64UrlToBytes(base64Url) {
-        return Base64Url.decode(base64Url);
+    static hasMessage(key) {
+        return Is.string(I18n._localeDictionaries[I18n._currentLocale]?.[key]);
     }
     /**
-     * Build the static lookup tables.
+     * 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 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;
-                    }
-                }
+    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);
             }
         }
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
- * Class to help with objects.
+ * Error helper functions.
  */
-class ObjectHelper {
+class ErrorHelper {
     /**
-     * Runtime name for the class.
-     * @internal
+     * Format Errors and returns just their messages.
+     * @param error The error to format.
+     * @returns The error formatted including any inner errors.
      */
-    static _CLASS_NAME = "ObjectHelper";
+    static formatErrors(error) {
+        return ErrorHelper.localizeErrors(error).map(e => e.message);
+    }
     /**
-     * Convert an object to bytes.
-     * @param obj The object to convert.
-     * @param format Format the JSON content.
-     * @returns The object as bytes.
+     * 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 toBytes(obj, format = false) {
-        if (obj === undefined) {
-            return new Uint8Array();
+    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);
+            }
         }
-        const json = format ? JSON.stringify(obj, undefined, "\t") : JSON.stringify(obj);
-        return Converter.utf8ToBytes(json);
+        return formattedErrors;
     }
     /**
-     * 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.
+     * 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 fromBytes(bytes) {
-        if (Is.empty(bytes) || bytes.length === 0) {
-            return undefined;
+    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");
         }
-        try {
-            const utf8 = Converter.bytesToUtf8(bytes);
-            return JSON.parse(utf8);
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Coerce an object from one type to another.
+ */
+class Coerce {
+    /**
+     * Coerce the value to a string.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
+     */
+    static string(value) {
+        if (Is.undefined(value)) {
+            return value;
         }
-        catch (err) {
-            throw new GeneralError(ObjectHelper._CLASS_NAME, "failedBytesToJSON", undefined, err);
+        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();
         }
     }
     /**
-     * Make a deep clone of an object.
-     * @param obj The object to clone.
-     * @returns The objects clone.
+     * 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 clone(obj) {
-        if (Is.undefined(obj)) {
-            return undefined;
+    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();
         }
-        return structuredClone(obj);
     }
     /**
-     * Deep merge objects.
-     * @param obj1 The first object to merge.
-     * @param obj2 The second object to merge.
-     * @returns The combined deep merge of the objects.
+     * Coerce the value to a bigint.
+     * @param value The value to coerce.
+     * @throws TypeError If the value can not be coerced.
+     * @returns The value if it can be coerced.
      */
-    static merge(obj1, obj2) {
-        if (Is.empty(obj1)) {
-            return ObjectHelper.clone(obj2);
+    static bigint(value) {
+        if (Is.undefined(value)) {
+            return value;
         }
-        if (Is.empty(obj2)) {
-            return ObjectHelper.clone(obj1);
+        if (Is.bigint(value)) {
+            return value;
         }
-        const obj1Clone = ObjectHelper.clone(obj1);
-        if (Is.object(obj1Clone) && Is.object(obj2)) {
-            const keys = Object.keys(obj2);
-            for (const key of keys) {
-                if (Is.object(obj1Clone[key]) && Is.object(obj2[key])) {
-                    ObjectHelper.propertySet(obj1Clone, key, ObjectHelper.merge(obj1Clone[key], obj2[key]));
-                }
-                else {
-                    ObjectHelper.propertySet(obj1Clone, key, obj2[key]);
-                }
+        if (Is.number(value)) {
+            return BigInt(value);
+        }
+        if (Is.string(value)) {
+            const parsed = Number.parseFloat(value);
+            if (Is.integer(parsed)) {
+                return BigInt(parsed);
             }
         }
-        return obj1Clone;
+        if (Is.boolean(value)) {
+            return value ? 1n : 0n;
+        }
     }
     /**
-     * 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 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 equal(obj1, obj2, strictPropertyOrder) {
-        if (strictPropertyOrder ?? true) {
-            return JSON.stringify(obj1) === JSON.stringify(obj2);
+    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 JsonHelper.canonicalize(obj1) === JsonHelper.canonicalize(obj2);
     }
     /**
-     * Get the property of an unknown object.
-     * @param obj The object to get the property from.
-     * @param property The property to get, can be separated by dots for nested path.
-     * @returns The property.
+     * Coerce the value to a date.
+     * @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 date(value) {
+        if (Is.undefined(value)) {
             return value;
         }
-        return Is.object(obj) ? obj[property] : undefined;
+        if (Is.date(value)) {
+            return value;
+        }
+        if (Is.number(value)) {
+            return new Date(value);
+        }
+        if (Is.string(value)) {
+            const dt = new Date(value);
+            if (!Number.isNaN(dt.getTime())) {
+                const utc = Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate());
+                return new Date(utc);
+            }
+        }
     }
     /**
-     * Set the property of an unknown object.
-     * @param obj The object to set the property from.
-     * @param property The property to set.
-     * @param value The value to set.
+     * Coerce the value to a 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 propertySet(obj, property, value) {
-        if (Is.object(obj)) {
-            obj[property] = value;
+    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);
+            }
         }
     }
     /**
-     * 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 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 propertyDelete(obj, property) {
-        if (Is.object(obj)) {
-            delete obj[property];
+    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);
+            }
         }
     }
     /**
-     * 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.
+     * 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 pick(obj, keys) {
-        if (Is.object(obj) && Is.arrayValue(keys)) {
-            const result = {};
-            for (const key of keys) {
-                result[key] = obj[key];
+    static object(value) {
+        if (Is.undefined(value)) {
+            return value;
+        }
+        if (Is.object(value)) {
+            return value;
+        }
+        if (Is.stringValue(value)) {
+            try {
+                return JSON.parse(value);
             }
-            return result;
+            catch { }
         }
-        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;
     }
 }
 
@@ -2883,7 +3137,7 @@ const CompressionType = {
      */
     Gzip: "gzip",
     /**
-     * deflate.
+     * Deflate.
      */
     Deflate: "deflate"
 };
@@ -3506,6 +3760,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 +3779,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,6 +4483,7 @@ exports.AlreadyExistsError = AlreadyExistsError;
 exports.ArrayHelper = ArrayHelper;
 exports.AsyncCache = AsyncCache;
 exports.Base32 = Base32;
+exports.Base58 = Base58;
 exports.Base64 = Base64;
 exports.Base64Url = Base64Url;
 exports.BaseError = BaseError;
@@ -4197,6 +4494,7 @@ exports.Compression = Compression;
 exports.CompressionType = CompressionType;
 exports.ConflictError = ConflictError;
 exports.Converter = Converter;
+exports.EnvHelper = EnvHelper;
 exports.ErrorHelper = ErrorHelper;
 exports.Factory = Factory;
 exports.FilenameHelper = FilenameHelper;