bard-legends-framework 0.9.6 → 0.9.7

package/dist/utilities/libraries/data-structures/queue/queue.test.js

@@ -1,58 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const queue_1 = require("./queue");
+Object.defineProperty(exports, '__esModule', { value: true });
+const vitest_1 = require('vitest');
+const queue_1 = require('./queue');
 (0, vitest_1.describe)('Queue', () => {
-    (0, vitest_1.describe)('Basic', () => {
-        (0, vitest_1.test)('should return undefined when queue is empty', () => {
-            let queue = new queue_1.Queue();
-            (0, vitest_1.expect)(queue.pop()).toBe(undefined);
-        });
-        (0, vitest_1.test)('should return false when queue is not empty', () => {
-            let queue = new queue_1.Queue(1);
-            (0, vitest_1.expect)(queue.isEmpty).toBe(false);
-        });
-        (0, vitest_1.test)('should add elements to the queue', () => {
-            let queue = new queue_1.Queue();
-            queue.add(1, 2, 3);
-            (0, vitest_1.expect)(queue.pop()).toBe(1);
-            (0, vitest_1.expect)(queue.pop()).toBe(2);
-            (0, vitest_1.expect)(queue.pop()).toBe(3);
-        });
-        (0, vitest_1.test)('should add elements to the queue with first element', () => {
-            let queue = new queue_1.Queue(1);
-            queue.add(2, 3);
-            (0, vitest_1.expect)(queue.pop()).toBe(1);
-            (0, vitest_1.expect)(queue.pop()).toBe(2);
-            (0, vitest_1.expect)(queue.pop()).toBe(3);
-        });
-        (0, vitest_1.test)('peek should return the first element in the queue without removing it', () => {
-            let queue = new queue_1.Queue(1);
-            (0, vitest_1.expect)(queue.peek()).toBe(1);
-            (0, vitest_1.expect)(queue.pop()).toBe(1);
-        });
-    });
-    (0, vitest_1.describe)('Duplicate', () => {
-        (0, vitest_1.test)('empty queue', () => {
-            let queue = new queue_1.Queue();
-            let duplicate = queue.duplicate();
-            (0, vitest_1.expect)(duplicate.pop()).toBe(undefined);
-        });
-        (0, vitest_1.test)('queue with elements', () => {
-            let queue = new queue_1.Queue(1);
-            queue.add(2, 3);
-            let duplicate = queue.duplicate();
-            (0, vitest_1.expect)(duplicate.pop()).toBe(1);
-            (0, vitest_1.expect)(duplicate.pop()).toBe(2);
-            (0, vitest_1.expect)(duplicate.pop()).toBe(3);
-        });
-        (0, vitest_1.test)('duplicate with deep copy', () => {
-            let queue = new queue_1.Queue({ value: 1 });
-            let duplicate = queue.duplicate(item => ({ value: item.value }));
-            (0, vitest_1.expect)(duplicate.peek()).toStrictEqual({ value: 1 });
-            (0, vitest_1.expect)(queue.peek()).toStrictEqual({ value: 1 });
-            (0, vitest_1.expect)(duplicate.peek() !== queue.peek()).toBeTruthy();
-        });
+  (0, vitest_1.describe)('Basic', () => {
+    (0, vitest_1.test)('should return undefined when queue is empty', () => {
+      const queue = new queue_1.Queue();
+      (0, vitest_1.expect)(queue.pop()).toBe(undefined);
     });
+    (0, vitest_1.test)('should return false when queue is not empty', () => {
+      const queue = new queue_1.Queue(1);
+      (0, vitest_1.expect)(queue.isEmpty).toBe(false);
+    });
+    (0, vitest_1.test)('should add elements to the queue', () => {
+      const queue = new queue_1.Queue();
+      queue.add(1, 2, 3);
+      (0, vitest_1.expect)(queue.pop()).toBe(1);
+      (0, vitest_1.expect)(queue.pop()).toBe(2);
+      (0, vitest_1.expect)(queue.pop()).toBe(3);
+    });
+    (0, vitest_1.test)('should add elements to the queue with first element', () => {
+      const queue = new queue_1.Queue(1);
+      queue.add(2, 3);
+      (0, vitest_1.expect)(queue.pop()).toBe(1);
+      (0, vitest_1.expect)(queue.pop()).toBe(2);
+      (0, vitest_1.expect)(queue.pop()).toBe(3);
+    });
+    (0, vitest_1.test)('peek should return the first element in the queue without removing it', () => {
+      const queue = new queue_1.Queue(1);
+      (0, vitest_1.expect)(queue.peek()).toBe(1);
+      (0, vitest_1.expect)(queue.pop()).toBe(1);
+    });
+  });
+  (0, vitest_1.describe)('Duplicate', () => {
+    (0, vitest_1.test)('empty queue', () => {
+      const queue = new queue_1.Queue();
+      const duplicate = queue.duplicate();
+      (0, vitest_1.expect)(duplicate.pop()).toBe(undefined);
+    });
+    (0, vitest_1.test)('queue with elements', () => {
+      const queue = new queue_1.Queue(1);
+      queue.add(2, 3);
+      const duplicate = queue.duplicate();
+      (0, vitest_1.expect)(duplicate.pop()).toBe(1);
+      (0, vitest_1.expect)(duplicate.pop()).toBe(2);
+      (0, vitest_1.expect)(duplicate.pop()).toBe(3);
+    });
+    (0, vitest_1.test)('duplicate with deep copy', () => {
+      const queue = new queue_1.Queue({ value: 1 });
+      const duplicate = queue.duplicate(item => ({ value: item.value }));
+      (0, vitest_1.expect)(duplicate.peek()).toStrictEqual({ value: 1 });
+      (0, vitest_1.expect)(queue.peek()).toStrictEqual({ value: 1 });
+      (0, vitest_1.expect)(duplicate.peek() !== queue.peek()).toBeTruthy();
+    });
+  });
 });
-//# sourceMappingURL=queue.test.js.map
+//# sourceMappingURL=queue.test.js.map

package/dist/utilities/libraries/grid-algorithms/closest-available-space/closest-available-space.helper.spec.js

@@ -1,70 +1,124 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const closest_available_space_helper_1 = require("./closest-available-space.helper");
-const grid_1 = require("../../data-structures/grid/grid");
+Object.defineProperty(exports, '__esModule', { value: true });
+const vitest_1 = require('vitest');
+const closest_available_space_helper_1 = require('./closest-available-space.helper');
+const grid_1 = require('../../data-structures/grid/grid');
 (0, vitest_1.describe)('findClosestAvailableSpace', () => {
-    let grid;
-    (0, vitest_1.beforeEach)(() => {
-        grid = grid_1.Grid.createNew({ x: 10, y: 10 }, true);
-    });
-    (0, vitest_1.test)('should return no change vector if the location is available', () => {
-        let boundingBox = { topLeft: { x: 50, y: 50 }, bottomRight: { x: 60, y: 60 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 0, y: 0 });
-    });
-    (0, vitest_1.test)('should support object positions outside of the world size', () => {
-        let boundingBox = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 5, y: 5 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 5, y: 5 });
-        boundingBox = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 15, y: 15 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 5, y: 5 });
-        boundingBox = { topLeft: { x: 95, y: 95 }, bottomRight: { x: 105, y: 105 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -5, y: -5 });
-        boundingBox = { topLeft: { x: 85, y: 85 }, bottomRight: { x: 105, y: 105 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -5, y: -5 });
-    });
-    (0, vitest_1.test)('should find the no change vector space next to an existing object', () => {
-        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } }, false);
-        let boundingBox = { topLeft: { x: 10, y: 10 }, bottomRight: { x: 20, y: 20 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 0, y: 0 });
-    });
-    (0, vitest_1.test)('should find the closest available space if trying to spawn in occupied space', () => {
-        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
-        let boundingBox = { topLeft: { x: 5, y: 5 }, bottomRight: { x: 15, y: 15 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -5, y: 15 });
-    });
-    (0, vitest_1.test)('should find the closest available space if trying to spawn in crowded space', () => {
-        // Crowded space
-        //   0 1 2 3 4 5 6 7 8 9
-        // 0 □ 1 1 1 2 2 □ □ □ □
-        // 1 □ 1 1 1 2 2 □ □ □ □
-        // 2 □ 1 1 1 2 2 □ □ □ □
-        // 3 3 3 3 ■ ■ ■ □ □ □ □
-        // 4 □ □ □ ■ ■ ■ □ □ □ □
-        // 5 □ □ 4 ■ ■ ■ 6 6 6 □
-        // 6 □ □ 4 5 5 5 □ □ □ □
-        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 3, y: 2 } }, false); // 1
-        grid.setArea({ topLeft: { x: 4, y: 0 }, bottomRight: { x: 5, y: 2 } }, false); // 2
-        grid.setArea({ topLeft: { x: 0, y: 3 }, bottomRight: { x: 1, y: 3 } }, false); // 3
-        grid.setArea({ topLeft: { x: 2, y: 5 }, bottomRight: { x: 2, y: 6 } }, false); // 4
-        grid.setArea({ topLeft: { x: 3, y: 6 }, bottomRight: { x: 5, y: 6 } }, false); // 5
-        grid.setArea({ topLeft: { x: 6, y: 5 }, bottomRight: { x: 8, y: 5 } }, false); // 6
-        let boundingBox = { topLeft: { x: 10, y: 20 }, bottomRight: { x: 40, y: 50 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 20, y: 10 });
-    });
-    (0, vitest_1.test)('should not fooled by initial position occupying more space in grid and find narrower gap 1', () => {
-        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 4, y: 3 } }, false);
-        let boundingBox = { topLeft: { x: 4, y: 2 }, bottomRight: { x: 12, y: 20 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -3, y: -1 });
-    });
-    (0, vitest_1.test)('should not fooled by initial position occupying more space in grid and find narrower gap 2', () => {
-        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 4, y: 3 } }, false);
-        let boundingBox = { topLeft: { x: -6, y: -8 }, bottomRight: { x: 2, y: 10 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 7, y: 9 });
-    });
-    (0, vitest_1.test)('should return undefined if there is no available space', () => {
-        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 9, y: 9 } }, false);
-        let boundingBox = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } };
-        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toBeUndefined();
-    });
+  let grid;
+  (0, vitest_1.beforeEach)(() => {
+    grid = grid_1.Grid.createNew({ x: 10, y: 10 }, true);
+  });
+  (0, vitest_1.test)('should return no change vector if the location is available', () => {
+    const boundingBox = {
+      topLeft: { x: 50, y: 50 },
+      bottomRight: { x: 60, y: 60 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: 0, y: 0 });
+  });
+  (0, vitest_1.test)('should support object positions outside of the world size', () => {
+    let boundingBox = {
+      topLeft: { x: -5, y: -5 },
+      bottomRight: { x: 5, y: 5 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: 5, y: 5 });
+    boundingBox = {
+      topLeft: { x: -5, y: -5 },
+      bottomRight: { x: 15, y: 15 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: 5, y: 5 });
+    boundingBox = {
+      topLeft: { x: 95, y: 95 },
+      bottomRight: { x: 105, y: 105 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: -5, y: -5 });
+    boundingBox = {
+      topLeft: { x: 85, y: 85 },
+      bottomRight: { x: 105, y: 105 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: -5, y: -5 });
+  });
+  (0, vitest_1.test)('should find the no change vector space next to an existing object', () => {
+    grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } }, false);
+    const boundingBox = {
+      topLeft: { x: 10, y: 10 },
+      bottomRight: { x: 20, y: 20 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: 0, y: 0 });
+  });
+  (0, vitest_1.test)('should find the closest available space if trying to spawn in occupied space', () => {
+    grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
+    const boundingBox = {
+      topLeft: { x: 5, y: 5 },
+      bottomRight: { x: 15, y: 15 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: -5, y: 15 });
+  });
+  (0, vitest_1.test)('should find the closest available space if trying to spawn in crowded space', () => {
+    // Crowded space
+    //   0 1 2 3 4 5 6 7 8 9
+    // 0 □ 1 1 1 2 2 □ □ □ □
+    // 1 □ 1 1 1 2 2 □ □ □ □
+    // 2 □ 1 1 1 2 2 □ □ □ □
+    // 3 3 3 3 ■ ■ ■ □ □ □ □
+    // 4 □ □ □ ■ ■ ■ □ □ □ □
+    // 5 □ □ 4 ■ ■ ■ 6 6 6 □
+    // 6 □ □ 4 5 5 5 □ □ □ □
+    grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 3, y: 2 } }, false); // 1
+    grid.setArea({ topLeft: { x: 4, y: 0 }, bottomRight: { x: 5, y: 2 } }, false); // 2
+    grid.setArea({ topLeft: { x: 0, y: 3 }, bottomRight: { x: 1, y: 3 } }, false); // 3
+    grid.setArea({ topLeft: { x: 2, y: 5 }, bottomRight: { x: 2, y: 6 } }, false); // 4
+    grid.setArea({ topLeft: { x: 3, y: 6 }, bottomRight: { x: 5, y: 6 } }, false); // 5
+    grid.setArea({ topLeft: { x: 6, y: 5 }, bottomRight: { x: 8, y: 5 } }, false); // 6
+    const boundingBox = {
+      topLeft: { x: 10, y: 20 },
+      bottomRight: { x: 40, y: 50 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: 20, y: 10 });
+  });
+  (0, vitest_1.test)('should not fooled by initial position occupying more space in grid and find narrower gap 1', () => {
+    grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 4, y: 3 } }, false);
+    const boundingBox = {
+      topLeft: { x: 4, y: 2 },
+      bottomRight: { x: 12, y: 20 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: -3, y: -1 });
+  });
+  (0, vitest_1.test)('should not fooled by initial position occupying more space in grid and find narrower gap 2', () => {
+    grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 4, y: 3 } }, false);
+    const boundingBox = {
+      topLeft: { x: -6, y: -8 },
+      bottomRight: { x: 2, y: 10 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toEqual({ x: 7, y: 9 });
+  });
+  (0, vitest_1.test)('should return undefined if there is no available space', () => {
+    grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 9, y: 9 } }, false);
+    const boundingBox = {
+      topLeft: { x: 0, y: 0 },
+      bottomRight: { x: 10, y: 10 }
+    };
+    (0, vitest_1.expect)(
+      closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)
+    ).toBeUndefined();
+  });
 });
-//# sourceMappingURL=closest-available-space.helper.spec.js.map
+//# sourceMappingURL=closest-available-space.helper.spec.js.map

package/dist/utilities/libraries/grid-algorithms/path-finder/path-finder.spec.js

@@ -1,146 +1,151 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const grid_1 = require("../../data-structures/grid/grid");
-const path_finder_1 = require("./path-finder");
+Object.defineProperty(exports, '__esModule', { value: true });
+const vitest_1 = require('vitest');
+const grid_1 = require('../../data-structures/grid/grid');
+const path_finder_1 = require('./path-finder');
 (0, vitest_1.describe)('PATH_FINDER', () => {
-    (0, vitest_1.test)('basic 1', () => {
-        let grid = grid_1.Grid.createByValues([[true]]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 0, y: 0 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({ directPathAvailable: true, path: [{ x: 0, y: 0 }] });
+  (0, vitest_1.test)('basic 1', () => {
+    const grid = grid_1.Grid.createByValues([[true]]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 0, y: 0 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [{ x: 0, y: 0 }]
     });
-    (0, vitest_1.test)('basic 2', () => {
-        let grid = grid_1.Grid.createByValues([[false]]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 0, y: 0 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({ directPathAvailable: true, path: [{ x: 0, y: 0 }] });
+  });
+  (0, vitest_1.test)('basic 2', () => {
+    const grid = grid_1.Grid.createByValues([[false]]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 0, y: 0 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [{ x: 0, y: 0 }]
     });
-    (0, vitest_1.test)('should give the shortest path without diagonals', () => {
-        let grid = grid_1.Grid.createByValues([
-            [true, true, true, true],
-            [true, false, false, true],
-            [true, false, false, true],
-            [true, false, false, true]
-        ]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: false });
-        (0, vitest_1.expect)(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 1, y: 0 },
-                { x: 2, y: 0 },
-                { x: 3, y: 0 },
-                { x: 3, y: 1 },
-                { x: 3, y: 2 },
-                { x: 3, y: 3 }
-            ]
-        });
+  });
+  (0, vitest_1.test)('should give the shortest path without diagonals', () => {
+    const grid = grid_1.Grid.createByValues([
+      [true, true, true, true],
+      [true, false, false, true],
+      [true, false, false, true],
+      [true, false, false, true]
+    ]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: false });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 1, y: 0 },
+        { x: 2, y: 0 },
+        { x: 3, y: 0 },
+        { x: 3, y: 1 },
+        { x: 3, y: 2 },
+        { x: 3, y: 3 }
+      ]
     });
-    (0, vitest_1.test)('should give the shortest path 1', () => {
-        let grid = grid_1.Grid.createByValues([
-            [true, true, true, true],
-            [true, false, false, true],
-            [true, false, false, true],
-            [true, false, false, true]
-        ]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 1, y: 0 },
-                { x: 2, y: 0 },
-                { x: 3, y: 1 },
-                { x: 3, y: 2 },
-                { x: 3, y: 3 }
-            ]
-        });
+  });
+  (0, vitest_1.test)('should give the shortest path 1', () => {
+    const grid = grid_1.Grid.createByValues([
+      [true, true, true, true],
+      [true, false, false, true],
+      [true, false, false, true],
+      [true, false, false, true]
+    ]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 1, y: 0 },
+        { x: 2, y: 0 },
+        { x: 3, y: 1 },
+        { x: 3, y: 2 },
+        { x: 3, y: 3 }
+      ]
     });
-    (0, vitest_1.test)('should give the shortest path 2', () => {
-        let grid = grid_1.Grid.createByValues([
-            [true, true, true, false],
-            [true, false, false, false],
-            [true, true, false, true],
-            [true, false, true, true]
-        ]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 0, y: 1 },
-                { x: 1, y: 2 },
-                { x: 2, y: 3 },
-                { x: 3, y: 3 }
-            ]
-        });
+  });
+  (0, vitest_1.test)('should give the shortest path 2', () => {
+    const grid = grid_1.Grid.createByValues([
+      [true, true, true, false],
+      [true, false, false, false],
+      [true, true, false, true],
+      [true, false, true, true]
+    ]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 1, y: 2 },
+        { x: 2, y: 3 },
+        { x: 3, y: 3 }
+      ]
     });
-    (0, vitest_1.test)('should give the shortest path 3', () => {
-        let grid = grid_1.Grid.createByValues([
-            [true, false, false, true, false],
-            [true, false, true, false, true],
-            [true, false, true, false, true],
-            [false, true, false, false, true]
-        ]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 4, y: 3 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 0, y: 1 },
-                { x: 0, y: 2 },
-                { x: 1, y: 3 },
-                { x: 2, y: 2 },
-                { x: 2, y: 1 },
-                { x: 3, y: 0 },
-                { x: 4, y: 1 },
-                { x: 4, y: 2 },
-                { x: 4, y: 3 }
-            ]
-        });
+  });
+  (0, vitest_1.test)('should give the shortest path 3', () => {
+    const grid = grid_1.Grid.createByValues([
+      [true, false, false, true, false],
+      [true, false, true, false, true],
+      [true, false, true, false, true],
+      [false, true, false, false, true]
+    ]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 4, y: 3 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 0, y: 2 },
+        { x: 1, y: 3 },
+        { x: 2, y: 2 },
+        { x: 2, y: 1 },
+        { x: 3, y: 0 },
+        { x: 4, y: 1 },
+        { x: 4, y: 2 },
+        { x: 4, y: 3 }
+      ]
     });
-    (0, vitest_1.test)('should give the shortest path backwards 3', () => {
-        let grid = grid_1.Grid.createByValues([
-            [true, false, false, true, false],
-            [true, false, true, false, true],
-            [true, false, true, false, true],
-            [false, true, false, false, true]
-        ]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 4, y: 3 }, { x: 0, y: 0 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 4, y: 3 },
-                { x: 4, y: 2 },
-                { x: 4, y: 1 },
-                { x: 3, y: 0 },
-                { x: 2, y: 1 },
-                { x: 2, y: 2 },
-                { x: 1, y: 3 },
-                { x: 0, y: 2 },
-                { x: 0, y: 1 },
-                { x: 0, y: 0 }
-            ]
-        });
+  });
+  (0, vitest_1.test)('should give the shortest path backwards 3', () => {
+    const grid = grid_1.Grid.createByValues([
+      [true, false, false, true, false],
+      [true, false, true, false, true],
+      [true, false, true, false, true],
+      [false, true, false, false, true]
+    ]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 4, y: 3 }, { x: 0, y: 0 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 4, y: 3 },
+        { x: 4, y: 2 },
+        { x: 4, y: 1 },
+        { x: 3, y: 0 },
+        { x: 2, y: 1 },
+        { x: 2, y: 2 },
+        { x: 1, y: 3 },
+        { x: 0, y: 2 },
+        { x: 0, y: 1 },
+        { x: 0, y: 0 }
+      ]
     });
-    (0, vitest_1.test)('should give the shortest path to closest position', () => {
-        let grid = grid_1.Grid.createByValues([
-            [true, true, true, false],
-            [true, false, false, false],
-            [true, false, false, false],
-            [true, true, false, true]
-        ]);
-        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
-        (0, vitest_1.expect)(result).toEqual({
-            directPathAvailable: false,
-            path: [
-                { x: 0, y: 0 },
-                { x: 0, y: 1 },
-                { x: 0, y: 2 },
-                { x: 1, y: 3 }
-            ]
-        });
+  });
+  (0, vitest_1.test)('should give the shortest path to closest position', () => {
+    const grid = grid_1.Grid.createByValues([
+      [true, true, true, false],
+      [true, false, false, false],
+      [true, false, false, false],
+      [true, true, false, true]
+    ]);
+    const result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
+    (0, vitest_1.expect)(result).toEqual({
+      directPathAvailable: false,
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 0, y: 2 },
+        { x: 1, y: 3 }
+      ]
     });
-    /*
+  });
+  /*
     test('stress test', () => {
       let size = 800;
       let centerPos = { x: Math.floor(size / 2), y: Math.floor(size / 2) };
@@ -161,4 +166,4 @@ const path_finder_1 = require("./path-finder");
       console.info(end.getTime() - start.getTime());
     });*/
 });
-//# sourceMappingURL=path-finder.spec.js.map
+//# sourceMappingURL=path-finder.spec.js.map