nmr-processing 8.0.0 → 8.3.0

package/src/signals/simulation/simulateXYPeaks.ts

@@ -0,0 +1,332 @@
+import binarySearch from 'binary-search';
+import { Matrix, EVD } from 'ml-matrix';
+import type { Matrix as MatrixClassType } from 'ml-matrix';
+import type { Shape1D } from 'ml-peak-shape-generator';
+import { SparseMatrix } from 'ml-sparse-matrix';
+
+import type { SpinSystem } from '../spinSystem';
+
+import getPauliMatrix from './getPauliMatrix';
+
+const smallValue = 1e-2;
+
+export interface Simulate1DOptions {
+  /**
+   * The linewidth of the output spectrum, expresed in Hz.
+   * @default 1
+   */
+  lineWidth?: number;
+  /**
+   * Maximum number of atoms on each cluster that can be considered to be simulated together. It affects the the quality and speed of the simulation.
+   * @default 8
+   */
+  maxClusterSize?: number;
+  /**
+   * The frequency in Mhz of the fake spectrometer that records the spectrum.
+   * @default 400
+   */
+  frequency?: number;
+  /**
+   * The low limit of the ordinate variable.
+   * @default 0
+   */
+  from?: number;
+  /**
+   * The upper limit of the ordinate variable.
+   * @default 10
+   */
+  to?: number;
+  /**
+   * Number of points of the output spectrum.
+   * @default 16K
+   */
+  nbPoints?: number;
+  /**
+   * Shape options
+   * @default {kind:'gaussian'}
+   */
+  shape?: Shape1D;
+}
+
+export function simulateXYPeaks(
+  /**
+   * The SpinSystem object to be simulated
+   */
+  spinSystem: SpinSystem,
+  options: Simulate1DOptions = {},
+) {
+  let {
+    lineWidth = 1,
+    maxClusterSize = 8,
+    frequency: frequencyMHz = 400,
+  } = options;
+
+  const chemicalShifts = spinSystem.chemicalShifts.slice();
+  for (let i = 0; i < chemicalShifts.length; i++) {
+    chemicalShifts[i] = chemicalShifts[i] * frequencyMHz;
+  }
+
+  const multiplicity = spinSystem.multiplicity;
+
+  const xyPeaks = [];
+  for (const cluster of spinSystem.clusters) {
+    let clusterFake = cluster.map((cluster) =>
+      cluster < 0 ? -cluster - 1 : cluster,
+    );
+
+    let weight = 1;
+    let sumI = 0;
+    let frequencies: number[] = [];
+    let intensities: number[] = [];
+    if (cluster.length > maxClusterSize) {
+      // This is a single spin, but the cluster exceeds the maxClusterSize criteria
+      // we use the simple multiplicity algorithm
+      // Add the central peak. It will be split with every single J coupling.
+      let index = 0;
+      while (cluster[index++] < 0);
+      index = cluster[index - 1];
+      frequencies.push(-chemicalShifts[index]);
+      for (let i = 0; i < cluster.length; i++) {
+        if (cluster[i] < 0) {
+          let jc = spinSystem.couplingConstants.get(index, clusterFake[i]) / 2;
+          let currentSize = frequencies.length;
+          for (let j = 0; j < currentSize; j++) {
+            frequencies.push(frequencies[j] + jc);
+            frequencies[j] -= jc;
+          }
+        }
+      }
+
+      frequencies.sort((a, b) => a - b);
+      sumI = frequencies.length;
+      weight = 1;
+
+      for (let i = 0; i < sumI; i++) {
+        intensities.push(1);
+      }
+    } else {
+      const hamiltonian = getHamiltonian(
+        chemicalShifts,
+        spinSystem.couplingConstants,
+        multiplicity,
+        spinSystem.connectivity,
+        clusterFake,
+      );
+      const hamSize = hamiltonian.rows;
+      // TODO: add support for sparse matrix in matrix types.
+      // @ts-expect-error sparse matrix not supported
+      const evd = new EVD(hamiltonian);
+      const V = evd.eigenvectorMatrix;
+      const diagB = evd.realEigenvalues;
+      const assignmentMatrix = new SparseMatrix(hamSize, hamSize);
+      const multLen = cluster.length;
+      weight = 0;
+      for (let n = 0; n < multLen; n++) {
+        const L = getPauliMatrix(multiplicity[clusterFake[n]]);
+
+        let temp = 1;
+        for (let j = 0; j < n; j++) {
+          temp *= multiplicity[clusterFake[j]];
+        }
+        const A = SparseMatrix.eye(temp);
+
+        temp = 1;
+        for (let j = n + 1; j < multLen; j++) {
+          temp *= multiplicity[clusterFake[j]];
+        }
+        const B = SparseMatrix.eye(temp);
+        const tempMat = A.kroneckerProduct(L.m).kroneckerProduct(B);
+        if (cluster[n] >= 0) {
+          assignmentMatrix.add(tempMat.mul(cluster[n] + 1));
+          weight++;
+        } else {
+          assignmentMatrix.add(tempMat.mul(cluster[n]));
+        }
+      }
+
+      let rhoip = Matrix.zeros(hamSize, hamSize);
+      assignmentMatrix.forEachNonZero((i, j, v) => {
+        if (v > 0) {
+          for (let k = 0; k < V.columns; k++) {
+            let element = V.get(j, k);
+            if (element !== 0) {
+              rhoip.set(i, k, rhoip.get(i, k) + element);
+            }
+          }
+        }
+        return v;
+      });
+
+      let rhoip2 = rhoip.clone();
+      assignmentMatrix.forEachNonZero((i: number, j: number, v: number) => {
+        if (v < 0) {
+          for (let k = 0; k < V.columns; k++) {
+            let element = V.get(j, k);
+            if (element !== 0) {
+              rhoip2.set(i, k, rhoip2.get(i, k) + element);
+            }
+          }
+        }
+        return v;
+      });
+      const tV = V.transpose();
+
+      rhoip = tV.mmul(rhoip);
+      const sparseRhoip = new SparseMatrix(rhoip.to2DArray(), {
+        threshold: smallValue,
+      });
+      triuTimesAbs(sparseRhoip, smallValue);
+
+      rhoip2 = tV.mmul(rhoip2);
+      const sparseRhoip2 = new SparseMatrix(rhoip2.to2DArray(), {
+        threshold: smallValue,
+      });
+      sparseRhoip2.forEachNonZero((i, j, v) => {
+        return v;
+      });
+      triuTimesAbs(sparseRhoip2, smallValue);
+      sparseRhoip2.forEachNonZero((i, j, v) => {
+        let val = rhoip.get(i, j);
+        val = Math.min(Math.abs(val), Math.abs(v));
+        val *= val;
+
+        sumI += val;
+        let valFreq = diagB[i] - diagB[j];
+        let insertIn = binarySearch(
+          frequencies,
+          valFreq,
+          (a: number, b: number) => a - b,
+        );
+        if (insertIn < 0) {
+          frequencies.splice(-1 - insertIn, 0, valFreq);
+          intensities.splice(-1 - insertIn, 0, val);
+        } else {
+          intensities[insertIn] += val;
+        }
+      });
+    }
+
+    const numFreq = frequencies.length;
+
+    if (numFreq > 0) {
+      weight /= sumI;
+      const diff = lineWidth / 64;
+      let valFreq = frequencies[0];
+      let inte = intensities[0];
+      let count = 1;
+      for (let i = 1; i < numFreq; i++) {
+        if (Math.abs(frequencies[i] - valFreq / count) < diff) {
+          inte += intensities[i];
+          valFreq += frequencies[i];
+          count++;
+        } else {
+          xyPeaks.push({
+            x: -valFreq / count / frequencyMHz,
+            y: inte * weight,
+          });
+          valFreq = frequencies[i];
+          inte = intensities[i];
+          count = 1;
+        }
+      }
+
+      xyPeaks.push({
+        x: -valFreq / count / frequencyMHz,
+        y: inte * weight,
+      });
+    }
+  }
+
+  return xyPeaks;
+}
+
+function triuTimesAbs(A: SparseMatrix, val: number) {
+  A.forEachNonZero((i, j, v) => {
+    if (i > j) return 0;
+    if (Math.abs(v) <= val) return 0;
+    return v;
+  });
+}
+/**
+ * Create a hamiltonian matrix for the given spinsystem
+ * @param {Array} chemicalShifts - An array containing the chemical shift in Hz
+ * @param {Array} couplingConstants - An array containing the coupling constants in Hz
+ * @param {Array} multiplicity - An array specifiying the multiplicities of each scalar coupling
+ * @param {Array} conMatrix - A one step connectivity matrix for the given spin system
+ * @param {Array} cluster - An binary array specifiying the spins to be considered for this hamiltonial
+ * @return {object}
+ */
+function getHamiltonian(
+  chemicalShifts: number[],
+  couplingConstants: MatrixClassType,
+  multiplicity: number[],
+  conMatrix: MatrixClassType,
+  cluster: number[],
+) {
+  let hamSize = 1;
+  for (const element of cluster) {
+    hamSize *= multiplicity[element];
+  }
+
+  const clusterHam = new SparseMatrix(hamSize, hamSize);
+
+  for (let pos = 0; pos < cluster.length; pos++) {
+    let n = cluster[pos];
+
+    const L = getPauliMatrix(multiplicity[n]);
+
+    let A1, B1;
+    let temp = 1;
+    for (let i = 0; i < pos; i++) {
+      temp *= multiplicity[cluster[i]];
+    }
+    A1 = SparseMatrix.eye(temp);
+
+    temp = 1;
+    for (let i = pos + 1; i < cluster.length; i++) {
+      temp *= multiplicity[cluster[i]];
+    }
+    B1 = SparseMatrix.eye(temp);
+
+    const alpha = chemicalShifts[n];
+    const kronProd = A1.kroneckerProduct(L.z).kroneckerProduct(B1);
+    clusterHam.add(kronProd.mul(alpha));
+    for (let pos2 = 0; pos2 < cluster.length; pos2++) {
+      const k = cluster[pos2];
+      if (conMatrix.get(n, k) === 1) {
+        const S = getPauliMatrix(multiplicity[k]);
+
+        let A2, B2;
+        let temp = 1;
+        for (let i = 0; i < pos2; i++) {
+          temp *= multiplicity[cluster[i]];
+        }
+        A2 = SparseMatrix.eye(temp);
+
+        temp = 1;
+        for (let i = pos2 + 1; i < cluster.length; i++) {
+          temp *= multiplicity[cluster[i]];
+        }
+        B2 = SparseMatrix.eye(temp);
+
+        const kron1 = A1.kroneckerProduct(L.x)
+          .kroneckerProduct(B1)
+          .mmul(A2.kroneckerProduct(S.x).kroneckerProduct(B2));
+        kron1.add(
+          A1.kroneckerProduct(L.y)
+            .kroneckerProduct(B1)
+            .mul(-1)
+            .mmul(A2.kroneckerProduct(S.y).kroneckerProduct(B2)),
+        );
+        kron1.add(
+          A1.kroneckerProduct(L.z)
+            .kroneckerProduct(B1)
+            .mmul(A2.kroneckerProduct(S.z).kroneckerProduct(B2)),
+        );
+
+        clusterHam.add(kron1.mul(couplingConstants.get(n, k) / 2));
+      }
+    }
+  }
+  return clusterHam;
+}

package/src/signals/simulation/splitSpinSystem.ts

@@ -80,19 +80,17 @@ function splitCluster(
         }
         if (count <= maxClusterSize) {
           clusterList.push(members);
+        } else if (child.index < 0) {
+          splitCluster(child, clusterList, {
+            maxClusterSize,
+            force: true,
+            nSpins,
+            connectivity,
+          });
         } else {
-          if (child.index < 0) {
-            splitCluster(child, clusterList, {
-              maxClusterSize,
-              force: true,
-              nSpins,
-              connectivity,
-            });
-          } else {
-            // We have to threat this spin alone and use the resurrection algorithm instead of the simulation
-            members[child.index] = 2;
-            clusterList.push(members);
-          }
+          // We have to threat this spin alone and use the resurrection algorithm instead of the simulation
+          members[child.index] = 2;
+          clusterList.push(members);
         }
       } else {
         splitCluster(child, clusterList, {

package/src/utilities/getFrequency.ts

@@ -1,4 +1,4 @@
-import { gyromagneticRatio, Nuclei } from '../constants/gyromagneticRatio';
+import { gyromagneticRatio, Nuclei } from 'gyromagnetic-ratio';
 
 export interface ObjervedNucleusData {
   /**

package/src/utilities/rangeFromSignal.ts

@@ -6,24 +6,32 @@ export interface RangeFromSignalOptions {
    * nucleus
    * @default '1h'
    */
-  nucleus: string;
+  nucleus?: string;
   /**
-   * frequency observed
+   * frequency observedhttps://www.wiley.com/en-us/NMR+Data+Processing-p-9780471039006#content-section
    * @default 400
    */
-  frequency: number;
+  frequency?: number;
+  /**
+   * tolerance to the halfWidth, default depends of the nucleus
+   */
+  tolerance?: number;
 }
 
-export function rangeFromSignal(signal: NMRSignal1D, options: any = {}) {
+export function rangeFromSignal(
+  signal: NMRSignal1D,
+  options: RangeFromSignalOptions,
+) {
   const { nucleus = '1h', frequency = 400 } = options;
   const { tolerance = getTolerance(nucleus) / frequency } = options;
-  let halfWidth =
-    (signal.js || []).reduce((total, j) => {
-      const { coupling, multiplicity = 'd' } = j;
-      return total + (couplingValues[multiplicity] * coupling) / frequency;
-    }, 0) /
-      2 +
-    tolerance;
+
+  let halfWidth = 0;
+  for (const js of signal.js || []) {
+    const { coupling, multiplicity = 'd' } = js;
+    halfWidth += (couplingValues[multiplicity] * coupling) / frequency;
+  }
+
+  halfWidth = tolerance + halfWidth / 2;
   return {
     from: signal.delta - halfWidth,
     to: signal.delta + halfWidth,

package/src/utilities/resurrectRange.ts

@@ -46,13 +46,10 @@ export function resurrectRange(part: string, options: any = {}) {
         signal.delta = from;
         signal.multiplicity = multiplicity;
       }
-    } else {
-      // looks like a real multiplicity, s, d, dd, etc..
-      if (!isARange) {
-        // a complex signal
-        signal.delta = from;
-        signal.multiplicity = multiplicity;
-      }
+    } else if (!isARange) {
+      // a complex signal
+      signal.delta = from;
+      signal.multiplicity = multiplicity;
     }
   }
 

package/src/xyz/util/formatZone.ts

@@ -0,0 +1,36 @@
+import { NMRSignal2D } from '../NMRSignal2D';
+import { NMRZone } from '../NMRZone';
+
+export function formatZones(signals: NMRSignal2D[]) {
+  let zones: NMRZone[] = [];
+  for (const signal of signals) {
+    let minMax1 = [Number.MAX_VALUE, 0];
+    let minMax2 = [Number.MAX_VALUE, 0];
+    for (const peak of signal.peaks || []) {
+      if (peak.minX < minMax1[0]) {
+        minMax1[0] = peak.minX;
+      }
+      if (peak.maxX > minMax1[1]) {
+        minMax1[1] = peak.maxX;
+      }
+      if (peak.minY < minMax2[0]) {
+        minMax2[0] = peak.minY;
+      }
+      if (peak.maxY > minMax2[1]) {
+        minMax2[1] = peak.maxY;
+      }
+    }
+    zones.push({
+      x: {
+        from: minMax1[0],
+        to: minMax1[1],
+      },
+      y: {
+        from: minMax2[0],
+        to: minMax2[1],
+      },
+      signals: [signal],
+    });
+  }
+  return zones;
+}

package/src/xyz/xyzAutoZonesPicking.ts

@@ -4,13 +4,13 @@ import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
 import simpleClustering from 'ml-simple-clustering';
 
-import { NMRZone } from '..';
 import { determineRealTop } from '../peaks/util/determineRealTop';
 import { getKernel } from '../peaks/util/getKernel';
 import type { GetKernelOptions } from '../peaks/util/getKernel';
 import * as PeakOptimizer from '../peaks/util/peakOptimizer';
 
 import type { NMRSignal2D } from './NMRSignal2D';
+import { formatZones } from './util/formatZone';
 
 const smallFilter = [
   [0, 0, 1, 2, 2, 2, 1, 0, 0],
@@ -183,40 +183,6 @@ export function xyzAutoZonesPicking(
   return formatZones(signals);
 }
 
-function formatZones(signals: NMRSignal2D[]) {
-  let zones: NMRZone[] = [];
-  for (const signal of signals) {
-    let minMax1 = [Number.MAX_VALUE, 0];
-    let minMax2 = [Number.MAX_VALUE, 0];
-    for (const peak of signal.peaks || []) {
-      if (peak.minX < minMax1[0]) {
-        minMax1[0] = peak.minX;
-      }
-      if (peak.maxX > minMax1[1]) {
-        minMax1[1] = peak.maxX;
-      }
-      if (peak.minY < minMax2[0]) {
-        minMax2[0] = peak.minY;
-      }
-      if (peak.maxY > minMax2[1]) {
-        minMax2[1] = peak.maxY;
-      }
-    }
-    zones.push({
-      x: {
-        from: minMax1[0],
-        to: minMax1[1],
-      },
-      y: {
-        from: minMax2[0],
-        to: minMax2[1],
-      },
-      signals: [signal],
-    });
-  }
-  return zones;
-}
-
 /**
  * This function converts a set of 2D-peaks in 2D-signals. Each signal could be composed
  * of many 2D-peaks, and it has some additional information related to the NMR spectrum.

package/src/xyz/xyzJResAnalyzer.ts

@@ -6,6 +6,7 @@ import jAnalyzer from '../peaks/util/jAnalyzer';
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
 import type { NMRSignal2D } from './NMRSignal2D';
+import { formatZones } from './util/formatZone';
 
 interface CompilePatternOptions {
   observedFrequencies?: number[] | Float64Array;
@@ -25,6 +26,11 @@ interface XYZJResAnalyzerOptions extends CompilePatternOptions {
    * @default 0
    */
   reference?: number;
+  /**
+   * if it is true returns zones instead of signals 2D
+   * @default false
+   */
+  getZones?: boolean;
 }
 
 type CompilePatternOptionsMandatory = MakeMandatory<
@@ -38,6 +44,7 @@ export function xyzJResAnalyzer(
 ) {
   let {
     reference = 0,
+    getZones = false,
     referenceMaxShiftError = 0.08,
     tolerances = [10, 100],
     nuclei = ['1H', '1H'],
@@ -46,20 +53,20 @@ export function xyzJResAnalyzer(
       jAxisKey: { jAxis: 'y', intensity: 'z' },
     },
   } = options;
-  let temporalSignals = compilePattern(signals, {
+  let temporalSignals = compilePattern([...signals], {
     observedFrequencies,
     tolerances,
     nuclei,
     jAnalyzer,
   });
   //check if the signal are symmetric around the reference
-  let result = [];
+  let signals2D = [];
   for (const tempSignal of temporalSignals) {
     let delta = tempSignal.y.delta;
     if (Math.abs(delta - reference) > referenceMaxShiftError) continue;
-    result.push(tempSignal);
+    signals2D.push(tempSignal);
   }
-  return result;
+  return getZones ? formatZones(signals2D) : signals2D;
 }
 
 function compilePattern(
@@ -122,10 +129,10 @@ function compilePattern(
       }
       if (peaksO.length > 0) {
         peaksO.reverse();
-        let ranges = createSignals2D(peaksO, signalOptions);
+        let signals2D = createSignals2D(peaksO, signalOptions);
 
-        for (const range of ranges) {
-          newSignals.push(range);
+        for (const signal of signals2D) {
+          newSignals.push(signal);
         }
       }
     }

package/lib/constants/gyromagneticRatio.d.ts

@@ -1,6 +0,0 @@
-export declare type Nuclei = '1H' | '2H' | '3H' | '3He' | '7Li' | '13C' | '14N' | '15N' | '17O' | '19F' | '23Na' | '27Al' | '29Si' | '31P' | '57Fe' | '63Cu' | '67Zn' | '129Xe';
-declare type GyromagneticRatio = {
-    [key in Nuclei]: number;
-};
-export declare const gyromagneticRatio: GyromagneticRatio;
-export {};

package/lib/constants/gyromagneticRatio.js

@@ -1,26 +0,0 @@
-"use strict";
-// sources:
-// https://en.wikipedia.org/wiki/Gyromagnetic_ratio
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gyromagneticRatio = void 0;
-exports.gyromagneticRatio = {
-    '1H': 267.52218744e6,
-    '2H': 41.065e6,
-    '3H': 285.3508e6,
-    '3He': -203.789e6,
-    '7Li': 103.962e6,
-    '13C': 67.28284e6,
-    '14N': 19.331e6,
-    '15N': -27.116e6,
-    '17O': -36.264e6,
-    '19F': 251.662e6,
-    '23Na': 70.761e6,
-    '27Al': 69.763e6,
-    '29Si': -53.19e6,
-    '31P': 108.291e6,
-    '57Fe': 8.681e6,
-    '63Cu': 71.118e6,
-    '67Zn': 16.767e6,
-    '129Xe': -73.997e6,
-};
-//# sourceMappingURL=gyromagneticRatio.js.map

package/lib/constants/gyromagneticRatio.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gyromagneticRatio.js","sourceRoot":"","sources":["../../src/constants/gyromagneticRatio.ts"],"names":[],"mappings":";AAAA,WAAW;AACX,mDAAmD;;;AA4BtC,QAAA,iBAAiB,GAAsB;IAClD,IAAI,EAAE,cAAc;IACpB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,CAAC,SAAS;IACjB,KAAK,EAAE,SAAS;IAChB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,CAAC,OAAO;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,CAAC,QAAQ;CACnB,CAAC"}

package/lib-esm/constants/gyromagneticRatio.js

@@ -1,23 +0,0 @@
-// sources:
-// https://en.wikipedia.org/wiki/Gyromagnetic_ratio
-export const gyromagneticRatio = {
-    '1H': 267.52218744e6,
-    '2H': 41.065e6,
-    '3H': 285.3508e6,
-    '3He': -203.789e6,
-    '7Li': 103.962e6,
-    '13C': 67.28284e6,
-    '14N': 19.331e6,
-    '15N': -27.116e6,
-    '17O': -36.264e6,
-    '19F': 251.662e6,
-    '23Na': 70.761e6,
-    '27Al': 69.763e6,
-    '29Si': -53.19e6,
-    '31P': 108.291e6,
-    '57Fe': 8.681e6,
-    '63Cu': 71.118e6,
-    '67Zn': 16.767e6,
-    '129Xe': -73.997e6,
-};
-//# sourceMappingURL=gyromagneticRatio.js.map

package/lib-esm/constants/gyromagneticRatio.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gyromagneticRatio.js","sourceRoot":"","sources":["../../src/constants/gyromagneticRatio.ts"],"names":[],"mappings":"AAAA,WAAW;AACX,mDAAmD;AA4BnD,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,IAAI,EAAE,cAAc;IACpB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,CAAC,SAAS;IACjB,KAAK,EAAE,SAAS;IAChB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,CAAC,OAAO;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,CAAC,QAAQ;CACnB,CAAC"}