brick-engine-js 1.0.1

package/src/core/module/grid/engines/GridAnalysisEngine.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import GridAnalysisEngine from './GridAnalysisEngine';
+import { Grid } from '../../../types/modules';
+import { Color } from '../../../types/enums';
+
+describe('GridAnalysisEngine', () => {
+    let engine: GridAnalysisEngine;
+    let mockGrid: Grid;
+
+    beforeEach(() => {
+        // [ARRANGE] Mock Grid facade
+        mockGrid = {
+            width: 10,
+            height: 20,
+            isValidCoordinate: vi.fn(),
+            isCellActive: vi.fn(),
+            getCell: vi.fn(),
+            stampCell: vi.fn(),
+        } as unknown as Grid;
+        engine = new GridAnalysisEngine(mockGrid);
+    });
+
+    describe('getFullRows', () => {
+        it('should return indices of rows where all cells are active', () => {
+            // [ARRANGE] Row 2 is full, others are not
+            vi.mocked(mockGrid.isCellActive).mockImplementation(({ y }) => y === 2);
+
+            // [ACT]
+            const result = engine.getFullRows();
+
+            // [ASSERT]
+            expect(result).toEqual([2]);
+        });
+
+        it('should return an empty array if no rows are full', () => {
+            // [ARRANGE]
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.getFullRows();
+
+            // [ASSERT]
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('getFullColumns', () => {
+        it('should return indices of columns where all cells are active', () => {
+            // [ARRANGE] Column 5 is full
+            vi.mocked(mockGrid.isCellActive).mockImplementation(({ x }) => x === 5);
+
+            // [ACT]
+            const result = engine.getFullColumns();
+
+            // [ASSERT]
+            expect(result).toEqual([5]);
+        });
+    });
+
+    describe('getNeighbors', () => {
+        it('should return only orthogonally adjacent cells by default', () => {
+            // [ARRANGE]
+            const coord = { x: 5, y: 5 };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.getCell).mockImplementation(c => ({ coordinate: c, value: 1, color: Color.DEFAULT }));
+
+            // [ACT]
+            const result = engine.getNeighbors(coord);
+
+            // [ASSERT]
+            expect(result).toHaveLength(4);
+            expect(result.map(c => c.coordinate)).toContainEqual({ x: 4, y: 5 });
+            expect(result.map(c => c.coordinate)).toContainEqual({ x: 6, y: 5 });
+            expect(result.map(c => c.coordinate)).toContainEqual({ x: 5, y: 4 });
+            expect(result.map(c => c.coordinate)).toContainEqual({ x: 5, y: 6 });
+        });
+
+        it('should return 8 neighbors if includeDiagonal is true', () => {
+            // [ARRANGE]
+            const coord = { x: 5, y: 5 };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.getCell).mockImplementation(c => ({ coordinate: c, value: 1, color: Color.DEFAULT }));
+
+            // [ACT]
+            const result = engine.getNeighbors(coord, true);
+
+            // [ASSERT]
+            expect(result).toHaveLength(8);
+            expect(result.map(c => c.coordinate)).toContainEqual({ x: 4, y: 4 });
+        });
+
+        it('should skip invalid coordinates (e.g., edges)', () => {
+            // [ARRANGE] Center at (0,0)
+            const coord = { x: 0, y: 0 };
+            vi.mocked(mockGrid.isValidCoordinate).mockImplementation(c => c.x >= 0 && c.y >= 0);
+            vi.mocked(mockGrid.getCell).mockImplementation(c => ({ coordinate: c, value: 1, color: Color.DEFAULT }));
+
+            // [ACT]
+            const result = engine.getNeighbors(coord);
+
+            // [ASSERT]
+            // Only (1,0) and (0,1) are valid
+            expect(result).toHaveLength(2);
+        });
+    });
+
+    describe('findConnectedCells', () => {
+        it('should return an empty array if starting cell is inactive', () => {
+            // [ARRANGE]
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.findConnectedCells({ x: 5, y: 5 });
+
+            // [ASSERT]
+            expect(result).toEqual([]);
+        });
+
+        it('should find all connected cells with the same value using BFS', () => {
+            // [ARRANGE] Simple 2x1 block
+            const start = { x: 5, y: 5 };
+            const neighbor = { x: 6, y: 5 };
+
+            vi.mocked(mockGrid.isCellActive).mockImplementation(c => (c.x === 5 && c.y === 5) || (c.x === 6 && c.y === 5));
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.getCell).mockImplementation(c => ({ coordinate: c, value: 1, color: Color.RED }));
+
+            // [ACT]
+            const result = engine.findConnectedCells(start);
+
+            // [ASSERT]
+            expect(result).toHaveLength(2);
+            expect(result.map(c => c.coordinate)).toContainEqual(start);
+            expect(result.map(c => c.coordinate)).toContainEqual(neighbor);
+        });
+    });
+
+    describe('swapCells', () => {
+        it('should swap attributes of two cells using stampCell', () => {
+            // [ARRANGE]
+            const a = { x: 1, y: 1 };
+            const b = { x: 2, y: 2 };
+            const cellA = { coordinate: a, value: 1, color: Color.RED };
+            const cellB = { coordinate: b, value: 2, color: Color.BLUE };
+
+            vi.mocked(mockGrid.getCell).mockImplementation(c => (c.x === 1 ? cellA : cellB));
+
+            // [ACT]
+            engine.swapCells(a, b);
+
+            // [ASSERT]
+            // Stamp cellB at a, and cellA at b
+            expect(mockGrid.stampCell).toHaveBeenCalledWith({ ...cellB, coordinate: a });
+            expect(mockGrid.stampCell).toHaveBeenCalledWith({ ...cellA, coordinate: b });
+        });
+    });
+});

package/src/core/module/grid/engines/GridAnalysisEngine.ts

@@ -0,0 +1,124 @@
+import { Cell, Coordinate, Piece } from '../../../types/Types';
+import { Grid } from '../../../types/modules';
+
+/**
+ * Handles analysis and search operations on the grid.
+ */
+export default class GridAnalysisEngine {
+    constructor(private grid: Grid) {}
+
+    /**
+     * Identifies all rows that are completely filled with active cells.
+     */
+    getFullRows(): number[] {
+        const fullRows: number[] = [];
+        for (let y = 0; y < this.grid.height; y++) {
+            let isFull = true;
+            for (let x = 0; x < this.grid.width; x++) {
+                if (!this.grid.isCellActive({ x, y })) {
+                    isFull = false;
+                    break;
+                }
+            }
+            if (isFull) fullRows.push(y);
+        }
+        return fullRows;
+    }
+
+    /**
+     * Identifies all columns that are completely filled with active cells.
+     */
+    getFullColumns(): number[] {
+        const fullColumns: number[] = [];
+        for (let x = 0; x < this.grid.width; x++) {
+            let isFull = true;
+            for (let y = 0; y < this.grid.height; y++) {
+                if (!this.grid.isCellActive({ x, y })) {
+                    isFull = false;
+                    break;
+                }
+            }
+            if (isFull) fullColumns.push(x);
+        }
+        return fullColumns;
+    }
+
+    /**
+     * Returns the active cells adjacent to a specific coordinate.
+     */
+    getNeighbors(coord: Coordinate, includeDiagonal: boolean = false): Cell[] {
+        const neighbors: Cell[] = [];
+        const offsets = [
+            { x: -1, y: 0 },
+            { x: 1, y: 0 },
+            { x: 0, y: -1 },
+            { x: 0, y: 1 },
+        ];
+
+        if (includeDiagonal) {
+            offsets.push({ x: -1, y: -1 }, { x: 1, y: -1 }, { x: -1, y: 1 }, { x: 1, y: 1 });
+        }
+
+        offsets.forEach(offset => {
+            const neighborCoord = { x: coord.x + offset.x, y: coord.y + offset.y };
+            if (this.grid.isValidCoordinate(neighborCoord)) {
+                neighbors.push(this.grid.getCell(neighborCoord));
+            }
+        });
+
+        return neighbors;
+    }
+
+    /**
+     * Finds all connected active cells of the same value starting from a specific coordinate.
+     */
+    findConnectedCells(coord: Coordinate): Piece {
+        if (!this.grid.isCellActive(coord)) return [];
+
+        const startCell = this.grid.getCell(coord);
+        const targetValue = startCell.value;
+        const connected: Piece = [];
+        const visited = new Set<string>();
+        const queue: Coordinate[] = [coord];
+
+        const getCoordKey = (c: Coordinate) => `${c.x},${c.y}`;
+        visited.add(getCoordKey(coord));
+
+        while (queue.length > 0) {
+            const current = queue.shift()!;
+            const cell = this.grid.getCell(current);
+
+            if (cell.value === targetValue) {
+                connected.push(cell);
+
+                const neighbors = [
+                    { x: current.x - 1, y: current.y },
+                    { x: current.x + 1, y: current.y },
+                    { x: current.x, y: current.y - 1 },
+                    { x: current.x, y: current.y + 1 },
+                ];
+
+                neighbors.forEach(n => {
+                    const key = getCoordKey(n);
+                    if (this.grid.isValidCoordinate(n) && !visited.has(key) && this.grid.isCellActive(n)) {
+                        visited.add(key);
+                        queue.push(n);
+                    }
+                });
+            }
+        }
+
+        return connected;
+    }
+
+    /**
+     * Swaps the values and colors of two cells.
+     */
+    swapCells(a: Coordinate, b: Coordinate): void {
+        const cellA = { ...this.grid.getCell(a) };
+        const cellB = { ...this.grid.getCell(b) };
+
+        this.grid.stampCell({ ...cellB, coordinate: a });
+        this.grid.stampCell({ ...cellA, coordinate: b });
+    }
+}

package/src/core/module/grid/engines/GridLineEngine.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import GridLineEngine from './GridLineEngine';
+import { Grid } from '../../../types/modules';
+import { Color } from '../../../types/enums';
+import { Cell } from '../../../types/Types';
+
+describe('GridLineEngine', () => {
+    let engine: GridLineEngine;
+    let mockGrid: Grid;
+    let gridData: Cell[][];
+
+    const createSmallGrid = (w: number, h: number) => {
+        const data: Cell[][] = [];
+        for (let y = 0; y < h; y++) {
+            data[y] = [];
+            for (let x = 0; x < w; x++) {
+                data[y][x] = { coordinate: { x, y }, value: 0, color: Color.DEFAULT };
+            }
+        }
+        return data;
+    };
+
+    beforeEach(() => {
+        gridData = createSmallGrid(3, 3);
+        mockGrid = {
+            width: 3,
+            height: 3,
+            getGrid: () => gridData,
+        } as unknown as Grid;
+        engine = new GridLineEngine(mockGrid);
+    });
+
+    describe('isRowFull', () => {
+        it('should return true if all cells in a row have value > 0', () => {
+            // [ARRANGE]
+            gridData[1].forEach(c => (c.value = 1));
+
+            // [ACT]
+            const result = engine.isRowFull(1);
+
+            // [ASSERT]
+            expect(result).toBe(true);
+        });
+
+        it('should return false if any cell in a row has value 0', () => {
+            // [ARRANGE]
+            gridData[1][0].value = 1;
+            gridData[1][1].value = 0; // one empty
+
+            // [ACT]
+            const result = engine.isRowFull(1);
+
+            // [ASSERT]
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('clearRow', () => {
+        it('should reset all cells in a row to value 0', () => {
+            // [ARRANGE]
+            gridData[1].forEach(c => (c.value = 5));
+
+            // [ACT]
+            engine.clearRow(1);
+
+            // [ASSERT]
+            expect(gridData[1].every(c => c.value === 0)).toBe(true);
+        });
+    });
+
+    describe('shiftRowsDown', () => {
+        it('should copy values from row above and clear top row', () => {
+            // [ARRANGE]
+            gridData[0][0].value = 9; // top row
+            gridData[1][0].value = 0; // target row
+
+            // [ACT]
+            engine.shiftRowsDown(1);
+
+            // [ASSERT]
+            expect(gridData[1][0].value).toBe(9);
+            expect(gridData[0][0].value).toBe(0); // top row cleared
+        });
+    });
+
+    describe('clearFullRows', () => {
+        it('should detect, clear, and shift rows, returning count', () => {
+            // [ARRANGE]
+            // Row 2 is full
+            gridData[2].forEach(c => (c.value = 1));
+            // Row 1 has a pattern
+            gridData[1][0].value = 7;
+
+            // [ACT]
+            const cleared = engine.clearFullRows();
+
+            // [ASSERT]
+            expect(cleared).toBe(1);
+            expect(gridData[2][0].value).toBe(7); // row 1 shifted to row 2
+            expect(gridData[1][0].value).toBe(0); // top row (originally 0 or 1) cleared
+        });
+    });
+
+    describe('isColumnFull', () => {
+        it('should return true if all cells in a column have value > 0', () => {
+            // [ARRANGE]
+            gridData[0][0].value = 1;
+            gridData[1][0].value = 1;
+            gridData[2][0].value = 1;
+
+            // [ACT]
+            const result = engine.isColumnFull(0);
+
+            // [ASSERT]
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('shiftColumnsRight', () => {
+        it('should copy values from left and clear first column', () => {
+            // [ARRANGE]
+            gridData[0][0].value = 8;
+
+            // [ACT]
+            engine.shiftColumnsRight(1);
+
+            // [ASSERT]
+            expect(gridData[0][1].value).toBe(8);
+            expect(gridData[0][0].value).toBe(0);
+        });
+    });
+});

package/src/core/module/grid/engines/GridLineEngine.ts

@@ -0,0 +1,165 @@
+import { Grid } from '../../../types/modules';
+import CellHelper from '../../../helpers/CellHelper';
+
+/**
+ * Handles line-based operations (rows and columns) on the grid.
+ */
+export default class GridLineEngine {
+    constructor(private grid: Grid) {}
+
+    /**
+     * Checks if every cell in a specific row is active.
+     */
+    isRowFull(y: number): boolean {
+        const gridData = this.grid.getGrid();
+        if (y < 0 || y >= this.grid.height) return false;
+        return gridData[y].every(cell => cell.value > 0);
+    }
+
+    /**
+     * Checks if every cell in a specific row is inactive.
+     */
+    isRowEmpty(y: number): boolean {
+        const gridData = this.grid.getGrid();
+        if (y < 0 || y >= this.grid.height) return true;
+        return gridData[y].every(cell => cell.value === 0);
+    }
+
+    /**
+     * Resets all cells in a specific row to their default empty state.
+     */
+    clearRow(y: number): void {
+        const gridData = this.grid.getGrid();
+        if (y < 0 || y >= this.grid.height) return;
+        for (let x = 0; x < this.grid.width; x++) {
+            gridData[y][x] = CellHelper.emptyCell({ x, y });
+        }
+    }
+
+    /**
+     * Shifts all rows above a certain index down by one position.
+     */
+    shiftRowsDown(fromY: number): void {
+        const gridData = this.grid.getGrid();
+        for (let y = fromY; y > 0; y--) {
+            for (let x = 0; x < this.grid.width; x++) {
+                const prevCell = gridData[y - 1][x];
+                gridData[y][x].value = prevCell.value;
+                gridData[y][x].color = prevCell.color;
+            }
+        }
+        this.clearRow(0);
+    }
+
+    /**
+     * Shifts all rows below a certain index up by one position.
+     */
+    shiftRowsUp(fromY: number): void {
+        const gridData = this.grid.getGrid();
+        for (let y = fromY; y < this.grid.height - 1; y++) {
+            for (let x = 0; x < this.grid.width; x++) {
+                const nextCell = gridData[y + 1][x];
+                gridData[y][x].value = nextCell.value;
+                gridData[y][x].color = nextCell.color;
+            }
+        }
+        this.clearRow(this.grid.height - 1);
+    }
+
+    /**
+     * Scans for full rows, clears them, and shifts remaining rows down.
+     */
+    clearFullRows(): number {
+        let rowsCleared = 0;
+        for (let y = this.grid.height - 1; y >= 0; y--) {
+            if (this.isRowFull(y)) {
+                this.clearRow(y);
+                this.shiftRowsDown(y);
+                rowsCleared++;
+                y++; // Re-check the same row index after shifting
+            }
+        }
+        return rowsCleared;
+    }
+
+    /**
+     * Checks if every cell in a specific column is active.
+     */
+    isColumnFull(x: number): boolean {
+        const gridData = this.grid.getGrid();
+        if (x < 0 || x >= this.grid.width) return false;
+        for (let y = 0; y < this.grid.height; y++) {
+            if (gridData[y][x].value === 0) return false;
+        }
+        return true;
+    }
+
+    /**
+     * Checks if every cell in a specific column is inactive.
+     */
+    isColumnEmpty(x: number): boolean {
+        const gridData = this.grid.getGrid();
+        if (x < 0 || x >= this.grid.width) return true;
+        for (let y = 0; y < this.grid.height; y++) {
+            if (gridData[y][x].value !== 0) return false;
+        }
+        return true;
+    }
+
+    /**
+     * Resets all cells in a specific column to their default empty state.
+     */
+    clearColumn(x: number): void {
+        const gridData = this.grid.getGrid();
+        if (x < 0 || x >= this.grid.width) return;
+        for (let y = 0; y < this.grid.height; y++) {
+            gridData[y][x] = CellHelper.emptyCell({ x, y });
+        }
+    }
+
+    /**
+     * Shifts all columns to the left of a certain index one position to the right.
+     */
+    shiftColumnsRight(fromX: number): void {
+        const gridData = this.grid.getGrid();
+        for (let x = fromX; x > 0; x--) {
+            for (let y = 0; y < this.grid.height; y++) {
+                const prevCell = gridData[y][x - 1];
+                gridData[y][x].value = prevCell.value;
+                gridData[y][x].color = prevCell.color;
+            }
+        }
+        this.clearColumn(0);
+    }
+
+    /**
+     * Shifts all columns to the right of a certain index one position to the left.
+     */
+    shiftColumnsLeft(fromX: number): void {
+        const gridData = this.grid.getGrid();
+        for (let x = fromX; x < this.grid.width - 1; x++) {
+            for (let y = 0; y < this.grid.height; y++) {
+                const nextCell = gridData[y][x + 1];
+                gridData[y][x].value = nextCell.value;
+                gridData[y][x].color = nextCell.color;
+            }
+        }
+        this.clearColumn(this.grid.width - 1);
+    }
+
+    /**
+     * Scans for full columns, clears them, and shifts remaining columns right.
+     */
+    clearFullColumns(): number {
+        let columnsCleared = 0;
+        for (let x = this.grid.width - 1; x >= 0; x--) {
+            if (this.isColumnFull(x)) {
+                this.clearColumn(x);
+                this.shiftColumnsRight(x);
+                columnsCleared++;
+                x++; // Re-check the same column index after shifting
+            }
+        }
+        return columnsCleared;
+    }
+}

package/src/core/module/grid/engines/GridMovementEngine.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import GridMovementEngine from './GridMovementEngine';
+import { Grid } from '../../../types/modules';
+import { Color } from '../../../types/enums';
+import { Vector, Coordinate } from '../../../types/Types';
+
+describe('GridMovementEngine', () => {
+    let engine: GridMovementEngine;
+    let mockGrid: Grid;
+
+    beforeEach(() => {
+        // [ARRANGE] Mock Grid facade
+        mockGrid = {
+            isValidCoordinate: vi.fn(),
+            isCellActive: vi.fn(),
+        } as unknown as Grid;
+        engine = new GridMovementEngine(mockGrid);
+    });
+
+    describe('movePiece', () => {
+        it('should return a new piece shifted in the specified direction', () => {
+            // [ARRANGE]
+            const piece = [{ coordinate: { x: 5, y: 5 }, value: 1, color: Color.RED }];
+            const direction: Vector = { x: 1, y: 0 };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.movePiece(piece, direction);
+
+            // [ASSERT]
+            expect(result).not.toBeNull();
+            expect(result![0].coordinate).toEqual({ x: 6, y: 5 });
+        });
+
+        it('should return null if the move is out of bounds', () => {
+            // [ARRANGE]
+            const piece = [{ coordinate: { x: 0, y: 0 }, value: 1, color: Color.RED }];
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.movePieceLeft(piece);
+
+            // [ASSERT]
+            expect(result).toBeNull();
+        });
+
+        it('should return null if it collides with an active cell that is NOT part of self', () => {
+            // [ARRANGE]
+            const piece = [{ coordinate: { x: 5, y: 5 }, value: 1, color: Color.RED }];
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(true); // Obstacle at (6,5)
+
+            // [ACT]
+            const result = engine.movePieceRight(piece);
+
+            // [ASSERT]
+            expect(result).toBeNull();
+        });
+
+        it('should NOT return null if it collides with its own current position (diagonal or overlapping)', () => {
+            // [ARRANGE] Piece with 2 cells
+            const piece = [
+                { coordinate: { x: 5, y: 5 }, value: 1, color: Color.RED },
+                { coordinate: { x: 6, y: 5 }, value: 1, color: Color.RED },
+            ];
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+
+            // isCellActive is true for (5,5) and (6,5)
+            vi.mocked(mockGrid.isCellActive).mockImplementation((c: Coordinate) => c.x === 5 || c.x === 6);
+
+            // [ACT] Move right: (5,5)->(6,5) and (6,5)->(7,5)
+            // (6,5) is active, but it matches the original piece's second cell
+            const result = engine.movePieceRight(piece);
+
+            // [ASSERT]
+            expect(result).not.toBeNull();
+            expect(result![0].coordinate).toEqual({ x: 6, y: 5 });
+            expect(result![1].coordinate).toEqual({ x: 7, y: 5 });
+        });
+    });
+
+    describe('getDropPath', () => {
+        it('should return the furthest possible position downwards', () => {
+            // [ARRANGE]
+            const piece = [{ coordinate: { x: 5, y: 0 }, value: 1, color: Color.RED }];
+            vi.mocked(mockGrid.isValidCoordinate).mockImplementation((c: Coordinate) => c.y >= 0 && c.y <= 10);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.getDropPath(piece);
+
+            // [ASSERT]
+            expect(result[0].coordinate.y).toBe(10);
+        });
+    });
+
+    describe('moveCell', () => {
+        it('should move a single cell if path is clear', () => {
+            // [ARRANGE]
+            const cell = { coordinate: { x: 1, y: 1 }, value: 1, color: Color.RED };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.moveCellDown(cell);
+
+            // [ASSERT]
+            expect(result?.coordinate).toEqual({ x: 1, y: 2 });
+        });
+
+        it('should return null if single cell path is blocked', () => {
+            // [ARRANGE]
+            const cell = { coordinate: { x: 1, y: 1 }, value: 1, color: Color.RED };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(true);
+
+            // [ACT]
+            const result = engine.moveCellDown(cell);
+
+            // [ASSERT]
+            expect(result).toBeNull();
+        });
+    });
+});