@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/crypto/interface.ts

@@ -48,24 +48,24 @@ export interface SessionKey {
 export enum VERIFICATION_STATUS {
     NOT_SIGNED = 0,
     SIGNED_AND_VALID = 1,
-    SIGNED_AND_INVALID = 2
+    SIGNED_AND_INVALID = 2,
 }
 
 export interface SRPModule {
-    getSrpVerifier: (password: string) => Promise<SRPVerifier>,
-    computeKeyPassword: (password: string, salt: string) => Promise<string>,
+    getSrpVerifier: (password: string) => Promise<SRPVerifier>;
+    computeKeyPassword: (password: string, salt: string) => Promise<string>;
 }
 
 export type SRPVerifier = {
-    modulusId: string,
-    version: number,
-    salt: string,
-    verifier: string,
-}
+    modulusId: string;
+    version: number;
+    salt: string;
+    verifier: string;
+};
 
 /**
  * OpenPGP crypto layer to provide necessary PGP operations for Drive crypto.
- * 
+ *
  * This layer focuses on providing general openPGP functions. Every operation
  * should prefer binary input and output. Ideally, armoring should be done
  * later in serialisation step, but for now, it is part of the interface to
@@ -77,38 +77,44 @@ export type SRPVerifier = {
 export interface OpenPGPCrypto {
     /**
      * Generate a random passphrase.
-     * 
+     *
      * 32 random bytes are generated and encoded into a base64 string.
      */
-    generatePassphrase: () => string,
+    generatePassphrase: () => string;
 
-    generateSessionKey: (encryptionKeys: PrivateKey[]) => Promise<SessionKey>,
+    generateSessionKey: (encryptionKeys: PrivateKey[]) => Promise<SessionKey>;
 
-    encryptSessionKey: (sessionKey: SessionKey, encryptionKeys: PublicKey | PublicKey[]) => Promise<{
-        keyPacket: Uint8Array,
-    }>,
+    encryptSessionKey: (
+        sessionKey: SessionKey,
+        encryptionKeys: PublicKey | PublicKey[],
+    ) => Promise<{
+        keyPacket: Uint8Array;
+    }>;
 
-    encryptSessionKeyWithPassword: (sessionKey: SessionKey, password: string) => Promise<{
-        keyPacket: Uint8Array,
-    }>,
+    encryptSessionKeyWithPassword: (
+        sessionKey: SessionKey,
+        password: string,
+    ) => Promise<{
+        keyPacket: Uint8Array;
+    }>;
 
     /**
      * Generate a new key pair locked by a passphrase.
-     * 
+     *
      * The key pair is generated using the Curve25519 algorithm.
      */
     generateKey: (passphrase: string) => Promise<{
-        privateKey: PrivateKey,
-        armoredKey: string,
-    }>,
+        privateKey: PrivateKey;
+        armoredKey: string;
+    }>;
 
     encryptArmored: (
         data: Uint8Array,
         encryptionKeys: PrivateKey[],
         sessionKey?: SessionKey,
     ) => Promise<{
-        armoredData: string,
-    }>,
+        armoredData: string;
+    }>;
 
     encryptAndSign: (
         data: Uint8Array,
@@ -116,8 +122,8 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        encryptedData: Uint8Array,
-    }>,
+        encryptedData: Uint8Array;
+    }>;
 
     encryptAndSignArmored: (
         data: Uint8Array,
@@ -125,8 +131,8 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        armoredData: string,
-    }>,
+        armoredData: string;
+    }>;
 
     encryptAndSignDetached: (
         data: Uint8Array,
@@ -134,9 +140,9 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        encryptedData: Uint8Array,
-        signature: Uint8Array,
-    }>,
+        encryptedData: Uint8Array;
+        signature: Uint8Array;
+    }>;
 
     encryptAndSignDetachedArmored: (
         data: Uint8Array,
@@ -144,56 +150,47 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        armoredData: string,
-        armoredSignature: string,
-    }>,
+        armoredData: string;
+        armoredSignature: string;
+    }>;
 
     sign: (
         data: Uint8Array,
         signingKey: PrivateKey,
         signatureContext: string,
     ) => Promise<{
-        signature: Uint8Array,
-    }>,
+        signature: Uint8Array;
+    }>;
 
     signArmored: (
         data: Uint8Array,
         signingKey: PrivateKey | PrivateKey[],
     ) => Promise<{
-        signature: string,
-    }>,
+        signature: string;
+    }>;
 
     verify: (
         data: Uint8Array,
         armoredSignature: string,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        verified: VERIFICATION_STATUS,
-    }>,
+        verified: VERIFICATION_STATUS;
+    }>;
 
-    decryptSessionKey: (
-        data: Uint8Array,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) => Promise<SessionKey>,
+    decryptSessionKey: (data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
 
-    decryptArmoredSessionKey: (
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) => Promise<SessionKey>,
+    decryptArmoredSessionKey: (armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
 
-    decryptKey: (
-        armoredKey: string,
-        passphrase: string,
-    ) => Promise<PrivateKey>,
+    decryptKey: (armoredKey: string, passphrase: string) => Promise<PrivateKey>;
 
     decryptAndVerify(
         data: Uint8Array,
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ): Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
     decryptAndVerifyDetached(
         data: Uint8Array,
@@ -201,23 +198,20 @@ export interface OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys?: PublicKey | PublicKey[],
     ): Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
-    decryptArmored(
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ): Promise<Uint8Array>,
+    decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]): Promise<Uint8Array>;
 
     decryptArmoredAndVerify: (
         armoredData: string,
         decryptionKeys: PrivateKey | PrivateKey[],
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
     decryptArmoredAndVerifyDetached: (
         armoredData: string,
@@ -225,12 +219,9 @@ export interface OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
-    decryptArmoredWithPassword(
-        armoredData: string,
-        password: string,
-    ): Promise<Uint8Array>,
+    decryptArmoredWithPassword(armoredData: string, password: string): Promise<Uint8Array>;
 }

package/src/crypto/openPGPCrypto.ts

@@ -6,57 +6,63 @@ import { uint8ArrayToBase64String } from './utils';
  * clients/packages/crypto/lib/proxy/proxy.ts.
  */
 export interface OpenPGPCryptoProxy {
-    generateKey: (options: { userIDs: { name: string }[], type: 'ecc', curve: 'ed25519Legacy' }) => Promise<PrivateKey>,
-    exportPrivateKey: (options: { privateKey: PrivateKey, passphrase: string | null }) => Promise<string>,
-    importPrivateKey: (options: { armoredKey: string, passphrase: string | null }) => Promise<PrivateKey>,
-    generateSessionKey: (options: { recipientKeys: PrivateKey[] }) => Promise<SessionKey>,
-    encryptSessionKey: (options: SessionKey & { format: 'binary', encryptionKeys?: PublicKey | PublicKey[], passwords?: string[] }) => Promise<Uint8Array>,
-    decryptSessionKey: (options: { armoredMessage?: string, binaryMessage?: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[] }) => Promise<SessionKey | undefined>,
+    generateKey: (options: { userIDs: { name: string }[]; type: 'ecc'; curve: 'ed25519Legacy' }) => Promise<PrivateKey>;
+    exportPrivateKey: (options: { privateKey: PrivateKey; passphrase: string | null }) => Promise<string>;
+    importPrivateKey: (options: { armoredKey: string; passphrase: string | null }) => Promise<PrivateKey>;
+    generateSessionKey: (options: { recipientKeys: PrivateKey[] }) => Promise<SessionKey>;
+    encryptSessionKey: (
+        options: SessionKey & { format: 'binary'; encryptionKeys?: PublicKey | PublicKey[]; passwords?: string[] },
+    ) => Promise<Uint8Array>;
+    decryptSessionKey: (options: {
+        armoredMessage?: string;
+        binaryMessage?: Uint8Array;
+        decryptionKeys: PrivateKey | PrivateKey[];
+    }) => Promise<SessionKey | undefined>;
     encryptMessage: (options: {
-        format?: 'armored' | 'binary',
-        binaryData: Uint8Array,
-        sessionKey?: SessionKey,
-        encryptionKeys: PrivateKey[],
-        signingKeys?: PrivateKey,
-        detached?: boolean,
+        format?: 'armored' | 'binary';
+        binaryData: Uint8Array;
+        sessionKey?: SessionKey;
+        encryptionKeys: PrivateKey[];
+        signingKeys?: PrivateKey;
+        detached?: boolean;
     }) => Promise<{
-        message: string | Uint8Array,
-        signature?: string | Uint8Array,
-    }>,
+        message: string | Uint8Array;
+        signature?: string | Uint8Array;
+    }>;
     decryptMessage: (options: {
-        format: 'utf8' | 'binary',
-        armoredMessage?: string,
-        binaryMessage?: Uint8Array,
-        armoredSignature?: string,
-        binarySignature?: Uint8Array,
-        sessionKeys?: SessionKey,
-        passwords?: string[],
-        decryptionKeys?: PrivateKey | PrivateKey[],
-        verificationKeys?: PublicKey | PublicKey[],
+        format: 'utf8' | 'binary';
+        armoredMessage?: string;
+        binaryMessage?: Uint8Array;
+        armoredSignature?: string;
+        binarySignature?: Uint8Array;
+        sessionKeys?: SessionKey;
+        passwords?: string[];
+        decryptionKeys?: PrivateKey | PrivateKey[];
+        verificationKeys?: PublicKey | PublicKey[];
     }) => Promise<{
-        data: Uint8Array | string,
+        data: Uint8Array | string;
         // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
         // Web clients are using newer pmcrypto, but CLI is using older version due to build issues with Bun.
-        verified?: VERIFICATION_STATUS,
-        verificationStatus?: VERIFICATION_STATUS,
-    }>,
+        verified?: VERIFICATION_STATUS;
+        verificationStatus?: VERIFICATION_STATUS;
+    }>;
     signMessage: (options: {
-        format: 'binary' | 'armored',
-        binaryData: Uint8Array,
-        signingKeys: PrivateKey | PrivateKey[],
-        detached: boolean,
-        signatureContext?: { critical: boolean, value: string },
-    }) => Promise<Uint8Array | string>,
+        format: 'binary' | 'armored';
+        binaryData: Uint8Array;
+        signingKeys: PrivateKey | PrivateKey[];
+        detached: boolean;
+        signatureContext?: { critical: boolean; value: string };
+    }) => Promise<Uint8Array | string>;
     verifyMessage: (options: {
-        binaryData: Uint8Array,
-        armoredSignature: string,
-        verificationKeys: PublicKey | PublicKey[],
+        binaryData: Uint8Array;
+        armoredSignature: string;
+        verificationKeys: PublicKey | PublicKey[];
     }) => Promise<{
         // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
         // Web clients are using newer pmcrypto, but CLI is using older version due to build issues with Bun.
-        verified?: VERIFICATION_STATUS,
-        verificationStatus?: VERIFICATION_STATUS,
-    }>,
+        verified?: VERIFICATION_STATUS;
+        verificationStatus?: VERIFICATION_STATUS;
+    }>;
 }
 
 /**
@@ -87,7 +93,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             encryptionKeys,
         });
         return {
-            keyPacket
+            keyPacket,
         };
     }
 
@@ -120,11 +126,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async encryptArmored(
-        data: Uint8Array,
-        encryptionKeys: PrivateKey[],
-        sessionKey?: SessionKey,
-    ) {
+    async encryptArmored(data: Uint8Array, encryptionKeys: PrivateKey[], sessionKey?: SessionKey) {
         const { message: armoredData } = await this.cryptoProxy.encryptMessage({
             binaryData: data,
             sessionKey,
@@ -132,7 +134,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
         return {
             armoredData: armoredData as string,
-        }
+        };
     }
 
     async encryptAndSign(
@@ -189,7 +191,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return {
             encryptedData: encryptedData as Uint8Array,
             signature: signature as Uint8Array,
-        }
+        };
     }
 
     async encryptAndSignDetachedArmored(
@@ -208,14 +210,10 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return {
             armoredData: armoredData as string,
             armoredSignature: armoredSignature as string,
-        }
+        };
     }
 
-    async sign(
-        data: Uint8Array,
-        signingKeys: PrivateKey | PrivateKey[],
-        signatureContext: string,
-    ) {
+    async sign(data: Uint8Array, signingKeys: PrivateKey | PrivateKey[], signatureContext: string) {
         const signature = await this.cryptoProxy.signMessage({
             binaryData: data,
             signingKeys,
@@ -228,10 +226,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async signArmored(
-        data: Uint8Array,
-        signingKeys: PrivateKey | PrivateKey[],
-    ) {
+    async signArmored(data: Uint8Array, signingKeys: PrivateKey | PrivateKey[]) {
         const signature = await this.cryptoProxy.signMessage({
             binaryData: data,
             signingKeys,
@@ -243,11 +238,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async verify(
-        data: Uint8Array,
-        armoredSignature: string,
-        verificationKeys: PublicKey | PublicKey[],
-    ) {
+    async verify(data: Uint8Array, armoredSignature: string, verificationKeys: PublicKey | PublicKey[]) {
         const { verified, verificationStatus } = await this.cryptoProxy.verifyMessage({
             binaryData: data,
             armoredSignature,
@@ -260,10 +251,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async decryptSessionKey(
-        data: Uint8Array,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) {
+    async decryptSessionKey(data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) {
         const sessionKey = await this.cryptoProxy.decryptSessionKey({
             binaryMessage: data,
             decryptionKeys,
@@ -276,10 +264,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return sessionKey;
     }
 
-    async decryptArmoredSessionKey(
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) {
+    async decryptArmoredSessionKey(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) {
         const sessionKey = await this.cryptoProxy.decryptSessionKey({
             armoredMessage: armoredData,
             decryptionKeys,
@@ -292,10 +277,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return sessionKey;
     }
 
-    async decryptKey(
-        armoredKey: string,
-        passphrase: string,
-    ) {
+    async decryptKey(armoredKey: string, passphrase: string) {
         const key = await this.cryptoProxy.importPrivateKey({
             armoredKey,
             passphrase,
@@ -303,12 +285,12 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return key;
     }
 
-    async decryptAndVerify(
-        data: Uint8Array,
-        sessionKey: SessionKey,
-        verificationKeys: PublicKey[],
-    ) {
-        const { data: decryptedData, verified, verificationStatus } = await this.cryptoProxy.decryptMessage({
+    async decryptAndVerify(data: Uint8Array, sessionKey: SessionKey, verificationKeys: PublicKey[]) {
+        const {
+            data: decryptedData,
+            verified,
+            verificationStatus,
+        } = await this.cryptoProxy.decryptMessage({
             binaryMessage: data,
             sessionKeys: sessionKey,
             verificationKeys,
@@ -320,7 +302,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
     async decryptAndVerifyDetached(
@@ -329,7 +311,11 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys?: PublicKey[],
     ) {
-        const { data: decryptedData, verified, verificationStatus } = await this.cryptoProxy.decryptMessage({
+        const {
+            data: decryptedData,
+            verified,
+            verificationStatus,
+        } = await this.cryptoProxy.decryptMessage({
             binaryMessage: data,
             binarySignature: signature,
             sessionKeys: sessionKey,
@@ -342,13 +328,10 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
-    async decryptArmored(
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) {
+    async decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) {
         const { data } = await this.cryptoProxy.decryptMessage({
             armoredMessage: armoredData,
             decryptionKeys,
@@ -374,7 +357,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
     async decryptArmoredAndVerifyDetached(
@@ -396,13 +379,10 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
-    async decryptArmoredWithPassword(
-        armoredData: string,
-        password: string,
-    ) {
+    async decryptArmoredWithPassword(armoredData: string, password: string) {
         const { data } = await this.cryptoProxy.decryptMessage({
             armoredMessage: armoredData,
             passwords: [password],

package/src/crypto/utils.ts

@@ -4,7 +4,7 @@ export function uint8ArrayToBase64String(array: Uint8Array) {
     return encodeBase64(arrayToBinaryString(array));
 }
 
-export function base64StringToUint8Array(string: string){
+export function base64StringToUint8Array(string: string) {
     return binaryStringToArray(decodeBase64(string) || '');
 }
 

package/src/diagnostic/eventsGenerator.ts

@@ -14,10 +14,10 @@ export class EventsGenerator {
         this.eventQueue.push(event);
         // Notify all waiting generators
         const resolvers = this.waitingResolvers.splice(0);
-        resolvers.forEach(resolve => resolve());
+        resolvers.forEach((resolve) => resolve());
     }
 
-    async* iterateEvents(): AsyncGenerator<DiagnosticResult> {
+    async *iterateEvents(): AsyncGenerator<DiagnosticResult> {
         try {
             while (true) {
                 if (this.eventQueue.length === 0) {

package/src/diagnostic/httpClient.ts

@@ -1,4 +1,8 @@
-import { ProtonDriveHTTPClient, ProtonDriveHTTPClientBlobOptions, ProtonDriveHTTPClientJsonOptions } from "../interface";
+import {
+    ProtonDriveHTTPClient,
+    ProtonDriveHTTPClientBlobOptions,
+    ProtonDriveHTTPClientJsonOptions,
+} from '../interface';
 import { EventsGenerator } from './eventsGenerator';
 
 /**
@@ -77,4 +81,4 @@ export class DiagnosticHTTPClient extends EventsGenerator implements ProtonDrive
     fetchBlob(options: ProtonDriveHTTPClientBlobOptions): Promise<Response> {
         return this.httpClient.fetchBlob(options);
     }
-}
+}

package/src/diagnostic/index.ts

@@ -1,13 +1,13 @@
-import { MemoryCache, NullCache } from "../cache";
-import { ProtonDriveClientContructorParameters } from "../interface";
-import { ProtonDriveClient } from "../protonDriveClient";
-import { DiagnosticHTTPClient } from "./httpClient";
-import { Diagnostic } from "./interface";
-import { SDKDiagnostic } from "./sdkDiagnostic";
-import { FullSDKDiagnostic } from "./sdkDiagnosticFull";
-import { DiagnosticTelemetry } from "./telemetry";
+import { MemoryCache, NullCache } from '../cache';
+import { ProtonDriveClientContructorParameters } from '../interface';
+import { ProtonDriveClient } from '../protonDriveClient';
+import { DiagnosticHTTPClient } from './httpClient';
+import { Diagnostic } from './interface';
+import { SDKDiagnostic } from './sdkDiagnostic';
+import { FullSDKDiagnostic } from './sdkDiagnosticFull';
+import { DiagnosticTelemetry } from './telemetry';
 
-export type { Diagnostic, DiagnosticResult } from "./interface";
+export type { Diagnostic, DiagnosticResult } from './interface';
 
 /**
  * Initializes the diagnostic tool. It creates the instance of
@@ -15,7 +15,9 @@ export type { Diagnostic, DiagnosticResult } from "./interface";
  * metrics and HTTP calls; and enforced null/empty cache to always
  * start from scratch.
  */
-export function initDiagnostic(options: Omit<ProtonDriveClientContructorParameters, 'entitiesCache' | 'cryptoCache' | 'telemetry'>): Diagnostic {
+export function initDiagnostic(
+    options: Omit<ProtonDriveClientContructorParameters, 'entitiesCache' | 'cryptoCache' | 'telemetry'>,
+): Diagnostic {
     const httpClient = new DiagnosticHTTPClient(options.httpClient);
     const telemetry = new DiagnosticTelemetry();
 

package/src/diagnostic/integrityVerificationStream.ts

@@ -1,4 +1,4 @@
-import { sha1 } from "@noble/hashes/legacy";
+import { sha1 } from '@noble/hashes/legacy';
 import { bytesToHex } from '@noble/hashes/utils';
 
 /**
@@ -30,7 +30,7 @@ export class IntegrityVerificationStream extends WritableStream<Uint8Array> {
             abort: () => {
                 this._isClosed = true;
                 this._computedSha1 = undefined;
-            }
+            },
         });
     }
 
@@ -52,5 +52,4 @@ export class IntegrityVerificationStream extends WritableStream<Uint8Array> {
         }
         return this._computedSizeInBytes;
     }
-
-} 
+}