brick-engine-js 1.0.1 → 1.0.2

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

@@ -1,157 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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();
-        });
-    });
-});