@devrev/ts-adaas 1.19.4 → 1.19.5

package/dist/repo/repo.test.js

@@ -25,13 +25,17 @@ describe(repo_1.Repo.name, () => {
         jest.clearAllMocks();
     });
     it('should normalize and push items when array contains items', async () => {
+        // Arrange
         const items = (0, test_helpers_1.createItems)(10);
+        // Act
         await repo.push(items);
+        // Assert
         expect(normalize).toHaveBeenCalledTimes(10);
         const normalizedItems = items.map((item) => (0, test_helpers_1.normalizeItem)(item));
         expect(repo.getItems()).toEqual(normalizedItems);
     });
     it('should not normalize items when normalize function is not provided', async () => {
+        // Arrange
         repo = new repo_1.Repo({
             event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
                 payload: { event_type: types_1.EventType.ExtractionDataStart },
@@ -41,14 +45,19 @@ describe(repo_1.Repo.name, () => {
             options: {},
         });
         const items = (0, test_helpers_1.createItems)(10);
+        // Act
         await repo.push(items);
+        // Assert
         expect(normalize).not.toHaveBeenCalled();
     });
     it('[edge] should not push items when items array is empty', async () => {
+        // Act
         await repo.push([]);
+        // Assert
         expect(repo.getItems()).toEqual([]);
     });
     it('should not normalize items when item type is external_domain_metadata', async () => {
+        // Arrange
         repo = new repo_1.Repo({
             event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
                 payload: { event_type: types_1.EventType.ExtractionDataStart },
@@ -59,10 +68,13 @@ describe(repo_1.Repo.name, () => {
             options: {},
         });
         const items = (0, test_helpers_1.createItems)(10);
+        // Act
         await repo.push(items);
+        // Assert
         expect(normalize).not.toHaveBeenCalled();
     });
     it('should not normalize items when item type is ssor_attachment', async () => {
+        // Arrange
         repo = new repo_1.Repo({
             event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
                 payload: { event_type: types_1.EventType.ExtractionDataStart },
@@ -73,29 +85,43 @@ describe(repo_1.Repo.name, () => {
             options: {},
         });
         const items = (0, test_helpers_1.createItems)(10);
+        // Act
         await repo.push(items);
+        // Assert
         expect(normalize).not.toHaveBeenCalled();
     });
     it('should leave 5 items in the items array after pushing 2005 items with batch size of 2000', async () => {
+        // Arrange
         const items = (0, test_helpers_1.createItems)(2005);
+        // Act
         await repo.push(items);
+        // Assert
         expect(repo.getItems().length).toBe(5);
     });
     it('should normalize all items when pushing 4005 items with batch size of 2000', async () => {
+        // Arrange
         const items = (0, test_helpers_1.createItems)(4005);
+        // Act
         await repo.push(items);
+        // Assert
         expect(normalize).toHaveBeenCalledTimes(4005);
     });
     it('should upload 2 batches when pushing 4005 items with batch size of 2000', async () => {
+        // Arrange
         const uploadSpy = jest.spyOn(repo, 'upload');
         const items = (0, test_helpers_1.createItems)(4005);
+        // Act
         await repo.push(items);
+        // Assert
         expect(uploadSpy).toHaveBeenCalledTimes(2);
         uploadSpy.mockRestore();
     });
     it('should leave 5 items in array after pushing 4005 items with batch size of 2000', async () => {
+        // Arrange
         const items = (0, test_helpers_1.createItems)(4005);
+        // Act
         await repo.push(items);
+        // Assert
         expect(repo.getItems().length).toBe(5);
     });
     describe('should take batch size into account', () => {
@@ -113,30 +139,45 @@ describe(repo_1.Repo.name, () => {
             });
         });
         it('should empty the items array after pushing 50 items with batch size of 50', async () => {
+            // Arrange
             const items = (0, test_helpers_1.createItems)(50);
+            // Act
             await repo.push(items);
+            // Assert
             expect(repo.getItems()).toEqual([]);
         });
         it('should leave 5 items in the items array after pushing 205 items with batch size of 50', async () => {
+            // Arrange
             const items = (0, test_helpers_1.createItems)(205);
+            // Act
             await repo.push(items);
+            // Assert
             expect(repo.getItems().length).toBe(5);
         });
         it('should normalize all items when pushing 205 items with batch size of 50', async () => {
+            // Arrange
             const items = (0, test_helpers_1.createItems)(205);
+            // Act
             await repo.push(items);
+            // Assert
             expect(normalize).toHaveBeenCalledTimes(205);
         });
         it('should upload 4 batches when pushing 205 items with batch size of 50', async () => {
+            // Arrange
             const uploadSpy = jest.spyOn(repo, 'upload');
             const items = (0, test_helpers_1.createItems)(205);
+            // Act
             await repo.push(items);
+            // Assert
             expect(uploadSpy).toHaveBeenCalledTimes(4);
             uploadSpy.mockRestore();
         });
         it('should leave 5 items in array after pushing 205 items with batch size of 50', async () => {
+            // Arrange
             const items = (0, test_helpers_1.createItems)(205);
+            // Act
             await repo.push(items);
+            // Assert
             expect(repo.getItems().length).toBe(5);
         });
     });

package/dist/state/state.extract-window.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.extract-window.test.d.ts.map

package/dist/state/state.extract-window.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.extract-window.test.d.ts","sourceRoot":"","sources":["../../src/state/state.extract-window.test.ts"],"names":[],"mappings":""}

package/dist/state/state.extract-window.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const state_1 = require("./state");
+describe('State — extraction window validation', () => {
+    let fetchStateSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        fetchStateSpy = jest.spyOn(state_1.State.prototype, 'fetchState');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    describe('Enhanced Control Protocol - extraction window validation', () => {
+        it('should exit the process if extract_from >= extract_to', async () => {
+            // Arrange: start is after end (inverted window)
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act & Assert
+            await expect((0, state_1.createAdapterState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            })).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should exit the process if extract_from equals extract_to', async () => {
+            // Arrange: start equals end (zero-width window)
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-06-01T00:00:00Z',
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act & Assert
+            await expect((0, state_1.createAdapterState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            })).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should not exit when extract_from < extract_to', async () => {
+            // Arrange: valid window
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, state_1.createAdapterState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: process.exit should NOT have been called
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+        it('should not validate when only extract_from is set', async () => {
+            // Arrange: only start, no end
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, state_1.createAdapterState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: process.exit should NOT have been called
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+        it('should not exit when extract_from is UNBOUNDED and extract_to is a real timestamp', async () => {
+            // Arrange: UNBOUNDED start (epoch) with a real ABSOLUTE end timestamp
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.UNBOUNDED,
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, state_1.createAdapterState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: process.exit should NOT have been called
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/state/state.pending-boundaries.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.pending-boundaries.test.d.ts.map

package/dist/state/state.pending-boundaries.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.pending-boundaries.test.d.ts","sourceRoot":"","sources":["../../src/state/state.pending-boundaries.test.ts"],"names":[],"mappings":""}

package/dist/state/state.pending-boundaries.test.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const state_1 = require("./state");
+/* eslint-disable @typescript-eslint/no-require-imports */
+const FIXED_NOW = '2026-03-26T10:00:00.000Z';
+describe('State — pending extraction boundaries', () => {
+    let postStateSpy;
+    let fetchStateSpy;
+    let installInitialDomainMappingSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        postStateSpy = jest.spyOn(state_1.State.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(state_1.State.prototype, 'fetchState');
+        installInitialDomainMappingSpy = jest.spyOn(require('../common/install-initial-domain-mapping'), 'installInitialDomainMapping');
+        jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date(FIXED_NOW));
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it('should store resolved values in pendingWorkersOldest/pendingWorkersNewest on StartExtractingMetadata', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: '',
+            },
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingMetadata,
+                event_context: {
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.UNBOUNDED,
+                    },
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                },
+            },
+        });
+        fetchStateSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        installInitialDomainMappingSpy.mockResolvedValue({ success: true });
+        postStateSpy.mockResolvedValue({ success: true });
+        // Act
+        const state = await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(state.state.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
+        expect(state.state.pendingWorkersNewest).toBe(FIXED_NOW);
+        expect(event.payload.event_context.extract_from).toBe('1970-01-01T00:00:00.000Z');
+        expect(event.payload.event_context.extract_to).toBe(FIXED_NOW);
+    });
+    it('should overwrite pending values on a retry (new StartExtractingMetadata after failure)', async () => {
+        // Arrange: state has stale pending values from a previous failed attempt
+        const staleOldest = '2026-03-25T08:00:00.000Z';
+        const staleNewest = '2026-03-25T09:00:00.000Z';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingMetadata,
+                event_context: {
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.UNBOUNDED,
+                    },
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                },
+            },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+            pendingWorkersOldest: staleOldest,
+            pendingWorkersNewest: staleNewest,
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        const state = await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: pending values are overwritten with fresh resolution, not stale values
+        expect(state.state.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
+        expect(state.state.pendingWorkersNewest).toBe(FIXED_NOW);
+        expect(state.state.pendingWorkersNewest).not.toBe(staleNewest);
+    });
+    it('should reuse pending values from state on ContinueExtractingData instead of re-resolving', async () => {
+        // Arrange: state has pending values from a prior StartExtractingMetadata phase
+        const pendingOldest = '1970-01-01T00:00:00.000Z';
+        const pendingNewest = '2026-03-26T08:00:00.000Z'; // Earlier than FIXED_NOW
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: {
+                event_type: extraction_1.EventType.ContinueExtractingData,
+                event_context: {
+                    // Platform still sends TimeValue objects, but they should be ignored
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                },
+            },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+            pendingWorkersOldest: pendingOldest,
+            pendingWorkersNewest: pendingNewest,
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        const state = await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: uses cached pending values, NOT new Date() resolution
+        expect(event.payload.event_context.extract_from).toBe(pendingOldest);
+        expect(event.payload.event_context.extract_to).toBe(pendingNewest);
+        // Pending values in state remain unchanged
+        expect(state.state.pendingWorkersOldest).toBe(pendingOldest);
+        expect(state.state.pendingWorkersNewest).toBe(pendingNewest);
+    });
+    it('should not set extract_from/extract_to on ContinueExtractingData if no pending values exist', async () => {
+        // Arrange: state has no pending values (e.g. old state from before this feature)
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: { event_type: extraction_1.EventType.ContinueExtractingData },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: no extraction timestamps are set
+        expect(event.payload.event_context.extract_from).toBeUndefined();
+        expect(event.payload.event_context.extract_to).toBeUndefined();
+    });
+    it('should reuse pending values on StartExtractingAttachments', async () => {
+        // Arrange: state has pending values from the StartExtractingMetadata phase
+        const pendingOldest = '1970-01-01T00:00:00.000Z';
+        const pendingNewest = '2026-03-26T08:00:00.000Z';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: { event_type: extraction_1.EventType.StartExtractingAttachments },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+            pendingWorkersOldest: pendingOldest,
+            pendingWorkersNewest: pendingNewest,
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: pending values are reused
+        expect(event.payload.event_context.extract_from).toBe(pendingOldest);
+        expect(event.payload.event_context.extract_to).toBe(pendingNewest);
+    });
+});

package/dist/state/state.post-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.post-state.test.d.ts.map

package/dist/state/state.post-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.post-state.test.d.ts","sourceRoot":"","sources":["../../src/state/state.post-state.test.ts"],"names":[],"mappings":""}

package/dist/state/state.post-state.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const state_1 = require("./state");
+/* eslint-disable @typescript-eslint/no-require-imports */
+describe('State.postState', () => {
+    let postStateSpy;
+    let fetchStateSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        postStateSpy = jest.spyOn(state_1.State.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(state_1.State.prototype, 'fetchState');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    it('should POST the stringified state to the update endpoint', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: '1.0.0',
+                secrets: { service_account_token: 'test_token' },
+            },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        const stateToPost = { snapInVersionId: '1.0.0', foo: 'bar' };
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+        });
+        postStateSpy.mockRestore();
+        const adapterState = await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Act
+        await adapterState.postState(stateToPost);
+        // Assert: the mock server records all incoming requests — inspect what was sent
+        const requests = jest_setup_1.mockServer.getRequests('POST', '/worker_data_url.update');
+        expect(requests).toHaveLength(1);
+        const body = requests[0].body;
+        // Body must contain the stringified state, preserving the original fields
+        expect(typeof body.state).toBe('string');
+        const parsed = JSON.parse(body.state);
+        expect(parsed.foo).toBe('bar');
+        expect(parsed.snapInVersionId).toBe('1.0.0');
+    });
+    it('should exit(1) when postState HTTP request fails', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: { snap_in_version_id: '1.0.0' },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+        });
+        postStateSpy.mockRestore();
+        const adapterState = await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Mock axiosClient.post directly to bypass the retry backoff
+        const axiosClientModule = require('../http/axios-client-internal');
+        const axiosPostSpy = jest
+            .spyOn(axiosClientModule.axiosClient, 'post')
+            .mockRejectedValue(new Error('network error'));
+        // Act & Assert
+        await expect(adapterState.postState()).rejects.toThrow('process.exit called');
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        axiosPostSpy.mockRestore();
+    });
+});