nmr-processing 9.7.8 → 9.8.0

package/src/peaks/solventSuppression.ts

@@ -25,16 +25,16 @@ export function solventSuppression<T extends NMRPeak1D>(
   const { markSolventPeaks = false, solventZoneExtension = 1.2 } = options;
 
   for (const solventSignal of solvent) {
-    let solventXYPeaks = solventSignal.peaks
+    const solventXYPeaks = solventSignal.peaks
       ? solventSignal.peaks
       : getSolventPeaks(solventSignal);
     solventXYPeaks.sort((a, b) => a.x - b.x);
 
-    let upIndex = xFindClosestIndex(
+    const upIndex = xFindClosestIndex(
       xValues,
       solventXYPeaks[solventXYPeaks.length - 1].x + solventZoneExtension,
     );
-    let lowIndex = xFindClosestIndex(
+    const lowIndex = xFindClosestIndex(
       xValues,
       solventXYPeaks[0].x - solventZoneExtension,
     );
@@ -45,7 +45,7 @@ export function solventSuppression<T extends NMRPeak1D>(
     const amplitudeResiduals = [];
     const deltaResiduals = [];
     const positionResiduals = [];
-    for (let peak of nearPeaks) {
+    for (const peak of nearPeaks) {
       const { peaks: shiftedSolventPeaks, delta: currentDelta } =
         getShiftedSolventPeaks(peak, solventSignal, solventXYPeaks);
 
@@ -88,7 +88,7 @@ export function solventSuppression<T extends NMRPeak1D>(
 
     let minIndex = -1;
     let minScore = Number.MAX_SAFE_INTEGER;
-    let score = [];
+    const score = [];
     for (let i = 0; i < deltaResiduals.length; i++) {
       const value =
         (amplitudeResiduals[i] / maxAmplitude +
@@ -125,12 +125,12 @@ export function solventSuppression<T extends NMRPeak1D>(
     }
 
     if (markSolventPeaks) {
-      for (let index of rowAssignments) {
+      for (const index of rowAssignments) {
         peaks[index + lowIndex].kind = 'solvent';
       }
     } else {
       rowAssignments.sort((a, b) => b - a);
-      for (let index of rowAssignments) {
+      for (const index of rowAssignments) {
         peaks.splice(index + lowIndex, 1);
       }
     }
@@ -143,8 +143,8 @@ function getSolventPeaks(
   signal: NMRSignal1D,
   options: { frequency?: number; maxClusterSize?: number } = {},
 ) {
-  let signals = addDummySignals([signal]);
-  let spinSystem = signalsToSpinSystem(signals);
+  const signals = addDummySignals([signal]);
+  const spinSystem = signalsToSpinSystem(signals);
 
   const { frequency = 400, maxClusterSize = 8 } = options;
 
@@ -175,7 +175,7 @@ function getShiftedSolventPeaks<T extends PointXY>(
     shiftedSolventPeaks[0].y,
   );
   let currentDelta = 0;
-  for (let shiftedSolventPeak of shiftedSolventPeaks) {
+  for (const shiftedSolventPeak of shiftedSolventPeaks) {
     shiftedSolventPeak.x += deltaPPM;
     shiftedSolventPeak.y /= maxIntensity;
     currentDelta += shiftedSolventPeak.x;
@@ -194,7 +194,7 @@ function getClosestPeaks(shiftedSolventPeaks: PointXY[], nearPeaks: PointXY[]) {
 
   const assignmentPeaks = [];
   let maxValue = Number.MIN_SAFE_INTEGER;
-  for (let index of rowAssignments) {
+  for (const index of rowAssignments) {
     if (maxValue < nearPeaks[index].y) maxValue = nearPeaks[index].y;
     assignmentPeaks.push({ ...nearPeaks[index] });
   }

package/src/peaks/util/addMissingIDs.ts

@@ -13,5 +13,5 @@ export function addMissingIDs<T extends { id?: string }>(
     }
   }
 
-  return output as (T & { id: string })[];
+  return output as Array<T & { id: string }>;
 }

package/src/peaks/util/determineRealTop.ts

@@ -10,13 +10,13 @@ const direction16Y = [-2, -1, 0, 1, 2, -2, 2, -2, 2, -2, 2, -2, -1, 0, 1, 2];
 type Data = number[] | Float64Array;
 
 export function determineRealTop<T extends Peak2D>(peaks: T[], options: any) {
-  let { nCols, absoluteData, originalData, minX, maxX, minY, maxY } = options;
+  const { nCols, absoluteData, originalData, minX, maxX, minY, maxY } = options;
   for (let i = 0; i < peaks.length; i++) {
-    let xIndex = Math.round(peaks[i].x);
-    let yIndex = Math.round(peaks[i].y);
+    const xIndex = Math.round(peaks[i].x);
+    const yIndex = Math.round(peaks[i].y);
 
     let currentIndex = xIndex + yIndex * nCols;
-    let { index, isMax } = determineMax(absoluteData, {
+    const { index, isMax } = determineMax(absoluteData, {
       xIndex,
       yIndex,
       nCols,
@@ -31,7 +31,7 @@ export function determineRealTop<T extends Peak2D>(peaks: T[], options: any) {
           shell: 2,
         }).index;
 
-    let realTopCoordinates = fitGaussian(originalData, {
+    const realTopCoordinates = fitGaussian(originalData, {
       nCols,
       index: currentIndex,
       minY,
@@ -49,21 +49,21 @@ function determineMax(
   data: Data,
   options: { xIndex: number; yIndex: number; shell: number; nCols: number },
 ) {
-  let { xIndex, yIndex, shell, nCols } = options;
+  const { xIndex, yIndex, shell, nCols } = options;
   let currentIndex = xIndex + yIndex * nCols;
-  let [directionX, directionY] =
+  const [directionX, directionY] =
     shell > 1 ? [direction16X, direction16Y] : [direction8X, direction8Y];
 
   let isMax = false;
   for (let i = 0; i < directionX.length; i++) {
-    let c = xIndex + directionX[i];
-    let r = yIndex + directionY[i];
+    const c = xIndex + directionX[i];
+    const r = yIndex + directionY[i];
     if (data[c + r * nCols] >= data[currentIndex]) {
       isMax = true;
-      let candidateIndex = c + r * nCols;
+      const candidateIndex = c + r * nCols;
       for (let k = 0; k < direction8Y.length; k++) {
-        let nc = c + direction8X[k];
-        let nr = r + direction8Y[k];
+        const nc = c + direction8X[k];
+        const nr = r + direction8Y[k];
         if (data[nc + nr * nCols] > data[candidateIndex]) {
           isMax = false;
           break;
@@ -89,25 +89,25 @@ function fitGaussian(
     maxX: number;
   },
 ) {
-  let { nCols, index, minY, maxY, minX, maxX } = options;
+  const { nCols, index, minY, maxY, minX, maxX } = options;
 
-  let nRows = data.length / nCols;
+  const nRows = data.length / nCols;
 
-  let intervalX = (maxX - minX) / (nCols - 1);
-  let intervalY = (maxY - minY) / (nRows - 1);
+  const intervalX = (maxX - minX) / (nCols - 1);
+  const intervalY = (maxY - minY) / (nRows - 1);
 
-  let col = index % nCols;
-  let row = (index - col) / nCols;
+  const col = index % nCols;
+  const row = (index - col) / nCols;
 
-  let newCol = 1;
-  let newRow = 1;
+  const newCol = 1;
+  const newRow = 1;
 
   let max = Number.MIN_SAFE_INTEGER;
-  let z = new Array(direction8X.length + 1);
-  let xAxis = new Array(direction8X.length + 1);
+  const z = new Array(direction8X.length + 1);
+  const xAxis = new Array(direction8X.length + 1);
   for (let i = -1, xi = 0; i < 2; i++) {
     for (let j = -1; j < 2; j++, xAxis[xi] = xi++) {
-      let value = data[col + j + (row + i) * nCols];
+      const value = data[col + j + (row + i) * nCols];
       if (max < value) max = value;
       z[newCol + j + (newRow + i) * 3] = value;
     }
@@ -115,13 +115,13 @@ function fitGaussian(
 
   for (let i = 0; i < z.length; i++) z[i] /= max;
 
-  let maxValues = [newCol + 1, newRow + 1, 1.5, 1, 1];
-  let minValues = [newCol - 1, newRow - 1, -1.5, 0.001, 0.001];
-  let initialValues = [newCol, newRow, z[newCol + newRow * 3], 0.2, 0.2];
-  let gradientDifference = [1e-4, 1e-4, 1e-3, 1e-3, 1e-3];
-  let func = paramGaussian2D(intervalX, intervalY, 3);
+  const maxValues = [newCol + 1, newRow + 1, 1.5, 1, 1];
+  const minValues = [newCol - 1, newRow - 1, -1.5, 0.001, 0.001];
+  const initialValues = [newCol, newRow, z[newCol + newRow * 3], 0.2, 0.2];
+  const gradientDifference = [1e-4, 1e-4, 1e-3, 1e-3, 1e-3];
+  const func = paramGaussian2D(intervalX, intervalY, 3);
 
-  let pFit = levenbergMarquardt({ x: xAxis, y: z }, func, {
+  const pFit = levenbergMarquardt({ x: xAxis, y: z }, func, {
     damping: 1.5,
     maxIterations: 100,
     errorTolerance: 1e-8,
@@ -142,10 +142,10 @@ function paramGaussian2D(intervalX: number, intervalY: number, nCols: number) {
   const gaussian2D = new Gaussian2D();
   return (p: number[]) => {
     return (t: number) => {
-      let nL = p.length / 5;
+      const nL = p.length / 5;
       let result = 0;
-      let xIndex = t % nCols;
-      let yIndex = (t - xIndex) / nCols;
+      const xIndex = t % nCols;
+      const yIndex = (t - xIndex) / nCols;
       for (let i = 0; i < nL; i++) {
         gaussian2D.fwhm = { x: p[i + 3 * nL], y: p[i + 4 * nL] };
         result +=

package/src/peaks/util/getKernel.ts

@@ -4,13 +4,13 @@ export interface GetKernelOptions {
   yLength?: number;
 }
 export function getKernel(options: GetKernelOptions = {}) {
-  let { sigma = 1.4, xLength = 9, yLength = 9 } = options;
+  const { sigma = 1.4, xLength = 9, yLength = 9 } = options;
 
-  let factor = -40 / laplacianOfGaussian(0, 0, sigma);
+  const factor = -40 / laplacianOfGaussian(0, 0, sigma);
 
   const xCenter = (xLength - 1) / 2;
   const yCenter = (yLength - 1) / 2;
-  let matrix = new Array(xLength);
+  const matrix = new Array(xLength);
   for (let x = 0; x < xLength; x++) {
     matrix[x] = new Array(yLength);
     for (let y = 0; y < yLength; y++) {
@@ -23,6 +23,6 @@ export function getKernel(options: GetKernelOptions = {}) {
 }
 
 const laplacianOfGaussian = (x: number, y: number, sigma: number) => {
-  let factor = -(Math.pow(x, 2) + Math.pow(y, 2)) / 2 / Math.pow(sigma, 2);
+  const factor = -(Math.pow(x, 2) + Math.pow(y, 2)) / 2 / Math.pow(sigma, 2);
   return -(1 / Math.PI / Math.pow(sigma, 4)) * (1 + factor) * Math.exp(factor);
 };

package/src/peaks/util/peakOptimizer.ts

@@ -2,8 +2,8 @@ import type { Peak2D } from 'ml-matrix-peaks-finder';
 
 import type { NMRSignal2D } from '../../xyz/NMRSignal2D';
 
-let diagonalError = 0.05;
-let tolerance = 0.05;
+const diagonalError = 0.05;
+const tolerance = 0.05;
 
 export function clean(peaks: Peak2D[], threshold: number) {
   let max = Number.NEGATIVE_INFINITY;
@@ -23,18 +23,18 @@ export function clean(peaks: Peak2D[], threshold: number) {
 }
 
 export function enhanceSymmetry(signals: NMRSignal2D[]) {
-  let properties = initializeProperties(signals);
-  let output = signals.slice();
+  const properties = initializeProperties(signals);
+  const output = signals.slice();
 
   // First step of the optimization: Symmetry validation
   let hits;
   for (let i = output.length - 1; i >= 0; i--) {
-    let signal = output[i];
+    const signal = output[i];
     if (signal.peaks && signal.peaks.length > 1) {
       properties[i][1]++;
     }
     if (properties[i][0] === 1) {
-      let index = exist(output, properties, signal, -1, true);
+      const index = exist(output, properties, signal, -1, true);
       if (index >= 0) {
         properties[i][1] += 2;
         properties[index][1] += 2;
@@ -43,7 +43,7 @@ export function enhanceSymmetry(signals: NMRSignal2D[]) {
   }
   // Second step of the optimization: Diagonal image existence
   for (let i = output.length - 1; i >= 0; i--) {
-    let signal = output[i];
+    const signal = output[i];
     if (properties[i][0] === 0) {
       hits = checkCrossPeaks(output, properties, signal, true);
       properties[i][1] += hits;
@@ -69,7 +69,7 @@ export function enhanceSymmetry(signals: NMRSignal2D[]) {
     }
   }
 
-  let toReturn = new Array(count);
+  const toReturn = new Array(count);
   count--;
   for (let i = output.length - 1; i >= 0; i--) {
     if (
@@ -99,7 +99,7 @@ function completeMissingIfNeeded(
   thisProp: number[],
 ) {
   // Check for symmetry
-  let index = exist(output, properties, thisSignal, -thisProp[0], true);
+  const index = exist(output, properties, thisSignal, -thisProp[0], true);
   let addedPeaks = 0;
   let newSignal: any;
   let tmpProp = null;
@@ -189,8 +189,8 @@ function checkCrossPeaks(
 ) {
   let hits = 0;
   let shift = signal.x.delta * 4;
-  let crossPeaksX = [];
-  let crossPeaksY = [];
+  const crossPeaksX = [];
+  const crossPeaksY = [];
   let cross;
   for (let i = output.length - 1; i >= 0; i--) {
     cross = output[i];
@@ -240,15 +240,15 @@ function exist(
     if (properties[i][0] === type) {
       if (distanceTo(signal, output[i], symmetricSearch) < tolerance) {
         if (!symmetricSearch) {
-          let shiftX = (output[i].x.delta + signal.x.delta) / 2.0;
-          let shiftY = (output[i].y.delta + signal.y.delta) / 2.0;
+          const shiftX = (output[i].x.delta + signal.x.delta) / 2.0;
+          const shiftY = (output[i].y.delta + signal.y.delta) / 2.0;
           output[i].x.delta = shiftX;
           output[i].y.delta = shiftY;
           signal.x.delta = shiftX;
           signal.y.delta = shiftY;
         } else {
-          let shiftX = signal.x.delta;
-          let shiftY = output[i].x.delta;
+          const shiftX = signal.x.delta;
+          const shiftY = output[i].x.delta;
           output[i].y.delta = shiftX;
           signal.y.delta = shiftY;
         }
@@ -267,13 +267,13 @@ function exist(
  * @private
  */
 function initializeProperties(signals: NMRSignal2D[]) {
-  let signalsProperties = new Array(signals.length);
+  const signalsProperties = new Array(signals.length);
   for (let i = signals.length - 1; i >= 0; i--) {
     signalsProperties[i] = [0, 0];
     // We check if it is a diagonal peak
     if (Math.abs(signals[i].x.delta - signals[i].y.delta) <= diagonalError) {
       signalsProperties[i][1] = 1;
-      let shift = (signals[i].x.delta * 2 + signals[i].y.delta) / 3.0;
+      const shift = (signals[i].x.delta * 2 + signals[i].y.delta) / 3.0;
       signals[i].x.delta = shift;
       signals[i].y.delta = shift;
     } else if (signals[i].x.delta - signals[i].y.delta > 0) {

package/src/peaks/util/setIDs.ts

@@ -3,12 +3,14 @@ import { v4 as generateID } from '@lukeed/uuid';
 const { parse, stringify } = JSON;
 
 export function setIDs<T>(peaks: T[], options: { output?: T[] } = {}) {
-  const output = (options.output || parse(stringify(peaks))) as (T & {
-    id?: string;
-  })[];
+  const output = (options.output || parse(stringify(peaks))) as Array<
+    T & {
+      id?: string;
+    }
+  >;
   for (const peak of output) {
     peak.id = generateID();
   }
 
-  return output as (T & { id: string })[];
+  return output as Array<T & { id: string }>;
 }

package/src/prediction/dataStructure.ts

@@ -1,5 +1,3 @@
-export interface DataBaseLevelStructure {
-  [key: string]: number[] | undefined;
-}
+export type DataBaseLevelStructure = Record<string, number[] | undefined>;
 
 export type DataBaseStructure = DataBaseLevelStructure[];

package/src/prediction/predictAll.ts

@@ -64,16 +64,17 @@ export async function predictAll(
   molecule: Molecule,
   options: PredictAllOptions = {},
 ): Promise<PredictedAll> {
-  let {
+  const {
     logger,
     predictor = { H: predictProton, C: predictCarbon },
-    predictions,
     joinDistance = { H: 0.05, C: 0.5 },
     predictOptions = {},
   } = options;
 
   const diaIDs = getDiastereotopicAtomIDs(molecule);
 
+  let { predictions } = options;
+
   const xPrediction = await getPredictions(
     'H',
     molecule,

package/src/prediction/predictCOSY.ts

@@ -55,7 +55,7 @@ export async function predictCOSY(
   molecule: Molecule,
   options: PredictCOSYOptions = {},
 ) {
-  let {
+  const {
     minLength = 2,
     maxLength = 3,
     predictions,

package/src/prediction/predictCarbon.ts

@@ -70,7 +70,7 @@ export async function predictCarbon(
     };
   }
 
-  let {
+  const {
     database,
     webserviceURL = 'https://nmr-prediction.service.zakodium.com/v1/predict/carbon',
     diaIDs = getDiastereotopicAtomIDs(molecule),
@@ -93,7 +93,7 @@ export async function predictCarbon(
     diaIDs,
   });
 
-  let predictions = queryByHose(carbonDiaIDs, database, {
+  const predictions = queryByHose(carbonDiaIDs, database, {
     maxSphereSize,
   });
 
@@ -111,7 +111,7 @@ export async function predictCarbon(
 }
 
 function formatSignals(predictions: Prediction[]) {
-  let signals = [];
+  const signals = [];
   for (const prediction of predictions) {
     const { atoms, nbAtoms, delta, diaIDs, statistic } = prediction;
     const signal = {
@@ -130,10 +130,10 @@ function formatSignals(predictions: Prediction[]) {
 }
 
 function joinSignalByDiaID(signals: NMRSignal1D[]) {
-  let joinedSignals: { [key: string]: Signal1DFromPrediction } = {};
-  for (let signal of signals) {
+  const joinedSignals: Record<string, Signal1DFromPrediction> = {};
+  for (const signal of signals) {
     checkFromPrediction(signal);
-    let diaID = signal.diaIDs[0];
+    const diaID = signal.diaIDs[0];
     if (!joinedSignals[diaID]) {
       joinedSignals[diaID] = JSON.parse(
         JSON.stringify(signal),

package/src/prediction/predictHMBC.ts

@@ -56,7 +56,7 @@ export async function predictHMBC(
   molecule: Molecule,
   options: PredictHMBCOptions = {},
 ) {
-  let {
+  const {
     minLength = 2,
     maxLength = 3,
     predictor = { H: predictProton, C: predictCarbon },

package/src/prediction/predictHSQC.ts

@@ -52,7 +52,7 @@ export async function predictHSQC(
   molecule: Molecule,
   options: PredictHSQCOptions = {},
 ) {
-  let {
+  const {
     minLength = 1,
     maxLength = 1,
     predictor = { H: predictProton, C: predictCarbon },

package/src/prediction/predictProton.ts

@@ -95,14 +95,14 @@ function protonParser(
   if (result.includes('ERR')) {
     throw Error(`Spinus optimization: ${result}`);
   }
-  let distanceMatrix = getConnectivityMatrix(molecule, { pathLength: true });
-  let lines = result.split('\n').filter((line) => line);
-  let signals = [];
-  for (let line of lines) {
-    let fields: string[] = line.split('\t');
-    let couplings = fields.slice(4);
-    let atom = Number(fields[0]) - 1;
-    let signal: NMRSignal1D = {
+  const distanceMatrix = getConnectivityMatrix(molecule, { pathLength: true });
+  const lines = result.split('\n').filter((line) => line);
+  const signals = [];
+  for (const line of lines) {
+    const fields: string[] = line.split('\t');
+    const couplings = fields.slice(4);
+    const atom = Number(fields[0]) - 1;
+    const signal: NMRSignal1D = {
       id: generateID(),
       atoms: [atom],
       diaIDs: [diaIDs[atom]],
@@ -115,7 +115,7 @@ function protonParser(
       throw new Error(`For atom js property was not added`);
     }
     for (let i = 0; i < couplings.length; i += 3) {
-      let linked = Number(couplings[i]) - 1;
+      const linked = Number(couplings[i]) - 1;
       signal.js.push({
         coupling: Number(couplings[i + 2]),
         atoms: [linked],

package/src/prediction/utils/getFilteredIDiaIDs.ts

@@ -24,11 +24,11 @@ export function getFilteredIDiaIDs(
 
   const molfile = molecule.toMolfile();
 
-  let groupedDiaIDs = groupDiastereotopicAtomIDs(diaIDs, molecule, {
+  const groupedDiaIDs = groupDiastereotopicAtomIDs(diaIDs, molecule, {
     atomLabel: 'C',
   });
 
-  let carbonDiaIDs = groupedDiaIDs.sort((a, b) => {
+  const carbonDiaIDs = groupedDiaIDs.sort((a, b) => {
     if (a.atomLabel === b.atomLabel) {
       return b.counter - a.counter;
     }
@@ -45,7 +45,7 @@ export function getFilteredIDiaIDs(
     );
   }
 
-  let toReturn = {
+  const toReturn = {
     molfile,
     carbonDiaIDs: carbonDiaIDs as GroupedDiaIDsWithHose,
   };

package/src/prediction/utils/getNuclei.ts

@@ -1,8 +1,8 @@
-const nucleusMap: { [key: string]: string } = {
+const nucleusMap: Record<string, string> = {
   h: '1H',
   c: '13C',
 };
 
-export function getNuclei(input: { [key: string]: string }) {
+export function getNuclei(input: Record<string, string>) {
   return Object.values(input).map((e) => nucleusMap[e.toLowerCase()]);
 }

package/src/prediction/utils/predict2D.ts

@@ -101,9 +101,7 @@ export interface PredictOptions {
   C?: PredictCarbonOptions;
 }
 
-export interface Predictions {
-  [key: string]: Prediction1D | undefined;
-}
+export type Predictions = Record<string, Prediction1D | undefined>;
 
 type GroupDiastereotopicAtomIDsWithAtomInfo = GroupDiastereotopicAtomIDs & {
   pathInfo: PathInfo;
@@ -122,9 +120,7 @@ function checkFromTo(
   }
 }
 
-interface Signal1DByDiaID {
-  [key: string]: { [key: string]: NMRSignal1D };
-}
+type Signal1DByDiaID = Record<string, Record<string, NMRSignal1D>>;
 
 export async function predict2D(
   molecule: Molecule,
@@ -134,7 +130,7 @@ export async function predict2D(
 
   molecule.addImplicitHydrogens();
 
-  let {
+  const {
     from,
     to,
     diaIDs,
@@ -158,8 +154,8 @@ export async function predict2D(
     ? groupDiastereotopicAtomIDs(diaIDs, molecule)
     : getGroupedDiastereotopicAtomIDs(molecule);
 
-  let diaIDswithAtomInfo: GroupDiastereotopicAtomIDsWithAtomInfo[] = [];
-  for (let diaID of groupedDiaIDS) {
+  const diaIDswithAtomInfo: GroupDiastereotopicAtomIDsWithAtomInfo[] = [];
+  for (const diaID of groupedDiaIDS) {
     diaIDswithAtomInfo.push({
       ...diaID,
       pathInfo: JSON.parse(
@@ -191,7 +187,7 @@ export async function predict2D(
     throw new Error('predictions are not availaible');
   }
 
-  const spectra: { [key: string]: Prediction1D } = {
+  const spectra: Record<string, Prediction1D> = {
     x: xPrediction,
     y: yPrediction,
   };
@@ -206,7 +202,7 @@ export async function predict2D(
       signalsByDiaID[axis][signal.diaIDs[0]] = signal;
     }
   }
-  let group: { [key: string]: NMRSignal2D } = {};
+  const group: Record<string, NMRSignal2D> = {};
   for (const diaID of diaIDswithAtomInfo) {
     const pathInfo = diaID.pathInfo;
     if (pathInfo.paths.length < 1) continue;
@@ -217,7 +213,7 @@ export async function predict2D(
     for (const path of currentPaths) {
       if (!signalsByDiaID.y[pathsInfo[path.to].oclID]) continue;
 
-      let fromToDiaID: { [key: string]: AtomInfo } = {
+      const fromToDiaID: Record<string, AtomInfo> = {
         x: pathInfo,
         y: pathsInfo[path.to],
       };
@@ -228,10 +224,10 @@ export async function predict2D(
         continue;
       }
 
-      let peak: any = { id: generateID(), z: 100 };
-      let signal: any = { id: generateID(), x: {}, y: {} };
-      for (let axis in fromToDiaID) {
-        let diaID = fromToDiaID[axis].oclID;
+      const peak: any = { id: generateID(), z: 100 };
+      const signal: any = { id: generateID(), x: {}, y: {} };
+      for (const axis in fromToDiaID) {
+        const diaID = fromToDiaID[axis].oclID;
         peak[axis] = signalsByDiaID[axis][diaID].delta;
         signal[axis].delta = signalsByDiaID[axis][diaID].delta;
         signal[axis].diaIDs = [diaID];
@@ -263,11 +259,11 @@ export async function predict2D(
 }
 
 function splitSignals(joinedSignals: NMRSignal2D[]) {
-  let signals: NMRSignal2D[] = [];
+  const signals: NMRSignal2D[] = [];
   for (const signal of joinedSignals) {
     for (const xAtom of signal.x.atoms || []) {
       for (const yAtom of signal.y.atoms || []) {
-        let newSignal = JSON.parse(JSON.stringify(signal));
+        const newSignal = JSON.parse(JSON.stringify(signal));
         newSignal.x.atoms = [xAtom];
         newSignal.y.atoms = [yAtom];
         signals.push(newSignal);
@@ -282,21 +278,21 @@ interface AddSelftCorrelationOptions {
   signalsByDiaID: Signal1DByDiaID;
 }
 function addSelftCorrelation(
-  group: { [key: string]: NMRSignal2D },
+  group: Record<string, NMRSignal2D>,
   options: AddSelftCorrelationOptions,
 ) {
   const { paths = [], signalsByDiaID } = options;
   for (const atom of paths) {
     if (atom.paths.length < 1) continue;
 
-    let diaID = atom.oclID;
+    const diaID = atom.oclID;
     if (!signalsByDiaID.x[diaID]) continue;
     if (group[`${diaID}-${diaID}`]) continue;
 
-    let signal: any = { x: {}, y: {} };
+    const signal: any = { x: {}, y: {} };
 
-    let peak: any = { z: 1 };
-    for (let axis of ['x', 'y']) {
+    const peak: any = { z: 1 };
+    for (const axis of ['x', 'y']) {
       peak[axis] = signalsByDiaID[axis][diaID].delta;
       signal[axis].delta = signalsByDiaID[axis][diaID].delta;
       signal[axis].diaIDs = [diaID];
@@ -335,7 +331,7 @@ function createZones(signals: NMRSignal2D[], options: CreateZonesOptions) {
       Math.pow(joinDistance[to] / (maxY - minY), 2),
   );
 
-  let hClusters = agnes(deltas.to2DArray(), { method: 'centroid' });
+  const hClusters = agnes(deltas.to2DArray(), { method: 'centroid' });
   const clusters = splitClusters([hClusters], cutOff);
 
   const zones: NMRZone[] = [];
@@ -376,7 +372,7 @@ function fromTo(signals: NMRSignal2D[], options: CreateZonesOptions) {
 }
 
 function splitClusters(clusters: Cluster[], maxDistance: number): Cluster[] {
-  let originalLength = clusters.length;
+  const originalLength = clusters.length;
   for (let i = 0; i < clusters.length; i++) {
     const cluster = clusters[i];
     if (cluster.height > maxDistance) {