@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.js

@@ -1,77 +1,79 @@
-/*!
- Copyright (c) Peculiar Ventures, LLC
-*/
+/**
+ * Copyright (c) 2019-2026, Peculiar Ventures
+ * SPDX-License-Identifier: MIT
+ */
 
 'use strict';
 
 var core = require('webcrypto-core');
-var buffer = require('buffer');
-var crypto = require('crypto');
-var process = require('process');
+var node_buffer = require('node:buffer');
+var crypto = require('node:crypto');
+var process = require('node:process');
 var tslib = require('tslib');
 var jsonSchema = require('@peculiar/json-schema');
-var pvtsutils = require('pvtsutils');
+var utils = require('@peculiar/utils');
 var asn1Schema = require('@peculiar/asn1-schema');
 
 function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
         });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
+    }
+    n.default = e;
+    return Object.freeze(n);
 }
 
 var core__namespace = /*#__PURE__*/_interopNamespaceDefault(core);
 var process__namespace = /*#__PURE__*/_interopNamespaceDefault(process);
 
 const JsonBase64UrlConverter = {
-    fromJSON: (value) => buffer.Buffer.from(pvtsutils.Convert.FromBase64Url(value)),
-    toJSON: (value) => pvtsutils.Convert.ToBase64Url(value),
+    fromJSON: (value) => node_buffer.Buffer.from(utils.convert.decode("base64url", value)),
+    toJSON: (value) => utils.convert.encode("base64url", value),
 };
 
 class CryptoKey extends core__namespace.CryptoKey {
-    constructor() {
-        super(...arguments);
-        this.data = buffer.Buffer.alloc(0);
-        this.algorithm = { name: "" };
-        this.extractable = false;
-        this.type = "secret";
-        this.usages = [];
-        this.kty = "oct";
-        this.alg = "";
-    }
+    data = node_buffer.Buffer.alloc(0);
+    algorithm = { name: "" };
+    extractable = false;
+    type = "secret";
+    usages = [];
+    kty = "oct";
+    alg = "";
 }
 tslib.__decorate([
-    jsonSchema.JsonProp({ name: "ext", type: jsonSchema.JsonPropTypes.Boolean, optional: true })
+    jsonSchema.JsonProp({
+        name: "ext", type: jsonSchema.JsonPropTypes.Boolean, optional: true,
+    })
 ], CryptoKey.prototype, "extractable", void 0);
 tslib.__decorate([
-    jsonSchema.JsonProp({ name: "key_ops", type: jsonSchema.JsonPropTypes.String, repeated: true, optional: true })
+    jsonSchema.JsonProp({
+        name: "key_ops", type: jsonSchema.JsonPropTypes.String, repeated: true, optional: true,
+    })
 ], CryptoKey.prototype, "usages", void 0);
 tslib.__decorate([
     jsonSchema.JsonProp({ type: jsonSchema.JsonPropTypes.String })
 ], CryptoKey.prototype, "kty", void 0);
 tslib.__decorate([
-    jsonSchema.JsonProp({ type: jsonSchema.JsonPropTypes.String, optional: true })
+    jsonSchema.JsonProp({
+        type: jsonSchema.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 {
@@ -97,10 +99,28 @@ class AesCryptoKey extends SymmetricKey {
     }
 }
 tslib.__decorate([
-    jsonSchema.JsonProp({ name: "k", converter: JsonBase64UrlConverter })
+    jsonSchema.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__namespace.OperationError("Cannot get CryptoKey from secure storage");
+    }
+    return res;
+}
+function setCryptoKey(value) {
+    const key = core__namespace.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 = node_buffer.Buffer.from("A6A6A6A6A6A6A6A6", "hex");
     static async generateKey(algorithm, extractable, keyUsages) {
         const key = new AesCryptoKey();
         key.algorithm = algorithm;
@@ -117,7 +137,7 @@ class AesCrypto {
             case "jwk":
                 return jsonSchema.JsonSerializer.toJSON(key);
             case "raw":
-                return new Uint8Array(key.data).buffer;
+                return utils.toArrayBuffer(key.data);
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk' or 'raw'");
         }
@@ -129,8 +149,9 @@ class AesCrypto {
                 key = jsonSchema.JsonParser.fromJSON(keyData, { targetSchema: AesCryptoKey });
                 break;
             case "raw":
+                utils.assertBufferSource(keyData);
                 key = new AesCryptoKey();
-                key.data = buffer.Buffer.from(keyData);
+                key.data = node_buffer.Buffer.from(utils.toUint8Array(keyData));
                 break;
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk' or 'raw'");
@@ -152,15 +173,15 @@ class AesCrypto {
     static async encrypt(algorithm, key, data) {
         switch (algorithm.name.toUpperCase()) {
             case "AES-CBC":
-                return this.encryptAesCBC(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptAesCBC(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-CTR":
-                return this.encryptAesCTR(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptAesCTR(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-GCM":
-                return this.encryptAesGCM(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptAesGCM(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-KW":
-                return this.encryptAesKW(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptAesKW(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-ECB":
-                return this.encryptAesECB(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptAesECB(algorithm, key, node_buffer.Buffer.from(data));
             default:
                 throw new core__namespace.OperationError("algorithm: Is not recognized");
         }
@@ -171,113 +192,93 @@ class AesCrypto {
         }
         switch (algorithm.name.toUpperCase()) {
             case "AES-CBC":
-                return this.decryptAesCBC(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptAesCBC(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-CTR":
-                return this.decryptAesCTR(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptAesCTR(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-GCM":
-                return this.decryptAesGCM(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptAesGCM(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-KW":
-                return this.decryptAesKW(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptAesKW(algorithm, key, node_buffer.Buffer.from(data));
             case "AES-ECB":
-                return this.decryptAesECB(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptAesECB(algorithm, key, node_buffer.Buffer.from(data));
             default:
                 throw new core__namespace.OperationError("algorithm: Is not recognized");
         }
     }
     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, utils.toUint8Array(algorithm.iv));
         let enc = cipher.update(data);
-        enc = buffer.Buffer.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final()]);
+        const res = utils.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, utils.toUint8Array(algorithm.iv));
         let dec = decipher.update(data);
-        dec = buffer.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.toArrayBuffer(dec);
     }
     static async encryptAesCTR(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-ctr`, key.data, buffer.Buffer.from(algorithm.counter));
+        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-ctr`, key.data, node_buffer.Buffer.from(utils.toUint8Array(algorithm.counter)));
         let enc = cipher.update(data);
-        enc = buffer.Buffer.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final()]);
+        const res = utils.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, utils.toUint8Array(algorithm.counter));
         let dec = decipher.update(data);
-        dec = buffer.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.toArrayBuffer(dec);
     }
     static async encryptAesGCM(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-gcm`, key.data, buffer.Buffer.from(algorithm.iv), {
-            authTagLength: (algorithm.tagLength || 128) >> 3,
-        });
+        const cipher = crypto.createCipheriv(`aes-${key.algorithm.length}-gcm`, key.data, node_buffer.Buffer.from(utils.toUint8Array(algorithm.iv)), { authTagLength: (algorithm.tagLength || 128) >> 3 });
         if (algorithm.additionalData) {
-            cipher.setAAD(buffer.Buffer.from(algorithm.additionalData));
+            cipher.setAAD(node_buffer.Buffer.from(utils.toUint8Array(algorithm.additionalData)));
         }
         let enc = cipher.update(data);
-        enc = buffer.Buffer.concat([enc, cipher.final(), cipher.getAuthTag()]);
-        const res = new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final(), cipher.getAuthTag()]);
+        const res = utils.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, utils.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.Buffer.from(algorithm.additionalData));
+            decipher.setAAD(node_buffer.Buffer.from(utils.toUint8Array(algorithm.additionalData)));
         }
         decipher.setAuthTag(tag);
         let dec = decipher.update(enc);
-        dec = buffer.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.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.Buffer.concat([enc, cipher.final()]);
-        return new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final()]);
+        return utils.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.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.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.Buffer.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final()]);
+        const res = utils.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.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
-    }
-}
-AesCrypto.AES_KW_IV = buffer.Buffer.from("A6A6A6A6A6A6A6A6", "hex");
-
-const keyStorage = new WeakMap();
-function getCryptoKey(key) {
-    const res = keyStorage.get(key);
-    if (!res) {
-        throw new core__namespace.OperationError("Cannot get CryptoKey from secure storage");
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.toArrayBuffer(dec);
     }
-    return res;
-}
-function setCryptoKey(value) {
-    const key = core__namespace.CryptoKey.create(value.algorithm, value.type, value.extractable, value.usages);
-    Object.freeze(key);
-    keyStorage.set(key, value);
-    return key;
 }
 
 class AesCbcProvider extends core__namespace.AesCbcProvider {
@@ -309,24 +310,24 @@ class AesCbcProvider extends core__namespace.AesCbcProvider {
     }
 }
 
-const zero = buffer.Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
-const rb = buffer.Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135]);
+const zero = node_buffer.Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+const rb = node_buffer.Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135]);
 const blockSize = 16;
-function bitShiftLeft(buffer$1) {
-    const shifted = buffer.Buffer.alloc(buffer$1.length);
-    const last = buffer$1.length - 1;
+function bitShiftLeft(buffer) {
+    const shifted = node_buffer.Buffer.alloc(buffer.length);
+    const last = buffer.length - 1;
     for (let index = 0; index < last; index++) {
-        shifted[index] = buffer$1[index] << 1;
-        if (buffer$1[index + 1] & 0x80) {
+        shifted[index] = buffer[index] << 1;
+        if (buffer[index + 1] & 0x80) {
             shifted[index] += 0x01;
         }
     }
-    shifted[last] = buffer$1[last] << 1;
+    shifted[last] = buffer[last] << 1;
     return shifted;
 }
 function xor(a, b) {
     const length = Math.min(a.length, b.length);
-    const output = buffer.Buffer.alloc(length);
+    const output = node_buffer.Buffer.alloc(length);
     for (let index = 0; index < length; index++) {
         output[index] = a[index] ^ b[index];
     }
@@ -339,14 +340,14 @@ function aes(key, message) {
     return result;
 }
 function getMessageBlock(message, blockIndex) {
-    const block = buffer.Buffer.alloc(blockSize);
+    const block = node_buffer.Buffer.alloc(blockSize);
     const start = blockIndex * blockSize;
     const end = start + blockSize;
     message.copy(block, 0, start, end);
     return block;
 }
 function getPaddedMessageBlock(message, blockIndex) {
-    const block = buffer.Buffer.alloc(blockSize);
+    const block = node_buffer.Buffer.alloc(blockSize);
     const start = blockIndex * blockSize;
     const end = message.length;
     block.fill(0);
@@ -364,7 +365,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);
@@ -403,12 +406,12 @@ class AesCmacProvider extends core__namespace.AesCmacProvider {
         return setCryptoKey(key);
     }
     async onSign(algorithm, key, data) {
-        const result = aesCmac(getCryptoKey(key).data, buffer.Buffer.from(data));
+        const result = aesCmac(getCryptoKey(key).data, node_buffer.Buffer.from(data));
         return new Uint8Array(result).buffer;
     }
     async onVerify(algorithm, key, signature, data) {
         const signature2 = await this.sign(algorithm, key, data);
-        return buffer.Buffer.from(signature).compare(buffer.Buffer.from(signature2)) === 0;
+        return node_buffer.Buffer.from(signature).compare(node_buffer.Buffer.from(signature2)) === 0;
     }
     async onExportKey(format, key) {
         return AesCrypto.exportKey(format, getCryptoKey(key));
@@ -545,9 +548,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__namespace.AlgorithmError("Unsupported algorithm name");
         }
@@ -556,7 +559,9 @@ class DesCryptoKey extends SymmetricKey {
     }
 }
 tslib.__decorate([
-    jsonSchema.JsonProp({ name: "k", converter: JsonBase64UrlConverter })
+    jsonSchema.JsonProp({
+        name: "k", converter: JsonBase64UrlConverter,
+    })
 ], DesCryptoKey.prototype, "data", void 0);
 
 class DesCrypto {
@@ -573,7 +578,7 @@ class DesCrypto {
             case "jwk":
                 return jsonSchema.JsonSerializer.toJSON(key);
             case "raw":
-                return new Uint8Array(key.data).buffer;
+                return utils.toArrayBuffer(key.data);
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk' or 'raw'");
         }
@@ -585,8 +590,9 @@ class DesCrypto {
                 key = jsonSchema.JsonParser.fromJSON(keyData, { targetSchema: DesCryptoKey });
                 break;
             case "raw":
+                utils.assertBufferSource(keyData);
                 key = new DesCryptoKey();
-                key.data = buffer.Buffer.from(keyData);
+                key.data = node_buffer.Buffer.from(utils.toUint8Array(keyData));
                 break;
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk' or 'raw'");
@@ -599,9 +605,9 @@ class DesCrypto {
     static async encrypt(algorithm, key, data) {
         switch (algorithm.name.toUpperCase()) {
             case "DES-CBC":
-                return this.encryptDesCBC(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptDesCBC(algorithm, key, node_buffer.Buffer.from(data));
             case "DES-EDE3-CBC":
-                return this.encryptDesEDE3CBC(algorithm, key, buffer.Buffer.from(data));
+                return this.encryptDesEDE3CBC(algorithm, key, node_buffer.Buffer.from(data));
             default:
                 throw new core__namespace.OperationError("algorithm: Is not recognized");
         }
@@ -612,48 +618,45 @@ class DesCrypto {
         }
         switch (algorithm.name.toUpperCase()) {
             case "DES-CBC":
-                return this.decryptDesCBC(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptDesCBC(algorithm, key, node_buffer.Buffer.from(data));
             case "DES-EDE3-CBC":
-                return this.decryptDesEDE3CBC(algorithm, key, buffer.Buffer.from(data));
+                return this.decryptDesEDE3CBC(algorithm, key, node_buffer.Buffer.from(data));
             default:
                 throw new core__namespace.OperationError("algorithm: Is not recognized");
         }
     }
     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, utils.toUint8Array(algorithm.iv));
         let enc = cipher.update(data);
-        enc = buffer.Buffer.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final()]);
+        const res = utils.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, utils.toUint8Array(algorithm.iv));
         let dec = decipher.update(data);
-        dec = buffer.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.toArrayBuffer(dec);
     }
     static async encryptDesEDE3CBC(algorithm, key, data) {
-        const cipher = crypto.createCipheriv(`des-ede3-cbc`, key.data, buffer.Buffer.from(algorithm.iv));
+        const cipher = crypto.createCipheriv("des-ede3-cbc", key.data, node_buffer.Buffer.from(utils.toUint8Array(algorithm.iv)));
         let enc = cipher.update(data);
-        enc = buffer.Buffer.concat([enc, cipher.final()]);
-        const res = new Uint8Array(enc).buffer;
+        enc = node_buffer.Buffer.concat([enc, cipher.final()]);
+        const res = utils.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, utils.toUint8Array(algorithm.iv));
         let dec = decipher.update(data);
-        dec = buffer.Buffer.concat([dec, decipher.final()]);
-        return new Uint8Array(dec).buffer;
+        dec = node_buffer.Buffer.concat([dec, decipher.final()]);
+        return utils.toArrayBuffer(dec);
     }
 }
 
 class DesCbcProvider extends core__namespace.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,
@@ -671,7 +674,9 @@ class DesCbcProvider extends core__namespace.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__namespace.OperationError("keyData: Wrong key size");
         }
@@ -686,12 +691,9 @@ class DesCbcProvider extends core__namespace.DesProvider {
 }
 
 class DesEde3CbcProvider extends core__namespace.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,
@@ -709,7 +711,9 @@ class DesEde3CbcProvider extends core__namespace.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__namespace.OperationError("keyData: Wrong key size");
         }
@@ -734,17 +738,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__namespace.OperationError("algorithm: Is not recognized");
     }
 }
 
 class RsaPrivateKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     getKey() {
         const keyInfo = asn1Schema.AsnParser.parse(this.data, core__namespace.asn1.PrivateKeyInfo);
         return asn1Schema.AsnParser.parse(keyInfo.privateKey, core__namespace.asn1.RsaPrivateKey);
@@ -765,15 +766,12 @@ class RsaPrivateKey extends AsymmetricKey {
         keyInfo.privateKeyAlgorithm.algorithm = "1.2.840.113549.1.1.1";
         keyInfo.privateKeyAlgorithm.parameters = null;
         keyInfo.privateKey = asn1Schema.AsnSerializer.serialize(key);
-        this.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        this.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
     }
 }
 
 class RsaPublicKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     getKey() {
         const keyInfo = asn1Schema.AsnParser.parse(this.data, core__namespace.asn1.PublicKeyInfo);
         return asn1Schema.AsnParser.parse(keyInfo.publicKey, core__namespace.asn1.RsaPublicKey);
@@ -794,11 +792,13 @@ class RsaPublicKey extends AsymmetricKey {
         keyInfo.publicKeyAlgorithm.algorithm = "1.2.840.113549.1.1.1";
         keyInfo.publicKeyAlgorithm.parameters = null;
         keyInfo.publicKey = asn1Schema.AsnSerializer.serialize(key);
-        this.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        this.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
     }
 }
 
 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;
@@ -808,9 +808,9 @@ class RsaCrypto {
         publicKey.algorithm = algorithm;
         publicKey.extractable = true;
         publicKey.usages = keyUsages.filter((usage) => this.publicKeyUsages.indexOf(usage) !== -1);
-        const publicExponent = buffer.Buffer.concat([
-            buffer.Buffer.alloc(4 - algorithm.publicExponent.byteLength, 0),
-            buffer.Buffer.from(algorithm.publicExponent),
+        const publicExponent = node_buffer.Buffer.concat([
+            node_buffer.Buffer.alloc(4 - algorithm.publicExponent.byteLength, 0),
+            node_buffer.Buffer.from(algorithm.publicExponent),
         ]).readInt32BE(0);
         const keys = crypto.generateKeyPairSync("rsa", {
             modulusLength: algorithm.modulusLength,
@@ -838,7 +838,7 @@ class RsaCrypto {
                 return jsonSchema.JsonSerializer.toJSON(key);
             case "pkcs8":
             case "spki":
-                return new Uint8Array(key.data).buffer;
+                return utils.toArrayBuffer(key.data);
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk', 'pkcs8' or 'spki'");
         }
@@ -857,12 +857,14 @@ class RsaCrypto {
                 }
             }
             case "spki": {
-                const keyInfo = asn1Schema.AsnParser.parse(new Uint8Array(keyData), core__namespace.asn1.PublicKeyInfo);
+                utils.assertBufferSource(keyData);
+                const keyInfo = asn1Schema.AsnParser.parse(utils.toUint8Array(keyData), core__namespace.asn1.PublicKeyInfo);
                 const asnKey = asn1Schema.AsnParser.parse(keyInfo.publicKey, core__namespace.asn1.RsaPublicKey);
                 return this.importPublicKey(asnKey, algorithm, extractable, keyUsages);
             }
             case "pkcs8": {
-                const keyInfo = asn1Schema.AsnParser.parse(new Uint8Array(keyData), core__namespace.asn1.PrivateKeyInfo);
+                utils.assertBufferSource(keyData);
+                const keyInfo = asn1Schema.AsnParser.parse(utils.toUint8Array(keyData), core__namespace.asn1.PrivateKeyInfo);
                 const asnKey = asn1Schema.AsnParser.parse(keyInfo.privateKey, core__namespace.asn1.RsaPrivateKey);
                 return this.importPrivateKey(asnKey, algorithm, extractable, keyUsages);
             }
@@ -910,7 +912,7 @@ class RsaCrypto {
         keyInfo.privateKeyAlgorithm.parameters = null;
         keyInfo.privateKey = asn1Schema.AsnSerializer.serialize(asnKey);
         const key = new RsaPrivateKey();
-        key.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        key.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         key.algorithm = Object.assign({}, algorithm);
         key.algorithm.publicExponent = new Uint8Array(asnKey.publicExponent);
         key.algorithm.modulusLength = asnKey.modulus.byteLength << 3;
@@ -924,7 +926,7 @@ class RsaCrypto {
         keyInfo.publicKeyAlgorithm.parameters = null;
         keyInfo.publicKey = asn1Schema.AsnSerializer.serialize(asnKey);
         const key = new RsaPublicKey();
-        key.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        key.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         key.algorithm = Object.assign({}, algorithm);
         key.algorithm.publicExponent = new Uint8Array(asnKey.publicExponent);
         key.algorithm.modulusLength = asnKey.modulus.byteLength << 3;
@@ -955,30 +957,26 @@ class RsaCrypto {
     static signRsa(algorithm, key, data) {
         const cryptoAlg = this.getCryptoAlgorithm(key.algorithm);
         const signer = crypto.createSign(cryptoAlg);
-        signer.update(buffer.Buffer.from(data));
+        signer.update(node_buffer.Buffer.from(data));
         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 utils.toArrayBuffer(signature);
     }
     static verifySSA(algorithm, key, data, signature) {
         const cryptoAlg = this.getCryptoAlgorithm(key.algorithm);
         const signer = crypto.createVerify(cryptoAlg);
-        signer.update(buffer.Buffer.from(data));
+        signer.update(node_buffer.Buffer.from(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 };
         if (algorithm.name.toUpperCase() === "RSA-PSS") {
             options.padding = crypto.constants.RSA_PKCS1_PSS_PADDING;
             options.saltLength = algorithm.saltLength;
@@ -992,7 +990,7 @@ class RsaCrypto {
             padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
         };
         if (algorithm.label) ;
-        return new Uint8Array(crypto.publicEncrypt(options, data)).buffer;
+        return utils.toArrayBuffer(crypto.publicEncrypt(options, data));
     }
     static decryptOAEP(algorithm, key, data) {
         const options = {
@@ -1000,21 +998,16 @@ class RsaCrypto {
             padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
         };
         if (algorithm.label) ;
-        return new Uint8Array(crypto.privateDecrypt(options, data)).buffer;
+        return utils.toArrayBuffer(crypto.privateDecrypt(options, data));
     }
 }
-RsaCrypto.publicKeyUsages = ["verify", "encrypt", "wrapKey"];
-RsaCrypto.privateKeyUsages = ["sign", "decrypt", "unwrapKey"];
 
 class RsaSsaProvider extends core__namespace.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,
@@ -1035,7 +1028,9 @@ class RsaSsaProvider extends core__namespace.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) {
@@ -1048,14 +1043,11 @@ class RsaSsaProvider extends core__namespace.RsaSsaProvider {
 }
 
 class RsaPssProvider extends core__namespace.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,
@@ -1076,7 +1068,9 @@ class RsaPssProvider extends core__namespace.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) {
@@ -1129,7 +1123,7 @@ class ShaCrypto {
     static digest(algorithm, data) {
         const hashAlg = this.getAlgorithmName(algorithm);
         const hash = crypto.createHash(hashAlg)
-            .update(buffer.Buffer.from(data)).digest();
+            .update(node_buffer.Buffer.from(data)).digest();
         return new Uint8Array(hash).buffer;
     }
 }
@@ -1147,7 +1141,7 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
     }
     async onEncrypt(algorithm, key, data) {
         const internalKey = getCryptoKey(key);
-        const dataView = new Uint8Array(data);
+        const dataView = utils.toUint8Array(data);
         const keySize = Math.ceil(internalKey.algorithm.modulusLength >> 3);
         const hashSize = ShaCrypto.size(internalKey.algorithm.hash) >> 3;
         const dataLength = dataView.byteLength;
@@ -1160,7 +1154,7 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
         const dataBlock = message.subarray(hashSize + 1);
         dataBlock.set(dataView, hashSize + psLength + 1);
         const labelHash = crypto.createHash(internalKey.algorithm.hash.name.replace("-", ""))
-            .update(core__namespace.BufferSourceConverter.toUint8Array(algorithm.label || new Uint8Array(0)))
+            .update(utils.toUint8Array(algorithm.label || new Uint8Array(0)))
             .digest();
         dataBlock.set(labelHash, 0);
         dataBlock[hashSize + psLength] = 1;
@@ -1179,8 +1173,8 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
         const pkcs0 = crypto.publicEncrypt({
             key: internalKey.pem,
             padding: crypto.constants.RSA_NO_PADDING,
-        }, buffer.Buffer.from(message));
-        return new Uint8Array(pkcs0).buffer;
+        }, node_buffer.Buffer.from(message));
+        return utils.toArrayBuffer(pkcs0);
     }
     async onDecrypt(algorithm, key, data) {
         const internalKey = getCryptoKey(key);
@@ -1196,7 +1190,7 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
         let pkcs0 = crypto.privateDecrypt({
             key: internalKey.pem,
             padding: crypto.constants.RSA_NO_PADDING,
-        }, buffer.Buffer.from(data));
+        }, node_buffer.Buffer.from(utils.toUint8Array(data)));
         const z = pkcs0[0];
         const seed = pkcs0.subarray(1, hashSize + 1);
         const dataBlock = pkcs0.subarray(hashSize + 1);
@@ -1212,7 +1206,7 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
             dataBlock[i] ^= dataBlockMask[i];
         }
         const labelHash = crypto.createHash(internalKey.algorithm.hash.name.replace("-", ""))
-            .update(core__namespace.BufferSourceConverter.toUint8Array(algorithm.label || new Uint8Array(0)))
+            .update(utils.toUint8Array(algorithm.label || new Uint8Array(0)))
             .digest();
         for (let i = 0; i < hashSize; i++) {
             if (labelHash[i] !== dataBlock[i]) {
@@ -1233,13 +1227,15 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
             throw new Error("Decryption failed");
         }
         pkcs0 = dataBlock.subarray(psEnd + 1);
-        return new Uint8Array(pkcs0).buffer;
+        return utils.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) {
@@ -1260,10 +1256,10 @@ class RsaOaepProvider extends core__namespace.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 = utils.toUint8Array(crypto.createHash(algorithm.name.replace("-", ""))
                 .update(seed)
                 .update(counter)
-                .digest();
+                .digest());
             if (chunk.length > submask.length) {
                 chunk = chunk.subarray(0, submask.length);
             }
@@ -1274,14 +1270,11 @@ class RsaOaepProvider extends core__namespace.RsaOaepProvider {
 }
 
 class RsaEsProvider extends core__namespace.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,
@@ -1297,7 +1290,7 @@ class RsaEsProvider extends core__namespace.ProviderCrypto {
         if (!(algorithm.publicExponent && algorithm.publicExponent instanceof Uint8Array)) {
             throw new TypeError("publicExponent: Missing or not a Uint8Array");
         }
-        const publicExponent = pvtsutils.Convert.ToBase64(algorithm.publicExponent);
+        const publicExponent = utils.convert.encode("base64", algorithm.publicExponent);
         if (!(publicExponent === "Aw==" || publicExponent === "AQAB")) {
             throw new TypeError("publicExponent: Must be [3] or [1,0,1]");
         }
@@ -1313,19 +1306,21 @@ class RsaEsProvider extends core__namespace.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, utils.toUint8Array(data));
+        return utils.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, utils.toUint8Array(data));
+        return utils.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) {
@@ -1353,33 +1348,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) {
@@ -1391,10 +1386,7 @@ function getOidByNamedCurve$1(namedCurve) {
 }
 
 class EcPrivateKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     getKey() {
         const keyInfo = asn1Schema.AsnParser.parse(this.data, core__namespace.asn1.PrivateKeyInfo);
         return asn1Schema.AsnParser.parse(keyInfo.privateKey, core__namespace.asn1.EcPrivateKey);
@@ -1411,23 +1403,20 @@ class EcPrivateKey extends AsymmetricKey {
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core__namespace.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core__namespace.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         const keyInfo = new core__namespace.asn1.PrivateKeyInfo();
         keyInfo.privateKeyAlgorithm.algorithm = "1.2.840.10045.2.1";
         keyInfo.privateKeyAlgorithm.parameters = asn1Schema.AsnSerializer.serialize(new core__namespace.asn1.ObjectIdentifier(getOidByNamedCurve$1(json.crv)));
         const key = jsonSchema.JsonParser.fromJSON(json, { targetSchema: core__namespace.asn1.EcPrivateKey });
         keyInfo.privateKey = asn1Schema.AsnSerializer.serialize(key);
-        this.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        this.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         return this;
     }
 }
 
 class EcPublicKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     getKey() {
         const keyInfo = asn1Schema.AsnParser.parse(this.data, core__namespace.asn1.PublicKeyInfo);
         return new core__namespace.asn1.EcPublicKey(keyInfo.publicKey);
@@ -1444,96 +1433,77 @@ class EcPublicKey extends AsymmetricKey {
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core__namespace.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core__namespace.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         const key = jsonSchema.JsonParser.fromJSON(json, { targetSchema: core__namespace.asn1.EcPublicKey });
         const keyInfo = new core__namespace.asn1.PublicKeyInfo();
         keyInfo.publicKeyAlgorithm.algorithm = "1.2.840.10045.2.1";
         keyInfo.publicKeyAlgorithm.parameters = asn1Schema.AsnSerializer.serialize(new core__namespace.asn1.ObjectIdentifier(getOidByNamedCurve$1(json.crv)));
         keyInfo.publicKey = asn1Schema.AsnSerializer.toASN(key).valueHex;
-        this.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        this.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         return this;
     }
 }
 
 class Sha1Provider extends core__namespace.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__namespace.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__namespace.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__namespace.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__namespace.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__namespace.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__namespace.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;
@@ -1565,34 +1535,30 @@ class EcCrypto {
     static async sign(algorithm, key, data) {
         const cryptoAlg = ShaCrypto.getAlgorithmName(algorithm.hash);
         const signer = crypto.createSign(cryptoAlg);
-        signer.update(buffer.Buffer.from(data));
+        signer.update(node_buffer.Buffer.from(data));
         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 = asn1Schema.AsnParser.parse(signature, core__namespace.asn1.EcDsaSignature);
         const signatureRaw = core__namespace.EcUtils.encodeSignature(ecSignature, core__namespace.EcCurves.get(key.algorithm.namedCurve).size);
-        return signatureRaw.buffer;
+        return utils.toArrayBuffer(signatureRaw);
     }
     static async verify(algorithm, key, signature, data) {
         const cryptoAlg = ShaCrypto.getAlgorithmName(algorithm.hash);
         const signer = crypto.createVerify(cryptoAlg);
-        signer.update(buffer.Buffer.from(data));
+        signer.update(node_buffer.Buffer.from(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 ecSignature = new core__namespace.asn1.EcDsaSignature();
         const namedCurve = core__namespace.EcCurves.get(key.algorithm.namedCurve);
         const signaturePoint = core__namespace.EcUtils.decodeSignature(signature, namedCurve.size);
-        ecSignature.r = pvtsutils.BufferSourceConverter.toArrayBuffer(signaturePoint.r);
-        ecSignature.s = pvtsutils.BufferSourceConverter.toArrayBuffer(signaturePoint.s);
-        const ecSignatureRaw = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(ecSignature));
+        ecSignature.r = utils.toArrayBuffer(signaturePoint.r);
+        ecSignature.s = utils.toArrayBuffer(signaturePoint.s);
+        const ecSignatureRaw = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(ecSignature));
         const ok = signer.verify(options, ecSignatureRaw);
         return ok;
     }
@@ -1601,13 +1567,13 @@ class EcCrypto {
         const ecdh = crypto.createECDH(cryptoAlg);
         const asnPrivateKey = asn1Schema.AsnParser.parse(baseKey.data, core__namespace.asn1.PrivateKeyInfo);
         const asnEcPrivateKey = asn1Schema.AsnParser.parse(asnPrivateKey.privateKey, core__namespace.asn1.EcPrivateKey);
-        ecdh.setPrivateKey(buffer.Buffer.from(asnEcPrivateKey.privateKey));
+        ecdh.setPrivateKey(node_buffer.Buffer.from(asnEcPrivateKey.privateKey));
         const asnPublicKey = asn1Schema.AsnParser.parse(algorithm.public.data, core__namespace.asn1.PublicKeyInfo);
-        const bits = ecdh.computeSecret(buffer.Buffer.from(asnPublicKey.publicKey));
+        const bits = ecdh.computeSecret(node_buffer.Buffer.from(asnPublicKey.publicKey));
         if (length === null) {
-            return bits;
+            return utils.toArrayBuffer(bits);
         }
-        return new Uint8Array(bits).buffer.slice(0, length >> 3);
+        return utils.toArrayBuffer(bits).slice(0, length >> 3);
     }
     static async exportKey(format, key) {
         switch (format.toLowerCase()) {
@@ -1615,7 +1581,7 @@ class EcCrypto {
                 return jsonSchema.JsonSerializer.toJSON(key);
             case "pkcs8":
             case "spki":
-                return new Uint8Array(key.data).buffer;
+                return utils.toArrayBuffer(key.data);
             case "raw": {
                 const publicKeyInfo = asn1Schema.AsnParser.parse(key.data, core__namespace.asn1.PublicKeyInfo);
                 return publicKeyInfo.publicKey;
@@ -1638,17 +1604,20 @@ class EcCrypto {
                 }
             }
             case "raw": {
-                const asnKey = new core__namespace.asn1.EcPublicKey(keyData);
+                utils.assertBufferSource(keyData);
+                const asnKey = new core__namespace.asn1.EcPublicKey(utils.toArrayBuffer(keyData));
                 return this.importPublicKey(asnKey, algorithm, extractable, keyUsages);
             }
             case "spki": {
-                const keyInfo = asn1Schema.AsnParser.parse(new Uint8Array(keyData), core__namespace.asn1.PublicKeyInfo);
+                utils.assertBufferSource(keyData);
+                const keyInfo = asn1Schema.AsnParser.parse(utils.toUint8Array(keyData), core__namespace.asn1.PublicKeyInfo);
                 const asnKey = new core__namespace.asn1.EcPublicKey(keyInfo.publicKey);
                 this.assertKeyParameters(keyInfo.publicKeyAlgorithm.parameters, algorithm.namedCurve);
                 return this.importPublicKey(asnKey, algorithm, extractable, keyUsages);
             }
             case "pkcs8": {
-                const keyInfo = asn1Schema.AsnParser.parse(new Uint8Array(keyData), core__namespace.asn1.PrivateKeyInfo);
+                utils.assertBufferSource(keyData);
+                const keyInfo = asn1Schema.AsnParser.parse(utils.toUint8Array(keyData), core__namespace.asn1.PrivateKeyInfo);
                 const asnKey = asn1Schema.AsnParser.parse(keyInfo.privateKey, core__namespace.asn1.EcPrivateKey);
                 this.assertKeyParameters(keyInfo.privateKeyAlgorithm.parameters, algorithm.namedCurve);
                 return this.importPrivateKey(asnKey, algorithm, extractable, keyUsages);
@@ -1665,7 +1634,7 @@ class EcCrypto {
         try {
             namedCurveIdentifier = asn1Schema.AsnParser.parse(parameters, core__namespace.asn1.ObjectIdentifier).value;
         }
-        catch (e) {
+        catch {
             throw new core__namespace.CryptoError("Cannot read key info parameters");
         }
         if (getOidByNamedCurve$1(namedCurve) !== namedCurveIdentifier) {
@@ -1678,7 +1647,7 @@ class EcCrypto {
         keyInfo.privateKeyAlgorithm.parameters = asn1Schema.AsnSerializer.serialize(new core__namespace.asn1.ObjectIdentifier(getOidByNamedCurve$1(algorithm.namedCurve)));
         keyInfo.privateKey = asn1Schema.AsnSerializer.serialize(asnKey);
         const key = new EcPrivateKey();
-        key.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        key.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         key.algorithm = Object.assign({}, algorithm);
         key.extractable = extractable;
         key.usages = keyUsages;
@@ -1691,7 +1660,7 @@ class EcCrypto {
         keyInfo.publicKeyAlgorithm.parameters = asn1Schema.AsnSerializer.serialize(new core__namespace.asn1.ObjectIdentifier(namedCurve));
         keyInfo.publicKey = asnKey.value;
         const key = new EcPublicKey();
-        key.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        key.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         key.algorithm = Object.assign({}, algorithm);
         key.extractable = extractable;
         key.usages = keyUsages;
@@ -1712,19 +1681,14 @@ class EcCrypto {
         }
     }
 }
-EcCrypto.publicKeyUsages = ["verify"];
-EcCrypto.privateKeyUsages = ["sign", "deriveKey", "deriveBits"];
 
 class EcdsaProvider extends core__namespace.EcdsaProvider {
-    constructor() {
-        super(...arguments);
-        this.namedCurves = core__namespace.EcCurves.names;
-        this.hashAlgorithms = [
-            "SHA-1", "SHA-256", "SHA-384", "SHA-512",
-            "shake128", "shake256",
-            "SHA3-256", "SHA3-384", "SHA3-512"
-        ];
-    }
+    namedCurves = core__namespace.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,
@@ -1745,7 +1709,9 @@ class EcdsaProvider extends core__namespace.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) {
@@ -1758,10 +1724,7 @@ class EcdsaProvider extends core__namespace.EcdsaProvider {
 }
 
 class EcdhProvider extends core__namespace.EcdhProvider {
-    constructor() {
-        super(...arguments);
-        this.namedCurves = core__namespace.EcCurves.names;
-    }
+    namedCurves = core__namespace.EcCurves.names;
     async onGenerateKey(algorithm, extractable, keyUsages) {
         const keys = await EcCrypto.generateKey({
             ...algorithm,
@@ -1776,7 +1739,9 @@ class EcdhProvider extends core__namespace.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) {
@@ -1787,20 +1752,22 @@ class EcdhProvider extends core__namespace.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__namespace.asn1.idEd448]: "Ed448",
-    "ed448": core__namespace.asn1.idEd448,
+    ed448: core__namespace.asn1.idEd448,
     [core__namespace.asn1.idX448]: "X448",
-    "x448": core__namespace.asn1.idX448,
+    x448: core__namespace.asn1.idX448,
     [core__namespace.asn1.idEd25519]: "Ed25519",
-    "ed25519": core__namespace.asn1.idEd25519,
+    ed25519: core__namespace.asn1.idEd25519,
     [core__namespace.asn1.idX25519]: "X25519",
-    "x25519": core__namespace.asn1.idX25519,
+    x25519: core__namespace.asn1.idX25519,
 };
 function getOidByNamedCurve(namedCurve) {
     const oid = edOIDs[namedCurve.toLowerCase()];
@@ -1811,10 +1778,7 @@ function getOidByNamedCurve(namedCurve) {
 }
 
 class EdPrivateKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "private";
-    }
+    type = "private";
     getKey() {
         const keyInfo = asn1Schema.AsnParser.parse(this.data, core__namespace.asn1.PrivateKeyInfo);
         return asn1Schema.AsnParser.parse(keyInfo.privateKey, core__namespace.asn1.CurvePrivateKey);
@@ -1831,22 +1795,19 @@ class EdPrivateKey extends AsymmetricKey {
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core__namespace.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core__namespace.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         const keyInfo = new core__namespace.asn1.PrivateKeyInfo();
         keyInfo.privateKeyAlgorithm.algorithm = getOidByNamedCurve(json.crv);
         const key = jsonSchema.JsonParser.fromJSON(json, { targetSchema: core__namespace.asn1.CurvePrivateKey });
         keyInfo.privateKey = asn1Schema.AsnSerializer.serialize(key);
-        this.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        this.data = node_buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
         return this;
     }
 }
 
 class EdPublicKey extends AsymmetricKey {
-    constructor() {
-        super(...arguments);
-        this.type = "public";
-    }
+    type = "public";
     getKey() {
         const keyInfo = asn1Schema.AsnParser.parse(this.data, core__namespace.asn1.PublicKeyInfo);
         return keyInfo.publicKey;
@@ -1859,26 +1820,26 @@ class EdPublicKey extends AsymmetricKey {
             key_ops: this.usages,
             ext: this.extractable,
         };
-        return Object.assign(json, {
-            x: pvtsutils.Convert.ToBase64Url(key)
-        });
+        return Object.assign(json, { x: utils.convert.encode("base64url", key) });
     }
     fromJSON(json) {
         if (!json.crv) {
-            throw new core__namespace.OperationError(`Cannot get named curve from JWK. Property 'crv' is required`);
+            throw new core__namespace.OperationError("Cannot get named curve from JWK. Property 'crv' is required");
         }
         if (!json.x) {
-            throw new core__namespace.OperationError(`Cannot get property from JWK. Property 'x' is required`);
+            throw new core__namespace.OperationError("Cannot get property from JWK. Property 'x' is required");
         }
         const keyInfo = new core__namespace.asn1.PublicKeyInfo();
         keyInfo.publicKeyAlgorithm.algorithm = getOidByNamedCurve(json.crv);
-        keyInfo.publicKey = pvtsutils.Convert.FromBase64Url(json.x);
-        this.data = buffer.Buffer.from(asn1Schema.AsnSerializer.serialize(keyInfo));
+        keyInfo.publicKey = utils.toArrayBuffer(utils.convert.decode("base64url", json.x));
+        this.data = node_buffer.Buffer.from(asn1Schema.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;
@@ -1911,20 +1872,16 @@ 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 signature = crypto.sign(null, buffer.Buffer.from(data), options);
-        return core__namespace.BufferSourceConverter.toArrayBuffer(signature);
+        const options = { key: key.pem };
+        const signature = crypto.sign(null, node_buffer.Buffer.from(data), options);
+        return utils.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 ok = crypto.verify(null, buffer.Buffer.from(data), options, buffer.Buffer.from(signature));
+        const options = { key: key.pem };
+        const ok = crypto.verify(null, node_buffer.Buffer.from(data), options, node_buffer.Buffer.from(signature));
         return ok;
     }
     static async deriveBits(algorithm, baseKey, length) {
@@ -1942,7 +1899,7 @@ class EdCrypto {
             publicKey,
             privateKey,
         });
-        return new Uint8Array(bits).buffer.slice(0, length >> 3);
+        return utils.toArrayBuffer(bits).slice(0, length >> 3);
     }
     static async exportKey(format, key) {
         switch (format.toLowerCase()) {
@@ -1950,7 +1907,7 @@ class EdCrypto {
                 return jsonSchema.JsonSerializer.toJSON(key);
             case "pkcs8":
             case "spki":
-                return new Uint8Array(key.data).buffer;
+                return utils.toArrayBuffer(key.data);
             case "raw": {
                 const publicKeyInfo = asn1Schema.AsnParser.parse(key.data, core__namespace.asn1.PublicKeyInfo);
                 return publicKeyInfo.publicKey;
@@ -1971,18 +1928,21 @@ class EdCrypto {
                     if (!jwk.x) {
                         throw new TypeError("keyData: Cannot get required 'x' filed");
                     }
-                    return this.importPublicKey(pvtsutils.Convert.FromBase64Url(jwk.x), algorithm, extractable, keyUsages);
+                    return this.importPublicKey(utils.toArrayBuffer(utils.convert.decode("base64url", jwk.x)), algorithm, extractable, keyUsages);
                 }
             }
             case "raw": {
-                return this.importPublicKey(keyData, algorithm, extractable, keyUsages);
+                utils.assertBufferSource(keyData);
+                return this.importPublicKey(utils.toArrayBuffer(keyData), algorithm, extractable, keyUsages);
             }
             case "spki": {
-                const keyInfo = asn1Schema.AsnParser.parse(new Uint8Array(keyData), core__namespace.asn1.PublicKeyInfo);
+                utils.assertBufferSource(keyData);
+                const keyInfo = asn1Schema.AsnParser.parse(utils.toUint8Array(keyData), core__namespace.asn1.PublicKeyInfo);
                 return this.importPublicKey(keyInfo.publicKey, algorithm, extractable, keyUsages);
             }
             case "pkcs8": {
-                const keyInfo = asn1Schema.AsnParser.parse(new Uint8Array(keyData), core__namespace.asn1.PrivateKeyInfo);
+                utils.assertBufferSource(keyData);
+                const keyInfo = asn1Schema.AsnParser.parse(utils.toUint8Array(keyData), core__namespace.asn1.PrivateKeyInfo);
                 const asnKey = asn1Schema.AsnParser.parse(keyInfo.privateKey, core__namespace.asn1.CurvePrivateKey);
                 return this.importPrivateKey(asnKey, algorithm, extractable, keyUsages);
             }
@@ -1994,7 +1954,7 @@ class EdCrypto {
         const key = new EdPrivateKey();
         key.fromJSON({
             crv: algorithm.namedCurve,
-            d: pvtsutils.Convert.ToBase64Url(asnKey.d),
+            d: utils.convert.encode("base64url", asnKey.d),
         });
         key.algorithm = Object.assign({}, algorithm);
         key.extractable = extractable;
@@ -2005,7 +1965,7 @@ class EdCrypto {
         const key = new EdPublicKey();
         key.fromJSON({
             crv: algorithm.namedCurve,
-            x: pvtsutils.Convert.ToBase64Url(asnKey),
+            x: utils.convert.encode("base64url", asnKey),
         });
         key.algorithm = Object.assign({}, algorithm);
         key.extractable = extractable;
@@ -2013,8 +1973,6 @@ class EdCrypto {
         return key;
     }
 }
-EdCrypto.publicKeyUsages = ["verify"];
-EdCrypto.privateKeyUsages = ["sign", "deriveKey", "deriveBits"];
 
 class EdDsaProvider extends core__namespace.EdDsaProvider {
     async onGenerateKey(algorithm, extractable, keyUsages) {
@@ -2037,7 +1995,9 @@ class EdDsaProvider extends core__namespace.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);
     }
 }
@@ -2054,14 +2014,18 @@ class EcdhEsProvider extends core__namespace.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);
     }
 }
@@ -2085,10 +2049,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,
@@ -2106,10 +2067,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,
@@ -2123,6 +2081,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, {
@@ -2135,9 +2095,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 {
@@ -2164,7 +2122,7 @@ class Ed25519Crypto {
             }
             case "raw": {
                 const jwk = key.toJWK();
-                return pvtsutils.Convert.FromBase64Url(jwk.x);
+                return utils.toArrayBuffer(utils.convert.decode("base64url", jwk.x));
             }
             default:
                 return Promise.reject(new core__namespace.OperationError("format: Must be 'jwk', 'raw', pkcs8' or 'spki'"));
@@ -2176,7 +2134,7 @@ class Ed25519Crypto {
                 const jwk = keyData;
                 if (jwk.d) {
                     const privateData = new core__namespace.asn1.EdPrivateKey();
-                    privateData.value = core__namespace.BufferSourceConverter.toArrayBuffer(Buffer.from(jwk.d, "base64url"));
+                    privateData.value = utils.toArrayBuffer(utils.convert.decode("base64url", jwk.d));
                     const pkcs8 = new core__namespace.asn1.PrivateKeyInfo();
                     pkcs8.privateKeyAlgorithm.algorithm = algorithm.name.toLowerCase() === "ed25519"
                         ? core__namespace.asn1.idEd25519
@@ -2191,7 +2149,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 {
@@ -2199,24 +2159,29 @@ class Ed25519Crypto {
                 }
             }
             case "pkcs8": {
-                const pem = core__namespace.PemConverter.fromBufferSource(keyData, "PRIVATE KEY");
+                utils.assertBufferSource(keyData);
+                const pem = core__namespace.PemConverter.fromBufferSource(utils.toArrayBuffer(keyData), "PRIVATE KEY");
                 return new Ed25519PrivateKey(algorithm, extractable, keyUsages, pem);
             }
             case "spki": {
-                const pem = core__namespace.PemConverter.fromBufferSource(keyData, "PUBLIC KEY");
+                utils.assertBufferSource(keyData);
+                const pem = core__namespace.PemConverter.fromBufferSource(utils.toArrayBuffer(keyData), "PUBLIC KEY");
                 return new Ed25519PublicKey(algorithm, extractable, keyUsages, pem);
             }
             case "raw": {
-                const raw = keyData;
+                utils.assertBufferSource(keyData);
+                const raw = utils.toArrayBuffer(keyData);
                 const key = crypto.createPublicKey({
                     format: "jwk",
                     key: {
                         kty: "OKP",
                         crv: algorithm.name.toLowerCase() === "ed25519" ? "Ed25519" : "X25519",
-                        x: pvtsutils.Convert.ToBase64Url(raw),
+                        x: utils.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:
@@ -2224,8 +2189,6 @@ class Ed25519Crypto {
         }
     }
 }
-Ed25519Crypto.privateKeyUsages = ["sign", "deriveBits", "deriveKey"];
-Ed25519Crypto.publicKeyUsages = ["verify"];
 
 class Ed25519Provider extends core__namespace.Ed25519Provider {
     async onGenerateKey(algorithm, extractable, keyUsages) {
@@ -2303,22 +2266,23 @@ class PbkdfCryptoKey extends CryptoKey {
 class Pbkdf2Provider extends core__namespace.Pbkdf2Provider {
     async onDeriveBits(algorithm, baseKey, length) {
         return new Promise((resolve, reject) => {
-            const salt = core__namespace.BufferSourceConverter.toArrayBuffer(algorithm.salt);
+            const salt = utils.toUint8Array(algorithm.salt);
             const hash = algorithm.hash.name.replace("-", "");
-            crypto.pbkdf2(getCryptoKey(baseKey).data, buffer.Buffer.from(salt), algorithm.iterations, length >> 3, hash, (err, derivedBits) => {
+            crypto.pbkdf2(getCryptoKey(baseKey).data, node_buffer.Buffer.from(salt), algorithm.iterations, length >> 3, hash, (err, derivedBits) => {
                 if (err) {
                     reject(err);
                 }
                 else {
-                    resolve(new Uint8Array(derivedBits).buffer);
+                    resolve(utils.toArrayBuffer(derivedBits));
                 }
             });
         });
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
         if (format === "raw") {
+            utils.assertBufferSource(keyData);
             const key = new PbkdfCryptoKey();
-            key.data = buffer.Buffer.from(keyData);
+            key.data = node_buffer.Buffer.from(utils.toUint8Array(keyData));
             key.algorithm = { name: this.name };
             key.extractable = false;
             key.usages = keyUsages;
@@ -2343,7 +2307,9 @@ class HmacCryptoKey extends CryptoKey {
     }
 }
 tslib.__decorate([
-    jsonSchema.JsonProp({ name: "k", converter: JsonBase64UrlConverter })
+    jsonSchema.JsonProp({
+        name: "k", converter: JsonBase64UrlConverter,
+    })
 ], HmacCryptoKey.prototype, "data", void 0);
 
 class HmacProvider extends core__namespace.HmacProvider {
@@ -2363,14 +2329,14 @@ class HmacProvider extends core__namespace.HmacProvider {
     async onSign(algorithm, key, data) {
         const cryptoAlg = ShaCrypto.getAlgorithmName(key.algorithm.hash);
         const hmac = crypto.createHmac(cryptoAlg, getCryptoKey(key).data)
-            .update(buffer.Buffer.from(data)).digest();
-        return new Uint8Array(hmac).buffer;
+            .update(node_buffer.Buffer.from(utils.toUint8Array(data))).digest();
+        return utils.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.Buffer.from(data)).digest();
-        return hmac.compare(buffer.Buffer.from(signature)) === 0;
+            .update(node_buffer.Buffer.from(utils.toUint8Array(data))).digest();
+        return hmac.compare(node_buffer.Buffer.from(utils.toUint8Array(signature))) === 0;
     }
     async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
         let key;
@@ -2379,8 +2345,9 @@ class HmacProvider extends core__namespace.HmacProvider {
                 key = jsonSchema.JsonParser.fromJSON(keyData, { targetSchema: HmacCryptoKey });
                 break;
             case "raw":
+                utils.assertBufferSource(keyData);
                 key = new HmacCryptoKey();
-                key.data = buffer.Buffer.from(keyData);
+                key.data = node_buffer.Buffer.from(utils.toUint8Array(keyData));
                 break;
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk' or 'raw'");
@@ -2399,7 +2366,7 @@ class HmacProvider extends core__namespace.HmacProvider {
             case "jwk":
                 return jsonSchema.JsonSerializer.toJSON(getCryptoKey(key));
             case "raw":
-                return new Uint8Array(getCryptoKey(key).data).buffer;
+                return utils.toArrayBuffer(getCryptoKey(key).data);
             default:
                 throw new core__namespace.OperationError("format: Must be 'jwk' or 'raw'");
         }
@@ -2421,7 +2388,7 @@ class HkdfProvider extends core__namespace.HkdfProvider {
             throw new core__namespace.OperationError("Operation not supported");
         }
         const key = new HkdfCryptoKey();
-        key.data = buffer.Buffer.from(keyData);
+        key.data = node_buffer.Buffer.from(keyData);
         key.algorithm = { name: this.name };
         key.extractable = extractable;
         key.usages = keyUsages;
@@ -2435,14 +2402,14 @@ class HkdfProvider extends core__namespace.HkdfProvider {
         const PRK = crypto.createHmac(hash, core.BufferSourceConverter.toUint8Array(params.salt))
             .update(core.BufferSourceConverter.toUint8Array(getCryptoKey(baseKey).data))
             .digest();
-        const blocks = [buffer.Buffer.alloc(0)];
+        const blocks = [node_buffer.Buffer.alloc(0)];
         const blockCount = Math.ceil(byteLength / hashLength) + 1;
         for (let i = 1; i < blockCount; ++i) {
             blocks.push(crypto.createHmac(hash, PRK)
-                .update(buffer.Buffer.concat([blocks[i - 1], info, buffer.Buffer.from([i])]))
+                .update(node_buffer.Buffer.concat([blocks[i - 1], info, node_buffer.Buffer.from([i])]))
                 .digest());
         }
-        return buffer.Buffer.concat(blocks).slice(0, byteLength);
+        return core.BufferSourceConverter.toArrayBuffer(node_buffer.Buffer.concat(blocks).slice(0, byteLength));
     }
     checkCryptoKey(key, keyUsage) {
         super.checkCryptoKey(key, keyUsage);
@@ -2455,7 +2422,7 @@ class HkdfProvider extends core__namespace.HkdfProvider {
 class ShakeCrypto {
     static digest(algorithm, data) {
         const hash = crypto.createHash(algorithm.name.toLowerCase(), { outputLength: algorithm.length })
-            .update(buffer.Buffer.from(data)).digest();
+            .update(node_buffer.Buffer.from(data)).digest();
         return new Uint8Array(hash).buffer;
     }
 }
@@ -2474,7 +2441,6 @@ class Shake256Provider extends core__namespace.Shake256Provider {
 
 class SubtleCrypto extends core__namespace.SubtleCrypto {
     constructor() {
-        var _a;
         super();
         this.providers.set(new AesCbcProvider());
         this.providers.set(new AesCtrProvider());
@@ -2500,7 +2466,7 @@ class SubtleCrypto extends core__namespace.SubtleCrypto {
         this.providers.set(new Pbkdf2Provider());
         this.providers.set(new HmacProvider());
         this.providers.set(new HkdfProvider());
-        const nodeMajorVersion = (_a = /^v(\d+)/.exec(process__namespace.version)) === null || _a === void 0 ? void 0 : _a[1];
+        const nodeMajorVersion = /^v(\d+)/.exec(process__namespace.version)?.[1];
         if (nodeMajorVersion && parseInt(nodeMajorVersion, 10) >= 12) {
             this.providers.set(new Shake128Provider());
             this.providers.set(new Shake256Provider());
@@ -2525,22 +2491,19 @@ class SubtleCrypto extends core__namespace.SubtleCrypto {
 }
 
 class Crypto extends core__namespace.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'");
         }
-        const buffer$1 = buffer.Buffer.from(array.buffer, array.byteOffset, array.byteLength);
-        crypto.randomFillSync(buffer$1);
+        const buffer = node_buffer.Buffer.from(array.buffer, array.byteOffset, array.byteLength);
+        crypto.randomFillSync(buffer);
         return array;
     }
 }
 
 Object.defineProperty(exports, "CryptoKey", {
-  enumerable: true,
-  get: function () { return core.CryptoKey; }
+    enumerable: true,
+    get: function () { return core.CryptoKey; }
 });
 exports.Crypto = Crypto;