nmr-processing 9.7.7 → 9.7.9-pre.1690349439

package/src/ml-tree-set.d.ts

@@ -3,7 +3,7 @@ declare module 'ml-tree-set' {
   type Elements = any;
   export default class TreeSet {
     public length: number;
-    public elements: Array<w>;
+    public elements: w[];
 
     public constructor(comparator: Comparator);
 

package/src/multiplicity/joinPatterns.ts

@@ -32,7 +32,9 @@ export function joinPatterns(
   }, 0);
 
   if (!couplingPatterns[sum]) {
-    throw new Error("The joined pattern doesn't exist");
+    throw new Error(
+      `The joined pattern from ${patterns.join(',')} doesn't exist`,
+    );
   }
 
   return options?.acsFormat ? couplingACSPatterns[sum] : couplingPatterns[sum];

package/src/multiplicity/splitPatterns.ts

@@ -15,7 +15,7 @@ possiblePatterns = possiblePatterns.sort((a, b) => b.length - a.length);
 export function splitPatterns(multiplet: string) {
   if (/^\s*$/.exec(multiplet)) return [];
   const regexp = new RegExp(possiblePatterns.join('|'), 'g');
-  let result = multiplet.match(regexp);
+  const result = multiplet.match(regexp);
   if (result) return result.map((entry) => entry.trim());
   return [multiplet];
 }

package/src/peaks/peaksFilterImpurities.ts

@@ -38,14 +38,15 @@ export function peaksFilterImpurities<T extends NMRPeak1D>(
   peakList: T[],
   options: OptionsPeaksFilterImpurities = {},
 ) {
-  let { solvent, error = 0.025, remove = false } = options;
+  const { error = 0.025, remove = false } = options;
 
-  if (solvent) {
+  if (options.solvent) {
+    let { solvent } = options;
     if (solvent === '(cd3)2so') solvent = 'dmso';
     if (solvent === 'meod') solvent = 'cd3od';
-    let solventImpurities = impurities[solvent];
-    for (let impurity of toCheck) {
-      let impurityShifts = solventImpurities[impurity];
+    const solventImpurities = impurities[solvent];
+    for (const impurity of toCheck) {
+      const impurityShifts = solventImpurities[impurity];
       checkImpurity(peakList, impurityShifts, {
         error,
         remove,
@@ -61,7 +62,7 @@ function checkImpurity<T extends NMRPeak1D>(
   impurity: ImpuritySignal[],
   options: OptionsCheckImpurity,
 ) {
-  let { name, error, remove } = options;
+  const { name, error, remove } = options;
   let j, tolerance, difference;
   let i = impurity.length;
   while (i--) {

package/src/peaks/peaksToRanges.ts

@@ -122,7 +122,7 @@ export function peaksToRanges(
   peakList: NMRPeak1DIntern[],
   options: OptionsPeaksToRanges = {},
 ): NMRRange[] {
-  let {
+  const {
     integrationSum = 100,
     joinOverlapRanges = true,
     clean = 0.4,
@@ -134,7 +134,7 @@ export function peaksToRanges(
     nucleus = '1H',
   } = options;
 
-  let signalOptions = {
+  const signalOptions = {
     integrationSum,
     integralType,
     frequencyCluster,
@@ -149,7 +149,7 @@ export function peaksToRanges(
     data.y = data.y.reverse();
   }
 
-  let signals = detectSignals(data, peakList, signalOptions);
+  const signals = detectSignals(data, peakList, signalOptions);
   if (clean) {
     for (let i = 0; i < signals.length; i++) {
       if (Math.abs(signals[i].integralData.value) < clean) {
@@ -162,7 +162,7 @@ export function peaksToRanges(
     let nHi, sum;
     for (let i = 0; i < signals.length; i++) {
       signals[i] = jAnalyzer.compilePattern(signals[i]);
-      let signal = signals[i];
+      const signal = signals[i];
       if (
         signal.maskPattern &&
         signal.multiplicity !== 'm' &&
@@ -172,11 +172,11 @@ export function peaksToRanges(
         // Create a new signal with the removed peaks
         nHi = 0;
         sum = 0;
-        let peaksO = [];
+        const peaksO = [];
         for (let j = signal.maskPattern.length - 1; j >= 0; j--) {
           sum += computeArea(signal.peaks[j], frequency);
           if (!signal.maskPattern[j]) {
-            let peakR = signal.peaks.splice(j, 1)[0];
+            const peakR = signal.peaks.splice(j, 1)[0];
             peaksO.push({
               x: peakR.x,
               y: peakR.intensity,
@@ -192,12 +192,12 @@ export function peaksToRanges(
         if (peaksO.length > 0) {
           nHi = (nHi * signal.integralData.value) / sum;
           signal.integralData.value -= nHi;
-          let peaks1 = [];
+          const peaks1 = [];
           for (let j = peaksO.length - 1; j >= 0; j--) {
             peaks1.push(peaksO[j]);
           }
           signalOptions.integrationSum = Math.abs(nHi);
-          let ranges = detectSignals(data, peaks1, signalOptions);
+          const ranges = detectSignals(data, peaks1, signalOptions);
 
           for (const range of ranges) {
             signals.push(range);
@@ -223,7 +223,7 @@ export function peaksToRanges(
 
   let ranges: NMRRange[] = [];
   for (let i = 0; i < signals.length; i++) {
-    let signal = signals[i];
+    const signal = signals[i];
     const range: NMRRange = {
       id: generateID(),
       from: signal.integralData.from,
@@ -277,27 +277,28 @@ export function detectSignals(
   peakList: NMRPeak1DIntern[],
   options: OptionsDetectSignals = {},
 ): SignalIntern[] {
-  let {
+  const {
+    frequencyCluster = 16,
     integrationSum = 100,
     integralType = 'sum',
-    frequencyCluster = 16,
     frequency = 400,
     nucleus = '1H',
   } = options;
 
   let signal1D: SignalIntern = assignSignal(peakList[0], frequency, nucleus);
   let peaks;
-  let signals = [];
+  const signals = [];
   let prevPeak = { x: Number.MIN_SAFE_INTEGER };
 
-  frequencyCluster /= frequency;
+  const distantToClustering = frequencyCluster / frequency;
+
   for (const peak of peakList) {
-    if (Math.abs(peak.x - prevPeak.x) > frequencyCluster) {
+    if (Math.abs(peak.x - prevPeak.x) > distantToClustering) {
       signal1D = assignSignal(peak, frequency, nucleus);
       if (peak.kind) signal1D.kind = peak.kind;
       signals.push(signal1D);
     } else {
-      let tmp = peak.x + peak.width / frequency;
+      const tmp = peak.x + peak.width / frequency;
       signal1D.stopX = Math.max(signal1D.stopX, tmp);
       signal1D.startX = Math.min(signal1D.startX, tmp);
       signal1D.nbPeaks++;
@@ -318,14 +319,14 @@ export function detectSignals(
     }
     prevPeak = peak;
   }
-  for (let signal of signals) {
+  for (const signal of signals) {
     peaks = signal.peaks;
-    let integration = signal.integralData;
+    const integration = signal.integralData;
     let chemicalShift = 0;
     let integralPeaks = 0;
 
     for (const peak of peaks) {
-      let area = computeArea(peak, frequency);
+      const area = computeArea(peak, frequency);
       chemicalShift += peak.x * area;
       integralPeaks += area;
     }

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 },