@expo/build-tools 21.0.1 → 21.0.3

package/resources/record-sim/Sources/RecordSim/SimulatorRecorder.swift

@@ -7,6 +7,7 @@ import UniformTypeIdentifiers
 public final class SimulatorRecorder {
     public var onSegment: ((SegmentOutput) -> Void)?
     public var onSimulatorStopped: ((String) -> Void)?
+    public var onFinalizationStage: ((RecordingFinalizationStage) -> Void)?
 
     private static let callbackStalenessTimeout: TimeInterval = 5
     private static let firstFrameRewireInterval: TimeInterval = 1
@@ -26,6 +27,8 @@ public final class SimulatorRecorder {
     private var monotonicClock = MonotonicClock()
     private var firstAcceptedCaptureTime: CMTime?
     private var firstAcceptedWallClock: Date?
+    private var recordingWidth: Int?
+    private var recordingHeight: Int?
     private var lastPTS: CMTime?
     private var lastSeed: UInt32?
     private var lastFrameCallbackElapsed: TimeInterval?
@@ -113,6 +116,7 @@ public final class SimulatorRecorder {
             displaySource?.stop()
             displaySource = nil
         }
+        onFinalizationStage?(.captureStopped)
 
         return try writerQueue.sync {
             if let firstError {
@@ -139,12 +143,18 @@ public final class SimulatorRecorder {
             if let error = outputWriter.error {
                 throw error
             }
+            onFinalizationStage?(.videoSaved)
             guard let firstAcceptedWallClock else {
                 throw RecorderError.make(25, "Missing first frame wall-clock timestamp")
             }
+            guard let recordingWidth, let recordingHeight else {
+                throw RecorderError.make(27, "Missing recording dimensions")
+            }
             return try outputWriter.writeManifest(
                 configuration: configuration,
-                firstFrameWallClock: firstAcceptedWallClock
+                firstFrameWallClock: firstAcceptedWallClock,
+                width: recordingWidth,
+                height: recordingHeight
             )
         }
     }
@@ -590,6 +600,8 @@ public final class SimulatorRecorder {
         self.writer = writer
         self.input = input
         self.adaptor = adaptor
+        recordingWidth = width
+        recordingHeight = height
     }
 
     private func assetWriterSettings(width: Int, height: Int) -> [String: Any] {

package/resources/record-sim/Sources/record-sim/main.swift

@@ -10,15 +10,15 @@ struct CLIOptions {
     var codec: RecorderCodec = .h264
 }
 
-private var stopRequested: CInt = 0
+private var requestedStopSignal: CInt = 0
 private var simulatorStopped: CInt = 0
 
-private func handleStopSignal(_: CInt) {
-    stopRequested = 1
+private func handleStopSignal(_ signal: CInt) {
+    requestedStopSignal = signal
 }
 
 private func isStopRequested() -> Bool {
-    stopRequested != 0 || simulatorStopped != 0
+    requestedStopSignal != 0 || simulatorStopped != 0
 }
 
 func usage() -> String {
@@ -112,6 +112,14 @@ do {
         simulatorStopped = 1
         fputs("[record-sim] simulator stopped state=\(state); finalizing recording\n", stderr)
     }
+    recorder.onFinalizationStage = { stage in
+        switch stage {
+        case .captureStopped:
+            fputs("[record-sim] screen capture stopped; saving final video\n", stderr)
+        case .videoSaved:
+            fputs("[record-sim] final video saved; writing recording details\n", stderr)
+        }
+    }
     recorder.onSegment = { segment in
         switch segment.kind {
         case .initialization:
@@ -130,6 +138,14 @@ do {
         Thread.sleep(forTimeInterval: 0.1)
     }
 
+    if requestedStopSignal != 0 {
+        let signalName = switch requestedStopSignal {
+        case SIGINT: "SIGINT"
+        case SIGTERM: "SIGTERM"
+        default: "signal \(requestedStopSignal)"
+        }
+        fputs("[record-sim] received \(signalName); finishing recording\n", stderr)
+    }
     let manifest = try recorder.stop()
     if let recording = manifest.recording {
         fputs("[record-sim] done recording=\(recording)\n", stderr)

package/dist/gcs/__unit__/gcs.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gcs/__unit__/gcs.test.js

@@ -1,335 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = require("crypto");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const path_1 = __importDefault(require("path"));
-const stream_1 = require("stream");
-const client_1 = __importDefault(require("../client"));
-jest.mock('node-fetch');
-class ErrorWithCode extends Error {
-    _code;
-    constructor(message, code) {
-        super(message);
-        if (code) {
-            this._code = code;
-        }
-    }
-    get code() {
-        return this._code;
-    }
-}
-class DNSError extends ErrorWithCode {
-    _code = 'ENOTFOUND';
-}
-const TEST_BUCKET = 'turtle-v2-test';
-let googleApplicationCredentials;
-beforeAll(() => {
-    googleApplicationCredentials = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    process.env.GOOGLE_APPLICATION_CREDENTIALS = path_1.default.join(__dirname, 'mock-credentials.json');
-});
-afterAll(() => {
-    process.env.GOOGLE_APPLICATION_CREDENTIALS = googleApplicationCredentials;
-});
-describe('GCS client', () => {
-    describe('uploadWithPresignedURL function', () => {
-        it('should throw an error if upload fails', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: false,
-                status: 500,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock.mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow();
-        });
-        it('should return stripped URL if successful', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock.mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-        });
-        it('should retry upload on DNS error up to 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed once');
-            })
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed twice', 'EAI_AGAIN');
-            })
-                .mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should retry upload on retriable status codes error up to 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 408,
-                };
-            })
-                .mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should retry upload on retriable status codes and DNS errors error up to 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed once');
-            })
-                .mockImplementation(async () => res);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/cat.jpg');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should not retry upload on DNS error more than 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            const lastDNSError = new DNSError('failed thrice');
-            fetchMock
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed once');
-            })
-                .mockImplementationOnce(async () => {
-                throw new DNSError('failed twice', 'EAI_AGAIN');
-            })
-                .mockImplementationOnce(async () => {
-                throw lastDNSError;
-            })
-                .mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow(lastDNSError);
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should not retry upload on retriable status code more than 2 times', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            fetchMock
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 408,
-                };
-            })
-                .mockImplementationOnce(async () => {
-                return {
-                    ok: false,
-                    status: 504,
-                };
-            })
-                .mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow();
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-        });
-        it('should not retry upload on other error codes', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const res = {
-                ok: true,
-                status: 200,
-            };
-            const localImagePath = path_1.default.join(__dirname, 'cat.jpg');
-            const key = 'cat.jpg';
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key,
-                expirationTime: 30000,
-                contentType: 'image/jpeg',
-            });
-            const nonDNSError = new ErrorWithCode('failed once', 'A_DIFFERENT_CODE');
-            fetchMock
-                .mockImplementationOnce(async () => {
-                throw nonDNSError;
-            })
-                .mockImplementation(async () => res);
-            await expect(client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => fs_extra_1.default.createReadStream(localImagePath),
-                retryIntervalMs: 500,
-            })).rejects.toThrow(nonDNSError);
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-        });
-        it('retries upload with full stream', async () => {
-            const fetchMock = jest.mocked(node_fetch_1.default);
-            const receivedBodies = [];
-            const recordBody = async (request) => {
-                let body = Buffer.from([]);
-                for await (const chunk of request.body) {
-                    body = Buffer.concat([body, chunk]);
-                }
-                receivedBodies.push(body);
-            };
-            fetchMock
-                .mockImplementationOnce(async (_path, request) => {
-                await recordBody(request);
-                return {
-                    ok: false,
-                    status: 503,
-                };
-            })
-                .mockImplementationOnce(async (_path, request) => {
-                await recordBody(request);
-                throw new DNSError('failed once');
-            })
-                .mockImplementation(async (_path, request) => {
-                await recordBody(request);
-                return {
-                    ok: true,
-                    status: 201,
-                };
-            });
-            const gcs = new client_1.default(TEST_BUCKET);
-            const signedUrl = await gcs.createSignedUploadUrl({
-                key: 'text.txt',
-                expirationTime: 30000,
-                contentType: 'text/plain',
-            });
-            const bufferToUpload = (0, crypto_1.randomBytes)(16);
-            const result = await client_1.default.uploadWithSignedUrl({
-                signedUrl,
-                srcGeneratorAsync: async () => stream_1.Readable.from(bufferToUpload),
-                retryIntervalMs: 500,
-            });
-            expect(result).toEqual('https://storage.googleapis.com/turtle-v2-test/text.txt');
-            expect(fetchMock).toHaveBeenCalledTimes(3);
-            expect(receivedBodies.length).toBe(3);
-            for (const body of receivedBodies) {
-                // Here we're testing that each body received in every retry is the same.
-                // If we passed the same body instance to each of the retries
-                // each retry would consume a chunk of the same stream,
-                // causing the uploaded file to be corrupted (missing first bytes).
-                expect(body).toStrictEqual(bufferToUpload);
-            }
-        });
-    });
-});

package/dist/gcs/client.d.ts

@@ -1,58 +0,0 @@
-import { CreateWriteStreamOptions, File } from '@google-cloud/storage';
-import { Readable } from 'stream';
-import { RetryOptions } from './retry';
-interface SignedUrlParams {
-    key: string;
-    expirationTime: number;
-    contentType?: string;
-    extensionHeaders?: {
-        [key: string]: number | string | string[];
-    };
-}
-interface UploadWithSignedUrlParams {
-    signedUrl: GCS.SignedUrl;
-    srcGeneratorAsync: () => Promise<Readable>;
-    retryIntervalMs?: RetryOptions['retryIntervalMs'];
-    retries?: RetryOptions['retries'];
-}
-declare class GCS {
-    private readonly bucket;
-    private readonly client;
-    constructor(bucket: string);
-    static uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries, retryIntervalMs, }: UploadWithSignedUrlParams): Promise<string>;
-    formatHttpUrl(key: string): string;
-    uploadFile({ key, src, streamOptions, }: {
-        key: string;
-        src: Readable;
-        streamOptions?: CreateWriteStreamOptions;
-    }): Promise<{
-        Location: string;
-    }>;
-    deleteFile(key: string): Promise<void>;
-    createSignedUploadUrl({ key, expirationTime, contentType, extensionHeaders, }: SignedUrlParams): Promise<GCS.SignedUrl>;
-    createSignedDownloadUrl({ key, expirationTime, }: {
-        key: string;
-        expirationTime: number;
-    }): Promise<string>;
-    checkIfFileExists(key: string, fileHash?: string): Promise<boolean>;
-    listDirectory(prefix: string): Promise<string[]>;
-    moveFile(src: string, dest: string): Promise<void>;
-    deleteFiles(keys: string[]): Promise<void>;
-    downloadFile(key: string, destinationPath: string): Promise<void>;
-    getFile(key: string): File;
-}
-declare namespace GCS {
-    interface SignedUrl {
-        url: string;
-        headers: {
-            [key: string]: string;
-        };
-    }
-    interface Config {
-        accessKeyId: string;
-        secretAccessKey: string;
-        region: string;
-        bucket: string;
-    }
-}
-export default GCS;

package/dist/gcs/client.js

@@ -1,173 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const storage_1 = require("@google-cloud/storage");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_fetch_1 = __importStar(require("node-fetch"));
-const node_stream_1 = __importDefault(require("node:stream"));
-const node_util_1 = require("node:util");
-const url_1 = require("url");
-const retry_1 = require("./retry");
-const pipeline = (0, node_util_1.promisify)(node_stream_1.default.pipeline);
-class GCS {
-    bucket;
-    client = new storage_1.Storage();
-    constructor(bucket) {
-        this.bucket = bucket;
-        this.bucket = bucket;
-    }
-    static async uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
-        let resp;
-        try {
-            resp = await (0, retry_1.retryOnGCSUploadFailure)(async () => {
-                const src = await srcGeneratorAsync();
-                return await (0, node_fetch_1.default)(signedUrl.url, {
-                    method: 'PUT',
-                    headers: signedUrl.headers,
-                    body: src,
-                });
-            }, {
-                retries,
-                retryIntervalMs,
-            });
-        }
-        catch (err) {
-            if (err instanceof node_fetch_1.FetchError) {
-                throw new Error(`Failed to upload the file, reason: ${err.code}`);
-            }
-            else {
-                throw err;
-            }
-        }
-        if (!resp.ok) {
-            let body;
-            try {
-                body = await resp.text();
-            }
-            catch { }
-            throw new Error(`Failed to upload file: status: ${resp.status} status text: ${resp.statusText}, body: ${body}`);
-        }
-        const url = new url_1.URL(signedUrl.url);
-        return `${url.protocol}//${url.host}${url.pathname}`; // strip query string
-    }
-    formatHttpUrl(key) {
-        return this.client.bucket(this.bucket).file(key).publicUrl();
-    }
-    async uploadFile({ key, src, streamOptions, }) {
-        const file = this.client.bucket(this.bucket).file(key);
-        await new Promise((res, rej) => {
-            src.pipe(file
-                .createWriteStream(streamOptions)
-                .on('error', err => {
-                rej(err);
-            })
-                .on('finish', () => {
-                res();
-            }));
-        });
-        return { Location: file.publicUrl() };
-    }
-    async deleteFile(key) {
-        try {
-            await this.client.bucket(this.bucket).file(key).delete();
-        }
-        catch (err) {
-            if (err.response?.statusCode === 404) {
-                return;
-            }
-            throw err;
-        }
-    }
-    async createSignedUploadUrl({ key, expirationTime, contentType, extensionHeaders = {}, }) {
-        const config = {
-            version: 'v4',
-            action: 'write',
-            expires: Date.now() + expirationTime,
-            contentType,
-            extensionHeaders,
-        };
-        const [url] = await this.client.bucket(this.bucket).file(key).getSignedUrl(config);
-        return {
-            url,
-            headers: {
-                ...(contentType ? { 'content-type': contentType } : {}),
-                ...extensionHeaders,
-            },
-        };
-    }
-    async createSignedDownloadUrl({ key, expirationTime, }) {
-        const options = {
-            version: 'v4',
-            action: 'read',
-            expires: Date.now() + expirationTime,
-        };
-        const [url] = await this.client.bucket(this.bucket).file(key).getSignedUrl(options);
-        return url;
-    }
-    async checkIfFileExists(key, fileHash) {
-        let metadata;
-        try {
-            [metadata] = await this.client.bucket(this.bucket).file(key).getMetadata();
-        }
-        catch (error) {
-            if (error.code === 404) {
-                return false;
-            }
-            throw error;
-        }
-        return fileHash ? metadata.etag === fileHash : true;
-    }
-    async listDirectory(prefix) {
-        const [files] = await this.client.bucket(this.bucket).getFiles({ prefix });
-        return files.map(x => this.formatHttpUrl(x.name));
-    }
-    async moveFile(src, dest) {
-        await this.client.bucket(this.bucket).file(src).move(dest);
-    }
-    async deleteFiles(keys) {
-        await Promise.all(keys.map(key => this.deleteFile(key)));
-    }
-    async downloadFile(key, destinationPath) {
-        const stream = this.client.bucket(this.bucket).file(key).createReadStream();
-        await pipeline(stream, fs_extra_1.default.createWriteStream(destinationPath));
-    }
-    getFile(key) {
-        return this.client.bucket(this.bucket).file(key);
-    }
-}
-exports.default = GCS;