@opcua/for-node-red 3.34.2 → 3.36.0

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

@@ -1,32 +1,37 @@
-/*!
- Copyright (c) Peculiar Ventures, LLC
-*/
+/**
+ * Copyright (c) 2019-2026, Peculiar Ventures
+ * SPDX-License-Identifier: MIT
+ */
 
 'use strict';
 
-var pvtsutils = require('pvtsutils');
+var bytes = require('@peculiar/utils/bytes');
+var encoding = require('@peculiar/utils/encoding');
 var asn1Schema = require('@peculiar/asn1-schema');
 var tslib = require('tslib');
 var jsonSchema = require('@peculiar/json-schema');
 var asn1 = require('asn1js');
+var legacy = require('@peculiar/utils/legacy');
 
 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 bytes__namespace = /*#__PURE__*/_interopNamespaceDefault(bytes);
+var encoding__namespace = /*#__PURE__*/_interopNamespaceDefault(encoding);
 var asn1__namespace = /*#__PURE__*/_interopNamespaceDefault(asn1);
 
 class CryptoError extends Error {
@@ -56,14 +61,14 @@ class PemConverter {
             .replace(/-{5}(BEGIN|END) .*-{5}/g, "")
             .replace("\r", "")
             .replace("\n", "");
-        return pvtsutils.Convert.FromBase64(base64);
+        return bytes__namespace.toArrayBuffer(encoding__namespace.base64.decode(base64));
     }
     static toUint8Array(pem) {
         const bytes = this.toArrayBuffer(pem);
         return new Uint8Array(bytes);
     }
     static fromBufferSource(buffer, tag) {
-        const base64 = pvtsutils.Convert.ToBase64(buffer);
+        const base64 = encoding__namespace.base64.encode(buffer);
         let sliced;
         let offset = 0;
         const rows = [];
@@ -134,7 +139,7 @@ class ProviderCrypto {
         this.checkAlgorithmName(algorithm);
         this.checkGenerateKeyParams(algorithm);
         if (!(keyUsages && keyUsages.length)) {
-            throw new TypeError(`Usages cannot be empty when creating a key.`);
+            throw new TypeError("Usages cannot be empty when creating a key.");
         }
         let allowedUsages;
         if (Array.isArray(this.usages)) {
@@ -262,7 +267,7 @@ class ProviderCrypto {
     checkCryptoKey(key, keyUsage) {
         this.checkAlgorithmName(key.algorithm);
         if (keyUsage && key.usages.indexOf(keyUsage) === -1) {
-            throw new CryptoError(`key does not match that of operation`);
+            throw new CryptoError("key does not match that of operation");
         }
     }
     checkRequiredProperty(data, propName) {
@@ -300,12 +305,12 @@ class ProviderCrypto {
                 throw new TypeError("keyData: Is not JsonWebToken");
             }
         }
-        else if (!pvtsutils.BufferSourceConverter.isBufferSource(keyData)) {
+        else if (!bytes__namespace.isBufferSource(keyData)) {
             throw new TypeError("keyData: Is not ArrayBufferView or ArrayBuffer");
         }
     }
     prepareData(data) {
-        return pvtsutils.BufferSourceConverter.toArrayBuffer(data);
+        return bytes__namespace.toArrayBuffer(data);
     }
 }
 
@@ -330,11 +335,8 @@ class AesProvider extends ProviderCrypto {
 }
 
 class AesCbcProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-CBC";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-CBC";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "iv");
         if (!(algorithm.iv instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.iv))) {
@@ -347,11 +349,8 @@ class AesCbcProvider extends AesProvider {
 }
 
 class AesCmacProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-CMAC";
-        this.usages = ["sign", "verify"];
-    }
+    name = "AES-CMAC";
+    usages = ["sign", "verify"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "length");
         if (typeof algorithm.length !== "number") {
@@ -364,11 +363,8 @@ class AesCmacProvider extends AesProvider {
 }
 
 class AesCtrProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-CTR";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-CTR";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "counter");
         if (!(algorithm.counter instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.counter))) {
@@ -388,21 +384,14 @@ class AesCtrProvider extends AesProvider {
 }
 
 class AesEcbProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-ECB";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-ECB";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
 }
 
 class AesGcmProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-GCM";
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    name = "AES-GCM";
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
-        var _a;
         this.checkRequiredProperty(algorithm, "iv");
         if (!(algorithm.iv instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.iv))) {
             throw new TypeError("iv: Is not of type '(ArrayBuffer or ArrayBufferView)'");
@@ -410,7 +399,7 @@ class AesGcmProvider extends AesProvider {
         if (algorithm.iv.byteLength < 1) {
             throw new OperationError("iv: Must have length more than 0 and less than 2^64 - 1");
         }
-        (_a = algorithm.tagLength) !== null && _a !== void 0 ? _a : (algorithm.tagLength = 128);
+        algorithm.tagLength ??= 128;
         switch (algorithm.tagLength) {
             case 32:
             case 64:
@@ -427,18 +416,12 @@ class AesGcmProvider extends AesProvider {
 }
 
 class AesKwProvider extends AesProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "AES-KW";
-        this.usages = ["wrapKey", "unwrapKey"];
-    }
+    name = "AES-KW";
+    usages = ["wrapKey", "unwrapKey"];
 }
 
 class DesProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
-    }
+    usages = ["encrypt", "decrypt", "wrapKey", "unwrapKey"];
     checkAlgorithmParams(algorithm) {
         if (this.ivSize) {
             this.checkRequiredProperty(algorithm, "iv");
@@ -465,10 +448,7 @@ class DesProvider extends ProviderCrypto {
 }
 
 class RsaProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-    }
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
     checkGenerateKeyParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
@@ -476,7 +456,7 @@ class RsaProvider extends 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 = encoding__namespace.base64url.encode(algorithm.publicExponent);
         if (!(publicExponent === "Aw==" || publicExponent === "AQAB")) {
             throw new TypeError("publicExponent: Must be [3] or [1,0,1]");
         }
@@ -494,25 +474,19 @@ class RsaProvider extends ProviderCrypto {
 }
 
 class RsaSsaProvider extends RsaProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "RSASSA-PKCS1-v1_5";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-    }
+    name = "RSASSA-PKCS1-v1_5";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
 }
 
 class RsaPssProvider extends RsaProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "RSA-PSS";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-    }
+    name = "RSA-PSS";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "saltLength");
         if (typeof algorithm.saltLength !== "number") {
@@ -525,14 +499,11 @@ class RsaPssProvider extends RsaProvider {
 }
 
 class RsaOaepProvider extends RsaProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "RSA-OAEP";
-        this.usages = {
-            privateKey: ["decrypt", "unwrapKey"],
-            publicKey: ["encrypt", "wrapKey"],
-        };
-    }
+    name = "RSA-OAEP";
+    usages = {
+        privateKey: ["decrypt", "unwrapKey"],
+        publicKey: ["encrypt", "wrapKey"],
+    };
     checkAlgorithmParams(algorithm) {
         if (algorithm.label
             && !(algorithm.label instanceof ArrayBuffer || ArrayBuffer.isView(algorithm.label))) {
@@ -557,16 +528,13 @@ class EllipticProvider extends ProviderCrypto {
 }
 
 class EcdsaProvider extends EllipticProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "ECDSA";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-        this.namedCurves = ["P-256", "P-384", "P-521", "K-256"];
-    }
+    name = "ECDSA";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
+    namedCurves = ["P-256", "P-384", "P-521", "K-256"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
@@ -586,21 +554,20 @@ class CryptoKey {
     static isKeyType(data) {
         return KEY_TYPES.indexOf(data) !== -1;
     }
-    get [Symbol.toStringTag]() {
-        return "CryptoKey";
-    }
+    algorithm;
+    type;
+    usages;
+    extractable;
+    [Symbol.toStringTag] = "CryptoKey";
 }
 
 class EcdhProvider extends EllipticProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "ECDH";
-        this.usages = {
-            privateKey: ["deriveBits", "deriveKey"],
-            publicKey: [],
-        };
-        this.namedCurves = ["P-256", "P-384", "P-521", "K-256"];
-    }
+    name = "ECDH";
+    usages = {
+        privateKey: ["deriveBits", "deriveKey"],
+        publicKey: [],
+    };
+    namedCurves = ["P-256", "P-384", "P-521", "K-256"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "public");
         if (!(algorithm.public instanceof CryptoKey)) {
@@ -616,26 +583,21 @@ class EcdhProvider extends EllipticProvider {
 }
 
 class EcdhEsProvider extends EcdhProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "ECDH-ES";
-        this.namedCurves = ["X25519", "X448"];
-    }
+    name = "ECDH-ES";
+    namedCurves = ["X25519", "X448"];
 }
 
 class EdDsaProvider extends EllipticProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "EdDSA";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-        this.namedCurves = ["Ed25519", "Ed448"];
-    }
+    name = "EdDSA";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
+    namedCurves = ["Ed25519", "Ed448"];
 }
 
 let ObjectIdentifier = class ObjectIdentifier {
+    value;
     constructor(value) {
         if (value) {
             this.value = value;
@@ -650,14 +612,14 @@ ObjectIdentifier = tslib.__decorate([
 ], ObjectIdentifier);
 
 class AlgorithmIdentifier {
+    algorithm;
+    parameters;
     constructor(params) {
         Object.assign(this, params);
     }
 }
 tslib.__decorate([
-    asn1Schema.AsnProp({
-        type: asn1Schema.AsnPropTypes.ObjectIdentifier,
-    })
+    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.ObjectIdentifier })
 ], AlgorithmIdentifier.prototype, "algorithm", void 0);
 tslib.__decorate([
     asn1Schema.AsnProp({
@@ -667,11 +629,10 @@ tslib.__decorate([
 ], AlgorithmIdentifier.prototype, "parameters", void 0);
 
 class PrivateKeyInfo {
-    constructor() {
-        this.version = 0;
-        this.privateKeyAlgorithm = new AlgorithmIdentifier();
-        this.privateKey = new ArrayBuffer(0);
-    }
+    version = 0;
+    privateKeyAlgorithm = new AlgorithmIdentifier();
+    privateKey = new ArrayBuffer(0);
+    attributes;
 }
 tslib.__decorate([
     asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer })
@@ -683,14 +644,14 @@ tslib.__decorate([
     asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.OctetString })
 ], PrivateKeyInfo.prototype, "privateKey", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Any, optional: true })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Any, optional: true,
+    })
 ], PrivateKeyInfo.prototype, "attributes", void 0);
 
 class PublicKeyInfo {
-    constructor() {
-        this.publicKeyAlgorithm = new AlgorithmIdentifier();
-        this.publicKey = new ArrayBuffer(0);
-    }
+    publicKeyAlgorithm = new AlgorithmIdentifier();
+    publicKey = new ArrayBuffer(0);
 }
 tslib.__decorate([
     asn1Schema.AsnProp({ type: AlgorithmIdentifier })
@@ -700,8 +661,8 @@ tslib.__decorate([
 ], PublicKeyInfo.prototype, "publicKey", void 0);
 
 const JsonBase64UrlArrayBufferConverter = {
-    fromJSON: (value) => pvtsutils.Convert.FromBase64Url(value),
-    toJSON: (value) => pvtsutils.Convert.ToBase64Url(new Uint8Array(value)),
+    fromJSON: (value) => bytes__namespace.toArrayBuffer(encoding__namespace.base64url.decode(value)),
+    toJSON: (value) => encoding__namespace.base64url.encode(value),
 };
 
 const AsnIntegerArrayBufferConverter = {
@@ -713,88 +674,129 @@ const AsnIntegerArrayBufferConverter = {
     },
     toASN: (value) => {
         const valueHex = new Uint8Array(value)[0] > 127
-            ? pvtsutils.combine(new Uint8Array([0]).buffer, value)
+            ? bytes__namespace.concat(new Uint8Array([0]).buffer, value)
             : value;
         return new asn1__namespace.Integer({ valueHex });
     },
 };
 
 var index$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AsnIntegerArrayBufferConverter: AsnIntegerArrayBufferConverter,
-  JsonBase64UrlArrayBufferConverter: JsonBase64UrlArrayBufferConverter
+    __proto__: null,
+    AsnIntegerArrayBufferConverter: AsnIntegerArrayBufferConverter,
+    JsonBase64UrlArrayBufferConverter: JsonBase64UrlArrayBufferConverter
 });
 
 class RsaPrivateKey {
-    constructor() {
-        this.version = 0;
-        this.modulus = new ArrayBuffer(0);
-        this.publicExponent = new ArrayBuffer(0);
-        this.privateExponent = new ArrayBuffer(0);
-        this.prime1 = new ArrayBuffer(0);
-        this.prime2 = new ArrayBuffer(0);
-        this.exponent1 = new ArrayBuffer(0);
-        this.exponent2 = new ArrayBuffer(0);
-        this.coefficient = new ArrayBuffer(0);
-    }
+    version = 0;
+    modulus = new ArrayBuffer(0);
+    publicExponent = new ArrayBuffer(0);
+    privateExponent = new ArrayBuffer(0);
+    prime1 = new ArrayBuffer(0);
+    prime2 = new ArrayBuffer(0);
+    exponent1 = new ArrayBuffer(0);
+    exponent2 = new ArrayBuffer(0);
+    coefficient = new ArrayBuffer(0);
+    otherPrimeInfos;
 }
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: asn1Schema.AsnIntegerConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: asn1Schema.AsnIntegerConverter,
+    })
 ], RsaPrivateKey.prototype, "version", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "n", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "n", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "modulus", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "e", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "e", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "publicExponent", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "d", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "d", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "privateExponent", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "p", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "p", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "prime1", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "q", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "q", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "prime2", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "dp", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "dp", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "exponent1", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "dq", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "dq", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "exponent2", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "qi", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "qi", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPrivateKey.prototype, "coefficient", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Any, optional: true })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Any, optional: true,
+    })
 ], RsaPrivateKey.prototype, "otherPrimeInfos", void 0);
 
 class RsaPublicKey {
-    constructor() {
-        this.modulus = new ArrayBuffer(0);
-        this.publicExponent = new ArrayBuffer(0);
-    }
+    modulus = new ArrayBuffer(0);
+    publicExponent = new ArrayBuffer(0);
 }
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "n", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "n", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPublicKey.prototype, "modulus", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter }),
-    jsonSchema.JsonProp({ name: "e", converter: JsonBase64UrlArrayBufferConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter,
+    }),
+    jsonSchema.JsonProp({
+        name: "e", converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], RsaPublicKey.prototype, "publicExponent", void 0);
 
 let EcPublicKey = class EcPublicKey {
+    value = new ArrayBuffer(0);
     constructor(value) {
-        this.value = new ArrayBuffer(0);
         if (value) {
             this.value = value;
         }
@@ -808,8 +810,8 @@ let EcPublicKey = class EcPublicKey {
         const size = bytes.length / 2;
         const offset = 0;
         const json = {
-            x: pvtsutils.Convert.ToBase64Url(bytes.buffer.slice(offset, offset + size)),
-            y: pvtsutils.Convert.ToBase64Url(bytes.buffer.slice(offset + size, offset + size + size)),
+            x: encoding__namespace.base64url.encode(bytes.buffer.slice(offset, offset + size)),
+            y: encoding__namespace.base64url.encode(bytes.buffer.slice(offset + size, offset + size + size)),
         };
         return json;
     }
@@ -820,10 +822,10 @@ let EcPublicKey = class EcPublicKey {
         if (!("y" in json)) {
             throw new Error("y: Missing required property");
         }
-        const x = pvtsutils.Convert.FromBase64Url(json.x);
-        const y = pvtsutils.Convert.FromBase64Url(json.y);
-        const value = pvtsutils.combine(new Uint8Array([0x04]).buffer, x, y);
-        this.value = new Uint8Array(value).buffer;
+        const x = encoding__namespace.base64url.decode(json.x);
+        const y = encoding__namespace.base64url.decode(json.y);
+        const value = bytes__namespace.concat(new Uint8Array([0x04]).buffer, x, y);
+        this.value = bytes__namespace.toArrayBuffer(value);
         return this;
     }
 };
@@ -835,15 +837,15 @@ EcPublicKey = tslib.__decorate([
 ], EcPublicKey);
 
 class EcPrivateKey {
-    constructor() {
-        this.version = 1;
-        this.privateKey = new ArrayBuffer(0);
-    }
+    version = 1;
+    privateKey = new ArrayBuffer(0);
+    parameters;
+    publicKey;
     fromJSON(json) {
         if (!("d" in json)) {
             throw new Error("d: Missing required property");
         }
-        this.privateKey = pvtsutils.Convert.FromBase64Url(json.d);
+        this.privateKey = bytes__namespace.toArrayBuffer(encoding__namespace.base64url.decode(json.d));
         if ("x" in json) {
             const publicKey = new EcPublicKey();
             publicKey.fromJSON(json);
@@ -856,7 +858,7 @@ class EcPrivateKey {
     }
     toJSON() {
         const jwk = {};
-        jwk.d = pvtsutils.Convert.ToBase64Url(this.privateKey);
+        jwk.d = encoding__namespace.base64url.encode(this.privateKey);
         if (this.publicKey) {
             Object.assign(jwk, new EcPublicKey(this.publicKey).toJSON());
         }
@@ -864,44 +866,27 @@ class EcPrivateKey {
     }
 }
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: asn1Schema.AsnIntegerConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: asn1Schema.AsnIntegerConverter,
+    })
 ], EcPrivateKey.prototype, "version", void 0);
 tslib.__decorate([
     asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.OctetString })
 ], EcPrivateKey.prototype, "privateKey", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ context: 0, type: asn1Schema.AsnPropTypes.Any, optional: true })
+    asn1Schema.AsnProp({
+        context: 0, type: asn1Schema.AsnPropTypes.Any, optional: true,
+    })
 ], EcPrivateKey.prototype, "parameters", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ context: 1, type: asn1Schema.AsnPropTypes.BitString, optional: true })
+    asn1Schema.AsnProp({
+        context: 1, type: asn1Schema.AsnPropTypes.BitString, optional: true,
+    })
 ], EcPrivateKey.prototype, "publicKey", void 0);
 
-const AsnIntegerWithoutPaddingConverter = {
-    fromASN: (value) => {
-        const bytes = new Uint8Array(value.valueBlock.valueHex);
-        return (bytes[0] === 0)
-            ? bytes.buffer.slice(1)
-            : bytes.buffer;
-    },
-    toASN: (value) => {
-        const bytes = new Uint8Array(value);
-        if (bytes[0] > 127) {
-            const newValue = new Uint8Array(bytes.length + 1);
-            newValue.set(bytes, 1);
-            return new asn1__namespace.Integer({ valueHex: newValue.buffer });
-        }
-        return new asn1__namespace.Integer({ valueHex: value });
-    },
-};
-
-var index$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AsnIntegerWithoutPaddingConverter: AsnIntegerWithoutPaddingConverter
-});
-
 class EcUtils {
     static decodePoint(data, pointSize) {
-        const view = pvtsutils.BufferSourceConverter.toUint8Array(data);
+        const view = bytes__namespace.toUint8Array(data);
         if ((view.length === 0) || (view[0] !== 4)) {
             throw new Error("Only uncompressed point format supported");
         }
@@ -911,15 +896,17 @@ class EcUtils {
         }
         const xb = view.slice(1, n + 1);
         const yb = view.slice(n + 1, n + 1 + n);
-        return { x: xb, y: yb };
+        return {
+            x: xb, y: yb,
+        };
     }
     static encodePoint(point, pointSize) {
         const size = Math.ceil(pointSize / 8);
         if (point.x.byteLength !== size || point.y.byteLength !== size) {
             throw new Error("X,Y coordinates don't match point size criteria");
         }
-        const x = pvtsutils.BufferSourceConverter.toUint8Array(point.x);
-        const y = pvtsutils.BufferSourceConverter.toUint8Array(point.y);
+        const x = bytes__namespace.toUint8Array(point.x);
+        const y = bytes__namespace.toUint8Array(point.y);
         const res = new Uint8Array(size * 2 + 1);
         res[0] = 4;
         res.set(x, 1);
@@ -931,8 +918,8 @@ class EcUtils {
     }
     static encodeSignature(signature, pointSize) {
         const size = this.getSize(pointSize);
-        const r = pvtsutils.BufferSourceConverter.toUint8Array(signature.r);
-        const s = pvtsutils.BufferSourceConverter.toUint8Array(signature.s);
+        const r = bytes__namespace.toUint8Array(signature.r);
+        const s = bytes__namespace.toUint8Array(signature.s);
         const res = new Uint8Array(size * 2);
         res.set(this.padStart(r, size));
         res.set(this.padStart(s, size), size);
@@ -940,15 +927,15 @@ class EcUtils {
     }
     static decodeSignature(data, pointSize) {
         const size = this.getSize(pointSize);
-        const view = pvtsutils.BufferSourceConverter.toUint8Array(data);
+        const view = bytes__namespace.toUint8Array(data);
         if (view.length !== (size * 2)) {
             throw new Error("Incorrect size of the signature");
         }
         const r = view.slice(0, size);
         const s = view.slice(size);
         return {
-            r: this.trimStart(r),
-            s: this.trimStart(s),
+            r: bytes__namespace.toArrayBuffer(this.trimStart(r)),
+            s: bytes__namespace.toArrayBuffer(this.trimStart(s)),
         };
     }
     static trimStart(data) {
@@ -971,19 +958,40 @@ class EcUtils {
     }
 }
 
+const AsnIntegerWithoutPaddingConverter = {
+    fromASN: (value) => {
+        const bytes = new Uint8Array(value.valueBlock.valueHex);
+        return (bytes[0] === 0)
+            ? bytes.buffer.slice(1)
+            : bytes.buffer;
+    },
+    toASN: (value) => {
+        const bytes = new Uint8Array(value);
+        if (bytes[0] > 127) {
+            const newValue = new Uint8Array(bytes.length + 1);
+            newValue.set(bytes, 1);
+            return new asn1__namespace.Integer({ valueHex: newValue.buffer });
+        }
+        return new asn1__namespace.Integer({ valueHex: value });
+    },
+};
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AsnIntegerWithoutPaddingConverter: AsnIntegerWithoutPaddingConverter
+});
+
 class EcDsaSignature {
-    constructor() {
-        this.r = new ArrayBuffer(0);
-        this.s = new ArrayBuffer(0);
-    }
     static fromWebCryptoSignature(value) {
         const pointSize = value.byteLength / 2;
         const point = EcUtils.decodeSignature(value, pointSize * 8);
         const ecSignature = new EcDsaSignature();
-        ecSignature.r = pvtsutils.BufferSourceConverter.toArrayBuffer(point.r);
-        ecSignature.s = pvtsutils.BufferSourceConverter.toArrayBuffer(point.s);
+        ecSignature.r = bytes__namespace.toArrayBuffer(point.r);
+        ecSignature.s = bytes__namespace.toArrayBuffer(point.s);
         return ecSignature;
     }
+    r = new ArrayBuffer(0);
+    s = new ArrayBuffer(0);
     toWebCryptoSignature(pointSize) {
         if (!pointSize) {
             const maxPointLength = Math.max(this.r.byteLength, this.s.byteLength);
@@ -998,37 +1006,40 @@ class EcDsaSignature {
             }
         }
         const signature = EcUtils.encodeSignature(this, pointSize);
-        return signature.buffer;
+        return bytes__namespace.toArrayBuffer(signature);
     }
 }
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter,
+    })
 ], EcDsaSignature.prototype, "r", void 0);
 tslib.__decorate([
-    asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter })
+    asn1Schema.AsnProp({
+        type: asn1Schema.AsnPropTypes.Integer, converter: AsnIntegerWithoutPaddingConverter,
+    })
 ], EcDsaSignature.prototype, "s", void 0);
 
 class OneAsymmetricKey extends PrivateKeyInfo {
+    publicKey;
 }
 tslib.__decorate([
-    asn1Schema.AsnProp({ context: 1, implicit: true, type: asn1Schema.AsnPropTypes.BitString, optional: true })
+    asn1Schema.AsnProp({
+        context: 1, implicit: true, type: asn1Schema.AsnPropTypes.BitString, optional: true,
+    })
 ], OneAsymmetricKey.prototype, "publicKey", void 0);
 
 let EdPrivateKey = class EdPrivateKey {
-    constructor() {
-        this.value = new ArrayBuffer(0);
-    }
+    value = new ArrayBuffer(0);
     fromJSON(json) {
         if (!json.d) {
             throw new Error("d: Missing required property");
         }
-        this.value = pvtsutils.Convert.FromBase64Url(json.d);
+        this.value = bytes__namespace.toArrayBuffer(encoding__namespace.base64url.decode(json.d));
         return this;
     }
     toJSON() {
-        const jwk = {
-            d: pvtsutils.Convert.ToBase64Url(this.value),
-        };
+        const jwk = { d: encoding__namespace.base64url.encode(this.value) };
         return jwk;
     }
 };
@@ -1040,23 +1051,21 @@ EdPrivateKey = tslib.__decorate([
 ], EdPrivateKey);
 
 let EdPublicKey = class EdPublicKey {
+    value = new ArrayBuffer(0);
     constructor(value) {
-        this.value = new ArrayBuffer(0);
         if (value) {
             this.value = value;
         }
     }
     toJSON() {
-        const json = {
-            x: pvtsutils.Convert.ToBase64Url(this.value),
-        };
+        const json = { x: encoding__namespace.base64url.encode(this.value) };
         return json;
     }
     fromJSON(json) {
         if (!("x" in json)) {
             throw new Error("x: Missing required property");
         }
-        this.value = pvtsutils.Convert.FromBase64Url(json.x);
+        this.value = bytes__namespace.toArrayBuffer(encoding__namespace.base64url.decode(json.x));
         return this;
     }
 };
@@ -1068,10 +1077,13 @@ EdPublicKey = tslib.__decorate([
 ], EdPublicKey);
 
 let CurvePrivateKey = class CurvePrivateKey {
+    d;
 };
 tslib.__decorate([
     asn1Schema.AsnProp({ type: asn1Schema.AsnPropTypes.OctetString }),
-    jsonSchema.JsonProp({ type: jsonSchema.JsonPropTypes.String, converter: JsonBase64UrlArrayBufferConverter })
+    jsonSchema.JsonProp({
+        type: jsonSchema.JsonPropTypes.String, converter: JsonBase64UrlArrayBufferConverter,
+    })
 ], CurvePrivateKey.prototype, "d", void 0);
 CurvePrivateKey = tslib.__decorate([
     asn1Schema.AsnType({ type: asn1Schema.AsnTypeTypes.Choice })
@@ -1103,49 +1115,50 @@ const idEd25519 = "1.3.101.112";
 const idEd448 = "1.3.101.113";
 
 var index$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AlgorithmIdentifier: AlgorithmIdentifier,
-  get CurvePrivateKey () { return CurvePrivateKey; },
-  EcDsaSignature: EcDsaSignature,
-  EcPrivateKey: EcPrivateKey,
-  get EcPublicKey () { return EcPublicKey; },
-  get EdPrivateKey () { return EdPrivateKey; },
-  get EdPublicKey () { return EdPublicKey; },
-  get ObjectIdentifier () { return ObjectIdentifier; },
-  OneAsymmetricKey: OneAsymmetricKey,
-  PrivateKeyInfo: PrivateKeyInfo,
-  PublicKeyInfo: PublicKeyInfo,
-  RsaPrivateKey: RsaPrivateKey,
-  RsaPublicKey: RsaPublicKey,
-  converters: index$2,
-  idBrainpoolP160r1: idBrainpoolP160r1,
-  idBrainpoolP160t1: idBrainpoolP160t1,
-  idBrainpoolP192r1: idBrainpoolP192r1,
-  idBrainpoolP192t1: idBrainpoolP192t1,
-  idBrainpoolP224r1: idBrainpoolP224r1,
-  idBrainpoolP224t1: idBrainpoolP224t1,
-  idBrainpoolP256r1: idBrainpoolP256r1,
-  idBrainpoolP256t1: idBrainpoolP256t1,
-  idBrainpoolP320r1: idBrainpoolP320r1,
-  idBrainpoolP320t1: idBrainpoolP320t1,
-  idBrainpoolP384r1: idBrainpoolP384r1,
-  idBrainpoolP384t1: idBrainpoolP384t1,
-  idBrainpoolP512r1: idBrainpoolP512r1,
-  idBrainpoolP512t1: idBrainpoolP512t1,
-  idEd25519: idEd25519,
-  idEd448: idEd448,
-  idEllipticCurve: idEllipticCurve,
-  idSecp256k1: idSecp256k1,
-  idSecp256r1: idSecp256r1,
-  idSecp384r1: idSecp384r1,
-  idSecp521r1: idSecp521r1,
-  idVersionOne: idVersionOne,
-  idX25519: idX25519,
-  idX448: idX448
+    __proto__: null,
+    AlgorithmIdentifier: AlgorithmIdentifier,
+    get CurvePrivateKey () { return CurvePrivateKey; },
+    EcDsaSignature: EcDsaSignature,
+    EcPrivateKey: EcPrivateKey,
+    get EcPublicKey () { return EcPublicKey; },
+    get EdPrivateKey () { return EdPrivateKey; },
+    get EdPublicKey () { return EdPublicKey; },
+    get ObjectIdentifier () { return ObjectIdentifier; },
+    OneAsymmetricKey: OneAsymmetricKey,
+    PrivateKeyInfo: PrivateKeyInfo,
+    PublicKeyInfo: PublicKeyInfo,
+    RsaPrivateKey: RsaPrivateKey,
+    RsaPublicKey: RsaPublicKey,
+    converters: index$2,
+    idBrainpoolP160r1: idBrainpoolP160r1,
+    idBrainpoolP160t1: idBrainpoolP160t1,
+    idBrainpoolP192r1: idBrainpoolP192r1,
+    idBrainpoolP192t1: idBrainpoolP192t1,
+    idBrainpoolP224r1: idBrainpoolP224r1,
+    idBrainpoolP224t1: idBrainpoolP224t1,
+    idBrainpoolP256r1: idBrainpoolP256r1,
+    idBrainpoolP256t1: idBrainpoolP256t1,
+    idBrainpoolP320r1: idBrainpoolP320r1,
+    idBrainpoolP320t1: idBrainpoolP320t1,
+    idBrainpoolP384r1: idBrainpoolP384r1,
+    idBrainpoolP384t1: idBrainpoolP384t1,
+    idBrainpoolP512r1: idBrainpoolP512r1,
+    idBrainpoolP512t1: idBrainpoolP512t1,
+    idEd25519: idEd25519,
+    idEd448: idEd448,
+    idEllipticCurve: idEllipticCurve,
+    idSecp256k1: idSecp256k1,
+    idSecp256r1: idSecp256r1,
+    idSecp384r1: idSecp384r1,
+    idSecp521r1: idSecp521r1,
+    idVersionOne: idVersionOne,
+    idX25519: idX25519,
+    idX448: idX448
 });
 
 class EcCurves {
-    constructor() { }
+    static items = [];
+    static names = [];
     static register(item) {
         const oid = new ObjectIdentifier();
         oid.value = item.id;
@@ -1173,59 +1186,84 @@ class EcCurves {
         return res;
     }
 }
-EcCurves.items = [];
-EcCurves.names = [];
-EcCurves.register({ name: "P-256", id: idSecp256r1, size: 256 });
-EcCurves.register({ name: "P-384", id: idSecp384r1, size: 384 });
-EcCurves.register({ name: "P-521", id: idSecp521r1, size: 521 });
-EcCurves.register({ name: "K-256", id: idSecp256k1, size: 256 });
-EcCurves.register({ name: "brainpoolP160r1", id: idBrainpoolP160r1, size: 160 });
-EcCurves.register({ name: "brainpoolP160t1", id: idBrainpoolP160t1, size: 160 });
-EcCurves.register({ name: "brainpoolP192r1", id: idBrainpoolP192r1, size: 192 });
-EcCurves.register({ name: "brainpoolP192t1", id: idBrainpoolP192t1, size: 192 });
-EcCurves.register({ name: "brainpoolP224r1", id: idBrainpoolP224r1, size: 224 });
-EcCurves.register({ name: "brainpoolP224t1", id: idBrainpoolP224t1, size: 224 });
-EcCurves.register({ name: "brainpoolP256r1", id: idBrainpoolP256r1, size: 256 });
-EcCurves.register({ name: "brainpoolP256t1", id: idBrainpoolP256t1, size: 256 });
-EcCurves.register({ name: "brainpoolP320r1", id: idBrainpoolP320r1, size: 320 });
-EcCurves.register({ name: "brainpoolP320t1", id: idBrainpoolP320t1, size: 320 });
-EcCurves.register({ name: "brainpoolP384r1", id: idBrainpoolP384r1, size: 384 });
-EcCurves.register({ name: "brainpoolP384t1", id: idBrainpoolP384t1, size: 384 });
-EcCurves.register({ name: "brainpoolP512r1", id: idBrainpoolP512r1, size: 512 });
-EcCurves.register({ name: "brainpoolP512t1", id: idBrainpoolP512t1, size: 512 });
+EcCurves.register({
+    name: "P-256", id: idSecp256r1, size: 256,
+});
+EcCurves.register({
+    name: "P-384", id: idSecp384r1, size: 384,
+});
+EcCurves.register({
+    name: "P-521", id: idSecp521r1, size: 521,
+});
+EcCurves.register({
+    name: "K-256", id: idSecp256k1, size: 256,
+});
+EcCurves.register({
+    name: "brainpoolP160r1", id: idBrainpoolP160r1, size: 160,
+});
+EcCurves.register({
+    name: "brainpoolP160t1", id: idBrainpoolP160t1, size: 160,
+});
+EcCurves.register({
+    name: "brainpoolP192r1", id: idBrainpoolP192r1, size: 192,
+});
+EcCurves.register({
+    name: "brainpoolP192t1", id: idBrainpoolP192t1, size: 192,
+});
+EcCurves.register({
+    name: "brainpoolP224r1", id: idBrainpoolP224r1, size: 224,
+});
+EcCurves.register({
+    name: "brainpoolP224t1", id: idBrainpoolP224t1, size: 224,
+});
+EcCurves.register({
+    name: "brainpoolP256r1", id: idBrainpoolP256r1, size: 256,
+});
+EcCurves.register({
+    name: "brainpoolP256t1", id: idBrainpoolP256t1, size: 256,
+});
+EcCurves.register({
+    name: "brainpoolP320r1", id: idBrainpoolP320r1, size: 320,
+});
+EcCurves.register({
+    name: "brainpoolP320t1", id: idBrainpoolP320t1, size: 320,
+});
+EcCurves.register({
+    name: "brainpoolP384r1", id: idBrainpoolP384r1, size: 384,
+});
+EcCurves.register({
+    name: "brainpoolP384t1", id: idBrainpoolP384t1, size: 384,
+});
+EcCurves.register({
+    name: "brainpoolP512r1", id: idBrainpoolP512r1, size: 512,
+});
+EcCurves.register({
+    name: "brainpoolP512t1", id: idBrainpoolP512t1, size: 512,
+});
 
 class X25519Provider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "X25519";
-        this.usages = {
-            privateKey: ["deriveKey", "deriveBits"],
-            publicKey: [],
-        };
-    }
+    name = "X25519";
+    usages = {
+        privateKey: ["deriveKey", "deriveBits"],
+        publicKey: [],
+    };
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "public");
     }
 }
 
 class Ed25519Provider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "Ed25519";
-        this.usages = {
-            privateKey: ["sign"],
-            publicKey: ["verify"],
-        };
-    }
+    name = "Ed25519";
+    usages = {
+        privateKey: ["sign"],
+        publicKey: ["verify"],
+    };
 }
 
 class HmacProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "HMAC";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = ["sign", "verify"];
-    }
+    name = "HMAC";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = ["sign", "verify"];
     getDefaultLength(algName) {
         switch (algName.toUpperCase()) {
             case "SHA-1":
@@ -1256,12 +1294,9 @@ class HmacProvider extends ProviderCrypto {
 }
 
 class Pbkdf2Provider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "PBKDF2";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = ["deriveBits", "deriveKey"];
-    }
+    name = "PBKDF2";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = ["deriveBits", "deriveKey"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
@@ -1286,22 +1321,19 @@ class Pbkdf2Provider extends ProviderCrypto {
 }
 
 class HkdfProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.name = "HKDF";
-        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
-        this.usages = ["deriveKey", "deriveBits"];
-    }
+    name = "HKDF";
+    hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+    usages = ["deriveKey", "deriveBits"];
     checkAlgorithmParams(algorithm) {
         this.checkRequiredProperty(algorithm, "hash");
         this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
         this.checkRequiredProperty(algorithm, "salt");
-        if (!pvtsutils.BufferSourceConverter.isBufferSource(algorithm.salt)) {
+        if (!bytes__namespace.isBufferSource(algorithm.salt)) {
             throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
         }
         this.checkRequiredProperty(algorithm, "info");
-        if (!pvtsutils.BufferSourceConverter.isBufferSource(algorithm.info)) {
-            throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
+        if (!bytes__namespace.isBufferSource(algorithm.info)) {
+            throw new TypeError("info: Is not of type '(ArrayBuffer or ArrayBufferView)'");
         }
     }
     checkImportKey(format, keyData, algorithm, extractable, keyUsages, ...args) {
@@ -1313,13 +1345,12 @@ class HkdfProvider extends ProviderCrypto {
 }
 
 class ShakeProvider extends ProviderCrypto {
-    constructor() {
-        super(...arguments);
-        this.usages = [];
-        this.defaultLength = 0;
-    }
+    usages = [];
+    defaultLength = 0;
     digest(...args) {
-        args[0] = { length: this.defaultLength, ...args[0] };
+        args[0] = {
+            length: this.defaultLength, ...args[0],
+        };
         return super.digest.apply(this, args);
     }
     checkDigest(algorithm, data) {
@@ -1335,38 +1366,28 @@ class ShakeProvider extends ProviderCrypto {
 }
 
 class Shake128Provider extends ShakeProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "shake128";
-        this.defaultLength = 16;
-    }
+    name = "shake128";
+    defaultLength = 16;
 }
 
 class Shake256Provider extends ShakeProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "shake256";
-        this.defaultLength = 32;
-    }
+    name = "shake256";
+    defaultLength = 32;
 }
 
 class Crypto {
-    get [Symbol.toStringTag]() {
-        return "Crypto";
-    }
+    [Symbol.toStringTag] = "Crypto";
     randomUUID() {
         const b = this.getRandomValues(new Uint8Array(16));
         b[6] = (b[6] & 0x0f) | 0x40;
         b[8] = (b[8] & 0x3f) | 0x80;
-        const uuid = pvtsutils.Convert.ToHex(b).toLowerCase();
+        const uuid = encoding__namespace.hex.encode(b, { case: "lower" });
         return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20)}`;
     }
 }
 
 class ProviderStorage {
-    constructor() {
-        this.items = {};
-    }
+    items = {};
     get(algorithmName) {
         return this.items[algorithmName.toLowerCase()] || null;
     }
@@ -1397,16 +1418,13 @@ class ProviderStorage {
 }
 
 const keyFormatMap = {
-    "jwk": ["private", "public", "secret"],
-    "pkcs8": ["private"],
-    "spki": ["public"],
-    "raw": ["secret", "public"]
+    jwk: ["private", "public", "secret"],
+    pkcs8: ["private"],
+    spki: ["public"],
+    raw: ["secret", "public"],
 };
 const sourceBufferKeyFormats = ["pkcs8", "spki", "raw"];
 class SubtleCrypto {
-    constructor() {
-        this.providers = new ProviderStorage();
-    }
     static isHashedAlgorithm(data) {
         return data
             && typeof data === "object"
@@ -1415,14 +1433,13 @@ class SubtleCrypto {
             ? true
             : false;
     }
-    get [Symbol.toStringTag]() {
-        return "SubtleCrypto";
-    }
+    providers = new ProviderStorage();
+    [Symbol.toStringTag] = "SubtleCrypto";
     async digest(...args) {
         this.checkRequiredArguments(args, 2, "digest");
         const [algorithm, data, ...params] = args;
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes__namespace.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
         const result = await provider.digest(preparedAlgorithm, preparedData, ...params);
         return result;
@@ -1432,7 +1449,9 @@ class SubtleCrypto {
         const [algorithm, extractable, keyUsages, ...params] = args;
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.generateKey({ ...preparedAlgorithm, name: provider.name }, extractable, keyUsages, ...params);
+        const result = await provider.generateKey({
+            ...preparedAlgorithm, name: provider.name,
+        }, extractable, keyUsages, ...params);
         return result;
     }
     async sign(...args) {
@@ -1440,9 +1459,11 @@ class SubtleCrypto {
         const [algorithm, key, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes__namespace.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.sign({ ...preparedAlgorithm, name: provider.name }, key, preparedData, ...params);
+        const result = await provider.sign({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedData, ...params);
         return result;
     }
     async verify(...args) {
@@ -1450,10 +1471,12 @@ class SubtleCrypto {
         const [algorithm, key, signature, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(data);
-        const preparedSignature = pvtsutils.BufferSourceConverter.toArrayBuffer(signature);
+        const preparedData = bytes__namespace.toArrayBuffer(data);
+        const preparedSignature = bytes__namespace.toArrayBuffer(signature);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.verify({ ...preparedAlgorithm, name: provider.name }, key, preparedSignature, preparedData, ...params);
+        const result = await provider.verify({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedSignature, preparedData, ...params);
         return result;
     }
     async encrypt(...args) {
@@ -1461,9 +1484,11 @@ class SubtleCrypto {
         const [algorithm, key, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes__namespace.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.encrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true }, ...params);
+        const result = await provider.encrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedData, { keyUsage: true }, ...params);
         return result;
     }
     async decrypt(...args) {
@@ -1471,9 +1496,11 @@ class SubtleCrypto {
         const [algorithm, key, data, ...params] = args;
         this.checkCryptoKey(key);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(data);
+        const preparedData = bytes__namespace.toArrayBuffer(data);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true }, ...params);
+        const result = await provider.decrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, key, preparedData, { keyUsage: true }, ...params);
         return result;
     }
     async deriveBits(...args) {
@@ -1482,7 +1509,9 @@ class SubtleCrypto {
         this.checkCryptoKey(baseKey);
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
         const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, length, { keyUsage: true }, ...params);
+        const result = await provider.deriveBits({
+            ...preparedAlgorithm, name: provider.name,
+        }, baseKey, length, { keyUsage: true }, ...params);
         return result;
     }
     async deriveKey(...args) {
@@ -1494,7 +1523,9 @@ class SubtleCrypto {
         const preparedAlgorithm = this.prepareAlgorithm(algorithm);
         const provider = this.getProvider(preparedAlgorithm.name);
         provider.checkCryptoKey(baseKey, "deriveKey");
-        const derivedBits = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, derivedKeyType.length || 512, { keyUsage: false }, ...params);
+        const derivedBits = await provider.deriveBits({
+            ...preparedAlgorithm, name: provider.name,
+        }, baseKey, derivedKeyType.length || 512, { keyUsage: false }, ...params);
         return this.importKey("raw", derivedBits, derivedKeyType, extractable, keyUsages, ...params);
     }
     async exportKey(...args) {
@@ -1522,34 +1553,40 @@ class SubtleCrypto {
             }
         }
         else if (sourceBufferKeyFormats.includes(format)) {
-            if (!pvtsutils.BufferSourceConverter.isBufferSource(keyData)) {
+            if (!bytes__namespace.isBufferSource(keyData)) {
                 throw new TypeError("Key data must be a BufferSource for non-JWK formats");
             }
         }
         else {
             throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView or JsonWebKey)'");
         }
-        return provider.importKey(format, keyData, { ...preparedAlgorithm, name: provider.name }, extractable, keyUsages, ...params);
+        return provider.importKey(format, keyData, {
+            ...preparedAlgorithm, name: provider.name,
+        }, extractable, keyUsages, ...params);
     }
     async wrapKey(format, key, wrappingKey, wrapAlgorithm, ...args) {
         let keyData = await this.exportKey(format, key, ...args);
         if (format === "jwk") {
             const json = JSON.stringify(keyData);
-            keyData = pvtsutils.Convert.FromUtf8String(json);
+            keyData = bytes__namespace.toArrayBuffer(encoding__namespace.utf8.encode(json));
         }
         const preparedAlgorithm = this.prepareAlgorithm(wrapAlgorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(keyData);
+        const preparedData = bytes__namespace.toArrayBuffer(keyData);
         const provider = this.getProvider(preparedAlgorithm.name);
-        return provider.encrypt({ ...preparedAlgorithm, name: provider.name }, wrappingKey, preparedData, { keyUsage: false }, ...args);
+        return provider.encrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, wrappingKey, preparedData, { keyUsage: false }, ...args);
     }
     async unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages, ...args) {
         const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
-        const preparedData = pvtsutils.BufferSourceConverter.toArrayBuffer(wrappedKey);
+        const preparedData = bytes__namespace.toArrayBuffer(wrappedKey);
         const provider = this.getProvider(preparedAlgorithm.name);
-        let keyData = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, unwrappingKey, preparedData, { keyUsage: false }, ...args);
+        let keyData = await provider.decrypt({
+            ...preparedAlgorithm, name: provider.name,
+        }, unwrappingKey, preparedData, { keyUsage: false }, ...args);
         if (format === "jwk") {
             try {
-                keyData = JSON.parse(pvtsutils.Convert.ToUtf8String(keyData));
+                keyData = JSON.parse(encoding__namespace.utf8.decode(keyData));
             }
             catch (e) {
                 const error = new TypeError("wrappedKey: Is not a JSON");
@@ -1566,9 +1603,7 @@ class SubtleCrypto {
     }
     prepareAlgorithm(algorithm) {
         if (typeof algorithm === "string") {
-            return {
-                name: algorithm,
-            };
+            return { name: algorithm };
         }
         if (SubtleCrypto.isHashedAlgorithm(algorithm)) {
             const preparedAlgorithm = { ...algorithm };
@@ -1586,26 +1621,26 @@ class SubtleCrypto {
     }
     checkCryptoKey(key) {
         if (!(key instanceof CryptoKey)) {
-            throw new TypeError(`Key is not of type 'CryptoKey'`);
+            throw new TypeError("Key is not of type 'CryptoKey'");
         }
     }
 }
 
 var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  converters: index$3
+    __proto__: null,
+    converters: index$3
 });
 
 const REQUIRED_FIELDS = ["crv", "e", "k", "kty", "n", "x", "y"];
 class JwkUtils {
     static async thumbprint(hash, jwk, crypto) {
         const data = this.format(jwk, true);
-        return crypto.subtle.digest(hash, pvtsutils.Convert.FromBinary(JSON.stringify(data)));
+        return crypto.subtle.digest(hash, bytes__namespace.toArrayBuffer(encoding__namespace.binary.decode(JSON.stringify(data))));
     }
     static format(jwk, remove = false) {
         let res = Object.entries(jwk);
         if (remove) {
-            res = res.filter(o => REQUIRED_FIELDS.includes(o[0]));
+            res = res.filter((o) => REQUIRED_FIELDS.includes(o[0]));
         }
         res = res.sort(([keyA], [keyB]) => keyA > keyB ? 1 : keyA < keyB ? -1 : 0);
         return Object.fromEntries(res);
@@ -1613,8 +1648,8 @@ class JwkUtils {
 }
 
 Object.defineProperty(exports, "BufferSourceConverter", {
-  enumerable: true,
-  get: function () { return pvtsutils.BufferSourceConverter; }
+    enumerable: true,
+    get: function () { return legacy.BufferSourceConverter; }
 });
 exports.AesCbcProvider = AesCbcProvider;
 exports.AesCmacProvider = AesCmacProvider;