@opcua/for-node-red 3.34.2 → 3.36.0

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

@@ -1,57 +1,59 @@
-/*!
- Copyright (c) Peculiar Ventures, LLC
-*/
+/**
+ * Copyright (c) 2019-2026, Peculiar Ventures
+ * SPDX-License-Identifier: MIT
+ */
 
 import * as core from 'webcrypto-core';
-import { BufferSourceConverter as BufferSourceConverter$1 } from 'webcrypto-core';
+import { BufferSourceConverter } from 'webcrypto-core';
 export { CryptoKey } from 'webcrypto-core';
-import { Buffer as Buffer$1 } from 'buffer';
-import crypto from 'crypto';
-import * as process from 'process';
+import { Buffer as Buffer$1 } from 'node:buffer';
+import crypto from 'node:crypto';
+import * as process from 'node:process';
 import { __decorate } from 'tslib';
 import { JsonProp, JsonPropTypes, JsonSerializer, JsonParser } from '@peculiar/json-schema';
-import { Convert, BufferSourceConverter } from 'pvtsutils';
+import { convert, toArrayBuffer, assertBufferSource, toUint8Array } from '@peculiar/utils';
 import { AsnParser, AsnSerializer, AsnConvert } from '@peculiar/asn1-schema';
 
 const JsonBase64UrlConverter = {
-    fromJSON: (value) => Buffer$1.from(Convert.FromBase64Url(value)),
-    toJSON: (value) => Convert.ToBase64Url(value),
+    fromJSON: (value) => Buffer$1.from(convert.decode("base64url", value)),
+    toJSON: (value) => convert.encode("base64url", value),
 };
 
 class CryptoKey extends core.CryptoKey {
-    constructor() {
-        super(...arguments);
-        this.data = Buffer$1.alloc(0);
-        this.algorithm = { name: "" };
-        this.extractable = false;
-        this.type = "secret";
-        this.usages = [];
-        this.kty = "oct";
-        this.alg = "";
-    }
+    data = Buffer$1.alloc(0);
+    algorithm = { name: "" };
+    extractable = false;
+    type = "secret";
+    usages = [];
+    kty = "oct";
+    alg = "";
 }
 __decorate([
-    JsonProp({ name: "ext", type: JsonPropTypes.Boolean, optional: true })
+    JsonProp({
+        name: "ext", type: JsonPropTypes.Boolean, optional: true,
+    })
 ], CryptoKey.prototype, "extractable", void 0);
 __decorate([
-    JsonProp({ name: "key_ops", type: JsonPropTypes.String, repeated: true, optional: true })
+    JsonProp({
+        name: "key_ops", type: JsonPropTypes.String, repeated: true, optional: true,
+    })
 ], CryptoKey.prototype, "usages", void 0);
 __decorate([
     JsonProp({ type: JsonPropTypes.String })
 ], CryptoKey.prototype, "kty", void 0);
 __decorate([
-    JsonProp({ type: JsonPropTypes.String, optional: true })
+    JsonProp({
+        type: JsonPropTypes.String, optional: true,
+    })
 ], CryptoKey.prototype, "alg", void 0);
 
 class SymmetricKey extends CryptoKey {
-    constructor() {
-        super(...arguments);
-        this.kty = "oct";
-        this.type = "secret";
-    }
+    kty = "oct";
+    type = "secret";
 }
 
 class AsymmetricKey extends CryptoKey {
+    pem;
 }
 
 class AesCryptoKey extends SymmetricKey {
@@ -77,10 +79,28 @@ class AesCryptoKey extends SymmetricKey {
     }
 }
 __decorate([
-    JsonProp({ name: "k", converter: JsonBase64UrlConverter })
+    JsonProp({
+        name: "k", converter: JsonBase64UrlConverter,
+    })
 ], AesCryptoKey.prototype, "data", void 0);
 
+const keyStorage = new WeakMap();
+function getCryptoKey(key) {
+    const res = keyStorage.get(key);
+    if (!res) {
+        throw new core.OperationError("Cannot get CryptoKey from secure storage");
+    }
+    return res;
+}
+function setCryptoKey(value) {
+    const key = core.CryptoKey.create(value.algorithm, value.type, value.extractable, value.usages);
+    Object.freeze(key);
+    keyStorage.set(key, value);
+    return key;
+}
+
 class AesCrypto {
+    static AES_KW_IV = Buffer$1.from("A6A6A6A6A6A6A6A6", "hex");
     static async generateKey(algorithm, extractable, keyUsages) {
         const key = new AesCryptoKey();
         key.algorithm = algorithm;
@@ -97,7 +117,7 @@ class AesCrypto {
             case "jwk":
                 return JsonSerializer.toJSON(key);
             case "raw":
-                return new Uint8Array(key.data).buffer;
+                return toArrayBuffer(key.data);
             default:
                 throw new core.OperationError("format: Must be 'jwk' or 'raw'");
         }
@@ -109,8 +129,9 @@ class AesCrypto {
                 key = JsonParser.fromJSON(keyData, { targetSchema: AesCryptoKey });
                 break;
             case "raw":
+                assertBufferSource(keyData);
                 key = new AesCryptoKey();
-                key.data = Buffer$1.from(keyData);
+                key.data = Buffer$1.from(toUint8Array(keyData));
                 break;
             default:
                 throw new core.OperationError("format: Must be 'jwk' or 'raw'");
@@ -165,99 +186,79 @@ class AesCrypto {
         }
     }
     static async encryptAesCBC(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-cbc`, key.data, new Uint8Array(algorithm.iv));
+        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-cbc`, key.data, toUint8Array(algorithm.iv));
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        const res = toArrayBuffer(enc);
         return res;
     }
     static async decryptAesCBC(algorithm, key, data) {
-        const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-cbc`, key.data, new Uint8Array(algorithm.iv));
+        const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-cbc`, key.data, toUint8Array(algorithm.iv));
         let dec = decipher.update(data);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        return toArrayBuffer(dec);
     }
     static async encryptAesCTR(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-ctr`, key.data, Buffer$1.from(algorithm.counter));
+        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-ctr`, key.data, Buffer$1.from(toUint8Array(algorithm.counter)));
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        const res = toArrayBuffer(enc);
         return res;
     }
     static async decryptAesCTR(algorithm, key, data) {
-        const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-ctr`, key.data, new Uint8Array(algorithm.counter));
+        const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-ctr`, key.data, toUint8Array(algorithm.counter));
         let dec = decipher.update(data);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        return toArrayBuffer(dec);
     }
     static async encryptAesGCM(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-gcm`, key.data, Buffer$1.from(algorithm.iv), {
-            authTagLength: (algorithm.tagLength || 128) >> 3,
-        });
+        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-gcm`, key.data, Buffer$1.from(toUint8Array(algorithm.iv)), { authTagLength: (algorithm.tagLength || 128) >> 3 });
         if (algorithm.additionalData) {
-            cipher.setAAD(Buffer$1.from(algorithm.additionalData));
+            cipher.setAAD(Buffer$1.from(toUint8Array(algorithm.additionalData)));
         }
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final(), cipher.getAuthTag()]);
-        const res = new Uint8Array(enc).buffer;
+        const res = toArrayBuffer(enc);
         return res;
     }
     static async decryptAesGCM(algorithm, key, data) {
         const tagLength = (algorithm.tagLength || 128) >> 3;
-        const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-gcm`, key.data, new Uint8Array(algorithm.iv), {
-            authTagLength: tagLength,
-        });
+        const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-gcm`, key.data, toUint8Array(algorithm.iv), { authTagLength: tagLength });
         const enc = data.slice(0, data.length - tagLength);
         const tag = data.slice(data.length - tagLength);
         if (algorithm.additionalData) {
-            decipher.setAAD(Buffer$1.from(algorithm.additionalData));
+            decipher.setAAD(Buffer$1.from(toUint8Array(algorithm.additionalData)));
         }
         decipher.setAuthTag(tag);
         let dec = decipher.update(enc);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        return toArrayBuffer(dec);
     }
     static async encryptAesKW(algorithm, key, data) {
         const cipher = crypto.createCipheriv(`id-aes${key.algorithm.length}-wrap`, key.data, this.AES_KW_IV);
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final()]);
-        return new Uint8Array(enc).buffer;
+        return toArrayBuffer(enc);
     }
     static async decryptAesKW(algorithm, key, data) {
         const decipher = crypto.createDecipheriv(`id-aes${key.algorithm.length}-wrap`, key.data, this.AES_KW_IV);
         let dec = decipher.update(data);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        return toArrayBuffer(dec);
     }
     static async encryptAesECB(algorithm, key, data) {
         const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-ecb`, key.data, new Uint8Array(0));
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        const res = toArrayBuffer(enc);
         return res;
     }
     static async decryptAesECB(algorithm, key, data) {
         const decipher = crypto.createDecipheriv(`aes-${key.algorithm.length}-ecb`, key.data, new Uint8Array(0));
         let dec = decipher.update(data);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
-    }
-}
-AesCrypto.AES_KW_IV = Buffer$1.from("A6A6A6A6A6A6A6A6", "hex");
-
-const keyStorage = new WeakMap();
-function getCryptoKey(key) {
-    const res = keyStorage.get(key);
-    if (!res) {
-        throw new core.OperationError("Cannot get CryptoKey from secure storage");
+        return toArrayBuffer(dec);
     }
-    return res;
-}
-function setCryptoKey(value) {
-    const key = core.CryptoKey.create(value.algorithm, value.type, value.extractable, value.usages);
-    Object.freeze(key);
-    keyStorage.set(key, value);
-    return key;
 }
 
 class AesCbcProvider extends core.AesCbcProvider {
@@ -344,7 +345,9 @@ function generateSubkeys(key) {
     if (subkey1[0] & 0x80) {
         subkey2 = xor(subkey2, rb);
     }
-    return { subkey1, subkey2 };
+    return {
+        subkey1, subkey2,
+    };
 }
 function aesCmac(key, message) {
     const subkeys = generateSubkeys(key);
@@ -525,9 +528,9 @@ class DesCryptoKey extends SymmetricKey {
     get alg() {
         switch (this.algorithm.name.toUpperCase()) {
             case "DES-CBC":
-                return `DES-CBC`;
+                return "DES-CBC";
             case "DES-EDE3-CBC":
-                return `3DES-CBC`;
+                return "3DES-CBC";
             default:
                 throw new core.AlgorithmError("Unsupported algorithm name");
         }
@@ -536,7 +539,9 @@ class DesCryptoKey extends SymmetricKey {
     }
 }
 __decorate([
-    JsonProp({ name: "k", converter: JsonBase64UrlConverter })
+    JsonProp({
+        name: "k", converter: JsonBase64UrlConverter,
+    })
 ], DesCryptoKey.prototype, "data", void 0);
 
 class DesCrypto {
@@ -553,7 +558,7 @@ class DesCrypto {
             case "jwk":
                 return JsonSerializer.toJSON(key);
             case "raw":
-                return new Uint8Array(key.data).buffer;
+                return toArrayBuffer(key.data);
             default:
                 throw new core.OperationError("format: Must be 'jwk' or 'raw'");
         }
@@ -565,8 +570,9 @@ class DesCrypto {
                 key = JsonParser.fromJSON(keyData, { targetSchema: DesCryptoKey });
                 break;
             case "raw":
+                assertBufferSource(keyData);
                 key = new DesCryptoKey();
-                key.data = Buffer$1.from(keyData);
+                key.data = Buffer$1.from(toUint8Array(keyData));
                 break;
             default:
                 throw new core.OperationError("format: Must be 'jwk' or 'raw'");
@@ -600,40 +606,37 @@ class DesCrypto {
         }
     }
     static async encryptDesCBC(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`des-cbc`, key.data, new Uint8Array(algorithm.iv));
+        const cipher = crypto.createCipheriv("des-cbc", key.data, toUint8Array(algorithm.iv));
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        const res = toArrayBuffer(enc);
         return res;
     }
     static async decryptDesCBC(algorithm, key, data) {
-        const decipher = crypto.createDecipheriv(`des-cbc`, key.data, new Uint8Array(algorithm.iv));
+        const decipher = crypto.createDecipheriv("des-cbc", key.data, toUint8Array(algorithm.iv));
         let dec = decipher.update(data);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        return toArrayBuffer(dec);
     }
     static async encryptDesEDE3CBC(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`des-ede3-cbc`, key.data, Buffer$1.from(algorithm.iv));
+        const cipher = crypto.createCipheriv("des-ede3-cbc", key.data, Buffer$1.from(toUint8Array(algorithm.iv)));
         let enc = cipher.update(data);
         enc = Buffer$1.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        const res = toArrayBuffer(enc);
         return res;
     }
     static async decryptDesEDE3CBC(algorithm, key, data) {
-        const decipher = crypto.createDecipheriv(`des-ede3-cbc`, key.data, new Uint8Array(algorithm.iv));
+        const decipher = crypto.createDecipheriv("des-ede3-cbc", key.data, toUint8Array(algorithm.iv));
         let dec = decipher.update(data);
         dec = Buffer$1.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        return toArrayBuffer(dec);
     }
 }
 
 class DesCbcProvider extends core.DesProvider {
-    constructor() {
-        super(...arguments);
-        this.keySizeBits = 64;
-        this.ivSize = 8;
-        this.name = "DES-CBC";
-    }
+    keySizeBits = 64;
+    ivSize = 8;
+    name = "DES-CBC";
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const key = await DesCrypto.generateKey({
             name: this.name,
@@ -651,7 +654,9 @@ class DesCbcProvider extends core.DesProvider {
         return DesCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await DesCrypto.importKey(format, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
+        const key = await DesCrypto.importKey(format, keyData, {
+            name: this.name, length: this.keySizeBits,
+        }, extractable, keyUsages);
         if (key.data.length !== (this.keySizeBits >> 3)) {
             throw new core.OperationError("keyData: Wrong key size");
         }
@@ -666,12 +671,9 @@ class DesCbcProvider extends core.DesProvider {
 }
 
 class DesEde3CbcProvider extends core.DesProvider {
-    constructor() {
-        super(...arguments);
-        this.keySizeBits = 192;
-        this.ivSize = 8;
-        this.name = "DES-EDE3-CBC";
-    }
+    keySizeBits = 192;
+    ivSize = 8;
+    name = "DES-EDE3-CBC";
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const key = await DesCrypto.generateKey({
             name: this.name,
@@ -689,7 +691,9 @@ class DesEde3CbcProvider extends core.DesProvider {
         return DesCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await DesCrypto.importKey(format, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
+        const key = await DesCrypto.importKey(format, keyData, {
+            name: this.name, length: this.keySizeBits,
+        }, extractable, keyUsages);
         if (key.data.length !== (this.keySizeBits >> 3)) {
             throw new core.OperationError("keyData: Wrong key size");
         }
@@ -714,17 +718,14 @@ function getJwkAlgorithm(algorithm) {
         case "RSA-PSS":
             return `PS${/(\d+)$/.exec(algorithm.hash.name)[1]}`;
         case "RSA-PKCS1":
-            return `RS1`;
+            return "RS1";
         default:
             throw new core.OperationError("algorithm: Is not recognized");
     }
 }
 
 class RsaPrivateKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     getKey() {
         const keyInfo = AsnParser.parse(this.data, core.asn1.PrivateKeyInfo);
         return AsnParser.parse(keyInfo.privateKey, core.asn1.RsaPrivateKey);
@@ -750,10 +751,7 @@ class RsaPrivateKey extends AsymmetricKey {
 }
 
 class RsaPublicKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     getKey() {
         const keyInfo = AsnParser.parse(this.data, core.asn1.PublicKeyInfo);
         return AsnParser.parse(keyInfo.publicKey, core.asn1.RsaPublicKey);
@@ -779,6 +777,8 @@ class RsaPublicKey extends AsymmetricKey {
 }
 
 class RsaCrypto {
+    static publicKeyUsages = ["verify", "encrypt", "wrapKey"];
+    static privateKeyUsages = ["sign", "decrypt", "unwrapKey"];
     static async generateKey(algorithm, extractable, keyUsages) {
         const privateKey = new RsaPrivateKey();
         privateKey.algorithm = algorithm;
@@ -818,7 +818,7 @@ class RsaCrypto {
                 return JsonSerializer.toJSON(key);
             case "pkcs8":
             case "spki":
-                return new Uint8Array(key.data).buffer;
+                return toArrayBuffer(key.data);
             default:
                 throw new core.OperationError("format: Must be 'jwk', 'pkcs8' or 'spki'");
         }
@@ -837,12 +837,14 @@ class RsaCrypto {
                 }
             }
             case "spki": {
-                const keyInfo = AsnParser.parse(new Uint8Array(keyData), core.asn1.PublicKeyInfo);
+                assertBufferSource(keyData);
+                const keyInfo = AsnParser.parse(toUint8Array(keyData), core.asn1.PublicKeyInfo);
                 const asnKey = AsnParser.parse(keyInfo.publicKey, core.asn1.RsaPublicKey);
                 return this.importPublicKey(asnKey, algorithm, extractable, keyUsages);
             }
             case "pkcs8": {
-                const keyInfo = AsnParser.parse(new Uint8Array(keyData), core.asn1.PrivateKeyInfo);
+                assertBufferSource(keyData);
+                const keyInfo = AsnParser.parse(toUint8Array(keyData), core.asn1.PrivateKeyInfo);
                 const asnKey = AsnParser.parse(keyInfo.privateKey, core.asn1.RsaPrivateKey);
                 return this.importPrivateKey(asnKey, algorithm, extractable, keyUsages);
             }
@@ -939,15 +941,13 @@ class RsaCrypto {
         if (!key.pem) {
             key.pem = `-----BEGIN PRIVATE KEY-----\n${key.data.toString("base64")}\n-----END PRIVATE KEY-----`;
         }
-        const options = {
-            key: key.pem,
-        };
+        const options = { key: key.pem };
         if (algorithm.name.toUpperCase() === "RSA-PSS") {
             options.padding = crypto.constants.RSA_PKCS1_PSS_PADDING;
             options.saltLength = algorithm.saltLength;
         }
         const signature = signer.sign(options);
-        return new Uint8Array(signature).buffer;
+        return toArrayBuffer(signature);
     }
     static verifySSA(algorithm, key, data, signature) {
         const cryptoAlg = this.getCryptoAlgorithm(key.algorithm);
@@ -956,9 +956,7 @@ class RsaCrypto {
         if (!key.pem) {
             key.pem = `-----BEGIN PUBLIC KEY-----\n${key.data.toString("base64")}\n-----END PUBLIC KEY-----`;
         }
-        const options = {
-            key: key.pem,
-        };
+        const options = { key: key.pem };
         if (algorithm.name.toUpperCase() === "RSA-PSS") {
             options.padding = crypto.constants.RSA_PKCS1_PSS_PADDING;
             options.saltLength = algorithm.saltLength;
@@ -972,7 +970,7 @@ class RsaCrypto {
             padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
         };
         if (algorithm.label) ;
-        return new Uint8Array(crypto.publicEncrypt(options, data)).buffer;
+        return toArrayBuffer(crypto.publicEncrypt(options, data));
     }
     static decryptOAEP(algorithm, key, data) {
         const options = {
@@ -980,21 +978,16 @@ class RsaCrypto {
             padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
         };
         if (algorithm.label) ;
-        return new Uint8Array(crypto.privateDecrypt(options, data)).buffer;
+        return toArrayBuffer(crypto.privateDecrypt(options, data));
     }
 }
-RsaCrypto.publicKeyUsages = ["verify", "encrypt", "wrapKey"];
-RsaCrypto.privateKeyUsages = ["sign", "decrypt", "unwrapKey"];
 
 class RsaSsaProvider extends core.RsaSsaProvider {
-    constructor() {
-        super(...arguments);
-        this.hashAlgorithms = [
-            "SHA-1", "SHA-256", "SHA-384", "SHA-512",
-            "shake128", "shake256",
-            "SHA3-256", "SHA3-384", "SHA3-512"
-        ];
-    }
+    hashAlgorithms = [
+        "SHA-1", "SHA-256", "SHA-384", "SHA-512",
+        "shake128", "shake256",
+        "SHA3-256", "SHA3-384", "SHA3-512"
+    ];
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const keys = await RsaCrypto.generateKey({
             ...algorithm,
@@ -1015,7 +1008,9 @@ class RsaSsaProvider extends core.RsaSsaProvider {
         return RsaCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await RsaCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await RsaCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
     checkCryptoKey(key, keyUsage) {
@@ -1028,14 +1023,11 @@ class RsaSsaProvider extends core.RsaSsaProvider {
 }
 
 class RsaPssProvider extends core.RsaPssProvider {
-    constructor() {
-        super(...arguments);
-        this.hashAlgorithms = [
-            "SHA-1", "SHA-256", "SHA-384", "SHA-512",
-            "shake128", "shake256",
-            "SHA3-256", "SHA3-384", "SHA3-512"
-        ];
-    }
+    hashAlgorithms = [
+        "SHA-1", "SHA-256", "SHA-384", "SHA-512",
+        "shake128", "shake256",
+        "SHA3-256", "SHA3-384", "SHA3-512"
+    ];
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const keys = await RsaCrypto.generateKey({
             ...algorithm,
@@ -1056,7 +1048,9 @@ class RsaPssProvider extends core.RsaPssProvider {
         return RsaCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await RsaCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await RsaCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
     checkCryptoKey(key, keyUsage) {
@@ -1127,7 +1121,7 @@ class RsaOaepProvider extends core.RsaOaepProvider {
     }
     async onEncrypt(algorithm, key, data) {
         const internalKey = getCryptoKey(key);
-        const dataView = new Uint8Array(data);
+        const dataView = toUint8Array(data);
         const keySize = Math.ceil(internalKey.algorithm.modulusLength >> 3);
         const hashSize = ShaCrypto.size(internalKey.algorithm.hash) >> 3;
         const dataLength = dataView.byteLength;
@@ -1140,7 +1134,7 @@ class RsaOaepProvider extends core.RsaOaepProvider {
         const dataBlock = message.subarray(hashSize + 1);
         dataBlock.set(dataView, hashSize + psLength + 1);
         const labelHash = crypto.createHash(internalKey.algorithm.hash.name.replace("-", ""))
-            .update(core.BufferSourceConverter.toUint8Array(algorithm.label || new Uint8Array(0)))
+            .update(toUint8Array(algorithm.label || new Uint8Array(0)))
             .digest();
         dataBlock.set(labelHash, 0);
         dataBlock[hashSize + psLength] = 1;
@@ -1160,7 +1154,7 @@ class RsaOaepProvider extends core.RsaOaepProvider {
             key: internalKey.pem,
             padding: crypto.constants.RSA_NO_PADDING,
         }, Buffer$1.from(message));
-        return new Uint8Array(pkcs0).buffer;
+        return toArrayBuffer(pkcs0);
     }
     async onDecrypt(algorithm, key, data) {
         const internalKey = getCryptoKey(key);
@@ -1176,7 +1170,7 @@ class RsaOaepProvider extends core.RsaOaepProvider {
         let pkcs0 = crypto.privateDecrypt({
             key: internalKey.pem,
             padding: crypto.constants.RSA_NO_PADDING,
-        }, Buffer$1.from(data));
+        }, Buffer$1.from(toUint8Array(data)));
         const z = pkcs0[0];
         const seed = pkcs0.subarray(1, hashSize + 1);
         const dataBlock = pkcs0.subarray(hashSize + 1);
@@ -1192,7 +1186,7 @@ class RsaOaepProvider extends core.RsaOaepProvider {
             dataBlock[i] ^= dataBlockMask[i];
         }
         const labelHash = crypto.createHash(internalKey.algorithm.hash.name.replace("-", ""))
-            .update(core.BufferSourceConverter.toUint8Array(algorithm.label || new Uint8Array(0)))
+            .update(toUint8Array(algorithm.label || new Uint8Array(0)))
             .digest();
         for (let i = 0; i < hashSize; i++) {
             if (labelHash[i] !== dataBlock[i]) {
@@ -1213,13 +1207,15 @@ class RsaOaepProvider extends core.RsaOaepProvider {
             throw new Error("Decryption failed");
         }
         pkcs0 = dataBlock.subarray(psEnd + 1);
-        return new Uint8Array(pkcs0).buffer;
+        return toArrayBuffer(pkcs0);
     }
     async onExportKey(format, key) {
         return RsaCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await RsaCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await RsaCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
     checkCryptoKey(key, keyUsage) {
@@ -1240,10 +1236,10 @@ class RsaOaepProvider extends core.RsaOaepProvider {
             counter[2] = (i >>> 8) & 255;
             counter[3] = i & 255;
             const submask = mask.subarray(i * hashSize);
-            let chunk = crypto.createHash(algorithm.name.replace("-", ""))
+            let chunk = toUint8Array(crypto.createHash(algorithm.name.replace("-", ""))
                 .update(seed)
                 .update(counter)
-                .digest();
+                .digest());
             if (chunk.length > submask.length) {
                 chunk = chunk.subarray(0, submask.length);
             }
@@ -1254,14 +1250,11 @@ class RsaOaepProvider extends core.RsaOaepProvider {
 }
 
 class RsaEsProvider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "RSAES-PKCS1-v1_5";
-        this.usages = {
-            publicKey: ["encrypt", "wrapKey"],
-            privateKey: ["decrypt", "unwrapKey"],
-        };
-    }
+    name = "RSAES-PKCS1-v1_5";
+    usages = {
+        publicKey: ["encrypt", "wrapKey"],
+        privateKey: ["decrypt", "unwrapKey"],
+    };
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const keys = await RsaCrypto.generateKey({
             ...algorithm,
@@ -1277,7 +1270,7 @@ class RsaEsProvider extends core.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 = convert.encode("base64", algorithm.publicExponent);
         if (!(publicExponent === "Aw==" || publicExponent === "AQAB")) {
             throw new TypeError("publicExponent: Must be [3] or [1,0,1]");
         }
@@ -1293,19 +1286,21 @@ class RsaEsProvider extends core.ProviderCrypto {
     }
     async onEncrypt(algorithm, key, data) {
         const options = this.toCryptoOptions(key);
-        const enc = crypto.publicEncrypt(options, new Uint8Array(data));
-        return new Uint8Array(enc).buffer;
+        const enc = crypto.publicEncrypt(options, toUint8Array(data));
+        return toArrayBuffer(enc);
     }
     async onDecrypt(algorithm, key, data) {
         const options = this.toCryptoOptions(key);
-        const dec = crypto.privateDecrypt(options, new Uint8Array(data));
-        return new Uint8Array(dec).buffer;
+        const dec = crypto.privateDecrypt(options, toUint8Array(data));
+        return toArrayBuffer(dec);
     }
     async onExportKey(format, key) {
         return RsaCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await RsaCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await RsaCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
     checkCryptoKey(key, keyUsage) {
@@ -1333,33 +1328,33 @@ const namedOIDs = {
     "P-521": "1.3.132.0.35",
     "1.3.132.0.10": "K-256",
     "K-256": "1.3.132.0.10",
-    "brainpoolP160r1": "1.3.36.3.3.2.8.1.1.1",
+    brainpoolP160r1: "1.3.36.3.3.2.8.1.1.1",
     "1.3.36.3.3.2.8.1.1.1": "brainpoolP160r1",
-    "brainpoolP160t1": "1.3.36.3.3.2.8.1.1.2",
+    brainpoolP160t1: "1.3.36.3.3.2.8.1.1.2",
     "1.3.36.3.3.2.8.1.1.2": "brainpoolP160t1",
-    "brainpoolP192r1": "1.3.36.3.3.2.8.1.1.3",
+    brainpoolP192r1: "1.3.36.3.3.2.8.1.1.3",
     "1.3.36.3.3.2.8.1.1.3": "brainpoolP192r1",
-    "brainpoolP192t1": "1.3.36.3.3.2.8.1.1.4",
+    brainpoolP192t1: "1.3.36.3.3.2.8.1.1.4",
     "1.3.36.3.3.2.8.1.1.4": "brainpoolP192t1",
-    "brainpoolP224r1": "1.3.36.3.3.2.8.1.1.5",
+    brainpoolP224r1: "1.3.36.3.3.2.8.1.1.5",
     "1.3.36.3.3.2.8.1.1.5": "brainpoolP224r1",
-    "brainpoolP224t1": "1.3.36.3.3.2.8.1.1.6",
+    brainpoolP224t1: "1.3.36.3.3.2.8.1.1.6",
     "1.3.36.3.3.2.8.1.1.6": "brainpoolP224t1",
-    "brainpoolP256r1": "1.3.36.3.3.2.8.1.1.7",
+    brainpoolP256r1: "1.3.36.3.3.2.8.1.1.7",
     "1.3.36.3.3.2.8.1.1.7": "brainpoolP256r1",
-    "brainpoolP256t1": "1.3.36.3.3.2.8.1.1.8",
+    brainpoolP256t1: "1.3.36.3.3.2.8.1.1.8",
     "1.3.36.3.3.2.8.1.1.8": "brainpoolP256t1",
-    "brainpoolP320r1": "1.3.36.3.3.2.8.1.1.9",
+    brainpoolP320r1: "1.3.36.3.3.2.8.1.1.9",
     "1.3.36.3.3.2.8.1.1.9": "brainpoolP320r1",
-    "brainpoolP320t1": "1.3.36.3.3.2.8.1.1.10",
+    brainpoolP320t1: "1.3.36.3.3.2.8.1.1.10",
     "1.3.36.3.3.2.8.1.1.10": "brainpoolP320t1",
-    "brainpoolP384r1": "1.3.36.3.3.2.8.1.1.11",
+    brainpoolP384r1: "1.3.36.3.3.2.8.1.1.11",
     "1.3.36.3.3.2.8.1.1.11": "brainpoolP384r1",
-    "brainpoolP384t1": "1.3.36.3.3.2.8.1.1.12",
+    brainpoolP384t1: "1.3.36.3.3.2.8.1.1.12",
     "1.3.36.3.3.2.8.1.1.12": "brainpoolP384t1",
-    "brainpoolP512r1": "1.3.36.3.3.2.8.1.1.13",
+    brainpoolP512r1: "1.3.36.3.3.2.8.1.1.13",
     "1.3.36.3.3.2.8.1.1.13": "brainpoolP512r1",
-    "brainpoolP512t1": "1.3.36.3.3.2.8.1.1.14",
+    brainpoolP512t1: "1.3.36.3.3.2.8.1.1.14",
     "1.3.36.3.3.2.8.1.1.14": "brainpoolP512t1",
 };
 function getOidByNamedCurve$1(namedCurve) {
@@ -1371,10 +1366,7 @@ function getOidByNamedCurve$1(namedCurve) {
 }
 
 class EcPrivateKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     getKey() {
         const keyInfo = AsnParser.parse(this.data, core.asn1.PrivateKeyInfo);
         return AsnParser.parse(keyInfo.privateKey, core.asn1.EcPrivateKey);
@@ -1391,7 +1383,7 @@ class EcPrivateKey extends AsymmetricKey {
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         const keyInfo = new core.asn1.PrivateKeyInfo();
         keyInfo.privateKeyAlgorithm.algorithm = "1.2.840.10045.2.1";
@@ -1404,10 +1396,7 @@ class EcPrivateKey extends AsymmetricKey {
 }
 
 class EcPublicKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     getKey() {
         const keyInfo = AsnParser.parse(this.data, core.asn1.PublicKeyInfo);
         return new core.asn1.EcPublicKey(keyInfo.publicKey);
@@ -1424,7 +1413,7 @@ class EcPublicKey extends AsymmetricKey {
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         const key = JsonParser.fromJSON(json, { targetSchema: core.asn1.EcPublicKey });
         const keyInfo = new core.asn1.PublicKeyInfo();
@@ -1437,83 +1426,64 @@ class EcPublicKey extends AsymmetricKey {
 }
 
 class Sha1Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA-1";
-        this.usages = [];
-    }
+    name = "SHA-1";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class Sha256Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA-256";
-        this.usages = [];
-    }
+    name = "SHA-256";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class Sha384Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA-384";
-        this.usages = [];
-    }
+    name = "SHA-384";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class Sha512Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA-512";
-        this.usages = [];
-    }
+    name = "SHA-512";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class Sha3256Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA3-256";
-        this.usages = [];
-    }
+    name = "SHA3-256";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class Sha3384Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA3-384";
-        this.usages = [];
-    }
+    name = "SHA3-384";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class Sha3512Provider extends core.ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "SHA3-512";
-        this.usages = [];
-    }
+    name = "SHA3-512";
+    usages = [];
     async onDigest(algorithm, data) {
         return ShaCrypto.digest(algorithm, data);
     }
 }
 
 class EcCrypto {
+    static publicKeyUsages = ["verify"];
+    static privateKeyUsages = ["sign", "deriveKey", "deriveBits"];
     static async generateKey(algorithm, extractable, keyUsages) {
         const privateKey = new EcPrivateKey();
         privateKey.algorithm = algorithm;
@@ -1549,13 +1519,11 @@ class EcCrypto {
         if (!key.pem) {
             key.pem = `-----BEGIN PRIVATE KEY-----\n${key.data.toString("base64")}\n-----END PRIVATE KEY-----`;
         }
-        const options = {
-            key: key.pem,
-        };
+        const options = { key: key.pem };
         const signature = signer.sign(options);
         const ecSignature = AsnParser.parse(signature, core.asn1.EcDsaSignature);
         const signatureRaw = core.EcUtils.encodeSignature(ecSignature, core.EcCurves.get(key.algorithm.namedCurve).size);
-        return signatureRaw.buffer;
+        return toArrayBuffer(signatureRaw);
     }
     static async verify(algorithm, key, signature, data) {
         const cryptoAlg = ShaCrypto.getAlgorithmName(algorithm.hash);
@@ -1564,14 +1532,12 @@ class EcCrypto {
         if (!key.pem) {
             key.pem = `-----BEGIN PUBLIC KEY-----\n${key.data.toString("base64")}\n-----END PUBLIC KEY-----`;
         }
-        const options = {
-            key: key.pem,
-        };
+        const options = { key: key.pem };
         const ecSignature = new core.asn1.EcDsaSignature();
         const namedCurve = core.EcCurves.get(key.algorithm.namedCurve);
         const signaturePoint = core.EcUtils.decodeSignature(signature, namedCurve.size);
-        ecSignature.r = BufferSourceConverter.toArrayBuffer(signaturePoint.r);
-        ecSignature.s = BufferSourceConverter.toArrayBuffer(signaturePoint.s);
+        ecSignature.r = toArrayBuffer(signaturePoint.r);
+        ecSignature.s = toArrayBuffer(signaturePoint.s);
         const ecSignatureRaw = Buffer$1.from(AsnSerializer.serialize(ecSignature));
         const ok = signer.verify(options, ecSignatureRaw);
         return ok;
@@ -1585,9 +1551,9 @@ class EcCrypto {
         const asnPublicKey = AsnParser.parse(algorithm.public.data, core.asn1.PublicKeyInfo);
         const bits = ecdh.computeSecret(Buffer$1.from(asnPublicKey.publicKey));
         if (length === null) {
-            return bits;
+            return toArrayBuffer(bits);
         }
-        return new Uint8Array(bits).buffer.slice(0, length >> 3);
+        return toArrayBuffer(bits).slice(0, length >> 3);
     }
     static async exportKey(format, key) {
         switch (format.toLowerCase()) {
@@ -1595,7 +1561,7 @@ class EcCrypto {
                 return JsonSerializer.toJSON(key);
             case "pkcs8":
             case "spki":
-                return new Uint8Array(key.data).buffer;
+                return toArrayBuffer(key.data);
             case "raw": {
                 const publicKeyInfo = AsnParser.parse(key.data, core.asn1.PublicKeyInfo);
                 return publicKeyInfo.publicKey;
@@ -1618,17 +1584,20 @@ class EcCrypto {
                 }
             }
             case "raw": {
-                const asnKey = new core.asn1.EcPublicKey(keyData);
+                assertBufferSource(keyData);
+                const asnKey = new core.asn1.EcPublicKey(toArrayBuffer(keyData));
                 return this.importPublicKey(asnKey, algorithm, extractable, keyUsages);
             }
             case "spki": {
-                const keyInfo = AsnParser.parse(new Uint8Array(keyData), core.asn1.PublicKeyInfo);
+                assertBufferSource(keyData);
+                const keyInfo = AsnParser.parse(toUint8Array(keyData), core.asn1.PublicKeyInfo);
                 const asnKey = new core.asn1.EcPublicKey(keyInfo.publicKey);
                 this.assertKeyParameters(keyInfo.publicKeyAlgorithm.parameters, algorithm.namedCurve);
                 return this.importPublicKey(asnKey, algorithm, extractable, keyUsages);
             }
             case "pkcs8": {
-                const keyInfo = AsnParser.parse(new Uint8Array(keyData), core.asn1.PrivateKeyInfo);
+                assertBufferSource(keyData);
+                const keyInfo = AsnParser.parse(toUint8Array(keyData), core.asn1.PrivateKeyInfo);
                 const asnKey = AsnParser.parse(keyInfo.privateKey, core.asn1.EcPrivateKey);
                 this.assertKeyParameters(keyInfo.privateKeyAlgorithm.parameters, algorithm.namedCurve);
                 return this.importPrivateKey(asnKey, algorithm, extractable, keyUsages);
@@ -1645,7 +1614,7 @@ class EcCrypto {
         try {
             namedCurveIdentifier = AsnParser.parse(parameters, core.asn1.ObjectIdentifier).value;
         }
-        catch (e) {
+        catch {
             throw new core.CryptoError("Cannot read key info parameters");
         }
         if (getOidByNamedCurve$1(namedCurve) !== namedCurveIdentifier) {
@@ -1692,19 +1661,14 @@ class EcCrypto {
         }
     }
 }
-EcCrypto.publicKeyUsages = ["verify"];
-EcCrypto.privateKeyUsages = ["sign", "deriveKey", "deriveBits"];
 
 class EcdsaProvider extends core.EcdsaProvider {
-    constructor() {
-        super(...arguments);
-        this.namedCurves = core.EcCurves.names;
-        this.hashAlgorithms = [
-            "SHA-1", "SHA-256", "SHA-384", "SHA-512",
-            "shake128", "shake256",
-            "SHA3-256", "SHA3-384", "SHA3-512"
-        ];
-    }
+    namedCurves = core.EcCurves.names;
+    hashAlgorithms = [
+        "SHA-1", "SHA-256", "SHA-384", "SHA-512",
+        "shake128", "shake256",
+        "SHA3-256", "SHA3-384", "SHA3-512"
+    ];
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const keys = await EcCrypto.generateKey({
             ...algorithm,
@@ -1725,7 +1689,9 @@ class EcdsaProvider extends core.EcdsaProvider {
         return EcCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await EcCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await EcCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
     checkCryptoKey(key, keyUsage) {
@@ -1738,10 +1704,7 @@ class EcdsaProvider extends core.EcdsaProvider {
 }
 
 class EcdhProvider extends core.EcdhProvider {
-    constructor() {
-        super(...arguments);
-        this.namedCurves = core.EcCurves.names;
-    }
+    namedCurves = core.EcCurves.names;
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const keys = await EcCrypto.generateKey({
             ...algorithm,
@@ -1756,7 +1719,9 @@ class EcdhProvider extends core.EcdhProvider {
         return EcCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await EcCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await EcCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
     checkCryptoKey(key, keyUsage) {
@@ -1767,20 +1732,22 @@ class EcdhProvider extends core.EcdhProvider {
         }
     }
     async onDeriveBits(algorithm, baseKey, length) {
-        const bits = await EcCrypto.deriveBits({ ...algorithm, public: getCryptoKey(algorithm.public) }, getCryptoKey(baseKey), length);
+        const bits = await EcCrypto.deriveBits({
+            ...algorithm, public: getCryptoKey(algorithm.public),
+        }, getCryptoKey(baseKey), length);
         return bits;
     }
 }
 
 const edOIDs = {
     [core.asn1.idEd448]: "Ed448",
-    "ed448": core.asn1.idEd448,
+    ed448: core.asn1.idEd448,
     [core.asn1.idX448]: "X448",
-    "x448": core.asn1.idX448,
+    x448: core.asn1.idX448,
     [core.asn1.idEd25519]: "Ed25519",
-    "ed25519": core.asn1.idEd25519,
+    ed25519: core.asn1.idEd25519,
     [core.asn1.idX25519]: "X25519",
-    "x25519": core.asn1.idX25519,
+    x25519: core.asn1.idX25519,
 };
 function getOidByNamedCurve(namedCurve) {
     const oid = edOIDs[namedCurve.toLowerCase()];
@@ -1791,10 +1758,7 @@ function getOidByNamedCurve(namedCurve) {
 }
 
 class EdPrivateKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     getKey() {
         const keyInfo = AsnParser.parse(this.data, core.asn1.PrivateKeyInfo);
         return AsnParser.parse(keyInfo.privateKey, core.asn1.CurvePrivateKey);
@@ -1811,7 +1775,7 @@ class EdPrivateKey extends AsymmetricKey {
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         const keyInfo = new core.asn1.PrivateKeyInfo();
         keyInfo.privateKeyAlgorithm.algorithm = getOidByNamedCurve(json.crv);
@@ -1823,10 +1787,7 @@ class EdPrivateKey extends AsymmetricKey {
 }
 
 class EdPublicKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     getKey() {
         const keyInfo = AsnParser.parse(this.data, core.asn1.PublicKeyInfo);
         return keyInfo.publicKey;
@@ -1839,26 +1800,26 @@ class EdPublicKey extends AsymmetricKey {
             key_ops: this.usages,
             ext: this.extractable,
         };
-        return Object.assign(json, {
-            x: Convert.ToBase64Url(key)
-        });
+        return Object.assign(json, { x: convert.encode("base64url", key) });
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         if (!json.x) {
-            throw new core.OperationError(`Cannot get property from JWK. Property 'x' is required`);
+            throw new core.OperationError("Cannot get property from JWK. Property 'x' is required");
         }
         const keyInfo = new core.asn1.PublicKeyInfo();
         keyInfo.publicKeyAlgorithm.algorithm = getOidByNamedCurve(json.crv);
-        keyInfo.publicKey = Convert.FromBase64Url(json.x);
+        keyInfo.publicKey = toArrayBuffer(convert.decode("base64url", json.x));
         this.data = Buffer$1.from(AsnSerializer.serialize(keyInfo));
         return this;
     }
 }
 
 class EdCrypto {
+    static publicKeyUsages = ["verify"];
+    static privateKeyUsages = ["sign", "deriveKey", "deriveBits"];
     static async generateKey(algorithm, extractable, keyUsages) {
         const privateKey = new EdPrivateKey();
         privateKey.algorithm = algorithm;
@@ -1891,19 +1852,15 @@ class EdCrypto {
         if (!key.pem) {
             key.pem = `-----BEGIN PRIVATE KEY-----\n${key.data.toString("base64")}\n-----END PRIVATE KEY-----`;
         }
-        const options = {
-            key: key.pem,
-        };
+        const options = { key: key.pem };
         const signature = crypto.sign(null, Buffer$1.from(data), options);
-        return core.BufferSourceConverter.toArrayBuffer(signature);
+        return toArrayBuffer(signature);
     }
     static async verify(algorithm, key, signature, data) {
         if (!key.pem) {
             key.pem = `-----BEGIN PUBLIC KEY-----\n${key.data.toString("base64")}\n-----END PUBLIC KEY-----`;
         }
-        const options = {
-            key: key.pem,
-        };
+        const options = { key: key.pem };
         const ok = crypto.verify(null, Buffer$1.from(data), options, Buffer$1.from(signature));
         return ok;
     }
@@ -1922,7 +1879,7 @@ class EdCrypto {
             publicKey,
             privateKey,
         });
-        return new Uint8Array(bits).buffer.slice(0, length >> 3);
+        return toArrayBuffer(bits).slice(0, length >> 3);
     }
     static async exportKey(format, key) {
         switch (format.toLowerCase()) {
@@ -1930,7 +1887,7 @@ class EdCrypto {
                 return JsonSerializer.toJSON(key);
             case "pkcs8":
             case "spki":
-                return new Uint8Array(key.data).buffer;
+                return toArrayBuffer(key.data);
             case "raw": {
                 const publicKeyInfo = AsnParser.parse(key.data, core.asn1.PublicKeyInfo);
                 return publicKeyInfo.publicKey;
@@ -1951,18 +1908,21 @@ class EdCrypto {
                     if (!jwk.x) {
                         throw new TypeError("keyData: Cannot get required 'x' filed");
                     }
-                    return this.importPublicKey(Convert.FromBase64Url(jwk.x), algorithm, extractable, keyUsages);
+                    return this.importPublicKey(toArrayBuffer(convert.decode("base64url", jwk.x)), algorithm, extractable, keyUsages);
                 }
             }
             case "raw": {
-                return this.importPublicKey(keyData, algorithm, extractable, keyUsages);
+                assertBufferSource(keyData);
+                return this.importPublicKey(toArrayBuffer(keyData), algorithm, extractable, keyUsages);
             }
             case "spki": {
-                const keyInfo = AsnParser.parse(new Uint8Array(keyData), core.asn1.PublicKeyInfo);
+                assertBufferSource(keyData);
+                const keyInfo = AsnParser.parse(toUint8Array(keyData), core.asn1.PublicKeyInfo);
                 return this.importPublicKey(keyInfo.publicKey, algorithm, extractable, keyUsages);
             }
             case "pkcs8": {
-                const keyInfo = AsnParser.parse(new Uint8Array(keyData), core.asn1.PrivateKeyInfo);
+                assertBufferSource(keyData);
+                const keyInfo = AsnParser.parse(toUint8Array(keyData), core.asn1.PrivateKeyInfo);
                 const asnKey = AsnParser.parse(keyInfo.privateKey, core.asn1.CurvePrivateKey);
                 return this.importPrivateKey(asnKey, algorithm, extractable, keyUsages);
             }
@@ -1974,7 +1934,7 @@ class EdCrypto {
         const key = new EdPrivateKey();
         key.fromJSON({
             crv: algorithm.namedCurve,
-            d: Convert.ToBase64Url(asnKey.d),
+            d: convert.encode("base64url", asnKey.d),
         });
         key.algorithm = Object.assign({}, algorithm);
         key.extractable = extractable;
@@ -1985,7 +1945,7 @@ class EdCrypto {
         const key = new EdPublicKey();
         key.fromJSON({
             crv: algorithm.namedCurve,
-            x: Convert.ToBase64Url(asnKey),
+            x: convert.encode("base64url", asnKey),
         });
         key.algorithm = Object.assign({}, algorithm);
         key.extractable = extractable;
@@ -1993,8 +1953,6 @@ class EdCrypto {
         return key;
     }
 }
-EdCrypto.publicKeyUsages = ["verify"];
-EdCrypto.privateKeyUsages = ["sign", "deriveKey", "deriveBits"];
 
 class EdDsaProvider extends core.EdDsaProvider {
     async onGenerateKey(algorithm, extractable, keyUsages) {
@@ -2017,7 +1975,9 @@ class EdDsaProvider extends core.EdDsaProvider {
         return EdCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await EdCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await EdCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
 }
@@ -2034,14 +1994,18 @@ class EcdhEsProvider extends core.EcdhEsProvider {
         };
     }
     async onDeriveBits(algorithm, baseKey, length) {
-        const bits = await EdCrypto.deriveBits({ ...algorithm, public: getCryptoKey(algorithm.public) }, getCryptoKey(baseKey), length);
+        const bits = await EdCrypto.deriveBits({
+            ...algorithm, public: getCryptoKey(algorithm.public),
+        }, getCryptoKey(baseKey), length);
         return bits;
     }
     async onExportKey(format, key) {
         return EdCrypto.exportKey(format, getCryptoKey(key));
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        const key = await EdCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+        const key = await EdCrypto.importKey(format, keyData, {
+            ...algorithm, name: this.name,
+        }, extractable, keyUsages);
         return setCryptoKey(key);
     }
 }
@@ -2065,10 +2029,7 @@ class Ed25519CryptoKey extends CryptoKey {
 }
 
 class Ed25519PrivateKey extends Ed25519CryptoKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     toJWK() {
         const pubJwk = crypto.createPublicKey({
             key: this.data,
@@ -2086,10 +2047,7 @@ class Ed25519PrivateKey extends Ed25519CryptoKey {
 }
 
 class Ed25519PublicKey extends Ed25519CryptoKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     toJWK() {
         const jwk = crypto.createPublicKey({
             key: this.data,
@@ -2103,6 +2061,8 @@ class Ed25519PublicKey extends Ed25519CryptoKey {
 }
 
 class Ed25519Crypto {
+    static privateKeyUsages = ["sign", "deriveBits", "deriveKey"];
+    static publicKeyUsages = ["verify"];
     static async generateKey(algorithm, extractable, keyUsages) {
         const type = algorithm.name.toLowerCase();
         const keys = crypto.generateKeyPairSync(type, {
@@ -2115,9 +2075,7 @@ class Ed25519Crypto {
                 type: "pkcs8",
             },
         });
-        const keyAlg = {
-            name: type === "ed25519" ? "Ed25519" : "X25519",
-        };
+        const keyAlg = { name: type === "ed25519" ? "Ed25519" : "X25519" };
         const privateKeyUsages = keyUsages.filter((usage) => this.privateKeyUsages.includes(usage));
         const publicKeyUsages = keyUsages.filter((usage) => this.publicKeyUsages.includes(usage));
         return {
@@ -2144,7 +2102,7 @@ class Ed25519Crypto {
             }
             case "raw": {
                 const jwk = key.toJWK();
-                return Convert.FromBase64Url(jwk.x);
+                return toArrayBuffer(convert.decode("base64url", jwk.x));
             }
             default:
                 return Promise.reject(new core.OperationError("format: Must be 'jwk', 'raw', pkcs8' or 'spki'"));
@@ -2156,7 +2114,7 @@ class Ed25519Crypto {
                 const jwk = keyData;
                 if (jwk.d) {
                     const privateData = new core.asn1.EdPrivateKey();
-                    privateData.value = core.BufferSourceConverter.toArrayBuffer(Buffer.from(jwk.d, "base64url"));
+                    privateData.value = toArrayBuffer(convert.decode("base64url", jwk.d));
                     const pkcs8 = new core.asn1.PrivateKeyInfo();
                     pkcs8.privateKeyAlgorithm.algorithm = algorithm.name.toLowerCase() === "ed25519"
                         ? core.asn1.idEd25519
@@ -2171,7 +2129,9 @@ class Ed25519Crypto {
                         format: "jwk",
                         key: jwk,
                     });
-                    const pem = pubKey.export({ format: "pem", type: "spki" });
+                    const pem = pubKey.export({
+                        format: "pem", type: "spki",
+                    });
                     return new Ed25519PublicKey(algorithm, extractable, keyUsages, pem);
                 }
                 else {
@@ -2179,24 +2139,29 @@ class Ed25519Crypto {
                 }
             }
             case "pkcs8": {
-                const pem = core.PemConverter.fromBufferSource(keyData, "PRIVATE KEY");
+                assertBufferSource(keyData);
+                const pem = core.PemConverter.fromBufferSource(toArrayBuffer(keyData), "PRIVATE KEY");
                 return new Ed25519PrivateKey(algorithm, extractable, keyUsages, pem);
             }
             case "spki": {
-                const pem = core.PemConverter.fromBufferSource(keyData, "PUBLIC KEY");
+                assertBufferSource(keyData);
+                const pem = core.PemConverter.fromBufferSource(toArrayBuffer(keyData), "PUBLIC KEY");
                 return new Ed25519PublicKey(algorithm, extractable, keyUsages, pem);
             }
             case "raw": {
-                const raw = keyData;
+                assertBufferSource(keyData);
+                const raw = toArrayBuffer(keyData);
                 const key = crypto.createPublicKey({
                     format: "jwk",
                     key: {
                         kty: "OKP",
                         crv: algorithm.name.toLowerCase() === "ed25519" ? "Ed25519" : "X25519",
-                        x: Convert.ToBase64Url(raw),
+                        x: convert.encode("base64url", raw),
                     },
                 });
-                const pem = key.export({ format: "pem", type: "spki" });
+                const pem = key.export({
+                    format: "pem", type: "spki",
+                });
                 return new Ed25519PublicKey(algorithm, extractable, keyUsages, pem);
             }
             default:
@@ -2204,8 +2169,6 @@ class Ed25519Crypto {
         }
     }
 }
-Ed25519Crypto.privateKeyUsages = ["sign", "deriveBits", "deriveKey"];
-Ed25519Crypto.publicKeyUsages = ["verify"];
 
 class Ed25519Provider extends core.Ed25519Provider {
     async onGenerateKey(algorithm, extractable, keyUsages) {
@@ -2283,22 +2246,23 @@ class PbkdfCryptoKey extends CryptoKey {
 class Pbkdf2Provider extends core.Pbkdf2Provider {
     async onDeriveBits(algorithm, baseKey, length) {
         return new Promise((resolve, reject) => {
-            const salt = core.BufferSourceConverter.toArrayBuffer(algorithm.salt);
+            const salt = toUint8Array(algorithm.salt);
             const hash = algorithm.hash.name.replace("-", "");
             crypto.pbkdf2(getCryptoKey(baseKey).data, Buffer$1.from(salt), algorithm.iterations, length >> 3, hash, (err, derivedBits) => {
                 if (err) {
                     reject(err);
                 }
                 else {
-                    resolve(new Uint8Array(derivedBits).buffer);
+                    resolve(toArrayBuffer(derivedBits));
                 }
             });
         });
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
         if (format === "raw") {
+            assertBufferSource(keyData);
             const key = new PbkdfCryptoKey();
-            key.data = Buffer$1.from(keyData);
+            key.data = Buffer$1.from(toUint8Array(keyData));
             key.algorithm = { name: this.name };
             key.extractable = false;
             key.usages = keyUsages;
@@ -2323,7 +2287,9 @@ class HmacCryptoKey extends CryptoKey {
     }
 }
 __decorate([
-    JsonProp({ name: "k", converter: JsonBase64UrlConverter })
+    JsonProp({
+        name: "k", converter: JsonBase64UrlConverter,
+    })
 ], HmacCryptoKey.prototype, "data", void 0);
 
 class HmacProvider extends core.HmacProvider {
@@ -2343,14 +2309,14 @@ class HmacProvider extends core.HmacProvider {
     async onSign(algorithm, key, data) {
         const cryptoAlg = ShaCrypto.getAlgorithmName(key.algorithm.hash);
         const hmac = crypto.createHmac(cryptoAlg, getCryptoKey(key).data)
-            .update(Buffer$1.from(data)).digest();
-        return new Uint8Array(hmac).buffer;
+            .update(Buffer$1.from(toUint8Array(data))).digest();
+        return toArrayBuffer(hmac);
     }
     async onVerify(algorithm, key, signature, data) {
         const cryptoAlg = ShaCrypto.getAlgorithmName(key.algorithm.hash);
         const hmac = crypto.createHmac(cryptoAlg, getCryptoKey(key).data)
-            .update(Buffer$1.from(data)).digest();
-        return hmac.compare(Buffer$1.from(signature)) === 0;
+            .update(Buffer$1.from(toUint8Array(data))).digest();
+        return hmac.compare(Buffer$1.from(toUint8Array(signature))) === 0;
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
         let key;
@@ -2359,8 +2325,9 @@ class HmacProvider extends core.HmacProvider {
                 key = JsonParser.fromJSON(keyData, { targetSchema: HmacCryptoKey });
                 break;
             case "raw":
+                assertBufferSource(keyData);
                 key = new HmacCryptoKey();
-                key.data = Buffer$1.from(keyData);
+                key.data = Buffer$1.from(toUint8Array(keyData));
                 break;
             default:
                 throw new core.OperationError("format: Must be 'jwk' or 'raw'");
@@ -2379,7 +2346,7 @@ class HmacProvider extends core.HmacProvider {
             case "jwk":
                 return JsonSerializer.toJSON(getCryptoKey(key));
             case "raw":
-                return new Uint8Array(getCryptoKey(key).data).buffer;
+                return toArrayBuffer(getCryptoKey(key).data);
             default:
                 throw new core.OperationError("format: Must be 'jwk' or 'raw'");
         }
@@ -2411,9 +2378,9 @@ class HkdfProvider extends core.HkdfProvider {
         const hash = params.hash.name.replace("-", "");
         const hashLength = crypto.createHash(hash).digest().length;
         const byteLength = length / 8;
-        const info = BufferSourceConverter$1.toUint8Array(params.info);
-        const PRK = crypto.createHmac(hash, BufferSourceConverter$1.toUint8Array(params.salt))
-            .update(BufferSourceConverter$1.toUint8Array(getCryptoKey(baseKey).data))
+        const info = BufferSourceConverter.toUint8Array(params.info);
+        const PRK = crypto.createHmac(hash, BufferSourceConverter.toUint8Array(params.salt))
+            .update(BufferSourceConverter.toUint8Array(getCryptoKey(baseKey).data))
             .digest();
         const blocks = [Buffer$1.alloc(0)];
         const blockCount = Math.ceil(byteLength / hashLength) + 1;
@@ -2422,7 +2389,7 @@ class HkdfProvider extends core.HkdfProvider {
                 .update(Buffer$1.concat([blocks[i - 1], info, Buffer$1.from([i])]))
                 .digest());
         }
-        return Buffer$1.concat(blocks).slice(0, byteLength);
+        return BufferSourceConverter.toArrayBuffer(Buffer$1.concat(blocks).slice(0, byteLength));
     }
     checkCryptoKey(key, keyUsage) {
         super.checkCryptoKey(key, keyUsage);
@@ -2454,7 +2421,6 @@ class Shake256Provider extends core.Shake256Provider {
 
 class SubtleCrypto extends core.SubtleCrypto {
     constructor() {
-        var _a;
         super();
         this.providers.set(new AesCbcProvider());
         this.providers.set(new AesCtrProvider());
@@ -2480,7 +2446,7 @@ class SubtleCrypto extends core.SubtleCrypto {
         this.providers.set(new Pbkdf2Provider());
         this.providers.set(new HmacProvider());
         this.providers.set(new HkdfProvider());
-        const nodeMajorVersion = (_a = /^v(\d+)/.exec(process.version)) === null || _a === void 0 ? void 0 : _a[1];
+        const nodeMajorVersion = /^v(\d+)/.exec(process.version)?.[1];
         if (nodeMajorVersion && parseInt(nodeMajorVersion, 10) >= 12) {
             this.providers.set(new Shake128Provider());
             this.providers.set(new Shake256Provider());
@@ -2505,10 +2471,7 @@ class SubtleCrypto extends core.SubtleCrypto {
 }
 
 class Crypto extends core.Crypto {
-    constructor() {
-        super(...arguments);
-        this.subtle = new SubtleCrypto();
-    }
+    subtle = new SubtleCrypto();
     getRandomValues(array) {
         if (!ArrayBuffer.isView(array)) {
             throw new TypeError("Failed to execute 'getRandomValues' on 'Crypto': parameter 1 is not of type 'ArrayBufferView'");