@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/getOrfsFromSequence.js

@@ -0,0 +1,124 @@
+import shortid from "shortid";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+
+
+/**
+ * @private
+ * Finds ORFs in a given DNA forward in a given frame.
+ * @param  {Int} frame The frame to look in.
+ * @param  {String}sequence The dna sequence.
+ * @param  {Int} minimumOrfSize The minimum length of ORF to return.
+ * @param  {boolean} forward Should we find forward facing orfs or reverse facing orfs
+ * @return {Teselagen.bio.orf.ORF[]} The list of ORFs found.
+ */
+export default function getOrfsFromSequence(options) {
+  // ac.throw([ac.shape({
+  //     sequence: ac.string,
+  //     minimumOrfSize: ac.posInt,
+  //     forward: ac.bool,
+  //     circular: ac.bool
+  // })], arguments);
+
+  // const frame = options.frame;
+  let sequence = options.sequence;
+  const minimumOrfSize = options.minimumOrfSize;
+  const forward = options.forward;
+  const circular = options.circular;
+  const useAdditionalOrfStartCodons = options.useAdditionalOrfStartCodons;
+
+  const originalSequenceLength = sequence.length;
+  if (!forward) {
+    //we reverse the sequence
+    sequence = getReverseComplementSequenceString(sequence);
+  }
+
+  if (circular) {
+    //we'll pass in double the sequence and then trim excess orfs
+    sequence += sequence;
+  }
+  const re = useAdditionalOrfStartCodons
+    ? /(?=((?:A[TU]G|G[TU]G|C[TU]G)(?:.{3})*?(?:[TU]AG|[TU]AA|[TU]GA)))/gi
+    : /(?=((?:A[TU]G)(?:.{3})*?(?:[TU]AG|[TU]AA|[TU]GA)))/gi;
+  // const str = 'tatgaatgaatgffffffatgfftaaftaafatgfatgfffffsdfatgffatgfffstaafftaafffffffffffffffatgtaaataa\n\natgffftaaf\n\natgffatgftaafftaa\n\natgatgftaafftaa\n\natgatgtaataa\n\ntttttttttttttaatgatgfffffffffftaa';
+  let m;
+  const orfRanges = [];
+  //loop through orf hits!
+  /* eslint-disable no-cond-assign*/
+
+  while ((m = re.exec(sequence)) !== null) {
+    //stuff to get the regex to work
+    if (m.index === re.lastIndex) {
+      re.lastIndex++;
+    }
+    //orf logic:
+    const orfLength = m[1].length;
+    if (orfLength >= minimumOrfSize) {
+      //only keep orfs >= to the minimum size
+      const start = m.index;
+      let end = orfLength + start - 1;
+      //normalize the end if it is greater than the original sequence length
+      if (end >= originalSequenceLength) {
+        end -= originalSequenceLength;
+      }
+      if (start < originalSequenceLength) {
+        //only keep orfs that *begin* before the original sequence length (only the case when dealing with circular orfs)
+        orfRanges.push({
+          start: start,
+          end: end,
+          length: m[1].length,
+          internalStartCodonIndices: [],
+          frame: start % 3,
+          forward: forward,
+          annotationTypePlural: "orfs",
+          isOrf: true,
+          id: shortid()
+        });
+      }
+    }
+  }
+  // pair down the orfs to remove duplicates
+  // and deal with revComp orfs
+  const orfEnds = {};
+  orfRanges.forEach((orf, index) => {
+    const indexOfAlreadyExistingOrf = orfEnds[orf.end];
+
+    if (typeof indexOfAlreadyExistingOrf !== "undefined") {
+      let internalOrf = orf;
+      let containingOrf = orfRanges[indexOfAlreadyExistingOrf];
+      if (containingOrf.length < internalOrf.length) {
+        internalOrf = orfRanges[indexOfAlreadyExistingOrf];
+        containingOrf = orf;
+        orfEnds[orf.end] = index;
+      }
+      const internalStartCodonIndex = forward
+        ? internalOrf.start
+        : originalSequenceLength - internalOrf.start - 1; //use either the start or the end depending on the direction of the internalOrf
+      //we know because of how the regex works that larger orfs come first in the array
+      containingOrf.internalStartCodonIndices = [
+        ...containingOrf.internalStartCodonIndices,
+        ...internalOrf.internalStartCodonIndices,
+        internalStartCodonIndex
+      ];
+      //set a flag that we'll use to remove all these shorter, duplicated orfs
+      internalOrf.remove = true;
+    } else {
+      orfEnds[orf.end] = index;
+      if (!forward) {
+        // if (originalSequenceLength - orf.end - 1 == 3657) {
+        // }
+        //this check needs to come after the above assignment of orfEnds
+        //flip the start and ends
+        const endHolder = orf.end; //temp variable
+        orf.end = originalSequenceLength - orf.start - 1;
+        orf.start = originalSequenceLength - endHolder - 1;
+      }
+    }
+  });
+  const nonDuplicatedOrfRanges = orfRanges.filter(orf => {
+    if (!orf.remove) {
+      return true;
+    }
+    return false;
+  });
+  return nonDuplicatedOrfRanges;
+};

package/src/getOrfsFromSequence.test.js

@@ -0,0 +1,210 @@
+
+
+import {expect} from "chai";
+
+import getOrfsFromSequence from "./getOrfsFromSequence.js";
+// getOrfsFromSequence(frame, sequence, minimumOrfSize, forward, circular)
+describe("getOrfsFromSequence", () => {
+  it("finds correct orfs in reverse direction in slightly more complex sequence", () => {
+    const orfs = getOrfsFromSequence({
+      sequence:
+        "gattttaatcactataccaattgagatgggctagtcaatgataattactagtccttttcccgggtgatctgggtatctgtaaattctgctagacctttgctggaaaacttgtaaattctgctagaccctctgtaaattccgctagacctttgtgtgttttttttgtttatattcaagtggttataatttatagaataaagaaagaataaaaaaagataaaaagaatagatcccagccctgtgtataactcactactttagtcagttccgcagtattacaaaaggatgtcgcaaacgctgtttgctcctctacaaaacagaccttaaaaccctaaaggcttaagtagcaccctcgcaagctcgggcaaatcgctgaatattccttttgtctccgaccatcaggcacctgagtcgctgtctttttcgtgacattcagttcgctgcgctcacggctctggcagtgaatgggggtaaatggcactacaggcgccttttatggattcatgcaaggaaactacccataatacaagaaaagcccgtcacgggcttctcagggcgttttatggcgggtctgctatgtggtgctatctgactttttgctgttcagcagttcctgccctctgattttccagtctgaccacttcggattatcccgtgacaggtcattcagactggctaatgcacccagtaaggcagcggtatcatcaacaggcttacccgtcttactgtccctagtgcttggattctcaccaataaaaaacgcccggcggcaaccgagcgttctgaacaaatccagatggagttctgaggtcattactggatctatcaacaggagtccaagcgagctcgatatcaaattacgccccgccctgccactcatcgcagtactgttgtaattcattaagcattctgccgacatggaagccatcacaaacggcatgatgaacctgaatcgccagcggcatcagcaccttgtcgccttgcgtataatatttgcccatggtgaaaacgggggcgaagaagttgtccatattggccacgtttaaatcaaaactggtgaaactcacccagggattggctgagacgaaaaacatattctcaataaaccctttagggaaataggccaggttttcaccgtaacacgccacatcttgcgaatatatgtgtagaaactgccggaaatcgtcgtggtattcactccagagcgatgaaaacgtttcagtttgctcatggaaaacggtgtaacaagggtgaacactatcccatatcaccagctcaccgtctttcattgccatacgaaattccggatgagcattcatcaggcgggcaagaatgtgaataaaggccggataaaacttgtgcttatttttctttacggtctttaaaaaggccgtaatatccagctgaacggtctggttataggtacattgagcaactgactgaaatgcctcaaaatgttctttacgatgccattgggatatatcaacggtggtatatccagtgatttttttctccattttagcttccttagctcctgaaaatctcgataactcaaaaaatacgcccggtagtgatcttatttcattatggtgaaagttggaacctcttacgtgccgatcaacgtctcattttcgccagatatcgacgtcttatgacaacttgacggctacatcattcactttttcttcacaaccggcacggaactcgctcgggctggccccggtgcattttttaaatacccgcgagaaatagagttgatcgtcaaaaccaacattgcgaccgacggtggcgataggcatccgggtggtgctcaaaagcagcttcgcctggctgatacgttggtcctcgcgccagcttaagacgctaatccctaactgctggcggaaaagatgtgacagacgcgacggcgacaagcaaacatgctgtgcgacgctggcgatatcaaaattgctgtctgccaggtgatcgctgatgtactgacaagcctcgcgtacccgattatccatcggtggatggagcgactcgttaatcgcttccatgcgccgcagtaacaattgctcaagcagatttatcgccagcagctccgaatagcgcccttccccttgcccggcgttaatgatttgcccaaacaggtcgctgaaatgcggctggtgcgcttcatccgggcgaaagaaccccgtattggcaaatattgacggccagttaagccattcatgccagtaggcgcgcggacgaaagtaaacccactggtgataccattcgcgagcctccggatgacgaccgtagtgatgaatctctcctggcgggaacagcaaaatatcacccggtcggcaaacaaattctcgtccctgatttttcaccaccccctgaccgcgaatggtgagattgagaatataacctttcattcccagcggtcggtcgataaaaaaatcgagataaccgttggcctcaatcggcgttaaacccgccaccagatgggcattaaacgagtatcccggcagcaggggatcattttgcgcttcagccatacttttcatactcccgccattcagagaagaaaccaattgtccatattgcatcagacattgccgtcactgcgtcttttactggctcttctcgctaaccaaaccggtaaccccgcttattaaaagcattctgtaacaaagcgggaccaaagccatgacaaaaacgcgtaacaaaagtgtctataatcacggcagaaaagtccacattgattatttgcacggcgtcacactttgctatgccatagcatttttatccataagattagcggattctacctgacgctttttatcgcaactctctactgtttctccatacccgtttttttgggaatttttaagaaggagatatacatatgagtaaaggagaagaacttttcactggagttgtcccaattcttgttgaattagatggtgatgttaatgggcacaaattttctgtcagtggagagggtgaaggtgatgcaacatacggaaaacttacccttaaatttatttgcactactggaaaactacctgttccatggccaacacttgtcactactttctcttatggtgttcaatgcttttcccgttatccggatcatatgaaacggcatgactttttcaagagtgccatgcccgaaggttatgtacaggaacgcactatatctttcaaagatgacgggaactacaagacgcgtgctgaagtcaagtttgaaggtgatacccttgttaatcgtatcgagttaaaaggtattgattttaaagaagatggaaacat",
+      minimumOrfSize: 3280,
+      forward: false,
+      circular: false
+    });
+    expect(orfs).to.be.length(0);
+    // const orf = orfs[0];
+    // expect(orf).to.be.an('object');
+    // expect(orf.start).to.equal(11);
+    // expect(orf.end).to.equal(0);
+    // expect(orf.forward).to.equal(false);
+    // expect(orf.frame).to.equal(0);
+    // expect(orf.internalStartCodonIndices).to.deep.equal([8]);
+    // expect(orf.id).to.be.a('string');
+  });
+  it("finds correct orfs in reverse direction in slightly more complex sequence", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "ttarrrcatcat",
+      //   E       S     S
+      //rrrttarrrcatrrrcatr
+      //fatgfffatgffftaafff
+      //0123456789012345678
+      // S     S       E
+      //
+      //E       S  S
+      //ttarrrcatcat
+      //atgatgffftaa
+      //0123456789012345
+      //S  S       E
+      //
+      minimumOrfSize: 0,
+      forward: false,
+      circular: false
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(11);
+    expect(orf.forward).to.equal(false);
+    expect(orf.frame).to.equal(0);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.internalStartCodonIndices).to.deep.equal([8]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("finds correct orfs in reverse direction in simple sequence", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "ttacat",
+      minimumOrfSize: 0,
+      forward: false,
+      circular: false
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(5);
+    expect(orf.forward).to.equal(false);
+    expect(orf.frame).to.equal(0);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.internalStartCodonIndices).to.deep.equal([]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("finds correct orfs in slightly more complex sequence", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "atgatgffftaa",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: false
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(11);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.forward).to.equal(true);
+    expect(orf.frame).to.equal(0);
+    expect(orf.internalStartCodonIndices).to.deep.equal([3]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("finds correct orfs in simple sequence", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "atgtaa",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: false
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(5);
+    expect(orf.forward).to.equal(true);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.frame).to.equal(0);
+    expect(orf.internalStartCodonIndices).to.deep.equal([]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("it will find additional orfs if useAdditionalOrfStartCodons is set to true in simple sequence", () => {
+    let orfs = getOrfsFromSequence({
+      sequence: "ctgtaa",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: false,
+      useAdditionalOrfStartCodons: true
+    });
+    expect(orfs).to.be.length(1);
+    let orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(5);
+    expect(orf.forward).to.equal(true);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.frame).to.equal(0);
+    expect(orf.internalStartCodonIndices).to.deep.equal([]);
+    expect(orf.id).to.be.a("string");
+    orfs = getOrfsFromSequence({
+      sequence: "gtgtaa",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: false,
+      useAdditionalOrfStartCodons: true
+    });
+    expect(orfs).to.be.length(1);
+    orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(5);
+    expect(orf.forward).to.equal(true);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.frame).to.equal(0);
+    expect(orf.internalStartCodonIndices).to.deep.equal([]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("finds correct orfs in simple sequence with different capitalizations", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "ATGTAA",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: false
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(0);
+    expect(orf.end).to.equal(5);
+    expect(orf.forward).to.equal(true);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.frame).to.equal(0);
+    expect(orf.internalStartCodonIndices).to.deep.equal([]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("finds a single correct orf in simple circular sequence", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "tgtaaa",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: true
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(5);
+    expect(orf.end).to.equal(4);
+    expect(orf.forward).to.equal(true);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.frame).to.equal(2);
+    expect(orf.internalStartCodonIndices).to.deep.equal([]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("finds multiple internal start codons correctly for orfs that span the origin", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "tgATGTAAatga",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: true
+    });
+    expect(orfs).to.be.length(1);
+    const orf = orfs[0];
+    expect(orf).to.be.an("object");
+    expect(orf.start).to.equal(8);
+    expect(orf.end).to.equal(7);
+    expect(orf.forward).to.equal(true);
+    expect(orf.isOrf).to.equal(true);
+    expect(orf.frame).to.equal(2);
+    expect(orf.internalStartCodonIndices).to.deep.equal([2, 11]);
+    expect(orf.id).to.be.a("string");
+  });
+  it("doesnt find orfs in simple sequence with no orfs", () => {
+    const orfs = getOrfsFromSequence({
+      sequence: "gtgtaa",
+      minimumOrfSize: 0,
+      forward: true,
+      circular: false
+    });
+    expect(orfs).to.be.an("array");
+    expect(orfs).to.be.length(0);
+  });
+});

package/src/getOverlapBetweenTwoSequences.js

@@ -0,0 +1,30 @@
+import {modulatePositionByRange} from "@teselagen/range-utils";
+
+/**
+ * This function gets the overlapping of one sequence to another based on sequence equality.
+ *
+ * @param  {string} sequenceToFind
+ * @param  {string} sequenceToSearchIn
+ * @param  {object} options            optional
+ * @return {object || null}            null if no overlap exists or a range object with .start and .end properties
+ */
+export default function getOverlapBetweenTwoSequences(
+  sequenceToFind,
+  sequenceToSearchIn,
+) {
+  sequenceToSearchIn = sequenceToSearchIn.toLowerCase();
+  sequenceToFind = sequenceToFind.toLowerCase();
+  const lengthenedSeqToSearch = sequenceToSearchIn + sequenceToSearchIn;
+  const index = lengthenedSeqToSearch.indexOf(sequenceToFind);
+  if (index > -1) {
+    return {
+      start: index,
+      end: modulatePositionByRange(index + sequenceToFind.length - 1, {
+        start: 0,
+        end: sequenceToSearchIn.length - 1
+      })
+    };
+  } else {
+    return null;
+  }
+};

package/src/getOverlapBetweenTwoSequences.test.js

@@ -0,0 +1,23 @@
+import {expect} from "chai";
+import getOverlapBetweenTwoSequences from "./getOverlapBetweenTwoSequences.js";
+describe("getOverlapBetweenTwoSequences", () => {
+  it("should get the range overlap given a seq and a seq to search in", () => {
+    expect(getOverlapBetweenTwoSequences("gtt", "agttaa")).to.deep.equal({
+      start: 1,
+      end: 3
+    });
+    expect(getOverlapBetweenTwoSequences("gtt", "ttaaag")).to.deep.equal({
+      start: 5,
+      end: 1
+    });
+  });
+  it("should return null if no overlap is found", () => {
+    expect(getOverlapBetweenTwoSequences("gtt", "agattaa")).to.deep.equal(null);
+  });
+  it("should not care about case sensitivity", () => {
+    expect(getOverlapBetweenTwoSequences("gTt", "agttaa")).to.deep.equal({
+      start: 1,
+      end: 3
+    });
+  });
+});

package/src/getPossiblePartsFromSequenceAndEnzymes.js

@@ -0,0 +1,121 @@
+import getComplementSequenceString from "./getComplementSequenceString";
+import {normalizePositionByRangeLength} from "@teselagen/range-utils";
+import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
+
+export default function getPossiblePartsFromSequenceAndEnzyme(
+  seqData,
+  restrictionEnzymes
+) {
+  // ac.throw([
+  //     ac.string,
+  //     ac.bool,
+  //     ac.shape({
+  //         "name": ac.string,
+  //         "site": ac.string,
+  //         "forwardRegex": ac.string,
+  //         "reverseRegex": ac.string,
+  //         "topSnipOffset": ac.number,
+  //         "bottomSnipOffset": ac.number
+  //     })
+  // ], arguments);
+  restrictionEnzymes = restrictionEnzymes.length
+    ? restrictionEnzymes
+    : [restrictionEnzymes];
+  const bps = seqData.sequence;
+  const seqLen = bps.length;
+  const circular = seqData.circular;
+  let cutsites = [];
+  restrictionEnzymes.forEach(enzyme => {
+    const newCutsites = cutSequenceByRestrictionEnzyme(bps, circular, enzyme);
+    cutsites = cutsites.concat(newCutsites);
+  });
+  const parts = [];
+  if (cutsites.length < 1) {
+    return parts;
+  } else if (cutsites.length === 1) {
+    parts.push(
+      getPartBetweenEnzymesWithInclusiveOverhangs(
+        cutsites[0],
+        cutsites[0],
+        seqLen
+      )
+    );
+    return parts;
+  } else {
+    const pairs = pairwise(cutsites);
+    pairs.forEach(pair => {
+      const cut1 = pair[0];
+      const cut2 = pair[1];
+      const part1 = getPartBetweenEnzymesWithInclusiveOverhangs(
+        cut1,
+        cut2,
+        seqLen
+      );
+      const part2 = getPartBetweenEnzymesWithInclusiveOverhangs(
+        cut2,
+        cut1,
+        seqLen
+      );
+      if (circular || !(part1.start > part1.end)) {
+        //only add origin spanning parts if the sequence is circular
+        parts.push(part1);
+      }
+      if (circular || !(part2.start > part2.end)) {
+        //only add origin spanning parts if the sequence is circular
+        parts.push(part2);
+      }
+    });
+    return parts;
+  }
+};
+
+function getPartBetweenEnzymesWithInclusiveOverhangs(cut1, cut2, seqLen) {
+  const firstCutOffset = getEnzymeRelativeOffset(cut1.restrictionEnzyme);
+  const secondCutOffset = getEnzymeRelativeOffset(cut2.restrictionEnzyme);
+  const start = cut1.topSnipBeforeBottom
+    ? cut1.topSnipPosition
+    : cut1.bottomSnipPosition;
+  const end = normalizePositionByRangeLength(
+    (cut2.topSnipBeforeBottom
+      ? cut2.bottomSnipPosition
+      : cut2.topSnipPosition) - 1,
+    seqLen
+  );
+  return {
+    start,
+    start1Based: start + 1,
+    end,
+    end1Based: end + 1,
+    firstCut: cut1,
+    //the offset is always counting with 0 being at the top snip position
+    firstCutOffset,
+    firstCutOverhang: cut1.overhangBps,
+    firstCutOverhangTop: firstCutOffset > 0 ? cut1.overhangBps : "",
+    firstCutOverhangBottom:
+      firstCutOffset < 0 ? getComplementSequenceString(cut1.overhangBps) : "",
+    secondCut: cut2,
+    //the offset is always counting with 0 being at the top snip position
+    secondCutOffset,
+    secondCutOverhang: cut2.overhangBps,
+    secondCutOverhangTop: secondCutOffset < 0 ? cut2.overhangBps : "",
+    secondCutOverhangBottom:
+      secondCutOffset > 0 ? getComplementSequenceString(cut2.overhangBps) : ""
+  };
+}
+
+function getEnzymeRelativeOffset(enzyme) {
+  //the offset is always counting with 0 being at the top snip position
+  return enzyme.bottomSnipOffset - enzyme.topSnipOffset;
+}
+
+function pairwise(list) {
+  if (list.length < 2) {
+    return [];
+  }
+  const first = list[0],
+    rest = list.slice(1),
+    pairs = rest.map(x => {
+      return [first, x];
+    });
+  return pairs.concat(pairwise(rest));
+}