chore: update dependencies

Author: lpatiny

package.json

@@ -46,11 +46,11 @@
     "ml-xsadd": "^3.0.1"
   },
   "devDependencies": {
-    "@types/node": "^24.3.1",
+    "@types/node": "^24.5.2",
     "@vitest/coverage-v8": "^3.2.4",
     "@zakodium/tsconfig": "^1.0.2",
     "cheminfo-build": "^1.3.1",
-    "eslint": "^9.35.0",
+    "eslint": "^9.36.0",
     "eslint-config-cheminfo-typescript": "^20.0.0",
     "jest-matcher-deep-close-to": "^3.0.2",
     "ml-spectra-fitting": "^5.0.1",

src/__tests__/index.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import * as SpectraProcessing from '../index.ts';
 
-test('test existence of exported functions', () => {
+test('existence of exported functions', () => {
   const exports = Object.keys(SpectraProcessing);
 
   expect(exports).toMatchSnapshot();

src/matrix/__tests__/matrixAutoCorrelation.test.ts

@@ -14,7 +14,7 @@ test('simple', () => {
   expect(result[1]).toBeCloseTo(-1, 10);
 });
 
-test('test matrixAutoCorrelation too small', () => {
+test('matrixAutoCorrelation too small', () => {
   const matrix = [[0]];
 
   expect(() => matrixAutoCorrelation(matrix)).toThrow(

src/matrix/__tests__/matrixBoxPlot.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { matrixBoxPlot } from '../matrixBoxPlot.ts';
 
-test('test matrixBoxPlot even', () => {
+test('matrixBoxPlot even', () => {
   const matrix = [
     [0, 0],
     [1, 10],
@@ -27,7 +27,7 @@ test('test matrixBoxPlot even', () => {
   });
 });
 
-test('test matrixBoxPlot even small', () => {
+test('matrixBoxPlot even small', () => {
   const matrix = [[0], [1], [2], [3], [4], [5]];
 
   expect(matrixBoxPlot(matrix)).toStrictEqual({
@@ -39,7 +39,7 @@ test('test matrixBoxPlot even small', () => {
   });
 });
 
-test('test matrixBoxPlot odd', () => {
+test('matrixBoxPlot odd', () => {
   const matrix = [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10]];
 
   expect(matrixBoxPlot(matrix)).toStrictEqual({
@@ -51,7 +51,7 @@ test('test matrixBoxPlot odd', () => {
   });
 });
 
-test('test matrixBoxPlot odd small', () => {
+test('matrixBoxPlot odd small', () => {
   const matrix = [[0], [1], [2], [3], [4]];
 
   expect(matrixBoxPlot(matrix)).toStrictEqual({
@@ -63,7 +63,7 @@ test('test matrixBoxPlot odd small', () => {
   });
 });
 
-test('test matrixBoxPlot too small', () => {
+test('matrixBoxPlot too small', () => {
   const matrix = [[0], [1], [2], [4]];
 
   expect(() => matrixBoxPlot(matrix)).toThrow(

src/reim/__tests__/reimAbsolute.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { reimAbsolute } from '../reimAbsolute.ts';
 
-test('test reimAbsolute', () => {
+test('reimAbsolute', () => {
   const re = [0, 3, 6];
   const im = [0, 4, 8];
   const result = reimAbsolute({ re, im });

src/reim/__tests__/reimFFT.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { reimFFT } from '../reimFFT.ts';
 
-test('test reimFFT', () => {
+test('reimFFT', () => {
   const re = Float64Array.from([0, 3, 6, 5]);
   const im = Float64Array.from([0, 4, 8, 3]);
   const transformed = reimFFT({ re, im }, { applyZeroShift: true });

src/reim/__tests__/reimPhaseCorrection.test.ts

@@ -107,7 +107,7 @@ const data = {
   ],
 };
 
-test('test reimPhaseCorrection even', () => {
+test('reimPhaseCorrection even', () => {
   const re = [0, 1, 2, 3];
   const im = [0, 1, 2, 3];
   const result = reimPhaseCorrection({ re, im }, 0, 0);

src/reim/__tests__/reimZeroFilling.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { reimZeroFilling } from '../reimZeroFilling.ts';
 
-test('test xreimZeroFilling over', () => {
+test('xreimZeroFilling over', () => {
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
   const result = reimZeroFilling({ re, im }, 6);
@@ -16,7 +16,7 @@ test('test xreimZeroFilling over', () => {
   });
 });
 
-test('test xreimZeroFilling equal', () => {
+test('xreimZeroFilling equal', () => {
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
   const result = reimZeroFilling({ re, im }, 4);
@@ -29,7 +29,7 @@ test('test xreimZeroFilling equal', () => {
   });
 });
 
-test('test xreimZeroFilling under', () => {
+test('xreimZeroFilling under', () => {
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
   const result = reimZeroFilling({ re, im }, 2);

src/x/__tests__/xAdd.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xAdd } from '../xAdd.ts';
 
-test('test xAdd of 2 vectors', () => {
+test('xAdd of 2 vectors', () => {
   const array1 = [10, 11, 12, 13, 14];
   const array2 = [5, 4, 3, 2, 1];
 
@@ -11,15 +11,15 @@ test('test xAdd of 2 vectors', () => {
   );
 });
 
-test('test xAdd of 2 a constant', () => {
+test('xAdd of 2 a constant', () => {
   const array1 = [10, 11, 12, 13, 14];
 
   expect(xAdd(array1, 5)).toStrictEqual(
     Float64Array.from([15, 16, 17, 18, 19]),
   );
 });
 
-test('test xAdd of array and floatarray', () => {
+test('xAdd of array and floatarray', () => {
   const array1 = [10, 11, 12, 13, 14];
   const array2 = new Float64Array([5, 4, 3, 2, 1]);
 

src/x/__tests__/xBoxPlot.test.ts

@@ -41,7 +41,7 @@ test('basic even', () => {
   });
 });
 
-test('test xBoxPlot even', () => {
+test('xBoxPlot even', () => {
   const array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
 
   expect(xBoxPlot(array)).toStrictEqual({
@@ -53,7 +53,7 @@ test('test xBoxPlot even', () => {
   });
 });
 
-test('test xBoxPlot even small', () => {
+test('xBoxPlot even small', () => {
   const array = [0, 1, 2, 3, 4, 5];
 
   expect(xBoxPlot(array)).toStrictEqual({
@@ -65,7 +65,7 @@ test('test xBoxPlot even small', () => {
   });
 });
 
-test('test xBoxPlot odd', () => {
+test('xBoxPlot odd', () => {
   const array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
   expect(xBoxPlot(array)).toStrictEqual({
@@ -77,7 +77,7 @@ test('test xBoxPlot odd', () => {
   });
 });
 
-test('test xBoxPlot odd small', () => {
+test('xBoxPlot odd small', () => {
   const array = [0, 1, 2, 3, 4];
 
   expect(xBoxPlot(array)).toStrictEqual({
@@ -89,13 +89,13 @@ test('test xBoxPlot odd small', () => {
   });
 });
 
-test('test xBoxPlot too small', () => {
+test('xBoxPlot too small', () => {
   const array: number[] = [];
 
   expect(() => xBoxPlot(array)).toThrow('input must not be empty');
 });
 
-test('test xBoxPlot with one element', () => {
+test('xBoxPlot with one element', () => {
   const array = [42];
 
   expect(xBoxPlot(array)).toStrictEqual({
@@ -107,7 +107,7 @@ test('test xBoxPlot with one element', () => {
   });
 });
 
-test('test xBoxPlot with 2 elements', () => {
+test('xBoxPlot with 2 elements', () => {
   const array = [40, 44];
   const result = xBoxPlot(array);
 
@@ -120,7 +120,7 @@ test('test xBoxPlot with 2 elements', () => {
   });
 });
 
-test('test xBoxPlot with 3 elements', () => {
+test('xBoxPlot with 3 elements', () => {
   const array = [44, 40, 42];
   const result = xBoxPlot(array);