@jbrowse/plugin-alignments 1.7.9 → 2.0.0

package/dist/BamAdapter/MismatchParser.js

@@ -1,445 +1,369 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.cigarToMismatches = cigarToMismatches;
-exports.getMismatches = getMismatches;
-exports.getModificationPositions = getModificationPositions;
-exports.getModificationTypes = getModificationTypes;
-exports.getNextRefPos = getNextRefPos;
-exports.mdToMismatches = mdToMismatches;
-exports.parseCigar = parseCigar;
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _util = require("@jbrowse/core/util");
-
-var _marked = /*#__PURE__*/_regenerator.default.mark(getNextRefPos);
-
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModificationTypes = exports.getModificationPositions = exports.getNextRefPos = exports.getMismatches = exports.mdToMismatches = exports.cigarToMismatches = exports.parseCigar = void 0;
+var util_1 = require("@jbrowse/core/util");
 var mdRegex = new RegExp(/(\d+|\^[a-z]+|[a-z])/gi);
 var modificationRegex = new RegExp(/([A-Z])([-+])([^,.?]+)([.?])?/);
-
 function parseCigar(cigar) {
-  return (cigar || '').split(/([MIDNSHPX=])/);
+    return (cigar || '').split(/([MIDNSHPX=])/);
 }
-
+exports.parseCigar = parseCigar;
 function cigarToMismatches(ops, seq, ref, qual) {
-  var roffset = 0; // reference offset
-
-  var soffset = 0; // seq offset
-
-  var mismatches = [];
-  var hasRefAndSeq = ref && seq;
-
-  for (var i = 0; i < ops.length; i += 2) {
-    var len = +ops[i];
-    var op = ops[i + 1];
-
-    if (op === 'M' || op === '=' || op === 'E') {
-      if (hasRefAndSeq) {
-        for (var j = 0; j < len; j++) {
-          if ( // @ts-ignore in the full yarn build of the repo, this says that object is possibly undefined for some reason, ignored
-          seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
+    var roffset = 0; // reference offset
+    var soffset = 0; // seq offset
+    var mismatches = [];
+    var hasRefAndSeq = ref && seq;
+    for (var i = 0; i < ops.length; i += 2) {
+        var len = +ops[i];
+        var op = ops[i + 1];
+        if (op === 'M' || op === '=' || op === 'E') {
+            if (hasRefAndSeq) {
+                for (var j = 0; j < len; j++) {
+                    if (
+                    // @ts-ignore in the full yarn build of the repo, this says that object is possibly undefined for some reason, ignored
+                    seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
+                        mismatches.push({
+                            start: roffset + j,
+                            type: 'mismatch',
+                            base: seq[soffset + j],
+                            altbase: ref[roffset + j],
+                            length: 1,
+                        });
+                    }
+                }
+            }
+            soffset += len;
+        }
+        if (op === 'I') {
             mismatches.push({
-              start: roffset + j,
-              type: 'mismatch',
-              base: seq[soffset + j],
-              length: 1
+                start: roffset,
+                type: 'insertion',
+                base: "".concat(len),
+                length: 0,
             });
-          }
+            soffset += len;
+        }
+        else if (op === 'D') {
+            mismatches.push({
+                start: roffset,
+                type: 'deletion',
+                base: '*',
+                length: len,
+            });
+        }
+        else if (op === 'N') {
+            mismatches.push({
+                start: roffset,
+                type: 'skip',
+                base: 'N',
+                length: len,
+            });
+        }
+        else if (op === 'X') {
+            var r = seq.slice(soffset, soffset + len);
+            var q = (qual === null || qual === void 0 ? void 0 : qual.slice(soffset, soffset + len)) || [];
+            for (var j = 0; j < len; j++) {
+                mismatches.push({
+                    start: roffset + j,
+                    type: 'mismatch',
+                    base: r[j],
+                    qual: q[j],
+                    length: 1,
+                });
+            }
+            soffset += len;
+        }
+        else if (op === 'H') {
+            mismatches.push({
+                start: roffset,
+                type: 'hardclip',
+                base: "H".concat(len),
+                cliplen: len,
+                length: 1,
+            });
+        }
+        else if (op === 'S') {
+            mismatches.push({
+                start: roffset,
+                type: 'softclip',
+                base: "S".concat(len),
+                cliplen: len,
+                length: 1,
+            });
+            soffset += len;
+        }
+        if (op !== 'I' && op !== 'S' && op !== 'H') {
+            roffset += len;
         }
-      }
-
-      soffset += len;
-    }
-
-    if (op === 'I') {
-      mismatches.push({
-        start: roffset,
-        type: 'insertion',
-        base: "".concat(len),
-        length: 0
-      });
-      soffset += len;
-    } else if (op === 'D') {
-      mismatches.push({
-        start: roffset,
-        type: 'deletion',
-        base: '*',
-        length: len
-      });
-    } else if (op === 'N') {
-      mismatches.push({
-        start: roffset,
-        type: 'skip',
-        base: 'N',
-        length: len
-      });
-    } else if (op === 'X') {
-      var r = seq.slice(soffset, soffset + len);
-      var q = (qual === null || qual === void 0 ? void 0 : qual.slice(soffset, soffset + len)) || [];
-
-      for (var _j = 0; _j < len; _j++) {
-        mismatches.push({
-          start: roffset + _j,
-          type: 'mismatch',
-          base: r[_j],
-          qual: q[_j],
-          length: 1
-        });
-      }
-
-      soffset += len;
-    } else if (op === 'H') {
-      mismatches.push({
-        start: roffset,
-        type: 'hardclip',
-        base: "H".concat(len),
-        cliplen: len,
-        length: 1
-      });
-    } else if (op === 'S') {
-      mismatches.push({
-        start: roffset,
-        type: 'softclip',
-        base: "S".concat(len),
-        cliplen: len,
-        length: 1
-      });
-      soffset += len;
-    }
-
-    if (op !== 'I' && op !== 'S' && op !== 'H') {
-      roffset += len;
     }
-  }
-
-  return mismatches;
+    return mismatches;
 }
+exports.cigarToMismatches = cigarToMismatches;
 /**
  * parse a SAM MD tag to find mismatching bases of the template versus the reference
  * @returns array of mismatches and their positions
  */
-
-
 function mdToMismatches(mdstring, ops, cigarMismatches, seq, qual) {
-  var mismatchRecords = [];
-  var curr = {
-    start: 0,
-    base: '',
-    length: 0,
-    type: 'mismatch'
-  };
-  var skips = cigarMismatches.filter(function (cigar) {
-    return cigar.type === 'skip';
-  });
-  var lastCigar = 0;
-  var lastTemplateOffset = 0;
-  var lastRefOffset = 0;
-  var lastSkipPos = 0; // convert a position on the reference sequence to a position
-  // on the template sequence, taking into account hard and soft
-  // clipping of reads
-
-  function nextRecord() {
-    mismatchRecords.push(curr); // get a new mismatch record ready
-
-    curr = {
-      start: curr.start + curr.length,
-      length: 0,
-      base: '',
-      type: 'mismatch'
-    };
-  }
-
-  function getTemplateCoordLocal(refCoord) {
-    var templateOffset = lastTemplateOffset;
-    var refOffset = lastRefOffset;
-
-    for (var i = lastCigar; i < ops.length && refOffset <= refCoord; i += 2, lastCigar = i) {
-      var len = +ops[i];
-      var op = ops[i + 1];
-
-      if (op === 'S' || op === 'I') {
-        templateOffset += len;
-      } else if (op === 'D' || op === 'P' || op === 'N') {
-        refOffset += len;
-      } else if (op !== 'H') {
-        templateOffset += len;
-        refOffset += len;
-      }
+    var mismatchRecords = [];
+    var curr = { start: 0, base: '', length: 0, type: 'mismatch' };
+    var skips = cigarMismatches.filter(function (cigar) { return cigar.type === 'skip'; });
+    var lastCigar = 0;
+    var lastTemplateOffset = 0;
+    var lastRefOffset = 0;
+    var lastSkipPos = 0;
+    // convert a position on the reference sequence to a position
+    // on the template sequence, taking into account hard and soft
+    // clipping of reads
+    function nextRecord() {
+        mismatchRecords.push(curr);
+        // get a new mismatch record ready
+        curr = {
+            start: curr.start + curr.length,
+            length: 0,
+            base: '',
+            type: 'mismatch',
+        };
+    }
+    function getTemplateCoordLocal(refCoord) {
+        var templateOffset = lastTemplateOffset;
+        var refOffset = lastRefOffset;
+        for (var i = lastCigar; i < ops.length && refOffset <= refCoord; i += 2, lastCigar = i) {
+            var len = +ops[i];
+            var op = ops[i + 1];
+            if (op === 'S' || op === 'I') {
+                templateOffset += len;
+            }
+            else if (op === 'D' || op === 'P' || op === 'N') {
+                refOffset += len;
+            }
+            else if (op !== 'H') {
+                templateOffset += len;
+                refOffset += len;
+            }
+        }
+        lastTemplateOffset = templateOffset;
+        lastRefOffset = refOffset;
+        return templateOffset - (refOffset - refCoord);
     }
-
-    lastTemplateOffset = templateOffset;
-    lastRefOffset = refOffset;
-    return templateOffset - (refOffset - refCoord);
-  } // now actually parse the MD string
-
-
-  var md = mdstring.match(mdRegex) || [];
-
-  for (var i = 0; i < md.length; i++) {
-    var token = md[i];
-    var num = +token;
-
-    if (!Number.isNaN(num)) {
-      curr.start += num;
-    } else if (token.startsWith('^')) {
-      curr.start += token.length - 1;
-    } else {
-      // mismatch
-      for (var j = 0; j < token.length; j += 1) {
-        curr.length = 1;
-
-        while (lastSkipPos < skips.length) {
-          var mismatch = skips[lastSkipPos];
-
-          if (curr.start >= mismatch.start) {
-            curr.start += mismatch.length;
-            lastSkipPos++;
-          } else {
-            break;
-          }
+    // now actually parse the MD string
+    var md = mdstring.match(mdRegex) || [];
+    for (var i = 0; i < md.length; i++) {
+        var token = md[i];
+        var num = +token;
+        if (!Number.isNaN(num)) {
+            curr.start += num;
         }
-
-        var s = getTemplateCoordLocal(curr.start);
-        curr.base = seq[s] || 'X';
-        var qualScore = qual === null || qual === void 0 ? void 0 : qual[s];
-
-        if (qualScore) {
-          curr.qual = qualScore;
+        else if (token.startsWith('^')) {
+            curr.start += token.length - 1;
+        }
+        else {
+            // mismatch
+            for (var j = 0; j < token.length; j += 1) {
+                curr.length = 1;
+                while (lastSkipPos < skips.length) {
+                    var mismatch = skips[lastSkipPos];
+                    if (curr.start >= mismatch.start) {
+                        curr.start += mismatch.length;
+                        lastSkipPos++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                var s = getTemplateCoordLocal(curr.start);
+                curr.base = seq[s] || 'X';
+                var qualScore = qual === null || qual === void 0 ? void 0 : qual[s];
+                if (qualScore) {
+                    curr.qual = qualScore;
+                }
+                curr.altbase = token;
+                nextRecord();
+            }
         }
-
-        curr.altbase = token;
-        nextRecord();
-      }
     }
-  }
-
-  return mismatchRecords;
+    return mismatchRecords;
 }
-
+exports.mdToMismatches = mdToMismatches;
 function getMismatches(cigar, md, seq, ref, qual) {
-  var mismatches = [];
-  var ops = parseCigar(cigar); // parse the CIGAR tag if it has one
-
-  if (cigar) {
-    mismatches = mismatches.concat(cigarToMismatches(ops, seq, ref, qual));
-  } // now let's look for CRAM or MD mismatches
-
-
-  if (md) {
-    mismatches = mismatches.concat(mdToMismatches(md, ops, mismatches, seq, qual));
-  }
-
-  return mismatches;
-} // get relative reference sequence positions for positions given relative to
+    var mismatches = [];
+    var ops = parseCigar(cigar);
+    // parse the CIGAR tag if it has one
+    if (cigar) {
+        mismatches = mismatches.concat(cigarToMismatches(ops, seq, ref, qual));
+    }
+    // now let's look for CRAM or MD mismatches
+    if (md) {
+        mismatches = mismatches.concat(mdToMismatches(md, ops, mismatches, seq, qual));
+    }
+    return mismatches;
+}
+exports.getMismatches = getMismatches;
+// get relative reference sequence positions for positions given relative to
 // the read sequence
-
-
 function getNextRefPos(cigarOps, positions) {
-  var readPos, refPos, currPos, i, len, op, _i, _i2;
-
-  return _regenerator.default.wrap(function getNextRefPos$(_context) {
-    while (1) {
-      switch (_context.prev = _context.next) {
-        case 0:
-          readPos = 0;
-          refPos = 0;
-          currPos = 0;
-          i = 0;
-
-        case 4:
-          if (!(i < cigarOps.length && currPos < positions.length)) {
-            _context.next = 31;
-            break;
-          }
-
-          len = +cigarOps[i];
-          op = cigarOps[i + 1];
-
-          if (!(op === 'S' || op === 'I')) {
-            _context.next = 12;
-            break;
-          }
-
-          for (_i = 0; _i < len && currPos < positions.length; _i++) {
-            if (positions[currPos] === readPos + _i) {
-              currPos++;
-            }
-          }
-
-          readPos += len;
-          _context.next = 28;
-          break;
-
-        case 12:
-          if (!(op === 'D' || op === 'N')) {
-            _context.next = 16;
-            break;
-          }
-
-          refPos += len;
-          _context.next = 28;
-          break;
-
-        case 16:
-          if (!(op === 'M' || op === 'X' || op === '=')) {
-            _context.next = 28;
-            break;
-          }
-
-          _i2 = 0;
-
-        case 18:
-          if (!(_i2 < len && currPos < positions.length)) {
-            _context.next = 26;
-            break;
-          }
-
-          if (!(positions[currPos] === readPos + _i2)) {
-            _context.next = 23;
-            break;
-          }
-
-          _context.next = 22;
-          return refPos + _i2;
-
-        case 22:
-          currPos++;
-
-        case 23:
-          _i2++;
-          _context.next = 18;
-          break;
-
-        case 26:
-          readPos += len;
-          refPos += len;
-
-        case 28:
-          i += 2;
-          _context.next = 4;
-          break;
-
-        case 31:
-        case "end":
-          return _context.stop();
-      }
-    }
-  }, _marked);
+    var readPos, refPos, currPos, i, len, op, i_1, i_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                readPos = 0;
+                refPos = 0;
+                currPos = 0;
+                i = 0;
+                _a.label = 1;
+            case 1:
+                if (!(i < cigarOps.length && currPos < positions.length)) return [3 /*break*/, 9];
+                len = +cigarOps[i];
+                op = cigarOps[i + 1];
+                if (!(op === 'S' || op === 'I')) return [3 /*break*/, 2];
+                for (i_1 = 0; i_1 < len && currPos < positions.length; i_1++) {
+                    if (positions[currPos] === readPos + i_1) {
+                        currPos++;
+                    }
+                }
+                readPos += len;
+                return [3 /*break*/, 8];
+            case 2:
+                if (!(op === 'D' || op === 'N')) return [3 /*break*/, 3];
+                refPos += len;
+                return [3 /*break*/, 8];
+            case 3:
+                if (!(op === 'M' || op === 'X' || op === '=')) return [3 /*break*/, 8];
+                i_2 = 0;
+                _a.label = 4;
+            case 4:
+                if (!(i_2 < len && currPos < positions.length)) return [3 /*break*/, 7];
+                if (!(positions[currPos] === readPos + i_2)) return [3 /*break*/, 6];
+                return [4 /*yield*/, refPos + i_2];
+            case 5:
+                _a.sent();
+                currPos++;
+                _a.label = 6;
+            case 6:
+                i_2++;
+                return [3 /*break*/, 4];
+            case 7:
+                readPos += len;
+                refPos += len;
+                _a.label = 8;
+            case 8:
+                i += 2;
+                return [3 /*break*/, 1];
+            case 9: return [2 /*return*/];
+        }
+    });
 }
-
+exports.getNextRefPos = getNextRefPos;
 function getModificationPositions(mm, fseq, fstrand) {
-  var seq = fstrand === -1 ? (0, _util.revcom)(fseq) : fseq;
-  var mods = mm.split(';').filter(function (mod) {
-    return !!mod;
-  });
-  var result = [];
-
-  for (var i = 0; i < mods.length; i++) {
-    var mod = mods[i];
-
-    var _mod$split = mod.split(','),
-        _mod$split2 = (0, _toArray2.default)(_mod$split),
-        basemod = _mod$split2[0],
-        skips = _mod$split2.slice(1); // regexes based on parse_mm.pl from hts-specs
-
-
-    var matches = basemod.match(modificationRegex);
-
-    if (!matches) {
-      throw new Error('bad format for MM tag');
-    }
-
-    var _matches = (0, _slicedToArray2.default)(matches, 4),
-        base = _matches[1],
-        strand = _matches[2],
-        typestr = _matches[3]; // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
-    // split, and they can also be chemical codes (ChEBI) e.g. C+16061
-
-
-    var types = typestr.split(/(\d+|.)/).filter(function (f) {
-      return !!f;
-    });
-
-    if (strand === '-') {
-      console.warn('unsupported negative strand modifications'); // make sure to return a somewhat matching type even in this case
-
-      result.push({
-        type: 'unsupported',
-        positions: []
-      });
-    } // this logic also based on parse_mm.pl from hts-specs is that in the
-    // sequence of the read, if we have a modification type e.g. C+m;2 and a
-    // sequence ACGTACGTAC we skip the two instances of C and go to the last
-    // C
-
-
-    for (var j = 0; j < types.length; j++) {
-      var type = types[j];
-      var _i3 = 0;
-      var positions = [];
-
-      for (var k = 0; k < skips.length; k++) {
-        var delta = +skips[k];
-
-        do {
-          if (base === 'N' || base === seq[_i3]) {
-            delta--;
-          }
-
-          _i3++;
-        } while (delta >= 0 && _i3 < seq.length);
-
-        var temp = _i3 - 1;
-        positions.push(fstrand === -1 ? seq.length - 1 - temp : temp);
-      }
-
-      if (fstrand === -1) {
-        positions.sort(function (a, b) {
-          return a - b;
-        });
-      }
-
-      result.push({
-        type: type,
-        positions: positions
-      });
+    var seq = fstrand === -1 ? (0, util_1.revcom)(fseq) : fseq;
+    var mods = mm.split(';').filter(function (mod) { return !!mod; });
+    var result = [];
+    for (var i = 0; i < mods.length; i++) {
+        var mod = mods[i];
+        var _a = __read(mod.split(',')), basemod = _a[0], skips = _a.slice(1);
+        // regexes based on parse_mm.pl from hts-specs
+        var matches = basemod.match(modificationRegex);
+        if (!matches) {
+            throw new Error('bad format for MM tag');
+        }
+        var _b = __read(matches, 4), base = _b[1], strand = _b[2], typestr = _b[3];
+        // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
+        // split, and they can also be chemical codes (ChEBI) e.g. C+16061
+        var types = typestr.split(/(\d+|.)/).filter(function (f) { return !!f; });
+        if (strand === '-') {
+            console.warn('unsupported negative strand modifications');
+            // make sure to return a somewhat matching type even in this case
+            result.push({ type: 'unsupported', positions: [] });
+        }
+        // this logic also based on parse_mm.pl from hts-specs is that in the
+        // sequence of the read, if we have a modification type e.g. C+m;2 and a
+        // sequence ACGTACGTAC we skip the two instances of C and go to the last
+        // C
+        for (var j = 0; j < types.length; j++) {
+            var type = types[j];
+            var i_3 = 0;
+            var positions = [];
+            for (var k = 0; k < skips.length; k++) {
+                var delta = +skips[k];
+                do {
+                    if (base === 'N' || base === seq[i_3]) {
+                        delta--;
+                    }
+                    i_3++;
+                } while (delta >= 0 && i_3 < seq.length);
+                var temp = i_3 - 1;
+                positions.push(fstrand === -1 ? seq.length - 1 - temp : temp);
+            }
+            if (fstrand === -1) {
+                positions.sort(function (a, b) { return a - b; });
+            }
+            result.push({
+                type: type,
+                positions: positions,
+            });
+        }
     }
-  }
-
-  return result;
+    return result;
 }
-
+exports.getModificationPositions = getModificationPositions;
 function getModificationTypes(mm) {
-  var mods = mm.split(';');
-  return mods.filter(function (mod) {
-    return !!mod;
-  }).map(function (mod) {
-    var _mod$split3 = mod.split(','),
-        _mod$split4 = (0, _slicedToArray2.default)(_mod$split3, 1),
-        basemod = _mod$split4[0];
-
-    var matches = basemod.match(modificationRegex);
-
-    if (!matches) {
-      throw new Error('bad format for MM tag');
-    }
-
-    var _matches2 = (0, _slicedToArray2.default)(matches, 4),
-        typestr = _matches2[3]; // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
-    // split, and they can also be chemical codes (ChEBI) e.g. C+16061
-
-
-    return typestr.split(/(\d+|.)/).filter(function (f) {
-      return !!f;
-    });
-  }).flat();
-}
+    var mods = mm.split(';');
+    return mods
+        .filter(function (mod) { return !!mod; })
+        .map(function (mod) {
+        var _a = __read(mod.split(','), 1), basemod = _a[0];
+        var matches = basemod.match(modificationRegex);
+        if (!matches) {
+            throw new Error('bad format for MM tag');
+        }
+        var _b = __read(matches, 4), typestr = _b[3];
+        // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
+        // split, and they can also be chemical codes (ChEBI) e.g. C+16061
+        return typestr.split(/(\d+|.)/).filter(function (f) { return !!f; });
+    })
+        .flat();
+}
+exports.getModificationTypes = getModificationTypes;
+//# sourceMappingURL=MismatchParser.js.map