diff --git a/package.json b/package.json
index 3df866c5..b80f73a4 100644
--- a/package.json
+++ b/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",
diff --git a/src/__tests__/__snapshots__/index.test.ts.snap b/src/__tests__/__snapshots__/index.test.ts.snap
index 055e9cf5..2dacb647 100644
--- a/src/__tests__/__snapshots__/index.test.ts.snap
+++ b/src/__tests__/__snapshots__/index.test.ts.snap
@@ -1,6 +1,6 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`test existence of exported functions 1`] = `
+exports[`existence of exported functions 1`] = `
 [
   "reimAbsolute",
   "reimAutoPhaseCorrection",
diff --git a/src/__tests__/index.test.ts b/src/__tests__/index.test.ts
index 6ef31c12..5540a628 100644
--- a/src/__tests__/index.test.ts
+++ b/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();
diff --git a/src/matrix/__tests__/matrixAutoCorrelation.test.ts b/src/matrix/__tests__/matrixAutoCorrelation.test.ts
index bd71facc..a29ed54f 100644
--- a/src/matrix/__tests__/matrixAutoCorrelation.test.ts
+++ b/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(
diff --git a/src/matrix/__tests__/matrixBoxPlot.test.ts b/src/matrix/__tests__/matrixBoxPlot.test.ts
index 9787a248..0b865b48 100644
--- a/src/matrix/__tests__/matrixBoxPlot.test.ts
+++ b/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(
diff --git a/src/reim/__tests__/reimAbsolute.test.ts b/src/reim/__tests__/reimAbsolute.test.ts
index 3dd7569e..d7fd18fe 100644
--- a/src/reim/__tests__/reimAbsolute.test.ts
+++ b/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 });
diff --git a/src/reim/__tests__/reimFFT.test.ts b/src/reim/__tests__/reimFFT.test.ts
index 207d44a2..0af28fd4 100644
--- a/src/reim/__tests__/reimFFT.test.ts
+++ b/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 });
diff --git a/src/reim/__tests__/reimPhaseCorrection.test.ts b/src/reim/__tests__/reimPhaseCorrection.test.ts
index a1306486..1ca29fef 100644
--- a/src/reim/__tests__/reimPhaseCorrection.test.ts
+++ b/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);
diff --git a/src/reim/__tests__/reimZeroFilling.test.ts b/src/reim/__tests__/reimZeroFilling.test.ts
index 0b6df84f..11151afe 100644
--- a/src/reim/__tests__/reimZeroFilling.test.ts
+++ b/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);
diff --git a/src/x/__tests__/xAdd.test.ts b/src/x/__tests__/xAdd.test.ts
index c3f27d25..4d2a25fc 100644
--- a/src/x/__tests__/xAdd.test.ts
+++ b/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,7 +11,7 @@ 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(
@@ -19,7 +19,7 @@ test('test xAdd of 2 a constant', () => {
   );
 });
 
-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]);
 
diff --git a/src/x/__tests__/xBoxPlot.test.ts b/src/x/__tests__/xBoxPlot.test.ts
index 138330de..99077eac 100644
--- a/src/x/__tests__/xBoxPlot.test.ts
+++ b/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);
 
diff --git a/src/x/__tests__/xBoxPlotWithOutliers.test.ts b/src/x/__tests__/xBoxPlotWithOutliers.test.ts
index d5d2cb16..159b0413 100644
--- a/src/x/__tests__/xBoxPlotWithOutliers.test.ts
+++ b/src/x/__tests__/xBoxPlotWithOutliers.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xBoxPlotWithOutliers } from '../xBoxPlotWithOutliers.ts';
 
-test('test xBoxPlotWithOutliers even', () => {
+test('xBoxPlotWithOutliers even', () => {
   const array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
   const result = xBoxPlotWithOutliers(array);
 
diff --git a/src/x/__tests__/xDivide.test.ts b/src/x/__tests__/xDivide.test.ts
index 74ed0e7f..23679781 100644
--- a/src/x/__tests__/xDivide.test.ts
+++ b/src/x/__tests__/xDivide.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xDivide } from '../xDivide.ts';
 
-test('test divide of 2 vectors', () => {
+test('divide of 2 vectors', () => {
   const array1 = [10, 15, 20, 25, 30];
   const array2 = [2, 3, 4, 5, 6];
 
@@ -11,7 +11,7 @@ test('test divide of 2 vectors', () => {
   );
 });
 
-test('test divide of Array and FloatArray', () => {
+test('divide of Array and FloatArray', () => {
   const array1 = [10, 15, 20, 25, 30];
   const array2 = new Float64Array([2, 3, 4, 5, 6]);
 
@@ -20,7 +20,7 @@ test('test divide of Array and FloatArray', () => {
   );
 });
 
-test('test mul of 2 a constant', () => {
+test('mul of 2 a constant', () => {
   const array1 = [10, 15, 20, 25, 30];
 
   expect(xDivide(array1, 5)).toStrictEqual(Float64Array.from([2, 3, 4, 5, 6]));
diff --git a/src/x/__tests__/xHilbertTransform.test.ts b/src/x/__tests__/xHilbertTransform.test.ts
index 48677c79..730f059e 100644
--- a/src/x/__tests__/xHilbertTransform.test.ts
+++ b/src/x/__tests__/xHilbertTransform.test.ts
@@ -3,7 +3,7 @@ import { expect, test } from 'vitest';
 import { xHilbertTransform } from '../xHilbertTransform.ts';
 import { xMaxValue } from '../xMaxValue.ts';
 
-test('test discrete hilbert transform', () => {
+test('discrete hilbert transform', () => {
   const length = 50;
   const cos = new Float64Array(length);
   const sin = new Float64Array(length);
@@ -26,7 +26,7 @@ test('test discrete hilbert transform', () => {
   }
 });
 
-test('test fast hilbert transform', () => {
+test('fast hilbert transform', () => {
   const length = 64;
   const cos = new Float64Array(length);
   const sin = new Float64Array(length);
@@ -49,7 +49,7 @@ test('test fast hilbert transform', () => {
   }
 });
 
-test('test fast hilbert transform of squareWave function', () => {
+test('fast hilbert transform of squareWave function', () => {
   const length = 64;
   const p = 16;
   const squareWave = new Float64Array(length);
@@ -66,7 +66,7 @@ test('test fast hilbert transform of squareWave function', () => {
   }
 });
 
-test('test fast hilbert transform with forceFFT (array length greater than a power of 2)', () => {
+test('fast hilbert transform with forceFFT (array length greater than a power of 2)', () => {
   const length = 74;
   const cos = new Float64Array(length);
   const sin = new Float64Array(length);
@@ -88,7 +88,7 @@ test('test fast hilbert transform with forceFFT (array length greater than a pow
   }
 });
 
-test('test fast hilbert transform with forceFFT (array length less than a power of 2)', () => {
+test('fast hilbert transform with forceFFT (array length less than a power of 2)', () => {
   const length = 54;
   const x = new Float64Array(length);
   const cos = new Float64Array(length);
diff --git a/src/x/__tests__/xIsMonotonic.test.ts b/src/x/__tests__/xIsMonotonic.test.ts
index b6f0bb90..f0e6ed91 100644
--- a/src/x/__tests__/xIsMonotonic.test.ts
+++ b/src/x/__tests__/xIsMonotonic.test.ts
@@ -2,55 +2,55 @@ import { expect, test } from 'vitest';
 
 import { xIsMonotonic } from '../xIsMonotonic.ts';
 
-test('test xIsMonotonic increasing', () => {
+test('xIsMonotonic increasing', () => {
   const array = [1, 2, 3, 4, 5];
 
   expect(xIsMonotonic(array)).toBe(1);
 });
 
-test('test xIsMonotonic increasing but duplicate value', () => {
+test('xIsMonotonic increasing but duplicate value', () => {
   const array = [1, 2, 4, 4, 5];
 
   expect(xIsMonotonic(array)).toBe(0);
 });
 
-test('test xIsMonotonic increasing but duplicate starting value', () => {
+test('xIsMonotonic increasing but duplicate starting value', () => {
   const array = [1, 1, 2, 4, 4, 5];
 
   expect(xIsMonotonic(array)).toBe(0);
 });
 
-test('test xIsMonotonic increasing with mistake', () => {
+test('xIsMonotonic increasing with mistake', () => {
   const array = [1, 2, 3, 5, 4];
 
   expect(xIsMonotonic(array)).toBe(0);
 });
 
-test('test xIsMonotonic decreasing', () => {
+test('xIsMonotonic decreasing', () => {
   const array = [5, 4, 3, 2, 1];
 
   expect(xIsMonotonic(array)).toBe(-1);
 });
 
-test('test xIsMonotonic decreasing but duplicate value', () => {
+test('xIsMonotonic decreasing but duplicate value', () => {
   const array = [5, 4, 4, 2, 1];
 
   expect(xIsMonotonic(array)).toBe(0);
 });
 
-test('test xIsMonotonic decreasing but duplicate starting value', () => {
+test('xIsMonotonic decreasing but duplicate starting value', () => {
   const array = [5, 5, 4, 4, 2, 1];
 
   expect(xIsMonotonic(array)).toBe(0);
 });
 
-test('test xIsMonotonic decreasing with mistake', () => {
+test('xIsMonotonic decreasing with mistake', () => {
   const array = [4, 5, 3, 2, 1];
 
   expect(xIsMonotonic(array)).toBe(0);
 });
 
-test('test xIsMonotonic constant series', () => {
+test('xIsMonotonic constant series', () => {
   const array = [1, 1, 1, 1];
 
   expect(xIsMonotonic(array)).toBe(1);
diff --git a/src/x/__tests__/xMultiply.test.ts b/src/x/__tests__/xMultiply.test.ts
index 0d8c344b..5b5626c5 100644
--- a/src/x/__tests__/xMultiply.test.ts
+++ b/src/x/__tests__/xMultiply.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xMultiply } from '../xMultiply.ts';
 
-test('test mul of 2 vectors', () => {
+test('mul of 2 vectors', () => {
   const array1 = [10, 11, 12, 13, 14];
   const array2 = [5, 4, 3, 2, 1];
 
@@ -11,7 +11,7 @@ test('test mul of 2 vectors', () => {
   );
 });
 
-test('test mul of array and floatarray', () => {
+test('mul of array and floatarray', () => {
   const array1 = [10, 11, 12, 13, 14];
   const array2 = new Float64Array([5, 4, 3, 2, 1]);
 
@@ -20,7 +20,7 @@ test('test mul of array and floatarray', () => {
   );
 });
 
-test('test mul of 2 a constant', () => {
+test('mul of 2 a constant', () => {
   const array1 = [10, 11, 12, 13, 14];
 
   expect(xMultiply(array1, 5)).toStrictEqual(
diff --git a/src/x/__tests__/xRotate.test.ts b/src/x/__tests__/xRotate.test.ts
index 937923c1..648bea8e 100644
--- a/src/x/__tests__/xRotate.test.ts
+++ b/src/x/__tests__/xRotate.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xRotate } from '../xRotate.ts';
 
-test('test xRotate positive', () => {
+test('xRotate positive', () => {
   const array = [10, 11, 12, 13, 14];
 
   expect(xRotate(array, 0)).toStrictEqual(
@@ -19,7 +19,7 @@ test('test xRotate positive', () => {
   );
 });
 
-test('test xRotate negative', () => {
+test('xRotate negative', () => {
   const array = [10, 11, 12, 13, 14];
 
   expect(xRotate(array, -2)).toStrictEqual(
diff --git a/src/x/__tests__/xSubtract.test.ts b/src/x/__tests__/xSubtract.test.ts
index 6d2a288e..821b8aec 100644
--- a/src/x/__tests__/xSubtract.test.ts
+++ b/src/x/__tests__/xSubtract.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xSubtract } from '../xSubtract.ts';
 
-test('test xSubtract of 2 vectors', () => {
+test('xSubtract of 2 vectors', () => {
   const array1 = [10, 11, 12, 13, 14];
   const array2 = [5, 4, 3, 2, 1];
 
@@ -11,7 +11,7 @@ test('test xSubtract of 2 vectors', () => {
   );
 });
 
-test('test xSubtract of 2 a constant', () => {
+test('xSubtract of 2 a constant', () => {
   const array1 = [10, 11, 12, 13, 14];
 
   expect(xSubtract(array1, 5)).toStrictEqual(
@@ -19,7 +19,7 @@ test('test xSubtract of 2 a constant', () => {
   );
 });
 
-test('test xSubtract of array and floatarray', () => {
+test('xSubtract of array and floatarray', () => {
   const array1 = new Float64Array([10, 11, 12, 13, 14]);
   const array2 = [5, 4, 3, 2, 1];
 
diff --git a/src/xreim/__tests__/xreimSortX.test.ts b/src/xreim/__tests__/xreimSortX.test.ts
index 3eea617d..d164828e 100644
--- a/src/xreim/__tests__/xreimSortX.test.ts
+++ b/src/xreim/__tests__/xreimSortX.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xreimSortX } from '../xreimSortX.ts';
 
-test('test xreimSortX do nothing', () => {
+test('xreimSortX do nothing', () => {
   const x = [0, 1, 2, 3];
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
@@ -15,7 +15,7 @@ test('test xreimSortX do nothing', () => {
   });
 });
 
-test('test xreimSortX reverse', () => {
+test('xreimSortX reverse', () => {
   const x = [3, 2, 1, 0];
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
diff --git a/src/xreim/__tests__/xreimZeroFilling.test.ts b/src/xreim/__tests__/xreimZeroFilling.test.ts
index d63a78be..f9c78ac9 100644
--- a/src/xreim/__tests__/xreimZeroFilling.test.ts
+++ b/src/xreim/__tests__/xreimZeroFilling.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xreimZeroFilling } from '../xreimZeroFilling.ts';
 
-test('test xreimZeroFilling over', () => {
+test('xreimZeroFilling over', () => {
   const x = [0, 0.1, 0.2, 0.3];
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
@@ -19,7 +19,7 @@ test('test xreimZeroFilling over', () => {
   });
 });
 
-test('test xreimZeroFilling equal', () => {
+test('xreimZeroFilling equal', () => {
   const x = [0, 0.1, 0.2, 0.3];
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
@@ -35,7 +35,7 @@ test('test xreimZeroFilling equal', () => {
   });
 });
 
-test('test xreimZeroFilling under', () => {
+test('xreimZeroFilling under', () => {
   const x = [0, 0.1, 0.2, 0.3];
   const re = [0, 1, 2, 3];
   const im = [4, 5, 6, 7];
diff --git a/src/xy/__tests__/xyAlign.test.ts b/src/xy/__tests__/xyAlign.test.ts
index 87a1eb91..96779b03 100644
--- a/src/xy/__tests__/xyAlign.test.ts
+++ b/src/xy/__tests__/xyAlign.test.ts
@@ -14,7 +14,7 @@ test('same length spectra, integers', () => {
   });
 });
 
-test('test permutability (should not be equal)', () => {
+test('permutability (should not be equal)', () => {
   const data1 = { x: [1, 2, 3], y: [1, 1, 1] };
   const data2 = { x: [2, 3, 4], y: [1, 1, 1] };
   const result = xyAlign(data2, data1);
@@ -190,7 +190,7 @@ test('options.delta=2', () => {
   });
 });
 
-test('test options.delta as a function', () => {
+test('options.delta as a function', () => {
   const data1 = { x: [0, 3, 5, 7], y: [1, 1, 1, 1] };
   const data2 = { x: [2, 3], y: [1, 1] };
   const result = xyAlign(data1, data2, {
@@ -206,7 +206,7 @@ test('test options.delta as a function', () => {
   });
 });
 
-test('test options.delta as a function: (x) => x', () => {
+test('options.delta as a function: (x) => x', () => {
   const data1 = { x: [0, 1, 2, 3], y: [1, 1, 1, 1] };
   const data2 = { x: [2, 3, 5], y: [1, 1, 1] };
   const result = xyAlign(data1, data2, {
diff --git a/src/xy/__tests__/xyGetNMaxY.test.ts b/src/xy/__tests__/xyGetNMaxY.test.ts
index 07a11c23..e48197cf 100644
--- a/src/xy/__tests__/xyGetNMaxY.test.ts
+++ b/src/xy/__tests__/xyGetNMaxY.test.ts
@@ -45,7 +45,7 @@ test('bigger spectrum', () => {
   });
 });
 
-test('test repeating values', () => {
+test('repeating values', () => {
   const spectrum = {
     x: [1, 5, 7, 3, 1, 8, 9, 13, 40, 3, 4],
     y: [1, 5, 7, 3, 1, 40, 51, 40, 40, 3, 4],
diff --git a/src/xy/__tests__/xyGrowingX.test.ts b/src/xy/__tests__/xyGrowingX.test.ts
index d6d9eee6..ef7f2491 100644
--- a/src/xy/__tests__/xyGrowingX.test.ts
+++ b/src/xy/__tests__/xyGrowingX.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 
 import { xyGrowingX } from '../xyGrowingX.ts';
 
-test('test xyGrowingX do nothing with zero first value', () => {
+test('xyGrowingX do nothing with zero first value', () => {
   const x = [0, 1, 2, 3];
   const y = [0, 1, 2, 3];
   const result = xyGrowingX({ x, y });
@@ -13,7 +13,7 @@ test('test xyGrowingX do nothing with zero first value', () => {
   });
 });
 
-test('test xyGrowingX do nothing', () => {
+test('xyGrowingX do nothing', () => {
   const x = [1, 2, 3];
   const y = [1, 2, 3];
   const result = xyGrowingX({ x, y });
@@ -24,7 +24,7 @@ test('test xyGrowingX do nothing', () => {
   });
 });
 
-test('test xyGrowingX reverse', () => {
+test('xyGrowingX reverse', () => {
   const x = [3, 2, 1, 0];
   const y = [0, 1, 2, 3];
   const result = xyGrowingX({ x, y });