spec-3nweb-server 1.8.5 → 1.8.7

package/ts-code/tests/protocols/3nstorage/owner.ts

@@ -0,0 +1,198 @@
+/*
+ Copyright (C) 2016, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { afterAllAsync, beforeAllAsync, itAsync } from '../../libs-for-tests/async-jasmine';
+import { StorageComponent } from '../../libs-for-tests/server-components/3nstorage';
+import { User, doMailerIdLogin } from '../../libs-for-tests/mailerid';
+import { midLoginSpecs } from '../../shared-checks/check-mid-login';
+import { resolve as resolveUrl } from 'url';
+import * as api from '../../../lib-common/service-api/3nstorage/owner';
+import { RequestOpts, doBodylessRequest, doJsonRequest } from '../../libs-for-tests/xhr-utils';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfNonEmptyBody, expectNonAcceptanceOfBadJsonRequest } from '../../shared-checks/requests';
+import { startSession } from './owner/test-utils';
+import { join as joinPaths } from 'path';
+import { addSpecsFrom } from '../../libs-for-tests/spec-assembly';
+import { deepEqual }  from '../../libs-for-tests/json-equal';
+
+const SPECS_FOLDER = joinPaths(__dirname, './owner/specs');
+
+describe('3NStorage owner service', () => {
+	
+	let storageServer: StorageComponent;
+	const midServiceDomain = 'localhost';
+	const signupDomains = [ 'company.inc', 'personal.net' ];
+	let user: User;
+	
+	beforeAllAsync(async () => {
+		storageServer = new StorageComponent(signupDomains, midServiceDomain);
+		await storageServer.start();
+		user = await storageServer.addUser(
+			`Bob Johnson @${signupDomains[0]}`);
+		await storageServer.stop(false);
+	});
+	
+	afterAllAsync(async () => {
+		if (storageServer.isRunning()) {
+			await storageServer.stop();
+		} else {
+			await storageServer.clean();
+		}
+		storageServer = (undefined as any);
+	});
+	
+	describe('session', () => {
+
+		beforeAllAsync(async () => {
+			await storageServer.restart();
+		});
+
+		describe('MailerId login', midLoginSpecs(
+			() => resolveUrl(user.storageOwnerUrl, api.midLogin.URL_PART),
+			() => user
+		));
+		
+		itAsync('closing', async () => {
+			const sessionId = await startSession(user);
+			
+			const reqOpts: RequestOpts = {
+				url: resolveUrl(user.storageOwnerUrl, api.closeSession.URL_END),
+				method: 'POST',
+				sessionId
+			};
+			
+			// normal closing of a session
+			let rep = await doBodylessRequest<void>(reqOpts);
+			expect(rep.status).withContext('status for successful closing of session').toBe(200);
+			
+			// repeated call should see invalid session respose
+			rep = await doBodylessRequest<void>(reqOpts);
+			expect(rep.status).toBe(api.ERR_SC.needAuth);
+			
+			reqOpts.sessionId = await doMailerIdLogin(
+				resolveUrl(user.storageOwnerUrl, api.midLogin.URL_PART),
+				user
+			);
+			
+			await expectNonAcceptanceOfNonEmptyBody(reqOpts);
+			
+			await expectNonAcceptanceOfBadSessionId(reqOpts);
+			
+		});
+	
+		itAsync('dictates parameters to client side', async () => {
+			const ownerUrl = user.storageOwnerUrl;
+			const sessionId = await startSession(user);
+			
+			const reqOpts: RequestOpts = {
+				url: resolveUrl(ownerUrl, api.sessionParams.URL_END),
+				method: 'GET',
+				responseType: 'json',
+				sessionId
+			};
+			
+			const rep = await doBodylessRequest<api.sessionParams.Reply>(reqOpts);
+			expect(rep.status).withContext('for successful getting of session parameters').toBe(200);
+			expect(typeof rep.data.maxChunkSize).toBe('number');
+			expect(rep.data.maxChunkSize).not.toBeLessThan(64*1024);
+			
+			await expectNonAcceptanceOfBadSessionId(reqOpts);
+			
+		});
+
+	});
+
+	function checkParamRoutes(
+		paramUrlPart: string, goodValues: any[], badValues: any[],
+		maxBodyLen: number
+	): () => void {
+		return () => {
+			
+			let sessionId: string;
+			
+			beforeAllAsync(async () => {
+				sessionId = await startSession(user); 
+			});
+			
+			itAsync('is readable', async () => {
+				
+				const reqOpts: RequestOpts = {
+					url: resolveUrl(user.storageOwnerUrl, paramUrlPart),
+					method: 'GET',
+					responseType: 'json',
+					sessionId
+				};
+				
+				const rep = await doBodylessRequest<any>(reqOpts);
+				expect(rep.status).withContext('status for reading parameter').toBe(api.PARAM_SC.ok);
+		
+				await expectNonAcceptanceOfBadSessionId(reqOpts);
+				
+			});
+			
+			async function getParam(): Promise<any> {
+				const reqOpts: RequestOpts = {
+					url: resolveUrl(user.storageOwnerUrl, paramUrlPart),
+					method: 'GET',
+					responseType: 'json',
+					sessionId
+				};
+				const rep = await doBodylessRequest<any>(reqOpts);
+				expect(rep.status).toBe(api.PARAM_SC.ok);
+				return rep.data;
+			}
+			
+			itAsync('is writable', async () => {
+				
+				const initValue = await getParam();
+				
+				const reqOpts: RequestOpts = {
+					url: resolveUrl(user.storageOwnerUrl, paramUrlPart),
+					method: 'PUT',
+					sessionId
+				};
+				
+				for (const paramVal of goodValues) {
+					
+					const rep = await doJsonRequest<void>(reqOpts, paramVal);
+					expect(rep.status).withContext('status for successful parameter value update').toBe(api.PARAM_SC.ok);
+					
+					const paramOnServer = await getParam();
+					expect(deepEqual(paramVal, paramOnServer)).withContext('parameter value on the server should be set to new value').toBe(true);
+					
+				}
+				
+				await expectNonAcceptanceOfBadJsonRequest(
+					reqOpts, maxBodyLen, badValues
+				);
+				
+				await expectNonAcceptanceOfBadSessionId(reqOpts);
+				
+			});
+			
+		}
+	}
+	
+	describe(`user's key derivation parameters`, checkParamRoutes(
+		api.keyDerivParams.URL_END,
+		[],
+		[ 1, undefined, 'string', [ 1, 2 ], [] ],
+		1024
+	));
+	
+	addSpecsFrom(SPECS_FOLDER, () => ({ user, storageServer }));
+	
+});

package/ts-code/tests/protocols/asmail/config.ts

@@ -0,0 +1,172 @@
+/*
+ Copyright (C) 2016, 2020, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { afterAllAsync, beforeAllAsync, itAsync } from '../../libs-for-tests/async-jasmine';
+import { ASMailComponent } from '../../libs-for-tests/server-components/asmail';
+import { User, doMailerIdLogin } from '../../libs-for-tests/mailerid';
+import { midLoginSpecs } from '../../shared-checks/check-mid-login';
+import * as api from '../../../lib-common/service-api/asmail/config';
+import { doJsonRequest, RequestOpts, doBodylessRequest } from '../../libs-for-tests/xhr-utils';
+import { expectNonAcceptanceOfBadJsonRequest, expectNonAcceptanceOfNonEmptyBody, expectNonAcceptanceOfBadSessionId } from '../../shared-checks/requests';
+import { resolve as resolveUrl } from 'url';
+import { deepEqual }  from '../../libs-for-tests/json-equal';
+
+describe('ASMail configuration', () => {
+	
+	let asmailServer: ASMailComponent;
+	const midServiceDomain = 'localhost';
+	const signupDomains = [ 'company.inc', 'personal.net' ];
+	let user1: User;
+	let confUrl: string;
+	
+	beforeAllAsync(async () => {
+		asmailServer = new ASMailComponent(signupDomains, midServiceDomain);
+		await asmailServer.start();
+		confUrl = await asmailServer.getConfUrl();
+		if (!confUrl.endsWith('/')) { confUrl += '/'; }
+		user1 = await asmailServer.addUser(`Bob Johnson @${signupDomains[0]}`);
+	});
+	
+	afterAllAsync(async () => {
+		await asmailServer.stop();
+		asmailServer = (undefined as any);
+	});
+	
+	describe('MailerId login', midLoginSpecs(
+		() => resolveUrl(confUrl, api.midLogin.URL_PART),
+		() => user1
+	));
+	
+	async function startSession(user: User): Promise<string> {
+		return await doMailerIdLogin(
+			resolveUrl(confUrl, api.midLogin.URL_PART),
+			user
+		);
+	}
+
+	function checkParamRoutes(
+		paramUrlPart: string, goodValues: any[], badValues: any[],
+		maxBodyLen: number
+	): () => void {
+		return () => {
+			
+			let sessionId: string;
+			
+			beforeAllAsync(async () => {
+				sessionId = await startSession(user1); 
+			});
+			
+			itAsync('is readable', async () => {
+				
+				const reqOpts: RequestOpts = {
+					url: resolveUrl(confUrl, paramUrlPart),
+					method: 'GET',
+					responseType: 'json',
+					sessionId
+				};
+				
+				const rep = await doBodylessRequest<any>(reqOpts);
+				expect(rep.status).withContext('status for reading parameter').toBe(api.PARAM_SC.ok);
+		
+				await expectNonAcceptanceOfBadSessionId(reqOpts);
+				
+			});
+			
+			async function getParam(): Promise<any> {
+				const reqOpts: RequestOpts = {
+					url: resolveUrl(confUrl, paramUrlPart),
+					method: 'GET',
+					responseType: 'json',
+					sessionId
+				};
+				const rep = await doBodylessRequest<any>(reqOpts);
+				expect(rep.status).toBe(api.PARAM_SC.ok);
+				return rep.data;
+			}
+			
+			itAsync('is writable', async () => {
+				
+				const reqOpts: RequestOpts = {
+					url: resolveUrl(confUrl, paramUrlPart),
+					method: 'PUT',
+					sessionId
+				};
+				
+				for (const paramVal of goodValues) {
+					
+					const rep = await doJsonRequest<void>(reqOpts, paramVal);
+					expect(rep.status).withContext('status for successful parameter value update').toBe(api.PARAM_SC.ok);
+					
+					const paramOnServer = await getParam();
+					expect(deepEqual(paramVal, paramOnServer)).withContext('parameter value on the server should be set to new value').toBe(true);
+					
+				}
+				
+				await expectNonAcceptanceOfBadJsonRequest(
+					reqOpts, maxBodyLen, badValues
+				);
+				
+				await expectNonAcceptanceOfBadSessionId(reqOpts);
+				
+			});
+			
+		}
+	}
+	
+	// TODO add route checking for other parameters,
+	//		write stricter good/bad values that go into the check
+	
+	describe(`user's initial public key`, checkParamRoutes(
+		api.p.initPubKey.URL_END,
+		[],
+		[ 1, undefined, 'string', [ 1, 2 ], [] ],
+		4*1024
+	));
+	
+	describe(`invites for anonymous senders`, checkParamRoutes(
+		api.p.anonSenderInvites.URL_END,
+		[ {} ],
+		[ 1, null, undefined, 'string' ],
+		40*1024
+	));
+	
+	itAsync(`closing session`, async () => {
+		const sessionId = await startSession(user1);
+		
+		const reqOpts: RequestOpts = {
+			url: resolveUrl(confUrl, api.closeSession.URL_END),
+			method: 'POST',
+			sessionId
+		};
+		
+		// normal closing of a session
+		let rep = await doBodylessRequest<void>(reqOpts);
+		expect(rep.status).withContext('status for successful closing of session').toBe(200);
+		
+		// repeated call should see invalid session respose
+		rep = await doBodylessRequest<void>(reqOpts);
+		expect(rep.status).toBe(api.ERR_SC.needAuth);
+		
+		reqOpts.sessionId = await startSession(user1);
+		
+		await expectNonAcceptanceOfNonEmptyBody(reqOpts);
+		
+		await expectNonAcceptanceOfBadSessionId(reqOpts);
+		
+	});
+	
+});

package/ts-code/tests/protocols/asmail/delivery/specs/finalize-delivery.ts

@@ -0,0 +1,69 @@
+/*
+ Copyright (C) 2016 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { SpecDescribe, TestSetup, User, msg, ASMailComponent, startSessionAndSendMsgObjs } from '../test-utils';
+import { doBodylessRequest, RequestOpts } from '../../../../libs-for-tests/xhr-utils';
+import { resolve as resolveUrl } from 'url';
+import { completion as api } from '../../../../../lib-common/service-api/asmail/delivery';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfNonEmptyBody, UNAUTHORIZED_STATUS } from '../../../../shared-checks/requests';
+import { DeliveryInfo } from '../../../../libs-for-tests/asmail';
+
+export const specs: SpecDescribe = {
+	description: `Request to complete message delivery`
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+
+	let user2: User;
+	let deliveryUrl: string;
+	let asmailServer: ASMailComponent;
+	let sessInfo: DeliveryInfo;
+	let reqOpts: RequestOpts;
+
+	beforeEachAsync(async () => {
+		user2 = setup().user2;
+		asmailServer = setup().asmailServer;
+		deliveryUrl = await asmailServer.getDeliveryUrl();
+		sessInfo = await startSessionAndSendMsgObjs(deliveryUrl, user2.id, msg);
+		reqOpts = {
+			url: resolveUrl(deliveryUrl, api.URL_END),
+			method: 'POST',
+			sessionId: sessInfo.sessionId
+		};
+	});
+	
+	itAsync(`marks message as completely delivered`, async () => {
+		expect(await asmailServer.msgExists(user2.id, sessInfo.msgId, false)).withContext('message is known to be in delivery').toBeTruthy();
+
+		let rep = await doBodylessRequest<void>(reqOpts);
+		expect(rep.status).withContext('normal end of message delivering session').toBe(api.SC.ok);
+		expect(await asmailServer.msgExists(user2.id, sessInfo.msgId, true, msg)).withContext('message must now be delivered').toBeTruthy();
+		
+		// duplicate should not work, as session is already closed
+		rep = await doBodylessRequest<void>(reqOpts);
+		expect(rep.status).toBe(UNAUTHORIZED_STATUS);
+	});
+	
+	itAsync('adequately responds to fuzzing', async () => {
+		await expectNonAcceptanceOfNonEmptyBody(reqOpts);
+		await expectNonAcceptanceOfBadSessionId(reqOpts);
+	});
+
+});
+
+Object.freeze(exports);

package/ts-code/tests/protocols/asmail/delivery/specs/provide-recipient-pubkey.ts

@@ -0,0 +1,88 @@
+/*
+ Copyright (C) 2016 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { beforeAllAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { SpecDescribe, TestSetup, User } from '../test-utils';
+import { doBodylessRequest, RequestOpts } from '../../../../libs-for-tests/xhr-utils';
+import { resolve as resolveUrl } from 'url';
+import { initPubKey as api } from '../../../../../lib-common/service-api/asmail/delivery';
+import { expectNonAcceptanceOfBadSessionId, UNAUTHORIZED_STATUS } from '../../../../shared-checks/requests';
+import { startMsgDeliverySession } from '../../../../libs-for-tests/asmail';
+import { copy } from '../../../../libs-for-tests/json-copy';
+
+export const specs: SpecDescribe = {
+	description: `Request to get recipient's registered initial key`
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+
+	let deliveryUrl: string;
+	let user1: User;
+	let user2: User;
+	let baseReqOpts: RequestOpts;
+
+	beforeAllAsync(async () => {
+		user1 = setup().user1;
+		user2 = setup().user2;
+		deliveryUrl = await setup().asmailServer.getDeliveryUrl();
+		baseReqOpts = {
+			url: resolveUrl(deliveryUrl, api.URL_END),
+			method: 'GET',
+			responseType: 'json'
+		};
+	});
+
+	itAsync(`returns certificates, registered by recipient`, async () => {
+
+		const sessInfo = await startMsgDeliverySession(
+			deliveryUrl, { recipient: user2.id });
+		const reqOpts = copy(baseReqOpts);
+		reqOpts.sessionId = sessInfo.sessionId;
+
+		const rep = await doBodylessRequest<api.Reply>(reqOpts);
+		expect(rep.status).withContext('status for successfully getting a key').toBe(api.SC.ok);
+
+		// TODO add check of certs, together with adding check in setting pkey
+		
+	});
+	
+	itAsync(`returns error, when recipient registered no certs`, async () => {
+
+		// recipient doesn't have initial public key registered
+		const sessInfo = await startMsgDeliverySession(
+			deliveryUrl, { recipient: user1.id });
+		const reqOpts = copy(baseReqOpts);
+		reqOpts.sessionId = sessInfo.sessionId;
+
+		let rep = await doBodylessRequest<api.Reply>(reqOpts);
+		expect(rep.status).withContext('status for no key registered with server').toBe(api.SC.pkeyNotRegistered);
+		
+		// session is closed, when there is no key, so repeat request is denied
+		rep = await doBodylessRequest<api.Reply>(reqOpts);
+		expect(rep.status).withContext('status for closed session').toBe(UNAUTHORIZED_STATUS);
+		
+	});
+
+	itAsync('adequately responds to fuzzing', async () => {
+		
+		await expectNonAcceptanceOfBadSessionId(baseReqOpts);
+			
+	});
+
+});
+
+Object.freeze(exports);

package/ts-code/tests/protocols/asmail/delivery/specs/put-metadata.ts

@@ -0,0 +1,102 @@
+/*
+ Copyright (C) 2016 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { beforeEachAsync, itAsync } from '../../../../libs-for-tests/async-jasmine';
+import { SpecDescribe, ASMailComponent, TestSetup, User, msg } from '../test-utils';
+import { doJsonRequest, RequestOpts } from '../../../../libs-for-tests/xhr-utils';
+import { resolve as resolveUrl } from 'url';
+import { msgMeta as api, ERR_SC } from '../../../../../lib-common/service-api/asmail/delivery';
+import { expectNonAcceptanceOfBadSessionId, expectNonAcceptanceOfBadJsonRequest } from '../../../../shared-checks/requests';
+import { startMsgDeliverySession } from '../../../../libs-for-tests/asmail';
+
+export const specs: SpecDescribe = {
+	description: `Request to put message's metadata`
+};
+
+specs.definition = (setup: () => TestSetup) => (() => {
+
+	let user2: User;
+	let reqOpts: RequestOpts;
+	let asmailServer: ASMailComponent;
+
+	beforeEachAsync(async () => {
+		user2 = setup().user2;
+		asmailServer = setup().asmailServer;
+		const deliveryUrl = await asmailServer.getDeliveryUrl();
+		const sessInfo = await startMsgDeliverySession(
+			deliveryUrl, { recipient: user2.id });
+		reqOpts = {
+			url: resolveUrl(deliveryUrl, api.URL_END),
+			method: 'PUT',
+			responseType: 'json',
+			sessionId: sessInfo.sessionId
+		};
+	});
+	
+	itAsync('starts actual message delivery, returning message id', async () => {
+		
+		const req: api.Request = {
+			pid: msg.cryptoMeta.pid,
+			objIds: [ msg.msgObjs[0].objId, msg.msgObjs[1].objId ]
+		};
+		
+		const rep = await doJsonRequest<api.Reply>(reqOpts, req);
+		expect(rep.status).withContext('status for normal meta acceptance and issue of a corresponding message id').toBe(api.SC.ok);
+		expect(typeof rep.data.msgId).toBe('string');
+		const msgId = rep.data.msgId;
+		expect(msgId.length).toBeGreaterThan(0);
+		expect(typeof rep.data.maxChunkSize).toBe('number');
+		expect(rep.data.maxChunkSize).not.toBeLessThan(64*1024);
+		expect(await asmailServer.msgExists(user2.id, msgId, false)).withContext('message is known to be in delivery').toBeTruthy();
+		
+	});
+	
+	itAsync('is not allowing message with object ids that are either same, or have chars not from base64 url-safe alphabet', async () => {
+
+		// request with object ids, exact to letter case
+		const req: api.Request = {
+			pid: msg.cryptoMeta.pid,
+			objIds: [ msg.msgObjs[0].objId, msg.msgObjs[0].objId.toLowerCase() ]
+		};
+
+		let rep = await doJsonRequest<api.Reply>(reqOpts, req);
+		expect(rep.status).withContext('same object ids are not allowed').toBe(ERR_SC.malformed);
+		
+		req.objIds = [ msg.msgObjs[0].objId, msg.msgObjs[0].objId+'+as' ];
+		rep = await doJsonRequest<api.Reply>(reqOpts, req);
+		expect(rep.status).withContext('object ids, equal to letter case, are not allowed').toBe(ERR_SC.malformed);
+		
+	});
+
+	itAsync('adequately responds to fuzzing', async () => {
+
+		// bad JSON's
+		const REQ_SIZE_LIMIT = 16*1024;
+		const badJSONs: any[] = [ null, undefined, 1, 'string',
+			// XXX add meta checks to screen out these
+			// [1,2], [], { a:1, b:2 }
+			];
+		await expectNonAcceptanceOfBadJsonRequest(reqOpts, REQ_SIZE_LIMIT,
+			badJSONs);
+		
+		await expectNonAcceptanceOfBadSessionId(reqOpts, true);
+		
+	});
+
+});
+
+Object.freeze(exports);