@arvarus/perlin-noise 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvarus/perlin-noise",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Perlin noise implementation in TypeScript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,8 +8,8 @@
     "build": "tsc",
     "watch": "tsc --watch",
     "clean": "rm -rf dist",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
+    "lint": "cross-env ESLINT_USE_FLAT_CONFIG=true eslint src",
+    "lint:fix": "cross-env ESLINT_USE_FLAT_CONFIG=true eslint src --fix",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
@@ -23,13 +23,20 @@
   ],
   "author": "",
   "license": "GPL-3.0",
+  "overrides": {
+    "minimatch": ">=10.2.1"
+  },
   "devDependencies": {
-    "@types/jest": "^29.5.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.50.0",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.1.0",
+    "@eslint/js": "^9.39.2",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.39.2",
+    "globals": "^17.3.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
     "typescript": "^5.0.0"
   },
   "files": [

package/dist/__tests__/grid.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/grid.test.js

@@ -1,270 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const grid_1 = require("../grid");
-describe('generateGradientGrid', () => {
-    describe('1D grid', () => {
-        it('should generate correct number of grid points', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
-            expect(grid.size).toBe(6); // size + 1
-        });
-        it('should generate scalars between -1 and 1', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [10], 456);
-            for (const gradient of grid.values()) {
-                expect(typeof gradient).toBe('number');
-                const scalar = gradient;
-                expect(scalar).toBeGreaterThanOrEqual(-1);
-                expect(scalar).toBeLessThanOrEqual(1);
-            }
-        });
-        it('should generate same grid with same seed', () => {
-            const grid1 = (0, grid_1.generateGradientGrid)(1, [5], 789);
-            const grid2 = (0, grid_1.generateGradientGrid)(1, [5], 789);
-            expect(grid1.size).toBe(grid2.size);
-            for (const [key, value] of grid1.entries()) {
-                expect(grid2.get(key)).toBe(value);
-            }
-        });
-        it('should generate different grid with different seed', () => {
-            const grid1 = (0, grid_1.generateGradientGrid)(1, [5], 100);
-            const grid2 = (0, grid_1.generateGradientGrid)(1, [5], 200);
-            // At least some values should be different
-            let hasDifference = false;
-            for (const [key, value] of grid1.entries()) {
-                if (grid2.get(key) !== value) {
-                    hasDifference = true;
-                    break;
-                }
-            }
-            expect(hasDifference).toBe(true);
-        });
-        it('should have correct keys for 1D grid', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [3], 123);
-            expect(grid.has('0')).toBe(true);
-            expect(grid.has('1')).toBe(true);
-            expect(grid.has('2')).toBe(true);
-            expect(grid.has('3')).toBe(true);
-            expect(grid.has('4')).toBe(false);
-        });
-    });
-    describe('2D grid', () => {
-        it('should generate correct number of grid points', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
-            expect(grid.size).toBe(16); // (3 + 1) * (3 + 1) = 16
-        });
-        it('should generate unit-length 2D vectors', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 456);
-            for (const gradient of grid.values()) {
-                expect(Array.isArray(gradient)).toBe(true);
-                const vector = gradient;
-                expect(vector.length).toBe(2);
-                // Check unit length (within floating point precision)
-                const magnitude = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1]);
-                expect(magnitude).toBeCloseTo(1, 10);
-            }
-        });
-        it('should generate same grid with same seed', () => {
-            const grid1 = (0, grid_1.generateGradientGrid)(2, [3, 3], 789);
-            const grid2 = (0, grid_1.generateGradientGrid)(2, [3, 3], 789);
-            expect(grid1.size).toBe(grid2.size);
-            for (const [key, value] of grid1.entries()) {
-                const v1 = value;
-                const v2 = grid2.get(key);
-                expect(v2).toBeDefined();
-                expect(v1[0]).toBeCloseTo(v2[0], 10);
-                expect(v1[1]).toBeCloseTo(v2[1], 10);
-            }
-        });
-        it('should have correct keys for 2D grid', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [2, 2], 123);
-            expect(grid.has('0,0')).toBe(true);
-            expect(grid.has('0,1')).toBe(true);
-            expect(grid.has('1,0')).toBe(true);
-            expect(grid.has('2,2')).toBe(true);
-            expect(grid.has('3,3')).toBe(false); // size is 2, so max is 2
-        });
-        it('should support different sizes per dimension', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [2, 3], 123);
-            // First dimension: 2 + 1 = 3 points (0, 1, 2)
-            // Second dimension: 3 + 1 = 4 points (0, 1, 2, 3)
-            // Total: 3 * 4 = 12 points
-            expect(grid.size).toBe(12);
-            expect(grid.has('0,0')).toBe(true);
-            expect(grid.has('2,3')).toBe(true);
-            expect(grid.has('3,3')).toBe(false); // First dimension max is 2
-            expect(grid.has('2,4')).toBe(false); // Second dimension max is 3
-        });
-    });
-    describe('3D grid', () => {
-        it('should generate correct number of grid points', () => {
-            const grid = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 123);
-            expect(grid.size).toBe(27); // (2 + 1) ^ 3 = 27
-        });
-        it('should generate unit-length 3D vectors', () => {
-            const grid = (0, grid_1.generateGradientGrid)(3, [3, 3, 3], 456);
-            for (const gradient of grid.values()) {
-                expect(Array.isArray(gradient)).toBe(true);
-                const vector = gradient;
-                expect(vector.length).toBe(3);
-                // Check unit length
-                const magnitude = Math.sqrt(vector[0] * vector[0] +
-                    vector[1] * vector[1] +
-                    vector[2] * vector[2]);
-                expect(magnitude).toBeCloseTo(1, 10);
-            }
-        });
-        it('should generate same grid with same seed', () => {
-            const grid1 = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 789);
-            const grid2 = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 789);
-            expect(grid1.size).toBe(grid2.size);
-            for (const [key, value] of grid1.entries()) {
-                const v1 = value;
-                const v2 = grid2.get(key);
-                expect(v2).toBeDefined();
-                expect(v1[0]).toBeCloseTo(v2[0], 10);
-                expect(v1[1]).toBeCloseTo(v2[1], 10);
-                expect(v1[2]).toBeCloseTo(v2[2], 10);
-            }
-        });
-        it('should have correct keys for 3D grid', () => {
-            const grid = (0, grid_1.generateGradientGrid)(3, [1, 1, 1], 123);
-            expect(grid.has('0,0,0')).toBe(true);
-            expect(grid.has('1,1,1')).toBe(true);
-            expect(grid.has('2,2,2')).toBe(false); // size is 1, so max is 1
-        });
-    });
-    describe('4D grid', () => {
-        it('should generate correct number of grid points', () => {
-            const grid = (0, grid_1.generateGradientGrid)(4, [2, 2, 2, 2], 123);
-            expect(grid.size).toBe(81); // (2 + 1) ^ 4 = 81
-        });
-        it('should generate unit-length 4D vectors', () => {
-            const grid = (0, grid_1.generateGradientGrid)(4, [2, 2, 2, 2], 456);
-            for (const gradient of grid.values()) {
-                expect(Array.isArray(gradient)).toBe(true);
-                const vector = gradient;
-                expect(vector.length).toBe(4);
-                // Check unit length
-                const magnitude = Math.sqrt(vector[0] * vector[0] +
-                    vector[1] * vector[1] +
-                    vector[2] * vector[2] +
-                    vector[3] * vector[3]);
-                expect(magnitude).toBeCloseTo(1, 10);
-            }
-        });
-        it('should generate same grid with same seed', () => {
-            const grid1 = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 789);
-            const grid2 = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 789);
-            expect(grid1.size).toBe(grid2.size);
-            for (const [key, value] of grid1.entries()) {
-                const v1 = value;
-                const v2 = grid2.get(key);
-                expect(v2).toBeDefined();
-                expect(v1[0]).toBeCloseTo(v2[0], 10);
-                expect(v1[1]).toBeCloseTo(v2[1], 10);
-                expect(v1[2]).toBeCloseTo(v2[2], 10);
-                expect(v1[3]).toBeCloseTo(v2[3], 10);
-            }
-        });
-        it('should have correct keys for 4D grid', () => {
-            const grid = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 123);
-            expect(grid.has('0,0,0,0')).toBe(true);
-            expect(grid.has('1,1,1,1')).toBe(true);
-            expect(grid.has('2,2,2,2')).toBe(false); // size is 1, so max is 1
-        });
-    });
-    describe('higher dimensions', () => {
-        it('should support 5D grids', () => {
-            const grid = (0, grid_1.generateGradientGrid)(5, [1, 1, 1, 1, 1], 123);
-            expect(grid.size).toBe(32); // (1 + 1) ^ 5 = 32
-            expect(grid.has('0,0,0,0,0')).toBe(true);
-            expect(grid.has('1,1,1,1,1')).toBe(true);
-            expect(grid.has('2,2,2,2,2')).toBe(false);
-            // Check that gradients are arrays of length 5
-            for (const gradient of grid.values()) {
-                expect(Array.isArray(gradient)).toBe(true);
-                const vector = gradient;
-                expect(vector.length).toBe(5);
-                // Check unit length
-                const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
-                expect(magnitude).toBeCloseTo(1, 10);
-            }
-        });
-        it('should support 6D grids', () => {
-            const grid = (0, grid_1.generateGradientGrid)(6, [1, 1, 1, 1, 1, 1], 123);
-            expect(grid.size).toBe(64); // (1 + 1) ^ 6 = 64
-            expect(grid.has('0,0,0,0,0,0')).toBe(true);
-            expect(grid.has('1,1,1,1,1,1')).toBe(true);
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle size 0', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [0], 123);
-            expect(grid.size).toBe(1); // 0 + 1 = 1
-            expect(grid.has('0')).toBe(true);
-        });
-        it('should handle size 0 for 2D', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [0, 0], 123);
-            expect(grid.size).toBe(1); // (0 + 1) ^ 2 = 1
-            expect(grid.has('0,0')).toBe(true);
-        });
-        it('should use different default seeds when seed not provided', () => {
-            const grid1 = (0, grid_1.generateGradientGrid)(1, [5]);
-            const grid2 = (0, grid_1.generateGradientGrid)(1, [5]);
-            // They might be the same by chance, but very unlikely
-            // We'll just check that the function doesn't crash
-            expect(grid1.size).toBe(6);
-            expect(grid2.size).toBe(6);
-        });
-        it('should throw error when size array length does not match dimension', () => {
-            expect(() => (0, grid_1.generateGradientGrid)(2, [3], 123)).toThrow();
-            expect(() => (0, grid_1.generateGradientGrid)(2, [3, 4, 5], 123)).toThrow();
-            expect(() => (0, grid_1.generateGradientGrid)(3, [2, 2], 123)).toThrow();
-        });
-        it('should throw error when dimension is not a positive integer', () => {
-            expect(() => (0, grid_1.generateGradientGrid)(0, [], 123)).toThrow();
-            expect(() => (0, grid_1.generateGradientGrid)(-1, [-1], 123)).toThrow();
-            expect(() => (0, grid_1.generateGradientGrid)(1.5, [1], 123)).toThrow();
-            expect(() => (0, grid_1.generateGradientGrid)(2.0, [1, 1], 123)).not.toThrow(); // 2.0 is valid
-        });
-    });
-});
-describe('getGradientAt', () => {
-    it('should retrieve gradient from 1D grid', () => {
-        const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
-        const gradient = (0, grid_1.getGradientAt)(grid, [2]);
-        expect(gradient).toBeDefined();
-        expect(typeof gradient).toBe('number');
-        expect(gradient).toBe(grid.get('2'));
-    });
-    it('should retrieve gradient from 2D grid', () => {
-        const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
-        const gradient = (0, grid_1.getGradientAt)(grid, [1, 2]);
-        expect(gradient).toBeDefined();
-        expect(Array.isArray(gradient)).toBe(true);
-        expect(gradient).toEqual(grid.get('1,2'));
-    });
-    it('should retrieve gradient from 3D grid', () => {
-        const grid = (0, grid_1.generateGradientGrid)(3, [2, 2, 2], 123);
-        const gradient = (0, grid_1.getGradientAt)(grid, [1, 0, 2]);
-        expect(gradient).toBeDefined();
-        expect(Array.isArray(gradient)).toBe(true);
-        expect(gradient).toEqual(grid.get('1,0,2'));
-    });
-    it('should retrieve gradient from 4D grid', () => {
-        const grid = (0, grid_1.generateGradientGrid)(4, [1, 1, 1, 1], 123);
-        const gradient = (0, grid_1.getGradientAt)(grid, [1, 1, 0, 1]);
-        expect(gradient).toBeDefined();
-        expect(Array.isArray(gradient)).toBe(true);
-        expect(gradient).toEqual(grid.get('1,1,0,1'));
-    });
-    it('should return undefined for non-existent coordinates', () => {
-        const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
-        const gradient = (0, grid_1.getGradientAt)(grid, [10, 10]);
-        expect(gradient).toBeUndefined();
-    });
-    it('should return undefined for empty grid', () => {
-        const emptyGrid = new Map();
-        const gradient = (0, grid_1.getGradientAt)(emptyGrid, [0, 0]);
-        expect(gradient).toBeUndefined();
-    });
-});

package/dist/__tests__/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/index.test.js

@@ -1,240 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-describe('PerlinNoise', () => {
-    describe('constructor', () => {
-        it('should create instance with default options', () => {
-            const noise = new index_1.PerlinNoise();
-            expect(noise).toBeInstanceOf(index_1.PerlinNoise);
-        });
-        it('should create instance with options object', () => {
-            const options = { seed: 456, gridSize: [10, 10, 10] };
-            const noise = new index_1.PerlinNoise(options);
-            expect(noise).toBeInstanceOf(index_1.PerlinNoise);
-        });
-        it('should use provided seed', () => {
-            const noise1 = new index_1.PerlinNoise({ seed: 789, gridSize: [10, 10, 10] });
-            const noise2 = new index_1.PerlinNoise({ seed: 789, gridSize: [10, 10, 10] });
-            // Same seed should produce same results
-            expect(noise1.noise([1.0, 1.0, 1.0])).toBeCloseTo(noise2.noise([1.0, 1.0, 1.0]), 10);
-        });
-        it('should use default grid size when not provided', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123 });
-            // Should work with 3D coordinates (default dimension)
-            const value = noise.noise([1.0, 1.0, 1.0]);
-            expect(typeof value).toBe('number');
-        });
-        it('should throw error for invalid grid size length', () => {
-            expect(() => new index_1.PerlinNoise({ gridSize: [] })).toThrow();
-            expect(() => new index_1.PerlinNoise({ gridSize: Array(11).fill(10) })).toThrow();
-        });
-    });
-    describe('1D noise', () => {
-        it('should generate noise value for 1D coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            const value = noise.noise([1.5]);
-            expect(typeof value).toBe('number');
-            expect(value).toBeGreaterThanOrEqual(-2);
-            expect(value).toBeLessThanOrEqual(2);
-        });
-        it('should produce consistent results for same point', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            const value1 = noise.noise([2.3]);
-            const value2 = noise.noise([2.3]);
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-        it('should produce different results for different points', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            const value1 = noise.noise([1.0]);
-            const value2 = noise.noise([5.0]);
-            // They might be the same by chance, but very unlikely
-            expect(typeof value1).toBe('number');
-            expect(typeof value2).toBe('number');
-        });
-        it('should handle negative coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            const value = noise.noise([-1.5]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle large coordinates (wrapping)', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            const value1 = noise.noise([1.5]);
-            const value2 = noise.noise([11.5]); // Should wrap to 1.5
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-        it('should handle coordinates at grid boundaries', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            const value = noise.noise([10.0]);
-            expect(typeof value).toBe('number');
-        });
-    });
-    describe('2D noise', () => {
-        it('should generate noise value for 2D coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            const value = noise.noise([1.5, 2.3]);
-            expect(typeof value).toBe('number');
-            expect(value).toBeGreaterThanOrEqual(-2);
-            expect(value).toBeLessThanOrEqual(2);
-        });
-        it('should produce consistent results for same point', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            const value1 = noise.noise([2.3, 4.7]);
-            const value2 = noise.noise([2.3, 4.7]);
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-        it('should produce different results for different points', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            const value1 = noise.noise([1.0, 1.0]);
-            const value2 = noise.noise([5.0, 5.0]);
-            expect(typeof value1).toBe('number');
-            expect(typeof value2).toBe('number');
-        });
-        it('should handle negative coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            const value = noise.noise([-1.5, -2.3]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle large coordinates (wrapping)', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            const value1 = noise.noise([1.5, 2.3]);
-            const value2 = noise.noise([11.5, 12.3]); // Should wrap
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-        it('should produce smooth transitions', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            const value1 = noise.noise([1.0, 1.0]);
-            const value2 = noise.noise([1.1, 1.0]);
-            const value3 = noise.noise([1.2, 1.0]);
-            // Values should change gradually (not jump dramatically)
-            expect(typeof value1).toBe('number');
-            expect(typeof value2).toBe('number');
-            expect(typeof value3).toBe('number');
-        });
-    });
-    describe('3D noise', () => {
-        it('should generate noise value for 3D coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value = noise.noise([1.5, 2.3, 3.7]);
-            expect(typeof value).toBe('number');
-            expect(value).toBeGreaterThanOrEqual(-2);
-            expect(value).toBeLessThanOrEqual(2);
-        });
-        it('should produce consistent results for same point', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value1 = noise.noise([2.3, 4.7, 1.2]);
-            const value2 = noise.noise([2.3, 4.7, 1.2]);
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-        it('should produce different results for different points', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value1 = noise.noise([1.0, 1.0, 1.0]);
-            const value2 = noise.noise([5.0, 5.0, 5.0]);
-            expect(typeof value1).toBe('number');
-            expect(typeof value2).toBe('number');
-        });
-        it('should handle negative coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value = noise.noise([-1.5, -2.3, -3.7]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle large coordinates (wrapping)', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value1 = noise.noise([1.5, 2.3, 3.7]);
-            const value2 = noise.noise([11.5, 12.3, 13.7]); // Should wrap
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-    });
-    describe('dimension validation', () => {
-        it('should throw error when noise dimension does not match grid dimension', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            expect(() => noise.noise([1.0])).toThrow(); // 1D noise on 2D grid
-            expect(() => noise.noise([1.0, 1.0, 1.0])).toThrow(); // 3D noise on 2D grid
-        });
-        it('should allow 1D noise on 1D grid', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10] });
-            expect(() => noise.noise([1.0])).not.toThrow();
-        });
-        it('should allow 2D noise on 2D grid', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10] });
-            expect(() => noise.noise([1.0, 1.0])).not.toThrow();
-        });
-        it('should allow 3D noise on 3D grid', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            expect(() => noise.noise([1.0, 1.0, 1.0])).not.toThrow();
-        });
-    });
-    describe('seed behavior', () => {
-        it('should produce different results with different seeds', () => {
-            const noise1 = new index_1.PerlinNoise({ seed: 100, gridSize: [10, 10, 10] });
-            const noise2 = new index_1.PerlinNoise({ seed: 200, gridSize: [10, 10, 10] });
-            const value1 = noise1.noise([1.0, 1.0, 1.0]);
-            const value2 = noise2.noise([1.0, 1.0, 1.0]);
-            // They might be the same by chance, but very unlikely
-            expect(typeof value1).toBe('number');
-            expect(typeof value2).toBe('number');
-        });
-        it('should produce same results with same seed', () => {
-            const noise1 = new index_1.PerlinNoise({ seed: 500, gridSize: [10, 10, 10] });
-            const noise2 = new index_1.PerlinNoise({ seed: 500, gridSize: [10, 10, 10] });
-            const value1 = noise1.noise([2.5, 3.7, 1.2]);
-            const value2 = noise2.noise([2.5, 3.7, 1.2]);
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle zero coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value = noise.noise([0.0, 0.0, 0.0]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle very small coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value = noise.noise([0.0001, 0.0001, 0.0001]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle very large coordinates', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value = noise.noise([1000.5, 2000.3, 3000.7]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle coordinates at exact grid boundaries', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [10, 10, 10] });
-            const value = noise.noise([10.0, 10.0, 10.0]);
-            expect(typeof value).toBe('number');
-        });
-        it('should handle different grid sizes', () => {
-            const noise1 = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5] });
-            const noise2 = new index_1.PerlinNoise({ seed: 123, gridSize: [20, 20, 20] });
-            const value1 = noise1.noise([1.0, 1.0, 1.0]);
-            const value2 = noise2.noise([1.0, 1.0, 1.0]);
-            // Different grid sizes with same seed should produce different results
-            expect(typeof value1).toBe('number');
-            expect(typeof value2).toBe('number');
-        });
-    });
-    describe('higher dimensions', () => {
-        it('should support 4D noise', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5, 5] });
-            const value = noise.noise([1.0, 1.0, 1.0, 1.0]);
-            expect(typeof value).toBe('number');
-            expect(value).toBeGreaterThanOrEqual(-2);
-            expect(value).toBeLessThanOrEqual(2);
-        });
-        it('should support 5D noise', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5, 5, 5] });
-            const value = noise.noise([1.0, 1.0, 1.0, 1.0, 1.0]);
-            expect(typeof value).toBe('number');
-        });
-        it('should support 10D noise (maximum)', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2] });
-            const value = noise.noise([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]);
-            expect(typeof value).toBe('number');
-        });
-        it('should produce consistent results for same point in higher dimensions', () => {
-            const noise = new index_1.PerlinNoise({ seed: 123, gridSize: [5, 5, 5, 5] });
-            const value1 = noise.noise([2.3, 4.7, 1.2, 3.5]);
-            const value2 = noise.noise([2.3, 4.7, 1.2, 3.5]);
-            expect(value1).toBeCloseTo(value2, 10);
-        });
-    });
-});

package/dist/__tests__/interpolation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/interpolation.test.js

@@ -1,253 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const interpolation_1 = require("../interpolation");
-describe('smoothstep', () => {
-    it('should return 0 for t = 0', () => {
-        expect((0, interpolation_1.smoothstep)(0)).toBe(0);
-    });
-    it('should return 1 for t = 1', () => {
-        expect((0, interpolation_1.smoothstep)(1)).toBe(1);
-    });
-    it('should return 0.5 for t = 0.5', () => {
-        expect((0, interpolation_1.smoothstep)(0.5)).toBe(0.5);
-    });
-    it('should be symmetric around 0.5', () => {
-        const t1 = 0.3;
-        const t2 = 0.7;
-        const s1 = (0, interpolation_1.smoothstep)(t1);
-        const s2 = (0, interpolation_1.smoothstep)(t2);
-        expect(s1 + s2).toBeCloseTo(1, 10);
-    });
-    it('should clamp values outside [0, 1]', () => {
-        expect((0, interpolation_1.smoothstep)(-1)).toBe(0);
-        expect((0, interpolation_1.smoothstep)(2)).toBe(1);
-    });
-    it('should have zero derivative at endpoints', () => {
-        // Numerical test of derivative near 0
-        const h = 0.0001;
-        const derivativeAt0 = ((0, interpolation_1.smoothstep)(h) - (0, interpolation_1.smoothstep)(0)) / h;
-        expect(derivativeAt0).toBeCloseTo(0, 2);
-        // Numerical test of derivative near 1
-        const derivativeAt1 = ((0, interpolation_1.smoothstep)(1) - (0, interpolation_1.smoothstep)(1 - h)) / h;
-        expect(derivativeAt1).toBeCloseTo(0, 2);
-    });
-    it('should be monotonically increasing', () => {
-        const values = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0];
-        for (let i = 1; i < values.length; i++) {
-            expect((0, interpolation_1.smoothstep)(values[i])).toBeGreaterThanOrEqual((0, interpolation_1.smoothstep)(values[i - 1]));
-        }
-    });
-});
-describe('calculateFractionalCoordinates', () => {
-    it('should calculate fractional coordinates for a 1D point', () => {
-        const point = [2.3];
-        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
-        expect(fractional).toHaveLength(1);
-        expect(fractional[0]).toBeCloseTo(0.3, 10);
-    });
-    it('should calculate fractional coordinates for a 2D point', () => {
-        const point = [1.7, 3.2];
-        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
-        expect(fractional).toHaveLength(2);
-        expect(fractional[0]).toBeCloseTo(0.7, 10);
-        expect(fractional[1]).toBeCloseTo(0.2, 10);
-    });
-    it('should return 0 for a point exactly on a grid node', () => {
-        const point = [2.0, 3.0];
-        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
-        expect(fractional[0]).toBe(0);
-        expect(fractional[1]).toBe(0);
-    });
-    it('should handle negative coordinates', () => {
-        const point = [-1.3];
-        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
-        // -1.3 is in cell [-2], so fractional coordinate is -1.3 - (-2) = 0.7
-        expect(fractional[0]).toBeCloseTo(0.7, 10);
-    });
-    it('should handle fractional coordinates close to 1', () => {
-        const point = [2.99];
-        const fractional = (0, interpolation_1.calculateFractionalCoordinates)(point);
-        expect(fractional[0]).toBeCloseTo(0.99, 10);
-    });
-});
-describe('interpolate1D', () => {
-    it('should return a0 for t = 0', () => {
-        expect((0, interpolation_1.interpolate1D)(5, 10, 0)).toBe(5);
-    });
-    it('should return a1 for t = 1', () => {
-        expect((0, interpolation_1.interpolate1D)(5, 10, 1)).toBe(10);
-    });
-    it('should return the average for t = 0.5', () => {
-        expect((0, interpolation_1.interpolate1D)(0, 10, 0.5)).toBeCloseTo(5, 10);
-    });
-    it('should interpolate correctly for different values', () => {
-        const result = (0, interpolation_1.interpolate1D)(0, 100, 0.3);
-        // For t=0.3, smoothstep(0.3) ≈ 0.216, so result ≈ 0 + 0.216 * 100 = 21.6
-        expect(result).toBeGreaterThan(0);
-        expect(result).toBeLessThan(100);
-    });
-    it('should handle negative values', () => {
-        expect((0, interpolation_1.interpolate1D)(-10, 10, 0.5)).toBeCloseTo(0, 10);
-    });
-    it('should be symmetric', () => {
-        const result1 = (0, interpolation_1.interpolate1D)(0, 10, 0.3);
-        const result2 = (0, interpolation_1.interpolate1D)(10, 0, 0.7);
-        expect(result1).toBeCloseTo(result2, 10);
-    });
-});
-describe('interpolateScalarValues', () => {
-    describe('1D interpolation', () => {
-        it('should interpolate between 2 scalar values for a 1D point', () => {
-            const scalarValues = [5, 10];
-            const point = [0.3]; // Fractional coordinate = 0.3
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            // Should be equivalent to interpolate1D(5, 10, 0.3)
-            const expected = (0, interpolation_1.interpolate1D)(5, 10, 0.3);
-            expect(result).toBeCloseTo(expected, 10);
-        });
-        it('should return the first value for a point at node 0', () => {
-            const scalarValues = [5, 10];
-            const point = [2.0]; // Exactly at node
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBeCloseTo(5, 10);
-        });
-        it('should return the second value for a point at node 1', () => {
-            const scalarValues = [5, 10];
-            // Note: for point=[3.0], fractional coordinate is 0, so we're at node of cell [3]
-            // But scalar values are for cell [2], so we test with point=[2.999...]
-            const point2 = [2.999999];
-            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point2);
-            expect(result2).toBeCloseTo(10, 2);
-        });
-        it('should throw error if number of values does not match', () => {
-            const scalarValues = [5, 10, 15]; // 3 values instead of 2
-            const point = [0.5];
-            expect(() => (0, interpolation_1.interpolateScalarValues)(scalarValues, point)).toThrow();
-        });
-    });
-    describe('2D interpolation', () => {
-        it('should interpolate between 4 scalar values for a 2D point', () => {
-            const scalarValues = [0, 10, 20, 30];
-            const point = [0.5, 0.5]; // Cell center
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            // At center, we should get approximately the average
-            expect(result).toBeGreaterThan(0);
-            expect(result).toBeLessThan(30);
-        });
-        it('should return corner value for a point exactly on a corner', () => {
-            const scalarValues = [5, 10, 15, 20];
-            const point = [2.0, 3.0]; // Exactly at corner [2,3]
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            // Should return the first value (bottom-left corner)
-            expect(result).toBeCloseTo(5, 10);
-        });
-        it('should interpolate correctly for different positions', () => {
-            const scalarValues = [0, 1, 2, 3];
-            const point = [0.0, 0.0]; // Bottom-left corner
-            const result1 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result1).toBeCloseTo(0, 10);
-            const point2 = [0.999, 0.999]; // Close to top-right corner
-            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point2);
-            expect(result2).toBeCloseTo(3, 1);
-        });
-        it('should throw error if number of values does not match', () => {
-            const scalarValues = [0, 1, 2]; // 3 values instead of 4
-            const point = [0.5, 0.5];
-            expect(() => (0, interpolation_1.interpolateScalarValues)(scalarValues, point)).toThrow();
-        });
-    });
-    describe('3D interpolation', () => {
-        it('should interpolate between 8 scalar values for a 3D point', () => {
-            const scalarValues = [0, 1, 2, 3, 4, 5, 6, 7];
-            const point = [0.5, 0.5, 0.5]; // Cell center
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBeGreaterThanOrEqual(0);
-            expect(result).toBeLessThanOrEqual(7);
-        });
-        it('should return corner value for a point exactly on a corner', () => {
-            const scalarValues = [10, 20, 30, 40, 50, 60, 70, 80];
-            const point = [1.0, 2.0, 3.0]; // Exactly at corner
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            // Should return the first value
-            expect(result).toBeCloseTo(10, 10);
-        });
-        it('should throw error if number of values does not match', () => {
-            const scalarValues = [0, 1, 2, 3, 4, 5, 6]; // 7 values instead of 8
-            const point = [0.5, 0.5, 0.5];
-            expect(() => (0, interpolation_1.interpolateScalarValues)(scalarValues, point)).toThrow();
-        });
-    });
-    describe('higher dimensions', () => {
-        it('should interpolate between 16 scalar values for a 4D point', () => {
-            const scalarValues = Array.from({ length: 16 }, (_, i) => i);
-            const point = [0.5, 0.5, 0.5, 0.5];
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBeGreaterThanOrEqual(0);
-            expect(result).toBeLessThanOrEqual(15);
-        });
-        it('should interpolate between 32 scalar values for a 5D point', () => {
-            const scalarValues = Array.from({ length: 32 }, (_, i) => i);
-            const point = [0.5, 0.5, 0.5, 0.5, 0.5];
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBeGreaterThanOrEqual(0);
-            expect(result).toBeLessThanOrEqual(31);
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle all identical scalar values', () => {
-            const scalarValues = [5, 5, 5, 5];
-            const point = [0.7, 0.3];
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBe(5);
-        });
-        it('should handle negative scalar values', () => {
-            const scalarValues = [-10, -5, 5, 10];
-            const point = [0.5, 0.5];
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBeGreaterThan(-10);
-            expect(result).toBeLessThan(10);
-        });
-        it('should handle very large scalar values', () => {
-            const scalarValues = [1000, 2000, 3000, 4000];
-            const point = [0.5, 0.5];
-            const result = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result).toBeGreaterThan(1000);
-            expect(result).toBeLessThan(4000);
-        });
-        it('should produce consistent results for the same point', () => {
-            const scalarValues = [0, 1, 2, 3];
-            const point = [0.7, 0.3];
-            const result1 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point);
-            expect(result1).toBeCloseTo(result2, 10);
-        });
-        it('should produce different results for different points', () => {
-            const scalarValues = [0, 1, 2, 3];
-            const point1 = [0.1, 0.1];
-            const point2 = [0.9, 0.9];
-            const result1 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point1);
-            const result2 = (0, interpolation_1.interpolateScalarValues)(scalarValues, point2);
-            expect(result1).not.toBeCloseTo(result2, 10);
-        });
-    });
-});
-describe('scaleNoiseValue', () => {
-    it('should return unchanged value with scale factor of 1.0', () => {
-        expect((0, interpolation_1.scaleNoiseValue)(0.5)).toBe(0.5);
-        expect((0, interpolation_1.scaleNoiseValue)(-0.3)).toBe(-0.3);
-        expect((0, interpolation_1.scaleNoiseValue)(1.0)).toBe(1.0);
-    });
-    it('should scale correctly with custom scale factor', () => {
-        expect((0, interpolation_1.scaleNoiseValue)(0.5, 2.0)).toBe(1.0);
-        expect((0, interpolation_1.scaleNoiseValue)(0.5, 0.5)).toBe(0.25);
-        expect((0, interpolation_1.scaleNoiseValue)(-0.5, 2.0)).toBe(-1.0);
-    });
-    it('should handle scale factor of 0', () => {
-        expect((0, interpolation_1.scaleNoiseValue)(0.5, 0)).toBe(0);
-        expect((0, interpolation_1.scaleNoiseValue)(-0.3, 0)).toBeCloseTo(0, 10);
-    });
-    it('should handle negative values', () => {
-        expect((0, interpolation_1.scaleNoiseValue)(-0.5, 2.0)).toBe(-1.0);
-        expect((0, interpolation_1.scaleNoiseValue)(-1.0, 0.5)).toBe(-0.5);
-    });
-});

package/dist/__tests__/scalar.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/scalar.test.js

@@ -1,210 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const grid_1 = require("../grid");
-const scalar_1 = require("../scalar");
-describe('calculateScalarValues', () => {
-    describe('1D grid', () => {
-        it('should return 2 scalar values for a point in 1D (2 vertices)', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
-            const point = [2.5]; // Point in cell [2]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(2); // 2^1 = 2 vertices
-        });
-        it('should calculate correct dot products for 1D', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
-            const point = [1.3]; // Point in cell [1]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            // Cell [1] has vertices at [1] and [2]
-            const gradient1 = grid.get('1');
-            const gradient2 = grid.get('2');
-            // Distance vectors: point - vertex
-            const distance1 = point[0] - 1; // 1.3 - 1 = 0.3
-            const distance2 = point[0] - 2; // 1.3 - 2 = -0.7
-            // Dot products: gradient * distance
-            const expected1 = gradient1 * distance1;
-            const expected2 = gradient2 * distance2;
-            expect(scalarValues[0]).toBeCloseTo(expected1, 10);
-            expect(scalarValues[1]).toBeCloseTo(expected2, 10);
-        });
-        it('should handle point at cell boundary', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
-            const point = [2.0]; // Exactly at cell boundary (cell [2])
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(2);
-            // Cell [2] has vertices at [2] (i=0) and [3] (i=1)
-            // Distance to vertex [2] should be 0
-            const gradient2 = grid.get('2');
-            expect(scalarValues[0]).toBeCloseTo(gradient2 * 0, 10); // First vertex is [2]
-        });
-        it('should handle negative coordinates', () => {
-            // Create a grid that covers negative coordinates by using a larger grid
-            // and testing a point that maps to a valid cell
-            const grid = (0, grid_1.generateGradientGrid)(1, [10], 123);
-            const point = [0.5]; // Cell [0], which is valid
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(2);
-            // Verify vertices are [0] and [1]
-            expect(grid.has('0')).toBe(true);
-            expect(grid.has('1')).toBe(true);
-        });
-        it('should throw error when point is outside grid bounds', () => {
-            const grid = (0, grid_1.generateGradientGrid)(1, [5], 123);
-            const point = [10.0]; // Outside grid (max is 5, so vertices go up to 6)
-            expect(() => (0, scalar_1.calculateScalarValues)(grid, point)).toThrow();
-        });
-    });
-    describe('2D grid', () => {
-        it('should return 4 scalar values for a point in 2D (4 vertices)', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [2.5, 3.2]; // Point in cell [2, 3]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(4); // 2^2 = 4 vertices
-        });
-        it('should calculate correct dot products for 2D', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [1.3, 2.7]; // Point in cell [1, 2]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            // Cell [1, 2] has vertices in order: [1,2] (i=0), [2,2] (i=1), [1,3] (i=2), [2,3] (i=3)
-            const gradient12 = grid.get('1,2');
-            const gradient22 = grid.get('2,2');
-            const gradient13 = grid.get('1,3');
-            const gradient23 = grid.get('2,3');
-            // Distance vectors: point - vertex
-            const distance12 = [point[0] - 1, point[1] - 2]; // [0.3, 0.7]
-            const distance22 = [point[0] - 2, point[1] - 2]; // [-0.7, 0.7]
-            const distance13 = [point[0] - 1, point[1] - 3]; // [0.3, -0.3]
-            const distance23 = [point[0] - 2, point[1] - 3]; // [-0.7, -0.3]
-            // Dot products
-            const expected12 = gradient12[0] * distance12[0] + gradient12[1] * distance12[1];
-            const expected22 = gradient22[0] * distance22[0] + gradient22[1] * distance22[1];
-            const expected13 = gradient13[0] * distance13[0] + gradient13[1] * distance13[1];
-            const expected23 = gradient23[0] * distance23[0] + gradient23[1] * distance23[1];
-            expect(scalarValues[0]).toBeCloseTo(expected12, 10);
-            expect(scalarValues[1]).toBeCloseTo(expected22, 10);
-            expect(scalarValues[2]).toBeCloseTo(expected13, 10);
-            expect(scalarValues[3]).toBeCloseTo(expected23, 10);
-        });
-        it('should handle point at cell corner', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [2.0, 3.0]; // Exactly at vertex [2, 3] in cell [2, 3]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(4);
-            // Cell [2, 3] has vertices in order: [2,3] (i=0), [3,3] (i=1), [2,4] (i=2), [3,4] (i=3)
-            // Distance to vertex [2, 3] should be [0, 0]
-            expect(scalarValues[0]).toBeCloseTo(0, 10); // dot product with [0, 0] is 0
-        });
-        it('should handle decimal coordinates correctly', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [0.1, 0.9]; // Should be in cell [0, 0]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(4);
-            // All vertices should be in cell [0, 0]: [0,0], [0,1], [1,0], [1,1]
-            expect(grid.has('0,0')).toBe(true);
-            expect(grid.has('0,1')).toBe(true);
-            expect(grid.has('1,0')).toBe(true);
-            expect(grid.has('1,1')).toBe(true);
-        });
-        it('should throw error when point is outside grid bounds', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [3, 3], 123);
-            const point = [10.0, 10.0]; // Outside grid
-            expect(() => (0, scalar_1.calculateScalarValues)(grid, point)).toThrow();
-        });
-    });
-    describe('3D grid', () => {
-        it('should return 8 scalar values for a point in 3D (8 vertices)', () => {
-            const grid = (0, grid_1.generateGradientGrid)(3, [5, 5, 5], 123);
-            const point = [2.5, 3.2, 1.8]; // Point in cell [2, 3, 1]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(8); // 2^3 = 8 vertices
-        });
-        it('should calculate correct dot products for 3D', () => {
-            const grid = (0, grid_1.generateGradientGrid)(3, [5, 5, 5], 123);
-            const point = [1.0, 1.0, 1.0]; // Point in cell [1, 1, 1]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            // Verify we get 8 values
-            expect(scalarValues).toHaveLength(8);
-            // Verify all vertices exist in grid
-            const cell = [1, 1, 1];
-            for (let i = 0; i < 8; i++) {
-                const vertex = [
-                    cell[0] + ((i >> 0) & 1),
-                    cell[1] + ((i >> 1) & 1),
-                    cell[2] + ((i >> 2) & 1),
-                ];
-                const key = vertex.join(',');
-                expect(grid.has(key)).toBe(true);
-            }
-        });
-        it('should handle point at cell center', () => {
-            const grid = (0, grid_1.generateGradientGrid)(3, [5, 5, 5], 123);
-            const point = [1.5, 1.5, 1.5]; // Center of cell [1, 1, 1]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(8);
-            // All distance vectors should have components of ±0.5
-            expect(scalarValues.every(val => typeof val === 'number')).toBe(true);
-        });
-    });
-    describe('higher dimensions', () => {
-        it('should return 16 scalar values for a point in 4D (16 vertices)', () => {
-            const grid = (0, grid_1.generateGradientGrid)(4, [3, 3, 3, 3], 123);
-            const point = [1.0, 1.0, 1.0, 1.0]; // Point in cell [1, 1, 1, 1]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(16); // 2^4 = 16 vertices
-        });
-        it('should return 32 scalar values for a point in 5D (32 vertices)', () => {
-            const grid = (0, grid_1.generateGradientGrid)(5, [2, 2, 2, 2, 2], 123);
-            const point = [1.0, 1.0, 1.0, 1.0, 1.0]; // Point in cell [1, 1, 1, 1, 1]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(32); // 2^5 = 32 vertices
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle point at origin', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [0.0, 0.0]; // Cell [0, 0]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(4);
-            expect(grid.has('0,0')).toBe(true);
-            expect(grid.has('0,1')).toBe(true);
-            expect(grid.has('1,0')).toBe(true);
-            expect(grid.has('1,1')).toBe(true);
-        });
-        it('should handle very small coordinates', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [0.0001, 0.0001]; // Cell [0, 0]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(4);
-        });
-        it('should handle large coordinates within bounds', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [10, 10], 123);
-            const point = [9.9, 9.9]; // Cell [9, 9], should have vertices at [9,9], [9,10], [10,9], [10,10]
-            const scalarValues = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues).toHaveLength(4);
-            // Grid size is 10, so vertices go up to 10
-            expect(grid.has('9,9')).toBe(true);
-            expect(grid.has('9,10')).toBe(true);
-            expect(grid.has('10,9')).toBe(true);
-            expect(grid.has('10,10')).toBe(true);
-        });
-        it('should produce consistent results for same point', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point = [2.5, 3.2];
-            const scalarValues1 = (0, scalar_1.calculateScalarValues)(grid, point);
-            const scalarValues2 = (0, scalar_1.calculateScalarValues)(grid, point);
-            expect(scalarValues1).toHaveLength(scalarValues2.length);
-            for (let i = 0; i < scalarValues1.length; i++) {
-                expect(scalarValues1[i]).toBeCloseTo(scalarValues2[i], 10);
-            }
-        });
-        it('should produce different results for different points', () => {
-            const grid = (0, grid_1.generateGradientGrid)(2, [5, 5], 123);
-            const point1 = [1.0, 1.0];
-            const point2 = [2.0, 2.0];
-            const scalarValues1 = (0, scalar_1.calculateScalarValues)(grid, point1);
-            const scalarValues2 = (0, scalar_1.calculateScalarValues)(grid, point2);
-            // They might have some same values, but at least one should be different
-            expect(scalarValues1).toHaveLength(4);
-            expect(scalarValues2).toHaveLength(4);
-        });
-    });
-});