@twin.org/crypto 0.0.2-next.20 → 0.0.2-next.21

package/dist/cjs/index.cjs

@@ -46,9 +46,8 @@ var otp__namespace = /*#__PURE__*/_interopNamespaceDefault(otp);
 class Bech32 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Bech32";
+    static CLASS_NAME = "Bech32";
     /**
      * Encode the buffer.
      * @param humanReadablePart The header.
@@ -56,8 +55,8 @@ class Bech32 {
      * @returns The encoded data.
      */
     static encode(humanReadablePart, data) {
-        core.Guards.stringValue(Bech32._CLASS_NAME, "humanReadablePart", humanReadablePart);
-        core.Guards.uint8Array(Bech32._CLASS_NAME, "data", data);
+        core.Guards.stringValue(Bech32.CLASS_NAME, "humanReadablePart", humanReadablePart);
+        core.Guards.uint8Array(Bech32.CLASS_NAME, "data", data);
         return base.bech32.encode(humanReadablePart, base.bech32.toWords(data));
     }
     /**
@@ -67,7 +66,7 @@ class Bech32 {
      * @throws An error if the decoding fails.
      */
     static decode(bech) {
-        core.Guards.stringValue(Bech32._CLASS_NAME, "bech", bech);
+        core.Guards.stringValue(Bech32.CLASS_NAME, "bech", bech);
         try {
             const result = base.bech32.decodeToBytes(bech);
             return {
@@ -77,19 +76,19 @@ class Bech32 {
         }
         catch (err) {
             if (core.BaseError.isErrorMessage(err, /checksum/)) {
-                throw new core.GeneralError(Bech32._CLASS_NAME, "invalidChecksum", { bech: base.bech32 });
+                throw new core.GeneralError(Bech32.CLASS_NAME, "invalidChecksum", { bech32: base.bech32 });
             }
             else if (core.BaseError.isErrorMessage(err, /between prefix and data only/i)) {
-                throw new core.GeneralError(Bech32._CLASS_NAME, "separatorMisused", { bech: base.bech32 });
+                throw new core.GeneralError(Bech32.CLASS_NAME, "separatorMisused", { bech32: base.bech32 });
             }
             else if (core.BaseError.isErrorMessage(err, /lowercase or uppercase/i)) {
-                throw new core.GeneralError(Bech32._CLASS_NAME, "lowerUpper", { bech: base.bech32 });
+                throw new core.GeneralError(Bech32.CLASS_NAME, "lowerUpper", { bech32: base.bech32 });
             }
             else if (core.BaseError.isErrorMessage(err, /must be at least/i) ||
                 core.BaseError.isErrorMessage(err, /wrong string length/i)) {
-                throw new core.GeneralError(Bech32._CLASS_NAME, "dataTooShort", { bech: base.bech32 });
+                throw new core.GeneralError(Bech32.CLASS_NAME, "dataTooShort", { bech32: base.bech32 });
             }
-            throw new core.GeneralError(Bech32._CLASS_NAME, "decodeFailed", { bech: base.bech32 }, err);
+            throw new core.GeneralError(Bech32.CLASS_NAME, "decodeFailed", { bech32: base.bech32 }, err);
         }
     }
     /**
@@ -125,9 +124,8 @@ class Ed25519 {
     static PUBLIC_KEY_SIZE = 32;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Ed25519";
+    static CLASS_NAME = "Ed25519";
     /**
      * Public returns the PublicKey corresponding to private.
      * @param privateKey The private key to get the corresponding public key.
@@ -135,9 +133,9 @@ class Ed25519 {
      * @throws Error if the private key is not the correct length.
      */
     static publicKeyFromPrivateKey(privateKey) {
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "privateKey", privateKey);
         if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
-            throw new core.GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+            throw new core.GeneralError(Ed25519.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Ed25519.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -152,10 +150,10 @@ class Ed25519 {
      * @throws Error if the private key is not the correct length.
      */
     static sign(privateKey, block) {
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "privateKey", privateKey);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "block", block);
         if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
-            throw new core.GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+            throw new core.GeneralError(Ed25519.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Ed25519.PRIVATE_KEY_SIZE,
                 actualSize: privateKey ? privateKey.length : 0
             });
@@ -171,11 +169,11 @@ class Ed25519 {
      * @throws Error if the public key is not the correct length.
      */
     static verify(publicKey, block, signature) {
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "publicKey", publicKey);
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "block", block);
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "signature", signature);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "publicKey", publicKey);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "signature", signature);
         if (publicKey.length !== Ed25519.PUBLIC_KEY_SIZE) {
-            throw new core.GeneralError(Ed25519._CLASS_NAME, "publicKeyLength", {
+            throw new core.GeneralError(Ed25519.CLASS_NAME, "publicKeyLength", {
                 requiredSize: Ed25519.PUBLIC_KEY_SIZE,
                 actualSize: publicKey ? publicKey.length : 0
             });
@@ -193,9 +191,9 @@ class Ed25519 {
      * @returns The private key in PKCS8 format.
      */
     static async privateKeyToPkcs8(privateKey) {
-        core.Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
+        core.Guards.uint8Array(Ed25519.CLASS_NAME, "privateKey", privateKey);
         if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
-            throw new core.GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+            throw new core.GeneralError(Ed25519.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Ed25519.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -214,7 +212,7 @@ class Ed25519 {
      * @returns The raw private key.
      */
     static async pkcs8ToPrivateKey(cryptoKey) {
-        core.Guards.defined(Ed25519._CLASS_NAME, "cryptoKey", cryptoKey);
+        core.Guards.defined(Ed25519.CLASS_NAME, "cryptoKey", cryptoKey);
         // crypto.subtle.exportKey does not support Ed25519 keys in raw format.
         // so we export as PKCS8 and remove the ASN.1 sequence prefix.
         const pkcs8Bytes = await crypto.subtle.exportKey("pkcs8", cryptoKey);
@@ -238,9 +236,8 @@ class Secp256k1 {
     static PUBLIC_KEY_SIZE = 33;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Secp256k1";
+    static CLASS_NAME = "Secp256k1";
     /**
      * Public returns the PublicKey corresponding to private.
      * @param privateKey The private key to get the corresponding public key.
@@ -248,9 +245,9 @@ class Secp256k1 {
      * @throws Error if the private key is not the correct length.
      */
     static publicKeyFromPrivateKey(privateKey) {
-        core.Guards.uint8Array(Secp256k1._CLASS_NAME, "privateKey", privateKey);
+        core.Guards.uint8Array(Secp256k1.CLASS_NAME, "privateKey", privateKey);
         if (privateKey.length !== Secp256k1.PRIVATE_KEY_SIZE) {
-            throw new core.GeneralError(Secp256k1._CLASS_NAME, "privateKeyLength", {
+            throw new core.GeneralError(Secp256k1.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Secp256k1.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -265,10 +262,10 @@ class Secp256k1 {
      * @throws Error if the private key is not the correct length.
      */
     static sign(privateKey, block) {
-        core.Guards.uint8Array(Secp256k1._CLASS_NAME, "privateKey", privateKey);
-        core.Guards.uint8Array(Secp256k1._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Secp256k1.CLASS_NAME, "privateKey", privateKey);
+        core.Guards.uint8Array(Secp256k1.CLASS_NAME, "block", block);
         if (privateKey.length !== Secp256k1.PRIVATE_KEY_SIZE) {
-            throw new core.GeneralError(Secp256k1._CLASS_NAME, "privateKeyLength", {
+            throw new core.GeneralError(Secp256k1.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Secp256k1.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -285,11 +282,11 @@ class Secp256k1 {
      * @throws Error if the public key is not the correct length.
      */
     static verify(publicKey, block, signature) {
-        core.Guards.uint8Array(Secp256k1._CLASS_NAME, "publicKey", publicKey);
-        core.Guards.uint8Array(Secp256k1._CLASS_NAME, "block", block);
-        core.Guards.uint8Array(Secp256k1._CLASS_NAME, "signature", signature);
+        core.Guards.uint8Array(Secp256k1.CLASS_NAME, "publicKey", publicKey);
+        core.Guards.uint8Array(Secp256k1.CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Secp256k1.CLASS_NAME, "signature", signature);
         if (publicKey.length !== Secp256k1.PUBLIC_KEY_SIZE) {
-            throw new core.GeneralError(Secp256k1._CLASS_NAME, "publicKeyLength", {
+            throw new core.GeneralError(Secp256k1.CLASS_NAME, "publicKeyLength", {
                 requiredSize: Secp256k1.PUBLIC_KEY_SIZE,
                 actualSize: publicKey ? publicKey.length : 0
             });
@@ -323,9 +320,8 @@ class Blake2b {
     static SIZE_512 = 64;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Blake2b";
+    static CLASS_NAME = "Blake2b";
     /**
      * The instance of the hash.
      * @internal
@@ -350,7 +346,7 @@ class Blake2b {
      * @returns The sum 160 of the block.
      */
     static sum160(block, key) {
-        core.Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         return new Blake2b(Blake2b.SIZE_160, key).update(block).digest();
     }
     /**
@@ -360,7 +356,7 @@ class Blake2b {
      * @returns The sum 256 of the block.
      */
     static sum256(block, key) {
-        core.Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         return new Blake2b(Blake2b.SIZE_256, key).update(block).digest();
     }
     /**
@@ -370,7 +366,7 @@ class Blake2b {
      * @returns The sum 512 of the block.
      */
     static sum512(block, key) {
-        core.Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         return new Blake2b(Blake2b.SIZE_512, key).update(block).digest();
     }
     /**
@@ -379,7 +375,7 @@ class Blake2b {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -490,9 +486,8 @@ const KeyType = {
 class Slip0010 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Slip0010";
+    static CLASS_NAME = "Slip0010";
     /**
      * Get the master key from the seed.
      * @param seed The seed to generate the master key from.
@@ -511,7 +506,7 @@ class Slip0010 {
             };
         }
         catch (error) {
-            throw new core.GeneralError(Slip0010._CLASS_NAME, "invalidSeed", { seed: core.Converter.bytesToUtf8(seed) }, error);
+            throw new core.GeneralError(Slip0010.CLASS_NAME, "invalidSeed", { seed: core.Converter.bytesToUtf8(seed) }, error);
         }
     }
     /**
@@ -567,9 +562,8 @@ class Slip0010 {
 class Bip44 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Bip44";
+    static CLASS_NAME = "Bip44";
     /**
      * Generate a bip44 key pair from the seed and parts.
      * @param seed The account seed.
@@ -598,7 +592,7 @@ class Bip44 {
                 publicKey
             };
         }
-        throw new core.GeneralError(Bip44._CLASS_NAME, "unsupportedKeyType", { keyType });
+        throw new core.GeneralError(Bip44.CLASS_NAME, "unsupportedKeyType", { keyType });
     }
     /**
      * Generate a bip44 path based on all its parts.
@@ -673,9 +667,8 @@ class Bip44 {
 class ChaCha20Poly1305 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "ChaCha20Poly1305";
+    static CLASS_NAME = "ChaCha20Poly1305";
     /**
      * The cipher instance.
      * @internal
@@ -688,8 +681,8 @@ class ChaCha20Poly1305 {
      * @param aad The additional authenticated data.
      */
     constructor(key, nonce, aad) {
-        core.Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "nonce", nonce);
+        core.Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "nonce", nonce);
         this._instance = chacha_js.chacha20poly1305(key, nonce, aad);
     }
     /**
@@ -698,7 +691,7 @@ class ChaCha20Poly1305 {
      * @returns The block encrypted.
      */
     encrypt(block) {
-        core.Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "block", block);
         return this._instance.encrypt(block);
     }
     /**
@@ -707,7 +700,7 @@ class ChaCha20Poly1305 {
      * @returns The block decrypted.
      */
     decrypt(block) {
-        core.Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "block", block);
         return this._instance.decrypt(block);
     }
 }
@@ -720,16 +713,15 @@ class ChaCha20Poly1305 {
 class X25519 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "X25519";
+    static CLASS_NAME = "X25519";
     /**
      * Convert Ed25519 private key to X25519 private key.
      * @param ed25519PrivateKey The ed25519 private key to convert.
      * @returns The x25519 private key.
      */
     static convertPrivateKeyToX25519(ed25519PrivateKey) {
-        core.Guards.uint8Array(X25519._CLASS_NAME, "ed25519PrivateKey", ed25519PrivateKey);
+        core.Guards.uint8Array(X25519.CLASS_NAME, "ed25519PrivateKey", ed25519PrivateKey);
         return ed25519_js.ed25519.utils.toMontgomerySecret(ed25519PrivateKey.slice(0, Ed25519.PRIVATE_KEY_SIZE));
     }
     /**
@@ -739,7 +731,7 @@ class X25519 {
      * @throws GeneralError On invalid public key.
      */
     static convertPublicKeyToX25519(ed25519PublicKey) {
-        core.Guards.uint8Array(X25519._CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
+        core.Guards.uint8Array(X25519.CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
         return ed25519_js.ed25519.utils.toMontgomery(ed25519PublicKey);
     }
 }
@@ -752,9 +744,8 @@ class X25519 {
 class Zip215 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Zip215";
+    static CLASS_NAME = "Zip215";
     /**
      * Verify reports whether sig is a valid signature of block by
      * publicKey, using precisely-specified validation criteria (ZIP 215) suitable
@@ -765,9 +756,9 @@ class Zip215 {
      * @returns True if the signature is valid.
      */
     static verify(publicKey, block, sig) {
-        core.Guards.uint8Array(Zip215._CLASS_NAME, "publicKey", publicKey);
-        core.Guards.uint8Array(Zip215._CLASS_NAME, "block", block);
-        core.Guards.uint8Array(Zip215._CLASS_NAME, "sig", sig);
+        core.Guards.uint8Array(Zip215.CLASS_NAME, "publicKey", publicKey);
+        core.Guards.uint8Array(Zip215.CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Zip215.CLASS_NAME, "sig", sig);
         if (publicKey.length !== Ed25519.PUBLIC_KEY_SIZE) {
             return false;
         }
@@ -791,9 +782,8 @@ class Blake3 {
     static SIZE_512 = 64;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Blake3";
+    static CLASS_NAME = "Blake3";
     /**
      * The instance of the hash.
      * @internal
@@ -818,7 +808,7 @@ class Blake3 {
      * @returns The sum 256 of the block.
      */
     static sum256(block, key) {
-        core.Guards.uint8Array(Blake3._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake3.CLASS_NAME, "block", block);
         return new Blake3(Blake3.SIZE_256, key).update(block).digest();
     }
     /**
@@ -828,7 +818,7 @@ class Blake3 {
      * @returns The sum 512 of the block.
      */
     static sum512(block, key) {
-        core.Guards.uint8Array(Blake3._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake3.CLASS_NAME, "block", block);
         return new Blake3(Blake3.SIZE_512, key).update(block).digest();
     }
     /**
@@ -837,7 +827,7 @@ class Blake3 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(Blake3._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Blake3.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -858,9 +848,8 @@ class Blake3 {
 class HmacSha1 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "HmacSha1";
+    static CLASS_NAME = "HmacSha1";
     /**
      * The instance of the hash.
      * @internal
@@ -881,8 +870,8 @@ class HmacSha1 {
      * @returns The sum of the block.
      */
     static sum(key, block) {
-        core.Guards.uint8Array(HmacSha1._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha1._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha1.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha1.CLASS_NAME, "block", block);
         return new HmacSha1(key).update(block).digest();
     }
     /**
@@ -891,7 +880,7 @@ class HmacSha1 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(HmacSha1._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha1.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -920,9 +909,8 @@ class HmacSha256 {
     static SIZE_224 = 224;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "HmacSha256";
+    static CLASS_NAME = "HmacSha256";
     /**
      * The instance of the hash.
      * @internal
@@ -936,7 +924,7 @@ class HmacSha256 {
      */
     constructor(key, bits = HmacSha256.SIZE_256) {
         if (bits !== HmacSha256.SIZE_224 && bits !== HmacSha256.SIZE_256) {
-            throw new core.GeneralError(HmacSha256._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new core.GeneralError(HmacSha256.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         this._instance = hmac_js.hmac.create(bits === HmacSha256.SIZE_256 ? sha2_js.sha256 : sha2_js.sha224, key);
     }
@@ -947,8 +935,8 @@ class HmacSha256 {
      * @returns The sum 224 of the block.
      */
     static sum224(key, block) {
-        core.Guards.uint8Array(HmacSha256._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha256._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha256.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha256.CLASS_NAME, "block", block);
         const instance = new HmacSha256(key, HmacSha256.SIZE_224);
         instance.update(block);
         return instance.digest();
@@ -960,8 +948,8 @@ class HmacSha256 {
      * @returns The sum 256 of the block.
      */
     static sum256(key, block) {
-        core.Guards.uint8Array(HmacSha256._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha256._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha256.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha256.CLASS_NAME, "block", block);
         const instance = new HmacSha256(key, HmacSha256.SIZE_256);
         instance.update(block);
         return instance.digest();
@@ -972,7 +960,7 @@ class HmacSha256 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(HmacSha256._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha256.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1010,9 +998,8 @@ class HmacSha512 {
     static SIZE_512 = 512;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "HmacSha512";
+    static CLASS_NAME = "HmacSha512";
     /**
      * The instance of the hash.
      * @internal
@@ -1029,7 +1016,7 @@ class HmacSha512 {
             bits !== HmacSha512.SIZE_256 &&
             bits !== HmacSha512.SIZE_384 &&
             bits !== HmacSha512.SIZE_512) {
-            throw new core.GeneralError(HmacSha512._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new core.GeneralError(HmacSha512.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         if (bits === HmacSha512.SIZE_224) {
             this._instance = hmac_js.hmac.create(sha2_js.sha512_224, key);
@@ -1051,8 +1038,8 @@ class HmacSha512 {
      * @returns The sum 512 of the block.
      */
     static sum512(key, block) {
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_512);
         instance.update(block);
         return instance.digest();
@@ -1064,8 +1051,8 @@ class HmacSha512 {
      * @returns The sum 384 of the block.
      */
     static sum384(key, block) {
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_384);
         instance.update(block);
         return instance.digest();
@@ -1077,8 +1064,8 @@ class HmacSha512 {
      * @returns The sum 256 of the block.
      */
     static sum256(key, block) {
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_256);
         instance.update(block);
         return instance.digest();
@@ -1090,8 +1077,8 @@ class HmacSha512 {
      * @returns The sum 224 of the block.
      */
     static sum224(key, block) {
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_224);
         instance.update(block);
         return instance.digest();
@@ -1102,7 +1089,7 @@ class HmacSha512 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1123,9 +1110,8 @@ class HmacSha512 {
 class Pbkdf2 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Pbkdf2";
+    static CLASS_NAME = "Pbkdf2";
     /**
      * Derive a key from the parameters using Sha256.
      * @param password The password to derive the key from.
@@ -1135,10 +1121,10 @@ class Pbkdf2 {
      * @returns The derived key.
      */
     static sha256(password, salt, iterations, keyLength) {
-        core.Guards.uint8Array(Pbkdf2._CLASS_NAME, "password", password);
-        core.Guards.uint8Array(Pbkdf2._CLASS_NAME, "salt", salt);
-        core.Guards.number(Pbkdf2._CLASS_NAME, "iterations", iterations);
-        core.Guards.number(Pbkdf2._CLASS_NAME, "keyLength", keyLength);
+        core.Guards.uint8Array(Pbkdf2.CLASS_NAME, "password", password);
+        core.Guards.uint8Array(Pbkdf2.CLASS_NAME, "salt", salt);
+        core.Guards.number(Pbkdf2.CLASS_NAME, "iterations", iterations);
+        core.Guards.number(Pbkdf2.CLASS_NAME, "keyLength", keyLength);
         return pbkdf2_js.pbkdf2(sha2_js.sha256, password, salt, { c: iterations, dkLen: keyLength });
     }
     /**
@@ -1150,10 +1136,10 @@ class Pbkdf2 {
      * @returns The derived key.
      */
     static sha512(password, salt, iterations, keyLength) {
-        core.Guards.uint8Array(Pbkdf2._CLASS_NAME, "password", password);
-        core.Guards.uint8Array(Pbkdf2._CLASS_NAME, "salt", salt);
-        core.Guards.number(Pbkdf2._CLASS_NAME, "iterations", iterations);
-        core.Guards.number(Pbkdf2._CLASS_NAME, "keyLength", keyLength);
+        core.Guards.uint8Array(Pbkdf2.CLASS_NAME, "password", password);
+        core.Guards.uint8Array(Pbkdf2.CLASS_NAME, "salt", salt);
+        core.Guards.number(Pbkdf2.CLASS_NAME, "iterations", iterations);
+        core.Guards.number(Pbkdf2.CLASS_NAME, "keyLength", keyLength);
         return pbkdf2_js.pbkdf2(sha2_js.sha512, password, salt, { c: iterations, dkLen: keyLength });
     }
 }
@@ -1166,9 +1152,8 @@ class Pbkdf2 {
 class Sha1 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha1";
+    static CLASS_NAME = "Sha1";
     /**
      * The instance of the hash.
      * @internal
@@ -1187,7 +1172,7 @@ class Sha1 {
      * @returns The sum of the block.
      */
     static sum(block) {
-        core.Guards.uint8Array(Sha1._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Sha1.CLASS_NAME, "block", block);
         return new Sha1().update(block).digest();
     }
     /**
@@ -1196,7 +1181,7 @@ class Sha1 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(Sha1._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Sha1.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1225,9 +1210,8 @@ class Sha256 {
     static SIZE_224 = 224;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha256";
+    static CLASS_NAME = "Sha256";
     /**
      * The instance of the hash.
      * @internal
@@ -1240,7 +1224,7 @@ class Sha256 {
      */
     constructor(bits = Sha256.SIZE_256) {
         if (bits !== Sha256.SIZE_224 && bits !== Sha256.SIZE_256) {
-            throw new core.GeneralError(Sha256._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new core.GeneralError(Sha256.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         this._instance = bits === Sha256.SIZE_256 ? sha2_js.sha256.create() : sha2_js.sha224.create();
     }
@@ -1270,7 +1254,7 @@ class Sha256 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(Sha256._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Sha256.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1308,9 +1292,8 @@ class Sha3 {
     static SIZE_512 = 512;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha3";
+    static CLASS_NAME = "Sha3";
     /**
      * The instance of the hash.
      * @internal
@@ -1326,7 +1309,7 @@ class Sha3 {
             bits !== Sha3.SIZE_256 &&
             bits !== Sha3.SIZE_384 &&
             bits !== Sha3.SIZE_512) {
-            throw new core.GeneralError(Sha3._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new core.GeneralError(Sha3.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         if (bits === Sha3.SIZE_224) {
             // eslint-disable-next-line camelcase
@@ -1391,7 +1374,7 @@ class Sha3 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(Sha3._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Sha3.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1429,9 +1412,8 @@ class Sha512 {
     static SIZE_512 = 512;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha512";
+    static CLASS_NAME = "Sha512";
     /**
      * The instance of the hash.
      * @internal
@@ -1447,7 +1429,7 @@ class Sha512 {
             bits !== Sha512.SIZE_256 &&
             bits !== Sha512.SIZE_384 &&
             bits !== Sha512.SIZE_512) {
-            throw new core.GeneralError(Sha512._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new core.GeneralError(Sha512.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         if (bits === Sha512.SIZE_224) {
             this._instance = sha2_js.sha512_224.create();
@@ -1508,7 +1490,7 @@ class Sha512 {
      * @returns The instance for chaining.
      */
     update(block) {
-        core.Guards.uint8Array(Sha512._CLASS_NAME, "block", block);
+        core.Guards.uint8Array(Sha512.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1529,16 +1511,15 @@ class Sha512 {
 class PemHelper {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "PemHelper";
+    static CLASS_NAME = "PemHelper";
     /**
      * Strip the PEM content of its headers, footers, and newlines.
      * @param pemContent The PEM content to strip.
      * @returns The stripped PEM content in bas64 format.
      */
     static stripPemMarkers(pemContent) {
-        core.Guards.string(PemHelper._CLASS_NAME, "pemContent", pemContent);
+        core.Guards.string(PemHelper.CLASS_NAME, "pemContent", pemContent);
         return pemContent
             .replace(/-----BEGIN.*-----/, "")
             .replace(/-----END.*-----/, "")
@@ -1553,8 +1534,8 @@ class PemHelper {
      * @returns The formatted PEM content.
      */
     static formatPem(marker, base64Content, lineLength = 64) {
-        core.Guards.stringValue(PemHelper._CLASS_NAME, "marker", marker);
-        core.Guards.stringBase64(PemHelper._CLASS_NAME, "base64Content", base64Content);
+        core.Guards.stringValue(PemHelper.CLASS_NAME, "marker", marker);
+        core.Guards.stringBase64(PemHelper.CLASS_NAME, "base64Content", base64Content);
         const lines = [];
         for (let i = 0; i < base64Content.length; i += lineLength) {
             lines.push(base64Content.slice(i, i + lineLength));
@@ -1571,9 +1552,8 @@ class PemHelper {
 class Bip39 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Bip39";
+    static CLASS_NAME = "Bip39";
     /**
      * Generate a random mnemonic.
      * @param strength The strength of the mnemonic to generate, defaults to 256.
@@ -1582,10 +1562,10 @@ class Bip39 {
      * @throws Error if the length is not a multiple of 32.
      */
     static randomMnemonic(strength = 256, words = english_js.wordlist) {
-        core.Guards.number(Bip39._CLASS_NAME, "strength", strength);
-        core.Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
+        core.Guards.number(Bip39.CLASS_NAME, "strength", strength);
+        core.Guards.arrayValue(Bip39.CLASS_NAME, "words", words);
         if (strength % 32 !== 0) {
-            throw new core.GuardError(Bip39._CLASS_NAME, "guard.length32Multiple", "strength", strength);
+            throw new core.GuardError(Bip39.CLASS_NAME, "guard.length32Multiple", "strength", strength);
         }
         return bip39__namespace.generateMnemonic(words, strength);
     }
@@ -1597,10 +1577,10 @@ class Bip39 {
      * @throws Error if the length of the entropy is not a multiple of 4, or is less than 16 or greater than 32.
      */
     static entropyToMnemonic(entropy, words = english_js.wordlist) {
-        core.Guards.uint8Array(Bip39._CLASS_NAME, "entropy", entropy);
-        core.Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
+        core.Guards.uint8Array(Bip39.CLASS_NAME, "entropy", entropy);
+        core.Guards.arrayValue(Bip39.CLASS_NAME, "words", words);
         if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-            throw new core.GuardError(Bip39._CLASS_NAME, "guard.lengthEntropy", "entropy", entropy.length);
+            throw new core.GuardError(Bip39.CLASS_NAME, "guard.lengthEntropy", "entropy", entropy.length);
         }
         return bip39__namespace.entropyToMnemonic(entropy, words);
     }
@@ -1611,7 +1591,7 @@ class Bip39 {
      * @returns The seed.
      */
     static mnemonicToSeed(mnemonic, password) {
-        core.Guards.stringValue(Bip39._CLASS_NAME, "mnemonic", mnemonic);
+        core.Guards.stringValue(Bip39.CLASS_NAME, "mnemonic", mnemonic);
         return bip39__namespace.mnemonicToSeedSync(mnemonic, password);
     }
     /**
@@ -1622,8 +1602,8 @@ class Bip39 {
      * @throws Error if the number of words is not a multiple of 3.
      */
     static mnemonicToEntropy(mnemonic, words = english_js.wordlist) {
-        core.Guards.stringValue(Bip39._CLASS_NAME, "mnemonic", mnemonic);
-        core.Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
+        core.Guards.stringValue(Bip39.CLASS_NAME, "mnemonic", mnemonic);
+        core.Guards.arrayValue(Bip39.CLASS_NAME, "words", words);
         return bip39__namespace.mnemonicToEntropy(mnemonic, words);
     }
     /**
@@ -1634,8 +1614,8 @@ class Bip39 {
      * @returns True if the mnemonic is valid.
      */
     static validateMnemonic(mnemonic, wordCount = 24, words = english_js.wordlist) {
-        core.Guards.string(Bip39._CLASS_NAME, "mnemonic", mnemonic);
-        core.Guards.integer(Bip39._CLASS_NAME, "wordCount", wordCount);
+        core.Guards.string(Bip39.CLASS_NAME, "mnemonic", mnemonic);
+        core.Guards.integer(Bip39.CLASS_NAME, "wordCount", wordCount);
         const mnemonicSplit = mnemonic.split(/\s+/);
         if (mnemonicSplit.length !== wordCount) {
             return false;
@@ -1653,9 +1633,8 @@ class Bip39 {
 class Hotp {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Hotp";
+    static CLASS_NAME = "Hotp";
     /**
      * Generate a counter based One Time Password.
      * @param key Key for the one time password.
@@ -1664,8 +1643,8 @@ class Hotp {
      * @returns The one time password.
      */
     static generate(key, counter) {
-        core.Guards.uint8Array(Hotp._CLASS_NAME, "key", key);
-        core.Guards.number(Hotp._CLASS_NAME, "counter", counter);
+        core.Guards.uint8Array(Hotp.CLASS_NAME, "key", key);
+        core.Guards.number(Hotp.CLASS_NAME, "counter", counter);
         return otp__namespace.hotp({ secret: key, digits: 6, algorithm: "sha1", interval: 30 }, counter);
     }
 }
@@ -1701,7 +1680,7 @@ class Totp {
         for (let i = -window; i < window; i++) {
             const intervalWindow = i * interval * 1000;
             if (timestamp + intervalWindow > 0) {
-                const gen = this.generate(key, interval, timestamp + intervalWindow);
+                const gen = Totp.generate(key, interval, timestamp + intervalWindow);
                 if (gen === token) {
                     // We have found a matching code
                     return i;
@@ -1796,7 +1775,8 @@ class PasswordValidator {
                     property,
                     reason: "validation.minLengthRequired",
                     properties: {
-                        minLength
+                        minLength,
+                        actualLength: password.length
                     }
                 });
             }
@@ -1806,7 +1786,8 @@ class PasswordValidator {
                     property,
                     reason: "validation.maxLengthRequired",
                     properties: {
-                        maxLength
+                        maxLength,
+                        actualLength: password.length
                     }
                 });
             }