@twin.org/core 0.0.2-next.3 → 0.0.2-next.5

package/dist/esm/index.mjs

@@ -629,31 +629,33 @@ class BaseError extends Error {
      */
     properties;
     /**
-     * The inner error if there was one.
+     * The cause of the error.
      */
-    inner;
+    cause;
     /**
      * Create a new instance of BaseError.
      * @param name The name of the error.
      * @param source The source of the error.
      * @param message The message as a code.
      * @param properties Any additional information for the error.
-     * @param inner The inner error if we have wrapped another error.
+     * @param cause The cause of error if we have wrapped another error.
      */
-    constructor(name, source, message, properties, inner) {
+    constructor(name, source, message, properties, cause) {
         super(message);
         this.name = name;
         this.source = source;
+        this.cause = Is.notEmpty(cause) ? BaseError.fromError(cause).toJsonObject(true) : undefined;
+        this.properties = properties;
         // If the message is camel case but has no namespace then prefix it
-        // with the source name in camel case
+        // with the source name in camel case.
         if (Is.stringValue(source) &&
             Is.stringValue(message) &&
             !message.includes(".") &&
+            // This comparison checks that it is most likely a camel case name
+            // and not a free text error with a dot in it
             StringHelper.camelCase(message) === message) {
             this.message = `${StringHelper.camelCase(source)}.${message}`;
         }
-        this.properties = properties;
-        this.inner = inner ? BaseError.fromError(inner).toJsonObject() : undefined;
     }
     /**
      * Construct an error from an existing one.
@@ -665,7 +667,7 @@ class BaseError extends Error {
         let message;
         let source;
         let properties;
-        let inner;
+        let cause;
         let stack;
         if (Is.object(err) && Is.stringValue(err.error)) {
             message = err.error;
@@ -683,8 +685,12 @@ class BaseError extends Error {
             if (Is.notEmpty(err.properties)) {
                 properties = err.properties;
             }
-            if (Is.notEmpty(err.inner)) {
-                inner = err.inner;
+            if (BaseError.isAggregateError(err)) {
+                properties ??= {};
+                properties.errors = err.errors;
+            }
+            if (Is.notEmpty(err.cause)) {
+                cause = err.cause;
             }
             if (Is.notEmpty(err.stack)) {
                 stack = err.stack;
@@ -696,7 +702,7 @@ class BaseError extends Error {
         else {
             message = JSON.stringify(err);
         }
-        const baseError = new BaseError(name, source ?? "", message ?? "", properties, inner);
+        const baseError = new BaseError(name, source ?? "", message ?? "", properties, cause);
         baseError.stack = stack;
         return baseError;
     }
@@ -709,10 +715,10 @@ class BaseError extends Error {
         const flattened = [];
         let e = BaseError.fromError(err).toJsonObject(true);
         while (e) {
-            const inner = e.inner;
-            e.inner = undefined;
+            const cause = e.cause;
+            e.cause = undefined;
             flattened.push(e);
-            e = inner;
+            e = cause;
         }
         return flattened;
     }
@@ -727,8 +733,8 @@ class BaseError extends Error {
             first = errors[0];
             let current = first;
             for (let i = 1; i < errors.length; i++) {
-                current.inner = errors[i];
-                current = current.inner;
+                current.cause = errors[i];
+                current = current.cause;
             }
         }
         return first;
@@ -802,7 +808,7 @@ class BaseError extends Error {
         return BaseError.flatten(error).some(e => BaseError.isErrorCode(e, code));
     }
     /**
-     * Is the error empty.
+     * Is the error empty, i.e. does it have no message, source, properties, or cause?
      * @param err The error to check for being empty.
      * @returns True if the error is empty.
      */
@@ -810,7 +816,27 @@ class BaseError extends Error {
         return (!Is.stringValue(err.message) &&
             !Is.stringValue(err.source) &&
             !Is.objectValue(err.properties) &&
-            Is.empty(err.inner));
+            Is.empty(err.cause));
+    }
+    /**
+     * Is the error an aggregate error.
+     * @param err The error to check for being an aggregate error.
+     * @returns True if the error is an aggregate error.
+     */
+    static isAggregateError(err) {
+        return err instanceof AggregateError;
+    }
+    /**
+     * Convert the aggregate error to an array of errors.
+     * @param err The error to convert.
+     * @param includeStackTrace Whether to include the error stack in the model, defaults to false.
+     * @returns The array of errors.
+     */
+    static fromAggregate(err, includeStackTrace) {
+        if (BaseError.isAggregateError(err)) {
+            return err.errors.map(e => BaseError.fromError(e).toJsonObject(includeStackTrace));
+        }
+        return [BaseError.fromError(err).toJsonObject(includeStackTrace)];
     }
     /**
      * Serialize the error to the error model.
@@ -834,8 +860,8 @@ class BaseError extends Error {
         if ((includeStackTrace ?? false) && Is.stringValue(this.stack)) {
             err.stack = this.stack;
         }
-        if (Is.notEmpty(this.inner)) {
-            err.inner = BaseError.fromError(this.inner).toJsonObject(includeStackTrace);
+        if (Is.notEmpty(this.cause)) {
+            err.cause = BaseError.fromError(this.cause).toJsonObject(includeStackTrace);
         }
         return err;
     }
@@ -854,1062 +880,1073 @@ class GeneralError extends BaseError {
      * @param source The source of the error.
      * @param message The message as a code.
      * @param properties Any additional information for the error.
-     * @param inner The inner error if we have wrapped another error.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    constructor(source, message, properties, inner) {
-        super(GeneralError.CLASS_NAME, source, message, properties, inner);
+    constructor(source, message, properties, cause) {
+        super(GeneralError.CLASS_NAME, source, message, properties, cause);
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
 /**
- * Class to help with base63 Encoding/Decoding.
+ * Class to handle errors which are triggered by data guards.
  */
-class Base32 {
+class GuardError extends BaseError {
     /**
      * Runtime name for the class.
-     * @internal
-     */
-    static _CLASS_NAME = "Base32";
-    /**
-     * Alphabet table for encoding.
-     * @internal
      */
-    static _ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-    /**
-     * Convert the base 32 string to a byte array.
-     * @param base32 The base32 string to convert.
-     * @returns The byte array.
-     * @throws If the input string contains a character not in the Base32 alphabet.
-     */
-    static decode(base32) {
-        let bits = 0;
-        let value = 0;
-        base32 = base32.replace(/=+$/, "");
-        let index = 0;
-        const output = new Uint8Array(Math.trunc((base32.length * 5) / 8));
-        for (let i = 0; i < base32.length; i++) {
-            const idx = Base32._ALPHABET.indexOf(base32[i]);
-            if (idx === -1) {
-                throw new GeneralError(Base32._CLASS_NAME, "invalidCharacter", {
-                    invalidCharacter: base32[i]
-                });
-            }
-            value = (value << 5) | idx;
-            bits += 5;
-            if (bits >= 8) {
-                output[index++] = (value >>> (bits - 8)) & 255;
-                bits -= 8;
-            }
-        }
-        return output;
-    }
+    static CLASS_NAME = "GuardError";
     /**
-     * Convert a byte array to base 32.
-     * @param bytes The byte array to convert.
-     * @returns The data as base32 string.
+     * Create a new instance of GuardError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param propertyName The property which triggered the guard error for the item.
+     * @param propertyValue The property value which triggered the guard error for the item.
+     * @param propertyOptions The property options which might be allowed.
      */
-    static encode(bytes) {
-        let bits = 0;
-        let value = 0;
-        let output = "";
-        for (let i = 0; i < bytes.byteLength; i++) {
-            value = (value << 8) | bytes[i];
-            bits += 8;
-            while (bits >= 5) {
-                output += Base32._ALPHABET[(value >>> (bits - 5)) & 31];
-                bits -= 5;
-            }
-        }
-        if (bits > 0) {
-            output += Base32._ALPHABET[(value << (5 - bits)) & 31];
-        }
-        while (output.length % 8 !== 0) {
-            output += "=";
-        }
-        return output;
+    constructor(source, message, propertyName, propertyValue, propertyOptions) {
+        super(GuardError.CLASS_NAME, source, message, {
+            property: propertyName ?? "property",
+            value: Is.undefined(propertyValue) ? "undefined" : propertyValue,
+            options: propertyOptions
+        });
     }
 }
 
 /**
- * Class to help with base58 Encoding/Decoding.
+ * Class to help with arrays.
  */
-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
-    ];
+class ArrayHelper {
     /**
-     * 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.
+     * Do the two arrays match.
+     * @param arr1 The first array.
+     * @param arr2 The second array.
+     * @returns True if both arrays are empty of have the same values.
      */
-    static decode(base58) {
-        let zeroes = 0;
-        for (let i = 0; i < base58.length; i++) {
-            if (base58[i] !== "1") {
-                break;
-            }
-            zeroes += 1;
+    static matches(arr1, arr2) {
+        if (Is.empty(arr1) && Is.empty(arr2)) {
+            return true;
         }
-        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;
+        if (!((Is.array(arr1) && Is.array(arr2)) || (Is.typedArray(arr1) && Is.typedArray(arr2)))) {
+            return false;
         }
-        const out = new Uint8Array(zeroes + length);
-        let j;
-        for (j = 0; j < zeroes; j++) {
-            out[j] = 0;
+        if (arr1.length !== arr2.length) {
+            return false;
         }
-        let i = size - length;
-        while (i < size) {
-            out[j++] = b256[i++];
+        for (let i = 0; i < arr1.length; i++) {
+            if (arr1[i] !== arr2[i]) {
+                return false;
+            }
         }
-        return out;
+        return true;
     }
     /**
-     * Convert a byte array to base 58.
-     * @param bytes The byte array to encode.
-     * @returns The data as base58 string.
+     * Convert an object or array to an array.
+     * @param value The object or array to convert.
+     * @returns The array.
      */
-    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";
+    static fromObjectOrArray(value) {
+        if (Is.empty(value)) {
+            return undefined;
         }
-        while (i < size) {
-            str += Base58._ALPHABET[b58[i++]];
+        if (Is.array(value)) {
+            return value;
         }
-        return str;
+        return [value];
     }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
-/* eslint-disable no-mixed-operators */
 /**
- * Class to help with base64 Encoding/Decoding.
- * Sourced from https://github.com/beatgammit/base64-js.
+ * Class to handle guard operations for parameters.
  */
-class Base64 {
+class Guards {
     /**
-     * Runtime name for the class.
-     * @internal
+     * Is the property defined.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static _CLASS_NAME = "Base64";
+    static defined(source, property, value) {
+        if (Is.undefined(value)) {
+            throw new GuardError(source, "guard.undefined", property, value);
+        }
+    }
     /**
-     * Alphabet table for encoding.
-     * @internal
+     * Is the property a string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static _LOOKUP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    static string(source, property, value) {
+        if (!Is.string(value)) {
+            throw new GuardError(source, "guard.string", property, value);
+        }
+    }
     /**
-     * Alphabet table for decoding.
-     * @internal
-     */
-    static _REVERSE_LOOKUP = {
-        "43": 62,
-        "45": 62,
-        "47": 63,
-        "48": 52,
-        "49": 53,
-        "50": 54,
-        "51": 55,
-        "52": 56,
-        "53": 57,
-        "54": 58,
-        "55": 59,
-        "56": 60,
-        "57": 61,
-        "65": 0,
-        "66": 1,
-        "67": 2,
-        "68": 3,
-        "69": 4,
-        "70": 5,
-        "71": 6,
-        "72": 7,
-        "73": 8,
-        "74": 9,
-        "75": 10,
-        "76": 11,
-        "77": 12,
-        "78": 13,
-        "79": 14,
-        "80": 15,
-        "81": 16,
-        "82": 17,
-        "83": 18,
-        "84": 19,
-        "85": 20,
-        "86": 21,
-        "87": 22,
-        "88": 23,
-        "89": 24,
-        "90": 25,
-        "95": 63,
-        "97": 26,
-        "98": 27,
-        "99": 28,
-        "100": 29,
-        "101": 30,
-        "102": 31,
-        "103": 32,
-        "104": 33,
-        "105": 34,
-        "106": 35,
-        "107": 36,
-        "108": 37,
-        "109": 38,
-        "110": 39,
-        "111": 40,
-        "112": 41,
-        "113": 42,
-        "114": 43,
-        "115": 44,
-        "116": 45,
-        "117": 46,
-        "118": 47,
-        "119": 48,
-        "120": 49,
-        "121": 50,
-        "122": 51
-    };
-    /**
-     * Get the byte length of the data.
-     * @param base64 The base64 string.
-     * @returns The byte length of the data.
+     * Is the property a string with a value.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static byteLength(base64) {
-        const lens = Base64.getLengths(base64);
-        return Base64.calcByteLength(lens[0], lens[1]);
+    static stringValue(source, property, value) {
+        if (!Is.string(value)) {
+            throw new GuardError(source, "guard.string", property, value);
+        }
+        if (value.length === 0) {
+            throw new GuardError(source, "guard.stringEmpty", property, value);
+        }
     }
     /**
-     * Convert the base 64 string to a byte array.
-     * @param base64 The base64 string to convert.
-     * @returns The byte array.
+     * 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 decode(base64) {
-        let tmp;
-        const lens = Base64.getLengths(base64);
-        const validLen = lens[0];
-        const placeHoldersLen = lens[1];
-        const arr = new Uint8Array(Base64.calcByteLength(validLen, placeHoldersLen));
-        let curByte = 0;
-        // if there are placeholders, only get up to the last complete 4 chars
-        const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
-        let i;
-        for (i = 0; i < len; i += 4) {
-            tmp =
-                (Base64._REVERSE_LOOKUP[base64.charCodeAt(i)] << 18) |
-                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 1)] << 12) |
-                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 2)] << 6) |
-                    Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 3)];
-            arr[curByte++] = (tmp >> 16) & 0xff;
-            arr[curByte++] = (tmp >> 8) & 0xff;
-            arr[curByte++] = tmp & 0xff;
+    static json(source, property, value) {
+        if (!Is.json(value)) {
+            throw new GuardError(source, "guard.stringJson", property, value);
         }
-        if (placeHoldersLen === 2) {
-            tmp =
-                (Base64._REVERSE_LOOKUP[base64.charCodeAt(i)] << 2) |
-                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 1)] >> 4);
-            arr[curByte++] = tmp & 0xff;
+    }
+    /**
+     * Is the property a base64 string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringBase64(source, property, value) {
+        if (!Is.stringBase64(value)) {
+            throw new GuardError(source, "guard.base64", property, value);
         }
-        if (placeHoldersLen === 1) {
-            tmp =
-                (Base64._REVERSE_LOOKUP[base64.charCodeAt(i)] << 10) |
-                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 1)] << 4) |
-                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 2)] >> 2);
-            arr[curByte++] = (tmp >> 8) & 0xff;
-            arr[curByte++] = tmp & 0xff;
+    }
+    /**
+     * Is the property a base64 url string.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringBase64Url(source, property, value) {
+        if (!Is.stringBase64Url(value)) {
+            throw new GuardError(source, "guard.base64Url", property, value);
         }
-        return arr;
     }
     /**
-     * Convert a byte array to base 64.
-     * @param bytes The byte array to convert.
-     * @returns The data as base64 string.
+     * 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 encode(bytes) {
-        let tmp;
-        const len = bytes.length;
-        const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
-        const parts = [];
-        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, Math.min(i + maxChunkLength, len2)));
+    static stringBase58(source, property, value) {
+        if (!Is.stringBase58(value)) {
+            throw new GuardError(source, "guard.base58", property, value);
         }
-        // pad the end with zeros, but make sure to not forget the extra bytes
-        if (extraBytes === 1) {
-            tmp = bytes[len - 1];
-            parts.push(`${Base64._LOOKUP[tmp >> 2] + Base64._LOOKUP[(tmp << 4) & 0x3f]}==`);
+    }
+    /**
+     * Is the property a string with a hex value.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param allowPrefix Allow the hex to have the 0x prefix.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringHex(source, property, value, allowPrefix = false) {
+        Guards.stringValue(source, property, value);
+        if (!HexHelper.isHex(value, allowPrefix)) {
+            throw new GuardError(source, "guard.stringHex", property, value);
         }
-        else if (extraBytes === 2) {
-            tmp = (bytes[len - 2] << 8) + bytes[len - 1];
-            parts.push(`${Base64._LOOKUP[tmp >> 10] + Base64._LOOKUP[(tmp >> 4) & 0x3f] + Base64._LOOKUP[(tmp << 2) & 0x3f]}=`);
+    }
+    /**
+     * Is the property a string with a hex value with fixed length.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param length The length of the string to match.
+     * @param allowPrefix Allow the hex to have the 0x prefix.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static stringHexLength(source, property, value, length, allowPrefix = false) {
+        Guards.stringHex(source, property, value, allowPrefix);
+        if (HexHelper.stripPrefix(value).length !== length) {
+            throw new GuardError(source, "guard.stringHexLength", property, value.length, length.toString());
         }
-        return parts.join("");
     }
     /**
-     * Calculate the byte length.
-     * @param validLen The valid length.
-     * @param placeHoldersLen The placeholder length.
-     * @returns The length.
-     * @internal
+     * Is the property a number.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static calcByteLength(validLen, placeHoldersLen) {
-        return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+    static number(source, property, value) {
+        if (!Is.number(value)) {
+            throw new GuardError(source, "guard.number", property, value);
+        }
     }
     /**
-     * Get the valid and placeholder lengths from a bas64 string.
-     * @param base64 The base64 string.
-     * @returns The lengths.
-     * @internal
+     * Is the property an integer.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static getLengths(base64) {
-        const len = base64.length;
-        if (len % 4 > 0) {
-            throw new GeneralError(Base64._CLASS_NAME, "length4Multiple", { value: len });
+    static integer(source, property, value) {
+        if (!Is.integer(value)) {
+            throw new GuardError(source, "guard.integer", property, value);
         }
-        // Trim off extra bytes after placeholder bytes are found
-        // See: https://github.com/beatgammit/base64-js/issues/42
-        let validLen = base64.indexOf("=");
-        if (validLen === -1) {
-            validLen = len;
+    }
+    /**
+     * Is the property a bigint.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
+     */
+    static bigint(source, property, value) {
+        if (!Is.bigint(value)) {
+            throw new GuardError(source, "guard.bigint", property, value);
         }
-        const placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
-        return [validLen, placeHoldersLen];
     }
     /**
-     * Convert the triplet to base 64.
-     * @param num The number to convert.
-     * @returns The base64 encoding.
-     * @internal
+     * Is the property a boolean.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static tripletToBase64(num) {
-        return (Base64._LOOKUP[(num >> 18) & 0x3f] +
-            Base64._LOOKUP[(num >> 12) & 0x3f] +
-            Base64._LOOKUP[(num >> 6) & 0x3f] +
-            Base64._LOOKUP[num & 0x3f]);
+    static boolean(source, property, value) {
+        if (!Is.boolean(value)) {
+            throw new GuardError(source, "guard.boolean", property, value);
+        }
     }
     /**
-     * Encode a chunk.
-     * @param bytes The byte array.
-     * @param start The start index in the buffer.
-     * @param end The end index in the buffer.
-     * @returns The encoded chunk.
-     * @internal
+     * Is the property a date.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static encodeChunk(bytes, start, end) {
-        let tmp;
-        const output = [];
-        for (let i = start; i < end; i += 3) {
-            tmp = ((bytes[i] << 16) & 0xff0000) + ((bytes[i + 1] << 8) & 0xff00) + (bytes[i + 2] & 0xff);
-            output.push(Base64.tripletToBase64(tmp));
+    static date(source, property, value) {
+        if (!Is.date(value)) {
+            throw new GuardError(source, "guard.date", property, value);
         }
-        return output.join("");
     }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to help with base64 URL Encoding/Decoding.
- * https://www.rfc-editor.org/rfc/rfc4648#section-5.
- */
-class Base64Url {
     /**
-     * Convert the base 64 string to a byte array.
-     * @param base64Url The base64 url string to convert.
-     * @returns The byte array.
+     * Is the property a timestamp in milliseconds.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static decode(base64Url) {
-        let base64 = base64Url;
-        // Base 64 url can have padding removed, so add it back if it is missing.
-        if (base64.length > 0 && !base64.endsWith("=")) {
-            const placeHoldersLen = 4 - (base64.length % 4);
-            if (placeHoldersLen > 0 && placeHoldersLen < 4) {
-                base64 = base64.padEnd(base64.length + placeHoldersLen, "=");
-            }
+    static timestampMilliseconds(source, property, value) {
+        if (!Is.timestampMilliseconds(value)) {
+            throw new GuardError(source, "guard.timestampMilliseconds", property, value);
         }
-        base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
-        return Base64.decode(base64);
     }
     /**
-     * Convert a byte array to base 64 url.
-     * @param bytes The byte array to convert.
-     * @returns The data as base64 url string.
+     * Is the property a timestamp in seconds.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static encode(bytes) {
-        const base64 = Base64.encode(bytes);
-        // Base 64 url can have padding removed, so remove it.
-        return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    static timestampSeconds(source, property, value) {
+        if (!Is.timestampSeconds(value)) {
+            throw new GuardError(source, "guard.timestampSeconds", property, value);
+        }
     }
-}
-
-/**
- * Class to handle errors which are triggered by data already existing.
- */
-class AlreadyExistsError extends BaseError {
     /**
-     * Runtime name for the class.
+     * Is the property an object.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static CLASS_NAME = "AlreadyExistsError";
+    static object(source, property, value) {
+        if (Is.undefined(value)) {
+            throw new GuardError(source, "guard.objectUndefined", property, value);
+        }
+        if (!Is.object(value)) {
+            throw new GuardError(source, "guard.object", property, value);
+        }
+    }
     /**
-     * Create a new instance of AlreadyExistsError.
+     * Is the property is an object with at least one property.
      * @param source The source of the error.
-     * @param message The message as a code.
-     * @param existingId The id for the item.
-     * @param inner The inner error if we have wrapped another error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    constructor(source, message, existingId, inner) {
-        super(AlreadyExistsError.CLASS_NAME, source, message, { existingId }, inner);
+    static objectValue(source, property, value) {
+        if (Is.undefined(value)) {
+            throw new GuardError(source, "guard.objectUndefined", property, value);
+        }
+        if (!Is.object(value)) {
+            throw new GuardError(source, "guard.object", property, value);
+        }
+        if (Object.keys(value || {}).length === 0) {
+            throw new GuardError(source, "guard.objectValue", property, value);
+        }
     }
-}
-
-/**
- * Class to handle errors which are triggered by conflicting data.
- */
-class ConflictError extends BaseError {
     /**
-     * Runtime name for the class.
+     * Is the property is an array.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static CLASS_NAME = "ConflictError";
+    static array(source, property, value) {
+        if (!Is.array(value)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+    }
     /**
-     * Create a new instance of ConflictError.
+     * Is the property is an array with at least one item.
      * @param source The source of the error.
-     * @param message The message as a code.
-     * @param conflictId The id that has conflicts.
-     * @param conflicts The conflicts that occurred.
-     * @param inner The inner error if we have wrapped another error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    constructor(source, message, conflictId, conflicts, inner) {
-        super(ConflictError.CLASS_NAME, source, message, { conflictId, conflicts }, inner);
+    static arrayValue(source, property, value) {
+        if (!Is.array(value)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+        if (value.length === 0) {
+            throw new GuardError(source, "guard.arrayValue", property, value);
+        }
     }
-}
-
-/**
- * Class to handle errors which are triggered by data guards.
- */
-class GuardError extends BaseError {
     /**
-     * Runtime name for the class.
+     * Is the property one of a list of items.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @param options The options the value must be one of.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static CLASS_NAME = "GuardError";
+    static arrayOneOf(source, property, value, options) {
+        if (!Is.array(options)) {
+            throw new GuardError(source, "guard.array", property, value);
+        }
+        if (!options.includes(value)) {
+            throw new GuardError(source, "guard.arrayOneOf", property, value, options.join(", "));
+        }
+    }
     /**
-     * Create a new instance of GuardError.
+     * Does the array start with the specified data.
      * @param source The source of the error.
-     * @param message The message as a code.
-     * @param propertyName The property which triggered the guard error for the item.
-     * @param propertyValue The property value which triggered the guard error for the item.
-     * @param propertyOptions The property options which might be allowed.
+     * @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.
      */
-    constructor(source, message, propertyName, propertyValue, propertyOptions) {
-        super(GuardError.CLASS_NAME, source, message, {
-            property: propertyName ?? "property",
-            value: Is.undefined(propertyValue) ? "undefined" : propertyValue,
-            options: propertyOptions
-        });
+    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(", "));
+            }
+        }
     }
-}
-
-/**
- * Class to handle errors which are triggered by data not being found.
- */
-class NotFoundError extends BaseError {
     /**
-     * Runtime name for the class.
+     * 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 CLASS_NAME = "NotFoundError";
+    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(", "));
+            }
+        }
+    }
     /**
-     * Create a new instance of NotFoundError.
+     * Is the property a Uint8Array.
      * @param source The source of the error.
-     * @param message The message as a code.
-     * @param notFoundId The id for the item.
-     * @param inner The inner error if we have wrapped another error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @throws GuardError If the value does not match the assertion.
      */
-    constructor(source, message, notFoundId, inner) {
-        super(NotFoundError.CLASS_NAME, source, message, { notFoundId }, inner);
+    static uint8Array(source, property, value) {
+        if (!Is.uint8Array(value)) {
+            throw new GuardError(source, "guard.uint8Array", property, value);
+        }
     }
-}
-
-/**
- * Class to handle errors.
- */
-class NotImplementedError extends BaseError {
     /**
-     * Runtime name for the class.
+     * Is the property a function.
+     * @param source The source of the error.
+     * @param property The name of the property.
+     * @param value The value to test.
+     * @returns True if the value is a function.
+     * @throws GuardError If the value does not match the assertion.
      */
-    static CLASS_NAME = "NotImplementedError";
+    static function(source, property, value) {
+        if (!Is.function(value)) {
+            throw new GuardError(source, "guard.function", property, value);
+        }
+        return true;
+    }
     /**
-     * Create a new instance of NotImplementedError.
+     * Is the property a string formatted as an email address.
      * @param source The source of the error.
-     * @param method The method for 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.
      */
-    constructor(source, method) {
-        super(NotImplementedError.CLASS_NAME, source, "common.notImplementedMethod", {
-            method
-        });
+    static email(source, property, value) {
+        if (!Is.email(value)) {
+            throw new GuardError(source, "guard.email", property, value);
+        }
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
 /**
- * Class to handle errors when a feature is unsupported.
+ * Class to help with base63 Encoding/Decoding.
  */
-class NotSupportedError extends BaseError {
+class Base32 {
     /**
      * Runtime name for the class.
+     * @internal
      */
-    static CLASS_NAME = "NotSupportedError";
+    static _CLASS_NAME = "Base32";
     /**
-     * Create a new instance of NotSupportedError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param inner The inner error if we have wrapped another error.
+     * Alphabet table for encoding.
+     * @internal
      */
-    constructor(source, message, inner) {
-        super(NotSupportedError.CLASS_NAME, source, message, undefined, inner);
-    }
-}
-
-/**
- * Class to handle errors which are triggered by access not being unauthorized.
- */
-class UnauthorizedError extends BaseError {
+    static _ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
     /**
-     * Runtime name for the class.
+     * Convert the base 32 string to a byte array.
+     * @param base32 The base32 string to convert.
+     * @returns The byte array.
+     * @throws If the input string contains a character not in the Base32 alphabet.
      */
-    static CLASS_NAME = "UnauthorizedError";
+    static decode(base32) {
+        Guards.string(Base32._CLASS_NAME, "base32", base32);
+        let bits = 0;
+        let value = 0;
+        base32 = base32.replace(/=+$/, "");
+        let index = 0;
+        const output = new Uint8Array(Math.trunc((base32.length * 5) / 8));
+        for (let i = 0; i < base32.length; i++) {
+            const idx = Base32._ALPHABET.indexOf(base32[i]);
+            if (idx === -1) {
+                throw new GeneralError(Base32._CLASS_NAME, "invalidCharacter", {
+                    invalidCharacter: base32[i]
+                });
+            }
+            value = (value << 5) | idx;
+            bits += 5;
+            if (bits >= 8) {
+                output[index++] = (value >>> (bits - 8)) & 255;
+                bits -= 8;
+            }
+        }
+        return output;
+    }
     /**
-     * Create a new instance of UnauthorizedError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param inner The inner error if we have wrapped another error.
+     * Convert a byte array to base 32.
+     * @param bytes The byte array to convert.
+     * @returns The data as base32 string.
      */
-    constructor(source, message, inner) {
-        super(UnauthorizedError.CLASS_NAME, source, message, undefined, inner);
+    static encode(bytes) {
+        Guards.uint8Array(Base32._CLASS_NAME, "bytes", bytes);
+        let bits = 0;
+        let value = 0;
+        let output = "";
+        for (let i = 0; i < bytes.byteLength; i++) {
+            value = (value << 8) | bytes[i];
+            bits += 8;
+            while (bits >= 5) {
+                output += Base32._ALPHABET[(value >>> (bits - 5)) & 31];
+                bits -= 5;
+            }
+        }
+        if (bits > 0) {
+            output += Base32._ALPHABET[(value << (5 - bits)) & 31];
+        }
+        while (output.length % 8 !== 0) {
+            output += "=";
+        }
+        return output;
     }
 }
 
 /**
- * Class to handle errors when some data can not be processed.
+ * Class to help with base58 Encoding/Decoding.
  */
-class UnprocessableError extends BaseError {
+class Base58 {
     /**
      * Runtime name for the class.
+     * @internal
      */
-    static CLASS_NAME = "UnprocessableError";
-    /**
-     * Create a new instance of UnprocessableError.
-     * @param source The source of the error.
-     * @param message The message as a code.
-     * @param properties Any additional information for the error.
-     * @param inner The inner error if we have wrapped another error.
-     */
-    constructor(source, message, properties, inner) {
-        super(UnprocessableError.CLASS_NAME, source, message, properties, inner);
-    }
-}
-
-/**
- * Class to handle errors which are triggered by entity validation.
- */
-class ValidationError extends BaseError {
+    static _CLASS_NAME = "Base58";
     /**
-     * Runtime name for the class.s
+     * Alphabet table for encoding.
+     * @internal
      */
-    static CLASS_NAME = "ValidationError";
+    static _ALPHABET = 
+    // cspell:disable-next-line
+    "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
     /**
-     * Create a new instance of ValidationError.
-     * @param source The source of the error.
-     * @param validationObject The object that failed validation.
-     * @param validationFailures The validation failures.
+     * Reverse map for decoding.
+     * @internal
      */
-    constructor(source, validationObject, validationFailures) {
-        super(ValidationError.CLASS_NAME, source, "common.validation", {
-            validationObject,
-            validationFailures
-        });
-    }
-}
-
-/**
- * Class to help with arrays.
- */
-class ArrayHelper {
+    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
+    ];
     /**
-     * Do the two arrays match.
-     * @param arr1 The first array.
-     * @param arr2 The second array.
-     * @returns True if both arrays are empty of have the same values.
+     * Convert 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 matches(arr1, arr2) {
-        if (Is.empty(arr1) && Is.empty(arr2)) {
-            return true;
+    static decode(base58) {
+        Guards.string(Base58._CLASS_NAME, "base58", base58);
+        let zeroes = 0;
+        for (let i = 0; i < base58.length; i++) {
+            if (base58[i] !== "1") {
+                break;
+            }
+            zeroes += 1;
         }
-        if (!((Is.array(arr1) && Is.array(arr2)) || (Is.typedArray(arr1) && Is.typedArray(arr2)))) {
-            return false;
+        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;
         }
-        if (arr1.length !== arr2.length) {
-            return false;
+        const out = new Uint8Array(zeroes + length);
+        let j;
+        for (j = 0; j < zeroes; j++) {
+            out[j] = 0;
         }
-        for (let i = 0; i < arr1.length; i++) {
-            if (arr1[i] !== arr2[i]) {
-                return false;
-            }
+        let i = size - length;
+        while (i < size) {
+            out[j++] = b256[i++];
         }
-        return true;
+        return out;
     }
     /**
-     * Convert an object or array to an array.
-     * @param value The object or array to convert.
-     * @returns The array.
+     * Convert a byte array to base 58.
+     * @param bytes The byte array to encode.
+     * @returns The data as base58 string.
      */
-    static fromObjectOrArray(value) {
-        if (Is.empty(value)) {
-            return undefined;
+    static encode(bytes) {
+        Guards.uint8Array(Base58._CLASS_NAME, "bytes", bytes);
+        let zeroes = 0;
+        for (let i = 0; i < bytes.length; i++) {
+            if (bytes[i] !== 0) {
+                break;
+            }
+            zeroes += 1;
         }
-        if (Is.array(value)) {
-            return value;
+        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;
         }
-        return [value];
+        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 */
+/* eslint-disable no-mixed-operators */
 /**
- * Class to handle guard operations for parameters.
+ * Class to help with base64 Encoding/Decoding.
+ * Sourced from https://github.com/beatgammit/base64-js.
  */
-class Guards {
+class Base64 {
     /**
-     * Is the property defined.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
+     * @internal
      */
-    static defined(source, property, value) {
-        if (Is.undefined(value)) {
-            throw new GuardError(source, "guard.undefined", property, value);
-        }
-    }
+    static _CLASS_NAME = "Base64";
+    /**
+     * Alphabet table for encoding.
+     * @internal
+     */
+    static _LOOKUP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    /**
+     * Alphabet table for decoding.
+     * @internal
+     */
+    static _REVERSE_LOOKUP = {
+        "43": 62,
+        "45": 62,
+        "47": 63,
+        "48": 52,
+        "49": 53,
+        "50": 54,
+        "51": 55,
+        "52": 56,
+        "53": 57,
+        "54": 58,
+        "55": 59,
+        "56": 60,
+        "57": 61,
+        "65": 0,
+        "66": 1,
+        "67": 2,
+        "68": 3,
+        "69": 4,
+        "70": 5,
+        "71": 6,
+        "72": 7,
+        "73": 8,
+        "74": 9,
+        "75": 10,
+        "76": 11,
+        "77": 12,
+        "78": 13,
+        "79": 14,
+        "80": 15,
+        "81": 16,
+        "82": 17,
+        "83": 18,
+        "84": 19,
+        "85": 20,
+        "86": 21,
+        "87": 22,
+        "88": 23,
+        "89": 24,
+        "90": 25,
+        "95": 63,
+        "97": 26,
+        "98": 27,
+        "99": 28,
+        "100": 29,
+        "101": 30,
+        "102": 31,
+        "103": 32,
+        "104": 33,
+        "105": 34,
+        "106": 35,
+        "107": 36,
+        "108": 37,
+        "109": 38,
+        "110": 39,
+        "111": 40,
+        "112": 41,
+        "113": 42,
+        "114": 43,
+        "115": 44,
+        "116": 45,
+        "117": 46,
+        "118": 47,
+        "119": 48,
+        "120": 49,
+        "121": 50,
+        "122": 51
+    };
     /**
-     * Is the property a string.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Get the byte length of the data.
+     * @param base64 The base64 string.
+     * @returns The byte length of the data.
      */
-    static string(source, property, value) {
-        if (!Is.string(value)) {
-            throw new GuardError(source, "guard.string", property, value);
-        }
+    static byteLength(base64) {
+        const lens = Base64.getLengths(base64);
+        return Base64.calcByteLength(lens[0], lens[1]);
     }
     /**
-     * Is the property a string with a value.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert the base 64 string to a byte array.
+     * @param base64 The base64 string to convert.
+     * @returns The byte array.
      */
-    static stringValue(source, property, value) {
-        if (!Is.string(value)) {
-            throw new GuardError(source, "guard.string", property, value);
+    static decode(base64) {
+        Guards.string(Base64._CLASS_NAME, "base64", base64);
+        let tmp;
+        const lens = Base64.getLengths(base64);
+        const validLen = lens[0];
+        const placeHoldersLen = lens[1];
+        const arr = new Uint8Array(Base64.calcByteLength(validLen, placeHoldersLen));
+        let curByte = 0;
+        // if there are placeholders, only get up to the last complete 4 chars
+        const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+        let i;
+        for (i = 0; i < len; i += 4) {
+            tmp =
+                (Base64._REVERSE_LOOKUP[base64.charCodeAt(i)] << 18) |
+                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 1)] << 12) |
+                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 2)] << 6) |
+                    Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 3)];
+            arr[curByte++] = (tmp >> 16) & 0xff;
+            arr[curByte++] = (tmp >> 8) & 0xff;
+            arr[curByte++] = tmp & 0xff;
         }
-        if (value.length === 0) {
-            throw new GuardError(source, "guard.stringEmpty", property, value);
+        if (placeHoldersLen === 2) {
+            tmp =
+                (Base64._REVERSE_LOOKUP[base64.charCodeAt(i)] << 2) |
+                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 1)] >> 4);
+            arr[curByte++] = tmp & 0xff;
         }
-    }
-    /**
-     * 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);
+        if (placeHoldersLen === 1) {
+            tmp =
+                (Base64._REVERSE_LOOKUP[base64.charCodeAt(i)] << 10) |
+                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 1)] << 4) |
+                    (Base64._REVERSE_LOOKUP[base64.charCodeAt(i + 2)] >> 2);
+            arr[curByte++] = (tmp >> 8) & 0xff;
+            arr[curByte++] = tmp & 0xff;
         }
+        return arr;
     }
     /**
-     * Is the property a base64 string.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert a byte array to base 64.
+     * @param bytes The byte array to convert.
+     * @returns The data as base64 string.
      */
-    static stringBase64(source, property, value) {
-        if (!Is.stringBase64(value)) {
-            throw new GuardError(source, "guard.base64", property, value);
+    static encode(bytes) {
+        Guards.uint8Array(Base64._CLASS_NAME, "bytes", bytes);
+        let tmp;
+        const len = bytes.length;
+        const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+        const parts = [];
+        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, Math.min(i + maxChunkLength, len2)));
+        }
+        // pad the end with zeros, but make sure to not forget the extra bytes
+        if (extraBytes === 1) {
+            tmp = bytes[len - 1];
+            parts.push(`${Base64._LOOKUP[tmp >> 2] + Base64._LOOKUP[(tmp << 4) & 0x3f]}==`);
+        }
+        else if (extraBytes === 2) {
+            tmp = (bytes[len - 2] << 8) + bytes[len - 1];
+            parts.push(`${Base64._LOOKUP[tmp >> 10] + Base64._LOOKUP[(tmp >> 4) & 0x3f] + Base64._LOOKUP[(tmp << 2) & 0x3f]}=`);
         }
+        return parts.join("");
     }
     /**
-     * Is the property a base64 url string.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Calculate the byte length.
+     * @param validLen The valid length.
+     * @param placeHoldersLen The placeholder length.
+     * @returns The length.
+     * @internal
      */
-    static stringBase64Url(source, property, value) {
-        if (!Is.stringBase64Url(value)) {
-            throw new GuardError(source, "guard.base64Url", property, value);
-        }
+    static calcByteLength(validLen, placeHoldersLen) {
+        return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
     }
     /**
-     * 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.
+     * Get the valid and placeholder lengths from a bas64 string.
+     * @param base64 The base64 string.
+     * @returns The lengths.
+     * @internal
      */
-    static stringBase58(source, property, value) {
-        if (!Is.stringBase58(value)) {
-            throw new GuardError(source, "guard.base58", property, value);
+    static getLengths(base64) {
+        const len = base64.length;
+        if (len % 4 > 0) {
+            throw new GeneralError(Base64._CLASS_NAME, "length4Multiple", { value: len });
+        }
+        // Trim off extra bytes after placeholder bytes are found
+        // See: https://github.com/beatgammit/base64-js/issues/42
+        let validLen = base64.indexOf("=");
+        if (validLen === -1) {
+            validLen = len;
         }
+        const placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
+        return [validLen, placeHoldersLen];
     }
     /**
-     * Is the property a string with a hex value.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param allowPrefix Allow the hex to have the 0x prefix.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert the triplet to base 64.
+     * @param num The number to convert.
+     * @returns The base64 encoding.
+     * @internal
      */
-    static stringHex(source, property, value, allowPrefix = false) {
-        Guards.stringValue(source, property, value);
-        if (!HexHelper.isHex(value, allowPrefix)) {
-            throw new GuardError(source, "guard.stringHex", property, value);
-        }
+    static tripletToBase64(num) {
+        return (Base64._LOOKUP[(num >> 18) & 0x3f] +
+            Base64._LOOKUP[(num >> 12) & 0x3f] +
+            Base64._LOOKUP[(num >> 6) & 0x3f] +
+            Base64._LOOKUP[num & 0x3f]);
     }
     /**
-     * Is the property a string with a hex value with fixed length.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param length The length of the string to match.
-     * @param allowPrefix Allow the hex to have the 0x prefix.
-     * @throws GuardError If the value does not match the assertion.
+     * Encode a chunk.
+     * @param bytes The byte array.
+     * @param start The start index in the buffer.
+     * @param end The end index in the buffer.
+     * @returns The encoded chunk.
+     * @internal
      */
-    static stringHexLength(source, property, value, length, allowPrefix = false) {
-        Guards.stringHex(source, property, value, allowPrefix);
-        if (HexHelper.stripPrefix(value).length !== length) {
-            throw new GuardError(source, "guard.stringHexLength", property, value.length, length.toString());
+    static encodeChunk(bytes, start, end) {
+        let tmp;
+        const output = [];
+        for (let i = start; i < end; i += 3) {
+            tmp = ((bytes[i] << 16) & 0xff0000) + ((bytes[i + 1] << 8) & 0xff00) + (bytes[i + 2] & 0xff);
+            output.push(Base64.tripletToBase64(tmp));
         }
+        return output.join("");
     }
+}
+
+/**
+ * Class to help with base64 URL Encoding/Decoding.
+ * https://www.rfc-editor.org/rfc/rfc4648#section-5.
+ */
+class Base64Url {
     /**
-     * Is the property a number.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
+     * @internal
      */
-    static number(source, property, value) {
-        if (!Is.number(value)) {
-            throw new GuardError(source, "guard.number", property, value);
-        }
-    }
+    static _CLASS_NAME = "Base64";
     /**
-     * Is the property an integer.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert the base 64 string to a byte array.
+     * @param base64Url The base64 url string to convert.
+     * @returns The byte array.
      */
-    static integer(source, property, value) {
-        if (!Is.integer(value)) {
-            throw new GuardError(source, "guard.integer", property, value);
+    static decode(base64Url) {
+        Guards.string(Base64Url._CLASS_NAME, "base64Url", base64Url);
+        let base64 = base64Url;
+        // Base 64 url can have padding removed, so add it back if it is missing.
+        if (base64.length > 0 && !base64.endsWith("=")) {
+            const placeHoldersLen = 4 - (base64.length % 4);
+            if (placeHoldersLen > 0 && placeHoldersLen < 4) {
+                base64 = base64.padEnd(base64.length + placeHoldersLen, "=");
+            }
         }
+        base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+        return Base64.decode(base64);
     }
     /**
-     * Is the property a bigint.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Convert a byte array to base 64 url.
+     * @param bytes The byte array to convert.
+     * @returns The data as base64 url string.
      */
-    static bigint(source, property, value) {
-        if (!Is.bigint(value)) {
-            throw new GuardError(source, "guard.bigint", property, value);
-        }
+    static encode(bytes) {
+        Guards.uint8Array(Base64Url._CLASS_NAME, "bytes", bytes);
+        const base64 = Base64.encode(bytes);
+        // Base 64 url can have padding removed, so remove it.
+        return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
     }
+}
+
+/**
+ * Class to handle errors which are triggered by data already existing.
+ */
+class AlreadyExistsError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "AlreadyExistsError";
     /**
-     * Is the property a boolean.
+     * Create a new instance of AlreadyExistsError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param existingId The id for the item.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static boolean(source, property, value) {
-        if (!Is.boolean(value)) {
-            throw new GuardError(source, "guard.boolean", property, value);
-        }
+    constructor(source, message, existingId, cause) {
+        super(AlreadyExistsError.CLASS_NAME, source, message, { existingId });
     }
+}
+
+/**
+ * Class to handle errors which are triggered by conflicting data.
+ */
+class ConflictError extends BaseError {
     /**
-     * Is the property a date.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static date(source, property, value) {
-        if (!Is.date(value)) {
-            throw new GuardError(source, "guard.date", property, value);
-        }
-    }
+    static CLASS_NAME = "ConflictError";
     /**
-     * Is the property a timestamp in milliseconds.
+     * Create a new instance of ConflictError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param conflictId The id that has conflicts.
+     * @param conflicts The conflicts that occurred.
+     * @param cause The cause or the error if we have wrapped another error.
      */
-    static timestampMilliseconds(source, property, value) {
-        if (!Is.timestampMilliseconds(value)) {
-            throw new GuardError(source, "guard.timestampMilliseconds", property, value);
-        }
+    constructor(source, message, conflictId, conflicts, cause) {
+        super(ConflictError.CLASS_NAME, source, message, { conflictId, conflicts }, cause);
     }
+}
+
+/**
+ * Class to handle errors which are triggered by data not being found.
+ */
+class NotFoundError extends BaseError {
     /**
-     * Is the property a timestamp in seconds.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static timestampSeconds(source, property, value) {
-        if (!Is.timestampSeconds(value)) {
-            throw new GuardError(source, "guard.timestampSeconds", property, value);
-        }
-    }
+    static CLASS_NAME = "NotFoundError";
     /**
-     * Is the property an object.
+     * Create a new instance of NotFoundError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param notFoundId The id for the item.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static object(source, property, value) {
-        if (Is.undefined(value)) {
-            throw new GuardError(source, "guard.objectUndefined", property, value);
-        }
-        if (!Is.object(value)) {
-            throw new GuardError(source, "guard.object", property, value);
-        }
+    constructor(source, message, notFoundId, cause) {
+        super(NotFoundError.CLASS_NAME, source, message, { notFoundId }, cause);
     }
+}
+
+/**
+ * Class to handle errors.
+ */
+class NotImplementedError extends BaseError {
     /**
-     * Is the property is an object with at least one property.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static objectValue(source, property, value) {
-        if (Is.undefined(value)) {
-            throw new GuardError(source, "guard.objectUndefined", property, value);
-        }
-        if (!Is.object(value)) {
-            throw new GuardError(source, "guard.object", property, value);
-        }
-        if (Object.keys(value || {}).length === 0) {
-            throw new GuardError(source, "guard.objectValue", property, value);
-        }
-    }
+    static CLASS_NAME = "NotImplementedError";
     /**
-     * Is the property is an array.
+     * Create a new instance of NotImplementedError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param method The method for the error.
      */
-    static array(source, property, value) {
-        if (!Is.array(value)) {
-            throw new GuardError(source, "guard.array", property, value);
-        }
+    constructor(source, method) {
+        super(NotImplementedError.CLASS_NAME, source, "common.notImplementedMethod", {
+            method
+        });
     }
+}
+
+/**
+ * Class to handle errors when a feature is unsupported.
+ */
+class NotSupportedError extends BaseError {
     /**
-     * Is the property is an array with at least one item.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static arrayValue(source, property, value) {
-        if (!Is.array(value)) {
-            throw new GuardError(source, "guard.array", property, value);
-        }
-        if (value.length === 0) {
-            throw new GuardError(source, "guard.arrayValue", property, value);
-        }
-    }
+    static CLASS_NAME = "NotSupportedError";
     /**
-     * Is the property one of a list of items.
+     * Create a new instance of NotSupportedError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param options The options the value must be one of.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static arrayOneOf(source, property, value, options) {
-        if (!Is.array(options)) {
-            throw new GuardError(source, "guard.array", property, value);
-        }
-        if (!options.includes(value)) {
-            throw new GuardError(source, "guard.arrayOneOf", property, value, options.join(", "));
-        }
+    constructor(source, message, cause) {
+        super(NotSupportedError.CLASS_NAME, source, message, undefined, cause);
     }
+}
+
+/**
+ * Class to handle errors which are triggered by access not being unauthorized.
+ */
+class UnauthorizedError extends BaseError {
     /**
-     * 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.
+     * Runtime name for the class.
      */
-    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(", "));
-            }
-        }
-    }
+    static CLASS_NAME = "UnauthorizedError";
     /**
-     * Does the array end with the specified data.
+     * Create a new instance of UnauthorizedError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @param endValues The values that must end the array.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static 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(", "));
-            }
-        }
+    constructor(source, message, cause) {
+        super(UnauthorizedError.CLASS_NAME, source, message, undefined, cause);
     }
+}
+
+/**
+ * Class to handle errors when some data can not be processed.
+ */
+class UnprocessableError extends BaseError {
     /**
-     * Is the property a Uint8Array.
-     * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * Runtime name for the class.
      */
-    static uint8Array(source, property, value) {
-        if (!Is.uint8Array(value)) {
-            throw new GuardError(source, "guard.uint8Array", property, value);
-        }
-    }
+    static CLASS_NAME = "UnprocessableError";
     /**
-     * Is the property a function.
+     * Create a new instance of UnprocessableError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @returns True if the value is a function.
-     * @throws GuardError If the value does not match the assertion.
+     * @param message The message as a code.
+     * @param properties Any additional information for the error.
+     * @param cause The cause of the error if we have wrapped another error.
      */
-    static function(source, property, value) {
-        if (!Is.function(value)) {
-            throw new GuardError(source, "guard.function", property, value);
-        }
-        return true;
+    constructor(source, message, properties, cause) {
+        super(UnprocessableError.CLASS_NAME, source, message, properties, cause);
     }
+}
+
+/**
+ * Class to handle errors which are triggered by entity validation.
+ */
+class ValidationError extends BaseError {
     /**
-     * Is the property a string formatted as an email address.
+     * Runtime name for the class.s
+     */
+    static CLASS_NAME = "ValidationError";
+    /**
+     * Create a new instance of ValidationError.
      * @param source The source of the error.
-     * @param property The name of the property.
-     * @param value The value to test.
-     * @throws GuardError If the value does not match the assertion.
+     * @param validationObject The object that failed validation.
+     * @param validationFailures The validation failures.
      */
-    static email(source, property, value) {
-        if (!Is.email(value)) {
-            throw new GuardError(source, "guard.email", property, value);
-        }
+    constructor(source, validationObject, validationFailures) {
+        super(ValidationError.CLASS_NAME, source, "common.validation", {
+            validationObject,
+            validationFailures
+        });
     }
 }
 
@@ -2102,6 +2139,7 @@ class Factory {
      * @throws GeneralError if no item exists to get.
      */
     get(name) {
+        Guards.stringValue(Factory._CLASS_NAME, "name", name);
         const instance = this.getIfExists(name);
         if (!instance) {
             throw new GeneralError(Factory._CLASS_NAME, "noGet", {
@@ -2117,6 +2155,9 @@ class Factory {
      * @returns An instance of the item or undefined if it does not exist.
      */
     getIfExists(name) {
+        if (Is.empty(name)) {
+            return;
+        }
         Guards.stringValue(Factory._CLASS_NAME, "name", name);
         const matchName = this._matcher(Object.keys(this._generators), name);
         if (Is.stringValue(matchName) && this._generators[matchName]) {
@@ -3145,7 +3186,7 @@ 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.
+     * @returns The error formatted including any causes errors.
      */
     static formatErrors(error, includeDetails) {
         const localizedErrors = ErrorHelper.localizeErrors(error);
@@ -3163,7 +3204,7 @@ class ErrorHelper {
         return localizedErrors.map(e => e.message);
     }
     /**
-     * Localize the content of an error and any inner errors.
+     * Localize the content of an error and any causes.
      * @param error The error to format.
      * @returns The localized version of the errors flattened.
      */
@@ -3204,7 +3245,7 @@ class ErrorHelper {
         return formattedErrors;
     }
     /**
-     * Localize the content of an error and any inner errors.
+     * Localize the content of an error and any causes.
      * @param error The error to format.
      * @returns The localized version of the errors flattened.
      */
@@ -4272,7 +4313,7 @@ class Compression {
     static async compress(bytes, type) {
         Guards.uint8Array(Compression._CLASS_NAME, "bytes", bytes);
         Guards.arrayOneOf(Compression._CLASS_NAME, "type", type, Object.values(CompressionType));
-        const blob = new Blob([bytes]);
+        const blob = new Blob([new Uint8Array(bytes)]);
         const compressionStream = new CompressionStream(type);
         const compressionPipe = blob.stream().pipeThrough(compressionStream);
         const compressedBlob = await new Response(compressionPipe).blob();
@@ -4294,7 +4335,7 @@ class Compression {
     static async decompress(compressedBytes, type) {
         Guards.uint8Array(Compression._CLASS_NAME, "compressedBytes", compressedBytes);
         Guards.arrayOneOf(Compression._CLASS_NAME, "type", type, Object.values(CompressionType));
-        const blob = new Blob([compressedBytes]);
+        const blob = new Blob([new Uint8Array(compressedBytes)]);
         const decompressionStream = new DecompressionStream(type);
         const decompressionPipe = blob.stream().pipeThrough(decompressionStream);
         const decompressedBlob = await new Response(decompressionPipe).blob();