@lockerpm/desktop-service 1.0.0

package/README.md

@@ -0,0 +1,98 @@
+# Locker Desktop Service Supporter for Desktop app
+
+## Installation
+
+Install from npm:
+
+```bash
+npm install -S locker-desktop-service
+```
+
+Install from yarn:
+
+```bash
+yarn add locker-desktop-service
+```
+
+## Usages
+
+This supporter service requires Node.js to work -> If you use this service in Electron, it must be running in main process and calling method through `ipcMain.handle()` and `ipcRenderer.invoke()`
+
+```js
+import { DesktopService, StorageService } from 'locker-desktop-service'
+import fs from 'fs'
+import path from 'path'
+import Store from 'electron-store'
+
+// Storing data secure data using electron-store, you can use others secure storage
+// or simply keep data in memory only
+class MockStorageService implements StorageService {
+  storage: Store
+  constructor() {
+    this.storage = new Store()
+  }
+  getSecure(key: string) {
+    return Promise.resolve(this.storage.get(key) || null)
+  }
+  setSecure(key: string, data: any) {
+    this.storage.set(key, data)
+    return Promise.resolve()
+  }
+  deleteSecure(key: string) {
+    this.storage.delete(key)
+    return Promise.resolve()
+  }
+}
+const storageService = new MockStorageService()
+
+// TLS cert is required to comunicate with the background service
+const rootCert = fs.readFileSync(path.resolve(process.resourcesPath, 'cert', 'ca-cert.pem'))
+
+// TLS cert to host WSS
+const cert = fs.readFileSync(path.resolve(process.resourcesPath, 'cert', 'server-cert.pem'))
+const key = fs.readFileSync(path.resolve(process.resourcesPath, 'cert', 'server-key.pem'))
+
+// Init service
+export const service = new DesktopService({
+  baseApiUrl: process.env.BASE_API_URL,
+  storageService,
+  ssl: {
+    rootCert,
+  },
+  socketSsl: {
+    cert,
+    key,
+  },
+  logLevel: 1,  // 1 is error, 2 is debug
+  unsafe: true, // set to false to enable checksum validation
+  serviceAlias: '' // optional, used to compare with service alias from background service
+})
+
+// Setup listners
+service.on('<event-name>', callback)
+```
+
+## Development
+
+Install required packages.
+```bash
+npm install
+```
+
+### Run tests
+
+Create a .env file with required access keys (refer to `.env.example`)
+
+To run all tests, use:
+```bash
+npm test
+```
+
+Run some tests only, please update `mocharc.js`:
+```js
+ignore: [
+  // './tests/index.spec.ts', // Comment the file you want to test
+  './tests/crypto.spec.ts',
+  '...'
+]
+```

package/lib/cjs/abstractions/api.service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/abstractions/crypto.service.js

@@ -0,0 +1,147 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedObject = exports.EncString = exports.SymmetricCryptoKey = exports.EncryptionType = exports.KdfType = exports.AES = exports.ECDH = void 0;
+const utils_1 = require("../misc/utils");
+exports.ECDH = {
+    name: 'ECDH',
+    namedCurve: 'P-384',
+};
+exports.AES = {
+    name: 'AES-CBC',
+};
+// -------------- CORE --------------
+var KdfType;
+(function (KdfType) {
+    KdfType[KdfType["PBKDF2_SHA256"] = 0] = "PBKDF2_SHA256";
+})(KdfType || (exports.KdfType = KdfType = {}));
+var EncryptionType;
+(function (EncryptionType) {
+    EncryptionType[EncryptionType["AesCbc256_B64"] = 0] = "AesCbc256_B64";
+    EncryptionType[EncryptionType["AesCbc128_HmacSha256_B64"] = 1] = "AesCbc128_HmacSha256_B64";
+    EncryptionType[EncryptionType["AesCbc256_HmacSha256_B64"] = 2] = "AesCbc256_HmacSha256_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha256_B64"] = 3] = "Rsa2048_OaepSha256_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha1_B64"] = 4] = "Rsa2048_OaepSha1_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha256_HmacSha256_B64"] = 5] = "Rsa2048_OaepSha256_HmacSha256_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha1_HmacSha256_B64"] = 6] = "Rsa2048_OaepSha1_HmacSha256_B64";
+})(EncryptionType || (exports.EncryptionType = EncryptionType = {}));
+class SymmetricCryptoKey {
+    constructor(key, encType) {
+        if (key == null) {
+            throw new Error('Must provide key');
+        }
+        if (encType == null) {
+            if (key.byteLength === 32) {
+                encType = EncryptionType.AesCbc256_B64;
+            }
+            else if (key.byteLength === 64) {
+                encType = EncryptionType.AesCbc256_HmacSha256_B64;
+            }
+            else {
+                throw new Error('Unable to determine encType.');
+            }
+        }
+        this.key = key;
+        this.encType = encType;
+        if (encType === EncryptionType.AesCbc256_B64 && key.byteLength === 32) {
+            this.encKey = key;
+            this.macKey = undefined;
+        }
+        else if (encType === EncryptionType.AesCbc128_HmacSha256_B64 && key.byteLength === 32) {
+            this.encKey = key.slice(0, 16);
+            this.macKey = key.slice(16, 32);
+        }
+        else if (encType === EncryptionType.AesCbc256_HmacSha256_B64 && key.byteLength === 64) {
+            this.encKey = key.slice(0, 32);
+            this.macKey = key.slice(32, 64);
+        }
+        else {
+            throw new Error('Unsupported encType/key length.');
+        }
+        if (this.key != null) {
+            this.keyB64 = utils_1.Utils.fromBufferToB64(this.key);
+        }
+        if (this.encKey != null) {
+            this.encKeyB64 = utils_1.Utils.fromBufferToB64(this.encKey);
+        }
+        if (this.macKey != null) {
+            this.macKeyB64 = utils_1.Utils.fromBufferToB64(this.macKey);
+        }
+    }
+}
+exports.SymmetricCryptoKey = SymmetricCryptoKey;
+class EncString {
+    constructor(encryptedStringOrType, data, iv, mac) {
+        if (data != null) {
+            // data and header
+            const encType = encryptedStringOrType;
+            if (iv != null) {
+                this.encryptedString = encType + '.' + iv + '|' + data;
+            }
+            else {
+                this.encryptedString = encType + '.' + data;
+            }
+            // mac
+            if (mac != null) {
+                this.encryptedString += '|' + mac;
+            }
+            this.encryptionType = encType;
+            this.data = data;
+            this.iv = iv;
+            this.mac = mac;
+            return;
+        }
+        this.encryptedString = encryptedStringOrType;
+        if (!this.encryptedString) {
+            return;
+        }
+        const headerPieces = this.encryptedString.split('.');
+        let encPieces = null;
+        if (headerPieces.length === 2) {
+            try {
+                this.encryptionType = parseInt(headerPieces[0]);
+                encPieces = headerPieces[1].split('|');
+            }
+            catch (e) {
+                return;
+            }
+        }
+        else {
+            encPieces = this.encryptedString.split('|');
+            this.encryptionType =
+                encPieces.length === 3
+                    ? EncryptionType.AesCbc128_HmacSha256_B64
+                    : EncryptionType.AesCbc256_B64;
+        }
+        switch (this.encryptionType) {
+            case EncryptionType.AesCbc128_HmacSha256_B64:
+            case EncryptionType.AesCbc256_HmacSha256_B64:
+                if (encPieces.length !== 3) {
+                    return;
+                }
+                this.iv = encPieces[0];
+                this.data = encPieces[1];
+                this.mac = encPieces[2];
+                break;
+            case EncryptionType.AesCbc256_B64:
+                if (encPieces.length !== 2) {
+                    return;
+                }
+                this.iv = encPieces[0];
+                this.data = encPieces[1];
+                break;
+            case EncryptionType.Rsa2048_OaepSha256_B64:
+            case EncryptionType.Rsa2048_OaepSha1_B64:
+                if (encPieces.length !== 1) {
+                    return;
+                }
+                this.data = encPieces[0];
+                break;
+            default:
+        }
+    }
+}
+exports.EncString = EncString;
+class EncryptedObject {
+}
+exports.EncryptedObject = EncryptedObject;

package/lib/cjs/abstractions/errors.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERRORS = exports.ServiceError = void 0;
+class ServiceError extends Error {
+    constructor(code, rawError) {
+        var _a, _b;
+        super(rawError);
+        this.rawError = rawError;
+        this.code = code;
+        const rawMessage = ((_b = (_a = rawError === null || rawError === void 0 ? void 0 : rawError.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
+            (rawError === null || rawError === void 0 ? void 0 : rawError.message) ||
+            (rawError === null || rawError === void 0 ? void 0 : rawError.toString()) ||
+            'Unknown error';
+        this.message = code === '0000' ? rawMessage : exports.ERRORS[code].message;
+    }
+    static fromError(rawError) {
+        var _a, _b;
+        const message = ((_b = (_a = rawError === null || rawError === void 0 ? void 0 : rawError.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
+            (rawError === null || rawError === void 0 ? void 0 : rawError.message) ||
+            (rawError === null || rawError === void 0 ? void 0 : rawError.toString()) ||
+            'Unknown error';
+        const error = ERRORS_LIST.filter((e) => !!e.signatures).find((e) => { var _a; return (_a = e.signatures) === null || _a === void 0 ? void 0 : _a.some((signature) => message.toLowerCase().includes(signature)); });
+        if (error) {
+            return new ServiceError(error.code, rawError);
+        }
+        return new ServiceError('0000', rawError);
+    }
+}
+exports.ServiceError = ServiceError;
+exports.ERRORS = {
+    '0000': {
+        message: 'Unspecified error',
+    },
+    // API
+    '1000': {
+        message: 'API error',
+    },
+    '1001': {
+        message: 'API token not found',
+    },
+    '1002': {
+        message: 'Passwordless is not enabled',
+    },
+    // FIDO
+    '2001': {
+        message: 'Cannot connect to fido key',
+    },
+    '2002': {
+        message: 'Cannot create credential, key return empty secret',
+    },
+    '2003': {
+        message: 'Invalid PIN',
+        signatures: ['pin invalid'],
+    },
+    '2004': {
+        message: 'Cannot find relying party',
+        signatures: ['no rp'],
+    },
+    '2005': {
+        message: 'Cannot find any valid credential in this key',
+    },
+    '2006': {
+        message: 'Cannot find the required credential in this key',
+        signatures: ['no credentials'],
+    },
+    '2007': {
+        message: 'Cannot use fingerprint, please use PIN instead',
+        signatures: ['unsupported option', 'pin required'],
+    },
+    '2008': {
+        message: 'PIN validation failed to many times, key is blocked',
+        signatures: ['pin auth blocked'],
+    },
+    '2009': {
+        message: 'Failed to verify fingerprint',
+        signatures: ['keep alive cancel'],
+    },
+    '2010': {
+        message: 'List credentials is not supported on this key',
+        signatures: ['failed to get relying party info: invalid command'],
+    },
+    '2011': {
+        message: 'FIDO action timed out',
+        signatures: ['failed to get assertion: action timed out'],
+    },
+    // PAIRING
+    '3001': {
+        message: 'Client is not confirmed',
+    },
+    // SOCKET
+    '4001': {
+        message: 'Client not found',
+    },
+    '4002': {
+        message: 'Cannot broadcast secure message',
+    },
+}; // as { [code: string]: { message: string; signatures?: string[] } }
+// @ts-ignore
+const ERRORS_LIST = Object.keys(exports.ERRORS).map((code) => (Object.assign({ code }, exports.ERRORS[code])));

package/lib/cjs/abstractions/event.service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/abstractions/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/abstractions/socket.service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOutgoingSocketMessage = void 0;
+function buildOutgoingSocketMessage(message, data, secure) {
+    return {
+        message,
+        data,
+        secure,
+    };
+}
+exports.buildOutgoingSocketMessage = buildOutgoingSocketMessage;

package/lib/cjs/abstractions/storage.service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/index.js

@@ -0,0 +1,243 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesktopService = exports.ServiceErrors = void 0;
+const socket_service_1 = require("./abstractions/socket.service");
+const api_service_1 = require("./services/api.service");
+const user_service_1 = require("./services/user.service");
+const crypto_service_1 = require("./services/crypto.service");
+const event_service_1 = require("./services/event.service");
+const fido_service_1 = require("./services/fido.service");
+const grpc_service_1 = require("./services/grpc.service");
+const log_service_1 = require("./services/log.service");
+const pairing_service_1 = require("./services/pairing.service");
+const socket_service_2 = require("./services/socket.service");
+const errors_1 = require("./abstractions/errors");
+const fido_1 = require("./usecases/fido");
+const cache_service_1 = require("./services/cache.service");
+exports.ServiceErrors = errors_1.ERRORS;
+class DesktopService {
+    // Constructor
+    constructor(params) {
+        this._interval = null;
+        const { baseApiUrl, logLevel, storageService, ssl, unsafe, apiHeaders, serviceAlias, socketSsl, } = params;
+        this.cryptoService = new crypto_service_1.CryptoService();
+        this.storageService = storageService;
+        this.logService = new log_service_1.LogService(logLevel);
+        this.eventService = new event_service_1.EventService(this.logService);
+        this.apiService = new api_service_1.ApiService({
+            baseUrl: baseApiUrl,
+            logger: this.logService,
+            headers: apiHeaders,
+        });
+        this.grpcService = new grpc_service_1.GRPCService({
+            logger: this.logService,
+            cryptoService: this.cryptoService,
+            apiService: this.apiService,
+        }, {
+            ssl,
+            unsafe,
+            serviceAlias: serviceAlias || '',
+        });
+        this.fidoService = new fido_service_1.FidoService(this.logService, this.eventService, this.grpcService);
+        this.pairingService = new pairing_service_1.PairingService({
+            cryptoService: this.cryptoService,
+            eventService: this.eventService,
+            storageService: this.storageService,
+            logger: this.logService,
+            grpcService: this.grpcService,
+        });
+        this.userService = new user_service_1.UserService({
+            logger: this.logService,
+            storageService: this.storageService,
+            grpcService: this.grpcService,
+        });
+        this.socketService = new socket_service_2.SocketService({
+            logger: this.logService,
+            pairingService: this.pairingService,
+            userService: this.userService,
+            eventService: this.eventService,
+            ssl: socketSsl,
+            serviceAlias: serviceAlias || '',
+        });
+        this.cacheService = new cache_service_1.CacheService(this.logService, this.grpcService);
+        this.waitUntilReady();
+    }
+    // ---------------------- READY STATE ----------------------
+    get isReady() {
+        const requiredService = [
+            this.grpcService,
+            this.userService,
+            this.pairingService,
+            this.socketService,
+        ];
+        return requiredService.reduce((isReady, service) => isReady && service.isReady, true);
+    }
+    waitUntilReady() {
+        return new Promise((resolve) => {
+            const step = 500;
+            const timeout = 5000;
+            let counter = 0;
+            if (this._interval) {
+                clearInterval(this._interval);
+            }
+            this._interval = setInterval(() => {
+                if (this.isReady) {
+                    this.eventService.emit('serviceReady', undefined);
+                    clearInterval(this._interval);
+                    resolve(true);
+                    return;
+                }
+                counter += step;
+                if (counter >= timeout) {
+                    this.logService.error(`Service not ready after ${timeout} ms`);
+                    clearInterval(this._interval);
+                    resolve(false);
+                }
+            }, step);
+        });
+    }
+    resetSocket() {
+        return this.socketService.initSocket();
+    }
+    resetGRPC() {
+        return this.grpcService.initConnection();
+    }
+    // ---------------------- FIDO ----------------------
+    setApiToken(token) {
+        this.apiService.setToken(token);
+    }
+    getFidoDeviceList() {
+        return this.fidoService.getDeviceList();
+    }
+    setNewPasswordless(params) {
+        return (0, fido_1.setNewPasswordless)(params, {
+            apiService: this.apiService,
+            fidoService: this.fidoService,
+        });
+    }
+    deletePasswordless() {
+        return this.apiService.deletePasswordlessCredential();
+    }
+    setBackupPasswordless(params) {
+        return (0, fido_1.setBackupPasswordless)(params, {
+            apiService: this.apiService,
+            fidoService: this.fidoService,
+            cryptoService: this.cryptoService,
+        });
+    }
+    listAllPasswordless(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [mainKey, backupKeys] = yield Promise.all([
+                this.apiService.getPasswordlessCredentials(email),
+                this.apiService.listBackupPasswordlessCredentials(),
+            ]);
+            const res = [...backupKeys];
+            if (mainKey.credential_id) {
+                res.push({
+                    id: 'primary',
+                    name: mainKey.name || '',
+                    creation_date: mainKey.creation_date,
+                    last_use_date: mainKey.last_use_date,
+                    master_password_hash: '',
+                    key: '',
+                    fd_credential_id: mainKey.credential_id,
+                    fd_random: mainKey.random || '',
+                    isPrimary: true,
+                    type: mainKey.type,
+                });
+            }
+            return res;
+        });
+    }
+    listBackupPasswordless() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiService.listBackupPasswordlessCredentials();
+        });
+    }
+    deleteBackupPasswordless(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiService.deleteBackupPasswordlessCredential(id);
+        });
+    }
+    getPasswordless(params) {
+        return (0, fido_1.getPasswordless)(params, {
+            apiService: this.apiService,
+            fidoService: this.fidoService,
+            logService: this.logService,
+        });
+    }
+    // ---------------------- PAIRING ----------------------
+    confirmPairingClient(clientId, clientType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pairingService.confirmPairingClient(clientId, clientType === 'extension');
+            this.socketService.sendMessageToClient(clientId, (0, socket_service_1.buildOutgoingSocketMessage)('pairingConfirmed', undefined));
+        });
+    }
+    resetPairingCode(clientId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.socketService.sendMessageToClient(clientId, (0, socket_service_1.buildOutgoingSocketMessage)('resetPairing', undefined));
+        });
+    }
+    sendCustomMessage(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('customMessage', data));
+        });
+    }
+    getCacheData() {
+        return this.cacheService.getCache();
+    }
+    setCacheData(data) {
+        return this.cacheService.setCache(data);
+    }
+    // ---------------------- USER ----------------------
+    getCurrentUser() {
+        return this.userService.getCurrentUser();
+    }
+    login(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.userService.login(params);
+            this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('userLogin', { email: params.email }));
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentUser = Object.assign({}, this.userService.currentUser);
+            if (currentUser === null || currentUser === void 0 ? void 0 : currentUser.email) {
+                yield this.userService.logout();
+                this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('userLogout', { email: currentUser.email }));
+            }
+        });
+    }
+    lock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentUser = Object.assign({}, this.userService.currentUser);
+            if (currentUser === null || currentUser === void 0 ? void 0 : currentUser.email) {
+                yield this.userService.lock();
+                this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('userLock', { email: currentUser.email }));
+            }
+        });
+    }
+    // ---------------------- EVENTS ----------------------
+    on(event, handler) {
+        return this.eventService.on(event, handler);
+    }
+    once(event, handler) {
+        return this.eventService.once(event, handler);
+    }
+    removeListener(event, handler) {
+        this.eventService.removeListener(event, handler);
+    }
+    removeAllListeners() {
+        this.eventService.removeAllListeners();
+    }
+}
+exports.DesktopService = DesktopService;

package/lib/cjs/misc/config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRPC_PING_TIMEOUT = exports.GRPC_CONNECTION_TIMEOUT = exports.WEBSOCKET_SSL_PORTS = exports.WEBSOCKET_PORTS = exports.HTTP_PORTS = void 0;
+exports.HTTP_PORTS = [
+    14411, 14110, 15611, 14412, 16311, 14514, 14515, 14413, 14401, 14100, 15601, 14402, 16301, 14504,
+    14505, 14403,
+];
+exports.WEBSOCKET_PORTS = [
+    10040, 10124, 10978, 11307, 11792, 21792, 10041, 10125, 10979, 11308, 11793, 21793,
+];
+exports.WEBSOCKET_SSL_PORTS = [
+    20040, 20124, 20978, 21307, 21792, 22792, 20041, 20125, 20979, 21308, 21793, 22793,
+];
+exports.GRPC_CONNECTION_TIMEOUT = 1500;
+exports.GRPC_PING_TIMEOUT = 1000;

package/lib/cjs/misc/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const os_1 = __importDefault(require("os"));
+class Utils {
+    static fromHexToArray(str) {
+        return new Uint8Array(Buffer.from(str, 'hex'));
+    }
+    static fromBufferToHex(buffer) {
+        return Buffer.from(buffer).toString('hex');
+    }
+    static fromBufferToB64(buffer) {
+        return Buffer.from(buffer).toString('base64');
+    }
+    static fromUtf8ToArray(str) {
+        return new Uint8Array(Buffer.from(str, 'utf8'));
+    }
+    static fromB64ToArray(str) {
+        return new Uint8Array(Buffer.from(str, 'base64'));
+    }
+    static getCurrentOS() {
+        const platform = os_1.default.platform();
+        const arc = os_1.default.arch();
+        let _os = 'linux';
+        if (platform === 'darwin') {
+            _os = arc === 'x64' ? 'mac-x64' : 'mac-arm64';
+        }
+        if (platform === 'win32') {
+            _os = 'windows';
+        }
+        return _os;
+    }
+}
+exports.Utils = Utils;

package/lib/cjs/proto/google/api/annotations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });