nmr-processing 7.1.0 → 7.4.0

package/lib-esm/utilities/getFrequency.js

@@ -0,0 +1,26 @@
+import { GYROMAGNETIC_RATIO } from '../constants/gyromagneticRatio';
+/**
+ * calculate the frequency of a nucleus with respect to a reference nucleus
+ */
+export function getFrequency(
+/**
+ * nucleus to calculate the frequency
+ */
+nucleus, observedNucleusData) {
+    const { nucleus: obsNucleus, frequency } = observedNucleusData;
+    checkExistence(nucleus, obsNucleus);
+    return ((frequency * GYROMAGNETIC_RATIO[nucleus]) /
+        GYROMAGNETIC_RATIO[obsNucleus]);
+}
+function checkExistence(...nucleus) {
+    let nuclei = [];
+    for (const n of nucleus) {
+        if (!(n in GYROMAGNETIC_RATIO)) {
+            nuclei.push(n);
+        }
+    }
+    if (nuclei.length !== 0) {
+        throw new Error(`${nuclei.join(' , ')} is not supported`);
+    }
+}
+//# sourceMappingURL=getFrequency.js.map

package/lib-esm/utilities/getFrequency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFrequency.js","sourceRoot":"","sources":["../../src/utilities/getFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAU,MAAM,gCAAgC,CAAC;AAgB5E;;GAEG;AACH,MAAM,UAAU,YAAY;AAC1B;;GAEG;AACH,OAAgB,EAChB,mBAAwC;IAExC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,mBAAmB,CAAC;IAE/D,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAEpC,OAAO,CACL,CAAC,SAAS,GAAG,kBAAkB,CAAC,OAAiB,CAAC,CAAC;QACnD,kBAAkB,CAAC,UAAoB,CAAC,CACzC,CAAC;AACJ,CAAC;AAED,SAAS,cAAc,CAAC,GAAG,OAAkB;IAC3C,IAAI,MAAM,GAAa,EAAE,CAAC;IAC1B,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE;QACvB,IAAI,CAAC,CAAC,CAAC,IAAI,kBAAkB,CAAC,EAAE;YAC9B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAChB;KACF;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,MAAM,IAAI,KAAK,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;KAC3D;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nmr-processing",
-  "version": "7.1.0",
+  "version": "7.4.0",
   "description": "Pure functions allowing to process NMR spectra.",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -41,18 +41,18 @@
     "@types/jest": "^27.4.1",
     "cheminfo-build": "^1.1.11",
     "cheminfo-types": "^1.1.0",
-    "eslint": "^8.10.0",
-    "eslint-config-cheminfo-typescript": "^10.3.0",
+    "eslint": "^8.11.0",
+    "eslint-config-cheminfo-typescript": "^10.4.0",
     "jest": "^27.5.1",
     "jest-matcher-deep-close-to": "^3.0.2",
     "md5": "^2.3.0",
     "ml-array-median": "^1.1.6",
     "nmr-xy-testdata": "^0.5.1",
     "openchemlib": "^7.4.3",
-    "prettier": "^2.5.1",
+    "prettier": "^2.6.1",
     "rimraf": "^3.0.2",
-    "ts-jest": "^27.1.3",
-    "typescript": "^4.6.2"
+    "ts-jest": "^27.1.4",
+    "typescript": "^4.6.3"
   },
   "dependencies": {
     "binary-search": "^1.3.6",
@@ -63,7 +63,7 @@
     "ml-array-rescale": "^1.3.7",
     "ml-array-sequential-fill": "^1.1.8",
     "ml-array-sum": "^1.1.6",
-    "ml-gsd": "^10.1.2",
+    "ml-gsd": "^10.2.0",
     "ml-hclust": "^3.1.0",
     "ml-levenberg-marquardt": "^4.1.0",
     "ml-matrix": "^6.9.0",
@@ -72,9 +72,10 @@
     "ml-peak-shape-generator": "^4.1.1",
     "ml-simple-clustering": "^0.1.0",
     "ml-sparse-matrix": "^2.1.0",
-    "ml-spectra-processing": "^11.0.0",
+    "ml-spectra-processing": "^11.1.0",
     "ml-tree-set": "^0.1.1",
-    "openchemlib-utils": "^1.9.0",
+    "nmr-correlation": "^2.2.5",
+    "openchemlib-utils": "^1.10.0",
     "spectrum-generator": "^8.0.0"
   }
 }

package/src/assignment/get13CAssignments.ts

@@ -12,7 +12,7 @@ import type {
   NMRSignal1DWithAtomsAndDiaIDs,
   Targets,
 } from './get1HAssignments';
-import { RestrictionByCS, buildAssignments } from './utils/buildAssignments';
+import { RestrictionByCS1D, buildAssignments } from './utils/buildAssignments';
 import generateID from './utils/generateID';
 
 function checkAtomsAndDiaIDs(
@@ -33,7 +33,7 @@ function checkIntegration(ranges: NMRRange[]) {
 }
 
 export interface Get13CAssignmentsOptions {
-  restrictionByCS?: Partial<RestrictionByCS>;
+  restrictionByCS?: Partial<RestrictionByCS1D>;
   /**
    * min score to accept an assignment
    * @default 1

package/src/assignment/get1HAssignments.ts

@@ -9,7 +9,7 @@ import {
 import type { NMRSignal1D } from '../signals/NMRSignal1D';
 import { MakeMandatory } from '../utilities/MakeMandatory';
 
-import { buildAssignments, RestrictionByCS } from './utils/buildAssignments';
+import { buildAssignments, RestrictionByCS1D } from './utils/buildAssignments';
 import generateID from './utils/generateID';
 
 export type NMRSignal1DWithAtomsAndDiaIDs = MakeMandatory<
@@ -40,7 +40,7 @@ function checkForIntegration(
 }
 
 export interface Get1HAssignmentsOptions {
-  restrictionByCS?: Partial<RestrictionByCS>;
+  restrictionByCS?: Partial<RestrictionByCS1D>;
   /**
    * min score to accept an assignment
    * @default 1

package/src/assignment/getAssignments.ts

@@ -0,0 +1,149 @@
+import { Molecule } from 'openchemlib';
+import { addDiastereotopicMissingChirality } from 'openchemlib-utils';
+
+import { NMRSignal1D } from '..';
+import type { PredictCarbonOptions } from '../prediction/predictCarbon';
+import type { PredictProtonOptions } from '../prediction/predictProton';
+import { NMRRange } from '../xy/NMRRange';
+import { NMRZone } from '../xyz/NMRZone';
+
+import {
+  AtomTypes,
+  buildAssignments,
+  RestrictionByCS,
+} from './utils/getAssignment/buildAssignments';
+import { checkIDs } from './utils/getAssignment/checkIDs';
+import { getTargetsAndCorrelations } from './utils/getAssignment/getTargetsAndCorrelations';
+import getWorkFlow from './utils/getAssignment/getWorkFlow';
+
+export interface SpectraData1D {
+  id?: string;
+  ranges: NMRRange[];
+  info?: any;
+}
+
+export interface SpectraData2D {
+  id?: string;
+  zones: NMRZone[];
+  info?: any;
+}
+
+export type SpectraData = SpectraData1D | SpectraData2D;
+
+export interface GetAutoAssignmentInput {
+  /**
+   * It has the number of each atoms in the chemical structure. e.g. { C: 6, H: 6 }
+   */
+  atoms?: { [key: string]: number };
+
+  spectra: SpectraData[];
+  /**
+   * Instance of Molecule
+   */
+  molecule: Molecule;
+}
+
+export interface GetAssignmentsOptions {
+  justAssign?: Array<AtomTypes[]>;
+
+  restrictionByCS?: Partial<RestrictionByCS>;
+  /**
+   * min score to accept an assignment
+   * @default 1
+   */
+  minScore?: number;
+  /**
+   * maximal number of assignments to return
+   * @default 10
+   */
+  maxSolutions?: number;
+  /**
+   * number of allowed unassignment signals
+   * @default 0
+   */
+  nbAllowedUnAssigned?: { [key: string]: number };
+  /**
+   * time limit in miliseconds to finish the assignment procedure.
+   * @default 6000
+   */
+  timeout?: number;
+  /**
+   * predictions
+   */
+  predictions?: {
+    H?: NMRSignal1D[];
+    C?: NMRSignal1D[];
+  };
+  /**
+   * prediction options
+   */
+  predictionOptions?: {
+    H?: PredictProtonOptions;
+    C?: PredictCarbonOptions;
+  };
+  /**
+   * correlation options
+   */
+  correlation?: {
+    tolerance?: number;
+  };
+}
+
+export async function getAssignments(
+  input: GetAutoAssignmentInput,
+  options: GetAssignmentsOptions = {},
+) {
+  let {
+    restrictionByCS = {},
+    justAssign,
+    minScore = 1,
+    maxSolutions = 10,
+    nbAllowedUnAssigned,
+    timeout = 6000,
+    predictionOptions = {},
+    predictions = {},
+    correlation: correlationOptions = {},
+  } = options;
+
+  const {
+    tolerance = { H: 0.2, C: 1 },
+    useChemicalShiftScore = false,
+    chemicalShiftRestriction = true,
+  } = restrictionByCS;
+
+  const molecule = input.molecule;
+
+  if (!molecule) throw new Error('It is needed a molecule to assign');
+
+  molecule.addImplicitHydrogens();
+  addDiastereotopicMissingChirality(molecule);
+
+  const spectra = checkIDs(input.spectra);
+
+  const { targets, correlations } = getTargetsAndCorrelations(
+    spectra,
+    correlationOptions,
+  );
+  const { assignmentOrder } = getWorkFlow(correlations, justAssign);
+
+  const solutions = await buildAssignments({
+    restrictionByCS: {
+      tolerance,
+      useChemicalShiftScore,
+      chemicalShiftRestriction,
+    },
+    spectra,
+    molecule,
+    timeout,
+    minScore,
+    maxSolutions,
+    assignmentOrder,
+    nbAllowedUnAssigned,
+    correlations,
+    targets,
+    predictionOptions,
+    predictions,
+  });
+
+  return solutions;
+}

package/src/assignment/utils/buildAssignments.ts

@@ -10,14 +10,14 @@ const comparator = (a: SolutionAssignment, b: SolutionAssignment) => {
   return b.score - a.score;
 };
 
-export interface RestrictionByCS {
+export interface RestrictionByCS1D {
   chemicalShiftRestriction: boolean;
   tolerance: number;
   useChemicalShiftScore: boolean;
 }
 
 export interface BuildAssignmentsProps {
-  restrictionByCS?: Partial<RestrictionByCS>;
+  restrictionByCS?: Partial<RestrictionByCS1D>;
   timeout: number;
   minScore: number;
   useIntegrationRestriction: boolean;
@@ -37,7 +37,7 @@ export interface Predictions1Dassignments {
   [key: string]: Signals1DAssignment;
 }
 
-export interface StoreAssignments1D {
+export interface StoreAssignments {
   solutions: treeSet;
   nSolutions: number;
 }
@@ -63,7 +63,7 @@ export async function buildAssignments(props: BuildAssignmentsProps) {
   let date = new Date();
   let timeStart = date.getTime();
 
-  let store: StoreAssignments1D = {
+  let store: StoreAssignments = {
     solutions: new treeSet(comparator),
     nSolutions: 0,
   };

package/src/assignment/utils/createMapPossibleAssignments.ts

@@ -2,12 +2,12 @@ import { MakeMandatory } from '../../utilities/MakeMandatory';
 import type { Targets } from '../get1HAssignments';
 
 import type {
-  RestrictionByCS,
+  RestrictionByCS1D,
   Predictions1Dassignments,
 } from './buildAssignments';
 
 type RestrictionByCSMandatory = MakeMandatory<
-  RestrictionByCS,
+  RestrictionByCS1D,
   'chemicalShiftRestriction' | 'tolerance' | 'useChemicalShiftScore'
 >;
 

package/src/assignment/utils/exploreTreeRec.ts

@@ -1,8 +1,8 @@
 import type { Targets } from '../get1HAssignments';
 
 import type {
-  RestrictionByCS,
-  StoreAssignments1D,
+  RestrictionByCS1D,
+  StoreAssignments,
   Predictions1Dassignments,
 } from './buildAssignments';
 import type { PossibleAssignmentMap } from './createMapPossibleAssignments';
@@ -10,7 +10,7 @@ import { partialScore } from './partialScore';
 
 export interface ExploreTreeRecProps {
   nSources: number;
-  restrictionByCS: RestrictionByCS;
+  restrictionByCS: RestrictionByCS1D;
   timeout: number;
   timeStart: number;
   maxSolutions: number;
@@ -26,7 +26,7 @@ export function exploreTreeRec(
   props: ExploreTreeRecProps,
   currentIndex: number,
   partial: Array<string | null>,
-  store: StoreAssignments1D,
+  store: StoreAssignments,
 ) {
   const {
     nSources,
@@ -107,7 +107,7 @@ interface AddSolutionProps {
   predictions: Predictions1Dassignments;
 }
 
-function addSolution(store: StoreAssignments1D, props: AddSolutionProps) {
+function addSolution(store: StoreAssignments, props: AddSolutionProps) {
   let { score, maxSolutions, partial, predictions } = props;
   score /= doubleAssignmentPenalty(partial, predictions);
   store.nSolutions++;

package/src/assignment/utils/getAssignment/buildAssignments.ts

@@ -0,0 +1,339 @@
+import treeSet from 'ml-tree-set';
+import { Values } from 'nmr-correlation';
+import { Molecule } from 'openchemlib';
+import { getConnectivityMatrix } from 'openchemlib-utils';
+
+import {
+  NMRSignal1D,
+  PredictCarbonOptions,
+  PredictProtonOptions,
+} from '../../..';
+import { predictCarbon } from '../../../prediction/predictCarbon';
+import { predictProton } from '../../../prediction/predictProton';
+import { MakeMandatory } from '../../../utilities/MakeMandatory';
+import { StoreAssignments } from '../buildAssignments';
+
+import { SpectraDataWithIds } from './checkIDs';
+import {
+  createMapPossibleAssignment,
+  MapPossibleAssignments,
+} from './createMapPossibleAssignment';
+import { AssignmentSolution, exploreTree } from './exploreTree';
+import { TargetsByAtomType } from './getTargetsAndCorrelations';
+import { isSpectraData1D } from './isSpectraData1D';
+import { searchIndices } from './searchIndices';
+
+const comparator = (a: AssignmentSolution, b: AssignmentSolution) => {
+  return b.score - a.score;
+};
+
+const predictor = { H: predictProton, C: predictCarbon };
+
+export type AtomTypes = 'H' | 'C';
+export type CurrentAtoms = Array<AtomTypes>;
+export interface Partial {
+  [key: string]: Array<string | null>;
+}
+
+export interface DiaIDPeerPossibleAssignment {
+  [key: string]: string[];
+}
+
+export interface RestrictionByCS {
+  chemicalShiftRestriction: boolean;
+  tolerance: { [key: string]: number };
+  useChemicalShiftScore: boolean;
+}
+
+export interface BuildAssignmentInput {
+  spectra: SpectraDataWithIds[];
+  molecule: Molecule;
+  restrictionByCS: RestrictionByCS;
+  timeout: number;
+  minScore: number;
+  nbAllowedUnAssigned?: { [key: string]: number };
+  maxSolutions: number;
+  correlations: Values;
+  assignmentOrder: Array<Array<AtomTypes>>;
+  predictions: {
+    H?: NMRSignal1D[];
+    C?: NMRSignal1D[];
+  };
+  predictionOptions: {
+    H?: PredictProtonOptions;
+    C?: PredictCarbonOptions;
+  };
+  targets: TargetsByAtomType;
+}
+
+type NMRSignal1DFromPrediction = MakeMandatory<
+  NMRSignal1D,
+  'nbAtoms' | 'diaIDs' | 'atoms'
+>;
+
+function checkNMRSignal1D(
+  signals: NMRSignal1D[],
+): asserts signals is NMRSignal1DFromPrediction[] {
+  const keys: Array<'nbAtoms' | 'diaIDs' | 'atoms'> = [
+    'nbAtoms',
+    'diaIDs',
+    'atoms',
+  ];
+  for (const signal of signals) {
+    for (let key of keys) {
+      if (!signal[key]) throw new Error(`property ${key} does not exist`);
+    }
+  }
+}
+
+export interface Prediction extends NMRSignal1DFromPrediction {
+  diaIDIndex: number;
+  allHydrogens: number;
+  protonsCount: number;
+  pathLength: number[];
+}
+
+export interface Predictions {
+  [key: string]: Prediction;
+}
+
+export interface PredictionsByAtomType {
+  [key: string]: Predictions;
+}
+
+export interface InfoByAtomType {
+  [key: string]: {
+    nSources: number;
+    currentIndex: number;
+    nbAllowedUnAssigned: number;
+  };
+}
+
+export const getAllHydrogens = {
+  C: (m: Molecule, i: number) => m.getAllHydrogens(i),
+  H: () => 1,
+};
+
+export async function buildAssignments(props: BuildAssignmentInput) {
+  const {
+    spectra,
+    molecule,
+    restrictionByCS,
+    timeout,
+    minScore,
+    nbAllowedUnAssigned = {},
+    maxSolutions,
+    correlations,
+    assignmentOrder,
+    predictionOptions,
+    predictions: inputPrediction = {},
+    targets,
+  } = props;
+
+  let date = new Date();
+  let timeStart = date.getTime();
+  let lowerBoundScore = minScore;
+
+  let store: StoreAssignments = {
+    solutions: new treeSet(comparator),
+    nSolutions: 0,
+  };
+
+  const pathLengthMatrix = getConnectivityMatrix(molecule, {
+    pathLength: true,
+  });
+
+  let infoByAtomType: InfoByAtomType = {};
+  const predictions: PredictionsByAtomType = {};
+  let possibleAssignmentMap: MapPossibleAssignments = {};
+  let diaIDPeerPossibleAssignment: DiaIDPeerPossibleAssignment = {};
+
+  for (const atomTypesToPredict of assignmentOrder) {
+    for (const atomType of atomTypesToPredict) {
+      const options = predictionOptions[atomType];
+      const predictedSignals = inputPrediction[atomType];
+      let { joinedSignals } = predictedSignals
+        ? { joinedSignals: predictedSignals }
+        : await predictor[atomType](molecule, options);
+
+      checkNMRSignal1D(joinedSignals);
+
+      if (!predictions[atomType]) predictions[atomType] = {};
+      for (let prediction of joinedSignals) {
+        const diaID = prediction.diaIDs[0];
+        const index = prediction.atoms[0];
+        const allHydrogens = getAllHydrogens[atomType](molecule, index);
+        predictions[atomType][diaID] = {
+          ...prediction,
+          diaIDIndex: index,
+          allHydrogens: prediction.nbAtoms * allHydrogens,
+          protonsCount: allHydrogens,
+          pathLength: pathLengthMatrix[index] as number[],
+        };
+      }
+      infoByAtomType[atomType] = {
+        nSources: joinedSignals.length,
+        currentIndex: 0,
+        nbAllowedUnAssigned: nbAllowedUnAssigned[atomType] || 0,
+      };
+    }
+
+    possibleAssignmentMap = createMapPossibleAssignment(possibleAssignmentMap, {
+      restrictionByCS,
+      predictions,
+      targets,
+    });
+
+    diaIDPeerPossibleAssignment = {};
+    for (const atomType in possibleAssignmentMap) {
+      diaIDPeerPossibleAssignment[atomType] = Object.keys(
+        possibleAssignmentMap[atomType],
+      );
+    }
+
+    let sourceOfPartials = getSourceOfPartials(
+      store,
+      infoByAtomType,
+      atomTypesToPredict,
+    );
+
+    store = {
+      solutions: new treeSet(comparator),
+      nSolutions: 0,
+    };
+
+    for (let partial of sourceOfPartials) {
+      exploreTree(
+        {
+          currentAtomTypes: atomTypesToPredict,
+          restrictionByCS,
+          timeout,
+          timeStart,
+          targets,
+          predictions,
+          correlations,
+          maxSolutions,
+          lowerBoundScore,
+          possibleAssignmentMap,
+          diaIDPeerPossibleAssignment,
+        },
+        infoByAtomType,
+        partial,
+        store,
+      );
+    }
+  }
+  return annotateSpectraData({
+    store,
+    spectra,
+    diaIDPeerPossibleAssignment,
+    targets,
+  });
+}
+
+interface AnnotateSpectraDataInput {
+  store: StoreAssignments;
+  spectra: SpectraDataWithIds[];
+  targets: TargetsByAtomType;
+  diaIDPeerPossibleAssignment: DiaIDPeerPossibleAssignment;
+}
+
+function annotateSpectraData(input: AnnotateSpectraDataInput) {
+  const { store, spectra, diaIDPeerPossibleAssignment, targets } = input;
+  const { solutions } = store;
+  const mapSignalId: any = {};
+  const atomTypes = Object.keys(targets) as AtomTypes[];
+  for (const atomType of atomTypes) {
+    const targetByAtomType = targets[atomType];
+    for (const targetId in targetByAtomType) {
+      let target = targetByAtomType[targetId];
+      for (const link of target.link) {
+        const signalId = link.signal.id;
+        if (mapSignalId[signalId]) continue;
+        mapSignalId[link.signal.id] = searchIndices(signalId, spectra);
+      }
+    }
+  }
+
+  const result = [];
+  for (let solution of solutions.elements) {
+    const spectraResult = JSON.parse(
+      JSON.stringify(spectra),
+    ) as SpectraDataWithIds[];
+    const { assignment, score } = solution;
+    const atomTypes = Object.keys(assignment) as AtomTypes[];
+    for (const atomType of atomTypes) {
+      const targetByAtomType = targets[atomType];
+      const assignmentPeerAtomType = assignment[atomType];
+      for (let index = 0; index < assignmentPeerAtomType.length; index++) {
+        const targetID = assignmentPeerAtomType[index];
+
+        if (targetID === '*' || !targetID) continue;
+
+        const target = targetByAtomType[targetID];
+        const diaId = diaIDPeerPossibleAssignment[atomType][index];
+
+        for (let link of target.link) {
+          const { spectrumIndex, elementIndex, signalIndex } =
+            mapSignalId[link.signal.id];
+          const spectrum = spectraResult[spectrumIndex];
+
+          if (isSpectraData1D(spectrum)) {
+            let { ranges } = spectrum;
+            let range = ranges[elementIndex];
+            let signal = range.signals[signalIndex];
+            if (!signal.diaIDs) signal.diaIDs = [];
+            signal.diaIDs.push(diaId);
+          } else {
+            const axis = link.axis as 'x' | 'y';
+            const signal = spectrum.zones[elementIndex].signals[signalIndex];
+            if (!signal[axis].diaIDs) signal[axis].diaIDs = [];
+            signal[axis].diaIDs?.push(diaId);
+          }
+        }
+      }
+    }
+    result.push({
+      score,
+      assignment: spectraResult,
+    });
+  }
+  return result;
+}
+
+function getSourceOfPartials(
+  store: StoreAssignments,
+  infoByAtomType: InfoByAtomType,
+  currentAtoms: CurrentAtoms,
+) {
+  return store.nSolutions > 0
+    ? store.solutions.elements.map((e) => {
+        let currentAssignment = e.assignment;
+        for (const atom of currentAtoms) {
+          currentAssignment[atom] = fillPartial(infoByAtomType[atom].nSources);
+        }
+        return currentAssignment;
+      })
+    : initializePartials(infoByAtomType, currentAtoms);
+}
+
+function initializePartials(
+  infoByAtomType: InfoByAtomType,
+  currentAtoms: CurrentAtoms,
+) {
+  const partial: Partial = {};
+  const atomsType = Object.keys(infoByAtomType) as CurrentAtoms;
+  for (const atom of atomsType) {
+    const value = currentAtoms.includes(atom) ? null : '*';
+    partial[atom] = fillPartial(infoByAtomType[atom].nSources, value);
+  }
+  return [partial];
+}
+
+function fillPartial(nSources: number, value: string | null = null) {
+  const partial: Array<string | null> = new Array(nSources);
+  for (let i = 0; i < nSources; i++) {
+    partial[i] = value;
+  }
+  return partial;
+}