@opcua/for-node-red 3.34.2 → 3.36.0

package/node_modules/@sterfive/opcua-pinned/node_modules/{webcrypto-core → node-opcua-crypto/node_modules/webcrypto-core}/build/webcrypto-core.es.js

@@ -1,13 +1,15 @@
-/*!
- Copyright (c) Peculiar Ventures, LLC
-*/
+/**
+ * Copyright (c) 2019-2026, Peculiar Ventures
+ * SPDX-License-Identifier: MIT
+ */
 
-import { Convert, BufferSourceConverter, combine } from 'pvtsutils';
-export { BufferSourceConverter } from 'pvtsutils';
+import * as bytes from '@peculiar/utils/bytes';
+import * as encoding from '@peculiar/utils/encoding';
 import { AsnProp, AsnPropTypes, AsnType, AsnTypeTypes, AsnIntegerConverter, AsnSerializer, AsnConvert } from '@peculiar/asn1-schema';
 import { __decorate } from 'tslib';
 import { JsonProp, JsonPropTypes } from '@peculiar/json-schema';
 import * as asn1 from 'asn1js';
+export { BufferSourceConverter } from '@peculiar/utils/legacy';
 
 class CryptoError extends Error {
 }
@@ -36,14 +38,14 @@ class PemConverter {
             .replace(/-{5}(BEGIN|END) .*-{5}/g, "")
             .replace("\r", "")
             .replace("\n", "");
-        return Convert.FromBase64(base64);
+        return bytes.toArrayBuffer(encoding.base64.decode(base64));
     }
     static toUint8Array(pem) {
         const bytes = this.toArrayBuffer(pem);
         return new Uint8Array(bytes);
     }
     static fromBufferSource(buffer, tag) {
-        const base64 = Convert.ToBase64(buffer);
+        const base64 = encoding.base64.encode(buffer);
         let sliced;
         let offset = 0;
         const rows = [];
@@ -114,7 +116,7 @@ class ProviderCrypto {
         this.checkAlgorithmName(algorithm);
         this.checkGenerateKeyParams(algorithm);
         if (!(keyUsages && keyUsages.length)) {
-            throw new TypeError(`Usages cannot be empty when creating a key.`);
+            throw new TypeError("Usages cannot be empty when creating a key.");
         }
         let allowedUsages;
         if (Array.isArray(this.usages)) {
@@ -242,7 +244,7 @@ class ProviderCrypto {
     checkCryptoKey(key, keyUsage) {
         this.checkAlgorithmName(key.algorithm);
         if (keyUsage && key.usages.indexOf(keyUsage) === -1) {
-            throw new CryptoError(`key does not match that of operation`);
+            throw new CryptoError("key does not match that of operation");
         }
     }
     checkRequiredProperty(data, propName) {
@@ -280,12 +282,12 @@ class ProviderCrypto {
                 throw new TypeError("keyData: Is not JsonWebToken");
             }
         }
-        else if (!BufferSourceConverter.isBufferSource(keyData)) {
+        else if (!bytes.isBufferSource(keyData)) {
             throw new TypeError("keyData: Is not ArrayBufferView or ArrayBuffer");
         }
     }
     prepareData(data) {
-        return BufferSourceConverter.toArrayBuffer(data);
+        return bytes.toArrayBuffer(data);
     }
 }
 
@@ -310,11 +312,8 @@ class AesProvider extends ProviderCrypto {
 }
 
 class AesCbcProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-CBC";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-CBC";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "iv");
         if (!(algorithm.iv instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.iv))) {
@@ -327,11 +326,8 @@ class AesCbcProvider extends AesProvider {
 }
 
 class AesCmacProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-CMAC";
-        this.usages = ["sign", "verify"];
-    }
+    name = "AES-CMAC";
+    usages = ["sign", "verify"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "length");
         if (typeof algorithm.length !== "number") {
@@ -344,11 +340,8 @@ class AesCmacProvider extends AesProvider {
 }
 
 class AesCtrProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-CTR";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-CTR";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "counter");
         if (!(algorithm.counter instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.counter))) {
@@ -368,21 +361,14 @@ class AesCtrProvider extends AesProvider {
 }
 
 class AesEcbProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-ECB";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-ECB";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
 }
 
 class AesGcmProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-GCM";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-GCM";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
-        var _a;
         this.checkRequiredProperty(algorithm, "iv");
         if (!(algorithm.iv instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.iv))) {
             throw new TypeError("iv: Is not of type '(ArrayBuffer or ArrayBufferView)'");
@@ -390,7 +376,7 @@ class AesGcmProvider extends AesProvider {
         if (algorithm.iv.byteLength < 1) {
             throw new OperationError("iv: Must have length more than 0 and less than 2^64 - 1");
         }
-        (_a = algorithm.tagLength) !== null && _a !== void 0 ? _a : (algorithm.tagLength = 128);
+        algorithm.tagLength ??= 128;
         switch (algorithm.tagLength) {
             case 32:
             case 64:
@@ -407,18 +393,12 @@ class AesGcmProvider extends AesProvider {
 }
 
 class AesKwProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-KW";
-        this.usages = ["wrapKey", "unwrapKey"];
-    }
+    name = "AES-KW";
+    usages = ["wrapKey", "unwrapKey"];
 }
 
 class DesProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
         if (this.ivSize) {
             this.checkRequiredProperty(algorithm, "iv");
@@ -445,10 +425,7 @@ class DesProvider extends ProviderCrypto {
 }
 
 class RsaProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-    }
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
     checkGenerateKeyParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
@@ -456,7 +433,7 @@ class RsaProvider extends ProviderCrypto {
         if (!(algorithm.publicExponent && algorithm.publicExponent instanceof Uint8Array)) {
             throw new TypeError("publicExponent: Missing or not a Uint8Array");
         }
-        const publicExponent = Convert.ToBase64(algorithm.publicExponent);
+        const publicExponent = encoding.base64url.encode(algorithm.publicExponent);
         if (!(publicExponent === "Aw==" || publicExponent === "AQAB")) {
             throw new TypeError("publicExponent: Must be [3] or [1,0,1]");
         }
@@ -474,25 +451,19 @@ class RsaProvider extends ProviderCrypto {
 }
 
 class RsaSsaProvider extends RsaProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "RSASSA-PKCS1-v1_5";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-    }
+    name = "RSASSA-PKCS1-v1_5";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
 }
 
 class RsaPssProvider extends RsaProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "RSA-PSS";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-    }
+    name = "RSA-PSS";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "saltLength");
         if (typeof algorithm.saltLength !== "number") {
@@ -505,14 +476,11 @@ class RsaPssProvider extends RsaProvider {
 }
 
 class RsaOaepProvider extends RsaProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "RSA-OAEP";
-        this.usages = {
-            privateKey: ["decrypt", "unwrapKey"],
-            publicKey: ["encrypt", "wrapKey"],
-        };
-    }
+    name = "RSA-OAEP";
+    usages = {
+        privateKey: ["decrypt", "unwrapKey"],
+        publicKey: ["encrypt", "wrapKey"],
+    };
     checkAlgorithmParams(algorithm) {
         if (algorithm.label
             && !(algorithm.label instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.label))) {
@@ -537,16 +505,13 @@ class EllipticProvider extends ProviderCrypto {
 }
 
 class EcdsaProvider extends EllipticProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "ECDSA";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-        this.namedCurves = ["P-256", "P-384", "P-521", "K-256"];
-    }
+    name = "ECDSA";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
+    namedCurves = ["P-256", "P-384", "P-521", "K-256"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
@@ -566,21 +531,20 @@ class CryptoKey {
     static isKeyType(data) {
         return KEY_TYPES.indexOf(data) !== -1;
     }
-    get [Symbol.toStringTag]() {
-        return "CryptoKey";
-    }
+    algorithm;
+    type;
+    usages;
+    extractable;
+    [Symbol.toStringTag] = "CryptoKey";
 }
 
 class EcdhProvider extends EllipticProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "ECDH";
-        this.usages = {
-            privateKey: ["deriveBits", "deriveKey"],
-            publicKey: [],
-        };
-        this.namedCurves = ["P-256", "P-384", "P-521", "K-256"];
-    }
+    name = "ECDH";
+    usages = {
+        privateKey: ["deriveBits", "deriveKey"],
+        publicKey: [],
+    };
+    namedCurves = ["P-256", "P-384", "P-521", "K-256"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "public");
         if (!(algorithm.public instanceof CryptoKey)) {
@@ -596,26 +560,21 @@ class EcdhProvider extends EllipticProvider {
 }
 
 class EcdhEsProvider extends EcdhProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "ECDH-ES";
-        this.namedCurves = ["X25519", "X448"];
-    }
+    name = "ECDH-ES";
+    namedCurves = ["X25519", "X448"];
 }
 
 class EdDsaProvider extends EllipticProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "EdDSA";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-        this.namedCurves = ["Ed25519", "Ed448"];
-    }
+    name = "EdDSA";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
+    namedCurves = ["Ed25519", "Ed448"];
 }
 
 let ObjectIdentifier = class ObjectIdentifier {
+    value;
     constructor(value) {
         if (value) {
             this.value = value;
@@ -630,14 +589,14 @@ ObjectIdentifier = __decorate([
 ], ObjectIdentifier);
 
 class AlgorithmIdentifier {
+    algorithm;
+    parameters;
     constructor(params) {
         Object.assign(this, params);
     }
 }
 __decorate([
-    AsnProp({
-        type: AsnPropTypes.ObjectIdentifier,
-    })
+    AsnProp({ type: AsnPropTypes.ObjectIdentifier })
 ], AlgorithmIdentifier.prototype, "algorithm", void 0);
 __decorate([
     AsnProp({
@@ -647,11 +606,10 @@ __decorate([
 ], AlgorithmIdentifier.prototype, "parameters", void 0);
 
 class PrivateKeyInfo {
-    constructor() {
-        this.version = 0;
-        this.privateKeyAlgorithm = new AlgorithmIdentifier();
-        this.privateKey = new ArrayBuffer(0);
-    }
+    version = 0;
+    privateKeyAlgorithm = new AlgorithmIdentifier();
+    privateKey = new ArrayBuffer(0);
+    attributes;
 }
 __decorate([
     AsnProp({ type: AsnPropTypes.Integer })
@@ -663,14 +621,14 @@ __decorate([
     AsnProp({ type: AsnPropTypes.OctetString })
 ], PrivateKeyInfo.prototype, "privateKey", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Any, optional: true })
+    AsnProp({
+        type: AsnPropTypes.Any, optional: true,
+    })
 ], PrivateKeyInfo.prototype, "attributes", void 0);
 
 class PublicKeyInfo {
-    constructor() {
-        this.publicKeyAlgorithm = new AlgorithmIdentifier();
-        this.publicKey = new ArrayBuffer(0);
-    }
+    publicKeyAlgorithm = new AlgorithmIdentifier();
+    publicKey = new ArrayBuffer(0);
 }
 __decorate([
     AsnProp({ type: AlgorithmIdentifier })
@@ -680,8 +638,8 @@ __decorate([
 ], PublicKeyInfo.prototype, "publicKey", void 0);
 
 const JsonBase64UrlArrayBufferConverter = {
-    fromJSON: (value) => Convert.FromBase64Url(value),
-    toJSON: (value) => Convert.ToBase64Url(new Uint8Array(value)),
+    fromJSON: (value) => bytes.toArrayBuffer(encoding.base64url.decode(value)),
+    toJSON: (value) => encoding.base64url.encode(value),
 };
 
 const AsnIntegerArrayBufferConverter = {
@@ -693,88 +651,129 @@ const AsnIntegerArrayBufferConverter = {
     },
     toASN: (value) => {
         const valueHex = new Uint8Array(value)[0] > 127
-            ? combine(new Uint8Array([0]).buffer, value)
+            ? bytes.concat(new Uint8Array([0]).buffer, value)
             : value;
         return new asn1.Integer({ valueHex });
     },
 };
 
 var index$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AsnIntegerArrayBufferConverter: AsnIntegerArrayBufferConverter,
-  JsonBase64UrlArrayBufferConverter: JsonBase64UrlArrayBufferConverter
+    __proto__: null,
+    AsnIntegerArrayBufferConverter: AsnIntegerArrayBufferConverter,
+    JsonBase64UrlArrayBufferConverter: JsonBase64UrlArrayBufferConverter
 });
 
 class RsaPrivateKey {
-    constructor() {
-        this.version = 0;
-        this.modulus = new ArrayBuffer(0);
-        this.publicExponent = new ArrayBuffer(0);
-        this.privateExponent = new ArrayBuffer(0);
-        this.prime1 = new ArrayBuffer(0);
-        this.prime2 = new ArrayBuffer(0);
-        this.exponent1 = new ArrayBuffer(0);
-        this.exponent2 = new ArrayBuffer(0);
-        this.coefficient = new ArrayBuffer(0);
-    }
+    version = 0;
+    modulus = new ArrayBuffer(0);
+    publicExponent = new ArrayBuffer(0);
+    privateExponent = new ArrayBuffer(0);
+    prime1 = new ArrayBuffer(0);
+    prime2 = new ArrayBuffer(0);
+    exponent1 = new ArrayBuffer(0);
+    exponent2 = new ArrayBuffer(0);
+    coefficient = new ArrayBuffer(0);
+    otherPrimeInfos;
 }
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerConverter,
+    })
 ], RsaPrivateKey.prototype, "version", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "n", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "n", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "modulus", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "e", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "e", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "publicExponent", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "d", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "d", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "privateExponent", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "p", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "p", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "prime1", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "q", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "q", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "prime2", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "dp", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "dp", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "exponent1", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "dq", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "dq", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "exponent2", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "qi", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "qi", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "coefficient", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Any, optional: true })
+    AsnProp({
+        type: AsnPropTypes.Any, optional: true,
+    })
 ], RsaPrivateKey.prototype, "otherPrimeInfos", void 0);
 
 class RsaPublicKey {
-    constructor() {
-        this.modulus = new ArrayBuffer(0);
-        this.publicExponent = new ArrayBuffer(0);
-    }
+    modulus = new ArrayBuffer(0);
+    publicExponent = new ArrayBuffer(0);
 }
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "n", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "n", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPublicKey.prototype, "modulus", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    JsonProp({ name: "e", converter: JsonBase64UrlArrayBufferConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    JsonProp({
+        name: "e", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPublicKey.prototype, "publicExponent", void 0);
 
 let EcPublicKey = class EcPublicKey {
+    value = new ArrayBuffer(0);
     constructor(value) {
-        this.value = new ArrayBuffer(0);
         if (value) {
             this.value = value;
         }
@@ -788,8 +787,8 @@ let EcPublicKey = class EcPublicKey {
         const size = bytes.length / 2;
         const offset = 0;
         const json = {
-            x: Convert.ToBase64Url(bytes.buffer.slice(offset, offset + size)),
-            y: Convert.ToBase64Url(bytes.buffer.slice(offset + size, offset + size + size)),
+            x: encoding.base64url.encode(bytes.buffer.slice(offset, offset + size)),
+            y: encoding.base64url.encode(bytes.buffer.slice(offset + size, offset + size + size)),
         };
         return json;
     }
@@ -800,10 +799,10 @@ let EcPublicKey = class EcPublicKey {
         if (!("y" in json)) {
             throw new Error("y: Missing required property");
         }
-        const x = Convert.FromBase64Url(json.x);
-        const y = Convert.FromBase64Url(json.y);
-        const value = combine(new Uint8Array([0x04]).buffer, x, y);
-        this.value = new Uint8Array(value).buffer;
+        const x = encoding.base64url.decode(json.x);
+        const y = encoding.base64url.decode(json.y);
+        const value = bytes.concat(new Uint8Array([0x04]).buffer, x, y);
+        this.value = bytes.toArrayBuffer(value);
         return this;
     }
 };
@@ -815,15 +814,15 @@ EcPublicKey = __decorate([
 ], EcPublicKey);
 
 class EcPrivateKey {
-    constructor() {
-        this.version = 1;
-        this.privateKey = new ArrayBuffer(0);
-    }
+    version = 1;
+    privateKey = new ArrayBuffer(0);
+    parameters;
+    publicKey;
     fromJSON(json) {
         if (!("d" in json)) {
             throw new Error("d: Missing required property");
         }
-        this.privateKey = Convert.FromBase64Url(json.d);
+        this.privateKey = bytes.toArrayBuffer(encoding.base64url.decode(json.d));
         if ("x" in json) {
             const publicKey = new EcPublicKey();
             publicKey.fromJSON(json);
@@ -836,7 +835,7 @@ class EcPrivateKey {
     }
     toJSON() {
         const jwk = {};
-        jwk.d = Convert.ToBase64Url(this.privateKey);
+        jwk.d = encoding.base64url.encode(this.privateKey);
         if (this.publicKey) {
             Object.assign(jwk, new EcPublicKey(this.publicKey).toJSON());
         }
@@ -844,44 +843,27 @@ class EcPrivateKey {
     }
 }
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerConverter,
+    })
 ], EcPrivateKey.prototype, "version", void 0);
 __decorate([
     AsnProp({ type: AsnPropTypes.OctetString })
 ], EcPrivateKey.prototype, "privateKey", void 0);
 __decorate([
-    AsnProp({ context: 0, type: AsnPropTypes.Any, optional: true })
+    AsnProp({
+        context: 0, type: AsnPropTypes.Any, optional: true,
+    })
 ], EcPrivateKey.prototype, "parameters", void 0);
 __decorate([
-    AsnProp({ context: 1, type: AsnPropTypes.BitString, optional: true })
+    AsnProp({
+        context: 1, type: AsnPropTypes.BitString, optional: true,
+    })
 ], EcPrivateKey.prototype, "publicKey", void 0);
 
-const AsnIntegerWithoutPaddingConverter = {
-    fromASN: (value) => {
-        const bytes = new Uint8Array(value.valueBlock.valueHex);
-        return (bytes[0] === 0)
-            ? bytes.buffer.slice(1)
-            : bytes.buffer;
-    },
-    toASN: (value) => {
-        const bytes = new Uint8Array(value);
-        if (bytes[0] > 127) {
-            const newValue = new Uint8Array(bytes.length + 1);
-            newValue.set(bytes, 1);
-            return new asn1.Integer({ valueHex: newValue.buffer });
-        }
-        return new asn1.Integer({ valueHex: value });
-    },
-};
-
-var index$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AsnIntegerWithoutPaddingConverter: AsnIntegerWithoutPaddingConverter
-});
-
 class EcUtils {
     static decodePoint(data, pointSize) {
-        const view = BufferSourceConverter.toUint8Array(data);
+        const view = bytes.toUint8Array(data);
         if ((view.length === 0) || (view[0] !== 4)) {
             throw new Error("Only uncompressed point format supported");
         }
@@ -891,15 +873,17 @@ class EcUtils {
         }
         const xb = view.slice(1, n + 1);
         const yb = view.slice(n + 1, n + 1 + n);
-        return { x: xb, y: yb };
+        return {
+            x: xb, y: yb,
+        };
     }
     static encodePoint(point, pointSize) {
         const size = Math.ceil(pointSize / 8);
         if (point.x.byteLength !== size || point.y.byteLength !== size) {
             throw new Error("X,Y coordinates don't match point size criteria");
         }
-        const x = BufferSourceConverter.toUint8Array(point.x);
-        const y = BufferSourceConverter.toUint8Array(point.y);
+        const x = bytes.toUint8Array(point.x);
+        const y = bytes.toUint8Array(point.y);
         const res = new Uint8Array(size * 2 + 1);
         res[0] = 4;
         res.set(x, 1);
@@ -911,8 +895,8 @@ class EcUtils {
     }
     static encodeSignature(signature, pointSize) {
         const size = this.getSize(pointSize);
-        const r = BufferSourceConverter.toUint8Array(signature.r);
-        const s = BufferSourceConverter.toUint8Array(signature.s);
+        const r = bytes.toUint8Array(signature.r);
+        const s = bytes.toUint8Array(signature.s);
         const res = new Uint8Array(size * 2);
         res.set(this.padStart(r, size));
         res.set(this.padStart(s, size), size);
@@ -920,15 +904,15 @@ class EcUtils {
     }
     static decodeSignature(data, pointSize) {
         const size = this.getSize(pointSize);
-        const view = BufferSourceConverter.toUint8Array(data);
+        const view = bytes.toUint8Array(data);
         if (view.length !== (size * 2)) {
             throw new Error("Incorrect size of the signature");
         }
         const r = view.slice(0, size);
         const s = view.slice(size);
         return {
-            r: this.trimStart(r),
-            s: this.trimStart(s),
+            r: bytes.toArrayBuffer(this.trimStart(r)),
+            s: bytes.toArrayBuffer(this.trimStart(s)),
         };
     }
     static trimStart(data) {
@@ -951,19 +935,40 @@ class EcUtils {
     }
 }
 
+const AsnIntegerWithoutPaddingConverter = {
+    fromASN: (value) => {
+        const bytes = new Uint8Array(value.valueBlock.valueHex);
+        return (bytes[0] === 0)
+            ? bytes.buffer.slice(1)
+            : bytes.buffer;
+    },
+    toASN: (value) => {
+        const bytes = new Uint8Array(value);
+        if (bytes[0] > 127) {
+            const newValue = new Uint8Array(bytes.length + 1);
+            newValue.set(bytes, 1);
+            return new asn1.Integer({ valueHex: newValue.buffer });
+        }
+        return new asn1.Integer({ valueHex: value });
+    },
+};
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AsnIntegerWithoutPaddingConverter: AsnIntegerWithoutPaddingConverter
+});
+
 class EcDsaSignature {
-    constructor() {
-        this.r = new ArrayBuffer(0);
-        this.s = new ArrayBuffer(0);
-    }
     static fromWebCryptoSignature(value) {
         const pointSize = value.byteLength / 2;
         const point = EcUtils.decodeSignature(value, pointSize * 8);
         const ecSignature = new EcDsaSignature();
-        ecSignature.r = BufferSourceConverter.toArrayBuffer(point.r);
-        ecSignature.s = BufferSourceConverter.toArrayBuffer(point.s);
+        ecSignature.r = bytes.toArrayBuffer(point.r);
+        ecSignature.s = bytes.toArrayBuffer(point.s);
         return ecSignature;
     }
+    r = new ArrayBuffer(0);
+    s = new ArrayBuffer(0);
     toWebCryptoSignature(pointSize) {
         if (!pointSize) {
             const maxPointLength = Math.max(this.r.byteLength, this.s.byteLength);
@@ -978,37 +983,40 @@ class EcDsaSignature {
             }
         }
         const signature = EcUtils.encodeSignature(this, pointSize);
-        return signature.buffer;
+        return bytes.toArrayBuffer(signature);
     }
 }
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter,
+    })
 ], EcDsaSignature.prototype, "r", void 0);
 __decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter })
+    AsnProp({
+        type: AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter,
+    })
 ], EcDsaSignature.prototype, "s", void 0);
 
 class OneAsymmetricKey extends PrivateKeyInfo {
+    publicKey;
 }
 __decorate([
-    AsnProp({ context: 1, implicit: true, type: AsnPropTypes.BitString, optional: true })
+    AsnProp({
+        context: 1, implicit: true, type: AsnPropTypes.BitString, optional: true,
+    })
 ], OneAsymmetricKey.prototype, "publicKey", void 0);
 
 let EdPrivateKey = class EdPrivateKey {
-    constructor() {
-        this.value = new ArrayBuffer(0);
-    }
+    value = new ArrayBuffer(0);
     fromJSON(json) {
         if (!json.d) {
             throw new Error("d: Missing required property");
         }
-        this.value = Convert.FromBase64Url(json.d);
+        this.value = bytes.toArrayBuffer(encoding.base64url.decode(json.d));
         return this;
     }
     toJSON() {
-        const jwk = {
-            d: Convert.ToBase64Url(this.value),
-        };
+        const jwk = { d: encoding.base64url.encode(this.value) };
         return jwk;
     }
 };
@@ -1020,23 +1028,21 @@ EdPrivateKey = __decorate([
 ], EdPrivateKey);
 
 let EdPublicKey = class EdPublicKey {
+    value = new ArrayBuffer(0);
     constructor(value) {
-        this.value = new ArrayBuffer(0);
         if (value) {
             this.value = value;
         }
     }
     toJSON() {
-        const json = {
-            x: Convert.ToBase64Url(this.value),
-        };
+        const json = { x: encoding.base64url.encode(this.value) };
         return json;
     }
     fromJSON(json) {
         if (!("x" in json)) {
             throw new Error("x: Missing required property");
         }
-        this.value = Convert.FromBase64Url(json.x);
+        this.value = bytes.toArrayBuffer(encoding.base64url.decode(json.x));
         return this;
     }
 };
@@ -1048,10 +1054,13 @@ EdPublicKey = __decorate([
 ], EdPublicKey);
 
 let CurvePrivateKey = class CurvePrivateKey {
+    d;
 };
 __decorate([
     AsnProp({ type: AsnPropTypes.OctetString }),
-    JsonProp({ type: JsonPropTypes.String, converter: JsonBase64UrlArrayBufferConverter })
+    JsonProp({
+        type: JsonPropTypes.String, converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], CurvePrivateKey.prototype, "d", void 0);
 CurvePrivateKey = __decorate([
     AsnType({ type: AsnTypeTypes.Choice })
@@ -1083,49 +1092,50 @@ const idEd25519 = "1.3.101.112";
 const idEd448 = "1.3.101.113";
 
 var index$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AlgorithmIdentifier: AlgorithmIdentifier,
-  get CurvePrivateKey () { return CurvePrivateKey; },
-  EcDsaSignature: EcDsaSignature,
-  EcPrivateKey: EcPrivateKey,
-  get EcPublicKey () { return EcPublicKey; },
-  get EdPrivateKey () { return EdPrivateKey; },
-  get EdPublicKey () { return EdPublicKey; },
-  get ObjectIdentifier () { return ObjectIdentifier; },
-  OneAsymmetricKey: OneAsymmetricKey,
-  PrivateKeyInfo: PrivateKeyInfo,
-  PublicKeyInfo: PublicKeyInfo,
-  RsaPrivateKey: RsaPrivateKey,
-  RsaPublicKey: RsaPublicKey,
-  converters: index$2,
-  idBrainpoolP160r1: idBrainpoolP160r1,
-  idBrainpoolP160t1: idBrainpoolP160t1,
-  idBrainpoolP192r1: idBrainpoolP192r1,
-  idBrainpoolP192t1: idBrainpoolP192t1,
-  idBrainpoolP224r1: idBrainpoolP224r1,
-  idBrainpoolP224t1: idBrainpoolP224t1,
-  idBrainpoolP256r1: idBrainpoolP256r1,
-  idBrainpoolP256t1: idBrainpoolP256t1,
-  idBrainpoolP320r1: idBrainpoolP320r1,
-  idBrainpoolP320t1: idBrainpoolP320t1,
-  idBrainpoolP384r1: idBrainpoolP384r1,
-  idBrainpoolP384t1: idBrainpoolP384t1,
-  idBrainpoolP512r1: idBrainpoolP512r1,
-  idBrainpoolP512t1: idBrainpoolP512t1,
-  idEd25519: idEd25519,
-  idEd448: idEd448,
-  idEllipticCurve: idEllipticCurve,
-  idSecp256k1: idSecp256k1,
-  idSecp256r1: idSecp256r1,
-  idSecp384r1: idSecp384r1,
-  idSecp521r1: idSecp521r1,
-  idVersionOne: idVersionOne,
-  idX25519: idX25519,
-  idX448: idX448
+    __proto__: null,
+    AlgorithmIdentifier: AlgorithmIdentifier,
+    get CurvePrivateKey () { return CurvePrivateKey; },
+    EcDsaSignature: EcDsaSignature,
+    EcPrivateKey: EcPrivateKey,
+    get EcPublicKey () { return EcPublicKey; },
+    get EdPrivateKey () { return EdPrivateKey; },
+    get EdPublicKey () { return EdPublicKey; },
+    get ObjectIdentifier () { return ObjectIdentifier; },
+    OneAsymmetricKey: OneAsymmetricKey,
+    PrivateKeyInfo: PrivateKeyInfo,
+    PublicKeyInfo: PublicKeyInfo,
+    RsaPrivateKey: RsaPrivateKey,
+    RsaPublicKey: RsaPublicKey,
+    converters: index$2,
+    idBrainpoolP160r1: idBrainpoolP160r1,
+    idBrainpoolP160t1: idBrainpoolP160t1,
+    idBrainpoolP192r1: idBrainpoolP192r1,
+    idBrainpoolP192t1: idBrainpoolP192t1,
+    idBrainpoolP224r1: idBrainpoolP224r1,
+    idBrainpoolP224t1: idBrainpoolP224t1,
+    idBrainpoolP256r1: idBrainpoolP256r1,
+    idBrainpoolP256t1: idBrainpoolP256t1,
+    idBrainpoolP320r1: idBrainpoolP320r1,
+    idBrainpoolP320t1: idBrainpoolP320t1,
+    idBrainpoolP384r1: idBrainpoolP384r1,
+    idBrainpoolP384t1: idBrainpoolP384t1,
+    idBrainpoolP512r1: idBrainpoolP512r1,
+    idBrainpoolP512t1: idBrainpoolP512t1,
+    idEd25519: idEd25519,
+    idEd448: idEd448,
+    idEllipticCurve: idEllipticCurve,
+    idSecp256k1: idSecp256k1,
+    idSecp256r1: idSecp256r1,
+    idSecp384r1: idSecp384r1,
+    idSecp521r1: idSecp521r1,
+    idVersionOne: idVersionOne,
+    idX25519: idX25519,
+    idX448: idX448
 });
 
 class EcCurves {
-    constructor() { }
+    static items = [];
+    static names = [];
     static register(item) {
         const oid = new ObjectIdentifier();
         oid.value = item.id;
@@ -1153,59 +1163,84 @@ class EcCurves {
         return res;
     }
 }
-EcCurves.items = [];
-EcCurves.names = [];
-EcCurves.register({ name: "P-256", id: idSecp256r1, size: 256 });
-EcCurves.register({ name: "P-384", id: idSecp384r1, size: 384 });
-EcCurves.register({ name: "P-521", id: idSecp521r1, size: 521 });
-EcCurves.register({ name: "K-256", id: idSecp256k1, size: 256 });
-EcCurves.register({ name: "brainpoolP160r1", id: idBrainpoolP160r1, size: 160 });
-EcCurves.register({ name: "brainpoolP160t1", id: idBrainpoolP160t1, size: 160 });
-EcCurves.register({ name: "brainpoolP192r1", id: idBrainpoolP192r1, size: 192 });
-EcCurves.register({ name: "brainpoolP192t1", id: idBrainpoolP192t1, size: 192 });
-EcCurves.register({ name: "brainpoolP224r1", id: idBrainpoolP224r1, size: 224 });
-EcCurves.register({ name: "brainpoolP224t1", id: idBrainpoolP224t1, size: 224 });
-EcCurves.register({ name: "brainpoolP256r1", id: idBrainpoolP256r1, size: 256 });
-EcCurves.register({ name: "brainpoolP256t1", id: idBrainpoolP256t1, size: 256 });
-EcCurves.register({ name: "brainpoolP320r1", id: idBrainpoolP320r1, size: 320 });
-EcCurves.register({ name: "brainpoolP320t1", id: idBrainpoolP320t1, size: 320 });
-EcCurves.register({ name: "brainpoolP384r1", id: idBrainpoolP384r1, size: 384 });
-EcCurves.register({ name: "brainpoolP384t1", id: idBrainpoolP384t1, size: 384 });
-EcCurves.register({ name: "brainpoolP512r1", id: idBrainpoolP512r1, size: 512 });
-EcCurves.register({ name: "brainpoolP512t1", id: idBrainpoolP512t1, size: 512 });
+EcCurves.register({
+    name: "P-256", id: idSecp256r1, size: 256,
+});
+EcCurves.register({
+    name: "P-384", id: idSecp384r1, size: 384,
+});
+EcCurves.register({
+    name: "P-521", id: idSecp521r1, size: 521,
+});
+EcCurves.register({
+    name: "K-256", id: idSecp256k1, size: 256,
+});
+EcCurves.register({
+    name: "brainpoolP160r1", id: idBrainpoolP160r1, size: 160,
+});
+EcCurves.register({
+    name: "brainpoolP160t1", id: idBrainpoolP160t1, size: 160,
+});
+EcCurves.register({
+    name: "brainpoolP192r1", id: idBrainpoolP192r1, size: 192,
+});
+EcCurves.register({
+    name: "brainpoolP192t1", id: idBrainpoolP192t1, size: 192,
+});
+EcCurves.register({
+    name: "brainpoolP224r1", id: idBrainpoolP224r1, size: 224,
+});
+EcCurves.register({
+    name: "brainpoolP224t1", id: idBrainpoolP224t1, size: 224,
+});
+EcCurves.register({
+    name: "brainpoolP256r1", id: idBrainpoolP256r1, size: 256,
+});
+EcCurves.register({
+    name: "brainpoolP256t1", id: idBrainpoolP256t1, size: 256,
+});
+EcCurves.register({
+    name: "brainpoolP320r1", id: idBrainpoolP320r1, size: 320,
+});
+EcCurves.register({
+    name: "brainpoolP320t1", id: idBrainpoolP320t1, size: 320,
+});
+EcCurves.register({
+    name: "brainpoolP384r1", id: idBrainpoolP384r1, size: 384,
+});
+EcCurves.register({
+    name: "brainpoolP384t1", id: idBrainpoolP384t1, size: 384,
+});
+EcCurves.register({
+    name: "brainpoolP512r1", id: idBrainpoolP512r1, size: 512,
+});
+EcCurves.register({
+    name: "brainpoolP512t1", id: idBrainpoolP512t1, size: 512,
+});
 
 class X25519Provider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "X25519";
-        this.usages = {
-            privateKey: ["deriveKey", "deriveBits"],
-            publicKey: [],
-        };
-    }
+    name = "X25519";
+    usages = {
+        privateKey: ["deriveKey", "deriveBits"],
+        publicKey: [],
+    };
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "public");
     }
 }
 
 class Ed25519Provider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "Ed25519";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-    }
+    name = "Ed25519";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
 }
 
 class HmacProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "HMAC";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = ["sign", "verify"];
-    }
+    name = "HMAC";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = ["sign", "verify"];
     getDefaultLength(algName) {
         switch (algName.toUpperCase()) {
             case "SHA-1":
@@ -1236,12 +1271,9 @@ class HmacProvider extends ProviderCrypto {
 }
 
 class Pbkdf2Provider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "PBKDF2";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = ["deriveBits", "deriveKey"];
-    }
+    name = "PBKDF2";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = ["deriveBits", "deriveKey"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
@@ -1266,22 +1298,19 @@ class Pbkdf2Provider extends ProviderCrypto {
 }
 
 class HkdfProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "HKDF";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = ["deriveKey", "deriveBits"];
-    }
+    name = "HKDF";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = ["deriveKey", "deriveBits"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
         this.checkRequiredProperty(algorithm, "salt");
-        if (!BufferSourceConverter.isBufferSource(algorithm.salt)) {
+        if (!bytes.isBufferSource(algorithm.salt)) {
             throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
         }
         this.checkRequiredProperty(algorithm, "info");
-        if (!BufferSourceConverter.isBufferSource(algorithm.info)) {
-            throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
+        if (!bytes.isBufferSource(algorithm.info)) {
+            throw new TypeError("info: Is not of type '(ArrayBuffer or ArrayBufferView)'");
         }
     }
     checkImportKey(format, keyData, algorithm, extractable, keyUsages, ...args) {
@@ -1293,13 +1322,12 @@ class HkdfProvider extends ProviderCrypto {
 }
 
 class ShakeProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.usages = [];
-        this.defaultLength = 0;
-    }
+    usages = [];
+    defaultLength = 0;
     digest(...args) {
-        args[0] = { length: this.defaultLength, ...args[0] };
+        args[0] = {
+            length: this.defaultLength, ...args[0],
+        };
         return super.digest.apply(this, args);
     }
     checkDigest(algorithm, data) {
@@ -1315,38 +1343,28 @@ class ShakeProvider extends ProviderCrypto {
 }
 
 class Shake128Provider extends ShakeProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "shake128";
-        this.defaultLength = 16;
-    }
+    name = "shake128";
+    defaultLength = 16;
 }
 
 class Shake256Provider extends ShakeProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "shake256";
-        this.defaultLength = 32;
-    }
+    name = "shake256";
+    defaultLength = 32;
 }
 
 class Crypto {
-    get [Symbol.toStringTag]() {
-        return "Crypto";
-    }
+    [Symbol.toStringTag] = "Crypto";
     randomUUID() {
         const b = this.getRandomValues(new Uint8Array(16));
         b[6] = (b[6] & 0x0f) | 0x40;
         b[8] = (b[8] & 0x3f) | 0x80;
-        const uuid = Convert.ToHex(b).toLowerCase();
+        const uuid = encoding.hex.encode(b, { case: "lower" });
         return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20)}`;
     }
 }
 
 class ProviderStorage {
-    constructor() {
-        this.items = {};
-    }
+    items = {};
     get(algorithmName) {
         return this.items[algorithmName.toLowerCase()] || null;
     }
@@ -1377,16 +1395,13 @@ class ProviderStorage {
 }
 
 const keyFormatMap = {
-    "jwk": ["private", "public", "secret"],
-    "pkcs8": ["private"],
-    "spki": ["public"],
-    "raw": ["secret", "public"]
+    jwk: ["private", "public", "secret"],
+    pkcs8: ["private"],
+    spki: ["public"],
+    raw: ["secret", "public"],
 };
 const sourceBufferKeyFormats = ["pkcs8", "spki", "raw"];
 class SubtleCrypto {
-    constructor() {
-        this.providers = new ProviderStorage();
-    }
     static isHashedAlgorithm(data) {
         return data
             && typeof data === "object"
@@ -1395,14 +1410,13 @@ class SubtleCrypto {
             ? true
             : false;
     }
-    get [Symbol.toStringTag]() {
-        return "SubtleCrypto";
-    }
+    providers = new ProviderStorage();
+    [Symbol.toStringTag] = "SubtleCrypto";
     async digest(...args) {
         this.checkRequiredArguments(args, 2, "digest");
         const [algorithm, data, ...params] = args;
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
         const result = await provider.digest(preparedAlgorithm, preparedData, ...params);
         return result;
@@ -1412,7 +1426,9 @@ class SubtleCrypto {
         const [algorithm, extractable, keyUsages, ...params] = args;
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.generateKey({ ...preparedAlgorithm, name: provider.name }, extractable, keyUsages, ...params);
+        const result = await provider.generateKey({
+            ...preparedAlgorithm, name: provider.name,
+        }, extractable, keyUsages, ...params);
         return result;
     }
     async sign(...args) {
@@ -1420,9 +1436,11 @@ class SubtleCrypto {
         const [algorithm, key, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.sign({ ...preparedAlgorithm, name: provider.name }, key, preparedData, ...params);
+        const result = await provider.sign({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedData, ...params);
         return result;
     }
     async verify(...args) {
@@ -1430,10 +1448,12 @@ class SubtleCrypto {
         const [algorithm, key, signature, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const preparedSignature = BufferSourceConverter.toArrayBuffer(signature);
+        const preparedData = bytes.toArrayBuffer(data);
+        const preparedSignature = bytes.toArrayBuffer(signature);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.verify({ ...preparedAlgorithm, name: provider.name }, key, preparedSignature, preparedData, ...params);
+        const result = await provider.verify({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedSignature, preparedData, ...params);
         return result;
     }
     async encrypt(...args) {
@@ -1441,9 +1461,11 @@ class SubtleCrypto {
         const [algorithm, key, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.encrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true }, ...params);
+        const result = await provider.encrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedData, { keyUsage: true }, ...params);
         return result;
     }
     async decrypt(...args) {
@@ -1451,9 +1473,11 @@ class SubtleCrypto {
         const [algorithm, key, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true }, ...params);
+        const result = await provider.decrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedData, { keyUsage: true }, ...params);
         return result;
     }
     async deriveBits(...args) {
@@ -1462,7 +1486,9 @@ class SubtleCrypto {
         this.checkCryptoKey(baseKey);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, length, { keyUsage: true }, ...params);
+        const result = await provider.deriveBits({
+            ...preparedAlgorithm, name: provider.name,
+        }, baseKey, length, { keyUsage: true }, ...params);
         return result;
     }
     async deriveKey(...args) {
@@ -1474,7 +1500,9 @@ class SubtleCrypto {
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
         const provider = this.getProvider(preparedAlgorithm.name);
         provider.checkCryptoKey(baseKey, "deriveKey");
-        const derivedBits = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, derivedKeyType.length || 512, { keyUsage: false }, ...params);
+        const derivedBits = await provider.deriveBits({
+            ...preparedAlgorithm, name: provider.name,
+        }, baseKey, derivedKeyType.length || 512, { keyUsage: false }, ...params);
         return this.importKey("raw", derivedBits, derivedKeyType, extractable, keyUsages, ...params);
     }
     async exportKey(...args) {
@@ -1502,34 +1530,40 @@ class SubtleCrypto {
             }
         }
         else if (sourceBufferKeyFormats.includes(format)) {
-            if (!BufferSourceConverter.isBufferSource(keyData)) {
+            if (!bytes.isBufferSource(keyData)) {
                 throw new TypeError("Key data must be a BufferSource for non-JWK formats");
             }
         }
         else {
             throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView or JsonWebKey)'");
         }
-        return provider.importKey(format, keyData, { ...preparedAlgorithm, name: provider.name }, extractable, keyUsages, ...params);
+        return provider.importKey(format, keyData, {
+            ...preparedAlgorithm, name: provider.name,
+        }, extractable, keyUsages, ...params);
     }
     async wrapKey(format, key, wrappingKey, wrapAlgorithm, ...args) {
         let keyData = await this.exportKey(format, key, ...args);
         if (format === "jwk") {
             const json = JSON.stringify(keyData);
-            keyData = Convert.FromUtf8String(json);
+            keyData = bytes.toArrayBuffer(encoding.utf8.encode(json));
         }
         const preparedAlgorithm = this.prepareAlgorithm(wrapAlgorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
+        const preparedData = bytes.toArrayBuffer(keyData);
         const provider = this.getProvider(preparedAlgorithm.name);
-        return provider.encrypt({ ...preparedAlgorithm, name: provider.name }, wrappingKey, preparedData, { keyUsage: false }, ...args);
+        return provider.encrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, wrappingKey, preparedData, { keyUsage: false }, ...args);
     }
     async unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages, ...args) {
         const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(wrappedKey);
+        const preparedData = bytes.toArrayBuffer(wrappedKey);
         const provider = this.getProvider(preparedAlgorithm.name);
-        let keyData = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, unwrappingKey, preparedData, { keyUsage: false }, ...args);
+        let keyData = await provider.decrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, unwrappingKey, preparedData, { keyUsage: false }, ...args);
         if (format === "jwk") {
             try {
-                keyData = JSON.parse(Convert.ToUtf8String(keyData));
+                keyData = JSON.parse(encoding.utf8.decode(keyData));
             }
             catch (e) {
                 const error = new TypeError("wrappedKey: Is not a JSON");
@@ -1546,9 +1580,7 @@ class SubtleCrypto {
     }
     prepareAlgorithm(algorithm) {
         if (typeof algorithm === "string") {
-            return {
-                name: algorithm,
-            };
+            return { name: algorithm };
         }
         if (SubtleCrypto.isHashedAlgorithm(algorithm)) {
             const preparedAlgorithm = { ...algorithm };
@@ -1566,26 +1598,26 @@ class SubtleCrypto {
     }
     checkCryptoKey(key) {
         if (!(key instanceof CryptoKey)) {
-            throw new TypeError(`Key is not of type 'CryptoKey'`);
+            throw new TypeError("Key is not of type 'CryptoKey'");
         }
     }
 }
 
 var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  converters: index$3
+    __proto__: null,
+    converters: index$3
 });
 
 const REQUIRED_FIELDS = ["crv", "e", "k", "kty", "n", "x", "y"];
 class JwkUtils {
     static async thumbprint(hash, jwk, crypto) {
         const data = this.format(jwk, true);
-        return crypto.subtle.digest(hash, Convert.FromBinary(JSON.stringify(data)));
+        return crypto.subtle.digest(hash, bytes.toArrayBuffer(encoding.binary.decode(JSON.stringify(data))));
     }
     static format(jwk, remove = false) {
         let res = Object.entries(jwk);
         if (remove) {
-            res = res.filter(o => REQUIRED_FIELDS.includes(o[0]));
+            res = res.filter((o) => REQUIRED_FIELDS.includes(o[0]));
         }
         res = res.sort(([keyA], [keyB]) => keyA > keyB ? 1 : keyA < keyB ? -1 : 0);
         return Object.fromEntries(res);