@teselagen/sequence-utils 0.3.37 → 0.3.38-beta.2

package/src/getReverseComplementSequenceAndAnnotations.ts

@@ -0,0 +1,46 @@
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+import getReverseComplementAnnotation from "./getReverseComplementAnnotation";
+import { annotationTypes } from "./annotationTypes";
+import { map } from "lodash-es";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+
+import getSequenceDataBetweenRange from "./getSequenceDataBetweenRange";
+import { SequenceData, Range, Annotation } from "./types";
+
+// ac.throw([ac.string,ac.bool],arguments);
+export default function getReverseComplementSequenceAndAnnoations(
+  pSeqObj: SequenceData,
+  options: { range?: Range; [key: string]: unknown } = {}
+): SequenceData {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const seqObj = tidyUpSequenceData(
+    getSequenceDataBetweenRange(pSeqObj, options.range || null),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    { doNotRemoveInvalidChars: true, ...options } as any
+  );
+  const newSeqObj = Object.assign(
+    {},
+    seqObj,
+    {
+      sequence: getReverseComplementSequenceString(seqObj.sequence)
+    },
+    annotationTypes.reduce(
+      (acc, type) => {
+        if (seqObj[type]) {
+          acc[type] = map(seqObj[type] as Annotation[], annotation => {
+            return getReverseComplementAnnotation(
+              annotation,
+              seqObj.sequence.length
+            );
+          });
+        }
+        return acc;
+      },
+      {} as Record<string, Annotation[]>
+    )
+  );
+  return tidyUpSequenceData(newSeqObj, {
+    doNotRemoveInvalidChars: true,
+    ...options
+  });
+}

package/src/getReverseComplementSequenceString.ts

@@ -0,0 +1,18 @@
+import DNAComplementMap from "./DNAComplementMap";
+
+// ac.throw([ac.string,ac.bool],arguments);
+export default function getReverseComplementSequenceString(
+  sequence: string
+): string {
+  // ac.throw([ac.string],arguments);
+  let reverseComplementSequenceString = "";
+  for (let i = sequence.length - 1; i >= 0; i--) {
+    let revChar = (DNAComplementMap as Record<string, string>)[sequence[i]];
+    if (!revChar) {
+      revChar = sequence[i];
+      // throw new Error('trying to get the reverse compelement of an invalid base');
+    }
+    reverseComplementSequenceString += revChar;
+  }
+  return reverseComplementSequenceString;
+}

package/src/getReverseSequenceString.ts

@@ -0,0 +1,12 @@
+export default function getReverseSequenceString(sequence: string): string {
+  let reverseSequenceString = "";
+  for (let i = sequence.length - 1; i >= 0; i--) {
+    let revChar = sequence[i];
+    if (!revChar) {
+      revChar = sequence[i];
+      // throw new Error('trying to get the reverse of an invalid base');
+    }
+    reverseSequenceString += revChar;
+  }
+  return reverseSequenceString;
+}

package/src/getSequenceDataBetweenRange.ts

@@ -0,0 +1,154 @@
+import { flatMap, extend, forEach, startCase } from "lodash-es";
+import { getRangeLength, Range } from "@teselagen/range-utils";
+import convertDnaCaretPositionOrRangeToAa from "./convertDnaCaretPositionOrRangeToAA";
+import insertSequenceDataAtPosition from "./insertSequenceDataAtPosition";
+import {
+  getSequenceWithinRange,
+  getZeroedRangeOverlaps
+} from "@teselagen/range-utils";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+import { annotationTypes } from "./annotationTypes";
+import { Annotation, SequenceData } from "./types";
+
+interface GetSequenceDataBetweenRangeOptions {
+  exclude?: Record<string, boolean>;
+  excludePartial?: Record<string, boolean>;
+  [key: string]: unknown;
+}
+
+export default function getSequenceDataBetweenRange(
+  seqData: SequenceData,
+  range: Range | null,
+  options: GetSequenceDataBetweenRangeOptions = {}
+): SequenceData {
+  if (!range) return seqData;
+  const { exclude = {}, excludePartial = {} } = options;
+  const seqDataToUse = tidyUpSequenceData(seqData, {
+    doNotRemoveInvalidChars: true,
+    ...options
+  });
+  annotationTypes.forEach(type => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    delete (seqDataToUse as any)[`filtered${startCase(type)}`];
+  });
+  const seqDataToReturn = extend(
+    {},
+    seqDataToUse,
+    {
+      circular:
+        seqDataToUse.sequence.length ===
+        getRangeLength(range, seqData.sequence.length)
+          ? seqDataToUse.circular
+          : false,
+      sequence: getSequenceWithinRange(range, seqDataToUse.sequence),
+      proteinSequence: getSequenceWithinRange(
+        convertDnaCaretPositionOrRangeToAa(range) as Range,
+        seqDataToUse.proteinSequence || ""
+      )
+    },
+    annotationTypes.reduce(
+      (acc, type) => {
+        if (exclude[type]) {
+          acc[type] = [];
+          return acc; //return early cause we're not interested in these annotations
+        }
+        acc[type] = getAnnotationsBetweenRange(
+          seqDataToUse[type] as Annotation[],
+          range,
+          seqDataToUse.sequence.length,
+          excludePartial[type]
+        );
+        return acc;
+      },
+      {} as Record<string, Annotation[]>
+    )
+  );
+  if (range.overlapsSelf) {
+    const extendedSeqData = insertSequenceDataAtPosition(
+      { sequence: (seqDataToReturn as SequenceData).sequence }, // Wrapping in object as per assumed signature
+      seqDataToUse,
+      range.start
+    );
+
+    const toRet = getSequenceDataBetweenRange(
+      extendedSeqData,
+      {
+        start: range.end + 1,
+        end: range.end
+      },
+      options
+    );
+    annotationTypes.forEach(type => {
+      //we need to go through and adjust any anns where overlapsSelf=true to no longer overlap themselves if they match the range completely
+      forEach(toRet[type] as Annotation[], ann => {
+        if (
+          ann.overlapsSelf &&
+          ann.start === 0 &&
+          getRangeLength(ann, seqDataToUse.sequence.length) ===
+            getRangeLength(range, seqDataToUse.sequence.length)
+        ) {
+          ann.overlapsSelf = false;
+          ann.end = toRet.sequence.length - 1;
+        }
+      });
+    });
+    return tidyUpSequenceData(toRet, {
+      doNotRemoveInvalidChars: true,
+      ...options
+    });
+  }
+
+  return tidyUpSequenceData(seqDataToReturn, {
+    doNotRemoveInvalidChars: true,
+    ...options
+  });
+}
+
+function getAnnotationsBetweenRange(
+  annotationsToBeAdjusted: Annotation[],
+  range: Range,
+  maxLength: number,
+  shouldExcludePartial?: boolean
+): Annotation[] {
+  return flatMap(annotationsToBeAdjusted, annotation => {
+    if (annotation.locations && annotation.locations.length) {
+      annotation.locations = getAnnotationsBetweenRange(
+        annotation.locations,
+        range,
+        maxLength,
+        shouldExcludePartial
+      );
+    }
+    //map through every annotation and get the overlap of the annotation with the range
+    const overlaps = getZeroedRangeOverlaps(annotation, range, maxLength).map(
+      overlap => {
+        //we get back 1 or more overlaps here
+
+        return extend({}, annotation, overlap);
+      }
+    );
+    if (shouldExcludePartial) {
+      if (overlaps.length > 1) return []; //the annotation has multiple overlaps and thus must be a partial copy so we exclude it completely
+      if (overlaps[0]) {
+        //there is just 1 overlap, if it doesn't have the same length, it must be a partial copy so we need to exclude it
+        if (
+          getRangeLength(overlaps[0], maxLength) !==
+          getRangeLength(annotation, maxLength)
+        ) {
+          return [];
+        }
+      }
+    }
+
+    return overlaps;
+  }).map(annotation => {
+    if (annotation.locations && annotation.locations.length) {
+      annotation.start = annotation.locations[0].start;
+      annotation.end =
+        annotation.locations[annotation.locations.length - 1].end;
+
+      if (annotation.locations.length === 1) delete annotation.locations;
+    }
+    return annotation;
+  }); //filter any fully deleted ranges
+}

package/src/getVirtualDigest.ts

@@ -0,0 +1,139 @@
+//UNDER CONSTRUCTION
+
+import { get } from "lodash-es";
+
+import {
+  normalizePositionByRangeLength,
+  getRangeLength
+} from "@teselagen/range-utils";
+import { CutSite, DigestFragment } from "./types";
+
+export default function getVirtualDigest({
+  cutsites,
+  sequenceLength,
+  isCircular,
+  computePartialDigest,
+  computePartialDigestDisabled,
+  computeDigestDisabled
+}: {
+  cutsites: CutSite[];
+  sequenceLength: number;
+  isCircular: boolean;
+  computePartialDigest?: boolean;
+  computePartialDigestDisabled?: boolean;
+  computeDigestDisabled?: boolean;
+}) {
+  let fragments: DigestFragment[] = [];
+  const overlappingEnzymes: DigestFragment[] = [];
+  const pairs: CutSite[][] = [];
+
+  const sortedCutsites = cutsites.sort((a, b) => {
+    return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
+  });
+
+  sortedCutsites.forEach((cutsite1, index) => {
+    if (computePartialDigest && !computePartialDigestDisabled) {
+      sortedCutsites.forEach((cs, index2) => {
+        // if (index2 === index + 1 || index2 === 0) { //tnw: not sure if this is necessary or not. commenting out for now
+        //   return;
+        // }
+        pairs.push([cutsite1, sortedCutsites[index2]]);
+      });
+    }
+    if (!computeDigestDisabled) {
+      pairs.push([
+        cutsite1,
+        sortedCutsites[index + 1]
+          ? sortedCutsites[index + 1]
+          : sortedCutsites[0]
+      ]);
+    }
+  });
+
+  pairs.forEach(([cut1, cut2]) => {
+    const start = normalizePositionByRangeLength(
+      cut1.topSnipPosition || 0,
+      sequenceLength
+    );
+    const end = normalizePositionByRangeLength(
+      (cut2.topSnipPosition || 0) - 1,
+      sequenceLength
+    );
+
+    if (!isCircular && start > end) {
+      //we have a fragment that spans the origin so we need to split it in 2 pieces
+      const frag1 = {
+        start: start,
+        end: sequenceLength - 1,
+        cut1,
+        cut2: {
+          type: "endOfSeq",
+          restrictionEnzyme: {
+            name: "End Of Seq"
+          }
+        } as unknown as CutSite // Cast to CutSite as it's a mock
+      };
+      const frag2 = {
+        start: 0,
+        end: end,
+        cut1: {
+          type: "startOfSeq",
+          restrictionEnzyme: {
+            name: "Start Of Seq"
+          }
+        } as unknown as CutSite, // Cast
+        cut2: cut2
+      };
+
+      fragments.push(addSizeIdName(frag1, sequenceLength));
+      fragments.push(addSizeIdName(frag2, sequenceLength));
+    } else {
+      const frag = {
+        cut1,
+        cut2,
+        start,
+        end
+      };
+      fragments.push(addSizeIdName(frag, sequenceLength));
+    }
+  });
+  fragments = fragments.filter(fragment => {
+    if (!fragment.size) {
+      overlappingEnzymes.push(fragment);
+      return false;
+    }
+    return true;
+  });
+  return {
+    computePartialDigestDisabled,
+    computeDigestDisabled,
+    fragments,
+    overlappingEnzymes
+  };
+}
+
+function addSizeIdName(
+  frag: { start: number; end: number; cut1: CutSite; cut2: CutSite },
+  sequenceLength: number
+): DigestFragment {
+  const size = getRangeLength(
+    { start: frag.start, end: frag.end },
+    sequenceLength
+  );
+  const name = `${get(
+    frag,
+    "cut1.restrictionEnzyme.name",
+    "Untitled Cutsite"
+  )} -- ${get(
+    frag,
+    "cut2.restrictionEnzyme.name",
+    "Untitled Cutsite"
+  )} ${size} bps`;
+
+  return {
+    ...frag,
+    size,
+    name,
+    id: frag.start + "-" + frag.end + "-" + size + "-"
+  };
+}

package/src/guessIfSequenceIsDnaAndNotProtein.ts

@@ -0,0 +1,39 @@
+import { ambiguous_dna_letters } from "./bioData";
+
+export default function guessIfSequenceIsDnaAndNotProtein(
+  seq: string,
+  options: { threshold?: number; loose?: boolean; dnaLetters?: string[] } = {}
+) {
+  const { threshold = 0.9, loose } = options;
+  const dnaLetters =
+    options.dnaLetters || loose
+      ? [...ambiguous_dna_letters.split(""), "U"]
+      : ["G", "A", "T", "C", "U"];
+  // Guess if the given sequence is DNA or Protein.
+
+  //   It's considered DNA if more than 90% of the sequence is GATCs. The threshold
+  //   is configurable via the threshold parameter. dnaLetters can be used to configure
+  //   which letters are considered DNA; for instance, adding N might be useful if
+  //   you are expecting data with ambiguous bases.
+  const dnaLetterMap = dnaLetters.reduce(
+    (acc, letter) => {
+      acc[letter.toUpperCase()] = true;
+      return acc;
+    },
+    {} as Record<string, boolean>
+  );
+  let count = 0;
+  if (!seq || !seq.length) return true;
+
+  for (let index = 0; index < seq.length; index++) {
+    const letter = seq[index];
+    if (dnaLetterMap[letter.toUpperCase()]) {
+      count = count + 1;
+    }
+  }
+
+  if (count / seq.length > threshold) {
+    return true; //it is DNA
+  }
+  return false; //it is protein
+}

package/src/index.test.ts

@@ -0,0 +1,43 @@
+import * as src from ".";
+import fs from "fs";
+
+describe("index.js", () => {
+  it(`should export all functions defined`, () => {
+    return new Promise<void>(resolve => {
+      fs.readdir(__dirname, (err, files) => {
+        let passes = true;
+        files.forEach(file => {
+          if (
+            file.indexOf(".test.ts") > -1 ||
+            file.indexOf(".test.js") > -1 ||
+            file.indexOf("index.ts") > -1 ||
+            file.indexOf("index.js") > -1 ||
+            file.indexOf("prepareRowData_output1.json") > -1 ||
+            file.indexOf("featureTypesAndColors") > -1 ||
+            file.indexOf("diffUtils") > -1 ||
+            file.indexOf("types.ts") > -1 ||
+            file.indexOf("shims.d.ts") > -1
+          ) {
+            return;
+          }
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          const funcOrObj = src[file.replace(".ts", "").replace(".js", "")];
+          if (!funcOrObj) {
+            console.info(
+              `Uh oh, it looks like you forgot to export (or explicitly ignore) this file:`,
+              file
+            );
+            passes = false;
+          }
+        });
+        if (!passes) {
+          throw new Error(
+            "Please make sure to export (or ignore) each file! Update index.ts to export the file"
+          );
+        }
+        resolve();
+      });
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,111 @@
+import {
+  autoAnnotate,
+  convertApELikeRegexToRegex,
+  convertProteinSeqToDNAIupac
+} from "./autoAnnotate";
+
+import {
+  genbankFeatureTypes,
+  getFeatureToColorMap,
+  getFeatureTypes,
+  getMergedFeatureMap
+} from "./featureTypesAndColors";
+
+export * from "./computeDigestFragments";
+export * from "./diffUtils";
+export * from "./annotationTypes";
+
+/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
+//tnr: these are deprecated exports and should no longer be used!
+const FeatureTypes = getFeatureTypes();
+const featureColors = getFeatureToColorMap();
+export {
+  getFeatureToColorMap,
+  getFeatureTypes,
+  genbankFeatureTypes,
+  getMergedFeatureMap,
+  FeatureTypes,
+  featureColors
+};
+
+/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
+export { autoAnnotate };
+export { convertApELikeRegexToRegex };
+export { convertProteinSeqToDNAIupac };
+export * as bioData from "./bioData";
+export { default as getAllInsertionsInSeqReads } from "./getAllInsertionsInSeqReads";
+export { default as annotateSingleSeq } from "./annotateSingleSeq";
+export { default as getDegenerateDnaStringFromAAString } from "./getDegenerateDnaStringFromAAString";
+export { default as getDegenerateRnaStringFromAAString } from "./getDegenerateRnaStringFromAAString";
+export { default as getVirtualDigest } from "./getVirtualDigest";
+export { default as isEnzymeType2S } from "./isEnzymeType2S";
+export { default as insertGapsIntoRefSeq } from "./insertGapsIntoRefSeq";
+export { default as findApproxMatches } from "./findApproxMatches";
+export { default as adjustBpsToReplaceOrInsert } from "./adjustBpsToReplaceOrInsert";
+export { default as calculatePercentGC } from "./calculatePercentGC";
+export { default as calculateTm } from "./calculateTm";
+export { default as cutSequenceByRestrictionEnzyme } from "./cutSequenceByRestrictionEnzyme";
+export { default as deleteSequenceDataAtRange } from "./deleteSequenceDataAtRange";
+export { default as DNAComplementMap } from "./DNAComplementMap";
+export { default as doesEnzymeChopOutsideOfRecognitionSite } from "./doesEnzymeChopOutsideOfRecognitionSite";
+export { default as aliasedEnzymesByName } from "./aliasedEnzymesByName";
+export { default as defaultEnzymesByName } from "./defaultEnzymesByName";
+export { default as generateSequenceData } from "./generateSequenceData";
+export { default as generateAnnotations } from "./generateAnnotations";
+export {
+  default as filterSequenceString,
+  filterRnaString
+} from "./filterSequenceString";
+export { default as findNearestRangeOfSequenceOverlapToPosition } from "./findNearestRangeOfSequenceOverlapToPosition";
+export { default as findOrfsInPlasmid } from "./findOrfsInPlasmid";
+export { default as findSequenceMatches } from "./findSequenceMatches";
+export { default as getAminoAcidDataForEachBaseOfDna } from "./getAminoAcidDataForEachBaseOfDna";
+export { default as getAminoAcidFromSequenceTriplet } from "./getAminoAcidFromSequenceTriplet";
+export { default as getAminoAcidStringFromSequenceString } from "./getAminoAcidStringFromSequenceString";
+export { default as getCodonRangeForAASliver } from "./getCodonRangeForAASliver";
+export { default as getComplementAminoAcidStringFromSequenceString } from "./getComplementAminoAcidStringFromSequenceString";
+export { default as getComplementSequenceAndAnnotations } from "./getComplementSequenceAndAnnotations";
+export { default as getComplementSequenceString } from "./getComplementSequenceString";
+export { default as getCutsitesFromSequence } from "./getCutsitesFromSequence";
+export { default as getCutsiteType } from "./getCutsiteType";
+export { default as getInsertBetweenVals } from "./getInsertBetweenVals";
+export { default as getLeftAndRightOfSequenceInRangeGivenPosition } from "./getLeftAndRightOfSequenceInRangeGivenPosition";
+export { default as getOrfsFromSequence } from "./getOrfsFromSequence";
+export { default as getOverlapBetweenTwoSequences } from "./getOverlapBetweenTwoSequences";
+export { default as getPossiblePartsFromSequenceAndEnzymes } from "./getPossiblePartsFromSequenceAndEnzymes";
+export { default as getReverseAminoAcidStringFromSequenceString } from "./getReverseAminoAcidStringFromSequenceString";
+export { default as getReverseComplementAminoAcidStringFromSequenceString } from "./getReverseComplementAminoAcidStringFromSequenceString";
+export { default as getReverseComplementAnnotation } from "./getReverseComplementAnnotation";
+export { default as getReverseComplementSequenceAndAnnotations } from "./getReverseComplementSequenceAndAnnotations";
+export { default as getReverseComplementSequenceString } from "./getReverseComplementSequenceString";
+export { default as getReverseSequenceString } from "./getReverseSequenceString";
+export { default as getSequenceDataBetweenRange } from "./getSequenceDataBetweenRange";
+export { default as guessIfSequenceIsDnaAndNotProtein } from "./guessIfSequenceIsDnaAndNotProtein";
+export { default as insertSequenceDataAtPosition } from "./insertSequenceDataAtPosition";
+export { default as insertSequenceDataAtPositionOrRange } from "./insertSequenceDataAtPositionOrRange";
+export { default as mapAnnotationsToRows } from "./mapAnnotationsToRows";
+export { default as prepareCircularViewData } from "./prepareCircularViewData";
+export { default as prepareRowData } from "./prepareRowData";
+export { default as proteinAlphabet } from "./proteinAlphabet";
+export { default as rotateSequenceDataToPosition } from "./rotateSequenceDataToPosition";
+export { default as rotateBpsToPosition } from "./rotateBpsToPosition";
+export { default as threeLetterSequenceStringToAminoAcidMap } from "./threeLetterSequenceStringToAminoAcidMap";
+export { default as tidyUpSequenceData } from "./tidyUpSequenceData";
+export { default as tidyUpAnnotation } from "./tidyUpAnnotation";
+export { default as condensePairwiseAlignmentDifferences } from "./condensePairwiseAlignmentDifferences";
+export { default as addGapsToSeqReads } from "./addGapsToSeqReads";
+export { default as calculateNebTm } from "./calculateNebTm";
+export { default as calculateNebTa } from "./calculateNebTa";
+export { default as calculateSantaLuciaTm } from "./calculateSantaLuciaTm";
+export { default as calculateEndStability } from "./calculateEndStability";
+export { default as getDigestFragmentsForCutsites } from "./getDigestFragmentsForCutsites";
+export { default as getDigestFragmentsForRestrictionEnzymes } from "./getDigestFragmentsForRestrictionEnzymes";
+export { default as convertDnaCaretPositionOrRangeToAA } from "./convertDnaCaretPositionOrRangeToAA";
+export { default as convertAACaretPositionOrRangeToDna } from "./convertAACaretPositionOrRangeToDna";
+export { default as aminoAcidToDegenerateDnaMap } from "./aminoAcidToDegenerateDnaMap";
+export { default as aminoAcidToDegenerateRnaMap } from "./aminoAcidToDegenerateRnaMap";
+export { default as degenerateDnaToAminoAcidMap } from "./degenerateDnaToAminoAcidMap";
+export { default as degenerateRnaToAminoAcidMap } from "./degenerateRnaToAminoAcidMap";
+export { default as getMassOfAaString } from "./getMassOfAaString";
+export { default as shiftAnnotationsByLen } from "./shiftAnnotationsByLen";
+export { default as adjustAnnotationsToInsert } from "./adjustAnnotationsToInsert";

package/src/insertGapsIntoRefSeq.ts

@@ -0,0 +1,43 @@
+import getAllInsertionsInSeqReads, {
+  SeqRead
+} from "./getAllInsertionsInSeqReads";
+
+// seqReads should be an array of objects [{name, seq, pos, cigar}, {name, seq, pos, cigar}, ...]
+// add gaps in reference sequence where there are insertions
+export default function insertGapsIntoRefSeq(
+  refSeq: string,
+  seqReads: SeqRead[]
+): string {
+  // turn ref seq into an array ["A", "T", "C", "G"...]
+  const refSeqWithGaps = refSeq.split("");
+  const allInsertionsInSeqReads = getAllInsertionsInSeqReads(seqReads);
+  for (let i = 0; i < allInsertionsInSeqReads.length; i++) {
+    const bpPosOfInsertion = allInsertionsInSeqReads[i].bpPos;
+    const numberOfInsertions = allInsertionsInSeqReads[i].number;
+    // adding gaps at the bp pos of insertion
+    let insertionGaps = "";
+    for (let gapI = 0; gapI < numberOfInsertions; gapI++) {
+      insertionGaps += "-";
+    }
+    refSeqWithGaps.splice(bpPosOfInsertion - 1, 0, insertionGaps);
+    for (let posI = i + 1; posI < allInsertionsInSeqReads.length; posI++) {
+      allInsertionsInSeqReads[posI].bpPos += 1;
+    }
+  }
+  // refSeqWithGaps is a string "GGGA--GA-C--ACC"
+  return refSeqWithGaps.join("");
+}
+
+// allInsertionsInSeqReads.forEach(insertion => {
+//       // adding gap at the bp pos of insertion
+//       refSeqWithGaps.splice(insertion - 1, 0, "-");
+//   });
+//   for (let i = 0; i < allInsertionsInSeqReads.length; i++) {
+//     refSeqWithGaps.splice(allInsertionsInSeqReads[i] - 1, 0, "-");
+//     for (let innerI = i + 1; innerI < allInsertionsInSeqReads.length; innerI++){
+//       if (refSeqWithGaps[i] - 1 !== "-") {
+//         // allInsertionsInSeqReads[innerI] += 1;
+//         allInsertionsInSeqReads[i + 1] += 1;
+//       }
+//     }
+//   }

package/src/insertSequenceDataAtPosition.ts

@@ -0,0 +1,2 @@
+import insertSequenceDataAtPositionOrRange from "./insertSequenceDataAtPositionOrRange";
+export default insertSequenceDataAtPositionOrRange;