*prettier format

src/keys/asymmetric.ts

@@ -1,8 +1,6 @@
 import { CryptoKey } from "./key";
 
 export abstract class AsymmetricKey extends CryptoKey {
-
   public abstract override type: "public" | "private";
   public pem?: string;
-
 }

src/keys/symmetric.ts

@@ -1,8 +1,6 @@
 import { CryptoKey } from "./key";
 
 export class SymmetricKey extends CryptoKey {
-
   public override readonly kty = "oct";
   public override readonly type = "secret" as const;
-
 }

src/mechs/aes/aes_cbc.ts

@@ -4,33 +4,68 @@ import { AesCryptoKey } from "./key";
 import { getCryptoKey, setCryptoKey } from "../storage";
 
 export class AesCbcProvider extends core.AesCbcProvider {
-
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: AesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+    algorithm: AesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
     const key = await AesCrypto.generateKey(
       {
         name: this.name,
         length: algorithm.length,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return setCryptoKey(key);
   }
 
-  public async onEncrypt(algorithm: Algorithm, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onEncrypt(
-    return AesCrypto.encrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onDecrypt(algorithm: Algorithm, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onDecrypt(
-    return AesCrypto.decrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: AesCryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: AesCryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return AesCrypto.exportKey(format, getCryptoKey(key) as AesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const key = await AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const key = await AesCrypto.importKey(
+      format,
+      keyData,
+      { name: algorithm.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
 

src/mechs/aes/aes_ctr.ts

@@ -4,33 +4,68 @@ import { AesCryptoKey } from "./key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class AesCtrProvider extends core.AesCtrProvider {
-
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: AesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+    algorithm: AesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
     const key = await AesCrypto.generateKey(
       {
         name: this.name,
         length: algorithm.length,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return setCryptoKey(key);
   }
 
-  public async onEncrypt(algorithm: AesCtrParams, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onEncrypt(
-    return AesCrypto.encrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: AesCtrParams,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onDecrypt(algorithm: AesCtrParams, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onDecrypt(
-    return AesCrypto.decrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: AesCtrParams,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: AesCryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: AesCryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return AesCrypto.exportKey(format, getCryptoKey(key) as AesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const res = await AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const res = await AesCrypto.importKey(
+      format,
+      keyData,
+      { name: algorithm.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(res);
   }
 

src/mechs/aes/aes_ecb.ts

@@ -4,33 +4,68 @@ import { AesCryptoKey } from "./key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class AesEcbProvider extends core.AesEcbProvider {
-
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: AesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+    algorithm: AesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
     const key = await AesCrypto.generateKey(
       {
         name: this.name,
         length: algorithm.length,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return setCryptoKey(key);
   }
 
-  public async onEncrypt(algorithm: Algorithm, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onEncrypt(
-    return AesCrypto.encrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onDecrypt(algorithm: Algorithm, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onDecrypt(
-    return AesCrypto.decrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: AesCryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: AesCryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return AesCrypto.exportKey(format, getCryptoKey(key) as AesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const res = await AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const res = await AesCrypto.importKey(
+      format,
+      keyData,
+      { name: algorithm.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(res);
   }
 

src/mechs/aes/aes_gcm.ts

@@ -4,33 +4,68 @@ import { AesCryptoKey } from "./key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class AesGcmProvider extends core.AesGcmProvider {
-
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: AesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+    algorithm: AesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
     const key = await AesCrypto.generateKey(
       {
         name: this.name,
         length: algorithm.length,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return setCryptoKey(key);
   }
 
-  public async onEncrypt(algorithm: AesGcmParams, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onEncrypt(
-    return AesCrypto.encrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: AesGcmParams,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onDecrypt(algorithm: AesGcmParams, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onDecrypt(
-    return AesCrypto.decrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: AesGcmParams,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: AesCryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: AesCryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return AesCrypto.exportKey(format, getCryptoKey(key) as AesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const res = await AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const res = await AesCrypto.importKey(
+      format,
+      keyData,
+      { name: algorithm.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(res);
   }
 

src/mechs/aes/aes_kw.ts

@@ -4,34 +4,68 @@ import { AesCryptoKey } from "./key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class AesKwProvider extends core.AesKwProvider {
-
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: AesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+    algorithm: AesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
     const res = await AesCrypto.generateKey(
       {
         name: this.name,
         length: algorithm.length,
       },
       extractable,
-      keyUsages,
+      keyUsages
     );
     return setCryptoKey(res);
   }
 
-  public async onExportKey(format: KeyFormat, key: AesCryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: AesCryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return AesCrypto.exportKey(format, getCryptoKey(key) as AesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const res = await AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const res = await AesCrypto.importKey(
+      format,
+      keyData,
+      { name: algorithm.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(res);
   }
 
-  public override async onEncrypt(algorithm: Algorithm, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onEncrypt(
-    return AesCrypto.encrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public override async onDecrypt(algorithm: Algorithm, key: AesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDecrypt(
-    return AesCrypto.decrypt(algorithm, getCryptoKey(key) as AesCryptoKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: AesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return AesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as AesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
   public override checkCryptoKey(key: CryptoKey, keyUsage?: KeyUsage) {

src/mechs/aes/key.ts

@@ -4,7 +4,6 @@ import { JsonBase64UrlConverter } from "../../converters";
 import { SymmetricKey } from "../../keys";
 
 export class AesCryptoKey extends SymmetricKey {
-
   public override algorithm!: AesKeyAlgorithm;
 
   @JsonProp({ name: "k", converter: JsonBase64UrlConverter })
@@ -34,5 +33,4 @@ export class AesCryptoKey extends SymmetricKey {
   public override set alg(value: string) {
     // nothing, cause set is needed for json-schema, but is not used by module
   }
-
 }

src/mechs/des/des_cbc.ts

@@ -7,38 +7,73 @@ import { setCryptoKey, getCryptoKey } from "../storage";
 export type DesCbcParams = core.DesParams;
 
 export class DesCbcProvider extends core.DesProvider {
-
   public keySizeBits = 64;
   public ivSize = 8;
   public name = "DES-CBC";
 
-  public async onGenerateKey(algorithm: core.DesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onGenerateKey(
+    algorithm: core.DesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
     const key = await DesCrypto.generateKey(
       {
         name: this.name,
         length: this.keySizeBits,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return setCryptoKey(key);
   }
 
-  public async onEncrypt(algorithm: DesCbcParams, key: DesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onEncrypt(
-    return DesCrypto.encrypt(algorithm, getCryptoKey(key) as DesCryptoKey, new Uint8Array(data));
+    algorithm: DesCbcParams,
+    key: DesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return DesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as DesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onDecrypt(algorithm: DesCbcParams, key: DesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onDecrypt(
-    return DesCrypto.decrypt(algorithm, getCryptoKey(key) as DesCryptoKey, new Uint8Array(data));
+    algorithm: DesCbcParams,
+    key: DesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return DesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as DesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return DesCrypto.exportKey(format, getCryptoKey(key) as DesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onImportKey(
-    const key = await DesCrypto.importKey(format, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
+    format: KeyFormat,
-    if (key.data.length !== (this.keySizeBits >> 3)) {
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
+    const key = await DesCrypto.importKey(
+      format,
+      keyData,
+      { name: this.name, length: this.keySizeBits },
+      extractable,
+      keyUsages
+    );
+    if (key.data.length !== this.keySizeBits >> 3) {
       throw new core.OperationError("keyData: Wrong key size");
     }
     return setCryptoKey(key);
@@ -50,5 +85,4 @@ export class DesCbcProvider extends core.DesProvider {
       throw new TypeError("key: Is not a DesCryptoKey");
     }
   }
-
 }

src/mechs/des/des_ede3_cbc.ts

@@ -7,38 +7,73 @@ import { setCryptoKey, getCryptoKey } from "../storage";
 export type DesEde3CbcParams = core.DesParams;
 
 export class DesEde3CbcProvider extends core.DesProvider {
-
   public keySizeBits = 192;
   public ivSize = 8;
   public name = "DES-EDE3-CBC";
 
-  public async onGenerateKey(algorithm: core.DesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onGenerateKey(
+    algorithm: core.DesKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
     const key = await DesCrypto.generateKey(
       {
         name: this.name,
         length: this.keySizeBits,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return setCryptoKey(key);
   }
 
-  public async onEncrypt(algorithm: DesEde3CbcParams, key: DesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onEncrypt(
-    return DesCrypto.encrypt(algorithm, getCryptoKey(key) as DesCryptoKey, new Uint8Array(data));
+    algorithm: DesEde3CbcParams,
+    key: DesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return DesCrypto.encrypt(
+      algorithm,
+      getCryptoKey(key) as DesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onDecrypt(algorithm: DesEde3CbcParams, key: DesCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onDecrypt(
-    return DesCrypto.decrypt(algorithm, getCryptoKey(key) as DesCryptoKey, new Uint8Array(data));
+    algorithm: DesEde3CbcParams,
+    key: DesCryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return DesCrypto.decrypt(
+      algorithm,
+      getCryptoKey(key) as DesCryptoKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return DesCrypto.exportKey(format, getCryptoKey(key) as DesCryptoKey);
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onImportKey(
-    const key = await DesCrypto.importKey(format, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
+    format: KeyFormat,
-    if (key.data.length !== (this.keySizeBits >> 3)) {
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: Algorithm,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
+    const key = await DesCrypto.importKey(
+      format,
+      keyData,
+      { name: this.name, length: this.keySizeBits },
+      extractable,
+      keyUsages
+    );
+    if (key.data.length !== this.keySizeBits >> 3) {
       throw new core.OperationError("keyData: Wrong key size");
     }
     return setCryptoKey(key);
@@ -50,5 +85,4 @@ export class DesEde3CbcProvider extends core.DesProvider {
       throw new TypeError("key: Is not a DesCryptoKey");
     }
   }
-
 }

src/mechs/des/key.ts

@@ -4,7 +4,6 @@ import { JsonBase64UrlConverter } from "../../converters";
 import { SymmetricKey } from "../../keys";
 
 export class DesCryptoKey extends SymmetricKey {
-
   public override algorithm!: core.DesKeyAlgorithm;
 
   @JsonProp({ name: "k", converter: JsonBase64UrlConverter })
@@ -26,5 +25,4 @@ export class DesCryptoKey extends SymmetricKey {
   public override set alg(value: string) {
     // nothing, cause set is needed for json-schema, but is not used by module
   }
-
 }

src/mechs/ec/ec_dh.ts

@@ -6,17 +6,21 @@ import { CryptoKey } from "../../keys";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class EcdhProvider extends core.EcdhProvider {
-
   public override namedCurves = core.EcCurves.names;
 
-  public async onGenerateKey(algorithm: EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair> {
+  public async onGenerateKey(
+    algorithm: EcKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKeyPair> {
     const keys = await EcCrypto.generateKey(
       {
         ...algorithm,
         name: this.name,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as CryptoKey),
@@ -24,26 +28,53 @@ export class EcdhProvider extends core.EcdhProvider {
     };
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return EcCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: EcKeyImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onImportKey(
-    const key = await EcCrypto.importKey(format, keyData, {...algorithm, name: this.name}, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: EcKeyImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
+    const key = await EcCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
 
   public override checkCryptoKey(key: CryptoKey, keyUsage?: KeyUsage) {
     super.checkCryptoKey(key, keyUsage);
     const internalKey = getCryptoKey(key);
-    if (!(internalKey instanceof EcPrivateKey || internalKey instanceof EcPublicKey)) {
+    if (
+      !(
+        internalKey instanceof EcPrivateKey ||
+        internalKey instanceof EcPublicKey
+      )
+    ) {
       throw new TypeError("key: Is not EC CryptoKey");
     }
   }
 
-  public async onDeriveBits(algorithm: EcdhKeyDeriveParams, baseKey: CryptoKey, length: number): Promise<ArrayBuffer> {
+  public async onDeriveBits(
-    const bits = await EcCrypto.deriveBits({...algorithm, public: getCryptoKey(algorithm.public)}, getCryptoKey(baseKey), length);
+    algorithm: EcdhKeyDeriveParams,
+    baseKey: CryptoKey,
+    length: number
+  ): Promise<ArrayBuffer> {
+    const bits = await EcCrypto.deriveBits(
+      { ...algorithm, public: getCryptoKey(algorithm.public) },
+      getCryptoKey(baseKey),
+      length
+    );
     return bits;
   }
-
 }

src/mechs/ec/ec_dsa.ts

@@ -5,22 +5,33 @@ import { EcPublicKey } from "./public_key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class EcdsaProvider extends core.EcdsaProvider {
-
   public override namedCurves = core.EcCurves.names;
 
   public override hashAlgorithms = [
-    "SHA-1", "SHA-256", "SHA-384", "SHA-512", 
+    "SHA-1",
-    "shake128", "shake256", 
+    "SHA-256",
-    "SHA3-256", "SHA3-384", "SHA3-512"];
+    "SHA-384",
+    "SHA-512",
+    "shake128",
+    "shake256",
+    "SHA3-256",
+    "SHA3-384",
+    "SHA3-512",
+  ];
 
-  public async onGenerateKey(algorithm: EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair> {
+  public async onGenerateKey(
+    algorithm: EcKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKeyPair> {
     const keys = await EcCrypto.generateKey(
       {
         ...algorithm,
         name: this.name,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as EcPrivateKey),
@@ -28,29 +39,66 @@ export class EcdsaProvider extends core.EcdsaProvider {
     };
   }
 
-  public async onSign(algorithm: EcdsaParams, key: EcPrivateKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onSign(
-    return EcCrypto.sign(algorithm, getCryptoKey(key) as EcPrivateKey, new Uint8Array(data));
+    algorithm: EcdsaParams,
+    key: EcPrivateKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return EcCrypto.sign(
+      algorithm,
+      getCryptoKey(key) as EcPrivateKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onVerify(algorithm: EcdsaParams, key: EcPublicKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean> {
+  public async onVerify(
-    return EcCrypto.verify(algorithm, getCryptoKey(key) as EcPublicKey, new Uint8Array(signature), new Uint8Array(data));
+    algorithm: EcdsaParams,
+    key: EcPublicKey,
+    signature: ArrayBuffer,
+    data: ArrayBuffer
+  ): Promise<boolean> {
+    return EcCrypto.verify(
+      algorithm,
+      getCryptoKey(key) as EcPublicKey,
+      new Uint8Array(signature),
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return EcCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: EcKeyImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const key = await EcCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: EcKeyImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const key = await EcCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
 
   public override checkCryptoKey(key: CryptoKey, keyUsage?: KeyUsage) {
     super.checkCryptoKey(key, keyUsage);
     const internalKey = getCryptoKey(key);
-    if (!(internalKey instanceof EcPrivateKey || internalKey instanceof EcPublicKey)) {
+    if (
+      !(
+        internalKey instanceof EcPrivateKey ||
+        internalKey instanceof EcPublicKey
+      )
+    ) {
       throw new TypeError("key: Is not EC CryptoKey");
     }
   }
-
 }

src/mechs/ec/helper.ts

@@ -15,40 +15,42 @@ const namedOIDs: { [key: string]: string } = {
   "K-256": "1.3.132.0.10",
 
   // brainpool
-  "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",
 };
 
 export function getNamedCurveByOid(oid: string) {
   const namedCurve = namedOIDs[oid];
   if (!namedCurve) {
-    throw new core.OperationError(`Cannot convert OID(${oid}) to WebCrypto named curve`);
+    throw new core.OperationError(
+      `Cannot convert OID(${oid}) to WebCrypto named curve`
+    );
   }
   return namedCurve;
 }
@@ -56,7 +58,9 @@ export function getNamedCurveByOid(oid: string) {
 export function getOidByNamedCurve(namedCurve: string) {
   const oid = namedOIDs[namedCurve];
   if (!oid) {
-    throw new core.OperationError(`Cannot convert WebCrypto named curve '${namedCurve}' to OID`);
+    throw new core.OperationError(
+      `Cannot convert WebCrypto named curve '${namedCurve}' to OID`
+    );
   }
   return oid;
 }

src/mechs/ed/ecdh_es.ts

@@ -4,15 +4,19 @@ import { CryptoKey } from "../../keys";
 import { getCryptoKey, setCryptoKey } from "../storage";
 
 export class EcdhEsProvider extends core.EcdhEsProvider {
-  
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair> {
+    algorithm: EcKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKeyPair> {
     const keys = await EdCrypto.generateKey(
       {
         name: this.name,
         namedCurve: algorithm.namedCurve.toUpperCase(),
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as CryptoKey),
@@ -20,18 +24,40 @@ export class EcdhEsProvider extends core.EcdhEsProvider {
     };
   }
 
-  public async onDeriveBits(algorithm: EcdhKeyDeriveParams, baseKey: core.CryptoKey, length: number): Promise<ArrayBuffer> {
+  public async onDeriveBits(
-    const bits = await EdCrypto.deriveBits({...algorithm, public: getCryptoKey(algorithm.public)}, getCryptoKey(baseKey), length);
+    algorithm: EcdhKeyDeriveParams,
+    baseKey: core.CryptoKey,
+    length: number
+  ): Promise<ArrayBuffer> {
+    const bits = await EdCrypto.deriveBits(
+      { ...algorithm, public: getCryptoKey(algorithm.public) },
+      getCryptoKey(baseKey),
+      length
+    );
     return bits;
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<ArrayBuffer | JsonWebKey> {
     return EdCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public async onImportKey(format: KeyFormat, keyData: ArrayBuffer | JsonWebKey, algorithm: EcKeyImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onImportKey(
-    const key = await EdCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: ArrayBuffer | JsonWebKey,
+    algorithm: EcKeyImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
+    const key = await EdCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
-
 }

src/mechs/ed/eddsa.ts

@@ -6,15 +6,19 @@ import { CryptoKey } from "../../keys";
 import { getCryptoKey, setCryptoKey } from "../storage";
 
 export class EdDsaProvider extends core.EdDsaProvider {
-
+  public async onGenerateKey(
-  public async onGenerateKey(algorithm: EcKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair> {
+    algorithm: EcKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKeyPair> {
     const keys = await EdCrypto.generateKey(
       {
         name: this.name,
         namedCurve: algorithm.namedCurve.replace(/^ed/i, "Ed"),
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as CryptoKey),
@@ -22,21 +26,53 @@ export class EdDsaProvider extends core.EdDsaProvider {
     };
   }
 
-  public async onSign(algorithm: EcdsaParams, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onSign(
-    return EdCrypto.sign(algorithm, getCryptoKey(key) as EdPrivateKey, new Uint8Array(data));
+    algorithm: EcdsaParams,
+    key: CryptoKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return EdCrypto.sign(
+      algorithm,
+      getCryptoKey(key) as EdPrivateKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onVerify(algorithm: EcdsaParams, key: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean> {
+  public async onVerify(
-    return EdCrypto.verify(algorithm, getCryptoKey(key) as EdPublicKey, new Uint8Array(signature), new Uint8Array(data));
+    algorithm: EcdsaParams,
+    key: CryptoKey,
+    signature: ArrayBuffer,
+    data: ArrayBuffer
+  ): Promise<boolean> {
+    return EdCrypto.verify(
+      algorithm,
+      getCryptoKey(key) as EdPublicKey,
+      new Uint8Array(signature),
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<ArrayBuffer | JsonWebKey> {
     return EdCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public async onImportKey(format: KeyFormat, keyData: ArrayBuffer | JsonWebKey, algorithm: EcKeyImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<core.CryptoKey> {
+  public async onImportKey(
-    const key = await EdCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: ArrayBuffer | JsonWebKey,
+    algorithm: EcKeyImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<core.CryptoKey> {
+    const key = await EdCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
-
 }

src/mechs/ed/helper.ts

@@ -3,22 +3,24 @@ import * as core from "webcrypto-core";
 const edOIDs: { [key: string]: string } = {
   // Ed448
   [core.asn1.idEd448]: "Ed448",
-  "ed448": core.asn1.idEd448,
+  ed448: core.asn1.idEd448,
   // X448
   [core.asn1.idX448]: "X448",
-  "x448": core.asn1.idX448,
+  x448: core.asn1.idX448,
   // Ed25519
   [core.asn1.idEd25519]: "Ed25519",
-  "ed25519": core.asn1.idEd25519,
+  ed25519: core.asn1.idEd25519,
   // X25519
   [core.asn1.idX25519]: "X25519",
-  "x25519": core.asn1.idX25519,
+  x25519: core.asn1.idX25519,
 };
 
 export function getNamedCurveByOid(oid: string) {
   const namedCurve = edOIDs[oid];
   if (!namedCurve) {
-    throw new core.OperationError(`Cannot convert OID(${oid}) to WebCrypto named curve`);
+    throw new core.OperationError(
+      `Cannot convert OID(${oid}) to WebCrypto named curve`
+    );
   }
   return namedCurve;
 }
@@ -26,7 +28,9 @@ export function getNamedCurveByOid(oid: string) {
 export function getOidByNamedCurve(namedCurve: string) {
   const oid = edOIDs[namedCurve.toLowerCase()];
   if (!oid) {
-    throw new core.OperationError(`Cannot convert WebCrypto named curve '${namedCurve}' to OID`);
+    throw new core.OperationError(
+      `Cannot convert WebCrypto named curve '${namedCurve}' to OID`
+    );
   }
   return oid;
 }

src/mechs/hkdf/key.ts

@@ -1,7 +1,6 @@
 import { CryptoKey } from "../../keys";
 
 export class HkdfCryptoKey extends CryptoKey {
-
   public override data!: Buffer;
 
   public override algorithm!: KeyAlgorithm;

src/mechs/hmac/key.ts

@@ -3,7 +3,6 @@ import { JsonBase64UrlConverter } from "../../converters";
 import { CryptoKey } from "../../keys";
 
 export class HmacCryptoKey extends CryptoKey {
-
   @JsonProp({ name: "k", converter: JsonBase64UrlConverter })
   public override data!: Buffer;
 
@@ -19,5 +18,4 @@ export class HmacCryptoKey extends CryptoKey {
   protected override set alg(value: string) {
     // nothing, cause set is needed for json-schema, but is not used by module
   }
-
 }

src/mechs/pbkdf/key.ts

@@ -1,4 +1,3 @@
 import { CryptoKey } from "../../keys";
 
-export class PbkdfCryptoKey extends CryptoKey {
+export class PbkdfCryptoKey extends CryptoKey {}
-}

src/mechs/rsa/rsa_es.ts

@@ -7,21 +7,25 @@ import { RsaPublicKey } from "./public_key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class RsaEsProvider extends core.ProviderCrypto {
-
   public name = "RSAES-PKCS1-v1_5";
   public usages = {
     publicKey: ["encrypt", "wrapKey"] as core.KeyUsages,
     privateKey: ["decrypt", "unwrapKey"] as core.KeyUsages,
   };
 
-  public override async onGenerateKey(algorithm: RsaKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair> {
+  public override async onGenerateKey(
+    algorithm: RsaKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKeyPair> {
     const keys = await RsaCrypto.generateKey(
       {
         ...algorithm,
         name: this.name,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as RsaPrivateKey),
@@ -32,7 +36,12 @@ export class RsaEsProvider extends core.ProviderCrypto {
   public override checkGenerateKeyParams(algorithm: RsaKeyGenParams) {
     // public exponent
     this.checkRequiredProperty(algorithm, "publicExponent");
-    if (!(algorithm.publicExponent && algorithm.publicExponent instanceof Uint8Array)) {
+    if (
+      !(
+        algorithm.publicExponent &&
+        algorithm.publicExponent instanceof Uint8Array
+      )
+    ) {
       throw new TypeError("publicExponent: Missing or not a Uint8Array");
     }
     const publicExponent = Convert.ToBase64(algorithm.publicExponent);
@@ -52,31 +61,59 @@ export class RsaEsProvider extends core.ProviderCrypto {
     }
   }
 
-  public override async onEncrypt(algorithm: Algorithm, key: RsaPublicKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onEncrypt(
+    algorithm: Algorithm,
+    key: RsaPublicKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     const options = this.toCryptoOptions(key);
     const enc = crypto.publicEncrypt(options, new Uint8Array(data));
     return new Uint8Array(enc).buffer;
   }
 
-  public override async onDecrypt(algorithm: Algorithm, key: RsaPrivateKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDecrypt(
+    algorithm: Algorithm,
+    key: RsaPrivateKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     const options = this.toCryptoOptions(key);
     const dec = crypto.privateDecrypt(options, new Uint8Array(data));
     return new Uint8Array(dec).buffer;
   }
 
-  public override async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public override async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return RsaCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public override async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public override async onImportKey(
-    const key = await RsaCrypto.importKey(format, keyData, { ...algorithm, name: this.name }, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: RsaHashedImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const key = await RsaCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
 
   public override checkCryptoKey(key: CryptoKey, keyUsage?: KeyUsage) {
     super.checkCryptoKey(key, keyUsage);
     const internalKey = getCryptoKey(key);
-    if (!(internalKey instanceof RsaPrivateKey || internalKey instanceof RsaPublicKey)) {
+    if (
+      !(
+        internalKey instanceof RsaPrivateKey ||
+        internalKey instanceof RsaPublicKey
+      )
+    ) {
       throw new TypeError("key: Is not RSA CryptoKey");
     }
   }
@@ -86,7 +123,9 @@ export class RsaEsProvider extends core.ProviderCrypto {
   private toCryptoOptions(key: RsaPrivateKey | RsaPublicKey) {
     const type = key.type.toUpperCase();
     return {
-      key: `-----BEGIN ${type} KEY-----\n${getCryptoKey(key).data.toString("base64")}\n-----END ${type} KEY-----`,
+      key: `-----BEGIN ${type} KEY-----\n${getCryptoKey(key).data.toString(
+        "base64"
+      )}\n-----END ${type} KEY-----`,
       padding: crypto.constants.RSA_PKCS1_PADDING,
     };
   }

src/mechs/rsa/rsa_pss.ts

@@ -5,20 +5,31 @@ import { RsaPublicKey } from "./public_key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class RsaPssProvider extends core.RsaPssProvider {
-
   public override hashAlgorithms = [
-    "SHA-1", "SHA-256", "SHA-384", "SHA-512", 
+    "SHA-1",
-    "shake128", "shake256", 
+    "SHA-256",
-    "SHA3-256", "SHA3-384", "SHA3-512"];
+    "SHA-384",
+    "SHA-512",
+    "shake128",
+    "shake256",
+    "SHA3-256",
+    "SHA3-384",
+    "SHA3-512",
+  ];
 
-  public async onGenerateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair> {
+  public async onGenerateKey(
+    algorithm: RsaHashedKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKeyPair> {
     const keys = await RsaCrypto.generateKey(
       {
         ...algorithm,
         name: this.name,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as RsaPrivateKey),
@@ -26,29 +37,66 @@ export class RsaPssProvider extends core.RsaPssProvider {
     };
   }
 
-  public async onSign(algorithm: RsaPssParams, key: RsaPrivateKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onSign(
-    return RsaCrypto.sign(algorithm, getCryptoKey(key) as RsaPrivateKey, new Uint8Array(data));
+    algorithm: RsaPssParams,
+    key: RsaPrivateKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return RsaCrypto.sign(
+      algorithm,
+      getCryptoKey(key) as RsaPrivateKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onVerify(algorithm: RsaPssParams, key: RsaPublicKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean> {
+  public async onVerify(
-    return RsaCrypto.verify(algorithm, getCryptoKey(key) as RsaPublicKey, new Uint8Array(signature), new Uint8Array(data));
+    algorithm: RsaPssParams,
+    key: RsaPublicKey,
+    signature: ArrayBuffer,
+    data: ArrayBuffer
+  ): Promise<boolean> {
+    return RsaCrypto.verify(
+      algorithm,
+      getCryptoKey(key) as RsaPublicKey,
+      new Uint8Array(signature),
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return RsaCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const key = await RsaCrypto.importKey(format, keyData, {...algorithm, name: this.name}, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: RsaHashedImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const key = await RsaCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
 
   public override checkCryptoKey(key: CryptoKey, keyUsage?: KeyUsage) {
     super.checkCryptoKey(key, keyUsage);
     const internalKey = getCryptoKey(key);
-    if (!(internalKey instanceof RsaPrivateKey || internalKey instanceof RsaPublicKey)) {
+    if (
+      !(
+        internalKey instanceof RsaPrivateKey ||
+        internalKey instanceof RsaPublicKey
+      )
+    ) {
       throw new TypeError("key: Is not RSA CryptoKey");
     }
   }
-
 }

src/mechs/rsa/rsa_ssa.ts

@@ -5,20 +5,31 @@ import { RsaPublicKey } from "./public_key";
 import { setCryptoKey, getCryptoKey } from "../storage";
 
 export class RsaSsaProvider extends core.RsaSsaProvider {
-
   public override hashAlgorithms = [
-    "SHA-1", "SHA-256", "SHA-384", "SHA-512", 
+    "SHA-1",
-    "shake128", "shake256", 
+    "SHA-256",
-    "SHA3-256", "SHA3-384", "SHA3-512"];
+    "SHA-384",
+    "SHA-512",
+    "shake128",
+    "shake256",
+    "SHA3-256",
+    "SHA3-384",
+    "SHA3-512",
+  ];
 
-  public async onGenerateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<globalThis.CryptoKeyPair> {
+  public async onGenerateKey(
+    algorithm: RsaHashedKeyGenParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<globalThis.CryptoKeyPair> {
     const keys = await RsaCrypto.generateKey(
       {
         ...algorithm,
         name: this.name,
       },
       extractable,
-      keyUsages);
+      keyUsages
+    );
 
     return {
       privateKey: setCryptoKey(keys.privateKey as RsaPrivateKey),
@@ -26,29 +37,66 @@ export class RsaSsaProvider extends core.RsaSsaProvider {
     };
   }
 
-  public async onSign(algorithm: Algorithm, key: RsaPrivateKey, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public async onSign(
-    return RsaCrypto.sign(algorithm, getCryptoKey(key) as RsaPrivateKey, new Uint8Array(data));
+    algorithm: Algorithm,
+    key: RsaPrivateKey,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    return RsaCrypto.sign(
+      algorithm,
+      getCryptoKey(key) as RsaPrivateKey,
+      new Uint8Array(data)
+    );
   }
 
-  public async onVerify(algorithm: Algorithm, key: RsaPublicKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean> {
+  public async onVerify(
-    return RsaCrypto.verify(algorithm, getCryptoKey(key) as RsaPublicKey, new Uint8Array(signature), new Uint8Array(data));
+    algorithm: Algorithm,
+    key: RsaPublicKey,
+    signature: ArrayBuffer,
+    data: ArrayBuffer
+  ): Promise<boolean> {
+    return RsaCrypto.verify(
+      algorithm,
+      getCryptoKey(key) as RsaPublicKey,
+      new Uint8Array(signature),
+      new Uint8Array(data)
+    );
   }
 
-  public async onExportKey(format: KeyFormat, key: CryptoKey): Promise<JsonWebKey | ArrayBuffer> {
+  public async onExportKey(
+    format: KeyFormat,
+    key: CryptoKey
+  ): Promise<JsonWebKey | ArrayBuffer> {
     return RsaCrypto.exportKey(format, getCryptoKey(key));
   }
 
-  public async onImportKey(format: KeyFormat, keyData: JsonWebKey | ArrayBuffer, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey> {
+  public async onImportKey(
-    const key = await RsaCrypto.importKey(format, keyData, {...algorithm, name: this.name}, extractable, keyUsages);
+    format: KeyFormat,
+    keyData: JsonWebKey | ArrayBuffer,
+    algorithm: RsaHashedImportParams,
+    extractable: boolean,
+    keyUsages: KeyUsage[]
+  ): Promise<CryptoKey> {
+    const key = await RsaCrypto.importKey(
+      format,
+      keyData,
+      { ...algorithm, name: this.name },
+      extractable,
+      keyUsages
+    );
     return setCryptoKey(key);
   }
 
   public override checkCryptoKey(key: CryptoKey, keyUsage?: KeyUsage) {
     super.checkCryptoKey(key, keyUsage);
     const internalKey = getCryptoKey(key);
-    if (!(internalKey instanceof RsaPrivateKey || internalKey instanceof RsaPublicKey)) {
+    if (
+      !(
+        internalKey instanceof RsaPrivateKey ||
+        internalKey instanceof RsaPublicKey
+      )
+    ) {
       throw new TypeError("key: Is not RSA CryptoKey");
     }
   }
-
 }

src/mechs/sha/sha3_256.ts

@@ -5,8 +5,10 @@ export class Sha3256Provider extends core.ProviderCrypto {
   public name = "SHA3-256";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/sha/sha3_384.ts

@@ -5,8 +5,10 @@ export class Sha3384Provider extends core.ProviderCrypto {
   public name = "SHA3-384";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/sha/sha3_512.ts

@@ -5,8 +5,10 @@ export class Sha3512Provider extends core.ProviderCrypto {
   public name = "SHA3-512";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/sha/sha_1.ts

@@ -5,8 +5,10 @@ export class Sha1Provider extends core.ProviderCrypto {
   public name = "SHA-1";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/sha/sha_256.ts

@@ -5,8 +5,10 @@ export class Sha256Provider extends core.ProviderCrypto {
   public name = "SHA-256";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/sha/sha_384.ts

@@ -5,8 +5,10 @@ export class Sha384Provider extends core.ProviderCrypto {
   public name = "SHA-384";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/sha/sha_512.ts

@@ -5,8 +5,10 @@ export class Sha512Provider extends core.ProviderCrypto {
   public name = "SHA-512";
   public usages = [];
 
-  public override async onDigest(algorithm: Algorithm, data: ArrayBuffer): Promise<ArrayBuffer> {
+  public override async onDigest(
+    algorithm: Algorithm,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShaCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/shake/shake128.ts

@@ -2,9 +2,10 @@ import * as core from "webcrypto-core";
 import { ShakeCrypto } from "./crypto";
 
 export class Shake128Provider extends core.Shake128Provider {
-
+  public override async onDigest(
-  public override async onDigest(algorithm: Required<core.ShakeParams>, data: ArrayBuffer): Promise<ArrayBuffer> {
+    algorithm: Required<core.ShakeParams>,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShakeCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/shake/shake256.ts

@@ -2,9 +2,10 @@ import * as core from "webcrypto-core";
 import { ShakeCrypto } from "./crypto";
 
 export class Shake256Provider extends core.Shake256Provider {
-
+  public override async onDigest(
-  public override async onDigest(algorithm: Required<core.ShakeParams>, data: ArrayBuffer): Promise<ArrayBuffer> {
+    algorithm: Required<core.ShakeParams>,
+    data: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     return ShakeCrypto.digest(algorithm, data);
   }
-
 }

src/mechs/storage.ts

@@ -12,7 +12,12 @@ export function getCryptoKey(key: core.CryptoKey) {
 }
 
 export function setCryptoKey(value: InternalCryptoKey) {
-  const key = core.CryptoKey.create(value.algorithm, value.type, value.extractable, value.usages);
+  const key = core.CryptoKey.create(
+    value.algorithm,
+    value.type,
+    value.extractable,
+    value.usages
+  );
   Object.freeze(key);
 
   keyStorage.set(key, value);

src/subtle.ts

@@ -2,18 +2,34 @@ import * as crypto from "crypto";
 import * as process from "process";
 import * as core from "webcrypto-core";
 import {
-  AesCbcProvider, AesCmacProvider, AesCtrProvider, AesEcbProvider, AesGcmProvider, AesKwProvider,
+  AesCbcProvider,
+  AesCmacProvider,
+  AesCtrProvider,
+  AesEcbProvider,
+  AesGcmProvider,
+  AesKwProvider,
   DesCbcProvider,
-  DesEde3CbcProvider, EcdhProvider,
+  DesEde3CbcProvider,
-  EcdsaProvider, HkdfProvider,
+  EcdhProvider,
+  EcdsaProvider,
+  HkdfProvider,
   EdDsaProvider,
   EcdhEsProvider,
   HmacProvider,
   Pbkdf2Provider,
-  RsaEsProvider, RsaOaepProvider, RsaPssProvider, RsaSsaProvider,
+  RsaEsProvider,
-  Sha1Provider, Sha256Provider, Sha384Provider, Sha512Provider,
+  RsaOaepProvider,
-  Shake128Provider, Shake256Provider,
+  RsaPssProvider,
-  Sha3256Provider, Sha3384Provider, Sha3512Provider,
+  RsaSsaProvider,
+  Sha1Provider,
+  Sha256Provider,
+  Sha384Provider,
+  Sha512Provider,
+  Shake128Provider,
+  Shake256Provider,
+  Sha3256Provider,
+  Sha3384Provider,
+  Sha3512Provider,
 } from "./mechs";
 
 export class SubtleCrypto extends core.SubtleCrypto {