@protontech/drive-sdk 0.12.1 → 0.13.0

package/src/internal/photos/upload.ts

@@ -1,8 +1,15 @@
 import { DriveCrypto } from '../../crypto';
-import { ProtonDriveTelemetry, UploadMetadata, Thumbnail, AnonymousUser, FeatureFlagProvider } from '../../interface';
+import {
+    ProtonDriveTelemetry,
+    UploadMetadata,
+    Thumbnail,
+    AnonymousUser,
+    FeatureFlagProvider,
+    PhotoTag,
+} from '../../interface';
 import { DriveAPIService, drivePaths } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';
-import { splitNodeRevisionUid } from '../uids';
+import { splitNodeRevisionUid, splitNodeUid } from '../uids';
 import { UploadAPIService } from '../upload/apiService';
 import { BlockVerifier } from '../upload/blockVerifier';
 import { UploadController } from '../upload/controller';
@@ -22,9 +29,8 @@ type PostCommitRevisionResponse =
 
 export type PhotoUploadMetadata = UploadMetadata & {
     captureTime?: Date;
-    mainPhotoLinkID?: string;
-    // TODO: handle tags enum in the SDK
-    tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+    mainPhotoNodeUid?: string;
+    tags?: PhotoTag[];
 };
 
 export class PhotoFileUploader extends FileUploader {
@@ -180,7 +186,7 @@ export class PhotoUploadManager extends UploadManager {
         const photo = {
             contentHash,
             captureTime: uploadMetadata.captureTime || extendedAttributes.modificationTime,
-            mainPhotoLinkID: uploadMetadata.mainPhotoLinkID,
+            mainPhotoNodeUid: uploadMetadata.mainPhotoNodeUid,
             tags: uploadMetadata.tags,
         };
         await this.photoApiService.commitDraftPhoto(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto, photo);
@@ -218,12 +224,19 @@ export class PhotoUploadAPIService extends UploadAPIService {
         photo: {
             contentHash: string;
             captureTime?: Date;
-            mainPhotoLinkID?: string;
-            // TODO: handle tags enum in the SDK
-            tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+            mainPhotoNodeUid?: string;
+            tags?: PhotoTag[];
         },
     ): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
+        const { volumeId: mainPhotoVolumeId, nodeId: mainPhotoNodeId } = photo.mainPhotoNodeUid
+            ? splitNodeUid(photo.mainPhotoNodeUid)
+            : { volumeId: null, nodeId: null };
+
+        if (mainPhotoVolumeId !== null && mainPhotoVolumeId !== volumeId) {
+            throw new Error('mainPhotoNodeUid must belong to the same volume as the draft');
+        }
+
         await this.apiService.put<
             // TODO: Deprected fields but not properly marked in the types.
             Omit<PostCommitRevisionRequest, 'BlockNumber' | 'BlockList' | 'ThumbnailToken' | 'State'>,
@@ -235,7 +248,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
             Photo: {
                 ContentHash: photo.contentHash,
                 CaptureTime: photo.captureTime ? Math.floor(photo.captureTime?.getTime() / 1000) : 0,
-                MainPhotoLinkID: photo.mainPhotoLinkID || null,
+                MainPhotoLinkID: mainPhotoNodeId,
                 Tags: photo.tags || [],
                 Exif: null, // Deprecated field, not used.
             },

package/src/internal/upload/apiService.ts

@@ -52,6 +52,26 @@ type PostLoadLinksMetadataRequest = Extract<
 type PostLoadLinksMetadataResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
 
+type PostSmallFileFormData = Extract<
+    Extract<
+        drivePaths['/drive/v2/volumes/{volumeID}/files/small']['post']['requestBody'],
+        { content: object }
+    >['content']['multipart/form-data'],
+    { Metadata: object }
+>;
+type PostSmallFileResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/small']['post']['responses']['200']['content']['application/json'];
+
+type PostSmallRevisionFormData = Extract<
+    Extract<
+        drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/small']['post']['requestBody'],
+        { content: object }
+    >['content']['multipart/form-data'],
+    { Metadata: object }
+>;
+type PostSmallRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/small']['post']['responses']['200']['content']['application/json'];
+
 export class UploadAPIService {
     constructor(
         protected apiService: DriveAPIService,
@@ -218,7 +238,7 @@ export class UploadAPIService {
         options: {
             armoredManifestSignature: string;
             signatureEmail: string | AnonymousUser;
-            armoredExtendedAttributes?: string;
+            armoredExtendedAttributes: string;
         },
     ): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
@@ -229,7 +249,7 @@ export class UploadAPIService {
         >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`, {
             ManifestSignature: options.armoredManifestSignature,
             SignatureAddress: options.signatureEmail,
-            XAttr: options.armoredExtendedAttributes || null,
+            XAttr: options.armoredExtendedAttributes,
             Photo: null, // Only used for photos in the Photo volume.
         });
     }
@@ -285,4 +305,149 @@ export class UploadAPIService {
             link.File?.ActiveRevision?.RevisionID === revisionId
         );
     }
+
+    async uploadSmallFile(
+        parentFolderUid: string,
+        metadata: {
+            armoredEncryptedName: string;
+            hash: string;
+            mediaType: string;
+            armoredNodeKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            base64ContentKeyPacket: string;
+            armoredContentKeyPacketSignature: string;
+            armoredExtendedAttributes: string;
+            signatureEmail: string | AnonymousUser;
+        },
+        content: {
+            armoredManifestSignature: string;
+            block:
+                | {
+                      encryptedData: Uint8Array<ArrayBuffer>;
+                      armoredSignature: string;
+                      verificationToken: Uint8Array<ArrayBuffer>;
+                  }
+                | undefined;
+            thumbnails: {
+                type: ThumbnailType;
+                encryptedData: Uint8Array<ArrayBuffer>;
+            }[];
+        },
+        signal?: AbortSignal,
+    ): Promise<{ nodeUid: string; nodeRevisionUid: string }> {
+        const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentFolderUid);
+
+        const metadataPayload: PostSmallFileFormData['Metadata'] = {
+            ParentLinkID: parentNodeId,
+            Name: metadata.armoredEncryptedName,
+            NameHash: metadata.hash,
+            NodePassphrase: metadata.armoredNodePassphrase,
+            NodePassphraseSignature: metadata.armoredNodePassphraseSignature,
+            SignatureEmail: metadata.signatureEmail,
+            NodeKey: metadata.armoredNodeKey,
+            MIMEType: metadata.mediaType,
+            ContentKeyPacket: metadata.base64ContentKeyPacket,
+            ContentKeyPacketSignature: metadata.armoredContentKeyPacketSignature,
+            ManifestSignature: content.armoredManifestSignature,
+            ContentBlockEncSignature: content.block ? content.block.armoredSignature : null,
+            ContentBlockVerificationToken: content.block
+                ? uint8ArrayToBase64String(content.block.verificationToken)
+                : null,
+            XAttr: metadata.armoredExtendedAttributes,
+            Photo: null, // TODO
+        };
+
+        const formData = new FormData();
+        formData.set('Metadata', new Blob([JSON.stringify(metadataPayload)], { type: 'application/json' }), 'Metadata');
+        if (content.block) {
+            formData.set('ContentBlock', new Blob([content.block.encryptedData]), 'ContentBlock');
+        }
+        for (const thumb of content.thumbnails) {
+            if (formData.get(`ThumbnailBlockType_${thumb.type}`)) {
+                throw new Error('Duplicate thumbnail types');
+            }
+            formData.set(
+                `ThumbnailBlockType_${thumb.type}`,
+                new Blob([thumb.encryptedData]),
+                `ThumbnailBlockType_${thumb.type}`,
+            );
+        }
+
+        const result = await this.apiService.postFormData<PostSmallFileResponse>(
+            `drive/v2/volumes/${volumeId}/files/small`,
+            formData,
+            signal,
+        );
+
+        return {
+            nodeUid: makeNodeUid(volumeId, result.LinkID),
+            nodeRevisionUid: makeNodeRevisionUid(volumeId, result.LinkID, result.RevisionID),
+        };
+    }
+
+    async uploadSmallRevision(
+        nodeUid: string,
+        currentRevisionUid: string,
+        metadata: {
+            signatureEmail: string | AnonymousUser | null;
+            armoredExtendedAttributes: string;
+        },
+        content: {
+            armoredManifestSignature: string;
+            block:
+                | {
+                      encryptedData: Uint8Array<ArrayBuffer>;
+                      armoredSignature: string;
+                      verificationToken: Uint8Array<ArrayBuffer>;
+                  }
+                | undefined;
+            thumbnails: {
+                type: ThumbnailType;
+                encryptedData: Uint8Array<ArrayBuffer>;
+            }[];
+        },
+        signal?: AbortSignal,
+    ): Promise<{ nodeUid: string; nodeRevisionUid: string }> {
+        const { volumeId, nodeId } = splitNodeUid(nodeUid);
+        const { revisionId: currentRevisionId } = splitNodeRevisionUid(currentRevisionUid);
+
+        const metadataPayload: PostSmallRevisionFormData['Metadata'] = {
+            CurrentRevisionID: currentRevisionId,
+            SignatureEmail: metadata.signatureEmail,
+            ManifestSignature: content.armoredManifestSignature,
+            ContentBlockEncSignature: content.block ? content.block.armoredSignature : null,
+            ContentBlockVerificationToken: content.block
+                ? uint8ArrayToBase64String(content.block.verificationToken)
+                : null,
+            XAttr: metadata.armoredExtendedAttributes,
+        };
+
+        const formData = new FormData();
+        formData.set('Metadata', new Blob([JSON.stringify(metadataPayload)], { type: 'application/json' }), 'Metadata');
+        if (content.block) {
+            formData.set('ContentBlock', new Blob([content.block.encryptedData]), 'ContentBlock');
+        }
+        for (const thumb of content.thumbnails) {
+            if (formData.get(`ThumbnailBlockType_${thumb.type}`)) {
+                throw new Error('Duplicate thumbnail types');
+            }
+            formData.set(
+                `ThumbnailBlockType_${thumb.type}`,
+                new Blob([thumb.encryptedData]),
+                `ThumbnailBlockType_${thumb.type}`,
+            );
+        }
+
+        const result = await this.apiService.postFormData<PostSmallRevisionResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/small`,
+            formData,
+            signal,
+        );
+
+        return {
+            nodeUid: makeNodeUid(volumeId, result.LinkID),
+            nodeRevisionUid: makeNodeRevisionUid(volumeId, result.LinkID, result.RevisionID),
+        };
+    }
 }

package/src/internal/upload/blockVerifier.ts

@@ -2,6 +2,18 @@ import { PrivateKey, SessionKey } from '../../crypto';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
 
+export async function verifyBlockWithContentKey(
+    cryptoService: UploadCryptoService,
+    contentKeyPacket: Uint8Array<ArrayBuffer>,
+    contentKeyPacketSessionKey: SessionKey,
+    encryptedBlock: Uint8Array<ArrayBuffer>,
+): Promise<{
+    verificationToken: Uint8Array<ArrayBuffer>;
+}> {
+    const verificationCode = contentKeyPacket.subarray(-32);
+    return cryptoService.verifyBlock(contentKeyPacketSessionKey, verificationCode, encryptedBlock);
+}
+
 export class BlockVerifier {
     private verificationCode?: Uint8Array<ArrayBuffer>;
     private contentKeyPacketSessionKey?: SessionKey;

package/src/internal/upload/cryptoService.ts

@@ -145,7 +145,9 @@ export class UploadCryptoService {
     }
 
     async encryptBlock(
-        verifyBlock: (encryptedBlock: Uint8Array<ArrayBuffer>) => Promise<{ verificationToken: Uint8Array<ArrayBuffer> }>,
+        verifyBlock: (
+            encryptedBlock: Uint8Array<ArrayBuffer>,
+        ) => Promise<{ verificationToken: Uint8Array<ArrayBuffer> }>,
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
         block: Uint8Array<ArrayBuffer>,
         index: number,
@@ -173,24 +175,22 @@ export class UploadCryptoService {
     async commitFile(
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
         manifest: Uint8Array<ArrayBuffer>,
-        extendedAttributes?: string,
+        extendedAttributes: string,
     ): Promise<{
         armoredManifestSignature: string;
         signatureEmail: string | AnonymousUser;
-        armoredExtendedAttributes?: string;
+        armoredExtendedAttributes: string;
     }> {
         const { armoredManifestSignature } = await this.driveCrypto.signManifest(
             manifest,
             nodeRevisionDraftKeys.signingKeys.contentSigningKey,
         );
 
-        const { armoredExtendedAttributes } = extendedAttributes
-            ? await this.driveCrypto.encryptExtendedAttributes(
-                  extendedAttributes,
-                  nodeRevisionDraftKeys.key,
-                  nodeRevisionDraftKeys.signingKeys.contentSigningKey,
-              )
-            : { armoredExtendedAttributes: undefined };
+        const { armoredExtendedAttributes } = await this.driveCrypto.encryptExtendedAttributes(
+            extendedAttributes,
+            nodeRevisionDraftKeys.key,
+            nodeRevisionDraftKeys.signingKeys.contentSigningKey,
+        );
 
         return {
             armoredManifestSignature,

package/src/internal/upload/fileUploader.ts

@@ -13,9 +13,9 @@ import { UploadTelemetry } from './telemetry';
  * and initiate the upload process for a file object or a stream.
  *
  * This class is not meant to be used directly, but rather to be extended
- * by `FileUploader` and `FileRevisionUploader`.
+ * by `FileUploader`, `FileRevisionUploader`, or `SmallFileUploader`.
  */
-abstract class Uploader {
+export abstract class Uploader {
     protected controller: UploadController;
     protected abortController: AbortController;
 
@@ -51,9 +51,9 @@ abstract class Uploader {
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
     ): Promise<UploadController> {
-        if (this.controller.promise) {
-            throw new Error(`Upload already started`);
-        }
+        this.assertNotStartedYet();
+        this.assertUniqueThumbnailTypes(thumbnails);
+
         if (!this.metadata.mediaType) {
             this.metadata.mediaType = fileObject.type;
         }
@@ -72,11 +72,24 @@ abstract class Uploader {
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
     ): Promise<UploadController> {
+        this.assertNotStartedYet();
+        this.assertUniqueThumbnailTypes(thumbnails);
+
+        this.controller.promise = this.startUpload(stream, thumbnails, onProgress);
+        return this.controller;
+    }
+
+    private assertNotStartedYet(): void {
         if (this.controller.promise) {
             throw new Error(`Upload already started`);
         }
-        this.controller.promise = this.startUpload(stream, thumbnails, onProgress);
-        return this.controller;
+    }
+
+    private assertUniqueThumbnailTypes(thumbnails: Thumbnail[]): void {
+        const uniqueThumbnailTypes = new Set(thumbnails.map(({ type }) => type));
+        if (uniqueThumbnailTypes.size !== thumbnails.length) {
+            throw new Error('Duplicate thumbnail types');
+        }
     }
 
     protected async startUpload(

package/src/internal/upload/index.test.ts

@@ -0,0 +1,99 @@
+import { FeatureFlagProvider, FeatureFlags, UploadMetadata } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { FileRevisionUploader, FileUploader } from './fileUploader';
+import { initUploadModule } from './index';
+import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
+
+const SMALL_FILE_SIZE_LIMIT = 128 * 1024; // 128 KiB, must match index.ts
+
+describe('initUploadModule - uploader selection', () => {
+    const parentFolderUid = 'parent-folder-uid';
+    const name = 'test-file.txt';
+    const nodeUid = 'node-uid';
+
+    let featureFlagProvider: jest.Mocked<FeatureFlagProvider>;
+    let uploadModule: ReturnType<typeof initUploadModule>;
+
+    beforeEach(() => {
+        const apiService = {};
+        const driveCrypto = {};
+        const sharesService = {};
+        const nodesService = {};
+        featureFlagProvider = {
+            isEnabled: jest.fn().mockResolvedValue(true),
+        };
+
+        uploadModule = initUploadModule(
+            getMockTelemetry(),
+            apiService as any,
+            driveCrypto as any,
+            sharesService as any,
+            nodesService as any,
+            featureFlagProvider as any,
+        );
+    });
+
+    describe('getFileUploader', () => {
+        it('returns SmallFileUploader when feature flag is enabled and file size is below limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileUploader(parentFolderUid, name, metadata);
+
+            expect(uploader).toBeInstanceOf(SmallFileUploader);
+        });
+
+        it('returns FileUploader when feature flag is enabled but file size exceeds limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = {
+                expectedSize: SMALL_FILE_SIZE_LIMIT,
+                mediaType: 'text/plain',
+            };
+            const uploader = await uploadModule.getFileUploader(parentFolderUid, name, metadata);
+
+            expect(uploader).toBeInstanceOf(FileUploader);
+        });
+
+        it('returns FileUploader when feature flag is disabled even for small file', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(false);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileUploader(parentFolderUid, name, metadata);
+
+            expect(uploader).toBeInstanceOf(FileUploader);
+        });
+    });
+
+    describe('getFileRevisionUploader', () => {
+        it('returns SmallFileRevisionUploader when feature flag is enabled and file size is below limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileRevisionUploader(nodeUid, metadata);
+
+            expect(uploader).toBeInstanceOf(SmallFileRevisionUploader);
+        });
+
+        it('returns FileRevisionUploader when feature flag is enabled but file size exceeds limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = {
+                expectedSize: SMALL_FILE_SIZE_LIMIT + 1,
+                mediaType: 'text/plain',
+            };
+            const uploader = await uploadModule.getFileRevisionUploader(nodeUid, metadata);
+
+            expect(uploader).toBeInstanceOf(FileRevisionUploader);
+        });
+
+        it('returns FileRevisionUploader when feature flag is disabled even for small file', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(false);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileRevisionUploader(nodeUid, metadata);
+
+            expect(uploader).toBeInstanceOf(FileRevisionUploader);
+        });
+    });
+});

package/src/internal/upload/index.ts

@@ -1,14 +1,18 @@
-import { FeatureFlagProvider, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
+import { FeatureFlagProvider, FeatureFlags, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
+import type { FileUploader } from '../../interface';
 import { DriveAPIService } from '../apiService';
 import { DriveCrypto } from '../../crypto';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
-import { FileUploader, FileRevisionUploader } from './fileUploader';
+import { FileUploader as FileUploaderClass, FileRevisionUploader } from './fileUploader';
 import { NodesService, SharesService } from './interface';
 import { UploadManager } from './manager';
 import { UploadQueue } from './queue';
+import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
 import { UploadTelemetry } from './telemetry';
 
+const SMALL_FILE_SIZE_LIMIT = 128 * 1024; // 128 KiB
+
 /**
  * Provides facade for the upload module.
  *
@@ -24,6 +28,7 @@ export function initUploadModule(
     nodesService: NodesService,
     featureFlagProvider: FeatureFlagProvider,
     clientUid?: string,
+    allowSmallFileUpload: boolean = true,
 ) {
     const api = new UploadAPIService(apiService, clientUid);
     const cryptoService = new UploadCryptoService(telemetry, driveCrypto, nodesService, featureFlagProvider);
@@ -33,6 +38,15 @@ export function initUploadModule(
 
     const queue = new UploadQueue();
 
+    async function useSmallFileUpload(metadata: UploadMetadata): Promise<boolean> {
+        const isEnabled =
+            allowSmallFileUpload && (await featureFlagProvider.isEnabled(FeatureFlags.DriveSmallFileUpload));
+        if (!isEnabled) {
+            return false;
+        }
+        return metadata.expectedSize < SMALL_FILE_SIZE_LIMIT;
+    }
+
     /**
      * Returns a FileUploader instance that can be used to upload a file to
      * a parent folder.
@@ -52,7 +66,21 @@ export function initUploadModule(
             queue.releaseCapacity(metadata.expectedSize);
         };
 
-        return new FileUploader(
+        if (await useSmallFileUpload(metadata)) {
+            return new SmallFileUploader(
+                uploadTelemetry,
+                api,
+                cryptoService,
+                manager,
+                metadata,
+                onFinish,
+                signal,
+                parentFolderUid,
+                name,
+            );
+        }
+
+        return new FileUploaderClass(
             uploadTelemetry,
             api,
             cryptoService,
@@ -76,13 +104,26 @@ export function initUploadModule(
         nodeUid: string,
         metadata: UploadMetadata,
         signal?: AbortSignal,
-    ): Promise<FileRevisionUploader> {
+    ): Promise<FileUploader> {
         await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
             queue.releaseCapacity(metadata.expectedSize);
         };
 
+        if (await useSmallFileUpload(metadata)) {
+            return new SmallFileRevisionUploader(
+                uploadTelemetry,
+                api,
+                cryptoService,
+                manager,
+                metadata,
+                onFinish,
+                signal,
+                nodeUid,
+            );
+        }
+
         return new FileRevisionUploader(
             uploadTelemetry,
             api,

package/src/internal/upload/interface.ts

@@ -40,6 +40,7 @@ export type NodeCrypto = {
     };
     contentKey: {
         encrypted: {
+            contentKeyPacket: Uint8Array<ArrayBuffer>;
             base64ContentKeyPacket: string;
             armoredContentKeyPacketSignature: string;
         };
@@ -100,6 +101,7 @@ export interface NodesService {
     getNodeKeys(nodeUid: string): Promise<{
         key: PrivateKey;
         passphraseSessionKey: SessionKey;
+        contentKeyPacket?: Uint8Array<ArrayBuffer>;
         contentKeyPacketSessionKey?: SessionKey;
         hashKey?: Uint8Array<ArrayBuffer>;
     }>;