@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/calculateTm.js

@@ -0,0 +1,297 @@
+/* eslint-disable eqeqeq */
+/**
+ * DNA melting temperature calculator.
+ * @author Nick Elsbree
+ * @author Zinovii Dmytriv (original author)
+ */
+const calcTmMethods = {
+  TABLE_BRESLAUER: "breslauer",
+  TABLE_SUGIMOTO: "sugimoto",
+  TABLE_UNIFIED: "unified",
+
+  A: -10.8, // Helix initiation for deltaS
+  R: 1.987, // Gas constant (cal/(K*mol)).
+  C: 0.5e-6, // Oligo concentration. 0.5uM is typical for PCR.
+  Na: 50e-3, // Monovalent salt concentration. 50mM is typical for PCR.
+
+  /**
+   * Calculates temperature for DNA sequence using a given algorithm.
+   * @param  {String} sequence The DNA sequence to use.
+   * @param  {String} type Either Teselagen.bio.tools.TemperatureCalculator.TABLE_BRESLAUER, TABLE_SUGIMOTO, or TABLE_UNIFIED
+   * @param  {Double} A Helix initation for deltaS. Defaults to -10.8.
+   * @param  {Double} R The gas constant, in cal/(K*mol). Defaults to 0.5e-6M.
+   * @param  {Double} Na THe monovalent salt concentration. Defaults to 50e-3M.
+   * @return {Double} Temperature for the given sequence, in Celsius.
+   */
+  calculateTemperature: function(sequence, type, A, R, C, Na) {
+    if (typeof type === "undefined") {
+      type = this.TABLE_BRESLAUER;
+    } else if (
+      type != this.TABLE_BRESLAUER &&
+      (type != this.TABLE_UNIFIED && type != this.TABLE_SUGIMOTO)
+    ) {
+      throw new Error("Invalid table type!");
+    }
+
+    if (!A) {
+      A = this.A;
+    }
+    if (!R) {
+      R = this.R;
+    }
+    if (!C) {
+      C = this.C;
+    }
+    if (!Na) {
+      Na = this.Na;
+    }
+
+    const sequenceLength = sequence.length;
+
+    if (sequenceLength == 0) {
+      return 0;
+    }
+
+    const deltaHTable = this.getDeltaHTable(type);
+    const deltaSTable = this.getDeltaSTable(type);
+
+    const neighbors = []; // List goes in order: aa, at, ac, ag, tt, ta, tc, tg, cc, ca, ct, cg, gg, gt, gc
+
+    neighbors.push(this.calculateReps(sequence, "aa"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "at"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "ac"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "ag"));
+
+    neighbors.push(this.calculateReps(sequence, "tt"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "ta"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "tc"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "tg"));
+
+    neighbors.push(this.calculateReps(sequence, "cc"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "ca"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "ct"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "cg"));
+
+    neighbors.push(this.calculateReps(sequence, "gg"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "ga"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "gt"));
+    neighbors.push(this.calculateNumberOfOccurrences(sequence, "gc"));
+
+    let sumDeltaH = 0.0;
+    let sumDeltaS = 0.0;
+
+    for (let i = 0; i < 16; i++) {
+      sumDeltaH = sumDeltaH + neighbors[i] * deltaHTable[i];
+      sumDeltaS = sumDeltaS + neighbors[i] * deltaSTable[i];
+    }
+
+    const temperature =
+      (-1000.0 * sumDeltaH) / (A + -sumDeltaS + R * Math.log(C / 4.0)) -
+      273.15 +
+      16.6 * Math.LOG10E * Math.log(Na);
+
+    // If temperature is negative then return 0.
+    if (temperature < 0) {
+      return 0;
+    }
+
+    return temperature.toFixed(2);
+  },
+
+  /**
+   * @private
+   * Function to return deltaH table for given algorithm.
+   * @param {String} type Algorithm to get table for.
+   * @return {Number[]} deltaH table for given algorithm.
+   */
+  getDeltaHTable: function(type) {
+    if (type == this.TABLE_BRESLAUER) {
+      return [
+        9.1,
+        8.6,
+        6.5,
+        7.8,
+        9.1,
+        6.0,
+        5.6,
+        5.8,
+        11.0,
+        5.8,
+        7.8,
+        11.9,
+        11.0,
+        5.6,
+        6.5,
+        11.1
+      ];
+    } else if (type == this.TABLE_SUGIMOTO) {
+      return [
+        8.0,
+        5.6,
+        6.5,
+        7.8,
+        8.0,
+        5.6,
+        5.6,
+        5.8,
+        10.9,
+        8.2,
+        6.6,
+        11.8,
+        10.9,
+        6.6,
+        9.4,
+        11.9
+      ];
+    } else if (type == this.TABLE_UNIFIED) {
+      return [
+        7.9,
+        7.2,
+        8.4,
+        7.8,
+        7.9,
+        7.2,
+        8.2,
+        8.5,
+        8.0,
+        8.5,
+        7.8,
+        10.6,
+        8.0,
+        8.2,
+        8.4,
+        9.8
+      ];
+    } else {
+      return null;
+    }
+  },
+
+  /**
+   * @private
+   * Function to return deltaS table for given algorithm.
+   * @param {String} type Algorithm to get table for.
+   * @return {Number[]} deltaS table for given algorithm.
+   */
+  getDeltaSTable: function(type) {
+    if (type == this.TABLE_BRESLAUER) {
+      return [
+        24.0,
+        23.9,
+        17.3,
+        20.8,
+        24.0,
+        16.9,
+        13.5,
+        12.9,
+        26.6,
+        12.9,
+        20.8,
+        27.8,
+        26.6,
+        13.5,
+        17.3,
+        26.7
+      ];
+    } else if (type == this.TABLE_SUGIMOTO) {
+      return [
+        21.9,
+        15.2,
+        17.3,
+        20.8,
+        21.9,
+        15.2,
+        13.5,
+        12.9,
+        28.4,
+        25.5,
+        23.5,
+        29.0,
+        28.4,
+        16.4,
+        25.5,
+        29.0
+      ];
+    } else if (type == this.TABLE_UNIFIED) {
+      return [
+        22.2,
+        20.4,
+        22.4,
+        21.0,
+        22.2,
+        21.3,
+        22.2,
+        22.7,
+        19.9,
+        22.7,
+        21.0,
+        27.2,
+        19.9,
+        22.2,
+        22.4,
+        24.4
+      ];
+    } else {
+      return null;
+    }
+  },
+
+  /**
+   * @private
+   * Finds number of occurrences of target in sequence.
+   * Will find repeating sequences, meaning that
+   * calculateReps("aaa", "aa") returns 2 rather than 1.
+   * @param  {String} sequence The string to search through.
+   * @param  {String} target   The string to search for.
+   * @return {Int} Number of occurrences of target in sequence, with repeats.
+   */
+  calculateReps: function(sequence, target) {
+    const sequenceLength = sequence.length;
+
+    if (sequenceLength == 0) {
+      return 0;
+    }
+
+    let numFound = 0;
+    let seqOffset = 0; // Search offset for finding multiple matches.
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const foundSeq = sequence.indexOf(target, seqOffset);
+
+      if (foundSeq == -1) {
+        break;
+      }
+
+      seqOffset = foundSeq + 1;
+      numFound++;
+
+      if (seqOffset > sequenceLength) {
+        break;
+      }
+    }
+
+    return numFound;
+  },
+
+  /**
+   * @private
+   * Counts number of occurrences of target in sequence, without repeating.
+   * @param  {String} sequence The string to search through.
+   * @param  {String} target   The string to search for.
+   * @return {Int} Number of occurrences of target in sequence.
+   */
+  calculateNumberOfOccurrences: function(sequence, target) {
+    const sequenceLength = sequence.length;
+
+    if (sequenceLength == 0) {
+      return 0;
+    }
+
+    const numberFound = sequence.split(target).length - 1;
+
+    return numberFound;
+  }
+};
+
+export default calcTmMethods.calculateTemperature.bind(calcTmMethods);

package/src/calculateTm.test.js

@@ -0,0 +1,7 @@
+import calculateTm from "./calculateTm";
+import assert from "assert";
+describe("calculateTm", () => {
+  it("should calculate the correct tm", () => {
+    assert.equal(calculateTm("atagagaggga"), 26.21);
+  });
+});

package/src/computeDigestFragments.js

@@ -0,0 +1,179 @@
+import shortid from "shortid";
+import {flatMap, cloneDeep} from "lodash";
+import {normalizePositionByRangeLength, getRangeLength} from "@teselagen/range-utils";
+import getCutsitesFromSequence from "./getCutsitesFromSequence";
+
+function computeDigestFragments({
+  cutsites,
+  sequenceLength,
+  circular,
+  //optional:
+  includeOverAndUnderHangs,
+  computePartialDigest,
+  computeDigestDisabled,
+  computePartialDigestDisabled,
+  selectionLayerUpdate,
+  updateSelectedFragment
+}) {
+  const fragments = [];
+  const overlappingEnzymes = [];
+  const pairs = [];
+
+  const sortedCutsites = cutsites.sort((a, b) => {
+    return a.topSnipPosition - b.topSnipPosition;
+  });
+  if (!circular && cutsites.length) {
+    sortedCutsites.push({
+      id: "seqTerm_" + shortid(),
+      start: 0,
+      end: 0,
+      overhangBps: "",
+      topSnipPosition: 0,
+      bottomSnipPosition: 0,
+      upstreamTopSnip: 0,
+      upstreamBottomSnip: 0,
+      upstreamTopBeforeBottom: false,
+      topSnipBeforeBottom: false,
+      recognitionSiteRange: {
+        start: 0,
+        end: 0
+      },
+      forward: true,
+      name: "Sequence_Terminus",
+      restrictionEnzyme: {
+        name: "Sequence_Terminus"
+      }
+    });
+  }
+
+  sortedCutsites.forEach((cutsite1, index) => {
+    if (computePartialDigest && !computePartialDigestDisabled) {
+      sortedCutsites.forEach((cs, index2) => {
+        if (index2 === index + 1 || index2 === 0) {
+          return;
+        }
+        pairs.push([cutsite1, sortedCutsites[index2]]);
+      });
+    }
+    if (!computeDigestDisabled) {
+      pairs.push([
+        cutsite1,
+        sortedCutsites[index + 1]
+          ? sortedCutsites[index + 1]
+          : sortedCutsites[0]
+      ]);
+    }
+  });
+
+  pairs.forEach(r => {
+    let [cut1, cut2] = r;
+
+    let start;
+    let end;
+    let size;
+    start = normalizePositionByRangeLength(
+      cut1.topSnipPosition,
+      sequenceLength
+    );
+    end = normalizePositionByRangeLength(
+      cut2.topSnipPosition - 1,
+      sequenceLength
+    );
+    size = getRangeLength({ start, end }, sequenceLength);
+    let overlapsSelf;
+    if (includeOverAndUnderHangs) {
+      const oldSize = size;
+      start = normalizePositionByRangeLength(
+        cut1.topSnipBeforeBottom
+          ? cut1.topSnipPosition
+          : cut1.bottomSnipPosition,
+        sequenceLength
+      );
+      end = normalizePositionByRangeLength(
+        cut2.topSnipBeforeBottom
+          ? cut2.bottomSnipPosition - 1
+          : cut2.topSnipPosition - 1,
+        sequenceLength
+      );
+      size = getRangeLength({ start, end }, sequenceLength);
+      if (oldSize > size) {
+        //we've got a part that wraps on itself
+        overlapsSelf = true;
+        size += sequenceLength;
+      }
+    }
+
+    let isFormedFromLinearEnd;
+    if (cut1.name === "Sequence_Terminus") {
+      cut1 = cloneDeep(cut1);
+      isFormedFromLinearEnd = true;
+      cut1.name = "Linear_Sequence_Start";
+      cut1.restrictionEnzyme.name = "Linear_Sequence_Start";
+    } else if (cut2.name === "Sequence_Terminus") {
+      cut2 = cloneDeep(cut2);
+      isFormedFromLinearEnd = true;
+      cut2.name = "Linear_Sequence_End";
+      cut2.restrictionEnzyme.name = "Linear_Sequence_End";
+    }
+
+    const id = start + "-" + end + "-" + size + "-";
+    const name = `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps`;
+    getRangeLength({ start, end }, sequenceLength);
+
+    fragments.push({
+      isFormedFromLinearEnd,
+      madeFromOneCutsite: cut1 === cut2,
+      start,
+      end,
+      size,
+      overlapsSelf,
+      id,
+      name,
+      cut1,
+      cut2,
+      onFragmentSelect:
+        selectionLayerUpdate && updateSelectedFragment
+          ? () => {
+              selectionLayerUpdate({
+                start,
+                end,
+                name
+              });
+
+              updateSelectedFragment(id);
+            }
+          : undefined
+    });
+  });
+  fragments.filter(fragment => {
+    if (!fragment.size) {
+      overlappingEnzymes.push(fragment);
+      return false;
+    }
+    return true;
+  });
+  return {
+    computePartialDigestDisabled,
+    computeDigestDisabled,
+    fragments,
+    overlappingEnzymes
+  };
+}
+
+function getDigestFragsForSeqAndEnzymes({
+  sequence,
+  circular,
+  enzymes,
+  includeOverAndUnderHangs
+}) {
+  const cutsitesByName = getCutsitesFromSequence(sequence, circular, enzymes);
+  return computeDigestFragments({
+    includeOverAndUnderHangs,
+    cutsites: flatMap(cutsitesByName),
+    sequenceLength: sequence.length,
+    circular
+  });
+}
+
+export {computeDigestFragments};
+export {getDigestFragsForSeqAndEnzymes};

package/src/computeDigestFragments.test.js

@@ -0,0 +1,73 @@
+import {getDigestFragsForSeqAndEnzymes} from "./computeDigestFragments.js";
+import aliasedEnzymesByName from "./aliasedEnzymesByName.js";
+
+describe("computeDigestFragments", () => {
+  it("it should correctly generate fragments for bamhi cutting once in a circular sequence with includeOverAndUnderHangs=true", () => {
+    const result = getDigestFragsForSeqAndEnzymes({
+      sequence: "ggggatccggggggggggggggggggggggggggggggggggggggggg",
+      circular: true,
+      enzymes: [aliasedEnzymesByName.bamhi],
+      includeOverAndUnderHangs: true
+    });
+    expect(result.fragments).toHaveLength(1);
+    expect(result.fragments[0].overlapsSelf).toEqual(true);
+    expect(result.fragments[0].start).toEqual(3);
+    expect(result.fragments[0].end).toEqual(6);
+    // expect(result.fragments[0].size).toEqual(4);
+    expect(result.fragments[0].size).toEqual(53);
+    expect(result.fragments[0].madeFromOneCutsite).toEqual(true);
+  });
+  it("it should correctly generate fragments for bamhi cutting once in a circular sequence", () => {
+    const result = getDigestFragsForSeqAndEnzymes({
+      sequence: "ggggatccggggggggggggggggggggggggggggggggggggggggg",
+      circular: true,
+      enzymes: [aliasedEnzymesByName.bamhi]
+    });
+    expect(result.fragments).toHaveLength(1);
+    expect(result.fragments[0].start).toEqual(3);
+    expect(result.fragments[0].end).toEqual(2);
+    expect(result.fragments[0].size).toEqual(49);
+    expect(result.fragments[0].madeFromOneCutsite).toEqual(true);
+  });
+  it("it should correctly generate fragments for bamhi cutting once in a linear sequence", () => {
+    const result = getDigestFragsForSeqAndEnzymes({
+      sequence: "ggggatccggggggggggggggggggggggggggggggggggggggggg",
+      circular: false,
+      enzymes: [aliasedEnzymesByName.bamhi]
+    });
+    expect(result.fragments).toHaveLength(2);
+    expect(result.fragments[0].isFormedFromLinearEnd).toEqual(true);
+    expect(result.fragments[0].name).toEqual(
+      "BamHI -- Linear_Sequence_End 46 bps"
+    );
+    expect(result.fragments[0].start).toEqual(3);
+    expect(result.fragments[0].end).toEqual(48);
+    expect(result.fragments[0].size).toEqual(46);
+    expect(result.fragments[0].madeFromOneCutsite).toEqual(false);
+
+    expect(result.fragments[1].isFormedFromLinearEnd).toEqual(true);
+    expect(result.fragments[1].name).toEqual(
+      "Linear_Sequence_Start -- BamHI 3 bps"
+    );
+    expect(result.fragments[1].start).toEqual(0);
+    expect(result.fragments[1].end).toEqual(2);
+    expect(result.fragments[1].size).toEqual(3);
+    expect(result.fragments[1].madeFromOneCutsite).toEqual(false);
+  });
+  it("it should not generate any fragments for bamhi if it doesn't cut in a linear sequence", () => {
+    const result = getDigestFragsForSeqAndEnzymes({
+      sequence: "ggggggggggggggggggggggggggggggggggggggggggggg",
+      circular: false,
+      enzymes: [aliasedEnzymesByName.bamhi]
+    });
+    expect(result.fragments).toHaveLength(0);
+  });
+  it("it should not generate any fragments for bamhi if it doesn't cut in a circular sequence", () => {
+    const result = getDigestFragsForSeqAndEnzymes({
+      sequence: "ggggggggggggggggggggggggggggggggggggggggggggg",
+      circular: true,
+      enzymes: [aliasedEnzymesByName.bamhi]
+    });
+    expect(result.fragments).toHaveLength(0);
+  });
+});

package/src/condensePairwiseAlignmentDifferences.js

@@ -0,0 +1,85 @@
+export default function condensePairwiseAlignmentDifferences(
+  referenceSeq,
+  alignedSeq
+) {
+  const overviewMinimapTrack = [];
+  const referenceSeqSplit = referenceSeq.toLowerCase().split("");
+  const alignedSeqSplit = alignedSeq.toLowerCase().split("");
+  const seqLength = alignedSeq.length;
+  const alignedSeqWithoutLeadingDashes = alignedSeq.replace(/^-+/g, "");
+  const alignedSeqWithoutTrailingDashes = alignedSeq.replace(/-+$/g, "");
+
+  const startIndex = seqLength - alignedSeqWithoutLeadingDashes.length;
+  const endIndex =
+    seqLength - (seqLength - alignedSeqWithoutTrailingDashes.length);
+  for (let i = 0; i < referenceSeqSplit.length; i++) {
+    if (i < startIndex || i >= endIndex) {
+      overviewMinimapTrack.push("W");
+    } else if (
+      referenceSeqSplit[i] === alignedSeqSplit[i] &&
+      referenceSeqSplit[i] !== "-" &&
+      alignedSeqSplit[i] !== "-"
+    ) {
+      // ACTG match
+      overviewMinimapTrack.push("G");
+    } else if (
+      referenceSeqSplit[i] !== alignedSeqSplit[i] &&
+      referenceSeqSplit[i] !== "-" &&
+      alignedSeqSplit[i] !== "-"
+    ) {
+      // ACTG mismatch
+      overviewMinimapTrack.push("R");
+    } else if (alignedSeqSplit[i] === "-") {
+      // deletion
+      overviewMinimapTrack.push("R");
+    } else if (
+      referenceSeqSplit[i] === "-" &&
+      referenceSeqSplit[i - 1] !== "-" &&
+      i !== referenceSeqSplit.length - 1 &&
+      referenceSeqSplit[i + 1] === "-"
+    ) {
+      // insertion (first "-" of a >1 insertion)
+      overviewMinimapTrack.push("R");
+    } else if (
+      referenceSeqSplit[i] === "-" &&
+      referenceSeqSplit[i - 1] !== "-" &&
+      i !== referenceSeqSplit.length - 1 &&
+      referenceSeqSplit[i + 1] !== "-"
+    ) {
+      // "-" of a one-bp insertion in the middle of the sequence
+      overviewMinimapTrack.push("R");
+      i++;
+    } else if (
+      i === referenceSeqSplit.length - 1 &&
+      referenceSeqSplit[i] === "-" &&
+      referenceSeqSplit[i - 1] === "-"
+    ) {
+      // final "-" of a >1 insertion at the 3' end of the sequence
+      overviewMinimapTrack.splice(-2, 1);
+    } else if (
+      i === referenceSeqSplit.length - 1 &&
+      referenceSeqSplit[i] === "-" &&
+      referenceSeqSplit[i - 1] !== "-"
+    ) {
+      // "-" of a one-bp insertion at the 3' end of the sequence
+      overviewMinimapTrack.pop();
+      overviewMinimapTrack.push("R");
+    } else if (
+      referenceSeqSplit[i] === "-" &&
+      referenceSeqSplit[i - 1] === "-" &&
+      referenceSeqSplit[i + 1] !== "-"
+    ) {
+      // "-" at the end of an insertion
+      i++;
+    } else if (
+      referenceSeqSplit[i] === "-" &&
+      referenceSeqSplit[i - 1] === "-"
+    ) {
+      // insertion (NOT first "-" of the insertion)
+      // do nothing, skip over these "-"
+    } else {
+      console.error("should not reach this step!");
+    }
+  }
+  return overviewMinimapTrack.join("");
+};

package/src/condensePairwiseAlignmentDifferences.test.js

@@ -0,0 +1,66 @@
+import condensePairwiseAlignmentDifferences from "./condensePairwiseAlignmentDifferences.js";
+describe("pairwise alignment differences", () => {
+  it("it should ignore start and end where dashes are ", () => {
+    const result = condensePairwiseAlignmentDifferences(
+      "cccccccGCTAG--Tccc",
+      "-------GCTAGAAT---"
+    );
+    expect(result).toBe("WWWWWWWGGGGGRWWW");
+  });
+  it("1 insertion of >1 bp", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAG--T", "GCTAGAAT");
+    expect(result).toBe("GGGGGR");
+  });
+  it("should be case insensitive", () => {
+    const result = condensePairwiseAlignmentDifferences("GctAG-T", "GCTAGAT");
+    expect(result).toBe("GGGGGR");
+  });
+  it("insertion of one bp in the middle of the sequence", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAG-T", "GCTAGAT");
+    expect(result).toBe("GGGGGR");
+  });
+  it("1 deletion", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAGAAT", "GC--GAAT");
+    expect(result).toBe("GGRRGGGG");
+  });
+  it("2 insertions", () => {
+    const result = condensePairwiseAlignmentDifferences("G--AG--T", "GCTAGAAT");
+    expect(result).toBe("GRGR");
+  });
+  it("insertion at the 3' end", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAGA--", "GCTAGAAT");
+    expect(result).toBe("GGGGGR");
+  });
+  it("insertion of one bp at the 3' end", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAGAA-", "GCTAGAAT");
+    expect(result).toBe("GGGGGGR");
+  });
+  it("insertion of three bp at the 3' end", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAG---", "GCTAGAAT");
+    expect(result).toBe("GGGGR");
+  });
+  it("insertion at the 5' end", () => {
+    const result = condensePairwiseAlignmentDifferences("--TAGAAT", "GCTAGAAT");
+    expect(result).toBe("RGGGGG");
+  });
+  it("insertion of one bp at the 5' end", () => {
+    const result = condensePairwiseAlignmentDifferences("-TAGAAT", "CTAGAAT");
+    expect(result).toBe("RGGGGG");
+  });
+  it("1 insertion & 1 deletion in the middle", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAG--T", "GC--GAAT");
+    expect(result).toBe("GGRRGR");
+  });
+  it("1 insertion & 1 deletion that are adjacent in the middle", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTA--T", "GC--AAT");
+    expect(result).toBe("GGRRR");
+  });
+  it("1 insertion then 1 deletion that are adjacent at the 5' end", () => {
+    const result = condensePairwiseAlignmentDifferences("--TAGAAT", "GC--GAAT");
+    expect(result).toBe("RRGGGG");
+  });
+  it("1 insertion then 1 deletion that are adjacent at the 3' end", () => {
+    const result = condensePairwiseAlignmentDifferences("GCTAGA--", "GCTA--AT");
+    expect(result).toBe("GGGGRR");
+  });
+});